Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/xorg-old/patches-6.8.2-r10/5200_all_6.8.0-newport-accel-v4.patch

    Annotation of /trunk/xorg-old/patches-6.8.2-r10/5200_all_6.8.0-newport-accel-v4.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 167 - (hide annotations) (download)
    Tue May 8 20:58:51 2007 UTC (17 years, 1 month ago) by niro
    File size: 66330 byte(s) 
    -import
    1 niro 167 diff -Nur xc.orig/programs/Xserver/hw/xfree86/drivers/newport/Imakefile xc/programs/Xserver/hw/xfree86/drivers/newport/Imakefile
    2     --- xc.orig/programs/Xserver/hw/xfree86/drivers/newport/Imakefile 2004-11-11 08:52:59.559743184 -0500
    3     +++ xc/programs/Xserver/hw/xfree86/drivers/newport/Imakefile 2004-11-11 08:52:32.848803864 -0500
    4     @@ -3,9 +3,9 @@
    5     #define IHaveModules
    6     #include <Server.tmpl>
    7    
    8     -SRCS = newport_driver.c newport_regs.c newport_cmap.c newport_shadow.c newport_cursor.c
    9     +SRCS = newport_driver.c newport_regs.c newport_cmap.c newport_shadow.c newport_cursor.c newport_accel.c
    10    
    11     -OBJS = newport_driver.o newport_regs.o newport_cmap.o newport_shadow.o newport_cursor.o
    12     +OBJS = newport_driver.o newport_regs.o newport_cmap.o newport_shadow.o newport_cursor.o newport_accel.o
    13    
    14     XF86CONFIG = XF86Config.indy
    15    
    16     @@ -46,6 +46,7 @@
    17     InstallDriverSDKNonExecFile(newport_cmap.c,$(DRIVERSDKDIR)/drivers/newport)
    18     InstallDriverSDKNonExecFile(newport_shadow.c,$(DRIVERSDKDIR)/drivers/newport)
    19     InstallDriverSDKNonExecFile(newport_cursor.c,$(DRIVERSDKDIR)/drivers/newport)
    20     +InstallDriverSDKNonExecFile(newport_accel.c,$(DRIVERSDKDIR)/drivers/newport)
    21     InstallDriverSDKNonExecFile(newport_regs.h,$(DRIVERSDKDIR)/drivers/newport)
    22     InstallDriverSDKNonExecFile(newport.h,$(DRIVERSDKDIR)/drivers/newport)
    23    
    24     diff -Nur xc.orig/programs/Xserver/hw/xfree86/drivers/newport/newport.h xc/programs/Xserver/hw/xfree86/drivers/newport/newport.h
    25     --- xc.orig/programs/Xserver/hw/xfree86/drivers/newport/newport.h 2004-11-11 08:52:59.561742880 -0500
    26     +++ xc/programs/Xserver/hw/xfree86/drivers/newport/newport.h 2004-11-11 08:52:32.849803712 -0500
    27     @@ -6,6 +6,17 @@
    28     #ifndef __NEWPORT_H__
    29     #define __NEWPORT_H__
    30    
    31     +/* use 32bpp shadow framebuffer surface instead of 24bpp */
    32     +#define NEWPORT_USE32BPP
    33     +/* enable accel patch */
    34     +#define NEWPORT_ACCEL
    35     +
    36     +#ifdef NEWPORT_ACCEL
    37     +#ifndef NEWPORT_USE32BPP
    38     +#define NEWPORT_USE32BPP
    39     +#endif
    40     +#endif
    41     +
    42     /*
    43     * All drivers should include these:
    44     */
    45     @@ -19,6 +30,7 @@
    46    
    47     /* xaa & hardware cursor */
    48     #include "xaa.h"
    49     +#include "xaalocal.h"
    50     #include "xf86Cursor.h"
    51    
    52     /* register definitions of the Newport card */
    53     @@ -45,6 +57,7 @@
    54     typedef struct {
    55     unsigned busID;
    56     int bitplanes;
    57     + Bool NoAccel;
    58     /* revision numbers of the various pieces of silicon */
    59     unsigned int board_rev, cmap_rev, rex3_rev, xmap9_rev, bt445_rev;
    60     /* shadow copies of frequently used registers */
    61     @@ -88,6 +101,43 @@
    62    
    63     LOCO txt_colormap[256];
    64    
    65     + /* XAA stuff */
    66     + XAAInfoRecPtr pXAAInfoRec;
    67     + /* writing to these regs causes pipeline stall
    68     + so be smart and check the shadow before writing it */
    69     + unsigned int shadow_drawmode1;
    70     + unsigned int shadow_colorvram;
    71     + unsigned int shadow_colorback;
    72     + unsigned int shadow_xymove;
    73     + unsigned int shadow_wrmask;
    74     + unsigned int shadow_clipmode;
    75     + unsigned int fifoleft; /* number of slots left in fifo */
    76     +
    77     + unsigned int shadow_drawmode0;
    78     + unsigned int shadow_colori;
    79     + unsigned int shadow_smask0x;
    80     + unsigned int shadow_smask0y;
    81     +
    82     + unsigned int setup_drawmode0;
    83     + unsigned int setup_drawmode1;
    84     + unsigned char dashline_pat[2048/8];
    85     + unsigned int dashline_patlen;
    86     +
    87     + int clipsx, clipex, clipsy, clipey;
    88     + int skipleft;
    89     +
    90     + unsigned int pat8x8[8][8];
    91     +
    92     + unsigned int (*Color2Planes)(unsigned int color);
    93     +
    94     +#ifdef RENDER
    95     + unsigned int uTextureWidth;
    96     + unsigned int uTextureHeight;
    97     + unsigned int uTextureSize;
    98     + unsigned int *pTexture;
    99     + unsigned int uTextureFlags;
    100     +#endif
    101     +
    102     OptionInfoPtr Options;
    103     } NewportRec, *NewportPtr;
    104    
    105     diff -Nur xc.orig/programs/Xserver/hw/xfree86/drivers/newport/newport_accel.c xc/programs/Xserver/hw/xfree86/drivers/newport/newport_accel.c
    106     --- xc.orig/programs/Xserver/hw/xfree86/drivers/newport/newport_accel.c 1969-12-31 19:00:00.000000000 -0500
    107     +++ xc/programs/Xserver/hw/xfree86/drivers/newport/newport_accel.c 2004-11-11 08:52:32.849803712 -0500
    108     @@ -0,0 +1,1842 @@
    109     +/*
    110     + * Accelerated Driver for the SGI Indy's Newport graphics card
    111     + *
    112     + * (c) 2004 Dominik Behr <dominikbehr@yahoo.com>
    113     + * this code is released under xfree 4.3.0 and xorg 6.8.0 license
    114     + *
    115     + */
    116     +
    117     +#include "newport.h"
    118     +
    119     +#ifdef NEWPORT_ACCEL
    120     +
    121     +#include "mi.h"
    122     +#include "mizerarc.h"
    123     +
    124     +#define BARF(a) xf86DrvMsg(0, X_INFO, (a))
    125     +#define BARF1(a,b) xf86DrvMsg(0, X_INFO, (a), (b))
    126     +#define BARF2(a,b,c) xf86DrvMsg(0, X_INFO, (a), (b), (c))
    127     +#define BARF3(a,b,c,d) xf86DrvMsg(0, X_INFO, (a), (b), (c), (d))
    128     +#define BARF4(a,b,c,d,e) xf86DrvMsg(0, X_INFO, (a), (b), (c), (d), (e))
    129     +#define BARF5(a,b,c,d,e,f) xf86DrvMsg(0, X_INFO, (a), (b), (c), (d), (e), (f))
    130     +#define BARF6(a,b,c,d,e,f,g) xf86DrvMsg(0, X_INFO, (a), (b), (c), (d), (e), (f), (g))
    131     +
    132     +/* XAA Functions */
    133     +
    134     +#define NEWPORT_PREROTATE
    135     +/*
    136     + there is a bug in XAA which causes it to reference NULL pointer to pattern cache when
    137     + using HARDWARE_PROGRAMMED_PATTERN only (try x11perf -strap1)
    138     + thus we have to also set HARDWARE_PROGRAMMED_ORIGIN and prerotate the pattern
    139     + in the setup function
    140     +*/
    141     +
    142     +#define NEWPORT_GFIFO_ENTRIES 30
    143     +/*
    144     + I dont know how many entries are in the gfx FIFO, judging by 6 bits in the GFIFO
    145     + level status register it can be at most 63. it must be at least 32 because
    146     + otherwise they would use less bits for status
    147     +
    148     + for now 16 seems to be safe value
    149     +*/
    150     +#define NEWPORT_DELAY 128
    151     +
    152     +/*******************************************************************************
    153     +
    154     +*******************************************************************************/
    155     +static void
    156     +NewportWaitIdle(NewportPtr pNewport, unsigned int uEntries)
    157     +{
    158     + NewportRegsPtr pNewportRegs;
    159     + pNewportRegs = pNewport->pNewportRegs;
    160     + /* wait for the GFIFO to drain */
    161     + while ((pNewportRegs->cset.stat & NPORT_STAT_GLMSK))
    162     + {
    163     + int i;
    164     + volatile int x;
    165     + for (x = 0, i = 0; i < NEWPORT_DELAY; i++)
    166     + {
    167     + x += i;
    168     + }
    169     + }
    170     + /* and then wait for the graphic to be idle */
    171     + while (pNewportRegs->cset.stat & NPORT_STAT_GBUSY)
    172     + {
    173     + int i;
    174     + volatile int x;
    175     + for (x = 0, i = 0; i < NEWPORT_DELAY; i++)
    176     + {
    177     + x += i;
    178     + }
    179     + }
    180     + pNewport->fifoleft = NEWPORT_GFIFO_ENTRIES-uEntries;
    181     +}
    182     +
    183     +
    184     +#if 0
    185     +/*******************************************************************************
    186     +
    187     +*******************************************************************************/
    188     +static void
    189     +NewportWaitGFIFO(NewportPtr pNewport, unsigned int uEntries)
    190     +{
    191     + unsigned int uWaitLevel;
    192     +
    193     +/* NewportWaitIdle(pNewport, NEWPORT_GFIFO_ENTRIES);
    194     + return;*/
    195     +
    196     + if (uEntries >= NEWPORT_GFIFO_ENTRIES)
    197     + {
    198     + uWaitLevel = 0;
    199     + }
    200     + else
    201     + {
    202     + uWaitLevel = NEWPORT_GFIFO_ENTRIES-uEntries;
    203     + }
    204     + /* HACK */
    205     + /*uWaitLevel = 0;*/
    206     + while (((pNewport->pNewportRegs->cset.stat & NPORT_STAT_GLMSK) >> 7) > uWaitLevel)
    207     + {
    208     + int i;
    209     + volatile int x;
    210     + for (x = 0, i = 0; i < NEWPORT_DELAY; i++)
    211     + {
    212     + x += i;
    213     + }
    214     + }
    215     +}
    216     +#endif
    217     +#if 1
    218     +/*******************************************************************************
    219     +
    220     +*******************************************************************************/
    221     +static void
    222     +NewportWaitGFIFO(NewportPtr pNewport, unsigned int uEntries)
    223     +{
    224     + if (uEntries > NEWPORT_GFIFO_ENTRIES)
    225     + {
    226     + uEntries = NEWPORT_GFIFO_ENTRIES;
    227     + }
    228     +
    229     + if (uEntries <= pNewport->fifoleft)
    230     + {
    231     + pNewport->fifoleft -= uEntries;
    232     + return;
    233     + }
    234     +
    235     + while (1)
    236     + {
    237     + unsigned int fifolevel;
    238     + int i;
    239     + volatile int x;
    240     +
    241     + fifolevel = (pNewport->pNewportRegs->cset.stat & NPORT_STAT_GLMSK) >> 7;
    242     + if (fifolevel < NEWPORT_GFIFO_ENTRIES)
    243     + {
    244     + pNewport->fifoleft = NEWPORT_GFIFO_ENTRIES - fifolevel;
    245     + }
    246     + else
    247     + {
    248     + pNewport->fifoleft = 0;
    249     + }
    250     + if (uEntries <= pNewport->fifoleft)
    251     + {
    252     + pNewport->fifoleft -= uEntries;
    253     + return;
    254     + }
    255     +
    256     + for (x = 0, i = 0; i < NEWPORT_DELAY; i++)
    257     + {
    258     + x += i;
    259     + }
    260     + }
    261     +}
    262     +#endif
    263     +
    264     +
    265     +/*******************************************************************************
    266     +
    267     +*******************************************************************************/
    268     +static void
    269     +NewportXAASync(ScrnInfoPtr pScrn)
    270     +{
    271     + NewportPtr pNewport;
    272     + pNewport = NEWPORTPTR(pScrn);
    273     +
    274     + NewportWaitIdle(pNewport, 0);
    275     +}
    276     +
    277     +
    278     +/*******************************************************************************
    279     +
    280     +*******************************************************************************/
    281     +static unsigned int
    282     +Rop2LogicOp(int rop)
    283     +{
    284     + return (unsigned int)rop << 28;
    285     +}
    286     +
    287     +/*******************************************************************************
    288     +
    289     +*******************************************************************************/
    290     +static void
    291     +NewportUpdateClipping(NewportPtr pNewport)
    292     +{
    293     + unsigned int smask0x, smask0y;
    294     +
    295     + if (pNewport->skipleft > pNewport->clipsx)
    296     + {
    297     + smask0x = ((pNewport->skipleft & 0xFFFF) << 16) | (pNewport->clipex & 0xFFFF);
    298     + }
    299     + else
    300     + {
    301     + smask0x = ((pNewport->clipsx & 0xFFFF) << 16) | (pNewport->clipex & 0xFFFF);
    302     + }
    303     +
    304     + if (smask0x != pNewport->shadow_smask0x)
    305     + {
    306     + NewportWaitGFIFO(pNewport, 1);
    307     + pNewport->shadow_smask0x = smask0x;
    308     + pNewport->pNewportRegs->set.smask0x = smask0x;
    309     + }
    310     +
    311     + smask0y = ((pNewport->clipsy & 0xFFFF) << 16) | (pNewport->clipey & 0xFFFF);
    312     + if (smask0y != pNewport->shadow_smask0y)
    313     + {
    314     + NewportWaitGFIFO(pNewport, 1);
    315     + pNewport->shadow_smask0y = smask0y;
    316     + pNewport->pNewportRegs->set.smask0y = smask0y;
    317     + }
    318     +}
    319     +
    320     +/*******************************************************************************
    321     +
    322     +*******************************************************************************/
    323     +static unsigned int
    324     +NewportColor2HOSTRW(unsigned int color)
    325     +{
    326     + /*
    327     + default XAA color is 0,R,G,B
    328     + */
    329     +#if 0
    330     + return ((color & 0x0000FF) << 16)
    331     + | ((color & 0xFF0000) >> 16)
    332     + | ((color & 0x00FF00))
    333     + ;
    334     +#endif
    335     +/* but we changed masks to match the native format */
    336     + return color;
    337     +}
    338     +
    339     +/*******************************************************************************
    340     +
    341     +*******************************************************************************/
    342     +static unsigned int
    343     +NewportColor2Planes24(unsigned int color)
    344     +{
    345     + unsigned int res;
    346     + unsigned int i;
    347     + unsigned int mr, mg, mb;
    348     + unsigned int sr, sg, sb;
    349     +
    350     + /*
    351     + XAA color is 0,R,G,B
    352     + */
    353     +
    354     + res = 0;
    355     +#if 0
    356     + mr = 0x800000;
    357     + mg = 0x008000;
    358     + mb = 0x000080;
    359     +#endif
    360     + mr = 0x000080;
    361     + mg = 0x008000;
    362     + mb = 0x800000;
    363     + sr = 2;
    364     + sg = 1;
    365     + sb = 4;
    366     +
    367     + for (i = 0; i < 8; i++)
    368     + {
    369     + res |= (color & mr)?sr:0;
    370     + res |= (color & mg)?sg:0;
    371     + res |= (color & mb)?sb:0;
    372     +
    373     + sr <<= 3;
    374     + sg <<= 3;
    375     + sb <<= 3;
    376     + mr >>= 1;
    377     + mg >>= 1;
    378     + mb >>= 1;
    379     + }
    380     +
    381     + return res;
    382     +}
    383     +
    384     +/*******************************************************************************
    385     +
    386     +*******************************************************************************/
    387     +static unsigned int
    388     +NewportColor2Planes8(unsigned int color)
    389     +{
    390     + return color;
    391     +}
    392     +
    393     +/*******************************************************************************
    394     +
    395     +*******************************************************************************/
    396     +static void
    397     +NewportUpdateCOLORI(NewportPtr pNewport, unsigned long colori)
    398     +{
    399     + if (colori != pNewport->shadow_colori)
    400     + {
    401     + NewportWaitGFIFO(pNewport, 1);
    402     + pNewport->shadow_colori = colori;
    403     + pNewport->pNewportRegs->set.colori = colori;
    404     + }
    405     +}
    406     +
    407     +
    408     +/*******************************************************************************
    409     +
    410     +*******************************************************************************/
    411     +static void
    412     +NewportUpdateDRAWMODE0(NewportPtr pNewport, unsigned long drawmode0)
    413     +{
    414     + if (drawmode0 != pNewport->shadow_drawmode0)
    415     + {
    416     + NewportWaitGFIFO(pNewport, 1);
    417     + pNewport->shadow_drawmode0 = drawmode0;
    418     + pNewport->pNewportRegs->set.drawmode0 = drawmode0;
    419     + }
    420     +}
    421     +
    422     +
    423     +/*******************************************************************************
    424     +
    425     +*******************************************************************************/
    426     +static void
    427     +NewportUpdateDRAWMODE1(NewportPtr pNewport, unsigned long drawmode1)
    428     +{
    429     + if (drawmode1 != pNewport->shadow_drawmode1)
    430     + {
    431     + NewportWaitIdle(pNewport, 1);
    432     + pNewport->shadow_drawmode1 = drawmode1;
    433     + pNewport->pNewportRegs->set.drawmode1 = drawmode1;
    434     + }
    435     +}
    436     +
    437     +/*******************************************************************************
    438     +
    439     +*******************************************************************************/
    440     +static void
    441     +NewportUpdateCOLORVRAM(NewportPtr pNewport, unsigned long colorvram)
    442     +{
    443     + if (colorvram != pNewport->shadow_colorvram)
    444     + {
    445     + NewportWaitIdle(pNewport, 1);
    446     + pNewport->shadow_colorvram = colorvram;
    447     + pNewport->pNewportRegs->set.colorvram = colorvram;
    448     + }
    449     +}
    450     +
    451     +/*******************************************************************************
    452     +
    453     +*******************************************************************************/
    454     +static void
    455     +NewportUpdateCOLORBACK(NewportPtr pNewport, unsigned long colorback)
    456     +{
    457     + if (colorback != pNewport->shadow_colorback)
    458     + {
    459     + NewportWaitIdle(pNewport, 1);
    460     + pNewport->shadow_colorback = colorback;
    461     + pNewport->pNewportRegs->set.colorback = colorback;
    462     + }
    463     +}
    464     +
    465     +/*******************************************************************************
    466     +
    467     +*******************************************************************************/
    468     +static void
    469     +NewportUpdateWRMASK(NewportPtr pNewport, unsigned long wrmask)
    470     +{
    471     + if (wrmask != pNewport->shadow_wrmask)
    472     + {
    473     + NewportWaitIdle(pNewport, 1);
    474     + pNewport->shadow_wrmask = wrmask;
    475     + pNewport->pNewportRegs->set.wrmask = wrmask;
    476     + }
    477     +}
    478     +
    479     +/*******************************************************************************
    480     +
    481     +*******************************************************************************/
    482     +static void
    483     +NewportUpdateXYMOVE(NewportPtr pNewport, unsigned long xymove)
    484     +{
    485     + if (xymove != pNewport->shadow_xymove)
    486     + {
    487     + NewportWaitIdle(pNewport, 1);
    488     + pNewport->shadow_xymove = xymove;
    489     + pNewport->pNewportRegs->set.xymove = xymove;
    490     + }
    491     +}
    492     +
    493     +
    494     +/*******************************************************************************
    495     +
    496     +*******************************************************************************/
    497     +static void
    498     +NewportXAASetupForScreenToScreenCopy(ScrnInfoPtr pScrn,
    499     + int xdir,
    500     + int ydir,
    501     + int rop,
    502     + unsigned int planemask,
    503     + int trans_color)
    504     +{
    505     + NewportRegsPtr pNewportRegs;
    506     + NewportPtr pNewport;
    507     + pNewport = NEWPORTPTR(pScrn);
    508     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    509     +
    510     + NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
    511     + NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(planemask));
    512     + pNewport->skipleft = 0;
    513     + NewportUpdateClipping(pNewport);
    514     + NewportUpdateDRAWMODE0(pNewport,
    515     + 0
    516     + | NPORT_DMODE0_S2S
    517     + | NPORT_DMODE0_BLOCK
    518     + | NPORT_DMODE0_DOSETUP
    519     + | NPORT_DMODE0_STOPX
    520     + | NPORT_DMODE0_STOPY
    521     + );
    522     +
    523     +
    524     +}
    525     +
    526     +/*******************************************************************************
    527     +
    528     +*******************************************************************************/
    529     +static void
    530     +NewportXAASubsequentScreenToScreenCopy(ScrnInfoPtr pScrn,
    531     + int x1, int y1,
    532     + int x2, int y2,
    533     + int width, int height)
    534     +{
    535     + int dx, dy;
    536     + unsigned int sx, sy, ex, ey;
    537     + NewportRegsPtr pNewportRegs;
    538     + NewportPtr pNewport;
    539     + pNewport = NEWPORTPTR(pScrn);
    540     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    541     +
    542     + dx = x2 - x1;
    543     + dy = y2 - y1;
    544     + if (!dx && !dy)
    545     + return;
    546     +
    547     + if (width)
    548     + x2 = x1 + width - 1;
    549     + else
    550     + x2 = x1;
    551     +
    552     + if (height)
    553     + y2 = y1 + height - 1;
    554     + else
    555     + y2 = y1;
    556     +
    557     + if (dx < 0)
    558     + {
    559     + sx = x1 & 0xFFFF;
    560     + ex = x2 & 0xFFFF;
    561     + }
    562     + else
    563     + {
    564     + sx = x2 & 0xFFFF;
    565     + ex = x1 & 0xFFFF;
    566     + }
    567     +
    568     + if (dy < 0)
    569     + {
    570     + sy = y1 & 0xFFFF;
    571     + ey = y2 & 0xFFFF;
    572     + }
    573     + else
    574     + {
    575     + sy = y2 & 0xFFFF;
    576     + ey = y1 & 0xFFFF;
    577     + }
    578     +
    579     + dx &= 0xFFFF;
    580     + dy &= 0xFFFF;
    581     +
    582     + NewportUpdateXYMOVE(pNewport, (dx << 16) | dy); /* this is bad because it stalls the pipeline but nothing can be done about it */
    583     + NewportWaitGFIFO(pNewport, 2);
    584     + pNewportRegs->set.xystarti = (sx << 16) | sy;
    585     + pNewportRegs->go.xyendi = (ex << 16) | ey;
    586     +}
    587     +
    588     +/*******************************************************************************
    589     +
    590     +*******************************************************************************/
    591     +static void
    592     +NewportXAASetupForSolidFill(ScrnInfoPtr pScrn,
    593     + int Color,
    594     + int rop,
    595     + unsigned int planemask)
    596     +{
    597     + NewportRegsPtr pNewportRegs;
    598     + NewportPtr pNewport;
    599     + pNewport = NEWPORTPTR(pScrn);
    600     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    601     +
    602     + if (rop == GXcopy
    603     + || rop == GXclear
    604     + || rop == GXset)
    605     + {
    606     + /* if possible try to set up a fast clear which is 4x faster */
    607     + NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | NPORT_DMODE1_FCLR | Rop2LogicOp(GXcopy));
    608     + if (rop == GXclear)
    609     + NewportUpdateCOLORVRAM(pNewport, 0);
    610     + else
    611     + if (rop == GXset)
    612     + NewportUpdateCOLORVRAM(pNewport, 0xFFFFFF);
    613     + else
    614     + NewportUpdateCOLORVRAM(pNewport, pNewport->Color2Planes((unsigned int)Color));
    615     + }
    616     + else
    617     + {
    618     + NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
    619     + NewportUpdateCOLORI(pNewport, NewportColor2HOSTRW(Color));
    620     + }
    621     +
    622     + NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(planemask));
    623     + pNewport->skipleft = 0;
    624     + NewportUpdateClipping(pNewport);
    625     + NewportUpdateDRAWMODE0(pNewport,
    626     + 0
    627     + | NPORT_DMODE0_DRAW
    628     + | NPORT_DMODE0_BLOCK
    629     + | NPORT_DMODE0_DOSETUP
    630     + | NPORT_DMODE0_STOPX
    631     + | NPORT_DMODE0_STOPY
    632     + );
    633     +}
    634     +
    635     +/*******************************************************************************
    636     +
    637     +*******************************************************************************/
    638     +static void
    639     +NewportXAASubsequentSolidFillRect(ScrnInfoPtr pScrn,
    640     + int x,
    641     + int y,
    642     + int w,
    643     + int h)
    644     +{
    645     + int ex, ey;
    646     + NewportRegsPtr pNewportRegs;
    647     + NewportPtr pNewport;
    648     + pNewport = NEWPORTPTR(pScrn);
    649     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    650     +
    651     + if (w == 0) w = 1;
    652     + if (h == 0) h = 1;
    653     + ex = x + w - 1;
    654     + ey = y + h - 1;
    655     +
    656     + NewportWaitGFIFO(pNewport, 2);
    657     + pNewportRegs->set.xystarti = ((x & 0xFFFF) << 16) | (y & 0xFFFF);
    658     + pNewportRegs->go.xyendi = ((ex & 0xFFFF) << 16) | (ey & 0xFFFF);
    659     +}
    660     +
    661     +/*******************************************************************************
    662     +
    663     +*******************************************************************************/
    664     +static void
    665     +NewportXAASetupForSolidLine(ScrnInfoPtr pScrn,
    666     + int Color,
    667     + int rop,
    668     + unsigned int planemask)
    669     +{
    670     + NewportRegsPtr pNewportRegs;
    671     + NewportPtr pNewport;
    672     + pNewport = NEWPORTPTR(pScrn);
    673     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    674     +
    675     + NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
    676     + NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(planemask));
    677     + NewportUpdateCOLORI(pNewport, NewportColor2HOSTRW(Color));
    678     +
    679     + pNewport->skipleft = 0;
    680     + NewportUpdateClipping(pNewport);
    681     + pNewport->setup_drawmode0 = (0
    682     + | NPORT_DMODE0_DRAW
    683     + | NPORT_DMODE0_ILINE
    684     + | NPORT_DMODE0_DOSETUP
    685     + | NPORT_DMODE0_STOPX
    686     + | NPORT_DMODE0_STOPY
    687     + );
    688     +}
    689     +
    690     +/*******************************************************************************
    691     +
    692     +*******************************************************************************/
    693     +static void
    694     +NewportXAASubsequentSolidTwoPointLine(ScrnInfoPtr pScrn,
    695     + int x1,
    696     + int y1,
    697     + int x2,
    698     + int y2,
    699     + int flags)
    700     +{
    701     + NewportRegsPtr pNewportRegs;
    702     + NewportPtr pNewport;
    703     + pNewport = NEWPORTPTR(pScrn);
    704     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    705     +
    706     + NewportUpdateDRAWMODE0(pNewport,
    707     + pNewport->setup_drawmode0
    708     + | ((flags & OMIT_LAST) ? NPORT_DMODE0_SKLST : 0)
    709     + );
    710     + NewportWaitGFIFO(pNewport, 2);
    711     + pNewportRegs->set.xystarti = ((x1 & 0xFFFF) << 16) | (y1 & 0xFFFF);
    712     + pNewportRegs->go.xyendi = ((x2 & 0xFFFF) << 16) | (y2 & 0xFFFF);
    713     +}
    714     +
    715     +
    716     +/*******************************************************************************
    717     +
    718     +*******************************************************************************/
    719     +static void
    720     +NewportXAASetupForDashedLine(ScrnInfoPtr pScrn,
    721     + int fg,
    722     + int bg,
    723     + int rop,
    724     + unsigned int planemask,
    725     + int length,
    726     + unsigned char *pattern)
    727     +{
    728     + NewportRegsPtr pNewportRegs;
    729     + NewportPtr pNewport;
    730     + int i;
    731     +
    732     + pNewport = NEWPORTPTR(pScrn);
    733     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    734     +
    735     + pNewport->dashline_patlen = length;
    736     + for (i = 0; i < (length+7)>>3; i++)
    737     + pNewport->dashline_pat[i] = pattern[i];
    738     +
    739     + NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
    740     + NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(planemask));
    741     + if (bg != -1)
    742     + NewportUpdateCOLORBACK(pNewport, NewportColor2HOSTRW(bg));
    743     + NewportUpdateCOLORI(pNewport, NewportColor2HOSTRW(fg));
    744     + pNewport->skipleft = 0;
    745     + NewportUpdateClipping(pNewport);
    746     + pNewport->setup_drawmode0 = (0
    747     + | NPORT_DMODE0_DRAW
    748     + | NPORT_DMODE0_ILINE
    749     + | NPORT_DMODE0_DOSETUP
    750     + | NPORT_DMODE0_STOPX
    751     + | NPORT_DMODE0_STOPY
    752     + | NPORT_DMODE0_L32
    753     + | NPORT_DMODE0_ZPENAB
    754     + | ((bg == -1) ? 0 : NPORT_DMODE0_ZOPQ)
    755     + );
    756     +}
    757     +
    758     +/*******************************************************************************
    759     +
    760     +*******************************************************************************/
    761     +static void
    762     +NewportXAASubsequentDashedTwoPointLine(ScrnInfoPtr pScrn,
    763     + int x1,
    764     + int y1,
    765     + int x2,
    766     + int y2,
    767     + int flags,
    768     + int phase)
    769     +{
    770     + NewportRegsPtr pNewportRegs;
    771     + NewportPtr pNewport;
    772     + int dx, dy;
    773     + unsigned int linelen;
    774     + unsigned int dwords;
    775     +
    776     + pNewport = NEWPORTPTR(pScrn);
    777     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    778     +
    779     + dx = x2 - x1; if (dx < 0) dx = -dx; dx++;
    780     + dy = y2 - y1; if (dy < 0) dy = -dy; dy++;
    781     + if (dx > dy)
    782     + linelen = dx;
    783     + else
    784     + linelen = dy;
    785     + dwords = (linelen + 31) >> 5;
    786     +
    787     + NewportUpdateDRAWMODE0(pNewport,
    788     + pNewport->setup_drawmode0
    789     + | ((flags & OMIT_LAST) ? NPORT_DMODE0_SKLST : 0)
    790     + );
    791     +
    792     + NewportWaitGFIFO(pNewport, 3);
    793     + pNewportRegs->set.xystarti = ((x1 & 0xFFFF) << 16) | (y1 & 0xFFFF);
    794     + pNewportRegs->set.xyendi = ((x2 & 0xFFFF) << 16) | (y2 & 0xFFFF);
    795     + pNewportRegs->set._setup = 1;
    796     +
    797     + phase %= pNewport->dashline_patlen;
    798     + while (dwords--) {
    799     + unsigned int bit;
    800     + unsigned int pat;
    801     + unsigned int mask;
    802     + pat = 0;
    803     + mask = 0x80000000;
    804     + for (bit = 0; bit < 32; bit++)
    805     + {
    806     + if (pNewport->dashline_pat[phase >> 3] & (0x80 >> (phase & 7)))
    807     + pat |= mask;
    808     + phase = (phase + 1) % pNewport->dashline_patlen;
    809     + mask >>= 1;
    810     + }
    811     + NewportWaitGFIFO(pNewport, 1);
    812     + pNewportRegs->go.zpattern = pat;
    813     + }
    814     +
    815     +}
    816     +
    817     +/*******************************************************************************
    818     +
    819     +*******************************************************************************/
    820     +static void
    821     +NewportXAASetupForCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
    822     + int fg,
    823     + int bg,
    824     + int rop,
    825     + unsigned int planemask)
    826     +{
    827     + NewportRegsPtr pNewportRegs;
    828     + NewportPtr pNewport;
    829     + pNewport = NEWPORTPTR(pScrn);
    830     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    831     +
    832     + NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
    833     + NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(planemask));
    834     + if (bg != -1)
    835     + NewportUpdateCOLORBACK(pNewport, NewportColor2HOSTRW(bg));
    836     + NewportUpdateCOLORI(pNewport, NewportColor2HOSTRW(fg));
    837     + NewportUpdateDRAWMODE0(pNewport,
    838     + 0
    839     + | NPORT_DMODE0_DRAW
    840     + | NPORT_DMODE0_BLOCK
    841     + | NPORT_DMODE0_DOSETUP
    842     + | NPORT_DMODE0_STOPX
    843     + | NPORT_DMODE0_ZPENAB
    844     + | ((bg == -1) ? 0 : NPORT_DMODE0_ZOPQ)
    845     + | NPORT_DMODE0_L32
    846     + );
    847     +}
    848     +
    849     +/*******************************************************************************
    850     +
    851     +*******************************************************************************/
    852     +static void
    853     +NewportXAASubsequentCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
    854     + int x,
    855     + int y,
    856     + int w,
    857     + int h,
    858     + int skipleft)
    859     +{
    860     + int ex, ey;
    861     + NewportRegsPtr pNewportRegs;
    862     + NewportPtr pNewport;
    863     + pNewport = NEWPORTPTR(pScrn);
    864     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    865     +
    866     + if (w == 0) w = 1;
    867     + if (h == 0) h = 1;
    868     + ex = x + w - 1;
    869     + ey = y + h - 1;
    870     +
    871     + if (skipleft)
    872     + {
    873     + pNewport->skipleft = x + skipleft;
    874     + }
    875     + else
    876     + {
    877     + pNewport->skipleft = 0;
    878     + }
    879     + NewportUpdateClipping(pNewport);
    880     +
    881     + NewportWaitGFIFO(pNewport, 3);
    882     + pNewportRegs->set.xystarti = ((x & 0xFFFF) << 16) | (y & 0xFFFF);
    883     + pNewportRegs->set.xyendi = ((ex & 0xFFFF) << 16) | (ey & 0xFFFF);
    884     + pNewportRegs->set._setup = 1;
    885     +
    886     + /* after return XAA will start blasting the pattern to go.zpattern register */
    887     + /* we have to wait here for idle because if there is something in the pipeline that will take
    888     + long time to complete and if following cpu transfers will overflow the FIFO causing GIO bus
    889     + stall it will end up in bus error */
    890     + NewportWaitIdle(pNewport, NEWPORT_GFIFO_ENTRIES);
    891     +
    892     +}
    893     +
    894     +/*******************************************************************************
    895     +
    896     +*******************************************************************************/
    897     +static void
    898     +NewportXAASetupForImageWrite(ScrnInfoPtr pScrn,
    899     + int rop,
    900     + unsigned int planemask,
    901     + int trans_color,
    902     + int bpp,
    903     + int depth)
    904     +{
    905     + NewportRegsPtr pNewportRegs;
    906     + NewportPtr pNewport;
    907     + pNewport = NEWPORTPTR(pScrn);
    908     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    909     +
    910     + NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
    911     + NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(planemask));
    912     + NewportUpdateDRAWMODE0(pNewport,
    913     + 0
    914     + | NPORT_DMODE0_DRAW
    915     + | NPORT_DMODE0_BLOCK
    916     + | NPORT_DMODE0_CHOST
    917     + | NPORT_DMODE0_DOSETUP
    918     + );
    919     +
    920     +}
    921     +
    922     +/*******************************************************************************
    923     +
    924     +*******************************************************************************/
    925     +static void
    926     +NewportXAASubsequentImageWriteRect(ScrnInfoPtr pScrn,
    927     + int x,
    928     + int y,
    929     + int w,
    930     + int h,
    931     + int skipleft)
    932     +{
    933     + int ex, ey;
    934     + NewportRegsPtr pNewportRegs;
    935     + NewportPtr pNewport;
    936     + pNewport = NEWPORTPTR(pScrn);
    937     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    938     +
    939     + if (w == 0) w = 1;
    940     + if (h == 0) h = 1;
    941     +
    942     + ex = x + w - 1;
    943     + ey = y + h - 1;
    944     +
    945     + if (skipleft)
    946     + {
    947     + pNewport->skipleft = x + skipleft;
    948     + }
    949     + else
    950     + {
    951     + pNewport->skipleft = 0;
    952     + }
    953     + NewportUpdateClipping(pNewport);
    954     +
    955     + NewportWaitGFIFO(pNewport, 3);
    956     + pNewportRegs->set.xystarti = ((x & 0xFFFF) << 16) | (y & 0xFFFF);
    957     + pNewportRegs->set.xyendi = ((ex & 0xFFFF) << 16) | (ey & 0xFFFF);
    958     + pNewportRegs->set._setup = 1;
    959     +
    960     + /* after return XAA will start blasting the image to go.hostrw0 register */
    961     + /* we have to wait here for idle because if there is something in the pipeline that will take
    962     + long time to complete and if following cpu transfers will overflow the FIFO causing GIO bus
    963     + stall it will end up in bus error */
    964     + NewportWaitIdle(pNewport, NEWPORT_GFIFO_ENTRIES);
    965     +}
    966     +
    967     +static unsigned int
    968     +repbyte(unsigned int b)
    969     +{
    970     + b &= 0xFF;
    971     + return b | (b << 8) | (b << 16) | (b << 24);
    972     +}
    973     +
    974     +static void
    975     +prerotatebyte(unsigned int b, unsigned int *p)
    976     +{
    977     + int i;
    978     +
    979     + b &= 0xFF;
    980     +
    981     + for (i = 0; i < 8; i++)
    982     + {
    983     + p[i] = repbyte(b);
    984     + if (b & 1)
    985     + b = (b >> 1) | 0x80;
    986     + else
    987     + b = b >> 1;
    988     + }
    989     +}
    990     +
    991     +/*******************************************************************************
    992     +
    993     +*******************************************************************************/
    994     +static void
    995     +NewportXAASetupForMono8x8PatternFill(ScrnInfoPtr pScrn,
    996     + int patx,
    997     + int paty,
    998     + int fg,
    999     + int bg,
    1000     + int rop,
    1001     + unsigned int planemask)
    1002     +{
    1003     + NewportRegsPtr pNewportRegs;
    1004     + NewportPtr pNewport;
    1005     + pNewport = NEWPORTPTR(pScrn);
    1006     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    1007     +
    1008     +#ifdef NEWPORT_PREROTATE
    1009     + /* prerotate the pattern */
    1010     + prerotatebyte((unsigned int)patx >> 24, pNewport->pat8x8[0]);
    1011     + prerotatebyte((unsigned int)patx >> 16, pNewport->pat8x8[1]);
    1012     + prerotatebyte((unsigned int)patx >> 8, pNewport->pat8x8[2]);
    1013     + prerotatebyte((unsigned int)patx, pNewport->pat8x8[3]);
    1014     + prerotatebyte((unsigned int)paty >> 24, pNewport->pat8x8[4]);
    1015     + prerotatebyte((unsigned int)paty >> 16, pNewport->pat8x8[5]);
    1016     + prerotatebyte((unsigned int)paty >> 8, pNewport->pat8x8[6]);
    1017     + prerotatebyte((unsigned int)paty, pNewport->pat8x8[7]);
    1018     +#endif
    1019     + NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
    1020     + NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(planemask));
    1021     + if (bg != -1)
    1022     + NewportUpdateCOLORBACK(pNewport, NewportColor2HOSTRW(bg));
    1023     + NewportUpdateCOLORI(pNewport, NewportColor2HOSTRW(fg));
    1024     + pNewport->skipleft = 0;
    1025     + NewportUpdateClipping(pNewport);
    1026     + NewportUpdateDRAWMODE0(pNewport,
    1027     + 0
    1028     + | NPORT_DMODE0_DRAW
    1029     + | NPORT_DMODE0_BLOCK
    1030     + | NPORT_DMODE0_DOSETUP
    1031     + | NPORT_DMODE0_STOPX
    1032     + | NPORT_DMODE0_ZPENAB
    1033     + | ((bg == -1) ? 0 : NPORT_DMODE0_ZOPQ)
    1034     + | NPORT_DMODE0_L32
    1035     + );
    1036     +}
    1037     +
    1038     +
    1039     +
    1040     +/*******************************************************************************
    1041     +
    1042     +*******************************************************************************/
    1043     +static void
    1044     +NewportXAASubsequentMono8x8PatternFillRect(ScrnInfoPtr pScrn,
    1045     + int patx,
    1046     + int paty,
    1047     + int x,
    1048     + int y,
    1049     + int w,
    1050     + int h)
    1051     +{
    1052     + int ex, ey;
    1053     + unsigned int d;
    1054     +#ifndef NEWPORT_PREROTATE
    1055     + unsigned int p;
    1056     + unsigned int epat[8];
    1057     +#endif
    1058     +
    1059     + NewportRegsPtr pNewportRegs;
    1060     + NewportPtr pNewport;
    1061     + pNewport = NEWPORTPTR(pScrn);
    1062     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    1063     +
    1064     + if (w == 0) w = 1;
    1065     + if (h == 0) h = 1;
    1066     + ex = x + w - 1;
    1067     + ey = y + h - 1;
    1068     +
    1069     + NewportWaitGFIFO(pNewport, 3);
    1070     + pNewportRegs->set.xystarti = ((x & 0xFFFF) << 16) | (y & 0xFFFF);
    1071     + pNewportRegs->set.xyendi = ((ex & 0xFFFF) << 16) | (ey & 0xFFFF);
    1072     + pNewportRegs->set._setup = 1;
    1073     +
    1074     +#ifdef NEWPORT_PREROTATE
    1075     + patx &= 7;
    1076     + paty &= 7;
    1077     + while (h--)
    1078     + {
    1079     + for (d = (w + 31) >> 5; d; d--)
    1080     + {
    1081     + NewportWaitGFIFO(pNewport, 1);
    1082     + pNewportRegs->go.zpattern = pNewport->pat8x8[paty][patx];
    1083     + }
    1084     + paty = (paty + 1) & 7;
    1085     + }
    1086     +#else
    1087     + epat[0] = repbyte(patx >> 24);
    1088     + epat[1] = repbyte(patx >> 16);
    1089     + epat[2] = repbyte(patx >> 8);
    1090     + epat[3] = repbyte(patx);
    1091     + epat[4] = repbyte(paty >> 24);
    1092     + epat[5] = repbyte(paty >> 16);
    1093     + epat[6] = repbyte(paty >> 8);
    1094     + epat[7] = repbyte(paty);
    1095     +
    1096     + p = 0;
    1097     + while (h--)
    1098     + {
    1099     + for (d = (w + 31) >> 5; d; d--)
    1100     + {
    1101     + NewportWaitGFIFO(pNewport, 1);
    1102     + pNewportRegs->go.zpattern = epat[p];
    1103     + }
    1104     + p = (p + 1) ^ 7;
    1105     + }
    1106     +#endif
    1107     +}
    1108     +
    1109     +/*******************************************************************************
    1110     +
    1111     +*******************************************************************************/
    1112     +static void
    1113     +NewportXAAReadPixmap(ScrnInfoPtr pScrn,
    1114     + int x,
    1115     + int y,
    1116     + int w,
    1117     + int h,
    1118     + unsigned char *dst,
    1119     + int dstwidth,
    1120     + int bpp,
    1121     + int depth)
    1122     +{
    1123     + int ex, ey;
    1124     + NewportRegsPtr pNewportRegs;
    1125     + NewportPtr pNewport;
    1126     + pNewport = NEWPORTPTR(pScrn);
    1127     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    1128     +
    1129     + if (w == 0) w = 1;
    1130     + if (h == 0) h = 1;
    1131     + ex = x + w - 1;
    1132     + ey = y + h - 1;
    1133     +
    1134     + NewportWaitIdle(pNewport, 0);
    1135     + NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(GXcopy) | NPORT_DMODE1_PFENAB);
    1136     + NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(0xFFFFFFFF));
    1137     + NewportUpdateDRAWMODE0(pNewport,
    1138     + 0
    1139     + | NPORT_DMODE0_RD
    1140     + | NPORT_DMODE0_BLOCK
    1141     + | NPORT_DMODE0_CHOST
    1142     + | NPORT_DMODE0_DOSETUP
    1143     + );
    1144     +
    1145     + NewportWaitGFIFO(pNewport, 3);
    1146     + pNewportRegs->set.xystarti = ((x & 0xFFFF) << 16) | (y & 0xFFFF);
    1147     + pNewportRegs->set.xyendi = ((ex & 0xFFFF) << 16) | (ey & 0xFFFF);
    1148     + /* with prefetch enabled go has to be issued before we start reading */
    1149     + pNewportRegs->go._setup = 1;
    1150     +
    1151     +
    1152     + if (pScrn->bitsPerPixel == 8)
    1153     + {
    1154     + unsigned int d;
    1155     + while (h--)
    1156     + {
    1157     + unsigned char *p;
    1158     + p = (unsigned char *)dst;
    1159     + for (x = 0; x < w; x += 4)
    1160     + {
    1161     + if (!h && x+4 >= w)
    1162     + { /* the last dword does not need go */
    1163     + d = pNewportRegs->set.hostrw0;
    1164     + }
    1165     + else
    1166     + {
    1167     + d = pNewportRegs->go.hostrw0;
    1168     + }
    1169     +
    1170     + *p++ = (d & 0xFF000000) >> 24;
    1171     + if (x+1 < w)
    1172     + {
    1173     + *p++ = (d & 0x00FF0000) >> 16;
    1174     + }
    1175     + if (x+2 < w)
    1176     + {
    1177     + *p++ = (d & 0x0000FF00) >> 8;
    1178     + }
    1179     + if (x+3 < w)
    1180     + {
    1181     + *p++ = d & 0x000000FF;
    1182     + }
    1183     + }
    1184     + dst += dstwidth;
    1185     + }
    1186     + }
    1187     + else
    1188     + {
    1189     + while (h--)
    1190     + {
    1191     + unsigned int *p;
    1192     + p = (unsigned int *)dst;
    1193     + for (x = 0; x < w; x++)
    1194     + {
    1195     + if (!h && x+1 == w)
    1196     + { /* the last dword does not need go */
    1197     + *p++ = pNewportRegs->set.hostrw0;
    1198     + }
    1199     + else
    1200     + {
    1201     + *p++ = pNewportRegs->go.hostrw0;
    1202     + }
    1203     + }
    1204     + dst += dstwidth;
    1205     + }
    1206     + }
    1207     +}
    1208     +
    1209     +/*******************************************************************************
    1210     +
    1211     +*******************************************************************************/
    1212     +static void
    1213     +NewportXAASetClippingRectangle(ScrnInfoPtr pScrn,
    1214     + int left,
    1215     + int top,
    1216     + int right,
    1217     + int bottom)
    1218     +{
    1219     + NewportPtr pNewport;
    1220     + pNewport = NEWPORTPTR(pScrn);
    1221     +
    1222     + if (left < 0) left = 0;
    1223     + if (right > pScrn->virtualX-1) right = pScrn->virtualX-1;
    1224     +
    1225     + if (top < 0) top = 0;
    1226     + if (bottom > pScrn->virtualY-1) bottom = pScrn->virtualY-1;
    1227     +
    1228     + pNewport->clipsx = left;
    1229     + pNewport->clipex = right;
    1230     + pNewport->clipsy = top;
    1231     + pNewport->clipey = bottom;
    1232     +
    1233     + NewportUpdateClipping(pNewport);
    1234     +}
    1235     +
    1236     +/*******************************************************************************
    1237     +
    1238     +*******************************************************************************/
    1239     +static void
    1240     +NewportXAADisableClipping(ScrnInfoPtr pScrn)
    1241     +{
    1242     + NewportPtr pNewport;
    1243     + pNewport = NEWPORTPTR(pScrn);
    1244     +
    1245     + pNewport->clipsx = 0;
    1246     + pNewport->clipex = pScrn->virtualX-1;
    1247     + pNewport->clipsy = 0;
    1248     + pNewport->clipey = pScrn->virtualY-1;
    1249     + NewportUpdateClipping(pNewport);
    1250     +}
    1251     +
    1252     +/*******************************************************************************
    1253     +
    1254     +*******************************************************************************/
    1255     +static void
    1256     +NewportPolyPoint(DrawablePtr pDraw,
    1257     + GCPtr pGC,
    1258     + int mode,
    1259     + int npt,
    1260     + xPoint *ppt)
    1261     +{
    1262     + ScrnInfoPtr pScrn;
    1263     + int numRects = REGION_NUM_RECTS(pGC->pCompositeClip);
    1264     + int rect;
    1265     + XAAInfoRecPtr infoRec;
    1266     + BoxPtr pbox;
    1267     + int x, y;
    1268     + int rop;
    1269     +
    1270     + NewportRegsPtr pNewportRegs;
    1271     + NewportPtr pNewport;
    1272     +
    1273     + infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
    1274     + pScrn = infoRec->pScrn;
    1275     +
    1276     + if (!numRects)
    1277     + return;
    1278     +
    1279     + pNewport = NEWPORTPTR(pScrn);
    1280     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    1281     +
    1282     + x = pDraw->x;
    1283     + y = pDraw->y;
    1284     +
    1285     + rop = pGC->alu;
    1286     +
    1287     + NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(pGC->planemask));
    1288     + if (rop == GXcopy
    1289     + || rop == GXclear
    1290     + || rop == GXset)
    1291     + {
    1292     + /* if possible try to set up a fast clear which is 4x faster */
    1293     + NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | NPORT_DMODE1_FCLR | Rop2LogicOp(GXcopy));
    1294     + if (rop == GXclear)
    1295     + NewportUpdateCOLORVRAM(pNewport, 0);
    1296     + else
    1297     + if (rop == GXset)
    1298     + NewportUpdateCOLORVRAM(pNewport, 0xFFFFFF);
    1299     + else
    1300     + NewportUpdateCOLORVRAM(pNewport, pNewport->Color2Planes((unsigned int)(pGC->fgPixel)));
    1301     + }
    1302     + else
    1303     + {
    1304     + NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(rop));
    1305     + NewportUpdateCOLORI(pNewport, NewportColor2HOSTRW(pGC->fgPixel));
    1306     + }
    1307     +
    1308     + pNewport->skipleft = 0;
    1309     + NewportUpdateClipping(pNewport);
    1310     + NewportUpdateDRAWMODE0(pNewport,
    1311     + 0
    1312     + | NPORT_DMODE0_DRAW
    1313     + | NPORT_DMODE0_BLOCK
    1314     + | NPORT_DMODE0_DOSETUP
    1315     + );
    1316     +
    1317     + pbox = REGION_RECTS(pGC->pCompositeClip);
    1318     +
    1319     + while (npt--) {
    1320     + if (mode == CoordModePrevious)
    1321     + {
    1322     + x += ppt->x;
    1323     + y += ppt->y;
    1324     + }
    1325     + else
    1326     + {
    1327     + x = pDraw->x + ppt->x;
    1328     + y = pDraw->y + ppt->y;
    1329     + }
    1330     + for (rect = 0; rect < numRects; rect++)
    1331     + if (x >= pbox[rect].x1 && x < pbox[rect].x2
    1332     + && y >= pbox[rect].y1 && y < pbox[rect].y2)
    1333     + { /* draw point */
    1334     + unsigned int xy;
    1335     + xy = ((x & 0xFFFF) << 16) | (y & 0xFFFF);
    1336     + NewportWaitGFIFO(pNewport, 2);
    1337     + pNewportRegs->set.xystarti = xy;
    1338     + pNewportRegs->go.xyendi = xy;
    1339     + break;
    1340     + }
    1341     + ppt++;
    1342     + }
    1343     +}
    1344     +
    1345     +/*******************************************************************************
    1346     +
    1347     +*******************************************************************************/
    1348     +static void
    1349     +NewportValidatePolyPoint(GCPtr pGC,
    1350     + unsigned long changes,
    1351     + DrawablePtr pDraw)
    1352     +{
    1353     +
    1354     + if (pDraw->type == DRAWABLE_WINDOW)
    1355     + {
    1356     + pGC->ops->PolyPoint = NewportPolyPoint;
    1357     + }
    1358     + else
    1359     + {
    1360     + pGC->ops->PolyPoint = XAAFallbackOps.PolyPoint;
    1361     + }
    1362     +}
    1363     +
    1364     +#if 1
    1365     +/*******************************************************************************
    1366     +
    1367     +*******************************************************************************/
    1368     +static void
    1369     +NewportPolyArc(DrawablePtr pDraw,
    1370     + GCPtr pGC,
    1371     + int narcs,
    1372     + xArc *parcs)
    1373     +{
    1374     + xArc *arc;
    1375     + BoxRec box;
    1376     + int i, x2, y2;
    1377     + RegionPtr cclip;
    1378     +
    1379     + cclip = pGC->pCompositeClip;
    1380     +
    1381     + if(!REGION_NUM_RECTS(cclip))
    1382     + return;
    1383     +
    1384     + for (arc = parcs, i = narcs; --i >= 0; arc++) {
    1385     + if (miCanZeroArc(arc)) {
    1386     + box.x1 = arc->x + pDraw->x;
    1387     + box.y1 = arc->y + pDraw->y;
    1388     + x2 = box.x1 + (int)arc->width + 1;
    1389     + box.x2 = x2;
    1390     + y2 = box.y1 + (int)arc->height + 1;
    1391     + box.y2 = y2;
    1392     + if ( (x2 <= MAXSHORT) && (y2 <= MAXSHORT) &&
    1393     + (RECT_IN_REGION(pDraw->pScreen, cclip, &box) == rgnIN) )
    1394     + miZeroPolyArc(pDraw, pGC, 1, arc);
    1395     + }
    1396     + else
    1397     + miPolyArc(pDraw, pGC, 1, arc);
    1398     + }
    1399     +}
    1400     +#endif
    1401     +
    1402     +/*******************************************************************************
    1403     +
    1404     +*******************************************************************************/
    1405     +static void
    1406     +NewportValidatePolyArc(GCPtr pGC,
    1407     + unsigned long changes,
    1408     + DrawablePtr pDraw)
    1409     +{
    1410     + if (pDraw->type == DRAWABLE_WINDOW)
    1411     + {
    1412     + pGC->ops->PolyPoint = NewportPolyPoint;
    1413     + /*pGC->ops->PolyArc = miPolyArc;*/
    1414     + pGC->ops->PolyArc = NewportPolyArc;
    1415     +
    1416     + }
    1417     + else
    1418     + {
    1419     + pGC->ops->PolyPoint = XAAFallbackOps.PolyPoint;
    1420     + pGC->ops->PolyArc = XAAFallbackOps.PolyArc;
    1421     + }
    1422     +}
    1423     +
    1424     +
    1425     +#ifdef RENDER
    1426     +/*******************************************************************************
    1427     +
    1428     +*******************************************************************************/
    1429     +static Bool
    1430     +NewportXAASetupForCPUToScreenAlphaTexture(
    1431     + ScrnInfoPtr pScrn,
    1432     + int op,
    1433     + CARD16 red,
    1434     + CARD16 green,
    1435     + CARD16 blue,
    1436     + CARD16 alpha,
    1437     + CARD32 maskFormat,
    1438     + CARD32 dstFormat,
    1439     + CARD8 *alphaPtr,
    1440     + int alphaPitch,
    1441     + int width,
    1442     + int height,
    1443     + int flags)
    1444     +{
    1445     + unsigned int col, a;
    1446     + unsigned char *pSrc;
    1447     + unsigned int *pDst;
    1448     + unsigned int w;
    1449     + NewportRegsPtr pNewportRegs;
    1450     + NewportPtr pNewport;
    1451     + pNewport = NEWPORTPTR(pScrn);
    1452     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    1453     +
    1454     + if (width * height * sizeof(unsigned int) > pNewport->uTextureSize)
    1455     + {
    1456     + free(pNewport->pTexture);
    1457     + pNewport->pTexture = xnfalloc(pNewport->uTextureSize = width * height * sizeof(unsigned int));
    1458     + }
    1459     + col = (((unsigned int)red & 0xFF00) << 8)
    1460     + | ((unsigned int)green & 0xFF00)
    1461     + | ((unsigned int)blue >> 8);
    1462     +
    1463     + pNewport->uTextureWidth = width;
    1464     + pNewport->uTextureHeight = height;
    1465     + pNewport->uTextureFlags = flags;
    1466     +
    1467     + /* copy texture */
    1468     + pDst = pNewport->pTexture;
    1469     + while (height--) {
    1470     + pSrc = (unsigned char *)alphaPtr;
    1471     +
    1472     + for (w = width; w; w--)
    1473     + {
    1474     + /* premultiply alpha */
    1475     + a = *pSrc++;
    1476     + a *= alpha;
    1477     + a /= 0xFFFF;
    1478     + a <<= 24;
    1479     + *pDst++ = col | a;
    1480     + }
    1481     + alphaPtr += alphaPitch;
    1482     + }
    1483     +#define SFACTOR (4 << 19)
    1484     +#define DFACTOR (5 << 22)
    1485     + NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(GXcopy) | NPORT_DMODE1_BENAB | SFACTOR | DFACTOR );
    1486     +#undef SFACTOR
    1487     +#undef DFACTOR
    1488     + NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(0xFFFFFFFF));
    1489     +
    1490     + pNewport->skipleft = 0;
    1491     + NewportUpdateClipping(pNewport);
    1492     + NewportUpdateDRAWMODE0(pNewport,
    1493     + 0
    1494     + | NPORT_DMODE0_DRAW
    1495     + | NPORT_DMODE0_BLOCK
    1496     + | NPORT_DMODE0_CHOST
    1497     + | NPORT_DMODE0_AHOST
    1498     + | NPORT_DMODE0_DOSETUP
    1499     + );
    1500     + return TRUE;
    1501     +}
    1502     +
    1503     +/*******************************************************************************
    1504     +
    1505     +*******************************************************************************/
    1506     +static Bool
    1507     +NewportXAASetupForCPUToScreenTexture(
    1508     + ScrnInfoPtr pScrn,
    1509     + int op,
    1510     + CARD32 srcFormat,
    1511     + CARD32 dstFormat,
    1512     + CARD8 *texPtr,
    1513     + int texPitch,
    1514     + int width,
    1515     + int height,
    1516     + int flags)
    1517     +{
    1518     + unsigned int *pSrc, *pDst;
    1519     + unsigned int w;
    1520     + NewportRegsPtr pNewportRegs;
    1521     + NewportPtr pNewport;
    1522     + pNewport = NEWPORTPTR(pScrn);
    1523     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    1524     +
    1525     + if (width * height * sizeof(unsigned int) > pNewport->uTextureSize)
    1526     + {
    1527     + free(pNewport->pTexture);
    1528     + pNewport->pTexture = xnfalloc(pNewport->uTextureSize = width * height * sizeof(unsigned int));
    1529     + }
    1530     +
    1531     + pNewport->uTextureWidth = width;
    1532     + pNewport->uTextureHeight = height;
    1533     + pNewport->uTextureFlags = flags;
    1534     +
    1535     + /* copy texture */
    1536     + pDst = pNewport->pTexture;
    1537     +
    1538     + if (srcFormat == PICT_a8r8g8b8)
    1539     + {
    1540     + while (height--) {
    1541     + pSrc = (unsigned int *)texPtr;
    1542     +
    1543     + for (w = width; w; w--)
    1544     + {
    1545     + unsigned int v;
    1546     + v = *pSrc++;
    1547     + *pDst++ = (v & 0xFF00FF00) | ((v & 0x00FF0000) >> 16) | ((v & 0x000000FF) << 16);
    1548     + }
    1549     + texPtr += texPitch;
    1550     + }
    1551     + }
    1552     + else
    1553     + if (srcFormat == PICT_a8b8g8r8)
    1554     + {
    1555     + while (height--) {
    1556     + pSrc = (unsigned int *)texPtr;
    1557     +
    1558     + for (w = width; w; w--)
    1559     + *pDst++ = *pSrc++;
    1560     + texPtr += texPitch;
    1561     + }
    1562     + }
    1563     + else
    1564     + {
    1565     + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "Unknown texture format\n");
    1566     + }
    1567     +
    1568     +#define SFACTOR (4 << 19)
    1569     +#define DFACTOR (5 << 22)
    1570     + NewportUpdateDRAWMODE1(pNewport, pNewport->setup_drawmode1 | Rop2LogicOp(GXcopy) | NPORT_DMODE1_BENAB | SFACTOR | DFACTOR );
    1571     +#undef SFACTOR
    1572     +#undef DFACTOR
    1573     + NewportUpdateWRMASK(pNewport, pNewport->Color2Planes(0xFFFFFFFF));
    1574     +
    1575     + pNewport->skipleft = 0;
    1576     + NewportUpdateClipping(pNewport);
    1577     + NewportUpdateDRAWMODE0(pNewport,
    1578     + 0
    1579     + | NPORT_DMODE0_DRAW
    1580     + | NPORT_DMODE0_BLOCK
    1581     + | NPORT_DMODE0_CHOST
    1582     + | NPORT_DMODE0_AHOST
    1583     + | NPORT_DMODE0_DOSETUP
    1584     + );
    1585     +
    1586     + return TRUE;
    1587     +}
    1588     +
    1589     +/*******************************************************************************
    1590     +
    1591     +*******************************************************************************/
    1592     +static void
    1593     +NewportRenderTexture1to1(NewportPtr pNewport, int srcx, int srcy, int w, int h)
    1594     +{
    1595     + unsigned int *p;
    1596     + unsigned int add, d;
    1597     + NewportRegsPtr pNewportRegs;
    1598     + pNewportRegs = pNewport->pNewportRegs;
    1599     +
    1600     + p = pNewport->pTexture + srcx + (srcy * pNewport->uTextureWidth);
    1601     + add = pNewport->uTextureWidth - w + srcx;
    1602     + while (h--)
    1603     + {
    1604     + for (d = w; d; d--)
    1605     + {
    1606     + /*NewportWaitGFIFO(pNewport, 1);*/
    1607     + /* hopefully we cannot write faster than XL24 can blend */
    1608     + pNewportRegs->go.hostrw0 = *p++;
    1609     + }
    1610     + p += add;
    1611     + }
    1612     +}
    1613     +
    1614     +/*******************************************************************************
    1615     +
    1616     +*******************************************************************************/
    1617     +static void
    1618     +NewportRenderTextureScale(NewportPtr pNewport, int srcx, int srcy, int w, int h)
    1619     +{
    1620     + int d;
    1621     + int dx, dy;
    1622     + int curx, cury;
    1623     + unsigned int *pLine;
    1624     + int l, p;
    1625     + NewportRegsPtr pNewportRegs;
    1626     + pNewportRegs = pNewport->pNewportRegs;
    1627     +
    1628     + dx = ((pNewport->uTextureWidth - srcx) << 16) / w;
    1629     + dy = ((pNewport->uTextureHeight - srcy) << 16) / h;
    1630     +
    1631     + cury = srcy << 16;
    1632     + while (h--)
    1633     + {
    1634     + l = (cury + 0x7FFF) >> 16;
    1635     + if (l >= pNewport->uTextureHeight)
    1636     + l = pNewport->uTextureHeight-1;
    1637     + pLine = pNewport->pTexture + l * pNewport->uTextureWidth;
    1638     +
    1639     + curx = srcx << 16;
    1640     + for (d = w; d; d--)
    1641     + {
    1642     + p = (curx + 0x7FFF) >> 16;
    1643     + if (p >= pNewport->uTextureWidth)
    1644     + p = pNewport->uTextureWidth-1;
    1645     + pNewportRegs->go.hostrw0 = pLine[p];
    1646     + curx += dx;
    1647     + }
    1648     + cury += dy;
    1649     + }
    1650     +}
    1651     +
    1652     +/*******************************************************************************
    1653     +
    1654     +*******************************************************************************/
    1655     +static void
    1656     +NewportRenderTextureRepeat(NewportPtr pNewport, int srcx, int srcy, int w, int h)
    1657     +{
    1658     + int d;
    1659     + unsigned int *pLine;
    1660     + NewportRegsPtr pNewportRegs;
    1661     + pNewportRegs = pNewport->pNewportRegs;
    1662     +
    1663     + srcx %= pNewport->uTextureWidth;
    1664     + srcy %= pNewport->uTextureHeight;
    1665     +
    1666     + while (h--)
    1667     + {
    1668     + pLine = pNewport->pTexture + pNewport->uTextureWidth * srcy;
    1669     + for (d = w; d; d--)
    1670     + {
    1671     + pNewportRegs->go.hostrw0 = pLine[srcx];
    1672     + srcx++;
    1673     + if (srcx >= pNewport->uTextureWidth)
    1674     + srcx = 0;
    1675     + }
    1676     + srcy++;
    1677     + if (srcy >= pNewport->uTextureHeight)
    1678     + srcy = 0;
    1679     + }
    1680     +
    1681     +}
    1682     +
    1683     +
    1684     +/*******************************************************************************
    1685     +
    1686     +*******************************************************************************/
    1687     +static void
    1688     +NewportXAASubsequentCPUToScreenTexture(
    1689     + ScrnInfoPtr pScrn,
    1690     + int x,
    1691     + int y,
    1692     + int srcx,
    1693     + int srcy,
    1694     + int w,
    1695     + int h)
    1696     +{
    1697     + int ex, ey;
    1698     + NewportRegsPtr pNewportRegs;
    1699     + NewportPtr pNewport;
    1700     + pNewport = NEWPORTPTR(pScrn);
    1701     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    1702     +
    1703     + if (w == 0) w = 1;
    1704     + if (h == 0) h = 1;
    1705     + ex = x + w - 1;
    1706     + ey = y + h - 1;
    1707     +
    1708     + NewportWaitGFIFO(pNewport, 3);
    1709     + pNewportRegs->set.xystarti = ((x & 0xFFFF) << 16) | (y & 0xFFFF);
    1710     + pNewportRegs->set.xyendi = ((ex & 0xFFFF) << 16) | (ey & 0xFFFF);
    1711     + pNewportRegs->set._setup = 1;
    1712     +
    1713     + NewportWaitIdle(pNewport, NEWPORT_GFIFO_ENTRIES);
    1714     +
    1715     + if (srcx + w == pNewport->uTextureWidth
    1716     + && srcy + h == pNewport->uTextureHeight)
    1717     + NewportRenderTexture1to1(pNewport, srcx, srcy, w, h);
    1718     + else
    1719     + if (pNewport->uTextureFlags & XAA_RENDER_REPEAT)
    1720     + NewportRenderTextureRepeat(pNewport, srcx, srcy, w, h);
    1721     + else
    1722     + NewportRenderTextureScale(pNewport, srcx, srcy, w, h);
    1723     +
    1724     + NewportWaitIdle(pNewport, NEWPORT_GFIFO_ENTRIES);
    1725     +
    1726     +}
    1727     +
    1728     +CARD32 NewportAlphaTextureFormats[2] = {PICT_a8, 0};
    1729     +CARD32 NewportTextureFormats[3] = {PICT_a8r8g8b8, PICT_a8b8g8r8, 0};
    1730     +/*CARD32 NewportTextureFormats[2] = {PICT_a8r8g8b8, 0};*/
    1731     +CARD32 NewportDstFormats[7] = {PICT_a8r8g8b8, PICT_a8b8g8r8, PICT_x8r8g8b8, PICT_x8b8g8r8, PICT_r8g8b8, PICT_b8g8r8, 0};
    1732     +
    1733     +#endif
    1734     +
    1735     +/*******************************************************************************
    1736     +
    1737     +*******************************************************************************/
    1738     +Bool
    1739     +NewportXAAScreenInit(ScreenPtr pScreen)
    1740     +{
    1741     + ScrnInfoPtr pScrn;
    1742     + NewportPtr pNewport;
    1743     + NewportRegsPtr pNewportRegs;
    1744     + XAAInfoRecPtr pXAAInfoRec;
    1745     +
    1746     + /* First get a pointer to our private info */
    1747     + pScrn = xf86Screens[pScreen->myNum];
    1748     + pNewport = NEWPORTPTR(pScrn);
    1749     + pNewportRegs = NEWPORTREGSPTR(pScrn);
    1750     +
    1751     + pXAAInfoRec =
    1752     + pNewport->pXAAInfoRec = XAACreateInfoRec();
    1753     + /* initialize accelerated functions */
    1754     + pXAAInfoRec->Sync = NewportXAASync;
    1755     +
    1756     + pXAAInfoRec->Flags = 0
    1757     + /*| LINEAR_FRAMEBUFFER*/
    1758     + ;
    1759     + /* screen to screen copy */
    1760     + pXAAInfoRec->ScreenToScreenCopyFlags = 0
    1761     + | NO_TRANSPARENCY
    1762     + ;
    1763     + pXAAInfoRec->SetupForScreenToScreenCopy = NewportXAASetupForScreenToScreenCopy;
    1764     + pXAAInfoRec->SubsequentScreenToScreenCopy = NewportXAASubsequentScreenToScreenCopy;
    1765     +
    1766     + /* solid fills */
    1767     + pXAAInfoRec->SolidFillFlags = 0
    1768     + ;
    1769     + pXAAInfoRec->SetupForSolidFill = NewportXAASetupForSolidFill;
    1770     + pXAAInfoRec->SubsequentSolidFillRect = NewportXAASubsequentSolidFillRect;
    1771     +
    1772     + /* solid lines */
    1773     + pXAAInfoRec->SolidLineFlags = 0
    1774     + ;
    1775     + pXAAInfoRec->SetupForSolidLine = NewportXAASetupForSolidLine;
    1776     + pXAAInfoRec->SubsequentSolidTwoPointLine = NewportXAASubsequentSolidTwoPointLine;
    1777     +
    1778     + /* dashed lines */
    1779     + pXAAInfoRec->DashedLineFlags = 0
    1780     + | LINE_PATTERN_MSBFIRST_MSBJUSTIFIED
    1781     + ;
    1782     + pXAAInfoRec->DashPatternMaxLength = 2048;
    1783     + pXAAInfoRec->SetupForDashedLine = NewportXAASetupForDashedLine;
    1784     + pXAAInfoRec->SubsequentDashedTwoPointLine = NewportXAASubsequentDashedTwoPointLine;
    1785     +
    1786     + /* cpu to screen expand color fill */
    1787     + pXAAInfoRec->CPUToScreenColorExpandFillFlags = 0
    1788     + | BIT_ORDER_IN_BYTE_LSBFIRST
    1789     + | SCANLINE_PAD_DWORD
    1790     + | CPU_TRANSFER_PAD_DWORD
    1791     + | CPU_TRANSFER_BASE_FIXED
    1792     + | LEFT_EDGE_CLIPPING
    1793     + | LEFT_EDGE_CLIPPING_NEGATIVE_X
    1794     + /*| SYNC_AFTER_COLOR_EXPAND*/
    1795     + ;
    1796     +
    1797     + pXAAInfoRec->SetupForCPUToScreenColorExpandFill = NewportXAASetupForCPUToScreenColorExpandFill;
    1798     + pXAAInfoRec->SubsequentCPUToScreenColorExpandFill = NewportXAASubsequentCPUToScreenColorExpandFill;
    1799     + pXAAInfoRec->ColorExpandRange = 4;
    1800     + pXAAInfoRec->ColorExpandBase = (unsigned char *)&(pNewportRegs->go.zpattern);
    1801     +
    1802     +
    1803     + /* mono 8x8 pattern fill */
    1804     + pXAAInfoRec->Mono8x8PatternFillFlags = 0
    1805     + | BIT_ORDER_IN_BYTE_LSBFIRST
    1806     + | HARDWARE_PATTERN_PROGRAMMED_BITS
    1807     +#ifdef NEWPORT_PREROTATE
    1808     + | HARDWARE_PATTERN_PROGRAMMED_ORIGIN
    1809     +#endif
    1810     + ;
    1811     +
    1812     + pXAAInfoRec->SetupForMono8x8PatternFill = NewportXAASetupForMono8x8PatternFill;
    1813     + pXAAInfoRec->SubsequentMono8x8PatternFillRect = NewportXAASubsequentMono8x8PatternFillRect;
    1814     +
    1815     + /* Image write */
    1816     + pXAAInfoRec->ImageWriteFlags = 0
    1817     + | NO_TRANSPARENCY
    1818     + | CPU_TRANSFER_BASE_FIXED
    1819     + | CPU_TRANSFER_PAD_DWORD
    1820     + | SCANLINE_PAD_DWORD
    1821     + | LEFT_EDGE_CLIPPING
    1822     + | LEFT_EDGE_CLIPPING_NEGATIVE_X
    1823     + /*| SYNC_AFTER_IMAGE_WRITE*/
    1824     + ;
    1825     + pXAAInfoRec->SetupForImageWrite = NewportXAASetupForImageWrite;
    1826     + pXAAInfoRec->SubsequentImageWriteRect = NewportXAASubsequentImageWriteRect;
    1827     + pXAAInfoRec->ImageWriteRange = 4;
    1828     + pXAAInfoRec->ImageWriteBase = (unsigned char *)&(pNewportRegs->go.hostrw0);
    1829     +
    1830     + /* read pixmap */
    1831     + pXAAInfoRec->ReadPixmapFlags = 0
    1832     + | CPU_TRANSFER_PAD_DWORD
    1833     + ;
    1834     + pXAAInfoRec->ReadPixmap = NewportXAAReadPixmap;
    1835     +
    1836     + /* clipping */
    1837     + pXAAInfoRec->ClippingFlags = 0
    1838     + /*| HARDWARE_CLIP_SCREEN_TO_SCREEN_COLOR_EXPAND*/
    1839     + | HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY
    1840     + | HARDWARE_CLIP_MONO_8x8_FILL
    1841     + /*| HARDWARE_CLIP_COLOR_8x8_FILL*/
    1842     + | HARDWARE_CLIP_SOLID_FILL
    1843     + | HARDWARE_CLIP_DASHED_LINE
    1844     + | HARDWARE_CLIP_SOLID_LINE
    1845     + ;
    1846     + pXAAInfoRec->SetClippingRectangle = NewportXAASetClippingRectangle;
    1847     + pXAAInfoRec->DisableClipping = NewportXAADisableClipping;
    1848     +
    1849     + /* make it draw points using our function */
    1850     + pXAAInfoRec->ValidatePolyPoint = NewportValidatePolyPoint;
    1851     + pXAAInfoRec->PolyPointMask = GCFunction | GCPlaneMask;
    1852     + /*pXAAInfoRec->PolyPointMask = 0xFFFFFFFF;*/
    1853     +
    1854     + pXAAInfoRec->ValidatePolyArc = NewportValidatePolyArc;
    1855     + pXAAInfoRec->PolyArcMask = GCFunction | GCLineWidth;
    1856     +#ifdef RENDER
    1857     + if (pScrn->bitsPerPixel > 8)
    1858     + {
    1859     + pXAAInfoRec->CPUToScreenTextureFlags = 0
    1860     + ;
    1861     + pXAAInfoRec->CPUToScreenTextureFormats = NewportTextureFormats;
    1862     + pXAAInfoRec->CPUToScreenTextureDstFormats = NewportDstFormats;
    1863     + pXAAInfoRec->SetupForCPUToScreenTexture2 = NewportXAASetupForCPUToScreenTexture;
    1864     + pXAAInfoRec->SubsequentCPUToScreenTexture = NewportXAASubsequentCPUToScreenTexture;
    1865     +
    1866     + pXAAInfoRec->CPUToScreenAlphaTextureFlags = 0
    1867     + ;
    1868     + pXAAInfoRec->CPUToScreenAlphaTextureFormats = NewportAlphaTextureFormats;
    1869     + pXAAInfoRec->CPUToScreenAlphaTextureDstFormats = NewportDstFormats;
    1870     + pXAAInfoRec->SetupForCPUToScreenAlphaTexture2 = NewportXAASetupForCPUToScreenAlphaTexture;
    1871     + pXAAInfoRec->SubsequentCPUToScreenAlphaTexture = NewportXAASubsequentCPUToScreenTexture; /* this is the same for both */
    1872     + pNewport->pTexture = (unsigned int *)xnfalloc(pNewport->uTextureSize = 16*16*sizeof(unsigned int));
    1873     + }
    1874     +#endif
    1875     +
    1876     + pNewport->Color2Planes = NewportColor2Planes24;
    1877     + if (pScrn->bitsPerPixel == 8)
    1878     + {
    1879     + pNewport->Color2Planes = NewportColor2Planes8;
    1880     + }
    1881     +
    1882     + if (!XAAInit(pScreen, pXAAInfoRec))
    1883     + {
    1884     + xf86DrvMsg(pScrn->scrnIndex, X_ERROR, "XAAInit Failed!\n");
    1885     + return FALSE;
    1886     + }
    1887     +
    1888     + pNewport->fifoleft = 0;
    1889     + /* init bunch of registers */
    1890     +
    1891     + pNewport->shadow_drawmode0 = pNewportRegs->set.drawmode0;
    1892     + pNewport->shadow_colori = pNewportRegs->set.colori;
    1893     + pNewport->shadow_smask0x = pNewportRegs->set.smask0x;
    1894     + pNewport->shadow_smask0y = pNewportRegs->set.smask0y;
    1895     +
    1896     + pNewport->shadow_drawmode1 = pNewport->drawmode1;
    1897     + pNewportRegs->set.drawmode1 = pNewport->drawmode1;
    1898     + pNewport->setup_drawmode1 = pNewport->drawmode1 & ~NPORT_DMODE1_LOMASK;
    1899     +
    1900     + pNewport->shadow_xymove = 0;
    1901     + pNewportRegs->set.xymove = 0;
    1902     +
    1903     + pNewport->shadow_wrmask = 0xFFFFFF;
    1904     + pNewportRegs->set.wrmask = 0xFFFFFF;
    1905     +
    1906     + pNewport->shadow_colorvram = 0;
    1907     + pNewportRegs->set.colorvram = 0;
    1908     +
    1909     + pNewport->shadow_colorback = 0;
    1910     + pNewportRegs->set.colorback = 0;
    1911     +
    1912     + pNewport->clipsx = 0;
    1913     + pNewport->clipex = pScrn->virtualX-1;
    1914     + pNewport->clipsy = 0;
    1915     + pNewport->clipey = pScrn->virtualY-1;
    1916     + pNewport->skipleft = 0;
    1917     +
    1918     + BARF1("CLIPMODE %08X\n", pNewportRegs->cset.clipmode);
    1919     + BARF1("XYWIN %08X\n", pNewportRegs->cset.xywin);
    1920     + BARF1("CONFIG %08X\n", pNewportRegs->cset.config);
    1921     + BARF1("SMASK0X %08X\n", pNewportRegs->set.smask0x);
    1922     + BARF1("SMASK0Y %08X\n", pNewportRegs->set.smask0y);
    1923     +
    1924     +/*
    1925     + set GIO bus timeout to highest possible value 4.32us
    1926     + this will allow for longer bus stalls without bus error
    1927     +*/
    1928     + {
    1929     + unsigned int conf;
    1930     + conf = pNewportRegs->cset.config;
    1931     + conf &= ~NPORT_CFG_TOMSK;
    1932     + conf |= NPORT_CFG_TOMSK;
    1933     +
    1934     + conf &= ~NPORT_CFG_GDMSK;
    1935     + conf |= NPORT_CFG_GDMSK;
    1936     +
    1937     + pNewportRegs->cset.config = conf;
    1938     + }
    1939     +
    1940     + BARF1("CONFIG %08X\n", pNewportRegs->cset.config);
    1941     +
    1942     + pNewport->shadow_clipmode = pNewportRegs->cset.clipmode;
    1943     + pNewportRegs->cset.clipmode |= 1; /* enable clipping mask 0 */
    1944     + NewportUpdateClipping(pNewport);
    1945     +
    1946     + return TRUE;
    1947     +}
    1948     +
    1949     +#endif
    1950     +/* NEWPORT_ACCEL */
    1951     diff -Nur xc.orig/programs/Xserver/hw/xfree86/drivers/newport/newport_driver.c xc/programs/Xserver/hw/xfree86/drivers/newport/newport_driver.c
    1952     --- xc.orig/programs/Xserver/hw/xfree86/drivers/newport/newport_driver.c 2004-11-11 08:52:59.559743184 -0500
    1953     +++ xc/programs/Xserver/hw/xfree86/drivers/newport/newport_driver.c 2004-11-11 08:52:32.849803712 -0500
    1954     @@ -117,6 +117,15 @@
    1955     NULL
    1956     };
    1957    
    1958     +static const char *xaaSymbols[] = {
    1959     + "XAACreateInfoRec",
    1960     + "XAADestroyInfoRec",
    1961     + "XAAFallbackOps",
    1962     + "XAAInit",
    1963     + NULL
    1964     +};
    1965     +
    1966     +
    1967     #ifdef XFree86LOADER
    1968    
    1969     static MODULESETUPPROTO(newportSetup);
    1970     @@ -128,6 +137,9 @@
    1971     MODINFOSTRING1,
    1972     MODINFOSTRING2,
    1973     XORG_VERSION_CURRENT,
    1974     +/*
    1975     + XF86_VERSION_CURRENT,
    1976     +*/
    1977     NEWPORT_MAJOR_VERSION, NEWPORT_MINOR_VERSION, NEWPORT_PATCHLEVEL,
    1978     ABI_CLASS_VIDEODRV,
    1979     ABI_VIDEODRV_VERSION,
    1980     @@ -156,7 +168,7 @@
    1981     * might refer to.
    1982     *
    1983     */
    1984     - LoaderRefSymLists( fbSymbols, ramdacSymbols, shadowSymbols, NULL);
    1985     + LoaderRefSymLists( fbSymbols, ramdacSymbols, shadowSymbols, xaaSymbols, NULL);
    1986    
    1987    
    1988     /*
    1989     @@ -175,7 +187,8 @@
    1990     typedef enum {
    1991     OPTION_BITPLANES,
    1992     OPTION_BUS_ID,
    1993     - OPTION_HWCURSOR
    1994     + OPTION_HWCURSOR,
    1995     + OPTION_NOACCEL
    1996     } NewportOpts;
    1997    
    1998     /* Supported options */
    1999     @@ -183,6 +196,7 @@
    2000     { OPTION_BITPLANES, "bitplanes", OPTV_INTEGER, {0}, FALSE },
    2001     { OPTION_BUS_ID, "BusID", OPTV_INTEGER, {0}, FALSE },
    2002     { OPTION_HWCURSOR, "HWCursor", OPTV_BOOLEAN, {0}, FALSE },
    2003     + { OPTION_NOACCEL, "NoAccel", OPTV_BOOLEAN, {0}, FALSE },
    2004     { -1, NULL, OPTV_NONE, {0}, FALSE }
    2005     };
    2006    
    2007     @@ -297,11 +311,15 @@
    2008     /* Fill in the monitor field */
    2009     pScrn->monitor = pScrn->confScreen->monitor;
    2010    
    2011     +#ifdef NEWPORT_USE32BPP
    2012     + if (!xf86SetDepthBpp(pScrn, 24, 32, 32, Support32bppFb))
    2013     + return FALSE;
    2014     +#else
    2015     if (!xf86SetDepthBpp(pScrn, 24, 0, 0,
    2016     Support24bppFb | SupportConvert32to24 |
    2017     PreferConvert32to24 ))
    2018     return FALSE;
    2019     -
    2020     +#endif
    2021     switch( pScrn->depth ) {
    2022     /* check if the returned depth is one we support */
    2023     case 8:
    2024     @@ -322,9 +340,16 @@
    2025    
    2026     /* Set Default Weight */
    2027     if( pScrn->depth > 8 ) {
    2028     +#ifdef NEWPORT_USE32BPP
    2029     + rgb w = {8, 8, 8};
    2030     + rgb m = {0x0000FF, 0x00FF00, 0xFF0000};
    2031     + if (!xf86SetWeight(pScrn, w, m))
    2032     + return FALSE;
    2033     +#else
    2034     rgb zeros = {0, 0, 0};
    2035     if (!xf86SetWeight(pScrn, zeros, zeros))
    2036     return FALSE;
    2037     +#endif
    2038     }
    2039    
    2040     if (!xf86SetDefaultVisual(pScrn, -1)) {
    2041     @@ -474,6 +499,11 @@
    2042     return TRUE;
    2043     }
    2044    
    2045     +
    2046     +Bool
    2047     +NewportXAAScreenInit(ScreenPtr pScreen);
    2048     +
    2049     +
    2050     static Bool
    2051     NewportScreenInit(int index, ScreenPtr pScreen, int argc, char **argv)
    2052     {
    2053     @@ -529,18 +559,48 @@
    2054     visual->redMask = pScrn->mask.red;
    2055     visual->greenMask = pScrn->mask.green;
    2056     visual->blueMask = pScrn->mask.blue;
    2057     + /*
    2058     + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "Bitplanes R:%d:%08X G:%d:%08X B:%d:%08X\n",
    2059     + visual->offsetRed, visual->redMask,
    2060     + visual->offsetGreen, visual->greenMask,
    2061     + visual->offsetBlue, visual->blueMask);
    2062     + */
    2063     }
    2064     }
    2065     }
    2066    
    2067     /* must be after RGB ordering fixed */
    2068     - fbPictureInit (pScreen, 0, 0);
    2069     + if (!fbPictureInit(pScreen, NULL, 0))
    2070     + xf86DrvMsg(pScrn->scrnIndex, X_WARNING,
    2071     + "RENDER extension initialisation failed.\n");
    2072    
    2073     miInitializeBackingStore(pScreen);
    2074     xf86SetBackingStore(pScreen);
    2075    
    2076     xf86SetBlackWhitePixels(pScreen);
    2077     -
    2078     +#ifdef NEWPORT_ACCEL
    2079     + pNewport->NoAccel = FALSE;
    2080     + if (xf86ReturnOptValBool(pNewport->Options, OPTION_NOACCEL, FALSE))
    2081     + {
    2082     + if (!xf86LoadSubModule(pScrn, "xaa"))
    2083     + return FALSE;
    2084     + xf86LoaderReqSymLists(xaaSymbols, NULL);
    2085     + pNewport->NoAccel = TRUE;
    2086     + xf86DrvMsg(pScrn->scrnIndex, X_CONFIG, "Acceleration disabled\n");
    2087     + }
    2088     +#if 0
    2089     + if (pScrn->bitsPerPixel < 24)
    2090     + { /* not implemented yet */
    2091     + pNewport->NoAccel = TRUE;
    2092     + }
    2093     +#endif
    2094     + pNewport->pXAAInfoRec = NULL;
    2095     + if (!pNewport->NoAccel)
    2096     + {
    2097     + if (!NewportXAAScreenInit(pScreen))
    2098     + return FALSE;
    2099     + }
    2100     +#endif
    2101     /* Initialize software cursor */
    2102     if(!miDCInitialize(pScreen, xf86GetPointerScreenFuncs()))
    2103     return FALSE;
    2104     @@ -564,7 +624,9 @@
    2105     "Colormap initialization failed\n");
    2106     return FALSE;
    2107     }
    2108     -
    2109     +#ifdef NEWPORT_ACCEL
    2110     + if (pNewport->NoAccel)
    2111     +#endif
    2112     /* Initialise shadow frame buffer */
    2113     if(!ShadowFBInit(pScreen, (pNewport->Bpp == 1) ? &NewportRefreshArea8 :
    2114     &NewportRefreshArea24)) {
    2115     @@ -617,6 +679,13 @@
    2116     {
    2117     ScrnInfoPtr pScrn = xf86Screens[scrnIndex];
    2118     NewportPtr pNewport = NEWPORTPTR(pScrn);
    2119     +#ifdef NEWPORT_ACCEL
    2120     + if (pNewport->pXAAInfoRec && !pNewport->NoAccel)
    2121     + {
    2122     + XAADestroyInfoRec(pNewport->pXAAInfoRec);
    2123     + pNewport->pXAAInfoRec = NULL;
    2124     + }
    2125     +#endif
    2126    
    2127     NewportRestore(pScrn, TRUE);
    2128     if (pNewport->ShadowPtr)
    2129     diff -Nur xc.orig/programs/Xserver/hw/xfree86/drivers/newport/newport_regs.h xc/programs/Xserver/hw/xfree86/drivers/newport/newport_regs.h
    2130     --- xc.orig/programs/Xserver/hw/xfree86/drivers/newport/newport_regs.h 2004-11-11 08:52:59.558743336 -0500
    2131     +++ xc/programs/Xserver/hw/xfree86/drivers/newport/newport_regs.h 2004-11-11 08:52:32.848803864 -0500
    2132     @@ -8,13 +8,6 @@
    2133    
    2134     typedef volatile unsigned long npireg_t;
    2135    
    2136     -union npfloat {
    2137     - volatile float f;
    2138     - npireg_t i;
    2139     -};
    2140     -
    2141     -typedef union npfloat npfreg_t;
    2142     -
    2143     union np_dcb {
    2144     npireg_t all;
    2145     struct { volatile unsigned short s0, s1; } hwords;
    2146     @@ -150,44 +143,44 @@
    2147     unsigned long _pad1[0x30];
    2148    
    2149     /* Iterators, full state for context switch */
    2150     - npfreg_t _xstart; /* X-start point (current) */
    2151     - npfreg_t _ystart; /* Y-start point (current) */
    2152     - npfreg_t _xend; /* x-end point */
    2153     - npfreg_t _yend; /* y-end point */
    2154     + npireg_t _xstart; /* X-start point (current) */
    2155     + npireg_t _ystart; /* Y-start point (current) */
    2156     + npireg_t _xend; /* x-end point */
    2157     + npireg_t _yend; /* y-end point */
    2158     npireg_t xsave; /* copy of xstart integer value for BLOCk addressing MODE */
    2159     npireg_t xymove; /* x.y offset from xstart, ystart for relative operations */
    2160     - npfreg_t bresd;
    2161     - npfreg_t bress1;
    2162     + npireg_t bresd;
    2163     + npireg_t bress1;
    2164     npireg_t bresoctinc1;
    2165     - volatile int bresrndinc2;
    2166     + npireg_t bresrndinc2;
    2167     npireg_t brese1;
    2168     npireg_t bress2;
    2169     npireg_t aweight0;
    2170     npireg_t aweight1;
    2171     - npfreg_t xstartf;
    2172     - npfreg_t ystartf;
    2173     - npfreg_t xendf;
    2174     - npfreg_t yendf;
    2175     + npireg_t xstartf;
    2176     + npireg_t ystartf;
    2177     + npireg_t xendf;
    2178     + npireg_t yendf;
    2179     npireg_t xstarti;
    2180     - npfreg_t xendf1;
    2181     + npireg_t xendf1;
    2182     npireg_t xystarti;
    2183     npireg_t xyendi;
    2184     npireg_t xstartendi;
    2185    
    2186     unsigned long _unused2[0x29];
    2187    
    2188     - npfreg_t colorred;
    2189     - npfreg_t coloralpha;
    2190     - npfreg_t colorgrn;
    2191     - npfreg_t colorblue;
    2192     - npfreg_t slopered;
    2193     - npfreg_t slopealpha;
    2194     - npfreg_t slopegrn;
    2195     - npfreg_t slopeblue;
    2196     + npireg_t colorred;
    2197     + npireg_t coloralpha;
    2198     + npireg_t colorgrn;
    2199     + npireg_t colorblue;
    2200     + npireg_t slopered;
    2201     + npireg_t slopealpha;
    2202     + npireg_t slopegrn;
    2203     + npireg_t slopeblue;
    2204     npireg_t wrmask;
    2205     npireg_t colori;
    2206     - npfreg_t colorx;
    2207     - npfreg_t slopered1;
    2208     + npireg_t colorx;
    2209     + npireg_t slopered1;
    2210     npireg_t hostrw0;
    2211     npireg_t hostrw1;
    2212     npireg_t dcbmode;
    2213     @@ -247,21 +240,22 @@
    2214     #define NPORT_CMODE_CMSK 0x00001e00
    2215    
    2216     unsigned long _unused0;
    2217     - unsigned long config;
    2218     + npireg_t config;
    2219     #define NPORT_CFG_G32MD 0x00000001
    2220     #define NPORT_CFG_BWIDTH 0x00000002
    2221     #define NPORT_CFG_ERCVR 0x00000004
    2222     #define NPORT_CFG_BDMSK 0x00000078
    2223     -#define NPORT_CFG_GDMSK 0x00000f80
    2224     -#define NPORT_CFG_GD0 0x00000080
    2225     -#define NPORT_CFG_GD1 0x00000100
    2226     -#define NPORT_CFG_GD2 0x00000200
    2227     -#define NPORT_CFG_GD3 0x00000400
    2228     -#define NPORT_CFG_GD4 0x00000800
    2229     -#define NPORT_CFG_GFAINT 0x00001000
    2230     -#define NPORT_CFG_TOMSK 0x0000e000
    2231     -#define NPORT_CFG_VRMSK 0x00070000
    2232     -#define NPORT_CFG_FBTYP 0x00080000
    2233     +#define NPORT_CFG_BFAINT 0x00000080
    2234     +#define NPORT_CFG_GDMSK 0x00001f00
    2235     +#define NPORT_CFG_GD0 0x00000100
    2236     +#define NPORT_CFG_GD1 0x00000200
    2237     +#define NPORT_CFG_GD2 0x00000400
    2238     +#define NPORT_CFG_GD3 0x00000800
    2239     +#define NPORT_CFG_GD4 0x00001000
    2240     +#define NPORT_CFG_GFAINT 0x00002000
    2241     +#define NPORT_CFG_TOMSK 0x0001C000
    2242     +#define NPORT_CFG_VRMSK 0x000E0000
    2243     +#define NPORT_CFG_FBTYP 0x00100000
    2244    
    2245     npireg_t _unused1;
    2246     npireg_t stat;
    2247     diff -Nur xc.orig/programs/Xserver/hw/xfree86/drivers/newport/newport_shadow.c xc/programs/Xserver/hw/xfree86/drivers/newport/newport_shadow.c
    2248     --- xc.orig/programs/Xserver/hw/xfree86/drivers/newport/newport_shadow.c 2004-11-11 08:52:59.558743336 -0500
    2249     +++ xc/programs/Xserver/hw/xfree86/drivers/newport/newport_shadow.c 2004-11-11 08:52:32.848803864 -0500
    2250     @@ -52,7 +52,9 @@
    2251     {
    2252     int dx, dy;
    2253     CARD8 *src, *base;
    2254     +#ifndef NEWPORT_USE32BPP
    2255     CARD32 dest;
    2256     +#endif
    2257     NewportPtr pNewport = NEWPORTPTR(pScrn);
    2258     NewportRegsPtr pNewportRegs = pNewport->pNewportRegs;
    2259    
    2260     @@ -65,8 +67,13 @@
    2261     NPORT_DMODE0_CHOST);
    2262    
    2263     while(num--) {
    2264     - base = (CARD8*)pNewport->ShadowPtr + pbox->y1 * pNewport->ShadowPitch + pbox->x1 * 3;
    2265     -
    2266     +
    2267     + base = (CARD8*)pNewport->ShadowPtr + pbox->y1 * pNewport->ShadowPitch + pbox->x1
    2268     +#ifdef NEWPORT_USE32BPP
    2269     + * 4;
    2270     +#else
    2271     + * 3;
    2272     +#endif
    2273     pNewportRegs->set.xystarti = (pbox->x1 << 16) | pbox->y1;
    2274     pNewportRegs->set.xyendi = ((pbox->x2-1) << 16) | (pbox->y2-1);
    2275    
    2276     @@ -76,9 +83,14 @@
    2277     /* Removing these shifts by using 32bpp fb
    2278     * yields < 2% percent performance gain and wastes 25% memory
    2279     */
    2280     +#ifdef NEWPORT_USE32BPP
    2281     + pNewportRegs->go.hostrw0 = *(CARD32 *)src;
    2282     + src += 4;
    2283     +#else
    2284     dest = src[0] | src[1] << 8 | src[2] << 16;
    2285     pNewportRegs->go.hostrw0 = dest;
    2286     src+=3;
    2287     +#endif
    2288     }
    2289     base += pNewport->ShadowPitch;
    2290     }