diff options
Diffstat (limited to 'src/mesa/drivers/dri/unichrome/via_ioctl.c')
| -rw-r--r-- | src/mesa/drivers/dri/unichrome/via_ioctl.c | 2217 |
1 files changed, 2217 insertions, 0 deletions
diff --git a/src/mesa/drivers/dri/unichrome/via_ioctl.c b/src/mesa/drivers/dri/unichrome/via_ioctl.c new file mode 100644 index 00000000000..04dc130d3f1 --- /dev/null +++ b/src/mesa/drivers/dri/unichrome/via_ioctl.c @@ -0,0 +1,2217 @@ +#/* + * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved. + * Copyright 2001-2003 S3 Graphics, Inc. All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sub license, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial portions + * of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL + * VIA, S3 GRAPHICS, AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ +#include <stdio.h> +#include <unistd.h> + +#include "glheader.h" +#include "mtypes.h" +#include "macros.h" +#include "dd.h" +#include "swrast/swrast.h" + +#include "mm.h" +#include "via_context.h" +#include "via_ioctl.h" +#include "via_state.h" + +#include "drm.h" +#include <sys/ioctl.h> + +GLuint FrameCount = 0; +GLuint dmaLow = 0; +/*=* John Sheng [2003.5.31] flip *=*/ +GLuint nFirstSwap = GL_TRUE; +GLuint nFirstFlip = GL_TRUE; +#define SetReg2DAGP(nReg, nData) { \ + *((GLuint *)(vb)) = ((nReg) >> 2) | 0xF0000000; \ + *((GLuint *)(vb) + 1) = (nData); \ + vb += 2; \ + vmesa->dmaLow +=8; \ +} + +#define DEPTH_SCALE ((1 << 16) - 1) + +static void viaClear(GLcontext *ctx, GLbitfield mask, GLboolean all, + GLint cx, GLint cy, GLint cw, GLint ch) +{ + viaContextPtr vmesa = VIA_CONTEXT(ctx); + __DRIdrawablePrivate *dPriv = vmesa->driDrawable; + const GLuint colorMask = *((GLuint *)&ctx->Color.ColorMask); + int flag = 0; + GLuint scrn = 0, i = 0, side = 0; + scrn = vmesa->saam & S_MASK; + side = vmesa->saam & P_MASK; +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__); +#endif + VIA_FIREVERTICES(vmesa); + + if ((mask & DD_FRONT_LEFT_BIT) && colorMask == ~0) { + flag |= VIA_FRONT; + mask &= ~DD_FRONT_LEFT_BIT; + } + + if ((mask & DD_BACK_LEFT_BIT) && colorMask == ~0) { + flag |= VIA_BACK; + mask &= ~DD_BACK_LEFT_BIT; + } + + if (mask & DD_DEPTH_BIT) { + if (ctx->Depth.Mask) + flag |= VIA_DEPTH; + mask &= ~DD_DEPTH_BIT; + } + + if (mask & DD_STENCIL_BIT) { + if (ctx->Stencil.Enabled) + flag |= VIA_STENCIL; + mask &= ~DD_STENCIL_BIT; + } + + /*=* [DBG] make draw to front buffer *=*/ + if(DRAW_FRONT) { + flag |= VIA_FRONT; + flag &= ~VIA_BACK; + } + + if (flag) { + LOCK_HARDWARE(vmesa); + /* flip top to bottom */ + cy = dPriv->h - cy - ch; + cx += vmesa->drawX; + cy += vmesa->drawY; + + if (vmesa->numClipRects) { + int nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, vmesa->numClipRects); + XF86DRIClipRectRec *box = vmesa->pClipRects; + drm_clip_rect_t *b = vmesa->sarea->boxes; + int n = 0; + + if (!vmesa->saam) { + if (!all) { +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr,"!all"); +#endif + for (; i < nr; i++) { + GLint x = box[i].x1; + GLint y = box[i].y1; + GLint w = box[i].x2 - x; + GLint h = box[i].y2 - y; + + if (x < cx) w -= cx - x, x = cx; + if (y < cy) h -= cy - y, y = cy; + if (x + w > cx + cw) w = cx + cw - x; + if (y + h > cy + ch) h = cy + ch - y; + if (w <= 0) continue; + if (h <= 0) continue; + + b->x1 = x; + b->y1 = y; + b->x2 = x + w; + b->y2 = y + h; + b++; + n++; + } + } + else { + for (; i < nr; i++) { + *b++ = *(drm_clip_rect_t *)&box[i]; + n++; + } + } + vmesa->sarea->nbox = n; + } + else { + GLuint scrn = 0; + scrn = vmesa->saam & S_MASK; + + if (scrn == S0 || scrn == S1) { + if (!all) { + for (; i < nr; i++) { + GLint x = box[i].x1; + GLint y = box[i].y1; + GLint w = box[i].x2 - x; + GLint h = box[i].y2 - y; + + if (x < cx) w -= cx - x, x = cx; + if (y < cy) h -= cy - y, y = cy; + if (x + w > cx + cw) w = cx + cw - x; + if (y + h > cy + ch) h = cy + ch - y; + if (w <= 0) continue; + if (h <= 0) continue; + + b->x1 = x; + b->y1 = y; + b->x2 = x + w; + b->y2 = y + h; + b++; + n++; + } + } + else { + for (; i < nr; i++) { + *b++ = *(drm_clip_rect_t *)&box[i]; + n++; + } + } + vmesa->sarea->nbox = n; + } + /* between */ + else { + if (!all) { + for (; i < nr; i++) { + GLint x = box[i].x1; + GLint y = box[i].y1; + GLint w = box[i].x2 - x; + GLint h = box[i].y2 - y; + + if (x < cx) w -= cx - x, x = cx; + if (y < cy) h -= cy - y, y = cy; + if (x + w > cx + cw) w = cx + cw - x; + if (y + h > cy + ch) h = cy + ch - y; + if (w <= 0) continue; + if (h <= 0) continue; + + b->x1 = x; + b->y1 = y; + b->x2 = x + w; + b->y2 = y + h; + b++; + n++; + } + + } + else { + for (; i < nr; i++) { + *b++ = *(drm_clip_rect_t *)&box[n]; + n++; + } + } + *b++ = *(drm_clip_rect_t *)vmesa->pSaamRects; + vmesa->sarea->nbox = n; + } + } + + { + if (flag & VIA_FRONT) { + + if (vmesa->drawType == GLX_PBUFFER_BIT) + viaFillFrontPBuffer(vmesa); + else + viaFillFrontBuffer(vmesa); + + if (vmesa->saam && (scrn == (S0 | S1))) { + nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, vmesa->numSaamRects); + box = vmesa->pSaamRects; + b = vmesa->sarea->boxes; + n = 0; + + for (i = 0; i < nr; i++) { + *b++ = *(drm_clip_rect_t *)&box[n]; + n++; + } + + vmesa->sarea->nbox = n; + viaFillFrontBufferSaam(vmesa); + } + } + + if (flag & VIA_BACK) { + viaFillBackBuffer(vmesa); + } + + if (flag & VIA_DEPTH) { + double depth_clamp, range = 0xffffffff; + if (vmesa->hasStencil == 0) { + if (vmesa->depthBits == 32) { + depth_clamp = ((double)ctx->Depth.Clear)*range; + viaFillDepthBuffer(vmesa, (GLuint)depth_clamp); + } + else { + depth_clamp = ((double)ctx->Depth.Clear)*range; + viaFillDepthBuffer(vmesa, (GLuint)depth_clamp); + } + } + else { + depth_clamp = ((double)ctx->Depth.Clear)*range; + viaFillStencilDepthBuffer(vmesa, (GLuint)depth_clamp); + } + } + /*=* [DBG] Fix tuxracer depth error *=*/ + else if (flag & VIA_STENCIL) { + viaFillStencilBuffer(vmesa, (GLuint)ctx->Stencil.Clear); + } + } + } + UNLOCK_HARDWARE(vmesa); + vmesa->uploadCliprects = GL_TRUE; + } + + if (mask) + _swrast_Clear(ctx, mask, all, cx, cy, cw, ch); +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__); +#endif +} + +/* + * Copy the back buffer to the front buffer. + */ +void viaCopyBuffer(const __DRIdrawablePrivate *dPriv) +{ + viaContextPtr vmesa; + XF86DRIClipRectPtr pbox; + int nbox, i; + GLuint scrn = 0, side = 0; +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__); +#endif + assert(dPriv); + assert(dPriv->driContextPriv); + assert(dPriv->driContextPriv->driverPrivate); + + vmesa = (viaContextPtr)dPriv->driContextPriv->driverPrivate; + + VIA_FIREVERTICES(vmesa); + LOCK_HARDWARE(vmesa); + + scrn = vmesa->saam & S_MASK; + side = vmesa->saam & P_MASK; + + pbox = vmesa->pClipRects; + nbox = vmesa->numClipRects; + +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s %d cliprects (%d), SAAM (%d)\n", + __FUNCTION__, nbox, vmesa->drawType, vmesa->saam); +#endif + + + if (vmesa->drawType == GLX_PBUFFER_BIT) { + viaDoSwapPBuffers(vmesa); +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s SwapPBuffers\n", __FUNCTION__); +#endif /*=* [DBG] for pbuffer *=*/ + /*viaDoSwapBufferSoftFront(vmesa);*/ + } + else { + GLuint scrn = 0; + scrn = vmesa->saam & S_MASK; + if (!vmesa->saam) { + for (i = 0; i < nbox; ) { + int nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, dPriv->numClipRects); + XF86DRIClipRectRec *b = (XF86DRIClipRectRec *)vmesa->sarea->boxes; + + vmesa->sarea->nbox = nr - i; + + for (; i < nr; i++) + *b++ = pbox[i]; + viaDoSwapBuffers(vmesa); +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s SwapBuffers\n", __FUNCTION__); +#endif + } + } + else if (scrn == S0 || scrn == S1) { + for (i = 0; i < nbox; ) { + int nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, vmesa->numClipRects); + XF86DRIClipRectRec *b = (XF86DRIClipRectRec *)vmesa->sarea->boxes; + + vmesa->sarea->nbox = nr - i; + + for (; i < nr; i++) { + *b++ = pbox[i]; + } + viaDoSwapBuffers(vmesa); + } + } + /* between */ + else { + for (i = 0; i < nbox; ) { + int nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, dPriv->numClipRects); + XF86DRIClipRectRec *b = (XF86DRIClipRectRec *)vmesa->sarea->boxes; + + vmesa->sarea->nbox = nr - i; + + for (; i < nr; i++) + *b++ = pbox[i]; + viaDoSwapBuffers(vmesa); + } + + pbox = vmesa->pSaamRects; + nbox = vmesa->numSaamRects; + + for (i = 0; i < nbox; ) { + int nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, vmesa->numSaamRects); + XF86DRIClipRectRec *b = (XF86DRIClipRectRec *)vmesa->sarea->boxes; + + vmesa->sarea->nbox = nr - i; + + for (; i < nr; i++) + *b++ = pbox[i]; + + viaDoSwapBuffersSaam(vmesa); + } + } + } + UNLOCK_HARDWARE(vmesa); + vmesa->uploadCliprects = GL_TRUE; +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__); +#endif +} + +/* + * XXX implement when full-screen extension is done. + */ +void viaPageFlip(const __DRIdrawablePrivate *dPriv) +{ + /*=* John Sheng [2003.5.31] flip *=*/ + viaContextPtr vmesa = (viaContextPtr)dPriv->driContextPriv->driverPrivate; + GLuint *vb = viaCheckDma(vmesa, vmesa->sarea->nbox*56); + GLuint nBackBase; + viaBuffer buffer_tmp; + GLcontext *ctx; + +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s - in\n", __FUNCTION__); +#endif + assert(dPriv); + assert(dPriv->driContextPriv); + assert(dPriv->driContextPriv->driverPrivate); + + ctx = vmesa->glCtx; + + /*=* [DBG] make draw to front buffer *=*/ + if(DRAW_FRONT) + return; + + /* Page Flip*/ + if(GL_FALSE) { + viaFlushPrimsLocked(vmesa); + while ((*(volatile GLuint *)((GLuint)vmesa->regMMIOBase + 0x200) & 0x2) != 0x2); + while (*(volatile GLuint *)((GLuint)vmesa->regMMIOBase + 0x200) & 0x2); + nBackBase = vmesa->back.offset >> 1; + + /*if (nFirstFlip) { + *vb++ = HALCYON_HEADER2; + *vb++ = 0x00fe0000; + *vb++ = 0x00001004; + *vb++ = 0x00001004; + vmesa->dmaLow += 16; + + nFirstFlip = GL_FALSE; + } + SetReg2DAGP(0x214, nBackBase); + viaFlushPrimsLocked(vmesa);*/ + if (nFirstFlip) { + *((volatile GLuint *)((GLuint)vmesa->regMMIOBase + 0x43c)) = 0x00fe0000; + *((volatile GLuint *)((GLuint)vmesa->regMMIOBase + 0x440)) = 0x00001004; + nFirstFlip = GL_FALSE; + } + *((GLuint *)((GLuint)vmesa->regMMIOBase + 0x214)) = nBackBase; + } + /* Auto Swap */ + else { + viaFlushPrimsLocked(vmesa); + vb = viaCheckDma(vmesa, vmesa->sarea->nbox*56); + if (nFirstSwap) { + *vb++ = HALCYON_HEADER2; + *vb++ = 0x00fe0000; + *vb++ = 0x0000000e; + *vb++ = 0x0000000e; + vmesa->dmaLow += 16; + + nFirstSwap = GL_FALSE; + } + nBackBase = (vmesa->back.offset << 1); + + *vb++ = HALCYON_HEADER2; + *vb++ = 0x00fe0000; + *vb++ = (HC_SubA_HFBBasL << 24) | (nBackBase & 0xFFFFF8) | 0x2; + *vb++ = (HC_SubA_HFBDrawFirst << 24) | + ((nBackBase & 0xFF000000) >> 24) | 0x0100; + vmesa->dmaLow += 16; + viaFlushPrimsLocked(vmesa); + } + + + memcpy(&buffer_tmp, &vmesa->back, sizeof(viaBuffer)); + memcpy(&vmesa->back, &vmesa->front, sizeof(viaBuffer)); + memcpy(&vmesa->front, &buffer_tmp, sizeof(viaBuffer)); + + if(vmesa->currentPage) { + vmesa->currentPage = 0; + if (vmesa->glCtx->Color._DrawDestMask & BACK_LEFT_BIT) { + ctx->Driver.DrawBuffer(ctx, GL_BACK_LEFT); + } + else { + ctx->Driver.DrawBuffer(ctx, GL_FRONT_LEFT); + } + } + else { + vmesa->currentPage = 1; + if (vmesa->glCtx->Color._DrawDestMask & BACK_LEFT_BIT) { + ctx->Driver.DrawBuffer(ctx, GL_BACK_LEFT); + } + else { + ctx->Driver.DrawBuffer(ctx, GL_FRONT_LEFT); + } + } +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s - out\n", __FUNCTION__); +#endif + +} + +/* This waits for *everybody* to finish rendering -- overkill. + */ +void viaDmaFinish(viaContextPtr vmesa) +{ +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__); +#endif + VIA_FIREVERTICES(vmesa); + LOCK_HARDWARE(vmesa); + UNLOCK_HARDWARE(vmesa); +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__); +#endif +} + +void viaRegetLockQuiescent(viaContextPtr vmesa) +{ + drmUnlock(vmesa->driFd, vmesa->hHWContext); +} + +static int intersect_rect(drm_clip_rect_t *out, + drm_clip_rect_t *a, + drm_clip_rect_t *b) +{ + *out = *a; + + if (b->x1 > out->x1) out->x1 = b->x1; + if (b->x2 < out->x2) out->x2 = b->x2; + if (out->x1 >= out->x2) return 0; + + if (b->y1 > out->y1) out->y1 = b->y1; + if (b->y2 < out->y2) out->y2 = b->y2; + if (out->y1 >= out->y2) return 0; + + return 1; +} + +void viaFlushPrimsLocked(viaContextPtr vmesa) +{ + drm_clip_rect_t *pbox = (drm_clip_rect_t *)vmesa->pClipRects; + int nbox = vmesa->numClipRects; + drm_via_sarea_t *sarea = vmesa->sarea; + drm_via_flush_agp_t agpCmd; + drm_via_flush_sys_t sysCmd; + GLuint *vb = viaCheckDma(vmesa, 0); + int i; + + if (vmesa->dmaLow == DMA_OFFSET) { + return; + } + if (vmesa->dmaLow > 2097152) + fprintf(stderr, "buffer overflow in Flush Prims = %d\n",vmesa->dmaLow); + + switch (vmesa->dmaLow & 0x1F) { + case 8: + *vb++ = HC_HEADER2; + *vb++ = (HC_ParaType_NotTex << 16); + *vb++ = HC_DUMMY; + *vb++ = HC_DUMMY; + *vb++ = HC_DUMMY; + *vb++ = HC_DUMMY; + vmesa->dmaLow += 24; + break; + case 16: + *vb++ = HC_HEADER2; + *vb++ = (HC_ParaType_NotTex << 16); + *vb++ = HC_DUMMY; + *vb++ = HC_DUMMY; + vmesa->dmaLow += 16; + break; + case 24: + *vb++ = HC_HEADER2; + *vb++ = (HC_ParaType_NotTex << 16); + *vb++ = HC_DUMMY; + *vb++ = HC_DUMMY; + *vb++ = HC_DUMMY; + *vb++ = HC_DUMMY; + *vb++ = HC_DUMMY; + *vb++ = HC_DUMMY; + *vb++ = HC_DUMMY; + *vb++ = HC_DUMMY; + vmesa->dmaLow += 40; + break; + case 0: + break; + default: + break; + } + + if (vmesa->useAgp) { + agpCmd.offset = 0x0; + agpCmd.size = vmesa->dmaLow; + agpCmd.index = vmesa->dma[vmesa->dmaIndex].index; + agpCmd.discard = 0; + } + else { + sysCmd.offset = 0x0; + sysCmd.size = vmesa->dmaLow; + sysCmd.index = (GLuint)vmesa->dma[vmesa->dmaIndex].map; + sysCmd.discard = 0; + } + + sarea->vertexPrim = vmesa->hwPrimitive; + + if (!nbox) { + if (vmesa->useAgp) + agpCmd.size = 0; + else + sysCmd.size = 0; + } + else if (nbox > VIA_NR_SAREA_CLIPRECTS) { + vmesa->uploadCliprects = GL_TRUE; + } +/*=* John Sheng [2003.5.31] flip *=*/ +/*#ifdef DEBUG + if (VIA_DEBUG) { + GLuint i; + GLuint *data = (GLuint *)vmesa->dmaAddr; + for (i = 0; i < vmesa->dmaLow; i += 16) { + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x\n", *data++); + } + fprintf(stderr, "******************************************\n"); + } +#endif*/ + if (!nbox || !vmesa->uploadCliprects) { + if (nbox == 1) + sarea->nbox = 0; + else + sarea->nbox = nbox; + + if (vmesa->useAgp) { + agpCmd.discard = 1; + flush_agp(vmesa, &agpCmd); + } + else { + sysCmd.discard = 1; + flush_sys(vmesa, &sysCmd); + } + } + else { + GLuint scrn; + GLuint side; + scrn = vmesa->saam & S_MASK; + side = vmesa->saam & P_MASK; + + for (i = 0; i < nbox; ) { + int nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, nbox); + drm_clip_rect_t *b = sarea->boxes; + + if (!vmesa->saam) { + if (vmesa->glCtx->Scissor.Enabled) { + sarea->nbox = 0; + + for (; i < nr; i++) { + b->x1 = pbox[i].x1 - vmesa->drawX; + b->y1 = pbox[i].y1 - vmesa->drawY; + b->x2 = pbox[i].x2 - vmesa->drawX; + b->y2 = pbox[i].y2 - vmesa->drawY; + if (intersect_rect(b, b, &vmesa->scissorRect)) { + sarea->nbox++; + b++; + } + } + if (!sarea->nbox) { + if (nr < nbox) continue; + agpCmd.size = 0; + } + } + else { + sarea->nbox = nr - i; + for (; i < nr; i++, b++) { + b->x1 = pbox[i].x1 - vmesa->drawX; + b->y1 = pbox[i].y1 - vmesa->drawY; + b->x2 = pbox[i].x2 - vmesa->drawX; + b->y2 = pbox[i].y2 - vmesa->drawY; + } + } + } + else if (scrn == S0 || scrn == S1){ + if (vmesa->scissor) { + sarea->nbox = 0; + for (; i < nr; i++) { + b->x1 = pbox[i].x1 - vmesa->drawX; + b->y1 = pbox[i].y1 - vmesa->drawY; + b->x2 = pbox[i].x2 - vmesa->drawX; + b->y2 = pbox[i].y2 - vmesa->drawY; + if (intersect_rect(b, b, &vmesa->scissorRect)) { + sarea->nbox++; + b++; + } + } + if (!sarea->nbox) { + if (nr < nbox) continue; + agpCmd.size = 0; + } + } + else { + sarea->nbox = nr - i; + for (; i < nr; i++, b++) { + b->x1 = pbox[i].x1 - vmesa->drawX; + b->y1 = pbox[i].y1 - vmesa->drawY; + b->x2 = pbox[i].x2 - vmesa->drawX; + b->y2 = pbox[i].y2 - vmesa->drawY; + } + } + + } + /* between */ + else { + if (vmesa->scissor) { + sarea->nbox = 0; + for (; i < nr; i++) { + b->x1 = pbox[i].x1 - vmesa->drawX; + b->y1 = pbox[i].y1 - vmesa->drawY; + b->x2 = pbox[i].x2 - vmesa->drawX; + b->y2 = pbox[i].y2 - vmesa->drawY; + + if (intersect_rect(b, b, &vmesa->scissorRect)) { + sarea->nbox++; + b++; + } + } + if (!sarea->nbox) { + if (nr < nbox) continue; + agpCmd.size = 0; + } + } + else { + sarea->nbox = nr - i; + for (; i < nr; i++, b++) { + b->x1 = pbox[i].x1 - vmesa->drawX; + b->y1 = pbox[i].y1 - vmesa->drawY; + b->x2 = pbox[i].x2 - vmesa->drawX; + b->y2 = pbox[i].y2 - vmesa->drawY; + } + } + } + + if (nr == nbox) { + if (vmesa->useAgp) { + agpCmd.discard = 1; + flush_agp(vmesa, &agpCmd); + } + else { + sysCmd.discard = 1; + flush_sys(vmesa, &sysCmd); + } + } + + if (scrn == (S0 | S1)) { + pbox = (drm_clip_rect_t *)vmesa->pSaamRects; + nbox = vmesa->numSaamRects; + for (i = 0; i < nbox; ) { + int nr = MIN2(i + VIA_NR_SAREA_CLIPRECTS, nbox); + drm_clip_rect_t *b = sarea->boxes; + if (vmesa->scissor) { + sarea->nbox = 0; + for (; i < nr; i++) { + b->x1 = pbox[i].x1 - vmesa->drawXSaam; + b->y1 = pbox[i].y1 - vmesa->drawYSaam; + b->x2 = pbox[i].x2 - vmesa->drawXSaam; + b->y2 = pbox[i].y2 - vmesa->drawYSaam; + + if (intersect_rect(b, b, &vmesa->scissorRect)) { + sarea->nbox++; + b++; + } + } + if (!sarea->nbox) { + if (nr < nbox) continue; + agpCmd.size = 0; + } + } + else { + sarea->nbox = nr - i; + for (; i < nr; i++, b++) { + b->x1 = pbox[i].x1 - vmesa->drawXSaam; + b->y1 = pbox[i].y1 - vmesa->drawYSaam; + b->x2 = pbox[i].x2 - vmesa->drawXSaam; + b->y2 = pbox[i].y2 - vmesa->drawYSaam; + } + } + } + flush_agp_saam(vmesa, &agpCmd); + } + } + } +#ifdef DEBUG + if (VIA_DEBUG) { + GLuint i; + GLuint *data = (GLuint *)vmesa->dmaAddr; + for (i = 0; i < vmesa->dmaLow; i += 16) { + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x\n", *data++); + } + fprintf(stderr, "******************************************\n"); + } +#endif + /* Reset vmesa vars: + */ + vmesa->dmaLow = DMA_OFFSET; + if (vmesa->dmaIndex) { + vmesa->dmaAddr = vmesa->dma[0].map; + vmesa->dmaHigh = vmesa->dma[0].size; + vmesa->dmaLastPrim = DMA_OFFSET; + vmesa->dmaIndex = 0; + } + else { + vmesa->dmaAddr = vmesa->dma[1].map; + vmesa->dmaHigh = vmesa->dma[1].size; + vmesa->dmaLastPrim = DMA_OFFSET; + vmesa->dmaIndex = 1; + } +} + +void viaFlushPrims(viaContextPtr vmesa) +{ +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__); +#endif + if (vmesa->dmaLow) { + LOCK_HARDWARE(vmesa); + viaFlushPrimsLocked(vmesa); + UNLOCK_HARDWARE(vmesa); + } +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__); +#endif +} + +static void viaFlush(GLcontext *ctx) +{ + viaContextPtr vmesa = VIA_CONTEXT(ctx); +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__); +#endif + VIA_FIREVERTICES(vmesa); +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__); +#endif +} + +static void viaFinish(GLcontext *ctx) +{ +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "%s in\n", __FUNCTION__); + if (VIA_DEBUG) fprintf(stderr, "%s out\n", __FUNCTION__); +#endif + return; +} + +static void viaClearStencil(GLcontext *ctx, int s) +{ + return; +} + +void viaInitIoctlFuncs(GLcontext *ctx) +{ + ctx->Driver.Flush = viaFlush; + ctx->Driver.Clear = viaClear; + ctx->Driver.Finish = viaFinish; + ctx->Driver.ClearStencil = viaClearStencil; +} + +void viaFillFrontBuffer(viaContextPtr vmesa) +{ + GLuint nDestBase, nDestPitch, nDestWidth, nDestHeight, offsetX, offset,i; + drm_clip_rect_t *b = vmesa->sarea->boxes; + GLuint *vb = viaCheckDma(vmesa, vmesa->sarea->nbox*48); + GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3; + GLuint pixel = (GLuint)vmesa->ClearColor; + + offset = vmesa->viaScreen->fbOffset + (vmesa->drawY * vmesa->front.pitch + vmesa->drawX * bytePerPixel); +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "Fill Front offset = %08x\n", offset); +#endif + nDestBase = offset & 0xffffffe0; + nDestPitch = vmesa->front.pitch; + + for (i = 0; i < vmesa->sarea->nbox ; i++) { + nDestWidth = b->x2 - b->x1 - 1; + nDestHeight = b->y2 - b->y1 - 1; + + if (bytePerPixel == 4) + offsetX = (b->x1 - vmesa->drawX) + (vmesa->drawX & 7); + else + offsetX = (b->x1 - vmesa->drawX) + (vmesa->drawX & 15); + + + if (GL_TRUE) { + /* GEFGCOLOR*/ + SetReg2DAGP(0x18, pixel | 0x00000000); + /* GEWD*/ + SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16)); + /* GEDST*/ + SetReg2DAGP(0x0C, (offsetX | ((b->y1 - vmesa->drawY) << 16))); + /* GEDSTBASE*/ + SetReg2DAGP(0x34, (nDestBase >> 3)); + /* GEPITCH*/ + SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000); + /* BITBLT*/ + SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000); + } + b++; + } + + viaFlushPrimsLocked(vmesa); +} + +void viaFillFrontBufferSaam(viaContextPtr vmesa) +{ + GLuint nDestBase, nDestPitch, nDestWidth, nDestHeight, offsetX, offset,i; + drm_clip_rect_t *b = vmesa->sarea->boxes; + GLuint *vb = viaCheckDma(vmesa, vmesa->sarea->nbox*48); + GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3; + GLuint pixel = (GLuint)vmesa->ClearColor; + + offset = vmesa->viaScreen->fbSize + + (vmesa->drawYSaam * vmesa->front.pitch + vmesa->drawXSaam * bytePerPixel); + nDestBase = offset & 0xffffffe0; + nDestPitch = vmesa->front.pitch; + + for (i = 0; i < vmesa->sarea->nbox ; i++) { + nDestWidth = b->x2 - b->x1 - 1; + nDestHeight = b->y2 - b->y1 - 1; + + if (bytePerPixel == 4) + offsetX = (b->x1 - vmesa->drawXSaam) + (vmesa->drawXSaam & 7); + else + offsetX = (b->x1 - vmesa->drawXSaam) + (vmesa->drawXSaam & 15); + + if (GL_TRUE) { + /* GEFGCOLOR*/ + SetReg2DAGP(0x18, pixel | 0x00000000); + /* GEWD*/ + SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16)); + /* GEDST*/ + SetReg2DAGP(0x0C, (offsetX | ((b->y1 - vmesa->drawYSaam) << 16))); + /* GEDSTBASE*/ + SetReg2DAGP(0x34, (nDestBase >> 3)); + /* GEPITCH*/ + SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000); + /* BITBLT*/ + SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000); + } + b++; + } + + viaFlushPrimsLocked(vmesa); +} + +void viaFillFrontPBuffer(viaContextPtr vmesa) +{ + GLuint nDestBase, nDestPitch, nDestWidth, nDestHeight, offsetX, offset; + GLuint *vb = viaCheckDma(vmesa, vmesa->sarea->nbox*48); + GLuint pixel = (GLuint)vmesa->ClearColor; + + offset = vmesa->front.offset; +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "Fill PFront offset = %08x\n", offset); +#endif + nDestBase = offset; + nDestPitch = vmesa->front.pitch; + + nDestWidth = vmesa->driDrawable->w - 1; + nDestHeight = vmesa->driDrawable->h - 1; + + offsetX = 0; + + /* GEFGCOLOR*/ + SetReg2DAGP(0x18, pixel | 0x00000000); + /* GEWD*/ + SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16)); + /* GEDST*/ + SetReg2DAGP(0x0C, (offsetX | (0 << 16))); + /* GEDSTBASE*/ + SetReg2DAGP(0x34, (nDestBase >> 3)); + /* GEPITCH*/ + SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000); + /* BITBLT*/ + SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000); + + viaFlushPrimsLocked(vmesa); +} + +void viaFillBackBuffer(viaContextPtr vmesa) +{ + GLuint nDestBase, nDestPitch, nDestWidth, nDestHeight, offsetX, offset; + GLcontext *ctx = vmesa->glCtx; + GLuint *vb = viaCheckDma(vmesa, 48); + GLuint pixel = (GLuint)vmesa->ClearColor; + GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3; + + offset = vmesa->back.offset; +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "Fill Back offset = %08x\n", offset); +#endif + nDestBase = offset; + nDestPitch = vmesa->back.pitch; + offsetX = vmesa->drawXoff; + + { + if (!ctx->Scissor.Enabled) { + + nDestWidth = (vmesa->back.pitch / vmesa->viaScreen->bitsPerPixel * 8) - 1; + nDestHeight = vmesa->driDrawable->h -1; + + /* GEFGCOLOR */ + SetReg2DAGP(0x18, pixel | 0x00000000); + /* GEWD */ + SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16)); + /* GEDST */ + SetReg2DAGP(0x0C, (offsetX | (0 << 16))); + /* GEDSTBASE */ + SetReg2DAGP(0x34, (nDestBase >> 3)); + /* GEPITCH */ + SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000); + /* BITBLT */ + SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000); + } + /*=* John Sheng [2003.7.18] texenv *=*/ + else { + int i; + drm_clip_rect_t *b = vmesa->sarea->boxes; + for (i = 0; i < vmesa->sarea->nbox ; i++) { + nDestWidth = b->x2 - b->x1 - 1; + nDestHeight = b->y2 - b->y1 - 1; + + if (bytePerPixel == 4) + offsetX = (b->x1 - vmesa->drawX) + (vmesa->drawX & 7); + else + offsetX = (b->x1 - vmesa->drawX) + (vmesa->drawX & 15); + + /* GEFGCOLOR */ + SetReg2DAGP(0x18, pixel | 0x00000000); + /* GEWD */ + SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16)); + /* GEDST */ + SetReg2DAGP(0x0C, ((offsetX + (b->x1 - vmesa->drawX)) | ((b->y1 - vmesa->drawY) << 16))); + /* GEDSTBASE */ + SetReg2DAGP(0x34, (nDestBase >> 3)); + /* GEPITCH */ + SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000); + /* BITBLT */ + SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000); + b++; + } + } +#ifdef DEBUG + if (VIA_DEBUG) { + fprintf(stderr," width = %08x\n", nDestWidth); + fprintf(stderr," height = %08x\n", nDestHeight); + } +#endif + } +} + +void viaFillStencilDepthBuffer(viaContextPtr vmesa, GLuint pixel) +{ + GLuint nDestBase, nDestPitch, nDestWidth, nDestHeight, offsetX, offset; + GLuint *vb = viaCheckDma(vmesa, 80); + GLuint nMask; + + offset = vmesa->depth.offset; +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "Fill Stencil Depth offset = %08x\n", offset); +#endif + nDestBase = offset; + nDestPitch = vmesa->depth.pitch; + offsetX = vmesa->drawXoff; + pixel = pixel & 0xffffff00; + nMask = 0x10000000; + + { + nDestWidth = (vmesa->depth.pitch / vmesa->depthBits * 8) - 1 - offsetX; + nDestHeight = vmesa->driDrawable->h -1; + + if (vmesa->viaScreen->bitsPerPixel == vmesa->depth.bpp) { + /* GEFGCOLOR */ + SetReg2DAGP(0x18, pixel); + /* GEMASK */ + SetReg2DAGP(0x2C, nMask); + /* GEWD */ + SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16)); + /* GEDST */ + SetReg2DAGP(0x0C, (offsetX | (0 << 16))); + /* GEDSTBASE */ + SetReg2DAGP(0x34, (nDestBase >> 3)); + /* GEPITCH */ + SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000); + /* BITBLT */ + SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000); + /* GEMASK */ + SetReg2DAGP(0x2C, 0x00000000); + } + else { + GLuint EngStatus = *(vmesa->pnGEMode); + /* GEMODE */ + SetReg2DAGP(0x04, (EngStatus & 0xFFFFFCFF) | 0x300); + /* GEFGCOLOR */ + SetReg2DAGP(0x18, pixel); + /* GEMASK */ + SetReg2DAGP(0x2C, nMask); + /* GEWD */ + SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16)); + /* GEDST */ + SetReg2DAGP(0x0C, (offsetX | (0 << 16))); + /* GEDSTBASE */ + SetReg2DAGP(0x34, (nDestBase >> 3)); + /* GEPITCH */ + SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000); + /* BITBLT */ + SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000); + /* GEMODE */ + SetReg2DAGP(0x04, EngStatus); + /* GEMASK */ + SetReg2DAGP(0x2C, 0x00000000); + + WAIT_IDLE + } + } + + if (vmesa->glCtx->Color._DrawDestMask & BACK_LEFT_BIT) { + viaFlushPrimsLocked(vmesa); + } +} + +void viaFillStencilBuffer(viaContextPtr vmesa, GLuint pixel) +{ + GLuint nDestBase, nDestPitch, nDestWidth, nDestHeight, offsetX, offset; + GLuint *vb = viaCheckDma(vmesa, 80); + GLuint nMask; + + offset = vmesa->depth.offset; +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "Fill Stencil offset = %08x\n", offset); +#endif + nDestBase = offset; + nDestPitch = vmesa->depth.pitch; + offsetX = vmesa->drawXoff; + pixel = pixel & 0x000000ff; + nMask = 0xe0000000; + + { + nDestWidth = (vmesa->depth.pitch / vmesa->depthBits * 8) - 1 - offsetX; + nDestHeight = vmesa->driDrawable->h -1; + + if (vmesa->viaScreen->bitsPerPixel == vmesa->depth.bpp) { + /* GEFGCOLOR */ + SetReg2DAGP(0x18, pixel); + /* GEMASK */ + SetReg2DAGP(0x2C, nMask); + /* GEWD */ + SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16)); + /* GEDST */ + SetReg2DAGP(0x0C, (offsetX | (0 << 16))); + /* GEDSTBASE */ + SetReg2DAGP(0x34, (nDestBase >> 3)); + /* GEPITCH */ + SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000); + /* BITBLT */ + SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000); + /* GEMASK */ + SetReg2DAGP(0x2C, 0x00000000); + } + else { + GLuint EngStatus = *(vmesa->pnGEMode); + /* GEMODE */ + SetReg2DAGP(0x04, (EngStatus & 0xFFFFFCFF) | 0x300); + /* GEFGCOLOR */ + SetReg2DAGP(0x18, pixel); + /* GEMASK */ + SetReg2DAGP(0x2C, nMask); + /* GEWD */ + SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16)); + /* GEDST */ + SetReg2DAGP(0x0C, (offsetX | (0 << 16))); + /* GEDSTBASE */ + SetReg2DAGP(0x34, (nDestBase >> 3)); + /* GEPITCH */ + SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000); + /* BITBLT */ + SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000); + /* GEMODE */ + SetReg2DAGP(0x04, EngStatus); + /* GEMASK */ + SetReg2DAGP(0x2C, 0x00000000); + } + } + + if (vmesa->glCtx->Color._DrawDestMask & BACK_LEFT_BIT) { + viaFlushPrimsLocked(vmesa); + } +} + +void viaFillDepthBuffer(viaContextPtr vmesa, GLuint pixel) +{ + GLuint nDestBase, nDestPitch, nDestWidth, nDestHeight, offsetX, offset; + GLuint *vb = viaCheckDma(vmesa, 72); + offset = vmesa->depth.offset; +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "Fill Depth offset = %08x\n", offset); +#endif + nDestBase = offset; + nDestPitch = vmesa->depth.pitch; + offsetX = vmesa->drawXoff; + + { + nDestWidth = (vmesa->depth.pitch / vmesa->depthBits * 8) - 1 - offsetX; + nDestHeight = vmesa->driDrawable->h -1; + + if (vmesa->viaScreen->bitsPerPixel == vmesa->depth.bpp) { + /* GEFGCOLOR */ + SetReg2DAGP(0x18, pixel); + /* GEMASK */ + SetReg2DAGP(0x2C, 0x0); + /* GEWD */ + SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16)); + /* GEDST */ + SetReg2DAGP(0x0C, (offsetX | (0 << 16))); + /* GEDSTBASE */ + SetReg2DAGP(0x34, (nDestBase >> 3)); + /* GEPITCH */ + SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000); + /* BITBLT */ + SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000); + } + /* depth = 16, color = 32 */ + else if (vmesa->depth.bpp == 16) { + GLuint EngStatus = *(vmesa->pnGEMode); + + /* GEMODE */ + SetReg2DAGP(0x04, (EngStatus & 0xFFFFFCFF) | 0x100); + /* GEMASK */ + SetReg2DAGP(0x2C, 0x0); + /* GEFGCOLOR */ + SetReg2DAGP(0x18, pixel); + /* GEWD */ + SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16)); + /* GEDST */ + SetReg2DAGP(0x0C, (offsetX | (0 << 16))); + /* GEDSTBASE */ + SetReg2DAGP(0x34, (nDestBase >> 3)); + /* GEPITCH */ + SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000); + /* BITBLT */ + SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000); + /* GEMODE */ + SetReg2DAGP(0x04, EngStatus); + } + /* depth = 32, color = 16 */ + else { + GLuint EngStatus = *(vmesa->pnGEMode); + + /* GEMODE */ + SetReg2DAGP(0x04, (EngStatus & 0xFFFFFCFF) | 0x300); + /* GEMASK */ + SetReg2DAGP(0x2C, 0x0); + /* GEFGCOLOR */ + SetReg2DAGP(0x18, pixel); + /* GEWD */ + SetReg2DAGP(0x10, nDestWidth | (nDestHeight << 16)); + /* GEDST */ + SetReg2DAGP(0x0C, (offsetX | (0 << 16))); + /* GEDSTBASE */ + SetReg2DAGP(0x34, (nDestBase >> 3)); + /* GEPITCH */ + SetReg2DAGP(0x38, (((nDestPitch >> 3) << 16) & 0x7FF0000) | 0x80000000); + /* BITBLT */ + SetReg2DAGP(0x0, 0x1 | 0x2000 | 0xF0000000); + /* GEMODE */ + SetReg2DAGP(0x04, EngStatus); + } + } + + if (vmesa->glCtx->Color._DrawDestMask & BACK_LEFT_BIT) { + viaFlushPrimsLocked(vmesa); + } +} + +void viaDoSwapBuffers(viaContextPtr vmesa) +{ + GLuint *vb = viaCheckDma(vmesa, vmesa->sarea->nbox*56); + GLuint nFrontPitch; + GLuint nBackPitch; + GLuint nFrontWidth, nFrontHeight, nBackWidth, nBackHeight; + GLuint nFrontBase, nBackBase; + GLuint nFrontOffsetX, nFrontOffsetY, nBackOffsetX, nBackOffsetY; + drm_clip_rect_t *b = vmesa->sarea->boxes; + GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3; + GLuint i; + + nFrontPitch = vmesa->front.pitch; + nBackPitch = vmesa->back.pitch; + + /* Caculate Base */ + nFrontBase = vmesa->viaScreen->fbOffset + (vmesa->drawY * nFrontPitch + vmesa->drawX * bytePerPixel); + nBackBase = vmesa->back.offset; + /* 128 bit alignment*/ + nFrontBase = nFrontBase & 0xffffffe0; + + /*=* [DBG] make draw to front buffer *=*/ + if(DRAW_FRONT) + return; + + for (i = 0; i < vmesa->sarea->nbox; i++) { + /* Width, Height */ + nFrontWidth = nBackWidth = b->x2 - b->x1 - 1; + nFrontHeight = nBackHeight = b->y2 - b->y1 - 1; + /* Offset */ + nFrontOffsetX = (b->x1 - vmesa->drawX) + vmesa->drawXoff; + nFrontOffsetY = b->y1 - vmesa->drawY; + + nBackOffsetX = nFrontOffsetX; + nBackOffsetY = nFrontOffsetY; + /* GEWD */ + SetReg2DAGP(0x10, nFrontWidth | (nFrontHeight << 16)); + /* GEDST */ + SetReg2DAGP(0x0C, nFrontOffsetX | (nFrontOffsetY << 16)); + /* GESRC */ + SetReg2DAGP(0x08, nBackOffsetX | (nBackOffsetY << 16)); + /* GEDSTBASE */ + SetReg2DAGP(0x34, (nFrontBase >> 3)); + /* GESCRBASE */ + SetReg2DAGP(0x30, (nBackBase >> 3)); + /* GEPITCH */ + SetReg2DAGP(0x38, (((nFrontPitch >> 3) << 16) & 0x7FF0000) | 0x80000000 | + ((nBackPitch >> 3) & 0x7FF)); + /* BITBLT */ + SetReg2DAGP(0x0, 0x1 | 0xCC000000); + b++; + } + + viaFlushPrimsLocked(vmesa); +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "Do Swap Buffer\n"); +#endif +} + +void viaDoSwapBuffersSaam(viaContextPtr vmesa) +{ + GLuint *vb = viaCheckDma(vmesa, vmesa->sarea->nbox*56); + GLuint nFrontPitch; + GLuint nBackPitch; + GLuint nFrontWidth, nFrontHeight, nBackWidth, nBackHeight; + GLuint nFrontBase, nBackBase; + GLuint nFrontOffsetX, nFrontOffsetY, nBackOffsetX, nBackOffsetY; + drm_clip_rect_t *b = vmesa->sarea->boxes; + GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3; + GLuint i; + + nFrontPitch = vmesa->front.pitch; + nBackPitch = vmesa->back.pitch; + + /* Caculate Base */ + nFrontBase = vmesa->viaScreen->fbSize + (vmesa->drawYSaam * nFrontPitch + vmesa->drawXSaam * bytePerPixel); + nBackBase = vmesa->back.offset; + /* 128 bit alignment*/ + nFrontBase = nFrontBase & 0xffffffe0; + + /*=* [DBG] make draw to front buffer *=*/ + if(DRAW_FRONT) + return; + + for (i = 0; i < vmesa->sarea->nbox; i++) { + /* Width, Height */ + nFrontWidth = nBackWidth = b->x2 - b->x1 - 1; + nFrontHeight = nBackHeight = b->y2 - b->y1 - 1; + /* Offset */ + nFrontOffsetX = (b->x1 - vmesa->drawXSaam) + vmesa->drawXoff; + nFrontOffsetY = b->y1 - vmesa->drawYSaam; + + nBackOffsetX = nFrontOffsetX; + nBackOffsetY = nFrontOffsetY; + /* GEWD */ + SetReg2DAGP(0x10, nFrontWidth | (nFrontHeight << 16)); + /* GEDST */ + SetReg2DAGP(0x0C, nFrontOffsetX | (nFrontOffsetY << 16)); + /* GESRC */ + SetReg2DAGP(0x08, nBackOffsetX | (nBackOffsetY << 16)); + /* GEDSTBASE */ + SetReg2DAGP(0x34, (nFrontBase >> 3)); + /* GESCRBASE */ + SetReg2DAGP(0x30, (nBackBase >> 3)); + /* GEPITCH */ + SetReg2DAGP(0x38, (((nFrontPitch >> 3) << 16) & 0x7FF0000) | 0x80000000 | + ((nBackPitch >> 3) & 0x7FF)); + /* BITBLT */ + SetReg2DAGP(0x0, 0x1 | 0xCC000000); + b++; + } + + viaFlushPrimsLocked(vmesa); +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "Do Swap Buffer\n"); +#endif +} + +void viaDoSwapPBuffers(viaContextPtr vmesa) +{ + GLuint *vb = viaCheckDma(vmesa, vmesa->sarea->nbox*56); + GLuint nFrontPitch; + GLuint nBackPitch; + GLuint nFrontWidth, nFrontHeight; + GLuint nFrontBase, nBackBase; + GLuint nFrontOffsetX, nFrontOffsetY, nBackOffsetX, nBackOffsetY; + GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3; + + nFrontPitch = vmesa->front.pitch; + nBackPitch = vmesa->back.pitch; + + /* Caculate Base */ + nFrontBase = vmesa->front.offset; + nBackBase = vmesa->back.offset; + + /* Width, Height */ + nFrontWidth = nFrontPitch / bytePerPixel; + nFrontHeight = nBackPitch / bytePerPixel; + + /* Offset */ + nFrontOffsetX = 0; + nFrontOffsetY = 0; + nBackOffsetX = nFrontOffsetX; + nBackOffsetY = nFrontOffsetY; + /* GEWD */ + SetReg2DAGP(0x10, nFrontWidth | (nFrontHeight << 16)); + /* GEDST */ + SetReg2DAGP(0x0C, nFrontOffsetX | (nFrontOffsetY << 16)); + /* GESRC */ + SetReg2DAGP(0x08, nBackOffsetX | (nBackOffsetY << 16)); + /* GEDSTBASE */ + SetReg2DAGP(0x34, (nFrontBase >> 3)); + /* GESCRBASE */ + SetReg2DAGP(0x30, (nBackBase >> 3)); + /* GEPITCH */ + SetReg2DAGP(0x38, (((nFrontPitch >> 3) << 16) & 0x7FF0000) | 0x80000000 | + ((nBackPitch >> 3) & 0x7FF)); + /* BITBLT */ + SetReg2DAGP(0x0, 0x1 | 0xCC000000); + + viaFlushPrimsLocked(vmesa); +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "Do Swap PBuffer\n"); +#endif +} + +void viaDoSwapBufferSoft(viaContextPtr vmesa) +{ + GLuint nFrontPitch; + GLuint nBackPitch; + GLuint nFrontBase, nBackBase; + GLuint i, j; + GLubyte *by, *fy; + GLuint w; + + w = vmesa->viaScreen->width; + w = BUFFER_ALIGN_WIDTH(w, BUFFER_ALIGNMENT); + + if (vmesa->viaScreen->bitsPerPixel == 0x20) + nFrontPitch = w << 2; + else + nFrontPitch = w << 1; + + nBackPitch = vmesa->back.pitch; + + /* Caculate Base */ + nFrontBase = (GLuint) vmesa->driScreen->pFB; + nBackBase = ((GLuint) vmesa->back.offset) + ((GLuint) vmesa->driScreen->pFB); + by = (GLubyte *) nBackBase; + fy = (GLubyte *) nFrontBase; + + viaFlushPrimsLocked(vmesa); + + for (i = 0; i < vmesa->driDrawable->h; i++) { + fy = (GLubyte *)(nFrontBase + i * nFrontPitch); + for (j = 0; j < nBackPitch; j++) { + *((GLubyte*)fy) = *((GLubyte*)by); + fy = fy + 1; + by = by + 1; + } + + } + +} + +void viaDoSwapBufferSoftFront(viaContextPtr vmesa) +{ + GLuint nFrontPitch; + GLuint nBackPitch; + GLuint nFrontBase, nBackBase; + GLuint i, j; + GLubyte *by, *fy; + GLuint w; + + w = vmesa->viaScreen->width; + w = BUFFER_ALIGN_WIDTH(w, BUFFER_ALIGNMENT); + + if (vmesa->viaScreen->bitsPerPixel == 0x20) + nFrontPitch = w << 2; + else + nFrontPitch = w << 1; + + nBackPitch = vmesa->front.pitch; + + /* Caculate Base */ + nFrontBase = (GLuint) vmesa->driScreen->pFB; + nBackBase = ((GLuint) vmesa->front.offset) + ((GLuint) vmesa->driScreen->pFB); + by = (GLubyte *) nBackBase; + fy = (GLubyte *) nFrontBase; + + viaFlushPrimsLocked(vmesa); + + for (i = 0; i < vmesa->driDrawable->h; i++) { + fy = (GLubyte *)(nFrontBase + i * nFrontPitch); + for (j = 0; j < nBackPitch; j++) { + *((GLubyte*)fy) = *((GLubyte*)by); + fy = fy + 1; + by = by + 1; + } + + } + +} +int flush_agp(viaContextPtr vmesa, drm_via_flush_agp_t* agpCmd) +{ + GLuint *pnAGPCurrentPhysStart; + GLuint *pnAGPCurrentPhysEnd; + GLuint *pnAGPCurrentStart; + GLuint *pnAGPCurrentEnd; + volatile GLuint *pnMMIOBase; + volatile GLuint *pnEngBaseTranSet; + volatile GLuint *pnEngBaseTranSpace; + GLuint *agpBase; + GLuint ofs = vmesa->dma[vmesa->dmaIndex].offset; + GLuint *vb = (GLuint *)vmesa->dmaAddr; + GLuint i = 0; + + pnMMIOBase = vmesa->regMMIOBase; + pnEngBaseTranSet = vmesa->regTranSet; + pnEngBaseTranSpace = vmesa->regTranSpace; + *pnEngBaseTranSet = (0x0010 << 16); + agpBase = vmesa->agpBase; + + if (!agpCmd->size) { + return -1; + } + + { + volatile GLuint *pnEngBase = vmesa->regEngineStatus; + int nStatus; + + while (1) { + nStatus = *pnEngBase; + if ((nStatus & 0xFFFEFFFF) == 0x00020000) + break; + i++; + } + } + + pnAGPCurrentStart = (GLuint *)(ofs + agpCmd->offset); + pnAGPCurrentEnd = (GLuint *)((GLuint)pnAGPCurrentStart + vmesa->dmaHigh); + pnAGPCurrentPhysStart = (GLuint *)( (GLuint)pnAGPCurrentStart + (GLuint)agpBase ); + pnAGPCurrentPhysEnd = (GLuint *)( (GLuint)pnAGPCurrentEnd + (GLuint)agpBase ); + + /*=* [DBG] make draw to front buffer *=*/ + if(DRAW_FRONT) + vmesa->glCtx->Color._DrawDestMask = FRONT_LEFT_BIT; + + if (vmesa->glCtx->Color._DrawDestMask & BACK_LEFT_BIT) { + + *vb++ = HC_HEADER2; + *vb++ = (HC_ParaType_NotTex << 16); + if (vmesa->driDrawable->w == 0 || vmesa->driDrawable->h == 0) { + *vb++ = (HC_SubA_HClipTB << 24) | 0x0; + *vb++ = (HC_SubA_HClipLR << 24) | 0x0; + } + else { + *vb++ = ((HC_SubA_HClipTB << 24) | (0x0 << 12) | vmesa->driDrawable->h); + *vb++ = ((HC_SubA_HClipLR << 24) | (vmesa->drawXoff << 12) | (vmesa->driDrawable->w + vmesa->drawXoff)); + } + + { + GLuint pitch, format, offset; + + if (vmesa->viaScreen->bitsPerPixel == 0x20) { + format = HC_HDBFM_ARGB8888; + } + else if (vmesa->viaScreen->bitsPerPixel == 0x10) { + format = HC_HDBFM_RGB565; + } + else + { + return -1; + } + + offset = vmesa->back.offset; + pitch = vmesa->back.pitch; + + *vb++ = ((HC_SubA_HDBBasL << 24) | (offset & 0xFFFFFF)); + *vb++ = ((HC_SubA_HDBBasH << 24) | ((offset & 0xFF000000)) >> 24); + *vb++ = ((HC_SubA_HDBFM << 24) | HC_HDBLoc_Local | format | pitch); + *vb++ = 0xcccccccc; + } + + *pnEngBaseTranSpace = (HC_SubA_HAGPBstL << 24) | + ((GLuint)(pnAGPCurrentPhysStart) & 0xFFFFFF); + *pnEngBaseTranSpace = (HC_SubA_HAGPBendL << 24) | + ((GLuint)(pnAGPCurrentPhysEnd) & 0xFFFFFF); + *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) | + ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 | + ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24; + *pnEngBaseTranSpace = (HC_SubA_HAGPBpH << 24) | + ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFF000000) >> 24; + *pnEngBaseTranSpace = (HC_SubA_HAGPBpL << 24) | + ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFFFFFF) | + HC_HAGPBpID_STOP; + *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) | + ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 | + ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24 | + HC_HAGPCMNT_MASK; + } + else { + GLuint *head; + GLuint clipL, clipR, clipT, clipB; + drm_clip_rect_t *b = vmesa->sarea->boxes; + *vb++ = HC_HEADER2; + *vb++ = (HC_ParaType_NotTex << 16); + head = vb; + + *pnEngBaseTranSpace = (HC_SubA_HAGPBstL << 24) | + ((GLuint)(pnAGPCurrentPhysStart) & 0xFFFFFF); + *pnEngBaseTranSpace = (HC_SubA_HAGPBendL << 24) | + ((GLuint)(pnAGPCurrentPhysEnd) & 0xFFFFFF); + *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) | + ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 | + ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24; + *pnEngBaseTranSpace = (HC_SubA_HAGPBpH << 24) | + ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFF000000) >> 24; + *pnEngBaseTranSpace = (HC_SubA_HAGPBpL << 24) | + ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFFFFFF) | + HC_HAGPBpID_STOP; + + for (i = 0; i < vmesa->sarea->nbox; i++) { + if (1) { + volatile GLuint *pnEngBase = vmesa->regEngineStatus; + int nStatus; + + while (1) { + nStatus = *pnEngBase; + if ((nStatus & 0xFFFEFFFF) == 0x00020000) + break; + } + } + + clipL = b->x1 + vmesa->drawXoff; + clipR = b->x2; + clipT = b->y1; + clipB = b->y2; +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "clip = %d\n", i); +#endif + if (vmesa->driDrawable->w == 0 || vmesa->driDrawable->h == 0) { + + *vb = (HC_SubA_HClipTB << 24) | 0x0; + vb++; + + *vb = (HC_SubA_HClipLR << 24) | 0x0; + vb++; + } + else { + *vb = (HC_SubA_HClipTB << 24) | (clipT << 12) | clipB; + vb++; + + *vb = (HC_SubA_HClipLR << 24) | (clipL << 12) | clipR; + vb++; + } + + { + GLuint pitch, format, offset; + GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3; + + if (vmesa->viaScreen->bitsPerPixel == 0x20) { + format = HC_HDBFM_ARGB8888; + } + else if (vmesa->viaScreen->bitsPerPixel == 0x10) { + format = HC_HDBFM_RGB565; + } + else + return -1; + + pitch = vmesa->front.pitch; + offset = vmesa->viaScreen->fbOffset + (vmesa->drawY * pitch + vmesa->drawX * bytePerPixel); + offset = offset & 0xffffffe0; + + *vb++ = ((HC_SubA_HDBBasL << 24) | (offset & 0xFFFFFF)); + *vb++ = ((HC_SubA_HDBBasH << 24) | ((offset & 0xFF000000)) >> 24); + *vb++ = ((HC_SubA_HDBFM << 24) | HC_HDBLoc_Local | format | pitch); + *vb++ = 0xcccccccc; + } + *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) | + ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 | + ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24 | + HC_HAGPCMNT_MASK; +#ifdef DEBUG + if (VIA_DEBUG) { + GLuint i; + GLuint *data = (GLuint *)vmesa->dmaAddr; + for (i = 0; i < vmesa->dmaLow; i += 16) { + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x\n", *data++); + } + fprintf(stderr, "******************************************\n"); + } +#endif + b++; + vb = head; + } + } + +#ifdef DEBUG + if (VIA_DEBUG && 0/*FIXME*/) { + volatile GLuint *pnEngBase = (volatile GLuint *)((GLuint)pnMMIOBase + 0x400); + int nStatus; + int i = 0; + + while (1) { + nStatus = *pnEngBase; + if ((nStatus & 0xFFFEFFFF) == 0x00020000) { + break; + } + else { + GLuint j; + GLuint *data; + /* dump current command buffer */ + data = (GLuint *)vmesa->dmaAddr; + + if (i == 500000) { + fprintf(stderr, "current command buffer"); + fprintf(stderr, "i = %d\n", i); + for (j = 0; j < vmesa->dmaLow; j += 16) { + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x\n", *data++); + } + } + /* dump previous command buffer */ + if (vmesa->dmaIndex) { + data = (GLuint *)vmesa->dma[0].map; + } + else { + data = (GLuint *)vmesa->dma[1].map; + } + if (i == 500000) { + fprintf(stderr, "previous command buffer"); + fprintf(stderr, "i = %d\n", i); + for (j = 0; j < dmaLow; j += 16) { + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x\n", *data++); + } + } + } + i++; + } + } +#endif + dmaLow = vmesa->dmaLow; + return 0; +} + +int flush_agp_saam(viaContextPtr vmesa, drm_via_flush_agp_t* agpCmd) +{ + GLuint *pnAGPCurrentPhysStart; + GLuint *pnAGPCurrentPhysEnd; + GLuint *pnAGPCurrentStart; + GLuint *pnAGPCurrentEnd; + volatile GLuint *pnMMIOBase; + volatile GLuint *pnEngBaseTranSet; + volatile GLuint *pnEngBaseTranSpace; + GLuint *agpBase; + GLuint ofs = vmesa->dma[vmesa->dmaIndex].offset; + GLuint *vb = (GLuint *)vmesa->dmaAddr; + GLuint i = 0; + + pnMMIOBase = vmesa->regMMIOBase; + pnEngBaseTranSet = vmesa->regTranSet; + pnEngBaseTranSpace = vmesa->regTranSpace; + *pnEngBaseTranSet = (0x0010 << 16); + agpBase = vmesa->agpBase; + + if (!agpCmd->size) { + return -1; + } + + { + volatile GLuint *pnEngBase = vmesa->regEngineStatus; + int nStatus; + + while (1) { + nStatus = *pnEngBase; + if ((nStatus & 0xFFFEFFFF) == 0x00020000) + break; + i++; + } + } + + pnAGPCurrentStart = (GLuint *)(ofs + agpCmd->offset); + pnAGPCurrentEnd = (GLuint *)((GLuint)pnAGPCurrentStart + vmesa->dmaHigh); + pnAGPCurrentPhysStart = (GLuint *)( (GLuint)pnAGPCurrentStart + (GLuint)agpBase ); + pnAGPCurrentPhysEnd = (GLuint *)( (GLuint)pnAGPCurrentEnd + (GLuint)agpBase ); + + /*=* [DBG] make draw to front buffer *=*/ + if(DRAW_FRONT) + vmesa->glCtx->Color._DrawDestMask = FRONT_LEFT_BIT; + + if (vmesa->glCtx->Color._DrawDestMask & BACK_LEFT_BIT) { + + *vb++ = HC_HEADER2; + *vb++ = (HC_ParaType_NotTex << 16); + if (vmesa->driDrawable->w == 0 || vmesa->driDrawable->h == 0) { + *vb++ = (HC_SubA_HClipTB << 24) | 0x0; + *vb++ = (HC_SubA_HClipLR << 24) | 0x0; + } + else { + *vb++ = ((HC_SubA_HClipTB << 24) | (0x0 << 12) | vmesa->driDrawable->h); + *vb++ = ((HC_SubA_HClipLR << 24) | (vmesa->drawXoff << 12) | (vmesa->driDrawable->w + vmesa->drawXoff)); + } + + { + GLuint pitch, format, offset; + + if (vmesa->viaScreen->bitsPerPixel == 0x20) { + format = HC_HDBFM_ARGB8888; + } + else if (vmesa->viaScreen->bitsPerPixel == 0x10) { + format = HC_HDBFM_RGB565; + } + else + return -1; + + offset = vmesa->back.offset; + pitch = vmesa->back.pitch; + + *vb++ = ((HC_SubA_HDBBasL << 24) | (offset & 0xFFFFFF)); + *vb++ = ((HC_SubA_HDBBasH << 24) | ((offset & 0xFF000000)) >> 24); + *vb++ = ((HC_SubA_HDBFM << 24) | HC_HDBLoc_Local | format | pitch); + *vb++ = 0xcccccccc; + } + + *pnEngBaseTranSpace = (HC_SubA_HAGPBstL << 24) | + ((GLuint)(pnAGPCurrentPhysStart) & 0xFFFFFF); + *pnEngBaseTranSpace = (HC_SubA_HAGPBendL << 24) | + ((GLuint)(pnAGPCurrentPhysEnd) & 0xFFFFFF); + *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) | + ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 | + ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24; + *pnEngBaseTranSpace = (HC_SubA_HAGPBpH << 24) | + ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFF000000) >> 24; + *pnEngBaseTranSpace = (HC_SubA_HAGPBpL << 24) | + ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFFFFFF) | + HC_HAGPBpID_STOP; + *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) | + ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 | + ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24 | + HC_HAGPCMNT_MASK; + } + else { + GLuint *head; + GLuint clipL, clipR, clipT, clipB; + drm_clip_rect_t *b = vmesa->sarea->boxes; + *vb++ = HC_HEADER2; + *vb++ = (HC_ParaType_NotTex << 16); + head = vb; + + *pnEngBaseTranSpace = (HC_SubA_HAGPBstL << 24) | + ((GLuint)(pnAGPCurrentPhysStart) & 0xFFFFFF); + *pnEngBaseTranSpace = (HC_SubA_HAGPBendL << 24) | + ((GLuint)(pnAGPCurrentPhysEnd) & 0xFFFFFF); + *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) | + ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 | + ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24; + *pnEngBaseTranSpace = (HC_SubA_HAGPBpH << 24) | + ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFF000000) >> 24; + *pnEngBaseTranSpace = (HC_SubA_HAGPBpL << 24) | + ((GLuint)((GLbyte *)pnAGPCurrentPhysStart + agpCmd->size - 4) & 0xFFFFFF) | + HC_HAGPBpID_STOP; + + for (i = 0; i < vmesa->sarea->nbox; i++) { + if (1) { + volatile GLuint *pnEngBase = vmesa->regEngineStatus; + int nStatus; + + while (1) { + nStatus = *pnEngBase; + if ((nStatus & 0xFFFEFFFF) == 0x00020000) + break; + } + } + + clipL = b->x1 + vmesa->drawXoff; + clipR = b->x2; + clipT = b->y1; + clipB = b->y2; +#ifdef DEBUG + if (VIA_DEBUG) fprintf(stderr, "clip = %d\n", i); +#endif + if (vmesa->driDrawable->w == 0 || vmesa->driDrawable->h == 0) { + + *vb = (HC_SubA_HClipTB << 24) | 0x0; + vb++; + + *vb = (HC_SubA_HClipLR << 24) | 0x0; + vb++; + } + else { + *vb = (HC_SubA_HClipTB << 24) | (clipT << 12) | clipB; + vb++; + + *vb = (HC_SubA_HClipLR << 24) | (clipL << 12) | clipR; + vb++; + } + + { + GLuint pitch, format, offset; + GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3; + + if (vmesa->viaScreen->bitsPerPixel == 0x20) { + format = HC_HDBFM_ARGB8888; + } + else if (vmesa->viaScreen->bitsPerPixel == 0x10) { + format = HC_HDBFM_RGB565; + } + else + return -1; + + pitch = vmesa->front.pitch; + offset = vmesa->viaScreen->fbOffset + (vmesa->drawY * pitch + vmesa->drawX * bytePerPixel); + offset = offset & 0xffffffe0; + + *vb++ = ((HC_SubA_HDBBasL << 24) | (offset & 0xFFFFFF)); + *vb++ = ((HC_SubA_HDBBasH << 24) | ((offset & 0xFF000000)) >> 24); + *vb++ = ((HC_SubA_HDBFM << 24) | HC_HDBLoc_Local | format | pitch); + *vb++ = 0xcccccccc; + } + *pnEngBaseTranSpace = (HC_SubA_HAGPCMNT << 24) | + ((GLuint)(pnAGPCurrentPhysEnd) & 0xFF000000) >> 16 | + ((GLuint)(pnAGPCurrentPhysStart) & 0xFF000000) >> 24 | + HC_HAGPCMNT_MASK; +#ifdef DEBUG + if (VIA_DEBUG) { + GLuint i; + GLuint *data = (GLuint *)vmesa->dmaAddr; + for (i = 0; i < vmesa->dmaLow; i += 16) { + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x\n", *data++); + } + fprintf(stderr, "******************************************\n"); + } +#endif + b++; + vb = head; + } + } + +#ifdef DEBUG + if (VIA_DEBUG) { + volatile GLuint *pnEngBase = (GLuint *)((GLuint)pnMMIOBase + 0x400); + int nStatus; + int i = 0; + + while (1) { + nStatus = *pnEngBase; + if ((nStatus & 0xFFFEFFFF) == 0x00020000) { + break; + } + else { + GLuint j; + GLuint *data; + /* dump current command buffer */ + data = (GLuint *)vmesa->dmaAddr; + + if (i == 500000) { + fprintf(stderr, "current command buffer"); + fprintf(stderr, "i = %d\n", i); + for (j = 0; j < vmesa->dmaLow; j += 16) { + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x\n", *data++); + } + } + /* dump previous command buffer */ + if (vmesa->dmaIndex) { + data = (GLuint *)vmesa->dma[0].map; + } + else { + data = (GLuint *)vmesa->dma[1].map; + } + if (i == 500000) { + fprintf(stderr, "previous command buffer"); + fprintf(stderr, "i = %d\n", i); + for (j = 0; j < dmaLow; j += 16) { + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x ", *data++); + fprintf(stderr, "%08x\n", *data++); + } + } + } + i++; + } + } +#endif + dmaLow = vmesa->dmaLow; + return 0; +} + +int flush_sys(viaContextPtr vmesa, drm_via_flush_sys_t* buf) + +{ + GLuint *pnBuf; + GLuint *pnEnd; + volatile GLuint *pnMMIOBase; + volatile GLuint *pnEngBaseTranSet; + volatile GLuint *pnEngBaseTranSpace; + GLuint uCheck2DCmd = GL_TRUE; + GLuint addr; + GLuint *vb = (GLuint *)vmesa->dmaAddr; + GLuint i = 0; + + pnMMIOBase = vmesa->regMMIOBase; + pnEngBaseTranSet = vmesa->regTranSet; + pnEngBaseTranSpace = vmesa->regTranSpace; + + pnBuf = (GLuint *)(buf->index + buf->offset); + pnEnd = (GLuint *)((GLuint)pnBuf + buf->size); + + /*=* [DBG] make draw to front buffer *=*/ + if(DRAW_FRONT) + vmesa->glCtx->Color._DrawDestMask = FRONT_LEFT_BIT; + + /*=* John Sheng [2003.6.20] fix pci *=*/ + { + volatile GLuint *pnEngBase = vmesa->regEngineStatus; + int nStatus; + + while (1) { + nStatus = *pnEngBase; + if ((nStatus & 0xFFFEFFFF) == 0x00020000) + break; + i++; + } + } + + if (vmesa->glCtx->Color._DrawDestMask & BACK_LEFT_BIT) { + *vb++ = HC_HEADER2; + *vb++ = (HC_ParaType_NotTex << 16); + + if (vmesa->driDrawable->w == 0 || vmesa->driDrawable->h == 0) { + *vb++ = (HC_SubA_HClipTB << 24) | 0x0; + *vb++ = (HC_SubA_HClipLR << 24) | 0x0; + } + else { + *vb++ = ((HC_SubA_HClipTB << 24) | (0x0 << 12) | vmesa->driDrawable->h); + *vb++ = ((HC_SubA_HClipLR << 24) | (vmesa->drawXoff << 12) | (vmesa->driDrawable->w + vmesa->drawXoff)); + } + + /*=* John Sheng [2003.6.16] fix pci path *=*/ + { + GLuint pitch, format, offset; + + if (vmesa->viaScreen->bitsPerPixel == 0x20) { + format = HC_HDBFM_ARGB8888; + } + else if (vmesa->viaScreen->bitsPerPixel == 0x10) { + format = HC_HDBFM_RGB565; + } + else + return -1; + + offset = vmesa->back.offset; + pitch = vmesa->back.pitch; + + *vb++ = ((HC_SubA_HDBBasL << 24) | (offset & 0xFFFFFF)); + *vb++ = ((HC_SubA_HDBBasH << 24) | ((offset & 0xFF000000)) >> 24); + *vb++ = ((HC_SubA_HDBFM << 24) | HC_HDBLoc_Local | format | pitch); + *vb++ = 0xcccccccc; + } + + while (pnBuf != pnEnd) { + if (*pnBuf == HALCYON_HEADER2) { + pnBuf++; + if (*pnBuf == HALCYON_SUB_ADDR0) { + *pnEngBaseTranSet = *pnBuf; + pnBuf++; + uCheck2DCmd = GL_FALSE; + } + else { + *pnEngBaseTranSet = *pnBuf; + pnBuf++; + uCheck2DCmd = GL_TRUE; + } + } + else if (uCheck2DCmd && ((*pnBuf&HALCYON_HEADER1MASK)==HALCYON_HEADER1)) { + addr = ((*pnBuf)&0x0000001f) << 2; + pnBuf++; + *((GLuint*)((GLuint)pnMMIOBase+addr)) = *pnBuf; + pnBuf++; + } + else if ((*pnBuf&HALCYON_FIREMASK) == HALCYON_FIRECMD) { + *pnEngBaseTranSpace = *pnBuf; + pnBuf++; + if ((pnBuf!=pnEnd)&&((*pnBuf&HALCYON_FIREMASK)==HALCYON_FIRECMD)) + pnBuf++; + if ((*pnBuf&HALCYON_CMDBMASK) != HC_ACMD_HCmdB) + uCheck2DCmd = GL_TRUE; + } + else { + *pnEngBaseTranSpace = *pnBuf; + pnBuf++; + } + } + } + else { + GLuint *head; + GLuint clipL, clipR, clipT, clipB; + drm_clip_rect_t *b = vmesa->sarea->boxes; + GLuint *pnTmp; + + *vb++ = HC_HEADER2; + *vb++ = (HC_ParaType_NotTex << 16); + + head = vb; + pnTmp = pnBuf; + + for (i = 0; i < vmesa->sarea->nbox; i++) { + clipL = b->x1 + vmesa->drawXoff; + clipR = b->x2 + vmesa->drawXoff; + clipT = b->y1; + clipB = b->y2; + + if (vmesa->driDrawable->w == 0 || vmesa->driDrawable->h == 0) { + *vb = (HC_SubA_HClipTB << 24) | 0x0; + vb++; + *vb = (HC_SubA_HClipLR << 24) | 0x0; + vb++; + } + else { + *vb = (HC_SubA_HClipTB << 24) | (clipT << 12) | clipB; + vb++; + *vb = (HC_SubA_HClipLR << 24) | (clipL << 12) | clipR; + vb++; + } + + /*=* John Sheng [2003.6.16] fix pci path *=*/ + { + GLuint pitch, format, offset; + GLuint bytePerPixel = vmesa->viaScreen->bitsPerPixel >> 3; + + if (vmesa->viaScreen->bitsPerPixel == 0x20) { + format = HC_HDBFM_ARGB8888; + } + else if (vmesa->viaScreen->bitsPerPixel == 0x10) { + format = HC_HDBFM_RGB565; + } + else + return -1; + + pitch = vmesa->front.pitch; + offset = vmesa->viaScreen->fbOffset + (vmesa->drawY * pitch + vmesa->drawX * bytePerPixel); + offset = offset & 0xffffffe0; + + *vb++ = ((HC_SubA_HDBBasL << 24) | (offset & 0xFFFFFF)); + *vb++ = ((HC_SubA_HDBBasH << 24) | ((offset & 0xFF000000)) >> 24); + *vb++ = ((HC_SubA_HDBFM << 24) | HC_HDBLoc_Local | format | pitch); + *vb++ = 0xcccccccc; + } + + pnBuf = pnTmp; + + while (pnBuf != pnEnd) { + if (*pnBuf == HALCYON_HEADER2) { + pnBuf++; + if (*pnBuf == HALCYON_SUB_ADDR0) { + *pnEngBaseTranSet = *pnBuf; + pnBuf++; + uCheck2DCmd = GL_FALSE; + } + else { + *pnEngBaseTranSet = *pnBuf; + pnBuf++; + uCheck2DCmd = GL_TRUE; + } + } + else if (uCheck2DCmd && ((*pnBuf&HALCYON_HEADER1MASK)==HALCYON_HEADER1)) { + addr = ((*pnBuf)&0x0000001f) << 2; + pnBuf++; + *((GLuint*)((GLuint)pnMMIOBase+addr)) = *pnBuf; + pnBuf++; + } + else if ((*pnBuf&HALCYON_FIREMASK) == HALCYON_FIRECMD) { + *pnEngBaseTranSpace = *pnBuf; + pnBuf++; + if ((pnBuf!=pnEnd)&&((*pnBuf&HALCYON_FIREMASK)==HALCYON_FIRECMD)) + pnBuf++; + if ((*pnBuf&HALCYON_CMDBMASK) != HC_ACMD_HCmdB) + uCheck2DCmd = GL_TRUE; + } + else { + *pnEngBaseTranSpace = *pnBuf; + pnBuf++; + } + } + b++; + vb = head; + } + } + return 0; +} |