Magellan Linux

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

    Contents 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 - (show annotations) (download)
    Tue May 8 20:58:51 2007 UTC (17 years ago) by niro
    File size: 66330 byte(s) 
    -import
    1 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 }