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