From a055d658bfbdc26b86a5ccd899000bcd09b8f7a5 Mon Sep 17 00:00:00 2001 From: kem Date: Sun, 19 Mar 2000 07:19:20 +0000 Subject: Preparing for alpha release - Still need to merge with 4.0 Added texture support - single and multi-texture Added both local and AGP texturing - not yet simultaneously - local by default, AGP can be enabled at compile time Added window clipping - prim rendering, clears, and swap bufs Added initial hardware vertex buffer support - only works for a single client (just for testing) - disabled by default Added software fallback support when not drawing to front or back color bufs Added alpha test support Added more rendering funcs Added preliminary fast path support Added code to allocate the ring buffer, vertex buffer pool, index buffer pool, and space for textures in AGP memory Added code to allocate local texture memory from the off-screen memory outside of the hw clip rect range (and thus not managed by the OSMM) and, if that fails, from the off-screen memory managed by the OSMM Moved code to start/stop CCE to X server Fixed hardware state update Fixed flat shaded color initialization bug Fixed rhw support Fixed to only allow 16 and 32bpp color buffer support - other bit depths possible, but not yet implemented Fixed depth buffer initialization in 32bpp mode Fixed CCE initialization Fixed visual config initialization Fixed AGP aperture initialization - vertex buffers and AGP texturing now works - ring buffer and indirect buffers should also now work Cleaned up code --- xc/lib/GL/mesa/src/drv/r128/Imakefile | 8 +- xc/lib/GL/mesa/src/drv/r128/mm.c | 262 +++++ xc/lib/GL/mesa/src/drv/r128/mm.h | 101 ++ xc/lib/GL/mesa/src/drv/r128/r128_cce.c | 53 +- xc/lib/GL/mesa/src/drv/r128/r128_cce.h | 67 +- xc/lib/GL/mesa/src/drv/r128/r128_ccevb.h | 48 + xc/lib/GL/mesa/src/drv/r128/r128_clear.c | 186 ++-- xc/lib/GL/mesa/src/drv/r128/r128_context.c | 183 ++++ xc/lib/GL/mesa/src/drv/r128/r128_context.h | 165 ++- xc/lib/GL/mesa/src/drv/r128/r128_dd.c | 75 +- xc/lib/GL/mesa/src/drv/r128/r128_depth.c | 15 + xc/lib/GL/mesa/src/drv/r128/r128_fastpath.c | 537 ++++++++++ xc/lib/GL/mesa/src/drv/r128/r128_fastpath.h | 48 + xc/lib/GL/mesa/src/drv/r128/r128_fasttmp.h | 155 +++ xc/lib/GL/mesa/src/drv/r128/r128_init.h | 16 +- xc/lib/GL/mesa/src/drv/r128/r128_lock.h | 18 +- xc/lib/GL/mesa/src/drv/r128/r128_pipeline.c | 126 +++ xc/lib/GL/mesa/src/drv/r128/r128_pipeline.h | 43 + xc/lib/GL/mesa/src/drv/r128/r128_screen.c | 160 +++ xc/lib/GL/mesa/src/drv/r128/r128_screen.h | 79 +- xc/lib/GL/mesa/src/drv/r128/r128_span.c | 42 +- xc/lib/GL/mesa/src/drv/r128/r128_state.c | 845 +++++++++------ xc/lib/GL/mesa/src/drv/r128/r128_state.h | 12 +- xc/lib/GL/mesa/src/drv/r128/r128_swap.c | 55 +- xc/lib/GL/mesa/src/drv/r128/r128_tex.c | 1096 +++++++++++++++++++- xc/lib/GL/mesa/src/drv/r128/r128_tex.h | 7 + xc/lib/GL/mesa/src/drv/r128/r128_texobj.h | 81 ++ xc/lib/GL/mesa/src/drv/r128/r128_tris.c | 121 ++- xc/lib/GL/mesa/src/drv/r128/r128_tris.h | 12 + xc/lib/GL/mesa/src/drv/r128/r128_tritmp.h | 170 ++- xc/lib/GL/mesa/src/drv/r128/r128_vb.c | 360 +++++-- xc/lib/GL/mesa/src/drv/r128/r128_vb.h | 112 +- xc/lib/GL/mesa/src/drv/r128/r128_xmesa.c | 260 ++--- xc/programs/Xserver/hw/xfree86/drivers/r128/r128.h | 27 +- .../Xserver/hw/xfree86/drivers/r128/r128_accel.c | 43 +- .../Xserver/hw/xfree86/drivers/r128/r128_dri.c | 464 ++++++--- .../Xserver/hw/xfree86/drivers/r128/r128_dri.h | 50 +- .../Xserver/hw/xfree86/drivers/r128/r128_dripriv.h | 5 - .../Xserver/hw/xfree86/drivers/r128/r128_driver.c | 71 +- .../Xserver/hw/xfree86/drivers/r128/r128_reg.h | 70 +- .../Xserver/hw/xfree86/drivers/r128/r128_sarea.h | 69 ++ 41 files changed, 5225 insertions(+), 1092 deletions(-) create mode 100644 xc/lib/GL/mesa/src/drv/r128/mm.c create mode 100644 xc/lib/GL/mesa/src/drv/r128/mm.h create mode 100644 xc/lib/GL/mesa/src/drv/r128/r128_ccevb.h create mode 100644 xc/lib/GL/mesa/src/drv/r128/r128_context.c create mode 100644 xc/lib/GL/mesa/src/drv/r128/r128_fastpath.c create mode 100644 xc/lib/GL/mesa/src/drv/r128/r128_fastpath.h create mode 100644 xc/lib/GL/mesa/src/drv/r128/r128_fasttmp.h create mode 100644 xc/lib/GL/mesa/src/drv/r128/r128_pipeline.c create mode 100644 xc/lib/GL/mesa/src/drv/r128/r128_pipeline.h create mode 100644 xc/lib/GL/mesa/src/drv/r128/r128_screen.c create mode 100644 xc/lib/GL/mesa/src/drv/r128/r128_texobj.h create mode 100644 xc/programs/Xserver/hw/xfree86/drivers/r128/r128_sarea.h diff --git a/xc/lib/GL/mesa/src/drv/r128/Imakefile b/xc/lib/GL/mesa/src/drv/r128/Imakefile index 6ca57a376..dd01c3ce2 100644 --- a/xc/lib/GL/mesa/src/drv/r128/Imakefile +++ b/xc/lib/GL/mesa/src/drv/r128/Imakefile @@ -25,10 +25,14 @@ MESA_INCLUDES = -I. -I.. -I../../include INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) $(MESA_INCLUDES) $(DRI_INCLUDES) DRISRCS = r128_xmesa.c r128_cce.c r128_dd.c r128_state.c \ r128_span.c r128_depth.c r128_tex.c r128_clear.c \ - r128_swap.c r128_tris.c r128_vb.c + r128_swap.c r128_tris.c r128_vb.c r128_context.c \ + r128_screen.c r128_pipeline.c r128_fastpath.c \ + mm.c DRIOBJS = r128_xmesa.o r128_cce.o r128_dd.o r128_state.o \ r128_span.o r128_depth.o r128_tex.o r128_clear.o \ - r128_swap.o r128_tris.o r128_vb.o + r128_swap.o r128_tris.o r128_vb.o r128_context.o \ + r128_screen.o r128_pipeline.o r128_fastpath.o \ + mm.o SRCS = $(DRISRCS) OBJS = $(DRIOBJS) diff --git a/xc/lib/GL/mesa/src/drv/r128/mm.c b/xc/lib/GL/mesa/src/drv/r128/mm.c new file mode 100644 index 000000000..00ad43a8c --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/r128/mm.c @@ -0,0 +1,262 @@ +/* + * GLX Hardware Device Driver common code + * Copyright (C) 1999 Keith Whitwell + * + * 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, sublicense, + * 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 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 NONINFRINGEMENT. IN NO EVENT SHALL + * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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 +#include + +#include "mm.h" +/* #include "hwlog.h" */ + +#define ISFREE(bptr) ((bptr)->free) +/* #define PRINTF(f,a...) hwMsg(1,f, ## a) */ +#define PRINTF(f,a...) fprintf(stderr, f, ## a) + +void mmDumpMemInfo( memHeap_t *heap ) +{ + TMemBlock *p; + + PRINTF("Memory heap %p:\n", heap); + if (heap == 0) { + PRINTF(" heap == 0\n"); + } else { + p = (TMemBlock *)heap; + while (p) { + PRINTF(" Offset:%08x, Size:%08x, %c%c\n",p->ofs,p->size, + p->free ? '.':'U', + p->reserved ? 'R':'.'); + p = p->next; + } + } + PRINTF("End of memory blocks\n"); +} + +memHeap_t *mmInit(int ofs, + int size) +{ + PMemBlock blocks; + + if (size <= 0) { + return 0; + } + blocks = (TMemBlock *) calloc(1,sizeof(TMemBlock)); + if (blocks) { + blocks->ofs = ofs; + blocks->size = size; + blocks->free = 1; + return (memHeap_t *)blocks; + } else + return 0; +} + +/* Kludgey workaround for existing i810 server. Remove soon. + */ +memHeap_t *mmAddRange( memHeap_t *heap, + int ofs, + int size ) +{ + PMemBlock blocks; + blocks = (TMemBlock *) calloc(2,sizeof(TMemBlock)); + if (blocks) { + blocks[0].size = size; + blocks[0].free = 1; + blocks[0].ofs = ofs; + blocks[0].next = &blocks[1]; + + /* Discontinuity - stops JoinBlock from trying to join non-adjacent + * ranges. + */ + blocks[1].size = 0; + blocks[1].free = 0; + blocks[1].ofs = ofs+size; + blocks[1].next = (PMemBlock) heap; + return (memHeap_t *)blocks; + } + else + return heap; +} + +static TMemBlock* SliceBlock(TMemBlock *p, + int startofs, int size, + int reserved, int alignment) +{ + TMemBlock *newblock; + + /* break left */ + if (startofs > p->ofs) { + newblock = (TMemBlock*) calloc(1,sizeof(TMemBlock)); + newblock->ofs = startofs; + newblock->size = p->size - (startofs - p->ofs); + newblock->free = 1; + newblock->next = p->next; + p->size -= newblock->size; + p->next = newblock; + p = newblock; + } + + /* break right */ + if (size < p->size) { + newblock = (TMemBlock*) calloc(1,sizeof(TMemBlock)); + newblock->ofs = startofs + size; + newblock->size = p->size - size; + newblock->free = 1; + newblock->next = p->next; + p->size = size; + p->next = newblock; + } + + /* p = middle block */ + p->align = alignment; + p->free = 0; + p->reserved = reserved; + return p; +} + +PMemBlock mmAllocMem( memHeap_t *heap, int size, int align2, int startSearch) +{ + int mask,startofs,endofs; + TMemBlock *p; + + if (!heap || align2 < 0 || size <= 0) + return NULL; + mask = (1 << align2)-1; + startofs = 0; + p = (TMemBlock *)heap; + while (p) { + if (ISFREE(p)) { + startofs = (p->ofs + mask) & ~mask; + if ( startofs < startSearch ) { + startofs = startSearch; + } + endofs = startofs+size; + if (endofs <= (p->ofs+p->size)) + break; + } + p = p->next; + } + if (!p) + return NULL; + p = SliceBlock(p,startofs,size,0,mask+1); + p->heap = heap; + return p; +} + +static __inline__ int Join2Blocks(TMemBlock *p) +{ + if (p->free && p->next && p->next->free) { + TMemBlock *q = p->next; + p->size += q->size; + p->next = q->next; + free(q); + return 1; + } + return 0; +} + +int mmFreeMem(PMemBlock b) +{ + TMemBlock *p,*prev; + + if (!b) + return 0; + if (!b->heap) { + fprintf(stderr, "no heap\n"); + return -1; + } + p = b->heap; + prev = NULL; + while (p && p != b) { + prev = p; + p = p->next; + } + if (!p || p->free || p->reserved) { + if (!p) + fprintf(stderr, "block not found in heap\n"); + else if (p->free) + fprintf(stderr, "block already free\n"); + else + fprintf(stderr, "block is reserved\n"); + return -1; + } + p->free = 1; + Join2Blocks(p); + if (prev) + Join2Blocks(prev); + return 0; +} + +int mmReserveMem(memHeap_t *heap, int offset,int size) +{ + int endofs; + TMemBlock *p; + + if (!heap || size <= 0) + return -1; + endofs = offset+size; + p = (TMemBlock *)heap; + while (p && p->ofs <= offset) { + if (ISFREE(p) && endofs <= (p->ofs+p->size)) { + SliceBlock(p,offset,size,1,1); + return 0; + } + p = p->next; + } + return -1; +} + +int mmFreeReserved(memHeap_t *heap, int offset) +{ + TMemBlock *p,*prev; + + if (!heap) + return -1; + p = (TMemBlock *)heap; + prev = NULL; + while (p && p->ofs != offset) { + prev = p; + p = p->next; + } + if (!p || !p->reserved) + return -1; + p->free = 1; + p->reserved = 0; + Join2Blocks(p); + if (prev) + Join2Blocks(prev); + return 0; +} + +void mmDestroy(memHeap_t *heap) +{ + TMemBlock *p,*q; + + if (!heap) + return; + p = (TMemBlock *)heap; + while (p) { + q = p->next; + free(p); + p = q; + } +} diff --git a/xc/lib/GL/mesa/src/drv/r128/mm.h b/xc/lib/GL/mesa/src/drv/r128/mm.h new file mode 100644 index 000000000..6fa6e8b69 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/r128/mm.h @@ -0,0 +1,101 @@ +/* + * GLX Hardware Device Driver common code + * Copyright (C) 1999 Keith Whitwell + * + * 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, sublicense, + * 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 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 NONINFRINGEMENT. IN NO EVENT SHALL + * KEITH WHITWELL, OR ANY OTHER CONTRIBUTORS 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. + * + */ + +#ifndef MM_INC +#define MM_INC + +struct mem_block_t { + struct mem_block_t *next; + struct mem_block_t *heap; + int ofs,size; + int align; + int free:1; + int reserved:1; +}; +typedef struct mem_block_t TMemBlock; +typedef struct mem_block_t *PMemBlock; + +/* a heap is just the first block in a chain */ +typedef struct mem_block_t memHeap_t; + +static __inline__ int mmBlockSize(PMemBlock b) +{ return b->size; } + +static __inline__ int mmOffset(PMemBlock b) +{ return b->ofs; } + +static __inline__ void mmMarkReserved(PMemBlock b) +{ b->reserved = 1; } + +/* + * input: total size in bytes + * return: a heap pointer if OK, NULL if error + */ +memHeap_t *mmInit( int ofs, int size ); + + + +memHeap_t *mmAddRange( memHeap_t *heap, + int ofs, + int size ); + + +/* + * Allocate 'size' bytes with 2^align2 bytes alignment, + * restrict the search to free memory after 'startSearch' + * depth and back buffers should be in different 4mb banks + * to get better page hits if possible + * input: size = size of block + * align2 = 2^align2 bytes alignment + * startSearch = linear offset from start of heap to begin search + * return: pointer to the allocated block, 0 if error + */ +PMemBlock mmAllocMem( memHeap_t *heap, int size, int align2, int startSearch ); + +/* + * Free block starts at offset + * input: pointer to a block + * return: 0 if OK, -1 if error + */ +int mmFreeMem( PMemBlock b ); + +/* + * Reserve 'size' bytes block start at offset + * This is used to prevent allocation of memory already used + * by the X server for the front buffer, pixmaps, and cursor + * input: size, offset + * output: 0 if OK, -1 if error + */ +int mmReserveMem( memHeap_t *heap, int offset,int size ); +int mmFreeReserved( memHeap_t *heap, int offset ); + +/* + * destroy MM + */ +void mmDestroy( memHeap_t *mmInit ); + +/* For debuging purpose. */ +void mmDumpMemInfo( memHeap_t *mmInit ); + +#endif diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_cce.c b/xc/lib/GL/mesa/src/drv/r128/r128_cce.c index 9f9fec81c..63742fe78 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_cce.c +++ b/xc/lib/GL/mesa/src/drv/r128/r128_cce.c @@ -38,6 +38,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #include "r128_reg.h" #include "r128_cce.h" +/* FIXME: Requires access to secure registers */ static int INPLL(r128ScreenPtr pScrn, int addr) { unsigned char *R128MMIO = pScrn->mmio; @@ -46,6 +47,7 @@ static int INPLL(r128ScreenPtr pScrn, int addr) return INREG(R128_CLOCK_CNTL_DATA); } +/* FIXME: Requires access to secure registers */ void R128EngineFlush(r128ScreenPtr pScrn) { unsigned char *R128MMIO = pScrn->mmio; @@ -57,6 +59,7 @@ void R128EngineFlush(r128ScreenPtr pScrn) } } +/* FIXME: Requires access to secure registers */ void R128EngineReset(r128ScreenPtr pScrn) { unsigned char *R128MMIO = pScrn->mmio; @@ -83,6 +86,8 @@ void R128EngineReset(r128ScreenPtr pScrn) OUTREG(R128_GEN_RESET_CNTL, gen_reset_cntl); } +/* The FIFO has 64 slots. This routines waits until at least `entries' + of these slots are empty. */ void R128WaitForFifoFunction(r128ScreenPtr pScrn, int entries) { unsigned char *R128MMIO = pScrn->mmio; @@ -100,6 +105,9 @@ void R128WaitForFifoFunction(r128ScreenPtr pScrn, int entries) } } +/* Wait for the graphics engine to be completely idle: the FIFO has + drained, the Pixel Cache is flushed, and the engine is idle. This is + a standard "sync" function that will make the hardware quiescent. */ void R128WaitForIdle(r128ScreenPtr pScrn) { unsigned char *R128MMIO = pScrn->mmio; @@ -120,6 +128,8 @@ void R128WaitForIdle(r128ScreenPtr pScrn) } } +/* Wait for at least `entries' slots are free. The actual number of + slots available is stored in info->CCEFifoSize. */ void R128CCEWaitForFifoFunction(r128ScreenPtr pScrn, int entries) { unsigned char *R128MMIO = pScrn->mmio; @@ -136,6 +146,8 @@ void R128CCEWaitForFifoFunction(r128ScreenPtr pScrn, int entries) } } +/* Wait until the CCE is completely idle: the FIFO has drained and the + CCE is idle. */ void R128CCEWaitForIdle(r128ScreenPtr pScrn) { unsigned char *R128MMIO = pScrn->mmio; @@ -157,28 +169,23 @@ void R128CCEWaitForIdle(r128ScreenPtr pScrn) } } -/* NOTE: This function must be called before using the CCE */ -void R128CCEStart(r128ScreenPtr pScrn) +/* Flush the CPU's write-combining cache */ +void R128FlushWCMemory(void) { - unsigned char *R128MMIO = pScrn->mmio; - - R128WaitForIdle(pScrn); - OUTREG(R128_PM4_BUFFER_CNTL, pScrn->CCEMode); - (void)INREG(R128_PM4_BUFFER_ADDR); /* as per the sample code */ - OUTREG(R128_PM4_MICRO_CNTL, R128_PM4_MICRO_FREERUN); -} - -/* NOTE: This function must be called before using the standard MMIO - mode for the X server. Also, this function is not (currently) called - by the client-side DRI driver; rather, it is only called in the X - server when the X server's context is swapped in. */ -void R128CCEEnd(r128ScreenPtr pScrn) -{ - unsigned char *R128MMIO = pScrn->mmio; - - R128CCEWaitForIdle(pScrn); - OUTREGP(R128_PM4_BUFFER_DL_WPTR, - R128_PM4_BUFFER_DL_DONE, ~R128_PM4_BUFFER_DL_DONE); - OUTREG(R128_PM4_MICRO_CNTL, 0); - OUTREG(R128_PM4_BUFFER_CNTL, R128_PM4_NONPM4); + int xchangeDummy; + + /* FIXME: This should be in standard XFree86 assembly format */ + __asm__ volatile("push %%eax ;" + "xchg %%eax, %0 ;" + "pop %%eax" : : "m" (xchangeDummy)); + __asm__ volatile("push %%eax ;" + "push %%ebx ;" + "push %%ecx ;" + "push %%edx ;" + "movl $0,%%eax ;" + "cpuid ;" + "pop %%edx ;" + "pop %%ecx ;" + "pop %%ebx ;" + "pop %%eax" : /* no outputs */ : /* no inputs */); } diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_cce.h b/xc/lib/GL/mesa/src/drv/r128/r128_cce.h index a1d426eb8..5da4fd348 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_cce.h +++ b/xc/lib/GL/mesa/src/drv/r128/r128_cce.h @@ -37,24 +37,48 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #ifdef GLX_DIRECT_RENDERING +#include "r128_dri.h" +#include "r128_reg.h" + typedef union { float f; int i; } floatTOint; -#define R128_USE_CCE_PIO_MODE -#ifdef R128_USE_CCE_PIO_MODE +#if (R128_CCE_MODE == R128_PM4_192PIO) || \ + (R128_CCE_MODE == R128_PM4_128PIO_64INDBM) || \ + (R128_CCE_MODE == R128_PM4_64PIO_128INDBM) || \ + (R128_CCE_MODE == R128_PM4_64PIO_64VCBM_64INDBM) || \ + (R128_CCE_MODE == R128_PM4_64PIO_64VCPIO_64INDPIO) + +/* The ring buffer is in PIO mode */ +/* Start a sequence of CCE commands. This grabs the lock, and wait for + `n' entries to be free in the ring buffer. */ #define R128CCE_BEGIN(n) \ do { \ LOCK_HARDWARE(r128ctx); \ R128WaitForFifo(r128ctx->r128Screen, (n)); \ } while (0) + +/* End a sequence of CCE commands. This also releases the lock. */ +#define R128CCE_END() \ + do { \ + if (r128ctx->r128Screen->CCEFifoAddr != R128_PM4_FIFO_DATA_EVEN) { \ + OUTREG(r128ctx->r128Screen->CCEFifoAddr, R128_CCE_PACKET2); \ + r128ctx->r128Screen->CCEFifoAddr ^= 0x0004; \ + } \ + UNLOCK_HARDWARE(r128ctx); \ + } while (0) + +/* Insert an integer value into the CCE ring buffer. */ #define R128CCE(v) \ do { \ OUTREG(r128ctx->r128Screen->CCEFifoAddr, (v)); \ r128ctx->r128Screen->CCEFifoAddr ^= 0x0004; \ } while (0) + +/* Insert an floating point value into the CCE ring buffer. */ #define R128CCEF(v) \ do { \ floatTOint fTi; \ @@ -62,23 +86,14 @@ typedef union { OUTREG(r128ctx->r128Screen->CCEFifoAddr, fTi.i); \ r128ctx->r128Screen->CCEFifoAddr ^= 0x0004; \ } while (0) -#define R128CCE_END() \ - do { \ - if (r128ctx->r128Screen->CCEFifoAddr != R128_PM4_FIFO_DATA_EVEN) { \ - OUTREG(r128ctx->r128Screen->CCEFifoAddr, R128_CCE_PACKET2); \ - r128ctx->r128Screen->CCEFifoAddr ^= 0x0004; \ - } \ - UNLOCK_HARDWARE(r128ctx); \ - } while (0) -#define R128CCE_BEGIN_LOCKED(n) \ - do { \ - R128WaitForFifo(r128ctx->r128Screen, (n)); \ - } while (0) +/* Wait for `n' entries to be free in the ring buffer, while locked. */ #define R128CCE_WAIT_LOCKED(n) \ do { \ R128WaitForFifo(r128ctx->r128Screen, (n)); \ } while (0) + +/* End a sequence of CCE commands, but do not releases the lock. */ #define R128CCE_END_LOCKED() \ do { \ if (r128ctx->r128Screen->CCEFifoAddr != R128_PM4_FIFO_DATA_EVEN) { \ @@ -89,12 +104,31 @@ typedef union { #else +/* The ring buffer is in BM mode */ +/* FIXME: Implement support for the ring buffer */ + +/* Start a sequence of CCE commands. This grabs the lock, and wait for + `n' entries to be free in the ring buffer. */ #define R128CCE_BEGIN(n) -#define R128CCE(v) + +/* End a sequence of CCE commands. This also releases the lock. */ #define R128CCE_END() +/* Insert an integer value into the CCE ring buffer. */ +#define R128CCE(v) + +/* Insert an floating point value into the CCE ring buffer. */ +#define R128CCEF(v) + +/* Wait for `n' entries to be free in the ring buffer, while locked. */ +#define R128CCE_WAIT_LOCKED(n) + +/* End a sequence of CCE commands, but do not releases the lock. */ +#define R128CCE_END_LOCKED() + #endif +/* Insert a type-[0123] packet header into the ring buffer */ #define R128CCE0(p,r,n) R128CCE((p) | ((n) << 16) | ((r) >> 2)) #define R128CCE1(p,r1,r2) R128CCE((p) | (((r2) >> 2) << 11) | ((r1) >> 2)) #define R128CCE2(p) R128CCE((p)) @@ -125,8 +159,7 @@ extern void R128WaitForIdle(r128ScreenPtr pScrn); extern void R128CCEWaitForFifoFunction(r128ScreenPtr pScrn, int entries); extern void R128CCEWaitForIdle(r128ScreenPtr pScrn); -extern void R128CCEStart(r128ScreenPtr pScrn); -extern void R128CCEEnd(r128ScreenPtr pScrn); +extern void R128FlushWCMemory(void); #endif #endif /* _R128_CCE_H_ */ diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_ccevb.h b/xc/lib/GL/mesa/src/drv/r128/r128_ccevb.h new file mode 100644 index 000000000..2a1d4e590 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/r128/r128_ccevb.h @@ -0,0 +1,48 @@ +/* $XFree86$ */ +/************************************************************************** + +Copyright 1999, 2000 ATI Technologies Inc. and Precision Insight, Inc., + Cedar Park, Texas. +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 +on 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 +ATI, PRECISION INSIGHT AND/OR THEIR 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. + +**************************************************************************/ + +/* + * Authors: + * Kevin E. Martin + * + */ + +#ifndef _R128_CCEVB_H_ +#define _R128_CCEVB_H_ + +#ifdef GLX_DIRECT_RENDERING + +typedef struct { + int start; /* in bytes from the beginning of AGP memory */ + int count; /* in vertices */ + int size; /* in vertices */ + int done; /* VB has been sent to ring (FIXME) */ +} r128CCEVertBuf, *r128CCEVertBufPtr; + +#endif +#endif /* _R128_CCEVB_H_ */ diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_clear.c b/xc/lib/GL/mesa/src/drv/r128/r128_clear.c index 19aaaebfe..b10bb4629 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_clear.c +++ b/xc/lib/GL/mesa/src/drv/r128/r128_clear.c @@ -39,106 +39,125 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #include "r128_lock.h" #include "r128_reg.h" #include "r128_cce.h" +#include "r128_vb.h" #include "r128_clear.h" +/* Clear the depth buffer */ void r128ClearDepthBuffer(r128ContextPtr r128ctx, GLboolean all, - GLint x, GLint y, GLint width, GLint height) + GLint cx, GLint cy, GLint cw, GLint ch) { - unsigned char *R128MMIO = r128ctx->r128Screen->mmio; - int dst_bpp; - CARD32 write_mask; + unsigned char *R128MMIO = r128ctx->r128Screen->mmio; + __DRIdrawablePrivate *dPriv = r128ctx->driDrawable; + int nc = dPriv->numClipRects; + XF86DRIClipRectPtr c = dPriv->pClipRects; + int dst_bpp; + CARD32 write_mask; if (!(r128ctx->regs.tex_cntl_c & R128_Z_WRITE_ENABLE)) return; switch (r128ctx->regs.z_sten_cntl_c & R128_Z_PIX_WIDTH_MASK) { case R128_Z_PIX_WIDTH_16: - dst_bpp = R128_GMC_DST_16BPP; write_mask = 0x0000ffff; + dst_bpp = R128_GMC_DST_16BPP; break; case R128_Z_PIX_WIDTH_24: - dst_bpp = R128_GMC_DST_24BPP; write_mask = 0x00ffffff; + dst_bpp = R128_GMC_DST_24BPP; break; case R128_Z_PIX_WIDTH_32: - dst_bpp = R128_GMC_DST_32BPP; write_mask = 0xffffffff; + dst_bpp = R128_GMC_DST_32BPP; break; default: return; } - /* FIXME: save DP_WRITE_MASK or add to context???? */ - /* FIXME: use x, y, width, height */ + cx += dPriv->x; + cy = dPriv->y + dPriv->h - cy - ch; - R128CCE_BEGIN(11); + /* Flush any outstanding vertex buffers */ + R128_FLUSH_VB(r128ctx); + + LOCK_HARDWARE(r128ctx); /* Set the write mask so that we _only_ clear the Z buffer */ + R128CCE_WAIT_LOCKED(2); R128CCE0(R128_CCE_PACKET0, R128_DP_WRITE_MASK, 0); R128CCE(write_mask); /* Temporarily disable Z and stencil buffer and texture mapping modes */ + R128CCE_WAIT_LOCKED(2); R128CCE0(R128_CCE_PACKET0, R128_TEX_CNTL_C, 0); R128CCE(r128ctx->regs.tex_cntl_c & ~(R128_Z_ENABLE | R128_STENCIL_ENABLE | R128_TEXMAP_ENABLE)); - R128CCE3(R128_CCE_PACKET3_CNTL_PAINT_MULTI, 3); -#if 0 - /* FIXME: do we want to set R128_GMC_DST_PITCH_OFFSET_CNTL? - This requires us to include the offset and pitch - registers below, but this could be very useful since it - means we don't have to add the depthX and depthY values - to the drawable's x and y values. */ - R128CCE(R128_GMC_DST_PITCH_OFFSET_CNTL - | R128_GMC_BRUSH_SOLID_COLOR - | dst_bpp - | R128_GMC_SRC_DATATYPE_COLOR - | R128_ROP3_P - | R128_GMC_3D_FCN_EN /* FIXME?? */ - | R128_GMC_CLR_CMP_CNTL_DIS /* FIXME?? */ - | R128_AUX_CLIP_DIS /* FIXME?? */ - | R128_GMC_WR_MSK_DIS); /* FIXME?? */ -#else - R128CCE(R128_GMC_BRUSH_SOLID_COLOR - | dst_bpp - | R128_GMC_SRC_DATATYPE_COLOR - | R128_ROP3_P - | R128_GMC_3D_FCN_EN /* FIXME?? */ - | R128_GMC_CLR_CMP_CNTL_DIS /* FIXME?? */ - | R128_AUX_CLIP_DIS /* FIXME?? */ - | R128_GMC_WR_MSK_DIS); /* FIXME?? */ -#endif - R128CCE(r128ctx->ClearDepth); - R128CCE(((r128ctx->driDrawable->x + r128ctx->r128Screen->depthX)<< 16) - | (r128ctx->driDrawable->y + r128ctx->r128Screen->depthY)); - R128CCE((r128ctx->driDrawable->w << 16) | r128ctx->driDrawable->h); + /* Cycle through the clip rects */ + while (nc--) { + int x = c[nc].x1; + int y = c[nc].y1; + int w = c[nc].x2 - x; + int h = c[nc].y2 - y; + + if (!all) { + 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 || h <= 0) continue; + } + + x += r128ctx->r128Screen->depthX; + y += r128ctx->r128Screen->depthY; + + R128CCE_WAIT_LOCKED(5); + R128CCE3(R128_CCE_PACKET3_CNTL_PAINT_MULTI, 3); + R128CCE(R128_GMC_BRUSH_SOLID_COLOR + | dst_bpp + | R128_GMC_SRC_DATATYPE_COLOR + | R128_ROP3_P + | R128_GMC_3D_FCN_EN /* FIXME?? */ + | R128_GMC_CLR_CMP_CNTL_DIS /* FIXME?? */ + | R128_AUX_CLIP_DIS /* FIXME?? */ + | R128_GMC_WR_MSK_DIS); /* FIXME?? */ + R128CCE(r128ctx->ClearDepth); + R128CCE((x << 16) | y); + R128CCE((w << 16) | h); + } #if 0 - /* FIXME: if we include this, change CCE_BEGIN() above */ - /* Set the write mask so that we _only_ clear the Z buffer */ - /* FIXME: should this be in the context? */ + R128CCE_WAIT_LOCKED(2); R128CCE0(R128_CCE_PACKET0, R128_DP_WRITE_MASK, 0); R128CCE(0xffffffff); /* Restore Z and stencil buffer and texture mapping modes */ + R128CCE_WAIT_LOCKED(2); R128CCE0(R128_CCE_PACKET0, R128_TEX_CNTL_C, 0); R128CCE(r128ctx->regs.tex_cntl_c); #else - /* FIXME: this should not be needed! */ + /* FIXME: We should be able to optimize this by restoring only the + registers that change (above) */ /* NOTE: The restore of TEX_CNTL_C and R128_DP_WRITE_MASK is handled by vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */ r128ctx->dirty = R128_UPDATE_CONTEXT; - /* r128UpdateState(r128ctx); */ #endif - R128CCE_END(); + R128CCE_END_LOCKED(); + + UNLOCK_HARDWARE(r128ctx); } +/* Clear a color buffer */ void r128ClearColorBuffer(r128ContextPtr r128ctx, GLboolean all, - GLint x, GLint y, GLint width, GLint height) + GLint cx, GLint cy, GLint cw, GLint ch) { - unsigned char *R128MMIO = r128ctx->r128Screen->mmio; - int dst_bpp; + unsigned char *R128MMIO = r128ctx->r128Screen->mmio; + __DRIdrawablePrivate *dPriv = r128ctx->driDrawable; + int nc = dPriv->numClipRects; + XF86DRIClipRectPtr c = dPriv->pClipRects; + int dst_bpp; switch (r128ctx->r128Screen->bpp) { case 8: @@ -157,44 +176,73 @@ void r128ClearColorBuffer(r128ContextPtr r128ctx, GLboolean all, break; } - /* FIXME: use x, y, width, height */ + cx += dPriv->x; + cy = dPriv->y + dPriv->h - cy - ch; + /* FIXME: use R128_GMC_DST_PITCH_OFFSET_CNTL to set to the back buffer when we should be draing to the back buffer? */ - R128CCE_BEGIN(7); + /* Flush any outstanding vertex buffers */ + R128_FLUSH_VB(r128ctx); + + LOCK_HARDWARE(r128ctx); /* Temporarily disable Z and stencil buffer and texture mapping modes */ + R128CCE_WAIT_LOCKED(2); R128CCE0(R128_CCE_PACKET0, R128_TEX_CNTL_C, 0); R128CCE(r128ctx->regs.tex_cntl_c & ~(R128_Z_ENABLE | R128_STENCIL_ENABLE | R128_TEXMAP_ENABLE)); - R128CCE3(R128_CCE_PACKET3_CNTL_PAINT_MULTI, 3); - R128CCE(R128_GMC_BRUSH_SOLID_COLOR - | dst_bpp - | R128_GMC_SRC_DATATYPE_COLOR - | R128_ROP3_P - | R128_GMC_3D_FCN_EN /* FIXME?? */ - | R128_GMC_CLR_CMP_CNTL_DIS /* FIXME?? */ - | R128_AUX_CLIP_DIS); /* FIXME?? */ - R128CCE(r128ctx->ClearColor); - /* FIXME: when not using the back buf, make sure clears go to front buf */ - R128CCE(((r128ctx->driDrawable->x + r128ctx->bufX)<< 16) - | (r128ctx->driDrawable->y + r128ctx->bufY)); - R128CCE((r128ctx->driDrawable->w << 16) | r128ctx->driDrawable->h); + /* Cycle through the clip rects */ + while (nc--) { + int x = c[nc].x1; + int y = c[nc].y1; + int w = c[nc].x2 - x; + int h = c[nc].y2 - y; + + if (!all) { + 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 - h; + + if (w <= 0 || h <= 0) continue; + } + + x += r128ctx->bufX; + y += r128ctx->bufY; + + R128CCE_WAIT_LOCKED(5); + R128CCE3(R128_CCE_PACKET3_CNTL_PAINT_MULTI, 3); + R128CCE(R128_GMC_BRUSH_SOLID_COLOR + | dst_bpp + | R128_GMC_SRC_DATATYPE_COLOR + | R128_ROP3_P + | R128_GMC_3D_FCN_EN /* FIXME?? */ + | R128_GMC_CLR_CMP_CNTL_DIS /* FIXME?? */ + | R128_AUX_CLIP_DIS); /* FIXME?? */ + R128CCE(r128ctx->ClearColor); + R128CCE((x << 16) | y); + R128CCE((w << 16) | h); + } #if 0 - /* FIXME: if we include this, change CCE_BEGIN() above */ /* Restore Z and stencil buffer and texture mapping modes */ + R128CCE_WAIT_LOCKED(2); R128CCE0(R128_CCE_PACKET0, R128_TEX_CNTL_C, 0); R128CCE(r128ctx->regs.tex_cntl_c); #else - /* FIXME: this should not be needed! */ + /* FIXME: We should be able to optimize this by restoring only the + registers that change (above) */ /* NOTE: The restore of TEX_CNTL_C is handled by vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv */ - r128ctx->dirty = R128_UPDATE_CONTEXT; - /* r128UpdateState(r128ctx); */ + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_ALL_DIRTY; #endif - R128CCE_END(); + R128CCE_END_LOCKED(); + + UNLOCK_HARDWARE(r128ctx); } diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_context.c b/xc/lib/GL/mesa/src/drv/r128/r128_context.c new file mode 100644 index 000000000..e3983d214 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/r128/r128_context.c @@ -0,0 +1,183 @@ +/* $XFree86$ */ +/************************************************************************** + +Copyright 1999, 2000 ATI Technologies Inc. and Precision Insight, Inc., + Cedar Park, Texas. +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 +on 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 +ATI, PRECISION INSIGHT AND/OR THEIR 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. + +**************************************************************************/ + +/* + * Authors: + * Kevin E. Martin + * + */ + +#include "r128_init.h" +#include "r128_mesa.h" +#include "r128_xmesa.h" +#include "r128_context.h" +#include "r128_dd.h" +#include "r128_state.h" +#include "r128_span.h" +#include "r128_depth.h" +#include "r128_tex.h" +#include "r128_vb.h" +#include "r128_pipeline.h" + +#include "context.h" +#include "simple_list.h" + +/* Create the device specific context */ +r128ContextPtr r128CreateContext(GLvisual *glVisual, + XMesaContext c, + XMesaContext share_list) +{ + r128ContextPtr r128ctx; + GLcontext *shareCtx, *glCtx; + + r128ctx = (r128ContextPtr)Xmalloc(sizeof(*r128ctx)); + if (!r128ctx) return NULL; + + if (share_list) + shareCtx = ((r128ContextPtr)(share_list->private))->glCtx; + else + shareCtx = NULL; + + /* Initialize r128Context */ + r128ctx->xmCtx = c; + r128ctx->glCtx = gl_create_context(glVisual, + shareCtx, + (void *)r128ctx, + GL_TRUE); + r128ctx->display = c->display; + r128ctx->driContext = c->driContextPriv; + r128ctx->driDrawable = NULL; /* Set by XMesaMakeCurrent */ + r128ctx->dirty = R128_ALL_DIRTY; + r128ctx->dirty_context = R128_CTX_ALL_DIRTY; + r128ctx->needClip = GL_TRUE; + if (getenv("LIBGL_SOFTWARE_RENDERING")) + r128ctx->SWonly = GL_TRUE; + else + r128ctx->SWonly = GL_FALSE; + if (getenv("LIBGL_NO_SOFTWARE_FALLBACKS")) + r128ctx->SWfallbackDisable = GL_TRUE; + else + r128ctx->SWfallbackDisable = GL_FALSE; + r128ctx->r128Screen = + (r128ScreenPtr)(c->driContextPriv->driScreenPriv->private); + r128ctx->SAREA = + (R128SAREAPrivPtr)((char *)c->driContextPriv->driScreenPriv->pSAREA + + sizeof(XF86DRISAREARec)); + + r128ctx->CurrentTexObj[0] = NULL; + r128ctx->CurrentTexObj[1] = NULL; + make_empty_list(&r128ctx->TexObjList); + make_empty_list(&r128ctx->SwappedOut); +#if USE_AGP_TEXTURES + r128ctx->texHeap = mmInit(0, r128ctx->r128Screen->agpTexSize); +#else + r128ctx->texHeap = mmInit(0, r128ctx->r128Screen->textureSize); +#endif + r128ctx->lastTexAge = -1; + + r128ctx->RenderIndex = -1; + r128ctx->useFastPath = GL_FALSE; + + r128ctx->vb = NULL; + + /* Initialize GLcontext */ + glCtx = r128ctx->glCtx; + + r128DDInitExtensions(glCtx); + + r128DDInitDriverFuncs(glCtx); + r128DDInitStateFuncs(glCtx); + r128DDInitSpanFuncs(glCtx); + r128DDInitDepthFuncs(glCtx); + r128DDInitTextureFuncs(glCtx); + + glCtx->Driver.TriangleCaps = (DD_TRI_CULL + | DD_TRI_LIGHT_TWOSIDE + | DD_TRI_OFFSET); + glCtx->TriangleCaps |= DD_CLIP_FOG_COORD; + + /* Reset Mesa's current 2D texture pointers to the driver's textures */ + glCtx->Shared->DefaultD[2][0].DriverData = NULL; + glCtx->Shared->DefaultD[2][1].DriverData = NULL; + + /* If Mesa has current a vertex buffer, make sure the driver's VB + data is up to date */ + if (glCtx->VB) r128DDRegisterVB(glCtx->VB); + + /* Register the fast path */ + if (glCtx->NrPipelineStages) + glCtx->NrPipelineStages = + r128RegisterPipelineStages(glCtx->PipelineStage, + glCtx->PipelineStage, + glCtx->NrPipelineStages); + + r128DDInitState(r128ctx); + + return r128ctx; +} + +/* Destroy the device specific context */ +void r128DestroyContext(r128ContextPtr r128ctx) +{ + if (r128ctx) { + r128TexObjPtr t, next_t; + + foreach_s (t, next_t, &r128ctx->TexObjList) + r128DestroyTexObj(r128ctx, t); + + foreach_s (t, next_t, &r128ctx->SwappedOut) + r128DestroyTexObj(r128ctx, t); + + gl_destroy_context(r128ctx->glCtx); + Xfree(r128ctx); + } +} + +/* Load the device specific context into the hardware. The actual + setting of the hardware state is done in the r128UpdateHWState(). */ +r128ContextPtr r128MakeCurrent(r128ContextPtr oldCtx, + r128ContextPtr newCtx, + __DRIdrawablePrivate *dPriv) +{ + if (oldCtx) { + newCtx->dirty = R128_REQUIRE_QUIESCENCE; + if (oldCtx != newCtx) { + newCtx->dirty |= R128_UPDATE_CONTEXT; + newCtx->dirty_context = R128_CTX_ALL_DIRTY; + } + if (oldCtx->driDrawable != dPriv) + newCtx->dirty |= R128_UPDATE_WINPOS; + } else { + newCtx->dirty = R128_ALL_DIRTY; + newCtx->dirty_context = R128_CTX_ALL_DIRTY; + } + + newCtx->driDrawable = dPriv; + + return newCtx; +} diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_context.h b/xc/lib/GL/mesa/src/drv/r128/r128_context.h index 3127223ef..1be2070b5 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_context.h +++ b/xc/lib/GL/mesa/src/drv/r128/r128_context.h @@ -37,17 +37,50 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #ifdef GLX_DIRECT_RENDERING +#include "r128_sarea.h" +#include "r128_texobj.h" +#include "r128_fastpath.h" +#include "r128_ccevb.h" + +/* Flags for what needs to be updated before a new primitive is rendered */ #define R128_CLEAN 0x0000 #define R128_REQUIRE_QUIESCENCE 0x0001 -#define R128_START_CCE 0x0002 -#define R128_UPDATE_CONTEXT 0x0004 -#define R128_UPDATE_CLIPRECTS 0x0008 +#define R128_UPDATE_CONTEXT 0x0002 +#define R128_UPDATE_WINPOS 0x0004 +#define R128_UPDATE_TEX0IMAGES 0x0008 +#define R128_UPDATE_TEX1IMAGES 0x0010 +#define R128_UPDATE_TEXSTATE 0x0020 #define R128_ALL_DIRTY 0xffff +/* Flags for what context state needs to be updated */ +#define R128_CTX_CLEAN 0x0000 +#define R128_CTX_MISC 0x0001 +#define R128_CTX_ENGINESTATE 0x0002 +#define R128_CTX_TEX0STATE 0x0004 +#define R128_CTX_TEX1STATE 0x0008 +#define R128_CTX_TEXENVSTATE 0x0010 +#define R128_CTX_FOGSTATE 0x0020 +#define R128_CTX_ZSTENSTATE 0x0040 +#define R128_CTX_SCISSORS 0x0080 +#define R128_CTX_ALPHASTATE 0x0100 +#define R128_CTX_SETUPSTATE 0x0200 +#define R128_CTX_WIN_Z_POS 0x0400 +#define R128_CTX_FLUSH_PIX_CACHE 0x0800 +#define R128_CTX_ALL_DIRTY 0xffff + +/* Flags for software fallback cases */ +#define R128_FALLBACK_TEXTURE 0x0001 +#define R128_FALLBACK_DRAW_BUFFER 0x0002 +#define R128_FALLBACK_READ_BUFFER 0x0004 +#define R128_FALLBACK_COLORMASK 0x0008 +#define R128_FALLBACK_STIPPLE 0x0010 + +/* NOTE: The groups below need to be kept together so that a single + memcpy can be used to transfer data to the ring buffer */ typedef struct { - CARD32 scale_3d_cntl; /* 0x1a00 */ + CARD32 scale_3d_cntl; /* 0x1a00 */ - CARD32 dst_pitch_offset_c; /* 0x1c80 */ + CARD32 dst_pitch_offset_c; /* 0x1c80 */ CARD32 dp_gui_master_cntl; CARD32 sc_top_left_c; CARD32 sc_bottom_right_c; @@ -62,80 +95,100 @@ typedef struct { CARD32 prim_tex_cntl_c; CARD32 prim_texture_combine_cntl_c; CARD32 tex_size_pitch_c; - CARD32 prim_tex_0_offset_c; - CARD32 prim_tex_1_offset_c; - CARD32 prim_tex_2_offset_c; - CARD32 prim_tex_3_offset_c; - CARD32 prim_tex_4_offset_c; - CARD32 prim_tex_5_offset_c; - CARD32 prim_tex_6_offset_c; - CARD32 prim_tex_7_offset_c; - CARD32 prim_tex_8_offset_c; - CARD32 prim_tex_9_offset_c; - CARD32 prim_tex_10_offset_c; /* 0x1ce4 */ - - CARD32 sec_tex_cntl_c; /* 0x1d00 */ + CARD32 prim_tex_offset[R128_TEX_MAXLEVELS]; /* 0x1ce4 */ + + CARD32 sec_tex_cntl_c; /* 0x1d00 */ CARD32 sec_tex_combine_cntl_c; - CARD32 sec_tex_0_offset_c; - CARD32 sec_tex_1_offset_c; - CARD32 sec_tex_2_offset_c; - CARD32 sec_tex_3_offset_c; - CARD32 sec_tex_4_offset_c; - CARD32 sec_tex_5_offset_c; - CARD32 sec_tex_6_offset_c; - CARD32 sec_tex_7_offset_c; - CARD32 sec_tex_8_offset_c; - CARD32 sec_tex_9_offset_c; - CARD32 sec_tex_10_offset_c; + CARD32 sec_tex_offset[R128_TEX_MAXLEVELS]; CARD32 constant_color_c; CARD32 prim_texture_border_color_c; CARD32 sec_texture_border_color_c; CARD32 sten_ref_mask_c; - CARD32 plane_3d_mask_c; /* 0x1d44 */ + CARD32 plane_3d_mask_c; /* 0x1d44 */ + + CARD32 setup_cntl; /* 0x1bc4 */ - CARD32 setup_cntl; /* 0x1bc4 */ - CARD32 pm4_vc_fpu_setup; /* 0x071c */ + CARD32 pm4_vc_fpu_setup; /* 0x071c */ - CARD32 fog_3d_table_start; /* 0x1810 */ + CARD32 fog_3d_table_start; /* 0x1810 */ CARD32 fog_3d_table_end; - CARD32 fog_3d_table_density; /* 0x181c */ + CARD32 fog_3d_table_density; /* 0x181c */ - CARD32 window_xy_offset; /* 0x1bcc */ + CARD32 window_xy_offset; /* 0x1bcc */ - CARD32 dp_write_mask; /* 0x16cc */ + CARD32 dp_write_mask; /* 0x16cc */ + + CARD32 pc_gui_ctlstat; /* 0x1748 */ } r128ContextRegs; typedef struct { - XMesaContext xmCtx; - GLcontext *glCtx; - int dirty; - int needClip; - - int RenderIndex; - points_func PointsFunc; - line_func LineFunc; + XMesaContext xmCtx; /* XMesa context */ + GLcontext *glCtx; /* Mesa context */ + int dirty; /* Hardware state to be updated */ + int dirty_context; /* Context state to be updated */ + + int needClip; /* Primitives need to be clipped + to the window */ + + int SWonly; /* Force software-only rendering */ + int SWfallbackDisable; /* Disable software fallbacks */ + + + r128TexObjPtr CurrentTexObj[2]; /* Ptr to current texture + object associated with + each texture unit */ + r128TexObj TexObjList; /* List of textures swapped in */ + r128TexObj SwappedOut; /* List of textures swapped out */ + memHeap_t *texHeap; /* Global heap of textures */ + int lastTexAge; /* Last known global texture age */ + + int useFastPath; /* Currently using Fast Path code */ + int SetupIndex; /* Raster setup function index */ + int SetupDone; /* Partial raster setup done? */ + int RenderIndex; /* Render state function index */ + r128InterpFunc interp; /* Current vert interp function */ + + r128CCEVertBufPtr vb; /* VB currently being filled */ + + points_func PointsFunc; /* Current Points, Line, Triangle */ + line_func LineFunc; /* and Quad rendering functions */ triangle_func TriangleFunc; quad_func QuadFunc; - CARD32 IndirectTriangles; - CARD32 Fallback; + CARD32 IndirectTriangles; /* Flags for point, line, + tri and quad software + fallbacks */ + CARD32 Fallback; /* Need software fallback */ + + r128ContextRegs regs; /* Hardware state */ + CARD32 Color; /* Current draw color */ + CARD32 ClearColor; /* Color used to clear color buffer */ + CARD32 ClearDepth; /* Value used to clear depth buffer */ - r128ContextRegs regs; - CARD32 ClearColor; - CARD32 ClearDepth; + int bufX; /* x-offset to current draw buffer */ + int bufY; /* y-offset to current draw buffer */ - int bufX; - int bufY; + R128SAREAPrivPtr SAREA; /* Pointer to SAREA private data */ - Display *display; + Display *display; /* X server display */ - __DRIcontextPrivate *driContext; - __DRIdrawablePrivate *driDrawable; + __DRIcontextPrivate *driContext; /* DRI context */ + __DRIdrawablePrivate *driDrawable; /* DRI drawable bound to this ctx */ - r128ScreenPtr r128Screen; + r128ScreenPtr r128Screen; /* Screen private DRI data */ } r128ContextRec, *r128ContextPtr; -extern r128ContextPtr r128Context; +#define R128_MESACTX(r128ctx) ((r128ctx)->glCtx) +#define R128_DRIDRAWABLE(r128ctx) ((r128ctx)->driDrawable) +#define R128_DRISCREEN(r128ctx) ((r128ctx)->r128Screen->driScreen) + +extern r128ContextPtr r128CreateContext(GLvisual *glVisual, + XMesaContext c, + XMesaContext share_list); +extern void r128DestroyContext(r128ContextPtr r128ctx); +extern r128ContextPtr r128MakeCurrent(r128ContextPtr oldCtx, + r128ContextPtr newCtx, + __DRIdrawablePrivate *dPriv); #endif #endif /* _R128_CONTEXT_H_ */ diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_dd.c b/xc/lib/GL/mesa/src/drv/r128/r128_dd.c index 04745d240..230205783 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_dd.c +++ b/xc/lib/GL/mesa/src/drv/r128/r128_dd.c @@ -37,8 +37,10 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #include "r128_cce.h" #include "r128_clear.h" #include "r128_vb.h" +#include "r128_pipeline.h" #include "r128_dd.h" +/* Driver entry point for clearing color and ancillary buffers */ static GLbitfield r128DDClear(GLcontext *ctx, GLbitfield mask, GLboolean all, GLint x, GLint y, GLint width, GLint height) { @@ -55,6 +57,7 @@ static GLbitfield r128DDClear(GLcontext *ctx, GLbitfield mask, GLboolean all, } #if 0 + /* FIXME: Add stencil support */ if (mask & GL_STENCIL_BUFFER_BIT) { r128ClearStencilBuffer(r128ctx, all, x, y, width, height); mask &= ~GL_STENCIL_BUFFER_BIT; @@ -64,6 +67,7 @@ static GLbitfield r128DDClear(GLcontext *ctx, GLbitfield mask, GLboolean all, return mask; } +/* Return the current color buffer size */ static void r128DDGetBufferSize(GLcontext *ctx, GLuint *width, GLuint *height) { r128ContextPtr r128ctx = R128_CONTEXT(ctx); @@ -72,6 +76,7 @@ static void r128DDGetBufferSize(GLcontext *ctx, GLuint *width, GLuint *height) *height = r128ctx->driDrawable->h; } +/* Return various strings for glGetString() */ static const GLubyte *r128DDGetString(GLcontext *ctx, GLenum name) { switch (name) { @@ -84,53 +89,75 @@ static const GLubyte *r128DDGetString(GLcontext *ctx, GLenum name) } } +/* Send all commands to the hardware. If vertex buffers or indirect + buffers are in use, then we need to make sure they are sent to the + hardware. All commands that are normally sent to the ring are + already considered `flushed'. */ +static void r128DDFlush(GLcontext *ctx) +{ + R128_FLUSH_VB(R128_CONTEXT(ctx)); +} + +/* Make sure all commands have been sent to the hardware and have + completed processing. */ static void r128DDFinish(GLcontext *ctx) { r128ContextPtr r128ctx = R128_CONTEXT(ctx); + r128DDFlush(ctx); R128CCEWaitForIdle(r128ctx->r128Screen); } -static void r128DDFlush(GLcontext *ctx) -{ - /* Nothing to do here since all commands are automatically flushed */ -} - +/* Return various parameters requested by Mesa */ static GLint r128DDGetParameteri(const GLcontext *ctx, GLint param) { switch (param) { #if 0 - case DD_MAX_TEXTURE_SIZE: - return 2048; /* FIXME ?? */ - case DD_MAX_TEXTURES: - return 2; /* FIXME ?? */ - case DD_HAVE_HARDWARE_FOG: - return 1; /* FIXME ?? */ + /* FIXME: Support for these needs to be added to Mesa */ + case DD_MAX_TEXTURE_SIZE: return 1024; + case DD_MAX_TEXTURES: return 2; #endif - default: - return 0; +#if 0 + case DD_HAVE_HARDWARE_FOG: return 1; /* FIXME: Add HW fog support */ +#endif + default: return 0; } } +/* Initialize the extensions supported by this driver */ void r128DDInitExtensions(GLcontext *ctx) { + /* FIXME: Are there other extensions to enable/disable??? */ + gl_extensions_disable(ctx, "GL_EXT_shared_texture_palette"); + gl_extensions_disable(ctx, "GL_EXT_paletted_texture"); + gl_extensions_disable(ctx, "GL_EXT_point_parameters"); + gl_extensions_disable(ctx, "ARB_imaging"); + gl_extensions_disable(ctx, "GL_EXT_blend_minmax"); + gl_extensions_disable(ctx, "GL_EXT_blend_logic_op"); + gl_extensions_disable(ctx, "GL_EXT_blend_subtract"); + gl_extensions_disable(ctx, "GL_INGR_blend_func_separate"); + + if (getenv("LIBGL_NO_MULTITEXTURE")) + gl_extensions_disable(ctx, "GL_ARB_multitexture"); } +/* Initialize the driver's misc functions */ void r128DDInitDriverFuncs(GLcontext *ctx) { - ctx->Driver.Clear = r128DDClear; + ctx->Driver.Clear = r128DDClear; - ctx->Driver.GetBufferSize = r128DDGetBufferSize; - ctx->Driver.GetString = r128DDGetString; - ctx->Driver.Finish = r128DDFinish; - ctx->Driver.Flush = r128DDFlush; + ctx->Driver.GetBufferSize = r128DDGetBufferSize; + ctx->Driver.GetString = r128DDGetString; + ctx->Driver.Finish = r128DDFinish; + ctx->Driver.Flush = r128DDFlush; - ctx->Driver.Error = NULL; - ctx->Driver.GetParameteri = r128DDGetParameteri; + ctx->Driver.Error = NULL; + ctx->Driver.GetParameteri = r128DDGetParameteri; - ctx->Driver.DrawPixels = NULL; - ctx->Driver.Bitmap = NULL; + ctx->Driver.DrawPixels = NULL; + ctx->Driver.Bitmap = NULL; - ctx->Driver.RegisterVB = r128DDRegisterVB; - ctx->Driver.UnregisterVB = r128DDUnregisterVB; + ctx->Driver.RegisterVB = r128DDRegisterVB; + ctx->Driver.UnregisterVB = r128DDUnregisterVB; + ctx->Driver.BuildPrecalcPipeline = r128DDBuildPrecalcPipeline; } diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_depth.c b/xc/lib/GL/mesa/src/drv/r128/r128_depth.c index 0c4076058..589556b15 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_depth.c +++ b/xc/lib/GL/mesa/src/drv/r128/r128_depth.c @@ -58,10 +58,13 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. volatile GLdepth *zptr; \ int i +/* Return a pointer to the offset in the depth buffer at (x,y) */ #define DEPTH_ADDR(base, _x, _y) \ (GLdepth*)(zbase + _x * (r128scrn->bpp/8) + \ (height - _y) * r128scrn->fbStride) +/* Test a span for a particular `_op_' comparison, and update the depth + buffer (if needed). */ #define DEPTH_TEST_SPAN(_op_) \ if (ctx->Depth.Mask) { /* Update Z buffer */ \ for (i = 0; i < n; i++, zptr++, m++) { \ @@ -86,6 +89,8 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. } \ } +/* Test a list of pixels for a particular `_op_' comparison, and update + the depth buffer (if needed). */ #define DEPTH_TEST_PIXELS(_op_) \ if (ctx->Depth.Mask) { /* Update Z buffer */ \ for (i = 0; i < n; i++) { \ @@ -105,10 +110,13 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. } \ } +/* Allocate a depth buffer */ static void r128DDAllocDepthBuffer(GLcontext *ctx) { } +/* Update the depth buffer for a given span. This is only used for + software fallbacks. */ static GLuint r128DDDepthTestSpan(GLcontext *ctx, GLuint n, GLint x, GLint y, const GLdepth z[], @@ -154,6 +162,8 @@ static GLuint r128DDDepthTestSpan(GLcontext *ctx, return passed; } +/* Update the depth buffer for a given array of pixels. This is only + used for software fallbacks. */ static void r128DDDepthTestPixels(GLcontext *ctx, GLuint n, const GLint x[], @@ -195,6 +205,8 @@ static void r128DDDepthTestPixels(GLcontext *ctx, UNLOCK_HARDWARE(r128ctx); } +/* Return a span in the depth buffer as floats. This is only used for + software fallbacks. */ static void r128DDReadDepthSpanFloat(GLcontext *ctx, GLuint n, GLint x, GLint y, GLfloat depth[]) @@ -216,6 +228,8 @@ static void r128DDReadDepthSpanFloat(GLcontext *ctx, UNLOCK_HARDWARE(r128ctx); } +/* Return a span in the depth buffer as ints. This is only used for + software fallbacks. */ static void r128DDReadDepthSpanInt(GLcontext *ctx, GLuint n, GLint x, GLint y, GLdepth depth[]) @@ -237,6 +251,7 @@ static void r128DDReadDepthSpanInt(GLcontext *ctx, } +/* Initialize the driver's depth functions */ void r128DDInitDepthFuncs(GLcontext *ctx) { ctx->Driver.AllocDepthBuffer = r128DDAllocDepthBuffer; diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_fastpath.c b/xc/lib/GL/mesa/src/drv/r128/r128_fastpath.c new file mode 100644 index 000000000..953f9d9a6 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/r128/r128_fastpath.c @@ -0,0 +1,537 @@ +/* $XFree86$ */ +/************************************************************************** + +Copyright 1999, 2000 ATI Technologies Inc. and Precision Insight, Inc., + Cedar Park, Texas. +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 +on 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 +ATI, PRECISION INSIGHT AND/OR THEIR 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. + +**************************************************************************/ + +/* + * Authors: + * Kevin E. Martin + * + */ + +#include "r128_init.h" +#include "r128_mesa.h" +#include "r128_state.h" +#include "r128_vb.h" +#include "r128_tris.h" +#include "r128_fastpath.h" + +#include "mmath.h" +#include "cva.h" +#include "vertices.h" + +/* FIXME: These routines were copied from the i810 driver, and were only + slightly modified for the Rage 128. They still need to be optmizied + and cleaned up. Also, support for USE_RHW2 needs to be added. */ + +typedef struct r128_fast_table { + r128BuildVerticesFunc build_vertices; + r128InterpFunc interp; +} r128FastPathTable; + +#define POINT(x) r128DrawPoint(r128ctx, &vert[x].v, psize) +#define LINE(x,y) r128DrawLine(r128ctx, &vert[x].v, &vert[y].v, lwidth) +#define TRI(x,y,z) r128DrawTriangle(r128ctx, &vert[x].v, &vert[y].v, &vert[z].v) + +/* Direct, and no clipping required. The clip funcs have not been + written yet, so this is only useful for the fast path. */ +#define RENDER_POINTS(start, count) \ +do { \ + GLuint e; \ + for (e = start; e <= count; e++) \ + POINT(elt[e]); \ +} while (0) + +#define RENDER_LINE(i1, i) \ +do { \ + GLuint e1 = elt[i1], e = elt[i]; \ + LINE(e1, e); \ +} while (0) + +#define RENDER_TRI(i2, i1, i, pv, parity) \ +do { \ + GLuint e2 = elt[i2], e1 = elt[i1], e = elt[i]; \ + if (parity) { \ + GLuint tmp = e2; \ + e2 = e1; \ + e1 = tmp; \ + } \ + TRI(e2, e1, e); \ +} while (0) + +#define RENDER_QUAD(i3, i2, i1, i, pv) \ +do { \ + GLuint e3 = elt[i3], e2 = elt[i2], e1 = elt[i1], e = elt[i]; \ + TRI(e3, e2, e); \ + TRI(e2, e1, e); \ +} while (0) + +#define LOCAL_VARS \ + r128VertexPtr vert = R128_DRIVER_DATA(VB)->verts; \ + const GLuint *elt = VB->EltPtr->data; \ + GLcontext *ctx = VB->ctx; \ + r128ContextPtr r128ctx = R128_CONTEXT(ctx); \ + const GLfloat lwidth = ctx->Line.Width; \ + const GLfloat psize = ctx->Point.Size; \ + (void) lwidth; (void)psize; (void) vert; + +#define TAG(x) x##_r128_smooth_indirect +#include "render_tmp.h" + + + +#define NEGATIVE(f) (f < 0) +#define DIFFERENT_SIGNS(a,b) ((a*b) < 0) +#define LINTERP(T, A, B) ((A) + (T) * ((B) - (A))) + + +#define INTERP_RGBA(t, out, a, b) \ +do { \ + int i; \ + for (i = 0; i < 4; i++) { \ + GLfloat fa = UBYTE_COLOR_TO_FLOAT_COLOR(a[i]); \ + GLfloat fb = UBYTE_COLOR_TO_FLOAT_COLOR(b[i]); \ + GLfloat fo = LINTERP(t, fa, fb); \ + FLOAT_COLOR_TO_UBYTE_COLOR(out[i], fo); \ + } \ +} while (0) + + +#define CLIP(SGN, V, PLANE) \ +do { \ + if (mask & PLANE) { \ + GLuint *indata = inlist[in]; \ + GLuint *outdata = inlist[in ^= 1]; \ + GLuint nr = n; \ + GLfloat *J = verts[indata[nr-1]].f; \ + GLfloat dpJ = (SGN J[V]) + J[3]; \ + \ + inlist[0] = vlist1; \ + for (i = n = 0 ; i < nr ; i++) { \ + GLuint elt_i = indata[i]; \ + GLfloat *I = verts[elt_i].f; \ + GLfloat dpI = (SGN I[V]) + I[3]; \ + \ + if (DIFFERENT_SIGNS(dpI, dpJ)) { \ + GLfloat *O = verts[next_vert].f; \ + GLfloat t, *in, *out; \ + \ + if (NEGATIVE(dpI)) { \ + t = dpI / (dpI - dpJ); \ + in = I; \ + out = J; \ + } else { \ + t = dpJ / (dpJ - dpI); \ + in = J; \ + out = I; \ + } \ + \ + interp(t, O, in, out); \ + \ + clipmask[next_vert] = 0; \ + outdata[n++] = next_vert++; \ + } \ + \ + clipmask[elt_i] |= PLANE; /* don't set up */ \ + \ + if (!NEGATIVE(dpI)) { \ + outdata[n++] = elt_i; \ + clipmask[elt_i] &= ~PLANE; /* set up after all */ \ + } \ + \ + J = I; \ + dpJ = dpI; \ + } \ + \ + if (n < 3) return; \ + } \ +} while (0) + +#define LINE_CLIP(x,y,z,w,PLANE) \ +do { \ + if (mask & PLANE) { \ + GLfloat dpI = DOT4V(I,x,y,z,w); \ + GLfloat dpJ = DOT4V(J,x,y,z,w); \ + \ + if (DIFFERENT_SIGNS(dpI, dpJ)) { \ + GLfloat *O = verts[next_vert].f; \ + GLfloat t = dpI / (dpI - dpJ); \ + \ + interp(t, O, I, J); \ + \ + clipmask[next_vert] = 0; \ + \ + if (NEGATIVE(dpI)) { \ + clipmask[elts[0]] |= PLANE; \ + I = O; \ + elts[0] = next_vert++; \ + } else { \ + clipmask[elts[1]] |= PLANE; \ + J = O; \ + elts[1] = next_vert++; \ + } \ + } else if (NEGATIVE(dpI)) return; \ + } \ +} while (0) + + +static void r128TriClip(GLuint **p_elts, + r128Vertex *verts, + GLubyte *clipmask, + GLuint *p_next_vert, + GLubyte mask, + r128InterpFunc interp) +{ + GLuint *elts = *p_elts; + GLuint next_vert = *p_next_vert; + GLuint in = 0; + GLuint n = 3; + GLuint vlist1[VB_MAX_CLIPPED_VERTS]; + GLuint vlist2[VB_MAX_CLIPPED_VERTS]; + GLuint *inlist[2]; + GLuint *out; + GLuint i; + + inlist[0] = elts; + inlist[1] = vlist2; + + CLIP(-,0,CLIP_RIGHT_BIT); + CLIP(+,0,CLIP_LEFT_BIT); + CLIP(-,1,CLIP_TOP_BIT); + CLIP(+,1,CLIP_BOTTOM_BIT); + CLIP(-,2,CLIP_FAR_BIT); + CLIP(+,2,CLIP_NEAR_BIT); + + /* Convert the planar polygon to a list of triangles */ + out = inlist[in]; + + for (i = 2 ; i < n ; i++) { + elts[0] = out[0]; + elts[1] = out[i-1]; + elts[2] = out[i]; + elts += 3; + } + + *p_next_vert = next_vert; + *p_elts = elts; +} + + +static void r128LineClip(GLuint **p_elts, + r128Vertex *verts, + GLubyte *clipmask, + GLuint *p_next_vert, + GLubyte mask, + r128InterpFunc interp) +{ + GLuint *elts = *p_elts; + GLfloat *I = verts[elts[0]].f; + GLfloat *J = verts[elts[1]].f; + GLuint next_vert = *p_next_vert; + + LINE_CLIP(1,0,0,-1,CLIP_LEFT_BIT); + LINE_CLIP(-1,0,0,1,CLIP_RIGHT_BIT); + LINE_CLIP(0,1,0,-1,CLIP_TOP_BIT); + LINE_CLIP(0,-1,0,1,CLIP_BOTTOM_BIT); + LINE_CLIP(0,0,1,-1,CLIP_FAR_BIT); + LINE_CLIP(0,0,-1,1,CLIP_NEAR_BIT); + + *p_next_vert = next_vert; + *p_elts += 2; +} + + + +#define CLIP_POINT(e) \ +do { \ + if (mask[e]) *out++ = e; \ +} while (0) + +#define CLIP_LINE(e1, e0) \ +do { \ + GLubyte ormask = mask[e0] | mask[e1]; \ + out[0] = e1; \ + out[1] = e0; \ + out += 2; \ + if (ormask) { \ + out-=2; \ + if (!(mask[e0] & mask[e1])) { \ + r128LineClip(&out, verts, mask, &next_vert, ormask, interp); \ + } \ + } \ +} while (0) + +#define CLIP_TRIANGLE(e2, e1, e0) \ +do { \ + GLubyte ormask; \ + out[0] = e2; \ + out[1] = e1; \ + out[2] = e0; \ + out += 3; \ + ormask = mask[e2] | mask[e1] | mask[e0]; \ + if (ormask) { \ + out -= 3; \ + if (!(mask[e2] & mask[e1] & mask[e0])) { \ + r128TriClip(&out, verts, mask, &next_vert, ormask, interp); \ + } \ + } \ +} while (0) + + + +/* Build a table of functions to clip each primitive type. These + * produce a list of elements in the appropriate 'reduced' primitive, + * ie (points, lines, triangles) containing all the clipped and + * unclipped primitives from the original list. + */ +#define LOCAL_VARS \ + r128ContextPtr r128ctx = R128_CONTEXT(VB->ctx); \ + r128VertexBufferPtr r128VB = R128_DRIVER_DATA(VB); \ + GLuint *elt = VB->EltPtr->data; \ + r128Vertex *verts = r128VB->verts; \ + GLuint next_vert = r128VB->last_vert; \ + GLuint *out = r128VB->clipped_elements.data; \ + GLubyte *mask = VB->ClipMask; \ + r128InterpFunc interp = r128ctx->interp; \ + (void) interp; (void) verts; + +#define POSTFIX \ + r128VB->clipped_elements.count = out - r128VB->clipped_elements.data; \ + r128VB->last_vert = next_vert; + + +#define INIT(x) + +#define RENDER_POINTS(start, count) \ +do { \ + GLuint i; \ + for (i = start; i < count; i++) \ + CLIP_POINT(elt[i]); \ +} while (0) + +#define RENDER_LINE(i1, i0) \ +do { \ + CLIP_LINE(elt[i1], elt[i0]); \ +} while (0) + +#define RENDER_TRI(i2, i1, i0, pv, parity) \ +do { \ + GLuint e2 = elt[i2], e1 = elt[i1], e0 = elt[i0]; \ + if (parity) e2 = elt[i1], e1 = elt[i2]; \ + CLIP_TRIANGLE(e2, e1, e0); \ +} while (0) + +#define RENDER_QUAD(i3, i2, i1, i0, pv) \ +do { \ + CLIP_TRIANGLE(elt[i3], elt[i2], elt[i0]); \ + CLIP_TRIANGLE(elt[i2], elt[i1], elt[i0]); \ +} while (0) + +#define TAG(x) r128_clip_##x##_elt +#include "render_tmp.h" + + +/* Pack rgba and/or texture into the remaining half of a 32 byte vertex. + */ +#define CLIP_UBYTE_COLOR 4 +#define CLIP_UBYTE_B 0 +#define CLIP_UBYTE_G 1 +#define CLIP_UBYTE_R 2 +#define CLIP_UBYTE_A 3 +#define CLIP_S0 6 +#define CLIP_T0 7 +#define CLIP_S1 8 +#define CLIP_T1 9 + +#define TYPE (0) +#define TAG(x) x +#include "r128_fasttmp.h" + +#define TYPE (R128_RGBA_BIT) +#define TAG(x) x##_RGBA +#include "r128_fasttmp.h" + +#define TYPE (R128_TEX0_BIT) +#define TAG(x) x##_TEX0 +#include "r128_fasttmp.h" + +#define TYPE (R128_RGBA_BIT | R128_TEX0_BIT) +#define TAG(x) x##_RGBA_TEX0 +#include "r128_fasttmp.h" + +#define TYPE (R128_RGBA_BIT | R128_TEX0_BIT | R128_TEX1_BIT) +#define TAG(x) x##_RGBA_TEX0_TEX1 +#include "r128_fasttmp.h" + +/* This one *could* get away with sneaking TEX1 into the color and + * specular slots, thus fitting inside a cache line. Would be even + * better to switch to a smaller vertex. + */ +#define TYPE (R128_TEX0_BIT | R128_TEX1_BIT) +#define TAG(x) x##_TEX0_TEX1 +#include "r128_fasttmp.h" + + + +/* Render elements directly from original list of vertices. */ +static void r128RenderElementsDirect(struct vertex_buffer *VB) +{ + GLcontext *ctx = VB->ctx; + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + GLenum prim = ctx->CVA.elt_mode; + GLuint nr = VB->EltPtr->count; + render_func func = render_tab_r128_smooth_indirect[prim]; + GLuint p = 0; + + if (r128ctx->dirty) r128UpdateHWState(r128ctx); + + do { + func(VB, 0, nr, 0); + } while (ctx->Driver.MultipassFunc && + ctx->Driver.MultipassFunc(VB, ++p)); +} + +/* Project vertices from clip to device space */ +static void r128ProjectVertices(struct vertex_buffer *VB) +{ + GLcontext *ctx = VB->ctx; + GLmatrix *mat = &ctx->Viewport.WindowMap; + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + r128VertexBufferPtr r128VB = R128_DRIVER_DATA(VB); + GLfloat m[16]; + + m[MAT_SX] = mat->m[MAT_SX]; + m[MAT_TX] = mat->m[MAT_TX]; + m[MAT_SY] = -mat->m[MAT_SY]; + m[MAT_TY] = -mat->m[MAT_TY] + r128ctx->driDrawable->h; + m[MAT_SZ] = mat->m[MAT_SZ] * (1.0 / 0x10000); + m[MAT_TZ] = mat->m[MAT_TZ] * (1.0 / 0x10000); + +#if USE_RHW2 + /* FIXME: Handle RHW2?? */ + gl_project_v16(r128VB->verts[VB->CopyStart].f, + r128VB->verts[r128VB->last_vert].f, + m, + 16 * 4); +#else + gl_project_v16(r128VB->verts[VB->CopyStart].f, + r128VB->verts[r128VB->last_vert].f, + m, + 16 * 4); +#endif +} + +/* Project clipped vertices from clip to device space */ +static void r128ProjectClippedVertices(struct vertex_buffer *VB) +{ + GLcontext *ctx = VB->ctx; + GLmatrix *mat = &ctx->Viewport.WindowMap; + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + r128VertexBufferPtr r128VB = R128_DRIVER_DATA(VB); + GLfloat m[16]; + + m[MAT_SX] = mat->m[MAT_SX]; + m[MAT_TX] = mat->m[MAT_TX]; + m[MAT_SY] = -mat->m[MAT_SY]; + m[MAT_TY] = -mat->m[MAT_TY] + r128ctx->driDrawable->h; + m[MAT_SZ] = mat->m[MAT_SZ] * (1.0 / 0x10000); + m[MAT_TZ] = mat->m[MAT_TZ] * (1.0 / 0x10000); + +#if USE_RHW2 + /* FIXME: Handle RHW2?? */ + gl_project_clipped_v16(r128VB->verts[VB->CopyStart].f, + r128VB->verts[r128VB->last_vert].f, + m, + 16 * 4, + VB->ClipMask + VB->CopyStart); +#else + gl_project_clipped_v16(r128VB->verts[VB->CopyStart].f, + r128VB->verts[r128VB->last_vert].f, + m, + 16 * 4, + VB->ClipMask + VB->CopyStart); +#endif +} + +static r128FastPathTable r128FastTab[0x80]; + +/* Initialize the table of fast path support functions */ +void r128FastPathInit(void) +{ + r128_clip_render_init_elt(); + render_init_r128_smooth_indirect(); + + r128_init_fastpath(&r128FastTab[0]); + r128_init_fastpath_RGBA(&r128FastTab[R128_RGBA_BIT]); + r128_init_fastpath_TEX0(&r128FastTab[R128_TEX0_BIT]); + r128_init_fastpath_RGBA_TEX0(&r128FastTab[R128_RGBA_BIT|R128_TEX0_BIT]); + r128_init_fastpath_TEX0_TEX1(&r128FastTab[R128_TEX0_BIT|R128_TEX1_BIT]); + r128_init_fastpath_RGBA_TEX0_TEX1(&r128FastTab[R128_RGBA_BIT|R128_TEX0_BIT| + R128_TEX1_BIT]); +} + +#define VALID_SETUP (R128_RGBA_BIT | R128_TEX0_BIT | R128_TEX1_BIT) + +void r128FastPath(struct vertex_buffer *VB) +{ + GLcontext *ctx = VB->ctx; + GLenum prim = ctx->CVA.elt_mode; + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + r128FastPathTable *tab = &r128FastTab[r128ctx->SetupIndex & VALID_SETUP]; + GLuint do_cliptest = 1; + + gl_prepare_arrays_cva(VB); /* still need this */ + + /* Reserve enough space for the pathological case */ + if (VB->EltPtr->count * 12 > R128_DRIVER_DATA(VB)->size) { + r128ResizeVB(VB, VB->EltPtr->count * 12); + do_cliptest = 1; + } + + tab->build_vertices(VB, do_cliptest); /* object->clip space */ + + if (r128ctx->dirty) r128UpdateHWState(r128ctx); + + if (VB->ClipOrMask) { + if (!VB->ClipAndMask) { + render_func *clip = r128_clip_render_tab_elt; + + r128ctx->interp = tab->interp; + clip[prim](VB, 0, VB->EltPtr->count, 0); /* build new elts */ + ctx->CVA.elt_mode = gl_reduce_prim[prim]; + VB->EltPtr = &(R128_DRIVER_DATA(VB)->clipped_elements); + r128ProjectClippedVertices(VB); /* clip->device space */ + r128RenderElementsDirect(VB); /* render using new list */ + } + } else { + r128ProjectVertices(VB); /* clip->device space */ + r128RenderElementsDirect(VB); /* render using orig list */ + } + + /* This indicates that there is no cached data to reuse */ + VB->pipeline->data_valid = 0; + VB->pipeline->new_state = 0; +} diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_fastpath.h b/xc/lib/GL/mesa/src/drv/r128/r128_fastpath.h new file mode 100644 index 000000000..47bb92049 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/r128/r128_fastpath.h @@ -0,0 +1,48 @@ +/* $XFree86$ */ +/************************************************************************** + +Copyright 1999, 2000 ATI Technologies Inc. and Precision Insight, Inc., + Cedar Park, Texas. +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 +on 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 +ATI, PRECISION INSIGHT AND/OR THEIR 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. + +**************************************************************************/ + +/* + * Authors: + * Kevin E. Martin + * + */ + +#ifndef _R128_FASTPATH_H_ +#define _R128_FASTPATH_H_ + +typedef void (*r128BuildVerticesFunc)(struct vertex_buffer *VB, + GLuint do_cliptest); +typedef void (*r128InterpFunc)(GLfloat t, + GLfloat *result, + const GLfloat *in, + const GLfloat *out); + +extern void r128FastPathInit(void); +extern void r128FastPath(struct vertex_buffer *VB); + +#endif /* _R128_FASTPATH_H_ */ diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_fasttmp.h b/xc/lib/GL/mesa/src/drv/r128/r128_fasttmp.h new file mode 100644 index 000000000..e76dd52b4 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/r128/r128_fasttmp.h @@ -0,0 +1,155 @@ +/* $XFree86$ */ +/************************************************************************** + +Copyright 1999, 2000 ATI Technologies Inc. and Precision Insight, Inc., + Cedar Park, Texas. +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 +on 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 +ATI, PRECISION INSIGHT AND/OR THEIR 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. + +**************************************************************************/ + +/* + * Authors: + * Kevin E. Martin + * + */ + +/* FIXME: These routines were copied from the i810 driver, and were only + slightly modified for the Rage 128. They still need to be optmizied + and cleaned up. Also, support for USE_RHW2 needs to be added. */ + +/* The first part of setup is applied to all vertices, clipped or + * unclipped. This data w!ill be used for clipping, and then all + * vertices with a zero clipmask will be projected to device space. + * + * This could be split into several loops, but - it seems that the + * large stride of the fxVertices makes cache issues the big + * performance factor, and that multiple loops mean multiple cache + * misses.... + */ +static void TAG(r128_setup_full)(struct vertex_buffer *VB, GLuint do_cliptest) +{ + GLcontext *ctx = VB->ctx; + r128VertexBufferPtr r128VB = R128_DRIVER_DATA(VB); + const GLfloat *m = ctx->ModelProjectMatrix.m; + GLuint start = VB->CopyStart; + GLuint count = VB->Count; + GLuint i; + + gl_xform_points3_v16_general(r128VB->verts[start].f, + m, + VB->ObjPtr->start, + VB->ObjPtr->stride, + count - start); + + if (do_cliptest) { + VB->ClipAndMask = ~0; + VB->ClipOrMask = 0; + gl_cliptest_points4_v16(r128VB->verts[start].f, + r128VB->verts[count].f, + &(VB->ClipOrMask), + &(VB->ClipAndMask), + VB->ClipMask + start); + } + + /* These branches are all resolved at compile time. Hopefully all + * the pointers are valid addresses even when not enabled. + */ + if (TYPE) { + GLubyte *color = VB->ColorPtr->start; + GLfloat *tex0_data = VB->TexCoordPtr[0]->start; + GLfloat *tex1_data = VB->TexCoordPtr[1]->start; + + GLuint color_stride = VB->ColorPtr->stride; + GLuint tex0_stride = VB->TexCoordPtr[0]->stride; + GLuint tex1_stride = VB->TexCoordPtr[1]->stride; + + GLfloat *f = r128VB->verts[start].f; + + for (i = start ; i < count ; i++, f += 16) { + if (TYPE & R128_RGBA_BIT) { + GLubyte *b = (GLubyte *)&f[CLIP_UBYTE_COLOR]; + GLubyte *col = color; color += color_stride; + b[CLIP_UBYTE_R] = col[0]; + b[CLIP_UBYTE_G] = col[1]; + b[CLIP_UBYTE_B] = col[2]; + b[CLIP_UBYTE_A] = col[3]; + } + if (TYPE & R128_TEX0_BIT) { + f[CLIP_S0] = tex0_data[0]; + f[CLIP_T0] = tex0_data[1]; + STRIDE_F(tex0_data, tex0_stride); + } + if (TYPE & R128_TEX1_BIT) { + f[CLIP_S1] = tex1_data[0]; + f[CLIP_T1] = tex1_data[1]; + STRIDE_F(tex1_data, tex1_stride); + } + } + } + + r128VB->clipped_elements.count = start; + r128VB->last_vert = count; +} + + +/* Changed to just put the interp func instead of the whole clip + * routine into the header. Less code and better chance of doing some + * of this stuff in assembly. + */ +static void TAG(r128_interp_vert)(GLfloat t, + GLfloat *O, + const GLfloat *I, + const GLfloat *J) +{ + O[0] = LINTERP(t, I[0], J[0]); + O[1] = LINTERP(t, I[1], J[1]); + O[2] = LINTERP(t, I[2], J[2]); + O[3] = LINTERP(t, I[3], J[3]); + + if (TYPE & R128_RGBA_BIT) { + INTERP_RGBA(t, + ((GLubyte *)&(O[4])), + ((GLubyte *)&(I[4])), + ((GLubyte *)&(J[4]))); + } + + if (TYPE & R128_TEX0_BIT) { + O[6] = LINTERP(t, I[6], J[6]); + O[7] = LINTERP(t, I[7], J[7]); + } + + if (TYPE & R128_TEX1_BIT) { + O[8] = LINTERP(t, I[8], J[8]); + O[9] = LINTERP(t, I[9], J[9]); + } +} + + +static void TAG(r128_init_fastpath)(r128FastPathTable *tab) +{ + tab->build_vertices = TAG(r128_setup_full); + tab->interp = TAG(r128_interp_vert); +} + +#undef TYPE +#undef TAG +#undef SIZE diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_init.h b/xc/lib/GL/mesa/src/drv/r128/r128_init.h index 6cb43ae90..2140a7525 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_init.h +++ b/xc/lib/GL/mesa/src/drv/r128/r128_init.h @@ -48,8 +48,20 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #include "r128_screen.h" #include "r128_context.h" -#define DEBUG -#ifdef DEBUG +/* NOTE: The vertex buffer code is currently unstable because of the + switches between CCE and MMIO mode in the X server. Fixing the X + server to use the CCE should fix this problem. So, for now, it is + recommended that you do not use it. */ + +#define DEBUG 1 +#define USE_FAST_PATH 1 +#define USE_VERTEX_BUFFERS 0 +#define USE_AGP_TEXTURES 0 +#define USE_RGB8_TEXTURES 0 +#define FLUSH_VB_ON_STATE_CHANGE 1 + + +#if DEBUG #include #define R128_DEBUG(p) printf p #endif diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_lock.h b/xc/lib/GL/mesa/src/drv/r128/r128_lock.h index 2d80b0bbe..58bb33f47 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_lock.h +++ b/xc/lib/GL/mesa/src/drv/r128/r128_lock.h @@ -92,6 +92,8 @@ extern int prevLockLine; DRM_CAS(&sPriv->pSAREA->lock, cPriv->hHWContext, \ DRM_LOCK_HELD|cPriv->hHWContext, __ret); \ if (__ret) { \ + /* We lost the context, so we need to request the lock from \ + the kernel and update our state. */ \ drmGetLock(sPriv->fd, cPriv->hHWContext, 0); \ XMesaUpdateState(CC->xmCtx); \ } \ @@ -116,16 +118,26 @@ extern int prevLockLine; /* FIXME: The Rage128 has multiple clip rects -- optimize! */ #define BEGIN_CLIP_LOOP(CC) \ do { \ - __DRIdrawablePrivate *dPriv = CC->driDrawable; \ - int _nc = dPriv->numClipRects; \ + __DRIdrawablePrivate *_dPriv = CC->driDrawable; \ + int _nc = _dPriv->numClipRects; \ \ LOCK_HARDWARE(CC); \ while (_nc--) { \ if (CC->needClip) { \ - r128SetClipRect(CC, &dPriv->pClipRects[_nc]); \ + r128SetClipRect(CC, &_dPriv->pClipRects[_nc]); \ } +/* FIXME: Have the X server save/restore its own clip rect */ #define END_CLIP_LOOP(CC) \ + if (CC->needClip) { \ + /* FIXME: Move this to r128_state.c ?? */ \ + unsigned char *R128MMIO = CC->r128Screen->mmio; \ + R128CCE_WAIT_LOCKED(3); \ + R128CCE0(R128_CCE_PACKET0, R128_SC_TOP_LEFT_C, 1); \ + R128CCE(0x00000000); \ + R128CCE(0x1fff1fff); \ + R128CCE_END_LOCKED(); \ + } \ } \ UNLOCK_HARDWARE(CC); \ } while (0) diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_pipeline.c b/xc/lib/GL/mesa/src/drv/r128/r128_pipeline.c new file mode 100644 index 000000000..55487ffcd --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/r128/r128_pipeline.c @@ -0,0 +1,126 @@ +/* $XFree86$ */ +/************************************************************************** + +Copyright 1999, 2000 ATI Technologies Inc. and Precision Insight, Inc., + Cedar Park, Texas. +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 +on 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 +ATI, PRECISION INSIGHT AND/OR THEIR 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. + +**************************************************************************/ + +/* + * Authors: + * Kevin E. Martin + * + */ + +#include "r128_init.h" +#include "r128_mesa.h" +#include "r128_vb.h" +#include "r128_fastpath.h" +#include "r128_pipeline.h" + +#include "types.h" + +static struct gl_pipeline_stage r128FastStage = { + "R128 Fast Path", + (PIPE_OP_VERT_XFORM | + PIPE_OP_RAST_SETUP_0 | + PIPE_OP_RAST_SETUP_1 | + PIPE_OP_RENDER), + PIPE_PRECALC, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + r128FastPath +}; + +/* Build the PRECALC pipeline with our stage, if possible. Otherwise, + return GL_FALSE */ +GLboolean r128DDBuildPrecalcPipeline(GLcontext *ctx) +{ +#if USE_FAST_PATH + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + struct gl_pipeline *pipe = &ctx->CVA.pre; + + if (r128ctx->RenderIndex == 0 && + !(ctx->Enabled & (TEXTURE0_3D | + TEXTURE1_3D | + ENABLE_TEXMAT0 | + ENABLE_TEXMAT1 | + ENABLE_TEXGEN0 | + ENABLE_TEXGEN1 | + ENABLE_USERCLIP | + ENABLE_LIGHT | + ENABLE_FOG)) && + (ctx->Array.Flags & (VERT_OBJ_234 | + VERT_TEX0_4 | + VERT_TEX1_4 | + VERT_ELT)) == (VERT_OBJ_23 | + VERT_ELT)) { + pipe->stages[0] = &r128FastStage; + pipe->stages[1] = 0; + pipe->new_inputs = ctx->RenderFlags & VERT_DATA; + pipe->ops = pipe->stages[0]->ops; + + r128ctx->useFastPath = GL_TRUE; + return GL_TRUE; + } + + if (r128ctx->useFastPath) { + r128ctx->useFastPath = GL_FALSE; + + ctx->CVA.VB->ClipOrMask = 0; + ctx->CVA.VB->ClipAndMask = CLIP_ALL_BITS; + ctx->Array.NewArrayState |= ctx->Array.Summary; + } +#endif + + return GL_FALSE; +} + +/* Register the pipeline with our stages included */ +GLuint r128RegisterPipelineStages(struct gl_pipeline_stage *out, + const struct gl_pipeline_stage *in, + GLuint nr) +{ +#if USE_FAST_PATH + int i; + + for (i = 0; i < nr; i++) { + out[i] = in[i]; + switch (in[i].ops) { + case PIPE_OP_RAST_SETUP_0: + out[i].cva_state_change = (NEW_LIGHTING | + NEW_TEXTURING | + NEW_RASTER_OPS); + out[i].state_change = ~0; + out[i].check = r128CheckPartialRasterSetup; + out[i].run = r128PartialRasterSetup; + break; + + case PIPE_OP_RAST_SETUP_0|PIPE_OP_RAST_SETUP_1: + out[i].run = r128DoRasterSetup; + break; + } + } +#endif + + return nr; +} diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_pipeline.h b/xc/lib/GL/mesa/src/drv/r128/r128_pipeline.h new file mode 100644 index 000000000..280e6b943 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/r128/r128_pipeline.h @@ -0,0 +1,43 @@ +/* $XFree86$ */ +/************************************************************************** + +Copyright 1999, 2000 ATI Technologies Inc. and Precision Insight, Inc., + Cedar Park, Texas. +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 +on 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 +ATI, PRECISION INSIGHT AND/OR THEIR 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. + +**************************************************************************/ + +/* + * Authors: + * Kevin E. Martin + * + */ + +#ifndef _R128_PIPELINE_H_ +#define _R128_PIPELINE_H_ + +extern GLboolean r128DDBuildPrecalcPipeline(GLcontext *ctx); +extern GLuint r128RegisterPipelineStages(struct gl_pipeline_stage *out, + const struct gl_pipeline_stage *in, + GLuint nr); + +#endif /* _R128_PIPELINE_H_ */ diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_screen.c b/xc/lib/GL/mesa/src/drv/r128/r128_screen.c new file mode 100644 index 000000000..32e72e97d --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/r128/r128_screen.c @@ -0,0 +1,160 @@ +/* $XFree86$ */ +/************************************************************************** + +Copyright 1999, 2000 ATI Technologies Inc. and Precision Insight, Inc., + Cedar Park, Texas. +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 +on 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 +ATI, PRECISION INSIGHT AND/OR THEIR 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. + +**************************************************************************/ + +/* + * Authors: + * Kevin E. Martin + * + */ + +#include "r128_dri.h" +#include "r128_reg.h" + +#include "r128_init.h" +#include "r128_context.h" +#include "r128_xmesa.h" +#include "r128_tris.h" +#include "r128_vb.h" +#include "r128_fastpath.h" + +/* Create the device specific screen private data struct */ +r128ScreenPtr r128CreateScreen(__DRIscreenPrivate *sPriv) +{ + r128ScreenPtr r128Screen; + R128DRIPtr r128DRIPriv = (R128DRIPtr)sPriv->pDevPriv; + + /* Allocate the private area */ + r128Screen = (r128ScreenPtr)Xmalloc(sizeof(*r128Screen)); + if (!r128Screen) return NULL; + + r128Screen->mmioRgn.handle = r128DRIPriv->registerHandle; + r128Screen->mmioRgn.size = r128DRIPriv->registerSize; + if (drmMap(sPriv->fd, + r128Screen->mmioRgn.handle, + r128Screen->mmioRgn.size, + (drmAddressPtr)&r128Screen->mmio)) { + Xfree(r128Screen); + return NULL; + } + + r128Screen->agpRgn.handle = r128DRIPriv->agpHandle; + r128Screen->agpRgn.size = r128DRIPriv->agpSize; + if (drmMap(sPriv->fd, + r128Screen->agpRgn.handle, + r128Screen->agpRgn.size, + (drmAddressPtr)&r128Screen->agp)) { + drmUnmap((drmAddress)r128Screen->mmio, r128Screen->mmioRgn.size); + Xfree(r128Screen); + return NULL; + } + + r128Screen->deviceID = r128DRIPriv->deviceID; + + r128Screen->width = r128DRIPriv->width; + r128Screen->height = r128DRIPriv->height; + r128Screen->depth = r128DRIPriv->depth; + r128Screen->bpp = r128DRIPriv->bpp; + + r128Screen->fb = sPriv->pFB; + r128Screen->fbOffset = sPriv->fbOrigin; + r128Screen->fbStride = sPriv->fbStride; + r128Screen->fbSize = sPriv->fbSize; + + r128Screen->fbX = r128DRIPriv->fbX; + r128Screen->fbY = r128DRIPriv->fbY; + r128Screen->backX = r128DRIPriv->backX; + r128Screen->backY = r128DRIPriv->backY; + r128Screen->depthX = r128DRIPriv->depthX; + r128Screen->depthY = r128DRIPriv->depthY; + r128Screen->textureX = r128DRIPriv->textureX; + r128Screen->textureY = r128DRIPriv->textureY; + r128Screen->textureSize = r128DRIPriv->textureSize; + r128Screen->log2TexGran = r128DRIPriv->log2TexGran; + +#if 0 + /* FIXME: For testing only */ + r128Screen->textureX = 0; + r128Screen->textureY = 8192; + r128Screen->textureSize = 4*1024*1024; + r128Screen->log2TexGran = 15; +#endif + +#if 1 + /* FIXME: For testing only */ + if (getenv("LIBGL_SHOW_BUFFERS")) { + r128Screen->backX = 0; + r128Screen->backY = r128DRIPriv->height/2; + r128Screen->depthX = r128DRIPriv->width/2; + r128Screen->depthY = r128DRIPriv->height/2; + } +#endif + + r128Screen->CCEMode = r128DRIPriv->CCEMode; + r128Screen->CCEFifoSize = r128DRIPriv->CCEFifoSize; + + r128Screen->ringStart = r128DRIPriv->ringStart; + r128Screen->ringSize = r128DRIPriv->ringSize; + r128Screen->ringWritePtr = &r128DRIPriv->ringWrite; + r128Screen->ringReadPtr = (int *)(r128Screen->agp + + r128DRIPriv->ringReadOffset); + + r128Screen->vbStart = r128DRIPriv->vbStart; + r128Screen->vbSize = r128DRIPriv->vbSize; + + r128Screen->indStart = r128DRIPriv->indStart; + r128Screen->indSize = r128DRIPriv->indSize; + + r128Screen->agpTexStart = r128DRIPriv->agpTexStart; + r128Screen->agpTexSize = r128DRIPriv->agpTexSize; + r128Screen->log2AGPTexGran = r128DRIPriv->log2AGPTexGran; + + r128Screen->MMIOFifoSlots = 0; + r128Screen->CCEFifoSlots = 0; + + r128Screen->CCEFifoAddr = R128_PM4_FIFO_DATA_EVEN; + + r128Screen->driScreen = sPriv; + + r128FastPathInit(); + r128TriangleFuncsInit(); + r128SetupInit(); + + return r128Screen; +} + +/* Destroy the device specific screen private data struct */ +void r128DestroyScreen(__DRIscreenPrivate *sPriv) +{ + r128ScreenPtr r128Screen = (r128ScreenPtr)sPriv->private; + + drmUnmap((drmAddress)r128Screen->mmio, r128Screen->mmioRgn.size); + drmUnmap((drmAddress)r128Screen->agp, r128Screen->agpRgn.size); + + Xfree(r128Screen); + sPriv->private = NULL; +} diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_screen.h b/xc/lib/GL/mesa/src/drv/r128/r128_screen.h index bfbf4bc5f..07670331e 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_screen.h +++ b/xc/lib/GL/mesa/src/drv/r128/r128_screen.h @@ -38,54 +38,85 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #ifdef GLX_DIRECT_RENDERING typedef struct { - drmHandle handle; - drmSize size; + drmHandle handle; /* Handle to the DRM region */ + drmSize size; /* Size of the DRM region */ } r128RegionRec, *r128RegionPtr; typedef struct { + /* FIXME: There needs to be two register regions. One to allow + read-only access to the block of non-FIFO'd GUI registers + (0x0000-0x0FFC), and one to allow read/write acces to the block + of FIFO'd GUI registers (0x1000-0x1FFC) */ + + /* MMIO register data */ r128RegionRec mmioRgn; unsigned char *mmio; + /* AGP data */ r128RegionRec agpRgn; unsigned char *agp; - int deviceID; - - int width; - int height; - int depth; - int bpp; - + /* Frame buffer data */ unsigned char *fb; unsigned long fbOffset; int fbStride; int fbSize; - int fbX; + int CCEMode; /* CCE mode that server/clients use */ + int CCEFifoSize; /* Size of the CCE command FIFO */ + + /* CCE ring buffer data */ + unsigned long ringStart; + int ringSize; + /* FIXME: These should be in the + SAREA so that they can be + shared with other clients. */ + int *ringWritePtr; /* Pointer to current write addr */ + int *ringReadPtr; /* Pointer to current read addr */ + + /* CCE vertex buffer data */ + unsigned long vbStart; + int vbSize; + + /* CCE indirect buffer data */ + unsigned long indStart; + int indSize; + + /* CCE AGP Texture data */ + unsigned long agpTexStart; + int agpTexSize; + int log2AGPTexGran; + + /* DRI screen private data */ + int deviceID; /* PCI device ID */ + int width; /* Width in pixels of display */ + int height; /* Height in scanlines of display */ + int depth; /* Depth of display (8, 15, 16, 24) */ + int bpp; /* Bit depth of disp (8, 16, 24, 32) */ + + int fbX; /* Start of frame buffer */ int fbY; - int backX; + int backX; /* Start of shared back buffer */ int backY; - int depthX; + int depthX; /* Start of shared depth buffer */ int depthY; - int textureX; + int textureX; /* Start of textures in frame buffer */ int textureY; int textureSize; + int log2TexGran; - int CCEMode; - int CCEFifoSize; + int MMIOFifoSlots; /* Free slots in the FIFO (64 max) */ + int CCEFifoSlots; /* Free slots in the CCE FIFO */ - unsigned long ringStart; - int ringSize; - int *ringWritePtr; - int *ringReadPtr; - - int MMIOFifoSlots; - int CCEFifoSlots; - - int CCEFifoAddr; + int CCEFifoAddr; /* MMIO offset to write next CCE + value (only used when CCE is + in PIO mode). */ __DRIscreenPrivate *driScreen; } r128ScreenRec, *r128ScreenPtr; +r128ScreenPtr r128CreateScreen(__DRIscreenPrivate *sPriv); +void r128DestroyScreen(__DRIscreenPrivate *sPriv); + #endif #endif /* _R128_SCREEN_H_ */ diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_span.c b/xc/lib/GL/mesa/src/drv/r128/r128_span.c index f6452b1b5..6338d0e54 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_span.c +++ b/xc/lib/GL/mesa/src/drv/r128/r128_span.c @@ -42,60 +42,42 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #include "r128_cce.h" #include "r128_span.h" +/* Null functions for span functions not yet implemented */ + static void r128DDWriteRGBASpan(const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgba[][4], - const GLubyte mask[]) -{ -} - + const GLubyte mask[]) {} static void r128DDWriteRGBSpan(const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgb[][3], - const GLubyte mask[]) -{ -} - + const GLubyte mask[]) {} static void r128DDWriteMonoRGBASpan(const GLcontext *ctx, GLuint n, GLint x, GLint y, - const GLubyte mask[]) -{ -} - + const GLubyte mask[]) {} static void r128DDWriteRGBAPixels(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], const GLubyte rgba[][4], - const GLubyte mask[]) -{ -} - + const GLubyte mask[]) {} static void r128DDWriteMonoRGBAPixels(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], - const GLubyte mask[]) -{ -} - + const GLubyte mask[]) {} static void r128DDReadRGBASpan(const GLcontext *ctx, GLuint n, GLint x, GLint y, - GLubyte rgba[][4]) -{ -} - + GLubyte rgba[][4]) {} static void r128DDReadRGBAPixels(const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLubyte rgba[][4], - const GLubyte mask[]) -{ -} + const GLubyte mask[]) {} -/* 16bpp span routines */ +/* 16bpp-specific span functions */ #define DBG 0 @@ -114,7 +96,7 @@ static void r128DDReadRGBAPixels(const GLcontext *ctx, (r128ctx->bufY + dPriv->y) * pitch) #define INIT_MONO_PIXEL(p) \ - GLushort p = R128_CONTEXT(ctx)->regs.constant_color_c; + GLushort p = R128_CONTEXT(ctx)->Color; #define CLIPPIXEL(_x,_y) (_x >= minx && _x <= maxx && \ _y >= miny && _y <= maxy) @@ -146,7 +128,6 @@ static void r128DDReadRGBAPixels(const GLcontext *ctx, UNLOCK_HARDWARE(r128ctx); -/* For 16 bit depth visuals */ #define Y_FLIP(_y) (height - _y) #define WRITE_RGBA(_x, _y, r, g, b, a) \ *(GLushort *)(buf + (_x)*2 + (_y)*pitch) = ((((int)r & 0xf8) << 8) | \ @@ -168,6 +149,7 @@ static void r128DDReadRGBAPixels(const GLcontext *ctx, #include "spantmp.h" +/* Initialize the driver's span functions */ void r128DDInitSpanFuncs(GLcontext *ctx) { r128ContextPtr r128ctx = R128_CONTEXT(ctx); diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_state.c b/xc/lib/GL/mesa/src/drv/r128/r128_state.c index 8517960f9..55ab014a7 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_state.c +++ b/xc/lib/GL/mesa/src/drv/r128/r128_state.c @@ -42,69 +42,41 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #include "r128_cce.h" #include "r128_tris.h" #include "r128_vb.h" +#include "r128_tex.h" -#if 0 -/* FIXME: FOR TESTING A SIMPLE DRAWING FUNCTION */ -static void pfunc(GLcontext *ctx, GLuint first, GLuint last) {} -static void lfunc(GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv) {} -static void tfunc(GLcontext *ctx, GLuint v1, GLuint v2, GLuint v3, GLuint pv) -{ - r128ContextPtr r128ctx = R128_CONTEXT(ctx); - unsigned char *R128MMIO = r128ctx->r128Screen->mmio; - float h = r128ctx->driDrawable->h; - - if (r128ctx->dirty) { - R128_DEBUG(("Rendering with a dirty context: %08x\n", r128ctx->dirty)); - /* r128UpdateState(r128ctx); */ - } - - R128CCE_BEGIN(15); - R128CCE3(R128_CCE_PACKET3_3D_RNDR_GEN_PRIM, 13); - R128CCE(R128_CCE_VC_FRMT_DIFFUSE_ARGB); - R128CCE(R128_CCE_VC_CNTL_PRIM_TYPE_TRI_LIST | - R128_CCE_VC_CNTL_PRIM_WALK_RING | - (3 << R128_CCE_VC_CNTL_NUM_SHIFT)); - - R128CCEF(ctx->VB->Win.data[v1][0]); - R128CCEF(h-ctx->VB->Win.data[v1][1]); - R128CCEF(ctx->VB->Win.data[v1][2]); - R128CCE((ctx->VB->Color[0]->data[v1][2] << 0) | - (ctx->VB->Color[0]->data[v1][1] << 8) | - (ctx->VB->Color[0]->data[v1][0] << 16) | - (ctx->VB->Color[0]->data[v1][3] << 24)); - - R128CCEF(ctx->VB->Win.data[v2][0]); - R128CCEF(h-ctx->VB->Win.data[v2][1]); - R128CCEF(ctx->VB->Win.data[v2][2]); - R128CCE((ctx->VB->Color[0]->data[v2][2] << 0) | - (ctx->VB->Color[0]->data[v2][1] << 8) | - (ctx->VB->Color[0]->data[v2][0] << 16) | - (ctx->VB->Color[0]->data[v2][3] << 24)); - - R128CCEF(ctx->VB->Win.data[v3][0]); - R128CCEF(h-ctx->VB->Win.data[v3][1]); - R128CCEF(ctx->VB->Win.data[v3][2]); - R128CCE((ctx->VB->Color[0]->data[v3][2] << 0) | - (ctx->VB->Color[0]->data[v3][1] << 8) | - (ctx->VB->Color[0]->data[v3][0] << 16) | - (ctx->VB->Color[0]->data[v3][3] << 24)); - - R128CCE_END(); -} -static void qfunc(GLcontext *ctx, GLuint v1, GLuint v2, GLuint v3, GLuint v4, GLuint pv) +CARD32 r128PackColor(GLuint d, + GLubyte r, GLubyte g, GLubyte b, GLubyte a) { - tfunc(ctx, v1, v2, v4, pv); - tfunc(ctx, v2, v3, v4, pv); -} + switch (d) { + case 8: + return (((r & 0xe0) >> 0) | + ((g & 0xe0) >> 3) | + ((b & 0xc0) >> 6) | + ((a & 0x00) >> 0)); + case 15: + return (((r & 0xf8) << 7) | + ((g & 0xf8) << 2) | + ((b & 0xf8) >> 3) | + ((a & 0x80) << 8)); + case 16: + return (((r & 0xf8) << 8) | + ((g & 0xfc) << 3) | + ((b & 0xf8) >> 3) | + ((a & 0x00) << 0)); + case 24: + return (((r & 0xff) << 16) | + ((g & 0xff) << 8) | + ((b & 0xff) >> 0) | + ((a & 0x00) << 0)); + case 32: + return (((r & 0xff) << 16) | + ((g & 0xff) << 8) | + ((b & 0xff) >> 0) | + ((a & 0xff) << 24)); + } -static void r128DDUpdateState(GLcontext *ctx) -{ - ctx->Driver.PointsFunc = pfunc; - ctx->Driver.LineFunc = lfunc; - ctx->Driver.TriangleFunc = tfunc; - ctx->Driver.QuadFunc = qfunc; + return 0; } -#else #define INTERESTED (~(NEW_MODELVIEW | \ NEW_PROJECTION | \ @@ -133,7 +105,6 @@ static void r128DDUpdateState(GLcontext *ctx) ctx->Driver.RectFunc = NULL; } } -#endif static void r128DDUpdateHWState(GLcontext *ctx) { @@ -141,7 +112,16 @@ static void r128DDUpdateHWState(GLcontext *ctx) /* FIXME: state is being updated too often */ if (r128ctx->dirty) - r128UpdateState(r128ctx); + r128UpdateHWState(r128ctx); +} + +static void r128DDReducedPrimitiveChange(GLcontext *ctx, GLenum prim) +{ + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + + /* FIXME: Also need to flush between tris and tristrips/fans when we + support them directly */ + R128_FLUSH_VB(r128ctx); } static void r128DDClearColor(GLcontext *ctx, @@ -149,10 +129,7 @@ static void r128DDClearColor(GLcontext *ctx, { r128ContextPtr r128ctx = R128_CONTEXT(ctx); - r128ctx->ClearColor = (((r >> 0) << 16) | - ((g >> 0) << 8) | - ((b >> 0) << 0) | - ((a >> 0) << 24)); + r128ctx->ClearColor = r128PackColor(32, r, g, b, a); } static void r128DDColor(GLcontext *ctx, @@ -160,25 +137,19 @@ static void r128DDColor(GLcontext *ctx, { r128ContextPtr r128ctx = R128_CONTEXT(ctx); -#if 1 - r128ctx->regs.constant_color_c = (((r >> 3) << 11) | - ((g >> 2) << 5) | - ((b >> 3) << 0) | - ((a >> 8) << 16)); -#else - r128ctx->regs.constant_color_c = (((r >> 0) << 16) | - ((g >> 0) << 8) | - ((b >> 0) << 0) | - ((a >> 0) << 24)); -#endif + r128ctx->Color = r128PackColor(r128ctx->r128Screen->depth, r, g, b, a); } -static GLboolean r128DDSetBuffer(GLcontext *ctx, GLenum mode ) +/* FIXME: After moving to Mesa 3.3, change this to SetReadBuffer and + SetDrawBuffer */ +static GLboolean r128DDSetBuffer(GLcontext *ctx, GLenum mode) { r128ContextPtr r128ctx = R128_CONTEXT(ctx); - int found = GL_FALSE; int x = r128ctx->driDrawable->x; int y = r128ctx->driDrawable->y; + int found; + + r128ctx->Fallback &= ~R128_FALLBACK_DRAW_BUFFER; switch (mode) { case GL_FRONT_LEFT: @@ -191,11 +162,18 @@ static GLboolean r128DDSetBuffer(GLcontext *ctx, GLenum mode ) r128ctx->bufY = r128ctx->r128Screen->backY; found = GL_TRUE; break; + default: + r128ctx->Fallback |= R128_FALLBACK_DRAW_BUFFER; + found = GL_FALSE; + break; } x += r128ctx->bufX; y += r128ctx->bufY; +#if FLUSH_VB_ON_STATE_CHANGE + R128_FLUSH_VB(r128ctx); +#endif r128ctx->regs.window_xy_offset = ((y << R128_WINDOW_Y_SHIFT) | (x << R128_WINDOW_X_SHIFT)); @@ -208,6 +186,9 @@ static GLboolean r128DDSetBuffer(GLcontext *ctx, GLenum mode ) (r128ctx->r128Screen->depthY - r128ctx->bufY) * r128ctx->r128Screen->fbStride); + + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_WIN_Z_POS; return found; } @@ -215,7 +196,9 @@ static GLboolean r128DDColorMask(GLcontext *ctx, GLboolean r, GLboolean g, GLboolean b, GLboolean a) { - /* FIXME??? */ + /* FIXME: Implement this function. Make sure the fallbacks are + covered if they do not properly handle individual color channel + masking. */ return GL_TRUE; } @@ -242,10 +225,16 @@ static void r128DDAlphaFunc(GLcontext *ctx, GLenum func, GLclampf ref) return; } - r128ctx->regs.misc_3d_state_cntl_reg = a; + if (r128ctx->regs.misc_3d_state_cntl_reg != a) { +#if FLUSH_VB_ON_STATE_CHANGE + R128_FLUSH_VB(r128ctx); +#endif + r128ctx->regs.misc_3d_state_cntl_reg = a; - /* FIXME: Load into hardware now??? */ - r128ctx->dirty |= R128_UPDATE_CONTEXT; + /* FIXME: Load into hardware now??? */ + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_ALPHASTATE; + } } static void r128DDBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor) @@ -275,7 +264,9 @@ static void r128DDBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor) case GL_SRC_ALPHA_SATURATE: b |= R128_ALPHA_BLEND_SRC_SRCALPHASAT; break; #if 0 - /* FIXME */ + /* FIXME: These are not supported directly by the Rage 128. + They could be emulated using something like the TexEnv + modes. */ case GL_CONSTANT_COLOR: b |= 0; break; case GL_ONE_MINUS_CONSTANT_COLOR: b |= 0; @@ -308,7 +299,9 @@ static void r128DDBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor) case GL_ONE_MINUS_DST_ALPHA: b |= R128_ALPHA_BLEND_DST_INVDESTALPHA; break; #if 0 - /* FIXME */ + /* FIXME: These are not supported directly by the Rage 128. + They could be emulated using something like the TexEnv + modes. */ case GL_CONSTANT_COLOR: b |= 0; break; case GL_ONE_MINUS_CONSTANT_COLOR: b |= 0; @@ -323,10 +316,16 @@ static void r128DDBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor) return; } - r128ctx->regs.misc_3d_state_cntl_reg = b; + if (r128ctx->regs.misc_3d_state_cntl_reg != b) { +#if FLUSH_VB_ON_STATE_CHANGE + R128_FLUSH_VB(r128ctx); +#endif + r128ctx->regs.misc_3d_state_cntl_reg = b; - /* FIXME: Load into hardware now??? */ - r128ctx->dirty |= R128_UPDATE_CONTEXT; + /* FIXME: Load into hardware now??? */ + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_ALPHASTATE; + } } static void r128DDBlendFuncSeparate(GLcontext *ctx, GLenum sfactorRGB, @@ -346,16 +345,10 @@ static void r128DDClearDepth(GLcontext *ctx, GLclampd d) r128ContextPtr r128ctx = R128_CONTEXT(ctx); switch (r128ctx->regs.z_sten_cntl_c & R128_Z_PIX_WIDTH_MASK) { - case R128_Z_PIX_WIDTH_16: - r128ctx->ClearDepth = d * 0x0000ffff; - break; - case R128_Z_PIX_WIDTH_24: - r128ctx->ClearDepth = d * 0x00ffffff; - break; - case R128_Z_PIX_WIDTH_32: - default: - r128ctx->ClearDepth = d * 0xffffffff; - break; + case R128_Z_PIX_WIDTH_16: r128ctx->ClearDepth = d * 0x0000ffff; break; + case R128_Z_PIX_WIDTH_24: r128ctx->ClearDepth = d * 0x00ffffff; break; + case R128_Z_PIX_WIDTH_32: r128ctx->ClearDepth = d * 0xffffffff; break; + default: return; } } @@ -375,10 +368,16 @@ static void r128DDCullFace(GLcontext *ctx, GLenum mode) default: return; } - r128ctx->regs.pm4_vc_fpu_setup = f; + if (r128ctx->regs.pm4_vc_fpu_setup != f) { +#if FLUSH_VB_ON_STATE_CHANGE + R128_FLUSH_VB(r128ctx); +#endif + r128ctx->regs.pm4_vc_fpu_setup = f; - /* FIXME: Load into hardware now??? */ - r128ctx->dirty |= R128_UPDATE_CONTEXT; + /* FIXME: Load into hardware now??? */ + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_SETUPSTATE; + } } static void r128DDFrontFace(GLcontext *ctx, GLenum mode) @@ -394,10 +393,16 @@ static void r128DDFrontFace(GLcontext *ctx, GLenum mode) default: return; } - r128ctx->regs.pm4_vc_fpu_setup = f; + if (r128ctx->regs.pm4_vc_fpu_setup != f) { +#if FLUSH_VB_ON_STATE_CHANGE + R128_FLUSH_VB(r128ctx); +#endif + r128ctx->regs.pm4_vc_fpu_setup = f; - /* FIXME: Load into hardware now??? */ - r128ctx->dirty |= R128_UPDATE_CONTEXT; + /* FIXME: Load into hardware now??? */ + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_SETUPSTATE; + } } static void r128DDDepthFunc(GLcontext *ctx, GLenum func) @@ -419,20 +424,36 @@ static void r128DDDepthFunc(GLcontext *ctx, GLenum func) default: return; } - r128ctx->regs.z_sten_cntl_c = z; + if (r128ctx->regs.z_sten_cntl_c != z) { +#if FLUSH_VB_ON_STATE_CHANGE + R128_FLUSH_VB(r128ctx); +#endif + r128ctx->regs.z_sten_cntl_c = z; - /* FIXME: Load into hardware now??? */ - r128ctx->dirty |= R128_UPDATE_CONTEXT; + /* FIXME: Load into hardware now??? */ + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_ZSTENSTATE; + } } static void r128DDDepthMask(GLcontext *ctx, GLboolean flag) { r128ContextPtr r128ctx = R128_CONTEXT(ctx); - if (flag) r128ctx->regs.tex_cntl_c |= R128_Z_WRITE_ENABLE; - else r128ctx->regs.tex_cntl_c &= ~R128_Z_WRITE_ENABLE; + CARD32 t = r128ctx->regs.tex_cntl_c; - /* FIXME: Load into hardware now??? */ - r128ctx->dirty |= R128_UPDATE_CONTEXT; + if (flag) t |= R128_Z_WRITE_ENABLE; + else t &= ~R128_Z_WRITE_ENABLE; + + if (r128ctx->regs.tex_cntl_c != t) { +#if FLUSH_VB_ON_STATE_CHANGE + R128_FLUSH_VB(r128ctx); +#endif + r128ctx->regs.tex_cntl_c = t; + + /* FIXME: Load into hardware now??? */ + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_ENGINESTATE; + } } static void r128DDEnable(GLcontext *ctx, GLenum cap, GLboolean state) @@ -442,7 +463,6 @@ static void r128DDEnable(GLcontext *ctx, GLenum cap, GLboolean state) CARD32 f = r128ctx->regs.pm4_vc_fpu_setup; switch (cap) { -#if 0 case GL_ALPHA_TEST: if (state) t |= R128_ALPHA_TEST_ENABLE; else t &= ~R128_ALPHA_TEST_ENABLE; @@ -462,7 +482,6 @@ static void r128DDEnable(GLcontext *ctx, GLenum cap, GLboolean state) case GL_CLIP_PLANE4: case GL_CLIP_PLANE5: case GL_COLOR_MATERIAL: return; -#endif case GL_CULL_FACE: f &= ~(R128_BACKFACE_MASK | R128_FRONTFACE_MASK); @@ -478,20 +497,21 @@ static void r128DDEnable(GLcontext *ctx, GLenum cap, GLboolean state) } break; -#if 1 case GL_DEPTH_TEST: if (state) t |= R128_Z_ENABLE; else t &= ~R128_Z_ENABLE; break; -#endif #if 0 + /* FIXME */ case GL_DITHER: return; + /* FIXME */ case GL_FOG: if (state) t |= R128_FOG_ENABLE; else t &= ~R128_FOG_ENABLE; break; +#endif case GL_LIGHT0: case GL_LIGHT1: @@ -531,15 +551,32 @@ static void r128DDEnable(GLcontext *ctx, GLenum cap, GLboolean state) case GL_POLYGON_OFFSET_POINT: case GL_POLYGON_OFFSET_LINE: case GL_POLYGON_OFFSET_FILL: +#if 0 + /* FIXME: Are there others in Mesa 3.3 that we need to add? */ case GL_RESCALE_NORMAL_EXT: +#endif case GL_SCISSOR_TEST: +#if 0 + /* FIXME: Are there others in Mesa 3.3 that we need to add? */ case GL_SHARED_TEXTURE_PALETTE_EXT: +#endif case GL_STENCIL_TEST: case GL_TEXTURE_1D: return; case GL_TEXTURE_2D: - if (state) t |= R128_TEXMAP_ENABLE; - else t &= ~R128_TEXMAP_ENABLE; + switch (ctx->Texture.CurrentUnit) { + case 0: + if (state) t |= R128_TEXMAP_ENABLE; + else t &= ~R128_TEXMAP_ENABLE; + break; + case 1: + if (state) t |= R128_SEC_TEXMAP_ENABLE; + else t &= ~R128_SEC_TEXMAP_ENABLE; + break; + default: + return; + } + r128ctx->dirty |= R128_UPDATE_TEXSTATE; break; case GL_TEXTURE_3D: @@ -555,22 +592,29 @@ static void r128DDEnable(GLcontext *ctx, GLenum cap, GLboolean state) case GL_INDEX_ARRAY: case GL_TEXTURE_COORD_ARRAY: case GL_EDGE_FLAG_ARRAY: return; -#endif default: return; } - if (t != r128ctx->regs.tex_cntl_c) { + if (r128ctx->regs.tex_cntl_c != t) { +#if FLUSH_VB_ON_STATE_CHANGE + R128_FLUSH_VB(r128ctx); +#endif r128ctx->regs.tex_cntl_c = t; /* FIXME: Load into hardware now??? */ - r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_ENGINESTATE; } - if (f != r128ctx->regs.pm4_vc_fpu_setup) { + if (r128ctx->regs.pm4_vc_fpu_setup != f) { +#if FLUSH_VB_ON_STATE_CHANGE + R128_FLUSH_VB(r128ctx); +#endif r128ctx->regs.pm4_vc_fpu_setup = f; /* FIXME: Load into hardware now??? */ - r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_SETUPSTATE; } } @@ -581,6 +625,7 @@ static void r128DDScissor(GLcontext *ctx, /* FIXME */ } +/* Initialize the driver's state functions */ void r128DDInitStateFuncs(GLcontext *ctx) { ctx->Driver.UpdateState = r128DDUpdateState; @@ -606,7 +651,7 @@ void r128DDInitStateFuncs(GLcontext *ctx) ctx->Driver.RenderVBCulledTab = NULL; ctx->Driver.RenderVBRawTab = NULL; - ctx->Driver.ReducedPrimitiveChange = NULL; + ctx->Driver.ReducedPrimitiveChange = r128DDReducedPrimitiveChange; ctx->Driver.MultipassFunc = NULL; ctx->Driver.AlphaFunc = r128DDAlphaFunc; @@ -635,9 +680,11 @@ void r128DDInitStateFuncs(GLcontext *ctx) ctx->Driver.Viewport = NULL; } +/* Initialize the context's hardware state */ void r128DDInitState(r128ContextPtr r128ctx) { - int dst_bpp, pitch; + int dst_bpp, depth_bpp, pitch, i; + CARD32 depthClear; pitch = r128ctx->r128Screen->fbStride / r128ctx->r128Screen->bpp; @@ -658,6 +705,33 @@ void r128DDInitState(r128ContextPtr r128ctx) break; } + switch ( +#if 0 + /* FIXME: Figure out how to use 16bpp depth buffer in 32bpp mode */ + r128ctx->glCtx->Visual->DepthBits +#else + r128ctx->r128Screen->bpp +#endif + ) { + case 16: + depthClear = 0x0000ffff; + depth_bpp = R128_Z_PIX_WIDTH_16; + break; + case 24: + depthClear = 0x00ffffff; + depth_bpp = R128_Z_PIX_WIDTH_24; + break; + case 32: + depthClear = 0xffffffff; + depth_bpp = R128_Z_PIX_WIDTH_32; + break; + default: + /* FIXME: This is an error */ + depthClear = 0x00000000; + depth_bpp = R128_Z_PIX_WIDTH_16; + break; + } + r128ctx->dirty = R128_CLEAN; r128ctx->needClip = GL_FALSE; @@ -679,37 +753,38 @@ void r128DDInitState(r128ContextPtr r128ctx) } r128ctx->ClearColor = 0x00000000; - r128ctx->ClearDepth = 0x0000ffff; /* FIXME: init to requested depth */ + r128ctx->ClearDepth = depthClear; r128ctx->regs.scale_3d_cntl = - R128_SCALE_DITHER_ERR_DIFF | - R128_TEX_CACHE_SIZE_FULL | - R128_DITHER_INIT_RESET | - R128_SCALE_3D_TEXMAP_SHADE | - R128_SCALE_PIX_REPLICATE | - R128_ALPHA_COMB_ADD_CLAMP | - R128_FOG_TABLE | - R128_ALPHA_BLEND_SRC_ONE | - R128_ALPHA_BLEND_DST_ZERO | - R128_ALPHA_TEST_ALWAYS | + R128_SCALE_DITHER_ERR_DIFF | + R128_TEX_CACHE_SIZE_FULL | + R128_DITHER_INIT_RESET | + R128_SCALE_3D_TEXMAP_SHADE | + R128_SCALE_PIX_REPLICATE | + R128_ALPHA_COMB_ADD_CLAMP | + R128_FOG_TABLE | + R128_ALPHA_BLEND_SRC_ONE | + R128_ALPHA_BLEND_DST_ZERO | + R128_ALPHA_TEST_ALWAYS | R128_COMPOSITE_SHADOW_CMP_EQUAL | - R128_TEX_MAP_ALPHA_IN_TEXTURE | + R128_TEX_MAP_ALPHA_IN_TEXTURE | R128_TEX_CACHE_LINE_SIZE_8QW; r128ctx->regs.dst_pitch_offset_c = pitch << R128_PITCH_SHIFT; r128ctx->regs.dp_gui_master_cntl = R128_GMC_DST_PITCH_OFFSET_CNTL | - R128_GMC_BRUSH_SOLID_COLOR | - dst_bpp | - R128_GMC_SRC_DATATYPE_COLOR | - R128_GMC_BYTE_MSB_TO_LSB | - R128_GMC_CONVERSION_TEMP_6500 | - R128_ROP3_S | - R128_DP_SRC_SOURCE_MEMORY | - R128_GMC_3D_FCN_EN | - R128_GMC_CLR_CMP_CNTL_DIS | - R128_AUX_CLIP_DIS | + R128_GMC_DST_CLIPPING | + R128_GMC_BRUSH_SOLID_COLOR | + dst_bpp | + R128_GMC_SRC_DATATYPE_COLOR | + R128_GMC_BYTE_MSB_TO_LSB | + R128_GMC_CONVERSION_TEMP_6500 | + R128_ROP3_S | + R128_DP_SRC_SOURCE_MEMORY | + R128_GMC_3D_FCN_EN | + R128_GMC_CLR_CMP_CNTL_DIS | + R128_AUX_CLIP_DIS | R128_GMC_WR_MSK_DIS; r128ctx->regs.sc_top_left_c = 0x00000000; @@ -721,28 +796,29 @@ void r128DDInitState(r128ContextPtr r128ctx) r128ctx->regs.z_pitch_c = pitch; r128ctx->regs.z_sten_cntl_c = - R128_Z_PIX_WIDTH_16 | - R128_Z_TEST_LESS | + depth_bpp | + R128_Z_TEST_LESS | R128_STENCIL_TEST_ALWAYS | R128_STENCIL_S_FAIL_KEEP | - R128_STENCIL_ZPASS_KEEP | + R128_STENCIL_ZPASS_KEEP | R128_STENCIL_ZFAIL_KEEP; r128ctx->regs.tex_cntl_c = - R128_Z_WRITE_ENABLE | - R128_SHADE_ENABLE | + R128_Z_WRITE_ENABLE | + R128_SHADE_ENABLE | R128_ALPHA_IN_TEX_COMPLETE_A | - R128_LIGHT_DIS | - R128_ALPHA_LIGHT_DIS | + R128_LIGHT_DIS | + R128_ALPHA_LIGHT_DIS | + R128_TEX_CACHE_FLUSH | (0x0f << R128_LOD_BIAS_SHIFT); r128ctx->regs.misc_3d_state_cntl_reg = R128_MISC_SCALE_3D_TEXMAP_SHADE | - R128_MISC_SCALE_PIX_REPLICATE | - R128_ALPHA_COMB_ADD_CLAMP | - R128_FOG_TABLE | - R128_ALPHA_BLEND_SRC_ONE | - R128_ALPHA_BLEND_DST_ZERO | + R128_MISC_SCALE_PIX_REPLICATE | + R128_ALPHA_COMB_ADD_CLAMP | + R128_FOG_TABLE | + R128_ALPHA_BLEND_SRC_ONE | + R128_ALPHA_BLEND_DST_ZERO | R128_ALPHA_TEST_ALWAYS; r128ctx->regs.texture_clr_cmp_clr_c = 0x00000000; @@ -752,62 +828,44 @@ void r128DDInitState(r128ContextPtr r128ctx) r128ctx->regs.prim_tex_cntl_c = R128_MIN_BLEND_NEAREST | R128_MAG_BLEND_NEAREST | - R128_MIP_MAP_DISABLE | - R128_TEX_CLAMP_S_WRAP | + R128_MIP_MAP_DISABLE | + R128_TEX_CLAMP_S_WRAP | R128_TEX_CLAMP_T_WRAP; r128ctx->regs.prim_texture_combine_cntl_c = - R128_COMB_MODULATE | - R128_COLOR_FACTOR_TEX | + R128_COMB_MODULATE | + R128_COLOR_FACTOR_TEX | R128_INPUT_FACTOR_INT_COLOR | - R128_COMB_ALPHA_COPY | + R128_COMB_ALPHA_COPY | R128_ALPHA_FACTOR_TEX_ALPHA | R128_INP_FACTOR_A_INT_ALPHA; r128ctx->regs.tex_size_pitch_c = - (0 << R128_TEX_PITCH_SHIFT) | - (0 << R128_TEX_SIZE_SHIFT) | - (0 << R128_TEX_HEIGHT_SHIFT) | - (0 << R128_TEX_MIN_SIZE_SHIFT) | - (0 << R128_SEC_TEX_PITCH_SHIFT) | - (0 << R128_SEC_TEX_SIZE_SHIFT) | + (0 << R128_TEX_PITCH_SHIFT) | + (0 << R128_TEX_SIZE_SHIFT) | + (0 << R128_TEX_HEIGHT_SHIFT) | + (0 << R128_TEX_MIN_SIZE_SHIFT) | + (0 << R128_SEC_TEX_PITCH_SHIFT) | + (0 << R128_SEC_TEX_SIZE_SHIFT) | (0 << R128_SEC_TEX_HEIGHT_SHIFT) | (0 << R128_SEC_TEX_MIN_SIZE_SHIFT); - r128ctx->regs.prim_tex_0_offset_c = 0x00000000; - r128ctx->regs.prim_tex_1_offset_c = 0x00000000; - r128ctx->regs.prim_tex_2_offset_c = 0x00000000; - r128ctx->regs.prim_tex_3_offset_c = 0x00000000; - r128ctx->regs.prim_tex_4_offset_c = 0x00000000; - r128ctx->regs.prim_tex_5_offset_c = 0x00000000; - r128ctx->regs.prim_tex_6_offset_c = 0x00000000; - r128ctx->regs.prim_tex_7_offset_c = 0x00000000; - r128ctx->regs.prim_tex_8_offset_c = 0x00000000; - r128ctx->regs.prim_tex_9_offset_c = 0x00000000; - r128ctx->regs.prim_tex_10_offset_c = 0x00000000; + for (i = 0; i < R128_TEX_MAXLEVELS; i++) + r128ctx->regs.prim_tex_offset[i] = 0x00000000; r128ctx->regs.sec_tex_cntl_c = R128_SEC_SELECT_PRIM_ST; r128ctx->regs.sec_tex_combine_cntl_c = - R128_COMB_DIS | - R128_COLOR_FACTOR_TEX | + R128_COMB_DIS | + R128_COLOR_FACTOR_TEX | R128_INPUT_FACTOR_PREV_COLOR | - R128_COMB_ALPHA_DIS | - R128_ALPHA_FACTOR_TEX_ALPHA | + R128_COMB_ALPHA_DIS | + R128_ALPHA_FACTOR_TEX_ALPHA | R128_INP_FACTOR_A_PREV_ALPHA; - r128ctx->regs.sec_tex_0_offset_c = 0x00000000; - r128ctx->regs.sec_tex_1_offset_c = 0x00000000; - r128ctx->regs.sec_tex_2_offset_c = 0x00000000; - r128ctx->regs.sec_tex_3_offset_c = 0x00000000; - r128ctx->regs.sec_tex_4_offset_c = 0x00000000; - r128ctx->regs.sec_tex_5_offset_c = 0x00000000; - r128ctx->regs.sec_tex_6_offset_c = 0x00000000; - r128ctx->regs.sec_tex_7_offset_c = 0x00000000; - r128ctx->regs.sec_tex_8_offset_c = 0x00000000; - r128ctx->regs.sec_tex_9_offset_c = 0x00000000; - r128ctx->regs.sec_tex_10_offset_c = 0x00000000; + for (i = 0; i < R128_TEX_MAXLEVELS; i++) + r128ctx->regs.sec_tex_offset[i] = 0x00000000; r128ctx->regs.constant_color_c = 0x00ffffff; r128ctx->regs.prim_texture_border_color_c = 0x00ffffff; @@ -816,26 +874,32 @@ void r128DDInitState(r128ContextPtr r128ctx) r128ctx->regs.plane_3d_mask_c = 0xffffffff; r128ctx->regs.setup_cntl = - R128_COLOR_GOURAUD | - R128_PRIM_TYPE_TRI | - R128_TEXTURE_ST_MULT_W | - R128_STARTING_VERTEX_1 | - R128_ENDING_VERTEX_3 | + R128_COLOR_GOURAUD | + R128_PRIM_TYPE_TRI | +#if 1 + /* FIXME: Let r128 multiply? */ + R128_TEXTURE_ST_MULT_W | +#else + /* FIXME: Or, pre multiply? */ + R128_TEXTURE_ST_DIRECT | +#endif + R128_STARTING_VERTEX_1 | + R128_ENDING_VERTEX_3 | R128_SU_POLY_LINE_NOT_LAST | R128_SUB_PIX_4BITS; r128ctx->regs.pm4_vc_fpu_setup = - R128_FRONT_DIR_CCW | - R128_BACKFACE_SOLID | - R128_FRONTFACE_SOLID | - R128_FPU_COLOR_GOURAUD | - R128_FPU_SUB_PIX_4BITS | - R128_FPU_MODE_3D | - R128_TRAP_BITS_DISABLE | - R128_XFACTOR_2 | - R128_YFACTOR_2 | + R128_FRONT_DIR_CCW | + R128_BACKFACE_SOLID | + R128_FRONTFACE_SOLID | + R128_FPU_COLOR_GOURAUD | + R128_FPU_SUB_PIX_4BITS | + R128_FPU_MODE_3D | + R128_TRAP_BITS_DISABLE | + R128_XFACTOR_2 | + R128_YFACTOR_2 | R128_FLAT_SHADE_VERTEX_OGL | - R128_FPU_ROUND_TRUNCATE | + R128_FPU_ROUND_TRUNCATE | R128_WM_SEL_8DW; r128ctx->regs.fog_3d_table_start = 0x00000000; @@ -845,105 +909,209 @@ void r128DDInitState(r128ContextPtr r128ctx) r128ctx->regs.window_xy_offset = 0x00000000; r128ctx->regs.dp_write_mask = 0xffffffff; + + r128ctx->regs.pc_gui_ctlstat = R128_PC_FLUSH_GUI; + + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_ALL_DIRTY; } -/* This is only called when we have the lock */ +/* Load the current context's state into the hardware */ +/* NOTE: This function is only called while holding the hardware lock */ static void r128LoadContext(r128ContextPtr r128ctx) { unsigned char *R128MMIO = r128ctx->r128Screen->mmio; + int i; + int tex_size_pitch_done = GL_FALSE; - R128CCE_BEGIN_LOCKED(2); - R128CCE0(R128_CCE_PACKET0, R128_SCALE_3D_CNTL, 0); - R128CCE(r128ctx->regs.scale_3d_cntl); - - R128CCE_WAIT_LOCKED(27); - R128CCE0(R128_CCE_PACKET0, R128_DST_PITCH_OFFSET_C, 25); - R128CCE(r128ctx->regs.dst_pitch_offset_c); - R128CCE(r128ctx->regs.dp_gui_master_cntl); - R128CCE(r128ctx->regs.sc_top_left_c); - R128CCE(r128ctx->regs.sc_bottom_right_c); - R128CCE(r128ctx->regs.z_offset_c); - R128CCE(r128ctx->regs.z_pitch_c); - R128CCE(r128ctx->regs.z_sten_cntl_c); - R128CCE(r128ctx->regs.tex_cntl_c); - R128CCE(r128ctx->regs.misc_3d_state_cntl_reg); - R128CCE(r128ctx->regs.texture_clr_cmp_clr_c); - R128CCE(r128ctx->regs.texture_clr_cmp_msk_c); - R128CCE(r128ctx->regs.fog_color_c); - R128CCE(r128ctx->regs.prim_tex_cntl_c); - R128CCE(r128ctx->regs.prim_texture_combine_cntl_c); - R128CCE(r128ctx->regs.tex_size_pitch_c); - R128CCE(r128ctx->regs.prim_tex_0_offset_c); - R128CCE(r128ctx->regs.prim_tex_1_offset_c); - R128CCE(r128ctx->regs.prim_tex_2_offset_c); - R128CCE(r128ctx->regs.prim_tex_3_offset_c); - R128CCE(r128ctx->regs.prim_tex_4_offset_c); - R128CCE(r128ctx->regs.prim_tex_5_offset_c); - R128CCE(r128ctx->regs.prim_tex_6_offset_c); - R128CCE(r128ctx->regs.prim_tex_7_offset_c); - R128CCE(r128ctx->regs.prim_tex_8_offset_c); - R128CCE(r128ctx->regs.prim_tex_9_offset_c); - R128CCE(r128ctx->regs.prim_tex_10_offset_c); - - R128CCE_WAIT_LOCKED(19); - R128CCE0(R128_CCE_PACKET0, R128_SEC_TEX_CNTL_C, 17); - R128CCE(r128ctx->regs.sec_tex_cntl_c); - R128CCE(r128ctx->regs.sec_tex_combine_cntl_c); - R128CCE(r128ctx->regs.sec_tex_0_offset_c); - R128CCE(r128ctx->regs.sec_tex_1_offset_c); - R128CCE(r128ctx->regs.sec_tex_2_offset_c); - R128CCE(r128ctx->regs.sec_tex_3_offset_c); - R128CCE(r128ctx->regs.sec_tex_4_offset_c); - R128CCE(r128ctx->regs.sec_tex_5_offset_c); - R128CCE(r128ctx->regs.sec_tex_6_offset_c); - R128CCE(r128ctx->regs.sec_tex_7_offset_c); - R128CCE(r128ctx->regs.sec_tex_8_offset_c); - R128CCE(r128ctx->regs.sec_tex_9_offset_c); - R128CCE(r128ctx->regs.sec_tex_10_offset_c); - R128CCE(r128ctx->regs.constant_color_c); - R128CCE(r128ctx->regs.prim_texture_border_color_c); - R128CCE(r128ctx->regs.sec_texture_border_color_c); - R128CCE(r128ctx->regs.sten_ref_mask_c); - R128CCE(r128ctx->regs.plane_3d_mask_c); - - R128CCE_WAIT_LOCKED(2); - R128CCE0(R128_CCE_PACKET0, R128_SETUP_CNTL, 0); - R128CCE(r128ctx->regs.setup_cntl); - - R128CCE_WAIT_LOCKED(2); - R128CCE0(R128_CCE_PACKET0, R128_PM4_VC_FPU_SETUP, 0); - R128CCE(r128ctx->regs.pm4_vc_fpu_setup); +#if 0 + r128ctx->dirty_context = R128_ALL_DIRTY; +#endif - R128CCE_WAIT_LOCKED(3); - R128CCE0(R128_CCE_PACKET0, R128_FOG_3D_TABLE_START, 1); - R128CCE(r128ctx->regs.fog_3d_table_start); - R128CCE(r128ctx->regs.fog_3d_table_end); +#if 1 + /* FIXME: Why do these need to be updated even when they don't change? */ + r128ctx->dirty_context |= (R128_CTX_MISC | + R128_CTX_ENGINESTATE | + R128_CTX_ALPHASTATE); +#endif + +#if 1 + /* FIXME: Is this _really_ needed? */ + if (r128ctx->dirty_context) R128CCEWaitForIdle(r128ctx->r128Screen); +#endif + +#if !FLUSH_VB_ON_STATE_CHANGE + /* FIXME: It might make sense to do this here instead of flushing + immediately in each state setting routine. */ + /* FIXME: Is this _really_ necessary? It slows down rendering, and + it seems like state changes shouldn't take effect until after the + VB has completed rendering. */ + if (r128ctx->dirty_context) R128_FLUSH_VB(r128ctx); +#endif + + if (r128ctx->dirty_context & R128_CTX_MISC) { + R128CCE_WAIT_LOCKED(3); + R128CCE1(R128_CCE_PACKET1, R128_SCALE_3D_CNTL, R128_DP_WRITE_MASK); + R128CCE(r128ctx->regs.scale_3d_cntl); + R128CCE(r128ctx->regs.dp_write_mask); + + R128CCE_WAIT_LOCKED(3); + R128CCE0(R128_CCE_PACKET0, R128_DST_PITCH_OFFSET_C, 1); + R128CCE(r128ctx->regs.dst_pitch_offset_c); + R128CCE(r128ctx->regs.dp_gui_master_cntl); + + R128CCE_WAIT_LOCKED(3); + R128CCE0(R128_CCE_PACKET0, R128_TEXTURE_CLR_CMP_CLR_C, 1); + R128CCE(r128ctx->regs.texture_clr_cmp_clr_c); + R128CCE(r128ctx->regs.texture_clr_cmp_msk_c); + + R128CCE_WAIT_LOCKED(3); + R128CCE0(R128_CCE_PACKET0, R128_STEN_REF_MASK_C, 1); + R128CCE(r128ctx->regs.sten_ref_mask_c); + R128CCE(r128ctx->regs.plane_3d_mask_c); + } + + if (r128ctx->dirty_context & R128_CTX_ENGINESTATE) { + R128CCE_WAIT_LOCKED(2); + R128CCE0(R128_CCE_PACKET0, R128_TEX_CNTL_C, 0); + R128CCE(r128ctx->regs.tex_cntl_c); + } - R128CCE_WAIT_LOCKED(2); - R128CCE0(R128_CCE_PACKET0, R128_FOG_3D_TABLE_DENSITY, 0); - R128CCE(r128ctx->regs.fog_3d_table_density); + if (r128ctx->dirty_context & R128_CTX_TEX0STATE) { + R128CCE_WAIT_LOCKED(4+R128_TEX_MAXLEVELS); + R128CCE0(R128_CCE_PACKET0, R128_PRIM_TEX_CNTL_C, 2+R128_TEX_MAXLEVELS); + R128CCE(r128ctx->regs.prim_tex_cntl_c); + R128CCE(r128ctx->regs.prim_texture_combine_cntl_c); + R128CCE(r128ctx->regs.tex_size_pitch_c); + for (i = 0; i < R128_TEX_MAXLEVELS; i++) + R128CCE(r128ctx->regs.prim_tex_offset[i]); - R128CCE_WAIT_LOCKED(2); - R128CCE0(R128_CCE_PACKET0, R128_WINDOW_XY_OFFSET, 0); - R128CCE(r128ctx->regs.window_xy_offset); + R128CCE_WAIT_LOCKED(2); + R128CCE0(R128_CCE_PACKET0, R128_PRIM_TEXTURE_BORDER_COLOR_C, 0); + R128CCE(r128ctx->regs.prim_texture_border_color_c); - R128CCE_WAIT_LOCKED(2); - R128CCE0(R128_CCE_PACKET0, R128_DP_WRITE_MASK, 0); - R128CCE(r128ctx->regs.dp_write_mask); + tex_size_pitch_done = GL_TRUE; + } + + if (r128ctx->dirty_context & R128_CTX_TEX1STATE) { + if (!tex_size_pitch_done) { + R128CCE_WAIT_LOCKED(2); + R128CCE0(R128_CCE_PACKET0, R128_TEX_SIZE_PITCH_C, 0); + R128CCE(r128ctx->regs.tex_size_pitch_c); + } + + R128CCE_WAIT_LOCKED(3+R128_TEX_MAXLEVELS); + R128CCE0(R128_CCE_PACKET0, R128_SEC_TEX_CNTL_C, 1+R128_TEX_MAXLEVELS); + R128CCE(r128ctx->regs.sec_tex_cntl_c); + R128CCE(r128ctx->regs.sec_tex_combine_cntl_c); + for (i = 0; i < R128_TEX_MAXLEVELS; i++) + R128CCE(r128ctx->regs.sec_tex_offset[i]); + + R128CCE_WAIT_LOCKED(2); + R128CCE0(R128_CCE_PACKET0, R128_SEC_TEXTURE_BORDER_COLOR_C, 0); + R128CCE(r128ctx->regs.sec_texture_border_color_c); + + } + + if (r128ctx->dirty_context & R128_CTX_TEXENVSTATE) { + R128CCE_WAIT_LOCKED(2); + R128CCE0(R128_CCE_PACKET0, R128_CONSTANT_COLOR_C, 0); + R128CCE(r128ctx->regs.constant_color_c); + } + + if (r128ctx->dirty_context & R128_CTX_FOGSTATE) { + R128CCE_WAIT_LOCKED(3); + R128CCE0(R128_CCE_PACKET0, R128_FOG_3D_TABLE_START, 1); + R128CCE(r128ctx->regs.fog_3d_table_start); + R128CCE(r128ctx->regs.fog_3d_table_end); + + R128CCE_WAIT_LOCKED(3); + R128CCE1(R128_CCE_PACKET1, + R128_FOG_COLOR_C, R128_FOG_3D_TABLE_DENSITY); + R128CCE(r128ctx->regs.fog_color_c); + R128CCE(r128ctx->regs.fog_3d_table_density); + } + + if (r128ctx->dirty_context & R128_CTX_ZSTENSTATE) { + R128CCE_WAIT_LOCKED(2); + R128CCE0(R128_CCE_PACKET0, R128_Z_STEN_CNTL_C, 0); + R128CCE(r128ctx->regs.z_sten_cntl_c); + } + + if (r128ctx->dirty_context & R128_CTX_SCISSORS) { + R128CCE_WAIT_LOCKED(3); + R128CCE0(R128_CCE_PACKET0, R128_SC_TOP_LEFT_C, 1); + R128CCE(r128ctx->regs.sc_top_left_c); + R128CCE(r128ctx->regs.sc_bottom_right_c); + } + + if (r128ctx->dirty_context & (R128_CTX_ALPHASTATE | + R128_CTX_FOGSTATE)) { + R128CCE_WAIT_LOCKED(2); + R128CCE0(R128_CCE_PACKET0, R128_MISC_3D_STATE_CNTL_REG, 0); + R128CCE(r128ctx->regs.misc_3d_state_cntl_reg); + } + + if (r128ctx->dirty_context & R128_CTX_SETUPSTATE) { + R128CCE_WAIT_LOCKED(3); + R128CCE1(R128_CCE_PACKET1, R128_SETUP_CNTL, R128_PM4_VC_FPU_SETUP); + R128CCE(r128ctx->regs.setup_cntl); + R128CCE(r128ctx->regs.pm4_vc_fpu_setup); + } + + if (r128ctx->dirty_context & R128_CTX_WIN_Z_POS) { + R128CCE_WAIT_LOCKED(2); + R128CCE0(R128_CCE_PACKET0, R128_WINDOW_XY_OFFSET, 0); + R128CCE(r128ctx->regs.window_xy_offset); + + R128CCE_WAIT_LOCKED(3); + R128CCE0(R128_CCE_PACKET0, R128_Z_OFFSET_C, 1); + R128CCE(r128ctx->regs.z_offset_c); + R128CCE(r128ctx->regs.z_pitch_c); + } + + if (r128ctx->dirty_context & R128_CTX_FLUSH_PIX_CACHE) { + R128CCE_WAIT_LOCKED(2); + R128CCE0(R128_CCE_PACKET0, R128_PC_GUI_CTLSTAT, 0); + R128CCE(r128ctx->regs.pc_gui_ctlstat); + } R128CCE_END_LOCKED(); + + /* Turn off the texture cache flushing */ + r128ctx->regs.tex_cntl_c &= ~R128_TEX_CACHE_FLUSH; + + /* Turn off the pixel cache flushing */ + r128ctx->regs.pc_gui_ctlstat &= ~R128_PC_FLUSH_ALL; + + r128ctx->dirty_context = R128_CTX_CLEAN; } -/* This is only called when we have the lock */ +/* Set a hardware clip rect for drawing to the current color buffer */ +/* NOTE: This function is only called while holding the hardware lock */ void r128SetClipRect(r128ContextPtr r128ctx, XF86DRIClipRectPtr pc) { + unsigned char *R128MMIO = r128ctx->r128Screen->mmio; + + /* FIXME: Use the Rage 128's multiple clip rects */ + R128CCE_WAIT_LOCKED(3); + R128CCE0(R128_CCE_PACKET0, R128_SC_TOP_LEFT_C, 1); + R128CCE(((pc->y1 + r128ctx->bufY) << 16)|(pc->x1 + r128ctx->bufX)); + R128CCE(((pc->y2 + r128ctx->bufY - 1) << 16)|(pc->x2 + r128ctx->bufX - 1)); + R128CCE_END_LOCKED(); } -static void r128LoadCliprects(r128ContextPtr r128ctx) +/* Update the driver's notion of the window position */ +/* NOTE: This function is only called while holding the hardware lock */ +static void r128UpdateWindowPosition(r128ContextPtr r128ctx) { int x = r128ctx->driDrawable->x + r128ctx->bufX; int y = r128ctx->driDrawable->y + r128ctx->bufY; +#if 0 + /* FIXME: This happens during a lock, but is it _really_ needed? */ + R128_FLUSH_VB(r128ctx); +#endif r128ctx->regs.window_xy_offset = ((y << R128_WINDOW_Y_SHIFT) | (x << R128_WINDOW_X_SHIFT)); @@ -956,24 +1124,109 @@ static void r128LoadCliprects(r128ContextPtr r128ctx) (r128ctx->r128Screen->depthY - r128ctx->bufY) * r128ctx->r128Screen->fbStride); + + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_WIN_Z_POS; + + r128ctx->needClip = (r128ctx->driDrawable->numClipRects > 1); } -void r128UpdateState(r128ContextPtr r128ctx) +/* Update the hardware state */ +/* NOTE: This function is only called while holding the hardware lock */ +static void r128UpdateHWStateLocked(r128ContextPtr r128ctx) +{ + r128ScreenPtr r128Screen = r128ctx->r128Screen; + + if (r128ctx->dirty & R128_REQUIRE_QUIESCENCE) + R128WaitForIdle(r128Screen); + + /* Update any state that might have changed recently */ + + /* Update the clip rects */ + if (r128ctx->dirty & R128_UPDATE_WINPOS) + r128UpdateWindowPosition(r128ctx); + + /* Update texture state and then upload the images */ + /* Note: Texture images can only be updated after the state has been set */ + if (r128ctx->dirty & R128_UPDATE_TEXSTATE) + r128UpdateTextureState(r128ctx); + if (r128ctx->dirty & R128_UPDATE_TEX0IMAGES) + r128UploadTexImages(r128ctx, r128ctx->CurrentTexObj[0]); + if (r128ctx->dirty & R128_UPDATE_TEX1IMAGES) + r128UploadTexImages(r128ctx, r128ctx->CurrentTexObj[1]); + + /* Load the state into the hardware */ + /* Note: This must be done after all other state has been set */ + if (r128ctx->dirty & R128_UPDATE_CONTEXT) + r128LoadContext(r128ctx); + + r128ctx->dirty = R128_CLEAN; +} + +/* Update the hardware state */ +void r128UpdateHWState(r128ContextPtr r128ctx) { LOCK_HARDWARE(r128ctx); - r128UpdateStateLocked(r128ctx); + r128UpdateHWStateLocked(r128ctx); UNLOCK_HARDWARE(r128ctx); } -/* This is only called when we have the lock */ -void r128UpdateStateLocked(r128ContextPtr r128ctx) +/* Update the driver's state */ +/* NOTE: This function is only called while holding the hardware lock */ +void r128UpdateState(r128ContextPtr r128ctx, int winMoved) { - r128ScreenPtr r128Screen = r128ctx->r128Screen; + if (r128ctx->SAREA->ctxOwner != r128ctx->driContext->hHWContext) { + r128ctx->SAREA->ctxOwner = r128ctx->driContext->hHWContext; + r128ctx->dirty |= R128_ALL_DIRTY; + } - if (r128ctx->dirty & R128_REQUIRE_QUIESCENCE) R128WaitForIdle(r128Screen); - if (r128ctx->dirty & R128_START_CCE) R128CCEStart(r128Screen); - if (r128ctx->dirty & R128_UPDATE_CLIPRECTS) r128LoadCliprects(r128ctx); - if (r128ctx->dirty & R128_UPDATE_CONTEXT) r128LoadContext(r128ctx); + if (r128ctx->SAREA->texAge != r128ctx->lastTexAge) { +#if USE_AGP_TEXTURES + int sz = 1 << r128ctx->r128Screen->log2AGPTexGran; +#else + int sz = 1 << r128ctx->r128Screen->log2TexGran; +#endif + int nr = 0; + int idx; + + for (idx = r128ctx->SAREA->texList[R128_NR_TEX_REGIONS].prev; + idx != R128_NR_TEX_REGIONS && nr < R128_NR_TEX_REGIONS; + idx = r128ctx->SAREA->texList[idx].prev, nr++) { + + /* If switching texturing schemes, then the SAREA might not + have been properly cleared, so we need to reset the + global texture LRU. */ +#if USE_AGP_TEXTURES + if (idx * sz > r128ctx->r128Screen->agpTexSize) { +#else + if (idx * sz > r128ctx->r128Screen->textureSize) { +#endif + nr = R128_NR_TEX_REGIONS; + break; + } - r128ctx->dirty = R128_CLEAN; + if (r128ctx->SAREA->texList[idx].age > r128ctx->lastTexAge) + r128TexturesGone(r128ctx, idx * sz, sz, + r128ctx->SAREA->texList[idx].in_use); + } + + if (nr == R128_NR_TEX_REGIONS) { +#if USE_AGP_TEXTURES + r128TexturesGone(r128ctx, 0, r128ctx->r128Screen->agpTexSize, 0); +#else + r128TexturesGone(r128ctx, 0, r128ctx->r128Screen->textureSize, 0); +#endif + r128ResetGlobalLRU(r128ctx); + } + + r128ctx->dirty |= R128_UPDATE_TEX0IMAGES; + r128ctx->dirty |= R128_UPDATE_TEX1IMAGES; + r128ctx->lastTexAge = r128ctx->SAREA->texAge; + } + + if (winMoved) { /* FIXME??: handle window moves */ + r128ctx->dirty |= R128_UPDATE_WINPOS; + } + + if (r128ctx->dirty) r128UpdateHWStateLocked(r128ctx); } diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_state.h b/xc/lib/GL/mesa/src/drv/r128/r128_state.h index f604f6ca8..570d38f8e 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_state.h +++ b/xc/lib/GL/mesa/src/drv/r128/r128_state.h @@ -37,13 +37,15 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #ifdef GLX_DIRECT_RENDERING -extern void r128DDInitState(r128ContextPtr r128ctx); -extern void r128DDInitStateFuncs(GLcontext *ctx); +extern void r128DDInitState(r128ContextPtr r128ctx); +extern void r128DDInitStateFuncs(GLcontext *ctx); -extern void r128UpdateState(r128ContextPtr r128ctx); -extern void r128UpdateStateLocked(r128ContextPtr r128ctx); +extern void r128UpdateState(r128ContextPtr r128ctx, int winMoved); +extern void r128UpdateHWState(r128ContextPtr r128ctx); -extern void r128SetClipRect(r128ContextPtr r128ctx, XF86DRIClipRectPtr pc); +extern void r128SetClipRect(r128ContextPtr r128ctx, XF86DRIClipRectPtr pc); +extern CARD32 r128PackColor(GLuint d, + GLubyte r, GLubyte g, GLubyte b, GLubyte a); #endif #endif /* _R128_STATE_H_ */ diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_swap.c b/xc/lib/GL/mesa/src/drv/r128/r128_swap.c index 2f561a74d..27150d510 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_swap.c +++ b/xc/lib/GL/mesa/src/drv/r128/r128_swap.c @@ -39,12 +39,17 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #include "r128_lock.h" #include "r128_reg.h" #include "r128_cce.h" +#include "r128_vb.h" #include "r128_swap.h" +/* Copy the back color buffer to the front color buffer */ void r128SwapBuffers(r128ContextPtr r128ctx) { - unsigned char *R128MMIO = r128ctx->r128Screen->mmio; - int dst_bpp; + unsigned char *R128MMIO = r128ctx->r128Screen->mmio; + __DRIdrawablePrivate *dPriv = r128ctx->driDrawable; + int nc = dPriv->numClipRects; + XF86DRIClipRectPtr c = dPriv->pClipRects; + int dst_bpp; switch (r128ctx->r128Screen->bpp) { case 8: @@ -63,21 +68,39 @@ void r128SwapBuffers(r128ContextPtr r128ctx) break; } - R128CCE_BEGIN(5); + /* Flush any outstanding vertex buffers */ + R128_FLUSH_VB(r128ctx); - R128CCE3(R128_CCE_PACKET3_CNTL_BITBLT_MULTI, 3); - R128CCE(R128_GMC_BRUSH_NONE - | R128_GMC_SRC_DATATYPE_COLOR - | R128_DP_SRC_SOURCE_MEMORY - | dst_bpp - | R128_ROP3_S); - R128CCE(((r128ctx->driDrawable->x + r128ctx->r128Screen->backX)<< 16) - | (r128ctx->driDrawable->y + r128ctx->r128Screen->backY)); - R128CCE((r128ctx->driDrawable->x << 16) | r128ctx->driDrawable->y); - R128CCE((r128ctx->driDrawable->w << 16) | r128ctx->driDrawable->h); + LOCK_HARDWARE(r128ctx); - r128ctx->dirty = R128_UPDATE_CONTEXT; - /* r128UpdateState(r128ctx); */ + /* Cycle through the clip rects */ + while (nc--) { + int fx = c[nc].x1; + int fy = c[nc].y1; + int fw = c[nc].x2 - fx; + int fh = c[nc].y2 - fy; + int bx = fx + r128ctx->r128Screen->backX; + int by = fy + r128ctx->r128Screen->backY; - R128CCE_END(); + fx += r128ctx->r128Screen->fbX; + fy += r128ctx->r128Screen->fbY; + + R128CCE_WAIT_LOCKED(5); + R128CCE3(R128_CCE_PACKET3_CNTL_BITBLT_MULTI, 3); + R128CCE(R128_GMC_BRUSH_NONE + | R128_GMC_SRC_DATATYPE_COLOR + | R128_DP_SRC_SOURCE_MEMORY + | dst_bpp + | R128_ROP3_S); + R128CCE((bx << 16) | by); + R128CCE((fx << 16) | fy); + R128CCE((fw << 16) | fh); + } + + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_ALL_DIRTY; + + R128CCE_END_LOCKED(); + + UNLOCK_HARDWARE(r128ctx); } diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_tex.c b/xc/lib/GL/mesa/src/drv/r128/r128_tex.c index 75b08e527..b61f9cdc1 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_tex.c +++ b/xc/lib/GL/mesa/src/drv/r128/r128_tex.c @@ -34,19 +34,1028 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #include "r128_init.h" #include "r128_mesa.h" +#include "r128_xmesa.h" +#include "r128_context.h" +#include "r128_lock.h" +#include "r128_state.h" +#include "r128_reg.h" +#include "r128_cce.h" +#include "r128_vb.h" #include "r128_tex.h" +#include "mmath.h" +#include "simple_list.h" + +static void r128SetTexWrap(r128TexObjPtr t, GLenum srwap, GLenum twrap); +static void r128SetTexFilter(r128TexObjPtr t, GLenum minf, GLenum magf); +static void r128SetTexBorderColor(r128TexObjPtr t, GLubyte c[4]); + +/* Allocate and initialize hardware state associated with texture `t' */ +/* NOTE: This function is only called while holding the hardware lock */ +static r128TexObjPtr r128CreateTexObj(r128ContextPtr r128ctx, + struct gl_texture_object *tObj) +{ + r128TexObjPtr t; + struct gl_texture_image *image; + CARD32 texFormat; + int log2Pitch, log2Height, log2Size, log2MinSize; + int pitch, totalSize, width; + int i; + + image = tObj->Image[0]; + if (!image) return NULL; /* ERROR!!! */ + + t = (r128TexObjPtr)calloc(1,sizeof(*t)); + if (!t) return NULL; /* ERROR!!! */ + + for (i = 1, log2Height = 0; i < image->Height; i *= 2) log2Height++; + for (i = 1, log2Pitch = 0; i < image->Width; i *= 2) log2Pitch++; + if (image->Width > image->Height) log2Size = log2Pitch; + else log2Size = log2Height; + + pitch = image->Width; + t->internFormat = image->IntFormat; + + switch (image->Format) { + case GL_LUMINANCE: + case GL_ALPHA: + case GL_RGB: + if (r128ctx->r128Screen->bpp == 16 && + (t->internFormat == GL_RGB || t->internFormat == 3)) + t->internFormat = GL_RGB5; + + switch (t->internFormat) { + case GL_RGB5: pitch *= 2; texFormat = R128_DATATYPE_RGB565; break; + case 3: + case GL_RGB: +#if USE_RGB8_TEXTURES + case GL_RGB8: pitch *= 3; texFormat = R128_DATATYPE_RGB888; break; +#else + case GL_RGB8: pitch *= 4; texFormat = R128_DATATYPE_ARGB8888; break; +#endif + default: + /* Format not supported */ + free(t); + return NULL; + } + break; + case GL_LUMINANCE_ALPHA: + case GL_INTENSITY: + case GL_RGBA: + if (r128ctx->r128Screen->bpp == 16 && + (t->internFormat == GL_RGBA || t->internFormat == 4)) + t->internFormat = GL_RGBA4; + + switch (t->internFormat) { + case GL_RGB5_A1: pitch *= 2; texFormat = R128_DATATYPE_ARGB1555; break; + case GL_RGBA4: pitch *= 2; texFormat = R128_DATATYPE_ARGB4444; break; + case 4: + case GL_RGBA: + case GL_RGBA8: pitch *= 4; texFormat = R128_DATATYPE_ARGB8888; break; + default: + /* Format not supported */ + free(t); + return NULL; + } + break; + case GL_COLOR_INDEX: + switch (t->internFormat) { + case 1: + case GL_COLOR_INDEX: + case GL_COLOR_INDEX8_EXT: texFormat = R128_DATATYPE_CI8; break; + default: + /* Format not supported */ + free(t); + return NULL; + } + break; + default: + /* ERROR!!! */ + free(t); + return NULL; + } + + t->dirty_images = 0; + t->bound = 0; + t->tObj = tObj; + + t->memBlock = NULL; + t->bufAddr = NULL; + + totalSize = 0; + width = image->Width; + for (i = 0; i <= log2Size && tObj->Image[i]; i++) { + t->image[i].offset = totalSize; + t->image[i].width = width; + t->dirty_images |= 1 << i; + totalSize += tObj->Image[i]->Height * pitch; + pitch /= 2; + width /= 2; + } + log2MinSize = log2Size - i + 1; + + t->totalSize = totalSize; + + t->regs.tex_cntl = texFormat; + t->regs.size_pitch = ((log2Pitch << R128_TEX_PITCH_SHIFT) | + (log2Size << R128_TEX_SIZE_SHIFT) | + (log2Height << R128_TEX_HEIGHT_SHIFT) | + (log2MinSize << R128_TEX_MIN_SIZE_SHIFT)); + t->regs.border_color = 0x00000000; + + if (log2MinSize == log2Size || + log2MinSize != 0) + t->regs.tex_cntl |= R128_MIP_MAP_DISABLE; + + r128SetTexWrap(t, tObj->WrapS, tObj->WrapT); + r128SetTexFilter(t, tObj->MinFilter, tObj->MagFilter); + r128SetTexBorderColor(t, tObj->BorderColor); + + tObj->DriverData = t; + /* r128ctx->dirty |= R128_UPDATE_CONTEXT; */ + + make_empty_list(t); + + return t; +} + +/* Destroy hardware state associated with texture `t' */ +/* NOTE: This function can be called while holding the hardware lock and + while not holding the lock*/ +void r128DestroyTexObj(r128ContextPtr r128ctx, r128TexObjPtr t) +{ + if (!t) return; + + if (t->memBlock) { + mmFreeMem(t->memBlock); + t->memBlock = NULL; + } + + if (t->tObj) t->tObj->DriverData = NULL; + if (t->bound) r128ctx->CurrentTexObj[t->bound-1] = NULL; + + remove_from_list(t); + free(t); +} + +/* Keep track of swapped out texture objects */ +/* NOTE: This function is only called while holding the hardware lock */ +static void r128SwapOutTexObj(r128ContextPtr r128ctx, r128TexObjPtr t) +{ + if (t->memBlock) { + mmFreeMem(t->memBlock); + t->memBlock = NULL; + } + + t->dirty_images = ~0; + move_to_tail(&r128ctx->SwappedOut, t); +} + +/* Upload the texture image associated with texture `t' at level `level' + at the address relative to `start'. */ +/* NOTE: This function is only called while holding the hardware lock */ +static void r128UploadTexLevel(r128TexObjPtr t, int level, int start) +{ + struct gl_texture_image *image; + int i, j, width; + + if (level < 0 || level > R128_TEX_MAXLEVELS) return; + if (!(image = t->tObj->Image[level])) return; + + width = t->image[level].width; + + /* FIXME: Use HOSTDATA_BLT (type 3 packet) for texture uploads */ + /* FIXME: Add the other texture formats that we support here */ + switch (t->internFormat) { + case GL_RGB5: + { + CARD16 *dst = (CARD16 *)(t->image[level].offset + t->bufAddr + start); + CARD8 *src = (CARD8 *)image->Data; + + for (j = 0; j < image->Height; j++) { + for (i = 0; i < width; i++) { + dst[i] = (((src[0] & 0xf8) << 8) | + ((src[1] & 0xfc) << 3) | + ((src[2] & 0xf8) >> 3)); + src += 3; + } + dst += width; + } + break; + } + case 3: + case GL_RGB: + case GL_RGB8: + { +#if USE_RGB8_TEXTURES + CARD8 *dst = (CARD8 *)(t->image[level].offset + t->bufAddr + start); + CARD8 *src = (CARD8 *)image->Data; + + for (j = 0; j < image->Height; j++) { + for (i = 0; i < width; i++) { + *dst++ = src[0]; + *dst++ = src[1]; + *dst++ = src[2]; + src += 3; + } + } +#else + CARD32 *dst = (CARD32 *)(t->image[level].offset + t->bufAddr + start); + CARD8 *src = (CARD8 *)image->Data; + + for (j = 0; j < image->Height; j++) { + for (i = 0; i < width; i++) { + dst[i] = ((src[0] << 16) | + (src[1] << 8) | + (src[2] << 0) | + (0xff << 24)); + src += 3; + } + dst += width; + } +#endif + break; + } + case GL_RGB5_A1: + { + CARD16 *dst = (CARD16 *)(t->image[level].offset + t->bufAddr + start); + CARD8 *src = (CARD8 *)image->Data; + + for (j = 0; j < image->Height; j++) { + for (i = 0; i < width; i++) { + dst[i] = (((src[0] & 0xf8) << 7) | + ((src[1] & 0xf8) << 2) | + ((src[2] & 0xf8) >> 3) | + ((src[3] & 0x80) << 8)); + src += 4; + } + dst += width; + } + break; + } + case GL_RGBA4: + { + CARD16 *dst = (CARD16 *)(t->image[level].offset + t->bufAddr + start); + CARD8 *src = (CARD8 *)image->Data; + + for (j = 0; j < image->Height; j++) { + for (i = 0; i < width; i++) { + dst[i] = (((src[0] & 0xf0) << 4) | + ((src[1] & 0xf0) << 0) | + ((src[2] & 0xf0) >> 4) | + ((src[3] & 0xf0) << 8)); + src += 4; + } + dst += width; + } + break; + } + case 4: + case GL_RGBA: + case GL_RGBA8: + { + CARD32 *dst = (CARD32 *)(t->image[level].offset + t->bufAddr + start); + CARD8 *src = (CARD8 *)image->Data; + + for (j = 0; j < image->Height; j++) { + for (i = 0; i < width; i++) { + dst[i] = ((src[0] << 16) | + (src[1] << 8) | + (src[2] << 0) | + (src[3] << 24)); + src += 4; + } + dst += width; + } + break; + } + default: + return; + } +} + +/* Reset the global texture LRU */ +/* NOTE: This function is only called while holding the hardware lock */ +void r128ResetGlobalLRU(r128ContextPtr r128ctx) +{ + R128TexRegion *list = r128ctx->SAREA->texList; +#if USE_AGP_TEXTURES + int sz = 1 << r128ctx->r128Screen->log2AGPTexGran; +#else + int sz = 1 << r128ctx->r128Screen->log2TexGran; +#endif + int i; + + /* + * (Re)initialize the global circular LRU list. The last element in + * the array (R128_NR_TEX_REGIONS) is the sentinal. Keeping it at + * the end of the array allows it to be addressed rationally when + * looking up objects at a particular location in texture memory. + */ + +#if USE_AGP_TEXTURES + for (i = 0; (i+1) * sz <= r128ctx->r128Screen->agpTexSize; i++) { +#else + for (i = 0; (i+1) * sz <= r128ctx->r128Screen->textureSize; i++) { +#endif + list[i].prev = i-1; + list[i].next = i+1; + list[i].age = 0; + } + + i--; + list[0].prev = R128_NR_TEX_REGIONS; + list[i].prev = i-1; + list[i].next = R128_NR_TEX_REGIONS; + list[R128_NR_TEX_REGIONS].prev = i; + list[R128_NR_TEX_REGIONS].next = 0; + r128ctx->SAREA->texAge = 0; +} + +/* Update the local and glock texture LRUs */ +/* NOTE: This function is only called while holding the hardware lock */ +static void r128UpdateTexLRU(r128ContextPtr r128ctx, r128TexObjPtr t) +{ + R128TexRegion *list = r128ctx->SAREA->texList; +#if USE_AGP_TEXTURES + int log2sz = r128ctx->r128Screen->log2AGPTexGran; +#else + int log2sz = r128ctx->r128Screen->log2TexGran; +#endif + + int start = t->memBlock->ofs >> log2sz; + int end = (t->memBlock->ofs + t->memBlock->size - 1) >> log2sz; + int i; + + r128ctx->lastTexAge = ++r128ctx->SAREA->texAge; + + /* Update our local LRU */ + move_to_head(&r128ctx->TexObjList, t); + + /* Update the global LRU */ + for (i = start ; i <= end ; i++) { + list[i].in_use = 1; + list[i].age = r128ctx->lastTexAge; + + /* remove_from_list(i) */ + list[(CARD32)list[i].next].prev = list[i].prev; + list[(CARD32)list[i].prev].next = list[i].next; + + /* insert_at_head(list, i) */ + list[i].prev = R128_NR_TEX_REGIONS; + list[i].next = list[R128_NR_TEX_REGIONS].next; + list[(CARD32)list[R128_NR_TEX_REGIONS].next].prev = i; + list[R128_NR_TEX_REGIONS].next = i; + } +} + +/* Update our notion of what textures have been changed since we last + held the lock. This pertains to both our local textures and the + textures belonging to other clients. Keep track of other client's + textures by pushing a placeholder texture onto the LRU list -- these + are denoted by (tObj == NULL). */ +/* NOTE: This function is only called while holding the hardware lock */ +void r128TexturesGone(r128ContextPtr r128ctx, + int offset, int size, int in_use) +{ + r128TexObjPtr t, tmp; + + foreach_s (t, tmp, &r128ctx->TexObjList) { + if (t->memBlock->ofs >= offset + size || + t->memBlock->ofs + t->memBlock->size <= offset) + continue; + + /* It overlaps - kick it out. Need to hold onto the currently + bound objects, however. */ + if (t->bound) r128SwapOutTexObj(r128ctx, t); + else r128DestroyTexObj(r128ctx, t); + } + + if (in_use) { + t = (r128TexObjPtr) calloc(1,sizeof(*t)); + if (!t) return; + + t->memBlock = mmAllocMem(r128ctx->texHeap, size, 0, offset); + insert_at_head(&r128ctx->TexObjList, t); + } +} + +/* Upload the texture images associated with texture `t'. This might + require removing our own and/or other client's texture objects to + make room for these images. */ +/* NOTE: This function is only called while holding the hardware lock */ +int r128UploadTexImages(r128ContextPtr r128ctx, r128TexObjPtr t) +{ + int i; + int minLevel; + int maxLevel; + + if (!t) return 0; + + /* Do we need to eject LRU texture objects? */ + if (!t->memBlock) { + while (1) { + /* Allocate a memory block on a 4k boundary (1<<12 == 4096) */ + t->memBlock = mmAllocMem(r128ctx->texHeap, t->totalSize, 12, 0); + if (t->memBlock) break; + + if (r128ctx->TexObjList.prev->bound) { + fprintf(stderr, + "r128UploadTexImages: ran into bound texture\n"); + return -1; + } + if (r128ctx->TexObjList.prev == &(r128ctx->TexObjList)) { + fprintf(stderr, + "r128UploadTexImages: upload texture failure, sz=%d\n", + t->totalSize); + return -1; + } + + r128DestroyTexObj(r128ctx, r128ctx->TexObjList.prev); + } + + /* FIXME: Allow both local and AGP textures to co-exist. */ +#if USE_AGP_TEXTURES + t->bufAddr = (unsigned char *)r128ctx->r128Screen->agpTexStart; +#else + t->bufAddr = (unsigned char *)(r128ctx->r128Screen->textureY * + r128ctx->r128Screen->fbStride + + r128ctx->r128Screen->textureX * + (r128ctx->r128Screen->bpp/8)); +#endif + t->bufAddr += t->memBlock->ofs; + + maxLevel = ((t->regs.size_pitch & R128_TEX_SIZE_MASK) >> + R128_TEX_SIZE_SHIFT); + minLevel = ((t->regs.size_pitch & R128_TEX_MIN_SIZE_MASK) >> + R128_TEX_MIN_SIZE_SHIFT); + + /* Update the hardware's texture image addresses */ + switch (t->bound) { + case 1: + if (t->regs.tex_cntl & R128_MIP_MAP_DISABLE) { + for (i = 0; i < R128_TEX_MAXLEVELS; i++) + r128ctx->regs.prim_tex_offset[i] = (CARD32)t->bufAddr; + } else { + for (i = maxLevel; i >= minLevel; i--) + r128ctx->regs.prim_tex_offset[i] = + t->image[maxLevel-i].offset + (CARD32)t->bufAddr; + } +#if USE_AGP_TEXTURES + for (i = 0; i < R128_TEX_MAXLEVELS; i++) + r128ctx->regs.prim_tex_offset[i] |= 0x02000000; +#endif + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_TEX0STATE; + break; + case 2: + if (t->regs.tex_cntl & R128_MIP_MAP_DISABLE) { + for (i = 0; i < R128_TEX_MAXLEVELS; i++) + r128ctx->regs.sec_tex_offset[i] = (CARD32)t->bufAddr; + } else { + for (i = maxLevel; i >= minLevel; i--) + r128ctx->regs.sec_tex_offset[i] = + t->image[maxLevel-i].offset + (CARD32)t->bufAddr; + } +#if USE_AGP_TEXTURES + for (i = 0; i < R128_TEX_MAXLEVELS; i++) + r128ctx->regs.sec_tex_offset[i] |= 0x02000000; +#endif + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_TEX1STATE; + break; + default: + return -1; + } + } + + /* Let the world know we've used this memory recently */ + r128UpdateTexLRU(r128ctx, t); + + /* Wait for texturing to complete */ + R128CCEWaitForIdle(r128ctx->r128Screen); + + /* Upload any images that are new */ + if (t->dirty_images) { + int num_levels = (((t->regs.size_pitch & R128_TEX_SIZE_MASK) >> + R128_TEX_SIZE_SHIFT) - + ((t->regs.size_pitch & R128_TEX_MIN_SIZE_MASK) >> + R128_TEX_MIN_SIZE_SHIFT)); + + for (i = 0; i <= num_levels; i++) + if (t->dirty_images & (1<r128Screen->agp); +#else + r128UploadTexLevel(t, i, (int)r128ctx->r128Screen->fb); +#endif + } + + r128ctx->regs.tex_cntl_c |= R128_TEX_CACHE_FLUSH; + + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_ENGINESTATE; + + /* FIXME: r128ctx->regs.pc_gui_ctlstat = R128_PC_FLUSH_GUI; */ + /* FIXME: r128ctx->dirty_context |= R128_CTX_FLUSH_PIX_CACHE; */ + } + + t->dirty_images = 0; + return 0; +} + +/* Update the hardware state for texture unit 0 */ +/* NOTE: This function is only called while holding the hardware lock */ +static void r128UpdateTex0State(r128ContextPtr r128ctx) +{ + GLcontext *ctx = r128ctx->glCtx; + r128TexObjPtr t; + struct gl_texture_object *tObj; + int i; + CARD32 tex_size_pitch, tex_combine_cntl; + + /* Only update the hardware texture state if the texture is current, + complete and enabled. */ + if (!(tObj = ctx->Texture.Unit[0].Current)) return; + if (tObj != ctx->Texture.Unit[0].CurrentD[2]) return; + if (!tObj->Complete) return; + if (!(ctx->Texture.Enabled & 0x0f)) return; + + /* If this is the first time the texture has been used, then create + a new texture object for it. */ + t = tObj->DriverData; + if (!t) t = r128CreateTexObj(r128ctx, tObj); + if (!t) return; + + /* Force any texture images to be loaded into the hardware */ + if (t->dirty_images) r128ctx->dirty |= R128_UPDATE_TEX0IMAGES; + + /* Bind texture to texture 0 unit */ + r128ctx->CurrentTexObj[0] = t; + t->bound = 1; + + if (t->memBlock) r128UpdateTexLRU(r128ctx, t); + + /* Set the texture environment state */ + /* FIXME: This only works for GL_RGB and GL_RGBA right now */ + /* FIXME: Handle GL_ALPHA, GL_LIMINANCE{_ALPHA} and GL_INTENSITY */ + switch (ctx->Texture.Unit[0].EnvMode) { + case GL_REPLACE: + switch (tObj->Image[0]->Format) { + case GL_RGB: + tex_combine_cntl = (R128_COMB_DIS | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_INT_COLOR | + R128_COMB_ALPHA_COPY_INP | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_INT_ALPHA); + break; + case GL_RGBA: + tex_combine_cntl = (R128_COMB_DIS | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_INT_COLOR | + R128_COMB_ALPHA_DIS | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_INT_ALPHA); + break; + case GL_LUMINANCE: + case GL_ALPHA: + case GL_LUMINANCE_ALPHA: + case GL_INTENSITY: + case GL_COLOR_INDEX: + default: + return; + } + break; + case GL_MODULATE: + switch (tObj->Image[0]->Format) { + case GL_RGB: + tex_combine_cntl = (R128_COMB_MODULATE | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_INT_COLOR | + R128_COMB_ALPHA_COPY_INP | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_INT_ALPHA); + break; + case GL_RGBA: + tex_combine_cntl = (R128_COMB_MODULATE | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_INT_COLOR | + R128_COMB_ALPHA_MODULATE | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_INT_ALPHA); + break; + case GL_LUMINANCE: + case GL_ALPHA: + case GL_LUMINANCE_ALPHA: + case GL_INTENSITY: + case GL_COLOR_INDEX: + default: + return; + } + break; + case GL_DECAL: + switch (tObj->Image[0]->Format) { + case GL_RGB: + tex_combine_cntl = (R128_COMB_DIS | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_INT_COLOR | + R128_COMB_ALPHA_COPY_INP | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_INT_ALPHA); + break; + case GL_RGBA: + tex_combine_cntl = (R128_COMB_BLEND_TEXTURE | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_INT_COLOR | + R128_COMB_ALPHA_COPY_INP | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_INT_ALPHA); + break; + case GL_LUMINANCE: + case GL_ALPHA: + case GL_LUMINANCE_ALPHA: + case GL_INTENSITY: + case GL_COLOR_INDEX: + default: + return; + } + break; + case GL_BLEND: + switch (tObj->Image[0]->Format) { + case GL_RGB: + tex_combine_cntl = (R128_COMB_BLEND_PREV | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_INT_COLOR | + R128_COMB_ALPHA_COPY_INP | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_INT_ALPHA); + break; + case GL_RGBA: + tex_combine_cntl = (R128_COMB_BLEND_PREV | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_INT_COLOR | + R128_COMB_ALPHA_MODULATE | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_INT_ALPHA); + break; + case GL_LUMINANCE: + case GL_ALPHA: + case GL_LUMINANCE_ALPHA: + case GL_INTENSITY: + case GL_COLOR_INDEX: + default: + return; + } + break; + default: + return; + } + + tex_size_pitch = r128ctx->regs.tex_size_pitch_c; + tex_size_pitch &= ~R128_TEX_SIZE_PITCH_MASK; + tex_size_pitch |= t->regs.size_pitch << R128_TEX_SIZE_PITCH_SHIFT; + + /* Set the primary texture state in r128ctx->regs */ + r128ctx->regs.prim_tex_cntl_c = t->regs.tex_cntl; + r128ctx->regs.prim_texture_combine_cntl_c = tex_combine_cntl; + r128ctx->regs.tex_size_pitch_c = tex_size_pitch; + r128ctx->regs.prim_texture_border_color_c = t->regs.border_color; + if (t->regs.tex_cntl & R128_MIP_MAP_DISABLE) { + for (i = 0; i < R128_TEX_MAXLEVELS; i++) + r128ctx->regs.prim_tex_offset[i] = (CARD32)t->bufAddr; + } else { + int maxLevel = ((t->regs.size_pitch & R128_TEX_SIZE_MASK) >> + R128_TEX_SIZE_SHIFT); + int minLevel = ((t->regs.size_pitch & R128_TEX_MIN_SIZE_MASK) >> + R128_TEX_MIN_SIZE_SHIFT); + for (i = maxLevel; i >= minLevel; i--) + r128ctx->regs.prim_tex_offset[i] = + t->image[maxLevel-i].offset + (CARD32)t->bufAddr; + } +#if USE_AGP_TEXTURES + for (i = 0; i < R128_TEX_MAXLEVELS; i++) + r128ctx->regs.prim_tex_offset[i] |= 0x02000000; +#endif + + /* Force loading the new state into the hardware */ + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_TEX0STATE; +} + +/* Update the hardware state for texture unit 1 */ +/* NOTE: This function is only called while holding the hardware lock */ +static void r128UpdateTex1State(r128ContextPtr r128ctx) +{ + GLcontext *ctx = r128ctx->glCtx; + r128TexObjPtr t; + struct gl_texture_object *tObj; + int i; + CARD32 tex_size_pitch, tex_combine_cntl, tex_cntl; + + /* Only update the hardware texture state if the texture is current, + complete and enabled. */ + if (!(tObj = ctx->Texture.Unit[1].Current)) return; + if (tObj != ctx->Texture.Unit[1].CurrentD[2]) return; + if (!tObj->Complete) return; + if (!(ctx->Texture.Enabled & 0xf0)) return; + + /* If this is the first time the texture has been used, then create + a new texture object for it. */ + t = tObj->DriverData; + if (!t) t = r128CreateTexObj(r128ctx, tObj); + if (!t) return; + + /* Force any texture images to be loaded into the hardware */ + if (t->dirty_images) r128ctx->dirty |= R128_UPDATE_TEX1IMAGES; + + /* Bind texture to texture 1 unit */ + r128ctx->CurrentTexObj[1] = t; + t->bound = 2; + + if (t->memBlock) r128UpdateTexLRU(r128ctx, t); + + /* Set the texture environment state */ + /* FIXME: This only works for GL_RBG and GL_RGBA right now */ + /* FIXME: Handle GL_ALPHA, GL_LIMINANCE{_ALPHA} and GL_INTENSITY */ + /* FIXME: Handle when no Tex0: i.e., !(ctx->Texture.Enabled & 0x0f) */ + switch (ctx->Texture.Unit[1].EnvMode) { + case GL_REPLACE: + switch (tObj->Image[0]->Format) { + case GL_RGB: + tex_combine_cntl = (R128_COMB_DIS | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_PREV_COLOR | + R128_COMB_ALPHA_COPY_INP | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_PREV_ALPHA); + break; + case GL_RGBA: + tex_combine_cntl = (R128_COMB_DIS | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_PREV_COLOR | + R128_COMB_ALPHA_DIS | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_PREV_ALPHA); + break; + case GL_LUMINANCE: + case GL_ALPHA: + case GL_LUMINANCE_ALPHA: + case GL_INTENSITY: + case GL_COLOR_INDEX: + default: + return; + } + break; + case GL_MODULATE: + switch (tObj->Image[0]->Format) { + case GL_RGB: + tex_combine_cntl = (R128_COMB_MODULATE | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_PREV_COLOR | + R128_COMB_ALPHA_COPY_INP | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_PREV_ALPHA); + break; + case GL_RGBA: + tex_combine_cntl = (R128_COMB_MODULATE | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_PREV_COLOR | + R128_COMB_ALPHA_MODULATE | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_PREV_ALPHA); + break; + case GL_LUMINANCE: + case GL_ALPHA: + case GL_LUMINANCE_ALPHA: + case GL_INTENSITY: + case GL_COLOR_INDEX: + default: + return; + } + break; + case GL_DECAL: + switch (tObj->Image[0]->Format) { + case GL_RGB: + tex_combine_cntl = (R128_COMB_DIS | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_PREV_COLOR | + R128_COMB_ALPHA_COPY_INP | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_PREV_ALPHA); + break; + case GL_RGBA: + tex_combine_cntl = (R128_COMB_BLEND_TEXTURE | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_PREV_COLOR | + R128_COMB_ALPHA_COPY_INP | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_PREV_ALPHA); + break; + case GL_LUMINANCE: + case GL_ALPHA: + case GL_LUMINANCE_ALPHA: + case GL_INTENSITY: + case GL_COLOR_INDEX: + default: + return; + } + break; + case GL_BLEND: + switch (tObj->Image[0]->Format) { + case GL_RGB: + tex_combine_cntl = (R128_COMB_BLEND_PREV | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_PREV_COLOR | + R128_COMB_ALPHA_COPY_INP | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_PREV_ALPHA); + break; + case GL_RGBA: + tex_combine_cntl = (R128_COMB_BLEND_PREV | + R128_COLOR_FACTOR_TEX | + R128_INPUT_FACTOR_PREV_COLOR | + R128_COMB_ALPHA_MODULATE | + R128_ALPHA_FACTOR_TEX_ALPHA | + R128_INP_FACTOR_A_PREV_ALPHA); + break; + case GL_LUMINANCE: + case GL_ALPHA: + case GL_LUMINANCE_ALPHA: + case GL_INTENSITY: + case GL_COLOR_INDEX: + default: + return; + } + break; + default: + return; + } + + tex_size_pitch = r128ctx->regs.tex_size_pitch_c; + tex_size_pitch &= ~R128_SEC_TEX_SIZE_PITCH_MASK; + tex_size_pitch |= t->regs.size_pitch << R128_SEC_TEX_SIZE_PITCH_SHIFT; + + tex_cntl = t->regs.tex_cntl | R128_SEC_SELECT_SEC_ST; + + /* Set the secondary texture state in r128ctx->regs */ + r128ctx->regs.sec_tex_cntl_c = tex_cntl; + r128ctx->regs.sec_tex_combine_cntl_c = tex_combine_cntl; + r128ctx->regs.tex_size_pitch_c = tex_size_pitch; + r128ctx->regs.sec_texture_border_color_c = t->regs.border_color; + if (t->regs.tex_cntl & R128_MIP_MAP_DISABLE) { + for (i = 0; i < R128_TEX_MAXLEVELS; i++) + r128ctx->regs.sec_tex_offset[i] = (CARD32)t->bufAddr; + } else { + int maxLevel = ((t->regs.size_pitch & R128_TEX_SIZE_MASK) >> + R128_TEX_SIZE_SHIFT); + int minLevel = ((t->regs.size_pitch & R128_TEX_MIN_SIZE_MASK) >> + R128_TEX_MIN_SIZE_SHIFT); + for (i = maxLevel; i >= minLevel; i--) + r128ctx->regs.sec_tex_offset[i] = + t->image[maxLevel-i].offset + (CARD32)t->bufAddr; + } +#if USE_AGP_TEXTURES + for (i = 0; i < R128_TEX_MAXLEVELS; i++) + r128ctx->regs.sec_tex_offset[i] |= 0x02000000; +#endif + + /* Force loading the new state into the hardware */ + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_TEX1STATE; +} + +/* Update the hardware texture state */ +/* NOTE: This function is only called while holding the hardware lock */ +void r128UpdateTextureState(r128ContextPtr r128ctx) +{ + /* Unbind any currently bound textures */ + if (r128ctx->CurrentTexObj[0]) r128ctx->CurrentTexObj[0]->bound = 0; + if (r128ctx->CurrentTexObj[1]) r128ctx->CurrentTexObj[1]->bound = 0; + r128ctx->CurrentTexObj[0] = NULL; + r128ctx->CurrentTexObj[1] = NULL; + + /* Update the texture unit 0/1 state */ + r128UpdateTex0State(r128ctx); + r128UpdateTex1State(r128ctx); +} + +/* Set the texture wrap mode */ +static void r128SetTexWrap(r128TexObjPtr t, GLenum swrap, GLenum twrap) +{ + t->regs.tex_cntl &= ~(R128_TEX_CLAMP_S_MASK | R128_TEX_CLAMP_T_MASK); + + switch (swrap) { + case GL_CLAMP: t->regs.tex_cntl |= R128_TEX_CLAMP_S_CLAMP; break; + case GL_REPEAT: t->regs.tex_cntl |= R128_TEX_CLAMP_S_WRAP; break; + default: /* ERROR!! */ return; + } + + switch (twrap) { + case GL_CLAMP: t->regs.tex_cntl |= R128_TEX_CLAMP_T_CLAMP; break; + case GL_REPEAT: t->regs.tex_cntl |= R128_TEX_CLAMP_T_WRAP; break; + default: /* ERROR!! */ return; + } +} + +/* Set the texture filter mode */ +static void r128SetTexFilter(r128TexObjPtr t, GLenum minf, GLenum magf) +{ + t->regs.tex_cntl &= ~(R128_MIN_BLEND_MASK | R128_MAG_BLEND_MASK); + + switch (minf) { + case GL_NEAREST: + t->regs.tex_cntl |= R128_MIN_BLEND_NEAREST; + break; + case GL_LINEAR: + t->regs.tex_cntl |= R128_MIN_BLEND_LINEAR; + break; + case GL_NEAREST_MIPMAP_NEAREST: + t->regs.tex_cntl |= R128_MIN_BLEND_MIPNEAREST; + break; + case GL_LINEAR_MIPMAP_NEAREST: + t->regs.tex_cntl |= R128_MIN_BLEND_LINEARMIPNEAREST; + break; + case GL_NEAREST_MIPMAP_LINEAR: + t->regs.tex_cntl |= R128_MIN_BLEND_MIPLINEAR; + break; + case GL_LINEAR_MIPMAP_LINEAR: + t->regs.tex_cntl |= R128_MIN_BLEND_LINEARMIPLINEAR; + break; + default: /* ERROR!! */ return; + } + + switch (magf) { + case GL_NEAREST: + t->regs.tex_cntl |= R128_MAG_BLEND_NEAREST; + break; + case GL_LINEAR: + t->regs.tex_cntl |= R128_MAG_BLEND_LINEAR; + break; + } +} + +/* Set the texture border color */ +static void r128SetTexBorderColor(r128TexObjPtr t, GLubyte c[4]) +{ + t->regs.border_color = r128PackColor(32, c[0], c[1], c[2], c[3]); +} + +/* Set the texture environment state */ static void r128DDTexEnv(GLcontext *ctx, GLenum pname, const GLfloat *param) { + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + struct gl_texture_unit *texUnit; + GLubyte c[4]; + CARD32 col; + + switch (pname) { + case GL_TEXTURE_ENV_MODE: + /* TexEnv modes are handled in UpdateTextureState */ + R128_FLUSH_VB(r128ctx); + r128ctx->dirty |= R128_UPDATE_TEXSTATE; + break; + case GL_TEXTURE_ENV_COLOR: + texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + FLOAT_RGBA_TO_UBYTE_RGBA(texUnit->EnvColor, c); + col = r128PackColor(32, c[0], c[1], c[2], c[3]); + if (r128ctx->regs.constant_color_c != col) { + R128_FLUSH_VB(r128ctx); + r128ctx->regs.constant_color_c = col; + r128ctx->dirty |= R128_UPDATE_CONTEXT; + r128ctx->dirty_context |= R128_CTX_TEXENVSTATE; + } + break; + default: + return; + } } +/* Upload a new texture image */ static void r128DDTexImage(GLcontext *ctx, GLenum target, struct gl_texture_object *tObj, GLint level, GLint internalFormat, const struct gl_texture_image *image) { + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + r128TexObjPtr t; + + if (target != GL_TEXTURE_2D) return; + if (level >= R128_TEX_MAXLEVELS) return; + + t = (r128TexObjPtr)tObj->DriverData; + if (t) { + if (t->bound) R128_FLUSH_VB(r128ctx); + + /* Destroy the old texture, and upload a new one. The actual + uploading of the texture image occurs in the UploadTexLevel + function. */ + r128DestroyTexObj(r128ctx, t); + r128ctx->dirty |= R128_UPDATE_TEXSTATE; + } } +/* Upload a new texture sub-image */ static void r128DDTexSubImage(GLcontext *ctx, GLenum target, struct gl_texture_object *tObj, GLint level, GLint xoffset, GLint yoffset, @@ -54,30 +1063,113 @@ static void r128DDTexSubImage(GLcontext *ctx, GLenum target, GLint internalFormat, const struct gl_texture_image *image) { + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + r128TexObjPtr t; + + if (target != GL_TEXTURE_2D) return; + if (level >= R128_TEX_MAXLEVELS) return; + + t = (r128TexObjPtr)tObj->DriverData; + if (t) { + if (t->bound) R128_FLUSH_VB(r128ctx); + + /* Destroy the old texture, and upload a new one. The actual + uploading of the texture image occurs in the UploadTexLevel + function. */ + r128DestroyTexObj(r128ctx, t); + tObj->DriverData = NULL; + r128ctx->dirty |= R128_UPDATE_TEXSTATE; + } } +/* Set the texture parameter state */ static void r128DDTexParameter(GLcontext *ctx, GLenum target, struct gl_texture_object *tObj, GLenum pname, const GLfloat *params) { + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + r128TexObjPtr t = (r128TexObjPtr)tObj->DriverData; + + if (!t) return; + if (target != GL_TEXTURE_2D) return; + + switch (pname) { + case GL_TEXTURE_MIN_FILTER: + case GL_TEXTURE_MAG_FILTER: + if (t->bound) R128_FLUSH_VB(r128ctx); + + r128SetTexFilter(t, tObj->MinFilter, tObj->MagFilter); + break; + + case GL_TEXTURE_WRAP_S: + case GL_TEXTURE_WRAP_T: + if (t->bound) R128_FLUSH_VB(r128ctx); + + r128SetTexWrap(t, tObj->WrapS, tObj->WrapT); + break; + + case GL_TEXTURE_BORDER_COLOR: + if (t->bound) R128_FLUSH_VB(r128ctx); + + r128SetTexBorderColor(t, tObj->BorderColor); + break; + + default: + return; + } + + r128ctx->dirty |= R128_UPDATE_TEXSTATE; } +/* Bind a texture to the currently active texture unit */ static void r128DDBindTexture(GLcontext *ctx, GLenum target, struct gl_texture_object *tObj) { + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + + R128_FLUSH_VB(r128ctx); + + /* Unbind the old texture */ + if (r128ctx->CurrentTexObj[ctx->Texture.CurrentUnit]) { + r128ctx->CurrentTexObj[ctx->Texture.CurrentUnit]->bound = 0; + r128ctx->CurrentTexObj[ctx->Texture.CurrentUnit] = NULL; + } + + /* The actualy binding occurs in the Tex[01]UpdateState function */ + r128ctx->dirty |= R128_UPDATE_TEXSTATE; } +/* Remove texture from AGP/local texture memory */ static void r128DDDeleteTexture(GLcontext *ctx, struct gl_texture_object *tObj) { + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + r128TexObjPtr t = (r128TexObjPtr)tObj->DriverData; + + if (t) { + if (t->bound) { + R128_FLUSH_VB(r128ctx); + + r128ctx->CurrentTexObj[t->bound-1] = 0; + r128ctx->dirty |= R128_UPDATE_TEXSTATE; + } + + r128DestroyTexObj(r128ctx, t); + tObj->DriverData = NULL; + } } +/* Determine if a texture is currently residing in either AGP/local + texture memory */ static GLboolean r128DDIsTextureResident(GLcontext *ctx, - struct gl_texture_object *t) + struct gl_texture_object *tObj) { - return GL_TRUE; + r128TexObjPtr t = (r128TexObjPtr)tObj->DriverData; + + return t && t->memBlock; } +/* Initialize the driver's texture functions */ void r128DDInitTextureFuncs(GLcontext *ctx) { ctx->Driver.TexEnv = r128DDTexEnv; diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_tex.h b/xc/lib/GL/mesa/src/drv/r128/r128_tex.h index 6543435a5..ff12f0a0d 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_tex.h +++ b/xc/lib/GL/mesa/src/drv/r128/r128_tex.h @@ -37,6 +37,13 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #ifdef GLX_DIRECT_RENDERING +extern void r128ResetGlobalLRU(r128ContextPtr r128ctx); +extern void r128TexturesGone(r128ContextPtr r128ctx, + int offset, int size, int in_use); +extern int r128UploadTexImages(r128ContextPtr r128ctx, r128TexObjPtr t); +extern void r128UpdateTextureState(r128ContextPtr r128ctx); +extern void r128DestroyTexObj(r128ContextPtr r128ctx, r128TexObjPtr t); + extern void r128DDInitTextureFuncs(GLcontext *ctx); #endif diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_texobj.h b/xc/lib/GL/mesa/src/drv/r128/r128_texobj.h new file mode 100644 index 000000000..6b94d90d5 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/r128/r128_texobj.h @@ -0,0 +1,81 @@ +/* $XFree86$ */ +/************************************************************************** + +Copyright 1999, 2000 ATI Technologies Inc. and Precision Insight, Inc., + Cedar Park, Texas. +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 +on 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 +ATI, PRECISION INSIGHT AND/OR THEIR 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. + +**************************************************************************/ + +/* + * Authors: + * Kevin E. Martin + * + */ + +#ifndef _R128_TEXOBJ_H_ +#define _R128_TEXOBJ_H_ + +#include "mm.h" + +#define R128_TEX_MAXLEVELS 11 + +/* Setup registers for each texture */ +typedef struct { + CARD32 tex_cntl; + CARD32 size_pitch; + CARD32 border_color; +} r128TextureRegs; + +/* Individual texture image information */ +typedef struct { + int offset; /* Offset into locally shared texture space (i.e., + relative to bufAddr (below) */ + int width; /* Width of texture image */ +} r128TexImage; + +typedef struct r128_tex_obj r128TexObj, *r128TexObjPtr; + +/* Texture object in locally shared texture space */ +struct r128_tex_obj { + r128TexObjPtr next, prev; + + struct gl_texture_object *tObj; /* Mesa texture object */ + + PMemBlock memBlock; /* Memory block containing texture */ + unsigned char *bufAddr; /* Offset to start of locally + shared texture block */ + + CARD32 dirty_images; /* Flags for whether or not + images need to be uploaded to + local or AGP texture space */ + int bound; /* Texture unit currently bound to */ + r128TexImage image[R128_TEX_MAXLEVELS]; /* Image data for all + mipmap levels */ + int totalSize; /* Total size of the texture + including all mipmap levels */ + int internFormat; /* Internal format used to store + texture on card */ + r128TextureRegs regs; /* Setup regs for texture */ +}; + +#endif /* _R128_TEXOBJ_H_ */ diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_tris.c b/xc/lib/GL/mesa/src/drv/r128/r128_tris.c index 58e2b5980..26753de78 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_tris.c +++ b/xc/lib/GL/mesa/src/drv/r128/r128_tris.c @@ -48,24 +48,66 @@ static quad_func quad_tab[0x40]; /* only 0x20 actually used */ static line_func line_tab[0x40]; /* less than 0x20 used */ static points_func points_tab[0x40]; /* less than 0x20 used */ -static void r128DrawTriangle(r128ContextPtr r128ctx, - r128_vertex *v0, - r128_vertex *v1, - r128_vertex *v2) +/* Draw a triangle from the vertices in the vertex buffer */ +void r128DrawTriangle(r128ContextPtr r128ctx, + r128_vertex *v0, + r128_vertex *v1, + r128_vertex *v2) { +#if USE_VERTEX_BUFFERS + r128_vertex *vbptr = r128CCEAllocVBSpace(r128ctx, 3); + + *vbptr++ = *v0; + *vbptr++ = *v1; + *vbptr++ = *v2; +#else + unsigned char *R128MMIO = r128ctx->r128Screen->mmio; + + BEGIN_CLIP_LOOP(r128ctx); + +#if USE_RHW2 + R128CCE_WAIT_LOCKED(36); + R128CCE3(R128_CCE_PACKET3_3D_RNDR_GEN_PRIM, 34); +#else + R128CCE_WAIT_LOCKED(33); + R128CCE3(R128_CCE_PACKET3_3D_RNDR_GEN_PRIM, 31); +#endif + R128CCE(R128_FULL_VERTEX_FORMAT); + R128CCE(R128_CCE_VC_CNTL_PRIM_TYPE_TRI_LIST | + R128_CCE_VC_CNTL_PRIM_WALK_RING | + (3 << R128_CCE_VC_CNTL_NUM_SHIFT)); + + R128CCE_SEND_VERTEX(v0); + R128CCE_SEND_VERTEX(v1); + R128CCE_SEND_VERTEX(v2); + + R128CCE_END_LOCKED(); + + END_CLIP_LOOP(r128ctx); +#endif } -static void r128DrawLine(r128ContextPtr r128ctx, - r128_vertex *tmp0, r128_vertex *tmp1, - float width) +/* Draw a line from the vertices in the vertex buffer */ +void r128DrawLine(r128ContextPtr r128ctx, + r128_vertex *tmp0, r128_vertex *tmp1, + float width) { } -static void r128DrawPoint(r128ContextPtr r128ctx, - r128_vertex *tmp, float sz) +/* Draw a point from the vertices in the vertex buffer */ +void r128DrawPoint(r128ContextPtr r128ctx, + r128_vertex *tmp, float sz) { } +#define R128_COLOR(to, from) \ +do { \ + (to)[0] = (from)[2]; \ + (to)[1] = (from)[1]; \ + (to)[2] = (from)[0]; \ + (to)[3] = (from)[3]; \ +} while (0) + #define IND (0) #define TAG(x) x #include "r128_tritmp.h" @@ -74,12 +116,46 @@ static void r128DrawPoint(r128ContextPtr r128ctx, #define TAG(x) x##_flat #include "r128_tritmp.h" +#define IND (R128_OFFSET_BIT) +#define TAG(x) x##_offset +#include "r128_tritmp.h" + +#define IND (R128_OFFSET_BIT | R128_FLAT_BIT) +#define TAG(x) x##_offset_flat +#include "r128_tritmp.h" + +#define IND (R128_TWOSIDE_BIT) +#define TAG(x) x##_twoside +#include "r128_tritmp.h" + +#define IND (R128_TWOSIDE_BIT | R128_FLAT_BIT) +#define TAG(x) x##_twoside_flat +#include "r128_tritmp.h" + +#define IND (R128_TWOSIDE_BIT | R128_OFFSET_BIT) +#define TAG(x) x##_twoside_offset +#include "r128_tritmp.h" + +#define IND (R128_TWOSIDE_BIT | R128_OFFSET_BIT | R128_FLAT_BIT) +#define TAG(x) x##_twoside_offset_flat +#include "r128_tritmp.h" + +/* Initialize the table of points, line and triangle drawing functions */ void r128TriangleFuncsInit(void) { init(); init_flat(); + init_offset(); + init_offset_flat(); + init_twoside(); + init_twoside_flat(); + init_twoside_offset(); + init_twoside_offset_flat(); } +/* Setup the Point, Line, Triangle and Quad functions based on the + current rendering state. Wherever possible, use the hardware to + render the primitive. Otherwise, fallback to software rendering. */ void r128ChooseRenderState(GLcontext *ctx) { r128ContextPtr r128ctx = R128_CONTEXT(ctx); @@ -92,25 +168,17 @@ void r128ChooseRenderState(GLcontext *ctx) CARD32 shared = 0; CARD32 fallback = R128_FALLBACK_BIT; -#if 0 - shared = fallback; /* Make everything a fallback */ -#endif - -#if 0 - fallback = 0; /* Turn off all fallbacks */ -#endif + if (r128ctx->SWfallbackDisable) fallback = 0; /* No fallbacks */ + if (r128ctx->SWonly) shared = fallback; /* Everything's a fallback */ if (flags & DD_FLATSHADE) shared |= R128_FLAT_BIT; if (flags & DD_MULTIDRAW) shared |= fallback; if (flags & DD_SELECT) shared |= R128_FALLBACK_BIT; if (flags & DD_FEEDBACK) shared |= R128_FALLBACK_BIT; + /* Setup PointFunc */ index = shared; -#if 1 if (flags & DD_POINT_SMOOTH) index |= fallback; -#else - if (flags & DD_POINT_SMOOTH) index |= R128_ANTIALIAS_BIT; -#endif if (flags & DD_POINT_ATTEN) index |= fallback; r128ctx->RenderIndex = index; @@ -118,12 +186,9 @@ void r128ChooseRenderState(GLcontext *ctx) if (index & R128_FALLBACK_BIT) r128ctx->IndirectTriangles |= DD_POINT_SW_RASTERIZE; + /* Setup LineFunc */ index = shared; -#if 1 if (flags & DD_LINE_SMOOTH) index |= fallback; -#else - if (flags & DD_LINE_SMOOTH) index |= R128_ANTIALIAS_BIT; -#endif if (flags & DD_LINE_STIPPLE) index |= fallback; r128ctx->RenderIndex |= index; @@ -131,14 +196,16 @@ void r128ChooseRenderState(GLcontext *ctx) if (index & R128_FALLBACK_BIT) r128ctx->IndirectTriangles |= DD_LINE_SW_RASTERIZE; + /* Setup TriangleFunc and QuadFunc */ index = shared; -#if 1 if (flags & DD_TRI_SMOOTH) index |= fallback; +#if 1 + if (flags & DD_TRI_OFFSET) index |= fallback; + if (flags & DD_TRI_LIGHT_TWOSIDE) index |= fallback; #else - if (flags & DD_TRI_SMOOTH) index |= R128_ANTIALIAS_BIT; -#endif if (flags & DD_TRI_OFFSET) index |= R128_OFFSET_BIT; if (flags & DD_TRI_LIGHT_TWOSIDE) index |= R128_TWOSIDE_BIT; +#endif if (flags & DD_TRI_UNFILLED) index |= fallback; if (flags & DD_TRI_STIPPLE) index |= fallback; diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_tris.h b/xc/lib/GL/mesa/src/drv/r128/r128_tris.h index ba98eb3e7..91f30d80b 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_tris.h +++ b/xc/lib/GL/mesa/src/drv/r128/r128_tris.h @@ -37,6 +37,8 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #ifdef GLX_DIRECT_RENDERING +#include "r128_vb.h" + #define R128_ANTIALIAS_BIT 0x00 /* ignored for now, no fallback */ #define R128_FLAT_BIT 0x01 #define R128_OFFSET_BIT 0x02 @@ -47,6 +49,16 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #define R128_SELECT_BIT 0x40 #define R128_POINT_PARAM_BIT 0x80 /* not needed? */ +extern void r128DrawTriangle(r128ContextPtr r128ctx, + r128_vertex *v0, + r128_vertex *v1, + r128_vertex *v2); +extern void r128DrawLine(r128ContextPtr r128ctx, + r128_vertex *tmp0, r128_vertex *tmp1, + float width); +extern void r128DrawPoint(r128ContextPtr r128ctx, + r128_vertex *tmp, float sz); + extern void r128ChooseRenderState(GLcontext *ctx); extern void r128TriangleFuncsInit(void); diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_tritmp.h b/xc/lib/GL/mesa/src/drv/r128/r128_tritmp.h index ff0804c4e..5cd66a8cd 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_tritmp.h +++ b/xc/lib/GL/mesa/src/drv/r128/r128_tritmp.h @@ -33,9 +33,11 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. */ #if !defined(TAG) || !defined(IND) - this is an error; + this is an error #endif +/* Draw a single triangle. Note that the device-dependent vertex data + might need to be changed based on the render state. */ static void TAG(triangle)(GLcontext *ctx, GLuint e0, GLuint e1, GLuint e2, GLuint pv) @@ -101,60 +103,153 @@ static void TAG(triangle)(GLcontext *ctx, } #endif - BEGIN_CLIP_LOOP(r128ctx); + if (r128ctx->regs.tex_cntl_c & (R128_TEXMAP_ENABLE | + R128_SEC_TEXMAP_ENABLE)) { + BEGIN_CLIP_LOOP(r128ctx); - R128CCE_BEGIN_LOCKED(15); - R128CCE3(R128_CCE_PACKET3_3D_RNDR_GEN_PRIM, 13); - R128CCE(R128_CCE_VC_FRMT_DIFFUSE_ARGB); - R128CCE(R128_CCE_VC_CNTL_PRIM_TYPE_TRI_LIST | - R128_CCE_VC_CNTL_PRIM_WALK_RING | - (3 << R128_CCE_VC_CNTL_NUM_SHIFT)); +#if USE_RHW2 + R128CCE_WAIT_LOCKED(36); + R128CCE3(R128_CCE_PACKET3_3D_RNDR_GEN_PRIM, 34); +#else + R128CCE_WAIT_LOCKED(33); + R128CCE3(R128_CCE_PACKET3_3D_RNDR_GEN_PRIM, 31); +#endif + R128CCE(R128_FULL_VERTEX_FORMAT); + R128CCE(R128_CCE_VC_CNTL_PRIM_TYPE_TRI_LIST | + R128_CCE_VC_CNTL_PRIM_WALK_RING | + (3 << R128_CCE_VC_CNTL_NUM_SHIFT)); - R128CCEF(v0->x); - R128CCEF(v0->y); + R128CCEF(v0->x); + R128CCEF(v0->y); #if (IND & R128_OFFSET_BIT) - R128CCEF(v0->z + offset); + R128CCEF(v0->z + offset); #else - R128CCEF(v0->z); + R128CCEF(v0->z); #endif + R128CCEF(v0->rhw); #if (IND & (R128_FLAT_BIT | R128_TWOSIDE_BIT)) - R128CCE(c0); + R128CCE(c0); #else - R128CCE(*(int *)&v0->dif_argb); + R128CCE(*(int *)&v0->dif_argb); +#endif + R128CCE(*(int *)&v0->spec_frgb); + + R128CCEF(v0->tu0); + R128CCEF(v0->tv0); + R128CCEF(v0->tu1); + R128CCEF(v0->tv1); +#if USE_RHW2 + R128CCEF(v0->rhw2); #endif - R128CCEF(v1->x); - R128CCEF(v1->y); + R128CCEF(v1->x); + R128CCEF(v1->y); #if (IND & R128_OFFSET_BIT) - R128CCEF(v1->z + offset); + R128CCEF(v1->z + offset); #else - R128CCEF(v1->z); + R128CCEF(v1->z); #endif + R128CCEF(v1->rhw); #if (IND & (R128_FLAT_BIT | R128_TWOSIDE_BIT)) - R128CCE(c1); + R128CCE(c1); #else - R128CCE(*(int *)&v1->dif_argb); + R128CCE(*(int *)&v1->dif_argb); +#endif + R128CCE(*(int *)&v1->spec_frgb); + + R128CCEF(v1->tu0); + R128CCEF(v1->tv0); + R128CCEF(v1->tu1); + R128CCEF(v1->tv1); +#if USE_RHW2 + R128CCEF(v1->rhw2); #endif - R128CCEF(v2->x); - R128CCEF(v2->y); + R128CCEF(v2->x); + R128CCEF(v2->y); #if (IND & R128_OFFSET_BIT) - R128CCEF(v2->z + offset); + R128CCEF(v2->z + offset); #else - R128CCEF(v2->z); + R128CCEF(v2->z); #endif + R128CCEF(v2->rhw); #if (IND & (R128_FLAT_BIT | R128_TWOSIDE_BIT)) - R128CCE(c2); + R128CCE(c2); #else - R128CCE(*(int *)&v2->dif_argb); + R128CCE(*(int *)&v2->dif_argb); +#endif + R128CCE(*(int *)&v2->spec_frgb); + + R128CCEF(v2->tu0); + R128CCEF(v2->tv0); + R128CCEF(v2->tu1); + R128CCEF(v2->tv1); +#if USE_RHW2 + R128CCEF(v2->rhw2); #endif - R128CCE_END_LOCKED(); + R128CCE_END_LOCKED(); - END_CLIP_LOOP(r128ctx); + END_CLIP_LOOP(r128ctx); + } else { + BEGIN_CLIP_LOOP(r128ctx); + + R128CCE_WAIT_LOCKED(15); + R128CCE3(R128_CCE_PACKET3_3D_RNDR_GEN_PRIM, 13); + R128CCE(R128_CCE_VC_FRMT_DIFFUSE_ARGB); + R128CCE(R128_CCE_VC_CNTL_PRIM_TYPE_TRI_LIST | + R128_CCE_VC_CNTL_PRIM_WALK_RING | + (3 << R128_CCE_VC_CNTL_NUM_SHIFT)); + + R128CCEF(v0->x); + R128CCEF(v0->y); +#if (IND & R128_OFFSET_BIT) + R128CCEF(v0->z + offset); +#else + R128CCEF(v0->z); +#endif + +#if (IND & (R128_FLAT_BIT | R128_TWOSIDE_BIT)) + R128CCE(c0); +#else + R128CCE(*(int *)&v0->dif_argb); +#endif + + R128CCEF(v1->x); + R128CCEF(v1->y); +#if (IND & R128_OFFSET_BIT) + R128CCEF(v1->z + offset); +#else + R128CCEF(v1->z); +#endif + +#if (IND & (R128_FLAT_BIT | R128_TWOSIDE_BIT)) + R128CCE(c1); +#else + R128CCE(*(int *)&v1->dif_argb); +#endif + + R128CCEF(v2->x); + R128CCEF(v2->y); +#if (IND & R128_OFFSET_BIT) + R128CCEF(v2->z + offset); +#else + R128CCEF(v2->z); +#endif + +#if (IND & (R128_FLAT_BIT | R128_TWOSIDE_BIT)) + R128CCE(c2); +#else + R128CCE(*(int *)&v2->dif_argb); +#endif + + R128CCE_END_LOCKED(); + + END_CLIP_LOOP(r128ctx); + } } static void TAG(quad)(GLcontext *ctx, @@ -167,15 +262,17 @@ static void TAG(quad)(GLcontext *ctx, #if ((IND & ~R128_FLAT_BIT) == 0) +/* Draw a single line. Note that the device-dependent vertex data might + need to be changed based on the render state. */ static void TAG(line)(GLcontext *ctx, GLuint v0, GLuint v1, GLuint pv) { - r128ContextPtr r128ctx = R128_CONTEXT(ctx); - r128VertexPtr r128verts = R128_DRIVER_DATA(ctx->VB)->verts; - r128_vertex tmp0 = r128verts[v0].v; - r128_vertex tmp1 = r128verts[v1].v; - float width = ctx->Line.Width; + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + r128VertexPtr r128verts = R128_DRIVER_DATA(ctx->VB)->verts; + r128_vertex tmp0 = r128verts[v0].v; + r128_vertex tmp1 = r128verts[v1].v; + float width = ctx->Line.Width; if (IND & R128_FLAT_BIT) { *(int *)&tmp1.dif_argb = @@ -190,6 +287,8 @@ static void TAG(line)(GLcontext *ctx, END_CLIP_LOOP(r128ctx); } +/* Draw a set of points. Note that the device-dependent vertex data + might need to be changed based on the render state. */ static void TAG(points)(GLcontext *ctx, GLuint first, GLuint last) { @@ -199,10 +298,6 @@ static void TAG(points)(GLcontext *ctx, GLfloat sz = ctx->Point.Size * 0.5; int i; - /* Culling is disabled automatically via. the - * ctx->Driver.ReducedPrimitiveChange() callback. - */ - BEGIN_CLIP_LOOP(r128ctx); for(i = first; i <= last; i++) { @@ -217,6 +312,7 @@ static void TAG(points)(GLcontext *ctx, #endif +/* Initialize the table of primitives to render. */ static void TAG(init)(void) { tri_tab[IND] = TAG(triangle); diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_vb.c b/xc/lib/GL/mesa/src/drv/r128/r128_vb.c index e3062a603..af271f50f 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_vb.c +++ b/xc/lib/GL/mesa/src/drv/r128/r128_vb.c @@ -36,20 +36,24 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #include "r128_mesa.h" #include "r128_xmesa.h" #include "r128_context.h" +#include "r128_lock.h" +#include "r128_reg.h" +#include "r128_cce.h" +#include "r128_state.h" #include "r128_vb.h" #include "stages.h" #define TEX0 \ do { \ - v->v.tu1 = tc0[i][0]; \ - v->v.tv1 = tc0[i][1]; \ + v->v.tu0 = tc0[i][0]; \ + v->v.tv0 = tc0[i][1]; \ } while (0) #define TEX1 \ do { \ - v->v.tu2 = tc1[i][0]; \ - v->v.tv2 = tc1[i][1]; \ + v->v.tu1 = tc1[i][0]; \ + v->v.tv1 = tc1[i][1]; \ } while (0) #define SPC \ @@ -75,6 +79,11 @@ do { \ v->v.dif_argb.b = col[2]; \ } while (0) +#if 1 +/* FIXME: These are handled by the Rage 128 */ +#define TEX0_4 +#define TEX1_4 +#else #define TEX0_4 \ do { \ if (VB->TexCoordPtr[0]->size == 4) { \ @@ -83,22 +92,32 @@ do { \ for (i = start; i < end; i++, v++) { \ float oow = 1.0 / tc[i][3]; \ v->v.rhw *= tc[i][3]; \ - v->v.tu1 *= oow; \ - v->v.tv1 *= oow; \ + v->v.tu0 *= oow; \ + v->v.tv0 *= oow; \ } \ } \ +} while (0) + +#if USE_RHW2 +#define TEX1_4 \ +do { \ if (VB->TexCoordPtr[1]->size == 4) { \ GLfloat (*tc)[4] = VB->TexCoordPtr[1]->data; \ v = &(R128_DRIVER_DATA(VB)->verts[start]); \ for (i = start; i < end; i++, v++) { \ float oow = 1.0 / tc[i][3]; \ v->v.rhw2 *= tc[i][3]; \ - v->v.tu2 *= oow; \ - v->v.tv2 *= oow; \ + v->v.tu1 *= oow; \ + v->v.tv1 *= oow; \ } \ } \ } while (0) +#else +#define TEX1_4 +#endif +#endif +#if USE_RHW2 #define COORD \ do { \ GLfloat *win = VB->Win.data[i]; \ @@ -107,10 +126,21 @@ do { \ v->v.z = (1.0/0x10000) * win[2]; \ v->v.rhw = v->v.rhw2 = win[3]; \ } while (0) +#else +#define COORD \ +do { \ + GLfloat *win = VB->Win.data[i]; \ + v->v.x = win[0]; \ + v->v.y = r128height - win[1]; \ + v->v.z = (1.0/0x10000) * win[2]; \ + v->v.rhw = win[3]; \ +} while (0) +#endif #define NOP -#define SETUPFUNC(name,win,col,tex0,tex1,tex0_4,spec,fog) \ +/* Setup the r128 vertex buffer entries */ +#define SETUPFUNC(name,win,col,tex0,tex1,tex0_4,tex1_4,spec,fog) \ static void name(struct vertex_buffer *VB, GLuint start, GLuint end) \ { \ r128ContextPtr r128ctx = R128_CONTEXT(VB->ctx); \ @@ -154,43 +184,56 @@ static void name(struct vertex_buffer *VB, GLuint start, GLuint end) \ col; \ } \ tex0_4; \ + tex1_4; \ } -SETUPFUNC(rs_wt0, COORD, NOP, TEX0, NOP, TEX0_4, NOP, NOP) -SETUPFUNC(rs_wt0t1, COORD, NOP, TEX0, TEX1, TEX0_4, NOP, NOP) -SETUPFUNC(rs_wft0, COORD, NOP, TEX0, NOP, TEX0_4, NOP, FOG) -SETUPFUNC(rs_wft0t1, COORD, NOP, TEX0, TEX1, TEX0_4, NOP, FOG) -SETUPFUNC(rs_wg, COORD, COL, NOP, NOP, NOP, NOP, NOP) -SETUPFUNC(rs_wgs, COORD, COL, NOP, NOP, NOP, SPC, NOP) -SETUPFUNC(rs_wgt0, COORD, COL, TEX0, NOP, TEX0_4, NOP, NOP) -SETUPFUNC(rs_wgt0t1, COORD, COL, TEX0, TEX1, TEX0_4, NOP, NOP) -SETUPFUNC(rs_wgst0, COORD, COL, TEX0, NOP, TEX0_4, SPC, NOP) -SETUPFUNC(rs_wgst0t1, COORD, COL, TEX0, TEX1, TEX0_4, SPC, NOP) -SETUPFUNC(rs_wgf, COORD, COL, NOP, NOP, NOP, NOP, FOG) -SETUPFUNC(rs_wgfs, COORD, COL, NOP, NOP, NOP, SPC, FOG) -SETUPFUNC(rs_wgft0, COORD, COL, TEX0, NOP, TEX0_4, NOP, FOG) -SETUPFUNC(rs_wgft0t1, COORD, COL, TEX0, TEX1, TEX0_4, NOP, FOG) -SETUPFUNC(rs_wgfst0, COORD, COL, TEX0, NOP, TEX0_4, SPC, FOG) -SETUPFUNC(rs_wgfst0t1, COORD, COL, TEX0, TEX1, TEX0_4, SPC, FOG) - -SETUPFUNC(rs_t0, NOP, NOP, TEX0, NOP, TEX0_4, NOP, NOP) -SETUPFUNC(rs_t0t1, NOP, NOP, TEX0, TEX1, TEX0_4, NOP, NOP) -SETUPFUNC(rs_f, NOP, NOP, NOP, NOP, NOP, NOP, FOG) -SETUPFUNC(rs_ft0, NOP, NOP, TEX0, NOP, TEX0_4, NOP, FOG) -SETUPFUNC(rs_ft0t1, NOP, NOP, TEX0, TEX1, TEX0_4, NOP, FOG) -SETUPFUNC(rs_g, NOP, COL, NOP, NOP, NOP, NOP, NOP) -SETUPFUNC(rs_gs, NOP, COL, NOP, NOP, NOP, SPC, NOP) -SETUPFUNC(rs_gt0, NOP, COL, TEX0, NOP, TEX0_4, NOP, NOP) -SETUPFUNC(rs_gt0t1, NOP, COL, TEX0, TEX1, TEX0_4, NOP, NOP) -SETUPFUNC(rs_gst0, NOP, COL, TEX0, NOP, TEX0_4, SPC, NOP) -SETUPFUNC(rs_gst0t1, NOP, COL, TEX0, TEX1, TEX0_4, SPC, NOP) -SETUPFUNC(rs_gf, NOP, COL, NOP, NOP, NOP, NOP, FOG) -SETUPFUNC(rs_gfs, NOP, COL, NOP, NOP, NOP, SPC, FOG) -SETUPFUNC(rs_gft0, NOP, COL, TEX0, NOP, TEX0_4, NOP, FOG) -SETUPFUNC(rs_gft0t1, NOP, COL, TEX0, TEX1, TEX0_4, NOP, FOG) -SETUPFUNC(rs_gfst0, NOP, COL, TEX0, NOP, TEX0_4, SPC, FOG) -SETUPFUNC(rs_gfst0t1, NOP, COL, TEX0, TEX1, TEX0_4, SPC, FOG) +SETUPFUNC(rs_wt0, COORD, NOP, TEX0, NOP, TEX0_4, NOP, NOP, NOP) +SETUPFUNC(rs_wt1, COORD, NOP, NOP, TEX1, NOP, TEX1_4, NOP, NOP) +SETUPFUNC(rs_wt0t1, COORD, NOP, TEX0, TEX1, TEX0_4, TEX1_4, NOP, NOP) +SETUPFUNC(rs_wft0, COORD, NOP, TEX0, NOP, TEX0_4, NOP, NOP, FOG) +SETUPFUNC(rs_wft1, COORD, NOP, NOP, TEX1, NOP, TEX1_4, NOP, FOG) +SETUPFUNC(rs_wft0t1, COORD, NOP, TEX0, TEX1, TEX0_4, TEX1_4, NOP, FOG) +SETUPFUNC(rs_wg, COORD, COL, NOP, NOP, NOP, NOP, NOP, NOP) +SETUPFUNC(rs_wgs, COORD, COL, NOP, NOP, NOP, NOP, SPC, NOP) +SETUPFUNC(rs_wgt0, COORD, COL, TEX0, NOP, TEX0_4, NOP, NOP, NOP) +SETUPFUNC(rs_wgt1, COORD, COL, NOP, TEX1, NOP, TEX1_4, NOP, NOP) +SETUPFUNC(rs_wgt0t1, COORD, COL, TEX0, TEX1, TEX0_4, TEX1_4, NOP, NOP) +SETUPFUNC(rs_wgst0, COORD, COL, TEX0, NOP, TEX0_4, NOP, SPC, NOP) +SETUPFUNC(rs_wgst1, COORD, COL, NOP, TEX1, NOP, TEX1_4, SPC, NOP) +SETUPFUNC(rs_wgst0t1, COORD, COL, TEX0, TEX1, TEX0_4, TEX1_4, SPC, NOP) +SETUPFUNC(rs_wgf, COORD, COL, NOP, NOP, NOP, NOP, NOP, FOG) +SETUPFUNC(rs_wgfs, COORD, COL, NOP, NOP, NOP, NOP, SPC, FOG) +SETUPFUNC(rs_wgft0, COORD, COL, TEX0, NOP, TEX0_4, NOP, NOP, FOG) +SETUPFUNC(rs_wgft1, COORD, COL, NOP, TEX1, NOP, TEX1_4, NOP, FOG) +SETUPFUNC(rs_wgft0t1, COORD, COL, TEX0, TEX1, TEX0_4, TEX1_4, NOP, FOG) +SETUPFUNC(rs_wgfst0, COORD, COL, TEX0, NOP, TEX0_4, NOP, SPC, FOG) +SETUPFUNC(rs_wgfst1 , COORD, COL, NOP, TEX1, NOP, TEX1_4, SPC, FOG) +SETUPFUNC(rs_wgfst0t1, COORD, COL, TEX0, TEX1, TEX0_4, TEX1_4, SPC, FOG) + +SETUPFUNC(rs_t0, NOP, NOP, TEX0, NOP, TEX0_4, NOP, NOP, NOP) +SETUPFUNC(rs_t1, NOP, NOP, NOP, TEX1, NOP, TEX1_4, NOP, NOP) +SETUPFUNC(rs_t0t1, NOP, NOP, TEX0, TEX1, TEX0_4, TEX1_4, NOP, NOP) +SETUPFUNC(rs_f, NOP, NOP, NOP, NOP, NOP, NOP, NOP, FOG) +SETUPFUNC(rs_ft0, NOP, NOP, TEX0, NOP, TEX0_4, NOP, NOP, FOG) +SETUPFUNC(rs_ft1, NOP, NOP, NOP, TEX1, NOP, TEX1_4, NOP, FOG) +SETUPFUNC(rs_ft0t1, NOP, NOP, TEX0, TEX1, TEX0_4, TEX1_4, NOP, FOG) +SETUPFUNC(rs_g, NOP, COL, NOP, NOP, NOP, NOP, NOP, NOP) +SETUPFUNC(rs_gs, NOP, COL, NOP, NOP, NOP, NOP, SPC, NOP) +SETUPFUNC(rs_gt0, NOP, COL, TEX0, NOP, TEX0_4, NOP, NOP, NOP) +SETUPFUNC(rs_gt1, NOP, COL, NOP, TEX1, NOP, TEX1_4, NOP, NOP) +SETUPFUNC(rs_gt0t1, NOP, COL, TEX0, TEX1, TEX0_4, TEX1_4, NOP, NOP) +SETUPFUNC(rs_gst0, NOP, COL, TEX0, NOP, TEX0_4, NOP, SPC, NOP) +SETUPFUNC(rs_gst1, NOP, COL, NOP, TEX1, NOP, TEX1_4, SPC, NOP) +SETUPFUNC(rs_gst0t1, NOP, COL, TEX0, TEX1, TEX0_4, TEX1_4, SPC, NOP) +SETUPFUNC(rs_gf, NOP, COL, NOP, NOP, NOP, NOP, NOP, FOG) +SETUPFUNC(rs_gfs, NOP, COL, NOP, NOP, NOP, NOP, SPC, FOG) +SETUPFUNC(rs_gft0, NOP, COL, TEX0, NOP, TEX0_4, NOP, NOP, FOG) +SETUPFUNC(rs_gft1, NOP, COL, NOP, TEX1, NOP, TEX1_4, NOP, FOG) +SETUPFUNC(rs_gft0t1, NOP, COL, TEX0, TEX1, TEX0_4, TEX1_4, NOP, FOG) +SETUPFUNC(rs_gfst0, NOP, COL, TEX0, NOP, TEX0_4, NOP, SPC, FOG) +SETUPFUNC(rs_gfst1, NOP, COL, NOP, TEX1, NOP, TEX1_4, SPC, FOG) +SETUPFUNC(rs_gfst0t1, NOP, COL, TEX0, TEX1, TEX0_4, TEX1_4, SPC, FOG) static void rs_invalid(struct vertex_buffer *VB, GLuint start, GLuint end) { @@ -200,6 +243,7 @@ static void rs_invalid(struct vertex_buffer *VB, GLuint start, GLuint end) typedef void (*setupFunc)(struct vertex_buffer *, GLuint, GLuint); static setupFunc setup_func[0x80]; +/* Initialize the table of vertex buffer setup functions */ void r128SetupInit(void) { int i; @@ -208,64 +252,167 @@ void r128SetupInit(void) /* Funcs to build vertices from scratch */ setup_func[R128_WIN_BIT|R128_TEX0_BIT] = rs_wt0; + setup_func[R128_WIN_BIT|R128_TEX1_BIT] = rs_wt1; setup_func[R128_WIN_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_wt0t1; setup_func[R128_WIN_BIT|R128_FOG_BIT|R128_TEX0_BIT] = rs_wft0; + setup_func[R128_WIN_BIT|R128_FOG_BIT|R128_TEX1_BIT] = rs_wft1; setup_func[R128_WIN_BIT|R128_FOG_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_wft0t1; setup_func[R128_WIN_BIT|R128_RGBA_BIT] = rs_wg; setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_SPEC_BIT] = rs_wgs; setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_TEX0_BIT] = rs_wgt0; + setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_TEX1_BIT] = rs_wgt1; setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_wgt0t1; setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_SPEC_BIT|R128_TEX0_BIT] = rs_wgst0; + setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_SPEC_BIT|R128_TEX1_BIT] = rs_wgst1; setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_SPEC_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_wgst0t1; setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_FOG_BIT] = rs_wgf; setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_FOG_BIT|R128_SPEC_BIT] = rs_wgfs; setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_FOG_BIT|R128_TEX0_BIT] = rs_wgft0; + setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_FOG_BIT|R128_TEX1_BIT] = rs_wgft1; setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_FOG_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_wgft0t1; setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_FOG_BIT|R128_SPEC_BIT|R128_TEX0_BIT] = rs_wgfst0; + setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_FOG_BIT|R128_SPEC_BIT|R128_TEX1_BIT] = rs_wgfst1; setup_func[R128_WIN_BIT|R128_RGBA_BIT|R128_FOG_BIT|R128_SPEC_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_wgfst0t1; /* Funcs to repair vertices */ setup_func[R128_TEX0_BIT] = rs_t0; + setup_func[R128_TEX1_BIT] = rs_t1; setup_func[R128_TEX0_BIT|R128_TEX1_BIT] = rs_t0t1; setup_func[R128_FOG_BIT] = rs_f; setup_func[R128_FOG_BIT|R128_TEX0_BIT] = rs_ft0; + setup_func[R128_FOG_BIT|R128_TEX1_BIT] = rs_ft1; setup_func[R128_FOG_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_ft0t1; setup_func[R128_RGBA_BIT] = rs_g; setup_func[R128_RGBA_BIT|R128_SPEC_BIT] = rs_gs; setup_func[R128_RGBA_BIT|R128_TEX0_BIT] = rs_gt0; + setup_func[R128_RGBA_BIT|R128_TEX1_BIT] = rs_gt1; setup_func[R128_RGBA_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_gt0t1; setup_func[R128_RGBA_BIT|R128_SPEC_BIT|R128_TEX0_BIT] = rs_gst0; + setup_func[R128_RGBA_BIT|R128_SPEC_BIT|R128_TEX1_BIT] = rs_gst1; setup_func[R128_RGBA_BIT|R128_SPEC_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_gst0t1; setup_func[R128_RGBA_BIT|R128_FOG_BIT] = rs_gf; setup_func[R128_RGBA_BIT|R128_FOG_BIT|R128_SPEC_BIT] = rs_gfs; setup_func[R128_RGBA_BIT|R128_FOG_BIT|R128_TEX0_BIT] = rs_gft0; + setup_func[R128_RGBA_BIT|R128_FOG_BIT|R128_TEX1_BIT] = rs_gft1; setup_func[R128_RGBA_BIT|R128_FOG_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_gft0t1; setup_func[R128_RGBA_BIT|R128_FOG_BIT|R128_SPEC_BIT|R128_TEX0_BIT] = rs_gfst0; + setup_func[R128_RGBA_BIT|R128_FOG_BIT|R128_SPEC_BIT|R128_TEX1_BIT] = rs_gfst1; setup_func[R128_RGBA_BIT|R128_FOG_BIT|R128_SPEC_BIT|R128_TEX0_BIT|R128_TEX1_BIT] = rs_gfst0t1; } +/* Initialize the vertex buffer setup functions based on the current + rendering state */ void r128ChooseRasterSetupFunc(GLcontext *ctx) { - int funcindex = R128_WIN_BIT | R128_RGBA_BIT; + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + int funcIndex = R128_WIN_BIT | R128_RGBA_BIT; if (ctx->Texture.Enabled & 0xf) { if (ctx->Texture.Unit[0].EnvMode == GL_REPLACE) - funcindex &= ~R128_RGBA_BIT; - funcindex |= R128_TEX0_BIT; + funcIndex &= ~R128_RGBA_BIT; + funcIndex |= R128_TEX0_BIT; } if (ctx->Texture.Enabled & 0xf0) - funcindex |= R128_TEX1_BIT; + funcIndex |= R128_TEX1_BIT; + /* FIXME: Verify this works properly */ if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR) - funcindex |= R128_SPEC_BIT; + funcIndex |= R128_SPEC_BIT; if (ctx->FogMode == FOG_FRAGMENT) - funcindex |= R128_FOG_BIT; - - ctx->Driver.RasterSetup = setup_func[funcindex]; + funcIndex |= R128_FOG_BIT; + + r128ctx->SetupIndex = funcIndex; + ctx->Driver.RasterSetup = setup_func[funcIndex]; +} + +/* Check to see if any updates of the vertex buffer entries are needed */ +void r128CheckPartialRasterSetup(GLcontext *ctx, + struct gl_pipeline_stage *s) +{ + r128ContextPtr r128ctx = R128_CONTEXT(ctx); + int tmp = r128ctx->SetupDone; + + s->type = 0; + r128ctx->SetupDone = GL_FALSE; + + if ((ctx->Array.Summary & VERT_OBJ_ANY) == 0) return; + if (ctx->IndirectTriangles) return; + + r128ctx->SetupDone = tmp; +} + +/* Update the vertex buffer entries, if necessary */ +void r128PartialRasterSetup(struct vertex_buffer *VB) +{ + r128ContextPtr r128ctx = R128_CONTEXT(VB->ctx); + int new = VB->pipeline->new_outputs; + int available = VB->pipeline->outputs; + int index = 0; + + if (new & VERT_WIN) { + new = available; + index |= R128_WIN_BIT | R128_FOG_BIT; + } + + if (new & VERT_RGBA) index |= R128_RGBA_BIT | R128_SPEC_BIT; + if (new & VERT_TEX0_ANY) index |= R128_TEX0_BIT; + if (new & VERT_TEX1_ANY) index |= R128_TEX1_BIT; + if (new & VERT_FOG_COORD) index |= R128_FOG_BIT; + + r128ctx->SetupDone &= ~index; + index &= r128ctx->SetupIndex; + r128ctx->SetupDone |= index; + + if (index) setup_func[index & ~R128_ALPHA_BIT](VB, VB->Start, VB->Count); +} + +/* Perform the raster setup for the fast path, if using CVA */ +void r128DoRasterSetup(struct vertex_buffer *VB) +{ + GLcontext *ctx = VB->ctx; + + if (VB->Type == VB_CVA_PRECALC) r128PartialRasterSetup(VB); + else if (ctx->Driver.RasterSetup) ctx->Driver.RasterSetup(VB, + VB->CopyStart, + VB->Count); +} + +/* Resize an existing vertex buffer */ +void r128ResizeVB(struct vertex_buffer *VB, GLuint size) +{ + r128VertexBufferPtr r128vb = R128_DRIVER_DATA(VB); + + while (r128vb->size < size) + r128vb->size *= 2; + + free(r128vb->vert_store); + r128vb->vert_store = malloc(sizeof(r128Vertex) * r128vb->size + 31); + if (!r128vb->vert_store) { + fprintf(stderr, "Cannot allocate vertex store! Exiting...\n"); + exit(1); + } + + r128vb->verts = (r128VertexPtr)(((CARD32)r128vb->vert_store + 31) & ~31); + + gl_vector1ui_free(&r128vb->clipped_elements); + gl_vector1ui_alloc(&r128vb->clipped_elements, + VEC_WRITABLE, r128vb->size, 32); + if (!r128vb->clipped_elements.start) { + fprintf(stderr, "Cannot allocate clipped elements! Exiting...\n"); + exit(1); + } + + free(VB->ClipMask); + VB->ClipMask = (GLubyte *)malloc(sizeof(GLubyte) * r128vb->size); + if (!VB->ClipMask) { + fprintf(stderr, "Cannot allocate clipmask! Exiting...\n"); + exit(1); + } } +/* Create a new device-dependent vertex buffer */ void r128DDRegisterVB(struct vertex_buffer *VB) { r128VertexBufferPtr r128vb; @@ -278,7 +425,7 @@ void r128DDRegisterVB(struct vertex_buffer *VB) fprintf(stderr, "Cannot allocate vertex store! Exiting...\n"); exit(1); } - + r128vb->verts = (r128VertexPtr)(((CARD32)r128vb->vert_store + 31) & ~31); gl_vector1ui_alloc(&r128vb->clipped_elements, @@ -287,7 +434,7 @@ void r128DDRegisterVB(struct vertex_buffer *VB) fprintf(stderr, "Cannot allocate clipped elements! Exiting...\n"); exit(1); } - + free(VB->ClipMask); VB->ClipMask = (GLubyte *)malloc(sizeof(GLubyte) * r128vb->size); if (!VB->ClipMask) { @@ -295,26 +442,115 @@ void r128DDRegisterVB(struct vertex_buffer *VB) exit(1); } - r128vb->primitive = (GLuint *)malloc(sizeof(GLuint) * r128vb->size); - r128vb->next_primitive = (GLuint *)malloc(sizeof(GLuint) * r128vb->size); - if (!r128vb->primitive || !r128vb->next_primitive) { - fprintf(stderr, "Cannot allocate primitive list! Exiting...\n"); - exit(1); - } - VB->driver_data = r128vb; } +/* Destroy a device-dependent vertex buffer */ void r128DDUnregisterVB(struct vertex_buffer *VB) { r128VertexBufferPtr r128vb = R128_DRIVER_DATA(VB); if (r128vb) { if (r128vb->vert_store) free(r128vb->vert_store); - if (r128vb->primitive) free(r128vb->primitive); - if (r128vb->next_primitive) free(r128vb->next_primitive); gl_vector1ui_free(&r128vb->clipped_elements); free(r128vb); VB->driver_data = 0; } } + +/* Get a new VB from the pool of vertex buffers in AGP space */ +static r128CCEVertBufPtr r128CCEGetNewVB(r128ContextPtr r128ctx) +{ +#define R128_VB_SIZE 4096 + + /* FIXME: This only works for a single client right now!!! */ + if (r128ctx->vb) { + r128ctx->vb->start += R128_VB_SIZE; + if (r128ctx->vb->start > + r128ctx->r128Screen->vbStart + r128ctx->r128Screen->vbSize) + r128ctx->vb->start = r128ctx->r128Screen->vbStart; + } else { + r128ctx->vb = (r128CCEVertBufPtr)malloc(sizeof(*r128ctx->vb)); + r128ctx->vb->start = r128ctx->r128Screen->vbStart; + r128ctx->vb->size = R128_VB_SIZE/sizeof(r128_vertex); + } + + r128ctx->vb->count = 0; + r128ctx->vb->done = GL_FALSE; + + return r128ctx->vb; +} + +/* Release a VB back to the pool of vertex buffers in AGP space */ +static void r128CCEReleaseVB(r128ContextPtr r128ctx) +{ + r128ctx->vb->done = GL_TRUE; +} + +/* Reserve space in a VB to store `verts' vertices. If adding these + vertices to the VB would exceed the size of the VB, then flush the + current VB, get a new one from the pool of VBs, and reserve space in + the new VB for the `verts' vertices. */ +r128_vertex *r128CCEAllocVBSpace(r128ContextPtr r128ctx, int verts) +{ + r128_vertex *vbptr; + r128CCEVertBufPtr vb = r128ctx->vb; + + if (!vb || vb->done) vb = r128CCEGetNewVB(r128ctx); + + if (vb->count + verts > vb->size) { + r128CCEFlushVB(r128ctx); + vb = r128CCEGetNewVB(r128ctx); + } + + vbptr = (r128_vertex *)(r128ctx->r128Screen->agp + vb->start) + vb->count; + vb->count += verts; + return vbptr; +} + +/* Send a VB to the Rage 128 to be processed */ +void r128CCEFlushVB(r128ContextPtr r128ctx) +{ + unsigned char *R128MMIO = r128ctx->r128Screen->mmio; + + if (!r128ctx->vb || + !r128ctx->vb->count || + r128ctx->vb->done) return; + + /* Make sure vertices are in memory, and not stuck in the WC cache */ + R128FlushWCMemory(); + + /* FIXME: The textures referenced in this VB cannot be removed until + after this buffer has been processed. ATI suggests loading new + textures via HOSTDATA command packets to solve this problem. */ + + /* FIXME: We need a way to detect if the VB is free or if it is + still in use. By waiting for idle, we know that the currently + processing buffer is complete, but waiting is slow. A better + solution is to use a counter that is stored in one of the + GUI_SCRATCH_REGs, which gets incremented after each VB is + processed. Also, we will need to associate the count value with + each VB in the pool of VBs -- this will need to be stored in the + SAREA. */ + +#if 1 + /* FIXME: Is this _really_ needed? */ + R128CCEWaitForIdle(r128ctx->r128Screen); +#endif + + BEGIN_CLIP_LOOP(r128ctx); + + R128CCE_WAIT_LOCKED(5); + R128CCE3(R128_CCE_PACKET3_3D_RNDR_GEN_INDX_PRIM, 3); + R128CCE(r128ctx->vb->start); + R128CCE(r128ctx->vb->count); + R128CCE(R128_FULL_VERTEX_FORMAT); + R128CCE(R128_CCE_VC_CNTL_PRIM_TYPE_TRI_LIST | + R128_CCE_VC_CNTL_PRIM_WALK_LIST | + (r128ctx->vb->count << R128_CCE_VC_CNTL_NUM_SHIFT)); + R128CCE_END_LOCKED(); + + END_CLIP_LOOP(r128ctx); + + r128CCEReleaseVB(r128ctx); +} diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_vb.h b/xc/lib/GL/mesa/src/drv/r128/r128_vb.h index 96a560411..9b0a3f7c7 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_vb.h +++ b/xc/lib/GL/mesa/src/drv/r128/r128_vb.h @@ -37,6 +37,9 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #ifdef GLX_DIRECT_RENDERING +#define USE_RHW2 0 + +/* FIXME: This is endian-specific */ typedef struct { GLubyte b; GLubyte g; @@ -45,34 +48,95 @@ typedef struct { } r128Color; typedef struct { - GLfloat x, y, z; - GLfloat rhw; - r128Color dif_argb; - r128Color spec_frgb; - GLfloat tu1; - GLfloat tv1; - GLfloat tu2; - GLfloat tv2; - GLfloat rhw2; + GLfloat x, y, z; /* Coordinates in screen space */ + GLfloat rhw; /* Reciprocal homogeneous w */ + r128Color dif_argb; /* Diffuse color */ + r128Color spec_frgb; /* Specular color (alpha is fog) */ + GLfloat tu0, tv0; /* Texture 0 coordinates */ + GLfloat tu1, tv1; /* Texture 1 coordinates */ +#if USE_RHW2 + GLfloat rhw2; /* Reciprocal homogeneous w */ +#endif } r128_vertex; +#if USE_RHW2 +/* Format of vertices in r128_vertex struct */ +#define R128_FULL_VERTEX_FORMAT \ + R128_CCE_VC_FRMT_RHW | \ + R128_CCE_VC_FRMT_DIFFUSE_ARGB | \ + R128_CCE_VC_FRMT_SPEC_FRGB | \ + R128_CCE_VC_FRMT_S_T | \ + R128_CCE_VC_FRMT_S2_T2 | \ + R128_CCE_VC_FRMT_RHW2 + +/* Send a single vertex to the ring buffer */ +#define R128CCE_SEND_VERTEX(v) \ +do { \ + R128CCEF((v)->x); \ + R128CCEF((v)->y); \ + R128CCEF((v)->z); \ + R128CCEF((v)->rhw); \ + R128CCE(*(int *)&(v)->dif_argb); \ + R128CCE(*(int *)&(v)->spec_frgb); \ + R128CCEF((v)->tu0); \ + R128CCEF((v)->tv0); \ + R128CCEF((v)->tu1); \ + R128CCEF((v)->tv1); \ + R128CCEF((v)->rhw2); \ +} while (0) + +#else /* !USE_RHW2 */ + +/* Format of vertices in r128_vertex struct */ +#define R128_FULL_VERTEX_FORMAT \ + R128_CCE_VC_FRMT_RHW | \ + R128_CCE_VC_FRMT_DIFFUSE_ARGB | \ + R128_CCE_VC_FRMT_SPEC_FRGB | \ + R128_CCE_VC_FRMT_S_T | \ + R128_CCE_VC_FRMT_S2_T2 + +/* Send a single vertex to the ring buffer */ +#define R128CCE_SEND_VERTEX(v) \ +do { \ + R128CCEF((v)->x); \ + R128CCEF((v)->y); \ + R128CCEF((v)->z); \ + R128CCEF((v)->rhw); \ + R128CCE(*(int *)&(v)->dif_argb); \ + R128CCE(*(int *)&(v)->spec_frgb); \ + R128CCEF((v)->tu0); \ + R128CCEF((v)->tv0); \ + R128CCEF((v)->tu1); \ + R128CCEF((v)->tv1); \ +} while (0) +#endif + +/* FIXME: We currently only have assembly for 16-stride vertices */ typedef union { r128_vertex v; float f[16]; } r128Vertex, *r128VertexPtr; +/* Vertex buffer for use when on the fast path */ typedef struct { - GLvector1ui clipped_elements; - r128VertexPtr verts; - int last_vert; - GLuint *primitive; - GLuint *next_primitive; - void *vert_store; - GLuint size; + GLuint size; /* Number of vertices in store */ + void *vert_store; /* Storage for vertex buffer */ + r128VertexPtr verts; /* Aligned start of verts in storage */ + int last_vert; /* Index of last vertex used */ + GLvector1ui clipped_elements; /* List of clipped elements */ } *r128VertexBufferPtr; #define R128_DRIVER_DATA(vb) ((r128VertexBufferPtr)((vb)->driver_data)) +#if USE_VERTEX_BUFFERS +#define R128_FLUSH_VB(CC) \ +do { \ + if ((CC)->vb) r128CCEFlushVB(CC); \ +} while (0) +#else +#define R128_FLUSH_VB(CC) (void)(CC) +#endif + #define R128_SPEC_BIT 0x01 #define R128_FOG_BIT 0x02 #define R128_ALPHA_BIT 0x04 /* GL_BLEND, not used */ @@ -81,10 +145,18 @@ typedef struct { #define R128_RGBA_BIT 0x20 #define R128_WIN_BIT 0x40 -extern void r128SetupInit(void); -extern void r128ChooseRasterSetupFunc(GLcontext *ctx); -extern void r128DDRegisterVB(struct vertex_buffer *VB); -extern void r128DDUnregisterVB(struct vertex_buffer *VB); +extern void r128SetupInit(void); +extern void r128ChooseRasterSetupFunc(GLcontext *ctx); +extern void r128CheckPartialRasterSetup(GLcontext *ctx, + struct gl_pipeline_stage *s); +extern void r128PartialRasterSetup(struct vertex_buffer *VB); +extern void r128DoRasterSetup(struct vertex_buffer *VB); +extern void r128ResizeVB(struct vertex_buffer *VB, GLuint size); +extern void r128DDRegisterVB(struct vertex_buffer *VB); +extern void r128DDUnregisterVB(struct vertex_buffer *VB); + +extern r128_vertex *r128CCEAllocVBSpace(r128ContextPtr r128ctx, int verts); +extern void r128CCEFlushVB(r128ContextPtr r128ctx); #endif #endif /* _R128_VB_H_ */ diff --git a/xc/lib/GL/mesa/src/drv/r128/r128_xmesa.c b/xc/lib/GL/mesa/src/drv/r128/r128_xmesa.c index c0d1697c6..a337b6ea7 100644 --- a/xc/lib/GL/mesa/src/drv/r128/r128_xmesa.c +++ b/xc/lib/GL/mesa/src/drv/r128/r128_xmesa.c @@ -34,37 +34,26 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #ifdef GLX_DIRECT_RENDERING -/* r128 DDX driver includes */ -#include "r128_dri.h" -#include "r128_reg.h" - /* r128 Mesa driver includes */ #include "r128_init.h" #include "r128_context.h" #include "r128_xmesa.h" -#include "r128_dd.h" #include "r128_state.h" -#include "r128_span.h" -#include "r128_depth.h" #include "r128_tex.h" #include "r128_swap.h" -#include "r128_tris.h" -#include "r128_vb.h" /* Mesa src includes */ #include "context.h" -#if 0 -#include "vbxform.h" -#include "matrix.h" -#endif +#include "simple_list.h" #ifdef DEBUG_LOCKING char *prevLockFile = NULL; int prevLockLine = 0; #endif -r128ContextPtr r128Context = NULL; +static r128ContextPtr r128Context = NULL; +/* Count the number of bits set */ static int count_bits(unsigned int n) { int bits = 0; @@ -76,100 +65,24 @@ static int count_bits(unsigned int n) return bits; } +/* FIXME: */ + +/* Initialize the driver specific screen private data */ GLboolean XMesaInitDriver(__DRIscreenPrivate *sPriv) { - r128ScreenPtr r128Screen; - R128DRIPtr r128DRIPriv = (R128DRIPtr)sPriv->pDevPriv; - - /* Allocate the private area */ - r128Screen = (r128ScreenPtr)Xmalloc(sizeof(*r128Screen)); - if (!r128Screen) return GL_FALSE; - - r128Screen->mmioRgn.handle = r128DRIPriv->registerHandle; - r128Screen->mmioRgn.size = r128DRIPriv->registerSize; - if (drmMap(sPriv->fd, - r128Screen->mmioRgn.handle, - r128Screen->mmioRgn.size, - (drmAddressPtr)&r128Screen->mmio)) { - Xfree(r128Screen); - return GL_FALSE; - } - - r128Screen->agpRgn.handle = r128DRIPriv->agpHandle; - r128Screen->agpRgn.size = r128DRIPriv->agpSize; - if (drmMap(sPriv->fd, - r128Screen->agpRgn.handle, - r128Screen->agpRgn.size, - (drmAddressPtr)&r128Screen->agp)) { - drmUnmap((drmAddress)r128Screen->mmio, r128Screen->mmioRgn.size); - Xfree(r128Screen); - return GL_FALSE; - } - - r128Screen->deviceID = r128DRIPriv->deviceID; - - r128Screen->width = r128DRIPriv->width; - r128Screen->height = r128DRIPriv->height; - r128Screen->depth = r128DRIPriv->depth; - r128Screen->bpp = r128DRIPriv->bpp; - - r128Screen->fb = sPriv->pFB; - r128Screen->fbOffset = sPriv->fbOrigin; - r128Screen->fbStride = sPriv->fbStride; - r128Screen->fbSize = sPriv->fbSize; - - r128Screen->fbX = r128DRIPriv->fbX; - r128Screen->fbY = r128DRIPriv->fbY; - r128Screen->backX = r128DRIPriv->backX; - r128Screen->backY = r128DRIPriv->backY; - r128Screen->depthX = r128DRIPriv->depthX; - r128Screen->depthY = r128DRIPriv->depthY; - r128Screen->textureX = r128DRIPriv->textureX; - r128Screen->textureY = r128DRIPriv->textureY; - r128Screen->textureSize = r128DRIPriv->textureSize; - -#if 0 - r128Screen->backX = 0; - r128Screen->backY = r128DRIPriv->height/2; - r128Screen->depthX = r128DRIPriv->width/2; - r128Screen->depthY = r128DRIPriv->height/2; -#endif - - r128Screen->CCEMode = r128DRIPriv->CCEMode; - r128Screen->CCEFifoSize = r128DRIPriv->CCEFifoSize; - - r128Screen->ringStart = r128DRIPriv->ringStart; - r128Screen->ringSize = r128DRIPriv->ringSize; - r128Screen->ringWritePtr = &r128DRIPriv->ringWrite; - r128Screen->ringReadPtr = (int *)(r128Screen->agp - + r128DRIPriv->ringReadOffset); - - r128Screen->MMIOFifoSlots = 0; - r128Screen->CCEFifoSlots = 0; - - r128Screen->CCEFifoAddr = R128_PM4_FIFO_DATA_EVEN; - - r128Screen->driScreen = sPriv; - - sPriv->private = (void *)r128Screen; - - r128TriangleFuncsInit(); - r128SetupInit(); + sPriv->private = (void *)r128CreateScreen(sPriv); + if (!sPriv->private) return GL_FALSE; return GL_TRUE; } +/* Reset the driver specific screen private data */ void XMesaResetDriver(__DRIscreenPrivate *sPriv) { - r128ScreenPtr r128Screen = (r128ScreenPtr)sPriv->private; - - drmUnmap((drmAddress)r128Screen->mmio, r128Screen->mmioRgn.size); - drmUnmap((drmAddress)r128Screen->agp, r128Screen->agpRgn.size); - - Xfree(r128Screen); - sPriv->private = NULL; + r128DestroyScreen(sPriv); } +/* Create and initialize the Mesa and driver specific visual data */ XMesaVisual XMesaCreateVisual(XMesaDisplay *display, XMesaVisualInfo visinfo, GLboolean rgb_flag, @@ -223,6 +136,7 @@ XMesaVisual XMesaCreateVisual(XMesaDisplay *display, return v; } +/* Destroy the Mesa and driver specific visual data */ void XMesaDestroyVisual(XMesaVisual v) { Xfree(v->gl_visual); @@ -230,91 +144,40 @@ void XMesaDestroyVisual(XMesaVisual v) Xfree(v); } +/* Create and initialize the Mesa and driver specific context data */ XMesaContext XMesaCreateContext(XMesaVisual v, XMesaContext share_list, __DRIcontextPrivate *driContextPriv) { XMesaContext c; - r128ContextPtr r128ctx; - GLcontext *shareCtx, *glCtx; c = (XMesaContext)Xmalloc(sizeof(*c)); if (!c) { return NULL; } - r128ctx = (r128ContextPtr)Xmalloc(sizeof(*r128ctx)); - if (!r128ctx) { - Xfree(c); - return NULL; - } - /* Initialize XMesaContext */ c->display = v->display; c->xm_visual = v; c->xm_buffer = NULL; /* Set by MakeCurrent */ c->driContextPriv = driContextPriv; - c->private = (void *)r128ctx; - - if (share_list) - shareCtx = ((r128ContextPtr)(share_list->private))->glCtx; - else - shareCtx = NULL; - - /* Initialize r128Context */ - r128ctx->xmCtx = c; - r128ctx->glCtx = gl_create_context(v->gl_visual, - shareCtx, - (void *)r128ctx, - GL_TRUE); - r128ctx->display = v->display; - r128ctx->driContext = driContextPriv; - r128ctx->driDrawable = NULL; /* Set by XMesaMakeCurrent */ - r128ctx->dirty = R128_ALL_DIRTY; - r128ctx->needClip = GL_TRUE; - r128ctx->r128Screen = - (r128ScreenPtr)(driContextPriv->driScreenPriv->private); - - /* Initialize GLcontext */ - glCtx = r128ctx->glCtx; - - r128DDInitExtensions(glCtx); - - r128DDInitDriverFuncs(glCtx); - r128DDInitStateFuncs(glCtx); - r128DDInitSpanFuncs(glCtx); - r128DDInitDepthFuncs(glCtx); - r128DDInitTextureFuncs(glCtx); - -#if 1 - /* FIXME: Move to r128_tris.c */ - glCtx->Driver.TriangleCaps = (DD_TRI_CULL - | DD_TRI_LIGHT_TWOSIDE - | DD_TRI_OFFSET); - glCtx->TriangleCaps |= DD_CLIP_FOG_COORD; - - if (glCtx->VB) r128DDRegisterVB(glCtx->VB); -#endif - - r128DDInitState(r128ctx); + c->private = (void *)r128CreateContext(v->gl_visual, c, share_list); + if (!c->private) { + Xfree(c); + return NULL; + } return c; } +/* Destroy the Mesa and driver specific context data */ void XMesaDestroyContext(XMesaContext c) { - r128ContextPtr r128ctx = (r128ContextPtr)c->private; - - if (r128ctx) { - gl_destroy_context(r128ctx->glCtx); - Xfree(r128ctx); - c->private = NULL; - } - - if (c->private == (void *)r128Context) { - r128Context = NULL; - } + if (c->private == (void *)r128Context) r128Context = NULL; + r128DestroyContext((r128ContextPtr)c->private); + Xfree(c); } +/* Create and initialize the Mesa and driver specific window buffer data */ XMesaBuffer XMesaCreateWindowBuffer(XMesaVisual v, XMesaWindow w, __DRIdrawablePrivate *driDrawPriv) @@ -328,6 +191,7 @@ XMesaBuffer XMesaCreateWindowBuffer(XMesaVisual v, return xm_buf; } +/* Create and initialize the Mesa and driver specific pixmap buffer data */ XMesaBuffer XMesaCreatePixmapBuffer(XMesaVisual v, XMesaPixmap p, XMesaColormap c, @@ -342,12 +206,14 @@ XMesaBuffer XMesaCreatePixmapBuffer(XMesaVisual v, return xm_buf; } +/* Destroy the Mesa and driver specific color buffer data */ void XMesaDestroyBuffer(XMesaBuffer b) { gl_destroy_framebuffer(b->gl_buffer); Xfree(b); } +/* Copy the back color buffer to the front color buffer */ void XMesaSwapBuffers(XMesaBuffer b) { /* @@ -356,36 +222,29 @@ void XMesaSwapBuffers(XMesaBuffer b) */ if (r128Context == NULL) return; + /* FIXME: Only swap buffers when a back buffer exists */ + + FLUSH_VB(R128_MESACTX(r128Context), "swap buffers"); r128SwapBuffers(r128Context); } +/* Force the context `c' to be the current context and associate with it + buffer `b' */ GLboolean XMesaMakeCurrent(XMesaContext c, XMesaBuffer b) { if (c) { - r128ContextPtr oldCtx = r128Context; - - if (r128Context - && c->private == (void *)r128Context - && b->driDrawPriv == r128Context->driDrawable) return GL_TRUE; - - r128Context = (r128ContextPtr)c->private; - - if (oldCtx) { - r128Context->dirty = R128_REQUIRE_QUIESCENCE | R128_START_CCE; - if (oldCtx != r128Context) - r128Context->dirty |= R128_UPDATE_CONTEXT; - if (oldCtx->driDrawable != b->driDrawPriv) - r128Context->dirty |= R128_UPDATE_CLIPRECTS; - } else { - r128Context->dirty = R128_ALL_DIRTY; - } + if (r128Context && + c->private == (void *)r128Context && + b->driDrawPriv == R128_DRIDRAWABLE(r128Context)) + return GL_TRUE; - r128Context->driDrawable = b->driDrawPriv; + r128Context = r128MakeCurrent(r128Context, (r128ContextPtr)c->private, + b->driDrawPriv); - gl_make_current(r128Context->glCtx, b->gl_buffer); + gl_make_current(R128_MESACTX(r128Context), b->gl_buffer); - if (!r128Context->glCtx->Viewport.Width) { - gl_Viewport(r128Context->glCtx, 0, 0, + if (!R128_MESACTX(r128Context)->Viewport.Width) { + gl_Viewport(R128_MESACTX(r128Context), 0, 0, b->driDrawPriv->w, b->driDrawPriv->h); } } else { @@ -396,29 +255,30 @@ GLboolean XMesaMakeCurrent(XMesaContext c, XMesaBuffer b) return GL_TRUE; } +/* Update the hardware state. This is called if another context has + grabbed the hardware lock, which includes the X server. This + function also updates the driver's window state after the X server + moves, resizes or restacks a window -- the change will be reflected + in the drawable position and clip rects. Since the X server grabs + the hardware lock when it changes the window state, this routine will + automatically be called after such a change. */ +/* NOTE: This routine is only called while holding the hardware lock. */ void XMesaUpdateState(XMesaContext c) { - r128ContextPtr r128ctx = (r128ContextPtr)c->private; - __DRIdrawablePrivate *dPriv = r128ctx->driDrawable; - __DRIscreenPrivate *sPriv = r128ctx->r128Screen->driScreen; - int stamp = dPriv->lastStamp; + __DRIscreenPrivate *sPriv = R128_DRISCREEN((r128ContextPtr)c->private); + __DRIdrawablePrivate *dPriv = R128_DRIDRAWABLE((r128ContextPtr)c->private); + int stamp = dPriv->lastStamp; - /* - * The window might have moved, so we might need to get new - * cliprects. - * - * NOTE: This releases and regrabs the hw lock, so all state - * checking must be done *after* this call. - */ - XMESA_VALIDATE_DRAWABLE_INFO(r128ctx->display, sPriv, dPriv); - - r128ctx->dirty |= R128_ALL_DIRTY; /* FIXME: Optimize this!! */ - - if (stamp != dPriv->lastStamp) { /* FIXME??: handle window moves */ - r128ctx->dirty |= R128_UPDATE_CLIPRECTS; - } + /* The window might have moved, so we might need to get new clip + rects. + + NOTE: This releases and regrabs the hw lock to allow the X server + to respond to the DRI protocol request for new drawable info. + Since the hardware state depends on having the latest drawable + clip rects, all state checking must be done _after_ this call. */ + XMESA_VALIDATE_DRAWABLE_INFO(c->display, sPriv, dPriv); - if (r128ctx->dirty) r128UpdateStateLocked(r128ctx); + r128UpdateState((r128ContextPtr)c->private, (stamp != dPriv->lastStamp)); } #endif diff --git a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128.h b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128.h index 92e55c85b..71771f42f 100644 --- a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128.h +++ b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128.h @@ -219,14 +219,30 @@ typedef struct { drmHandle agpHandle; /* Handle from drmAddMap */ unsigned char *AGP; /* Map */ - int CCEMode; - int CCEFifoSize; + Bool CCEInUse; /* CCE is currently active */ + int CCEMode; /* CCE mode that server/clients use */ + int CCEFifoSize; /* Size of the CCE command FIFO */ + /* CCE ring buffer data */ unsigned long ringStart; int ringSize; int ringWrite; unsigned long ringReadOffset; + /* CCE vertex buffer data */ + unsigned long vbStart; + int vbSize; + + /* CCE indirect buffer data */ + unsigned long indStart; + int indSize; + + /* CCE AGP Texture data */ + unsigned long agpTexStart; + int agpTexSize; + int log2AGPTexGran; + + /* DRI screen private data */ int fbX; int fbY; int backX; @@ -236,6 +252,7 @@ typedef struct { int textureX; int textureY; int textureSize; + int log2TexGran; #endif } R128InfoRec, *R128InfoPtr; @@ -256,13 +273,15 @@ extern void R128WaitForVerticalSync(ScrnInfoPtr pScrn); extern Bool R128AccelInit(ScreenPtr pScreen); extern Bool R128CursorInit(ScreenPtr pScreen); +extern int R128MinBits(int val); + #ifdef XF86DRI extern Bool R128DRIScreenInit(ScreenPtr pScreen); extern void R128DRICloseScreen(ScreenPtr pScreen); extern Bool R128DRIFinishScreenInit(ScreenPtr pScreen); extern void R128DRICCEInitRingBuffer(ScrnInfoPtr pScrn); -extern void R128LostContext(ScreenPtr pScreen); -extern void R128SwapContextPrivate(ScreenPtr pScreen); +extern void R128CCEStart(ScrnInfoPtr pScrn); +extern void R128CCEStop(ScrnInfoPtr pScrn); #endif #endif diff --git a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_accel.c b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_accel.c index 36a2a1092..4db9ba44e 100644 --- a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_accel.c +++ b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_accel.c @@ -969,16 +969,20 @@ static void R128EngineInit(ScrnInfoPtr pScrn) R128WaitForIdle(pScrn); } -/* Initialize XAA for supported acceleration and also initialize the - graphics hardware for acceleration. */ -Bool R128AccelInit(ScreenPtr pScreen) +#if 0 +#ifdef XF86DRI + /* FIXME: When direct rendering is enabled, we should use the CCE to + draw 2D commands */ +static void R128CCEAccelInit(ScrnInfoPtr pScrn, XAAInfoRecPtr a) { - ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; - R128InfoPtr info = R128PTR(pScrn); - XAAInfoRecPtr a; +} +#endif +#endif + +static void R128MMIOAccelInit(ScrnInfoPtr pScrn, XAAInfoRecPtr a) +{ + R128InfoPtr info = R128PTR(pScrn); - if (!(a = info->accel = XAACreateInfoRec())) return FALSE; - a->Flags = (PIXMAP_CACHE | OFFSCREEN_PIXMAPS | LINEAR_FRAMEBUFFER); @@ -1061,12 +1065,29 @@ Bool R128AccelInit(ScreenPtr pScreen) | SCANLINE_PAD_DWORD | SYNC_AFTER_IMAGE_WRITE); #endif - - R128EngineInit(pScrn); +} + +/* Initialize XAA for supported acceleration and also initialize the + graphics hardware for acceleration. */ +Bool R128AccelInit(ScreenPtr pScreen) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + R128InfoPtr info = R128PTR(pScrn); + XAAInfoRecPtr a; + if (!(a = info->accel = XAACreateInfoRec())) return FALSE; + +#if 0 #ifdef XF86DRI - R128DRICCEInitRingBuffer(pScrn); + /* FIXME: When direct rendering is enabled, we should use the CCE to + draw 2D commands */ + if (info->directRenderingEnabled) R128CCEAccelInit(pScrn, a); + else +#endif #endif + R128MMIOAccelInit(pScrn, a); + + R128EngineInit(pScrn); return XAAInit(pScreen, a); } diff --git a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_dri.c b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_dri.c index 07d7f1bf3..d14f8c574 100644 --- a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_dri.c +++ b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_dri.c @@ -71,9 +71,6 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #include "xf86DDC.h" /* DRI support */ -#if 0 -#include "GL/glxtokens.h" -#endif #include "GL/glxint.h" #include "xf86drm.h" #include "sarea.h" @@ -81,6 +78,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #include "xf86dri.h" #include "dri.h" #include "r128_dri.h" +#include "r128_sarea.h" #include "r128_dripriv.h" /* Driver data structures */ @@ -100,6 +98,8 @@ do { \ CCEFifoSlots -= entries; \ } while (0) +/* Wait for at least `entries' slots are free. The actual number of + slots available is stored in info->CCEFifoSize. */ static void R128CCEWaitForFifoFunction(ScrnInfoPtr pScrn, int entries) { R128InfoPtr info = R128PTR(pScrn); @@ -115,6 +115,8 @@ static void R128CCEWaitForFifoFunction(ScrnInfoPtr pScrn, int entries) } } +/* Wait until the CCE is completely idle: the FIFO has drained and the + CCE is idle. */ static void R128CCEWaitForIdle(ScrnInfoPtr pScrn) { R128InfoPtr info = R128PTR(pScrn); @@ -135,7 +137,48 @@ static void R128CCEWaitForIdle(ScrnInfoPtr pScrn) } } - /* FIXME: this routine is from tdfx */ +/* Start the CCE, but only if it is not already in use and the requested + mode is a CCE mode. The mode is stored in info->CCEMode. */ +void R128CCEStart(ScrnInfoPtr pScrn) +{ + R128InfoPtr info = R128PTR(pScrn); + unsigned char *R128MMIO = info->MMIO; + + if (info->CCEInUse || info->CCEMode == R128_PM4_NONPM4) return; + + R128WaitForIdle(pScrn); + OUTREG(R128_PM4_BUFFER_CNTL, info->CCEMode); + (void)INREG(R128_PM4_BUFFER_ADDR); /* as per the sample code */ + OUTREG(R128_PM4_MICRO_CNTL, R128_PM4_MICRO_FREERUN); + info->CCEInUse = TRUE; +} + +/* Stop the CCE, but only if it is in use and the requested mode is not + the non-CCE mode. This function also flushes any outstanding + requests before switching modes.*/ +void R128CCEStop(ScrnInfoPtr pScrn) +{ + R128InfoPtr info = R128PTR(pScrn); + unsigned char *R128MMIO = info->MMIO; + + if (!info->CCEInUse || info->CCEMode == R128_PM4_NONPM4) return; + + R128CCEWaitForIdle(pScrn); +#if 0 + /* FIXME: This is needed when we use the ring buffer to flush any + unfinished commands */ + OUTREGP(R128_PM4_BUFFER_DL_WPTR, + R128_PM4_BUFFER_DL_DONE, ~R128_PM4_BUFFER_DL_DONE); +#endif + OUTREG(R128_PM4_MICRO_CNTL, 0); + OUTREG(R128_PM4_BUFFER_CNTL, R128_PM4_NONPM4); + info->CCEInUse = FALSE; +} + +/* Initialize the visual configs that are supported by the hardware. + These are combined with the visual configs that the indirect + rendering core supports, and the intersection is exported to the + client. */ static Bool R128InitVisualConfigs(ScreenPtr pScreen) { ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; @@ -146,17 +189,15 @@ static Bool R128InitVisualConfigs(ScreenPtr pScreen) R128ConfigPrivPtr *pR128ConfigPtrs = 0; int i; - switch (pScrn->bitsPerPixel) { - case 8: + switch (pR128->pixel_code) { + case 8: /* 8bpp mode is not support */ + case 15: /* FIXME */ + case 24: /* FIXME */ + return FALSE; + case 16: - case 24: - break; case 32: -#if 0 numConfigs = 4; -#else - numConfigs = 1; -#endif if (!(pConfigs = (__GLXvisualConfig*)xnfcalloc(sizeof(__GLXvisualConfig), @@ -177,45 +218,55 @@ static Bool R128InitVisualConfigs(ScreenPtr pScreen) return FALSE; } - for (i = 0; i < numConfigs; i++) pR128ConfigPtrs[i] = &pR128Configs[i]; - - pConfigs[0].vid = -1; - pConfigs[0].class = -1; - pConfigs[0].rgba = TRUE; - if (pScrn->depth == 16) { - pConfigs[0].redSize = 5; - pConfigs[0].greenSize = 6; - pConfigs[0].blueSize = 5; - pConfigs[0].redMask = 0x0000F800; - pConfigs[0].greenMask = 0x000007E0; - pConfigs[0].blueMask = 0x0000001F; - } else { - pConfigs[0].redSize = 8; - pConfigs[0].greenSize = 8; - pConfigs[0].blueSize = 8; - pConfigs[0].redMask = 0x00FF0000; - pConfigs[0].greenMask = 0x0000FF00; - pConfigs[0].blueMask = 0x000000FF; + for (i = 0; i < numConfigs; i++) { + pR128ConfigPtrs[i] = &pR128Configs[i]; + + pConfigs[i].vid = -1; + pConfigs[i].class = -1; + pConfigs[i].rgba = TRUE; + if (pScrn->depth == 16) { + pConfigs[i].redSize = 5; + pConfigs[i].greenSize = 6; + pConfigs[i].blueSize = 5; + pConfigs[i].redMask = 0x0000F800; + pConfigs[i].greenMask = 0x000007E0; + pConfigs[i].blueMask = 0x0000001F; + } else { + pConfigs[i].redSize = 8; + pConfigs[i].greenSize = 8; + pConfigs[i].blueSize = 8; + pConfigs[i].redMask = 0x00FF0000; + pConfigs[i].greenMask = 0x0000FF00; + pConfigs[i].blueMask = 0x000000FF; + } + pConfigs[i].alphaMask = 0; + pConfigs[i].accumRedSize = 0; + pConfigs[i].accumGreenSize = 0; + pConfigs[i].accumBlueSize = 0; + pConfigs[i].accumAlphaSize = 0; + pConfigs[i].doubleBuffer = TRUE; + pConfigs[i].stereo = FALSE; + pConfigs[i].bufferSize = pScrn->depth; + pConfigs[i].depthSize = 16; /* FIXME: Support other depth */ + pConfigs[i].stencilSize = 0; /* buffer depths with the new */ + pConfigs[i].auxBuffers = 0; /* Mesa code. */ + pConfigs[i].level = 0; + pConfigs[i].visualRating = 0; + pConfigs[i].transparentPixel = 0; + pConfigs[i].transparentRed = 0; + pConfigs[i].transparentGreen = 0; + pConfigs[i].transparentBlue = 0; + pConfigs[i].transparentAlpha = 0; + pConfigs[i].transparentIndex = 0; } - pConfigs[0].alphaMask = 0; - pConfigs[0].accumRedSize = 0; - pConfigs[0].accumGreenSize = 0; - pConfigs[0].accumBlueSize = 0; - pConfigs[0].accumAlphaSize = 0; - pConfigs[0].doubleBuffer = TRUE; - pConfigs[0].stereo = FALSE; - pConfigs[0].bufferSize = pScrn->depth; - pConfigs[0].depthSize = 16; - pConfigs[0].stencilSize = 0; - pConfigs[0].auxBuffers = 0; - pConfigs[0].level = 0; - pConfigs[0].visualRating = 0; - pConfigs[0].transparentPixel = 0; - pConfigs[0].transparentRed = 0; - pConfigs[0].transparentGreen = 0; - pConfigs[0].transparentBlue = 0; - pConfigs[0].transparentAlpha = 0; - pConfigs[0].transparentIndex = 0; + + /* Turn off double buffer support for certain visuals */ + pConfigs[1].doubleBuffer = FALSE; + pConfigs[3].doubleBuffer = FALSE; + + /* Turn off depth buffer support for certain visuals */ + pConfigs[2].depthSize = 0; + pConfigs[3].depthSize = 0; break; } @@ -226,50 +277,83 @@ static Bool R128InitVisualConfigs(ScreenPtr pScreen) return TRUE; } +/* Create the Rage 128-specific context information */ static Bool R128CreateContext(ScreenPtr pScreen, VisualPtr visual, drmContext hwContext, void *pVisualConfigPriv, DRIContextType contextStore) { + /* Nothing yet */ return TRUE; } +/* Destroy the Rage 128-specific context information */ static void R128DestroyContext(ScreenPtr pScreen, drmContext hwContext, DRIContextType contextStore) { + /* Nothing yet */ } -void R128LostContext(ScreenPtr pScreen) +/* Called when the X server is woken up to allow the last client's + context to be saved and the X server's context to be loaded. This is + not necessary for the Rage 128 since the client detects when it's + context is not currently loaded and then load's it itself. Since the + registers to start and stop the CCE are privileged, only the X server + can start/stop the engine. */ +static void R128EnterServer(ScreenPtr pScreen) { + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + +#if 1 + /* FIXME: When the CCE is used for 2D drawing in the X server, we + will not need to stop/start the CCE when entering/leaving the X + server. */ + R128CCEStop(pScrn); +#else + R128CCEWaitForIdle(pScrn); +#endif } -void R128SwapContextPrivate(ScreenPtr pScreen) +/* Called when the X server goes to sleep to allow the X server's + context to be saved and the last client's context to be loaded. This + is not necessary for the Rage 128 since the client detects when it's + context is not currently loaded and then load's it itself. Since the + registers to start and stop the CCE are privileged, only the X server + can start/stop the engine. */ +static void R128LeaveServer(ScreenPtr pScreen) { +#if 1 ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; - unsigned char *R128MMIO = R128PTR(pScrn)->MMIO; - R128CCEWaitForIdle(pScrn); - OUTREGP(R128_PM4_BUFFER_DL_WPTR, - R128_PM4_BUFFER_DL_DONE, ~R128_PM4_BUFFER_DL_DONE); - OUTREG(R128_PM4_MICRO_CNTL, 0); - OUTREG(R128_PM4_BUFFER_CNTL, R128_PM4_NONPM4); + /* FIXME: When the CCE is used for 2D drawing in the X server, we + will not need to stop/start the CCE when entering/leaving the X + server. */ + R128CCEStart(pScrn); +#endif } +/* Contexts can be swapped by the X server if necessary. This callback + is currently only used to perform any functions necessary when + entering or leaving the X server, and in the future might not be + necessary. */ static void R128DRISwapContext(ScreenPtr pScreen, DRISyncType syncType, DRIContextType oldContextType, void *oldContext, DRIContextType newContextType, void *newContext) { if ((syncType==DRI_3D_SYNC) && (oldContextType==DRI_2D_CONTEXT) && (newContextType==DRI_2D_CONTEXT)) { /* Entering from Wakeup */ - R128SwapContextPrivate(pScreen); + R128EnterServer(pScreen); } if ((syncType==DRI_2D_SYNC) && (oldContextType==DRI_NO_CONTEXT) && (newContextType==DRI_2D_CONTEXT)) { /* Exiting from Block Handler */ - R128LostContext(pScreen); + R128LeaveServer(pScreen); } } +/* Initialize the state of the back and depth buffers. */ static void R128DRIInitBuffers(WindowPtr pWin, RegionPtr prgn, CARD32 index) { +#if 0 + /* FIXME: This routine needs to have acceleration turned on */ ScreenPtr pScreen = pWin->drawable.pScreen; ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; R128InfoPtr pR128 = R128PTR(pScrn); @@ -277,6 +361,8 @@ static void R128DRIInitBuffers(WindowPtr pWin, RegionPtr prgn, CARD32 index) int nbox; /* FIXME: Copy XAAPaintWindow() and use REGION_TRANSLATE() */ + /* FIXME: Only initialize the back and depth buffers for contexts + that request them */ pbox = REGION_RECTS(prgn); nbox = REGION_NUM_RECTS(prgn); @@ -296,19 +382,28 @@ static void R128DRIInitBuffers(WindowPtr pWin, RegionPtr prgn, CARD32 index) } pR128->accel->NeedToSync = TRUE; +#endif } +/* Copy the back and depth buffers when the X server moves a window. */ static void R128DRIMoveBuffers(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc, CARD32 index) { + /* FIXME: This routine needs to have acceleration turned on */ /* FIXME: Copy XAACopyWindow() and use REGION_TRANSLATE() */ + /* FIXME: Only initialize the back and depth buffers for contexts + that request them */ } +/* Initialize the AGP state. Request memory for use in AGP space, and + initialize the Rage 128 registers to point to that memory. */ static Bool R128DRIAgpInit(R128InfoPtr pR128, ScreenPtr pScreen) { + unsigned char *R128MMIO = pR128->MMIO; unsigned long mode; unsigned int vendor, device; int ret; + unsigned long cntl; if (drmAgpAcquire(pR128->drmFD) < 0) { xf86DrvMsg(pScreen->myNum, X_ERROR, "[agp] AGP not available\n"); @@ -319,11 +414,17 @@ static Bool R128DRIAgpInit(R128InfoPtr pR128, ScreenPtr pScreen) not appropriate for this particular combination of graphics card and AGP chipset. */ - + mode = drmAgpGetMode(pR128->drmFD); /* Default mode */ vendor = drmAgpVendorId(pR128->drmFD); device = drmAgpDeviceId(pR128->drmFD); +#if 0 + /* FIXME: This turns off AGP 2X mode */ + /* FIXME: Make this configurable */ + mode &= ~0x00000002; +#endif + xf86DrvMsg(pScreen->myNum, X_INFO, "[agp] Mode 0x%08lx [AGP 0x%04x/0x%04x; Card 0x%04x/0x%04x]\n", mode, vendor, device, @@ -336,7 +437,8 @@ static Bool R128DRIAgpInit(R128InfoPtr pR128, ScreenPtr pScreen) return FALSE; } - pR128->agpSize = 4 * 1024 * 1024; /* FIXME -- arbitrary */ + /* FIXME: This size was chosen arbitrarily -- make it configurable */ + pR128->agpSize = 8 * 1024 * 1024; if ((ret = drmAgpAlloc(pR128->drmFD, pR128->agpSize, &pR128->agpMemHandle)) < 0) { xf86DrvMsg(pScreen->myNum, X_ERROR, "[agp] Out of memory (%d)\n", ret); @@ -347,7 +449,7 @@ static Bool R128DRIAgpInit(R128InfoPtr pR128, ScreenPtr pScreen) "[agp] %d kB allocated with handle 0x%08x\n", pR128->agpSize / 1024, pR128->agpMemHandle); - pR128->agpOffset = 0; /* FIXME -- arbitrary */ + pR128->agpOffset = 0; if (drmAgpBind(pR128->drmFD, pR128->agpMemHandle, pR128->agpOffset) < 0) { xf86DrvMsg(pScreen->myNum, X_ERROR, "[agp] Could not bind\n"); drmAgpFree(pR128->drmFD, pR128->agpMemHandle); @@ -375,9 +477,35 @@ static Bool R128DRIAgpInit(R128InfoPtr pR128, ScreenPtr pScreen) "[agp] Aperture mapped at 0x%08lx\n", (unsigned long)pR128->AGP); + /* Initialize Rage 128's AGP registers */ + cntl = INREG(R128_AGP_CNTL); + cntl &= ~R128_AGP_APER_SIZE_MASK; + switch (pR128->agpSize) { + case 256*1024*1024: cntl |= R128_AGP_APER_SIZE_256MB; break; + case 128*1024*1024: cntl |= R128_AGP_APER_SIZE_128MB; break; + case 64*1024*1024: cntl |= R128_AGP_APER_SIZE_64MB; break; + case 32*1024*1024: cntl |= R128_AGP_APER_SIZE_32MB; break; + case 16*1024*1024: cntl |= R128_AGP_APER_SIZE_16MB; break; + case 8*1024*1024: cntl |= R128_AGP_APER_SIZE_8MB; break; + case 4*1024*1024: cntl |= R128_AGP_APER_SIZE_4MB; break; + default: + xf86DrvMsg(pScreen->myNum, X_ERROR, + "[agp] Illegal aperture size %d kB\n", + pR128->agpSize / 1024); + drmUnmap(pR128->AGP, pR128->agpSize); + pR128->AGP = NULL; + drmAgpFree(pR128->drmFD, pR128->agpMemHandle); + drmAgpRelease(pR128->drmFD); + return FALSE; + } + OUTREG(R128_AGP_BASE, pR128->agpHandle); + OUTREG(R128_AGP_CNTL, cntl); + return TRUE; } +/* Add a map for the MMIO registers that will be accessed by any + DRI-based clients. */ static Bool R128DRIMapInit(R128InfoPtr pR128, ScreenPtr pScreen) { /* Map registers */ @@ -392,12 +520,13 @@ static Bool R128DRIMapInit(R128InfoPtr pR128, ScreenPtr pScreen) return TRUE; } +/* Load the microcode for the CCE */ static void R128DRILoadMicrocode(ScrnInfoPtr pScrn) { unsigned char *R128MMIO = R128PTR(pScrn)->MMIO; int i; unsigned long R128Microcode[] = { - /* Tedz Special Microcode */ + /* CCE microcode (from ATI) */ 0, 276838400, 0, 268449792, 2, 142, 2, 145, 0, 1076765731, 0, 1617039951, 0, 774592877, 0, 1987540286, 0, 2307490946U, 0, 599558925, 0, 589505315, 0, 596487092, 0, 589505315, 1, 11544576, 1, 206848, 1, 311296, 1, 198656, 2, @@ -444,26 +573,78 @@ static void R128DRILoadMicrocode(ScrnInfoPtr pScrn) } } +/* Initialize the CCE state, and reserve space in AGP memory for the + ring, vertex, indirect buffers (if used by the current CCEMode. + Allow the rest of AGP memory to be used for textures. */ static void R128DRICCEInit(ScrnInfoPtr pScrn) { - R128InfoPtr info = R128PTR(pScrn); + R128InfoPtr info = R128PTR(pScrn); + int s, l; + +/* FIXME: These sizes ware chosen arbitrarily -- make them configurable */ +/* NOTE: These must be page aligned */ +#define RING_SIZE 1*1024*1024 +#define VERTBUF_SIZE 1*1024*1024 +#define INDBUF_SIZE 1*1024*1024 + + /* FIXME: Currently, the ring, vertex and indirect buffers all take + space, even when the CCEMode does not use them. Make the use of + AGP space configurable by only reserving space for the buffers + that are required for the current CCEMode. */ /* Initialize the CCE ring buffer data */ info->ringStart = 0; - info->ringSize = 8192; /* FIXME */ + info->ringSize = RING_SIZE; info->ringWrite = 0; - info->ringReadOffset = 8192; /* FIXME */ - - info->CCEMode = R128_PM4_192_DWORD_CCE_PIO; /* FIXME */ - info->CCEFifoSize = 192; /* FIXME */ + info->ringReadOffset = info->ringStart + info->ringSize + 4096; + + /* Reserve space for the vertex buffer */ + info->vbStart = info->ringReadOffset + 4096; + info->vbSize = VERTBUF_SIZE; + + /* Reserve space for the indirect buffer */ + info->indStart = info->vbStart + info->vbSize; + info->indSize = INDBUF_SIZE; + + /* Reserve the rest for AGP textures */ + info->agpTexStart = info->indStart + info->indSize; + s = (info->agpSize - info->agpTexStart); + l = R128MinBits((s-1) / R128_NR_TEX_REGIONS); + if (l < R128_LOG_TEX_GRANULARITY) l = R128_LOG_TEX_GRANULARITY; + info->agpTexSize = (s >> l) << l; + info->log2AGPTexGran = l; + + /* Initialize the CCE ring buffer FIFO size */ + info->CCEInUse = FALSE; + info->CCEMode = R128_CCE_MODE; + switch (info->CCEMode) { + case R128_PM4_NONPM4: info->CCEFifoSize = 0; break; + case R128_PM4_192PIO: info->CCEFifoSize = 192; break; + case R128_PM4_192BM: info->CCEFifoSize = 192; break; + case R128_PM4_128PIO_64INDBM: info->CCEFifoSize = 128; break; + case R128_PM4_128BM_64INDBM: info->CCEFifoSize = 128; break; + case R128_PM4_64PIO_128INDBM: info->CCEFifoSize = 64; break; + case R128_PM4_64BM_128INDBM: info->CCEFifoSize = 64; break; + case R128_PM4_64PIO_64VCBM_64INDBM: info->CCEFifoSize = 64; break; + case R128_PM4_64BM_64VCBM_64INDBM: info->CCEFifoSize = 64; break; + case R128_PM4_64PIO_64VCPIO_64INDPIO: info->CCEFifoSize = 64; break; + } } +/* Initialize the ring buffer state for use in the X server and any + DRI-based clients. */ void R128DRICCEInitRingBuffer(ScrnInfoPtr pScrn) { R128InfoPtr info = R128PTR(pScrn); unsigned char *R128MMIO = info->MMIO; unsigned long addr; + /* FIXME: When we use the CCE for the X server, we should move this + function (and the support functions above) to r128_accel.c */ + + /* Initialize CCE data */ + R128DRICCEInit(pScrn); + /* The manual (p. 2) says this address is in "VM space". This means it's an offset from the start of AGP space. */ @@ -476,42 +657,41 @@ void R128DRICCEInitRingBuffer(ScrnInfoPtr pScrn) OUTREG(R128_PM4_BUFFER_DL_RPTR_ADDR, 0x00000000); #else /* DL_RPTR_ADDR is a physical address. - This should probably be in the SAREA. */ + This should be in the SAREA. */ *(volatile long unsigned *)(info->AGP + info->ringReadOffset) = 0; OUTREG(R128_PM4_BUFFER_DL_RPTR_ADDR, (info->agpHandle + info->ringReadOffset)); #endif /* Set watermark control */ -#if 1 - OUTREG(R128_PM4_BUFFER_WM_CNTL, 0x00000000); -#else OUTREG(R128_PM4_BUFFER_WM_CNTL, ((R128_WATERMARK_L/4) << R128_WMA_SHIFT) | ((R128_WATERMARK_M/4) << R128_WMB_SHIFT) | ((R128_WATERMARK_N/4) << R128_WMC_SHIFT) | ((R128_WATERMARK_K/64) << R128_WB_WM_SHIFT)); -#endif -#if 1 addr = INREG(R128_PM4_BUFFER_ADDR); /* Force read. Why? Because it's in the examples... */ -#endif R128CCEWaitForIdle(pScrn); /* Turn on bus mastering */ -#if 1 - OUTREGP(R128_BUS_CNTL, R128_BUS_MASTER_DIS, ~R128_BUS_MASTER_DIS); -#else OUTREGP(R128_BUS_CNTL, 0, ~R128_BUS_MASTER_DIS); -#endif +#if 0 + /* FIXME: If we use the CCE ring buffer for the X server, we need to + start the engine here for the X server. */ +#else /* Make sure the CCE is off for the X server */ OUTREG(R128_PM4_MICRO_CNTL, 0); OUTREG(R128_PM4_BUFFER_CNTL, R128_PM4_NONPM4); +#endif } +/* Initialize the screen-specific data structures for the DRI and the + Rage 128. This is the main entry point to the device-specific + initialization code. It calls device-independent DRI functions to + create the DRI data structures and initialize the DRI state. */ Bool R128DRIScreenInit(ScreenPtr pScreen) { ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; @@ -519,6 +699,21 @@ Bool R128DRIScreenInit(ScreenPtr pScreen) DRIInfoPtr pDRIInfo; R128DRIPtr pR128DRI; + switch (pR128->pixel_code) { + case 8: + /* These modes are not supported (yet). */ + case 15: + case 24: + return FALSE; + + /* Only 16 and 32 color depths are supports currently. */ + case 16: + case 32: + break; + } + + /* Create the DRI data structure, and fill it in before calling the + DRIScreenInit(). */ if (!(pDRIInfo = DRICreateInfoRec())) return FALSE; pR128->pDRIInfo = pDRIInfo; @@ -614,56 +809,25 @@ Bool R128DRIScreenInit(ScreenPtr pScreen) /* Reset the Graphics Engine */ R128EngineReset(pScrn); - /* Initialize CCE */ - R128DRICCEInit(pScrn); - return TRUE; } -void R128DRICloseScreen(ScreenPtr pScreen) +/* Finish initializing the device-dependent DRI state, and call + DRIFinishScreenInit() to complete the device-independent DRI + initialization. */ +Bool R128DRIFinishScreenInit(ScreenPtr pScreen) { - ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; - R128InfoPtr pR128 = R128PTR(pScrn); - - /* De-allocate all AGP resources */ - if (pR128->AGP) { - drmUnmap(pR128->AGP, pR128->agpSize); - pR128->AGP = NULL; - } - if (pR128->agpMemHandle) { - drmAgpUnbind(pR128->drmFD, pR128->agpMemHandle); - drmAgpFree(pR128->drmFD, pR128->agpMemHandle); - pR128->agpMemHandle = 0; - drmAgpRelease(pR128->drmFD); - } + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + R128InfoPtr pR128 = R128PTR(pScrn); + R128SAREAPrivPtr pSAREAPriv; + R128DRIPtr pR128DRI; - DRICloseScreen(pScreen); - - if (pR128->pDRIInfo) { - if (pR128->pDRIInfo->devPrivate) { - xfree(pR128->pDRIInfo->devPrivate); - pR128->pDRIInfo->devPrivate = NULL; - } - DRIDestroyInfoRec(pR128->pDRIInfo); - pR128->pDRIInfo = NULL; - } - if (pR128->pVisualConfigs) { - xfree(pR128->pVisualConfigs); - pR128->pVisualConfigs = NULL; - } - if (pR128->pVisualConfigsPriv) { - xfree(pR128->pVisualConfigsPriv); - pR128->pVisualConfigsPriv = NULL; - } -} + pSAREAPriv = (R128SAREAPrivPtr)DRIGetSAREAPrivate(pScreen); + memset(pSAREAPriv, 0, sizeof(*pSAREAPriv)); + R128DRICCEInitRingBuffer(pScrn); + /* FIXME: R128CCEStart(pScrn); */ -Bool R128DRIFinishScreenInit(ScreenPtr pScreen) -{ - ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; - R128InfoPtr pR128 = R128PTR(pScrn); - R128DRIPtr pR128DRI; - pR128->pDRIInfo->driverSwapMethod = DRI_HIDE_X_CONTEXT; /* pR128->pDRIInfo->driverSwapMethod = DRI_SERVER_SWAP; */ @@ -688,6 +852,7 @@ Bool R128DRIFinishScreenInit(ScreenPtr pScreen) pR128DRI->textureX = pR128->textureX; pR128DRI->textureY = pR128->textureY; pR128DRI->textureSize = pR128->textureSize; + pR128DRI->log2TexGran = pR128->log2TexGran; pR128DRI->CCEMode = pR128->CCEMode; pR128DRI->CCEFifoSize = pR128->CCEFifoSize; @@ -697,7 +862,58 @@ Bool R128DRIFinishScreenInit(ScreenPtr pScreen) pR128DRI->ringWrite = pR128->ringWrite; pR128DRI->ringReadOffset = pR128->ringReadOffset; + pR128DRI->vbStart = pR128->vbStart; + pR128DRI->vbSize = pR128->vbSize; + + pR128DRI->indStart = pR128->indStart; + pR128DRI->indSize = pR128->indSize; + + pR128DRI->agpTexStart = pR128->agpTexStart; + pR128DRI->agpTexSize = pR128->agpTexSize; + pR128DRI->log2AGPTexGran = pR128->log2AGPTexGran; + xf86DrvMsg(pScrn->scrnIndex, X_INFO, "0x%08lx %d\n", pR128DRI->registerHandle, pR128DRI->registerSize); return DRIFinishScreenInit(pScreen); } + +/* The screen is being closed, so clean up any state and free any + resources used by the DRI. */ +void R128DRICloseScreen(ScreenPtr pScreen) +{ + ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum]; + R128InfoPtr pR128 = R128PTR(pScrn); + + /* De-allocate all AGP resources */ + if (pR128->AGP) { + drmUnmap(pR128->AGP, pR128->agpSize); + pR128->AGP = NULL; + } + if (pR128->agpMemHandle) { + drmAgpUnbind(pR128->drmFD, pR128->agpMemHandle); + drmAgpFree(pR128->drmFD, pR128->agpMemHandle); + pR128->agpMemHandle = 0; + drmAgpRelease(pR128->drmFD); + } + + /* De-allocate all DRI resources */ + DRICloseScreen(pScreen); + + /* De-allocate all DRI data structures */ + if (pR128->pDRIInfo) { + if (pR128->pDRIInfo->devPrivate) { + xfree(pR128->pDRIInfo->devPrivate); + pR128->pDRIInfo->devPrivate = NULL; + } + DRIDestroyInfoRec(pR128->pDRIInfo); + pR128->pDRIInfo = NULL; + } + if (pR128->pVisualConfigs) { + xfree(pR128->pVisualConfigs); + pR128->pVisualConfigs = NULL; + } + if (pR128->pVisualConfigsPriv) { + xfree(pR128->pVisualConfigsPriv); + pR128->pVisualConfigsPriv = NULL; + } +} diff --git a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_dri.h b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_dri.h index a443c060c..911cde1b5 100644 --- a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_dri.h +++ b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_dri.h @@ -28,8 +28,8 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. /* * Authors: - * Rickard E. Faith * Kevin E. Martin + * Rickard E. Faith * */ @@ -38,36 +38,62 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #include +/* The CCE will default to the following mode: */ +#define R128_CCE_MODE R128_PM4_64PIO_64VCBM_64INDBM typedef struct { + /* FIXME: There needs to be two register regions. One to allow + read-only access to the block of non-FIFO'd GUI registers + (0x0000-0x0FFC), and one to allow read/write acces to the block + of FIFO'd GUI registers (0x1000-0x1FFC) */ + + /* MMIO register data */ drmHandle registerHandle; drmSize registerSize; + + /* AGP data */ drmHandle agpHandle; drmSize agpSize; - int deviceID; - int width; - int height; - int depth; - int bpp; + /* DRI screen private data */ + int deviceID; /* PCI device ID */ + int width; /* Width in pixels of display */ + int height; /* Height in scanlines of display */ + int depth; /* Depth of display (8, 15, 16, 24) */ + int bpp; /* Bit depth of display (8, 16, 24, 32) */ - int fbX; + int fbX; /* Start of frame buffer */ int fbY; - int backX; + int backX; /* Start of shared back buffer */ int backY; - int depthX; + int depthX; /* Start of shared depth buffer */ int depthY; - int textureX; + int textureX; /* Start of texture data in frame buffer */ int textureY; int textureSize; + int log2TexGran; - int CCEMode; - int CCEFifoSize; + int CCEMode; /* CCE mode that server/clients use */ + int CCEFifoSize; /* Size of the CCE command FIFO */ + /* CCE ring buffer data */ unsigned long ringStart; int ringSize; int ringWrite; unsigned long ringReadOffset; + + /* CCE vertex buffer data */ + unsigned long vbStart; + int vbSize; + + /* CCE indirect buffer data */ + unsigned long indStart; + int indSize; + + /* CCE AGP Texture data */ + unsigned long agpTexStart; + int agpTexSize; + int log2AGPTexGran; } R128DRIRec, *R128DRIPtr; #endif diff --git a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_dripriv.h b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_dripriv.h index 81c6f2ba8..acec5e269 100644 --- a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_dripriv.h +++ b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_dripriv.h @@ -51,9 +51,4 @@ typedef struct { int dummy; } R128DRIContextRec, *R128DRIContextPtr; -typedef struct { - /* Nothing here yet */ - int dummy; -} R128SAREAPriv; - #endif diff --git a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_driver.c b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_driver.c index 944034b1e..df6f0e1e5 100644 --- a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_driver.c +++ b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_driver.c @@ -109,6 +109,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #include "dri.h" #include "r128_dri.h" #include "r128_dripriv.h" +#include "r128_sarea.h" #endif /* Driver data structures */ @@ -495,7 +496,7 @@ static void R128Unblank(ScrnInfoPtr pScrn) } /* Compute log base 2 of val. */ -static int R128MinBits(int val) +int R128MinBits(int val) { int bits; @@ -1111,6 +1112,12 @@ static Bool R128ScreenInit(int scrnIndex, ScreenPtr pScreen, R128TRACE(("R128ScreenInit %x %d\n", pScrn->memPhysBase, pScrn->fbOffset)); +#ifdef XF86DRI + /* Turn off the CCE for now. */ + info->CCEInUse = FALSE; + info->CCEMode = R128_PM4_NONPM4; +#endif + if (!R128MapMem(pScrn)) return FALSE; pScrn->fbOffset = 0; #ifdef XF86DRI @@ -1138,8 +1145,6 @@ static Bool R128ScreenInit(int scrnIndex, ScreenPtr pScreen, call into the driver's InitGLXVisuals call back. */ info->directRenderingEnabled = R128DRIScreenInit(pScreen); - /* Force the initialization of the context */ - R128LostContext(pScreen); #endif @@ -1288,10 +1293,16 @@ static Bool R128ScreenInit(int scrnIndex, ScreenPtr pScreen, } #ifdef XF86DRI + /* Allocate frame buffer space for the + shared back and depth buffers as well + as for local textures. */ if (info->directRenderingEnabled) { FBAreaPtr fbarea; + int width_bytes = pScrn->displayWidth * info->pixel_bytes; + int maxy = info->FbMapSize / width_bytes; + int l; - /* Back buffer setup */ + /* Allocate the shared back buffer */ if ((fbarea = xf86AllocateOffscreenArea(pScreen, pScrn->virtualX, pScrn->virtualY, @@ -1309,7 +1320,7 @@ static Bool R128ScreenInit(int scrnIndex, ScreenPtr pScreen, info->backY = -1; } - /* Depth buffer setup */ + /* Allocate the shared depth buffer */ if ((fbarea = xf86AllocateOffscreenArea(pScreen, pScrn->virtualX, pScrn->virtualY, @@ -1325,6 +1336,53 @@ static Bool R128ScreenInit(int scrnIndex, ScreenPtr pScreen, xf86DrvMsg(scrnIndex, X_ERROR, "Unable to reserve depth buffer\n"); info->depthX = -1; info->depthY = -1; + } + + /* Allocate local texture space */ + if (((maxy - MemBox.y2 - 1) * width_bytes) > + (pScrn->virtualX * pScrn->virtualY * 2 * info->pixel_bytes)) { + info->textureX = 0; + info->textureY = MemBox.y2 + 1; + info->textureSize = (maxy - MemBox.y2 - 1) * width_bytes; + + l = R128MinBits((info->textureSize-1) / R128_NR_TEX_REGIONS); + if (l < R128_LOG_TEX_GRANULARITY) l = R128_LOG_TEX_GRANULARITY; + + info->log2TexGran = l; + info->textureSize = (info->textureSize >> l) << l; + + xf86DrvMsg(scrnIndex, X_INFO, + "Reserved %d kb for textures: (%d,%d)-(%d,%d)\n", + info->textureSize/1024, + info->textureX, info->textureY, + pScrn->displayWidth, maxy); + } else if ((fbarea = xf86AllocateOffscreenArea(pScreen, + pScrn->virtualX, + pScrn->virtualY * 2, + 32, + NULL, NULL, NULL))) { + info->textureX = fbarea->box.x1; + info->textureY = fbarea->box.y1; + info->textureSize = ((fbarea->box.y2 - fbarea->box.y1) * + (fbarea->box.x2 - fbarea->box.x1) * + info->pixel_bytes); + + l = R128MinBits((info->textureSize-1) / R128_NR_TEX_REGIONS); + if (l < R128_LOG_TEX_GRANULARITY) l = R128_LOG_TEX_GRANULARITY; + + info->log2TexGran = l; + info->textureSize = (info->textureSize >> l) << l; + + xf86DrvMsg(scrnIndex, X_INFO, + "Reserved %d kb for textures: (%d,%d)-(%d,%d)\n", + info->textureSize/1024, + fbarea->box.x1, fbarea->box.y1, + fbarea->box.x2, fbarea->box.y2); + } else { + xf86DrvMsg(scrnIndex, X_ERROR, + "Unable to reserve texture space in frame buffer\n"); + info->textureX = -1; + info->textureY = -1; } } #endif @@ -1375,8 +1433,8 @@ static Bool R128ScreenInit(int scrnIndex, ScreenPtr pScreen, if (serverGeneration == 1) xf86ShowUnusedOptions(pScrn->scrnIndex, pScrn->options); - /* DRI finalization */ #ifdef XF86DRI + /* DRI finalization */ if (info->directRenderingEnabled) { /* Now that mi, cfb, drm and others have done their thing, complete the DRI @@ -2050,6 +2108,7 @@ static Bool R128CloseScreen(int scrnIndex, ScreenPtr pScreen) R128TRACE(("R128CloseScreen\n")); #ifdef XF86DRI + /* Disable direct rendering */ if (info->directRenderingEnabled) { R128DRICloseScreen(pScreen); info->directRenderingEnabled = FALSE; diff --git a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_reg.h b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_reg.h index 50ed5b1d7..64c414a8d 100644 --- a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_reg.h +++ b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_reg.h @@ -108,6 +108,14 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #define R128_AGP_APER_OFFSET 0x0178 #define R128_AGP_BASE 0x0170 #define R128_AGP_CNTL 0x0174 +# define R128_AGP_APER_SIZE_256MB (0x00 << 0) +# define R128_AGP_APER_SIZE_128MB (0x20 << 0) +# define R128_AGP_APER_SIZE_64MB (0x30 << 0) +# define R128_AGP_APER_SIZE_32MB (0x38 << 0) +# define R128_AGP_APER_SIZE_16MB (0x3c << 0) +# define R128_AGP_APER_SIZE_8MB (0x3e << 0) +# define R128_AGP_APER_SIZE_4MB (0x3f << 0) +# define R128_AGP_APER_SIZE_MASK (0x3f << 0) #define R128_AGP_COMMAND 0x0f58 /* PCI */ #define R128_AGP_PLL_CNTL 0x0010 /* PLL */ #define R128_AGP_STATUS 0x0f54 /* PCI */ @@ -556,6 +564,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #define R128_PC_GUI_CTLSTAT 0x1748 #define R128_PC_GUI_MODE 0x1744 #define R128_PC_NGUI_CTLSTAT 0x0184 +# define R128_PC_FLUSH_GUI (3 << 0) # define R128_PC_FLUSH_ALL 0x00ff # define R128_PC_BUSY (1 << 31) #define R128_PC_NGUI_MODE 0x0180 @@ -660,9 +669,16 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. #define R128_PM4_BUFFER_OFFSET 0x0700 #define R128_PM4_BUFFER_CNTL 0x0704 -# define R128_PM4_NONPM4 (0 << 28) -# define R128_PM4_192_DWORD_CCE_PIO (1 << 28) -# define R128_PM4_192_DWORD_CCE_BM (2 << 28) +# define R128_PM4_NONPM4 (0 << 28) +# define R128_PM4_192PIO (1 << 28) +# define R128_PM4_192BM (2 << 28) +# define R128_PM4_128PIO_64INDBM (3 << 28) +# define R128_PM4_128BM_64INDBM (4 << 28) +# define R128_PM4_64PIO_128INDBM (5 << 28) +# define R128_PM4_64BM_128INDBM (6 << 28) +# define R128_PM4_64PIO_64VCBM_64INDBM (7 << 28) +# define R128_PM4_64BM_64VCBM_64INDBM (8 << 28) +# define R128_PM4_64PIO_64VCPIO_64INDPIO (15 << 28) #define R128_PM4_BUFFER_WM_CNTL 0x0708 # define R128_WMA_SHIFT 0 # define R128_WMB_SHIFT 8 @@ -810,6 +826,8 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. # define R128_WINDOW_Y_SHIFT 4 # define R128_WINDOW_X_SHIFT 20 +#define R128_Z_OFFSET_C 0x1c90 +#define R128_Z_PITCH_C 0x1c94 #define R128_Z_STEN_CNTL_C 0x1c98 # define R128_Z_PIX_WIDTH_16 (0 << 1) # define R128_Z_PIX_WIDTH_24 (1 << 1) @@ -856,7 +874,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. # define R128_STENCIL_ENABLE (1 << 3) # define R128_SHADE_ENABLE (0 << 4) # define R128_TEXMAP_ENABLE (1 << 4) -# define R128_SECONDARY_TEX_ENABLE (1 << 5) +# define R128_SEC_TEXMAP_ENABLE (1 << 5) # define R128_FOG_ENABLE (1 << 7) # define R128_DITHER_ENABLE (1 << 8) # define R128_ALPHA_ENABLE (1 << 9) @@ -918,7 +936,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. # define R128_ALPHA_BLEND_DST_DESTCOLOR (8 << 20) # define R128_ALPHA_BLEND_DST_INVDESTCOLOR (9 << 20) # define R128_ALPHA_BLEND_DST_SRCALPHASAT (10 << 20) -# define R128_ALPHA_BLEND_DST_MASK (15 << 16) +# define R128_ALPHA_BLEND_DST_MASK (15 << 20) # define R128_ALPHA_TEST_NEVER (0 << 24) # define R128_ALPHA_TEST_LESS (1 << 24) # define R128_ALPHA_TEST_LESSEQUAL (2 << 24) @@ -941,18 +959,22 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. # define R128_MIN_BLEND_MIPLINEAR (3 << 1) # define R128_MIN_BLEND_LINEARMIPNEAREST (4 << 1) # define R128_MIN_BLEND_LINEARMIPLINEAR (5 << 1) +# define R128_MIN_BLEND_MASK (7 << 1) # define R128_MAG_BLEND_NEAREST (0 << 4) # define R128_MAG_BLEND_LINEAR (1 << 4) +# define R128_MAG_BLEND_MASK (7 << 4) # define R128_MIP_MAP_DISABLE (1 << 7) # define R128_TEX_CLAMP_S_WRAP (0 << 8) # define R128_TEX_CLAMP_S_MIRROR (1 << 8) # define R128_TEX_CLAMP_S_CLAMP (2 << 8) # define R128_TEX_CLAMP_S_BORDER_COLOR (3 << 8) +# define R128_TEX_CLAMP_S_MASK (3 << 8) # define R128_TEX_WRAP_S (1 << 10) # define R128_TEX_CLAMP_T_WRAP (0 << 11) # define R128_TEX_CLAMP_T_MIRROR (1 << 11) # define R128_TEX_CLAMP_T_CLAMP (2 << 11) # define R128_TEX_CLAMP_T_BORDER_COLOR (3 << 11) +# define R128_TEX_CLAMP_T_MASK (3 << 11) # define R128_TEX_WRAP_T (1 << 13) # define R128_TEX_PERSPECTIVE_DISABLE (1 << 14) # define R128_DATATYPE_VQ (0 << 16) @@ -968,8 +990,8 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. # define R128_DATATYPE_CI16 (10 << 16) # define R128_DATATYPE_YUV422 (11 << 16) # define R128_DATATYPE_YUV422_2 (12 << 16) -# define R128_DATATYPE_AYUV444 (13 << 16) -# define R128_DATATYPE_ARGB4444 (14 << 16) +# define R128_DATATYPE_AYUV444 (14 << 16) +# define R128_DATATYPE_ARGB4444 (15 << 16) # define R128_PALLETE_EITHER (0 << 20) # define R128_PALLETE_1 (1 << 20) # define R128_PALLETE_2 (2 << 20) @@ -993,14 +1015,17 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. # define R128_COMB_BLEND_PREMULT_INV (13 << 0) # define R128_COMB_ADD_SIGNED2X (14 << 0) # define R128_COMB_BLEND_CONST_COLOR (15 << 0) +# define R128_COMB_MASK (15 << 0) # define R128_COLOR_FACTOR_TEX (4 << 4) # define R128_COLOR_FACTOR_NTEX (5 << 4) # define R128_COLOR_FACTOR_ALPHA (6 << 4) # define R128_COLOR_FACTOR_NALPHA (7 << 4) +# define R128_COLOR_FACTOR_MASK (15 << 4) # define R128_INPUT_FACTOR_CONST_COLOR (2 << 10) # define R128_INPUT_FACTOR_CONST_ALPHA (3 << 10) # define R128_INPUT_FACTOR_INT_COLOR (4 << 10) # define R128_INPUT_FACTOR_INT_ALPHA (5 << 10) +# define R128_INPUT_FACTOR_MASK (15 << 10) # define R128_COMB_ALPHA_DIS (0 << 14) # define R128_COMB_ALPHA_COPY (1 << 14) # define R128_COMB_ALPHA_COPY_INP (2 << 14) @@ -1010,19 +1035,34 @@ USE OR OTHER DEALINGS IN THE SOFTWARE. # define R128_COMB_ALPHA_ADD (6 << 14) # define R128_COMB_ALPHA_ADD_SIGNED (7 << 14) # define R128_COMB_ALPHA_ADD_SIGNED2X (14 << 14) +# define R128_COMB_ALPHA_MASK (15 << 14) # define R128_ALPHA_FACTOR_TEX_ALPHA (6 << 18) # define R128_ALPHA_FACTOR_NTEX_ALPHA (7 << 18) +# define R128_ALPHA_FACTOR_MASK (15 << 18) # define R128_INP_FACTOR_A_CONST_ALPHA (1 << 25) # define R128_INP_FACTOR_A_INT_ALPHA (2 << 25) +# define R128_INP_FACTOR_A_MASK (7 << 25) #define R128_TEX_SIZE_PITCH_C 0x1cb8 -# define R128_TEX_PITCH_SHIFT 0 -# define R128_TEX_SIZE_SHIFT 4 -# define R128_TEX_HEIGHT_SHIFT 8 -# define R128_TEX_MIN_SIZE_SHIFT 12 -# define R128_SEC_TEX_PITCH_SHIFT 16 -# define R128_SEC_TEX_SIZE_SHIFT 20 -# define R128_SEC_TEX_HEIGHT_SHIFT 24 -# define R128_SEC_TEX_MIN_SIZE_SHIFT 28 +# define R128_TEX_PITCH_SHIFT 0 +# define R128_TEX_SIZE_SHIFT 4 +# define R128_TEX_HEIGHT_SHIFT 8 +# define R128_TEX_MIN_SIZE_SHIFT 12 +# define R128_SEC_TEX_PITCH_SHIFT 16 +# define R128_SEC_TEX_SIZE_SHIFT 20 +# define R128_SEC_TEX_HEIGHT_SHIFT 24 +# define R128_SEC_TEX_MIN_SIZE_SHIFT 28 +# define R128_TEX_PITCH_MASK (0x0f << 0) +# define R128_TEX_SIZE_MASK (0x0f << 4) +# define R128_TEX_HEIGHT_MASK (0x0f << 8) +# define R128_TEX_MIN_SIZE_MASK (0x0f << 12) +# define R128_SEC_TEX_PITCH_MASK (0x0f << 16) +# define R128_SEC_TEX_SIZE_MASK (0x0f << 20) +# define R128_SEC_TEX_HEIGHT_MASK (0x0f << 24) +# define R128_SEC_TEX_MIN_SIZE_MASK (0x0f << 28) +# define R128_TEX_SIZE_PITCH_SHIFT 0 +# define R128_SEC_TEX_SIZE_PITCH_SHIFT 16 +# define R128_TEX_SIZE_PITCH_MASK (0xffff << 0) +# define R128_SEC_TEX_SIZE_PITCH_MASK (0xffff << 16) #define R128_PRIM_TEX_0_OFFSET_C 0x1cbc #define R128_PRIM_TEX_1_OFFSET_C 0x1cc0 #define R128_PRIM_TEX_2_OFFSET_C 0x1cc4 diff --git a/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_sarea.h b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_sarea.h new file mode 100644 index 000000000..2b835472e --- /dev/null +++ b/xc/programs/Xserver/hw/xfree86/drivers/r128/r128_sarea.h @@ -0,0 +1,69 @@ +/* $XFree86$ */ +/************************************************************************** + +Copyright 1999, 2000 ATI Technologies Inc. and Precision Insight, Inc., + Cedar Park, Texas. +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 +on 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 +ATI, PRECISION INSIGHT AND/OR THEIR 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. + +**************************************************************************/ + +/* + * Authors: + * Kevin E. Martin + * + */ + +#ifndef _R128_SAREA_H_ +#define _R128_SAREA_H_ + +/* Each region is a minimum of 64k, and there are at most 128 of them */ +#define R128_NR_TEX_REGIONS 128 +#define R128_LOG_TEX_GRANULARITY 16 + +typedef struct { + unsigned char next, prev; /* indices to form a circular LRU */ + unsigned char in_use; /* owned by a client, or free? */ + int age; /* tracked by clients to update local LRU's */ +} R128TexRegion; + +typedef struct { + /* Maintain an LRU of contiguous regions of texture space. If you + * think you own a region of texture memory, and it has an age + * different to the one you set, then you are mistaken and it has + * been stolen by another client. If global texAge hasn't changed, + * there is no need to walk the list. + * + * These regions can be used as a proxy for the fine-grained texture + * information of other clients - by maintaining them in the same + * lru which is used to age their own textures, clients have an + * approximate lru for the whole of global texture space, and can + * make informed decisions as to which areas to kick out. There is + * no need to choose whether to kick out your own texture or someone + * else's - simply eject them all in LRU order. + */ + R128TexRegion texList[R128_NR_TEX_REGIONS+1]; /* Last elt is sentinal */ + int texAge; /* last time texture was uploaded */ + + int ctxOwner; /* last context to upload state */ +} R128SAREAPriv, *R128SAREAPrivPtr; + +#endif -- cgit v1.2.3