accelX.c revision 72313efb 
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
57void RENDITIONSaveUcode(ScrnInfoPtr pScreenInfo);
58void RENDITIONRestoreUcode(ScrnInfoPtr pScreenInfo);
59
60void RENDITIONSyncV1000(ScrnInfoPtr pScreenInfo);
61
62void RENDITIONSetupForScreenToScreenCopy(ScrnInfoPtr pScreenInfo,
63					 int xdir, int ydir, int rop,
64					 unsigned int planemask,
65					 int trans_color);
66
67void RENDITIONSubsequentScreenToScreenCopy(ScrnInfoPtr pScreenInfo,
68					   int srcX, int srcY,
69					   int dstX, int dstY,
70					   int w, int h);
71
72
73void RENDITIONSetupForSolidFill(ScrnInfoPtr pScreenInfo,
74				int color, int rop,
75				unsigned int planemask);
76
77
78void RENDITIONSubsequentSolidFillRect(ScrnInfoPtr pScreenInfo,
79				      int x, int y, int w, int h);
80
81
82void RENDITIONSubsequentTwoPointLine(ScrnInfoPtr pScreenInfo,
83				     int x1, int y1,
84				     int x2, int y2,
85				     int bias);
86
87
88/*
89 * global data
90 */
91
92static 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
110void
111RENDITIONAccelPreInit(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
133void
134RENDITIONAccelXAAInit(ScreenPtr pScreen)
135{
136    ScrnInfoPtr  pScreenInfo = xf86Screens[pScreen->myNum];
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
231void
232RENDITIONAccelNone(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
257int
258RENDITIONLoadUcode(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
288int
289RENDITIONInitUcode(ScrnInfoPtr pScreenInfo)
290{
291    renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
292    IOADDRESS 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
366void
367RENDITIONRestoreUcode(ScrnInfoPtr pScreenInfo)
368{
369    renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
370    IOADDRESS 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
409void
410RENDITIONSaveUcode(ScrnInfoPtr pScreenInfo)
411{
412    renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
413    IOADDRESS 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 */
444void
445RENDITIONSyncV1000(ScrnInfoPtr pScreenInfo)
446{
447    renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
448    IOADDRESS 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 */
535void
536RENDITIONSetupForScreenToScreenCopy(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
551void
552RENDITIONSubsequentScreenToScreenCopy(ScrnInfoPtr pScreenInfo,
553					   int srcX, int srcY,
554					   int dstX, int dstY,
555					   int w, int h)
556{
557    renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
558    IOADDRESS 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 */
585void
586RENDITIONSetupForSolidFill(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
605void
606RENDITIONSubsequentSolidFillRect(ScrnInfoPtr pScreenInfo,
607				      int x, int y, int w, int h)
608{
609    renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
610    IOADDRESS 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
635void
636RENDITIONSubsequentTwoPointLine(ScrnInfoPtr pScreenInfo,
637				     int x1, int y1,
638				     int x2, int y2,
639				     int bias)
640{
641    renditionPtr pRendition = RENDITIONPTR(pScreenInfo);
642    IOADDRESS 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