projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Replace the numerous switch-statements to derive GL_COMBINE post-scale
[mesa.git] / src / mesa / drivers / dri / unichrome / via_ioctl.c
1 #/*
2 * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
3 * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sub license,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial portions
14 * of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
19 * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 */
24 #include <stdio.h>
25 #include <unistd.h>
26
27 #include "glheader.h"
28 #include "mtypes.h"
29 #include "macros.h"
30 #include "dd.h"
31 #include "swrast/swrast.h"
32
33 #include "mm.h"
34 #include "via_context.h"
35 #include "via_ioctl.h"
36 #include "via_state.h"
37
38 #include "drm.h"
39 #include <sys/ioctl.h>
40
41 GLuint FrameCount = 0;
42 GLuint dmaLow = 0;
43 /*=* John Sheng [2003.5.31] flip *=*/
44 GLuint nFirstSwap = GL_TRUE;
45 GLuint nFirstFlip = GL_TRUE;
46 #define SetReg2DAGP(nReg, nData) { \
47 *((GLuint *)(vb)) = ((nReg) >> 2) | 0xF0000000; \
48 *((GLuint *)(vb) + 1) = (nData); \
49 vb = ((GLuint *)vb) + 2; \
50 vmesa->dmaLow +=8; \
51 }
52
53 #define DEPTH_SCALE ((1 << 16) - 1)
54
55 static void viaClear(GLcontext *ctx, GLbitfield mask, GLboolean all,
56 GLint cx, GLint cy, GLint cw, GLint ch)
57 {
58 viaContextPtr vmesa = VIA_CONTEXT(ctx);
59 __DRIdrawablePrivate *dPriv = vmesa->driDrawable;
60 const GLuint colorMask = *((GLuint *)&ctx->Color.ColorMask);
61 int flag = 0;
62 GLuint scrn = 0, i = 0, side = 0;
63 scrn = vmesa->saam & S_MASK;
64 side = vmesa->saam & P_MASK;
65 #ifdef DEBUG
66 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
67 #endif
68 VIA_FIREVERTICES(vmesa);
69
70 if ((mask & DD_FRONT_LEFT_BIT) && colorMask == ~0) {
71 flag |= VIA_FRONT;
72 mask &= ~DD_FRONT_LEFT_BIT;
73 }
74
75 if ((mask & DD_BACK_LEFT_BIT) && colorMask == ~0) {
76 flag |= VIA_BACK;
77 mask &= ~DD_BACK_LEFT_BIT;
78 }
79
80 if (mask & DD_DEPTH_BIT) {
81 if (ctx->Depth.Mask)
82 flag |= VIA_DEPTH;
83 mask &= ~DD_DEPTH_BIT;
84 }
85
86 if (mask & DD_STENCIL_BIT) {
87 if (ctx->Stencil.Enabled)
88 flag |= VIA_STENCIL;
89 mask &= ~DD_STENCIL_BIT;
90 }
91
92 /*=* [DBG] make draw to front buffer *=*/
93 if(DRAW_FRONT) {
94 flag |= VIA_FRONT;
95 flag &= ~VIA_BACK;
96 }
97
98 if (flag) {
99 LOCK_HARDWARE(vmesa);
100 /* flip top to bottom */
101 cy = dPriv->h - cy - ch;
102 cx += vmesa->drawX;
103 cy += vmesa->drawY;
104
105 if (vmesa->numClipRects) {
106 int nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, vmesa->numClipRects);
107 drm_clip_rect_t *box = vmesa->pClipRects;
108 drm_clip_rect_t *b = vmesa->sarea->boxes;
109 int n = 0;
110
111 if (!vmesa->saam) {
112 if (!all) {
113 #ifdef DEBUG
114 if (VIA_DEBUG) fprintf(stderr,"!all");
115 #endif
116 for (; i < nr; i++) {
117 GLint x = box[i].x1;
118 GLint y = box[i].y1;
119 GLint w = box[i].x2 - x;
120 GLint h = box[i].y2 - y;
121
122 if (x < cx) w -= cx - x, x = cx;
123 if (y < cy) h -= cy - y, y = cy;
124 if (x + w > cx + cw) w = cx + cw - x;
125 if (y + h > cy + ch) h = cy + ch - y;
126 if (w <= 0) continue;
127 if (h <= 0) continue;
128
129 b->x1 = x;
130 b->y1 = y;
131 b->x2 = x + w;
132 b->y2 = y + h;
133 b++;
134 n++;
135 }
136 }
137 else {
138 for (; i < nr; i++) {
139 *b++ = *(drm_clip_rect_t *)&box[i];
140 n++;
141 }
142 }
143 vmesa->sarea->nbox = n;
144 }
145 else {
146 GLuint scrn = 0;
147 scrn = vmesa->saam & S_MASK;
148
149 if (scrn == S0 || scrn == S1) {
150 if (!all) {
151 for (; i < nr; i++) {
152 GLint x = box[i].x1;
153 GLint y = box[i].y1;
154 GLint w = box[i].x2 - x;
155 GLint h = box[i].y2 - y;
156
157 if (x < cx) w -= cx - x, x = cx;
158 if (y < cy) h -= cy - y, y = cy;
159 if (x + w > cx + cw) w = cx + cw - x;
160 if (y + h > cy + ch) h = cy + ch - y;
161 if (w <= 0) continue;
162 if (h <= 0) continue;
163
164 b->x1 = x;
165 b->y1 = y;
166 b->x2 = x + w;
167 b->y2 = y + h;
168 b++;
169 n++;
170 }
171 }
172 else {
173 for (; i < nr; i++) {
174 *b++ = *(drm_clip_rect_t *)&box[i];
175 n++;
176 }
177 }
178 vmesa->sarea->nbox = n;
179 }
180 /* between */
181 else {
182 if (!all) {
183 for (; i < nr; i++) {
184 GLint x = box[i].x1;
185 GLint y = box[i].y1;
186 GLint w = box[i].x2 - x;
187 GLint h = box[i].y2 - y;
188
189 if (x < cx) w -= cx - x, x = cx;
190 if (y < cy) h -= cy - y, y = cy;
191 if (x + w > cx + cw) w = cx + cw - x;
192 if (y + h > cy + ch) h = cy + ch - y;
193 if (w <= 0) continue;
194 if (h <= 0) continue;
195
196 b->x1 = x;
197 b->y1 = y;
198 b->x2 = x + w;
199 b->y2 = y + h;
200 b++;
201 n++;
202 }
203
204 }
205 else {
206 for (; i < nr; i++) {
207 *b++ = *(drm_clip_rect_t *)&box[n];
208 n++;
209 }
210 }
211 *b++ = *(drm_clip_rect_t *)vmesa->pSaamRects;
212 vmesa->sarea->nbox = n;
213 }
214 }
215
216 {
217 if (flag & VIA_FRONT) {
218
219 if (vmesa->drawType == GLX_PBUFFER_BIT)
220 viaFillFrontPBuffer(vmesa);
221 else
222 viaFillFrontBuffer(vmesa);
223
224 if (vmesa->saam && (scrn == (S0 | S1))) {
225 nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, vmesa->numSaamRects);
226 box = vmesa->pSaamRects;
227 b = vmesa->sarea->boxes;
228 n = 0;
229
230 for (i = 0; i < nr; i++) {
231 *b++ = *(drm_clip_rect_t *)&box[n];
232 n++;
233 }
234
235 vmesa->sarea->nbox = n;
236 viaFillFrontBufferSaam(vmesa);
237 }
238 }
239
240 if (flag & VIA_BACK) {
241 viaFillBackBuffer(vmesa);
242 }
243
244 if (flag & VIA_DEPTH) {
245 double depth_clamp, range = 0xffffffff;
246 if (vmesa->hasStencil == 0) {
247 if (vmesa->depthBits == 32) {
248 depth_clamp = ((double)ctx->Depth.Clear)*range;
249 viaFillDepthBuffer(vmesa, (GLuint)depth_clamp);
250 }
251 else {
252 depth_clamp = ((double)ctx->Depth.Clear)*range;
253 viaFillDepthBuffer(vmesa, (GLuint)depth_clamp);
254 }
255 }
256 else {
257 depth_clamp = ((double)ctx->Depth.Clear)*range;
258 viaFillStencilDepthBuffer(vmesa, (GLuint)depth_clamp);
259 }
260 }
261 /*=* [DBG] Fix tuxracer depth error *=*/
262 else if (flag & VIA_STENCIL) {
263 viaFillStencilBuffer(vmesa, (GLuint)ctx->Stencil.Clear);
264 }
265 }
266 }
267 UNLOCK_HARDWARE(vmesa);
268 vmesa->uploadCliprects = GL_TRUE;
269 }
270
271 if (mask)
272 _swrast_Clear(ctx, mask, all, cx, cy, cw, ch);
273 #ifdef DEBUG
274 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
275 #endif
276 }
277
278 /*
279 * Copy the back buffer to the front buffer.
280 */
281 void viaCopyBuffer(const __DRIdrawablePrivate *dPriv)
282 {
283 viaContextPtr vmesa;
284 drm_clip_rect_t *pbox;
285 int nbox, i;
286 GLuint scrn = 0, side = 0;
287 #ifdef DEBUG
288 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
289 #endif
290 assert(dPriv);
291 assert(dPriv->driContextPriv);
292 assert(dPriv->driContextPriv->driverPrivate);
293
294 vmesa = (viaContextPtr)dPriv->driContextPriv->driverPrivate;
295
296 VIA_FIREVERTICES(vmesa);
297 LOCK_HARDWARE(vmesa);
298
299 scrn = vmesa->saam & S_MASK;
300 side = vmesa->saam & P_MASK;
301
302 pbox = vmesa->pClipRects;
303 nbox = vmesa->numClipRects;
304
305 #ifdef DEBUG
306 if (VIA_DEBUG) fprintf(stderr, "%s %d cliprects (%d), SAAM (%d)\n",
307 __FUNCTION__, nbox, vmesa->drawType, vmesa->saam);
308 #endif
309
310
311 if (vmesa->drawType == GLX_PBUFFER_BIT) {
312 viaDoSwapPBuffers(vmesa);
313 #ifdef DEBUG
314 if (VIA_DEBUG) fprintf(stderr, "%s SwapPBuffers\n", __FUNCTION__);
315 #endif /*=* [DBG] for pbuffer *=*/
316 /*viaDoSwapBufferSoftFront(vmesa);*/
317 }
318 else {
319 GLuint scrn = 0;
320 scrn = vmesa->saam & S_MASK;
321 if (!vmesa->saam) {
322 for (i = 0; i < nbox; ) {
323 int nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, dPriv->numClipRects);
324 drm_clip_rect_t *b = (drm_clip_rect_t *)vmesa->sarea->boxes;
325
326 vmesa->sarea->nbox = nr - i;
327
328 for (; i < nr; i++)
329 *b++ = pbox[i];
330 viaDoSwapBuffers(vmesa);
331 #ifdef DEBUG
332 if (VIA_DEBUG) fprintf(stderr, "%s SwapBuffers\n", __FUNCTION__);
333 #endif
334 }
335 }
336 else if (scrn == S0 || scrn == S1) {
337 for (i = 0; i < nbox; ) {
338 int nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, vmesa->numClipRects);
339 drm_clip_rect_t *b = (drm_clip_rect_t *)vmesa->sarea->boxes;
340
341 vmesa->sarea->nbox = nr - i;
342
343 for (; i < nr; i++) {
344 *b++ = pbox[i];
345 }
346 viaDoSwapBuffers(vmesa);
347 }
348 }
349 /* between */
350 else {
351 for (i = 0; i < nbox; ) {
352 int nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, dPriv->numClipRects);
353 drm_clip_rect_t *b = (drm_clip_rect_t *)vmesa->sarea->boxes;
354
355 vmesa->sarea->nbox = nr - i;
356
357 for (; i < nr; i++)
358 *b++ = pbox[i];
359 viaDoSwapBuffers(vmesa);
360 }
361
362 pbox = vmesa->pSaamRects;
363 nbox = vmesa->numSaamRects;
364
365 for (i = 0; i < nbox; ) {
366 int nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, vmesa->numSaamRects);
367 drm_clip_rect_t *b = (drm_clip_rect_t *)vmesa->sarea->boxes;
368
369 vmesa->sarea->nbox = nr - i;
370
371 for (; i < nr; i++)
372 *b++ = pbox[i];
373
374 viaDoSwapBuffersSaam(vmesa);
375 }
376 }
377 }
378 UNLOCK_HARDWARE(vmesa);
379 vmesa->uploadCliprects = GL_TRUE;
380 #ifdef DEBUG
381 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
382 #endif
383 }
384
385 /*
386 * XXX implement when full-screen extension is done.
387 */
388 void viaPageFlip(const __DRIdrawablePrivate *dPriv)
389 {
390 /*=* John Sheng [2003.5.31] flip *=*/
391 viaContextPtr vmesa = (viaContextPtr)dPriv->driContextPriv->driverPrivate;
392 GLuint *vb = viaCheckDma(vmesa, vmesa->sarea->nbox*56);
393 GLuint nBackBase;
394 viaBuffer buffer_tmp;
395 GLcontext *ctx;
396
397 #ifdef DEBUG
398 if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__);
399 #endif
400 assert(dPriv);
401 assert(dPriv->driContextPriv);
402 assert(dPriv->driContextPriv->driverPrivate);
403
404 ctx = vmesa->glCtx;
405
406 /*=* [DBG] make draw to front buffer *=*/
407 if(DRAW_FRONT)
408 return;
409
410 /* Page Flip*/
411 if(GL_FALSE) {
412 viaFlushPrimsLocked(vmesa);
413 while ((*(volatile GLuint *)((GLuint)vmesa->regMMIOBase + 0x200) & 0x2) != 0x2);
414 while (*(volatile GLuint *)((GLuint)vmesa->regMMIOBase + 0x200) & 0x2);
415 nBackBase = vmesa->back.offset >> 1;
416
417 /*if (nFirstFlip) {
418 *vb++ = HALCYON_HEADER2;
419 *vb++ = 0x00fe0000;
420 *vb++ = 0x00001004;
421 *vb++ = 0x00001004;
422 vmesa->dmaLow += 16;
423
424 nFirstFlip = GL_FALSE;
425 }
426 SetReg2DAGP(0x214, nBackBase);
427 viaFlushPrimsLocked(vmesa);*/
428 if (nFirstFlip) {
429 *((volatile GLuint *)((GLuint)vmesa->regMMIOBase + 0x43c)) = 0x00fe0000;
430 *((volatile GLuint *)((GLuint)vmesa->regMMIOBase + 0x440)) = 0x00001004;
431 nFirstFlip = GL_FALSE;
432 }
433 *((GLuint *)((GLuint)vmesa->regMMIOBase + 0x214)) = nBackBase;
434 }
435 /* Auto Swap */
436 else {
437 viaFlushPrimsLocked(vmesa);
438 vb = viaCheckDma(vmesa, vmesa->sarea->nbox*56);
439 if (nFirstSwap) {
440 *vb++ = HALCYON_HEADER2;
441 *vb++ = 0x00fe0000;
442 *vb++ = 0x0000000e;
443 *vb++ = 0x0000000e;
444 vmesa->dmaLow += 16;
445
446 nFirstSwap = GL_FALSE;
447 }
448 nBackBase = (vmesa->back.offset << 1);
449
450 *vb++ = HALCYON_HEADER2;
451 *vb++ = 0x00fe0000;
452 *vb++ = (HC_SubA_HFBBasL << 24) | (nBackBase & 0xFFFFF8) | 0x2;
453 *vb++ = (HC_SubA_HFBDrawFirst << 24) |
454 ((nBackBase & 0xFF000000) >> 24) | 0x0100;
455 vmesa->dmaLow += 16;
456 viaFlushPrimsLocked(vmesa);
457 }
458
459
460 memcpy(&buffer_tmp, &vmesa->back, sizeof(viaBuffer));
461 memcpy(&vmesa->back, &vmesa->front, sizeof(viaBuffer));
462 memcpy(&vmesa->front, &buffer_tmp, sizeof(viaBuffer));
463
464 if(vmesa->currentPage) {
465 vmesa->currentPage = 0;
466 if (vmesa->glCtx->Color._DrawDestMask == __GL_BACK_BUFFER_MASK) {
467 ctx->Driver.DrawBuffer(ctx, GL_BACK);
468 }
469 else {
470 ctx->Driver.DrawBuffer(ctx, GL_FRONT);
471 }
472 }
473 else {
474 vmesa->currentPage = 1;
475 if (vmesa->glCtx->Color._DrawDestMask == __GL_BACK_BUFFER_MASK) {
476 ctx->Driver.DrawBuffer(ctx, GL_BACK);
477 }
478 else {
479 ctx->Driver.DrawBuffer(ctx, GL_FRONT);
480 }
481 }
482 #ifdef DEBUG
483 if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__);
484 #endif
485
486 }
487
488 /* This waits for *everybody* to finish rendering -- overkill.
489 */
490 void viaDmaFinish(viaContextPtr vmesa)
491 {
492 #ifdef DEBUG
493 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
494 #endif
495 VIA_FIREVERTICES(vmesa);
496 LOCK_HARDWARE(vmesa);
497 UNLOCK_HARDWARE(vmesa);
498 #ifdef DEBUG
499 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
500 #endif
501 }
502
503 void viaRegetLockQuiescent(viaContextPtr vmesa)
504 {
505 drmUnlock(vmesa->driFd, vmesa->hHWContext);
506 }
507
508 static int intersect_rect(drm_clip_rect_t *out,
509 drm_clip_rect_t *a,
510 drm_clip_rect_t *b)
511 {
512 *out = *a;
513
514 if (b->x1 > out->x1) out->x1 = b->x1;
515 if (b->x2 < out->x2) out->x2 = b->x2;
516 if (out->x1 >= out->x2) return 0;
517
518 if (b->y1 > out->y1) out->y1 = b->y1;
519 if (b->y2 < out->y2) out->y2 = b->y2;
520 if (out->y1 >= out->y2) return 0;
521
522 return 1;
523 }
524
525 void viaFlushPrimsLocked(viaContextPtr vmesa)
526 {
527 drm_clip_rect_t *pbox = (drm_clip_rect_t *)vmesa->pClipRects;
528 int nbox = vmesa->numClipRects;
529 drm_via_sarea_t *sarea = vmesa->sarea;
530 drm_via_flush_agp_t agpCmd;
531 drm_via_flush_sys_t sysCmd;
532 GLuint *vb = viaCheckDma(vmesa, 0);
533 int i;
534
535 if (vmesa->dmaLow == DMA_OFFSET) {
536 return;
537 }
538 if (vmesa->dmaLow > 2097152)
539 fprintf(stderr, "buffer overflow in Flush Prims = %d\n",vmesa->dmaLow);
540
541 switch (vmesa->dmaLow & 0x1F) {
542 case 8:
543 *vb++ = HC_HEADER2;
544 *vb++ = (HC_ParaType_NotTex << 16);
545 *vb++ = HC_DUMMY;
546 *vb++ = HC_DUMMY;
547 *vb++ = HC_DUMMY;
548 *vb++ = HC_DUMMY;
549 vmesa->dmaLow += 24;
550 break;
551 case 16:
552 *vb++ = HC_HEADER2;
553 *vb++ = (HC_ParaType_NotTex << 16);
554 *vb++ = HC_DUMMY;
555 *vb++ = HC_DUMMY;
556 vmesa->dmaLow += 16;
557 break;
558 case 24:
559 *vb++ = HC_HEADER2;
560 *vb++ = (HC_ParaType_NotTex << 16);
561 *vb++ = HC_DUMMY;
562 *vb++ = HC_DUMMY;
563 *vb++ = HC_DUMMY;
564 *vb++ = HC_DUMMY;
565 *vb++ = HC_DUMMY;
566 *vb++ = HC_DUMMY;
567 *vb++ = HC_DUMMY;
568 *vb++ = HC_DUMMY;
569 vmesa->dmaLow += 40;
570 break;
571 case 0:
572 break;
573 default:
574 break;
575 }
576
577 if (vmesa->useAgp) {
578 agpCmd.offset = 0x0;
579 agpCmd.size = vmesa->dmaLow;
580 agpCmd.index = vmesa->dma[vmesa->dmaIndex].index;
581 agpCmd.discard = 0;
582 }
583 else {
584 sysCmd.offset = 0x0;
585 sysCmd.size = vmesa->dmaLow;
586 sysCmd.index = (GLuint)vmesa->dma[vmesa->dmaIndex].map;
587 sysCmd.discard = 0;
588 }
589
590 sarea->vertexPrim = vmesa->hwPrimitive;
591
592 if (!nbox) {
593 if (vmesa->useAgp)
594 agpCmd.size = 0;
595 else
596 sysCmd.size = 0;
597 }
598 else if (nbox > VIA_NR_SAREA_CLIPRECTS) {
599 vmesa->uploadCliprects = GL_TRUE;
600 }
601 /*=* John Sheng [2003.5.31] flip *=*/
602 /*#ifdef DEBUG
603 if (VIA_DEBUG) {
604 GLuint i;
605 GLuint *data = (GLuint *)vmesa->dmaAddr;
606 for (i = 0; i < vmesa->dmaLow; i += 16) {
607 fprintf(stderr, "%08x ", *data++);
608 fprintf(stderr, "%08x ", *data++);
609 fprintf(stderr, "%08x ", *data++);
610 fprintf(stderr, "%08x\n", *data++);
611 }
612 fprintf(stderr, "******************************************\n");
613 }
614 #endif*/
615 if (!nbox || !vmesa->uploadCliprects) {
616 if (nbox == 1)
617 sarea->nbox = 0;
618 else
619 sarea->nbox = nbox;
620
621 if (vmesa->useAgp) {
622 agpCmd.discard = 1;
623 flush_agp(vmesa, &agpCmd);
624 }
625 else {
626 sysCmd.discard = 1;
627 flush_sys(vmesa, &sysCmd);
628 }
629 }
630 else {
631 GLuint scrn;
632 GLuint side;
633 scrn = vmesa->saam & S_MASK;
634 side = vmesa->saam & P_MASK;
635
636 for (i = 0; i < nbox; ) {
637 int nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, nbox);
638 drm_clip_rect_t *b = sarea->boxes;
639
640 if (!vmesa->saam) {
641 if (vmesa->glCtx->Scissor.Enabled) {
642 sarea->nbox = 0;
643
644 for (; i < nr; i++) {
645 b->x1 = pbox[i].x1 - vmesa->drawX;
646 b->y1 = pbox[i].y1 - vmesa->drawY;
647 b->x2 = pbox[i].x2 - vmesa->drawX;
648 b->y2 = pbox[i].y2 - vmesa->drawY;
649 if (intersect_rect(b, b, &vmesa->scissorRect)) {
650 sarea->nbox++;
651 b++;
652 }
653 }
654 if (!sarea->nbox) {
655 if (nr < nbox) continue;
656 agpCmd.size = 0;
657 }
658 }
659 else {
660 sarea->nbox = nr - i;
661 for (; i < nr; i++, b++) {
662 b->x1 = pbox[i].x1 - vmesa->drawX;
663 b->y1 = pbox[i].y1 - vmesa->drawY;
664 b->x2 = pbox[i].x2 - vmesa->drawX;
665 b->y2 = pbox[i].y2 - vmesa->drawY;
666 }
667 }
668 }
669 else if (scrn == S0 || scrn == S1){
670 if (vmesa->scissor) {
671 sarea->nbox = 0;
672 for (; i < nr; i++) {
673 b->x1 = pbox[i].x1 - vmesa->drawX;
674 b->y1 = pbox[i].y1 - vmesa->drawY;
675 b->x2 = pbox[i].x2 - vmesa->drawX;
676 b->y2 = pbox[i].y2 - vmesa->drawY;
677 if (intersect_rect(b, b, &vmesa->scissorRect)) {
678 sarea->nbox++;
679 b++;
680 }
681 }
682 if (!sarea->nbox) {
683 if (nr < nbox) continue;
684 agpCmd.size = 0;
685 }
686 }
687 else {
688 sarea->nbox = nr - i;
689 for (; i < nr; i++, b++) {
690 b->x1 = pbox[i].x1 - vmesa->drawX;
691 b->y1 = pbox[i].y1 - vmesa->drawY;
692 b->x2 = pbox[i].x2 - vmesa->drawX;
693 b->y2 = pbox[i].y2 - vmesa->drawY;
694 }
695 }
696
697 }
698 /* between */
699 else {
700 if (vmesa->scissor) {
701 sarea->nbox = 0;
702 for (; i < nr; i++) {
703 b->x1 = pbox[i].x1 - vmesa->drawX;
704 b->y1 = pbox[i].y1 - vmesa->drawY;
705 b->x2 = pbox[i].x2 - vmesa->drawX;
706 b->y2 = pbox[i].y2 - vmesa->drawY;
707
708 if (intersect_rect(b, b, &vmesa->scissorRect)) {
709 sarea->nbox++;
710 b++;
711 }
712 }
713 if (!sarea->nbox) {
714 if (nr < nbox) continue;
715 agpCmd.size = 0;
716 }
717 }
718 else {
719 sarea->nbox = nr - i;
720 for (; i < nr; i++, b++) {
721 b->x1 = pbox[i].x1 - vmesa->drawX;
722 b->y1 = pbox[i].y1 - vmesa->drawY;
723 b->x2 = pbox[i].x2 - vmesa->drawX;
724 b->y2 = pbox[i].y2 - vmesa->drawY;
725 }
726 }
727 }
728
729 if (nr == nbox) {
730 if (vmesa->useAgp) {
731 agpCmd.discard = 1;
732 flush_agp(vmesa, &agpCmd);
733 }
734 else {
735 sysCmd.discard = 1;
736 flush_sys(vmesa, &sysCmd);
737 }
738 }
739
740 if (scrn == (S0 | S1)) {
741 pbox = (drm_clip_rect_t *)vmesa->pSaamRects;
742 nbox = vmesa->numSaamRects;
743 for (i = 0; i < nbox; ) {
744 int nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, nbox);
745 drm_clip_rect_t *b = sarea->boxes;
746 if (vmesa->scissor) {
747 sarea->nbox = 0;
748 for (; i < nr; i++) {
749 b->x1 = pbox[i].x1 - vmesa->drawXSaam;
750 b->y1 = pbox[i].y1 - vmesa->drawYSaam;
751 b->x2 = pbox[i].x2 - vmesa->drawXSaam;
752 b->y2 = pbox[i].y2 - vmesa->drawYSaam;
753
754 if (intersect_rect(b, b, &vmesa->scissorRect)) {
755 sarea->nbox++;
756 b++;
757 }
758 }
759 if (!sarea->nbox) {
760 if (nr < nbox) continue;
761 agpCmd.size = 0;
762 }
763 }
764 else {
765 sarea->nbox = nr - i;
766 for (; i < nr; i++, b++) {
767 b->x1 = pbox[i].x1 - vmesa->drawXSaam;
768 b->y1 = pbox[i].y1 - vmesa->drawYSaam;
769 b->x2 = pbox[i].x2 - vmesa->drawXSaam;
770 b->y2 = pbox[i].y2 - vmesa->drawYSaam;
771 }
772 }
773 }
774 flush_agp_saam(vmesa, &agpCmd);
775 }
776 }
777 }
778 #ifdef DEBUG
779 if (VIA_DEBUG) {
780 GLuint i;
781 GLuint *data = (GLuint *)vmesa->dmaAddr;
782 for (i = 0; i < vmesa->dmaLow; i += 16) {
783 fprintf(stderr, "%08x ", *data++);
784 fprintf(stderr, "%08x ", *data++);
785 fprintf(stderr, "%08x ", *data++);
786 fprintf(stderr, "%08x\n", *data++);
787 }
788 fprintf(stderr, "******************************************\n");
789 }
790 #endif
791 /* Reset vmesa vars:
792 */
793 vmesa->dmaLow = DMA_OFFSET;
794 if (vmesa->dmaIndex) {
795 vmesa->dmaAddr = vmesa->dma[0].map;
796 vmesa->dmaHigh = vmesa->dma[0].size;
797 vmesa->dmaLastPrim = DMA_OFFSET;
798 vmesa->dmaIndex = 0;
799 }
800 else {
801 vmesa->dmaAddr = vmesa->dma[1].map;
802 vmesa->dmaHigh = vmesa->dma[1].size;
803 vmesa->dmaLastPrim = DMA_OFFSET;
804 vmesa->dmaIndex = 1;
805 }
806 }
807
808 void viaFlushPrims(viaContextPtr vmesa)
809 {
810 #ifdef DEBUG
811 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
812 #endif
813 if (vmesa->dmaLow) {
814 LOCK_HARDWARE(vmesa);
815 viaFlushPrimsLocked(vmesa);
816 UNLOCK_HARDWARE(vmesa);
817 }
818 #ifdef DEBUG
819 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
820 #endif
821 }
822
823 static void viaFlush(GLcontext *ctx)
824 {
825 viaContextPtr vmesa = VIA_CONTEXT(ctx);
826 #ifdef DEBUG
827 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
828 #endif
829 VIA_FIREVERTICES(vmesa);
830 #ifdef DEBUG
831 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
832 #endif
833 }
834
835 static void viaFinish(GLcontext *ctx)
836 {
837 #ifdef DEBUG
838 if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__);
839 if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__);
840 #endif
841 return;
842 }
843
844 static void viaClearStencil(GLcontext *ctx, int s)
845 {
846 return;
847 }
848
849 void viaInitIoctlFuncs(GLcontext *ctx)
850 {
851 ctx->Driver.Flush = viaFlush;
852 ctx->Driver.Clear = viaClear;
853 ctx->Driver.Finish = viaFinish;
854 ctx->Driver.ClearStencil = viaClearStencil;
855 }
856
857 void viaFillFrontBuffer(viaContextPtr vmesa)
858 {
859 GLuint nDestBase, nDestPitch, nDestWidth, nDestHeight, offsetX, offset,i;
860 drm_clip_rect_t *b = vmesa->sarea->boxes;
861 GLuint *vb = viaCheckDma(vmesa, vmesa->sarea->nbox*48);
862 GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3;
863 GLuint pixel = (GLuint)vmesa->ClearColor;
864
865 offset = vmesa->viaScreen->fbOffset + (vmesa->drawY * vmesa->front.pitch + vmesa->drawX * bytePerPixel);
866 #ifdef DEBUG
867 if (VIA_DEBUG) fprintf(stderr, "Fill Front offset = %08x\n", offset);
868 #endif
869 nDestBase = offset & 0xffffffe0;
870 nDestPitch = vmesa->front.pitch;
871
872 for (i = 0; i < vmesa->sarea->nbox ; i++) {
873 nDestWidth = b->x2 - b->x1 - 1;
874 nDestHeight = b->y2 - b->y1 - 1;
875
876 if (bytePerPixel == 4)
877 offsetX = (b->x1 - vmesa->drawX) + (vmesa->drawX & 7);
878 else
879 offsetX = (b->x1 - vmesa->drawX) + (vmesa->drawX & 15);
880
881
882 if (GL_TRUE) {
883 /* GEFGCOLOR*/
884 SetReg2DAGP(0x18, pixel | 0x00000000);
885 /* GEWD*/
886 SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16));
887 /* GEDST*/
888 SetReg2DAGP(0x0C, (offsetX | ((b->y1 - vmesa->drawY) << 16)));
889 /* GEDSTBASE*/
890 SetReg2DAGP(0x34, (nDestBase >> 3));
891 /* GEPITCH*/
892 SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000);
893 /* BITBLT*/
894 SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000);
895 }
896 b++;
897 }
898
899 viaFlushPrimsLocked(vmesa);
900 }
901
902 void viaFillFrontBufferSaam(viaContextPtr vmesa)
903 {
904 GLuint nDestBase, nDestPitch, nDestWidth, nDestHeight, offsetX, offset,i;
905 drm_clip_rect_t *b = vmesa->sarea->boxes;
906 GLuint *vb = viaCheckDma(vmesa, vmesa->sarea->nbox*48);
907 GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3;
908 GLuint pixel = (GLuint)vmesa->ClearColor;
909
910 offset = vmesa->viaScreen->fbSize +
911 (vmesa->drawYSaam * vmesa->front.pitch + vmesa->drawXSaam * bytePerPixel);
912 nDestBase = offset & 0xffffffe0;
913 nDestPitch = vmesa->front.pitch;
914
915 for (i = 0; i < vmesa->sarea->nbox ; i++) {
916 nDestWidth = b->x2 - b->x1 - 1;
917 nDestHeight = b->y2 - b->y1 - 1;
918
919 if (bytePerPixel == 4)
920 offsetX = (b->x1 - vmesa->drawXSaam) + (vmesa->drawXSaam & 7);
921 else
922 offsetX = (b->x1 - vmesa->drawXSaam) + (vmesa->drawXSaam & 15);
923
924 if (GL_TRUE) {
925 /* GEFGCOLOR*/
926 SetReg2DAGP(0x18, pixel | 0x00000000);
927 /* GEWD*/
928 SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16));
929 /* GEDST*/
930 SetReg2DAGP(0x0C, (offsetX | ((b->y1 - vmesa->drawYSaam) << 16)));
931 /* GEDSTBASE*/
932 SetReg2DAGP(0x34, (nDestBase >> 3));
933 /* GEPITCH*/
934 SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000);
935 /* BITBLT*/
936 SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000);
937 }
938 b++;
939 }
940
941 viaFlushPrimsLocked(vmesa);
942 }
943
944 void viaFillFrontPBuffer(viaContextPtr vmesa)
945 {
946 GLuint nDestBase, nDestPitch, nDestWidth, nDestHeight, offsetX, offset;
947 GLuint *vb = viaCheckDma(vmesa, vmesa->sarea->nbox*48);
948 GLuint pixel = (GLuint)vmesa->ClearColor;
949
950 offset = vmesa->front.offset;
951 #ifdef DEBUG
952 if (VIA_DEBUG) fprintf(stderr, "Fill PFront offset = %08x\n", offset);
953 #endif
954 nDestBase = offset;
955 nDestPitch = vmesa->front.pitch;
956
957 nDestWidth = vmesa->driDrawable->w - 1;
958 nDestHeight = vmesa->driDrawable->h - 1;
959
960 offsetX = 0;
961
962 /* GEFGCOLOR*/
963 SetReg2DAGP(0x18, pixel | 0x00000000);
964 /* GEWD*/
965 SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16));
966 /* GEDST*/
967 SetReg2DAGP(0x0C, (offsetX | (0 << 16)));
968 /* GEDSTBASE*/
969 SetReg2DAGP(0x34, (nDestBase >> 3));
970 /* GEPITCH*/
971 SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000);
972 /* BITBLT*/
973 SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000);
974
975 viaFlushPrimsLocked(vmesa);
976 }
977
978 void viaFillBackBuffer(viaContextPtr vmesa)
979 {
980 GLuint nDestBase, nDestPitch, nDestWidth, nDestHeight, offsetX, offset;
981 GLcontext *ctx = vmesa->glCtx;
982 GLuint *vb = viaCheckDma(vmesa, 48);
983 GLuint pixel = (GLuint)vmesa->ClearColor;
984 GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3;
985
986 offset = vmesa->back.offset;
987 #ifdef DEBUG
988 if (VIA_DEBUG) fprintf(stderr, "Fill Back offset = %08x\n", offset);
989 #endif
990 nDestBase = offset;
991 nDestPitch = vmesa->back.pitch;
992 offsetX = vmesa->drawXoff;
993
994 {
995 if (!ctx->Scissor.Enabled) {
996
997 nDestWidth = (vmesa->back.pitch / vmesa->viaScreen->bitsPerPixel * 8) - 1;
998 nDestHeight = vmesa->driDrawable->h -1;
999
1000 /* GEFGCOLOR */
1001 SetReg2DAGP(0x18, pixel | 0x00000000);
1002 /* GEWD */
1003 SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16));
1004 /* GEDST */
1005 SetReg2DAGP(0x0C, (offsetX | (0 << 16)));
1006 /* GEDSTBASE */
1007 SetReg2DAGP(0x34, (nDestBase >> 3));
1008 /* GEPITCH */
1009 SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000);
1010 /* BITBLT */
1011 SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000);
1012 }
1013 /*=* John Sheng [2003.7.18] texenv *=*/
1014 else {
1015 int i;
1016 drm_clip_rect_t *b = vmesa->sarea->boxes;
1017 for (i = 0; i < vmesa->sarea->nbox ; i++) {
1018 nDestWidth = b->x2 - b->x1 - 1;
1019 nDestHeight = b->y2 - b->y1 - 1;
1020
1021 if (bytePerPixel == 4)
1022 offsetX = (b->x1 - vmesa->drawX) + (vmesa->drawX & 7);
1023 else
1024 offsetX = (b->x1 - vmesa->drawX) + (vmesa->drawX & 15);
1025
1026 /* GEFGCOLOR */
1027 SetReg2DAGP(0x18, pixel | 0x00000000);
1028 /* GEWD */
1029 SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16));
1030 /* GEDST */
1031 SetReg2DAGP(0x0C, ((offsetX + (b->x1 - vmesa->drawX)) | ((b->y1 - vmesa->drawY) << 16)));
1032 /* GEDSTBASE */
1033 SetReg2DAGP(0x34, (nDestBase >> 3));
1034 /* GEPITCH */
1035 SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000);
1036 /* BITBLT */
1037 SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000);
1038 b++;
1039 }
1040 }
1041 #ifdef DEBUG
1042 if (VIA_DEBUG) {
1043 fprintf(stderr," width = %08x\n", nDestWidth);
1044 fprintf(stderr," height = %08x\n", nDestHeight);
1045 }
1046 #endif
1047 }
1048 }
1049
1050 void viaFillStencilDepthBuffer(viaContextPtr vmesa, GLuint pixel)
1051 {
1052 GLuint nDestBase, nDestPitch, nDestWidth, nDestHeight, offsetX, offset;
1053 GLuint *vb = viaCheckDma(vmesa, 80);
1054 GLuint nMask;
1055
1056 offset = vmesa->depth.offset;
1057 #ifdef DEBUG
1058 if (VIA_DEBUG) fprintf(stderr, "Fill Stencil Depth offset = %08x\n", offset);
1059 #endif
1060 nDestBase = offset;
1061 nDestPitch = vmesa->depth.pitch;
1062 offsetX = vmesa->drawXoff;
1063 pixel = pixel & 0xffffff00;
1064 nMask = 0x10000000;
1065
1066 {
1067 nDestWidth = (vmesa->depth.pitch / vmesa->depthBits * 8) - 1 - offsetX;
1068 nDestHeight = vmesa->driDrawable->h -1;
1069
1070 if (vmesa->viaScreen->bitsPerPixel == vmesa->depth.bpp) {
1071 /* GEFGCOLOR */
1072 SetReg2DAGP(0x18, pixel);
1073 /* GEMASK */
1074 SetReg2DAGP(0x2C, nMask);
1075 /* GEWD */
1076 SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16));
1077 /* GEDST */
1078 SetReg2DAGP(0x0C, (offsetX | (0 << 16)));
1079 /* GEDSTBASE */
1080 SetReg2DAGP(0x34, (nDestBase >> 3));
1081 /* GEPITCH */
1082 SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000);
1083 /* BITBLT */
1084 SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000);
1085 /* GEMASK */
1086 SetReg2DAGP(0x2C, 0x00000000);
1087 }
1088 else {
1089 GLuint EngStatus = *(vmesa->pnGEMode);
1090 /* GEMODE */
1091 SetReg2DAGP(0x04, (EngStatus & 0xFFFFFCFF) | 0x300);
1092 /* GEFGCOLOR */
1093 SetReg2DAGP(0x18, pixel);
1094 /* GEMASK */
1095 SetReg2DAGP(0x2C, nMask);
1096 /* GEWD */
1097 SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16));
1098 /* GEDST */
1099 SetReg2DAGP(0x0C, (offsetX | (0 << 16)));
1100 /* GEDSTBASE */
1101 SetReg2DAGP(0x34, (nDestBase >> 3));
1102 /* GEPITCH */
1103 SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000);
1104 /* BITBLT */
1105 SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000);
1106 /* GEMODE */
1107 SetReg2DAGP(0x04, EngStatus);
1108 /* GEMASK */
1109 SetReg2DAGP(0x2C, 0x00000000);
1110
1111 WAIT_IDLE
1112 }
1113 }
1114
1115 if (vmesa->glCtx->Color._DrawDestMask == __GL_BACK_BUFFER_MASK) {
1116 viaFlushPrimsLocked(vmesa);
1117 }
1118 }
1119
1120 void viaFillStencilBuffer(viaContextPtr vmesa, GLuint pixel)
1121 {
1122 GLuint nDestBase, nDestPitch, nDestWidth, nDestHeight, offsetX, offset;
1123 GLuint *vb = viaCheckDma(vmesa, 80);
1124 GLuint nMask;
1125
1126 offset = vmesa->depth.offset;
1127 #ifdef DEBUG
1128 if (VIA_DEBUG) fprintf(stderr, "Fill Stencil offset = %08x\n", offset);
1129 #endif
1130 nDestBase = offset;
1131 nDestPitch = vmesa->depth.pitch;
1132 offsetX = vmesa->drawXoff;
1133 pixel = pixel & 0x000000ff;
1134 nMask = 0xe0000000;
1135
1136 {
1137 nDestWidth = (vmesa->depth.pitch / vmesa->depthBits * 8) - 1 - offsetX;
1138 nDestHeight = vmesa->driDrawable->h -1;
1139
1140 if (vmesa->viaScreen->bitsPerPixel == vmesa->depth.bpp) {
1141 /* GEFGCOLOR */
1142 SetReg2DAGP(0x18, pixel);
1143 /* GEMASK */
1144 SetReg2DAGP(0x2C, nMask);
1145 /* GEWD */
1146 SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16));
1147 /* GEDST */
1148 SetReg2DAGP(0x0C, (offsetX | (0 << 16)));
1149 /* GEDSTBASE */
1150 SetReg2DAGP(0x34, (nDestBase >> 3));
1151 /* GEPITCH */
1152 SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000);
1153 /* BITBLT */
1154 SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000);
1155 /* GEMASK */
1156 SetReg2DAGP(0x2C, 0x00000000);
1157 }
1158 else {
1159 GLuint EngStatus = *(vmesa->pnGEMode);
1160 /* GEMODE */
1161 SetReg2DAGP(0x04, (EngStatus & 0xFFFFFCFF) | 0x300);
1162 /* GEFGCOLOR */
1163 SetReg2DAGP(0x18, pixel);
1164 /* GEMASK */
1165 SetReg2DAGP(0x2C, nMask);
1166 /* GEWD */
1167 SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16));
1168 /* GEDST */
1169 SetReg2DAGP(0x0C, (offsetX | (0 << 16)));
1170 /* GEDSTBASE */
1171 SetReg2DAGP(0x34, (nDestBase >> 3));
1172 /* GEPITCH */
1173 SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000);
1174 /* BITBLT */
1175 SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000);
1176 /* GEMODE */
1177 SetReg2DAGP(0x04, EngStatus);
1178 /* GEMASK */
1179 SetReg2DAGP(0x2C, 0x00000000);
1180 }
1181 }
1182
1183 if (vmesa->glCtx->Color._DrawDestMask == __GL_BACK_BUFFER_MASK) {
1184 viaFlushPrimsLocked(vmesa);
1185 }
1186 }
1187
1188 void viaFillDepthBuffer(viaContextPtr vmesa, GLuint pixel)
1189 {
1190 GLuint nDestBase, nDestPitch, nDestWidth, nDestHeight, offsetX, offset;
1191 GLuint *vb = viaCheckDma(vmesa, 72);
1192 offset = vmesa->depth.offset;
1193 #ifdef DEBUG
1194 if (VIA_DEBUG) fprintf(stderr, "Fill Depth offset = %08x\n", offset);
1195 #endif
1196 nDestBase = offset;
1197 nDestPitch = vmesa->depth.pitch;
1198 offsetX = vmesa->drawXoff;
1199
1200 {
1201 nDestWidth = (vmesa->depth.pitch / vmesa->depthBits * 8) - 1 - offsetX;
1202 nDestHeight = vmesa->driDrawable->h -1;
1203
1204 if (vmesa->viaScreen->bitsPerPixel == vmesa->depth.bpp) {
1205 /* GEFGCOLOR */
1206 SetReg2DAGP(0x18, pixel);
1207 /* GEMASK */
1208 SetReg2DAGP(0x2C, 0x0);
1209 /* GEWD */
1210 SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16));
1211 /* GEDST */
1212 SetReg2DAGP(0x0C, (offsetX | (0 << 16)));
1213 /* GEDSTBASE */
1214 SetReg2DAGP(0x34, (nDestBase >> 3));
1215 /* GEPITCH */
1216 SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000);
1217 /* BITBLT */
1218 SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000);
1219 }
1220 /* depth = 16, color = 32 */
1221 else if (vmesa->depth.bpp == 16) {
1222 GLuint EngStatus = *(vmesa->pnGEMode);
1223
1224 /* GEMODE */
1225 SetReg2DAGP(0x04, (EngStatus & 0xFFFFFCFF) | 0x100);
1226 /* GEMASK */
1227 SetReg2DAGP(0x2C, 0x0);
1228 /* GEFGCOLOR */
1229 SetReg2DAGP(0x18, pixel);
1230 /* GEWD */
1231 SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16));
1232 /* GEDST */
1233 SetReg2DAGP(0x0C, (offsetX | (0 << 16)));
1234 /* GEDSTBASE */
1235 SetReg2DAGP(0x34, (nDestBase >> 3));
1236 /* GEPITCH */
1237 SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000);
1238 /* BITBLT */
1239 SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000);
1240 /* GEMODE */
1241 SetReg2DAGP(0x04, EngStatus);
1242 }
1243 /* depth = 32, color = 16 */
1244 else {
1245 GLuint EngStatus = *(vmesa->pnGEMode);
1246
1247 /* GEMODE */
1248 SetReg2DAGP(0x04, (EngStatus & 0xFFFFFCFF) | 0x300);
1249 /* GEMASK */
1250 SetReg2DAGP(0x2C, 0x0);
1251 /* GEFGCOLOR */
1252 SetReg2DAGP(0x18, pixel);
1253 /* GEWD */
1254 SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16));
1255 /* GEDST */
1256 SetReg2DAGP(0x0C, (offsetX | (0 << 16)));
1257 /* GEDSTBASE */
1258 SetReg2DAGP(0x34, (nDestBase >> 3));
1259 /* GEPITCH */
1260 SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000);
1261 /* BITBLT */
1262 SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000);
1263 /* GEMODE */
1264 SetReg2DAGP(0x04, EngStatus);
1265 }
1266 }
1267
1268 if (vmesa->glCtx->Color._DrawDestMask == __GL_BACK_BUFFER_MASK) {
1269 viaFlushPrimsLocked(vmesa);
1270 }
1271 }
1272
1273 void viaDoSwapBuffers(viaContextPtr vmesa)
1274 {
1275 GLuint *vb = viaCheckDma(vmesa, vmesa->sarea->nbox*56);
1276 GLuint nFrontPitch;
1277 GLuint nBackPitch;
1278 GLuint nFrontWidth, nFrontHeight, nBackWidth, nBackHeight;
1279 GLuint nFrontBase, nBackBase;
1280 GLuint nFrontOffsetX, nFrontOffsetY, nBackOffsetX, nBackOffsetY;
1281 drm_clip_rect_t *b = vmesa->sarea->boxes;
1282 GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3;
1283 GLuint i;
1284
1285 nFrontPitch = vmesa->front.pitch;
1286 nBackPitch = vmesa->back.pitch;
1287
1288 /* Caculate Base */
1289 nFrontBase = vmesa->viaScreen->fbOffset + (vmesa->drawY * nFrontPitch + vmesa->drawX * bytePerPixel);
1290 nBackBase = vmesa->back.offset;
1291 /* 128 bit alignment*/
1292 nFrontBase = nFrontBase & 0xffffffe0;
1293
1294 /*=* [DBG] make draw to front buffer *=*/
1295 if(DRAW_FRONT)
1296 return;
1297
1298 for (i = 0; i < vmesa->sarea->nbox; i++) {
1299 /* Width, Height */
1300 nFrontWidth = nBackWidth = b->x2 - b->x1 - 1;
1301 nFrontHeight = nBackHeight = b->y2 - b->y1 - 1;
1302 /* Offset */
1303 nFrontOffsetX = (b->x1 - vmesa->drawX) + vmesa->drawXoff;
1304 nFrontOffsetY = b->y1 - vmesa->drawY;
1305
1306 nBackOffsetX = nFrontOffsetX;
1307 nBackOffsetY = nFrontOffsetY;
1308 /* GEWD */
1309 SetReg2DAGP(0x10, nFrontWidth | (nFrontHeight << 16));
1310 /* GEDST */
1311 SetReg2DAGP(0x0C, nFrontOffsetX | (nFrontOffsetY << 16));
1312 /* GESRC */
1313 SetReg2DAGP(0x08, nBackOffsetX | (nBackOffsetY << 16));
1314 /* GEDSTBASE */
1315 SetReg2DAGP(0x34, (nFrontBase >> 3));
1316 /* GESCRBASE */
1317 SetReg2DAGP(0x30, (nBackBase >> 3));
1318 /* GEPITCH */
1319 SetReg2DAGP(0x38, (((nFrontPitch >> 3) << 16) & 0x7FF0000) | 0x80000000 |
1320 ((nBackPitch >> 3) & 0x7FF));
1321 /* BITBLT */
1322 SetReg2DAGP(0x0, 0x1 | 0xCC000000);
1323 b++;
1324 }
1325
1326 viaFlushPrimsLocked(vmesa);
1327 #ifdef DEBUG
1328 if (VIA_DEBUG) fprintf(stderr, "Do Swap Buffer\n");
1329 #endif
1330 }
1331
1332 void viaDoSwapBuffersSaam(viaContextPtr vmesa)
1333 {
1334 GLuint *vb = viaCheckDma(vmesa, vmesa->sarea->nbox*56);
1335 GLuint nFrontPitch;
1336 GLuint nBackPitch;
1337 GLuint nFrontWidth, nFrontHeight, nBackWidth, nBackHeight;
1338 GLuint nFrontBase, nBackBase;
1339 GLuint nFrontOffsetX, nFrontOffsetY, nBackOffsetX, nBackOffsetY;
1340 drm_clip_rect_t *b = vmesa->sarea->boxes;
1341 GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3;
1342 GLuint i;
1343
1344 nFrontPitch = vmesa->front.pitch;
1345 nBackPitch = vmesa->back.pitch;
1346
1347 /* Caculate Base */
1348 nFrontBase = vmesa->viaScreen->fbSize + (vmesa->drawYSaam * nFrontPitch + vmesa->drawXSaam * bytePerPixel);
1349 nBackBase = vmesa->back.offset;
1350 /* 128 bit alignment*/
1351 nFrontBase = nFrontBase & 0xffffffe0;
1352
1353 /*=* [DBG] make draw to front buffer *=*/
1354 if(DRAW_FRONT)
1355 return;
1356
1357 for (i = 0; i < vmesa->sarea->nbox; i++) {
1358 /* Width, Height */
1359 nFrontWidth = nBackWidth = b->x2 - b->x1 - 1;
1360 nFrontHeight = nBackHeight = b->y2 - b->y1 - 1;
1361 /* Offset */
1362 nFrontOffsetX = (b->x1 - vmesa->drawXSaam) + vmesa->drawXoff;
1363 nFrontOffsetY = b->y1 - vmesa->drawYSaam;
1364
1365 nBackOffsetX = nFrontOffsetX;
1366 nBackOffsetY = nFrontOffsetY;
1367 /* GEWD */
1368 SetReg2DAGP(0x10, nFrontWidth | (nFrontHeight << 16));
1369 /* GEDST */
1370 SetReg2DAGP(0x0C, nFrontOffsetX | (nFrontOffsetY << 16));
1371 /* GESRC */
1372 SetReg2DAGP(0x08, nBackOffsetX | (nBackOffsetY << 16));
1373 /* GEDSTBASE */
1374 SetReg2DAGP(0x34, (nFrontBase >> 3));
1375 /* GESCRBASE */
1376 SetReg2DAGP(0x30, (nBackBase >> 3));
1377 /* GEPITCH */
1378 SetReg2DAGP(0x38, (((nFrontPitch >> 3) << 16) & 0x7FF0000) | 0x80000000 |
1379 ((nBackPitch >> 3) & 0x7FF));
1380 /* BITBLT */
1381 SetReg2DAGP(0x0, 0x1 | 0xCC000000);
1382 b++;
1383 }
1384
1385 viaFlushPrimsLocked(vmesa);
1386 #ifdef DEBUG
1387 if (VIA_DEBUG) fprintf(stderr, "Do Swap Buffer\n");
1388 #endif
1389 }
1390
1391 void viaDoSwapPBuffers(viaContextPtr vmesa)
1392 {
1393 GLuint *vb = viaCheckDma(vmesa, vmesa->sarea->nbox*56);
1394 GLuint nFrontPitch;
1395 GLuint nBackPitch;
1396 GLuint nFrontWidth, nFrontHeight;
1397 GLuint nFrontBase, nBackBase;
1398 GLuint nFrontOffsetX, nFrontOffsetY, nBackOffsetX, nBackOffsetY;
1399 GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3;
1400
1401 nFrontPitch = vmesa->front.pitch;
1402 nBackPitch = vmesa->back.pitch;
1403
1404 /* Caculate Base */
1405 nFrontBase = vmesa->front.offset;
1406 nBackBase = vmesa->back.offset;
1407
1408 /* Width, Height */
1409 nFrontWidth = nFrontPitch / bytePerPixel;
1410 nFrontHeight = nBackPitch / bytePerPixel;
1411
1412 /* Offset */
1413 nFrontOffsetX = 0;
1414 nFrontOffsetY = 0;
1415 nBackOffsetX = nFrontOffsetX;
1416 nBackOffsetY = nFrontOffsetY;
1417 /* GEWD */
1418 SetReg2DAGP(0x10, nFrontWidth | (nFrontHeight << 16));
1419 /* GEDST */
1420 SetReg2DAGP(0x0C, nFrontOffsetX | (nFrontOffsetY << 16));
1421 /* GESRC */
1422 SetReg2DAGP(0x08, nBackOffsetX | (nBackOffsetY << 16));
1423 /* GEDSTBASE */
1424 SetReg2DAGP(0x34, (nFrontBase >> 3));
1425 /* GESCRBASE */
1426 SetReg2DAGP(0x30, (nBackBase >> 3));
1427 /* GEPITCH */
1428 SetReg2DAGP(0x38, (((nFrontPitch >> 3) << 16) & 0x7FF0000) | 0x80000000 |
1429 ((nBackPitch >> 3) & 0x7FF));
1430 /* BITBLT */
1431 SetReg2DAGP(0x0, 0x1 | 0xCC000000);
1432
1433 viaFlushPrimsLocked(vmesa);
1434 #ifdef DEBUG
1435 if (VIA_DEBUG) fprintf(stderr, "Do Swap PBuffer\n");
1436 #endif
1437 }
1438
1439 void viaDoSwapBufferSoft(viaContextPtr vmesa)
1440 {
1441 GLuint nFrontPitch;
1442 GLuint nBackPitch;
1443 GLuint nFrontBase, nBackBase;
1444 GLuint i, j;
1445 GLubyte *by, *fy;
1446 GLuint w;
1447
1448 w = vmesa->viaScreen->width;
1449 w = BUFFER_ALIGN_WIDTH(w, BUFFER_ALIGNMENT);
1450
1451 if (vmesa->viaScreen->bitsPerPixel == 0x20)
1452 nFrontPitch = w << 2;
1453 else
1454 nFrontPitch = w << 1;
1455
1456 nBackPitch = vmesa->back.pitch;
1457
1458 /* Caculate Base */
1459 nFrontBase = (GLuint) vmesa->driScreen->pFB;
1460 nBackBase = ((GLuint) vmesa->back.offset) + ((GLuint) vmesa->driScreen->pFB);
1461 by = (GLubyte *) nBackBase;
1462 fy = (GLubyte *) nFrontBase;
1463
1464 viaFlushPrimsLocked(vmesa);
1465
1466 for (i = 0; i < vmesa->driDrawable->h; i++) {
1467 fy = (GLubyte *)(nFrontBase + i * nFrontPitch);
1468 for (j = 0; j < nBackPitch; j++) {
1469 *((GLubyte*)fy) = *((GLubyte*)by);
1470 fy = fy + 1;
1471 by = by + 1;
1472 }
1473
1474 }
1475
1476 }
1477
1478 void viaDoSwapBufferSoftFront(viaContextPtr vmesa)
1479 {
1480 GLuint nFrontPitch;
1481 GLuint nBackPitch;
1482 GLuint nFrontBase, nBackBase;
1483 GLuint i, j;
1484 GLubyte *by, *fy;
1485 GLuint w;
1486
1487 w = vmesa->viaScreen->width;
1488 w = BUFFER_ALIGN_WIDTH(w, BUFFER_ALIGNMENT);
1489
1490 if (vmesa->viaScreen->bitsPerPixel == 0x20)
1491 nFrontPitch = w << 2;
1492 else
1493 nFrontPitch = w << 1;
1494
1495 nBackPitch = vmesa->front.pitch;
1496
1497 /* Caculate Base */
1498 nFrontBase = (GLuint) vmesa->driScreen->pFB;
1499 nBackBase = ((GLuint) vmesa->front.offset) + ((GLuint) vmesa->driScreen->pFB);
1500 by = (GLubyte *) nBackBase;
1501 fy = (GLubyte *) nFrontBase;
1502
1503 viaFlushPrimsLocked(vmesa);
1504
1505 for (i = 0; i < vmesa->driDrawable->h; i++) {
1506 fy = (GLubyte *)(nFrontBase + i * nFrontPitch);
1507 for (j = 0; j < nBackPitch; j++) {
1508 *((GLubyte*)fy) = *((GLubyte*)by);
1509 fy = fy + 1;
1510 by = by + 1;
1511 }
1512
1513 }
1514
1515 }
1516 int flush_agp(viaContextPtr vmesa, drm_via_flush_agp_t* agpCmd)
1517 {
1518 GLuint *pnAGPCurrentPhysStart;
1519 GLuint *pnAGPCurrentPhysEnd;
1520 GLuint *pnAGPCurrentStart;
1521 GLuint *pnAGPCurrentEnd;
1522 volatile GLuint *pnMMIOBase;
1523 volatile GLuint *pnEngBaseTranSet;
1524 volatile GLuint *pnEngBaseTranSpace;
1525 GLuint *agpBase;
1526 GLuint ofs = vmesa->dma[vmesa->dmaIndex].offset;
1527 GLuint *vb = (GLuint *)vmesa->dmaAddr;
1528 GLuint i = 0;
1529
1530 pnMMIOBase = vmesa->regMMIOBase;
1531 pnEngBaseTranSet = vmesa->regTranSet;
1532 pnEngBaseTranSpace = vmesa->regTranSpace;
1533 *pnEngBaseTranSet = (0x0010 << 16);
1534 agpBase = vmesa->agpBase;
1535
1536 if (!agpCmd->size) {
1537 return -1;
1538 }
1539
1540 {
1541 volatile GLuint *pnEngBase = vmesa->regEngineStatus;
1542 int nStatus;
1543
1544 while (1) {
1545 nStatus = *pnEngBase;
1546 if ((nStatus & 0xFFFEFFFF) == 0x00020000)
1547 break;
1548 i++;
1549 }
1550 }
1551
1552 pnAGPCurrentStart = (GLuint *)(ofs + agpCmd->offset);
1553 pnAGPCurrentEnd = (GLuint *)((GLuint)pnAGPCurrentStart + vmesa->dmaHigh);
1554 pnAGPCurrentPhysStart = (GLuint *)( (GLuint)pnAGPCurrentStart + (GLuint)agpBase );
1555 pnAGPCurrentPhysEnd = (GLuint *)( (GLuint)pnAGPCurrentEnd + (GLuint)agpBase );
1556
1557 /*=* [DBG] make draw to front buffer *=*/
1558 if(DRAW_FRONT)
1559 vmesa->glCtx->Color._DrawDestMask = __GL_FRONT_BUFFER_MASK;
1560
1561 if (vmesa->glCtx->Color._DrawDestMask == __GL_BACK_BUFFER_MASK) {
1562
1563 *vb++ = HC_HEADER2;
1564 *vb++ = (HC_ParaType_NotTex << 16);
1565 if (vmesa->driDrawable->w == 0 || vmesa->driDrawable->h == 0) {
1566 *vb++ = (HC_SubA_HClipTB << 24) | 0x0;
1567 *vb++ = (HC_SubA_HClipLR << 24) | 0x0;
1568 }
1569 else {
1570 *vb++ = ((HC_SubA_HClipTB << 24) | (0x0 << 12) | vmesa->driDrawable->h);
1571 *vb++ = ((HC_SubA_HClipLR << 24) | (vmesa->drawXoff << 12) | (vmesa->driDrawable->w + vmesa->drawXoff));
1572 }
1573
1574 {
1575 GLuint pitch, format, offset;
1576
1577 if (vmesa->viaScreen->bitsPerPixel == 0x20) {
1578 format = HC_HDBFM_ARGB8888;
1579 }
1580 else if (vmesa->viaScreen->bitsPerPixel == 0x10) {
1581 format = HC_HDBFM_RGB565;
1582 }
1583 else
1584 {
1585 return -1;
1586 }
1587
1588 offset = vmesa->back.offset;
1589 pitch = vmesa->back.pitch;
1590
1591 *vb++ = ((HC_SubA_HDBBasL << 24) | (offset & 0xFFFFFF));
1592 *vb++ = ((HC_SubA_HDBBasH << 24) | ((offset & 0xFF000000)) >> 24);
1593 *vb++ = ((HC_SubA_HDBFM << 24) | HC_HDBLoc_Local | format | pitch);
1594 *vb++ = 0xcccccccc;
1595 }
1596
1597 *pnEngBaseTranSpace = (HC_SubA_HAGPBstL << 24) |
1598 ((GLuint)(pnAGPCurrentPhysStart) & 0xFFFFFF);
1599 *pnEngBaseTranSpace = (HC_SubA_HAGPBendL << 24) |
1600 ((GLuint)(pnAGPCurrentPhysEnd) & 0xFFFFFF);
1601 *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) |
1602 ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 |
1603 ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24;
1604 *pnEngBaseTranSpace = (HC_SubA_HAGPBpH << 24) |
1605 ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFF000000) >> 24;
1606 *pnEngBaseTranSpace = (HC_SubA_HAGPBpL << 24) |
1607 ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFFFFFF) |
1608 HC_HAGPBpID_STOP;
1609 *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) |
1610 ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 |
1611 ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24 |
1612 HC_HAGPCMNT_MASK;
1613 }
1614 else {
1615 GLuint *head;
1616 GLuint clipL, clipR, clipT, clipB;
1617 drm_clip_rect_t *b = vmesa->sarea->boxes;
1618 *vb++ = HC_HEADER2;
1619 *vb++ = (HC_ParaType_NotTex << 16);
1620 head = vb;
1621
1622 *pnEngBaseTranSpace = (HC_SubA_HAGPBstL << 24) |
1623 ((GLuint)(pnAGPCurrentPhysStart) & 0xFFFFFF);
1624 *pnEngBaseTranSpace = (HC_SubA_HAGPBendL << 24) |
1625 ((GLuint)(pnAGPCurrentPhysEnd) & 0xFFFFFF);
1626 *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) |
1627 ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 |
1628 ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24;
1629 *pnEngBaseTranSpace = (HC_SubA_HAGPBpH << 24) |
1630 ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFF000000) >> 24;
1631 *pnEngBaseTranSpace = (HC_SubA_HAGPBpL << 24) |
1632 ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFFFFFF) |
1633 HC_HAGPBpID_STOP;
1634
1635 for (i = 0; i < vmesa->sarea->nbox; i++) {
1636 if (1) {
1637 volatile GLuint *pnEngBase = vmesa->regEngineStatus;
1638 int nStatus;
1639
1640 while (1) {
1641 nStatus = *pnEngBase;
1642 if ((nStatus & 0xFFFEFFFF) == 0x00020000)
1643 break;
1644 }
1645 }
1646
1647 clipL = b->x1 + vmesa->drawXoff;
1648 clipR = b->x2;
1649 clipT = b->y1;
1650 clipB = b->y2;
1651 #ifdef DEBUG
1652 if (VIA_DEBUG) fprintf(stderr, "clip = %d\n", i);
1653 #endif
1654 if (vmesa->driDrawable->w == 0 || vmesa->driDrawable->h == 0) {
1655
1656 *vb = (HC_SubA_HClipTB << 24) | 0x0;
1657 vb++;
1658
1659 *vb = (HC_SubA_HClipLR << 24) | 0x0;
1660 vb++;
1661 }
1662 else {
1663 *vb = (HC_SubA_HClipTB << 24) | (clipT << 12) | clipB;
1664 vb++;
1665
1666 *vb = (HC_SubA_HClipLR << 24) | (clipL << 12) | clipR;
1667 vb++;
1668 }
1669
1670 {
1671 GLuint pitch, format, offset;
1672 GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3;
1673
1674 if (vmesa->viaScreen->bitsPerPixel == 0x20) {
1675 format = HC_HDBFM_ARGB8888;
1676 }
1677 else if (vmesa->viaScreen->bitsPerPixel == 0x10) {
1678 format = HC_HDBFM_RGB565;
1679 }
1680 else
1681 return -1;
1682
1683 pitch = vmesa->front.pitch;
1684 offset = vmesa->viaScreen->fbOffset + (vmesa->drawY * pitch + vmesa->drawX * bytePerPixel);
1685 offset = offset & 0xffffffe0;
1686
1687 *vb++ = ((HC_SubA_HDBBasL << 24) | (offset & 0xFFFFFF));
1688 *vb++ = ((HC_SubA_HDBBasH << 24) | ((offset & 0xFF000000)) >> 24);
1689 *vb++ = ((HC_SubA_HDBFM << 24) | HC_HDBLoc_Local | format | pitch);
1690 *vb++ = 0xcccccccc;
1691 }
1692 *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) |
1693 ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 |
1694 ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24 |
1695 HC_HAGPCMNT_MASK;
1696 #ifdef DEBUG
1697 if (VIA_DEBUG) {
1698 GLuint i;
1699 GLuint *data = (GLuint *)vmesa->dmaAddr;
1700 for (i = 0; i < vmesa->dmaLow; i += 16) {
1701 fprintf(stderr, "%08x ", *data++);
1702 fprintf(stderr, "%08x ", *data++);
1703 fprintf(stderr, "%08x ", *data++);
1704 fprintf(stderr, "%08x\n", *data++);
1705 }
1706 fprintf(stderr, "******************************************\n");
1707 }
1708 #endif
1709 b++;
1710 vb = head;
1711 }
1712 }
1713
1714 #ifdef DEBUG
1715 if (VIA_DEBUG) {
1716 volatile GLuint *pnEngBase = (volatile GLuint *)((GLuint)pnMMIOBase + 0x400);
1717 int nStatus;
1718 int i = 0;
1719
1720 while (1) {
1721 nStatus = *pnEngBase;
1722 if ((nStatus & 0xFFFEFFFF) == 0x00020000) {
1723 break;
1724 }
1725 else {
1726 GLuint j;
1727 GLuint *data;
1728 /* dump current command buffer */
1729 data = (GLuint *)vmesa->dmaAddr;
1730
1731 if (i == 500000) {
1732 fprintf(stderr, "current command buffer");
1733 fprintf(stderr, "i = %d\n", i);
1734 for (j = 0; j < vmesa->dmaLow; j += 16) {
1735 fprintf(stderr, "%08x ", *data++);
1736 fprintf(stderr, "%08x ", *data++);
1737 fprintf(stderr, "%08x ", *data++);
1738 fprintf(stderr, "%08x\n", *data++);
1739 }
1740 }
1741 /* dump previous command buffer */
1742 if (vmesa->dmaIndex) {
1743 data = (GLuint *)vmesa->dma[0].map;
1744 }
1745 else {
1746 data = (GLuint *)vmesa->dma[1].map;
1747 }
1748 if (i == 500000) {
1749 fprintf(stderr, "previous command buffer");
1750 fprintf(stderr, "i = %d\n", i);
1751 for (j = 0; j < dmaLow; j += 16) {
1752 fprintf(stderr, "%08x ", *data++);
1753 fprintf(stderr, "%08x ", *data++);
1754 fprintf(stderr, "%08x ", *data++);
1755 fprintf(stderr, "%08x\n", *data++);
1756 }
1757 }
1758 }
1759 i++;
1760 }
1761 }
1762 #endif
1763 dmaLow = vmesa->dmaLow;
1764 return 0;
1765 }
1766
1767 int flush_agp_saam(viaContextPtr vmesa, drm_via_flush_agp_t* agpCmd)
1768 {
1769 GLuint *pnAGPCurrentPhysStart;
1770 GLuint *pnAGPCurrentPhysEnd;
1771 GLuint *pnAGPCurrentStart;
1772 GLuint *pnAGPCurrentEnd;
1773 volatile GLuint *pnMMIOBase;
1774 volatile GLuint *pnEngBaseTranSet;
1775 volatile GLuint *pnEngBaseTranSpace;
1776 GLuint *agpBase;
1777 GLuint ofs = vmesa->dma[vmesa->dmaIndex].offset;
1778 GLuint *vb = (GLuint *)vmesa->dmaAddr;
1779 GLuint i = 0;
1780
1781 pnMMIOBase = vmesa->regMMIOBase;
1782 pnEngBaseTranSet = vmesa->regTranSet;
1783 pnEngBaseTranSpace = vmesa->regTranSpace;
1784 *pnEngBaseTranSet = (0x0010 << 16);
1785 agpBase = vmesa->agpBase;
1786
1787 if (!agpCmd->size) {
1788 return -1;
1789 }
1790
1791 {
1792 volatile GLuint *pnEngBase = vmesa->regEngineStatus;
1793 int nStatus;
1794
1795 while (1) {
1796 nStatus = *pnEngBase;
1797 if ((nStatus & 0xFFFEFFFF) == 0x00020000)
1798 break;
1799 i++;
1800 }
1801 }
1802
1803 pnAGPCurrentStart = (GLuint *)(ofs + agpCmd->offset);
1804 pnAGPCurrentEnd = (GLuint *)((GLuint)pnAGPCurrentStart + vmesa->dmaHigh);
1805 pnAGPCurrentPhysStart = (GLuint *)( (GLuint)pnAGPCurrentStart + (GLuint)agpBase );
1806 pnAGPCurrentPhysEnd = (GLuint *)( (GLuint)pnAGPCurrentEnd + (GLuint)agpBase );
1807
1808 /*=* [DBG] make draw to front buffer *=*/
1809 if(DRAW_FRONT)
1810 vmesa->glCtx->Color._DrawDestMask = __GL_FRONT_BUFFER_MASK;
1811
1812 if (vmesa->glCtx->Color._DrawDestMask == __GL_BACK_BUFFER_MASK) {
1813
1814 *vb++ = HC_HEADER2;
1815 *vb++ = (HC_ParaType_NotTex << 16);
1816 if (vmesa->driDrawable->w == 0 || vmesa->driDrawable->h == 0) {
1817 *vb++ = (HC_SubA_HClipTB << 24) | 0x0;
1818 *vb++ = (HC_SubA_HClipLR << 24) | 0x0;
1819 }
1820 else {
1821 *vb++ = ((HC_SubA_HClipTB << 24) | (0x0 << 12) | vmesa->driDrawable->h);
1822 *vb++ = ((HC_SubA_HClipLR << 24) | (vmesa->drawXoff << 12) | (vmesa->driDrawable->w + vmesa->drawXoff));
1823 }
1824
1825 {
1826 GLuint pitch, format, offset;
1827
1828 if (vmesa->viaScreen->bitsPerPixel == 0x20) {
1829 format = HC_HDBFM_ARGB8888;
1830 }
1831 else if (vmesa->viaScreen->bitsPerPixel == 0x10) {
1832 format = HC_HDBFM_RGB565;
1833 }
1834 else
1835 return -1;
1836
1837 offset = vmesa->back.offset;
1838 pitch = vmesa->back.pitch;
1839
1840 *vb++ = ((HC_SubA_HDBBasL << 24) | (offset & 0xFFFFFF));
1841 *vb++ = ((HC_SubA_HDBBasH << 24) | ((offset & 0xFF000000)) >> 24);
1842 *vb++ = ((HC_SubA_HDBFM << 24) | HC_HDBLoc_Local | format | pitch);
1843 *vb++ = 0xcccccccc;
1844 }
1845
1846 *pnEngBaseTranSpace = (HC_SubA_HAGPBstL << 24) |
1847 ((GLuint)(pnAGPCurrentPhysStart) & 0xFFFFFF);
1848 *pnEngBaseTranSpace = (HC_SubA_HAGPBendL << 24) |
1849 ((GLuint)(pnAGPCurrentPhysEnd) & 0xFFFFFF);
1850 *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) |
1851 ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 |
1852 ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24;
1853 *pnEngBaseTranSpace = (HC_SubA_HAGPBpH << 24) |
1854 ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFF000000) >> 24;
1855 *pnEngBaseTranSpace = (HC_SubA_HAGPBpL << 24) |
1856 ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFFFFFF) |
1857 HC_HAGPBpID_STOP;
1858 *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) |
1859 ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 |
1860 ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24 |
1861 HC_HAGPCMNT_MASK;
1862 }
1863 else {
1864 GLuint *head;
1865 GLuint clipL, clipR, clipT, clipB;
1866 drm_clip_rect_t *b = vmesa->sarea->boxes;
1867 *vb++ = HC_HEADER2;
1868 *vb++ = (HC_ParaType_NotTex << 16);
1869 head = vb;
1870
1871 *pnEngBaseTranSpace = (HC_SubA_HAGPBstL << 24) |
1872 ((GLuint)(pnAGPCurrentPhysStart) & 0xFFFFFF);
1873 *pnEngBaseTranSpace = (HC_SubA_HAGPBendL << 24) |
1874 ((GLuint)(pnAGPCurrentPhysEnd) & 0xFFFFFF);
1875 *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) |
1876 ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 |
1877 ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24;
1878 *pnEngBaseTranSpace = (HC_SubA_HAGPBpH << 24) |
1879 ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFF000000) >> 24;
1880 *pnEngBaseTranSpace = (HC_SubA_HAGPBpL << 24) |
1881 ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFFFFFF) |
1882 HC_HAGPBpID_STOP;
1883
1884 for (i = 0; i < vmesa->sarea->nbox; i++) {
1885 if (1) {
1886 volatile GLuint *pnEngBase = vmesa->regEngineStatus;
1887 int nStatus;
1888
1889 while (1) {
1890 nStatus = *pnEngBase;
1891 if ((nStatus & 0xFFFEFFFF) == 0x00020000)
1892 break;
1893 }
1894 }
1895
1896 clipL = b->x1 + vmesa->drawXoff;
1897 clipR = b->x2;
1898 clipT = b->y1;
1899 clipB = b->y2;
1900 #ifdef DEBUG
1901 if (VIA_DEBUG) fprintf(stderr, "clip = %d\n", i);
1902 #endif
1903 if (vmesa->driDrawable->w == 0 || vmesa->driDrawable->h == 0) {
1904
1905 *vb = (HC_SubA_HClipTB << 24) | 0x0;
1906 vb++;
1907
1908 *vb = (HC_SubA_HClipLR << 24) | 0x0;
1909 vb++;
1910 }
1911 else {
1912 *vb = (HC_SubA_HClipTB << 24) | (clipT << 12) | clipB;
1913 vb++;
1914
1915 *vb = (HC_SubA_HClipLR << 24) | (clipL << 12) | clipR;
1916 vb++;
1917 }
1918
1919 {
1920 GLuint pitch, format, offset;
1921 GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3;
1922
1923 if (vmesa->viaScreen->bitsPerPixel == 0x20) {
1924 format = HC_HDBFM_ARGB8888;
1925 }
1926 else if (vmesa->viaScreen->bitsPerPixel == 0x10) {
1927 format = HC_HDBFM_RGB565;
1928 }
1929 else
1930 return -1;
1931
1932 pitch = vmesa->front.pitch;
1933 offset = vmesa->viaScreen->fbOffset + (vmesa->drawY * pitch + vmesa->drawX * bytePerPixel);
1934 offset = offset & 0xffffffe0;
1935
1936 *vb++ = ((HC_SubA_HDBBasL << 24) | (offset & 0xFFFFFF));
1937 *vb++ = ((HC_SubA_HDBBasH << 24) | ((offset & 0xFF000000)) >> 24);
1938 *vb++ = ((HC_SubA_HDBFM << 24) | HC_HDBLoc_Local | format | pitch);
1939 *vb++ = 0xcccccccc;
1940 }
1941 *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) |
1942 ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 |
1943 ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24 |
1944 HC_HAGPCMNT_MASK;
1945 #ifdef DEBUG
1946 if (VIA_DEBUG) {
1947 GLuint i;
1948 GLuint *data = (GLuint *)vmesa->dmaAddr;
1949 for (i = 0; i < vmesa->dmaLow; i += 16) {
1950 fprintf(stderr, "%08x ", *data++);
1951 fprintf(stderr, "%08x ", *data++);
1952 fprintf(stderr, "%08x ", *data++);
1953 fprintf(stderr, "%08x\n", *data++);
1954 }
1955 fprintf(stderr, "******************************************\n");
1956 }
1957 #endif
1958 b++;
1959 vb = head;
1960 }
1961 }
1962
1963 #ifdef DEBUG
1964 if (VIA_DEBUG) {
1965 volatile GLuint *pnEngBase = (GLuint *)((GLuint)pnMMIOBase + 0x400);
1966 int nStatus;
1967 int i = 0;
1968
1969 while (1) {
1970 nStatus = *pnEngBase;
1971 if ((nStatus & 0xFFFEFFFF) == 0x00020000) {
1972 break;
1973 }
1974 else {
1975 GLuint j;
1976 GLuint *data;
1977 /* dump current command buffer */
1978 data = (GLuint *)vmesa->dmaAddr;
1979
1980 if (i == 500000) {
1981 fprintf(stderr, "current command buffer");
1982 fprintf(stderr, "i = %d\n", i);
1983 for (j = 0; j < vmesa->dmaLow; j += 16) {
1984 fprintf(stderr, "%08x ", *data++);
1985 fprintf(stderr, "%08x ", *data++);
1986 fprintf(stderr, "%08x ", *data++);
1987 fprintf(stderr, "%08x\n", *data++);
1988 }
1989 }
1990 /* dump previous command buffer */
1991 if (vmesa->dmaIndex) {
1992 data = (GLuint *)vmesa->dma[0].map;
1993 }
1994 else {
1995 data = (GLuint *)vmesa->dma[1].map;
1996 }
1997 if (i == 500000) {
1998 fprintf(stderr, "previous command buffer");
1999 fprintf(stderr, "i = %d\n", i);
2000 for (j = 0; j < dmaLow; j += 16) {
2001 fprintf(stderr, "%08x ", *data++);
2002 fprintf(stderr, "%08x ", *data++);
2003 fprintf(stderr, "%08x ", *data++);
2004 fprintf(stderr, "%08x\n", *data++);
2005 }
2006 }
2007 }
2008 i++;
2009 }
2010 }
2011 #endif
2012 dmaLow = vmesa->dmaLow;
2013 return 0;
2014 }
2015
2016 int flush_sys(viaContextPtr vmesa, drm_via_flush_sys_t* buf)
2017
2018 {
2019 GLuint *pnBuf;
2020 GLuint *pnEnd;
2021 volatile GLuint *pnMMIOBase;
2022 volatile GLuint *pnEngBaseTranSet;
2023 volatile GLuint *pnEngBaseTranSpace;
2024 GLuint uCheck2DCmd = GL_TRUE;
2025 GLuint addr;
2026 GLuint *vb = (GLuint *)vmesa->dmaAddr;
2027 GLuint i = 0;
2028
2029 pnMMIOBase = vmesa->regMMIOBase;
2030 pnEngBaseTranSet = vmesa->regTranSet;
2031 pnEngBaseTranSpace = vmesa->regTranSpace;
2032
2033 pnBuf = (GLuint *)(buf->index + buf->offset);
2034 pnEnd = (GLuint *)((GLuint)pnBuf + buf->size);
2035
2036 /*=* [DBG] make draw to front buffer *=*/
2037 if(DRAW_FRONT)
2038 vmesa->glCtx->Color._DrawDestMask = __GL_FRONT_BUFFER_MASK;
2039
2040
2041 /*=* John Sheng [2003.6.20] fix pci *=*/
2042 {
2043 volatile GLuint *pnEngBase = vmesa->regEngineStatus;
2044 int nStatus;
2045
2046 while (1) {
2047 nStatus = *pnEngBase;
2048 if ((nStatus & 0xFFFEFFFF) == 0x00020000)
2049 break;
2050 i++;
2051 }
2052 }
2053 /*=* John Sheng [2003.12.9] Tuxracer & VQ *=*/
2054 /*=* Disable VQ *=*/
2055 if (vmesa->VQEnable)
2056 {
2057 WAIT_IDLE
2058 *vmesa->regTranSet = 0x00fe0000;
2059 *vmesa->regTranSet = 0x00fe0000;
2060 *vmesa->regTranSpace = 0x00000004;
2061 *vmesa->regTranSpace = 0x40008c0f;
2062 *vmesa->regTranSpace = 0x44000000;
2063 *vmesa->regTranSpace = 0x45080c04;
2064 *vmesa->regTranSpace = 0x46800408;
2065 vmesa->VQEnable = 0;
2066 }
2067 if (vmesa->glCtx->Color._DrawDestMask == __GL_BACK_BUFFER_MASK) {
2068 *vb++ = HC_HEADER2;
2069 *vb++ = (HC_ParaType_NotTex << 16);
2070
2071 if (vmesa->driDrawable->w == 0 || vmesa->driDrawable->h == 0) {
2072 *vb++ = (HC_SubA_HClipTB << 24) | 0x0;
2073 *vb++ = (HC_SubA_HClipLR << 24) | 0x0;
2074 }
2075 else {
2076 *vb++ = ((HC_SubA_HClipTB << 24) | (0x0 << 12) | vmesa->driDrawable->h);
2077 *vb++ = ((HC_SubA_HClipLR << 24) | (vmesa->drawXoff << 12) | (vmesa->driDrawable->w + vmesa->drawXoff));
2078 }
2079
2080 /*=* John Sheng [2003.6.16] fix pci path *=*/
2081 {
2082 GLuint pitch, format, offset;
2083
2084 if (vmesa->viaScreen->bitsPerPixel == 0x20) {
2085 format = HC_HDBFM_ARGB8888;
2086 }
2087 else if (vmesa->viaScreen->bitsPerPixel == 0x10) {
2088 format = HC_HDBFM_RGB565;
2089 }
2090 else
2091 return -1;
2092
2093 offset = vmesa->back.offset;
2094 pitch = vmesa->back.pitch;
2095
2096 *vb++ = ((HC_SubA_HDBBasL << 24) | (offset & 0xFFFFFF));
2097 *vb++ = ((HC_SubA_HDBBasH << 24) | ((offset & 0xFF000000)) >> 24);
2098 *vb++ = ((HC_SubA_HDBFM << 24) | HC_HDBLoc_Local | format | pitch);
2099 *vb++ = 0xcccccccc;
2100 }
2101
2102 while (pnBuf != pnEnd) {
2103 if (*pnBuf == HALCYON_HEADER2) {
2104 pnBuf++;
2105 if (*pnBuf == HALCYON_SUB_ADDR0) {
2106 *pnEngBaseTranSet = *pnBuf;
2107 pnBuf++;
2108 uCheck2DCmd = GL_FALSE;
2109 }
2110 else {
2111 *pnEngBaseTranSet = *pnBuf;
2112 pnBuf++;
2113 uCheck2DCmd = GL_TRUE;
2114 }
2115 }
2116 else if (uCheck2DCmd && ((*pnBuf&HALCYON_HEADER1MASK)==HALCYON_HEADER1)) {
2117 addr = ((*pnBuf)&0x0000001f) << 2;
2118 pnBuf++;
2119 *((GLuint*)((GLuint)pnMMIOBase+addr)) = *pnBuf;
2120 pnBuf++;
2121 }
2122 else if ((*pnBuf&HALCYON_FIREMASK) == HALCYON_FIRECMD) {
2123 *pnEngBaseTranSpace = *pnBuf;
2124 pnBuf++;
2125 if ((pnBuf!=pnEnd)&&((*pnBuf&HALCYON_FIREMASK)==HALCYON_FIRECMD))
2126 pnBuf++;
2127 if ((*pnBuf&HALCYON_CMDBMASK) != HC_ACMD_HCmdB)
2128 uCheck2DCmd = GL_TRUE;
2129 }
2130 else {
2131 *pnEngBaseTranSpace = *pnBuf;
2132 pnBuf++;
2133 }
2134 }
2135 }
2136 else {
2137 GLuint *head;
2138 GLuint clipL, clipR, clipT, clipB;
2139 drm_clip_rect_t *b = vmesa->sarea->boxes;
2140 GLuint *pnTmp;
2141
2142 *vb++ = HC_HEADER2;
2143 *vb++ = (HC_ParaType_NotTex << 16);
2144
2145 head = vb;
2146 pnTmp = pnBuf;
2147
2148 for (i = 0; i < vmesa->sarea->nbox; i++) {
2149 clipL = b->x1 + vmesa->drawXoff;
2150 clipR = b->x2 + vmesa->drawXoff;
2151 clipT = b->y1;
2152 clipB = b->y2;
2153
2154 if (vmesa->driDrawable->w == 0 || vmesa->driDrawable->h == 0) {
2155 *vb = (HC_SubA_HClipTB << 24) | 0x0;
2156 vb++;
2157 *vb = (HC_SubA_HClipLR << 24) | 0x0;
2158 vb++;
2159 }
2160 else {
2161 *vb = (HC_SubA_HClipTB << 24) | (clipT << 12) | clipB;
2162 vb++;
2163 *vb = (HC_SubA_HClipLR << 24) | (clipL << 12) | clipR;
2164 vb++;
2165 }
2166
2167 /*=* John Sheng [2003.6.16] fix pci path *=*/
2168 {
2169 GLuint pitch, format, offset;
2170 GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3;
2171
2172 if (vmesa->viaScreen->bitsPerPixel == 0x20) {
2173 format = HC_HDBFM_ARGB8888;
2174 }
2175 else if (vmesa->viaScreen->bitsPerPixel == 0x10) {
2176 format = HC_HDBFM_RGB565;
2177 }
2178 else
2179 return -1;
2180
2181 pitch = vmesa->front.pitch;
2182 offset = vmesa->viaScreen->fbOffset + (vmesa->drawY * pitch + vmesa->drawX * bytePerPixel);
2183 offset = offset & 0xffffffe0;
2184
2185 *vb++ = ((HC_SubA_HDBBasL << 24) | (offset & 0xFFFFFF));
2186 *vb++ = ((HC_SubA_HDBBasH << 24) | ((offset & 0xFF000000)) >> 24);
2187 *vb++ = ((HC_SubA_HDBFM << 24) | HC_HDBLoc_Local | format | pitch);
2188 *vb++ = 0xcccccccc;
2189 }
2190
2191 pnBuf = pnTmp;
2192
2193 while (pnBuf != pnEnd) {
2194 if (*pnBuf == HALCYON_HEADER2) {
2195 pnBuf++;
2196 if (*pnBuf == HALCYON_SUB_ADDR0) {
2197 *pnEngBaseTranSet = *pnBuf;
2198 pnBuf++;
2199 uCheck2DCmd = GL_FALSE;
2200 }
2201 else {
2202 *pnEngBaseTranSet = *pnBuf;
2203 pnBuf++;
2204 uCheck2DCmd = GL_TRUE;
2205 }
2206 }
2207 else if (uCheck2DCmd && ((*pnBuf&HALCYON_HEADER1MASK)==HALCYON_HEADER1)) {
2208 addr = ((*pnBuf)&0x0000001f) << 2;
2209 pnBuf++;
2210 *((GLuint*)((GLuint)pnMMIOBase+addr)) = *pnBuf;
2211 pnBuf++;
2212 }
2213 else if ((*pnBuf&HALCYON_FIREMASK) == HALCYON_FIRECMD) {
2214 *pnEngBaseTranSpace = *pnBuf;
2215 pnBuf++;
2216 if ((pnBuf!=pnEnd)&&((*pnBuf&HALCYON_FIREMASK)==HALCYON_FIRECMD))
2217 pnBuf++;
2218 if ((*pnBuf&HALCYON_CMDBMASK) != HC_ACMD_HCmdB)
2219 uCheck2DCmd = GL_TRUE;
2220 }
2221 else {
2222 *pnEngBaseTranSpace = *pnBuf;
2223 pnBuf++;
2224 }
2225 }
2226 b++;
2227 vb = head;
2228 }
2229 }
2230 /*=* John Sheng [2003.6.20] debug pci *=*/
2231 if (VIA_DEBUG) {
2232 GLuint *pnEngBase = (GLuint *)((GLuint)pnMMIOBase + 0x400);
2233 int nStatus;
2234 int i = 0;
2235
2236 while (1) {
2237 nStatus = *pnEngBase;
2238 if ((nStatus & 0xFFFEFFFF) == 0x00020000) {
2239 break;
2240 }
2241 else {
2242 GLuint j;
2243 GLuint *data;
2244 /*=* John Sheng [2003.12.9] Tuxracer & VQ *=*/
2245 GLuint k;
2246 GLuint *ES;
2247
2248 data = (GLuint *)vmesa->dmaAddr;
2249 ES = pnEngBase;
2250
2251 if (i == 500000) {
2252 /*=* John Sheng [2003.12.9] Tuxracer & VQ *=*/
2253 for (k =0 ; k < 35; k++) {
2254 fprintf(stderr, "%02xh - %02xh\n", k*4 + 3, k*4);
2255 fprintf(stderr, "%08x\n", *ES);
2256 ES++;
2257 }
2258 fprintf(stderr, "current command buffer");
2259 fprintf(stderr, "i = %d\n", i);
2260 for (j = 0; j < vmesa->dmaLow; j += 16) {
2261 fprintf(stderr, "%08x ", *data++);
2262 fprintf(stderr, "%08x ", *data++);
2263 fprintf(stderr, "%08x ", *data++);
2264 fprintf(stderr, "%08x\n", *data++);
2265 }
2266 }
2267 if (vmesa->dmaIndex) {
2268 data = (GLuint *)vmesa->dma[0].map;
2269 }
2270 else {
2271 data = (GLuint *)vmesa->dma[1].map;
2272 }
2273 if (i == 500000) {
2274 fprintf(stderr, "previous command buffer");
2275 fprintf(stderr, "i = %d\n", i);
2276 for (j = 0; j < dmaLow; j += 16) {
2277 fprintf(stderr, "%08x ", *data++);
2278 fprintf(stderr, "%08x ", *data++);
2279 fprintf(stderr, "%08x ", *data++);
2280 fprintf(stderr, "%08x\n", *data++);
2281 }
2282 }
2283 }
2284 i++;
2285 }
2286 }
2287 dmaLow = vmesa->dmaLow;
2288 return 0;
2289 }