1 /*
2 * file accelX.c
3 *
4 * accelerator functions for X
5 */
6
7 #ifdef HAVE_CONFIG_H
8 #include "config.h"
9 #endif
10
11 /*
12 * includes
13 */
14
15 #include "rendition.h"
16 #include "accel.h"
17 #include "vboard.h"
18 #include "vmodes.h"
19 #include "vos.h"
20 #include "v1kregs.h"
21 #include "v1krisc.h"
22 #include "v2kregs.h"
23 #include "cmd2d.h"
24 #include "vloaduc.h"
25
26 #undef DEBUG
27
28 /*
29 * defines
30 */
31
32 #define waitfifo(size) do { int _c=0; \
33 while ((_c++<0xfffff)&&((verite_in8(iob+FIFOINFREE)&0x1f)<size)) /* if(!(_c%0xffff))ErrorF("#1# !0x%x! -- ",verite_in8(iob+FIFOINFREE)) */; \
34 if (_c >= 0xfffff) { \
35 ErrorF("RENDITION: Input fifo full (1) FIFO in == %d\n",verite_in8(iob+FIFOINFREE)&0x1f); \
36 return; \
37 } \
38 } while (0)
39
40 #define waitfifo2(size, rv) do { int _c=0; \
41 while ((_c++<0xfffff)&&((verite_in8(iob+FIFOINFREE)&0x1f)<size)) /* if(!(_c%0xffff))ErrorF("#2# !0x%x! -- ",verite_in8(iob+FIFOINFREE)) */; \
42 if (_c >= 0xfffff) { \
43 ErrorF("RENDITION: Input fifo full (2) FIFO in ==%d\n",verite_in8(iob+FIFOINFREE)&0x1f); \
44 RENDITIONAccelNone(pScreenInfo); \
45 pRendition->board.accel=0; \
46 return rv; \
47 } \
48 } while (0)
49
50 #define P1(x) ((vu32)x)
51 #define P2(x, y) ((((vu16)x)<<16)+((vu16)y))
52
53 /*
54 * local function prototypes
55 */
56
57 void RENDITIONSaveUcode(ScrnInfoPtr pScreenInfo);
58 void RENDITIONRestoreUcode(ScrnInfoPtr pScreenInfo);
59
60 void RENDITIONSyncV1000(ScrnInfoPtr pScreenInfo);
61
62 void RENDITIONSetupForScreenToScreenCopy(ScrnInfoPtr pScreenInfo,
63 int xdir, int ydir, int rop,
64 unsigned int planemask,
65 int trans_color);
66
67 void RENDITIONSubsequentScreenToScreenCopy(ScrnInfoPtr pScreenInfo,
68 int srcX, int srcY,
69 int dstX, int dstY,
70 int w, int h);
71
72
73 void RENDITIONSetupForSolidFill(ScrnInfoPtr pScreenInfo,
74 int color, int rop,
75 unsigned int planemask);
76
77
78 void RENDITIONSubsequentSolidFillRect(ScrnInfoPtr pScreenInfo,
79 int x, int y, int w, int h);
80
81
82 void RENDITIONSubsequentTwoPointLine(ScrnInfoPtr pScreenInfo,
83 int x1, int y1,
84 int x2, int y2,
85 int bias);
86
87
88 /*
89 * global data
90 */
91
92 static int Rop2Rop[]={
93 ROP_ALLBITS0, ROP_AND_SD, ROP_AND_SND, ROP_S,
94 /* GXclear, GXand, GXandReverse, GXcopy, */
95 ROP_AND_NSD, ROP_D, ROP_XOR_SD, ROP_OR_SD,
96 /* GXandInverted, GXnoop, GXxor, GXor, */
97 ROP_NOR_SD, ROP_S, ROP_NOT_D, ROP_NOT_S,
98 /* suppose I have some problems understanding what invert and revers means <ml>
99 ROP_NOR_SD, ROP_S, ROP_NOT_S, ROP_NOT_D, */
100 /* GXnor, GXequiv, GXinvert, GXorReverse, */
101 ROP_NOT_S, ROP_XNOR_SD, ROP_NAND_SD, ROP_ALLBITS1 };
102 /* GXcopyInverted, GXorInverted, GXnand, GXset */
103
104
105
106 /*
107 * functions
108 */
109
110 void
RENDITIONAccelPreInit(ScrnInfoPtr pScreenInfo)111 RENDITIONAccelPreInit(ScrnInfoPtr pScreenInfo)
112 {
113 renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
114
115 #ifdef DEBUG
116 ErrorF("RENDITION: RENDITIONAccelPreInit called\n");
117 sleep(1);
118 #endif
119 #if 1
120 if (RENDITIONLoadUcode(pScreenInfo)){
121 ErrorF ("RENDITION: AccelPreInit - Warning. Loading of microcode failed!!\n");
122 }
123 #endif
124 pRendition->board.fbOffset += MC_SIZE;
125
126 #ifdef DEBUG
127 ErrorF("RENDITION: Offset is now %d\n",pRendition->board.fbOffset);
128 sleep(2);
129 #endif
130
131 }
132
133 void
RENDITIONAccelXAAInit(ScreenPtr pScreen)134 RENDITIONAccelXAAInit(ScreenPtr pScreen)
135 {
136 ScrnInfoPtr pScreenInfo = xf86ScreenToScrn(pScreen);
137 renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
138 XAAInfoRecPtr pXAAinfo;
139
140 BoxRec AvailFBArea;
141
142 #ifdef DEBUG
143 ErrorF("RENDITION: RENDITIONAccelInit called\n");
144 sleep(2);
145 #endif
146
147 pRendition->AccelInfoRec = pXAAinfo = XAACreateInfoRec();
148
149 if(!pXAAinfo){
150 xf86DrvMsg(pScreenInfo->scrnIndex,X_ERROR,
151 ("Failed to set up XAA structure!\n"));
152 return;
153 }
154
155 /* Here we fill in the XAA callback names */
156 /* Sync is the only compulsary function */
157 pXAAinfo->Sync = RENDITIONSyncV1000;
158
159 /* Here are the other functions & flags */
160 pXAAinfo->Flags=DO_NOT_BLIT_STIPPLES|
161 LINEAR_FRAMEBUFFER|
162 PIXMAP_CACHE|
163 OFFSCREEN_PIXMAPS;
164
165 /* screen to screen copy */
166 #if 1
167 pXAAinfo->CopyAreaFlags=NO_TRANSPARENCY|
168 ONLY_TWO_BITBLT_DIRECTIONS;
169 pXAAinfo->SetupForScreenToScreenCopy=
170 RENDITIONSetupForScreenToScreenCopy;
171 pXAAinfo->SubsequentScreenToScreenCopy=
172 RENDITIONSubsequentScreenToScreenCopy;
173 #endif
174
175 #if 0
176 /* solid filled rectangles */
177 pXAAinfo->SetupForSolidFill=
178 RENDITIONSetupForSolidFill;
179 pXAAinfo->SubsequentSolidFillRect=
180 RENDITIONSubsequentSolidFillRect;
181
182 /* line */
183 xf86AccelInfoRec.SubsequentTwoPointLine =
184 RENDITIONSubsequentTwoPointLine;
185 #endif /* #if 0 */
186
187 verite_check_csucode(pScreenInfo);
188
189 if (RENDITIONLoadUcode(pScreenInfo)) return;
190 if (RENDITIONInitUcode(pScreenInfo)) return;
191
192 verite_check_csucode(pScreenInfo);
193
194 /* the remaining code was copied from s3verite_accel.c.
195 * we need to check it if it is suitable <ml> */
196
197 /* make sure offscreen pixmaps aren't bigger than our address space */
198 pXAAinfo->maxOffPixWidth = 2048;
199 pXAAinfo->maxOffPixHeight = 2048;
200
201
202 /*
203 * Finally, we set up the video memory space available to the pixmap
204 * cache. In this case, all memory from the end of the virtual screen to
205 * the end of video memory minus 64K (and any other memory which we
206 * already reserved like HW-Cursor), can be used.
207 */
208
209 pXAAinfo->PixmapCacheFlags = DO_NOT_BLIT_STIPPLES;
210 AvailFBArea.x1 = 0;
211 AvailFBArea.y1 = 0;
212 AvailFBArea.x2 = pScreenInfo->displayWidth;
213 AvailFBArea.y2 = (((pScreenInfo->videoRam*1024) -
214 pRendition->board.fbOffset) /
215 ((pScreenInfo->displayWidth * pScreenInfo->bitsPerPixel)
216 / 8));
217 xf86InitFBManager(pScreen, &AvailFBArea);
218
219 XAAInit(pScreen, pXAAinfo);
220
221 pRendition->board.accel=1;
222
223 #ifdef DEBUG
224 ErrorF("RENDITION: RENDITIONAccelInit End\n");
225 sleep(2);
226 #endif
227 }
228
229
230
231 void
RENDITIONAccelNone(ScrnInfoPtr pScreenInfo)232 RENDITIONAccelNone(ScrnInfoPtr pScreenInfo)
233 {
234 renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
235 XAAInfoRecPtr pXAAinfo=pRendition->AccelInfoRec;
236
237 #ifdef DEBUG
238 ErrorF("RENDITION: RENDITIONAccelNone called\n");
239 #endif
240 pXAAinfo->Flags=0;
241 pXAAinfo->Sync=NULL;
242 pXAAinfo->SetupForScreenToScreenCopy=NULL;
243 pXAAinfo->SubsequentScreenToScreenCopy=NULL;
244 pXAAinfo->SetupForSolidFill=NULL;
245 pXAAinfo->SubsequentSolidFillRect=NULL;
246
247 #if 0
248 pXAAinfo->SubsequentTwoPointLine=NULL;
249 #endif
250
251 XAADestroyInfoRec(pRendition->AccelInfoRec);
252 pRendition->AccelInfoRec=NULL;
253 }
254
255
256
257 int
RENDITIONLoadUcode(ScrnInfoPtr pScreenInfo)258 RENDITIONLoadUcode(ScrnInfoPtr pScreenInfo)
259 {
260 renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
261
262 static int ucode_loaded=0;
263
264 #ifdef DEBUG
265 ErrorF("RENDITION: RENDITIONLoadUcode called\n");
266 #endif
267
268 /* load or restore ucode */
269 if (!ucode_loaded) {
270 if (0 != verite_initboard(pScreenInfo)) {
271 RENDITIONAccelNone(pScreenInfo);
272 pRendition->board.accel=0;
273 return 1;
274 }
275 RENDITIONSaveUcode(pScreenInfo);
276 }
277 else
278 RENDITIONRestoreUcode(pScreenInfo);
279
280 ErrorF ("Rendition: Ucode successfully %s\n",
281 (ucode_loaded ? "restored" : "loaded"));
282
283 ucode_loaded=1;
284 return 0;
285 }
286
287
288 int
RENDITIONInitUcode(ScrnInfoPtr pScreenInfo)289 RENDITIONInitUcode(ScrnInfoPtr pScreenInfo)
290 {
291 renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
292 unsigned long iob = pRendition->board.io_base;
293
294 if (0 == verite_getstride(pScreenInfo, NULL,
295 &pRendition->board.mode.stride0,
296 &pRendition->board.mode.stride1)) {
297 xf86DrvMsg(pScreenInfo->scrnIndex,X_ERROR,
298 ("Acceleration for this resolution not available\n"));
299 RENDITIONAccelNone(pScreenInfo);
300 pRendition->board.accel=0;
301 return 1;
302 }
303 else
304 ErrorF ("Rendition: Stride 0: %d, stride 1: %d\n",
305 pRendition->board.mode.stride0,
306 pRendition->board.mode.stride1);
307
308 /* NOTE: for 1152x864 only!
309 stride0=6;
310 stride1=1;
311 */
312
313 #ifdef DEBUG
314 ErrorF("#InitUcode(1)# FIFOIN_FREE 0x%x -- \n",verite_in8(iob+FIFOINFREE));
315 #endif
316
317 /* init the ucode */
318
319 /* ... and start accelerator */
320 v1k_flushicache(pScreenInfo);
321 v1k_start(pScreenInfo, pRendition->board.csucode_base);
322
323 #ifdef DEBUG
324 ErrorF("#InitUcode(2)# FIFOIN_FREE 0x%x -- \n",verite_in8(iob+FIFOINFREE));
325 #endif
326
327 verite_out32(iob, 0); /* a0 - ucode init command */
328 verite_out32(iob, 0); /* a1 - 1024 byte context store area */
329 verite_out32(iob, 0); /* a2 */
330 verite_out32(iob, pRendition->board.ucode_entry);
331
332 #ifdef DEBUG
333 ErrorF("#InitUcode(3)# FIFOIN_FREE 0x%x -- \n",verite_in8(iob+FIFOINFREE));
334 #endif
335
336 waitfifo2(6, 1);
337
338 #ifdef DEBUG
339 ErrorF("#InitUcode(4)# FIFOIN_FREE 0x%x -- \n",verite_in8(iob+FIFOINFREE));
340 #endif
341
342 verite_out32(iob, CMD_SETUP);
343 verite_out32(iob, P2(pRendition->board.mode.virtualwidth,
344 pRendition->board.mode.virtualheight));
345 verite_out32(iob, P2(pRendition->board.mode.bitsperpixel,
346 pRendition->board.mode.pixelformat));
347 verite_out32(iob, MC_SIZE);
348
349 verite_out32(iob, (pRendition->board.mode.virtualwidth)*
350 (pRendition->board.mode.bitsperpixel>>3));
351 verite_out32(iob, (pRendition->board.mode.stride1<<12)|
352 (pRendition->board.mode.stride0<<8));
353
354 #ifdef DEBUG
355 ErrorF("#InitUcode(5)# FIFOIN_FREE 0x%x -- \n",verite_in8(iob+FIFOINFREE));
356 #endif
357
358 #if 0
359 verite_out32(iob+0x60, 129);
360 ErrorF("RENDITION: PC at %x\n", verite_in32(iob+0x64));
361 #endif
362
363 return 0;
364 }
365
366 void
RENDITIONRestoreUcode(ScrnInfoPtr pScreenInfo)367 RENDITIONRestoreUcode(ScrnInfoPtr pScreenInfo)
368 {
369 renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
370 unsigned long iob = pRendition->board.io_base;
371
372 vu8 memend;
373
374 #ifdef DEBUG
375 ErrorF("RENDITION: RENDITIONRestoreUcode called\n");
376 #endif
377
378 #ifdef DEBUG
379 ErrorF("Restore...1\n");
380 sleep(2);
381 #endif
382
383 v1k_stop(pScreenInfo);
384 memend=verite_in8(iob+MEMENDIAN);
385 verite_out8(iob+MEMENDIAN, MEMENDIAN_NO);
386 #if 1
387 memcpy(pRendition->board.vmem_base, pRendition->board.ucode_buffer, MC_SIZE);
388 #else
389 /* SlowBcopy has inverted src and dst */
390 xf86SlowBcopy(pRendition->board.ucode_buffer,pRendition->board.vmem_base,MC_SIZE);
391 #endif
392 verite_out8(iob+MEMENDIAN, memend);
393
394 v1k_flushicache(pScreenInfo);
395 v1k_start(pScreenInfo, pRendition->board.csucode_base);
396 verite_out32(iob, 0); /* a0 - ucode init command */
397 verite_out32(iob, 0); /* a1 - 1024 byte context store area */
398 verite_out32(iob, 0); /* a2 */
399 verite_out32(iob, pRendition->board.ucode_entry);
400
401 #if 0
402 verite_out32(iob+0x60, 129);
403 ErrorF("RENDITION: PC at %x\n", verite_in32(iob+0x64));
404 #endif
405 }
406
407
408
409 void
RENDITIONSaveUcode(ScrnInfoPtr pScreenInfo)410 RENDITIONSaveUcode(ScrnInfoPtr pScreenInfo)
411 {
412 renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
413 unsigned long iob = pRendition->board.io_base;
414 vu8 memend;
415
416 #ifdef DEBUG
417 ErrorF("RENDITION: RENDITIONSaveUcode called\n");
418 sleep(2);
419 #endif
420
421 v1k_stop(pScreenInfo);
422 memend=verite_in8(iob+MEMENDIAN);
423 verite_out8(iob+MEMENDIAN, MEMENDIAN_NO);
424
425 #if 1
426 memcpy(pRendition->board.ucode_buffer, pRendition->board.vmem_base, MC_SIZE);
427 #else
428 /* SlowBcopy has inverted src and dst */
429 xf86SlowBcopy(pRendition->board.vmem_base,pRendition->board.ucode_buffer,MC_SIZE);
430 #endif
431 verite_out8(iob+MEMENDIAN, memend);
432 v1k_continue(pScreenInfo);
433 }
434
435
436
437 /*
438 * local functions
439 */
440
441 /*
442 * synchronization -- wait for RISC and pixel engine to become idle
443 */
444 void
RENDITIONSyncV1000(ScrnInfoPtr pScreenInfo)445 RENDITIONSyncV1000(ScrnInfoPtr pScreenInfo)
446 {
447 renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
448 unsigned long iob = pRendition->board.io_base;
449
450 int c;
451
452 #ifdef DEBUG
453 ErrorF("RENDITION: RENDITIONSyncV1000 called\n");
454
455 ErrorF("#Sync (1)# FIFO_INFREE 0x%x -- \n",verite_in8(iob+FIFOINFREE));
456 ErrorF("#Sync (1)# FIFO_OUTVALID 0x%x -- \n",verite_in8(iob+FIFOOUTVALID));
457 #endif
458
459 c=0;
460 /* empty output fifo,
461 i.e. if there is any valid data in the output fifo then read it */
462
463 while ((c++<0xfffff) && ((verite_in8(iob+FIFOOUTVALID)&0x7)>0))
464 (void)verite_in32(iob);
465
466 /* if(!(c%0xffff))ErrorF("#F1# !0x%x! -- ",verite_in8(iob+FIFOOUTVALID)); */
467
468 if (c >= 0xfffff) {
469 ErrorF("RENDITION: RISC synchronization failed (1) FIFO out == %d!\n",
470 verite_in8(iob+FIFOOUTVALID)&0x1f);
471 return;
472 }
473
474 /* sync RISC */
475 waitfifo(2);
476 verite_out32(iob, CMD_GET_PIXEL);
477 verite_out32(iob, 0);
478
479 c=0;
480 while ((c++<0xfffff) && ((verite_in8(iob+FIFOOUTVALID)&0x7)>0))
481 (void)verite_in32(iob);
482
483 /* if(!(c%0xffff))ErrorF("#F2# !0x%x! -- ",verite_in8(iob+FIFOOUTVALID)); */
484
485
486 if (c >= 0xfffff) {
487 ErrorF ("Rendition: RISC synchronization failed (2) FIFO out == %d!\n",
488 verite_in8(iob+FIFOOUTVALID)&0x1f);
489 return;
490 }
491
492 /* sync pixel engine using csucode -- I suppose this is quite slow <ml> */
493 v1k_stop(pScreenInfo);
494 v1k_start(pScreenInfo, pRendition->board.csucode_base);
495 verite_out32(iob, 2); /* a0 - sync command */
496
497 c=0;
498 while ((c++<0xfffff) && ((verite_in8(iob+FIFOOUTVALID)&0x7)>0))
499 (void)verite_in32(iob);
500
501 /* if(!(c%0xffff))ErrorF("#F3# !0x%x! -- ",verite_in8(iob+FIFOOUTVALID)); */
502
503 if (c == 0xfffff) {
504 ErrorF ("Rendition: Pixel engine synchronization failed FIFO out == %d!\n",
505 verite_in8(iob+FIFOOUTVALID)&0x1f);
506 return;
507 }
508
509 /* restart the ucode */
510 verite_out32(iob, 0); /* a0 - ucode init command */
511 verite_out32(iob, 0); /* a1 - 1024 byte context store area */
512 verite_out32(iob, 0); /* a2 */
513 verite_out32(iob, pRendition->board.ucode_entry);
514
515 /* init the ucode */
516 waitfifo(6);
517 verite_out32(iob, CMD_SETUP);
518 verite_out32(iob, P2(pRendition->board.mode.virtualwidth,
519 pRendition->board.mode.virtualheight));
520 verite_out32(iob, P2(pRendition->board.mode.bitsperpixel,
521 pRendition->board.mode.pixelformat));
522 verite_out32(iob, MC_SIZE);
523
524 verite_out32(iob, pRendition->board.mode.virtualwidth *
525 (pRendition->board.mode.bitsperpixel>>3));
526 verite_out32(iob, (pRendition->board.mode.stride1<<12) |
527 (pRendition->board.mode.stride0<<8));
528 }
529
530
531
532 /*
533 * screen to screen copy
534 */
535 void
RENDITIONSetupForScreenToScreenCopy(ScrnInfoPtr pScreenInfo,int xdir,int ydir,int rop,unsigned planemask,int trans_color)536 RENDITIONSetupForScreenToScreenCopy(ScrnInfoPtr pScreenInfo,
537 int xdir, int ydir, int rop,
538 unsigned planemask, int trans_color)
539 {
540 renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
541
542 #ifdef DEBUG
543 ErrorF("RENDITION: RENDITIONSetupForScreenToScreenCopy("
544 "%2d, %2d, %2d, %u, %d) called\n", xdir, ydir, rop, planemask, trans_color);
545 ErrorF("RENDITION: rop is %x/%x\n", rop, Rop2Rop[rop]);
546 #endif
547
548 pRendition->board.Rop=Rop2Rop[rop];
549 }
550
551 void
RENDITIONSubsequentScreenToScreenCopy(ScrnInfoPtr pScreenInfo,int srcX,int srcY,int dstX,int dstY,int w,int h)552 RENDITIONSubsequentScreenToScreenCopy(ScrnInfoPtr pScreenInfo,
553 int srcX, int srcY,
554 int dstX, int dstY,
555 int w, int h)
556 {
557 renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
558 unsigned long iob = pRendition->board.io_base;
559
560
561 #ifdef DEBUG
562 ErrorF("RENDITION: RENDITIONSubsequentScreenToScreenCopy("
563 "%d, %d, %d, %d, %d, %d) called\n", srcX, srcY, dstX, dstY, w, h);
564 #endif
565
566
567 #if 1 /* def DEBUG */
568 ErrorF("#ScreentoScreen# FIFO_INFREE 0x%x -- \n",verite_in8(iob+FIFOINFREE));
569 ErrorF("#ScreentoScreen# FIFO_OUTVALID 0x%x -- \n",verite_in8(iob+FIFOOUTVALID));
570 #endif
571
572 waitfifo(5);
573 verite_out32(iob, CMD_SCREEN_BLT);
574 verite_out32(iob, pRendition->board.Rop);
575 verite_out32(iob, P2(srcX, srcY));
576 verite_out32(iob, P2(w, h));
577 verite_out32(iob, P2(dstX, dstY));
578 }
579
580
581
582 /*
583 * solid filled rectangles
584 */
585 void
RENDITIONSetupForSolidFill(ScrnInfoPtr pScreenInfo,int color,int rop,unsigned planemask)586 RENDITIONSetupForSolidFill(ScrnInfoPtr pScreenInfo,
587 int color, int rop,
588 unsigned planemask)
589 {
590 renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
591
592 #ifdef DEBUG
593 ErrorF("RENDITION: RENDITIONSetupForSolidFill called\n");
594 ErrorF("RENDITION: Rop is %x/%x\n", rop, Rop2Rop[rop]);
595 #endif
596
597 pRendition->board.Rop=Rop2Rop[rop];
598 pRendition->board.Color=color;
599 if (pRendition->board.mode.bitsperpixel < 32)
600 pRendition->board.Color|=(pRendition->board.Color<<16);
601 if (pRendition->board.mode.bitsperpixel < 16)
602 pRendition->board.Color|=(pRendition->board.Color<<8);
603 }
604
605 void
RENDITIONSubsequentSolidFillRect(ScrnInfoPtr pScreenInfo,int x,int y,int w,int h)606 RENDITIONSubsequentSolidFillRect(ScrnInfoPtr pScreenInfo,
607 int x, int y, int w, int h)
608 {
609 renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
610 unsigned long iob = pRendition->board.io_base;
611
612
613 #ifdef DEBUG
614 ErrorF("RENDITION: RENDITIONSubsequentSolidFillRect called\n");
615 #endif
616
617 waitfifo(4);
618 #ifdef DEBUG
619 ErrorF("#SubsequentSolidFill# FIFO_INFREE 0x%x -- \n",verite_in8(iob+FIFOINFREE));
620 ErrorF("#SubsequentSolidFill# FIFO_OUTVALID 0x%x -- \n",verite_in8(iob+FIFOOUTVALID));
621 sleep(1);
622 #endif
623 verite_out32(iob, P2(pRendition->board.Rop, CMD_RECT_SOLID_ROP));
624 verite_out32(iob, pRendition->board.Color);
625 verite_out32(iob, P2(x, y));
626 verite_out32(iob, P2(w, h));
627 }
628
629
630
631 /*
632 * line
633 */
634
635 void
RENDITIONSubsequentTwoPointLine(ScrnInfoPtr pScreenInfo,int x1,int y1,int x2,int y2,int bias)636 RENDITIONSubsequentTwoPointLine(ScrnInfoPtr pScreenInfo,
637 int x1, int y1,
638 int x2, int y2,
639 int bias)
640 {
641 renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
642 unsigned long iob = pRendition->board.io_base;
643
644
645 #ifdef DEBUG
646 ErrorF("RENDITION: RENDITIONSubsequentTwoPointLine("
647 "%d, %d, %d, %d, %d) called\n", x1, y1, x2, y2, bias);
648 #endif
649
650 waitfifo(5);
651 verite_out32(iob, P2(1, CMD_LINE_SOLID));
652 verite_out32(iob, pRendition->board.Rop);
653 verite_out32(iob, pRendition->board.Color);
654 verite_out32(iob, P2(x1, y1));
655 verite_out32(iob, P2(x2, y2));
656 }
657
658 /*
659 * end of file accelX.c
660 */
661