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