pnozz_accel.c revision f55eacde 
1/*
2 * SBus Weitek P9100 hardware acceleration support
3 *
4 * Copyright (C) 2005 Michael Lorenz
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
19 * MICHAEL LORENZ BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
20 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22 */
23/* $NetBSD: pnozz_accel.c,v 1.3 2021/05/27 04:48:10 jdc Exp $ */
24
25#ifdef HAVE_CONFIG_H
26#include "config.h"
27#endif
28
29#include "pnozz.h"
30#include "pnozz_regs.h"
31#include "dgaproc.h"
32
33static CARD32 PnozzCopyROP[] = {
34	/*GXclear*/		0,
35	/*GXand*/		ROP_SRC & ROP_DST,
36	/*GXandReverse*/	ROP_SRC & (~ROP_DST),
37	/*GXcopy*/		ROP_SRC,
38	/*GXandInverted*/	(~ROP_SRC) & ROP_DST,
39	/*GXnoop*/		ROP_DST,
40	/*GXxor*/		ROP_SRC ^ ROP_DST,
41	/*GXor*/		ROP_SRC | ROP_DST,
42	/*GXnor*/		(~ROP_SRC) & (~ROP_DST),
43	/*GXequiv*/		(~ROP_SRC) ^ ROP_DST,
44	/*GXinvert*/		(~ROP_DST),
45	/*GXorReverse*/		ROP_SRC | (~ROP_DST),
46	/*GXcopyInverted*/	(~ROP_SRC),
47	/*GXorInverted*/	(~ROP_SRC) | ROP_DST,
48	/*GXnand*/		(~ROP_SRC) | (~ROP_DST),
49	/*GXset*/		ROP_SET
50};
51
52static CARD32 PnozzDrawROP[] = {
53	/*GXclear*/		0,
54	/*GXand*/		ROP_PAT & ROP_DST,
55	/*GXandReverse*/	ROP_PAT & (~ROP_DST),
56	/*GXcopy*/		ROP_PAT,
57	/*GXandInverted*/	(~ROP_PAT) & ROP_DST,
58	/*GXnoop*/		ROP_DST,
59	/*GXxor*/		ROP_PAT ^ ROP_DST,
60	/*GXor*/		ROP_PAT | ROP_DST,
61	/*GXnor*/		(~ROP_PAT) & (~ROP_DST),
62	/*GXequiv*/		(~ROP_PAT) ^ ROP_DST,
63	/*GXinvert*/		(~ROP_DST),
64	/*GXorReverse*/		ROP_PAT | (~ROP_DST),
65	/*GXcopyInverted*/	(~ROP_PAT),
66	/*GXorInverted*/	(~ROP_PAT) | ROP_DST,
67	/*GXnand*/		(~ROP_PAT) | (~ROP_DST),
68	/*GXset*/		ROP_PAT
69};
70
71/* DGA stuff */
72
73static Bool Pnozz_OpenFramebuffer(ScrnInfoPtr pScrn, char **,
74    unsigned char **mem, int *, int *, int *);
75static Bool Pnozz_SetMode(ScrnInfoPtr, DGAModePtr);
76static void Pnozz_SetViewport(ScrnInfoPtr, int, int, int);
77static int Pnozz_GetViewport(ScrnInfoPtr);
78static void Pnozz_FillRect(ScrnInfoPtr, int, int, int, int, unsigned long);
79static void Pnozz_BlitRect(ScrnInfoPtr, int, int, int, int, int, int);
80
81static void PnozzSync(ScrnInfoPtr);
82
83static DGAFunctionRec Pnozz_DGAFuncs = {
84        Pnozz_OpenFramebuffer,
85        NULL,
86        Pnozz_SetMode,
87        Pnozz_SetViewport,
88        Pnozz_GetViewport,
89        PnozzSync,
90        Pnozz_FillRect,
91        Pnozz_BlitRect,
92        NULL
93};
94
95
96CARD32 MaxClip, junk;
97
98void
99PnozzSync(ScrnInfoPtr pScrn)
100{
101    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
102    while((pnozz_read_4(pPnozz, ENGINE_STATUS) &
103        (ENGINE_BUSY | BLITTER_BUSY)) !=0 );
104}
105
106/*
107 * Both the framebuffer and the colour registers are apparently little endian.
108 * For framebuffer accesses we can just turn on byte swapping, for the colour
109 * registers we need to juggle bytes ourselves.
110 */
111
112void
113pnozz_write_colour(PnozzPtr pPnozz, int reg, CARD32 colour)
114{
115    CARD32 c2;
116
117    switch(pPnozz->depthshift)
118    {
119    	case 0:
120	    c2 = (colour << 8 | colour);
121	    pnozz_write_4(pPnozz, reg, c2 << 16 | c2);
122	    break;
123    	case 1:
124    	    c2 = ((colour & 0xff) << 8) | ((colour & 0xff00) >> 8);
125	    c2 |= c2 << 16;
126	    pnozz_write_4(pPnozz, reg, c2);
127	    break;
128    	case 2:
129    	    c2 = ((colour & 0x00ff00ff) << 8) | ((colour & 0xff00ff00) >> 8);
130    	    c2 = (( c2 & 0xffff0000) >> 16) | ((c2 & 0x0000ffff) << 16);
131	    pnozz_write_4(pPnozz, reg, c2);
132	    break;
133    }
134}
135
136static void unClip(PnozzPtr pPnozz)
137{
138    pnozz_write_4(pPnozz, WINDOW_OFFSET, 0);
139    pnozz_write_4(pPnozz, WINDOW_MIN, 0);
140    pnozz_write_4(pPnozz, WINDOW_MAX, MaxClip);
141    pnozz_write_4(pPnozz, BYTE_CLIP_MIN, 0);
142    pnozz_write_4(pPnozz, BYTE_CLIP_MAX, MaxClip);
143}
144
145void
146PnozzInitEngine(PnozzPtr pPnozz)
147{
148    unClip(pPnozz);
149    pnozz_write_4(pPnozz, DRAW_MODE, 0);
150    pnozz_write_4(pPnozz, PLANE_MASK, 0xffffffff);
151    pnozz_write_4(pPnozz, PATTERN0, 0xffffffff);
152    pnozz_write_4(pPnozz, PATTERN1, 0xffffffff);
153    pnozz_write_4(pPnozz, PATTERN2, 0xffffffff);
154    pnozz_write_4(pPnozz, PATTERN3, 0xffffffff);
155}
156
157static void
158PnozzSetupForScreenToScreenCopy(
159    ScrnInfoPtr  pScrn,
160    int          xdir,
161    int          ydir,
162    int          rop,
163    unsigned int planemask,
164    int          TransparencyColour
165)
166{
167    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
168    PnozzSync(pScrn);
169
170    pnozz_write_4(pPnozz, RASTER_OP, (PnozzCopyROP[rop] & 0xff));
171    pnozz_write_4(pPnozz, PLANE_MASK, planemask);
172}
173
174/*
175 * the drawing engine is weird. Even though BLIT and QUAD commands use the
176 * same registers to program coordinates there's an important difference -
177 * horizontal coordinates for QUAD commands are in pixels, for BLIT commands
178 * and the byte clipping registers they're IN BYTES.
179 */
180static void
181PnozzSubsequentScreenToScreenCopy
182(
183    ScrnInfoPtr pScrn,
184    int         xSrc,
185    int         ySrc,
186    int         xDst,
187    int         yDst,
188    int         w,
189    int         h
190)
191{
192    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
193    CARD32 src, dst, srcw, dstw;
194
195    src = (((xSrc << pPnozz->depthshift) & 0x1fff) << 16) | (ySrc & 0x1fff);
196    dst = (((xDst << pPnozz->depthshift) & 0x1fff) << 16) | (yDst & 0x1fff);
197    srcw = ((((xSrc + w) << pPnozz->depthshift) - 1) << 16) |
198        ((ySrc + h - 1) & 0x1fff);
199    dstw = ((((xDst + w) << pPnozz->depthshift) - 1) << 16) |
200        ((yDst + h - 1) & 0x1fff);
201
202    PnozzSync(pScrn);
203
204    pnozz_write_4(pPnozz, ABS_XY0, src);
205    pnozz_write_4(pPnozz, ABS_XY1, srcw);
206    pnozz_write_4(pPnozz, ABS_XY2, dst);
207    pnozz_write_4(pPnozz, ABS_XY3, dstw);
208    junk = pnozz_read_4(pPnozz, COMMAND_BLIT);
209}
210
211static void
212PnozzSetupForSolidFill
213(
214    ScrnInfoPtr  pScrn,
215    int          colour,
216    int          rop,
217    unsigned int planemask
218)
219{
220    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
221    CARD32 c2;
222
223    PnozzSync(pScrn);
224
225    pnozz_write_colour(pPnozz, FOREGROUND_COLOR, colour);
226    pnozz_write_4(pPnozz, RASTER_OP, PnozzDrawROP[rop] & 0xff);
227    pnozz_write_4(pPnozz, PLANE_MASK, planemask);
228    pnozz_write_4(pPnozz, COORD_INDEX, 0);
229}
230
231static void
232PnozzSubsequentSolidFillRect
233(
234    ScrnInfoPtr pScrn,
235    int         x,
236    int         y,
237    int         w,
238    int         h
239)
240{
241    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
242
243    PnozzSync(pScrn);
244    pnozz_write_4(pPnozz, RECT_RTW_XY, ((x & 0x1fff) << 16) |
245        (y & 0x1fff));
246    pnozz_write_4(pPnozz, RECT_RTP_XY, (((w & 0x1fff) << 16) |
247        (h & 0x1fff)));
248    junk = pnozz_read_4(pPnozz, COMMAND_QUAD);
249}
250
251#ifdef HAVE_XAA_H
252
253static void
254PnozzSetupForCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
255        		int fg, int bg,
256			int rop,
257			unsigned int planemask)
258{
259    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
260
261    PnozzSync(pScrn);
262
263    if (bg == -1) {
264    	/* transparent */
265	pnozz_write_colour(pPnozz, FOREGROUND_COLOR, fg);
266	pnozz_write_4(pPnozz, RASTER_OP, PnozzDrawROP[rop] | ROP_PIX1_TRANS);
267    } else {
268	/*
269	 * this doesn't make any sense to me either, but for some reason the
270	 * chip applies the foreground colour to 0 pixels and background to 1
271	 * when set to this sort of ROP. The old XF 3.3 driver source claimed
272	 * that the chip doesn't support opaque colour expansion at all.
273	 */
274	pnozz_write_colour(pPnozz, FOREGROUND_COLOR, bg);
275	pnozz_write_colour(pPnozz, BACKGROUND_COLOR, fg);
276
277	pnozz_write_4(pPnozz, RASTER_OP, PnozzCopyROP[rop] & 0xff);
278    }
279
280    pnozz_write_4(pPnozz, PLANE_MASK, planemask);
281    pnozz_write_4(pPnozz, COORD_INDEX, 0);
282}
283
284static void
285PnozzSubsequentScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
286			int x, int y, int w, int h,
287			int skipleft )
288{
289    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
290    CARD32 rest = w & 0x1f;
291
292    pnozz_write_4(pPnozz, ABS_X0, x);
293    pnozz_write_4(pPnozz, ABS_XY1, (x << 16) | (y & 0xFFFFL));
294    pnozz_write_4(pPnozz, ABS_X2, (x + w));
295    pnozz_write_4(pPnozz, ABS_Y3, 1);
296
297    pPnozz->words = (w >> 5);	/* whole words to write */
298
299    if (rest > 0) {
300    	pPnozz->last_word = (rest - 1) << 2;
301    } else
302    	pPnozz->last_word = -1;
303}
304
305static void
306PnozzSubsequentColorExpandScanline(ScrnInfoPtr pScrn, int bufno)
307{
308    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
309#define PIXEL_1_FULL (PIXEL_1 + (31 << 2))
310    CARD32 *buf;
311    volatile CARD32 *pix = ((volatile CARD32 *)(pPnozz->fbc + PIXEL_1_FULL));
312    int i = 0;
313
314    PnozzSync(pScrn);
315    buf = (CARD32 *)pPnozz->buffers[bufno];
316    junk = *(volatile CARD32 *)(pPnozz->fb + PIXEL_1_FULL);
317    for (i = 0; i < pPnozz->words; i++)
318	*pix = buf[i];
319    if (pPnozz->last_word >= 0)
320    	*(volatile CARD32 *)(pPnozz->fbc + PIXEL_1 + pPnozz->last_word) =
321    	    buf[i];
322}
323
324static void
325PnozzSetupForSolidLine(ScrnInfoPtr pScrn, int color, int rop,
326    unsigned int planemask)
327{
328    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
329
330    PnozzSync(pScrn);
331
332    pnozz_write_colour(pPnozz, FOREGROUND_COLOR, color);
333    pnozz_write_4(pPnozz, RASTER_OP, (PnozzDrawROP[rop] & 0xff) | ROP_OVERSIZE);
334
335    pnozz_write_4(pPnozz, PLANE_MASK, planemask);
336    pnozz_write_4(pPnozz, COORD_INDEX, 0);
337
338}
339
340static void
341PnozzSubsequentSolidTwoPointLine(ScrnInfoPtr pScrn, int x1, int y1, int x2,
342    int y2, int flags)
343{
344    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
345
346    PnozzSync(pScrn);
347
348    /*
349     * XXX we're blatantly ignoring the flags parameter which could tell us not
350     * to draw the last point. Xsun simply reads it from the framebuffer and
351     * puts it back after drawing the line but that would mean we have to wait
352     * until the line is actually drawn. On the other hand - line drawing is
353     * pretty fast so we won't lose too much speed
354     */
355    pnozz_write_4(pPnozz, LINE_RTW_XY, (x1 << 16) | y1);
356    pnozz_write_4(pPnozz, LINE_RTW_XY, (x2 << 16) | y2);
357    junk = pnozz_read_4(pPnozz, COMMAND_QUAD);
358}
359
360static void
361PnozzSetupForMono8x8PatternFill(ScrnInfoPtr pScrn, int pat0, int pat1,
362        int fg, int bg, int rop, unsigned int planemask)
363{
364    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
365    CARD32 pat;
366
367    PnozzSync(pScrn);
368
369    if (bg == -1) {
370	pnozz_write_4(pPnozz, RASTER_OP,
371	    (PnozzDrawROP[rop] & 0xff) | ROP_NO_SOLID | ROP_TRANS);
372    } else {
373        pnozz_write_colour(pPnozz, COLOR_0, bg);
374        pnozz_write_4(pPnozz, RASTER_OP,
375            (PnozzDrawROP[rop] & 0xff) | ROP_NO_SOLID);
376    }
377    pnozz_write_colour(pPnozz, COLOR_1, fg);
378    pnozz_write_4(pPnozz, PLANE_MASK, planemask);
379    pat = (pat0 & 0xff000000) | ((pat0 >> 8) & 0x00ffff00) |
380        ((pat0 >> 16) & 0x000000ff);
381    pnozz_write_4(pPnozz, PATTERN0, pat);
382    pat = ((pat0 << 8) & 0x00ffff00) | ((pat0 << 16) & 0xff000000) |
383        (pat0 & 0x000000ff);
384    pnozz_write_4(pPnozz, PATTERN1, pat);
385    pat = (pat1 & 0xff000000) | ((pat1 >> 8) & 0x00ffff00) |
386        ((pat1 >> 16) & 0x000000ff);
387    pnozz_write_4(pPnozz, PATTERN2, pat);
388    pat = ((pat1 << 8) & 0x00ffff00) | ((pat1 << 16) & 0xff000000) |
389        (pat1 & 0x000000ff);
390    pnozz_write_4(pPnozz, PATTERN3, pat);
391    pnozz_write_4(pPnozz, COORD_INDEX, 0);
392}
393
394static void
395PnozzSubsequentMono8x8PatternFillRect(ScrnInfoPtr pScrn,
396        	int patx, int paty, int x, int y, int w, int h)
397{
398    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
399
400    PnozzSync(pScrn);
401    pnozz_write_4(pPnozz, PATTERN_ORIGIN_X, patx);
402    pnozz_write_4(pPnozz, PATTERN_ORIGIN_Y, paty);
403    pnozz_write_4(pPnozz, RECT_RTW_XY, ((x & 0x1fff) << 16) |
404        (y & 0x1fff));
405    pnozz_write_4(pPnozz, RECT_RTP_XY, (((w & 0x1fff) << 16) |
406        (h & 0x1fff)));
407    junk = pnozz_read_4(pPnozz, COMMAND_QUAD);
408
409}
410
411static void
412PnozzSetClippingRectangle(ScrnInfoPtr pScrn, int left, int top, int right,
413			 int bottom)
414{
415    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
416    CARD32 cmin, cmax;
417
418    cmin = (left << 16) | top;
419    cmax = (right << 16) | bottom;
420
421    pnozz_write_4(pPnozz, WINDOW_MIN, cmin);
422    pnozz_write_4(pPnozz, WINDOW_MAX, cmax);
423
424    cmin = ((left << pPnozz->depthshift) << 16) | top;
425    cmax = ((right << pPnozz->depthshift) << 16) | bottom;
426
427    pnozz_write_4(pPnozz, BYTE_CLIP_MIN, cmin);
428    pnozz_write_4(pPnozz, BYTE_CLIP_MAX, cmax);
429}
430
431static void
432PnozzDisableClipping(ScrnInfoPtr pScrn)
433{
434    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
435
436    pnozz_write_4(pPnozz, WINDOW_MIN, 0);
437    pnozz_write_4(pPnozz, WINDOW_MAX, MaxClip);
438    pnozz_write_4(pPnozz, BYTE_CLIP_MIN, 0);
439    pnozz_write_4(pPnozz, BYTE_CLIP_MAX, MaxClip);
440}
441
442static void
443PnozzSetupForImageWrite(ScrnInfoPtr pScrn, int rop, unsigned int planemask,
444  int trans_color, int depth, int bpp)
445{
446    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
447
448    pnozz_write_4(pPnozz, RASTER_OP, PnozzCopyROP[rop] & 0xff);
449    pnozz_write_4(pPnozz, PLANE_MASK, planemask);
450    pnozz_write_4(pPnozz, COORD_INDEX, 0);
451
452    xf86Msg(X_ERROR, "setup for image write\n");
453}
454
455static void
456PnozzImageWriteRect(ScrnInfoPtr pScrn, int x, int y, int wi, int he, int skip)
457{
458    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
459    volatile CARD32 junk;
460
461    pnozz_write_4(pPnozz, ABS_X0, x);
462    pnozz_write_4(pPnozz, ABS_XY1, (x << 16) | y);
463    pnozz_write_4(pPnozz, ABS_X2, x + wi);
464    pnozz_write_4(pPnozz, ABS_Y3, 1);
465    junk = *(volatile CARD32 *)(pPnozz->fb + PIXEL_8);
466}
467
468/*
469 * TODO:
470 * - CPU to VRAM colour blits
471 */
472
473int
474PnozzAccelInit(ScrnInfoPtr pScrn)
475{
476    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
477    XAAInfoRecPtr pXAAInfo = pPnozz->pXAA;
478
479    pXAAInfo->Flags = LINEAR_FRAMEBUFFER | PIXMAP_CACHE | OFFSCREEN_PIXMAPS;
480    pXAAInfo->maxOffPixWidth = pPnozz->width;
481    pXAAInfo->maxOffPixHeight = pPnozz->maxheight;
482    MaxClip = ((pPnozz->scanlinesize & 0xffff) << 16) | (pPnozz->maxheight);
483
484    PnozzInitEngine(pPnozz);
485
486#if 1
487    {
488	CARD32 src, srcw, junk;
489	src = 0;
490	srcw = pPnozz->width << 16 | pPnozz->height;
491
492	/* Blit the screen black. For aesthetic reasons. */
493
494	PnozzSync(pScrn);
495	pnozz_write_4(pPnozz, FOREGROUND_COLOR, 0x00000000);
496	pnozz_write_4(pPnozz, BACKGROUND_COLOR, 0xffffffff);
497	pnozz_write_4(pPnozz, RASTER_OP, ROP_PAT);
498	pnozz_write_4(pPnozz, COORD_INDEX, 0);
499	pnozz_write_4(pPnozz, RECT_RTW_XY, src);
500	pnozz_write_4(pPnozz, RECT_RTW_XY, srcw);
501	junk = pnozz_read_4(pPnozz, COMMAND_QUAD);
502	PnozzSync(pScrn);
503    }
504#endif
505
506    /* Sync */
507    pXAAInfo->Sync = PnozzSync;
508
509    /* Screen-to-screen copy */
510    pXAAInfo->ScreenToScreenCopyFlags = NO_TRANSPARENCY;
511    pXAAInfo->SetupForScreenToScreenCopy = PnozzSetupForScreenToScreenCopy;
512    pXAAInfo->SubsequentScreenToScreenCopy =
513        PnozzSubsequentScreenToScreenCopy;
514
515    /* Solid fills */
516    pXAAInfo->SetupForSolidFill = PnozzSetupForSolidFill;
517    pXAAInfo->SubsequentSolidFillRect = PnozzSubsequentSolidFillRect;
518
519    /* colour expansion */
520    pXAAInfo->ScanlineCPUToScreenColorExpandFillFlags =
521	/*LEFT_EDGE_CLIPPING|*/SCANLINE_PAD_DWORD;
522    pXAAInfo->NumScanlineColorExpandBuffers = 2;
523    pPnozz->buffers[0] = (unsigned char *)pPnozz->Buffer;
524    pPnozz->buffers[1] = (unsigned char *)&pPnozz->Buffer[pPnozz->scanlinesize];
525    pXAAInfo->ScanlineColorExpandBuffers = pPnozz->buffers;
526    pXAAInfo->SetupForScanlineCPUToScreenColorExpandFill =
527	PnozzSetupForCPUToScreenColorExpandFill;
528    pXAAInfo->SubsequentScanlineCPUToScreenColorExpandFill =
529	PnozzSubsequentScanlineCPUToScreenColorExpandFill;
530    pXAAInfo->SubsequentColorExpandScanline =
531	PnozzSubsequentColorExpandScanline;
532
533    /* line drawing */
534    pXAAInfo->SetupForSolidLine = PnozzSetupForSolidLine;
535    pXAAInfo->SubsequentSolidTwoPointLine = PnozzSubsequentSolidTwoPointLine;
536    pXAAInfo->SolidLineFlags = BIT_ORDER_IN_BYTE_MSBFIRST;
537
538    /* clipping */
539    pXAAInfo->SetClippingRectangle = PnozzSetClippingRectangle;
540    pXAAInfo->DisableClipping = PnozzDisableClipping;
541    pXAAInfo->ClippingFlags = HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY |
542        HARDWARE_CLIP_SOLID_FILL |
543        HARDWARE_CLIP_MONO_8x8_FILL |
544        /*HARDWARE_CLIP_COLOR_8x8_FILL |*/
545        HARDWARE_CLIP_SOLID_LINE;
546
547    /* 8x8 mono pattern fills */
548    pXAAInfo->Mono8x8PatternFillFlags = HARDWARE_PATTERN_PROGRAMMED_BITS |
549        HARDWARE_PATTERN_SCREEN_ORIGIN | HARDWARE_PATTERN_PROGRAMMED_ORIGIN;
550    pXAAInfo->SetupForMono8x8PatternFill = PnozzSetupForMono8x8PatternFill;
551    pXAAInfo->SubsequentMono8x8PatternFillRect =
552        PnozzSubsequentMono8x8PatternFillRect;
553
554    /* image uploads */
555    pXAAInfo->ImageWriteBase = pPnozz->fbc + PIXEL_8;
556    pXAAInfo->ImageWriteRange = 4;
557    pXAAInfo->ImageWriteFlags = /*CPU_TRANSFER_BASE_FIXED |*/ CPU_TRANSFER_PAD_DWORD |
558        NO_TRANSPARENCY;
559    pXAAInfo->SetupForImageWrite = PnozzSetupForImageWrite;
560    pXAAInfo->SubsequentImageWriteRect = PnozzImageWriteRect;
561
562    return 0;
563}
564
565#endif /* HAVE_XAA_H */
566
567Bool
568PnozzDGAInit(ScreenPtr pScreen)
569{
570    ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
571    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
572    DGAModePtr mode;
573    int result;
574
575    mode = xnfcalloc(sizeof(DGAModeRec), 1);
576    if (mode == NULL) {
577        xf86Msg(X_WARNING, "%s: DGA setup failed, cannot allocate memory\n",
578            pPnozz->psdp->device);
579        return FALSE;
580    }
581
582    mode->mode = pScrn->modes;
583    mode->flags = DGA_PIXMAP_AVAILABLE | DGA_CONCURRENT_ACCESS;
584    if(!pPnozz->NoAccel) {
585        mode->flags |= DGA_FILL_RECT | DGA_BLIT_RECT;
586    }
587
588    mode->imageWidth = mode->pixmapWidth = mode->viewportWidth =
589	pScrn->virtualX;
590    mode->imageHeight = mode->pixmapHeight = mode->viewportHeight =
591	pScrn->virtualY;
592
593    mode->bytesPerScanline = mode->imageWidth;
594
595    mode->byteOrder = pScrn->imageByteOrder;
596    mode->depth = 8;
597    mode->bitsPerPixel = 8;
598    mode->red_mask = pScrn->mask.red;
599    mode->green_mask = pScrn->mask.green;
600    mode->blue_mask = pScrn->mask.blue;
601
602    mode->visualClass = PseudoColor;
603    mode->address = pPnozz->fb;
604
605    result = DGAInit(pScreen, &Pnozz_DGAFuncs, mode, 1);
606
607    if (result) {
608	xf86Msg(X_INFO, "%s: DGA initialized\n",
609            pPnozz->psdp->device);
610	return TRUE;
611    } else {
612	xf86Msg(X_WARNING, "%s: DGA setup failed\n",
613            pPnozz->psdp->device);
614	return FALSE;
615    }
616}
617
618static Bool
619Pnozz_OpenFramebuffer(ScrnInfoPtr pScrn, char **name,
620				unsigned char **mem,
621				int *size, int *offset,
622				int *extra)
623{
624    PnozzPtr pPnozz = GET_PNOZZ_FROM_SCRN(pScrn);
625
626    *name = pPnozz->psdp->device;
627
628    *mem = (unsigned char*)0;
629    *size = pPnozz->vidmem;
630    *offset = 0;
631    *extra = 0;
632
633    return TRUE;
634}
635
636static Bool
637Pnozz_SetMode(ScrnInfoPtr pScrn, DGAModePtr pMode)
638{
639    /*
640     * Nothing to do, we currently only support one mode
641     * and we are always in it.
642     */
643    return TRUE;
644}
645
646static void
647Pnozz_SetViewport(ScrnInfoPtr pScrn, int x, int y, int flags)
648{
649     /* We don't support viewports, so... */
650}
651
652static int
653Pnozz_GetViewport(ScrnInfoPtr pScrn)
654{
655    /* No viewports, none pending... */
656    return 0;
657}
658
659static void
660Pnozz_FillRect(ScrnInfoPtr pScrn, int x, int y, int w, int h, unsigned long color)
661{
662
663    PnozzSetupForSolidFill(pScrn, color, GXset, 8);
664    PnozzSubsequentSolidFillRect(pScrn, x, y, w, h);
665}
666
667static void
668Pnozz_BlitRect(ScrnInfoPtr pScrn, int srcx, int srcy,
669			 int w, int h, int dstx, int dsty)
670{
671
672    PnozzSetupForScreenToScreenCopy(pScrn, 0, 0, GXcopy, 8, 0);
673    PnozzSubsequentScreenToScreenCopy(pScrn, srcx, srcy, dstx, dsty, w, h);
674}
675