1/*
2 * Copyright 1997-2003 by Alan Hourihane, North Wales, UK.
3 *
4 * Permission to use, copy, modify, distribute, and sell this software
5 * and its documentation for any purpose is hereby granted without
6 * fee, provided that the above copyright notice appear in all copies
7 * and that both that copyright notice and this permission notice
8 * appear in supporting documentation, and that the name of Alan
9 * Hourihane not be used in advertising or publicity pertaining to
10 * distribution of the software without specific, written prior
11 * permission.  Alan Hourihane makes no representations about the
12 * suitability of this software for any purpose.  It is provided
13 * "as is" without express or implied warranty.
14 *
15 * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
16 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
17 * FITNESS, IN NO EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY
18 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
19 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
20 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
21 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
22 * SOFTWARE.
23 *
24 * Authors:  Alan Hourihane, <alanh@fairlite.demon.co.uk>
25 *
26 * Trident 3DImage' accelerated options.
27 */
28
29#ifdef HAVE_CONFIG_H
30#include "config.h"
31#endif
32
33#include "xf86.h"
34#include "xf86_OSproc.h"
35
36#include "xf86Pci.h"
37
38#include "miline.h"
39
40#include "trident.h"
41#include "trident_regs.h"
42
43#ifdef HAVE_XAA_H
44#include "xaarop.h"
45#include "xaalocal.h"
46
47
48static void ImageSync(ScrnInfoPtr pScrn);
49static void ImageSyncClip(ScrnInfoPtr pScrn);
50#if 0
51static void ImageSetupForSolidLine(ScrnInfoPtr pScrn,
52                                    int color,
53                                    int rop,
54                                    unsigned int planemask);
55static void ImageSubsequentSolidBresenhamLine(ScrnInfoPtr pScrn,
56                                                int x, int y,
57                                                int dmaj, int dmin,
58                                                int e, int len,
59                                                int octant);
60#endif
61static void ImageSetupForFillRectSolid(ScrnInfoPtr pScrn,
62                                            int color,
63                                            int rop,
64                                            unsigned int planemask);
65static void ImageSubsequentFillRectSolid(ScrnInfoPtr pScrn,
66                                            int x, int y,
67                                            int w, int h);
68static void ImageSubsequentScreenToScreenCopy(ScrnInfoPtr pScrn,
69                                                int x1, int y1,
70                                                int x2, int y2,
71                                                int w, int h);
72static void ImageSetupForScreenToScreenCopy(ScrnInfoPtr pScrn,
73                                            int xdir, int ydir,
74                                            int rop,
75                                            unsigned int planemask,
76                                            int transparency_color);
77static void ImageSetClippingRectangle(ScrnInfoPtr pScrn,
78                                        int x1, int y1,
79                                        int x2, int y2);
80static void ImageDisableClipping(ScrnInfoPtr pScrn);
81static void ImageSetupForMono8x8PatternFill(ScrnInfoPtr pScrn,
82                                            int patternx,
83                                            int patterny,
84                                            int fg, int bg,
85                                            int rop,
86                                            unsigned int planemask);
87static void ImageSubsequentMono8x8PatternFillRect(ScrnInfoPtr pScrn,
88                                                    int patternx,
89                                                    int patterny,
90                                                    int x, int y,
91                                                    int w, int h);
92#if 0
93static void ImageSetupForColor8x8PatternFill(ScrnInfoPtr pScrn,
94                                                int patternx,
95                                                int patterny,
96                                                int rop,
97                                                unsigned int planemask,
98                                                int trans_col);
99static void ImageSubsequentColor8x8PatternFillRect(ScrnInfoPtr pScrn,
100                                                    int patternx,
101                                                    int patterny,
102                                                    int x, int y,
103                                                    int w, int h);
104#endif
105static void ImageSetupForScanlineImageWrite(ScrnInfoPtr pScrn,
106                                            int rop,
107                                            unsigned int planemask,
108                                            int transparency_color,
109                                            int bpp,
110                                            int depth);
111static void ImageSubsequentScanlineImageWriteRect(ScrnInfoPtr pScrn,
112                                                    int x, int y,
113                                                    int w, int h,
114                                                    int skipleft);
115static void ImageSubsequentImageWriteScanline(ScrnInfoPtr pScrn,
116                                                int bufno);
117static void ImageSetupForScanlineCPUToScreenColorExpandFill(
118                                            ScrnInfoPtr pScrn,
119                                            int fg, int bg,
120                                            int rop,
121                                            unsigned int planemask);
122static void ImageSubsequentScanlineCPUToScreenColorExpandFill(
123                                                    ScrnInfoPtr pScrn,
124                                                    int x, int y,
125                                                    int w, int h,
126                                                    int skipleft);
127static void ImageSubsequentColorExpandScanline(ScrnInfoPtr pScrn,
128                                                int bufno);
129
130
131static void
132ImageInitializeAccelerator(ScrnInfoPtr pScrn)
133{
134    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
135
136    switch (pScrn->depth) {
137    case 8:
138        pTrident->EngineOperation = 0;
139        break;
140    case 15:
141        pTrident->EngineOperation = 5;
142        break;
143    case 16:
144        pTrident->EngineOperation = 1;
145        break;
146    case 24:
147        pTrident->EngineOperation = 2;
148        break;
149    }
150    IMAGE_OUT(0x2120, 0xF0000000);
151    IMAGE_OUT(0x2120, 0x40000000 | pTrident->EngineOperation);
152    IMAGE_OUT(0x2120, 0x80000000);
153    IMAGE_OUT(0x2144, 0x00000000);
154    IMAGE_OUT(0x2148, 0x00000000);
155    IMAGE_OUT(0x2150, 0x00000000);
156    IMAGE_OUT(0x2154, 0x00000000);
157    IMAGE_OUT(0x2120, 0x60000000 |
158                        (pScrn->displayWidth << 16) |
159                        pScrn->displayWidth);
160    IMAGE_OUT(0x216C, 0x00000000);
161    IMAGE_OUT(0x2170, 0x00000000);
162    IMAGE_OUT(0x217C, 0x00000000);
163    IMAGE_OUT(0x2120, 0x10000000);
164    IMAGE_OUT(0x2130, (2047 << 16) | 2047);
165    pTrident->Clipping = FALSE;
166    pTrident->DstEnable = FALSE;
167}
168#endif
169
170Bool
171ImageAccelInit(ScreenPtr pScreen)
172{
173#ifdef HAVE_XAA_H
174    XAAInfoRecPtr infoPtr;
175    ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
176    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
177
178    if (pTrident->NoAccel)
179        return FALSE;
180
181    pTrident->AccelInfoRec = infoPtr = XAACreateInfoRec();
182    if (!infoPtr) return FALSE;
183
184    pTrident->InitializeAccelerator = ImageInitializeAccelerator;
185    ImageInitializeAccelerator(pScrn);
186
187    infoPtr->Flags = PIXMAP_CACHE |
188            LINEAR_FRAMEBUFFER |
189            OFFSCREEN_PIXMAPS;
190
191    infoPtr->Sync = ImageSync;
192
193#if 0
194    infoPtr->SetClippingRectangle = ImageSetClippingRectangle;
195    infoPtr->DisableClipping = ImageDisableClipping;
196    infoPtr->ClippingFlags = HARDWARE_CLIP_SOLID_FILL |
197                                HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY |
198                                HARDWARE_CLIP_MONO_8x8_FILL;
199#endif
200
201#if 0
202    infoPtr->SolidLineFlags = NO_PLANEMASK;
203    infoPtr->SetupForSolidLine = ImageSetupForSolidLine;
204    infoPtr->SolidBresenhamLineErrorTermBits = 13;
205    infoPtr->SubsequentSolidBresenhamLine =
206                                    ImageSubsequentSolidBresenhamLine;
207    infoPtr->ClippingFlags |= HARDWARE_CLIP_SOLID_LINE;
208#endif
209
210    infoPtr->SolidFillFlags = NO_PLANEMASK;
211    infoPtr->SetupForSolidFill = ImageSetupForFillRectSolid;
212    infoPtr->SubsequentSolidFillRect = ImageSubsequentFillRectSolid;
213
214    infoPtr->ScreenToScreenCopyFlags = NO_PLANEMASK |
215                                        NO_TRANSPARENCY |
216                                        ONLY_TWO_BITBLT_DIRECTIONS;
217
218    infoPtr->SetupForScreenToScreenCopy =
219                                    ImageSetupForScreenToScreenCopy;
220    infoPtr->SubsequentScreenToScreenCopy =
221                                    ImageSubsequentScreenToScreenCopy;
222
223    infoPtr->Mono8x8PatternFillFlags =  NO_PLANEMASK |
224                                    BIT_ORDER_IN_BYTE_MSBFIRST |
225                                    HARDWARE_PATTERN_SCREEN_ORIGIN |
226                                    HARDWARE_PATTERN_PROGRAMMED_BITS;
227
228    infoPtr->SetupForMono8x8PatternFill =
229                                    ImageSetupForMono8x8PatternFill;
230    infoPtr->SubsequentMono8x8PatternFillRect =
231                                ImageSubsequentMono8x8PatternFillRect;
232
233#if 0
234    infoPtr->Color8x8PatternFillFlags = NO_PLANEMASK |
235                                    NO_TRANSPARENCY |
236                                    HARDWARE_PATTERN_SCREEN_ORIGIN |
237                                    BIT_ORDER_IN_BYTE_MSBFIRST;
238
239    infoPtr->SetupForColor8x8PatternFill =
240                                    ImageSetupForColor8x8PatternFill;
241    infoPtr->SubsequentColor8x8PatternFillRect =
242                            ImageSubsequentColor8x8PatternFillRect;
243    infoPtr->ClippingFlags |= HARDWARE_CLIP_COLOR_8x8_FILL;
244#endif
245
246    if (pTrident->Chipset != CYBER9397DVD) {
247        /*
248         * It seems as though the 9397DVD doesn't like the transfer
249         * window.  But then, I've also tried at the two port
250         * addresses too, with no luck.  Disable for this chipset for
251         * now. I'd guess there's some extra setup needed for this
252         * chipset.
253         */
254        infoPtr->ScanlineCPUToScreenColorExpandFillFlags =
255                                            NO_PLANEMASK |
256                                            LEFT_EDGE_CLIPPING |
257                                            BIT_ORDER_IN_BYTE_MSBFIRST;
258
259        pTrident->XAAScanlineColorExpandBuffers[0] =
260                            xnfalloc(((pScrn->virtualX + 63)) * 4 *
261                                        (pScrn->bitsPerPixel / 8));
262
263        infoPtr->NumScanlineColorExpandBuffers = 1;
264        infoPtr->ScanlineColorExpandBuffers =
265                            pTrident->XAAScanlineColorExpandBuffers;
266
267        infoPtr->SetupForScanlineCPUToScreenColorExpandFill =
268                    ImageSetupForScanlineCPUToScreenColorExpandFill;
269        infoPtr->SubsequentScanlineCPUToScreenColorExpandFill =
270                    ImageSubsequentScanlineCPUToScreenColorExpandFill;
271        infoPtr->SubsequentColorExpandScanline =
272                                ImageSubsequentColorExpandScanline;
273
274        infoPtr->ScanlineImageWriteFlags = NO_PLANEMASK |
275                                                LEFT_EDGE_CLIPPING;
276
277        infoPtr->SetupForScanlineImageWrite =
278                                    ImageSetupForScanlineImageWrite;
279        infoPtr->SubsequentScanlineImageWriteRect =
280                ImageSubsequentScanlineImageWriteRect;
281        infoPtr->SubsequentImageWriteScanline =
282                                    ImageSubsequentImageWriteScanline;
283
284        infoPtr->NumScanlineImageWriteBuffers = 1;
285        infoPtr->ScanlineImageWriteBuffers =
286                                    pTrident->XAAImageScanlineBuffer;
287
288        pTrident->XAAImageScanlineBuffer[0] =
289                xnfalloc(pScrn->virtualX * pScrn->bitsPerPixel / 8);
290
291        infoPtr->ImageWriteBase = pTrident->IOBase + 0x10000;
292    }
293
294    return(XAAInit(pScreen, infoPtr));
295#else
296    return FALSE;
297#endif
298}
299
300#ifdef HAVE_XAA_H
301static void
302ImageSync(ScrnInfoPtr pScrn)
303{
304    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
305    int busy;
306    int cnt = 5000000;
307
308    if (pTrident->Clipping) ImageDisableClipping(pScrn);
309    if (pTrident->DstEnable) {
310        IMAGE_OUT(0x2120, 0x70000000);
311        pTrident->DstEnable = FALSE;
312    }
313
314    IMAGEBUSY(busy);
315    while (busy != 0) {
316        if (--cnt < 0) {
317            ErrorF("GE timeout\n");
318            IMAGE_OUT(0x2164, 0x80000000);
319        }
320
321        IMAGEBUSY(busy);
322    }
323}
324
325static void
326ImageSyncClip(ScrnInfoPtr pScrn)
327{
328    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
329    int busy;
330    int cnt = 5000000;
331
332    IMAGEBUSY(busy);
333    while (busy != 0) {
334        if (--cnt < 0) {
335            ErrorF("GE timeout\n");
336            IMAGE_OUT(0x2164, 0x80000000);
337        }
338
339        IMAGEBUSY(busy);
340    }
341}
342
343static void
344ImageSetupForScreenToScreenCopy(ScrnInfoPtr pScrn,
345                                int xdir, int ydir,
346                                int rop,
347                                unsigned int planemask,
348                                int transparency_color)
349{
350    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
351
352    pTrident->BltScanDirection = 0;
353    if ((xdir < 0) || (ydir < 0))
354        pTrident->BltScanDirection |= (1 << 2);
355
356    IMAGE_OUT(0x2120, 0x80000000);
357    IMAGE_OUT(0x2120, 0x90000000 | XAAGetCopyROP(rop));
358
359    if (transparency_color != -1) {
360        IMAGE_OUT(0x2120, 0x70000000 |
361                            (1 << 26) |
362                            (transparency_color & 0xffffff));
363        pTrident->DstEnable = TRUE;
364    }
365}
366
367static void
368ImageSubsequentScreenToScreenCopy(ScrnInfoPtr pScrn,
369                                    int x1, int y1,
370                                    int x2, int y2,
371                                    int w, int h)
372{
373    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
374
375    if (pTrident->BltScanDirection) {
376        IMAGE_OUT(0x2100, ((y1 + h - 1) << 16) | (x1 + w - 1));
377        IMAGE_OUT(0x2104, (y1 << 16) | x1);
378        IMAGE_OUT(0x2108, ((y2 + h - 1) << 16) | (x2 + w - 1));
379        IMAGE_OUT(0x210C, y2<<16 | x2);
380    } else {
381        IMAGE_OUT(0x2100, (y1 << 16) | x1);
382        IMAGE_OUT(0x2104, ((y1 + h - 1) << 16) | (x1 + w - 1));
383        IMAGE_OUT(0x2108, (y2 << 16) | x2);
384        IMAGE_OUT(0x210C, ((y2 + h - 1) << 16) | (x2 + w - 1));
385    }
386
387    IMAGE_OUT(0x2124, 0x80000000 |
388                        (1 << 7) | (1 << 22) | (1 << 10) |
389                        pTrident->BltScanDirection |
390                        (pTrident->Clipping ? 1 : 0));
391
392    if (!pTrident->UsePCIRetry)
393        ImageSyncClip(pScrn);
394}
395
396static void
397ImageSetClippingRectangle(ScrnInfoPtr pScrn,
398                            int x1, int y1,
399                            int x2, int y2)
400{
401    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
402
403    IMAGE_OUT(0x2120, 0x10000000 |
404                        ((y1 & 0xfff) << 16) | (x1 & 0xfff));
405    IMAGE_OUT(0x2130, ((y2 & 0xfff) << 16) | (x2 & 0xfff));
406    pTrident->Clipping = TRUE;
407}
408
409static void
410ImageDisableClipping(ScrnInfoPtr pScrn)
411{
412    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
413    pTrident->Clipping = FALSE;
414}
415
416#if 0
417static void
418ImageSetupForSolidLine(ScrnInfoPtr pScrn,
419                        int color,
420                        int rop,
421                        unsigned int planemask)
422{
423    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
424
425    REPLICATE(color);
426    IMAGE_OUT(0x2120, 0x84000000);
427    IMAGE_OUT(0x2120, 0x90000000 | XAAGetCopyROP(rop));
428    IMAGE_OUT(0x2144, color);
429}
430
431static void
432ImageSubsequentSolidBresenhamLine(ScrnInfoPtr pScrn,
433                                    int x, int y,
434                                    int dmaj, int dmin,
435                                    int e, int len, int octant)
436{
437    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
438    int tmp;
439    int D = 0, E = 0, ymajor = 0;
440
441    IMAGE_OUT(0x2124, 0x20000000 |
442                        (3 << 22) | (1 << 10) | (1 << 9) |
443                        (pTrident->Clipping ? 1 : 0));
444    if (!(octant & YMAJOR)) {
445        if ((!(octant & XDECREASING)) && (!(octant & YDECREASING))) {
446            E = 1;
447            D = 0;
448        }
449
450        if ((!(octant & XDECREASING)) && ( (octant & YDECREASING))) {
451            E = 1;
452            D = 1;
453        }
454
455        if (( (octant & XDECREASING)) && (!(octant & YDECREASING))) {
456            E = 1;
457            D = 2;
458        }
459        if (( (octant & XDECREASING)) && ( (octant & YDECREASING))) {
460            E = 1;
461            D = 3;
462        }
463
464        ymajor = 0;
465    } else {
466        if ((!(octant & XDECREASING)) && (!(octant & YDECREASING))) {
467            E = 0;
468            D = 0;
469        }
470
471        if ((!(octant & XDECREASING)) && ( (octant & YDECREASING))) {
472            E = 0;
473            D = 2;
474        }
475
476        if (( (octant & XDECREASING)) && (!(octant & YDECREASING))) {
477            E = 0;
478            D = 1;
479        }
480
481        if (( (octant & XDECREASING)) && ( (octant & YDECREASING))) {
482            E = 0;
483            D = 3;
484        }
485
486        ymajor = (1 << 18);
487    }
488
489    if (E) {
490        tmp = x;
491        x = y;
492        y = tmp;
493    }
494    if (D & 0x02) {
495        IMAGE_OUT(0x21FC, 0x20000000 |
496                            (1 << 27) | (1 << 19) | (1 << 17) |
497                            ymajor | (x + len - 1));
498    } else {
499        IMAGE_OUT(0x21FC, 0x20000000 |
500                            (1 << 27) | (1 << 19) | (1 << 17) |
501                            ymajor | ( y + len - 1));
502    }
503    IMAGE_OUT(0x2100, (E << 30) | ((y & 0xfff) << 16) | (x & 0xfff));
504    IMAGE_OUT(0x2104, (D << 30) |
505                        (((dmaj - dmin) & 0xfff) << 16) |
506                        (-dmin & 0xfff));
507    IMAGE_OUT(0x2108, ((-e & 0xfff) << 16));
508
509    if (!pTrident->UsePCIRetry)
510        ImageSyncClip(pScrn);
511}
512#endif
513
514static void
515ImageSetupForFillRectSolid(ScrnInfoPtr pScrn,
516                            int color,
517                            int rop,
518                            unsigned int planemask)
519{
520    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
521
522    REPLICATE(color);
523    IMAGE_OUT(0x2120, 0x80000000);
524    IMAGE_OUT(0x2120, 0x90000000 | XAAGetCopyROP(rop));
525    IMAGE_OUT(0x2144, color);
526}
527
528static void
529ImageSubsequentFillRectSolid(ScrnInfoPtr pScrn,
530                                int x, int y,
531                                int w, int h)
532{
533    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
534
535    if ((w <= 0) || (h <= 0))
536        return;
537
538    IMAGE_OUT(0x2108, ((y & 0xfff) << 16) | (x & 0xfff));
539    IMAGE_OUT(0x210C, (((y + h - 1) & 0xfff) << 16) |
540                        ((x + w - 1) & 0xfff));
541    IMAGE_OUT(0x2124, 0x80000000 |
542                        (3 << 22) | (1 << 10) | (1 << 9) |
543                        (pTrident->Clipping ? 1 : 0));
544    if (!pTrident->UsePCIRetry)
545        ImageSyncClip(pScrn);
546}
547
548static void
549MoveDWORDS(register CARD32* dest,
550            register CARD32* src,
551            register int dwords )
552{
553    Bool extra = FALSE;
554
555    if (dwords & 0x01) extra = TRUE;
556
557    while(dwords & ~0x03) {
558        *dest = *src;
559        *(dest + 1) = *(src + 1);
560        *(dest + 2) = *(src + 2);
561        *(dest + 3) = *(src + 3);
562        src += 4;
563        dest += 4;
564        dwords -= 4;
565    }
566
567    if(!dwords) {
568        if (extra) *dest = 0x00000000;
569        return;
570    }
571
572    *dest = *src;
573    if(dwords == 1) {
574        if (extra) *(dest + 1) = 0x00000000;
575        return;
576    }
577
578    *(dest + 1) = *(src + 1);
579    if(dwords == 2) {
580        if (extra) *(dest + 2) = 0x00000000;
581        return;
582    }
583
584    *(dest + 2) = *(src + 2);
585    if (extra) *(dest + 3) = 0x00000000;
586}
587
588static void
589ImageSetupForMono8x8PatternFill(ScrnInfoPtr pScrn,
590                                int patternx, int patterny,
591                                int fg, int bg,
592                                int rop,
593                                unsigned int planemask)
594{
595    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
596
597    IMAGE_OUT(0x2120, 0x90000000 | XAAGetPatternROP(rop));
598    if (bg == -1) {
599        REPLICATE(fg);
600        IMAGE_OUT(0x2120, 0x80000000 | (1 << 27));
601        IMAGE_OUT(0x2130, patternx);
602        IMAGE_OUT(0x2134, patterny);
603        IMAGE_OUT(0x2150, fg);
604        IMAGE_OUT(0x2154, ~fg);
605    } else {
606        REPLICATE(bg);
607        REPLICATE(fg);
608        IMAGE_OUT(0x2120, 0x80000000 | (1 << 27) | (1 << 26));
609        IMAGE_OUT(0x2130, patternx);
610        IMAGE_OUT(0x2134, patterny);
611        IMAGE_OUT(0x2150, fg);
612        IMAGE_OUT(0x2154, bg);
613    }
614}
615
616static void
617ImageSubsequentMono8x8PatternFillRect(ScrnInfoPtr pScrn,
618                                        int patternx, int patterny,
619                                        int x, int y,
620                                        int w, int h)
621{
622    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
623
624    IMAGE_OUT(0x2108, ((y & 0xfff) << 16) | (x & 0xfff));
625    IMAGE_OUT(0x210C, (((y + h - 1) & 0xfff) << 16) |
626                        ((x + w - 1) & 0xfff));
627    IMAGE_OUT(0x2124, 0x80000000 |
628                        (7 << 18) | (1 << 22) | (1 << 10) | (1 << 9) |
629                        (pTrident->Clipping ? 1 : 0));
630    if (!pTrident->UsePCIRetry)
631        ImageSyncClip(pScrn);
632}
633
634#if 0
635static void
636ImageSetupForColor8x8PatternFill(ScrnInfoPtr pScrn,
637                                    int patternx, int patterny,
638                                    int rop,
639                                    unsigned int planemask,
640                                    int transparency_color)
641{
642    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
643
644    IMAGE_OUT(0x2120, 0x90000000 | XAAGetPatternROP(rop));
645    IMAGE_OUT(0x2120, 0x80000000 | (1 << 26));
646    if (transparency_color != -1) {
647        IMAGE_OUT(0x2120, 0x70000000 |
648                            (1 << 26) |
649                            (transparency_color & 0xffffff));
650        pTrident->DstEnable = TRUE;
651    }
652}
653
654static void
655ImageSubsequentColor8x8PatternFillRect(ScrnInfoPtr pScrn,
656                                        int patternx, int patterny,
657                                        int x, int y,
658                                        int w, int h)
659{
660    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
661
662    IMAGE_OUT(0x2100, ((patterny & 0xfff) << 16) |
663                        (patternx & 0xfff));
664    IMAGE_OUT(0x2104, (((patterny + h - 1) & 0xfff) << 16) |
665                        ((patternx + w - 1) & 0xfff));
666    IMAGE_OUT(0x2108, ((y & 0xfff) << 16) | (x & 0xfff));
667    IMAGE_OUT(0x210C, (((y + h - 1) & 0xfff) << 16) |
668                        ((x + w - 1) & 0xfff));
669    IMAGE_OUT(0x2124, 0x80000000 |
670                        (1 << 22) | (1 << 10) | (1 << 7) |
671                        (pTrident->Clipping ? 1 : 0));
672    if (!pTrident->UsePCIRetry)
673        ImageSyncClip(pScrn);
674}
675#endif
676
677static void
678ImageSetupForScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
679                                                int fg, int bg,
680                                                int rop,
681                                                unsigned int planemask
682){
683    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
684
685    IMAGE_OUT(0x2120, 0x80000000);
686    IMAGE_OUT(0x2120, 0x90000000 | XAAGetCopyROP(rop));
687    if (bg == -1) {
688        pTrident->ROP = (2 << 22);
689        REPLICATE(fg);
690        IMAGE_OUT(0x2144, fg);
691        IMAGE_OUT(0x2148, ~fg);
692    } else {
693        pTrident->ROP = (3 << 22);
694        REPLICATE(fg);
695        IMAGE_OUT(0x2144, fg);
696        REPLICATE(bg);
697        IMAGE_OUT(0x2148, bg);
698    }
699}
700
701static void
702ImageSubsequentScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
703                                                    int x, int y,
704                                                    int w, int h,
705                                                    int skipleft
706){
707    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
708    ImageSetClippingRectangle(pScrn,(x + skipleft), y,
709                                (x + w - 1), (y + h - 1));
710    IMAGE_OUT(0x2108, ((y & 0xfff) << 16) | (x & 0xfff));
711    IMAGE_OUT(0x210C, (((y + h - 1) & 0xfff) << 16) |
712                        ((x + w - 1) & 0xfff));
713    IMAGE_OUT(0x2124, 0x80000000 | (pTrident->ROP) | (1 << 10) | 1);
714    pTrident->dwords = (w + 31) >> 5;
715    pTrident->h = h;
716}
717
718static void
719ImageSubsequentColorExpandScanline(ScrnInfoPtr pScrn, int bufno)
720{
721    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
722    XAAInfoRecPtr infoRec;
723    infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
724
725    MoveDWORDS((CARD32*)infoRec->ImageWriteBase,
726            (CARD32*)pTrident->XAAScanlineColorExpandBuffers[bufno],
727            pTrident->dwords);
728
729    pTrident->h--;
730    if (!pTrident->h)
731        ImageSync(pScrn);
732}
733
734static void
735ImageSetupForScanlineImageWrite(ScrnInfoPtr pScrn,
736                                int rop,
737                                unsigned int planemask,
738                                int transparency_color,
739                                int bpp, int depth)
740{
741    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
742    IMAGE_OUT(0x2120, 0x90000000 | XAAGetCopyROP(rop));
743    if (transparency_color != -1) {
744        IMAGE_OUT(0x2120, 0x70000000 |
745                            (1 << 26) |
746                            (transparency_color & 0xffffff));
747        pTrident->DstEnable = TRUE;
748    }
749
750    IMAGE_OUT(0x2120, 0x80000000);
751}
752
753static void
754ImageSubsequentScanlineImageWriteRect(ScrnInfoPtr pScrn,
755                                        int x, int y,
756                                        int w, int h,
757                                        int skipleft)
758{
759    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
760    ImageSetClippingRectangle(pScrn,
761                                (x + skipleft), y,
762                                (x + w - 1), (y + h - 1));
763    IMAGE_OUT(0x2108, ((y & 0xfff) << 16) | (x & 0xfff));
764    IMAGE_OUT(0x210C, (((y + h - 1) & 0xfff) << 16) |
765                        ((x + w - 1) & 0xfff));
766    IMAGE_OUT(0x2124, 0x80000000 |
767                        (1 << 22) | (1 << 10) | 1);
768    pTrident->dwords = ((w * (pScrn->bitsPerPixel / 8)) + 3) >> 2;
769    pTrident->h = h;
770}
771
772
773static void
774ImageSubsequentImageWriteScanline(ScrnInfoPtr pScrn, int bufno)
775{
776    TRIDENTPtr pTrident = TRIDENTPTR(pScrn);
777    XAAInfoRecPtr infoRec;
778    infoRec = GET_XAAINFORECPTR_FROM_SCRNINFOPTR(pScrn);
779
780    MoveDWORDS((CARD32*)infoRec->ImageWriteBase,
781                (CARD32*)pTrident->XAAImageScanlineBuffer[bufno],
782                pTrident->dwords);
783
784    pTrident->h--;
785    if (!pTrident->h)
786        ImageSync(pScrn);
787}
788#endif
789