Attachment #43627 for bug #38549




#define IHaveModules
#include <Server.tmpl>

SRCS = newport_driver.c newport_regs.c newport_cmap.c newport_shadow.c newport_cursor.c newport_accel.c

OBJS = newport_driver.o newport_regs.o newport_cmap.o newport_shadow.o newport_cursor.o newport_accel.o

XF86CONFIG = XF86Config.indy


InstallDriverSDKNonExecFile(newport_cmap.c,$(DRIVERSDKDIR)/drivers/newport)
InstallDriverSDKNonExecFile(newport_shadow.c,$(DRIVERSDKDIR)/drivers/newport)
InstallDriverSDKNonExecFile(newport_cursor.c,$(DRIVERSDKDIR)/drivers/newport)
InstallDriverSDKNonExecFile(newport_accel.c,$(DRIVERSDKDIR)/drivers/newport)
InstallDriverSDKNonExecFile(newport_regs.h,$(DRIVERSDKDIR)/drivers/newport)
InstallDriverSDKNonExecFile(newport.h,$(DRIVERSDKDIR)/drivers/newport)


Lines 6-11 Link Here

(-)xc/programs/Xserver/hw/xfree86/drivers/newport-old/newport.h (+50 lines)
6	#ifndef __NEWPORT_H__	6	#ifndef __NEWPORT_H__
7	#define __NEWPORT_H__	7	#define __NEWPORT_H__
8		8
		9	/* use 32bpp shadow framebuffer surface instead of 24bpp */
		10	#define NEWPORT_USE32BPP
		11	/* enable accel patch */
		12	#define NEWPORT_ACCEL
		13
		14	#ifdef NEWPORT_ACCEL
		15	#ifndef NEWPORT_USE32BPP
		16	#define NEWPORT_USE32BPP
		17	#endif
		18	#endif
		19
9	/*	20	/*
10	* All drivers should include these:	21	* All drivers should include these:
11	*/	22	*/
Lines 19-24 Link Here
19		30
20	/* xaa & hardware cursor */	31	/* xaa & hardware cursor */
21	#include "xaa.h"	32	#include "xaa.h"
		33	#include "xaalocal.h"
22	#include "xf86Cursor.h"	34	#include "xf86Cursor.h"
23		35
24	/* register definitions of the Newport card */	36	/* register definitions of the Newport card */
Lines 45-50 Link Here
45	typedef struct {	57	typedef struct {
46	unsigned busID;	58	unsigned busID;
47	int bitplanes;	59	int bitplanes;
		60	Bool NoAccel;
48	/* revision numbers of the various pieces of silicon */	61	/* revision numbers of the various pieces of silicon */
49	unsigned int board_rev, cmap_rev, rex3_rev, xmap9_rev, bt445_rev;	62	unsigned int board_rev, cmap_rev, rex3_rev, xmap9_rev, bt445_rev;
50	/* shadow copies of frequently used registers */	63	/* shadow copies of frequently used registers */
Lines 88-93 Link Here
88		101
89	LOCO txt_colormap[256];	102	LOCO txt_colormap[256];
90		103
		104	/* XAA stuff */
		105	XAAInfoRecPtr pXAAInfoRec;
		106	/* writing to these regs causes pipeline stall
		107	so be smart and check the shadow before writing it */
		108	unsigned int shadow_drawmode1;
		109	unsigned int shadow_colorvram;
		110	unsigned int shadow_colorback;
		111	unsigned int shadow_xymove;
		112	unsigned int shadow_wrmask;
		113	unsigned int shadow_clipmode;
		114	unsigned int fifoleft; /* number of slots left in fifo */
		115
		116	unsigned int shadow_drawmode0;
		117	unsigned int shadow_colori;
		118	unsigned int shadow_smask0x;
		119	unsigned int shadow_smask0y;
		120
		121	unsigned int setup_drawmode0;
		122	unsigned int setup_drawmode1;
		123	unsigned char dashline_pat[2048/8];
		124	unsigned int dashline_patlen;
		125
		126	int clipsx, clipex, clipsy, clipey;
		127	int skipleft;
		128
		129	unsigned int pat8x8[8][8];
		130
		131	unsigned int (*Color2Planes)(unsigned int color);
		132
		133	#ifdef RENDER
		134	unsigned int uTextureWidth;
		135	unsigned int uTextureHeight;
		136	unsigned int uTextureSize;
		137	unsigned int *pTexture;
		138	unsigned int uTextureFlags;
		139	#endif
		140
91	OptionInfoPtr Options;	141	OptionInfoPtr Options;
92	} NewportRec, *NewportPtr;	142	} NewportRec, *NewportPtr;
93		143




/*
 * Accelerated Driver for the SGI Indy's Newport graphics card
 * 
 * (c) 2004 Dominik Behr <dominikbehr@yahoo.com>
 * this code is released under xfree 4.3.0 and xorg 6.8.0 license
 *
 */

#include "newport.h"

#ifdef NEWPORT_ACCEL

#include "mi.h"
#include "mizerarc.h"

#define BARF(a) xf86DrvMsg(0, X_INFO, (a))
#define BARF1(a,b) xf86DrvMsg(0, X_INFO, (a), (b))
#define BARF2(a,b,c) xf86DrvMsg(0, X_INFO, (a), (b), (c))
#define BARF3(a,b,c,d) xf86DrvMsg(0, X_INFO, (a), (b), (c), (d))
#define BARF4(a,b,c,d,e) xf86DrvMsg(0, X_INFO, (a), (b), (c), (d), (e))

/* XAA Functions */

#define NEWPORT_PREROTATE
/*
    there is a bug in XAA which causes it to reference NULL pointer to pattern cache when
    using HARDWARE_PROGRAMMED_PATTERN only (try x11perf -strap1)
    thus we have to also set HARDWARE_PROGRAMMED_ORIGIN and prerotate the pattern 
    in the setup function
*/

#define NEWPORT_GFIFO_ENTRIES 30
/* 
 I dont know how many entries are in the gfx FIFO, judging by 6 bits in the GFIFO 
 level status register it can be at most 63. it must be at least 32 because 
 otherwise they would use less bits for status
 
 for now 16 seems to be safe value
*/
#define NEWPORT_DELAY 128

/*******************************************************************************

*******************************************************************************/
static void
NewportWaitIdle(NewportPtr pNewport, unsigned int uEntries)
{
    NewportRegsPtr pNewportRegs;
    pNewportRegs = pNewport->pNewportRegs;
    /* wait for the GFIFO to drain */
    while ((pNewportRegs->cset.stat & NPORT_STAT_GLMSK)) 
    {
	int i;
	volatile int x;	
	for (x = 0, i = 0; i < NEWPORT_DELAY; i++)
	{
	    x += i;
	}
    } 
    /* and then wait for the graphic to be idle */
    while (pNewportRegs->cset.stat & NPORT_STAT_GBUSY)
    {
	int i;
	volatile int x;
	for (x = 0, i = 0; i < NEWPORT_DELAY; i++)
	{
	    x += i;
	}
    }
    pNewport->fifoleft = NEWPORT_GFIFO_ENTRIES-uEntries;
}


#if 0
/*******************************************************************************

*******************************************************************************/
static void
NewportWaitGFIFO(NewportPtr pNewport, unsigned int uEntries)
{
    unsigned int uWaitLevel;
    
/*    NewportWaitIdle(pNewport, NEWPORT_GFIFO_ENTRIES);
    return;*/
    
    if (uEntries >= NEWPORT_GFIFO_ENTRIES)
    {
	uWaitLevel = 0;
    }
    else
    {
	uWaitLevel = NEWPORT_GFIFO_ENTRIES-uEntries;
    }
    /* HACK */
    /*uWaitLevel = 0;*/
    while (((pNewport->pNewportRegs->cset.stat & NPORT_STAT_GLMSK) >> 7) > uWaitLevel)
    {
	int i;
	volatile int x;
	for (x = 0, i = 0; i < NEWPORT_DELAY; i++)
	{
	    x += i;
	}
    }
}
#endif
#if 1
/*******************************************************************************

*******************************************************************************/
static void
NewportWaitGFIFO(NewportPtr pNewport, unsigned int uEntries)
{
    if (uEntries > NEWPORT_GFIFO_ENTRIES)
    {
	uEntries = NEWPORT_GFIFO_ENTRIES;
    }
    
    if (uEntries <= pNewport->fifoleft)
    {
	pNewport->fifoleft -= uEntries;
	return;
    }
    
    while (1)
    {
	unsigned int fifolevel;
	int i;
	volatile int x;
	
	fifolevel = (pNewport->pNewportRegs->cset.stat & NPORT_STAT_GLMSK) >> 7;
	if (fifolevel < NEWPORT_GFIFO_ENTRIES)
	{
	    pNewport->fifoleft = NEWPORT_GFIFO_ENTRIES - fifolevel;
	}
	else
	{
	    pNewport->fifoleft = 0;
	}
	if (uEntries <= pNewport->fifoleft)
	{
	    pNewport->fifoleft -= uEntries;
	    return;
        }
	
	for (x = 0, i = 0; i < NEWPORT_DELAY; i++)
	{
	    x += i;
	}
    }
}
#endif


/*******************************************************************************

*******************************************************************************/
static void
NewportXAASync(ScrnInfoPtr pScrn)
{
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    
    NewportWaitIdle(pNewport, 0);
}


/*******************************************************************************

*******************************************************************************/
static unsigned int
Rop2LogicOp(int rop)
{
    return (unsigned int)rop << 28;
}

/*******************************************************************************

*******************************************************************************/
static void
NewportUpdateClipping(NewportPtr pNewport)
{
    unsigned int smask0x, smask0y;
    
    if (pNewport->skipleft > pNewport->clipsx)
    {
        smask0x = ((pNewport->skipleft & 0xFFFF) << 16) | (pNewport->clipex & 0xFFFF);
    }
    else
    {
	smask0x = ((pNewport->clipsx & 0xFFFF) << 16) | (pNewport->clipex & 0xFFFF);
    }

    if (smask0x != pNewport->shadow_smask0x)
    {
	NewportWaitGFIFO(pNewport, 1);
	pNewport->shadow_smask0x = smask0x;
	pNewport->pNewportRegs->set.smask0x = smask0x;
    }
    
    smask0y = ((pNewport->clipsy & 0xFFFF) << 16) | (pNewport->clipey & 0xFFFF);	
    if (smask0y != pNewport->shadow_smask0y)
    {
	NewportWaitGFIFO(pNewport, 1);
	pNewport->shadow_smask0y = smask0y;
	pNewport->pNewportRegs->set.smask0y = smask0y;
    }
}

/*******************************************************************************

*******************************************************************************/
static unsigned int
NewportColor2HOSTRW(unsigned int color)
{
 /*
  default XAA color is 0,R,G,B
 */
#if 0 
 return  ((color & 0x0000FF) << 16)
       | ((color & 0xFF0000) >> 16)
       | ((color & 0x00FF00))
       ;
#endif
/* but we changed masks to match the native format */
 return color;       
}

/*******************************************************************************

*******************************************************************************/
static unsigned int
NewportColor2Planes24(unsigned int color)
{
    unsigned int res;
    unsigned int i;
    unsigned int mr, mg, mb;
    unsigned int sr, sg, sb;
    
 /*
  XAA color is 0,R,G,B
 */
 
    res = 0;
#if 0    
    mr = 0x800000;
    mg = 0x008000;
    mb = 0x000080;
#endif    
    mr = 0x000080;
    mg = 0x008000;
    mb = 0x800000;
    sr = 2;
    sg = 1;
    sb = 4;
    
    for (i = 0; i < 8; i++)
    {
	res |= (color & mr)?sr:0;
	res |= (color & mg)?sg:0;
	res |= (color & mb)?sb:0;

	sr <<= 3;    
	sg <<= 3;
	sb <<= 3;
	mr >>= 1;
	mg >>= 1;
	mb >>= 1;
    }
    
    return  res;
}

/*******************************************************************************

*******************************************************************************/
static unsigned int
NewportColor2Planes8(unsigned int color)
{
    return color;
}

/*******************************************************************************

*******************************************************************************/
static void
NewportUpdateCOLORI(NewportPtr pNewport, unsigned long colori)
{
    if (colori != pNewport->shadow_colori)
    {
	NewportWaitGFIFO(pNewport, 1);
	pNewport->shadow_colori = colori;
	pNewport->pNewportRegs->set.colori = colori;
    }
}


/*******************************************************************************

*******************************************************************************/
static void
NewportUpdateDRAWMODE0(NewportPtr pNewport, unsigned long drawmode0)
{
    if (drawmode0 != pNewport->shadow_drawmode0)
    {
	NewportWaitGFIFO(pNewport, 1);
	pNewport->shadow_drawmode0 = drawmode0;
	pNewport->pNewportRegs->set.drawmode0 = drawmode0;
    }
}


/*******************************************************************************

*******************************************************************************/
static void
NewportUpdateDRAWMODE1(NewportPtr pNewport, unsigned long drawmode1)
{
    if (drawmode1 != pNewport->shadow_drawmode1)
    {
	NewportWaitIdle(pNewport, 1);
	pNewport->shadow_drawmode1 = drawmode1;
	pNewport->pNewportRegs->set.drawmode1 = drawmode1;
    }
}

/*******************************************************************************

*******************************************************************************/
static void
NewportUpdateCOLORVRAM(NewportPtr pNewport, unsigned long colorvram)
{
    if (colorvram != pNewport->shadow_colorvram)
    {
	NewportWaitIdle(pNewport, 1);
	pNewport->shadow_colorvram = colorvram;
	pNewport->pNewportRegs->set.colorvram = colorvram;
    }
}

/*******************************************************************************

*******************************************************************************/
static void
NewportUpdateCOLORBACK(NewportPtr pNewport, unsigned long colorback)
{
    if (colorback != pNewport->shadow_colorback)
    {
	NewportWaitIdle(pNewport, 1);
	pNewport->shadow_colorback = colorback;
	pNewport->pNewportRegs->set.colorback = colorback;
    }
}

/*******************************************************************************

*******************************************************************************/
static void
NewportUpdateWRMASK(NewportPtr pNewport, unsigned long wrmask)
{
    if (wrmask != pNewport->shadow_wrmask)
    {
	NewportWaitIdle(pNewport, 1);
	pNewport->shadow_wrmask = wrmask;
	pNewport->pNewportRegs->set.wrmask = wrmask;
    }
}

/*******************************************************************************

*******************************************************************************/
static void
NewportUpdateXYMOVE(NewportPtr pNewport, unsigned long xymove)
{
    if (xymove != pNewport->shadow_xymove)
    {
	NewportWaitIdle(pNewport, 1);
	pNewport->shadow_xymove = xymove;
	pNewport->pNewportRegs->set.xymove = xymove;
    }
}


/*******************************************************************************

*******************************************************************************/
static void
NewportXAASetupForScreenToScreenCopy(ScrnInfoPtr pScrn,
                                     int xdir,
				     int ydir,
				     int rop,
				     unsigned int planemask,
				     int trans_color)
{
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);
    
    NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
    NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(planemask));
    pNewport->skipleft = 0;
    NewportUpdateClipping(pNewport);
    NewportUpdateDRAWMODE0(pNewport,
                           0
                           | NPORT_DMODE0_S2S
                           | NPORT_DMODE0_BLOCK
		           | NPORT_DMODE0_DOSETUP
		           | NPORT_DMODE0_STOPX
			   | NPORT_DMODE0_STOPY
			  );
    
    
}

/*******************************************************************************

*******************************************************************************/
static void
NewportXAASubsequentScreenToScreenCopy(ScrnInfoPtr pScrn,
                                       int x1, int y1,
				       int x2, int y2,
				       int width, int height)
{
    int dx, dy;
    unsigned int sx, sy, ex, ey;
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);
    
    dx = x2 - x1;
    dy = y2 - y1;
    if (!dx && !dy) 
	return;
    
    if (width)
	x2 = x1 + width - 1;
    else
	x2 = x1;
	
    if (height)
	y2 = y1 + height - 1;
    else
	y2 = y1;
    
    if (dx < 0)
    {
	sx = x1 & 0xFFFF;
	ex = x2 & 0xFFFF;
    }
    else
    {
	sx = x2 & 0xFFFF;
	ex = x1 & 0xFFFF;
    }
    
    if (dy < 0)
    {
	sy = y1 & 0xFFFF;
	ey = y2 & 0xFFFF;
    }
    else
    {
	sy = y2 & 0xFFFF;
	ey = y1 & 0xFFFF;
    }
    
    dx &= 0xFFFF;
    dy &= 0xFFFF;

    NewportUpdateXYMOVE(pNewport, (dx << 16) | dy); /* this is bad because it stalls the pipeline but nothing can be done about it */    
    NewportWaitGFIFO(pNewport, 2);
    pNewportRegs->set.xystarti = (sx << 16) | sy;
    pNewportRegs->go.xyendi = (ex << 16) | ey;        
}				       

/*******************************************************************************

*******************************************************************************/
static void
NewportXAASetupForSolidFill(ScrnInfoPtr pScrn,
                            int Color,
			    int rop,
			    unsigned int planemask)
{
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);

    if (rop == GXcopy
        || rop == GXclear
	|| rop == GXset)
    {
	/* if possible try to set up a fast clear which is 4x faster */
	NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | NPORT_DMODE1_FCLR | Rop2LogicOp(GXcopy));
	if (rop == GXclear)
	    NewportUpdateCOLORVRAM(pNewport, 0);
	else
	if (rop == GXset)
	    NewportUpdateCOLORVRAM(pNewport, 0xFFFFFF);
	else
            NewportUpdateCOLORVRAM(pNewport, pNewport->Color2Planes((unsigned int)Color));
    }
    else
    {
	NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
	NewportUpdateCOLORI(pNewport, NewportColor2HOSTRW(Color));
    }
    
    NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(planemask));
    pNewport->skipleft = 0;
    NewportUpdateClipping(pNewport);
    NewportUpdateDRAWMODE0(pNewport, 
                           0
                           | NPORT_DMODE0_DRAW
                           | NPORT_DMODE0_BLOCK
			   | NPORT_DMODE0_DOSETUP
			   | NPORT_DMODE0_STOPX
			   | NPORT_DMODE0_STOPY
			  );
}

/*******************************************************************************

*******************************************************************************/
static void
NewportXAASubsequentSolidFillRect(ScrnInfoPtr pScrn,
                                  int x,
				  int y,
				  int w,
				  int h)
{
    int ex, ey;
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);
    
    if (w == 0) w = 1;
    if (h == 0) h = 1;
    ex = x + w - 1;
    ey = y + h - 1;
    
    NewportWaitGFIFO(pNewport, 2);
    pNewportRegs->set.xystarti = ((x & 0xFFFF) << 16) | (y & 0xFFFF);
    pNewportRegs->go.xyendi = ((ex & 0xFFFF) << 16) | (ey & 0xFFFF);
}

/*******************************************************************************

*******************************************************************************/
static void
NewportXAASetupForSolidLine(ScrnInfoPtr pScrn,
                            int Color,
			    int rop,
			    unsigned int planemask)
{
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);

    NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
    NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(planemask));
    NewportUpdateCOLORI(pNewport, NewportColor2HOSTRW(Color));

    pNewport->skipleft = 0;
    NewportUpdateClipping(pNewport);
    pNewport->setup_drawmode0 = (0
                                | NPORT_DMODE0_DRAW
                                | NPORT_DMODE0_ILINE
				| NPORT_DMODE0_DOSETUP
				| NPORT_DMODE0_STOPX
				| NPORT_DMODE0_STOPY
				);
}

/*******************************************************************************

*******************************************************************************/
static void
NewportXAASubsequentSolidTwoPointLine(ScrnInfoPtr pScrn,
                                      int x1,
				      int y1,
				      int x2,
				      int y2,
				      int flags)
{
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);
    
    NewportUpdateDRAWMODE0(pNewport, 
                           pNewport->setup_drawmode0
			   | ((flags & OMIT_LAST) ? NPORT_DMODE0_SKLST : 0)
			  );    
    NewportWaitGFIFO(pNewport, 2);
    pNewportRegs->set.xystarti = ((x1 & 0xFFFF) << 16) | (y1 & 0xFFFF);
    pNewportRegs->go.xyendi = ((x2 & 0xFFFF) << 16) | (y2 & 0xFFFF);
}


/*******************************************************************************

*******************************************************************************/
static void
NewportXAASetupForDashedLine(ScrnInfoPtr pScrn,
                             int fg,
			     int bg,
			     int rop,
			     unsigned int planemask,
			     int length,
			     unsigned char *pattern)
{
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    int i;
    
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);
    
    pNewport->dashline_patlen = length;
    for (i = 0; i < (length+7)>>3; i++)
	pNewport->dashline_pat[i] = pattern[i];

    NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
    NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(planemask));
    if (bg != -1)
	NewportUpdateCOLORBACK(pNewport, NewportColor2HOSTRW(bg));
    NewportUpdateCOLORI(pNewport, NewportColor2HOSTRW(fg));
    pNewport->skipleft = 0;
    NewportUpdateClipping(pNewport);    
    pNewport->setup_drawmode0 = (0
                                | NPORT_DMODE0_DRAW
                                | NPORT_DMODE0_ILINE
				| NPORT_DMODE0_DOSETUP
				| NPORT_DMODE0_STOPX
				| NPORT_DMODE0_STOPY
				| NPORT_DMODE0_L32
				| NPORT_DMODE0_ZPENAB
				| ((bg == -1) ? 0 : NPORT_DMODE0_ZOPQ)
				);
}

/*******************************************************************************

*******************************************************************************/
static void
NewportXAASubsequentDashedTwoPointLine(ScrnInfoPtr pScrn,
                                       int x1,
			 	       int y1,
			 	       int x2,
			 	       int y2,
			 	       int flags,
				       int phase)
{
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    int dx, dy;
    unsigned int linelen;
    unsigned int dwords;
    
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);

    dx = x2 - x1; if (dx < 0) dx = -dx; dx++;
    dy = y2 - y1; if (dy < 0) dy = -dy; dy++;
    if (dx > dy)
	linelen = dx;
    else
	linelen = dy;
    dwords = (linelen + 31) >> 5;

    NewportUpdateDRAWMODE0(pNewport, 
                           pNewport->setup_drawmode0
			   | ((flags & OMIT_LAST) ? NPORT_DMODE0_SKLST : 0)
			  );
    
    NewportWaitGFIFO(pNewport, 3);
    pNewportRegs->set.xystarti = ((x1 & 0xFFFF) << 16) | (y1 & 0xFFFF);
    pNewportRegs->set.xyendi = ((x2 & 0xFFFF) << 16) | (y2 & 0xFFFF);
    pNewportRegs->set._setup = 1;
    
    phase %= pNewport->dashline_patlen;
    while (dwords--) {
	unsigned int bit;
	unsigned int pat;
	unsigned int mask;
	pat = 0;
	mask = 0x80000000;
	for (bit = 0; bit < 32; bit++)
	{
	    if (pNewport->dashline_pat[phase >> 3] & (0x80 >> (phase & 7)))
		pat |= mask;	    
	    phase = (phase + 1) % pNewport->dashline_patlen;
	    mask >>= 1;
	}	
	NewportWaitGFIFO(pNewport, 1);
	pNewportRegs->go.zpattern = pat;
    }

}

/*******************************************************************************

*******************************************************************************/
static void
NewportXAASetupForCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
                                             int fg,
					     int bg,
					     int rop,
					     unsigned int planemask)
{
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);
    
    NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
    NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(planemask));    
    if (bg != -1)
	NewportUpdateCOLORBACK(pNewport, NewportColor2HOSTRW(bg));
    NewportUpdateCOLORI(pNewport, NewportColor2HOSTRW(fg));
    NewportUpdateDRAWMODE0(pNewport,
                           0
                           | NPORT_DMODE0_DRAW
                           | NPORT_DMODE0_BLOCK
			   | NPORT_DMODE0_DOSETUP
			   | NPORT_DMODE0_STOPX
			   | NPORT_DMODE0_ZPENAB
			   | ((bg == -1) ? 0 : NPORT_DMODE0_ZOPQ)
			   | NPORT_DMODE0_L32
			  );
}

/*******************************************************************************

*******************************************************************************/
static void
NewportXAASubsequentCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
					       int x,
					       int y,
					       int w,
					       int h,
					       int skipleft)
{
    int ex, ey;
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);
    
    if (w == 0) w = 1;
    if (h == 0) h = 1;
    ex = x + w - 1;
    ey = y + h - 1;
	
    if (skipleft)
    {
	pNewport->skipleft = x + skipleft;
    }
    else
    {
	pNewport->skipleft = 0;
    }
    NewportUpdateClipping(pNewport);
    
    NewportWaitGFIFO(pNewport, 3);
    pNewportRegs->set.xystarti = ((x & 0xFFFF) << 16) | (y & 0xFFFF);
    pNewportRegs->set.xyendi = ((ex & 0xFFFF) << 16) | (ey & 0xFFFF);
    pNewportRegs->set._setup = 1;

    /* after return XAA will start blasting the pattern to go.zpattern register */    
    /* we have to wait here for idle because if there is something in the pipeline that will take
     long time to complete and if following cpu transfers will overflow the FIFO causing GIO bus 
     stall it will end up in bus error */
    NewportWaitIdle(pNewport, NEWPORT_GFIFO_ENTRIES);
    
}

/*******************************************************************************

*******************************************************************************/
static void
NewportXAASetupForImageWrite(ScrnInfoPtr pScrn,
                             int rop,
			     unsigned int planemask,
			     int trans_color,
			     int bpp,
			     int depth)
{
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);
 
    NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
    NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(planemask));
    NewportUpdateDRAWMODE0(pNewport,
                           0
                           | NPORT_DMODE0_DRAW
                           | NPORT_DMODE0_BLOCK
			   | NPORT_DMODE0_CHOST
			   | NPORT_DMODE0_DOSETUP
			  );

}
				       
/*******************************************************************************

*******************************************************************************/
static void
NewportXAASubsequentImageWriteRect(ScrnInfoPtr pScrn,
                                   int x,
				   int y,
				   int w,
				   int h,
				   int skipleft)
{
    int ex, ey;
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);
    
    if (w == 0) w = 1;
    if (h == 0) h = 1;
    
    ex = x + w - 1;
    ey = y + h - 1;

    if (skipleft)
    {
	pNewport->skipleft = x + skipleft;
    }
    else
    {
	pNewport->skipleft = 0;
    }
    NewportUpdateClipping(pNewport);
    
    NewportWaitGFIFO(pNewport, 3);
    pNewportRegs->set.xystarti = ((x & 0xFFFF) << 16) | (y & 0xFFFF);
    pNewportRegs->set.xyendi = ((ex & 0xFFFF) << 16) | (ey & 0xFFFF);
    pNewportRegs->set._setup = 1;

    /* after return XAA will start blasting the image to go.hostrw0 register */    
    /* we have to wait here for idle because if there is something in the pipeline that will take
     long time to complete and if following cpu transfers will overflow the FIFO causing GIO bus 
     stall it will end up in bus error */
    NewportWaitIdle(pNewport, NEWPORT_GFIFO_ENTRIES);
}

static unsigned int 
repbyte(unsigned int b)
{
    b &= 0xFF;
    return b | (b << 8) | (b << 16) | (b << 24);
}

static void 
prerotatebyte(unsigned int b, unsigned int *p)
{
    int i;
    
    b &= 0xFF;
    
    for (i = 0; i < 8; i++)
    {
	p[i] = repbyte(b);
	if (b & 1)
	    b = (b >> 1) | 0x80;
	else
	    b = b >> 1;
    }
}

/*******************************************************************************

*******************************************************************************/
static void
NewportXAASetupForMono8x8PatternFill(ScrnInfoPtr pScrn,
                                     int patx,
				     int paty,
				     int fg,
				     int bg,
				     int rop,
				     unsigned int planemask)
{
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);
    
#ifdef NEWPORT_PREROTATE    
    /* prerotate the pattern */
    prerotatebyte((unsigned int)patx >> 24, pNewport->pat8x8[0]);
    prerotatebyte((unsigned int)patx >> 16, pNewport->pat8x8[1]);
    prerotatebyte((unsigned int)patx >> 8, pNewport->pat8x8[2]);
    prerotatebyte((unsigned int)patx, pNewport->pat8x8[3]);
    prerotatebyte((unsigned int)paty >> 24, pNewport->pat8x8[4]);
    prerotatebyte((unsigned int)paty >> 16, pNewport->pat8x8[5]);
    prerotatebyte((unsigned int)paty >> 8, pNewport->pat8x8[6]);
    prerotatebyte((unsigned int)paty, pNewport->pat8x8[7]);
#endif    
    NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
    NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(planemask));    
    if (bg != -1)
	NewportUpdateCOLORBACK(pNewport, NewportColor2HOSTRW(bg));
    NewportUpdateCOLORI(pNewport, NewportColor2HOSTRW(fg));
    pNewport->skipleft = 0;
    NewportUpdateClipping(pNewport);
    NewportUpdateDRAWMODE0(pNewport,
                           0
                           | NPORT_DMODE0_DRAW
                           | NPORT_DMODE0_BLOCK
		           | NPORT_DMODE0_DOSETUP
		           | NPORT_DMODE0_STOPX
			   | NPORT_DMODE0_ZPENAB
			   | ((bg == -1) ? 0 : NPORT_DMODE0_ZOPQ)
			   | NPORT_DMODE0_L32
			  );
}



/*******************************************************************************

*******************************************************************************/
static void
NewportXAASubsequentMono8x8PatternFillRect(ScrnInfoPtr pScrn,
                                           int patx,
					   int paty,
					   int x,
					   int y,
					   int w,
					   int h)
{
    int ex, ey;
    unsigned int d;    
#ifndef NEWPORT_PREROTATE
    unsigned int p;
    unsigned int epat[8];
#endif    
    
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);

    if (w == 0) w = 1;
    if (h == 0) h = 1;
    ex = x + w - 1;
    ey = y + h - 1;
    
    NewportWaitGFIFO(pNewport, 3);
    pNewportRegs->set.xystarti = ((x & 0xFFFF) << 16) | (y & 0xFFFF);
    pNewportRegs->set.xyendi = ((ex & 0xFFFF) << 16) | (ey & 0xFFFF);
    pNewportRegs->set._setup = 1;
    
#ifdef NEWPORT_PREROTATE
    patx &= 7;
    paty &= 7;
    while (h--)
    {
	for (d = (w + 31) >> 5; d; d--)
	{
	    NewportWaitGFIFO(pNewport, 1);
	    pNewportRegs->go.zpattern = pNewport->pat8x8[paty][patx];
	}
	paty = (paty + 1) & 7;
    }
#else
    epat[0] = repbyte(patx >> 24);
    epat[1] = repbyte(patx >> 16);
    epat[2] = repbyte(patx >> 8);
    epat[3] = repbyte(patx);
    epat[4] = repbyte(paty >> 24);
    epat[5] = repbyte(paty >> 16);
    epat[6] = repbyte(paty >> 8);
    epat[7] = repbyte(paty);
    
    p = 0;
    while (h--)
    {
	for (d = (w + 31) >> 5; d; d--)
	{
	    NewportWaitGFIFO(pNewport, 1);
	    pNewportRegs->go.zpattern = epat[p];
	}
	p = (p + 1) ^ 7;
    }
#endif    
}					   

/*******************************************************************************

*******************************************************************************/
static void 
NewportXAAReadPixmap(ScrnInfoPtr pScrn, 
                     int x, 
		     int y, 
		     int w, 
		     int h,
		     unsigned char *dst, 
		     int dstwidth, 
		     int bpp, 
		     int depth)
{
    int ex, ey;
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);
    
    if (w == 0) w = 1;
    if (h == 0) h = 1;
    ex = x + w - 1;
    ey = y + h - 1;
    
    NewportWaitIdle(pNewport, 0);
    NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(GXcopy) | NPORT_DMODE1_PFENAB);
    NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(0xFFFFFFFF));
    NewportUpdateDRAWMODE0(pNewport,
                           0
                           | NPORT_DMODE0_RD
                           | NPORT_DMODE0_BLOCK
			   | NPORT_DMODE0_CHOST
			   | NPORT_DMODE0_DOSETUP
			  );

    NewportWaitGFIFO(pNewport, 3);
    pNewportRegs->set.xystarti = ((x & 0xFFFF) << 16) | (y & 0xFFFF);
    pNewportRegs->set.xyendi = ((ex & 0xFFFF) << 16) | (ey & 0xFFFF);
    /* with prefetch enabled go has to be issued before we start reading */
    pNewportRegs->go._setup = 1;


    if (pScrn->bitsPerPixel == 8)
    {
	unsigned int d;
	while (h--)
	{
	    unsigned char *p;
	    p = (unsigned char *)dst;
    	    for (x = 0; x < w; x += 4)
	    {
		if (!h && x+4 >= w)
		{ /* the last dword does not need go */
		    d = pNewportRegs->set.hostrw0;
		}
		else
		{
		    d = pNewportRegs->go.hostrw0;
		}
		
		*p++ = (d & 0xFF000000) >> 24;
		if (x+1 < w)
		{
		    *p++ = (d & 0x00FF0000) >> 16;
		}
		if (x+2 < w)
		{
		    *p++ = (d & 0x0000FF00) >> 8;
		}
		if (x+3 < w)
		{
		    *p++ = d & 0x000000FF;
		}
	    }
	    dst += dstwidth;
	}
    }
    else
    {
	while (h--)
	{
	    unsigned int *p;
	    p = (unsigned int *)dst;
    	    for (x = 0; x < w; x++)
	    {
		if (!h && x+1 == w)
		{ /* the last dword does not need go */
		    *p++ = pNewportRegs->set.hostrw0;
		}
		else
		{
		    *p++ = pNewportRegs->go.hostrw0;
		}
	    }
	    dst += dstwidth;
	}
    }
}

/*******************************************************************************

*******************************************************************************/
static void
NewportXAASetClippingRectangle(ScrnInfoPtr pScrn,
                               int left,
			       int top,
			       int right,
			       int bottom)
{
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);

    if (left < 0) left = 0;
    if (right > pScrn->virtualX-1) right = pScrn->virtualX-1;
    
    if (top < 0) top = 0;
    if (bottom > pScrn->virtualY-1) bottom = pScrn->virtualY-1;
    
    pNewport->clipsx = left;
    pNewport->clipex = right;
    pNewport->clipsy = top;
    pNewport->clipey = bottom;

    NewportUpdateClipping(pNewport);
}

/*******************************************************************************

*******************************************************************************/
static void
NewportXAADisableClipping(ScrnInfoPtr pScrn)
{
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);

    pNewport->clipsx = 0;
    pNewport->clipex = pScrn->virtualX-1;
    pNewport->clipsy = 0;
    pNewport->clipey = pScrn->virtualY-1;
    NewportUpdateClipping(pNewport);
}

/*******************************************************************************

*******************************************************************************/
static void
NewportPolyPoint(DrawablePtr pDraw,
                 GCPtr pGC,
                 int mode,
                 int npt,
                 xPoint *ppt)
{
    ScrnInfoPtr pScrn;
    int numRects = REGION_NUM_RECTS(pGC->pCompositeClip);
    int rect;
    XAAInfoRecPtr infoRec;
    BoxPtr pbox;
    int x, y;
    int rop;

    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    
    infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
    pScrn = infoRec->pScrn;
    
    if (!numRects) 
	return;

    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);

    x = pDraw->x;
    y = pDraw->y;
    
    rop = pGC->alu;
    
    NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(pGC->planemask));
    if (rop == GXcopy
        || rop == GXclear
	|| rop == GXset)
    {
	/* if possible try to set up a fast clear which is 4x faster */
	NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | NPORT_DMODE1_FCLR | Rop2LogicOp(GXcopy));
	if (rop == GXclear)
	    NewportUpdateCOLORVRAM(pNewport, 0);
	else
	if (rop == GXset)
	    NewportUpdateCOLORVRAM(pNewport, 0xFFFFFF);
	else
            NewportUpdateCOLORVRAM(pNewport, pNewport->Color2Planes((unsigned int)(pGC->fgPixel)));
    }
    else
    {
	NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
	NewportUpdateCOLORI(pNewport, NewportColor2HOSTRW(pGC->fgPixel));
    }
    
    pNewport->skipleft = 0;
    NewportUpdateClipping(pNewport);
    NewportUpdateDRAWMODE0(pNewport,
                           0
                           | NPORT_DMODE0_DRAW
			   | NPORT_DMODE0_BLOCK
		           | NPORT_DMODE0_DOSETUP
			  );
    
    pbox = REGION_RECTS(pGC->pCompositeClip);
    
    while (npt--) {
	if (mode == CoordModePrevious)
	{
	    x += ppt->x;
	    y += ppt->y;
	}
	else
	{
	    x = pDraw->x + ppt->x;
	    y = pDraw->y + ppt->y;
	}
	for (rect = 0; rect < numRects; rect++)
	    if (x >= pbox[rect].x1 && x < pbox[rect].x2
	        && y >= pbox[rect].y1 && y < pbox[rect].y2)
	       { /* draw point */
	    	    unsigned int xy;
		    xy = ((x & 0xFFFF) << 16) | (y & 0xFFFF);
	    	    NewportWaitGFIFO(pNewport, 2);
		    pNewportRegs->set.xystarti = xy;
		    pNewportRegs->go.xyendi = xy;
		    break;
	       }
	ppt++;
    }
}

/*******************************************************************************

*******************************************************************************/
static void
NewportValidatePolyPoint(GCPtr pGC,
                         unsigned long changes,
                         DrawablePtr pDraw)
{

    if (pDraw->type == DRAWABLE_WINDOW)   
    {
	pGC->ops->PolyPoint = NewportPolyPoint;
    }
    else
    {
	pGC->ops->PolyPoint = XAAFallbackOps.PolyPoint;
    }
}

#if 1
/*******************************************************************************

*******************************************************************************/
static void
NewportPolyArc(DrawablePtr pDraw,
               GCPtr pGC,
               int narcs,
               xArc *parcs)
{
    xArc *arc;
    BoxRec box;
    int i, x2, y2;
    RegionPtr cclip;

    cclip = pGC->pCompositeClip;

    if(!REGION_NUM_RECTS(cclip))
	return;

    for (arc = parcs, i = narcs; --i >= 0; arc++) {
	if (miCanZeroArc(arc)) {
	    box.x1 = arc->x + pDraw->x;
	    box.y1 = arc->y + pDraw->y;
 	    x2 = box.x1 + (int)arc->width + 1;
 	    box.x2 = x2;
 	    y2 = box.y1 + (int)arc->height + 1;
 	    box.y2 = y2;
 	    if ( (x2 <= MAXSHORT) && (y2 <= MAXSHORT) &&
 		    (RECT_IN_REGION(pDraw->pScreen, cclip, &box) == rgnIN) )
		miZeroPolyArc(pDraw, pGC, 1, arc);
	}
	else
	    miPolyArc(pDraw, pGC, 1, arc);
    }
}
#endif

/*******************************************************************************

*******************************************************************************/
static void
NewportValidatePolyArc(GCPtr pGC,
                       unsigned long changes,
                       DrawablePtr pDraw)
{
    if (pDraw->type == DRAWABLE_WINDOW)   
    {
	pGC->ops->PolyPoint = NewportPolyPoint;
	/*pGC->ops->PolyArc = miPolyArc;*/
	pGC->ops->PolyArc = NewportPolyArc;
	
    }
    else
    {
	pGC->ops->PolyPoint = XAAFallbackOps.PolyPoint;
	pGC->ops->PolyArc = XAAFallbackOps.PolyArc;
    }
}


#ifdef RENDER
/*******************************************************************************

*******************************************************************************/
static Bool 
NewportXAASetupForCPUToScreenAlphaTexture(
	ScrnInfoPtr	pScrn,
	int		op,
	CARD16		red,
	CARD16		green,
	CARD16		blue,
	CARD16		alpha,
	CARD32		maskFormat,
	CARD32		dstFormat,
	CARD8		*alphaPtr,
	int		alphaPitch,
	int		width,
	int		height,
	int		flags)
{
    unsigned int col, a;
    unsigned char *pSrc;
    unsigned int *pDst;
    unsigned int w;
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);

    if (width * height * sizeof(unsigned int) > pNewport->uTextureSize)
    {
	free(pNewport->pTexture);
	pNewport->pTexture = xnfalloc(pNewport->uTextureSize = width * height * sizeof(unsigned int));
    }
    col = (((unsigned int)red & 0xFF00) << 8)
        | ((unsigned int)green & 0xFF00)
	| ((unsigned int)blue >> 8);
	
    pNewport->uTextureWidth = width;
    pNewport->uTextureHeight = height;
    pNewport->uTextureFlags = flags;
    
    /* copy texture */
    pDst = pNewport->pTexture;
    while (height--) {
	pSrc = (unsigned char *)alphaPtr;
	
	for (w = width; w; w--)
	{
	    /* premultiply alpha */
	    a = *pSrc++;
	    a *= alpha;
	    a /= 0xFFFF;
	    a <<= 24;
	    *pDst++ = col | a;
	}
	alphaPtr += alphaPitch;
    }
#define SFACTOR (4 << 19)
#define DFACTOR (5 << 22)
    NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(GXcopy) | NPORT_DMODE1_BENAB | SFACTOR | DFACTOR );
#undef SFACTOR
#undef DFACTOR    
    NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(0xFFFFFFFF));

    pNewport->skipleft = 0;
    NewportUpdateClipping(pNewport);
    NewportUpdateDRAWMODE0(pNewport,
                           0
                           | NPORT_DMODE0_DRAW
                           | NPORT_DMODE0_BLOCK
			   | NPORT_DMODE0_CHOST
			   | NPORT_DMODE0_AHOST
			   | NPORT_DMODE0_DOSETUP
			  );
    return TRUE;
}   

/*******************************************************************************

*******************************************************************************/
static Bool 
NewportXAASetupForCPUToScreenTexture(
	ScrnInfoPtr	pScrn,
	int		op,
	CARD32		srcFormat,
	CARD32		dstFormat,
	CARD8		*texPtr,
	int		texPitch,
	int		width,
	int		height,
	int		flags)
{
    unsigned int *pSrc, *pDst;
    unsigned int w;
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);

    if (width * height * sizeof(unsigned int) > pNewport->uTextureSize)
    {
	free(pNewport->pTexture);
	pNewport->pTexture = xnfalloc(pNewport->uTextureSize = width * height * sizeof(unsigned int));
    }
	
    pNewport->uTextureWidth = width;
    pNewport->uTextureHeight = height;
    pNewport->uTextureFlags = flags;
    
    /* copy texture */
    pDst = pNewport->pTexture;
    
    if (srcFormat == PICT_a8r8g8b8)
    {
	while (height--) {
	    pSrc = (unsigned int *)texPtr;
	
	    for (w = width; w; w--)
	    {
		unsigned int v;
		v = *pSrc++;
		*pDst++ = (v & 0xFF00FF00) | ((v & 0x00FF0000) >> 16) | ((v & 0x000000FF) << 16);
	    }
	    texPtr += texPitch;
	}
    }
    else
    if (srcFormat == PICT_a8b8g8r8)
    {
	while (height--) {
	    pSrc = (unsigned int *)texPtr;
	
	    for (w = width; w; w--)
		*pDst++ = *pSrc++;
	    texPtr += texPitch;
	}
    }
    else
    {
	xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Unknown texture format\n");
    }
    
#define SFACTOR (4 << 19)
#define DFACTOR (5 << 22)
    NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(GXcopy) | NPORT_DMODE1_BENAB | SFACTOR | DFACTOR );
#undef SFACTOR
#undef DFACTOR    
    NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(0xFFFFFFFF));

    pNewport->skipleft = 0;
    NewportUpdateClipping(pNewport);
    NewportUpdateDRAWMODE0(pNewport,
                           0
                           | NPORT_DMODE0_DRAW
                           | NPORT_DMODE0_BLOCK
			   | NPORT_DMODE0_CHOST
			   | NPORT_DMODE0_AHOST
			   | NPORT_DMODE0_DOSETUP
			  );

    return TRUE;
}	

/*******************************************************************************

*******************************************************************************/
static void
NewportRenderTexture1to1(NewportPtr pNewport, int srcx, int srcy, int w, int h)
{
    unsigned int *p;
    unsigned int add, d;
    NewportRegsPtr pNewportRegs;
    pNewportRegs = pNewport->pNewportRegs;

    p = pNewport->pTexture + srcx + (srcy * pNewport->uTextureWidth);
    add = pNewport->uTextureWidth - srcx;
    while (h--) 
    {
	for (d = w; d; d--)
	{
	    /*NewportWaitGFIFO(pNewport, 1);*/
	    /* hopefully we cannot write faster than XL24 can blend */
	    pNewportRegs->go.hostrw0 = *p++;
	}
	p += add;
    }
}

/*******************************************************************************

*******************************************************************************/
static void
NewportRenderTextureScale(NewportPtr pNewport, int srcx, int srcy, int w, int h)
{
    int d;
    int dx, dy;
    int curx, cury;
    unsigned int *pLine;
    int l, p;
    NewportRegsPtr pNewportRegs;
    pNewportRegs = pNewport->pNewportRegs;
    
    dx = ((pNewport->uTextureWidth - srcx) << 16) / w;
    dy = ((pNewport->uTextureHeight - srcy) << 16) / h;
    
    cury = srcy << 16;    
    while (h--)
    {	
	l = (cury + 0x7FFF) >> 16;
	if (l >= pNewport->uTextureHeight)
	    l = pNewport->uTextureHeight-1;
	pLine = pNewport->pTexture + l * pNewport->uTextureWidth;

	curx = srcx << 16;
	for (d = w; d; d--)
	{
	    p = (curx + 0x7FFF) >> 16;
	    if (p >= pNewport->uTextureWidth)
		p = pNewport->uTextureWidth-1;
	    pNewportRegs->go.hostrw0 = pLine[p];		
	    curx += dx;
	}
        cury += dy;
    }
}

/*******************************************************************************

*******************************************************************************/
static void
NewportRenderTextureRepeat(NewportPtr pNewport, int srcx, int srcy, int w, int h)
{
    int d;
    unsigned int *pLine;
    NewportRegsPtr pNewportRegs;
    pNewportRegs = pNewport->pNewportRegs;
    
    srcx %= pNewport->uTextureWidth;
    srcy %= pNewport->uTextureHeight;
    
    while (h--)
    {	
	pLine = pNewport->pTexture + pNewport->uTextureWidth * srcy;
	for (d = w; d; d--)
	{
	    pNewportRegs->go.hostrw0 = pLine[srcx];
	    srcx++;
	    if (srcx >= pNewport->uTextureWidth)
		srcx = 0;
	}
        srcy++;
	if (srcy >= pNewport->uTextureHeight)
	    srcy = 0;
    }

}


/*******************************************************************************

*******************************************************************************/
static void 
NewportXAASubsequentCPUToScreenTexture(
	ScrnInfoPtr	pScrn,
	int		x,
	int		y,
	int		srcx,
	int		srcy,
	int		w,
	int		h)
{
    int ex, ey;
    NewportRegsPtr pNewportRegs;
    NewportPtr pNewport;
    pNewport = NEWPORTPTR(pScrn);
    pNewportRegs = NEWPORTREGSPTR(pScrn);
    
    if (w == 0) w = 1;
    if (h == 0) h = 1;
    ex = x + w - 1;
    ey = y + h - 1;
    
    NewportWaitGFIFO(pNewport, 3);
    pNewportRegs->set.xystarti = ((x & 0xFFFF) << 16) | (y & 0xFFFF);
    pNewportRegs->set.xyendi = ((ex & 0xFFFF) << 16) | (ey & 0xFFFF);
    pNewportRegs->set._setup = 1;

    NewportWaitIdle(pNewport, NEWPORT_GFIFO_ENTRIES);
    
    if (srcx + w == pNewport->uTextureWidth
        && srcy + h == pNewport->uTextureHeight)
	NewportRenderTexture1to1(pNewport, srcx, srcy, w, h);
    else
    if (pNewport->uTextureFlags & XAA_RENDER_REPEAT)
	NewportRenderTextureRepeat(pNewport,  srcx, srcy, w, h);
    else
	NewportRenderTextureScale(pNewport, srcx, srcy, w, h);

    NewportWaitIdle(pNewport, NEWPORT_GFIFO_ENTRIES);        

}	

CARD32 NewportAlphaTextureFormats[2] = {PICT_a8, 0};
CARD32 NewportTextureFormats[3] = {PICT_a8r8g8b8, PICT_a8b8g8r8, 0};
/*CARD32 NewportTextureFormats[2] = {PICT_a8r8g8b8, 0};*/

#endif

/*******************************************************************************

*******************************************************************************/
Bool
NewportXAAScreenInit(ScreenPtr pScreen)
{
	ScrnInfoPtr pScrn;
	NewportPtr pNewport;
	NewportRegsPtr pNewportRegs;
	XAAInfoRecPtr pXAAInfoRec;

	/* First get a pointer to our private info */
	pScrn = xf86Screens[pScreen->myNum];
	pNewport = NEWPORTPTR(pScrn);
	pNewportRegs = NEWPORTREGSPTR(pScrn);

	pXAAInfoRec =
	pNewport->pXAAInfoRec = XAACreateInfoRec();
	/* initialize accelerated functions */
	pXAAInfoRec->Sync = NewportXAASync;
	
	pXAAInfoRec->Flags = 0
	                     /*| LINEAR_FRAMEBUFFER*/
	                     ;
	/* screen to screen copy */
	pXAAInfoRec->ScreenToScreenCopyFlags = 0
					     | NO_TRANSPARENCY
					     ;
	pXAAInfoRec->SetupForScreenToScreenCopy = NewportXAASetupForScreenToScreenCopy;
	pXAAInfoRec->SubsequentScreenToScreenCopy = NewportXAASubsequentScreenToScreenCopy;

	/* solid fills */
	pXAAInfoRec->SolidFillFlags = 0
				      ;
	pXAAInfoRec->SetupForSolidFill = NewportXAASetupForSolidFill;
	pXAAInfoRec->SubsequentSolidFillRect = NewportXAASubsequentSolidFillRect;
	
	/* solid lines */
	pXAAInfoRec->SolidLineFlags = 0
	                              ;
	pXAAInfoRec->SetupForSolidLine = NewportXAASetupForSolidLine;
	pXAAInfoRec->SubsequentSolidTwoPointLine = NewportXAASubsequentSolidTwoPointLine;
	
	/* dashed lines */
	pXAAInfoRec->DashedLineFlags = 0
	                             | LINE_PATTERN_MSBFIRST_MSBJUSTIFIED
	                             ;
	pXAAInfoRec->DashPatternMaxLength = 2048;
	pXAAInfoRec->SetupForDashedLine = NewportXAASetupForDashedLine;
	pXAAInfoRec->SubsequentDashedTwoPointLine = NewportXAASubsequentDashedTwoPointLine;

	/* cpu to screen expand color fill */
	pXAAInfoRec->CPUToScreenColorExpandFillFlags = 0
						     | BIT_ORDER_IN_BYTE_LSBFIRST
						     | SCANLINE_PAD_DWORD
						     | CPU_TRANSFER_PAD_DWORD
						     | CPU_TRANSFER_BASE_FIXED
				                     | LEFT_EDGE_CLIPPING
				                     | LEFT_EDGE_CLIPPING_NEGATIVE_X
						     /*| SYNC_AFTER_COLOR_EXPAND*/
						     ;
						     
	pXAAInfoRec->SetupForCPUToScreenColorExpandFill	= NewportXAASetupForCPUToScreenColorExpandFill;
	pXAAInfoRec->SubsequentCPUToScreenColorExpandFill = NewportXAASubsequentCPUToScreenColorExpandFill;
	pXAAInfoRec->ColorExpandRange = 4;
	pXAAInfoRec->ColorExpandBase = (unsigned char *)&(pNewportRegs->go.zpattern);


	/* mono 8x8 pattern fill */
	pXAAInfoRec->Mono8x8PatternFillFlags = 0
	                                       | BIT_ORDER_IN_BYTE_LSBFIRST
					       | HARDWARE_PATTERN_PROGRAMMED_BITS
#ifdef NEWPORT_PREROTATE
                                               | HARDWARE_PATTERN_PROGRAMMED_ORIGIN
#endif					       
                                               ;
						     
	pXAAInfoRec->SetupForMono8x8PatternFill	= NewportXAASetupForMono8x8PatternFill;
	pXAAInfoRec->SubsequentMono8x8PatternFillRect = NewportXAASubsequentMono8x8PatternFillRect;

	/* Image write */
	pXAAInfoRec->ImageWriteFlags = 0
				     | NO_TRANSPARENCY
				     | CPU_TRANSFER_BASE_FIXED
				     | CPU_TRANSFER_PAD_DWORD
				     | SCANLINE_PAD_DWORD
				     | LEFT_EDGE_CLIPPING
				     | LEFT_EDGE_CLIPPING_NEGATIVE_X
				     /*| SYNC_AFTER_IMAGE_WRITE*/
				     ;
	pXAAInfoRec->SetupForImageWrite = NewportXAASetupForImageWrite;
	pXAAInfoRec->SubsequentImageWriteRect = NewportXAASubsequentImageWriteRect;
	pXAAInfoRec->ImageWriteRange = 4;
	pXAAInfoRec->ImageWriteBase =  (unsigned char *)&(pNewportRegs->go.hostrw0);

	/* read pixmap */
	pXAAInfoRec->ReadPixmapFlags = 0
	                             | CPU_TRANSFER_PAD_DWORD
				     ;
	pXAAInfoRec->ReadPixmap = NewportXAAReadPixmap;

	/* clipping */
	pXAAInfoRec->ClippingFlags = 0
	                             /*| HARDWARE_CLIP_SCREEN_TO_SCREEN_COLOR_EXPAND*/
				     | HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY
				     | HARDWARE_CLIP_MONO_8x8_FILL
				     /*| HARDWARE_CLIP_COLOR_8x8_FILL*/
				     | HARDWARE_CLIP_SOLID_FILL
				     | HARDWARE_CLIP_DASHED_LINE
				     | HARDWARE_CLIP_SOLID_LINE
	                             ;
	pXAAInfoRec->SetClippingRectangle = NewportXAASetClippingRectangle;
	pXAAInfoRec->DisableClipping = NewportXAADisableClipping;

	/* make it draw points using our function */	
	pXAAInfoRec->ValidatePolyPoint = NewportValidatePolyPoint;
	pXAAInfoRec->PolyPointMask = GCFunction | GCPlaneMask;
	/*pXAAInfoRec->PolyPointMask = 0xFFFFFFFF;*/

	pXAAInfoRec->ValidatePolyArc = NewportValidatePolyArc;
	pXAAInfoRec->PolyArcMask = GCFunction | GCLineWidth;
#ifdef RENDER
	if (pScrn->bitsPerPixel > 8) {
	pXAAInfoRec->CPUToScreenTextureFlags = 0
	                                       ;
	pXAAInfoRec->CPUToScreenTextureFormats = NewportTextureFormats;
	pXAAInfoRec->CPUToScreenTextureDstFormats = NewportTextureFormats;
	pXAAInfoRec->SetupForCPUToScreenTexture2 = NewportXAASetupForCPUToScreenTexture;
	pXAAInfoRec->SubsequentCPUToScreenTexture = NewportXAASubsequentCPUToScreenTexture;

	pXAAInfoRec->CPUToScreenAlphaTextureFlags = 0
	                                            ;
	pXAAInfoRec->CPUToScreenAlphaTextureFormats = NewportAlphaTextureFormats;
	pXAAInfoRec->CPUToScreenAlphaTextureDstFormats = NewportAlphaTextureFormats;
	pXAAInfoRec->SetupForCPUToScreenAlphaTexture2 = NewportXAASetupForCPUToScreenAlphaTexture;
	pXAAInfoRec->SubsequentCPUToScreenAlphaTexture = NewportXAASubsequentCPUToScreenTexture; /* this is the same for both */
	pNewport->pTexture = (unsigned int *)xnfalloc(pNewport->uTextureSize = 16*16*sizeof(unsigned int));
	}
#endif	
	
	pNewport->Color2Planes = NewportColor2Planes24;
	if (pScrn->bitsPerPixel == 8)
	{
	    pNewport->Color2Planes = NewportColor2Planes8;
	}

	if (!XAAInit(pScreen, pXAAInfoRec))
	{
	    xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "XAAInit Failed!\n"); 
	    return FALSE;
	}

	pNewport->fifoleft = 0;
	/* init bunch of registers */
	
	pNewport->shadow_drawmode0 = pNewportRegs->set.drawmode0;
	pNewport->shadow_colori = pNewportRegs->set.colori;
	pNewport->shadow_smask0x = pNewportRegs->set.smask0x;
	pNewport->shadow_smask0y = pNewportRegs->set.smask0y;
	
	pNewport->shadow_drawmode1 = pNewport->drawmode1;
	pNewportRegs->set.drawmode1 = pNewport->drawmode1;
	pNewport->setup_drawmode1 = pNewport->drawmode1 & ~NPORT_DMODE1_LOMASK;
	
	pNewport->shadow_xymove = 0;
	pNewportRegs->set.xymove = 0;
	
	pNewport->shadow_wrmask = 0xFFFFFF;
	pNewportRegs->set.wrmask = 0xFFFFFF;
	
	pNewport->shadow_colorvram = 0;
	pNewportRegs->set.colorvram = 0;
	
	pNewport->shadow_colorback = 0;
	pNewportRegs->set.colorback = 0;
	
	pNewport->clipsx = 0;
	pNewport->clipex = pScrn->virtualX-1;
	pNewport->clipsy = 0;
	pNewport->clipey = pScrn->virtualY-1;
	pNewport->skipleft = 0;
	
	BARF1("CLIPMODE %08X\n", pNewportRegs->cset.clipmode);
	BARF1("XYWIN %08X\n", pNewportRegs->cset.xywin);
	BARF1("CONFIG %08X\n", pNewportRegs->cset.config);
	BARF1("SMASK0X %08X\n", pNewportRegs->set.smask0x);
	BARF1("SMASK0Y %08X\n", pNewportRegs->set.smask0y);
	
/*
  set GIO bus timeout to highest possible value 4.32us 
  this will allow for longer bus stalls without bus error
*/	
	{
	    unsigned int conf;
	    conf = pNewportRegs->cset.config;
	    conf &= ~NPORT_CFG_TOMSK;
	    conf |= NPORT_CFG_TOMSK;
	    
	    conf &= ~NPORT_CFG_GDMSK;
	    conf |= NPORT_CFG_GDMSK;
	    
	    pNewportRegs->cset.config = conf;
	}
	
	BARF1("CONFIG %08X\n", pNewportRegs->cset.config);
	
	pNewport->shadow_clipmode = pNewportRegs->cset.clipmode;
	pNewportRegs->cset.clipmode |= 1; /* enable clipping mask 0 */
	NewportUpdateClipping(pNewport);
	
	return TRUE;
}

#endif 
/* NEWPORT_ACCEL */

Lines 117-122 Link Here

(-)xc/programs/Xserver/hw/xfree86/drivers/newport-old/newport_driver.c (-5 / +75 lines)
117	NULL	117	NULL
118	};	118	};
119		119
		120	static const char *xaaSymbols[] = {
		121	"XAACreateInfoRec",
		122	"XAADestroyInfoRec",
		123	"XAAFallbackOps",
		124	"XAAInit",
		125	NULL
		126	};
		127
		128
120	#ifdef XFree86LOADER	129	#ifdef XFree86LOADER
121		130
122	static MODULESETUPPROTO(newportSetup);	131	static MODULESETUPPROTO(newportSetup);
Lines 128-133 Link Here
128	MODINFOSTRING1,	137	MODINFOSTRING1,
129	MODINFOSTRING2,	138	MODINFOSTRING2,
130	XORG_VERSION_CURRENT,	139	XORG_VERSION_CURRENT,
		140	/*
		141	XF86_VERSION_CURRENT,
		142	*/
131	NEWPORT_MAJOR_VERSION, NEWPORT_MINOR_VERSION, NEWPORT_PATCHLEVEL,	143	NEWPORT_MAJOR_VERSION, NEWPORT_MINOR_VERSION, NEWPORT_PATCHLEVEL,
132	ABI_CLASS_VIDEODRV,	144	ABI_CLASS_VIDEODRV,
133	ABI_VIDEODRV_VERSION,	145	ABI_VIDEODRV_VERSION,
Lines 156-162 Link Here
156	* might refer to.	168	* might refer to.
157	*	169	*
158	*/	170	*/
159	LoaderRefSymLists( fbSymbols, ramdacSymbols, shadowSymbols, NULL);	171	LoaderRefSymLists( fbSymbols, ramdacSymbols, shadowSymbols, xaaSymbols, NULL);
160		172
161		173
162	/*	174	/*
Lines 175-181 Link Here
175	typedef enum {	187	typedef enum {
176	OPTION_BITPLANES,	188	OPTION_BITPLANES,
177	OPTION_BUS_ID,	189	OPTION_BUS_ID,
178	OPTION_HWCURSOR	190	OPTION_HWCURSOR,
		191	OPTION_NOACCEL
179	} NewportOpts;	192	} NewportOpts;
180		193
181	/* Supported options */	194	/* Supported options */
Lines 183-188 Link Here
183	{ OPTION_BITPLANES, "bitplanes", OPTV_INTEGER, {0}, FALSE },	196	{ OPTION_BITPLANES, "bitplanes", OPTV_INTEGER, {0}, FALSE },
184	{ OPTION_BUS_ID, "BusID", OPTV_INTEGER, {0}, FALSE },	197	{ OPTION_BUS_ID, "BusID", OPTV_INTEGER, {0}, FALSE },
185	{ OPTION_HWCURSOR, "HWCursor", OPTV_BOOLEAN, {0}, FALSE },	198	{ OPTION_HWCURSOR, "HWCursor", OPTV_BOOLEAN, {0}, FALSE },
		199	{ OPTION_NOACCEL, "NoAccel", OPTV_BOOLEAN, {0}, FALSE },
186	{ -1, NULL, OPTV_NONE, {0}, FALSE }	200	{ -1, NULL, OPTV_NONE, {0}, FALSE }
187	};	201	};
188		202
Lines 297-307 Link Here
297	/* Fill in the monitor field */	311	/* Fill in the monitor field */
298	pScrn->monitor = pScrn->confScreen->monitor;	312	pScrn->monitor = pScrn->confScreen->monitor;
299		313
		314	#ifdef NEWPORT_USE32BPP
		315	if (!xf86SetDepthBpp(pScrn, 24, 32, 32, Support32bppFb))
		316	return FALSE;
		317	#else
300	if (!xf86SetDepthBpp(pScrn, 24, 0, 0,	318	if (!xf86SetDepthBpp(pScrn, 24, 0, 0,
301	Support24bppFb \| SupportConvert32to24 \|	319	Support24bppFb \| SupportConvert32to24 \|
302	PreferConvert32to24 ))	320	PreferConvert32to24 ))
303	return FALSE;	321	return FALSE;
304		322	#endif
305	switch( pScrn->depth ) {	323	switch( pScrn->depth ) {
306	/* check if the returned depth is one we support */	324	/* check if the returned depth is one we support */
307	case 8:	325	case 8:
Lines 322-330 Link Here
322		340
323	/* Set Default Weight */	341	/* Set Default Weight */
324	if( pScrn->depth > 8 ) {	342	if( pScrn->depth > 8 ) {
		343	#ifdef NEWPORT_USE32BPP
		344	rgb w = {8, 8, 8};
		345	rgb m = {0x0000FF, 0x00FF00, 0xFF0000};
		346	if (!xf86SetWeight(pScrn, w, m))
		347	return FALSE;
		348	#else
325	rgb zeros = {0, 0, 0};	349	rgb zeros = {0, 0, 0};
326	if (!xf86SetWeight(pScrn, zeros, zeros))	350	if (!xf86SetWeight(pScrn, zeros, zeros))
327	return FALSE;	351	return FALSE;
		352	#endif
328	}	353	}
329		354
330	if (!xf86SetDefaultVisual(pScrn, -1)) {	355	if (!xf86SetDefaultVisual(pScrn, -1)) {
Lines 474-479 Link Here
474	return TRUE;	499	return TRUE;
475	}	500	}
476		501
		502
		503	Bool
		504	NewportXAAScreenInit(ScreenPtr pScreen);
		505
		506
477	static Bool	507	static Bool
478	NewportScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)	508	NewportScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
479	{	509	{
Lines 529-546 Link Here
529	visual->redMask = pScrn->mask.red;	559	visual->redMask = pScrn->mask.red;
530	visual->greenMask = pScrn->mask.green;	560	visual->greenMask = pScrn->mask.green;
531	visual->blueMask = pScrn->mask.blue;	561	visual->blueMask = pScrn->mask.blue;
		562	/*
		563	xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Bitplanes R:%d:%08X G:%d:%08X B:%d:%08X\n",
		564	visual->offsetRed, visual->redMask,
		565	visual->offsetGreen, visual->greenMask,
		566	visual->offsetBlue, visual->blueMask);
		567	*/
532	}	568	}
533	}	569	}
534	}	570	}
535		571
536	/* must be after RGB ordering fixed */	572	/* must be after RGB ordering fixed */
537	fbPictureInit (pScreen, 0, 0);	573	if (!fbPictureInit(pScreen, NULL, 0))
		574	xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
		575	"RENDER extension initialisation failed.\n");
538		576
539	miInitializeBackingStore(pScreen);	577	miInitializeBackingStore(pScreen);
540	xf86SetBackingStore(pScreen);	578	xf86SetBackingStore(pScreen);
541		579
542	xf86SetBlackWhitePixels(pScreen);	580	xf86SetBlackWhitePixels(pScreen);
		581	#ifdef NEWPORT_ACCEL
		582	pNewport->NoAccel = FALSE;
		583	if (xf86ReturnOptValBool(pNewport->Options, OPTION_NOACCEL, FALSE))
		584	{
		585	pNewport->NoAccel = TRUE;
		586	xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Acceleration disabled\n");
		587	}
		588	#if 0
		589	if (pScrn->bitsPerPixel < 24)
		590	{ /* not implemented yet */
		591	pNewport->NoAccel = TRUE;
		592	}
		593	#endif
		594	pNewport->pXAAInfoRec = NULL;
		595	if (!pNewport->NoAccel)
		596	{
		597	if (!xf86LoadSubModule(pScrn, "xaa"))
		598	return FALSE;
		599	xf86LoaderReqSymLists(xaaSymbols, NULL);
543		600
		601	if (!NewportXAAScreenInit(pScreen))
		602	return FALSE;
		603	}
		604	#endif
544	/* Initialize software cursor */	605	/* Initialize software cursor */
545	if(!miDCInitialize(pScreen, xf86GetPointerScreenFuncs()))	606	if(!miDCInitialize(pScreen, xf86GetPointerScreenFuncs()))
546	return FALSE;	607	return FALSE;
Lines 564-570 Link Here
564	"Colormap initialization failed\n");	625	"Colormap initialization failed\n");
565	return FALSE;	626	return FALSE;
566	}	627	}
567		628	#ifdef NEWPORT_ACCEL
		629	if (pNewport->NoAccel)
		630	#endif
568	/* Initialise shadow frame buffer */	631	/* Initialise shadow frame buffer */
569	if(!ShadowFBInit(pScreen, (pNewport->Bpp == 1) ? &NewportRefreshArea8 :	632	if(!ShadowFBInit(pScreen, (pNewport->Bpp == 1) ? &NewportRefreshArea8 :
570	&NewportRefreshArea24)) {	633	&NewportRefreshArea24)) {
Lines 617-622 Link Here
617	{	680	{
618	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];	681	ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
619	NewportPtr pNewport = NEWPORTPTR(pScrn);	682	NewportPtr pNewport = NEWPORTPTR(pScrn);
		683	#ifdef NEWPORT_ACCEL
		684	if (pNewport->pXAAInfoRec && !pNewport->NoAccel)
		685	{
		686	XAADestroyInfoRec(pNewport->pXAAInfoRec);
		687	pNewport->pXAAInfoRec = NULL;
		688	}
		689	#endif
620		690
621	NewportRestore(pScrn, TRUE);	691	NewportRestore(pScrn, TRUE);
622	if (pNewport->ShadowPtr)	692	if (pNewport->ShadowPtr)





typedef volatile unsigned long npireg_t;

union npfloat {
	volatile float f;
	npireg_t       i;
};

typedef union npfloat npfreg_t;

union np_dcb {
	npireg_t all;
	struct { volatile unsigned short s0, s1; } hwords;

	unsigned long _pad1[0x30];

	/* Iterators, full state for context switch */
	npireg_t _xstart;	/* X-start point (current) */
	npireg_t _ystart;	/* Y-start point (current) */
	npireg_t _xend;		/* x-end point */
	npireg_t _yend;		/* y-end point */
	npireg_t xsave;		/* copy of xstart integer value for BLOCk addressing MODE */
	npireg_t xymove;	/* x.y offset from xstart, ystart for relative operations */
	npireg_t bresd;
	npireg_t bress1;
	npireg_t bresoctinc1;
	npireg_t bresrndinc2;
	npireg_t brese1;
	npireg_t bress2;
	npireg_t aweight0;
	npireg_t aweight1;
	npireg_t xstartf;
	npireg_t ystartf;
	npireg_t xendf;
	npireg_t yendf;
	npireg_t xstarti;
	npireg_t xendf1;
	npireg_t xystarti;
	npireg_t xyendi;
	npireg_t xstartendi;

	unsigned long _unused2[0x29];

	npireg_t colorred;
	npireg_t coloralpha;
	npireg_t colorgrn;
	npireg_t colorblue;
	npireg_t slopered;
	npireg_t slopealpha;
	npireg_t slopegrn;
	npireg_t slopeblue;
	npireg_t wrmask;
	npireg_t colori;
	npireg_t colorx;
	npireg_t slopered1;
	npireg_t hostrw0;
	npireg_t hostrw1;
	npireg_t dcbmode;

#define NPORT_CMODE_CMSK  0x00001e00

	unsigned long _unused0;
	npireg_t config;
#define NPORT_CFG_G32MD   0x00000001
#define NPORT_CFG_BWIDTH  0x00000002
#define NPORT_CFG_ERCVR   0x00000004
#define NPORT_CFG_BDMSK   0x00000078
#define NPORT_CFG_BFAINT  0x00000080
#define NPORT_CFG_GDMSK   0x00001f00
#define NPORT_CFG_GD0     0x00000100
#define NPORT_CFG_GD1     0x00000200
#define NPORT_CFG_GD2     0x00000400
#define NPORT_CFG_GD3     0x00000800
#define NPORT_CFG_GD4     0x00001000
#define NPORT_CFG_GFAINT  0x00002000
#define NPORT_CFG_TOMSK   0x0001C000
#define NPORT_CFG_VRMSK   0x000E0000
#define NPORT_CFG_FBTYP   0x00100000

	npireg_t _unused1;
	npireg_t stat;

Lines 52-58 Link Here

(-)xc/programs/Xserver/hw/xfree86/drivers/newport-old/newport_shadow.c (-2 / +14 lines)
52	{	52	{
53	int dx, dy;	53	int dx, dy;
54	CARD8 src, base;	54	CARD8 src, base;
		55	#ifndef NEWPORT_USE32BPP
55	CARD32 dest;	56	CARD32 dest;
		57	#endif
56	NewportPtr pNewport = NEWPORTPTR(pScrn);	58	NewportPtr pNewport = NEWPORTPTR(pScrn);
57	NewportRegsPtr pNewportRegs = pNewport->pNewportRegs;	59	NewportRegsPtr pNewportRegs = pNewport->pNewportRegs;
58		60
Lines 65-72 Link Here
65	NPORT_DMODE0_CHOST);	67	NPORT_DMODE0_CHOST);
66		68
67	while(num--) {	69	while(num--) {
68	base = (CARD8)pNewport->ShadowPtr + pbox->y1 pNewport->ShadowPitch + pbox->x1 * 3;	70
69		71	base = (CARD8)pNewport->ShadowPtr + pbox->y1 pNewport->ShadowPitch + pbox->x1
		72	#ifdef NEWPORT_USE32BPP
		73	* 4;
		74	#else
		75	* 3;
		76	#endif
70	pNewportRegs->set.xystarti = (pbox->x1 << 16) \| pbox->y1;	77	pNewportRegs->set.xystarti = (pbox->x1 << 16) \| pbox->y1;
71	pNewportRegs->set.xyendi = ((pbox->x2-1) << 16) \| (pbox->y2-1);	78	pNewportRegs->set.xyendi = ((pbox->x2-1) << 16) \| (pbox->y2-1);
72		79
Lines 76-84 Link Here
76	/* Removing these shifts by using 32bpp fb	83	/* Removing these shifts by using 32bpp fb
77	* yields < 2% percent performance gain and wastes 25% memory	84	* yields < 2% percent performance gain and wastes 25% memory
78	*/	85	*/
		86	#ifdef NEWPORT_USE32BPP
		87	pNewportRegs->go.hostrw0 = (CARD32 )src;
		88	src += 4;
		89	#else
79	dest = src[0] \| src[1] << 8 \| src[2] << 16;	90	dest = src[0] \| src[1] << 8 \| src[2] << 16;
80	pNewportRegs->go.hostrw0 = dest;	91	pNewportRegs->go.hostrw0 = dest;
81	src+=3;	92	src+=3;
		93	#endif
82	}	94	}
83	base += pNewport->ShadowPitch;	95	base += pNewport->ShadowPitch;
84	}	96	}

Return to bug 38549

Lines 3-11 Link Here

(-)xc/programs/Xserver/hw/xfree86/drivers/newport-old/Imakefile (-2 / +3 lines)
3	#define IHaveModules	3	#define IHaveModules
4	#include <Server.tmpl>	4	#include <Server.tmpl>
5		5
6	SRCS = newport_driver.c newport_regs.c newport_cmap.c newport_shadow.c newport_cursor.c	6	SRCS = newport_driver.c newport_regs.c newport_cmap.c newport_shadow.c newport_cursor.c newport_accel.c
7		7
8	OBJS = newport_driver.o newport_regs.o newport_cmap.o newport_shadow.o newport_cursor.o	8	OBJS = newport_driver.o newport_regs.o newport_cmap.o newport_shadow.o newport_cursor.o newport_accel.o
9		9
10	XF86CONFIG = XF86Config.indy	10	XF86CONFIG = XF86Config.indy
11		11
Lines 46-51 Link Here
46	InstallDriverSDKNonExecFile(newport_cmap.c,$(DRIVERSDKDIR)/drivers/newport)	46	InstallDriverSDKNonExecFile(newport_cmap.c,$(DRIVERSDKDIR)/drivers/newport)
47	InstallDriverSDKNonExecFile(newport_shadow.c,$(DRIVERSDKDIR)/drivers/newport)	47	InstallDriverSDKNonExecFile(newport_shadow.c,$(DRIVERSDKDIR)/drivers/newport)
48	InstallDriverSDKNonExecFile(newport_cursor.c,$(DRIVERSDKDIR)/drivers/newport)	48	InstallDriverSDKNonExecFile(newport_cursor.c,$(DRIVERSDKDIR)/drivers/newport)
		49	InstallDriverSDKNonExecFile(newport_accel.c,$(DRIVERSDKDIR)/drivers/newport)
49	InstallDriverSDKNonExecFile(newport_regs.h,$(DRIVERSDKDIR)/drivers/newport)	50	InstallDriverSDKNonExecFile(newport_regs.h,$(DRIVERSDKDIR)/drivers/newport)
50	InstallDriverSDKNonExecFile(newport.h,$(DRIVERSDKDIR)/drivers/newport)	51	InstallDriverSDKNonExecFile(newport.h,$(DRIVERSDKDIR)/drivers/newport)
51		52

Lines 8-20 Link Here

(-)xc/programs/Xserver/hw/xfree86/drivers/newport-old/newport_regs.h (-40 / +34 lines)
8		8
9	typedef volatile unsigned long npireg_t;	9	typedef volatile unsigned long npireg_t;
10		10
11	union npfloat {
12	volatile float f;
13	npireg_t i;
14	};
15
16	typedef union npfloat npfreg_t;
17
18	union np_dcb {	11	union np_dcb {
19	npireg_t all;	12	npireg_t all;
20	struct { volatile unsigned short s0, s1; } hwords;	13	struct { volatile unsigned short s0, s1; } hwords;
Lines 150-193 Link Here
150	unsigned long _pad1[0x30];	143	unsigned long _pad1[0x30];
151		144
152	/* Iterators, full state for context switch */	145	/* Iterators, full state for context switch */
153	npfreg_t _xstart; /* X-start point (current) */	146	npireg_t _xstart; /* X-start point (current) */
154	npfreg_t _ystart; /* Y-start point (current) */	147	npireg_t _ystart; /* Y-start point (current) */
155	npfreg_t _xend; /* x-end point */	148	npireg_t _xend; /* x-end point */
156	npfreg_t _yend; /* y-end point */	149	npireg_t _yend; /* y-end point */
157	npireg_t xsave; /* copy of xstart integer value for BLOCk addressing MODE */	150	npireg_t xsave; /* copy of xstart integer value for BLOCk addressing MODE */
158	npireg_t xymove; /* x.y offset from xstart, ystart for relative operations */	151	npireg_t xymove; /* x.y offset from xstart, ystart for relative operations */
159	npfreg_t bresd;	152	npireg_t bresd;
160	npfreg_t bress1;	153	npireg_t bress1;
161	npireg_t bresoctinc1;	154	npireg_t bresoctinc1;
162	volatile int bresrndinc2;	155	npireg_t bresrndinc2;
163	npireg_t brese1;	156	npireg_t brese1;
164	npireg_t bress2;	157	npireg_t bress2;
165	npireg_t aweight0;	158	npireg_t aweight0;
166	npireg_t aweight1;	159	npireg_t aweight1;
167	npfreg_t xstartf;	160	npireg_t xstartf;
168	npfreg_t ystartf;	161	npireg_t ystartf;
169	npfreg_t xendf;	162	npireg_t xendf;
170	npfreg_t yendf;	163	npireg_t yendf;
171	npireg_t xstarti;	164	npireg_t xstarti;
172	npfreg_t xendf1;	165	npireg_t xendf1;
173	npireg_t xystarti;	166	npireg_t xystarti;
174	npireg_t xyendi;	167	npireg_t xyendi;
175	npireg_t xstartendi;	168	npireg_t xstartendi;
176		169
177	unsigned long _unused2[0x29];	170	unsigned long _unused2[0x29];
178		171
179	npfreg_t colorred;	172	npireg_t colorred;
180	npfreg_t coloralpha;	173	npireg_t coloralpha;
181	npfreg_t colorgrn;	174	npireg_t colorgrn;
182	npfreg_t colorblue;	175	npireg_t colorblue;
183	npfreg_t slopered;	176	npireg_t slopered;
184	npfreg_t slopealpha;	177	npireg_t slopealpha;
185	npfreg_t slopegrn;	178	npireg_t slopegrn;
186	npfreg_t slopeblue;	179	npireg_t slopeblue;
187	npireg_t wrmask;	180	npireg_t wrmask;
188	npireg_t colori;	181	npireg_t colori;
189	npfreg_t colorx;	182	npireg_t colorx;
190	npfreg_t slopered1;	183	npireg_t slopered1;
191	npireg_t hostrw0;	184	npireg_t hostrw0;
192	npireg_t hostrw1;	185	npireg_t hostrw1;
193	npireg_t dcbmode;	186	npireg_t dcbmode;
Lines 247-267 Link Here
247	#define NPORT_CMODE_CMSK 0x00001e00	240	#define NPORT_CMODE_CMSK 0x00001e00
248		241
249	unsigned long _unused0;	242	unsigned long _unused0;
250	unsigned long config;	243	npireg_t config;
251	#define NPORT_CFG_G32MD 0x00000001	244	#define NPORT_CFG_G32MD 0x00000001
252	#define NPORT_CFG_BWIDTH 0x00000002	245	#define NPORT_CFG_BWIDTH 0x00000002
253	#define NPORT_CFG_ERCVR 0x00000004	246	#define NPORT_CFG_ERCVR 0x00000004
254	#define NPORT_CFG_BDMSK 0x00000078	247	#define NPORT_CFG_BDMSK 0x00000078
255	#define NPORT_CFG_GDMSK 0x00000f80	248	#define NPORT_CFG_BFAINT 0x00000080
256	#define NPORT_CFG_GD0 0x00000080	249	#define NPORT_CFG_GDMSK 0x00001f00
257	#define NPORT_CFG_GD1 0x00000100	250	#define NPORT_CFG_GD0 0x00000100
258	#define NPORT_CFG_GD2 0x00000200	251	#define NPORT_CFG_GD1 0x00000200
259	#define NPORT_CFG_GD3 0x00000400	252	#define NPORT_CFG_GD2 0x00000400
260	#define NPORT_CFG_GD4 0x00000800	253	#define NPORT_CFG_GD3 0x00000800
261	#define NPORT_CFG_GFAINT 0x00001000	254	#define NPORT_CFG_GD4 0x00001000
262	#define NPORT_CFG_TOMSK 0x0000e000	255	#define NPORT_CFG_GFAINT 0x00002000
263	#define NPORT_CFG_VRMSK 0x00070000	256	#define NPORT_CFG_TOMSK 0x0001C000
264	#define NPORT_CFG_FBTYP 0x00080000	257	#define NPORT_CFG_VRMSK 0x000E0000
		258	#define NPORT_CFG_FBTYP 0x00100000
265		259
266	npireg_t _unused1;	260	npireg_t _unused1;
267	npireg_t stat;	261	npireg_t stat;