diff options
| author | jhartmann <jhartmann> | 2000-04-04 22:08:12 +0000 |
|---|---|---|
| committer | jhartmann <jhartmann> | 2000-04-04 22:08:12 +0000 |
| commit | 4fe5b7fbada2f73c1533e30f8abc5cf71e7c61c4 (patch) | |
| tree | d526515e629abcae4e03e1c5c02b60243dc35f72 /xc/lib/GL/mesa/src/drv | |
| parent | d13b9c4ecba68ca9c63d94dbf48a395e3d39b847 (diff) | |
Merged mga branch with trunkmga-0-0-2-20000404-merge
Diffstat (limited to 'xc/lib/GL/mesa/src/drv')
67 files changed, 5901 insertions, 5138 deletions
diff --git a/xc/lib/GL/mesa/src/drv/Imakefile b/xc/lib/GL/mesa/src/drv/Imakefile index fadb29bb2..306bf16dc 100644 --- a/xc/lib/GL/mesa/src/drv/Imakefile +++ b/xc/lib/GL/mesa/src/drv/Imakefile @@ -16,6 +16,12 @@ DRIVER += gamma #if GlxBuiltInTdfx DRIVER += tdfx #endif +#if GlxBuiltInMga +DRIVER += common mga +#endif +#if GlxBuiltInI810 +DRIVER += common i810 +#endif SUBDIRS = $(DRIVER) #else @@ -23,6 +29,9 @@ SUBDIRS += gamma #if HasGlide3 SUBDIRS += tdfx #endif +SUBDIRS += common +SUBDIRS += mga +SUBDIRS += i810 #endif MakeSubdirs($(SUBDIRS)) diff --git a/xc/lib/GL/mesa/src/drv/common/Imakefile b/xc/lib/GL/mesa/src/drv/common/Imakefile index 5c3d40dd7..e96291842 100644 --- a/xc/lib/GL/mesa/src/drv/common/Imakefile +++ b/xc/lib/GL/mesa/src/drv/common/Imakefile @@ -22,8 +22,7 @@ MESA_INCLUDES = -I. -I.. -I../../include DEFINES = $(ALLOC_DEFINES) $(DRI_DEFINES) - INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) $(MESA_INCLUDES) $(DRI_INCLUDES) \ - -I/usr/include/glide + INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) $(MESA_INCLUDES) $(DRI_INCLUDES) DRISRCS = hwlog.c mm.c DRIOBJS = hwlog.o mm.o @@ -44,7 +43,8 @@ LibraryObjectRule() SubdirLibraryRule($(OBJS)) NormalLintTarget($(SRCS)) -#if !GlxUseBuiltInDRIDriver +XCOMM #if !GlxUseBuiltInDRIDriver +#if 0 LIBNAME = i810_dri.so ALL_OBJS = $(OBJS) ALL_DEPS = DONE diff --git a/xc/lib/GL/mesa/src/drv/common/depthtmp.h b/xc/lib/GL/mesa/src/drv/common/depthtmp.h new file mode 100644 index 000000000..3aa307904 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/common/depthtmp.h @@ -0,0 +1,133 @@ +#ifndef DBG +#define DBG 0 +#endif + + + +static void TAG(WriteDepthSpan)( GLcontext *ctx, + GLuint n, GLint x, GLint y, + const GLdepth *depth, + const GLubyte mask[] ) +{ + HW_LOCK() + { + GLint x1; + GLint n1; + LOCAL_DEPTH_VARS; + + y = Y_FLIP(y); + + HW_CLIPLOOP() + { + GLint i = 0; + CLIPSPAN(x,y,n,x1,n1,i); + + if (DBG) fprintf(stderr, "WriteDepthSpan %d..%d (x1 %d)\n", + (int)i, (int)n1, (int)x1); + + if (mask) + { + for (;i<n1;i++,x1++) + if (mask[i]) + WRITE_DEPTH( x1, y, depth[i] ); + } + else + { + for (;i<n1;i++,x1++) + WRITE_DEPTH( x1, y, depth[i] ); + } + } + HW_ENDCLIPLOOP(); + } + HW_UNLOCK(); +} + + +static void TAG(WriteDepthPixels)( GLcontext *ctx, + GLuint n, + const GLint x[], + const GLint y[], + const GLdepth depth[], + const GLubyte mask[] ) +{ + HW_LOCK() + { + GLint i; + LOCAL_DEPTH_VARS; + + if (DBG) fprintf(stderr, "WriteDepthPixels\n"); + + HW_CLIPLOOP() + { + for (i=0;i<n;i++) + { + if (mask[i]) { + const int fy = Y_FLIP(y[i]); + if (CLIPPIXEL(x[i],fy)) + WRITE_DEPTH( x[i], fy, depth[i] ); + } + } + } + HW_ENDCLIPLOOP(); + } + HW_UNLOCK(); +} + + + + +/* Read depth spans and pixels + */ +static void TAG(ReadDepthSpan)( GLcontext *ctx, + GLuint n, GLint x, GLint y, + GLdepth depth[]) +{ + HW_LOCK() + { + GLint x1,n1; + LOCAL_DEPTH_VARS; + + y = Y_FLIP(y); + + if (DBG) fprintf(stderr, "ReadDepthSpan\n"); + + HW_CLIPLOOP() + { + GLint i = 0; + CLIPSPAN(x,y,n,x1,n1,i); + for (;i<n1;i++) + READ_DEPTH( depth[i], (x1+i), y ); + } + HW_ENDCLIPLOOP(); + } + HW_UNLOCK(); +} + +static void TAG(ReadDepthPixels)( GLcontext *ctx, GLuint n, + const GLint x[], const GLint y[], + GLdepth depth[] ) +{ + HW_LOCK() + { + GLint i; + LOCAL_DEPTH_VARS; + + if (DBG) fprintf(stderr, "ReadDepthPixels\n"); + + HW_CLIPLOOP() + { + for (i=0;i<n;i++) { + int fy = Y_FLIP( y[i] ); + if (CLIPPIXEL( x[i], fy )) + READ_DEPTH( depth[i], x[i], fy ); + } + } + HW_ENDCLIPLOOP(); + } + HW_UNLOCK(); +} + + +#undef WRITE_DEPTH +#undef READ_DEPTH +#undef TAG diff --git a/xc/lib/GL/mesa/src/drv/common/shared_texture_lru.c b/xc/lib/GL/mesa/src/drv/common/shared_texture_lru.c new file mode 100644 index 000000000..2fd80eb3e --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/common/shared_texture_lru.c @@ -0,0 +1,88 @@ +#include <stdio.h> +#include "shared_texture_lru.h" + +/* (Re)initialize the global circular LRU list. The last element + * in the array (heap->nrRegions) is the sentinal. Keeping it + * at the end of the array allows the other elements of the array + * to be addressed rationally when looking up objects at a + * particular location in texture memory. + */ +static void resetGlobalLRU( driHeapPtr heap ) +{ + driTexRegion *list = heap->shared->list; + int sz = 1 << heap->logGranularity; + int i; + + heap->localAge = ++heap->shared->texAge; + + for (i = 0 ; (i+1) * sz <= heap->size ; i++) { + list[i].prev = i-1; + list[i].next = i+1; + list[i].age = heap->shared->texAge; + } + + i--; + list[0].prev = heap->nrRegions; + list[i].prev = i-1; + list[i].next = heap->nrRegions; + list[heap->nrRegions].prev = i; + list[heap->nrRegions].next = 0; +} + +/* Called by the client whenever it touches a local texture. + */ +void driUpdateHeap( driHeapPtr heap, int start, int end ) +{ + driTexRegion *list = heap->shared->list; + int i; + + heap->localAge = ++heap->shared->globalAge; + + for (i = start ; i <= end ; i++) + { + list[i].in_use = 1; + list[i].age = heap->localAge; + + /* remove_from_list(i) + */ + list[(unsigned)list[i].next].prev = list[i].prev; + list[(unsigned)list[i].prev].next = list[i].next; + + /* insert_at_head(list, i) + */ + list[i].prev = heap->nrRegions; + list[i].next = list[heap->nrRegions].next; + list[(unsigned)list[heap->nrRegions].next].prev = i; + list[heap->nrRegions].next = i; + } +} + + +/* Called by the client on lock contention to determine whether + * textures have been stolen + */ +void driAgeTextures( driHeapPtr heap ) +{ + driTexRegion *list = heap->shared->list; + int sz = 1 << (heap->logGranularity); + int i, nr = 0; + + /* Have to go right round from the back to ensure stuff ends up + * LRU in the local list... Fix with a cursor pointer. + */ + for (i = list[heap->nrRegions].prev ; + i != heap->nrRegions && nr < heap->nrRegions ; + i = list[i].prev, nr++) + { + if (list[i].age > heap->localAge) + heap->texturesGone( heap->driverContext, heap->heapId, i * sz, sz, 1); + } + + /* Loop or uninitialized heap detected. Reset. + */ + if (nr == heap->nrRegions) { + heap->texturesGone( heap->driverContext, heap->heapId, 0, heap->size, 0); + resetGlobalLRU( heap ); + } +} + diff --git a/xc/lib/GL/mesa/src/drv/common/shared_texture_lru.h b/xc/lib/GL/mesa/src/drv/common/shared_texture_lru.h new file mode 100644 index 000000000..e6cee567d --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/common/shared_texture_lru.h @@ -0,0 +1,76 @@ +#ifndef DRI_TEX_HEAP_H +#define DRI_TEX_HEAP_H + + +/* Private struct. + */ +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 */ +} driTexRegion; + + +/* This is the global part of the shared texture mechanism. + * + * Do not use this struct directly - declare an equivalent one with a + * larger list[] array, tuned to suit your application. + * + * Your expanded struct should be placed in the driver-specific + * portion of the sarea. + */ +struct { + int globalAge; + driTexRegion list[1]; /* drivers will want to define a larger list */ +} driGlobalList; + + +/* This is the client-private part of the mechanism. + * + * Clients will place one or more of these structs in their driver + * context struct to manage one or more global texture heaps. All + * fields except print_local_lru must be filled in. + */ +struct dri_tex_heap_t { + + int heapId; /* client-supplied identifier */ + void *driverContext; /* pointer to the client's context private */ + int size; /* heap size in bytes */ + int logGranularity; /* log base 2 of size of single heap region */ + int nrRegions; /* number of elements in global list */ + driGlobalList *shared; /* pointer to sarea driGlobalList struct */ + int localAge; /* initialize to zero */ + + /* Callback to the client to let it know a region of texture + * space has changed age. The client must integrate this + * information with its local texture knowledge, in particular + * checking whether any of its own textures have been + * invalidated. + */ + void (*textures_gone)( void *driverContext, + int heapId, + int offset, + int size, + int inUse ); + + /* Optional hook for debugging. + */ + void (*print_local_lru)( void *driverContext, + int heapId ); +} driTexHeap; + + +#define DRI_AGE_TEXTURES( heap ) \ + if ((heap)->localAge > (heap)->shared->globalAge) \ + driAgeTextures( heap ); + + +/* This should be called whenever there has been contention on the + * hardware lock. Clients can shortcircuit this slightly by using + * DRI_AGE_TEXTURES, above. + */ +void driAgeTextures( driTexHeap *heap ); + +#endif + + diff --git a/xc/lib/GL/mesa/src/drv/common/spantmp.h b/xc/lib/GL/mesa/src/drv/common/spantmp.h index e10dca1a2..b475c6b18 100644 --- a/xc/lib/GL/mesa/src/drv/common/spantmp.h +++ b/xc/lib/GL/mesa/src/drv/common/spantmp.h @@ -1,37 +1,48 @@ +#ifndef DBG +#define DBG 0 +#endif static void TAG(WriteRGBASpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte rgba[][4], const GLubyte mask[] ) { - GLuint x1,n1; - LOCAL_VARS; - - y = Y_FLIP(y); - - if (DBG) fprintf(stderr, "WriteRGBASpan\n"); - - HW_CLIPLOOP() + HW_LOCK() { - GLuint i = 0; - CLIPSPAN(x,y,n,x1,n1,i); - if (mask) - { - for (i=0;i<n1;i++,x1++) - if (mask[i]) - WRITE_RGBA( x1, y, - rgba[i][0], rgba[i][1], - rgba[i][2], rgba[i][3] ); - } - else - { - for (i=0;i<n1;i++,x1++) - WRITE_RGBA( x1, y, - rgba[i][0], rgba[i][1], - rgba[i][2], rgba[i][3] ); - } + GLint x1; + GLint n1; + LOCAL_VARS; + + y = Y_FLIP(y); + + + HW_CLIPLOOP() + { + GLint i = 0; + CLIPSPAN(x,y,n,x1,n1,i); + + if (DBG) fprintf(stderr, "WriteRGBASpan %d..%d (x1 %d)\n", + (int)i, (int)n1, (int)x1); + + if (mask) + { + for (;i<n1;i++,x1++) + if (mask[i]) + WRITE_RGBA( x1, y, + rgba[i][0], rgba[i][1], + rgba[i][2], rgba[i][3] ); + } + else + { + for (;i<n1;i++,x1++) + WRITE_RGBA( x1, y, + rgba[i][0], rgba[i][1], + rgba[i][2], rgba[i][3] ); + } + } + HW_ENDCLIPLOOP(); } - HW_ENDCLIPLOOP(); + HW_UNLOCK(); } static void TAG(WriteRGBSpan)( const GLcontext *ctx, @@ -39,32 +50,37 @@ static void TAG(WriteRGBSpan)( const GLcontext *ctx, const GLubyte rgb[][3], const GLubyte mask[] ) { - GLuint x1,n1; - LOCAL_VARS; - - y = Y_FLIP(y); - - - if (DBG) fprintf(stderr, "WriteRGBSpan\n"); - - HW_CLIPLOOP() + HW_LOCK() { - GLuint i = 0; - CLIPSPAN(x,y,n,x1,n1,i); - - if (mask) - { - for (;i<n1;i++,x1++) - if (mask[i]) - WRITE_RGBA( x1, y, rgb[i][0], rgb[i][1], rgb[i][2], 0 ); - } - else - { - for (;i<n1;i++,x1++) - WRITE_RGBA( x1, y, rgb[i][0], rgb[i][1], rgb[i][2], 0 ); - } + GLint x1; + GLint n1; + LOCAL_VARS; + + y = Y_FLIP(y); + + HW_CLIPLOOP() + { + GLint i = 0; + CLIPSPAN(x,y,n,x1,n1,i); + + if (DBG) fprintf(stderr, "WriteRGBSpan %d..%d (x1 %d)\n", + (int)i, (int)n1, (int)x1); + + if (mask) + { + for (;i<n1;i++,x1++) + if (mask[i]) + WRITE_RGBA( x1, y, rgb[i][0], rgb[i][1], rgb[i][2], 0 ); + } + else + { + for (;i<n1;i++,x1++) + WRITE_RGBA( x1, y, rgb[i][0], rgb[i][1], rgb[i][2], 0 ); + } + } + HW_ENDCLIPLOOP(); } - HW_ENDCLIPLOOP(); + HW_UNLOCK(); } static void TAG(WriteRGBAPixels)( const GLcontext *ctx, @@ -74,25 +90,29 @@ static void TAG(WriteRGBAPixels)( const GLcontext *ctx, const GLubyte rgba[][4], const GLubyte mask[] ) { - GLuint i; - LOCAL_VARS; - - if (DBG) fprintf(stderr, "WriteRGBAPixels\n"); - - HW_CLIPLOOP() + HW_LOCK() { - for (i=0;i<n;i++) - { - if (mask[i]) { - const int fy = Y_FLIP(y[i]); - if (CLIPPIXEL(x[i],fy)) - WRITE_RGBA( x[i], fy, - rgba[i][0], rgba[i][1], - rgba[i][2], rgba[i][3] ); + GLint i; + LOCAL_VARS; + + if (DBG) fprintf(stderr, "WriteRGBAPixels\n"); + + HW_CLIPLOOP() + { + for (i=0;i<n;i++) + { + if (mask[i]) { + const int fy = Y_FLIP(y[i]); + if (CLIPPIXEL(x[i],fy)) + WRITE_RGBA( x[i], fy, + rgba[i][0], rgba[i][1], + rgba[i][2], rgba[i][3] ); + } + } } - } + HW_ENDCLIPLOOP(); } - HW_ENDCLIPLOOP(); + HW_UNLOCK(); } @@ -100,23 +120,28 @@ static void TAG(WriteMonoRGBASpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte mask[] ) { - GLuint x1,n1; - LOCAL_VARS; - INIT_MONO_PIXEL(p); - - y = Y_FLIP( y ); - - if (DBG) fprintf(stderr, "WriteMonoRGBASpan\n"); - - HW_CLIPLOOP() + HW_LOCK() { - GLuint i = 0; - CLIPSPAN(x,y,n,x1,n1,i); - for (;i<n1;i++,x1++) - if (mask[i]) - WRITE_PIXEL( x1, y, p ); + GLint x1; + GLint n1; + LOCAL_VARS; + INIT_MONO_PIXEL(p); + + y = Y_FLIP( y ); + + if (DBG) fprintf(stderr, "WriteMonoRGBASpan\n"); + + HW_CLIPLOOP() + { + GLint i = 0; + CLIPSPAN(x,y,n,x1,n1,i); + for (;i<n1;i++,x1++) + if (mask[i]) + WRITE_PIXEL( x1, y, p ); + } + HW_ENDCLIPLOOP(); } - HW_ENDCLIPLOOP(); + HW_UNLOCK(); } @@ -125,22 +150,26 @@ static void TAG(WriteMonoRGBAPixels)( const GLcontext *ctx, const GLint x[], const GLint y[], const GLubyte mask[] ) { - GLuint i; - LOCAL_VARS; - INIT_MONO_PIXEL(p); - - if (DBG) fprintf(stderr, "WriteMonoRGBAPixels\n"); - - HW_CLIPLOOP() + HW_LOCK() { - for (i=0;i<n;i++) - if (mask[i]) { - int fy = Y_FLIP(y[i]); - if (CLIPPIXEL( x[i], fy )) - WRITE_PIXEL( x[i], fy, p ); + GLint i; + LOCAL_VARS; + INIT_MONO_PIXEL(p); + + if (DBG) fprintf(stderr, "WriteMonoRGBAPixels\n"); + + HW_CLIPLOOP() + { + for (i=0;i<n;i++) + if (mask[i]) { + int fy = Y_FLIP(y[i]); + if (CLIPPIXEL( x[i], fy )) + WRITE_PIXEL( x[i], fy, p ); + } } - } - HW_ENDCLIPLOOP(); + HW_ENDCLIPLOOP(); + } + HW_UNLOCK(); } @@ -152,42 +181,50 @@ static void TAG(ReadRGBASpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y, GLubyte rgba[][4]) { - GLuint x1,n1; - LOCAL_VARS; + HW_LOCK() + { + GLint x1,n1; + LOCAL_VARS; - y = Y_FLIP(y); + y = Y_FLIP(y); - if (DBG) fprintf(stderr, "ReadRGBASpan\n"); + if (DBG) fprintf(stderr, "ReadRGBASpan\n"); - HW_CLIPLOOP() - { - GLuint i = 0; - CLIPSPAN(x,y,n,x1,n1,i); - for (;i<n1;i++) - READ_RGBA( rgba[i], x1+i, y ); + HW_CLIPLOOP() + { + GLint i = 0; + CLIPSPAN(x,y,n,x1,n1,i); + for (;i<n1;i++) + READ_RGBA( rgba[i], (x1+i), y ); + } + HW_ENDCLIPLOOP(); } - HW_ENDCLIPLOOP(); + HW_UNLOCK(); } static void TAG(ReadRGBAPixels)( const GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLubyte rgba[][4], const GLubyte mask[] ) { - GLuint i; - LOCAL_VARS; + HW_LOCK() + { + GLint i; + LOCAL_VARS; - if (DBG) fprintf(stderr, "ReadRGBAPixels\n"); + if (DBG) fprintf(stderr, "ReadRGBAPixels\n"); - HW_CLIPLOOP() - { - for (i=0;i<n;i++) - if (mask[i]) { - int fy = Y_FLIP( y[i] ); - if (CLIPPIXEL( x[i], fy )) - READ_RGBA( rgba[i], x[i], fy ); + HW_CLIPLOOP() + { + for (i=0;i<n;i++) + if (mask[i]) { + int fy = Y_FLIP( y[i] ); + if (CLIPPIXEL( x[i], fy )) + READ_RGBA( rgba[i], x[i], fy ); + } } + HW_ENDCLIPLOOP(); } - HW_ENDCLIPLOOP(); + HW_UNLOCK(); } diff --git a/xc/lib/GL/mesa/src/drv/i810/Imakefile b/xc/lib/GL/mesa/src/drv/i810/Imakefile index 5f1d93072..5c6a33796 100644 --- a/xc/lib/GL/mesa/src/drv/i810/Imakefile +++ b/xc/lib/GL/mesa/src/drv/i810/Imakefile @@ -1,4 +1,6 @@ +#include <Threads.tmpl> + #define DoNormalLib NormalLibGlx #define DoSharedLib SharedLibGlx #define DoExtraLib SharedLibGlx @@ -10,12 +12,14 @@ ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL #endif #if BuildXF86DRI - DRI_DEFINES = GlxDefines -DFX -DFX_GLIDE3 -DGLIDE3 -DDRIVERTS + DRI_DEFINES = GlxDefines -DDRIVERTS DRI_INCLUDES = -I../../../../dri -I../../../../glx \ + -I../../../dri \ -I$(TOP)/include -I$(TOP)/include/GL \ -I$(XF86OSSRC) -I$(SERVERSRC)/GL/dri \ - -I$(XF86DRIVERSRC)/i810 \ - -I../../../include -I../.. -I../../X + -I$(XF86DRIVERSRC)/i810 \ + -I../../../include -I../.. -I../common -I../../X \ + -I$(XF86OSSRC)/linux/drm/kernel #endif MESA_INCLUDES = -I. -I.. -I../../include @@ -23,20 +27,234 @@ MESA_INCLUDES = -I. -I.. -I../../include DEFINES = $(ALLOC_DEFINES) $(DRI_DEFINES) - INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) $(MESA_INCLUDES) $(DRI_INCLUDES) \ - -I/usr/include/glide - DRISRCS = i810_init.c i810_inithw.c i810_xmesa.c i810clear.c \ - i810context.c i810dd.c i810depth.c i810dma.c \ + INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) $(MESA_INCLUDES) $(DRI_INCLUDES) + + DRISRCS = ../../../dri/dri_mesa.c \ + ../../../../dri/dri_tmm.c + + DRIOBJS = ../../../dri/dri_mesa.o \ + ../../../../dri/dri_tmm.o + + DRMSRCS = ../../../../dri/drm/xf86drm.c \ + ../../../../dri/drm/xf86drmHash.c \ + ../../../../dri/drm/xf86drmRandom.c \ + ../../../../dri/drm/xf86drmSL.c + + DRMOBJS = ../../../../dri/drm/xf86drm.o \ + ../../../../dri/drm/xf86drmHash.o \ + ../../../../dri/drm/xf86drmRandom.o \ + ../../../../dri/drm/xf86drmSL.o + + + I810SRCS = i810_xmesa.c i810clear.c \ + i810dd.c \ i810pipeline.c i810span.c i810state.c i810swap.c \ - i810tex.c i810tris.c i810vb.c + i810tex.c i810tris.c i810vb.c i810fastpath.c i810ioctl.c - DRIOBJS = i810_init.o i810_inithw.o i810_xmesa.o i810clear.o \ - i810context.o i810dd.o i810depth.o i810dma.o \ + I810OBJS = i810_xmesa.o i810clear.o \ + i810dd.o \ i810pipeline.o i810span.o i810state.o i810swap.o \ - i810tex.o i810tris.o i810vb.o + i810tex.o i810tris.o i810vb.o i810fastpath.o i810ioctl.o + + MESASRCS = ../../accum.c \ + ../../alpha.c \ + ../../alphabuf.c \ + ../../attrib.c \ + ../../bbox.c \ + ../../bitmap.c \ + ../../blend.c \ + ../../buffers.c \ + ../../clip.c \ + ../../colortab.c \ + ../../config.c \ + ../../context.c \ + ../../copypix.c \ + ../../cva.c \ + ../../debug_xform.c \ + ../../depth.c \ + ../../dlist.c \ + ../../drawpix.c \ + ../../enable.c \ + ../../enums.c \ + ../../eval.c \ + ../../extensions.c \ + ../../feedback.c \ + ../../fog.c \ + ../../get.c \ + ../../glapi.c \ + ../../glapinoop.c \ + ../../glthread.c \ + ../../hash.c \ + ../../image.c \ + ../../imaging.o \ + ../../light.c \ + ../../lines.c \ + ../../logic.c \ + ../../masking.c \ + ../../matrix.c \ + ../../mem.c \ + ../../mmath.c \ + ../../pb.c \ + ../../pipeline.c \ + ../../pixel.c \ + ../../points.c \ + ../../polygon.c \ + ../../quads.c \ + ../../rastpos.c \ + ../../readpix.c \ + ../../rect.c \ + ../../scissor.c \ + ../../shade.c \ + ../../span.c \ + ../../stages.c \ + ../../state.c \ + ../../stencil.c \ + ../../teximage.c \ + ../../texobj.c \ + ../../texstate.c \ + ../../texture.c \ + ../../translate.c \ + ../../triangle.c \ + ../../varray.c \ + ../../vb.c \ + ../../vbcull.c \ + ../../vbfill.c \ + ../../vbindirect.c \ + ../../vbrender.c \ + ../../vbxform.c \ + ../../vector.c \ + ../../vertices.c \ + ../../winpos.c \ + ../../xform.c \ + ../../zoom.c \ + ../../X86/common_x86.c + + MESAOBJS = ../../accum.o \ + ../../alpha.o \ + ../../alphabuf.o \ + ../../attrib.o \ + ../../bbox.o \ + ../../bitmap.o \ + ../../blend.o \ + ../../buffers.o \ + ../../clip.o \ + ../../colortab.o \ + ../../config.o \ + ../../context.o \ + ../../copypix.o \ + ../../cva.o \ + ../../debug_xform.o \ + ../../depth.o \ + ../../dlist.o \ + ../../drawpix.o \ + ../../enable.o \ + ../../enums.o \ + ../../eval.o \ + ../../extensions.o \ + ../../feedback.o \ + ../../fog.o \ + ../../get.o \ + ../../hash.o \ + ../../hint.o \ + ../../image.o \ + ../../imaging.o \ + ../../light.o \ + ../../lines.o \ + ../../logic.o \ + ../../masking.o \ + ../../matrix.o \ + ../../mem.o \ + ../../mmath.o \ + ../../pb.o \ + ../../pipeline.o \ + ../../pixel.o \ + ../../points.o \ + ../../polygon.o \ + ../../quads.o \ + ../../rastpos.o \ + ../../readpix.o \ + ../../rect.o \ + ../../scissor.o \ + ../../shade.o \ + ../../span.o \ + ../../stages.o \ + ../../state.o \ + ../../stencil.o \ + ../../teximage.o \ + ../../texobj.o \ + ../../texstate.o \ + ../../texture.o \ + ../../translate.o \ + ../../triangle.o \ + ../../varray.o \ + ../../vb.o \ + ../../vbcull.o \ + ../../vbfill.o \ + ../../vbindirect.o \ + ../../vbrender.o \ + ../../vbxform.o \ + ../../vector.o \ + ../../vertices.o \ + ../../winpos.o \ + ../../xform.o \ + ../../zoom.o + +#ifdef i386Architecture + X86_SRCS = ../../X86/x86.c \ + ../../X86/x86a.S \ + ../../X86/common_x86.c \ + ../../X86/common_x86asm.S \ + ../../X86/vertex.S + + X86_OBJS = ../../X86/x86.o \ + ../../X86/x86a.o \ + ../../X86/common_x86.o \ + ../../X86/common_x86asm.o \ + ../../X86/vertex.o + + MMX_SRCS = ../../X86/mmx_blend.S + + MMX_OBJS = ../../X86/mmx_blend.o + +XCOMM Disabling 3Dnow code for the time being. +#if 0 + 3DNOW_SRCS = ../../X86/3dnow.c \ + ../../X86/3dnow_norm_raw.S \ + ../../X86/3dnow_xform_masked1.S \ + ../../X86/3dnow_xform_masked2.S \ + ../../X86/3dnow_xform_masked3.S \ + ../../X86/3dnow_xform_masked4.S \ + ../../X86/3dnow_xform_raw1.S \ + ../../X86/3dnow_xform_raw2.S \ + ../../X86/3dnow_xform_raw3.S \ + ../../X86/3dnow_xform_raw4.S \ + ../../X86/vertex_3dnow.S + + 3DNOW_OBJS = ../../X86/3dnow.o \ + ../../X86/3dnow_norm_raw.o \ + ../../X86/3dnow_xform_masked1.o \ + ../../X86/3dnow_xform_masked2.o \ + ../../X86/3dnow_xform_masked3.o \ + ../../X86/3dnow_xform_masked4.o \ + ../../X86/3dnow_xform_raw1.o \ + ../../X86/3dnow_xform_raw2.o \ + ../../X86/3dnow_xform_raw3.o \ + ../../X86/3dnow_xform_raw4.o \ + ../../X86/vertex_3dnow.o +#endif + +#endif + + ASMSRCS = $(X86_SRCS) $(MMX_SRCS) $(3DNOW_SRCS) + ASMOBJS = $(X86_OBJS) $(MMX_OBJS) $(3DNOW_OBJS) + + COMMONSRCS = ../common/mm.c ../common/hwlog.c + COMMONOBJS = ../common/mm.o ../common/hwlog.o + + SRCS = $(DRISRCS) $(DRMSRCS) $(MESASRCS) $(ASMSRCS) $(COMMONSRCS) $(I810SRCS) + OBJS = $(DRIOBJS) $(DRMOBJS) $(MESAOBJS) $(ASMOBJS) $(COMMONOBJS) $(I810OBJS) - SRCS = $(DRISRCS) - OBJS = $(DRIOBJS) +REQUIREDLIBS += -lm #if !GlxUseBuiltInDRIDriver #undef DoNormalLib NormalLibGlx @@ -57,7 +275,7 @@ LIBNAME = i810_dri.so ALL_OBJS = $(OBJS) ALL_DEPS = DONE SharedDepModuleTarget($(LIBNAME),$(ALL_DEPS),$(ALL_OBJS)) -InstallDynamicModule($(LIBNAME),$(MODULEDIR),.) +InstallDynamicModule($(LIBNAME),$(MODULEDIR)/dri,.) #endif DependTarget() diff --git a/xc/lib/GL/mesa/src/drv/i810/i810_3d_reg.h b/xc/lib/GL/mesa/src/drv/i810/i810_3d_reg.h index 677a35222..e4e274e9a 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810_3d_reg.h +++ b/xc/lib/GL/mesa/src/drv/i810/i810_3d_reg.h @@ -75,7 +75,8 @@ * 4: DR4_* */ #define GFX_OP_DRAWRECT_INFO ((0x3<<29)|(0x1d<<24)|(0x80<<16)|(0x3)) -#define DR1_RECT_CLIP_ENABLE (0x1<<31) +#define DR1_RECT_CLIP_ENABLE (0x0<<31) +#define DR1_RECT_CLIP_DISABLE (0x1<<31) #define DR1_X_DITHER_BIAS_MASK (0x3<<26) #define DR1_X_DITHER_BIAS_SHIFT 26 #define DR1_Y_DITHER_BIAS_MASK (0x3<<24) @@ -107,6 +108,8 @@ #define LCS_UPDATE_LINEWIDTH (0x1<<15) #define LCS_LINEWIDTH_MASK (0x7<<12) #define LCS_LINEWIDTH_SHIFT 12 +#define LCS_LINEWIDTH_0_5 (0x1<<12) +#define LCS_LINEWIDTH_1_0 (0x2<<12) #define LCS_UPDATE_ALPHA_INTERP (0x1<<11) #define LCS_ALPHA_FLAT (0x0<<10) #define LCS_ALPHA_INTERP (0x1<<10) @@ -238,18 +241,6 @@ #define SDM_DST_BOTH_SRC_ALPHA (0xc<<0) #define SDM_DST_BOTH_INV_SRC_ALPHA (0xd<<0) -/* GFXRENDERSTATE_COLOR_CHROMA_KEY, p135 - */ -#define GFX_OP_COLOR_CHROMA_KEY ((0x3<<29)|(0x1d<<24)|(0x2<<16)|0x1) -#define CC1_UPDATE_CC_TEST_ENABLE (1<<28) -#define CC1_CC_TEST_ENABLE (1<<27) -#define CC1_UPDATE_CI_VALUE (1<<26) -#define CC1_UPDATE_CK_LOW_VALUE (1<<25) -#define CC1_UPDATE_CK_HI_VALUE (1<<24) -#define CC1_CK_LOW_VALUE_MASK ((1<<24)-1) -#define CC2_CI_VALUE_MASK (0xff<<24) -#define CC2_CI_VALUE_SHIFT 24 -#define CC2_CK_HIGH_VALUE_MASK ((1<<24)-1) /* GFXRENDERSTATE_COLOR_FACTOR, p134 * @@ -628,13 +619,43 @@ typedef struct { #define DV_PF_565 (0x2<<8) + + +#define GFX_OP_ANTIALIAS ((0x3<<29)|(0x6<<24)) +#define AA_UPDATE_EDGEFLAG (1<<13) +#define AA_ENABLE_EDGEFLAG (1<<12) +#define AA_UPDATE_POLYWIDTH (1<<11) +#define AA_POLYWIDTH_05 (1<<9) +#define AA_POLYWIDTH_10 (2<<9) +#define AA_POLYWIDTH_20 (3<<9) +#define AA_POLYWIDTH_40 (4<<9) +#define AA_UPDATE_LINEWIDTH (1<<8) +#define AA_LINEWIDTH_05 (1<<6) +#define AA_LINEWIDTH_10 (2<<6) +#define AA_LINEWIDTH_20 (3<<6) +#define AA_LINEWIDTH_40 (4<<6) +#define AA_UPDATE_BB_EXPANSION (1<<5) +#define AA_BB_EXPANSION_SHIFT 2 +#define AA_UPDATE_AA_ENABLE (1<<1) +#define AA_ENABLE (1<<0) + +#define GFX_OP_STIPPLE ((0x3<<29)|(0x1d<<24)|(0x83<<16)) +#define ST1_ENABLE (1<<16) +#define ST1_MASK (0xffff) + + /* Indices into buf.Setup where various bits of state are mirrored per * context and per buffer. These can be fired at the card as a unit, * or in a piecewise fashion as required. */ -/* Destbuffer state (includes zbuffer). Drawrect is the only thing - * that needs to be restored for 2d??? +/* Destbuffer state + * - backbuffer linear offset and pitch -- invarient in the current dri + * - zbuffer linear offset and pitch -- also invarient + * - drawing origin in back and depth buffers. + * + * Keep the depth/back buffer state here to acommodate private buffers + * in the future. */ #define I810_DESTREG_DI0 0 /* CMD_OP_DESTBUFFER_INFO (2 dwords) */ #define I810_DESTREG_DI1 1 @@ -667,14 +688,24 @@ typedef struct { #define I810_CTXREG_B1 12 /* GFX_OP_BOOL_1 */ #define I810_CTXREG_B2 13 /* GFX_OP_BOOL_2 */ #define I810_CTXREG_LCS 14 /* GFX_OP_LINEWIDTH_CULL_SHADE_MODE */ -#define I810_CTXREG_SCI0 15 /* GFX_OP_SCISSOR_INFO (3 dwords) */ -#define I810_CTXREG_SCI1 16 -#define I810_CTXREG_SCI2 17 -#define I810_CTXREG_SC 18 /* GFX_OP_SCISSOR */ -#define I810_CTXREG_PV 19 /* GFX_OP_PV_RULE -- Invarient! */ -#define I810_CTXREG_ZA 20 /* GFX_OP_ZBIAS_ALPHAFUNC */ - -#define I810_CTX_SETUP_SIZE (21+1) /* pad to qword */ +#define I810_CTXREG_PV 15 /* GFX_OP_PV_RULE -- Invarient! */ +#define I810_CTXREG_ZA 16 /* GFX_OP_ZBIAS_ALPHAFUNC */ +#define I810_CTXREG_ST0 17 /* GFX_OP_STIPPLE */ +#define I810_CTXREG_ST1 18 +#define I810_CTXREG_AA 19 /* GFX_OP_ANTIALIAS */ +#define I810_CTX_SETUP_SIZE (20) /* pad to qword */ + + +/* Cliprect state - keep seperate from context as it is used for + * drawing triangles to the shared backbuffer, and + * changes more frequently than the 'normal' context. + */ +#define I810_CLIPREG_SCI0 0 /* GFX_OP_SCISSOR_INFO (3 dwords) */ +#define I810_CLIPREG_SCI1 1 +#define I810_CLIPREG_SCI2 2 +#define I810_CLIPREG_SC 3 /* GFX_OP_SCISSOR */ + +#define I810_CLIP_SETUP_SIZE 4 /* Texture state (per tex_buffer) */ diff --git a/xc/lib/GL/mesa/src/drv/i810/i810_init.c b/xc/lib/GL/mesa/src/drv/i810/i810_init.c deleted file mode 100644 index 5f37cd769..000000000 --- a/xc/lib/GL/mesa/src/drv/i810/i810_init.c +++ /dev/null @@ -1,99 +0,0 @@ -/************************************************************************** - -Copyright 1998-1999 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 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 PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR -ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -**************************************************************************/ - -/* - * Authors: - * Keith Whitwell <keithw@precisioninsight.com> - * - * based on tdfx driver by - * Daryll Strauss <daryll@precisioninsight.com> - * - * $PI: # - */ - -#ifdef GLX_DIRECT_RENDERING - -#include <X11/Xlibint.h> -#include "xf86dri.h" -#include "i810_dri.h" -#include "i810_init.h" - -#ifdef DEBUG_LOCKING -char *prevLockFile=0; -int prevLockLine=0; -#endif - -static void performMagic(__DRIscreenPrivate *driScrnPriv) -{ - i810ScreenPrivate *gPriv = (i810ScreenPrivate *)driScrnPriv->private; - I810DRIPtr gDRIPriv = (I810DRIPtr)driScrnPriv->pDevPriv; - - gPriv->regs.handle=gDRIPriv->regs; - gPriv->regs.size=gDRIPriv->regsSize; - gPriv->deviceID=gDRIPriv->deviceID; - gPriv->width=gDRIPriv->width; - gPriv->height=gDRIPriv->height; - gPriv->mem=gDRIPriv->mem; - gPriv->cpp=gDRIPriv->cpp; - gPriv->stride=gDRIPriv->stride; - gPriv->fbOffset=gDRIPriv->fbOffset; - gPriv->backOffset=gDRIPriv->backOffset; - gPriv->depthOffset=gDRIPriv->depthOffset; - gPriv->textureOffset=gDRIPriv->textureOffset; - gPriv->textureSize=gDRIPriv->textureSize; -} - -GLboolean i810MapAllRegions(__DRIscreenPrivate *driScrnPriv) -{ - i810ScreenPrivate *gPriv = (i810ScreenPrivate *)driScrnPriv->private; - - /* First, pick apart pDevPriv & friends */ - performMagic(driScrnPriv); - - if (drmMap(driScrnPriv->fd, gPriv->regs.handle, gPriv->regs.size, - &gPriv->regs.map)) { - return GL_FALSE; - } - - return GL_TRUE; -} - -void i810UnmapAllRegions(__DRIscreenPrivate *driScrnPriv) -{ - i810ScreenPrivate *gPriv = (i810ScreenPrivate *)driScrnPriv->private; - - drmUnmap(gPriv->regs.map, gPriv->regs.size); -} - -/* - * Shutdown hardware - nothing to do... - */ -void i810CloseHardware(void) -{ -} - -#endif diff --git a/xc/lib/GL/mesa/src/drv/i810/i810_init.h b/xc/lib/GL/mesa/src/drv/i810/i810_init.h index c7af9c443..804f66889 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810_init.h +++ b/xc/lib/GL/mesa/src/drv/i810/i810_init.h @@ -27,7 +27,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. /* * Authors: - * Daryll Strauss <daryll@precisioninsight.com> + * Keith Whitwell <keithw@precisioninsight.com> * */ @@ -37,7 +37,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #ifdef GLX_DIRECT_RENDERING #include <sys/time.h> -#include <glide.h> #include "dri_tmm.h" #include "dri_mesaint.h" #include "dri_mesa.h" @@ -45,148 +44,88 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include "xmesaP.h" typedef struct { - drmHandle handle; - drmSize size; - drmAddress map; + drmHandle handle; + drmSize size; + char *map; } i810Region, *i810RegionPtr; typedef struct { - i810Region regs; - int deviceID; - int width; - int height; - int mem; - int cpp; - int stride; - int fbOffset; - int backOffset; - int depthOffset; - int textureOffset; - int textureSize; - __DRIscreenPrivate *driScrnPriv; -} i810ScreenPrivate; + i810Region front; + i810Region back; + i810Region depth; + i810Region tex; -typedef struct { - volatile int *fifoPtr; - volatile int *fifoRead; - volatile int fifoOwner; - volatile int ctxOwner; - volatile int texOwner; -} I810SAREAPriv; + int deviceID; + int width; + int height; + int mem; + + int cpp; /* for front and back buffers */ + int bitsPerPixel; + + int fbFormat; + int fbOffset; + int fbStride; + + int backOffset; + int depthOffset; + + int backPitch; + int backPitchBits; + int textureOffset; + int textureSize; + int logTextureGranularity; + __DRIscreenPrivate *driScrnPriv; + drmBufMapPtr bufs; + +} i810ScreenPrivate; #include "i810context.h" -extern GLboolean i810MapAllRegions(__DRIscreenPrivate *driScrnPriv); -extern void i810UnmapAllRegions(__DRIscreenPrivate *driScrnPriv); -extern GLboolean i810InitHW(XMesaContext c); - -extern void XMesaWindowMoved(XMesaContext *c); -extern void XMesaUpdateState(XMesaContext *c, int windowMoved); -extern void XMesaSetSAREA(XMesaContext *c); - -extern XMesaContext gCC; -extern i810ContextPtr i810Ctx; - -/* -You can turn this on to find locking conflicts. -#define DEBUG_LOCKING -*/ - -#ifdef DEBUG_LOCKING -extern char *prevLockFile; -extern int prevLockLine; -#define DEBUG_LOCK() \ - do { \ - prevLockFile=(__FILE__); \ - prevLockLine=(__LINE__); \ - } while (0) -#define DEBUG_RESET() \ - do { \ - prevLockFile=0; \ - prevLockLine=0; \ - } while (0) -#define DEBUG_CHECK_LOCK() \ - do { \ - if (prevLockFile) { \ - fprintf(stderr, "LOCK SET!\n\tPrevious %s:%d\n\tCurrent: %s:%d\n", \ - prevLockFile, prevLockLine, __FILE__, __LINE__); \ - exit(1); \ - } \ - } while (0) -#else -#define DEBUG_LOCK() -#define DEBUG_RESET() -#define DEBUG_CHECK_LOCK() -#endif +extern void i810GetLock( i810ContextPtr imesa, GLuint flags ); +extern void i810EmitHwStateLocked( i810ContextPtr imesa ); +extern void i810EmitScissorValues( i810ContextPtr imesa, int box_nr, int emit ); +extern void i810EmitDrawingRectangle( i810ContextPtr imesa ); +extern void i810XMesaSetBackClipRects( i810ContextPtr imesa ); +extern void i810XMesaSetFrontClipRects( i810ContextPtr imesa ); -/* !!! We may want to separate locks from locks with validation. - This could be used to improve performance for those things - commands that do not do any drawing !!! */ - -#define DRM_LIGHT_LOCK_RETURN(fd,lock,context,__ret) \ - do { \ - DRM_CAS(lock,context,DRM_LOCK_HELD|context,__ret); \ - if (__ret) drmGetLock(fd,context,0); \ - } while(0) - -/* Lock the hardware using the global current context */ -#define LOCK_HARDWARE() \ - do { \ - int stamp; \ - char __ret=0; \ - __DRIdrawablePrivate *dPriv = gCC->driContextPriv->driDrawablePriv; \ - __DRIscreenPrivate *sPriv = dPriv->driScreenPriv; \ - DEBUG_CHECK_LOCK(); \ - DRM_LIGHT_LOCK_RETURN(sPriv->fd, &sPriv->pSAREA->lock, \ - dPriv->driContextPriv->hHWContext, __ret); \ - if (__ret) __ret=1; \ - stamp=dPriv->lastStamp; \ - XMESA_VALIDATE_DRAWABLE_INFO(gCC->display, sPriv, dPriv); \ - if (*(dPriv->pStamp)!=stamp) __ret=2; \ - if (__ret) XMesaUpdateState(gCC, __ret==2); \ - DEBUG_LOCK(); \ - } while (0) -/* Unlock the hardware using the global current context */ -#define UNLOCK_HARDWARE() \ - do { \ - __DRIdrawablePrivate *dPriv = gCC->driContextPriv->driDrawablePriv; \ - __DRIscreenPrivate *sPriv = dPriv->driScreenPriv; \ - XMesaSetSAREA(gCC); \ - DRM_UNLOCK(sPriv->fd, &sPriv->pSAREA->lock, \ - dPriv->driContextPriv->hHWContext); \ - DEBUG_RESET(); \ - } while (0) +#define GET_DISPATCH_AGE( imesa ) imesa->sarea->last_dispatch +#define GET_ENQUEUE_AGE( imesa ) imesa->sarea->last_enqueue -#define BEGIN_BOARD_LOCK() LOCK_HARDWARE() -#define END_BOARD_LOCK() UNLOCK_HARDWARE() -/* - This pair of macros makes a loop over the drawing operations - so it is not self contained and doesn't have the nice single - statement semantics of most macros -*/ -#define BEGIN_CLIP_LOOP() \ - do { \ - __DRIdrawablePrivate *dPriv = gCC->driContextPriv->driDrawablePriv; \ - int _nc = dPriv->numClipRects; \ - LOCK_HARDWARE(); \ - while (_nc--) { \ - if (i810Ctx->needClip) { \ - i810Ctx->clipMinX=dPriv->pClipRects[_nc].x1; \ - i810Ctx->clipMaxX=dPriv->pClipRects[_nc].x2; \ - i810Ctx->clipMinY=dPriv->pClipRects[_nc].y1; \ - i810Ctx->clipMaxY=dPriv->pClipRects[_nc].y2; \ - i810SetScissorValues(i810Ctx->glCtx); \ - } - -#define END_CLIP_LOOP() \ - } \ - UNLOCK_HARDWARE(); \ +/* Lock the hardware and validate our state. + */ +#define LOCK_HARDWARE( imesa ) \ + do { \ + char __ret=0; \ + DRM_CAS(imesa->driHwLock, imesa->hHWContext, \ + (DRM_LOCK_HELD|imesa->hHWContext), __ret); \ + if (__ret) \ + i810GetLock( imesa, 0 ); \ } while (0) + + +/* Unlock the hardware using the global current context + */ +#define UNLOCK_HARDWARE(imesa) \ + DRM_UNLOCK(imesa->driFd, imesa->driHwLock, imesa->hHWContext); + + +/* This is the wrong way to do it, I'm sure. Otherwise the drm + * bitches that I've already got the heavyweight lock. At worst, + * this is 3 ioctls. The best solution probably only gets me down + * to 2 ioctls in the worst case. + */ +#define LOCK_HARDWARE_QUIESCENT( imesa ) do { \ + LOCK_HARDWARE( imesa ); \ + i810RegetLockQuiescent( imesa ); \ +} while(0) + + #endif #endif diff --git a/xc/lib/GL/mesa/src/drv/i810/i810_inithw.c b/xc/lib/GL/mesa/src/drv/i810/i810_inithw.c deleted file mode 100644 index 6bcae44c7..000000000 --- a/xc/lib/GL/mesa/src/drv/i810/i810_inithw.c +++ /dev/null @@ -1,99 +0,0 @@ -/************************************************************************** - -Copyright 1998-1999 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 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 PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR -ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - -**************************************************************************/ - -/* - * Authors: - * Daryll Strauss <daryll@precisioninsight.com> - * - * $PI: $ - */ - -#ifdef GLX_DIRECT_RENDERING - -#include "i810_init.h" -#include <glide.h> - -GLboolean i810InitHW(XMesaContext c) -{ - /* KW: Would be nice to make one of these a member of the other. - */ - i810ContextPtr cPriv = (i810ContextPtr)c->private; - __DRIdrawablePrivate *driDrawPriv = c->driContextPriv->driDrawablePriv; - __DRIscreenPrivate *driScrnPriv = driDrawPriv->driScreenPriv; - i810ScreenPrivate *sPriv = (i810ScreenPrivate*)driScrnPriv->private; - -#ifdef DEBUG_LOCKING - fprintf(stderr, "Debug locking enabled\n"); -#endif - - if (cPriv->initDone) return GL_TRUE; - - cPriv->width=driDrawPriv->w; - cPriv->height=driDrawPriv->h; - - DRM_LIGHT_LOCK(driScrnPriv->fd, &driScrnPriv->pSAREA->lock, - driDrawPriv->driContextPriv->hHWContext); - FX_grGlideInit_NoLock(); - - - if (sPriv->deviceID==0x3) - cPriv->haveTwoTMUs=GL_FALSE; - else - cPriv->haveTwoTMUs=GL_TRUE; - - /* !!! We are forcing these !!! */ - cPriv->haveDoubleBuffer=GL_TRUE; - cPriv->haveAlphaBuffer=GL_FALSE; - cPriv->haveZBuffer=GL_TRUE; - cPriv->haveGlobalPaletteTexture=GL_FALSE; - - cPriv->glideContext = FX_grSstWinOpen_NoLock((FxU32)-1, GR_RESOLUTION_NONE, - GR_REFRESH_NONE, - GR_COLORFORMAT_ARGB, - GR_ORIGIN_LOWER_LEFT, 2, 1); - - - grDRIResetSAREA(); - - DRM_UNLOCK(driScrnPriv->fd, &driScrnPriv->pSAREA->lock, - driDrawPriv->driContextPriv->hHWContext); - - cPriv->needClip=1; - - if (!fxDDInitFxMesaContext( fxMesa )) - return GL_FALSE; - - cPriv->initDone=GL_TRUE; - return GL_TRUE; - -} - -#endif - - - - diff --git a/xc/lib/GL/mesa/src/drv/i810/i810_xmesa.c b/xc/lib/GL/mesa/src/drv/i810/i810_xmesa.c index d4b540507..7716b4634 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810_xmesa.c +++ b/xc/lib/GL/mesa/src/drv/i810/i810_xmesa.c @@ -27,21 +27,54 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. /* * Authors: - * Daryll Strauss <daryll@precisioninsight.com> + * Keith Whitwell <keithw@precisioninsight.com> * */ #ifdef GLX_DIRECT_RENDERING #include <X11/Xlibint.h> -#include <glide.h> +#include <stdio.h> + #include "i810_init.h" #include "context.h" #include "vbxform.h" #include "matrix.h" +#include "simple_list.h" + +#include "i810dd.h" +#include "i810state.h" +#include "i810tex.h" +#include "i810span.h" +#include "i810tris.h" +#include "i810swap.h" +#include "i810pipeline.h" +#include "i810ioctl.h" + +#include "i810_dri.h" + + + +#ifndef I810_DEBUG +int I810_DEBUG = (0 +/* | DEBUG_ALWAYS_SYNC */ +/* | DEBUG_VERBOSE_RING */ +/* | DEBUG_VERBOSE_OUTREG */ +/* | DEBUG_VERBOSE_MSG */ +/* | DEBUG_NO_OUTRING */ +/* | DEBUG_NO_OUTREG */ +/* | DEBUG_VERBOSE_API */ +/* | DEBUG_VERBOSE_2D */ +/* | DEBUG_VERBOSE_DRI */ +/* | DEBUG_VALIDATE_RING */ +/* | DEBUG_VERBOSE_IOCTL */ + ); +#endif + + +static i810ContextPtr i810Ctx = 0; -XMesaContext gCC = 0; -i810ContextPtr *i810Ctx = 0; +i810Glx_t i810glx; static int count_bits(unsigned int n) { @@ -76,32 +109,106 @@ static int count_bits(unsigned int n) */ -GLboolean XMesaInitDriver(__DRIscreenPrivate *driScrnPriv) +GLboolean XMesaInitDriver(__DRIscreenPrivate *sPriv) { - i810ScreenPrivate *gsp; + i810ScreenPrivate *i810Screen; + I810DRIPtr gDRIPriv = (I810DRIPtr)sPriv->pDevPriv; /* Allocate the private area */ - gsp = (i810ScreenPrivate *)Xmalloc(sizeof(i810ScreenPrivate)); - if (!gsp) return GL_FALSE; + i810Screen = (i810ScreenPrivate *)Xmalloc(sizeof(i810ScreenPrivate)); + if (!i810Screen) return GL_FALSE; + + i810Screen->driScrnPriv = sPriv; + sPriv->private = (void *)i810Screen; + + i810Screen->deviceID=gDRIPriv->deviceID; + i810Screen->width=gDRIPriv->width; + i810Screen->height=gDRIPriv->height; + i810Screen->mem=gDRIPriv->mem; + i810Screen->cpp=gDRIPriv->cpp; + i810Screen->fbStride=gDRIPriv->fbStride; + i810Screen->fbOffset=gDRIPriv->fbOffset; + + if (gDRIPriv->bitsPerPixel == 15) + i810Screen->fbFormat = DV_PF_555; + else + i810Screen->fbFormat = DV_PF_565; + + i810Screen->backOffset=gDRIPriv->backOffset; + i810Screen->depthOffset=gDRIPriv->depthOffset; + i810Screen->backPitch = gDRIPriv->auxPitch; + i810Screen->backPitchBits = gDRIPriv->auxPitchBits; + i810Screen->textureOffset=gDRIPriv->textureOffset; + i810Screen->textureSize=gDRIPriv->textureSize; + i810Screen->logTextureGranularity = gDRIPriv->logTextureGranularity; + + if (1) + fprintf(stderr, "Tex heap size %x, granularity %x bytes\n", + i810Screen->textureSize, 1<<(i810Screen->logTextureGranularity)); + + i810Screen->bufs = drmMapBufs(sPriv->fd); + + + i810Screen->back.handle = gDRIPriv->backbuffer; + i810Screen->back.size = gDRIPriv->backbufferSize; + + if (drmMap(sPriv->fd, + i810Screen->back.handle, + i810Screen->back.size, + (drmAddress *)&i810Screen->back.map) != 0) + { + Xfree(i810Screen); + return GL_FALSE; + } + + i810Screen->depth.handle = gDRIPriv->depthbuffer; + i810Screen->depth.size = gDRIPriv->depthbufferSize; - gsp->driScrnPriv = driScrnPriv; + if (drmMap(sPriv->fd, + i810Screen->depth.handle, + i810Screen->depth.size, + (drmAddress *)&i810Screen->depth.map) != 0) + { + Xfree(i810Screen); + return GL_FALSE; + } - driScrnPriv->private = (void *)gsp; + i810Screen->tex.handle = gDRIPriv->textures; + i810Screen->tex.size = gDRIPriv->textureSize; - if (!i810MapAllRegions(driScrnPriv)) { - Xfree(driScrnPriv->private); + if (drmMap(sPriv->fd, + i810Screen->tex.handle, + i810Screen->tex.size, + (drmAddress *)&i810Screen->tex.map) != 0) + { + Xfree(i810Screen); return GL_FALSE; } + + /* Ditch i810glx in favor of i810Screen? + */ + memset(&i810glx, 0, sizeof(i810glx)); + i810glx.texVirtual = i810Screen->tex.map; + + i810DDFastPathInit(); + i810DDTrifuncInit(); + i810DDSetupInit(); + return GL_TRUE; } /* Accessed by dlsym from dri_mesa_init.c */ -void XMesaResetDriver(__DRIscreenPrivate *driScrnPriv) +void XMesaResetDriver(__DRIscreenPrivate *sPriv) { - i810UnmapAllRegions(driScrnPriv); /* in i810_init.c */ - Xfree(driScrnPriv->private); + i810ScreenPrivate *i810Screen = (i810ScreenPrivate *)sPriv->private; + + /* Need to unmap all the bufs and maps here: + */ + + + Xfree(i810Screen); } /* Accessed by dlsym from dri_mesa_init.c @@ -135,27 +242,18 @@ XMesaVisual XMesaCreateVisual(XMesaDisplay *display, v->display = display; v->level = level; - - v->gl_visual = (GLvisual *)Xmalloc(sizeof(GLvisual)); + v->gl_visual = gl_create_visual(rgb_flag, GL_FALSE, db_flag, stereo_flag, + depth_size, stencil_size, accum_size, 0, + count_bits(visinfo->red_mask), + count_bits(visinfo->green_mask), + count_bits(visinfo->blue_mask), + GL_FALSE); if (!v->gl_visual) { Xfree(v->visinfo); - XFree(v); - return 0; + Xfree(v); + return NULL; } - - v->gl_visual->RGBAflag = rgb_flag; - v->gl_visual->DBflag = db_flag; - v->gl_visual->StereoFlag = stereo_flag; - - v->gl_visual->RedBits = count_bits(visinfo->red_mask); - v->gl_visual->GreenBits = count_bits(visinfo->green_mask); - v->gl_visual->BlueBits = count_bits(visinfo->blue_mask); - v->gl_visual->AlphaBits = 0; /* Not currently supported */ - - v->gl_visual->AccumBits = accum_size; - v->gl_visual->DepthBits = depth_size; - v->gl_visual->StencilBits = stencil_size; - + return v; } @@ -169,71 +267,143 @@ void XMesaDestroyVisual(XMesaVisual v) XMesaContext XMesaCreateContext(XMesaVisual v, XMesaContext share_list, __DRIcontextPrivate *driContextPriv) { + GLcontext *ctx; XMesaContext c; - i810ContextPtr cPriv; - __DRIscreenPrivate *driScrnPriv = driContextPriv->driScreenPriv; - i810ScreenPrivate *sPriv = (i810ScreenPrivate *)driScrnPriv->private; - I810SAREAPriv *saPriv; - GLcontext *shareCtx; -/* int **fifoPtr; */ + i810ContextPtr imesa; + __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv; + i810ScreenPrivate *i810Screen = (i810ScreenPrivate *)sPriv->private; + drm_i810_sarea_t *saPriv=(drm_i810_sarea_t *)(((char*)sPriv->pSAREA)+ + sizeof(XF86DRISAREARec)); + + GLcontext *shareCtx = 0; c = (XMesaContext)Xmalloc(sizeof(struct xmesa_context)); - if (!c) return 0; + if (!c) { + return 0; + } + + imesa = (i810ContextPtr)Xcalloc(sizeof(i810Context), 1); + if (!imesa) { + Xfree(c); + return 0; + } c->driContextPriv = driContextPriv; c->xm_visual = v; c->xm_buffer = 0; /* Set by MakeCurrent */ c->display = v->display; + c->private = (void *)imesa; - cPriv = (i810ContextPtr)Xmalloc(sizeof(i810Context)); - if (!cPriv) { - Xfree(c); - return NULL; - } + if (share_list) + shareCtx=((i810ContextPtr)(share_list->private))->glCtx; - cPriv->hHWContext = driContextPriv->hHWContext; - cPriv->i810ScrnPriv = sPriv; - c->private = (void *)cPriv; + ctx = imesa->glCtx = gl_create_context(v->gl_visual, shareCtx, + (void*)imesa, GL_TRUE); - cPriv->glVis=v->gl_visual; - cPriv->glBuffer=gl_create_framebuffer(v->gl_visual); - cPriv->screen_width=sPriv->width; - cPriv->screen_height=sPriv->height; - cPriv->new_state = ~0; + /* Set the maximum texture size small enough that we can guarentee + * that both texture units can bind a maximal texture and have them + * in memory at once. + */ + if (i810Screen->textureSize < 2*1024*1024) { + ctx->Const.MaxTextureLevels = 8; + ctx->Const.MaxTextureSize = 1<<8; + } else if (i810Screen->textureSize < 8*1024*1024) { + ctx->Const.MaxTextureLevels = 9; + ctx->Const.MaxTextureSize = 1<<9; + } else { + ctx->Const.MaxTextureLevels = 10; + ctx->Const.MaxTextureSize = 1<<10; + } - if (share_list) - shareCtx=((i810ContextPtr)(share_list->private))->glCtx; - else - shareCtx=0; - cPriv->glCtx=gl_create_context(v->gl_visual, shareCtx, (void*)cPriv, GL_TRUE); - cPriv->initDone=GL_FALSE; - saPriv=(I810SAREAPriv*)((void*)driScrnPriv->pSAREA+sizeof(XF86DRISAREARec)); + /* Dri stuff + */ + imesa->display = v->display; + imesa->hHWContext = driContextPriv->hHWContext; + imesa->driFd = sPriv->fd; + imesa->driHwLock = &sPriv->pSAREA->lock; + imesa->i810Screen = i810Screen; + imesa->driScreen = sPriv; + imesa->sarea = saPriv; - fprintf(stderr, "would call grDRIOpen here\n"); + imesa->glBuffer = gl_create_framebuffer(v->gl_visual, + GL_FALSE, + v->gl_visual->StencilBits > 0, + v->gl_visual->AccumBits > 0, + v->gl_visual->AlphaBits > 0); -/* - grDRIOpen(driScrnPriv->pFB, sPriv->regs.map, sPriv->deviceID, - sPriv->width, sPriv->height, sPriv->mem, sPriv->cpp, sPriv->stride, - sPriv->fifoOffset, sPriv->fifoSize, sPriv->fbOffset, - sPriv->backOffset, sPriv->depthOffset, sPriv->textureOffset, - sPriv->textureSize, &saPriv->fifoPtr, &saPriv->fifoRead); -*/ + imesa->texHeap = mmInit( 0, i810Screen->textureSize ); + + + /* Utah stuff + */ + imesa->renderindex = -1; /* impossible value */ + imesa->new_state = ~0; + imesa->dirty = ~0; + + make_empty_list(&imesa->TexObjList); + make_empty_list(&imesa->SwappedOut); + + imesa->TextureMode = ctx->Texture.Unit[0].EnvMode; + imesa->CurrentTexObj[0] = 0; + imesa->CurrentTexObj[1] = 0; + + i810DDExtensionsInit( ctx ); + + i810DDInitStateFuncs( ctx ); + i810DDInitTextureFuncs( ctx ); + i810DDInitSpanFuncs( ctx ); + i810DDInitDriverFuncs( ctx ); + i810DDInitIoctlFuncs( ctx ); + + ctx->Driver.TriangleCaps = (DD_TRI_CULL| + DD_TRI_LIGHT_TWOSIDE| + DD_TRI_STIPPLE| + DD_TRI_OFFSET); + + /* Ask mesa to clip fog coordinates for us. + */ + ctx->TriangleCaps |= DD_CLIP_FOG_COORD; + + ctx->Shared->DefaultD[2][0].DriverData = 0; + ctx->Shared->DefaultD[2][1].DriverData = 0; + + if (ctx->VB) + i810DDRegisterVB( ctx->VB ); + + if (ctx->NrPipelineStages) + ctx->NrPipelineStages = + i810DDRegisterPipelineStages(ctx->PipelineStage, + ctx->PipelineStage, + ctx->NrPipelineStages); + + i810DDInitState( imesa ); return c; } void XMesaDestroyContext(XMesaContext c) { - i810ContextPtr cPriv; + i810ContextPtr imesa = (i810ContextPtr) c->private; + + if (imesa) { + i810TextureObjectPtr next_t, t; - cPriv=(i810ContextPtr)c->private; - if (cPriv) { - gl_destroy_context(cPriv->glCtx); - gl_destroy_framebuffer(cPriv->glBuffer); + gl_destroy_context(imesa->glCtx); + gl_destroy_framebuffer(imesa->glBuffer); + + foreach_s (t, next_t, &(imesa->TexObjList)) + i810DestroyTexObj(imesa, t); + + foreach_s (t, next_t, &(imesa->SwappedOut)) + i810DestroyTexObj(imesa, t); + + Xfree(imesa); + + c->private = 0; } } @@ -254,137 +424,232 @@ void XMesaDestroyBuffer(XMesaBuffer b) { } -void XMesaSwapBuffers(XMesaBuffer b) +void XMesaSwapBuffers(XMesaBuffer bogus) { - FxI32 result; - XMesaContext *xmc = b->xm_context; - i810ContextPtr imesa; - - if (!xmc || !xmc->private) return; + i810ContextPtr imesa = i810Ctx; - imesa = (i810ContextPtr) xmc->private; + FLUSH_VB( imesa->glCtx, "swap buffers" ); + i810SwapBuffers(imesa); +} + +static void i810InitClipRects( i810ContextPtr imesa ) +{ + switch (imesa->numClipRects) { + case 0: + imesa->ClipSetup[I810_CLIPREG_SC] = ( GFX_OP_SCISSOR | + SC_UPDATE_SCISSOR ); + imesa->ClipSetup[I810_CLIPREG_SCI1] = 0; + imesa->ClipSetup[I810_CLIPREG_SCI2] = 0; + break; + case 1: + break; + default: + break; + } + imesa->dirty |= I810_EMIT_CLIPRECT; +} - fprintf(stderr, "imesa %x i810Ctx %x\n", imesa, i810Ctx ); - FLUSH_VB( imesa->glCtx, "swap buffers" ); - if (imesa->haveDoubleBuffer) { - i810BackToFront(imesa); - i810Ctx->stats.swapBuffer++; +void i810XMesaSetFrontClipRects( i810ContextPtr imesa ) +{ + __DRIdrawablePrivate *dPriv = imesa->driDrawable; + + imesa->numClipRects = dPriv->numClipRects; + imesa->pClipRects = dPriv->pClipRects; + imesa->drawX = dPriv->x; + imesa->drawY = dPriv->y; + + imesa->drawMap = imesa->driScreen->pFB; + i810EmitDrawingRectangle( imesa ); + i810InitClipRects( imesa ); +} + + +void i810XMesaSetBackClipRects( i810ContextPtr imesa ) +{ + __DRIdrawablePrivate *dPriv = imesa->driDrawable; + int i; + + if (dPriv->numBackClipRects == 0) + { + if (I810_DEBUG & DEBUG_VERBOSE_DRI) + fprintf(stderr, "FRONT_CLIPRECTS, %d rects\n", + dPriv->numClipRects); + + imesa->numClipRects = dPriv->numClipRects; + imesa->pClipRects = dPriv->pClipRects; + imesa->drawX = dPriv->x; + imesa->drawY = dPriv->y; } else { - fprintf(stderr, "No double buffer\n"); + if (I810_DEBUG & DEBUG_VERBOSE_DRI) + fprintf(stderr, "BACK_RECTS, %d rects\n", + dPriv->numBackClipRects); + + imesa->numClipRects = dPriv->numBackClipRects; + imesa->pClipRects = dPriv->pBackClipRects; + imesa->drawX = dPriv->backX; + imesa->drawY = dPriv->backY; } + + imesa->drawMap = imesa->i810Screen->back.map; + i810EmitDrawingRectangle( imesa ); + i810InitClipRects( imesa ); + + if (I810_DEBUG & DEBUG_VERBOSE_DRI) + for (i = 0 ; i < imesa->numClipRects ; i++) + fprintf(stderr, "cliprect %d: %d,%d - %d,%d\n", + i, + imesa->pClipRects[i].x1, + imesa->pClipRects[i].y1, + imesa->pClipRects[i].x2, + imesa->pClipRects[i].y2); +} + + +static void i810XMesaWindowMoved( i810ContextPtr imesa ) +{ + if (0) + fprintf(stderr, "i810XMesaWindowMoved\n\n"); + + switch (imesa->glCtx->Color.DriverDrawBuffer) { + case GL_FRONT_LEFT: + i810XMesaSetFrontClipRects( imesa ); + break; + case GL_BACK_LEFT: + i810XMesaSetBackClipRects( imesa ); + break; + default: + fprintf(stderr, "fallback buffer\n"); + break; + } +} + + +GLboolean XMesaUnbindContext(XMesaContext c) +{ + if (c->private) + ((i810ContextPtr)c->private)->dirty = ~0; + + return GL_TRUE; } -/* This looks buggy to me: + +/* This looks buggy to me - the 'b' variable isn't used anywhere... + * Hmm - It seems that the drawable is already hooked in to + * driDrawablePriv. */ GLboolean XMesaMakeCurrent(XMesaContext c, XMesaBuffer b) { - __DRIdrawablePrivate *driDrawPriv; + + if (c->private==(void *)i810Ctx) return GL_TRUE; if (c) { - if (c==gCC) return GL_TRUE; - gCC = c; - i810Ctx = (i810ContextPtr)c->private; + __DRIdrawablePrivate *dPriv = c->driContextPriv->driDrawablePriv; - fprintf(stderr, "Make current\n"); - driDrawPriv = c->driContextPriv->driDrawablePriv; - if (!i810Ctx->initDone) { - i810Ctx->width=driDrawPriv->w; - i810Ctx->height=driDrawPriv->h; - if (!i810InitHW(c)) return GL_FALSE; - /* Zap the width to force XMesaWindowMoved to execute */ - i810Ctx->width=0; - } - FX_grSstSelect(i810Ctx->board); - XMesaWindowMoved(); + i810Ctx = (i810ContextPtr)c->private; - FX_grGlideSetState((GrState*)i810Ctx->state); gl_make_current(i810Ctx->glCtx, i810Ctx->glBuffer); - fxSetupDDPointers(i810Ctx->glCtx); + + i810Ctx->driDrawable = dPriv; + i810Ctx->dirty = ~0; + + i810XMesaWindowMoved( i810Ctx ); + if (!i810Ctx->glCtx->Viewport.Width) - gl_Viewport(i810Ctx->glCtx, 0, 0, driDrawPriv->w, driDrawPriv->h); + gl_Viewport(i810Ctx->glCtx, 0, 0, dPriv->w, dPriv->h); + } else { gl_make_current(0,0); - gCC = NULL; i810Ctx = NULL; } return GL_TRUE; } -void i810XMesaWindowMoved( XMesaContext xmc ) + +void i810GetLock( i810ContextPtr imesa, GLuint flags ) { - i810ContextPtr imesa = (i810ContextPtr) xmc->private; - __DRIdrawablePrivate *dPriv = xmc->driContextPriv->driDrawablePriv; - GLcontext *ctx=imesa->glCtx; - -/* grDRIPosition(dPriv->x, dPriv->y, dPriv->w, dPriv->h, */ -/* dPriv->numClipRects, dPriv->pClipRects); */ - - - imesa->numClipRects=dPriv->numClipRects; - imesa->pClipRects=dPriv->pClipRects; - if (dPriv->x!=imesa->x_offset || dPriv->y!=imesa->y_offset || - dPriv->w!=imesa->width || dPriv->h!=imesa->height) { - imesa->x_offset=dPriv->x; - imesa->y_offset=dPriv->y; - imesa->width=dPriv->w; - imesa->height=dPriv->h; - imesa->y_delta=imesa->screen_height-imesa->y_offset-imesa->height; + __DRIdrawablePrivate *dPriv = imesa->driDrawable; + __DRIscreenPrivate *sPriv = imesa->driScreen; + drm_i810_sarea_t *sarea = imesa->sarea; + int me = imesa->hHWContext; + int stamp = dPriv->lastStamp; + + + if (0) fprintf(stderr, ".\n"); + + /* We know there has been contention. + */ + drmGetLock(imesa->driFd, imesa->hHWContext, flags); + + + /* Note contention for throttling hint + */ + imesa->any_contend = 1; + + /* If the window moved, may need to set a new cliprect now. + * + * NOTE: This releases and regains the hw lock, so all state + * checking must be done *after* this call: + */ + XMESA_VALIDATE_DRAWABLE_INFO(imesa->display, sPriv, dPriv); + + + if (0) + fprintf(stderr, "i810GetLock, last enque: %d last dispatch: %d\n", + sarea->last_enqueue, + sarea->last_dispatch); + + /* If we lost context, need to dump all registers to hardware. + * Note that we don't care about 2d contexts, even if they perform + * accelerated commands, so the DRI locking in the X server is even + * more broken than usual. + */ + if (sarea->ctxOwner != me) { + i810glx.c_ctxlost++; + imesa->dirty |= I810_UPLOAD_CTX; + imesa->dirty |= I810_EMIT_CLIPRECT; + imesa->dirty |= I810_UPLOAD_BUFFERS; + sarea->ctxOwner = me; } - switch (dPriv->numClipRects) { - case 0: - imesa->clipMinX=dPriv->x; - imesa->clipMaxX=dPriv->x+dPriv->w; - imesa->clipMinY=dPriv->y; - imesa->clipMaxY=dPriv->y+dPriv->h; - fxSetScissorValues(ctx); - imesa->needClip=0; - break; - case 1: - imesa->clipMinX=dPriv->pClipRects[0].x1; - imesa->clipMaxX=dPriv->pClipRects[0].x2; - imesa->clipMinY=dPriv->pClipRects[0].y1; - imesa->clipMaxY=dPriv->pClipRects[0].y2; - fxSetScissorValues(ctx); - imesa->needClip=0; - break; - default: - imesa->needClip=1; - } -} -void i810XMesaUpdateState(XMesaContext *xmc, int windowMoved) { - __DRIdrawablePrivate *dPriv = xmc->driContextPriv->driDrawablePriv; - __DRIscreenPrivate *sPriv = dPriv->driScreenPriv; - I810SAREAPriv *saPriv=(I810SAREAPriv*)(((char*)sPriv->pSAREA)+sizeof(XF86DRISAREARec)); - - /* fprintf(stderr, "In FifoPtr=%d FifoRead=%d\n", saPriv->fifoPtr, saPriv->fifoRead); */ - if (saPriv->fifoOwner!=dPriv->driContextPriv->hHWContext) { - grDRIImportFifo(saPriv->fifoPtr, saPriv->fifoRead); - } - if (saPriv->ctxOwner!=dPriv->driContextPriv->hHWContext) { - grDRIInvalidateAll(); - /* This shouldn't be needed if the state is reset by Glide */ - /* FX_grConstantColorValue_NoLock(FXCOLOR4(&i810Ctx->constColor)); */ - } - if (saPriv->texOwner!=dPriv->driContextPriv->hHWContext) { - fxTMRestoreTextures(i810Ctx); - } - if (windowMoved) - XMesaWindowMoved( xmc ); -} + /* Shared texture managment - if another client has played with + * texture space, figure out which if any of our textures have been + * ejected, and update our global LRU. + */ + if (sarea->texAge != imesa->texAge) { + int sz = 1 << (imesa->i810Screen->logTextureGranularity); + int idx, nr = 0; + + /* Have to go right round from the back to ensure stuff ends up + * LRU in our local list... + */ + for (idx = sarea->texList[I810_NR_TEX_REGIONS].prev ; + idx != I810_NR_TEX_REGIONS && nr < I810_NR_TEX_REGIONS ; + idx = sarea->texList[idx].prev, nr++) + { + if (sarea->texList[idx].age > imesa->texAge) + i810TexturesGone(imesa, idx * sz, sz, sarea->texList[idx].in_use); + } -void i810XMesaSetSAREA( XMesaContext *xmc ) { - __DRIdrawablePrivate *dPriv = xmc->driContextPriv->driDrawablePriv; - __DRIscreenPrivate *sPriv = dPriv->driScreenPriv; - I810SAREAPriv *saPriv=(I810SAREAPriv*)(((char*)sPriv->pSAREA)+sizeof(XF86DRISAREARec)); + if (nr == I810_NR_TEX_REGIONS) { + i810TexturesGone(imesa, 0, imesa->i810Screen->textureSize, 0); + i810ResetGlobalLRU( imesa ); + } + + if (0) fprintf(stderr, "imesa %d sarea %d\n", imesa->texAge, sarea->texAge); + imesa->dirty |= I810_UPLOAD_TEX0IMAGE; + imesa->dirty |= I810_UPLOAD_TEX1IMAGE; + imesa->texAge = sarea->texAge; + } - saPriv->fifoOwner=dPriv->driContextPriv->hHWContext; - saPriv->ctxOwner=dPriv->driContextPriv->hHWContext; - saPriv->texOwner=dPriv->driContextPriv->hHWContext; - grDRIResetSAREA(); - /* fprintf(stderr, "Out FifoPtr=%d FifoRead=%d\n", saPriv->fifoPtr, saPriv->fifoRead); */ + + if (dPriv->lastStamp != stamp) + i810XMesaWindowMoved( imesa ); + + + sarea->last_quiescent = -1; /* just kill it for now */ } + #endif diff --git a/xc/lib/GL/mesa/src/drv/i810/i810buf.h b/xc/lib/GL/mesa/src/drv/i810/i810buf.h deleted file mode 100644 index e72b0f225..000000000 --- a/xc/lib/GL/mesa/src/drv/i810/i810buf.h +++ /dev/null @@ -1,90 +0,0 @@ -/* - * GLX Hardware Device Driver for Intel 810 - * 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. - * - * Keith Whitwell <keithw@precisioninsight.com> - * - * based on matrox driver by - * Wittawat Yamwong <Wittawat.Yamwong@stud.uni-hannover.de> - * and others. - */ - -#ifndef I810BUF_INC -#define I810BUF_INC - -#include "i810common.h" -#include "i810_3d_reg.h" -#include "types.h" -#include "mm.h" - -#define VALID_I810_BUFFER(b) (b) - - -struct i810_dest_buffer -{ - int refcount; - PMemBlock MemBlock; - GLuint Setup[I810_DEST_SETUP_SIZE]; - - int Format; - int Width; /* in pixels */ - int Height; - int Pitch; - int BytesPerPixel; - int Size; - int Drawable; - char *BufAddr; - struct i810_z_buffer *ZBuffer; -}; - -struct i810_z_buffer -{ - int refcount; - PMemBlock MemBlock; - - int Format; - char *BufAddr; - - int Pitch; -}; - - - -/* Don't bother trying to hide the differences between these types of - * buffer. - */ -struct i810_dest_buffer *i810CreateDestBuffer(int Format, - int Width, - int Height); -void i810DestroyDestBuffer(struct i810_dest_buffer *buf); - - - -/* Parent is a dest-buffer, supplies geometry info. - */ -struct i810_z_buffer *i810CreateZBuffer( struct i810_dest_buffer *parent ); -void i810FreeZBuffer(struct i810_z_buffer *buf); - - - - - -#endif diff --git a/xc/lib/GL/mesa/src/drv/i810/i810clear.c b/xc/lib/GL/mesa/src/drv/i810/i810clear.c index 3749b9659..f6e74beb8 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810clear.c +++ b/xc/lib/GL/mesa/src/drv/i810/i810clear.c @@ -1,144 +1,145 @@ -#include "xsmesaP.h" -#include "mesaglx/types.h" +#include "types.h" #include "vbrender.h" -#include "glx_log.h" - -#include "vga.h" -#include "vgaPCI.h" +#include "i810log.h" #include <stdio.h> #include <stdlib.h> +#include <unistd.h> #include "mm.h" #include "i810lib.h" #include "i810dd.h" -#include "i810glx.h" #include "i810clear.h" #include "i810state.h" #include "i810tris.h" +#include "i810ioctl.h" + +#define DEPTH_SCALE 65535.0F + +static void i810_clear_buffer( GLcontext *ctx, + GLboolean all, + GLint cx, GLint cy, + GLint cwidth, + GLint cheight, + GLushort value, + GLuint offset ) +{ + i810ContextPtr imesa = I810_CONTEXT( ctx ); + i810ScreenPrivate *i810Screen = imesa->i810Screen; + __DRIdrawablePrivate *dPriv = imesa->driDrawable; + + int _nc = imesa->numClipRects; + XF86DRIClipRectPtr box = imesa->pClipRects; + + cy = dPriv->h-cy-cheight; + cx += imesa->drawX; + cy += imesa->drawY; + + while (_nc--) { + GLint x = box[_nc].x1; + GLint y = box[_nc].y1; + GLint width = box[_nc].x2 - x; + GLint height = box[_nc].y2 - y; + + if (!all) { + if (x < cx) width -= cx - x, x = cx; + if (y < cy) height -= cy - y, y = cy; + if (x + width > cx + cwidth) width = cx + cwidth - x; + if (y + height > cy + cheight) height = cy + cheight - y; + if (width <= 0) continue; + if (height <= 0) continue; + } + + if (I810_DEBUG&DEBUG_VERBOSE_2D) + fprintf(stderr, "clear color rect %d,%d %dx%d\n", + (int) x, (int) y, (int) width, (int) height); + + + { + int start = (offset + + y * i810Screen->backPitch + + x * i810Screen->cpp); + + BEGIN_BATCH( imesa, 6 ); + + OUT_BATCH( BR00_BITBLT_CLIENT | BR00_OP_COLOR_BLT | 0x3 ); + OUT_BATCH( BR13_SOLID_PATTERN | + (0xF0 << 16) | + i810Screen->backPitch ); + OUT_BATCH( (height << 16) | (width * i810Screen->cpp)); + OUT_BATCH( start ); + OUT_BATCH( value ); + OUT_BATCH( 0 ); + + ADVANCE_BATCH(); + } + } +} + /* * i810Clear - * perform hardware accelerated clearing of the color and/or depth - * buffer. Software may still clear stencil buffers. - * If all==GL_TRUE, clear whole buffer, else just clear region defined - * by x,y,width,height + * + * Clear the color and/or depth buffers. If 'all' is GL_TRUE, clear + * whole buffer, otherwise clear the region defined by the remaining + * parameters. */ - - GLbitfield i810Clear( GLcontext *ctx, GLbitfield mask, GLboolean all, - GLint x, GLint y, GLint width, GLint height ) + GLint cx, GLint cy, GLint cwidth, GLint cheight ) { - XSMesaContext xsmesa = (XSMesaContext) ctx->DriverCtx; - GLubyte *c; - GLuint zval; + i810ContextPtr imesa = I810_CONTEXT( ctx ); + const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask); - i810Msg(10, "i810Clear( %i, %i, %i, %i, %i )\n", - mask, x, y, width, height ); + if (I810_DEBUG&DEBUG_VERBOSE_API) + fprintf(stderr, "i810Clear( %d, %d, %d, %d, %d )\n", + (int)mask, (int)cx, (int)cy, (int)cwidth, (int)cheight ); - CHECK_CONTEXT( return mask; ); - - if (all == GL_TRUE) { - x = 0; - y = 0; - width = i810DB->Width; - height = i810DB->Height; - } - - if ( y + height > i810DB->Height ) { - height = i810DB->Height - y; - } - if ( x + width > i810DB->Width ) { - width = i810DB->Width - x; - } - if ( x < 0 ) { - width += x; - x = 0; - } - if ( y < 0 ) { - height += y; - y = 0; - } - if ( x >= i810DB->Width || y >= i810DB->Height || width < 1 || height < 1 ) { - return 0; - } - - /* flip top to bottom */ - y = i810DB->Height-y-height; - c = xsmesa->clearcolor; - zval = (GLuint) (ctx->Depth.Clear * DEPTH_SCALE); - - i810FinishPrimitive(); + FLUSH_BATCH(imesa); + + LOCK_HARDWARE(imesa); + i810GetGeneralDmaBufferLocked( imesa ); - if (1) { - BEGIN_BATCH(2); + BEGIN_BATCH( imesa, 2 ); OUT_BATCH( INST_PARSER_CLIENT | INST_OP_FLUSH ); - OUT_BATCH( 0 ); /* pad to quadword */ + OUT_BATCH( 0 ); ADVANCE_BATCH(); } - /* color buffer */ - if (mask & GL_COLOR_BUFFER_BIT) - { - int start = (i810DB->MemBlock->ofs + - y * i810DB->Pitch + - x * vgaBytesPerPixel); - - BEGIN_BATCH(6); - - OUT_BATCH( BR00_BITBLT_CLIENT | BR00_OP_COLOR_BLT | 0x3 ); - OUT_BATCH( BR13_SOLID_PATTERN | - (0xF0 << 16) | - i810DB->Pitch ); - OUT_BATCH( (height << 16) | (width * vgaBytesPerPixel)); - OUT_BATCH( start ); - OUT_BATCH( i810PackColor( i810DB->Format, c[0], c[1], c[2], c[3] ) ); - OUT_BATCH( 0 ); - - ADVANCE_BATCH(); - - mask &= ~GL_COLOR_BUFFER_BIT; + if ( (mask & DD_FRONT_LEFT_BIT) && colorMask == ~0) { + i810_clear_buffer( ctx, all, cx, cy, cwidth, cheight, + imesa->ClearColor, + imesa->i810Screen->fbOffset); + mask &= ~DD_FRONT_LEFT_BIT; } - /* depth buffer */ - if ( (mask & GL_DEPTH_BUFFER_BIT) && - i810DB->ZBuffer && - ctx->Depth.Mask ) - { - int start = (i810DB->ZBuffer->MemBlock->ofs + - y * i810DB->ZBuffer->Pitch + - x * 2); - - BEGIN_BATCH(6); - - OUT_BATCH( BR00_BITBLT_CLIENT | BR00_OP_COLOR_BLT | 0x3 ); - OUT_BATCH( BR13_SOLID_PATTERN | - (0xF0 << 16) | - i810DB->ZBuffer->Pitch ); - OUT_BATCH( (height << 16) | (width * 2)); - OUT_BATCH( start ); - OUT_BATCH( zval ); - OUT_BATCH( 0 ); - - ADVANCE_BATCH(); - - mask &= ~GL_DEPTH_BUFFER_BIT; + if ( (mask & DD_BACK_LEFT_BIT) && colorMask == ~0) { + i810_clear_buffer( ctx, all, cx, cy, cwidth, cheight, + imesa->ClearColor, + imesa->i810Screen->backOffset); + mask &= ~DD_BACK_LEFT_BIT; } - if (1) + if ( (mask & DD_DEPTH_BIT) && ctx->Depth.Mask ) { + i810_clear_buffer( ctx, all, cx, cy, cwidth, cheight, + ctx->Depth.Clear * DEPTH_SCALE, + imesa->i810Screen->depthOffset); + mask &= ~DD_DEPTH_BIT; + } + { - BEGIN_BATCH(2); + BEGIN_BATCH( imesa, 2 ); OUT_BATCH( INST_PARSER_CLIENT | INST_OP_FLUSH ); - OUT_BATCH( 0 ); /* pad to quadword */ + OUT_BATCH( 0 ); ADVANCE_BATCH(); } + i810FlushGeneralLocked(imesa); + UNLOCK_HARDWARE( imesa ); return mask; } - diff --git a/xc/lib/GL/mesa/src/drv/i810/i810context.c b/xc/lib/GL/mesa/src/drv/i810/i810context.c deleted file mode 100644 index a9bd855d5..000000000 --- a/xc/lib/GL/mesa/src/drv/i810/i810context.c +++ /dev/null @@ -1,126 +0,0 @@ -/* - * GLX Hardware Device Driver for Intel i810 - * 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 "xsmesaP.h" -#include <stdlib.h> -#include <stdio.h> -#include <time.h> -#include <GL/gl.h> - -#include "i810context.h" -#include "i810lib.h" -#include "i810log.h" -#include "i810dd.h" -#include "i810pipeline.h" -/* #include "i810render.h" */ -#include "i810state.h" -#include "i810tris.h" -#include "simple_list.h" - - - -i810ContextPtr i810CreateContext(GLcontext *ctx) -{ - i810ContextPtr c; - - c = (i810ContextPtr) calloc(1,sizeof(i810Context)); - if (!c) - return NULL; - - c->gl_ctx = ctx; - - c->renderindex = -1; /* impossible value */ - c->new_state = ~0; - c->reg_dirty = ~0; - - make_empty_list(&c->SwappedOut); - make_empty_list(&c->TexObjList); - - c->TextureMode = ctx->Texture.Unit[0].EnvMode; - - c->CurrentTex0Obj = 0; - c->CurrentTex1Obj = 0; - ctx->Shared->DefaultD[2][0].DriverData = 0; - ctx->Shared->DefaultD[2][1].DriverData = 0; - - if (ctx->VB) - i810DDRegisterVB( ctx->VB ); - - if (ctx->NrPipelineStages) - ctx->NrPipelineStages = - i810DDRegisterPipelineStages(ctx->PipelineStage, - ctx->PipelineStage, - ctx->NrPipelineStages); - - - /* Ask mesa to clip fog coordinates for us. - */ - ctx->TriangleCaps |= DD_CLIP_FOG_COORD; - - -#if 0 - if (!getenv("I810_NO_FAST_PATH")) - ctx->Driver.BuildPrecalcPipeline = i810DDBuildPrecalcPipeline; - - i810DDRenderInit(); - i810DDFastPathInit(); -#endif - - - i810DDTrifuncInit(); - i810DDSetupInit(); - i810DDExtensionsInit( ctx ); - - i810_setup_DD_pointers( ctx ); - i810DDInitState( c ); - - if (MESA_VERBOSE&VERBOSE_DRIVER) - fprintf(stderr,"i810CreateContext(): successful.\n"); - - return c; -} - -int i810DestroyContext(i810ContextPtr ctx) -{ - i810TextureObjectPtr next_t, t; - - if (!ctx) - return 0; - - if (--(ctx->refcount) > 0) - return 0; - - foreach_s (t, next_t, &(ctx->TexObjList)) - i810DestroyTexObj(ctx, t); - - foreach_s (t, next_t, &(ctx->SwappedOut)) - i810DestroyTexObj(ctx, t); - - free(ctx); - - if (MESA_VERBOSE&VERBOSE_DRIVER) - fprintf(stderr,"i810DestroyContext(): successfully destroyed.\n"); - - return 0; -} diff --git a/xc/lib/GL/mesa/src/drv/i810/i810context.h b/xc/lib/GL/mesa/src/drv/i810/i810context.h index 754a0e3f1..6a7ffa968 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810context.h +++ b/xc/lib/GL/mesa/src/drv/i810/i810context.h @@ -26,60 +26,82 @@ #ifndef I810CONTEXT_INC #define I810CONTEXT_INC +typedef struct i810_context_t i810Context; +typedef struct i810_context_t *i810ContextPtr; + +#include <X11/Xlibint.h> +#include "dri_tmm.h" +#include "dri_mesaint.h" +#include "dri_mesa.h" +#include "xmesaP.h" -#include "mesaglx/types.h" +#include "types.h" +#include "i810_init.h" +#include "drm.h" -#include "i810common.h" -#include "i810buf.h" #include "i810tex.h" #include "i810vb.h" -#include "xsmesaP.h" -/* Hmmm */ -#define FALLBACK_TEXTURE 1 + +#define I810_FALLBACK_TEXTURE 0x1 +#define I810_FALLBACK_DRAW_BUFFER 0x2 +#define I810_FALLBACK_READ_BUFFER 0x4 +#define I810_FALLBACK_COLORMASK 0x8 +#define I810_FALLBACK_STIPPLE 0x10 +#define I810_FALLBACK_SPECULAR 0x20 + +/* for i810ctx.new_state - manage GL->driver state changes + */ +#define I810_NEW_TEXTURE 0x1 + +/* for i810ctx.dirty - manage driver->hw state changes, including + * lost contexts. + */ +#define I810_WAIT_AGE 0x1 +#define I810_UPLOAD_TEX0IMAGE 0x2 +#define I810_UPLOAD_TEX1IMAGE 0x4 +#define I810_UPLOAD_CTX 0x8 +#define I810_UPLOAD_BUFFERS 0x10 +#define I810_REFRESH_RING 0x20 +#define I810_EMIT_CLIPRECT 0x40 -#define I810_NEW_TEXTURE 0x20 -#define I810_NEW_CONTEXT 0x100 +typedef void (*i810_interp_func)( GLfloat t, + GLfloat *result, + const GLfloat *in, + const GLfloat *out ); + struct i810_context_t { GLint refcount; - struct i810_dest_buffer *DB; - GLcontext *gl_ctx; + GLcontext *glCtx; - i810TextureObjectPtr CurrentTex0Obj; - i810TextureObjectPtr CurrentTex1Obj; + i810TextureObjectPtr CurrentTexObj[2]; - struct i810_texture_object_t TexObjList, SwappedOut; + struct i810_texture_object_t TexObjList; + struct i810_texture_object_t SwappedOut; int TextureMode; - /* flags - */ - int GlobalPaletteUpdated:1; - - /* Hardware state */ GLuint Setup[I810_CTX_SETUP_SIZE]; + GLuint BufferSetup[I810_DEST_SETUP_SIZE]; + GLuint ClipSetup[I810_CLIP_SETUP_SIZE]; - /* Context hardware state mirrors. - */ - GLushort GlobalPalette[256]; - /* Support for CVA and the fast paths. */ GLuint setupdone; GLuint setupindex; GLuint renderindex; GLuint using_fast_path; -/* gl_vertex_interp_func interp; */ + i810_interp_func interp; /* Shortcircuit some state changes. */ @@ -90,39 +112,98 @@ struct i810_context_t { /* Manage our own state */ GLuint new_state; - GLuint reg_dirty; - + + /* Manage hardware state */ + GLuint dirty; + memHeap_t *texHeap; + /* One of the few bits of hardware state that can't be calculated * completely on the fly: */ GLuint LcsCullMode; - /* For mono span and pixel funcs. + /* Funny mesa mirrors */ - GLushort CurrentColor; + GLushort MonoColor; + GLushort ClearColor; /* DRI stuff */ - GLuint needClip; - GLuint clipMinX; - GLuint clipMaxX; - GLuint clipMinY; - GLuint clipMaxY; + drmBufPtr dma_buffer; + drmBufPtr vertex_dma_buffer; + + GLframebuffer *glBuffer; + /* Two flags to keep track of fallbacks. + */ + GLuint IndirectTriangles; + GLuint Fallback; - drmContext hHWContext; - int numClipRects; + + GLuint needClip; + + /* These refer to the current draw (front vs. back) buffer: + */ + char *drawMap; /* draw buffer address in virtual mem */ + char *readMap; + int drawX; /* origin of drawable in draw buffer */ + int drawY; + GLuint numClipRects; /* cliprects for that buffer */ XF86DRIClipRectPtr pClipRects; - i810ScreenPrivate *i810ScrnPriv; + + int lastSwap; + int secondLastSwap; + int texAge; + int ctxAge; + int dirtyAge; + int any_contend; /* throttle me harder */ + + int scissor; + + int lines_are_tris; /* not used */ + int horiz_line_stipple; + int vert_line_stipple; + + int poly_stipple; + + drm_clip_rect_t draw_rect; + drm_clip_rect_t scissor_rect; + + drmContext hHWContext; + drmLock *driHwLock; + int driFd; + Display *display; + + __DRIdrawablePrivate *driDrawable; + __DRIscreenPrivate *driScreen; + i810ScreenPrivate *i810Screen; + drm_i810_sarea_t *sarea; }; -typedef struct i810_context_t i810Context; -typedef struct i810_context_t *i810ContextPtr; + +/* To remove all debugging, make sure I810_DEBUG is defined as a + * preprocessor symbol, and equal to zero. + */ +#define I810_DEBUG 0 +#ifndef I810_DEBUG +#warning "Debugging enabled - expect reduced performance" +extern int I810_DEBUG; +#endif + +#define DEBUG_VERBOSE_2D 0x1 +#define DEBUG_VERBOSE_RING 0x8 +#define DEBUG_VERBOSE_OUTREG 0x10 +#define DEBUG_ALWAYS_SYNC 0x40 +#define DEBUG_VERBOSE_MSG 0x80 +#define DEBUG_NO_OUTRING 0x100 +#define DEBUG_NO_OUTREG 0x200 +#define DEBUG_VERBOSE_API 0x400 +#define DEBUG_VALIDATE_RING 0x800 +#define DEBUG_VERBOSE_LRU 0x1000 +#define DEBUG_VERBOSE_DRI 0x2000 +#define DEBUG_VERBOSE_IOCTL 0x4000 -i810ContextPtr i810CreateContext(GLcontext *ctx); /* Do I need visual info? */ -int i810DestroyContext(i810ContextPtr ctx); -int i810BindBuffer(i810ContextPtr ctx, struct i810_dest_buffer *buf); extern GLuint i810DDRegisterPipelineStages( struct gl_pipeline_stage *out, const struct gl_pipeline_stage *in, diff --git a/xc/lib/GL/mesa/src/drv/i810/i810dd.c b/xc/lib/GL/mesa/src/drv/i810/i810dd.c index 7a762ce9b..954f60a79 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810dd.c +++ b/xc/lib/GL/mesa/src/drv/i810/i810dd.c @@ -30,17 +30,15 @@ #include "mm.h" #include "i810lib.h" -#include "i810glx.h" #include "i810clear.h" #include "i810dd.h" -#include "i810direct.h" -#include "i810depth.h" #include "i810log.h" #include "i810state.h" #include "i810span.h" #include "i810tex.h" #include "i810tris.h" #include "i810vb.h" +#include "i810pipeline.h" #include "extensions.h" #include "vb.h" #include "dd.h" @@ -54,18 +52,39 @@ extern int xf86VTSema; ***************************************/ -const GLubyte *i810DDGetString( GLcontext *ctx, GLenum name ) +static const GLubyte *i810DDGetString( GLcontext *ctx, GLenum name ) { switch (name) { case GL_VENDOR: return "Keith Whitwell, Precision Insight Inc."; case GL_RENDERER: - return "GLX-I810"; + return "DRI-I810"; default: return 0; } } +static GLint i810GetParameteri(const GLcontext *ctx, GLint param) +{ + switch (param) { + case DD_HAVE_HARDWARE_FOG: + return 1; + default: + return 0; + } +} + + + +static void i810BufferSize(GLcontext *ctx, GLuint *width, GLuint *height) +{ + i810ContextPtr imesa = I810_CONTEXT(ctx); + *width = imesa->driDrawable->w; + *height = imesa->driDrawable->h; +} + + + void i810DDExtensionsInit( GLcontext *ctx ) { @@ -86,77 +105,26 @@ void i810DDExtensionsInit( GLcontext *ctx ) gl_extensions_disable( ctx, "GL_INGR_blend_func_separate" ); + if (0) gl_extensions_disable( ctx, "GL_ARB_multitexture" ); + + /* We do support tex_env_add, however */ gl_extensions_enable( ctx, "GL_EXT_texture_env_add" ); } -static GLint i810GetParameteri(const GLcontext *ctx, GLint param) -{ - switch (param) { - case DD_HAVE_HARDWARE_FOG: - return 1; - default: - return 0; - } -} -GLboolean i810IsTextureResident( GLcontext *ctx, struct gl_texture_object *t ) +void i810DDInitDriverFuncs( GLcontext *ctx ) { - i810TextureObjectPtr mt = (i810TextureObjectPtr)t->DriverData; - return mt && mt->MemBlock; -} - - - - -void i810_setup_DD_pointers( GLcontext *ctx ) -{ - i810DDInitStatePointers(ctx); - + ctx->Driver.GetBufferSize = i810BufferSize; ctx->Driver.GetString = i810DDGetString; - ctx->Driver.UpdateState = i810DDUpdateState; + ctx->Driver.GetParameteri = i810GetParameteri; ctx->Driver.RegisterVB = i810DDRegisterVB; ctx->Driver.UnregisterVB = i810DDUnregisterVB; ctx->Driver.Clear = i810Clear; - ctx->Driver.GetParameteri = i810GetParameteri; - ctx->Driver.TexEnv = i810TexEnv; - ctx->Driver.TexImage = i810TexImage; - ctx->Driver.TexSubImage = i810TexSubImage; - ctx->Driver.BindTexture = i810BindTexture; - ctx->Driver.DeleteTexture = i810DeleteTexture; - ctx->Driver.TexParameter = i810TexParameter; - ctx->Driver.UpdateTexturePalette = i810UpdateTexturePalette; - ctx->Driver.IsTextureResident = i810IsTextureResident; - - ctx->Driver.TriangleCaps = (DD_TRI_CULL| - DD_TRI_LIGHT_TWOSIDE| - DD_TRI_OFFSET); - - i810DDInitSpans( ctx ); - - ctx->Driver.ReadDepthSpanFloat = i810_read_depth_span_float; - ctx->Driver.ReadDepthSpanInt = i810_read_depth_span_int; - if (ctx->Depth.Test) { - switch (ctx->Depth.Func) { - case GL_LESS: - ctx->Driver.DepthTestSpan = i810_depth_test_span_less; - ctx->Driver.DepthTestPixels = i810_depth_test_pixels_less; - break; - case GL_GREATER: - ctx->Driver.DepthTestSpan = i810_depth_test_span_greater; - ctx->Driver.DepthTestPixels = i810_depth_test_pixels_greater; - break; - default: - ctx->Driver.DepthTestSpan = i810_depth_test_span_generic; - ctx->Driver.DepthTestPixels = i810_depth_test_pixels_generic; - break; - } - } - /* Also do the normal GL state-change checks. - */ - i810DDUpdateState( ctx ); + + ctx->Driver.BuildPrecalcPipeline = i810DDBuildPrecalcPipeline; } diff --git a/xc/lib/GL/mesa/src/drv/i810/i810dd.h b/xc/lib/GL/mesa/src/drv/i810/i810dd.h index 1274e66e2..86a8618d0 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810dd.h +++ b/xc/lib/GL/mesa/src/drv/i810/i810dd.h @@ -25,23 +25,9 @@ #ifndef I810DD_INC #define I810DD_INC -#include "mesaglx/context.h" +#include "context.h" -#include "i810buf.h" - -void i810_setup_DD_pointers( GLcontext *ctx ); -void i810DDRegisterVB( struct vertex_buffer *VB ); - -void i810DDFastPath( struct vertex_buffer *VB ); -void i810DDImmediateFastPath( struct vertex_buffer *VB ); -void i810DDFastPathInit(); void i810DDExtensionsInit( GLcontext *ctx ); - -void i810_setup_DD_pointers_no_accel( GLcontext *ctx ); -/* void i810FinishPrimitive( void ); */ - -#define i810FinishPrimitive() - - +void i810DDInitDriverFuncs( GLcontext *ctx ); #endif diff --git a/xc/lib/GL/mesa/src/drv/i810/i810depth.c b/xc/lib/GL/mesa/src/drv/i810/i810depth.c deleted file mode 100644 index 9b089f7de..000000000 --- a/xc/lib/GL/mesa/src/drv/i810/i810depth.c +++ /dev/null @@ -1,735 +0,0 @@ -/* - * Mesa 3-D graphics library - * Version: 3.1 - * - * Copyright (C) 1999 Brian Paul All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, 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 - * BRIAN PAUL 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. - */ - -/* - * This file has been modified by Wittawat Yamwong for GLX module. - */ - -/* - * Depth buffer functions - */ - - -#ifdef PC_HEADER -#include "all.h" -#else -#include <stdlib.h> -#include <string.h> -#include "mesaglx/context.h" -#include "i810depth.h" -#include "mesaglx/types.h" -#include "mm.h" -#include "i810lib.h" -#endif - - - -/* - * Return the address of the Z-buffer value for window coordinate (x,y): - */ -#define Z_SETUP \ - GLdepth *zbstart = (GLdepth *)i810DB->ZBuffer->BufAddr; \ - GLint zbpitch = i810DB->ZBuffer->Pitch; -#define Z_ADDRESS( X, Y ) \ - (zbstart + zbpitch * (Y) + (X)) - - -/**********************************************************************/ -/***** Depth Testing Functions *****/ -/**********************************************************************/ - - -/* - * Depth test horizontal spans of fragments. These functions are called - * via ctx->Driver.depth_test_span only. - * - * Input: n - number of pixels in the span - * x, y - location of leftmost pixel in span in window coords - * z - array [n] of integer depth values - * In/Out: mask - array [n] of flags (1=draw pixel, 0=don't draw) - * Return: number of pixels which passed depth test - */ - - -/* - * glDepthFunc( any ) and glDepthMask( GL_TRUE or GL_FALSE ). - */ -GLuint i810_depth_test_span_generic( GLcontext* ctx, - GLuint n, GLint x, GLint y, - const GLdepth z[], - GLubyte mask[] ) -{ - Z_SETUP - GLdepth *zptr = Z_ADDRESS( x, y ); - GLubyte *m = mask; - GLuint i; - GLuint passed = 0; - - i810WaitDrawingEngine(); - - /* switch cases ordered from most frequent to less frequent */ - switch (ctx->Depth.Func) { - case GL_LESS: - if (ctx->Depth.Mask) { - /* Update Z buffer */ - for (i=0; i<n; i++,zptr++,m++) { - if (*m) { - if (z[i] < *zptr) { - /* pass */ - *zptr = z[i]; - passed++; - } - else { - /* fail */ - *m = 0; - } - } - } - } - else { - /* Don't update Z buffer */ - for (i=0; i<n; i++,zptr++,m++) { - if (*m) { - if (z[i] < *zptr) { - /* pass */ - passed++; - } - else { - *m = 0; - } - } - } - } - break; - case GL_LEQUAL: - if (ctx->Depth.Mask) { - /* Update Z buffer */ - for (i=0;i<n;i++,zptr++,m++) { - if (*m) { - if (z[i] <= *zptr) { - *zptr = z[i]; - passed++; - } - else { - *m = 0; - } - } - } - } - else { - /* Don't update Z buffer */ - for (i=0;i<n;i++,zptr++,m++) { - if (*m) { - if (z[i] <= *zptr) { - /* pass */ - passed++; - } - else { - *m = 0; - } - } - } - } - break; - case GL_GEQUAL: - if (ctx->Depth.Mask) { - /* Update Z buffer */ - for (i=0;i<n;i++,zptr++,m++) { - if (*m) { - if (z[i] >= *zptr) { - *zptr = z[i]; - passed++; - } - else { - *m = 0; - } - } - } - } - else { - /* Don't update Z buffer */ - for (i=0;i<n;i++,zptr++,m++) { - if (*m) { - if (z[i] >= *zptr) { - /* pass */ - passed++; - } - else { - *m = 0; - } - } - } - } - break; - case GL_GREATER: - if (ctx->Depth.Mask) { - /* Update Z buffer */ - for (i=0;i<n;i++,zptr++,m++) { - if (*m) { - if (z[i] > *zptr) { - *zptr = z[i]; - passed++; - } - else { - *m = 0; - } - } - } - } - else { - /* Don't update Z buffer */ - for (i=0;i<n;i++,zptr++,m++) { - if (*m) { - if (z[i] > *zptr) { - /* pass */ - passed++; - } - else { - *m = 0; - } - } - } - } - break; - case GL_NOTEQUAL: - if (ctx->Depth.Mask) { - /* Update Z buffer */ - for (i=0;i<n;i++,zptr++,m++) { - if (*m) { - if (z[i] != *zptr) { - *zptr = z[i]; - passed++; - } - else { - *m = 0; - } - } - } - } - else { - /* Don't update Z buffer */ - for (i=0;i<n;i++,zptr++,m++) { - if (*m) { - if (z[i] != *zptr) { - /* pass */ - passed++; - } - else { - *m = 0; - } - } - } - } - break; - case GL_EQUAL: - if (ctx->Depth.Mask) { - /* Update Z buffer */ - for (i=0;i<n;i++,zptr++,m++) { - if (*m) { - if (z[i] == *zptr) { - *zptr = z[i]; - passed++; - } - else { - *m =0; - } - } - } - } - else { - /* Don't update Z buffer */ - for (i=0;i<n;i++,zptr++,m++) { - if (*m) { - if (z[i] == *zptr) { - /* pass */ - passed++; - } - else { - *m =0; - } - } - } - } - break; - case GL_ALWAYS: - if (ctx->Depth.Mask) { - /* Update Z buffer */ - for (i=0;i<n;i++,zptr++,m++) { - if (*m) { - *zptr = z[i]; - passed++; - } - } - } - else { - /* Don't update Z buffer or mask */ - passed = n; - } - break; - case GL_NEVER: - for (i=0;i<n;i++) { - mask[i] = 0; - } - break; - default: - gl_problem(ctx, "Bad depth func in gl_depth_test_span_generic"); - } /*switch*/ - - return passed; -} - - - -/* - * glDepthFunc(GL_LESS) and glDepthMask(GL_TRUE). - */ -GLuint i810_depth_test_span_less( GLcontext* ctx, - GLuint n, GLint x, GLint y, const GLdepth z[], - GLubyte mask[] ) -{ - Z_SETUP - GLdepth *zptr = Z_ADDRESS( x, y ); - GLuint i; - GLuint passed = 0; - - i810WaitDrawingEngine(); - - for (i=0; i<n; i++) { - if (mask[i]) { - if (z[i] < zptr[i]) { - /* pass */ - zptr[i] = z[i]; - passed++; - } - else { - /* fail */ - mask[i] = 0; - } - } - } - return passed; -} - - -/* - * glDepthFunc(GL_GREATER) and glDepthMask(GL_TRUE). - */ -GLuint i810_depth_test_span_greater( GLcontext* ctx, - GLuint n, GLint x, GLint y, - const GLdepth z[], - GLubyte mask[] ) -{ - Z_SETUP - GLdepth *zptr = Z_ADDRESS( x, y ); - GLuint i; - GLuint passed = 0; - - i810WaitDrawingEngine(); - - for (i=0; i<n; i++) { - if (mask[i]) { - if (z[i] > zptr[i]) { - /* pass */ - zptr[i] = z[i]; - passed++; - } - else { - /* fail */ - mask[i] = 0; - } - } - } - return passed; -} - - - -/* - * Depth test an array of randomly positioned fragments. - */ - -/* - * glDepthFunc( any ) and glDepthMask( GL_TRUE or GL_FALSE ). - */ -void i810_depth_test_pixels_generic( GLcontext* ctx, - GLuint n, const GLint x[], const GLint y[], - const GLdepth z[], GLubyte mask[] ) -{ - Z_SETUP - register GLdepth *zptr; - register GLuint i; - - i810WaitDrawingEngine(); - - /* switch cases ordered from most frequent to less frequent */ - switch (ctx->Depth.Func) { - case GL_LESS: - if (ctx->Depth.Mask) { - /* Update Z buffer */ - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - if (z[i] < *zptr) { - /* pass */ - *zptr = z[i]; - } - else { - /* fail */ - mask[i] = 0; - } - } - } - } - else { - /* Don't update Z buffer */ - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - if (z[i] < *zptr) { - /* pass */ - } - else { - /* fail */ - mask[i] = 0; - } - } - } - } - break; - case GL_LEQUAL: - if (ctx->Depth.Mask) { - /* Update Z buffer */ - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - if (z[i] <= *zptr) { - /* pass */ - *zptr = z[i]; - } - else { - /* fail */ - mask[i] = 0; - } - } - } - } - else { - /* Don't update Z buffer */ - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - if (z[i] <= *zptr) { - /* pass */ - } - else { - /* fail */ - mask[i] = 0; - } - } - } - } - break; - case GL_GEQUAL: - if (ctx->Depth.Mask) { - /* Update Z buffer */ - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - if (z[i] >= *zptr) { - /* pass */ - *zptr = z[i]; - } - else { - /* fail */ - mask[i] = 0; - } - } - } - } - else { - /* Don't update Z buffer */ - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - if (z[i] >= *zptr) { - /* pass */ - } - else { - /* fail */ - mask[i] = 0; - } - } - } - } - break; - case GL_GREATER: - if (ctx->Depth.Mask) { - /* Update Z buffer */ - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - if (z[i] > *zptr) { - /* pass */ - *zptr = z[i]; - } - else { - /* fail */ - mask[i] = 0; - } - } - } - } - else { - /* Don't update Z buffer */ - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - if (z[i] > *zptr) { - /* pass */ - } - else { - /* fail */ - mask[i] = 0; - } - } - } - } - break; - case GL_NOTEQUAL: - if (ctx->Depth.Mask) { - /* Update Z buffer */ - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - if (z[i] != *zptr) { - /* pass */ - *zptr = z[i]; - } - else { - /* fail */ - mask[i] = 0; - } - } - } - } - else { - /* Don't update Z buffer */ - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - if (z[i] != *zptr) { - /* pass */ - } - else { - /* fail */ - mask[i] = 0; - } - } - } - } - break; - case GL_EQUAL: - if (ctx->Depth.Mask) { - /* Update Z buffer */ - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - if (z[i] == *zptr) { - /* pass */ - *zptr = z[i]; - } - else { - /* fail */ - mask[i] = 0; - } - } - } - } - else { - /* Don't update Z buffer */ - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - if (z[i] == *zptr) { - /* pass */ - } - else { - /* fail */ - mask[i] = 0; - } - } - } - } - break; - case GL_ALWAYS: - if (ctx->Depth.Mask) { - /* Update Z buffer */ - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - *zptr = z[i]; - } - } - } - else { - /* Don't update Z buffer or mask */ - } - break; - case GL_NEVER: - /* depth test never passes */ - for (i=0;i<n;i++) { - mask[i] = 0; - } - break; - default: - gl_problem(ctx, "Bad depth func in gl_depth_test_pixels_generic"); - } /*switch*/ -} - - - -/* - * glDepthFunc( GL_LESS ) and glDepthMask( GL_TRUE ). - */ -void i810_depth_test_pixels_less( GLcontext* ctx, - GLuint n, const GLint x[], const GLint y[], - const GLdepth z[], GLubyte mask[] ) -{ - Z_SETUP - GLdepth *zptr; - GLuint i; - - i810WaitDrawingEngine(); - - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - if (z[i] < *zptr) { - /* pass */ - *zptr = z[i]; - } - else { - /* fail */ - mask[i] = 0; - } - } - } -} - - -/* - * glDepthFunc( GL_GREATER ) and glDepthMask( GL_TRUE ). - */ -void i810_depth_test_pixels_greater( GLcontext* ctx, - GLuint n, const GLint x[], const GLint y[], - const GLdepth z[], GLubyte mask[] ) -{ - Z_SETUP - GLdepth *zptr; - GLuint i; - - i810WaitDrawingEngine(); - - for (i=0; i<n; i++) { - if (mask[i]) { - zptr = Z_ADDRESS(x[i],y[i]); - if (z[i] > *zptr) { - /* pass */ - *zptr = z[i]; - } - else { - /* fail */ - mask[i] = 0; - } - } - } -} - - - - -/**********************************************************************/ -/***** Read Depth Buffer *****/ -/**********************************************************************/ - - -/* - * Return a span of depth values from the depth buffer as floats in [0,1]. - * This function is only called through Driver.read_depth_span_float() - * Input: n - how many pixels - * x,y - location of first pixel - * Output: depth - the array of depth values - */ -void i810_read_depth_span_float( GLcontext* ctx, - GLuint n, GLint x, GLint y, GLfloat depth[] ) -{ - Z_SETUP - GLdepth *zptr; - GLfloat scale; - GLuint i; - - i810WaitDrawingEngine(); - - scale = 1.0F / DEPTH_SCALE; - - if (ctx->Buffer->Depth) { - zptr = Z_ADDRESS( x, y ); - for (i=0;i<n;i++) { - depth[i] = (GLfloat) zptr[i] * scale; - } - } - else { - for (i=0;i<n;i++) { - depth[i] = 0.0F; - } - } -} - - -/* - * Return a span of depth values from the depth buffer as integers in - * [0,MAX_DEPTH]. - * This function is only called through Driver.read_depth_span_int() - * Input: n - how many pixels - * x,y - location of first pixel - * Output: depth - the array of depth values - */ -void i810_read_depth_span_int( GLcontext* ctx, - GLuint n, GLint x, GLint y, GLdepth depth[] ) -{ - Z_SETUP - - i810WaitDrawingEngine(); - - if (ctx->Buffer->Depth) { - GLdepth *zptr = Z_ADDRESS( x, y ); - MEMCPY( depth, zptr, n * sizeof(GLdepth) ); - } - else { - GLuint i; - for (i=0;i<n;i++) { - depth[i] = 0; - } - } -} diff --git a/xc/lib/GL/mesa/src/drv/i810/i810depth.h b/xc/lib/GL/mesa/src/drv/i810/i810depth.h deleted file mode 100644 index 878fbefe8..000000000 --- a/xc/lib/GL/mesa/src/drv/i810/i810depth.h +++ /dev/null @@ -1,80 +0,0 @@ -/* - * Mesa 3-D graphics library - * Version: 3.1 - * - * Copyright (C) 1999 Brian Paul All Rights Reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, 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 - * BRIAN PAUL 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. - */ - -/* - * This file has been modified by Wittawat Yamwong for GLX module. - */ - - -#ifndef I810DEPTH_INC -#define I810DEPTH_INC - - -#include "mesaglx/types.h" - - - - - -extern GLuint -i810_depth_test_span_generic( GLcontext* ctx, GLuint n, GLint x, GLint y, - const GLdepth z[], GLubyte mask[] ); - -extern GLuint -i810_depth_test_span_less( GLcontext* ctx, GLuint n, GLint x, GLint y, - const GLdepth z[], GLubyte mask[] ); - -extern GLuint -i810_depth_test_span_greater( GLcontext* ctx, GLuint n, GLint x, GLint y, - const GLdepth z[], GLubyte mask[] ); - - - -extern void -i810_depth_test_pixels_generic( GLcontext* ctx, - GLuint n, const GLint x[], const GLint y[], - const GLdepth z[], GLubyte mask[] ); - -extern void -i810_depth_test_pixels_less( GLcontext* ctx, - GLuint n, const GLint x[], const GLint y[], - const GLdepth z[], GLubyte mask[] ); - -extern void -i810_depth_test_pixels_greater( GLcontext* ctx, - GLuint n, const GLint x[], const GLint y[], - const GLdepth z[], GLubyte mask[] ); - - -extern void i810_read_depth_span_float( GLcontext* ctx, - GLuint n, GLint x, GLint y, - GLfloat depth[] ); - - -extern void i810_read_depth_span_int( GLcontext* ctx, GLuint n, GLint x, GLint y, - GLdepth depth[] ); - - - -#endif diff --git a/xc/lib/GL/mesa/src/drv/i810/i810dma.c b/xc/lib/GL/mesa/src/drv/i810/i810dma.c deleted file mode 100644 index f745d272f..000000000 --- a/xc/lib/GL/mesa/src/drv/i810/i810dma.c +++ /dev/null @@ -1,363 +0,0 @@ -/* -*- mode: C; c-basic-offset:8 -*- */ -/* - * GLX Hardware Device Driver for Intel i810 - * 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. - * - * based on the original mgadma.c by Jeff Hartmann <slicer@ionet.net> - * as rewritten by John Carmack <johnc@idsoftware.com> - */ - -#include <stdlib.h> -#include <errno.h> -#include <unistd.h> -#include <sys/mman.h> -#include <stdio.h> -#include <sys/time.h> -#include <sys/types.h> -#include <sys/stat.h> -#include <fcntl.h> -#include <signal.h> - -#include "mm.h" -#include "i810buf.h" -#include "i810dd.h" -#include "i810lib.h" -#include "i810log.h" -#include "i810tris.h" -#include "i810direct.h" -#include "i810state.h" - -#include "pb.h" - -/* X server include: - */ -#include "i810.h" - - - -/* This will be overwritten from the default values when glx.so is - * loaded on the client. - */ -void i810ServerDmaFlush( int wait ); -GLuint i810ActiveDmaBuffer = 0; - - - -#ifndef I810_DEBUG -int I810_DEBUG = (0 -/* | DEBUG_ALWAYS_SYNC */ -/* | DEBUG_VERBOSE_ACCEL */ -/* | DEBUG_VERBOSE_SYNC */ -/* | DEBUG_VERBOSE_VGA */ -/* | DEBUG_VERBOSE_RING */ -/* | DEBUG_VERBOSE_OUTREG */ -/* | DEBUG_VERBOSE_MEMORY */ -/* | DEBUG_ALWAYS_SYNC */ -/* | DEBUG_VERBOSE_MSG */ - ); -#endif - - - -static void delay( void ) { -} - - - -int i810WaitForDmaCompletion( void ) -{ - int start, end; - - if (I810LpRing.head == I810LpRing.tail && I810LpRing.space) - return 0; - - start = i810_usec(); - I810LpRing.head = INREG(I810LpRing.base_reg + RING_HEAD); - end = i810_usec(); - - if (0 && start + 100 < end) - fprintf(stderr, "INREG in WaitForDma: %d usec\n", end - start); - - I810LpRing.head &= HEAD_ADDR; - I810LpRing.space = I810LpRing.head - (I810LpRing.tail + 8); - if (I810LpRing.space < 0) - I810LpRing.space += I810LpRing.mem.Size; - - if (I810LpRing.head == I810LpRing.tail) - return 0; - - start = i810_usec(); - I810Sync(); - end = i810_usec(); - - return 1; -} - - - -/* - * i810DmaResetBuffer - */ -void i810DmaResetBuffer( void ) { - - i810glx.dma_buffer = dmaBuffers[ i810ActiveDmaBuffer ]; - i810glx.dma_buffer->head = 0; - i810glx.dma_buffer->space = 0; - i810glx.dma_buffer->additional_space = - i810glx.dma_buffer->mem.Size - 256; - - i810DmaOverflow( 0 ); - - if (i810glx.dma_buffer_age < i810glx.dma_buffer->texture_age) - i810glx.dma_buffer_age = i810glx.dma_buffer->texture_age; -} - - - - -/* - * i810FlushRealDma - */ -void i810FlushRealDma( void ) { - - GLuint start; - - if (MESA_VERBOSE&VERBOSE_DRIVER) - fprintf(stderr, "i810FlushRealDma()\n" ); - - - if ( i810glx.skipDma || !I810_USE_BATCH ) - return; - - - if (i810glx.dma_buffer->head & 0x4) { - FatalError( "Misaligned batch buffer\n" ); - } - - if ( (I810_DEBUG&DEBUG_VERBOSE_OUTREG) && 0) - { - int i; - for (i = 0 ; i <= i810glx.dma_buffer->head ; i+=4) - fprintf(stderr, - " 0x%05x : 0x%08x\n", - i/4, - *(GLuint *)(i810glx.dma_buffer->virtual_start + - i)); - } - - - /* fire the batch buffer */ - for (start = 0 ; start < i810glx.dma_buffer->head ; start += MAX_BATCH) - { - GLuint ofs = i810glx.dma_buffer->mem.Start; - GLuint end = MIN2(start + MAX_BATCH, i810glx.dma_buffer->head); - - BEGIN_LP_RING(4); - OUT_RING( CMD_OP_BATCH_BUFFER ); - OUT_RING( (ofs + start) | BB1_PROTECTED ); - OUT_RING( (ofs + end) - 4 ); - OUT_RING( 0 ); - ADVANCE_LP_RING(); - } - - { - BEGIN_LP_RING(2); - OUT_RING( INST_PARSER_CLIENT | INST_OP_FLUSH | - INST_FLUSH_MAP_CACHE ); - OUT_RING( 0 ); - } -} - -/* - * i810DmaFlush - * Send all pending commands off to the hardware. - * If we are running async, the hardware will be drawing - * while we return to do other things. - */ -void i810ServerDmaFlush( int wait ) { - int start, end; - - if (I810_DEBUG) - fprintf(stderr, - "i810ServerDmaFlush, buffer %d, head %x space %x\n", - i810ActiveDmaBuffer, - i810glx.dma_buffer->head, - i810glx.dma_buffer->space); - - if ( i810glx.dma_buffer->head == 0 ) - { - if (wait && !i810WaitForDmaCompletion()) - i810glx.hardwareWentIdle = 1; - - return; - } - - i810glx.c_dmaFlush++; - - /* wait for the last buffer to complete */ - if ( !i810WaitForDmaCompletion() ) - i810glx.hardwareWentIdle = 1; - - - /* collect timing information if we are going syncronously */ - if ( i810glx.dmaDriver != 3 ) { - start = i810_usec(); - } else { - start = end = 0; - } - - i810FlushRealDma(); - - if ( i810glx.dmaDriver == 2 ) { - /* wait until the dma completes */ - i810WaitForDmaCompletion(); - } - - if ( i810glx.dmaDriver != 3 ) { - end = i810_usec(); - } - - i810Msg(10, "flushmode %i, buffer %i: prim dwords:%i usec:%i\n", - i810glx.dmaDriver, i810ActiveDmaBuffer, - i810glx.dma_buffer->head / 4, - end - start ); - - /* swap to using the other buffer */ - i810ActiveDmaBuffer ^= 1; - i810DmaResetBuffer(); - - if ( wait ) - i810WaitForDmaCompletion(); -} - - -/* - * i810DmaFlush - */ -void i810DmaFlush( void ) { - i810FinishPrimitive(); - i810glx.dma_buffer->texture_age = ++i810glx.current_texture_age; - - if ( i810Ctx && i810Ctx->CurrentTex0Obj ) - i810Ctx->CurrentTex0Obj->age = ++i810glx.current_texture_age; - - if ( i810Ctx && i810Ctx->CurrentTex1Obj ) - i810Ctx->CurrentTex1Obj->age = ++i810glx.current_texture_age; - - i810ServerDmaFlush( 0 ); -} - - -/* - * i810DmaFinish - */ -void i810DmaFinish( void ) { - i810FinishPrimitive(); - i810ServerDmaFlush( 1 ); - - i810glx.dma_buffer_age = ++i810glx.current_texture_age; - - if ( i810Ctx && i810Ctx->CurrentTex0Obj ) - i810Ctx->CurrentTex0Obj->age = ++i810glx.current_texture_age; - - if ( i810Ctx && i810Ctx->CurrentTex1Obj ) - i810Ctx->CurrentTex1Obj->age = ++i810glx.current_texture_age; -} - - -/* - * i810DmaOverflow - * This is called when I810DMAGETPTR is at the end of the buffer - */ -void i810DmaOverflow( int newDwords ) { - - if (i810glx.dma_buffer->additional_space) { - GLuint incr = MAX_BATCH; - - if (i810glx.dma_buffer->additional_space < incr) - incr = i810glx.dma_buffer->additional_space; - - while (i810glx.dma_buffer->head & (MAX_BATCH - 1)) { - GLuint outbatch = i810glx.dma_buffer->head; - GLubyte *virt = i810glx.dma_buffer->virtual_start; - - *(volatile unsigned int *)(virt + outbatch) = 0; - i810glx.dma_buffer->head += 4; - } - - i810glx.dma_buffer->space += incr; - i810glx.dma_buffer->additional_space -= incr; - - if (0) - fprintf(stderr, "overflow, head %x space %x\n", - i810glx.dma_buffer->head, - i810glx.dma_buffer->space); - return; - } - - i810Msg( 9, "i810DmaOverflow(%i)\n", newDwords ); - - /* flush all the current commands so we will have another - empty buffer */ - i810DmaFlush(); - - i810glx.c_overflows++; - - if ( newDwords > i810glx.dma_buffer->space ) - FatalError("i810DmaOverflow > maxPrimaryDwords"); -} - - -/* - * i810WaitDrawingEngine - * This will not return until the drawing engine has completed - * drawing pixels and it is safe to read or write the framebuffer - * for software rendering. - */ -int i810WaitDrawingEngine( void ) { - /* note this for the performance block display */ - i810glx.c_drawWaits++; - - /* make sure all pending dma has completed */ - i810DmaFinish(); - return 0; -} - - -/* - * i810DmaExecute - * Add a block of data to the dma buffer - */ -void i810DmaExecute( GLuint *code, int dwords ) -{ - int i; - BEGIN_BATCH(dwords); - - if (dwords & 1) - FatalError( "Misaligned buffer in i810DmaExecute\n" ); - - for ( i = 0 ; i < dwords ; i++ ) - OUT_BATCH( code[i] ); - ADVANCE_BATCH(); -} - - - diff --git a/xc/lib/GL/mesa/src/drv/i810/i810dma.h b/xc/lib/GL/mesa/src/drv/i810/i810dma.h index 55adbcddd..3fd995cb3 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810dma.h +++ b/xc/lib/GL/mesa/src/drv/i810/i810dma.h @@ -1,138 +1,44 @@ -/* - GLX Hardware Device Driver for Intel i810 - Copyright (C) 1999 Keith Whitwell <keithw@precisioninsight.com> - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - - original by Jeff Hartmann <slicer@ionet.net> - 6/16/99: rewrite by John Carmack <johnc@idsoftware.com> - Oct 99: port to i180 by Keith Whitwell <keithw@precisioninsight.com> -*/ #ifndef I810DMA_H #define I810DMA_H -#include "i810common.h" #include "i810lib.h" -#include "i810.h" +#include "i810_init.h" #include "mm.h" -/* the main initialization of the entire i810 hardware driver */ -GLboolean i810InitGLX( void ); -/* a flush command will guarantee that all data added to the dma buffer -is on its way to the card, and will eventually complete with no more -intervention. -*/ -void i810DmaFlush(void); - -/* the overflow function is called when a block can't be allocated -in the current dma buffer. It flushes the current buffer and -records some information */ -void i810DmaOverflow(int newDwords); - -/* a finish command will guarantee that all dma commands have actually -been consumed by the card. Note that there may still be a couple primitives -that have not yet been executed out of the internal FIFO, so this does not -guarantee that the drawing engine is idle. */ -void i810DmaFinish( void ); - -/* a i810WaitDrawingEngine command will guarantee that the framebuffer -is safe to read or write for software rendering */ -int i810WaitDrawingEngine( void ); - - - - - -typedef struct { - I810MemRange mem; - char *virtual_start; - int head; - int space; - int additional_space; - int texture_age; -} i810BatchBuffer; - - - -#define I810_USE_BATCH 1 -#if I810_USE_BATCH - -#define BEGIN_BATCH(n) \ +/* Vertex data does not use these macros. + */ +#define BEGIN_BATCH( imesa, n ) \ unsigned int outbatch; \ volatile char *virt; \ if (I810_DEBUG & DEBUG_VERBOSE_RING) \ - fprintf(stderr, \ - "BEGIN_BATCH(%d) in %s\n" \ - "(spc left %d/%d, head %x vstart %x start %x)\n", \ - n, __FUNCTION__, i810glx.dma_buffer->space, \ - i810glx.dma_buffer->mem.Size - i810glx.dma_buffer->head, \ - i810glx.dma_buffer->head, \ - i810glx.dma_buffer->virtual_start, \ - i810glx.dma_buffer->mem.Start ); \ - if (i810glx.dma_buffer->space < n*4) \ - i810DmaOverflow(n); \ - outbatch = i810glx.dma_buffer->head; \ - virt = i810glx.dma_buffer->virtual_start; - - -#define OUT_BATCH(val) { \ - *(volatile unsigned int *)(virt + outbatch) = val; \ - if (I810_DEBUG & DEBUG_VERBOSE_RING) \ - fprintf(stderr, "OUT_BATCH %x: %x\n", outbatch/4, val); \ - outbatch += 4; \ -} + fprintf(stderr, "BEGIN_BATCH(%d) in %s\n", n, __FUNCTION__); \ + if (imesa->dma_buffer->total - imesa->dma_buffer->used < n*4) { \ + i810FlushGeneralLocked( imesa ); \ + i810GetGeneralDmaBufferLocked( imesa ); \ + } \ + outbatch = imesa->dma_buffer->used; \ + virt = imesa->dma_buffer->address; + + +#define OUT_BATCH(val) do { \ + *(volatile unsigned int *)(virt + outbatch) = val; \ + if (I810_DEBUG & DEBUG_VERBOSE_RING) \ + fprintf(stderr, "OUT_BATCH %x: %x\n", \ + (int)(outbatch/4), (int)(val)); \ + outbatch += 4; \ +} while (0) -#define ADVANCE_BATCH() { \ - if (I810_DEBUG & DEBUG_VERBOSE_RING) \ - fprintf(stderr, "ADVANCE_BATCH(%f) in %s\n", \ - (outbatch - i810glx.dma_buffer->head) / 4.0, \ - __FUNCTION__); \ - i810glx.dma_buffer->space -= outbatch - i810glx.dma_buffer->head; \ - i810glx.dma_buffer->head = outbatch; \ -} +#define ADVANCE_BATCH() do { \ + if (I810_DEBUG & DEBUG_VERBOSE_RING) \ + fprintf(stderr, "ADVANCE_BATCH(%.1f) in %s\n", \ + (outbatch - imesa->dma_buffer->used) / 4.0, \ + __FUNCTION__); \ + imesa->dma_buffer->used = outbatch; \ +} while(0) #define FINISH_PRIM() -#else - -/* Need some work to be able to do primitives this way. - */ -#define BEGIN_BATCH(n) BEGIN_LP_RING(n) -#define ADVANCE_BATCH() ADVANCE_LP_RING() -#define OUT_BATCH(val) OUT_RING(val) -#define FINISH_PRIM() OUTREG(I810LpRing.base_reg + RING_TAIL, I810LpRing.tail) - -#endif - - -/* These are only required by i810direct.c: - */ -extern GLuint i810ActiveDmaBuffer; -extern void (*i810DoDmaFlush)( int ); -extern i810BatchBuffer *dmaBuffers[2]; - -extern int i810WaitForDmaCompletion( void ); -extern void i810DmaResetBuffer( void ); - -extern void i810DmaExecute( GLuint *code, int dwords ); - -extern void I810Sync( void ) ; -extern void I810WaitLpRing( int n ); - - #endif diff --git a/xc/lib/GL/mesa/src/drv/i810/i810dmainit.c b/xc/lib/GL/mesa/src/drv/i810/i810dmainit.c deleted file mode 100644 index 335c4a612..000000000 --- a/xc/lib/GL/mesa/src/drv/i810/i810dmainit.c +++ /dev/null @@ -1,389 +0,0 @@ - -/* -*- mode: C; c-basic-offset:8 -*- */ -/* - * GLX Hardware Device Driver for Intel i810 - * 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. - * - * - * based on the original by Jeff Hartmann <slicer@ionet.net> - * as rewritten by John Carmack <johnc@idsoftware.com> - */ - -/* - -This file is only entered at startup. After i810GlxInit completes, -nothing here will be executed again. - -*/ - -#include <stdlib.h> -#include <errno.h> -#include <unistd.h> -#include <sys/mman.h> -#include <stdio.h> -#include <sys/stat.h> -#include <sys/ioctl.h> -#include <fcntl.h> -#include <signal.h> - -#include "context.h" -#include "depth.h" -#include "macros.h" -#include "texstate.h" -#include "triangle.h" -#include "vb.h" -#include "types.h" - -#include "xsmesaP.h" -#include "glx_log.h" -#include "mesaglx/context.h" -#include "mesaglx/matrix.h" -#include "mesaglx/types.h" - -#define GC XXGC -#include "gcstruct.h" -#include "pixmapstr.h" -#include "servermd.h" /* PixmapBytePad */ -#include "scrnintstr.h" -#include "regionstr.h" -#include "windowstr.h" -#undef GC - -#include "vga.h" -#include "vgaPCI.h" -#include "i810.h" -#include "xaa/xf86xaa.h" - -#include "mm.h" -#include "i810buf.h" -#include "i810dd.h" -#include "i810lib.h" -#include "i810log.h" -#include "i810direct.h" -#include "i810glx.h" - -#include <agpgart.h> - -/* private vars */ -i810BatchBuffer *dmaBuffers[2]; -static I810MemRange I810SysMem2; - - -static const char *getenvSafe(const char *name ) { - const char *r; - - r = getenv( name ); - if ( !r ) { - return ""; - } - return r; -} - - -static void AllocateCommandBuffers( void ) -{ - PMemBlock block; - GLuint bufferBytes = i810glx.cmdSize; - GLuint start, i; - - if ( 1 || !bufferBytes ) { - fprintf(stderr,"temporarily hardwiring GLX_I810_CMDSIZE = 1\n" ); - bufferBytes = 1; - } - - bufferBytes *= 0x100000; - - block = mmAllocMem( i810glx.sysmemHeap, bufferBytes, 8, 0 ); - - if ( !block ) { - fprintf(stderr, - "failed to allocate 0x%x bytes from " - "sysmemHeap for command buffers.\n", - bufferBytes ); - - FatalError("Couldn't get dma buffer\n"); - } - - start = block->ofs; - - /* setup the two buffers that will be ping-ponged - */ - for (i = 0 ; i < 2 ; i++) { - dmaBuffers[i] = calloc(1,sizeof(i810BatchBuffer)); - dmaBuffers[i]->virtual_start = i810glx.sysmemVirtual + start; - dmaBuffers[i]->mem.Start = start; - dmaBuffers[i]->mem.Size = bufferBytes / 2; - dmaBuffers[i]->mem.End = (start += bufferBytes / 2); - } - - i810DmaResetBuffer(); -} - - -/* Another bit of duplication caused by 'static' code in the X server. - */ -static int gartfd; -static struct gart_info gartinf; -static char *gart_buf; - -static int AllocateGARTMemory( int size ) -{ - int i, pages = size / 4096; - int start = vga256InfoRec.videoRam / 4; /* a crock! */ - struct stat sb; - - if (stat("/dev/agpgart", &sb) != 0) { - ErrorF("Stat failed on /dev/agpgart: %s\n", - sys_errlist[errno]); - return -1; - } - - gartfd = open("/dev/agpgart", O_RDWR); - if (gartfd == -1) { - ErrorF("unable to open /dev/agpgart: %s\n", - sys_errlist[errno]); - FatalError("Aborting"); - } - - if (ioctl(gartfd, GARTIOCINFO, &gartinf) != 0) { - ErrorF("error doing ioctl(GARTIOCINFO): %s\n", - sys_errlist[errno]); - FatalError("Aborting"); - } - - /* Treat the gart like video memory - we assume we own all that is - * there, so ignore EBUSY errors. Don't try to remove it on - * failure, either. - */ - for (i = start; i < start+pages; i++) - if (ioctl(gartfd, GARTIOCINSERT, &i) != 0) { - if (errno != EBUSY) - { - perror("gart insert"); - ErrorF("GART: allocation of %d pages failed at page %d\n", - pages, i); - FatalError("Aborting"); - } - } - - ErrorF("GART: allocated %dK system ram\n", pages * 4); - - I810SysMem2.Start = start * 4096; - I810SysMem2.End = (start + pages) * 4096; - I810SysMem2.Size = pages * 4096; - - gart_buf = mmap( 0, - gartinf.size * 0x100000, - PROT_READ | PROT_WRITE, - MAP_SHARED, - gartfd, - 0 ); - - if ((unsigned int)gart_buf == ~0) { - perror("/dev/agpgart"); - FatalError("Couldn't mmap /dev/agpgart - aborting"); - } - - return 0; -} - - -/* - * AllocateSystemMemory - * Looks at environment variables to determine if a block - * of physical memory has been left for graphics after the - * memory available to the kernel. - * System memory can be used for dma command buffers or - * textures. - */ -static void AllocateSystemMemory( void ) -{ - GLuint sysmemBytes = i810glx.dmaSize; - - if ( !sysmemBytes ) - sysmemBytes = 8; - - sysmemBytes *= 0x100000; - - if (AllocateGARTMemory(sysmemBytes) != 0) - FatalError( "AllocateGARTMemory failed.\n" ); - - - i810glx.sysmemVirtual = (unsigned char *)gart_buf; - - /* Suck in any leftover memory from the 2d server. - - i810glx.sysmemHeap = mmInit( I810SysMem.Start, - I810SysMem.Size ); - */ - - /* Add our new memory. - */ - i810glx.sysmemHeap = -/* mmAddRange( i810glx.sysmemHeap, */ - mmInit( - I810SysMem2.Start, - I810SysMem2.Size ); - - - /* Manage dcache mem via. a seperate heap. - */ - i810glx.cardHeap = mmInit( I810DcacheMem.Start, - I810DcacheMem.Size ); - - i810Msg( 1, "sysmemSize: 0x%x\n", sysmemBytes ); - i810Msg( 1, "cardSize: 0x%lx\n", I810DcacheMem.Size ); -} - - - -/* - * i810DmaInit - * -*/ -void i810DmaInit(void) { - - /* Server init - queries environment variables. The client - * gets these values from the sever and initializes them in - * i810direct.c - */ - if (__glx_is_server) { - i810glx.dmaDriver = atoi( getenvSafe("GLX_I810_DMA") ); - i810glx.dmaSize = atoi( getenvSafe("GLX_I810_DMASIZE") ); - i810glx.cmdSize = atoi( getenvSafe("GLX_I810_CMDSIZE") ); - - if (i810glx.dmaDriver != 3) - FatalError("GLX_I810_DMA not set\n"); - } - - /* get some system memory and make it write combining if we can */ - AllocateSystemMemory(); - - /* read the command environment variable */ - i810Msg(1,"i810DmaInit: GLX_I810_DMA = %i\n", i810glx.dmaDriver ); - - /* setup the two command buffers in the apropriate memory space */ - AllocateCommandBuffers(); - - /* prepare the first buffer for use */ - i810DmaResetBuffer(); -} - - -/* - * This function should only verify that the current hardware is supported. - * It should do no setup. - */ -static GLboolean i810_detect_hw( void ) -{ - if (I810Chipset == -1) - return GL_FALSE; - - if (vga256InfoRec.depth != 15 && - vga256InfoRec.depth != 16) - { - i810Error("Unsupported depth: %d, only 15 and 16d bpp " - "are supported right now\n", - vga256InfoRec.depth); - return GL_FALSE; - } - - return GL_TRUE; -} - -/* - * i810InitLogging - * - */ -void i810InitLogging( void ) -{ - i810glx.logLevel = 100; -} - - - -/* - * i810InitGLX - * This is the initial entry point for the i810 hardware driver, - * called at X server module load time, or libGL direct rendering - * init time. - */ -GLboolean i810InitGLX( void ) { - - fprintf(stderr, "\n\n\n\ni810InitGLX\n"); - - i810InitLogging(); - - i810Msg(1,"virtual (x, y) (%d, %d)\n", vga256InfoRec.virtualX, - vga256InfoRec.virtualY); - i810Msg(1,"width: %d\n", vga256InfoRec.displayWidth); - i810Msg(1,"depth: %d\n", vga256InfoRec.depth); - i810Msg(1,"memBase: %p\n", vgaLinearBase); - i810Msg(1,"videoRam: 0x%08x\n", vga256InfoRec.videoRam); - - if (!i810_detect_hw()) { - ErrorF("Couldn't find i810 hardware\n\n\n"); - return GL_FALSE; - } - - /* init the dma system */ - i810DmaInit(); - - /* Register as a glx driver */ - GLXProcs.CreateContext = i810GLXCreateContext; - GLXProcs.DestroyContext = i810GLXDestroyContext; - GLXProcs.SwapBuffers = i810GLXSwapBuffers; - GLXProcs.CreateImage = i810GLXCreateImage; - GLXProcs.DestroyImage = i810GLXDestroyImage; - GLXProcs.CreateDepthBuffer = i810GLXCreateDepthBuffer; - GLXProcs.MakeCurrent = i810GLXMakeCurrent; - GLXProcs.BindBuffer = i810GLXBindBuffer; - GLXProcs.SwapBuffers = i810GLXSwapBuffers; - GLXProcs.VendorPrivate = i810GLXVendorPrivate; - GLXProcs.AllowDirect = i810GLXAllowDirect; - - if (!__glx_is_server) { - GLXProcs.ValidateFrontBuffer = i810ClientGetGeometry; - } - - /* these vars can be changed between invocations of direct clients */ - if (getenv("GLX_I810_NULLPRIMS") ) { - i810Msg( 1, "enabling GLX_I810_NULLPRIMS\n" ); - i810glx.nullprims = 1; - } - if (getenv("GLX_I810_SKIPDMA") ) { - i810Msg( 1, "enabling GLX_I810_SKIPDMA\n" ); - i810glx.skipDma = 1; - } - if (getenv("GLX_I810_BOXES") ) { - i810Msg( 1, "enabling GLX_I810_BOXES\n" ); - i810glx.boxes = 1; - } - if (getenv("GLX_I810_NOFALLBACK") ) { - i810Msg( 1, "enabling GLX_I810_NOFALLBACK\n" ); - i810glx.noFallback = 1; - } - - i810Error("i810InitGLX completed\n"); - return GL_TRUE; -} - - diff --git a/xc/lib/GL/mesa/src/drv/i810/i810fastpath.c b/xc/lib/GL/mesa/src/drv/i810/i810fastpath.c index 9223060e7..3e4887619 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810fastpath.c +++ b/xc/lib/GL/mesa/src/drv/i810/i810fastpath.c @@ -116,14 +116,10 @@ static void i810_render_elements_direct( struct vertex_buffer *VB ) if (imesa->new_state) i810DDUpdateHwState( ctx ); - BEGIN_CLIP_LOOP(imesa) - { - do { - func( VB, 0, nr, 0 ); - } while (ctx->Driver.MultipassFunc && - ctx->Driver.MultipassFunc( VB, ++p )); - } - END_CLIP_LOOP(imesa); + do { + func( VB, 0, nr, 0 ); + } while (ctx->Driver.MultipassFunc && + ctx->Driver.MultipassFunc( VB, ++p )); } diff --git a/xc/lib/GL/mesa/src/drv/i810/i810glx.h b/xc/lib/GL/mesa/src/drv/i810/i810glx.h deleted file mode 100644 index df5c08674..000000000 --- a/xc/lib/GL/mesa/src/drv/i810/i810glx.h +++ /dev/null @@ -1,44 +0,0 @@ -/* - * GLX Hardware Device Driver for Intel i810 - * Copyright (C) 1999 Wittawat Yamwong - * - * 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 - * WITTAWAT YAMWONG, 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 I810GLX_INC -#define I810GLX_INC - -void i810DumpDB(struct i810_dest_buffer *buf); -void i810GLXCreateDepthBuffer(GLcontext* ctx); -void i810GLXDestroyImage(GLXImage* image); -GLXImage* i810GLXCreateImage(WindowPtr pwindow, int depth, int width, int height); -GLboolean i810GLXMakeCurrent( XSMesaContext c ); -GLboolean i810GLXBindBuffer( XSMesaContext c, XSMesaBuffer b ); -XSMesaContext i810GLXCreateContext( XSMesaVisual v, - XSMesaContext share_list ); -void i810GLXDestroyContext( XSMesaContext c ); - -extern int i810BackToFront(DrawablePtr drawable, struct i810_dest_buffer *buf); -extern void (*i810GLXSwapBuffers)(XSMesaBuffer b); -extern void i810PerformanceBoxes( int is_direct ); - - -#endif diff --git a/xc/lib/GL/mesa/src/drv/i810/i810ioctl.c b/xc/lib/GL/mesa/src/drv/i810/i810ioctl.c new file mode 100644 index 000000000..93e2f4492 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i810/i810ioctl.c @@ -0,0 +1,436 @@ +#include <stdio.h> + + +#include "types.h" +#include "pb.h" +#include "dd.h" + +#include "mm.h" +#include "i810context.h" +#include "i810log.h" +#include "i810ioctl.h" + +#include "drm.h" +#include <sys/ioctl.h> + +static int _tot_used, _tot_size; + +void i810FlushGeneralLocked( i810ContextPtr imesa ) +{ + int retcode; + drm_i810_general_t dma; + drmBufPtr buf = imesa->dma_buffer; + + if (!buf) { + fprintf(stderr, "i810FlushGeneralLocked: no buffer\n"); + return; + } + + _tot_used += buf->used; + _tot_size += buf->total; + + dma.idx = buf->idx; + dma.used = buf->used; + + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "DRM_IOCTL_I810_DMA idx %d used %d\n", + dma.idx, dma.used); + + if ((retcode = ioctl(imesa->driFd, DRM_IOCTL_I810_DMA, &dma))) { + printf("send dma retcode = %d\n", retcode); + exit(1); + } + + imesa->dma_buffer = 0; + + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "finished general dma put\n"); +} + +static drmBufPtr i810_get_buffer_ioctl( i810ContextPtr imesa ) +{ + int idx = 0; + int size = 0; + drmDMAReq dma; + int retcode; + drmBufPtr buf; + int cnt = 0; + + + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "Getting dma buffer\n"); + + dma.context = imesa->hHWContext; + dma.send_count = 0; + dma.send_list = NULL; + dma.send_sizes = NULL; + dma.flags = 0; + dma.request_count = 1; + dma.request_size = I810_DMA_BUF_SZ; + dma.request_list = &idx; + dma.request_sizes = &size; + dma.granted_count = 0; + + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "drmDMA (get) ctx %d count %d size 0x%x\n", + dma.context, dma.request_count, + dma.request_size); + + while (1) { + retcode = drmDMA(imesa->driFd, &dma); + + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "retcode %d sz %d idx %d count %d\n", + retcode, + dma.request_sizes[0], + dma.request_list[0], + dma.granted_count); + + if (retcode == 0 && + dma.request_list[0] && + dma.request_sizes[0] && + dma.granted_count) + break; + + if (++cnt > 1000) { + + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) { + fprintf(stderr, "\n\nflush retcode %d idx %d sz %d count %d\n", + retcode, dma.request_list[0], + dma.request_sizes[0], dma.granted_count); + + fprintf(stderr, "used %d size %d (ratio %.3f)\n", + _tot_used, _tot_size, (float)_tot_size / (float)_tot_used); + } + + ioctl(imesa->driFd, DRM_IOCTL_I810_FLUSH); + } + } + + + + buf = &(imesa->i810Screen->bufs->list[idx]); + buf->used = 0; + + + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, + "drmDMA (get) returns size[0] 0x%x idx[0] %d\n" + "dma_buffer now: buf idx: %d size: %d used: %d\n", + dma.request_sizes[0], dma.request_list[0], + buf->idx, buf->total, + buf->used); + + return buf; +} + + + +void i810GetGeneralDmaBufferLocked( i810ContextPtr imesa ) +{ + if (imesa->dma_buffer) { + fprintf(stderr, "i810GetGeneralDmaBufferLocked - dma_buffer not zero\n"); + exit(1); + } + + imesa->dma_buffer = i810_get_buffer_ioctl( imesa ); +} + + + +/* This waits for *everybody* to finish rendering -- overkill. + */ +void i810DmaFinish( i810ContextPtr imesa ) +{ + FLUSH_BATCH( imesa ); + + if (imesa->sarea->last_quiescent != imesa->sarea->last_enqueue) { + + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "i810DmaFinish\n"); + + LOCK_HARDWARE( imesa ); + i810RegetLockQuiescent( imesa ); + UNLOCK_HARDWARE( imesa ); + imesa->sarea->last_quiescent = imesa->sarea->last_enqueue; + } +} + + +void i810RegetLockQuiescent( i810ContextPtr imesa ) +{ + if (imesa->sarea->last_quiescent != imesa->sarea->last_enqueue) { + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "i810RegetLockQuiescent\n"); + + drmUnlock(imesa->driFd, imesa->hHWContext); + i810GetLock( imesa, DRM_LOCK_QUIESCENT ); + imesa->sarea->last_quiescent = imesa->sarea->last_enqueue; + } +} + +void i810WaitAgeLocked( i810ContextPtr imesa, int age ) +{ + int i = 0; + + if (0) fprintf(stderr, "waitagelocked\n"); + + while (++i < 500000 && GET_DISPATCH_AGE(imesa) < age) { + ioctl(imesa->driFd, DRM_IOCTL_I810_GETAGE); + } + + if (GET_DISPATCH_AGE(imesa) < age) { + if (0) + fprintf(stderr, "wait locked %d %d\n", age, GET_DISPATCH_AGE(imesa)); + ioctl(imesa->driFd, DRM_IOCTL_I810_FLUSH); + } +} + + +void i810WaitAge( i810ContextPtr imesa, int age ) +{ + int i = 0; + + while (++i < 500000 && GET_DISPATCH_AGE(imesa) < age) { + ioctl(imesa->driFd, DRM_IOCTL_I810_GETAGE); + } + + if (GET_DISPATCH_AGE(imesa) >= age) + return; + + i = 0; + while (++i < 1000 && GET_DISPATCH_AGE(imesa) < age) { + ioctl(imesa->driFd, DRM_IOCTL_I810_GETAGE); + usleep(1000); + } + + /* To be effective at letting other clients at the hardware, + * particularly the X server which regularly needs quiescence to + * touch the framebuffer, we really need to sleep *beyond* the + * point where our last buffer clears the hardware. + */ + if (imesa->any_contend) { + usleep(3000); + } + + imesa->any_contend = 0; + + if (GET_DISPATCH_AGE(imesa) < age) { + LOCK_HARDWARE(imesa); + if (GET_DISPATCH_AGE(imesa) < age) + ioctl(imesa->driFd, DRM_IOCTL_I810_FLUSH); + UNLOCK_HARDWARE(imesa); + } +} + + + +void i810FlushVertices( i810ContextPtr imesa ) +{ + if (!imesa->vertex_dma_buffer) return; + + LOCK_HARDWARE( imesa ); + i810FlushVerticesLocked( imesa ); + UNLOCK_HARDWARE( imesa ); +} + + +static int intersect_rect( drm_clip_rect_t *out, + drm_clip_rect_t *a, + drm_clip_rect_t *b ) +{ + *out = *a; + if (b->x1 > out->x1) out->x1 = b->x1; + if (b->y1 > out->y1) out->y1 = b->y1; + if (b->x2 < out->x2) out->x2 = b->x2; + if (b->y2 < out->y2) out->y2 = b->y2; + if (out->x1 >= out->x2) return 0; + if (out->y1 >= out->y2) return 0; + return 1; +} + + +static void age_imesa( i810ContextPtr imesa, int age ) +{ + if (imesa->CurrentTexObj[0]) imesa->CurrentTexObj[0]->age = age; + if (imesa->CurrentTexObj[1]) imesa->CurrentTexObj[1]->age = age; +} + +void i810FlushVerticesLocked( i810ContextPtr imesa ) +{ + drm_clip_rect_t *pbox = (drm_clip_rect_t *)imesa->pClipRects; + int nbox = imesa->numClipRects; + drmBufPtr buffer = imesa->vertex_dma_buffer; + drm_i810_vertex_t vertex; + int i; + + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "i810FlushVerticesLocked, buf %p\n", buffer); + + if (!buffer) + return; + + if (imesa->dirty & ~I810_EMIT_CLIPRECT) + i810EmitHwStateLocked( imesa ); + + + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "i810FlushVerticesLocked, used %d\n", + buffer->used); + + _tot_used += buffer->used; + _tot_size += buffer->total; + + imesa->vertex_dma_buffer = 0; + + vertex.idx = buffer->idx; + vertex.used = buffer->used; + vertex.discard = 0; + + if (!nbox) + vertex.used = 0; + + if (nbox > I810_NR_SAREA_CLIPRECTS) + imesa->dirty |= I810_EMIT_CLIPRECT; + + if (!vertex.used || !(imesa->dirty & I810_EMIT_CLIPRECT)) + { + if (nbox == 1) + imesa->sarea->nbox = 0; + else + imesa->sarea->nbox = nbox; + + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "DRM_IOCTL_I810_VERTEX CASE1 nbox %d used %d\n", + nbox, vertex.used); + + vertex.discard = 1; + ioctl(imesa->driFd, DRM_IOCTL_I810_VERTEX, &vertex); + age_imesa(imesa, imesa->sarea->last_enqueue); + } + else + { + for (i = 0 ; i < nbox ; ) + { + int nr = MIN2(i + I810_NR_SAREA_CLIPRECTS, nbox); + drm_clip_rect_t *b = imesa->sarea->boxes; + + if (imesa->scissor) { + imesa->sarea->nbox = 0; + + for ( ; i < nr ; i++) { + b->x1 = pbox[i].x1 - imesa->drawX; + b->y1 = pbox[i].y1 - imesa->drawY; + b->x2 = pbox[i].x2 - imesa->drawX; + b->y2 = pbox[i].y2 - imesa->drawY; + + if (intersect_rect(b, b, &imesa->scissor_rect)) { + imesa->sarea->nbox++; + b++; + } + } + + /* Culled? + */ + if (!imesa->sarea->nbox) { + if (nr < nbox) continue; + vertex.used = 0; + } + } else { + imesa->sarea->nbox = nr - i; + for ( ; i < nr ; i++, b++) { + b->x1 = pbox[i].x1 - imesa->drawX; + b->y1 = pbox[i].y1 - imesa->drawY; + b->x2 = pbox[i].x2 - imesa->drawX; + b->y2 = pbox[i].y2 - imesa->drawY; + } + } + + /* Finished with the buffer? + */ + if (nr == nbox) + vertex.discard = 1; + + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "DRM_IOCTL_I810_VERTEX nbox %d used %d\n", + nbox, vertex.used); + + ioctl(imesa->driFd, DRM_IOCTL_I810_VERTEX, &vertex); + age_imesa(imesa, imesa->sarea->last_enqueue); + } + } + + imesa->dirty = 0; + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "finished i810FlushVerticesLocked\n"); +} + + +GLuint *i810AllocDwords( i810ContextPtr imesa, int dwords ) +{ + GLuint orig_dwords = dwords; + GLuint *start; + + dwords++; + dwords&=~1; + + if (!imesa->vertex_dma_buffer) + { + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "i810AllocPrimitiveVerts -- get buf\n"); + LOCK_HARDWARE(imesa); + imesa->vertex_dma_buffer = i810_get_buffer_ioctl( imesa ); + UNLOCK_HARDWARE(imesa); + } + else if (imesa->vertex_dma_buffer->used + dwords * 4 > + imesa->vertex_dma_buffer->total) + { + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "i810AllocPrimitiveVerts -- flush\n"); + i810FlushVertices( imesa ); + LOCK_HARDWARE(imesa); + imesa->vertex_dma_buffer = i810_get_buffer_ioctl( imesa ); + UNLOCK_HARDWARE(imesa); + } + + if (0) + fprintf(stderr, "i810AllocPrimitiveVerts %d, buf %d, used %d\n", + dwords, imesa->vertex_dma_buffer->idx, + imesa->vertex_dma_buffer->used); + + + start = (GLuint *)((char *)imesa->vertex_dma_buffer->address + + imesa->vertex_dma_buffer->used); + + imesa->vertex_dma_buffer->used += dwords * 4; + + if (orig_dwords & 1) + *start++ = 0; + + return start; +} + + + + + + +static void i810DDFlush( GLcontext *ctx ) +{ + i810ContextPtr imesa = I810_CONTEXT( ctx ); + FLUSH_BATCH( imesa ); +} + + +static void i810DDFinish( GLcontext *ctx ) +{ + i810ContextPtr imesa = I810_CONTEXT( ctx ); + i810DmaFinish( imesa ); +} + + +void i810DDInitIoctlFuncs( GLcontext *ctx ) +{ + ctx->Driver.Flush = i810DDFlush; + ctx->Driver.Finish = i810DDFinish; +} diff --git a/xc/lib/GL/mesa/src/drv/i810/i810ioctl.h b/xc/lib/GL/mesa/src/drv/i810/i810ioctl.h new file mode 100644 index 000000000..ac213bf1e --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/i810/i810ioctl.h @@ -0,0 +1,32 @@ +#ifndef MGA_IOCTL_H +#define MGA_IOCTL_H + +#include "i810context.h" + + +GLuint *i810AllocDwords( i810ContextPtr imesa, int dwords ); + +void i810GetGeneralDmaBufferLocked( i810ContextPtr mmesa ); + +void i810FlushVertices( i810ContextPtr mmesa ); +void i810FlushVerticesLocked( i810ContextPtr mmesa ); + +void i810FlushGeneralLocked( i810ContextPtr imesa ); +void i810WaitAgeLocked( i810ContextPtr imesa, int age ); +void i810WaitAge( i810ContextPtr imesa, int age ); + +void i810DmaFinish( i810ContextPtr imesa ); + +void i810RegetLockQuiescent( i810ContextPtr imesa ); + +void i810DDInitIoctlFuncs( GLcontext *ctx ); + + +#define FLUSH_BATCH(imesa) do { \ + if (I810_DEBUG&DEBUG_VERBOSE_IOCTL) \ + fprintf(stderr, "FLUSH_BATCH in %s\n", __FUNCTION__); \ + if (imesa->vertex_dma_buffer) i810FlushVertices(imesa); \ +} while (0) + + +#endif diff --git a/xc/lib/GL/mesa/src/drv/i810/i810lib.h b/xc/lib/GL/mesa/src/drv/i810/i810lib.h index ec07995a0..ad80674f0 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810lib.h +++ b/xc/lib/GL/mesa/src/drv/i810/i810lib.h @@ -28,29 +28,34 @@ #include <stdio.h> -#include "i810common.h" -#include "i810buf.h" #include "i810context.h" #include "mm.h" #include "i810log.h" -#include "i810dma.h" -#ifndef MESA31 -#error "The I810 driver now requires Mesa 3.1 or higher" -#endif +struct i810_mem_range { + unsigned long Start; + unsigned long End; + unsigned long Size; +}; + +struct i810_batch_buffer; + +struct i810_ring_buffer { + int tail_mask; + struct i810_mem_range mem; + char *virtual_start; + int head; + int tail; + int space; + int synced; +}; typedef struct { /* logging stuff */ GLuint logLevel; FILE *logFile; - /* dma stuff */ - GLuint dmaDriver; - GLuint dmaSize; - GLuint dmaAdr; - GLuint cmdSize; - /* bookkeeping for texture swaps */ GLuint dma_buffer_age; GLuint current_texture_age; @@ -68,37 +73,28 @@ typedef struct { GLuint c_lines; GLuint c_drawWaits; GLuint c_textureSwaps; - GLuint c_signals; GLuint c_dmaFlush; GLuint c_overflows; + + GLuint c_ringlost; + GLuint c_texlost; + GLuint c_ctxlost; GLuint hardwareWentIdle; /* cleared each swapbuffers, set if a waitfordmacompletion ever exited without having to wait */ - /* Primitive managment (like warpSerie) */ - GLuint prim_start; - GLuint prim_dwords; - - /* card == dcache - * sysmem == normal gart memory - */ - memHeap_t *cardHeap; - memHeap_t *sysmemHeap; - unsigned char *sysmemVirtual; + unsigned char *texVirtual; - i810BatchBuffer *dma_buffer; + + struct i810_batch_buffer *dma_buffer; + struct i810_ring_buffer LpRing; + unsigned char *MMIOBase; } i810Glx_t; extern i810Glx_t i810glx; -int i810_usec( void ); -void i810LibInit(); -void i810SoftReset(); - -int i810MakeCurrent(i810ContextPtr ctx, struct i810_dest_buffer *buf); -void i810LoadTexturePalette(unsigned short *pal, int start, int len); #define I810PACKCOLOR1555(r,g,b,a) \ ((((r) & 0xf8) << 7) | (((g) & 0xf8) << 2) | (((b) & 0xf8) >> 3) | \ @@ -123,6 +119,7 @@ static __inline__ GLuint i810PackColor(GLuint format, case DV_PF_565: return I810PACKCOLOR565(r,g,b); default: + fprintf(stderr, "unknown format %d\n", (int)format); return 0; } } diff --git a/xc/lib/GL/mesa/src/drv/i810/i810pipeline.c b/xc/lib/GL/mesa/src/drv/i810/i810pipeline.c index 2cd53b42e..06269a818 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810pipeline.c +++ b/xc/lib/GL/mesa/src/drv/i810/i810pipeline.c @@ -1,15 +1,16 @@ /* #include "i810pipeline.h" */ #include <stdio.h> -#include "xsmesaP.h" + +#include "types.h" +#include "fog.h" + #include "i810vb.h" #include "i810dd.h" #include "i810lib.h" #include "i810tris.h" +#include "i810pipeline.h" -#include "fog.h" - -#if 0 static struct gl_pipeline_stage i810_fast_stage = { "I810 fast path", @@ -68,11 +69,6 @@ GLboolean i810DDBuildPrecalcPipeline( GLcontext *ctx ) } -#endif - - - - GLuint i810DDRegisterPipelineStages( struct gl_pipeline_stage *out, const struct gl_pipeline_stage *in, @@ -83,7 +79,6 @@ GLuint i810DDRegisterPipelineStages( struct gl_pipeline_stage *out, for (i = o = 0 ; i < nr ; i++) { switch (in[i].ops) { -#if 0 case PIPE_OP_RAST_SETUP_0: out[o] = in[i]; out[o].cva_state_change = NEW_LIGHTING|NEW_TEXTURING|NEW_RASTER_OPS; @@ -98,7 +93,6 @@ GLuint i810DDRegisterPipelineStages( struct gl_pipeline_stage *out, out[o].run = i810DDDoRasterSetup; o++; break; -#endif /* Completely replace Mesa's fog processing to generate fog * coordinates instead of messing with colors. diff --git a/xc/lib/GL/mesa/src/drv/i810/i810pipeline.h b/xc/lib/GL/mesa/src/drv/i810/i810pipeline.h index 350f23431..87b95455d 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810pipeline.h +++ b/xc/lib/GL/mesa/src/drv/i810/i810pipeline.h @@ -7,4 +7,8 @@ extern GLuint i810DDRegisterPipelineStages( struct gl_pipeline_stage *out, extern GLboolean i810DDBuildPrecalcPipeline( GLcontext *ctx ); +extern void i810DDFastPath( struct vertex_buffer *VB ); +extern void i810DDFastPathInit( void ); + + #endif diff --git a/xc/lib/GL/mesa/src/drv/i810/i810ring.c b/xc/lib/GL/mesa/src/drv/i810/i810ring.c deleted file mode 100644 index 2e5909e9f..000000000 --- a/xc/lib/GL/mesa/src/drv/i810/i810ring.c +++ /dev/null @@ -1,162 +0,0 @@ -#include <stdlib.h> -#include <errno.h> -#include <unistd.h> -#include <sys/mman.h> -#include <stdio.h> -#include <sys/time.h> -#include <sys/types.h> -#include <sys/stat.h> -#include <fcntl.h> -#include <signal.h> - -#include "mm.h" -#include "i810dd.h" -#include "i810lib.h" -#include "i810state.h" - - -#include "i810dma.h" - -static void -I810PrintErrorState( void ) -{ - fprintf(stderr, "pgetbl_ctl: 0x%x pgetbl_err: 0x%x\n", - INREG(PGETBL_CTL), - INREG(PGE_ERR)); - - fprintf(stderr, "ipeir: %x iphdr: %x\n", - INREG(IPEIR), - INREG(IPEHR)); - - fprintf(stderr, "LP ring tail: %x head: %x len: %x start %x\n", - INREG(LP_RING + RING_TAIL), - INREG(LP_RING + RING_HEAD) & HEAD_ADDR, - INREG(LP_RING + RING_LEN), - INREG(LP_RING + RING_START)); - - fprintf(stderr, "eir: %x esr: %x emr: %x\n", - INREG16(EIR), - INREG16(ESR), - INREG16(EMR)); - - fprintf(stderr, "instdone: %x instpm: %x\n", - INREG16(INST_DONE), - INREG8(INST_PM)); - - fprintf(stderr, "memmode: %x instps: %x\n", - INREG(MEMMODE), - INREG(INST_PS)); - - fprintf(stderr, "hwstam: %x ier: %x imr: %x iir: %x\n", - INREG16(HWSTAM), - INREG16(IER), - INREG16(IMR), - INREG16(IIR)); -} - - - - -static int -I810USec( void ) -{ - struct timeval tv; - struct timezone tz; - gettimeofday( &tv, &tz ); - return (tv.tv_sec & 2047) * 1000000 + tv.tv_usec; -} - - - -void -_I810RefreshLpRing( i810ContextPtr imesa, int update ) -{ - struct i810_ring_buffer *ring = &(i810glx.LpRing); - - ring->head = INREG(LP_RING + RING_HEAD) & HEAD_ADDR; - ring->tail = INREG(LP_RING + RING_TAIL); - ring->space = ring->head - (ring->tail+8); - - if (ring->space < 0) { - ring->space += ring->mem.Size; - if (update) - imesa->sarea->lastWrap = ++imesa->sarea->ringAge; - } -} - -int -_I810WaitLpRing( i810ContextPtr imesa, int n, int timeout_usec ) -{ - struct i810_ring_buffer *ring = &(i810glx.LpRing); - int iters = 0; - int startTime = 0; - int curTime = 0; - - if (timeout_usec == 0) - timeout_usec = 15000000; - - if (I810_DEBUG & DEBUG_VERBOSE_API) - fprintf(stderr, "I810WaitLpRing %d\n", n); - - while (ring->space < n) - { - int i; - - ring->head = INREG(LP_RING + RING_HEAD) & HEAD_ADDR; - ring->space = ring->head - (ring->tail+8); - - if (ring->space < 0) { - imesa->sarea->lastWrap = ++imesa->sarea->ringAge; - ring->space += ring->mem.Size; - } - - iters++; - curTime = I810USec(); - if ( startTime == 0 || curTime < startTime /*wrap case*/) { - startTime = curTime; - } else if ( curTime - startTime > timeout_usec ) { - I810PrintErrorState(); - fprintf(stderr, "space: %d wanted %d\n", - ring->space, n ); - UNLOCK_HARDWARE(imesa); - exit(1); - } - - for (i = 0 ; i < 2000 ; i++) - ; - } - - return iters; -} - -int -_I810Sync( i810ContextPtr imesa ) -{ - int rv; - - if (I810_DEBUG & DEBUG_VERBOSE_API) - fprintf(stderr, "I810Sync\n"); - - /* Send a flush instruction and then wait till the ring is empty. - * This is stronger than waiting for the blitter to finish as it also - * flushes the internal graphics caches. - */ - { - BEGIN_LP_RING( imesa, 2 ); - OUT_RING( INST_PARSER_CLIENT | INST_OP_FLUSH ); - OUT_RING( 0 ); /* pad to quadword */ - ADVANCE_LP_RING(); - } - - - i810glx.LpRing.synced = 1; /* ?? */ - - rv = _I810WaitLpRing( imesa, i810glx.LpRing.mem.Size - 8, 0 ); - imesa->sarea->lastSync = ++imesa->sarea->ringAge; - - return rv; -} - - - - diff --git a/xc/lib/GL/mesa/src/drv/i810/i810span.c b/xc/lib/GL/mesa/src/drv/i810/i810span.c index ce55c6f70..c47bf2f40 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810span.c +++ b/xc/lib/GL/mesa/src/drv/i810/i810span.c @@ -1,149 +1,174 @@ #include "types.h" -#include "i810buf.h" #include "i810dd.h" #include "i810lib.h" #include "i810dma.h" #include "i810log.h" +#include "i810span.h" +#include "i810ioctl.h" -static void (*xsmWriteRGBASpan)( const GLcontext *ctx, - GLuint n, GLint x, GLint y, - CONST GLubyte rgba[][4], - const GLubyte mask[] ); -static void (*xsmWriteRGBSpan)( const GLcontext *ctx, - GLuint n, GLint x, GLint y, - CONST GLubyte rgb[][3], const GLubyte mask[] ); -static void (*xsmWriteMonoRGBASpan)(const GLcontext *ctx, GLuint n, - GLint x, GLint y,const GLubyte mask[] ); -static void (*xsmWriteRGBAPixels)(const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - CONST GLubyte rgba[][4], - const GLubyte mask[] ); -static void (*xsmWriteMonoRGBAPixels)(const GLcontext *ctx,GLuint n, - const GLint x[], const GLint y[], - const GLubyte mask[] ); -static void (*xsmReadRGBASpan)(const GLcontext *ctx, GLuint n, - GLint x, GLint y,GLubyte rgba[][4] ); -static void (*xsmReadRGBAPixels)(const GLcontext *ctx,GLuint n, - const GLint x[], const GLint y[], - GLubyte rgba[][4], const GLubyte mask[] ); - -/* Wrapper functions */ - -static void WriteRGBASpan( const GLcontext *ctx, - GLuint n, GLint x, GLint y, - CONST GLubyte rgba[][4], - const GLubyte mask[] ) -{ - i810Msg(12,__FUNCTION__ "\n"); - i810WaitDrawingEngine(); - (*xsmWriteRGBASpan)(ctx,n,x,y,rgba,mask); -} -static void WriteRGBSpan( const GLcontext *ctx, - GLuint n, GLint x, GLint y, - CONST GLubyte rgb[][3], const GLubyte mask[] ) -{ - i810Msg(12,__FUNCTION__ "\n"); - i810WaitDrawingEngine(); - (*xsmWriteRGBSpan)(ctx,n,x,y,rgb,mask); -} +#define DBG 0 -static void WriteMonoRGBASpan(const GLcontext *ctx, GLuint n, - GLint x, GLint y,const GLubyte mask[] ) -{ - i810Msg(12,__FUNCTION__ "\n"); - i810WaitDrawingEngine(); - (*xsmWriteMonoRGBASpan)(ctx,n,x,y,mask); -} +#define LOCAL_VARS \ + __DRIdrawablePrivate *dPriv = imesa->driDrawable; \ + i810ScreenPrivate *i810Screen = imesa->i810Screen; \ + GLuint pitch = i810Screen->backPitch; \ + GLuint height = dPriv->h; \ + char *buf = (char *)(imesa->drawMap + \ + dPriv->x * 2 + \ + dPriv->y * pitch); \ + char *read_buf = (char *)(imesa->readMap + \ + dPriv->x * 2 + \ + dPriv->y * pitch); \ + GLushort p = I810_CONTEXT( ctx )->MonoColor; \ + (void) read_buf; (void) buf; (void) p -static void WriteRGBAPixels(const GLcontext *ctx, - GLuint n, const GLint x[], const GLint y[], - CONST GLubyte rgba[][4], - const GLubyte mask[] ) -{ - i810Msg(12,__FUNCTION__ "\n"); - i810WaitDrawingEngine(); - (*xsmWriteRGBAPixels)(ctx,n,x,y,rgba,mask); -} +#define LOCAL_DEPTH_VARS \ + __DRIdrawablePrivate *dPriv = imesa->driDrawable; \ + i810ScreenPrivate *i810Screen = imesa->i810Screen; \ + GLuint pitch = i810Screen->backPitch; \ + GLuint height = dPriv->h; \ + char *buf = (char *)(i810Screen->depth.map + \ + dPriv->x * 2 + \ + dPriv->y * pitch) -static void WriteMonoRGBAPixels(const GLcontext *ctx,GLuint n, - const GLint x[], const GLint y[], - const GLubyte mask[] ) -{ - i810Msg(12,__FUNCTION__ "\n"); - i810WaitDrawingEngine(); - (*xsmWriteMonoRGBAPixels)(ctx,n,x,y,mask); -} +#define INIT_MONO_PIXEL(p) -static void ReadRGBASpan(const GLcontext *ctx, GLuint n, - GLint x, GLint y,GLubyte rgba[][4] ) -{ - i810Msg(12,__FUNCTION__ "\n"); - i810WaitDrawingEngine(); - (*xsmReadRGBASpan)(ctx,n,x,y,rgba); -} +#define CLIPPIXEL(_x,_y) (_x >= minx && _x < maxx && \ + _y >= miny && _y < maxy) -static void ReadRGBAPixels(const GLcontext *ctx,GLuint n, - const GLint x[], const GLint y[], - GLubyte rgba[][4], const GLubyte mask[] ) -{ - i810Msg(12,__FUNCTION__ "\n"); - i810WaitDrawingEngine(); - (*xsmReadRGBAPixels)(ctx,n,x,y,rgba,mask); -} -#define WRAP(x) \ - xsm ## x = ctx->Driver.x; \ - ctx->Driver.x = x +#define CLIPSPAN(_x,_y,_n,_x1,_n1,_i) \ + if (_y < miny || _y >= maxy) _n1 = 0, _x1 = x; \ + else { \ + _n1 = _n; \ + _x1 = _x; \ + if (_x1 < minx) _i += (minx - _x1), _x1 = minx; \ + if (_x1 + _n1 >= maxx) n1 -= (_x1 + n1 - maxx) + 1; \ + } -void i810DDInitSpans( GLcontext *ctx ) -{ - /* Need another hook from mesa to synchronize hardware before - * write-pixels and read-spans/pixels. - */ - WRAP(WriteRGBASpan); - WRAP(WriteRGBSpan); - WRAP(WriteMonoRGBASpan); - WRAP(WriteRGBAPixels); - WRAP(WriteMonoRGBAPixels); - WRAP(ReadRGBASpan); - WRAP(ReadRGBAPixels); -} +#define Y_FLIP(_y) (height - _y - 1) +#define HW_LOCK() \ + i810ContextPtr imesa = I810_CONTEXT(ctx); \ + LOCK_HARDWARE_QUIESCENT(imesa); +#define HW_CLIPLOOP() \ + do { \ + __DRIdrawablePrivate *dPriv = imesa->driDrawable; \ + int _nc = dPriv->numClipRects; \ + while (_nc--) { \ + int minx = dPriv->pClipRects[_nc].x1 - dPriv->x; \ + int miny = dPriv->pClipRects[_nc].y1 - dPriv->y; \ + int maxx = dPriv->pClipRects[_nc].x2 - dPriv->x; \ + int maxy = dPriv->pClipRects[_nc].y2 - dPriv->y; +#define HW_ENDCLIPLOOP() \ + } \ + } while (0) +#define HW_UNLOCK() \ + UNLOCK_HARDWARE(imesa); -void fxUpdateDDSpanPointers(GLcontext *ctx) -{ - ctx->Driver.DepthTestSpan=fxDDDepthTestSpanGeneric; - ctx->Driver.DepthTestPixels=fxDDDepthTestPixelsGeneric; - ctx->Driver.ReadDepthSpanFloat=fxDDReadDepthSpanFloat; - ctx->Driver.ReadDepthSpanInt=fxDDReadDepthSpanInt; -} +/* 16 bit, 565 rgb color spanline and pixel functions + */ +#define WRITE_RGBA( _x, _y, r, g, b, a ) \ + *(GLushort *)(buf + _x*2 + _y*pitch) = ( (((int)r & 0xf8) << 8) | \ + (((int)g & 0xfc) << 3) | \ + (((int)b & 0xf8) >> 3)) +#define WRITE_PIXEL( _x, _y, p ) \ + *(GLushort *)(buf + _x*2 + _y*pitch) = p + +#define READ_RGBA( rgba, _x, _y ) \ +do { \ + GLushort p = *(GLushort *)(read_buf + _x*2 + _y*pitch); \ + rgba[0] = (p >> 8) & 0xf8; \ + rgba[1] = (p >> 3) & 0xfc; \ + rgba[2] = (p << 3) & 0xf8; \ + rgba[3] = 0; /* or 255? */ \ +} while(0) + +#define TAG(x) i810##x##_565 +#include "spantmp.h" + + + + +/* 15 bit, 555 rgb color spanline and pixel functions + */ +#define WRITE_RGBA( _x, _y, r, g, b, a ) \ + *(GLushort *)(buf + _x*2 + _y*pitch) = (((r & 0xf8) << 7) | \ + ((g & 0xf8) << 3) | \ + ((b & 0xf8) >> 3)) + +#define WRITE_PIXEL( _x, _y, p ) \ + *(GLushort *)(buf + _x*2 + _y*pitch) = p + +#define READ_RGBA( rgba, _x, _y ) \ +do { \ + GLushort p = *(GLushort *)(read_buf + _x*2 + _y*pitch); \ + rgba[0] = (p >> 7) & 0xf8; \ + rgba[1] = (p >> 3) & 0xf8; \ + rgba[2] = (p << 3) & 0xf8; \ + rgba[3] = 0; /* or 255? */ \ +} while(0) + +#define TAG(x) i810##x##_555 +#include "spantmp.h" + + + + +/* 16 bit depthbuffer functions. + */ +#define WRITE_DEPTH( _x, _y, d ) \ + *(GLdepth *)(buf + _x*2 + _y*pitch) = d; + +#define READ_DEPTH( d, _x, _y ) \ + d = *(GLdepth *)(buf + _x*2 + _y*pitch); + +/* d = 0xffff; */ + +#define TAG(x) i810##x##_16 +#include "depthtmp.h" + + -void fxSetupDDSpanPointers(GLcontext *ctx) +void i810DDInitSpanFuncs( GLcontext *ctx ) { - ctx->Driver.WriteRGBASpan =fxDDWriteRGBASpan; - ctx->Driver.WriteRGBSpan =fxDDWriteRGBSpan; - ctx->Driver.WriteMonoRGBASpan =fxDDWriteMonoRGBASpan; - ctx->Driver.WriteRGBAPixels =fxDDWriteRGBAPixels; - ctx->Driver.WriteMonoRGBAPixels =fxDDWriteMonoRGBAPixels; - - ctx->Driver.WriteCI8Span =NULL; - ctx->Driver.WriteCI32Span =NULL; - ctx->Driver.WriteMonoCISpan =NULL; - ctx->Driver.WriteCI32Pixels =NULL; - ctx->Driver.WriteMonoCIPixels =NULL; - - ctx->Driver.ReadRGBASpan =fxDDReadRGBASpan; - ctx->Driver.ReadRGBAPixels =fxDDReadRGBAPixels; - - ctx->Driver.ReadCI32Span =NULL; - ctx->Driver.ReadCI32Pixels =NULL; + if (1) { + ctx->Driver.WriteRGBASpan = i810WriteRGBASpan_565; + ctx->Driver.WriteRGBSpan = i810WriteRGBSpan_565; + ctx->Driver.WriteMonoRGBASpan = i810WriteMonoRGBASpan_565; + ctx->Driver.WriteRGBAPixels = i810WriteRGBAPixels_565; + ctx->Driver.WriteMonoRGBAPixels = i810WriteMonoRGBAPixels_565; + ctx->Driver.ReadRGBASpan = i810ReadRGBASpan_565; + ctx->Driver.ReadRGBAPixels = i810ReadRGBAPixels_565; + } else { + ctx->Driver.WriteRGBASpan = i810WriteRGBASpan_555; + ctx->Driver.WriteRGBSpan = i810WriteRGBSpan_555; + ctx->Driver.WriteMonoRGBASpan = i810WriteMonoRGBASpan_555; + ctx->Driver.WriteRGBAPixels = i810WriteRGBAPixels_555; + ctx->Driver.WriteMonoRGBAPixels = i810WriteMonoRGBAPixels_555; + ctx->Driver.ReadRGBASpan = i810ReadRGBASpan_555; + ctx->Driver.ReadRGBAPixels = i810ReadRGBAPixels_555; + } + + ctx->Driver.ReadDepthSpan = i810ReadDepthSpan_16; + ctx->Driver.WriteDepthSpan = i810WriteDepthSpan_16; + ctx->Driver.ReadDepthPixels = i810ReadDepthPixels_16; + ctx->Driver.WriteDepthPixels = i810WriteDepthPixels_16; + + ctx->Driver.WriteCI8Span =NULL; + ctx->Driver.WriteCI32Span =NULL; + ctx->Driver.WriteMonoCISpan =NULL; + ctx->Driver.WriteCI32Pixels =NULL; + ctx->Driver.WriteMonoCIPixels =NULL; + ctx->Driver.ReadCI32Span =NULL; + ctx->Driver.ReadCI32Pixels =NULL; } diff --git a/xc/lib/GL/mesa/src/drv/i810/i810span.h b/xc/lib/GL/mesa/src/drv/i810/i810span.h index 07276cd86..17a52085b 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810span.h +++ b/xc/lib/GL/mesa/src/drv/i810/i810span.h @@ -1,6 +1,6 @@ #ifndef _I810_SPAN_H #define _I810_SPAN_H -extern void i810DDInitSpans( GLcontext *ctx ); +extern void i810DDInitSpanFuncs( GLcontext *ctx ); #endif diff --git a/xc/lib/GL/mesa/src/drv/i810/i810state.c b/xc/lib/GL/mesa/src/drv/i810/i810state.c index e4a77efc1..caf9fafd6 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810state.c +++ b/xc/lib/GL/mesa/src/drv/i810/i810state.c @@ -1,33 +1,33 @@ #include <stdio.h> -#include "xsmesaP.h" - #include "types.h" +#include "enums.h" #include "pb.h" #include "dd.h" -#include "glx_log.h" #include "mm.h" #include "i810lib.h" -#include "i810glx.h" #include "i810dd.h" #include "i810context.h" #include "i810state.h" -#include "i810depth.h" #include "i810tex.h" #include "i810log.h" #include "i810vb.h" #include "i810tris.h" +#include "i810ioctl.h" + + static void i810DDAlphaFunc(GLcontext *ctx, GLenum func, GLclampf ref) { i810ContextPtr imesa = I810_CONTEXT(ctx); - CARD32 a = (ZA_UPDATE_ALPHAFUNC|ZA_UPDATE_ALPHAREF); + FLUSH_BATCH(imesa); + switch (ctx->Color.AlphaFunc) { case GL_NEVER: a |= ZA_ALPHA_NEVER; break; case GL_LESS: a |= ZA_ALPHA_LESS; break; @@ -42,21 +42,17 @@ static void i810DDAlphaFunc(GLcontext *ctx, GLenum func, GLclampf ref) a |= ctx->Color.AlphaRef << ZA_ALPHAREF_SHIFT; - imesa->reg_dirty |= (1<<I810_CTXREG_ZA); + imesa->dirty |= I810_UPLOAD_CTX; imesa->Setup[I810_CTXREG_ZA] &= ~(ZA_ALPHA_MASK|ZA_ALPHAREF_MASK); imesa->Setup[I810_CTXREG_ZA] |= a; } -/* This shouldn't get called, as the extension is disabled. However, - * there are internal Mesa calls, and rouge use of the api which must be - * caught. - */ static void i810DDBlendEquation(GLcontext *ctx, GLenum mode) { if (mode != GL_FUNC_ADD_EXT) { ctx->Color.BlendEquation = GL_FUNC_ADD_EXT; - FatalError("Unsupported blend equation"); - gl_error( ctx, GL_INVALID_OPERATION, "glBlendEquation (disabled)"); + i810Error("Unsupported blend equation"); + exit(1); } } @@ -65,6 +61,9 @@ static void i810DDBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor) i810ContextPtr imesa = I810_CONTEXT(ctx); GLuint a; + FLUSH_BATCH(imesa); + + a = SDM_UPDATE_SRC_BLEND | SDM_UPDATE_DST_BLEND; switch (ctx->Color.BlendSrcRGB) { @@ -80,7 +79,8 @@ static void i810DDBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor) a |= SDM_SRC_SRC_ALPHA; /* use GFXRENDERSTATE_COLOR_FACTOR ??? */ break; default: - FatalError("unknown blend source func"); + i810Error("unknown blend source func"); + exit(1); return; } @@ -94,11 +94,12 @@ static void i810DDBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor) case GL_DST_ALPHA: a |= SDM_DST_ONE; break; case GL_ONE_MINUS_DST_ALPHA: a |= SDM_DST_ZERO; break; default: - FatalError("unknown blend dst func"); + i810Error( "unknown blend dst func"); + exit(1); return; } - imesa->reg_dirty |= (1<<I810_CTXREG_SDM); + imesa->dirty |= I810_UPLOAD_CTX; imesa->Setup[I810_CTXREG_SDM] &= ~(SDM_SRC_MASK|SDM_DST_MASK); imesa->Setup[I810_CTXREG_SDM] |= a; } @@ -124,6 +125,8 @@ static void i810DDDepthFunc(GLcontext *ctx, GLenum func) i810ContextPtr imesa = I810_CONTEXT(ctx); int zmode; + FLUSH_BATCH(imesa); + switch(func) { case GL_NEVER: zmode = LCS_Z_NEVER; break; case GL_ALWAYS: zmode = LCS_Z_ALWAYS; break; @@ -135,43 +138,161 @@ static void i810DDDepthFunc(GLcontext *ctx, GLenum func) case GL_NOTEQUAL: zmode = LCS_Z_NOTEQUAL; break; default: return; } - - /* Could just fire it off now... - */ + imesa->Setup[I810_CTXREG_LCS] &= ~LCS_Z_MASK; imesa->Setup[I810_CTXREG_LCS] |= LCS_UPDATE_ZMODE | zmode; - imesa->reg_dirty |= (1<<I810_CTXREG_LCS); + + imesa->dirty |= I810_UPLOAD_CTX; } static void i810DDDepthMask(GLcontext *ctx, GLboolean flag) { i810ContextPtr imesa = I810_CONTEXT(ctx); - imesa->reg_dirty |= (1<<I810_CTXREG_B2); + FLUSH_BATCH(imesa); + + imesa->dirty |= I810_UPLOAD_CTX; imesa->Setup[I810_CTXREG_B2] &= ~B2_ZB_WRITE_ENABLE; - imesa->Setup[I810_CTXREG_B2] |= B2_UPDATE_ZB_WRITE_ENABLE; if (flag) imesa->Setup[I810_CTXREG_B2] |= B2_ZB_WRITE_ENABLE; +} -/* - Possible technique to reduce the amount of checking for small state - changes. Large ones detect wrap on update_count & just send the - whole state... - { - imesa->Update[imesa->update_count & MAX_UPDATE] = - ( imesa->Setup[I810_CTXREG_B2] & - (B1_ZB_WRITE_ENABLE | B1_UPDATE_ZB_WRITE_ENABLE | GFX_OP_BOOL_1) - ); - imesa->update_count++; - } -*/ +/* ============================================================= + * Polygon stipple + * + * The i810 supports a 4x4 stipple natively, GL wants 32x32. + * Fortunately stipple is usually a repeating pattern. Could + * also consider using a multitexturing mechanism for this, but + * that has real issues, too. + */ +static void i810DDPolygonStipple( GLcontext *ctx, const GLubyte *mask ) +{ + i810ContextPtr imesa = I810_CONTEXT(ctx); + const GLubyte *m = mask; + GLubyte p[4]; + int i,j,k; + int active = (ctx->Polygon.StippleFlag && ctx->PB->primitive == GL_POLYGON); + + FLUSH_BATCH(imesa); + ctx->Driver.TriangleCaps |= DD_TRI_STIPPLE; + + if (active) { + imesa->dirty |= I810_UPLOAD_CTX; + imesa->Setup[I810_CTXREG_ST1] &= ~ST1_ENABLE; + } + + p[0] = mask[0] & 0xf; p[0] |= p[0] << 4; + p[1] = mask[4] & 0xf; p[1] |= p[1] << 4; + p[2] = mask[8] & 0xf; p[2] |= p[2] << 4; + p[3] = mask[12] & 0xf; p[3] |= p[3] << 4; + + for (k = 0 ; k < 8 ; k++) + for (j = 0 ; j < 4; j++) + for (i = 0 ; i < 4 ; i++) + if (*m++ != p[j]) { + ctx->Driver.TriangleCaps &= ~DD_TRI_STIPPLE; + return; + } + + + + imesa->poly_stipple = ( ((p[0] & 0xf) << 0) | + ((p[1] & 0xf) << 4) | + ((p[2] & 0xf) << 8) | + ((p[3] & 0xf) << 12) ); + + if (1) { + imesa->Setup[I810_CTXREG_ST1] &= ~0xffff; + imesa->Setup[I810_CTXREG_ST1] |= ( ((p[0] & 0xf) << 0) | + ((p[1] & 0xf) << 4) | + ((p[2] & 0xf) << 8) | + ((p[3] & 0xf) << 12) ); + } + + if (active) + imesa->Setup[I810_CTXREG_ST1] |= ST1_ENABLE; } +/* ============================================================ + * Line stipple -- not completed + * - need to cope with stipplecounter + */ +#if 0 +static void i810DDLineStipple( GLcontext *ctx, GLint factor, GLushort pattern ) +{ + i810ContextPtr imesa = I810_CONTEXT(ctx); + GLushort p, h, test; + + FLUSH_BATCH(imesa); + ctx->Driver.TriangleCaps |= DD_LINE_STIPPLE; + + if (ctx->Line.StippleFlag) { + imesa->lines_are_tris |= I810_LINE_STIPPLE; + + if (ctx->PB->primitive == GL_LINE) { + imesa->dirty |= I810_UPLOAD_CTX; + imesa->Setup[I810_CTXREG_ST1] &= ~ST1_ENABLE; + } + } + + switch (factor) { + case 1: + p = pattern & 0xf; + p |= p << 4; + p |= p << 8; + test = p; + break; + case 2: + p = pattern & 1; + p |= (pattern & 2) << 2; + p |= p << 1; + p |= p << 4; + p |= p << 8; + test = pattern & 3; + test |= test << 2; + test |= test << 4; + test |= test << 8; + break; + default: + p = 0; + if (pattern) + p = 0xffff; + test = p; + break; + } + + if (pattern != test) { + ctx->Driver.TriangleCaps &= ~DD_LINE_STIPPLE; + imesa->lines_are_tris &= ~I810_LINE_STIPPLE; + return; + } + + h = (((p & 1) << 0) | + ((p & 2) << 4) | + ((p & 3) << 8) | + ((p & 4) << 12)); + + h |= h << 1; + h |= h << 2; + + imesa->vert_line_stipple = p; + imesa->horiz_line_stipple = h; + + if (ctx->Line.Stipple && ctx->PB->primitive == GL_LINE) + imesa->Setup[I810_CTXREG_ST1] |= ST1_ENABLE; +} +#endif + +/* ============================================================ + * Antialiased lines and triangles + */ +/* Nothing to do... + */ @@ -184,36 +305,105 @@ static void i810DDDepthMask(GLcontext *ctx, GLboolean flag) static void i810DDScissor( GLcontext *ctx, GLint x, GLint y, - GLsizei w, GLsizei h ) + GLsizei w, GLsizei h ) +{ + i810ContextPtr imesa = I810_CONTEXT(ctx); + + FLUSH_BATCH(imesa); + imesa->scissor_rect.x1 = x; + imesa->scissor_rect.y1 = imesa->driDrawable->h - (y+h); + imesa->scissor_rect.x2 = x+w; + imesa->scissor_rect.y2 = imesa->driDrawable->h - y; + + + if (I810_DEBUG&DEBUG_VERBOSE_2D) + fprintf(stderr, "SET SCISSOR %d,%d-%d,%d\n", + imesa->scissor_rect.x1, + imesa->scissor_rect.y1, + imesa->scissor_rect.x2, + imesa->scissor_rect.y2); + + + imesa->dirty |= I810_EMIT_CLIPRECT; +} + + +static void i810DDDither(GLcontext *ctx, GLboolean enable) +{ +} + + +static GLboolean i810DDSetDrawBuffer(GLcontext *ctx, GLenum mode ) { i810ContextPtr imesa = I810_CONTEXT(ctx); - int x1,x2,y1,y2; - x1 = ctx->Scissor.X; - x2 = ctx->Scissor.X + ctx->Scissor.Width - 1; - y1 = i810DB->Height - ctx->Scissor.Y - ctx->Scissor.Height; - y2 = i810DB->Height - ctx->Scissor.Y - 1; - - if (x1 < 0) x1 = 0; - if (y1 < 0) y1 = 0; - if (x2 >= i810DB->Width) x2 = i810DB->Width-1; - if (y2 >= i810DB->Height) y2 = i810DB->Height-1; - - if (x1 > x2 || y1 > y2) { - x1 = 0; x2 = 0; - y2 = 0; y1 = 1; + FLUSH_BATCH(imesa); + + imesa->Fallback &= ~I810_FALLBACK_DRAW_BUFFER; + + if (mode == GL_FRONT_LEFT) + { + imesa->drawMap = imesa->driScreen->pFB; + imesa->BufferSetup[I810_DESTREG_DI1] = (imesa->i810Screen->fbOffset | + imesa->i810Screen->backPitchBits); + imesa->dirty |= I810_UPLOAD_BUFFERS; + i810XMesaSetFrontClipRects( imesa ); + return GL_TRUE; + } + else if (mode == GL_BACK_LEFT) + { + imesa->drawMap = imesa->i810Screen->back.map; + imesa->BufferSetup[I810_DESTREG_DI1] = (imesa->i810Screen->backOffset | + imesa->i810Screen->backPitchBits); + imesa->dirty |= I810_UPLOAD_BUFFERS; + i810XMesaSetBackClipRects( imesa ); + return GL_TRUE; } - /* Turn it off if full screen? - */ - imesa->Setup[I810_CTXREG_SCI0] = GFX_OP_SCISSOR_INFO; - imesa->Setup[I810_CTXREG_SCI1] = (y1<<16)|x1; - imesa->Setup[I810_CTXREG_SCI2] = (y2<<16)|x2; + imesa->Fallback |= I810_FALLBACK_DRAW_BUFFER; + return GL_FALSE; +} +static void i810DDSetReadBuffer(GLcontext *ctx, GLframebuffer *colorBuffer, + GLenum mode ) +{ + i810ContextPtr imesa = I810_CONTEXT(ctx); - imesa->reg_dirty |= ((1<<I810_CTXREG_SCI0) | - (1<<I810_CTXREG_SCI1) | - (1<<I810_CTXREG_SCI2)); + if (mode == GL_FRONT_LEFT) + { + imesa->readMap = imesa->driScreen->pFB; + imesa->Fallback &= ~I810_FALLBACK_READ_BUFFER; + } + else if (mode == GL_BACK_LEFT) + { + imesa->readMap = imesa->i810Screen->back.map; + imesa->Fallback &= ~I810_FALLBACK_READ_BUFFER; + } + else + imesa->Fallback |= I810_FALLBACK_READ_BUFFER; +} + + + +static void i810DDSetColor(GLcontext *ctx, + GLubyte r, GLubyte g, + GLubyte b, GLubyte a ) +{ + i810ContextPtr imesa = I810_CONTEXT(ctx); + + imesa->MonoColor = i810PackColor( imesa->i810Screen->fbFormat, + r, g, b, a ); +} + + +static void i810DDClearColor(GLcontext *ctx, + GLubyte r, GLubyte g, + GLubyte b, GLubyte a ) +{ + i810ContextPtr imesa = I810_CONTEXT(ctx); + + imesa->ClearColor = i810PackColor( imesa->i810Screen->fbFormat, + r, g, b, a ); } @@ -226,6 +416,8 @@ static void i810DDCullFaceFrontFace(GLcontext *ctx, GLenum unused) i810ContextPtr imesa = I810_CONTEXT(ctx); GLuint mode = LCS_CULL_BOTH; + FLUSH_BATCH(imesa); + if (ctx->Polygon.CullFaceMode != GL_FRONT_AND_BACK) { mode = LCS_CULL_CW; if (ctx->Polygon.CullFaceMode == GL_FRONT) @@ -238,25 +430,55 @@ static void i810DDCullFaceFrontFace(GLcontext *ctx, GLenum unused) if (ctx->Polygon.CullFlag && ctx->PB->primitive == GL_POLYGON) { - imesa->reg_dirty |= (1<<I810_CTXREG_LCS); + imesa->dirty |= I810_UPLOAD_CTX; imesa->Setup[I810_CTXREG_LCS] &= ~LCS_CULL_MASK; - imesa->Setup[I810_CTXREG_LCS] |= (LCS_UPDATE_CULL_MODE | mode); + imesa->Setup[I810_CTXREG_LCS] |= mode; } } static void i810DDReducedPrimitiveChange( GLcontext *ctx, GLenum prim ) { - if (ctx->Polygon.CullFlag) { - i810ContextPtr imesa = I810_CONTEXT(ctx); - GLuint mode = imesa->LcsCullMode; - - if (ctx->PB->primitive != GL_POLYGON) - mode = LCS_CULL_DISABLE; - - imesa->reg_dirty |= (1<<I810_CTXREG_LCS); - imesa->Setup[I810_CTXREG_LCS] &= ~LCS_CULL_MASK; - imesa->Setup[I810_CTXREG_LCS] |= (LCS_UPDATE_CULL_MODE | mode); + i810ContextPtr imesa = I810_CONTEXT(ctx); + FLUSH_BATCH(imesa); + + imesa->dirty |= I810_UPLOAD_CTX; + imesa->Setup[I810_CTXREG_LCS] &= ~LCS_CULL_MASK; + imesa->Setup[I810_CTXREG_ST1] &= ~ST1_ENABLE; + imesa->Setup[I810_CTXREG_AA] &= ~AA_ENABLE; + + switch (ctx->PB->primitive) { + case GL_POLYGON: + if (ctx->Polygon.StippleFlag && + (ctx->Driver.TriangleCaps & DD_TRI_STIPPLE)) + imesa->Setup[I810_CTXREG_ST1] |= ST1_ENABLE; + if (ctx->Polygon.CullFlag) + imesa->Setup[I810_CTXREG_LCS] |= imesa->LcsCullMode; + else + imesa->Setup[I810_CTXREG_LCS] |= LCS_CULL_DISABLE; + if (ctx->Polygon.SmoothFlag) + imesa->Setup[I810_CTXREG_AA] |= AA_ENABLE; + break; + case GL_LINES: +#if 0 + if (ctx->Line.StippleFlag && (ctx->Driver.TriangleCaps & DD_LINE_STIPPLE)) + imesa->Setup[I810_CTXREG_ST1] |= ST1_ENABLE; +#endif + imesa->Setup[I810_CTXREG_LCS] &= ~LCS_LINEWIDTH_0_5; + if (ctx->Line.SmoothFlag) { + imesa->Setup[I810_CTXREG_AA] |= AA_ENABLE; + imesa->Setup[I810_CTXREG_LCS] |= LCS_LINEWIDTH_0_5; + } + imesa->Setup[I810_CTXREG_LCS] |= LCS_CULL_DISABLE; + break; + case GL_POINTS: + if (ctx->Point.SmoothFlag) + imesa->Setup[I810_CTXREG_AA] |= AA_ENABLE; + imesa->Setup[I810_CTXREG_LCS] |= LCS_CULL_DISABLE; + break; + default: + imesa->Setup[I810_CTXREG_LCS] |= LCS_CULL_DISABLE; + break; } } @@ -266,15 +488,36 @@ static void i810DDReducedPrimitiveChange( GLcontext *ctx, GLenum prim ) * Color masks */ -/* Mesa calls this from the wrong place. +/* Mesa calls this from the wrong place - it is called a very large + * number of redundant times. * - * Its a fallback... + * Colormask can be simulated by multipass or multitexture techniques. */ static GLboolean i810DDColorMask(GLcontext *ctx, GLboolean r, GLboolean g, GLboolean b, GLboolean a ) { - return 1; + i810ContextPtr imesa = I810_CONTEXT( ctx ); + GLuint tmp = 0; + GLuint rv = 1; + + imesa->Fallback &= ~I810_FALLBACK_COLORMASK; + + if (r && g && b) { + tmp = imesa->Setup[I810_CTXREG_B2] | B2_FB_WRITE_ENABLE; + } else if (!r && !g && !b) { + tmp = imesa->Setup[I810_CTXREG_B2] & ~B2_FB_WRITE_ENABLE; + } else { + rv = 0; + imesa->Fallback |= I810_FALLBACK_COLORMASK; + } + + if (tmp != imesa->Setup[I810_CTXREG_B2]) { + FLUSH_BATCH(imesa); + imesa->Setup[I810_CTXREG_B2] = tmp; + } + + return rv; } /* Seperate specular not fully implemented in hardware... Needs @@ -284,7 +527,16 @@ static GLboolean i810DDColorMask(GLcontext *ctx, static void i810DDLightModelfv(GLcontext *ctx, GLenum pname, const GLfloat *param) { - if (pname == GL_LIGHT_MODEL_COLOR_CONTROL) { + if (pname == GL_LIGHT_MODEL_COLOR_CONTROL) + { + i810ContextPtr imesa = I810_CONTEXT( ctx ); + FLUSH_BATCH(imesa); + + imesa->Fallback &= ~I810_FALLBACK_SPECULAR; + + if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR) + imesa->Fallback |= I810_FALLBACK_SPECULAR; + I810_CONTEXT(ctx)->new_state |= I810_NEW_TEXTURE; } } @@ -295,7 +547,7 @@ static void i810DDLightModelfv(GLcontext *ctx, GLenum pname, * Fog */ -void i810DDFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param) +static void i810DDFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param) { i810ContextPtr imesa = I810_CONTEXT(ctx); @@ -304,7 +556,7 @@ void i810DDFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param) ((GLubyte)(ctx->Fog.Color[1]*255.0F) << 8) | ((GLubyte)(ctx->Fog.Color[2]*255.0F) << 0)); - imesa->reg_dirty |= (1<<I810_CTXREG_FOG); + imesa->dirty |= I810_UPLOAD_CTX; imesa->Setup[I810_CTXREG_FOG] = ((GFX_OP_FOG_COLOR | color) & ~FOG_RESERVED_MASK); } @@ -320,66 +572,126 @@ static void i810DDEnable(GLcontext *ctx, GLenum cap, GLboolean state) switch(cap) { case GL_ALPHA_TEST: - imesa->reg_dirty |= (1<<I810_CTXREG_B1); + FLUSH_BATCH(imesa); + imesa->dirty |= I810_UPLOAD_CTX; imesa->Setup[I810_CTXREG_B1] &= ~B1_ALPHA_TEST_ENABLE; - imesa->Setup[I810_CTXREG_B1] |= B1_UPDATE_ALPHA_TEST_ENABLE; if (state) imesa->Setup[I810_CTXREG_B1] |= B1_ALPHA_TEST_ENABLE; break; case GL_BLEND: - imesa->reg_dirty |= (1<<I810_CTXREG_B1); + FLUSH_BATCH(imesa); + imesa->dirty |= I810_UPLOAD_CTX; imesa->Setup[I810_CTXREG_B1] &= ~B1_BLEND_ENABLE; - imesa->Setup[I810_CTXREG_B1] |= B1_UPDATE_BLEND_ENABLE; if (state) imesa->Setup[I810_CTXREG_B1] |= B1_BLEND_ENABLE; break; case GL_DEPTH_TEST: - imesa->reg_dirty |= (1<<I810_CTXREG_B1); + FLUSH_BATCH(imesa); + imesa->dirty |= I810_UPLOAD_CTX; imesa->Setup[I810_CTXREG_B1] &= ~B1_Z_TEST_ENABLE; - imesa->Setup[I810_CTXREG_B1] |= B1_UPDATE_Z_TEST_ENABLE; if (state) imesa->Setup[I810_CTXREG_B1] |= B1_Z_TEST_ENABLE; break; case GL_SCISSOR_TEST: - imesa->reg_dirty |= (1<<I810_CTXREG_SC); - imesa->Setup[I810_CTXREG_SC] &= ~SC_ENABLE_MASK; - imesa->Setup[I810_CTXREG_SC] |= SC_UPDATE_SCISSOR; - if (state) - imesa->Setup[I810_CTXREG_SC] |= SC_ENABLE; + FLUSH_BATCH(imesa); + imesa->scissor = state; + imesa->dirty |= I810_EMIT_CLIPRECT; + break; + case GL_POLYGON_STIPPLE: + if ((ctx->Driver.TriangleCaps & DD_TRI_STIPPLE) && + ctx->PB->primitive == GL_POLYGON) + { + FLUSH_BATCH(imesa); + imesa->dirty |= I810_UPLOAD_CTX; + imesa->Setup[I810_CTXREG_ST1] &= ~ST1_ENABLE; + if (state) + imesa->Setup[I810_CTXREG_ST1] |= ST1_ENABLE; + } + break; + case GL_LINE_STIPPLE: +#if 0 + if (ctx->Driver.TriangleCaps & DD_LINE_STIPPLE) + { + imesa->lines_are_tris &= ~I810_LINE_STIPPLE; + if (state) + imesa->lines_are_tris |= I810_LINE_STIPPLE; + + if (ctx->PB->primitive == GL_LINE) { + FLUSH_BATCH(imesa); + imesa->dirty |= I810_UPLOAD_CTX; + imesa->Setup[I810_CTXREG_ST1] &= ~ST1_ENABLE; + if (state) + imesa->Setup[I810_CTXREG_ST1] |= ST1_ENABLE; + } + } +#endif + break; + case GL_LINE_SMOOTH: + if (ctx->PB->primitive == GL_LINE) { + FLUSH_BATCH(imesa); + imesa->dirty |= I810_UPLOAD_CTX; + imesa->Setup[I810_CTXREG_AA] &= ~AA_ENABLE; + imesa->Setup[I810_CTXREG_LCS] &= ~LCS_LINEWIDTH_0_5; + if (state) { + imesa->Setup[I810_CTXREG_AA] |= AA_ENABLE; + imesa->Setup[I810_CTXREG_LCS] |= LCS_LINEWIDTH_0_5; + } + } + break; + case GL_POINT_SMOOTH: + if (ctx->PB->primitive == GL_POINT) { + FLUSH_BATCH(imesa); + imesa->dirty |= I810_UPLOAD_CTX; + imesa->Setup[I810_CTXREG_AA] &= ~AA_ENABLE; + if (state) + imesa->Setup[I810_CTXREG_AA] |= AA_ENABLE; + } + break; + case GL_POLYGON_SMOOTH: + if (ctx->PB->primitive == GL_POLYGON) { + FLUSH_BATCH(imesa); + imesa->dirty |= I810_UPLOAD_CTX; + imesa->Setup[I810_CTXREG_AA] &= ~AA_ENABLE; + if (state) + imesa->Setup[I810_CTXREG_AA] |= AA_ENABLE; + } break; case GL_FOG: - imesa->reg_dirty |= (1<<I810_CTXREG_B1); + FLUSH_BATCH(imesa); + imesa->dirty |= I810_UPLOAD_CTX; imesa->Setup[I810_CTXREG_B1] &= ~B1_FOG_ENABLE; - imesa->Setup[I810_CTXREG_B1] |= B1_UPDATE_FOG_ENABLE; if (state) imesa->Setup[I810_CTXREG_B1] |= B1_FOG_ENABLE; break; case GL_CULL_FACE: if (ctx->PB->primitive == GL_POLYGON) { - imesa->reg_dirty |= (1<<I810_CTXREG_LCS); + FLUSH_BATCH(imesa); + imesa->dirty |= I810_UPLOAD_CTX; imesa->Setup[I810_CTXREG_LCS] &= ~LCS_CULL_MASK; - imesa->Setup[I810_CTXREG_LCS] |= LCS_UPDATE_CULL_MODE; if (state) imesa->Setup[I810_CTXREG_LCS] |= imesa->LcsCullMode; else imesa->Setup[I810_CTXREG_LCS] |= LCS_CULL_DISABLE; } break; + case GL_TEXTURE_1D: + case GL_TEXTURE_3D: + FLUSH_BATCH(imesa); + imesa->new_state |= I810_NEW_TEXTURE; + break; case GL_TEXTURE_2D: - imesa->reg_dirty |= (1<<I810_CTXREG_MT); + FLUSH_BATCH(imesa); + imesa->new_state |= I810_NEW_TEXTURE; + imesa->dirty |= I810_UPLOAD_CTX; if (ctx->Texture.CurrentUnit == 0) { imesa->Setup[I810_CTXREG_MT] &= ~MT_TEXEL0_ENABLE; - imesa->Setup[I810_CTXREG_MT] |= MT_UPDATE_TEXEL0_STATE; if (state) imesa->Setup[I810_CTXREG_MT] |= MT_TEXEL0_ENABLE; } else { imesa->Setup[I810_CTXREG_MT] &= ~MT_TEXEL1_ENABLE; - imesa->Setup[I810_CTXREG_MT] |= MT_UPDATE_TEXEL1_STATE; if (state) imesa->Setup[I810_CTXREG_MT] |= MT_TEXEL1_ENABLE; } - - I810_CONTEXT(ctx)->new_state |= I810_NEW_TEXTURE; break; default: ; @@ -387,26 +699,6 @@ static void i810DDEnable(GLcontext *ctx, GLenum cap, GLboolean state) } -/* Don't use the regs parm yet. - */ -static void i810UpdateRegs( GLcontext *ctx, GLuint regs ) -{ - i810ContextPtr imesa = I810_CONTEXT(ctx); - int i; - - { - BEGIN_BATCH( I810_CTX_SETUP_SIZE ); - - for (i = 0 ; i < I810_CTX_SETUP_SIZE ; i++) { - OUT_BATCH( imesa->Setup[i] ); - } - - ADVANCE_BATCH(); - } - - imesa->reg_dirty = 0; -} - /* ============================================================= */ @@ -417,50 +709,158 @@ void i810DDPrintState( const char *msg, GLuint state ) { fprintf(stderr, "%s (0x%x): %s\n", msg, - state, + (unsigned int) state, (state & I810_NEW_TEXTURE) ? "texture, " : ""); } + + void i810DDUpdateHwState( GLcontext *ctx ) { i810ContextPtr imesa = I810_CONTEXT(ctx); - if (imesa->new_state & I810_NEW_TEXTURE) + if (imesa->new_state & I810_NEW_TEXTURE) { + FLUSH_BATCH(imesa); i810UpdateTextureState( ctx ); + } imesa->new_state = 0; +} + - if (imesa->reg_dirty) { - i810FinishPrimitive(); - i810UpdateRegs( ctx, imesa->reg_dirty ); + +/* + * i810DmaExecute + * Add a block of data to the dma buffer + * + * -- In ring buffer mode, must be called with lock held, and translates to + * OUT_RING rather than outbatch + * + * -- In dma mode, probably won't be used because state updates will have + * to be done via the kernel for security... + */ +static void i810DmaExecute( i810ContextPtr imesa, + GLuint *code, int dwords, const char *where ) +{ + if (I810_DEBUG & DEBUG_VERBOSE_RING) + fprintf(stderr, "i810DmaExecute (%s)\n", where); + + if (dwords & 1) { + i810Error( "Misaligned buffer in i810DmaExecute\n" ); + exit(1); + } + + { + int i; + BEGIN_BATCH( imesa, dwords); + + for ( i = 0 ; i < dwords ; i++ ) { + OUT_BATCH( code[i] ); + } + + ADVANCE_BATCH(); } } -void i810DDInitStatePointers(GLcontext *ctx) + +void i810EmitDrawingRectangle( i810ContextPtr imesa ) { - ctx->Driver.Enable = i810DDEnable; - ctx->Driver.LightModelfv = i810DDLightModelfv; - ctx->Driver.AlphaFunc = i810DDAlphaFunc; - ctx->Driver.BlendEquation = i810DDBlendEquation; - ctx->Driver.BlendFunc = i810DDBlendFunc; - ctx->Driver.BlendFuncSeparate = i810DDBlendFuncSeparate; - ctx->Driver.DepthFunc = i810DDDepthFunc; - ctx->Driver.DepthMask = i810DDDepthMask; - ctx->Driver.Fogfv = i810DDFogfv; - ctx->Driver.Scissor = i810DDScissor; - ctx->Driver.CullFace = i810DDCullFaceFrontFace; - ctx->Driver.FrontFace = i810DDCullFaceFrontFace; - ctx->Driver.ColorMask = i810DDColorMask; - ctx->Driver.ReducedPrimitiveChange = i810DDReducedPrimitiveChange; - ctx->Driver.RenderStart = i810DDUpdateHwState; - ctx->Driver.RenderFinish = 0; + __DRIdrawablePrivate *dPriv = imesa->driDrawable; + i810ScreenPrivate *i810Screen = imesa->i810Screen; + + int x0 = imesa->drawX; + int y0 = imesa->drawY; + int x1 = x0 + dPriv->w; + int y1 = y0 + dPriv->h; + + + /* Coordinate origin of the window - may be offscreen. + */ + imesa->BufferSetup[I810_DESTREG_DR4] = ((y0<<16) | + (((unsigned)x0)&0xFFFF)); + + /* Clip to screen. + */ + if (x0 < 0) x0 = 0; + if (y0 < 0) y0 = 0; + if (x1 > i810Screen->width-1) x1 = i810Screen->width-1; + if (y1 > i810Screen->height-1) y1 = i810Screen->height-1; + + + /* Onscreen drawing rectangle. + */ + imesa->BufferSetup[I810_DESTREG_DR2] = ((y0<<16) | x0); + imesa->BufferSetup[I810_DESTREG_DR3] = (((y1+1)<<16) | (x1+1)); + imesa->dirty |= I810_UPLOAD_BUFFERS; +} + + +static void i810DDPrintDirty( const char *msg, GLuint state ) +{ + fprintf(stderr, "%s (0x%x): %s%s%s%s%s%s%s\n", + msg, + (unsigned int) state, + (state & I810_REFRESH_RING) ? "read-lp-ring, " : "", + (state & I810_WAIT_AGE) ? "wait-age, " : "", + (state & I810_UPLOAD_TEX0IMAGE) ? "upload-tex0, " : "", + (state & I810_UPLOAD_TEX1IMAGE) ? "upload-tex1, " : "", + (state & I810_UPLOAD_CTX) ? "upload-ctx, " : "", + (state & I810_UPLOAD_BUFFERS) ? "upload-bufs, " : "", + (state & I810_EMIT_CLIPRECT) ? "emit-single-cliprect, " : "" + ); } +/* Spew the state onto the ring/batch buffer and/or texture memory. + */ +void i810EmitHwStateLocked( i810ContextPtr imesa ) +{ + if (I810_DEBUG & DEBUG_VERBOSE_API) + i810DDPrintDirty( "\n\n\ni810EmitHwStateLocked", imesa->dirty ); + + if (imesa->dirty & ~(I810_WAIT_AGE|I810_EMIT_CLIPRECT)) + { + i810GetGeneralDmaBufferLocked( imesa ); + + if ((imesa->dirty & I810_UPLOAD_TEX0IMAGE) && imesa->CurrentTexObj[0]) + i810UploadTexImages(imesa, imesa->CurrentTexObj[0]); + + if ((imesa->dirty & I810_UPLOAD_TEX1IMAGE) && imesa->CurrentTexObj[1]) + i810UploadTexImages(imesa, imesa->CurrentTexObj[1]); + + if ((imesa->dirty & I810_UPLOAD_CTX)) { + i810DmaExecute( imesa, imesa->Setup, I810_CTX_SETUP_SIZE, "context" ); + + if (imesa->CurrentTexObj[0]) + i810DmaExecute( imesa, imesa->CurrentTexObj[0]->Setup, + I810_TEX_SETUP_SIZE, "tex-0"); + + if (imesa->CurrentTexObj[1]) + i810DmaExecute( imesa, imesa->CurrentTexObj[1]->Setup, + I810_TEX_SETUP_SIZE, "tex-1"); + } + + if (imesa->dirty & I810_UPLOAD_BUFFERS) + i810DmaExecute( imesa, imesa->BufferSetup, + I810_DEST_SETUP_SIZE, "buffers" ); + + i810FlushGeneralLocked( imesa ); + } + + /* Clear everything but the cliprect dirty flag: + */ + imesa->dirty &= (I810_EMIT_CLIPRECT|I810_WAIT_AGE); +} + + + void i810DDInitState( i810ContextPtr imesa ) { + i810ScreenPrivate *i810Screen = imesa->i810Screen; + + memset(imesa->Setup, 0, sizeof(imesa->Setup)); imesa->Setup[I810_CTXREG_VF] = (GFX_OP_VERTEX_FMT | VF_TEXCOORD_COUNT_2 | @@ -562,6 +962,8 @@ void i810DDInitState( i810ContextPtr imesa ) imesa->Setup[I810_CTXREG_SDM] = ( GFX_OP_SRC_DEST_MONO | + SDM_UPDATE_MONO_ENABLE | + 0 | SDM_UPDATE_SRC_BLEND | SDM_SRC_ONE | SDM_UPDATE_DST_BLEND | @@ -627,7 +1029,7 @@ void i810DDInitState( i810ContextPtr imesa ) LCS_UPDATE_ZMODE | LCS_Z_LESS | LCS_UPDATE_LINEWIDTH | - (0x2<<LCS_LINEWIDTH_SHIFT) | + LCS_LINEWIDTH_1_0 | LCS_UPDATE_ALPHA_INTERP | LCS_ALPHA_INTERP | LCS_UPDATE_FOG_INTERP | @@ -641,14 +1043,6 @@ void i810DDInitState( i810ContextPtr imesa ) imesa->LcsCullMode = LCS_CULL_CW; - imesa->Setup[I810_CTXREG_SCI0] = GFX_OP_SCISSOR_INFO; - imesa->Setup[I810_CTXREG_SCI1] = 0; - imesa->Setup[I810_CTXREG_SCI2] = 0; - - imesa->Setup[I810_CTXREG_SC] = ( GFX_OP_SCISSOR | - SC_UPDATE_SCISSOR | - 0 ); - imesa->Setup[I810_CTXREG_PV] = ( GFX_OP_PV_RULE | PV_UPDATE_PIXRULE | PV_PIXRULE_ENABLE | @@ -659,8 +1053,59 @@ void i810DDInitState( i810ContextPtr imesa ) PV_UPDATE_TRISTRIP | PV_TRISTRIP_PV0 ); -} + imesa->Setup[I810_CTXREG_ST0] = GFX_OP_STIPPLE; + imesa->Setup[I810_CTXREG_ST1] = 0; + + + + imesa->Setup[I810_CTXREG_AA] = ( GFX_OP_ANTIALIAS | + AA_UPDATE_EDGEFLAG | + AA_ENABLE_EDGEFLAG | /* ? */ + AA_UPDATE_POLYWIDTH | + AA_POLYWIDTH_05 | + AA_UPDATE_LINEWIDTH | + AA_LINEWIDTH_05 | + AA_UPDATE_BB_EXPANSION | + 0 | + AA_UPDATE_AA_ENABLE | + 0 ); + + + + /* This stuff is all invarient as long as we are using + * shared back and depth buffers. + */ + memset(imesa->BufferSetup, 0, sizeof(imesa->BufferSetup)); + imesa->BufferSetup[I810_DESTREG_DI0] = CMD_OP_DESTBUFFER_INFO; + + if (imesa->glCtx->Color.DriverDrawBuffer == GL_BACK_LEFT) { + imesa->drawMap = i810Screen->back.map; + imesa->BufferSetup[I810_DESTREG_DI1] = (i810Screen->backOffset | + i810Screen->backPitchBits); + } else { + imesa->drawMap = imesa->driScreen->pFB; + imesa->BufferSetup[I810_DESTREG_DI1] = (i810Screen->fbOffset | + i810Screen->backPitchBits); + } + + if (imesa->glCtx->Color.DriverDrawBuffer == GL_BACK_LEFT) { + imesa->readMap = i810Screen->back.map; + } else { + imesa->readMap = imesa->driScreen->pFB; + } + + imesa->BufferSetup[I810_DESTREG_DV0] = GFX_OP_DESTBUFFER_VARS; + imesa->BufferSetup[I810_DESTREG_DV1] = (DV_HORG_BIAS_OGL | + DV_VORG_BIAS_OGL | + i810Screen->fbFormat); + imesa->BufferSetup[I810_DESTREG_ZB0] = CMD_OP_Z_BUFFER_INFO; + imesa->BufferSetup[I810_DESTREG_ZB1] = (i810Screen->depthOffset | + i810Screen->backPitchBits); + + imesa->BufferSetup[I810_DESTREG_DR0] = GFX_OP_DRAWRECT_INFO; + imesa->BufferSetup[I810_DESTREG_DR1] = DR1_RECT_CLIP_ENABLE; +} #define INTERESTED (~(NEW_MODELVIEW|NEW_PROJECTION|\ @@ -672,16 +1117,66 @@ void i810DDUpdateState( GLcontext *ctx ) { i810ContextPtr imesa = I810_CONTEXT( ctx ); + /* Have to do this here to detect texture fallbacks in time: + */ + if (I810_CONTEXT(ctx)->new_state & I810_NEW_TEXTURE) + i810DDUpdateHwState( ctx ); + + if (ctx->NewState & INTERESTED) { - i810FinishPrimitive(); i810DDChooseRenderState(ctx); i810ChooseRasterSetupFunc(ctx); } + + if (0) + fprintf(stderr, "IndirectTriangles %x Fallback %x\n", + imesa->IndirectTriangles, imesa->Fallback); - /* TODO: stop mesa from clobbering these. - */ - ctx->Driver.PointsFunc=imesa->PointsFunc; - ctx->Driver.LineFunc=imesa->LineFunc; - ctx->Driver.TriangleFunc=imesa->TriangleFunc; - ctx->Driver.QuadFunc=imesa->QuadFunc; + if (!imesa->Fallback) + { + ctx->IndirectTriangles &= ~DD_SW_RASTERIZE; + ctx->IndirectTriangles |= imesa->IndirectTriangles; + + ctx->Driver.PointsFunc=imesa->PointsFunc; + ctx->Driver.LineFunc=imesa->LineFunc; + ctx->Driver.TriangleFunc=imesa->TriangleFunc; + ctx->Driver.QuadFunc=imesa->QuadFunc; + } +} + + +void i810DDInitStateFuncs(GLcontext *ctx) +{ + ctx->Driver.UpdateState = i810DDUpdateState; + ctx->Driver.Enable = i810DDEnable; + ctx->Driver.LightModelfv = i810DDLightModelfv; + ctx->Driver.AlphaFunc = i810DDAlphaFunc; + ctx->Driver.BlendEquation = i810DDBlendEquation; + ctx->Driver.BlendFunc = i810DDBlendFunc; + ctx->Driver.BlendFuncSeparate = i810DDBlendFuncSeparate; + ctx->Driver.DepthFunc = i810DDDepthFunc; + ctx->Driver.DepthMask = i810DDDepthMask; + ctx->Driver.Fogfv = i810DDFogfv; + ctx->Driver.Scissor = i810DDScissor; + ctx->Driver.CullFace = i810DDCullFaceFrontFace; + ctx->Driver.FrontFace = i810DDCullFaceFrontFace; + ctx->Driver.ColorMask = i810DDColorMask; + ctx->Driver.ReducedPrimitiveChange = i810DDReducedPrimitiveChange; + ctx->Driver.RenderStart = i810DDUpdateHwState; + ctx->Driver.RenderFinish = 0; + + ctx->Driver.PolygonStipple = i810DDPolygonStipple; + ctx->Driver.LineStipple = 0; + + ctx->Driver.SetReadBuffer = i810DDSetReadBuffer; + ctx->Driver.SetDrawBuffer = i810DDSetDrawBuffer; + + ctx->Driver.Color = i810DDSetColor; + ctx->Driver.ClearColor = i810DDClearColor; + ctx->Driver.Dither = i810DDDither; + + ctx->Driver.Index = 0; + ctx->Driver.ClearIndex = 0; + ctx->Driver.IndexMask = 0; } + diff --git a/xc/lib/GL/mesa/src/drv/i810/i810state.h b/xc/lib/GL/mesa/src/drv/i810/i810state.h index 1cccb44bb..d0551631e 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810state.h +++ b/xc/lib/GL/mesa/src/drv/i810/i810state.h @@ -2,10 +2,12 @@ #define _I810_STATE_H -extern void i810DDInitStatePointers(GLcontext *ctx); extern void i810DDUpdateHwState( GLcontext *ctx ); extern void i810DDUpdateState( GLcontext *ctx ); extern void i810DDInitState( i810ContextPtr imesa ); +extern void i810DDInitStateFuncs( GLcontext *ctx ); + +extern void i810DDPrintState( const char *msg, GLuint state ); #endif diff --git a/xc/lib/GL/mesa/src/drv/i810/i810swap.c b/xc/lib/GL/mesa/src/drv/i810/i810swap.c index 3c78921e3..a0f6d8938 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810swap.c +++ b/xc/lib/GL/mesa/src/drv/i810/i810swap.c @@ -1,66 +1,71 @@ + +#include "types.h" +#include "vbrender.h" +#include "i810log.h" + +#include <stdio.h> +#include <stdlib.h> + +#include "mm.h" +#include "i810lib.h" +#include "i810dd.h" +#include "i810dma.h" +#include "i810state.h" +#include "i810swap.h" +#include "i810dma.h" +#include "i810ioctl.h" + /* * i810BackToFront * - * Blit the visible rectangles from the back buffer to the screen - * Can't really do this from a direct context - don't have the clip - * info, and getting it would be a lot slower than just sending a - * request to the server to do the blit there. - * - * drawable -- front buffer - * buf -- back buffer + * Blit the visible rectangles from the back buffer to the screen. + * Respects the frontbuffer cliprects, and applies the offset + * necessary if the backbuffer is positioned elsewhere in the screen. */ -int i810BackToFront(DrawablePtr drawable, - struct i810_dest_buffer *buf) +static int i810BackToFront( i810ContextPtr imesa ) { - RegionPtr prgnClip; - BoxPtr pbox; - int i,nbox; - int ofs, xorg, yorg, pitch; - - if ( !xf86VTSema ) { - i810Error("BackToFront(): !xf86VTSema\n"); - return BadMatch; /* Is this really an error? */ - } - - if ( drawable->width != buf->Width || - drawable->height != buf->Height || - drawable->type != DRAWABLE_WINDOW ) { - i810Error("BackToFront(): bad drawable\n"); - return BadMatch; - } + __DRIdrawablePrivate *dPriv = imesa->driDrawable; + i810ScreenPrivate *i810Screen = imesa->i810Screen; - prgnClip = &((WindowPtr)drawable)->clipList; - pbox = REGION_RECTS(prgnClip); - nbox = REGION_NUM_RECTS(prgnClip); - if( !nbox ) return Success; - xorg = drawable->x; - yorg = drawable->y; - pitch = buf->Pitch; - ofs = buf->MemBlock->ofs; + /* Use the frontbuffer cliprects: + */ + XF86DRIClipRectPtr pbox = dPriv->pClipRects; + int nbox = dPriv->numClipRects; + if( nbox ) { - unsigned int BR13 = ((vga256InfoRec.displayWidth * vgaBytesPerPixel) | + int i; + int pitch = i810Screen->backPitch; + + int dx = dPriv->backX - dPriv->x; + int dy = dPriv->backY - dPriv->y; + int ofs = ( i810Screen->backOffset + + dy * i810Screen->backPitch + + dx * i810Screen->cpp); + + unsigned int BR13 = ((i810Screen->fbStride) | (0xCC << 16)); for (i=0; i < nbox; i++, pbox++) { - int x = pbox->x1 - xorg; - int y = pbox->y1 - yorg; int w = pbox->x2 - pbox->x1; int h = pbox->y2 - pbox->y1; - int start = ofs + x*vgaBytesPerPixel + y*pitch; - int dst = ((pbox->x1 + pbox->y1 * vga256InfoRec.displayWidth) * - vgaBytesPerPixel); + int start = ofs + pbox->x1*i810Screen->cpp + pbox->y1*pitch; + int dst = pbox->x1*i810Screen->cpp + pbox->y1*i810Screen->fbStride; + + if (I810_DEBUG&DEBUG_VERBOSE_2D) + fprintf(stderr, "i810BackToFront %d,%d-%dx%d\n", + pbox->x1,pbox->y1,w,h); { - BEGIN_BATCH( 6 ); + BEGIN_BATCH( imesa, 6 ); OUT_BATCH( BR00_BITBLT_CLIENT | BR00_OP_SRC_COPY_BLT | 0x4 ); OUT_BATCH( BR13 ); /* dest pitch, rop */ - OUT_BATCH( (h << 16) | (w * vgaBytesPerPixel)); + OUT_BATCH( (h << 16) | (w * i810Screen->cpp)); OUT_BATCH( dst ); OUT_BATCH( pitch ); /* src pitch */ @@ -76,33 +81,70 @@ int i810BackToFront(DrawablePtr drawable, /* * ClearBox - * Add hardware commands to draw a filled box for the - * debugging display. + * + * Add hardware commands to draw a filled box for the debugging + * display. These are drawn into the current drawbuffer, so should + * work with both front and backbuffer rendering. (However, it + * is only ever called on swapbuffer - ie backbuffer rendering). */ -static void ClearBox( int x, int y, int w, int h, int r, int g, int b ) +static void ClearBox( i810ContextPtr imesa, + int cx, int cy, int cw, int ch, + int r, int g, int b ) { - int start = (i810DB->MemBlock->ofs + - y * i810DB->Pitch + - x * vgaBytesPerPixel); - - BEGIN_BATCH(6); - - OUT_BATCH( BR00_BITBLT_CLIENT | BR00_OP_COLOR_BLT | 0x3 ); - OUT_BATCH( BR13_SOLID_PATTERN | - (0xF0 << 16) | - i810DB->Pitch ); - OUT_BATCH( (h << 16) | (w * vgaBytesPerPixel)); - OUT_BATCH( start ); - OUT_BATCH( i810PackColor( i810DB->Format, r, g, b, 0 ) ); - OUT_BATCH( 0 ); + __DRIdrawablePrivate *dPriv = imesa->driDrawable; + i810ScreenPrivate *i810Screen = imesa->i810Screen; + + int _nc = imesa->numClipRects; + + while (_nc--) { + int x1 = cx + dPriv->x; + int y1 = cy + dPriv->y; + int x2 = x1 + cw; + int y2 = y1 + ch; + + { + int rx1 = imesa->pClipRects[_nc].x1; + int ry1 = imesa->pClipRects[_nc].y1; + int rx2 = imesa->pClipRects[_nc].x2; + int ry2 = imesa->pClipRects[_nc].y2; + + + if (x2 < rx1) continue; + if (y2 < ry1) continue; + if (x1 > rx2) continue; + if (y1 > ry2) continue; + if (x1 < rx1) x1 = rx1; + if (y1 < ry1) y1 = ry1; + if (x2 > rx2) x2 = rx2; + if (y2 > ry2) y2 = ry2; + } - if (0) - fprintf(stderr, "box %d,%x %dx%d col %x (%d,%d,%d)\n", x,y,w,h, - i810PackColor( i810DB->Format, r, g, b, 0 ), r, g, b); - ADVANCE_BATCH(); + { + int start = (0 + + y1 * i810Screen->backPitch + + x1 * i810Screen->cpp); + BEGIN_BATCH( imesa, 6 ); + OUT_BATCH( BR00_BITBLT_CLIENT | BR00_OP_COLOR_BLT | 0x3 ); + OUT_BATCH( BR13_SOLID_PATTERN | + (0xF0 << 16) | + i810Screen->backPitch ); + OUT_BATCH( ((y2-y1) << 16) | ((x2-x1) * i810Screen->cpp)); + OUT_BATCH( start ); + OUT_BATCH( i810PackColor( i810Screen->fbFormat, r, g, b, 0 ) ); + OUT_BATCH( 0 ); + + if (I810_DEBUG&DEBUG_VERBOSE_2D) + fprintf(stderr, "box %d,%x %d,%d col %x (%d,%d,%d)\n", + (int)x1,(int)y1, (int)x2,(int)y2, + (int)i810PackColor( i810Screen->fbFormat, r, g, b, 0 ), + (int)r, (int)g, (int)b); + + ADVANCE_BATCH(); + } + } } @@ -111,143 +153,110 @@ static void ClearBox( int x, int y, int w, int h, int r, int g, int b ) * Draw some small boxesin the corner of the buffer * based on some performance information */ -void i810PerformanceBoxes( int is_direct ) { - int w, t; +static void i810PerformanceBoxes( i810ContextPtr imesa ) { - if ( !i810glx.boxes ) - return; - - - /* draw a box to show we are active, so if it is't seen - it means that it is completely software based rendering */ - /* draw a purple box if we are direct rendering */ - if ( is_direct ) { /* purple = direct (client dma) rendering */ - ClearBox( 4, 4, 8, 8, 255, 0, 255 ); - } else if ( i810glx.dmaDriver ) { /* white = server dma rendering */ - ClearBox( 4, 4, 8, 8, 255, 255, 255 ); - } else { /* grey = servery PDMA */ - ClearBox( 4, 4, 8, 8, 128, 128, 128 ); - } + + /* draw a box to show we are active, so if it is't seen it means + that it is completely software based. Purple is traditional for + direct rendering */ + ClearBox( imesa, 4, 4, 8, 8, 255, 0, 255 ); /* draw a red box if we had to wait for drawing to complete (software render or texture swap) */ if ( i810glx.c_drawWaits ) { - ClearBox( 16, 4, 8, 8, 255, 0, 0 ); + ClearBox( imesa, 16, 4, 8, 8, 255, 0, 0 ); i810glx.c_drawWaits = 0; } - /* draw a blue box if the register protection signal was hit */ - if ( i810glx.c_signals ) { - ClearBox( 28, 4, 8, 8, 0, 0, 255 ); - i810glx.c_signals = 0; + /* draw a blue box if the 3d context was lost + */ + if ( i810glx.c_ctxlost ) { + ClearBox( imesa, 28, 4, 8, 8, 0, 0, 255 ); + i810glx.c_ctxlost = 0; } + /* draw an orange box if texture state was stomped */ + if ( i810glx.c_texlost ) { + ClearBox( imesa, 40, 4, 8, 8, 255, 128, 0 ); + i810glx.c_texlost = 0; + } + /* draw a yellow box if textures were swapped */ if ( i810glx.c_textureSwaps ) { - ClearBox( 40, 4, 8, 8, 255, 255, 0 ); + ClearBox( imesa, 56, 4, 8, 8, 255, 255, 0 ); i810glx.c_textureSwaps = 0; } - - + /* draw a green box if we had to wait for dma to complete (full utilization) on the previous frame */ if ( !i810glx.hardwareWentIdle ) { - ClearBox( 64, 4, 8, 8, 0, 255, 0 ); + ClearBox( imesa, 72, 4, 8, 8, 0, 255, 0 ); } i810glx.hardwareWentIdle = 0; +#if 0 /* show buffer utilization */ if ( i810glx.c_dmaFlush > 1 ) { /* draw a solid bar if we flushed more than one buffer */ - ClearBox( 4, 16, 252, 4, 255, 32, 32 ); + ClearBox( imesa, 4, 16, 252, 4, 255, 32, 32 ); } else { - /* draw bars to represent the utilization of primary and secondary buffers */ - ClearBox( 4, 16, 252, 4, 32, 32, 32 ); + /* draw bars to represent the utilization of primary and + secondary buffers */ + ClearBox( imesa, 4, 16, 252, 4, 32, 32, 32 ); t = i810glx.dma_buffer->mem.Size; w = 252 * i810glx.dma_buffer->head / t; if ( w < 1 ) { w = 1; } - ClearBox( 4, 16, w, 4, 196, 128, 128 ); + ClearBox( imesa, 4, 16, w, 4, 196, 128, 128 ); } +#endif + i810glx.c_dmaFlush = 0; } -static void i810SendDmaFlush( void ) + +static void i810EmitFlush( i810ContextPtr imesa ) { - BEGIN_BATCH(2); + BEGIN_BATCH( imesa, 2 ); OUT_BATCH( INST_PARSER_CLIENT | INST_OP_FLUSH ); OUT_BATCH( 0 ); ADVANCE_BATCH(); } - -/* - * Copy the back buffer to the front buffer. If there's no back buffer - * this is a no-op. Only called in indirect contexts. - */ -static void i810ServerSwapBuffers( XSMesaBuffer b ) +void i810SwapBuffers( i810ContextPtr imesa ) { - /* make sure mesa gives us everything */ - if (i810Ctx && i810Ctx->gl_ctx) - glFlush(); + int tmp; - if ( !b->db_state ) { - /* not double buffered, so do nothing */ - } else { - ValidateGC(b->frontbuffer, b->cleargc); - if ( b->backimage ) { - - struct i810_dest_buffer *buf = - (struct i810_dest_buffer *)b->backimage->devPriv; + if (I810_DEBUG & DEBUG_VERBOSE_API) + fprintf(stderr, "i810SwapBuffers()\n"); - if ( buf && buf->Drawable ) { + FLUSH_BATCH( imesa ); + LOCK_HARDWARE( imesa ); + + i810GetGeneralDmaBufferLocked( imesa ); + i810EmitFlush( imesa ); - /* flush the last primitive */ - i810FinishPrimitive(); + if ( i810glx.boxes ) + i810PerformanceBoxes( imesa ); - /* Drop a flush op into the dma stream */ - i810SendDmaFlush(); + i810BackToFront( imesa ); + i810EmitFlush( imesa ); + i810FlushGeneralLocked( imesa ); - /* diagnostic drawing tools */ - i810PerformanceBoxes( 0 ); + /* Throttle app if the last swap hasn't dispatched yet + */ + if (0) + fprintf(stderr, "dispatch age: %d last swap: %d\n", + GET_DISPATCH_AGE(imesa), imesa->lastSwap); + + tmp = GET_ENQUEUE_AGE(imesa); - /* hardware accelerated back to front blit */ - i810BackToFront( (DrawablePtr)b->frontbuffer,buf ); + UNLOCK_HARDWARE( imesa ); - /* make sure all dma is going to get executed if - * everything has gone well, this will be the only flush - * each frame - */ - i810DmaFlush(); + if (GET_DISPATCH_AGE(imesa) < imesa->lastSwap) + i810WaitAge(imesa, imesa->lastSwap); - } else { - /* Use backimage's dimension (not buffer's) */ - (*b->cleargc->ops->PutImage)((DrawablePtr)b->frontbuffer, - b->cleargc, - b->frontbuffer->depth, - 0, 0, - b->backimage->width, - b->backimage->height, - 0, ZPixmap, b->backimage->data); - } - } else { - /* Copy pixmap to window on server */ - (*b->cleargc->ops->CopyArea)((DrawablePtr)b->backpixmap, - b->frontbuffer, - b->cleargc, - 0, 0, b->width, b->height, - 0, 0); - } - } - - /* report performance counters */ - i810Msg(10, "swapBuffers: c_triangles:%i c_lines:%i c_points:%i c_setup:%i c_textures:%i\n", - i810glx.c_triangles, i810glx.c_lines, i810glx.c_points, i810glx.c_setupPointers, - i810glx.c_textureSwaps ); - i810glx.c_triangles = 0; - i810glx.c_lines = 0; - i810glx.c_points = 0; - i810glx.c_setupPointers = 0; - i810Msg(10, "---------------------------------------------------------\n" ); + imesa->secondLastSwap = imesa->lastSwap; + imesa->lastSwap = tmp; } diff --git a/xc/lib/GL/mesa/src/drv/i810/i810tex.c b/xc/lib/GL/mesa/src/drv/i810/i810tex.c index 5b1d00398..35c395296 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810tex.c +++ b/xc/lib/GL/mesa/src/drv/i810/i810tex.c @@ -22,7 +22,6 @@ * */ -#include "xsmesaP.h" #include <stdlib.h> #include <stdio.h> @@ -32,6 +31,7 @@ #include "i810lib.h" #include "i810tex.h" #include "i810log.h" +#include "i810ioctl.h" #include "simple_list.h" #include "enums.h" @@ -49,7 +49,6 @@ static void i810SetTexWrapping(i810TextureObjectPtr tex, GLenum s, GLenum t) val ^= (MCS_V_WRAP^MCS_V_CLAMP); tex->Setup[I810_TEXREG_MCS] = val; - tex->reg_dirty |= (1 << I810_TEXREG_MCS); } static void i810SetTexFilter(i810TextureObjectPtr t, GLenum minf, GLenum magf) @@ -136,10 +135,6 @@ static void i810SetTexFilter(i810TextureObjectPtr t, GLenum minf, GLenum magf) MLC_LOD_BIAS_MASK, 0x0); } - - t->reg_dirty |= ((1<<I810_TEXREG_MLC) | - (1<<I810_TEXREG_MLL) | - (1<<I810_TEXREG_MF)); } @@ -161,8 +156,8 @@ static void ReplicateMesaTexState(i810TextureObjectPtr t, i810SetTexBorderColor(t,mesatex->BorderColor); } -i810TextureObjectPtr i810CreateTexObj(i810ContextPtr ctx, - struct gl_texture_object *tObj) +static i810TextureObjectPtr i810CreateTexObj(i810ContextPtr imesa, + struct gl_texture_object *tObj) { i810TextureObjectPtr t; GLuint height, width, pitch, i, textureFormat, log_pitch; @@ -194,7 +189,6 @@ i810TextureObjectPtr i810CreateTexObj(i810ContextPtr ctx, case GL_COLOR_INDEX: textureFormat = MI1_FMT_8CI | MI1_PF_8CI_ARGB4444; t->texelBytes = 1; - t->UsePalette = 1; break; default: i810Error( "i810CreateTexObj: bad image->Format\n" ); @@ -211,6 +205,7 @@ i810TextureObjectPtr i810CreateTexObj(i810ContextPtr ctx, log_pitch++; t->dirty_images = 0; + t->bound = 0; for ( height = i = 0 ; i < I810_TEX_MAXLEVELS && tObj->Image[i] ; i++ ) { t->image[i].image = tObj->Image[i]; @@ -226,7 +221,6 @@ i810TextureObjectPtr i810CreateTexObj(i810ContextPtr ctx, t->min_level = 0; t->globj = tObj; t->age = 0; - t->reg_dirty = ~0; t->Setup[I810_TEXREG_MI0] = GFX_OP_MAP_INFO; @@ -279,89 +273,72 @@ i810TextureObjectPtr i810CreateTexObj(i810ContextPtr ctx, ReplicateMesaTexState(t,tObj); tObj->DriverData = t; - insert_at_head(&ctx->SwappedOut, t); + imesa->dirty |= I810_UPLOAD_CTX; + make_empty_list( t ); return t; } -int i810DestroyTexObj(i810ContextPtr ctx, i810TextureObjectPtr t) +void i810DestroyTexObj(i810ContextPtr imesa, i810TextureObjectPtr t) { - if (t) { - if (t->age > i810glx.dma_buffer_age) - i810WaitDrawingEngine(); + if (!t) return; + /* This is sad - need to sync *in case* we upload a texture + * to this newly free memory... + */ + if (t->MemBlock) { mmFreeMem(t->MemBlock); - t->MemBlock = 0; - remove_from_list(t); - free(t); + t->MemBlock = 0; + + if (t->age > imesa->dirtyAge) + imesa->dirtyAge = t->age; } - return 0; + + if (t->globj) + t->globj->DriverData = 0; + + if (t->bound) + imesa->CurrentTexObj[t->bound - 1] = 0; + + remove_from_list(t); + free(t); } -/* Card memory management - */ -static void i810SwapOutOldestTexObj( i810ContextPtr ctx ) +static void i810SwapOutTexObj(i810ContextPtr imesa, i810TextureObjectPtr t) { - i810TextureObjectPtr t = ctx->TexObjList.prev; - - fprintf(stderr, "swap out oldest, age %d, dma age %d\n", - t->age, i810glx.dma_buffer_age); + if (t->MemBlock) { + mmFreeMem(t->MemBlock); + t->MemBlock = 0; - if (t->age > i810glx.dma_buffer_age) - i810WaitDrawingEngine(); + if (t->age > imesa->dirtyAge) + imesa->dirtyAge = t->age; + } - mmFreeMem( t->MemBlock ); - t->MemBlock = 0; t->dirty_images = ~0; - move_to_tail(&ctx->SwappedOut, t); + move_to_tail(&(imesa->SwappedOut), t); } -/* Just allocates the memory - doesn't do the upload. - */ -static int i810SwapInTexObj( i810ContextPtr ctx, i810TextureObjectPtr t) -{ - i810Msg(10," Swapping in texture.\n"); - i810glx.c_textureSwaps++; - - /* Try to allocate textureHeap memory, swapping out stuff until we - * can. - */ - while (1) - { - t->MemBlock = mmAllocMem( i810glx.sysmemHeap, t->totalSize, 12, 0 ); - - if (t->MemBlock) - break; - if (is_empty_list(&ctx->TexObjList)) - return -1; - - i810SwapOutOldestTexObj( ctx ); - } - - t->Setup[I810_TEXREG_MI3] = t->MemBlock->ofs; - t->BufAddr = i810glx.sysmemVirtual + t->MemBlock->ofs; - t->reg_dirty |= ((1<<I810_TEXREG_MI0) | - (1<<I810_TEXREG_MI1) | - (1<<I810_TEXREG_MI2) | - (1<<I810_TEXREG_MI3)); - return 0; -} /* Upload an image from mesa's internal copy. */ -static int i810UploadTexLevel( i810TextureObjectPtr t, int level ) +static void i810UploadTexLevel( i810TextureObjectPtr t, int level ) { const struct gl_texture_image *image = t->image[level].image; int i,j; - i810Msg(10,"CopyImage():\n"); + if (I810_DEBUG & DEBUG_VERBOSE_LRU) + fprintf(stderr, "i810UploadTexLevel %d, BufAddr %p offset %x\n", + level, t->BufAddr, t->image[level].offset); /* Need triangle (rather than pixel) fallbacks to simulate this using * normal textured triangles. - */ + * + * DO THIS IN DRIVER STATE MANAGMENT, not hardware state. + * if (image->Border != 0) - i810Error("Not supported texture border %d.\n",image->Border); + i810Error("Not supported texture border %d.\n", (int) image->Border); + */ switch (t->image[level].internalFormat) { case GL_RGB: @@ -440,6 +417,8 @@ static int i810UploadTexLevel( i810TextureObjectPtr t, int level ) } break; + /* TODO: Translate color indices *now*: + */ case GL_COLOR_INDEX: { GLubyte *dst = (GLubyte *)(t->BufAddr + t->image[level].offset); @@ -452,38 +431,221 @@ static int i810UploadTexLevel( i810TextureObjectPtr t, int level ) src += 1; } } - - t->UsePalette = I810_USE_PALETTE; } break; default: - i810Error("Not supported texture format %d\n",image->Format); - FatalError("bummer"); - return -1; + i810Error("Not supported texture format %d\n",(int)image->Format); + exit(1); } +} - return 0; + + +void i810PrintLocalLRU( i810ContextPtr imesa ) +{ + i810TextureObjectPtr t; + int sz = 1 << (imesa->i810Screen->logTextureGranularity); + + foreach( t, &imesa->TexObjList ) { + if (!t->globj) + fprintf(stderr, "Placeholder %d at %x sz %x\n", + t->MemBlock->ofs / sz, + t->MemBlock->ofs, + t->MemBlock->size); + else + fprintf(stderr, "Texture (bound %d) at %x sz %x\n", + t->bound, + t->MemBlock->ofs, + t->MemBlock->size); + + } +} + +void i810PrintGlobalLRU( i810ContextPtr imesa ) +{ + int i, j; + drm_i810_tex_region_t *list = imesa->sarea->texList; + + for (i = 0, j = I810_NR_TEX_REGIONS ; i < I810_NR_TEX_REGIONS ; i++) { + fprintf(stderr, "list[%d] age %d next %d prev %d\n", + j, list[j].age, list[j].next, list[j].prev); + j = list[j].next; + if (j == I810_NR_TEX_REGIONS) break; + } + + if (j != I810_NR_TEX_REGIONS) + fprintf(stderr, "Loop detected in global LRU\n"); +} + + +void i810ResetGlobalLRU( i810ContextPtr imesa ) +{ + drm_i810_tex_region_t *list = imesa->sarea->texList; + int sz = 1 << imesa->i810Screen->logTextureGranularity; + int i; + + /* (Re)initialize the global circular LRU list. The last element + * in the array (I810_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. + */ + for (i = 0 ; (i+1) * sz <= imesa->i810Screen->textureSize ; i++) { + list[i].prev = i-1; + list[i].next = i+1; + list[i].age = 0; + } + + i--; + list[0].prev = I810_NR_TEX_REGIONS; + list[i].prev = i-1; + list[i].next = I810_NR_TEX_REGIONS; + list[I810_NR_TEX_REGIONS].prev = i; + list[I810_NR_TEX_REGIONS].next = 0; + imesa->sarea->texAge = 0; } +static void i810UpdateTexLRU( i810ContextPtr imesa, i810TextureObjectPtr t ) +{ + int i; + int logsz = imesa->i810Screen->logTextureGranularity; + int start = t->MemBlock->ofs >> logsz; + int end = (t->MemBlock->ofs + t->MemBlock->size - 1) >> logsz; + drm_i810_tex_region_t *list = imesa->sarea->texList; + + imesa->texAge = ++imesa->sarea->texAge; + + /* Update our local LRU + */ + move_to_head( &(imesa->TexObjList), t ); + + /* Update the global LRU + */ + for (i = start ; i <= end ; i++) { + + list[i].in_use = 1; + list[i].age = imesa->texAge; + + /* remove_from_list(i) + */ + list[(unsigned)list[i].next].prev = list[i].prev; + list[(unsigned)list[i].prev].next = list[i].next; + + /* insert_at_head(list, i) + */ + list[i].prev = I810_NR_TEX_REGIONS; + list[i].next = list[I810_NR_TEX_REGIONS].next; + list[(unsigned)list[I810_NR_TEX_REGIONS].next].prev = i; + list[I810_NR_TEX_REGIONS].next = i; + } +} + -static int i810UploadTexImages( i810ContextPtr ctx, i810TextureObjectPtr t ) +/* Called for every shared texture region which has increased in age + * since we last held the lock. + * + * Figures out which of our textures have been ejected by other clients, + * and pushes a placeholder texture onto the LRU list to represent + * the other client's textures. + */ +void i810TexturesGone( i810ContextPtr imesa, + GLuint offset, + GLuint size, + GLuint in_use ) +{ + i810TextureObjectPtr t, tmp; + + foreach_s ( t, tmp, &imesa->TexObjList ) { + + if (t->MemBlock->ofs >= offset + size || + t->MemBlock->ofs + t->MemBlock->size <= offset) + continue; + + /* It overlaps - kick it off. Need to hold onto the currently bound + * objects, however. + */ + if (t->bound) + i810SwapOutTexObj( imesa, t ); + else + i810DestroyTexObj( imesa, t ); + } + + + if (in_use) { + t = (i810TextureObjectPtr) calloc(1,sizeof(*t)); + if (!t) return; + + t->MemBlock = mmAllocMem( imesa->texHeap, size, 0, offset); + insert_at_head( &imesa->TexObjList, t ); + } +} + + + + + +/* This is called with the lock held. May have to eject our own and/or + * other client's texture objects to make room for the upload. + */ +int i810UploadTexImages( i810ContextPtr imesa, i810TextureObjectPtr t ) { int i; + int ofs; i810glx.c_textureSwaps++; - if (!t->MemBlock) - i810SwapInTexObj( ctx, t ); + /* Do we need to eject LRU texture objects? + */ + if (!t->MemBlock) { + while (1) + { + t->MemBlock = mmAllocMem( imesa->texHeap, t->totalSize, 12, 0 ); + if (t->MemBlock) + break; - if (t->age > i810glx.dma_buffer_age) - i810WaitDrawingEngine(); + if (imesa->TexObjList.prev->bound) { + fprintf(stderr, "Hit bound texture in upload\n"); + i810PrintLocalLRU( imesa ); + return -1; + } - for (i = t->min_level ; i <= t->max_level ; i++) - if (t->dirty_images & (1<<i)) { - if (i810UploadTexLevel( t, i ) != 0) + if (imesa->TexObjList.prev == &(imesa->TexObjList)) { + fprintf(stderr, "Failed to upload texture, sz %d\n", t->totalSize); + mmDumpMemInfo( imesa->texHeap ); return -1; + } + + i810DestroyTexObj( imesa, imesa->TexObjList.prev ); } + + ofs = t->MemBlock->ofs; + t->Setup[I810_TEXREG_MI3] = imesa->i810Screen->textureOffset + ofs; + t->BufAddr = i810glx.texVirtual + ofs; + imesa->dirty |= I810_UPLOAD_CTX; + } + + /* Let the world know we've used this memory recently. + */ + i810UpdateTexLRU( imesa, t ); + + if (I810_DEBUG & DEBUG_VERBOSE_LRU) + fprintf(stderr, "dispatch age: %d age freed memory: %d\n", + GET_DISPATCH_AGE(imesa), imesa->dirtyAge); + + if (imesa->dirtyAge >= GET_DISPATCH_AGE(imesa)) + i810WaitAgeLocked( imesa, imesa->dirtyAge ); + + + if (t->dirty_images) { + if (I810_DEBUG & DEBUG_VERBOSE_LRU) + fprintf(stderr, "*"); + + for (i = t->min_level ; i <= t->max_level ; i++) + if (t->dirty_images & (1<<i)) + i810UploadTexLevel( t, i ); + } + t->dirty_images = 0; return 0; @@ -499,7 +661,6 @@ static void i810TexSetUnit( i810TextureObjectPtr t, GLuint unit ) t->Setup[I810_TEXREG_MCS] ^= (MCS_COORD_0 ^ MCS_COORD_1); t->Setup[I810_TEXREG_MF] ^= (MF_MAP_0 ^ MF_MAP_1); - t->reg_dirty = ~0; t->current_unit = unit; } @@ -519,30 +680,29 @@ static void i810UpdateTex0State( GLcontext *ctx ) if ( tObj != ctx->Texture.Unit[0].CurrentD[2] ) tObj = 0; - if (!(ctx->Texture.Enabled & 0xf) || !tObj || !tObj->Complete) { - - imesa->Setup[I810_CTXREG_MC0] = ( GFX_OP_MAP_COLOR_STAGES | - MC_STAGE_0 | - MC_UPDATE_DEST | - MC_DEST_CURRENT | - MC_UPDATE_ARG1 | - MC_ARG1_ITERATED_COLOR | - MC_UPDATE_ARG2 | - MC_ARG2_ONE | - MC_UPDATE_OP | - MC_OP_ARG1 ); - imesa->Setup[I810_CTXREG_MA0] = ( GFX_OP_MAP_ALPHA_STAGES | - MA_STAGE_0 | - MA_UPDATE_ARG1 | - MA_ARG1_ITERATED_ALPHA | - MA_UPDATE_ARG2 | - MA_ARG2_TEX0_ALPHA | - MA_UPDATE_OP | - MA_OP_ARG1 ); + imesa->Setup[I810_CTXREG_MC0] = ( GFX_OP_MAP_COLOR_STAGES | + MC_STAGE_0 | + MC_UPDATE_DEST | + MC_DEST_CURRENT | + MC_UPDATE_ARG1 | + MC_ARG1_ITERATED_COLOR | + MC_UPDATE_ARG2 | + MC_ARG2_ONE | + MC_UPDATE_OP | + MC_OP_ARG1 ); + + imesa->Setup[I810_CTXREG_MA0] = ( GFX_OP_MAP_ALPHA_STAGES | + MA_STAGE_0 | + MA_UPDATE_ARG1 | + MA_ARG1_ITERATED_ALPHA | + MA_UPDATE_ARG2 | + MA_ARG2_TEX0_ALPHA | + MA_UPDATE_OP | + MA_OP_ARG1 ); - imesa->reg_dirty |= ((1<<I810_CTXREG_MA0) | - (1<<I810_CTXREG_MC0)); + + if (!(ctx->Texture.Enabled & 0xf) || !tObj || !tObj->Complete) { return; } @@ -557,30 +717,13 @@ static void i810UpdateTex0State( GLcontext *ctx ) i810TexSetUnit( t, 0 ); if (t->dirty_images) - i810UploadTexImages(imesa, t); - - t->age = ++i810glx.current_texture_age; - move_to_head(&imesa->TexObjList, t); - - imesa->CurrentTex0Obj = t; - - if (0) - if (t->UsePalette == I810_USE_PALETTE) { - if (ctx->Texture.SharedPalette) { - if (imesa->GlobalPaletteUpdated) - i810LoadTexturePalette(imesa->GlobalPalette,0,256); - imesa->GlobalPaletteUpdated = 0; - } - else { - i810LoadTexturePalette(t->Palette,0,256); - imesa->GlobalPaletteUpdated = 1; - } - } - - - if (t->reg_dirty) - i810DmaExecute(t->Setup,I810_TEX_SETUP_SIZE); + imesa->dirty |= I810_UPLOAD_TEX0IMAGE; + + imesa->CurrentTexObj[0] = t; + t->bound = 1; + if (t->MemBlock) + i810UpdateTexLRU( imesa, t ); switch (ctx->Texture.Unit[0].EnvMode) { case GL_REPLACE: @@ -730,15 +873,10 @@ static void i810UpdateTex0State( GLcontext *ctx ) break; default: - FatalError("unkown tex env mode"); + fprintf(stderr, "unknown tex env mode"); + exit(1); break; } - - - - imesa->reg_dirty |= ((1<<I810_CTXREG_MA0) | - (1<<I810_CTXREG_MC0)); - } @@ -756,36 +894,34 @@ static void i810UpdateTex1State( GLcontext *ctx ) if ( tObj != ctx->Texture.Unit[1].CurrentD[2] ) tObj = 0; - if (!(ctx->Texture.Enabled & 0xf0) || !tObj || !tObj->Complete) { - imesa->Setup[I810_CTXREG_MC1] = ( GFX_OP_MAP_COLOR_STAGES | - MC_STAGE_1 | - MC_UPDATE_DEST | - MC_DEST_CURRENT | - MC_UPDATE_ARG1 | - MC_ARG1_ONE | - MC_ARG1_DONT_REPLICATE_ALPHA | - MC_ARG1_DONT_INVERT | - MC_UPDATE_ARG2 | - MC_ARG2_ONE | - MC_ARG2_DONT_REPLICATE_ALPHA | - MC_ARG2_DONT_INVERT | - MC_UPDATE_OP | - MC_OP_DISABLE ); + imesa->Setup[I810_CTXREG_MC1] = ( GFX_OP_MAP_COLOR_STAGES | + MC_STAGE_1 | + MC_UPDATE_DEST | + MC_DEST_CURRENT | + MC_UPDATE_ARG1 | + MC_ARG1_ONE | + MC_ARG1_DONT_REPLICATE_ALPHA | + MC_ARG1_DONT_INVERT | + MC_UPDATE_ARG2 | + MC_ARG2_ONE | + MC_ARG2_DONT_REPLICATE_ALPHA | + MC_ARG2_DONT_INVERT | + MC_UPDATE_OP | + MC_OP_DISABLE ); + + imesa->Setup[I810_CTXREG_MA1] = ( GFX_OP_MAP_ALPHA_STAGES | + MA_STAGE_1 | + MA_UPDATE_ARG1 | + MA_ARG1_CURRENT_ALPHA | + MA_ARG1_DONT_INVERT | + MA_UPDATE_ARG2 | + MA_ARG2_CURRENT_ALPHA | + MA_ARG2_DONT_INVERT | + MA_UPDATE_OP | + MA_OP_ARG1 ); - imesa->Setup[I810_CTXREG_MA1] = ( GFX_OP_MAP_ALPHA_STAGES | - MA_STAGE_1 | - MA_UPDATE_ARG1 | - MA_ARG1_CURRENT_ALPHA | - MA_ARG1_DONT_INVERT | - MA_UPDATE_ARG2 | - MA_ARG2_CURRENT_ALPHA | - MA_ARG2_DONT_INVERT | - MA_UPDATE_OP | - MA_OP_ARG1 ); - - imesa->reg_dirty |= ((1<<I810_CTXREG_MA1) | - (1<<I810_CTXREG_MC1)); + if (!(ctx->Texture.Enabled & 0xf0) || !tObj || !tObj->Complete) { return; } @@ -796,35 +932,18 @@ static void i810UpdateTex1State( GLcontext *ctx ) if (!t) return; } - if (t->dirty_images) - i810UploadTexImages(imesa, t); - if (t->current_unit != 1) i810TexSetUnit( t, 1 ); - t->age = ++i810glx.current_texture_age; - move_to_head(&imesa->TexObjList, t); - imesa->CurrentTex1Obj = t; - - if (0) - if (t->UsePalette == I810_USE_PALETTE) { - if (ctx->Texture.SharedPalette) { - if (imesa->GlobalPaletteUpdated) - i810LoadTexturePalette(imesa->GlobalPalette,0,256); - imesa->GlobalPaletteUpdated = 0; - } - else { - i810LoadTexturePalette(t->Palette,0,256); - imesa->GlobalPaletteUpdated = 1; - } - } - + if (t->dirty_images) + imesa->dirty |= I810_UPLOAD_TEX1IMAGE; - if (t->reg_dirty) - i810DmaExecute(t->Setup,I810_TEX_SETUP_SIZE); + imesa->CurrentTexObj[1] = t; + t->bound = 2; + if (t->MemBlock) + i810UpdateTexLRU( imesa, t ); - switch (ctx->Texture.Unit[1].EnvMode) { case GL_REPLACE: imesa->Setup[I810_CTXREG_MC1] = ( GFX_OP_MAP_COLOR_STAGES | @@ -980,64 +1099,70 @@ static void i810UpdateTex1State( GLcontext *ctx ) break; default: - FatalError("unkown tex 1 env mode"); + fprintf(stderr, "unkown tex 1 env mode\n"); + exit(1); break; } - - imesa->reg_dirty |= ((1<<I810_CTXREG_MA1) | - (1<<I810_CTXREG_MC1)); } void i810UpdateTextureState( GLcontext *ctx ) { + i810ContextPtr imesa = I810_CONTEXT(ctx); + if (imesa->CurrentTexObj[0]) imesa->CurrentTexObj[0]->bound = 0; + if (imesa->CurrentTexObj[1]) imesa->CurrentTexObj[1]->bound = 0; + imesa->CurrentTexObj[0] = 0; + imesa->CurrentTexObj[1] = 0; i810UpdateTex0State( ctx ); i810UpdateTex1State( ctx ); + I810_CONTEXT( ctx )->dirty |= I810_UPLOAD_CTX; } /***************************************** - * Driver functions + * DRIVER functions *****************************************/ -void i810TexEnv( GLcontext *ctx, GLenum pname, const GLfloat *param ) +static void i810TexEnv( GLcontext *ctx, GLenum pname, const GLfloat *param ) { i810ContextPtr imesa = I810_CONTEXT( ctx ); if (pname == GL_TEXTURE_ENV_MODE) { + FLUSH_BATCH(imesa); imesa->new_state |= I810_NEW_TEXTURE; } else if (pname == GL_TEXTURE_ENV_COLOR) { struct gl_texture_unit *texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; - GLubyte c[4]; + GLfloat *fc = texUnit->EnvColor; GLuint col; - FLOAT_RGBA_TO_UBYTE_RGBA(texUnit->EnvColor, c); - col = (c[3]<<24) | (c[0]<<16) | (c[1]<<8) | (c[2]); + col = ((((GLubyte)fc[3])<<24) | + (((GLubyte)fc[0])<<16) | + (((GLubyte)fc[1])<<8) | + (((GLubyte)fc[2])<<0)); if (imesa->Setup[I810_CTXREG_CF1] != col) { + FLUSH_BATCH(imesa); imesa->Setup[I810_CTXREG_CF1] = col; - imesa->reg_dirty |= (1<<I810_CTXREG_CF1); + imesa->dirty |= I810_UPLOAD_CTX; } } } -void i810TexImage( GLcontext *ctx, - GLenum target, - struct gl_texture_object *tObj, - GLint level, - GLint internalFormat, - const struct gl_texture_image *image ) +static void i810TexImage( GLcontext *ctx, + GLenum target, + struct gl_texture_object *tObj, + GLint level, + GLint internalFormat, + const struct gl_texture_image *image ) { i810ContextPtr imesa = I810_CONTEXT( ctx ); i810TextureObjectPtr t; - CHECK_CONTEXT( return; ); - i810Msg(10,"i810TexImage(%d): level %d internalFormat %x\n", tObj->Name, level, internalFormat); @@ -1049,6 +1174,7 @@ void i810TexImage( GLcontext *ctx, t = (i810TextureObjectPtr) tObj->DriverData; if (t) { + if (t->bound) FLUSH_BATCH(imesa); /* if this is the current object, it will force an update */ i810DestroyTexObj( imesa, t ); tObj->DriverData = 0; @@ -1056,12 +1182,12 @@ void i810TexImage( GLcontext *ctx, } } -void i810TexSubImage( GLcontext *ctx, GLenum target, - struct gl_texture_object *tObj, GLint level, - GLint xoffset, GLint yoffset, - GLsizei width, GLsizei height, - GLint internalFormat, - const struct gl_texture_image *image ) +static void i810TexSubImage( GLcontext *ctx, GLenum target, + struct gl_texture_object *tObj, GLint level, + GLint xoffset, GLint yoffset, + GLsizei width, GLsizei height, + GLint internalFormat, + const struct gl_texture_image *image ) { i810ContextPtr imesa = I810_CONTEXT( ctx ); i810TextureObjectPtr t; @@ -1070,13 +1196,12 @@ void i810TexSubImage( GLcontext *ctx, GLenum target, width, height, image->Width,image->Height, level); - CHECK_CONTEXT( return; ); - if ( target != GL_TEXTURE_2D ) return; t = (i810TextureObjectPtr) tObj->DriverData; if (t) { + if (t->bound) FLUSH_BATCH( imesa ); i810DestroyTexObj( imesa, t ); tObj->DriverData = 0; imesa->new_state |= I810_NEW_TEXTURE; @@ -1084,9 +1209,9 @@ void i810TexSubImage( GLcontext *ctx, GLenum target, } } -void i810TexParameter( GLcontext *ctx, GLenum target, - struct gl_texture_object *tObj, - GLenum pname, const GLfloat *params ) +static void i810TexParameter( GLcontext *ctx, GLenum target, + struct gl_texture_object *tObj, + GLenum pname, const GLfloat *params ) { i810TextureObjectPtr t = (i810TextureObjectPtr) tObj->DriverData; i810ContextPtr imesa = I810_CONTEXT( ctx ); @@ -1097,97 +1222,82 @@ void i810TexParameter( GLcontext *ctx, GLenum target, switch (pname) { case GL_TEXTURE_MIN_FILTER: case GL_TEXTURE_MAG_FILTER: + if (t->bound) FLUSH_BATCH( imesa ); i810SetTexFilter(t,tObj->MinFilter,tObj->MagFilter); break; case GL_TEXTURE_WRAP_S: case GL_TEXTURE_WRAP_T: + if (t->bound) FLUSH_BATCH( imesa ); i810SetTexWrapping(t,tObj->WrapS,tObj->WrapT); break; case GL_TEXTURE_BORDER_COLOR: + if (t->bound) FLUSH_BATCH( imesa ); i810SetTexBorderColor(t,tObj->BorderColor); break; default: return; } + imesa->new_state |= I810_NEW_TEXTURE; } -void i810BindTexture( GLcontext *ctx, GLenum target, - struct gl_texture_object *tObj ) +static void i810BindTexture( GLcontext *ctx, GLenum target, + struct gl_texture_object *tObj ) { i810ContextPtr imesa = I810_CONTEXT( ctx ); + + FLUSH_BATCH(imesa); - if (target != GL_TEXTURE_2D) - return; + if (imesa->CurrentTexObj[ctx->Texture.CurrentUnit]) { + imesa->CurrentTexObj[ctx->Texture.CurrentUnit]->bound = 0; + imesa->CurrentTexObj[ctx->Texture.CurrentUnit] = 0; + } imesa->new_state |= I810_NEW_TEXTURE; } -void i810DeleteTexture( GLcontext *ctx, struct gl_texture_object *tObj ) +static void i810DeleteTexture( GLcontext *ctx, struct gl_texture_object *tObj ) { i810TextureObjectPtr t = (i810TextureObjectPtr)tObj->DriverData; i810ContextPtr imesa = I810_CONTEXT( ctx ); - i810DestroyTexObj(imesa,t); - tObj->DriverData=0; -} - -void i810UpdateTexturePalette( GLcontext *ctx, struct gl_texture_object *tObj ) -{ - i810ContextPtr imesa = I810_CONTEXT( ctx ); - i810TextureObjectPtr t; - GLushort *dst; - GLubyte *src; - int i, size, next; - GLenum format; + if (t) { + if (t->bound) { + FLUSH_BATCH(imesa); + imesa->CurrentTexObj[t->bound-1] = 0; + imesa->new_state |= I810_NEW_TEXTURE; + } - return; + i810DestroyTexObj(imesa,t); + tObj->DriverData=0; + } +} - if (tObj) - { - i810Msg(8,"i810UpdateTexturePalette(): size %d\n", tObj->PaletteSize); - t = (i810TextureObjectPtr) tObj->DriverData;; - if (!t) return; - size = tObj->PaletteSize; - format = tObj->PaletteFormat; - dst = t->Palette; - src = (GLubyte *) tObj->Palette; - } - else - { - /* shared palette */ - imesa->GlobalPaletteUpdated = 1; - size = ctx->Texture.PaletteSize; - format = ctx->Texture.PaletteFormat; - dst = imesa->GlobalPalette; - src = (GLubyte *) ctx->Texture.Palette; - - i810Msg(8, "i810UpdateTexturePalette(): size %d intFormat %x format %x\n", - size, ctx->Texture.PaletteIntFormat, ctx->Texture.PaletteFormat); - } +static GLboolean i810IsTextureResident( GLcontext *ctx, + struct gl_texture_object *t ) +{ + i810TextureObjectPtr mt; - if (size > 256) { - i810Error("i810UpdateTexturePalette(): palette > 256 entries!\n"); - return; - } +/* LOCK_HARDWARE; */ + mt = (i810TextureObjectPtr)t->DriverData; +/* UNLOCK_HARDWARE; */ - switch (format) - { - case GL_RGB: next = 3; break; - case GL_RGBA:next = 4; break; - default : - i810Error("i810UpdateTexturePalette(): unsupported palette format %x\n"); - next = 4; - } + return mt && mt->MemBlock; +} - for (i=0; i < size; i++) { - *dst = I810PACKCOLOR565(src[RCOMP],src[GCOMP],src[BCOMP]); - dst++; - src += next; - } +void i810DDInitTextureFuncs( GLcontext *ctx ) +{ + ctx->Driver.TexEnv = i810TexEnv; + ctx->Driver.TexImage = i810TexImage; + ctx->Driver.TexSubImage = i810TexSubImage; + ctx->Driver.BindTexture = i810BindTexture; + ctx->Driver.DeleteTexture = i810DeleteTexture; + ctx->Driver.TexParameter = i810TexParameter; + ctx->Driver.UpdateTexturePalette = 0; + ctx->Driver.IsTextureResident = i810IsTextureResident; } diff --git a/xc/lib/GL/mesa/src/drv/i810/i810tex.h b/xc/lib/GL/mesa/src/drv/i810/i810tex.h index ed9875be8..5261d0b1b 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810tex.h +++ b/xc/lib/GL/mesa/src/drv/i810/i810tex.h @@ -26,16 +26,31 @@ #ifndef I810TEX_INC #define I810TEX_INC -#include "mesaglx/types.h" +#include "types.h" #include "mmath.h" +#include "mm.h" -#include "i810common.h" -#include "i810buf.h" +#include "i810context.h" +#include "i810_3d_reg.h" #define VALID_I810_TEXTURE_OBJECT(tobj) (tobj) #define I810_TEX_MAXLEVELS 10 + + +/* For shared texture space managment, these texture objects may also + * be used as proxies for regions of texture memory containing other + * client's textures. Such proxy textures (not to be confused with GL + * proxy textures) are subject to the same LRU aging we use for our + * own private textures, and thus we have a mechanism where we can + * fairly decide between kicking out our own textures and those of + * other clients. + * + * Non-local texture objects have a valid MemBlock to describe the + * region managed by the other client, and can be identified by + * 't->globj == 0' + */ struct i810_texture_object_t { struct i810_texture_object_t *next, *prev; @@ -46,11 +61,11 @@ struct i810_texture_object_t { int Height; int texelBytes; int totalSize; + int bound; - PMemBlock MemBlock; - + PMemBlock MemBlock; char *BufAddr; - + GLuint min_level; GLuint max_level; GLuint dirty_images; @@ -64,13 +79,8 @@ struct i810_texture_object_t { /* Support for multitexture. */ - GLuint current_unit; - + GLuint current_unit; GLuint Setup[I810_TEX_SETUP_SIZE]; - GLuint reg_dirty; - - GLushort Palette[256]; - int UsePalette; }; #define I810_NO_PALETTE 0x0 @@ -80,38 +90,20 @@ struct i810_texture_object_t { typedef struct i810_texture_object_t *i810TextureObjectPtr; -i810TextureObjectPtr i810CreateTexObj(i810ContextPtr ctx, - struct gl_texture_object *tObj); -int i810DestroyTexObj(i810ContextPtr ctx, i810TextureObjectPtr t); -void i810UpdateTextureState(GLcontext *ctx); - - -/* Driver functions */ - -void i810TexEnv( GLcontext *ctx, GLenum pname, const GLfloat *param ); - -void i810TexImage( GLcontext *ctx, GLenum target, - struct gl_texture_object *tObj, GLint level, - GLint internalFormat, - const struct gl_texture_image *image ); +void i810UpdateTextureState( GLcontext *ctx ); +void i810DDInitTextureFuncs( GLcontext *ctx ); -void i810TexSubImage( GLcontext *ctx, GLenum target, - struct gl_texture_object *tObj, GLint level, - GLint xoffset, GLint yoffset, - GLsizei width, GLsizei height, - GLint internalFormat, - const struct gl_texture_image *image ); +void i810DestroyTexObj( i810ContextPtr imesa, i810TextureObjectPtr t); +int i810UploadTexImages( i810ContextPtr imesa, i810TextureObjectPtr t ); -void i810TexParameter( GLcontext *ctx, GLenum target, - struct gl_texture_object *tObj, - GLenum pname, const GLfloat *params ); +void i810ResetGlobalLRU( i810ContextPtr imesa ); +void i810TexturesGone( i810ContextPtr imesa, + GLuint start, GLuint end, + GLuint in_use ); -void i810BindTexture( GLcontext *ctx, GLenum target, - struct gl_texture_object *tObj ); +void i810PrintLocalLRU( i810ContextPtr imesa ); +void i810PrintGlobalLRU( i810ContextPtr imesa ); -void i810DeleteTexture( GLcontext *ctx, struct gl_texture_object *tObj ); -void i810UpdateTexturePalette( GLcontext *ctx, struct gl_texture_object *tObj ); -void i810UseGlobalTexturePalette( GLcontext *ctx, GLboolean state ); #endif diff --git a/xc/lib/GL/mesa/src/drv/i810/i810tris.c b/xc/lib/GL/mesa/src/drv/i810/i810tris.c index 1c81b9549..d970e3a36 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810tris.c +++ b/xc/lib/GL/mesa/src/drv/i810/i810tris.c @@ -26,6 +26,7 @@ #include <stdio.h> #include <math.h> +#include "types.h" #include "vb.h" #include "pipeline.h" @@ -34,28 +35,9 @@ #include "i810tris.h" #include "i810vb.h" #include "i810log.h" -#include "xsmesaP.h" - - -static void i810_null_quad( GLcontext *ctx, GLuint v0, - GLuint v1, GLuint v2, GLuint v3, GLuint pv ) -{ -} - -static void i810_null_triangle( GLcontext *ctx, GLuint v0, - GLuint v1, GLuint v2, GLuint pv ) -{ -} - -static void i810_null_line( GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv ) -{ -} - -static void i810_null_points( GLcontext *ctx, GLuint first, GLuint last ) -{ -} - +/* Used in i810tritmp.h + */ #define I810_COLOR(to, from) { \ (to)[0] = (from)[2]; \ (to)[1] = (from)[1]; \ @@ -70,17 +52,6 @@ static quad_func quad_tab[0x20]; static line_func line_tab[0x20]; static points_func points_tab[0x20]; -void i810PrintRenderState( const char *msg, GLuint state ) -{ - fprintf(stderr, "%s: (%x) %s%s%s%s%s%s\n", - msg, state, - (state & I810_FLAT_BIT) ? "flat, " : "", - (state & I810_OFFSET_BIT) ? "offset, " : "", - (state & I810_TWOSIDE_BIT) ? "twoside, " : "", - (state & I810_ANTIALIAS_BIT) ? "antialias, " : "", - (state & I810_NODRAW_BIT) ? "no-draw, " : "", - (state & I810_FALLBACK_BIT) ? "fallback" : ""); -} #define IND (0) #define TAG(x) x @@ -90,33 +61,32 @@ void i810PrintRenderState( const char *msg, GLuint state ) #define TAG(x) x##_flat #include "i810tritmp.h" -#define IND (I810_OFFSET_BIT) +#define IND (I810_OFFSET_BIT) /* wide */ #define TAG(x) x##_offset #include "i810tritmp.h" -#define IND (I810_OFFSET_BIT|I810_FLAT_BIT) +#define IND (I810_OFFSET_BIT|I810_FLAT_BIT) /* wide|flat */ #define TAG(x) x##_offset_flat #include "i810tritmp.h" -#define IND (I810_TWOSIDE_BIT) +#define IND (I810_TWOSIDE_BIT) /* stipple */ #define TAG(x) x##_twoside #include "i810tritmp.h" -#define IND (I810_TWOSIDE_BIT|I810_FLAT_BIT) +#define IND (I810_TWOSIDE_BIT|I810_FLAT_BIT) /* stipple|flat */ #define TAG(x) x##_twoside_flat #include "i810tritmp.h" -#define IND (I810_TWOSIDE_BIT|I810_OFFSET_BIT) +#define IND (I810_TWOSIDE_BIT|I810_OFFSET_BIT) /* stipple|wide */ #define TAG(x) x##_twoside_offset #include "i810tritmp.h" -#define IND (I810_TWOSIDE_BIT|I810_OFFSET_BIT|I810_FLAT_BIT) +#define IND (I810_TWOSIDE_BIT|I810_OFFSET_BIT|I810_FLAT_BIT) /* stip|wide|flat*/ #define TAG(x) x##_twoside_offset_flat #include "i810tritmp.h" void i810DDTrifuncInit() { - int i; init(); init_flat(); init_offset(); @@ -125,113 +95,9 @@ void i810DDTrifuncInit() init_twoside_flat(); init_twoside_offset(); init_twoside_offset_flat(); - - /* Hmmm... - */ - for (i = 0 ; i < 0x20 ; i++) { - if (i & ~I810_FLAT_BIT) { - points_tab[i] = points_tab[i&I810_FLAT_BIT]; - line_tab[i] = line_tab[i&I810_FLAT_BIT]; - } - } - - for (i = 0 ; i < 0x20 ; i++) - if ((i & (I810_NODRAW_BIT|I810_FALLBACK_BIT)) == I810_NODRAW_BIT || - i810glx.nullprims) - { - quad_tab[i] = i810_null_quad; - tri_tab[i] = i810_null_triangle; - line_tab[i] = i810_null_line; - points_tab[i] = i810_null_points; - } - - if (i810glx.noFallback) { - for (i = 0 ; i < 0x10 ; i++) { - points_tab[i|I810_FALLBACK_BIT] = points_tab[i]; - line_tab[i|I810_FALLBACK_BIT] = line_tab[i]; - tri_tab[i|I810_FALLBACK_BIT] = tri_tab[i]; - quad_tab[i|I810_FALLBACK_BIT] = quad_tab[i]; - } - } - } -/* Everything is done via single triangle instructiopns at the moment; - * this can change fairly easily. - */ -#if I810_USE_BATCH - -GLuint *i810AllocPrimitiveVerts( int dwords ) -{ - GLuint orig_dwords = dwords; - - dwords+=2; - dwords&=~1; - - while (1) { - if (i810glx.dma_buffer->space < dwords * 4) - { - if (I810_DEBUG & DEBUG_VERBOSE_RING) - fprintf(stderr, "i810AllocPrimitiveVerts: dma buffer overflow\n"); - i810DmaOverflow( dwords ); - } - else - { - GLuint start = i810glx.dma_buffer->head; - i810glx.dma_buffer->head += dwords * 4; - i810glx.dma_buffer->space -= dwords * 4; - - if ((orig_dwords & 1) == 0) { - *(GLuint *)(i810glx.dma_buffer->virtual_start + start ) = 0; - start += 4; - } - - *(GLuint *)(i810glx.dma_buffer->virtual_start + start ) = - GFX_OP_PRIMITIVE | PR_TRIANGLES | (orig_dwords-1); - - return (GLuint *)(i810glx.dma_buffer->virtual_start + start + 4); - } - } -} - -#else -GLuint *i810AllocPrimitiveVerts( int dwords ) -{ - GLuint orig_dwords = dwords; - - dwords+=2; - dwords&=~1; - - while (1) - { - BEGIN_LP_RING( dwords ); - - if (outring + dwords * 4 != ((outring + dwords * 4) & ringmask)) - { - int i; - - if (I810_DEBUG & DEBUG_VERBOSE_RING) - fprintf(stderr, "\n\nwrap case in i810AllocPrimitiveVerts\n\n"); - - for (i = 0 ; i < dwords ; i++) - OUT_RING( 0 ); - ADVANCE_LP_RING(); - } - else - { - I810LpRing.tail = outring + dwords * 4; - - if ((orig_dwords & 1) == 0) - OUT_RING(0); - - OUT_RING( GFX_OP_PRIMITIVE | PR_TRIANGLES | (orig_dwords-1) ); - return (GLuint *)(virt + outring); - } - } -} -#endif - void i810DDChooseRenderState( GLcontext *ctx ) @@ -239,50 +105,41 @@ void i810DDChooseRenderState( GLcontext *ctx ) i810ContextPtr imesa = I810_CONTEXT( ctx ); GLuint flags = ctx->TriangleCaps; - ctx->IndirectTriangles &= ~DD_SW_RASTERIZE; + imesa->IndirectTriangles = 0; if (flags) { GLuint ind = 0; GLuint shared = 0; - GLuint setup = imesa->setupindex; - GLuint fallback = I810_FALLBACK_BIT; - - if (i810glx.noFallback) fallback = 0; - if ((flags & DD_FLATSHADE) && (setup & I810_RGBA_BIT)) shared |= I810_FLAT_BIT; - if (flags & DD_MULTIDRAW) shared |= fallback; + if (flags & DD_FLATSHADE) shared |= I810_FLAT_BIT; + if (flags & DD_MULTIDRAW) shared |= I810_FALLBACK_BIT; if (flags & DD_SELECT) shared |= I810_FALLBACK_BIT; if (flags & DD_FEEDBACK) shared |= I810_FALLBACK_BIT; - ind = shared; - if (flags & DD_POINT_SMOOTH) ind |= I810_ANTIALIAS_BIT; - if (flags & DD_POINT_ATTEN) ind |= fallback; - - imesa->renderindex = ind; - imesa->PointsFunc = points_tab[ind]; - if (ind & I810_FALLBACK_BIT) - ctx->IndirectTriangles |= DD_POINT_SW_RASTERIZE; + imesa->renderindex = shared; + imesa->PointsFunc = points_tab[shared]; ind = shared; - if (flags & DD_LINE_SMOOTH) ind |= I810_ANTIALIAS_BIT; - if (flags & DD_LINE_STIPPLE) ind |= fallback; + if (flags & DD_LINE_WIDTH) ind |= I810_WIDE_LINE_BIT; + if (flags & DD_LINE_STIPPLE) ind |= I810_FALLBACK_BIT; imesa->renderindex |= ind; imesa->LineFunc = line_tab[ind]; if (ind & I810_FALLBACK_BIT) - ctx->IndirectTriangles |= DD_LINE_SW_RASTERIZE; + imesa->IndirectTriangles |= DD_LINE_SW_RASTERIZE; ind = shared; - if (flags & DD_TRI_SMOOTH) ind |= I810_ANTIALIAS_BIT; if (flags & DD_TRI_OFFSET) ind |= I810_OFFSET_BIT; if (flags & DD_TRI_LIGHT_TWOSIDE) ind |= I810_TWOSIDE_BIT; - if (flags & (DD_TRI_UNFILLED|DD_TRI_STIPPLE)) ind |= fallback; + if (flags & DD_TRI_UNFILLED) ind |= I810_FALLBACK_BIT; + if ((flags & DD_TRI_STIPPLE) && + (ctx->IndirectTriangles & DD_TRI_STIPPLE)) ind |= I810_FALLBACK_BIT; imesa->renderindex |= ind; imesa->TriangleFunc = tri_tab[ind]; imesa->QuadFunc = quad_tab[ind]; if (ind & I810_FALLBACK_BIT) - ctx->IndirectTriangles |= (DD_TRI_SW_RASTERIZE|DD_QUAD_SW_RASTERIZE); + imesa->IndirectTriangles |= (DD_TRI_SW_RASTERIZE|DD_QUAD_SW_RASTERIZE); } else if (imesa->renderindex) { @@ -293,9 +150,9 @@ void i810DDChooseRenderState( GLcontext *ctx ) imesa->QuadFunc = quad_tab[0]; } - if (MESA_VERBOSE&VERBOSE_DRIVER) { + + if (I810_DEBUG&DEBUG_VERBOSE_API) { gl_print_tri_caps("tricaps", ctx->TriangleCaps); - i810PrintRenderState("i810: Render state", imesa->renderindex); } } diff --git a/xc/lib/GL/mesa/src/drv/i810/i810tris.h b/xc/lib/GL/mesa/src/drv/i810/i810tris.h index 12e0ec7fd..5b73b7676 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810tris.h +++ b/xc/lib/GL/mesa/src/drv/i810/i810tris.h @@ -23,107 +23,76 @@ * */ -#ifndef I810TIS_INC -#define I810TIS_INC +#ifndef I810TRIS_INC +#define I810TRIS_INC -#include "mesaglx/types.h" +#include "types.h" +#include "i810dma.h" +#include "i810ioctl.h" +extern void i810PrintRenderState( const char *msg, GLuint state ); extern void i810DDChooseRenderState(GLcontext *ctx); -extern void i810DDTrifuncInit(); +extern void i810DDTrifuncInit( void ); -/* extern void i810FinishPrimitive( void ); */ -extern void i810NaughtyFinishPrimitive( void ); -extern GLuint *i810AllocPrimitiveVerts( int dwords ); +/* shared */ +#define I810_FLAT_BIT 0x1 +/* triangle */ +#define I810_OFFSET_BIT 0x2 +#define I810_TWOSIDE_BIT 0x4 -/* Todo: - * - multidraw, ... - * - Antialiasing (?) - * - line and polygon stipple - * - select and feedback - * - stencil - * - point parameters - * - - */ -#define I810_ANTIALIAS_BIT 0 /* ignored for now, no fallback */ -#define I810_FLAT_BIT 0x1 -#define I810_OFFSET_BIT 0x2 /* 3.1 only */ -#define I810_TWOSIDE_BIT 0x4 /* 3.1 only */ -#define I810_NODRAW_BIT 0x8 -#define I810_FALLBACK_BIT 0x10 - -/* Not in use: - */ -#define I810_FEEDBACK_BIT 0x20 -#define I810_SELECT_BIT 0x40 -#define I810_POINT_PARAM_BIT 0x80 /* not needed? */ +/* line */ +#define I810_WIDE_LINE_BIT 0x2 +#define I810_STIPPLE_LINE_BIT 0x4 +/* shared */ +#define I810_FALLBACK_BIT 0x8 -static inline void i810_draw_triangle( i810_vertex *v0, - i810_vertex *v1, - i810_vertex *v2 ) -{ -#if 0 - fprintf(stderr, "i810_draw_triangle( %p, %p, %p )\n", v0, v1, v2); -#endif +static i810_vertex __inline__ *i810AllocTriangles( i810ContextPtr imesa, int nr) +{ + GLuint *start = i810AllocDwords( imesa, 30*nr+1 ); + *start++ = GFX_OP_PRIMITIVE | PR_TRIANGLES | (30*nr-1); + return (i810_vertex *)start; +} -#if 0 -#define WID 640 -#define HI 480 - { - GLuint print = 1, draw = 1; - GLfloat area = ((v0->x - v2->x) * (v1->y - v2->y) - - (v0->y - v2->y) * (v1->x - v2->x)); - - if (v0->x < -.501 || v0->x > WID || v0->y < -.501 || v0->y > HI || - v1->x < -.501 || v1->x > WID || v1->y < -.501 || v1->y > HI || - v2->x < -.501 || v2->x > WID || v2->y < -.501 || v2->y > HI) { - fprintf(stderr, "not clipped\n"); - print = 1; - } - - if (area == 0 && ((v0 == v1) || (v1 == v2))) { - fprintf(stderr, "zero area %p %p %p\n", v0, v1, v2); - draw = 0; - } - - if (print) { - fprintf(stderr," v0: %f %f %f %f tex: %f %f\n", - v0->x, v0->y, v0->z, v0->oow, v0->tu0, v0->tv0); - fprintf(stderr," v1: %f %f %f %f tex: %f %f\n", - v1->x, v1->y, v1->z, v1->oow, v1->tu0, v1->tv0); - fprintf(stderr," v2: %f %f %f %f tex: %f %f\n", - v2->x, v2->y, v2->z, v2->oow, v2->tu0, v2->tv0); - return; - } - - if (!draw) return; - } -#endif +static i810_vertex __inline__ *i810AllocLine( i810ContextPtr imesa ) +{ + GLuint *start = i810AllocDwords( imesa, 21 ); + *start++ = GFX_OP_PRIMITIVE | PR_LINESTRIP | (20-1); + return (i810_vertex *)start; +} - { - i810_vertex *wv = (i810_vertex *)i810AllocPrimitiveVerts( 3 * 10 ); - wv[0] = *v0; - wv[1] = *v1; - wv[2] = *v2; - FINISH_PRIM(); - } +static i810_vertex __inline__ *i810AllocRect( i810ContextPtr imesa ) +{ + GLuint *start = i810AllocDwords( imesa, 31 ); + *start++ = GFX_OP_PRIMITIVE | PR_RECTS | (30-1); + return (i810_vertex *)start; } +static void __inline__ i810_draw_triangle( i810ContextPtr imesa, + i810_vertex *v0, + i810_vertex *v1, + i810_vertex *v2 ) +{ + i810_vertex *wv = i810AllocTriangles( imesa, 1 ); + wv[0] = *v0; + wv[1] = *v1; + wv[2] = *v2; + FINISH_PRIM(); +} -/* These can go soon, but for the meantime we're using triangles for - * everything. - */ -static inline void i810_draw_point( i810_vertex *tmp, float sz ) + +static __inline__ void i810_draw_point( i810ContextPtr imesa, + i810_vertex *tmp, float sz ) { - i810_vertex *wv = (i810_vertex *)i810AllocPrimitiveVerts(6*10); + i810_vertex *wv = i810AllocTriangles( imesa, 2 ); wv[0] = *tmp; wv[0].x = tmp->x - sz; @@ -153,11 +122,23 @@ static inline void i810_draw_point( i810_vertex *tmp, float sz ) } -static inline void i810_draw_line( i810_vertex *tmp0, - i810_vertex *tmp1, - float width ) +static __inline__ void i810_draw_line_line( i810ContextPtr imesa, + i810_vertex *tmp0, + i810_vertex *tmp1 ) +{ + i810_vertex *wv = i810AllocLine( imesa ); + wv[0] = *tmp0; + wv[1] = *tmp1; + FINISH_PRIM(); +} + +static __inline__ void i810_draw_tri_line( i810ContextPtr imesa, + i810_vertex *tmp0, + i810_vertex *tmp1, + float width ) { - i810_vertex *wv = (i810_vertex *)i810AllocPrimitiveVerts( 6 * 10 ); + i810_vertex *wv = i810AllocTriangles( imesa, 2 ); + float dx, dy, ix, iy; dx = tmp0->x - tmp1->x; @@ -168,15 +149,6 @@ static inline void i810_draw_line( i810_vertex *tmp0, iy = ix; ix = 0; } -#if 0 - fprintf(stderr,"tmp0: %f %f %f %f col: %x tex: %f %f\n", - tmp0->x, tmp0->y, tmp0->z, tmp0->oow, *(GLuint*)&tmp0->color, tmp0->tu0, tmp0->tv0); - fprintf(stderr,"tmp1: %f %f %f %f col: %x tex: %f %f\n", - tmp1->x, tmp1->y, tmp1->z, tmp1->oow, *(GLuint*)&tmp1->color, tmp1->tu0, tmp1->tv0); - fprintf(stderr, "ix: %f, iy: %f\n", ix, iy); -#endif - - wv[0] = *tmp0; wv[0].x = tmp0->x - ix; wv[0].y = tmp0->y - iy; @@ -200,8 +172,16 @@ static inline void i810_draw_line( i810_vertex *tmp0, wv[5] = *tmp1; wv[5].x = tmp1->x + ix; wv[5].y = tmp1->y + iy; - FINISH_PRIM(); } + +static __inline__ void i810_draw_line( i810ContextPtr imesa, + i810_vertex *tmp0, + i810_vertex *tmp1, + float width ) +{ + i810_draw_line_line( imesa, tmp0, tmp1 ); +} + #endif diff --git a/xc/lib/GL/mesa/src/drv/i810/i810tritmp.h b/xc/lib/GL/mesa/src/drv/i810/i810tritmp.h index c8ec01d49..ebe1ef5ea 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810tritmp.h +++ b/xc/lib/GL/mesa/src/drv/i810/i810tritmp.h @@ -1,19 +1,20 @@ -static inline void TAG(triangle)( GLcontext *ctx, GLuint e0, - GLuint e1, GLuint e2, GLuint pv ) +static __inline__ void TAG(triangle)( GLcontext *ctx, GLuint e0, + GLuint e1, GLuint e2, GLuint pv ) { + i810ContextPtr imesa = I810_CONTEXT(ctx); struct vertex_buffer *VB = ctx->VB; i810VertexPtr i810VB = I810_DRIVER_DATA(VB)->verts; - const i810_vertex *v0 = &i810VB[e0].v.v; - const i810_vertex *v1 = &i810VB[e1].v.v; - const i810_vertex *v2 = &i810VB[e2].v.v; + const i810_vertex *v0 = &i810VB[e0].v; + const i810_vertex *v1 = &i810VB[e1].v; + const i810_vertex *v2 = &i810VB[e2].v; #if (IND & I810_OFFSET_BIT) GLfloat offset = ctx->Polygon.OffsetUnits * 1.0/0x10000; #endif #if (IND & (I810_FLAT_BIT|I810_TWOSIDE_BIT)) - int c0 = *(int *)&i810VB[pv].v.v.color; + int c0 = *(int *)&i810VB[pv].v.color; int c1 = c0; int c2 = c0; #endif @@ -64,78 +65,39 @@ static inline void TAG(triangle)( GLcontext *ctx, GLuint e0, i810glx.c_triangles++; -#if 0 -#define WID 512 -#define HI 384 - { - GLuint print = 0, draw = 1; - GLfloat area = ((v0->x - v2->x) * (v1->y - v2->y) - - (v0->y - v2->y) * (v1->x - v2->x)); - - if (v0->x < -.501 || v0->x > WID || v0->y < -.501 || v0->y > HI || - v1->x < -.501 || v1->x > WID || v1->y < -.501 || v1->y > HI || - v2->x < -.501 || v2->x > WID || v2->y < -.501 || v2->y > HI) { - fprintf(stderr, "not clipped\n"); - print = 1; - } - - if (area == 0 && ((v0 == v1) || (v1 == v2))) { - fprintf(stderr, "zero area %p %p %p\n", v0, v1, v2); - draw = 0; - } - - if (print) { - fprintf(stderr,"v0: %f %f %f %f col: %x tex: %f %f\n", - v0->x, v0->y, v0->z, v0->oow, - *(GLuint*)&v0->color, v0->tu0, v0->tv0); - fprintf(stderr,"v1: %f %f %f %f col: %x tex: %f %f\n", - v1->x, v1->y, v1->z, v1->oow, - *(GLuint*)&v1->color, v1->tu0, v1->tv0); - fprintf(stderr,"v2: %f %f %f %f col: %x tex: %f %f\n", - v2->x, v2->y, v2->z, v2->oow, - *(GLuint*)&v2->color, v2->tu0, v2->tv0); -/* return; */ - } - - if (!draw) return; - } -#endif - BEGIN_CLIP_LOOP() - { - i810_vertex *wv = (i810_vertex *)i810AllocPrimitiveVerts( 3 * 10 ); - wv[0] = *v0; + { + i810_vertex *wv = i810AllocTriangles( imesa, 1 ); + wv[0] = *v0; #if (IND & (I810_FLAT_BIT|I810_TWOSIDE_BIT)) - *((int *)(&wv[0].color)) = c0; + *((int *)(&wv[0].color)) = c0; #endif #if (IND & I810_OFFSET_BIT) - wv[0].z = v0->z + offset; + wv[0].z = v0->z + offset; #endif - wv[1] = *v1; + wv[1] = *v1; #if (IND & (I810_FLAT_BIT|I810_TWOSIDE_BIT)) - *((int *)(&wv[1].color)) = c1; + *((int *)(&wv[1].color)) = c1; #endif #if (IND & I810_OFFSET_BIT) - wv[1].z = v1->z + offset; + wv[1].z = v1->z + offset; #endif - wv[2] = *v2; + wv[2] = *v2; #if (IND & (I810_FLAT_BIT|I810_TWOSIDE_BIT)) - *((int *)(&wv[2].color)) = c2; + *((int *)(&wv[2].color)) = c2; #endif #if (IND & I810_OFFSET_BIT) - wv[2].z = v2->z + offset; + wv[2].z = v2->z + offset; #endif - FINISH_PRIM(); - } - END_CLIP_LOOP(); + FINISH_PRIM(); + } } - static void TAG(quad)( GLcontext *ctx, GLuint v0, GLuint v1, GLuint v2, GLuint v3, GLuint pv ) @@ -144,60 +106,66 @@ static void TAG(quad)( GLcontext *ctx, GLuint v0, TAG(triangle)( ctx, v1, v2, v3, pv ); } - -#if ((IND & ~I810_FLAT_BIT) == 0) - static void TAG(line)( GLcontext *ctx, GLuint v0, GLuint v1, GLuint pv ) { + i810ContextPtr imesa = I810_CONTEXT( ctx ); i810VertexPtr i810VB = I810_DRIVER_DATA(ctx->VB)->verts; - i810_vertex tmp0 = i810VB[v0].v.v; - i810_vertex tmp1 = i810VB[v1].v.v; - float width = ctx->Line.Width; + int tmp0, tmp1; + (void) tmp0; (void) tmp1; + if (IND & I810_FLAT_BIT) { - *(int *)&tmp1.color = *(int *)&tmp0.color = - *(int *)&i810VB[pv].v.v.color; - } + tmp0 = *(int *)&i810VB[v0].v.color; + tmp1 = *(int *)&i810VB[v1].v.color; + i810VB[v0].v.color = i810VB[pv].v.color; + i810VB[v1].v.color = i810VB[pv].v.color; + } - BEGIN_CLIP_LOOP() - i810_draw_line( &tmp0, &tmp1, width ); - END_CLIP_LOOP(); + if (IND & I810_WIDE_LINE_BIT) + { + i810_draw_tri_line( imesa, &i810VB[v0].v, &i810VB[v1].v, + ctx->Line.Width ); + } + else + { + i810_draw_line_line( imesa, &i810VB[v0].v, &i810VB[v1].v ); + } + + if (IND & I810_FLAT_BIT) { + *(int *)&i810VB[v0].v.color = tmp0; + *(int *)&i810VB[v1].v.color = tmp1; + } } static void TAG(points)( GLcontext *ctx, GLuint first, GLuint last ) { - int i; + i810ContextPtr imesa = I810_CONTEXT( ctx ); struct vertex_buffer *VB = ctx->VB; i810VertexPtr i810VB = I810_DRIVER_DATA(VB)->verts; GLfloat sz = ctx->Point.Size * .5; + int i; /* Culling is disabled automatically via. the * ctx->Driver.ReducedPrimitiveChange() callback. */ - + for(i=first;i<=last;i++) { if(VB->ClipMask[i]==0) { - i810_vertex *tmp = &i810VB[i].v.v; - BEGIN_CLIP_LOOP() - i810_draw_point( tmp, sz ); - END_CLIP_LOOP(); + i810_vertex *tmp = &i810VB[i].v; + i810_draw_point( imesa, tmp, sz ); } } } -#endif -static void TAG(init)() +static void TAG(init)( void ) { tri_tab[IND] = TAG(triangle); quad_tab[IND] = TAG(quad); - -#if ((IND & ~I810_FLAT_BIT) == 0) line_tab[IND] = TAG(line); points_tab[IND] = TAG(points); -#endif } diff --git a/xc/lib/GL/mesa/src/drv/i810/i810vb.c b/xc/lib/GL/mesa/src/drv/i810/i810vb.c index b41ad0960..6ba7eb9a5 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810vb.c +++ b/xc/lib/GL/mesa/src/drv/i810/i810vb.c @@ -28,46 +28,43 @@ #include "i810vb.h" #include "i810log.h" #include "i810dma.h" -#include "xsmesaP.h" -#include "xsmesa.h" #include "stages.h" -#include "os.h" #include <stdio.h> #include <stdlib.h> #define TEX0 { \ - v->v.v.tu0 = tc0[i][0]; \ - v->v.v.tv0 = tc0[i][1]; \ + v->v.tu0 = tc0[i][0]; \ + v->v.tv0 = tc0[i][1]; \ } #define TEX1 { \ - v->v.v.tu1 = tc1[i][0]; \ - v->v.v.tv1 = tc1[i][1]; \ + v->v.tu1 = tc1[i][0]; \ + v->v.tv1 = tc1[i][1]; \ } /* Doesn't seem to work very well (golly). */ #define SPC { \ GLubyte *spec = &(VB->Spec[0][i][0]); \ - v->v.v.specular.red = spec[0]; \ - v->v.v.specular.green = spec[1]; \ - v->v.v.specular.blue = spec[2]; \ + v->v.specular.red = spec[0]; \ + v->v.specular.green = spec[1]; \ + v->v.specular.blue = spec[2]; \ } #define FOG { \ GLubyte *spec = &(VB->Spec[0][i][0]); \ - v->v.v.specular.alpha = spec[3]; \ + v->v.specular.alpha = spec[3]; \ } #define COL { \ GLubyte *col = &(VB->Color[0]->data[i][0]); \ - v->v.v.color.blue = col[2]; \ - v->v.v.color.green = col[1]; \ - v->v.v.color.red = col[0]; \ - v->v.v.color.alpha = col[3]; \ + v->v.color.blue = col[2]; \ + v->v.color.green = col[1]; \ + v->v.color.red = col[0]; \ + v->v.color.alpha = col[3]; \ } /* The vertex formats we have don't seem to support projective texturing @@ -82,19 +79,19 @@ imesa->setupdone &= ~I810_WIN_BIT; \ for (i=start; i < end; i++, v++) { \ float oow = 1.0 / tc[i][3]; \ - v->v.v.oow *= tc[i][3]; \ - v->v.v.tu0 *= oow; \ - v->v.v.tv0 *= oow; \ + v->v.oow *= tc[i][3]; \ + v->v.tu0 *= oow; \ + v->v.tv0 *= oow; \ } \ } #define COORD \ GLfloat *win = VB->Win.data[i]; \ - v->v.v.x = win[0]; \ - v->v.v.y = i810height - win[1]; \ - v->v.v.z = (1.0/0x10000) * win[2]; \ - v->v.v.oow = win[3]; + v->v.x = win[0]; \ + v->v.y = i810height - win[1]; \ + v->v.z = (1.0/0x10000) * win[2]; \ + v->v.oow = win[3]; @@ -104,15 +101,15 @@ #define SETUPFUNC(name,win,col,tex0,tex1,tex0_4,spec,fog) \ static void name(struct vertex_buffer *VB, GLuint start, GLuint end) \ { \ - i810ContextPtr imesa = I810_CONTEXT( ctx ); \ + i810ContextPtr imesa = I810_CONTEXT( VB->ctx ); \ + __DRIdrawablePrivate *dPriv = imesa->driDrawable; \ i810VertexPtr v; \ GLfloat (*tc0)[4]; \ GLfloat (*tc1)[4]; \ - GLfloat i810height = i810DB->Height; \ + GLfloat i810height = dPriv->h; \ int i; \ - (void) i810height; \ + (void) i810height; (void) imesa; \ \ - CHECK_CONTEXT( return; ); \ \ gl_import_client_data( VB, VB->ctx->RenderFlags, \ (VB->ClipOrMask \ @@ -143,7 +140,7 @@ static void name(struct vertex_buffer *VB, GLuint start, GLuint end) \ tex1; \ } \ col; \ - } \ + } \ tex0_4; \ } @@ -155,11 +152,13 @@ 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) @@ -171,11 +170,13 @@ 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) @@ -206,11 +207,13 @@ void i810DDSetupInit( void ) setup_func[I810_WIN_BIT|I810_FOG_BIT|I810_TEX0_BIT] = rs_wft0; setup_func[I810_WIN_BIT|I810_FOG_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_wft0t1; setup_func[I810_WIN_BIT|I810_RGBA_BIT] = rs_wg; + setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_SPEC_BIT] = rs_wgs; setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_TEX0_BIT] = rs_wgt0; setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_wgt0t1; setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_SPEC_BIT|I810_TEX0_BIT] = rs_wgst0; setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_SPEC_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_wgst0t1; setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_FOG_BIT] = rs_wgf; + setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_FOG_BIT|I810_SPEC_BIT] = rs_wgfs; setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_FOG_BIT|I810_TEX0_BIT] = rs_wgft0; setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_FOG_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_wgft0t1; setup_func[I810_WIN_BIT|I810_RGBA_BIT|I810_FOG_BIT|I810_SPEC_BIT|I810_TEX0_BIT] = rs_wgfst0; @@ -223,11 +226,13 @@ void i810DDSetupInit( void ) setup_func[I810_FOG_BIT|I810_TEX0_BIT] = rs_ft0; setup_func[I810_FOG_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_ft0t1; setup_func[I810_RGBA_BIT] = rs_g; + setup_func[I810_RGBA_BIT|I810_SPEC_BIT] = rs_gs; setup_func[I810_RGBA_BIT|I810_TEX0_BIT] = rs_gt0; setup_func[I810_RGBA_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_gt0t1; setup_func[I810_RGBA_BIT|I810_SPEC_BIT|I810_TEX0_BIT] = rs_gst0; setup_func[I810_RGBA_BIT|I810_SPEC_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_gst0t1; setup_func[I810_RGBA_BIT|I810_FOG_BIT] = rs_gf; + setup_func[I810_RGBA_BIT|I810_FOG_BIT|I810_SPEC_BIT] = rs_gfs; setup_func[I810_RGBA_BIT|I810_FOG_BIT|I810_TEX0_BIT] = rs_gft0; setup_func[I810_RGBA_BIT|I810_FOG_BIT|I810_TEX0_BIT|I810_TEX1_BIT] = rs_gft0t1; setup_func[I810_RGBA_BIT|I810_FOG_BIT|I810_SPEC_BIT|I810_TEX0_BIT] = rs_gfst0; @@ -240,7 +245,7 @@ void i810PrintSetupFlags(char *msg, GLuint flags ) { fprintf(stderr, "%s: %d %s%s%s%s%s%s%s\n", msg, - flags, + (int)flags, (flags & I810_WIN_BIT) ? " xyzw," : "", (flags & I810_RGBA_BIT) ? " rgba," : "", (flags & I810_SPEC_BIT) ? " spec," : "", @@ -274,7 +279,7 @@ void i810ChooseRasterSetupFunc(GLcontext *ctx) if (ctx->FogMode == FOG_FRAGMENT) funcindex |= I810_FOG_BIT; - if (MESA_VERBOSE || I810_DEBUG) + if (MESA_VERBOSE) i810PrintSetupFlags("xsmesa: full setup function", funcindex); imesa->setupindex = funcindex; @@ -312,6 +317,7 @@ void i810DDCheckPartialRasterSetup( GLcontext *ctx, */ void i810DDPartialRasterSetup( struct vertex_buffer *VB ) { + i810ContextPtr imesa = I810_CONTEXT( VB->ctx ); GLuint new = VB->pipeline->new_outputs; GLuint available = VB->pipeline->outputs; GLuint ind = 0; @@ -337,7 +343,7 @@ void i810DDPartialRasterSetup( struct vertex_buffer *VB ) ind &= imesa->setupindex; imesa->setupdone |= ind; - i810PrintSetupFlags("xsmesa: partial setup function", ind); + if (0) i810PrintSetupFlags("xsmesa: partial setup function", ind); if (ind) setup_func[ind&~I810_ALPHA_BIT]( VB, VB->Start, VB->Count ); @@ -366,28 +372,37 @@ void i810DDResizeVB( struct vertex_buffer *VB, GLuint size ) free( mvb->vert_store ); mvb->vert_store = malloc( sizeof(i810Vertex) * mvb->size + 31); - if (!mvb->vert_store) - FatalError("i810-glx: out of memory !\n"); + if (!mvb->vert_store) { + fprintf(stderr, "i810-glx: out of memory !\n"); + exit(1); + } mvb->verts = (i810VertexPtr)(((unsigned long)mvb->vert_store + 31) & ~31); gl_vector1ui_free( &mvb->clipped_elements ); gl_vector1ui_alloc( &mvb->clipped_elements, VEC_WRITABLE, mvb->size, 32 ); - if (!mvb->clipped_elements.start) - FatalError("i810-glx: out of memory !\n"); + if (!mvb->clipped_elements.start) { + fprintf(stderr, "i810-glx: out of memory !\n"); + exit(1); + } free( VB->ClipMask ); VB->ClipMask = (GLubyte *)malloc(sizeof(GLubyte) * mvb->size); - if (!VB->ClipMask) - FatalError("i810-glx: out of memory !\n"); + if (!VB->ClipMask) { + fprintf(stderr, "i810-glx: out of memory !\n"); + exit(1); + } + if (VB->Type == VB_IMMEDIATE) { free( mvb->primitive ); free( mvb->next_primitive ); mvb->primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size ); mvb->next_primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size ); - if (!mvb->primitive || !mvb->next_primitive) - FatalError("i810-glx: out of memory!"); + if (!mvb->primitive || !mvb->next_primitive) { + fprintf(stderr, "i810-glx: out of memory !\n"); + exit(1); + } } } @@ -398,31 +413,35 @@ void i810DDRegisterVB( struct vertex_buffer *VB ) mvb = (i810VertexBufferPtr)calloc( 1, sizeof(*mvb) ); - /* This looks like it allocates a lot of memory, but it basically - * just sets an upper limit on how much can be used - nothing like - * this amount will ever be turned into 'real' memory. - */ - mvb->size = VB->Size * 5; + mvb->size = VB->Size * 2; mvb->vert_store = malloc( sizeof(i810Vertex) * mvb->size + 31); - if (!mvb->vert_store) - FatalError("i810-glx: out of memory !\n"); + if (!mvb->vert_store) { + fprintf(stderr, "i810-glx: out of memory !\n"); + exit(1); + } mvb->verts = (i810VertexPtr)(((unsigned long)mvb->vert_store + 31) & ~31); gl_vector1ui_alloc( &mvb->clipped_elements, VEC_WRITABLE, mvb->size, 32 ); - if (!mvb->clipped_elements.start) - FatalError("i810-glx: out of memory !\n"); - + if (!mvb->clipped_elements.start) { + fprintf(stderr, "i810-glx: out of memory !\n"); + exit(1); + } + free( VB->ClipMask ); VB->ClipMask = (GLubyte *)malloc(sizeof(GLubyte) * mvb->size); - if (!VB->ClipMask) - FatalError("i810-glx: out of memory !\n"); + if (!VB->ClipMask) { + fprintf(stderr, "i810-glx: out of memory !\n"); + exit(1); + } mvb->primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size ); mvb->next_primitive = (GLuint *)malloc( sizeof(GLuint) * mvb->size ); - if (!mvb->primitive || !mvb->next_primitive) - FatalError("i810-glx: out of memory!"); - + if (!mvb->primitive || !mvb->next_primitive) { + fprintf(stderr, "i810-glx: out of memory !\n"); + exit(1); + } + VB->driver_data = mvb; } diff --git a/xc/lib/GL/mesa/src/drv/i810/i810vb.h b/xc/lib/GL/mesa/src/drv/i810/i810vb.h index 640afa678..23685f106 100644 --- a/xc/lib/GL/mesa/src/drv/i810/i810vb.h +++ b/xc/lib/GL/mesa/src/drv/i810/i810vb.h @@ -26,7 +26,8 @@ #ifndef I810VB_INC #define I810VB_INC -#include "mesaglx/vb.h" +#include "vb.h" +#include "types.h" /* * color type for the vertex data @@ -56,15 +57,13 @@ typedef struct { /* Unfortunately only have assembly for 16-stride vertices. */ -struct i810_vertex_t { - union { - i810_vertex v; - float f[16]; - } v; +union i810_vertex_t { + i810_vertex v; + float f[16]; }; -typedef struct i810_vertex_t i810Vertex; -typedef struct i810_vertex_t *i810VertexPtr; +typedef union i810_vertex_t i810Vertex; +typedef union i810_vertex_t *i810VertexPtr; struct i810_vertex_buffer_t { GLvector1ui clipped_elements; @@ -79,7 +78,7 @@ struct i810_vertex_buffer_t { typedef struct i810_vertex_buffer_t *i810VertexBufferPtr; -#define I810_CONTEXT(ctx) ((i810ContextPtr)(((XSMesaContext)(ctx)->DriverCtx)->hw_ctx)) +#define I810_CONTEXT(ctx) ((i810ContextPtr)(ctx->DriverCtx)) #define I810_DRIVER_DATA(vb) ((i810VertexBufferPtr)((vb)->driver_data)) @@ -97,7 +96,7 @@ extern void i810PrintSetupFlags(char *msg, GLuint flags ); extern void i810DDDoRasterSetup( struct vertex_buffer *VB ); extern void i810DDPartialRasterSetup( struct vertex_buffer *VB ); extern void i810DDCheckPartialRasterSetup( GLcontext *ctx, - struct gl_pipeline_stage *d ); + struct gl_pipeline_stage *d ); extern void i810DDViewport( GLcontext *ctx, GLint x, GLint y, diff --git a/xc/lib/GL/mesa/src/drv/mga/Imakefile b/xc/lib/GL/mesa/src/drv/mga/Imakefile index e4e39b747..1ca3bde8a 100644 --- a/xc/lib/GL/mesa/src/drv/mga/Imakefile +++ b/xc/lib/GL/mesa/src/drv/mga/Imakefile @@ -1,4 +1,6 @@ +#include <Threads.tmpl> + #define DoNormalLib NormalLibGlx #define DoSharedLib SharedLibGlx #define DoExtraLib SharedLibGlx @@ -12,6 +14,7 @@ ALLOC_DEFINES = -DMALLOC_0_RETURNS_NULL #if BuildXF86DRI DRI_DEFINES = GlxDefines -DDRIVERTS DRI_INCLUDES = -I../../../../dri -I../../../../glx \ + -I../../../dri \ -I$(TOP)/include -I$(TOP)/include/GL \ -I$(XF86OSSRC) -I$(SERVERSRC)/GL/dri \ -I$(XF86DRIVERSRC)/mga \ @@ -24,23 +27,244 @@ MESA_INCLUDES = -I. -I.. -I../../include DEFINES = $(ALLOC_DEFINES) $(DRI_DEFINES) - INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) $(MESA_INCLUDES) $(DRI_INCLUDES) \ - -I/usr/include/glide - DRISRCS = mgaclear.c mgacnvtex.c mgadd.c mgadepth.c \ + INCLUDES = -I$(XLIBSRC) -I$(EXTINCSRC) $(MESA_INCLUDES) $(DRI_INCLUDES) + +#if 0 + LOSRC = ../../../../lowpc.c + LOOBJ = ../../../../lowpc.o + + HISRC = ../../../../highpc.c + HIOBJ = ../../../../highpc.o +#endif + + DRISRCS = ../../../dri/dri_mesa.c \ + ../../../../dri/dri_tmm.c + + DRIOBJS = ../../../dri/dri_mesa.o \ + ../../../../dri/dri_tmm.o + + DRMSRCS = ../../../../dri/drm/xf86drm.c \ + ../../../../dri/drm/xf86drmHash.c \ + ../../../../dri/drm/xf86drmRandom.c \ + ../../../../dri/drm/xf86drmSL.c + + DRMOBJS = ../../../../dri/drm/xf86drm.o \ + ../../../../dri/drm/xf86drmHash.o \ + ../../../../dri/drm/xf86drmRandom.o \ + ../../../../dri/drm/xf86drmSL.o + + + MGASRCS = mgaclear.c mgacnvtex.c mgadd.c \ mgafastpath.c \ mgapipeline.c \ mgaspan.c mgastate.c mgatex.c \ - mgatris.c mgavb.c mgaioctl.c mga_xmesa.c + mgatris.c mgavb.c mgaioctl.c mga_xmesa.c mgabuffers.c - DRIOBJS = mgaclear.o mgacnvtex.o mgadd.o mgadepth.o \ + MGAOBJS = mgaclear.o mgacnvtex.o mgadd.o \ mgafastpath.o \ mgapipeline.o \ mgaspan.o mgastate.o mgatex.o \ - mgatris.o mgavb.o mgaioctl.o mga_xmesa.o + mgatris.o mgavb.o mgaioctl.o mga_xmesa.o mgabuffers.o + + MESASRCS = ../../accum.c \ + ../../alpha.c \ + ../../alphabuf.c \ + ../../attrib.c \ + ../../bbox.c \ + ../../bitmap.c \ + ../../blend.c \ + ../../buffers.c \ + ../../clip.c \ + ../../colortab.c \ + ../../config.c \ + ../../context.c \ + ../../copypix.c \ + ../../cva.c \ + ../../debug_xform.c \ + ../../depth.c \ + ../../dlist.c \ + ../../drawpix.c \ + ../../enable.c \ + ../../enums.c \ + ../../eval.c \ + ../../extensions.c \ + ../../feedback.c \ + ../../fog.c \ + ../../get.c \ + ../../glapi.c \ + ../../glapinoop.c \ + ../../glthread.c \ + ../../hash.c \ + ../../image.c \ + ../../imaging.o \ + ../../light.c \ + ../../lines.c \ + ../../logic.c \ + ../../masking.c \ + ../../matrix.c \ + ../../mem.c \ + ../../mmath.c \ + ../../pb.c \ + ../../pipeline.c \ + ../../pixel.c \ + ../../points.c \ + ../../polygon.c \ + ../../quads.c \ + ../../rastpos.c \ + ../../readpix.c \ + ../../rect.c \ + ../../scissor.c \ + ../../shade.c \ + ../../span.c \ + ../../stages.c \ + ../../state.c \ + ../../stencil.c \ + ../../teximage.c \ + ../../texobj.c \ + ../../texstate.c \ + ../../texture.c \ + ../../translate.c \ + ../../triangle.c \ + ../../varray.c \ + ../../vb.c \ + ../../vbcull.c \ + ../../vbfill.c \ + ../../vbindirect.c \ + ../../vbrender.c \ + ../../vbxform.c \ + ../../vector.c \ + ../../vertices.c \ + ../../winpos.c \ + ../../xform.c \ + ../../zoom.c \ + ../../X86/common_x86.c + + MESAOBJS = ../../accum.o \ + ../../alpha.o \ + ../../alphabuf.o \ + ../../attrib.o \ + ../../bbox.o \ + ../../bitmap.o \ + ../../blend.o \ + ../../buffers.o \ + ../../clip.o \ + ../../colortab.o \ + ../../config.o \ + ../../context.o \ + ../../copypix.o \ + ../../cva.o \ + ../../debug_xform.o \ + ../../depth.o \ + ../../dlist.o \ + ../../drawpix.o \ + ../../enable.o \ + ../../enums.o \ + ../../eval.o \ + ../../extensions.o \ + ../../feedback.o \ + ../../fog.o \ + ../../get.o \ + ../../hash.o \ + ../../hint.o \ + ../../image.o \ + ../../imaging.o \ + ../../light.o \ + ../../lines.o \ + ../../logic.o \ + ../../masking.o \ + ../../matrix.o \ + ../../mem.o \ + ../../mmath.o \ + ../../pb.o \ + ../../pipeline.o \ + ../../pixel.o \ + ../../points.o \ + ../../polygon.o \ + ../../quads.o \ + ../../rastpos.o \ + ../../readpix.o \ + ../../rect.o \ + ../../scissor.o \ + ../../shade.o \ + ../../span.o \ + ../../stages.o \ + ../../state.o \ + ../../stencil.o \ + ../../teximage.o \ + ../../texobj.o \ + ../../texstate.o \ + ../../texture.o \ + ../../translate.o \ + ../../triangle.o \ + ../../varray.o \ + ../../vb.o \ + ../../vbcull.o \ + ../../vbfill.o \ + ../../vbindirect.o \ + ../../vbrender.o \ + ../../vbxform.o \ + ../../vector.o \ + ../../vertices.o \ + ../../winpos.o \ + ../../xform.o \ + ../../zoom.o + +#ifdef i386Architecture + X86_SRCS = ../../X86/x86.c \ + ../../X86/x86a.S \ + ../../X86/common_x86.c \ + ../../X86/common_x86asm.S \ + ../../X86/vertex.S + + X86_OBJS = ../../X86/x86.o \ + ../../X86/x86a.o \ + ../../X86/common_x86.o \ + ../../X86/common_x86asm.o \ + ../../X86/vertex.o + + MMX_SRCS = ../../X86/mmx_blend.S + + MMX_OBJS = ../../X86/mmx_blend.o + +XCOMM Disabling 3Dnow code for the time being. +#if 0 + 3DNOW_SRCS = ../../X86/3dnow.c \ + ../../X86/3dnow_norm_raw.S \ + ../../X86/3dnow_xform_masked1.S \ + ../../X86/3dnow_xform_masked2.S \ + ../../X86/3dnow_xform_masked3.S \ + ../../X86/3dnow_xform_masked4.S \ + ../../X86/3dnow_xform_raw1.S \ + ../../X86/3dnow_xform_raw2.S \ + ../../X86/3dnow_xform_raw3.S \ + ../../X86/3dnow_xform_raw4.S \ + ../../X86/vertex_3dnow.S + + 3DNOW_OBJS = ../../X86/3dnow.o \ + ../../X86/3dnow_norm_raw.o \ + ../../X86/3dnow_xform_masked1.o \ + ../../X86/3dnow_xform_masked2.o \ + ../../X86/3dnow_xform_masked3.o \ + ../../X86/3dnow_xform_masked4.o \ + ../../X86/3dnow_xform_raw1.o \ + ../../X86/3dnow_xform_raw2.o \ + ../../X86/3dnow_xform_raw3.o \ + ../../X86/3dnow_xform_raw4.o \ + ../../X86/vertex_3dnow.o +#endif + +#endif + + ASMSRCS = $(X86_SRCS) $(MMX_SRCS) $(3DNOW_SRCS) + ASMOBJS = $(X86_OBJS) $(MMX_OBJS) $(3DNOW_OBJS) + + COMMONSRCS = ../common/mm.c ../common/hwlog.c + COMMONOBJS = ../common/mm.o ../common/hwlog.o + SRCS = $(LOWSRC) $(DRISRCS) $(DRMSRCS) $(MESASRCS) $(ASMSRCS) $(COMMONSRCS) $(MGASRCS) $(HISRC) + OBJS = $(LOWOBJ) $(DRIOBJS) $(DRMOBJS) $(MESAOBJS) $(ASMOBJS) $(COMMONOBJS) $(MGAOBJS) $(HIOBJ) - SRCS = $(DRISRCS) - OBJS = $(DRIOBJS) +REQUIREDLIBS += -lm #if !GlxUseBuiltInDRIDriver #undef DoNormalLib NormalLibGlx @@ -61,7 +285,7 @@ LIBNAME = mga_dri.so ALL_OBJS = $(OBJS) ALL_DEPS = DONE SharedDepModuleTarget($(LIBNAME),$(ALL_DEPS),$(ALL_OBJS)) -InstallDynamicModule($(LIBNAME),$(MODULEDIR),.) +InstallDynamicModule($(LIBNAME),$(MODULEDIR)/dri,.) #endif DependTarget() diff --git a/xc/lib/GL/mesa/src/drv/mga/mga_xmesa.c b/xc/lib/GL/mesa/src/drv/mga/mga_xmesa.c index 496c29a05..996dc3819 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mga_xmesa.c +++ b/xc/lib/GL/mesa/src/drv/mga/mga_xmesa.c @@ -27,7 +27,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. /* * Authors: - * Daryll Strauss <daryll@precisioninsight.com> + * Keith Whitwell <keithw@precisioninsight.com> * */ @@ -36,6 +36,7 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include <X11/Xlibint.h> #include <stdio.h> +#include "drm.h" #include "mga_xmesa.h" #include "context.h" #include "vbxform.h" @@ -49,20 +50,25 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include "mgadepth.h" #include "mgatris.h" #include "mgapipeline.h" +#include "mgabuffers.h" #include "xf86dri.h" -#include "mga_dri.h" -#include "mga_drm_public.h" #include "mga_xmesa.h" +#include "mga_dri.h" + #ifndef MGA_DEBUG int MGA_DEBUG = (0 -/* | MGA_DEBUG_ALWAYS_SYNC */ -/* | MGA_DEBUG_VERBOSE_MSG */ +/* | DEBUG_ALWAYS_SYNC */ +/* | DEBUG_VERBOSE_MSG */ +/* | DEBUG_VERBOSE_LRU */ +/* | DEBUG_VERBOSE_DRI */ +/* | DEBUG_VERBOSE_IOCTL */ +/* | DEBUG_VERBOSE_2D */ ); #endif @@ -107,7 +113,10 @@ static int count_bits(unsigned int n) GLboolean XMesaInitDriver(__DRIscreenPrivate *sPriv) { mgaScreenPrivate *mgaScreen; - MGADRIPtr gDRIPriv = (MGADRIPtr)sPriv->pDevPriv; + MGADRIPtr serverInfo = (MGADRIPtr)sPriv->pDevPriv; + + + fprintf(stderr, "XMesaInitDriver\n"); /* Allocate the private area */ mgaScreen = (mgaScreenPrivate *)Xmalloc(sizeof(mgaScreenPrivate)); @@ -116,20 +125,68 @@ GLboolean XMesaInitDriver(__DRIscreenPrivate *sPriv) mgaScreen->sPriv = sPriv; sPriv->private = (void *)mgaScreen; - mgaScreen->chipset=gDRIPriv->chipset; - mgaScreen->width=gDRIPriv->width; - mgaScreen->height=gDRIPriv->height; - mgaScreen->mem=gDRIPriv->mem; - mgaScreen->cpp=gDRIPriv->cpp; - mgaScreen->frontPitch=gDRIPriv->frontPitch; - mgaScreen->frontOffset=gDRIPriv->frontOffset; - mgaScreen->backOffset=gDRIPriv->backOffset; - mgaScreen->backPitch = gDRIPriv->backPitch; - mgaScreen->depthOffset=gDRIPriv->depthOffset; - mgaScreen->depthPitch = gDRIPriv->depthPitch; - mgaScreen->textureOffset=gDRIPriv->textureOffset; - mgaScreen->textureSize=gDRIPriv->textureSize; - mgaScreen->logTextureGranularity = gDRIPriv->logTextureGranularity; + fprintf(stderr, "serverInfo->chipset: %d\n", serverInfo->chipset); + + if (serverInfo->chipset != MGA_CARD_TYPE_G200 && + serverInfo->chipset != MGA_CARD_TYPE_G400) + return GL_FALSE; + + mgaScreen->chipset = serverInfo->chipset; + mgaScreen->width = serverInfo->width; + mgaScreen->height = serverInfo->height; + mgaScreen->mem = serverInfo->mem; + mgaScreen->cpp = serverInfo->cpp; + mgaScreen->frontPitch = serverInfo->frontPitch; + mgaScreen->frontOffset = serverInfo->frontOffset; + mgaScreen->backOffset = serverInfo->backOffset; + mgaScreen->backPitch = serverInfo->backPitch; + mgaScreen->depthOffset = serverInfo->depthOffset; + mgaScreen->depthPitch = serverInfo->depthPitch; + + + mgaScreen->agp_tex.handle = serverInfo->agp; + mgaScreen->agp_tex.size = serverInfo->agpSize; + + if (drmMap(sPriv->fd, + mgaScreen->agp_tex.handle, + mgaScreen->agp_tex.size, + (drmAddress *)&mgaScreen->agp_tex.map) != 0) + { + Xfree(mgaScreen); + return GL_FALSE; + } + + + + mgaScreen->textureOffset[MGA_CARD_HEAP] = serverInfo->textureOffset; + mgaScreen->textureOffset[MGA_AGP_HEAP] = (mgaScreen->agp_tex.handle | + PDEA_pagpxfer_enable | 1); + + fprintf(stderr, "CARD texture size %x, granul %d --> %x\n", + serverInfo->textureSize, serverInfo->logTextureGranularity, + 1<<serverInfo->logTextureGranularity); + + mgaScreen->textureSize[MGA_CARD_HEAP] = serverInfo->textureSize; + mgaScreen->textureSize[MGA_AGP_HEAP] = serverInfo->agpTextureSize; + + mgaScreen->logTextureGranularity[MGA_CARD_HEAP] = + serverInfo->logTextureGranularity; + mgaScreen->logTextureGranularity[MGA_AGP_HEAP] = + serverInfo->logAgpTextureGranularity; + + mgaScreen->texVirtual[MGA_CARD_HEAP] = (mgaScreen->sPriv->pFB + + mgaScreen->textureOffset[0]); + mgaScreen->texVirtual[MGA_AGP_HEAP] = mgaScreen->agp_tex.map; + + mgaScreen->mAccess = serverInfo->mAccess; + + + fprintf(stderr, "\n\n\nbackOffset: %x pitch %x\n", + mgaScreen->backOffset, + mgaScreen->backPitch); + + + mgaScreen->Attrib = MGA_PF_565; mgaScreen->bufs = drmMapBufs(sPriv->fd); @@ -169,6 +226,8 @@ XMesaVisual XMesaCreateVisual(XMesaDisplay *display, { XMesaVisual v; + fprintf(stderr, "XMesaCreateVisual\n"); + /* Only RGB visuals are supported on the MGA boards */ if (!rgb_flag) return 0; @@ -183,28 +242,19 @@ XMesaVisual XMesaCreateVisual(XMesaDisplay *display, memcpy(v->visinfo, visinfo, sizeof(*visinfo)); v->display = display; - v->level = level; - - v->gl_visual = (GLvisual *)Xmalloc(sizeof(GLvisual)); + v->level = level; + v->gl_visual = gl_create_visual(rgb_flag, GL_FALSE, db_flag, stereo_flag, + depth_size, stencil_size, accum_size, 0, + count_bits(visinfo->red_mask), + count_bits(visinfo->green_mask), + count_bits(visinfo->blue_mask), + GL_FALSE); if (!v->gl_visual) { Xfree(v->visinfo); - XFree(v); - return 0; + Xfree(v); + return NULL; } - v->gl_visual->RGBAflag = rgb_flag; - v->gl_visual->DBflag = db_flag; - v->gl_visual->StereoFlag = stereo_flag; - - v->gl_visual->RedBits = count_bits(visinfo->red_mask); - v->gl_visual->GreenBits = count_bits(visinfo->green_mask); - v->gl_visual->BlueBits = count_bits(visinfo->blue_mask); - v->gl_visual->AlphaBits = 0; /* Not currently supported */ - - v->gl_visual->AccumBits = accum_size; - v->gl_visual->DepthBits = depth_size; - v->gl_visual->StencilBits = stencil_size; - return v; } @@ -218,6 +268,7 @@ void XMesaDestroyVisual(XMesaVisual v) XMesaContext XMesaCreateContext(XMesaVisual v, XMesaContext share_list, __DRIcontextPrivate *driContextPriv) { + int i; GLcontext *ctx; XMesaContext c; mgaContextPtr mmesa; @@ -227,12 +278,15 @@ XMesaContext XMesaCreateContext(XMesaVisual v, XMesaContext share_list, sizeof(XF86DRISAREARec)); GLcontext *shareCtx = 0; + fprintf(stderr, "XMesaCreateContext\n"); + + c = (XMesaContext)Xmalloc(sizeof(struct xmesa_context)); if (!c) { return 0; } - mmesa = (mgaContextPtr)Xmalloc(sizeof(mgaContext)); + mmesa = (mgaContextPtr)Xcalloc(sizeof(mgaContext), 1); if (!mmesa) { Xfree(c); return 0; @@ -250,8 +304,6 @@ XMesaContext XMesaCreateContext(XMesaVisual v, XMesaContext share_list, ctx = mmesa->glCtx = gl_create_context(v->gl_visual, shareCtx, (void*)mmesa, GL_TRUE); - /* Dri stuff - */ mmesa->display = v->display; mmesa->hHWContext = driContextPriv->hHWContext; mmesa->driFd = sPriv->fd; @@ -261,40 +313,45 @@ XMesaContext XMesaCreateContext(XMesaVisual v, XMesaContext share_list, mmesa->driScreen = sPriv; mmesa->sarea = saPriv; - mmesa->glBuffer=gl_create_framebuffer(v->gl_visual); + mmesa->glBuffer=gl_create_framebuffer(v->gl_visual, + GL_FALSE, /* software depth buffer? */ + v->gl_visual->StencilBits > 0, + v->gl_visual->AccumBits > 0, + v->gl_visual->AlphaBits > 0); + + make_empty_list(&mmesa->SwappedOut); - mmesa->needClip=1; + mmesa->lastTexHeap = mgaScreen->texVirtual[MGA_AGP_HEAP] ? 2 : 1; - mmesa->texHeap = mmInit( 0, mgaScreen->textureSize ); + for (i = 0 ; i < mmesa->lastTexHeap ; i++) { + mmesa->texHeap[i] = mmInit( 0, mgaScreen->textureSize[i]); + make_empty_list(&mmesa->TexObjList[i]); + } - /* Utah stuff - */ mmesa->renderindex = -1; /* impossible value */ mmesa->new_state = ~0; mmesa->dirty = ~0; - - mmesa->warp_pipe = 0; - - - make_empty_list(&mmesa->SwappedOut); - make_empty_list(&mmesa->TexObjList); - + mmesa->warp_pipe = 0; mmesa->CurrentTexObj[0] = 0; mmesa->CurrentTexObj[1] = 0; + mmesa->texAge[0] = 0; + mmesa->texAge[1] = 0; + + mgaDDExtensionsInit( ctx ); mgaDDInitStateFuncs( ctx ); mgaDDInitTextureFuncs( ctx ); mgaDDInitSpanFuncs( ctx ); - mgaDDInitDepthFuncs( ctx ); mgaDDInitDriverFuncs( ctx ); mgaDDInitIoctlFuncs( ctx ); ctx->Driver.TriangleCaps = (DD_TRI_CULL| DD_TRI_LIGHT_TWOSIDE| + DD_TRI_STIPPLE| DD_TRI_OFFSET); /* Ask mesa to clip fog coordinates for us. @@ -312,6 +369,9 @@ XMesaContext XMesaCreateContext(XMesaVisual v, XMesaContext share_list, mgaDDRegisterPipelineStages(ctx->PipelineStage, ctx->PipelineStage, ctx->NrPipelineStages); + + mgaInitState( mmesa ); + return c; } @@ -364,59 +424,12 @@ void XMesaSwapBuffers(XMesaBuffer bogus_value_do_not_use) - -void mgaXMesaSetFrontClipRects( mgaContextPtr mmesa ) +GLboolean XMesaUnbindContext(XMesaContext c) { - __DRIdrawablePrivate *dPriv = mmesa->driDrawable; - - mmesa->numClipRects = dPriv->numClipRects; - mmesa->pClipRects = dPriv->pClipRects; - mmesa->drawX = dPriv->x; - mmesa->drawY = dPriv->y; - - mmesa->drawOffset = mmesa->mgaScreen->frontOffset; -} - - -void mgaXMesaSetBackClipRects( mgaContextPtr mmesa ) -{ - __DRIdrawablePrivate *dPriv = mmesa->driDrawable; - - if (dPriv->numAuxClipRects == 0) - { - mmesa->numClipRects = dPriv->numClipRects; - mmesa->pClipRects = dPriv->pClipRects; - mmesa->drawX = dPriv->x; - mmesa->drawY = dPriv->y; - } else { - mmesa->numClipRects = dPriv->numAuxClipRects; - mmesa->pClipRects = dPriv->pAuxClipRects; - mmesa->drawX = dPriv->auxX; - mmesa->drawY = dPriv->auxY; - } - - mmesa->drawOffset = mmesa->mgaScreen->backOffset; -} - - -static void mgaXMesaWindowMoved( mgaContextPtr mmesa ) -{ - /* Clear any contaminated CVA data. - */ - mmesa->setupdone = 0; - - switch (mmesa->glCtx->Color.DriverDrawBuffer) { - case GL_FRONT_LEFT: - mgaXMesaSetFrontClipRects( mmesa ); - break; - case GL_BACK_LEFT: - mgaXMesaSetBackClipRects( mmesa ); - break; - default: - fprintf(stderr, "fallback buffer\n"); - break; - } + if (c->private) + ((mgaContextPtr)c->private)->dirty = ~0; + return GL_TRUE; } @@ -439,9 +452,9 @@ GLboolean XMesaMakeCurrent(XMesaContext c, XMesaBuffer b) gl_make_current(mgaCtx->glCtx, mgaCtx->glBuffer); - mgaXMesaWindowMoved( mgaCtx ); mgaCtx->driDrawable = dPriv; mgaCtx->dirty = ~0; + mgaCtx->dirty_cliprects = (MGA_FRONT|MGA_BACK); if (!mgaCtx->glCtx->Viewport.Width) gl_Viewport(mgaCtx->glCtx, 0, 0, dPriv->w, dPriv->h); @@ -455,54 +468,36 @@ GLboolean XMesaMakeCurrent(XMesaContext c, XMesaBuffer b) } -void mgaXMesaUpdateState( mgaContextPtr mmesa ) +void mgaGetLock( mgaContextPtr mmesa, GLuint flags ) { __DRIdrawablePrivate *dPriv = mmesa->driDrawable; - __DRIscreenPrivate *sPriv = mmesa->driScreen; drm_mga_sarea_t *sarea = mmesa->sarea; - int me = mmesa->hHWContext; - int stamp = dPriv->lastStamp; + int i; - /* If the window moved, may need to set a new cliprect now. - * - * NOTE: This releases and regains the hw lock, so all state - * checking must be done *after* this call: - */ - XMESA_VALIDATE_DRAWABLE_INFO(mmesa->display, sPriv, dPriv); + drmGetLock(mmesa->driFd, mmesa->hHWContext, flags); - if (sarea->ctxOwner != me) { - mmesa->dirty |= MGA_UPLOAD_CTX; + if (*(dPriv->pStamp) != dPriv->lastStamp) { + mmesa->setupdone = 0; + mmesa->dirty_cliprects = (MGA_FRONT|MGA_BACK); + mgaUpdateRects( mmesa, (MGA_FRONT|MGA_BACK) ); } - if (sarea->texAge != mmesa->texAge) { - int sz = 1 << (mmesa->mgaScreen->logTextureGranularity); - int idx, nr = 0; - - /* Have to go right round from the back to ensure stuff ends up - * LRU in our local list... - */ - for (idx = sarea->texList[MGA_NR_TEX_REGIONS].prev ; - idx != MGA_NR_TEX_REGIONS && nr < MGA_NR_TEX_REGIONS ; - idx = sarea->texList[idx].prev, nr++) - { - if (sarea->texList[idx].age > mmesa->texAge) - mgaTexturesGone(mmesa, idx * sz, sz, 1); - } - - if (nr == MGA_NR_TEX_REGIONS) { - mgaTexturesGone(mmesa, 0, mmesa->mgaScreen->textureSize, 0); - mgaResetGlobalLRU( mmesa ); - } - - mmesa->texAge = sarea->texAge; - mmesa->dirty |= MGA_UPLOAD_TEX0IMAGE | MGA_UPLOAD_TEX1IMAGE; + mmesa->dirty |= MGA_UPLOAD_CTX | MGA_UPLOAD_CLIPRECTS; + + mmesa->sarea->dirty |= MGA_UPLOAD_CTX; + + if (sarea->ctxOwner != me) { + mmesa->dirty |= (MGA_UPLOAD_CTX | MGA_UPLOAD_TEX0 | + MGA_UPLOAD_TEX1 | MGA_UPLOAD_PIPE); + sarea->ctxOwner=me; } - if (dPriv->lastStamp != stamp) - mgaXMesaWindowMoved( mmesa ); + for (i = 0 ; i < mmesa->lastTexHeap ; i++) + if (sarea->texAge[i] != mmesa->texAge[i]) + mgaAgeTextures( mmesa, i ); - sarea->ctxOwner=me; + sarea->last_quiescent = -1; /* just kill it for now */ } diff --git a/xc/lib/GL/mesa/src/drv/mga/mga_xmesa.h b/xc/lib/GL/mesa/src/drv/mga/mga_xmesa.h index d563bd429..1379f48d9 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mga_xmesa.h +++ b/xc/lib/GL/mesa/src/drv/mga/mga_xmesa.h @@ -28,7 +28,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. /* * Authors: * Keith Whitwell <keithw@precisioninsight.com> - * Daryll Strauss <daryll@precisioninsight.com> (Origninal tdfx driver). * */ @@ -43,6 +42,13 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include "dri_mesa.h" #include "types.h" #include "xmesaP.h" +#include "mgaregs.h" + +typedef struct { + drmHandle handle; + drmSize size; + char *map; +} mgaRegion, *mgaRegionPtr; typedef struct { @@ -54,6 +60,7 @@ typedef struct { int cpp; /* for front and back buffers */ int Attrib; + int mAccess; int frontOffset; int frontPitch; @@ -64,43 +71,54 @@ typedef struct { int depthPitch; int depthCpp; - int textureOffset; - int textureSize; - int logTextureGranularity; + int textureOffset[MGA_NR_TEX_HEAPS]; + int textureSize[MGA_NR_TEX_HEAPS]; + int logTextureGranularity[MGA_NR_TEX_HEAPS]; + char *texVirtual[MGA_NR_TEX_HEAPS]; + __DRIscreenPrivate *sPriv; drmBufMapPtr bufs; + mgaRegion agp_tex; + } mgaScreenPrivate; #include "mgalib.h" -extern void mgaXMesaUpdateState( mgaContextPtr mmesa ); +extern void mgaGetLock( mgaContextPtr mmesa, GLuint flags ); extern void mgaEmitHwStateLocked( mgaContextPtr mmesa ); extern void mgaEmitScissorValues( mgaContextPtr mmesa, int box_nr, int emit ); -extern void mgaXMesaSetBackClipRects( mgaContextPtr mmesa ); -extern void mgaXMesaSetFrontClipRects( mgaContextPtr mmesa ); + +#define GET_DISPATCH_AGE( mmesa ) mmesa->sarea->last_dispatch +#define GET_ENQUEUE_AGE( mmesa ) mmesa->sarea->last_enqueue /* Lock the hardware and validate our state. */ -#define LOCK_HARDWARE( mmesa ) \ - do { \ - char __ret=0; \ - DRM_CAS(mmesa->driHwLock, mmesa->hHWContext, \ - (DRM_LOCK_HELD|mmesa->hHWContext), __ret); \ - if (__ret) { \ - drmGetLock(mmesa->driFd, mmesa->hHWContext, 0); \ - mgaXMesaUpdateState( mmesa ); \ - } \ +#define LOCK_HARDWARE( mmesa ) \ + do { \ + char __ret=0; \ + DRM_CAS(mmesa->driHwLock, mmesa->hHWContext, \ + (DRM_LOCK_HELD|mmesa->hHWContext), __ret); \ + if (__ret) \ + mgaGetLock( mmesa, 0 ); \ } while (0) +/* + */ +#define LOCK_HARDWARE_QUIESCENT( mmesa ) do { \ + LOCK_HARDWARE( mmesa ); \ + mgaUpdateLock( mmesa, DRM_LOCK_QUIESCENT | DRM_LOCK_FLUSH ); \ +} while (0) + + /* Unlock the hardware using the global current context */ -#define UNLOCK_HARDWARE(mmesa) \ +#define UNLOCK_HARDWARE(mmesa) \ DRM_UNLOCK(mmesa->driFd, mmesa->driHwLock, mmesa->hHWContext); @@ -109,6 +127,8 @@ extern void mgaXMesaSetFrontClipRects( mgaContextPtr mmesa ); #define REFRESH_DRAWABLE_INFO( mmesa ) \ do { \ LOCK_HARDWARE( mmesa ); \ + mmesa->lastX = mmesa->drawX; \ + mmesa->lastY = mmesa->drawY; \ UNLOCK_HARDWARE( mmesa ); \ } while (0) diff --git a/xc/lib/GL/mesa/src/drv/mga/mgabuffers.c b/xc/lib/GL/mesa/src/drv/mga/mgabuffers.c new file mode 100644 index 000000000..276c5df85 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/mga/mgabuffers.c @@ -0,0 +1,315 @@ +/************************************************************************** + +Copyright 1998-1999 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 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 PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +**************************************************************************/ + +/* + * Authors: + * Keith Whitwell <keithw@precisioninsight.com> + * + * $PI: $ + */ + +#include <stdio.h> +#include "mgalib.h" +#include "mgabuffers.h" +#include "mgastate.h" + +static void mgaXMesaSetFrontClipRects( mgaContextPtr mmesa ) +{ + __DRIdrawablePrivate *driDrawable = mmesa->driDrawable; + + mmesa->numClipRects = driDrawable->numClipRects; + mmesa->pClipRects = driDrawable->pClipRects; + mmesa->drawX = driDrawable->x; + mmesa->drawY = driDrawable->y; + + mmesa->drawOffset = mmesa->mgaScreen->frontOffset; + mmesa->Setup[MGA_CTXREG_DSTORG] = mmesa->drawOffset; + mmesa->dirty |= MGA_UPLOAD_CTX; + mmesa->dirty |= MGA_UPLOAD_CLIPRECTS; +} + + +static void mgaXMesaSetBackClipRects( mgaContextPtr mmesa ) +{ + __DRIdrawablePrivate *driDrawable = mmesa->driDrawable; + + if (driDrawable->numBackClipRects == 0) + { + mmesa->numClipRects = driDrawable->numClipRects; + mmesa->pClipRects = driDrawable->pClipRects; + mmesa->drawX = driDrawable->x; + mmesa->drawY = driDrawable->y; + } else { + mmesa->numClipRects = driDrawable->numBackClipRects; + mmesa->pClipRects = driDrawable->pBackClipRects; + mmesa->drawX = driDrawable->backX; + mmesa->drawY = driDrawable->backY; + } + + mmesa->drawOffset = mmesa->mgaScreen->backOffset; + mmesa->Setup[MGA_CTXREG_DSTORG] = mmesa->drawOffset; + + mmesa->dirty |= MGA_UPLOAD_CTX; + mmesa->dirty |= MGA_UPLOAD_CLIPRECTS; +} + + + +static void mgaUpdateRectsFromSarea( mgaContextPtr mmesa ) +{ + __DRIdrawablePrivate *driDrawable = mmesa->driDrawable; + __DRIscreenPrivate *driScreen = mmesa->driScreen; + drm_mga_sarea_t *sarea = mmesa->sarea; + int i = 0, top = 0; + + + if (sarea->exported_buffers & MGA_BACK) { + XF86DRIClipRectPtr boxes = + (XF86DRIClipRectPtr)malloc( sarea->exported_nback * sizeof(*boxes) ); + + if (driDrawable->pBackClipRects) + free(driDrawable->pBackClipRects); + + driDrawable->numBackClipRects = sarea->exported_nback; + driDrawable->pBackClipRects = boxes; + + top = sarea->exported_nback; + for (i = 0 ; i < top ; i++) + boxes[i] = *(XF86DRIClipRectPtr)&(sarea->exported_boxes[i]); + } + + + if (sarea->exported_buffers & MGA_FRONT) + { + int start = top; + XF86DRIClipRectPtr boxes = + (XF86DRIClipRectPtr)malloc( sarea->exported_nfront * sizeof(*boxes) ); + + if (driDrawable->pClipRects) + free(driDrawable->pClipRects); + + driDrawable->numClipRects = sarea->exported_nfront; + driDrawable->pClipRects = boxes; + + top += sarea->exported_nfront; + for ( ; i < top ; i++) + boxes[i-start] = *(XF86DRIClipRectPtr)&(sarea->exported_boxes[i]); + + } + + + + driDrawable->index = sarea->exported_index; + driDrawable->lastStamp = sarea->exported_stamp; + driDrawable->x = sarea->exported_front_x; + driDrawable->y = sarea->exported_front_y; + driDrawable->backX = sarea->exported_back_x; + driDrawable->backY = sarea->exported_back_y; + driDrawable->w = sarea->exported_w; + driDrawable->h = sarea->exported_h; + driDrawable->pStamp = + &(driScreen->pSAREA->drawableTable[driDrawable->index].stamp); + + mmesa->dirty_cliprects = (MGA_FRONT|MGA_BACK) & ~(sarea->exported_buffers); +} + + + +static void printSareaRects( mgaContextPtr mmesa ) +{ + __DRIscreenPrivate *driScreen = mmesa->driScreen; + drm_mga_sarea_t *sarea = mmesa->sarea; + int i; + + fprintf(stderr, "sarea->exported: %d\n", sarea->exported_drawable); + fprintf(stderr, "sarea->exported_index: %d\n", sarea->exported_index); + fprintf(stderr, "sarea->exported_stamp: %d\n", sarea->exported_stamp); + fprintf(stderr, "sarea->exported_front_x: %d\n", sarea->exported_front_x); + fprintf(stderr, "sarea->exported_front_y: %d\n", sarea->exported_front_y); + fprintf(stderr, "sarea->exported_back_x: %d\n", sarea->exported_back_x); + fprintf(stderr, "sarea->exported_back_y: %d\n", sarea->exported_back_y); + fprintf(stderr, "sarea->exported_w: %d\n", sarea->exported_w); + fprintf(stderr, "sarea->exported_h: %d\n", sarea->exported_h); + fprintf(stderr, "sarea->exported_buffers: %d\n", sarea->exported_buffers); + fprintf(stderr, "sarea->exported_nfront: %d\n", sarea->exported_nfront); + fprintf(stderr, "sarea->exported_nback: %d\n", sarea->exported_nback); + + i = 0; + if (sarea->exported_buffers & MGA_BACK) + for ( ; i < sarea->exported_nback ; i++) + fprintf(stderr, "back %d: %d,%d-%d,%d\n", i, + sarea->exported_boxes[i].x1, sarea->exported_boxes[i].y1, + sarea->exported_boxes[i].x2, sarea->exported_boxes[i].y2); + + if (sarea->exported_buffers & MGA_FRONT) { + int start = i; + int top = i + sarea->exported_nfront; + for ( ; i < top ; i++) + fprintf(stderr, "front %d: %d,%d-%d,%d\n", + i - start, + sarea->exported_boxes[i].x1, sarea->exported_boxes[i].y1, + sarea->exported_boxes[i].x2, sarea->exported_boxes[i].y2); + } + + fprintf(stderr, "drawableTable[%d].stamp: %d\n", + sarea->exported_index, + driScreen->pSAREA->drawableTable[sarea->exported_index].stamp); +} + +static void printMmesaRects( mgaContextPtr mmesa ) +{ + __DRIscreenPrivate *driScreen = mmesa->driScreen; + __DRIdrawablePrivate *driDrawable = mmesa->driDrawable; + int nr = mmesa->numClipRects; + int i; + + fprintf(stderr, "driDrawable->draw: %ld\n", driDrawable->draw); + fprintf(stderr, "driDrawable->index: %d\n", driDrawable->index); + fprintf(stderr, "driDrawable->lastStamp: %d\n", driDrawable->lastStamp); + fprintf(stderr, "mmesa->drawX: %d\n", mmesa->drawX); + fprintf(stderr, "mmesa->drawY: %d\n", mmesa->drawY); + fprintf(stderr, "driDrawable->w: %d\n", driDrawable->w); + fprintf(stderr, "driDrawable->h: %d\n", driDrawable->h); + + for (i = 0 ; i < nr ; i++) + fprintf(stderr, "box %d: %d,%d-%d,%d\n", i, + mmesa->pClipRects[i].x1, mmesa->pClipRects[i].y1, + mmesa->pClipRects[i].x2, mmesa->pClipRects[i].y2); + + fprintf(stderr, "mmesa->draw_buffer: %d\n", mmesa->draw_buffer); + fprintf(stderr, "drawableTable[%d].stamp: %d\n", + driDrawable->index, + driScreen->pSAREA->drawableTable[driDrawable->index].stamp); +} + + + +void mgaUpdateRects( mgaContextPtr mmesa, GLuint buffers ) +{ + __DRIdrawablePrivate *driDrawable = mmesa->driDrawable; + drm_mga_sarea_t *sarea = mmesa->sarea; + + /* The MGA X driver will try to push one set of cliprects (back or + * front, the last active) for one drawable (the last used) into + * the sarea. See if that window was ours, else retrieve both back + * and front rects from the X server via a protocol request. + * + * If there isn't room for the cliprects in the sarea, the X server + * clears the drawable value to indicate failure. + */ + if (0) printSareaRects(mmesa); + + if (sarea->exported_drawable == driDrawable->draw && + (sarea->exported_buffers & buffers) == buffers) + { + mgaUpdateRectsFromSarea( mmesa ); + } + else + { + if(MGA_DEBUG & DEBUG_VERBOSE_MSG) + fprintf(stderr, "^"); + driDrawable->lastStamp = 0; + + XMESA_VALIDATE_DRAWABLE_INFO(mmesa->display, + mmesa->driScreen, + driDrawable); + mmesa->dirty_cliprects = 0; + } + + if (mmesa->draw_buffer == MGA_FRONT) + mgaXMesaSetFrontClipRects( mmesa ); + else + mgaXMesaSetBackClipRects( mmesa ); + + + if (0) printMmesaRects(mmesa); + + sarea->req_drawable = driDrawable->draw; + sarea->req_draw_buffer = mmesa->draw_buffer; + + + mgaUpdateClipping( mmesa->glCtx ); + + mmesa->dirty |= MGA_UPLOAD_CLIPRECTS; +} + + + +GLboolean mgaDDSetDrawBuffer(GLcontext *ctx, GLenum mode ) +{ + mgaContextPtr mmesa = MGA_CONTEXT(ctx); + + FLUSH_BATCH( MGA_CONTEXT(ctx) ); + + mmesa->Fallback &= ~MGA_FALLBACK_BUFFER; + + if (mode == GL_FRONT_LEFT) + { + mmesa->drawOffset = mmesa->mgaScreen->frontOffset; + mmesa->Setup[MGA_CTXREG_DSTORG] = mmesa->mgaScreen->frontOffset; + mmesa->dirty |= MGA_UPLOAD_CTX; + mmesa->draw_buffer = MGA_FRONT; + mgaXMesaSetFrontClipRects( mmesa ); + return GL_TRUE; + } + else if (mode == GL_BACK_LEFT) + { + mmesa->drawOffset = mmesa->mgaScreen->backOffset; + mmesa->Setup[MGA_CTXREG_DSTORG] = mmesa->mgaScreen->backOffset; + mmesa->draw_buffer = MGA_BACK; + mmesa->dirty |= MGA_UPLOAD_CTX; + mgaXMesaSetBackClipRects( mmesa ); + return GL_TRUE; + } + else + { + mmesa->Fallback |= MGA_FALLBACK_BUFFER; + return GL_FALSE; + } +} + +GLboolean mgaDDSetReadBuffer(GLcontext *ctx, GLenum mode ) +{ + mgaContextPtr mmesa = MGA_CONTEXT(ctx); + + if (mode == GL_FRONT_LEFT) + { + mmesa->readOffset = mmesa->mgaScreen->frontOffset; + mmesa->read_buffer = MGA_FRONT; + return GL_TRUE; + } + else if (mode == GL_BACK_LEFT) + { + mmesa->readOffset = mmesa->mgaScreen->backOffset; + mmesa->read_buffer = MGA_BACK; + return GL_TRUE; + } + else + { + return GL_FALSE; + } +} diff --git a/xc/lib/GL/mesa/src/drv/mga/mgabuffers.h b/xc/lib/GL/mesa/src/drv/mga/mgabuffers.h new file mode 100644 index 000000000..9345fd9c4 --- /dev/null +++ b/xc/lib/GL/mesa/src/drv/mga/mgabuffers.h @@ -0,0 +1,9 @@ +#ifndef MGA_BUFFERS_H +#define MGA_BUFFERS_H + +GLboolean mgaDDSetReadBuffer(GLcontext *ctx, GLenum mode ); +GLboolean mgaDDSetDrawBuffer(GLcontext *ctx, GLenum mode ); + +void mgaUpdateRects( mgaContextPtr mmesa, GLuint buffers ); + +#endif diff --git a/xc/lib/GL/mesa/src/drv/mga/mgacnvtex.c b/xc/lib/GL/mesa/src/drv/mga/mgacnvtex.c index ae8d95037..428b65d06 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgacnvtex.c +++ b/xc/lib/GL/mesa/src/drv/mga/mgacnvtex.c @@ -46,205 +46,206 @@ */ void mgaConvertTexture( mgaUI32 *destPtr, int texelBytes, struct gl_texture_image *image, - int x, int y, int width, int height ) { + int x, int y, int width, int height ) +{ register int i, j; mgaUI8 *src; int stride; /* FIXME: g400 luminance_alpha internal format */ switch (texelBytes) { - case 1: - switch (image->Format) { - case GL_COLOR_INDEX: - case GL_INTENSITY: - case GL_LUMINANCE: - case GL_ALPHA: - src = (mgaUI8 *)image->Data + ( y * image->Width + x ); - stride = (image->Width - width); - for ( i = height ; i ; i-- ) { - for ( j = width >> 2 ; j ; j-- ) { + case 1: + switch (image->Format) { + case GL_COLOR_INDEX: + case GL_INTENSITY: + case GL_LUMINANCE: + case GL_ALPHA: + src = (mgaUI8 *)image->Data + ( y * image->Width + x ); + stride = (image->Width - width); + for ( i = height ; i ; i-- ) { + for ( j = width >> 2 ; j ; j-- ) { - *destPtr++ = src[0] | ( src[1] << 8 ) | ( src[2] << 16 ) | ( src[3] << 24 ); - src += 4; - } - src += stride; - } - break; - default: - goto format_error; - } - break; - case 2: - switch (image->Format) { - case GL_RGB: - src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 3; - stride = (image->Width - width) * 3; - for ( i = height ; i ; i-- ) { - for ( j = width >> 1 ; j ; j-- ) { + *destPtr++ = src[0] | ( src[1] << 8 ) | ( src[2] << 16 ) | ( src[3] << 24 ); + src += 4; + } + src += stride; + } + break; + default: + goto format_error; + } + break; + case 2: + switch (image->Format) { + case GL_RGB: + src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 3; + stride = (image->Width - width) * 3; + for ( i = height ; i ; i-- ) { + for ( j = width >> 1 ; j ; j-- ) { - *destPtr++ = MGAPACKCOLOR565(src[0],src[1],src[2]) | - ( MGAPACKCOLOR565(src[3],src[4],src[5]) << 16 ); - src += 6; - } - src += stride; - } - break; - case GL_RGBA: - src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 4; - stride = (image->Width - width) * 4; - for ( i = height ; i ; i-- ) { - for ( j = width >> 1 ; j ; j-- ) { + *destPtr++ = MGAPACKCOLOR565(src[0],src[1],src[2]) | + ( MGAPACKCOLOR565(src[3],src[4],src[5]) << 16 ); + src += 6; + } + src += stride; + } + break; + case GL_RGBA: + src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 4; + stride = (image->Width - width) * 4; + for ( i = height ; i ; i-- ) { + for ( j = width >> 1 ; j ; j-- ) { - *destPtr++ = MGAPACKCOLOR4444(src[0],src[1],src[2],src[3]) | - ( MGAPACKCOLOR4444(src[4],src[5],src[6],src[7]) << 16 ); - src += 8; - } - src += stride; - } - break; - case GL_LUMINANCE: - src = (mgaUI8 *)image->Data + ( y * image->Width + x ); - stride = (image->Width - width); - for ( i = height ; i ; i-- ) { - for ( j = width >> 1 ; j ; j-- ) { - /* FIXME: should probably use 555 texture to get true grey */ - *destPtr++ = MGAPACKCOLOR565(src[0],src[0],src[0]) | - ( MGAPACKCOLOR565(src[1],src[1],src[1]) << 16 ); - src += 2; - } - src += stride; - } - break; - case GL_INTENSITY: - src = (mgaUI8 *)image->Data + ( y * image->Width + x ); - stride = (image->Width - width); - for ( i = height ; i ; i-- ) { - for ( j = width >> 1 ; j ; j-- ) { + *destPtr++ = MGAPACKCOLOR4444(src[0],src[1],src[2],src[3]) | + ( MGAPACKCOLOR4444(src[4],src[5],src[6],src[7]) << 16 ); + src += 8; + } + src += stride; + } + break; + case GL_LUMINANCE: + src = (mgaUI8 *)image->Data + ( y * image->Width + x ); + stride = (image->Width - width); + for ( i = height ; i ; i-- ) { + for ( j = width >> 1 ; j ; j-- ) { + /* FIXME: should probably use 555 texture to get true grey */ + *destPtr++ = MGAPACKCOLOR565(src[0],src[0],src[0]) | + ( MGAPACKCOLOR565(src[1],src[1],src[1]) << 16 ); + src += 2; + } + src += stride; + } + break; + case GL_INTENSITY: + src = (mgaUI8 *)image->Data + ( y * image->Width + x ); + stride = (image->Width - width); + for ( i = height ; i ; i-- ) { + for ( j = width >> 1 ; j ; j-- ) { - *destPtr++ = MGAPACKCOLOR4444(src[0],src[0],src[0],src[0]) | - ( MGAPACKCOLOR4444(src[1],src[1],src[1],src[1]) << 16 ); - src += 2; - } - src += stride; - } - break; - case GL_ALPHA: - src = (mgaUI8 *)image->Data + ( y * image->Width + x ); - stride = (image->Width - width); - for ( i = height ; i ; i-- ) { - for ( j = width >> 1 ; j ; j-- ) { + *destPtr++ = MGAPACKCOLOR4444(src[0],src[0],src[0],src[0]) | + ( MGAPACKCOLOR4444(src[1],src[1],src[1],src[1]) << 16 ); + src += 2; + } + src += stride; + } + break; + case GL_ALPHA: + src = (mgaUI8 *)image->Data + ( y * image->Width + x ); + stride = (image->Width - width); + for ( i = height ; i ; i-- ) { + for ( j = width >> 1 ; j ; j-- ) { - *destPtr++ = MGAPACKCOLOR4444(255,255,255,src[0]) | - ( MGAPACKCOLOR4444(255,255,255,src[1]) << 16 ); - src += 2; - } - src += stride; - } - break; - case GL_LUMINANCE_ALPHA: - src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 2; - stride = (image->Width - width) * 2; - for ( i = height ; i ; i-- ) { - for ( j = width >> 1 ; j ; j-- ) { + *destPtr++ = MGAPACKCOLOR4444(255,255,255,src[0]) | + ( MGAPACKCOLOR4444(255,255,255,src[1]) << 16 ); + src += 2; + } + src += stride; + } + break; + case GL_LUMINANCE_ALPHA: + src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 2; + stride = (image->Width - width) * 2; + for ( i = height ; i ; i-- ) { + for ( j = width >> 1 ; j ; j-- ) { - *destPtr++ = MGAPACKCOLOR4444(src[0],src[0],src[0],src[1]) | - ( MGAPACKCOLOR4444(src[2],src[2],src[2],src[3]) << 16 ); - src += 4; - } - src += stride; - } - break; - default: - goto format_error; - } - break; - case 4: - switch (image->Format) { - case GL_RGB: - src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 3; - stride = (image->Width - width) * 3; - for ( i = height ; i ; i-- ) { - for ( j = width ; j ; j-- ) { + *destPtr++ = MGAPACKCOLOR4444(src[0],src[0],src[0],src[1]) | + ( MGAPACKCOLOR4444(src[2],src[2],src[2],src[3]) << 16 ); + src += 4; + } + src += stride; + } + break; + default: + goto format_error; + } + break; + case 4: + switch (image->Format) { + case GL_RGB: + src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 3; + stride = (image->Width - width) * 3; + for ( i = height ; i ; i-- ) { + for ( j = width ; j ; j-- ) { - *destPtr++ = MGAPACKCOLOR8888(src[0],src[1],src[2], 255); - src += 3; - } - src += stride; - } - break; - case GL_RGBA: - src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 4; - stride = (image->Width - width) * 4; - for ( i = height ; i ; i-- ) { - for ( j = width ; j ; j-- ) { + *destPtr++ = MGAPACKCOLOR8888(src[0],src[1],src[2], 255); + src += 3; + } + src += stride; + } + break; + case GL_RGBA: + src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 4; + stride = (image->Width - width) * 4; + for ( i = height ; i ; i-- ) { + for ( j = width ; j ; j-- ) { - *destPtr++ = MGAPACKCOLOR8888(src[0],src[1],src[2],src[3]); - src += 4; - } - src += stride; - } - break; - case GL_LUMINANCE: - src = (mgaUI8 *)image->Data + ( y * image->Width + x ); - stride = (image->Width - width); - for ( i = height ; i ; i-- ) { - for ( j = width ; j ; j-- ) { + *destPtr++ = MGAPACKCOLOR8888(src[0],src[1],src[2],src[3]); + src += 4; + } + src += stride; + } + break; + case GL_LUMINANCE: + src = (mgaUI8 *)image->Data + ( y * image->Width + x ); + stride = (image->Width - width); + for ( i = height ; i ; i-- ) { + for ( j = width ; j ; j-- ) { - *destPtr++ = MGAPACKCOLOR8888(src[0],src[0],src[0], 255); - src += 1; - } - src += stride; - } - break; - case GL_INTENSITY: - src = (mgaUI8 *)image->Data + ( y * image->Width + x ); - stride = (image->Width - width); - for ( i = height ; i ; i-- ) { - for ( j = width ; j ; j-- ) { + *destPtr++ = MGAPACKCOLOR8888(src[0],src[0],src[0], 255); + src += 1; + } + src += stride; + } + break; + case GL_INTENSITY: + src = (mgaUI8 *)image->Data + ( y * image->Width + x ); + stride = (image->Width - width); + for ( i = height ; i ; i-- ) { + for ( j = width ; j ; j-- ) { - *destPtr++ = MGAPACKCOLOR8888(src[0],src[0],src[0],src[0]); - src += 1; - } - src += stride; - } - break; - case GL_ALPHA: - src = (mgaUI8 *)image->Data + ( y * image->Width + x ); - stride = (image->Width - width); - for ( i = height ; i ; i-- ) { - for ( j = width ; j ; j-- ) { + *destPtr++ = MGAPACKCOLOR8888(src[0],src[0],src[0],src[0]); + src += 1; + } + src += stride; + } + break; + case GL_ALPHA: + src = (mgaUI8 *)image->Data + ( y * image->Width + x ); + stride = (image->Width - width); + for ( i = height ; i ; i-- ) { + for ( j = width ; j ; j-- ) { - *destPtr++ = MGAPACKCOLOR8888(255,255,255,src[0]); - src += 1; - } - src += stride; - } - break; - case GL_LUMINANCE_ALPHA: - src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 2; - stride = (image->Width - width) * 2; - for ( i = height ; i ; i-- ) { - for ( j = width ; j ; j-- ) { + *destPtr++ = MGAPACKCOLOR8888(255,255,255,src[0]); + src += 1; + } + src += stride; + } + break; + case GL_LUMINANCE_ALPHA: + src = (mgaUI8 *)image->Data + ( y * image->Width + x ) * 2; + stride = (image->Width - width) * 2; + for ( i = height ; i ; i-- ) { + for ( j = width ; j ; j-- ) { - *destPtr++ = MGAPACKCOLOR8888(src[0],src[0], - src[0],src[1]); - src += 2; - } - src += stride; - } - break; - default: - goto format_error; - } - break; - default: - goto format_error; + *destPtr++ = MGAPACKCOLOR8888(src[0],src[0], + src[0],src[1]); + src += 2; + } + src += stride; + } + break; + default: + goto format_error; + } + break; + default: + goto format_error; } return; -format_error: + format_error: - mgaError( "Unsupported texelBytes %i, image->Format %i\n", - texelBytes, image->Format ); + mgaError( "Unsupported texelBytes %i, image->Format %i\n", + (int)texelBytes, (int)image->Format ); } diff --git a/xc/lib/GL/mesa/src/drv/mga/mgadd.c b/xc/lib/GL/mesa/src/drv/mga/mgadd.c index ad56cbbc3..bdae9a2bf 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgadd.c +++ b/xc/lib/GL/mesa/src/drv/mga/mgadd.c @@ -61,11 +61,11 @@ static const GLubyte *mgaDDGetString( GLcontext *ctx, GLenum name ) mgaContextPtr mmesa = MGA_CONTEXT( ctx ); switch (name) { case GL_VENDOR: - return "Utah GLX"; + return "Precision Insight"; case GL_RENDERER: - if (MGA_IS_G200(mmesa)) return "GLX-MGA-G200"; - if (MGA_IS_G400(mmesa)) return "GLX-MGA-G400"; - return "GLX-MGA"; + if (MGA_IS_G200(mmesa)) return "DRI-MGA-G200"; + if (MGA_IS_G400(mmesa)) return "DRI-MGA-G400"; + return "DRI-MGA"; default: return 0; } diff --git a/xc/lib/GL/mesa/src/drv/mga/mgadepth.c b/xc/lib/GL/mesa/src/drv/mga/mgadepth.c index 0d55137d1..2dfc3e00c 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgadepth.c +++ b/xc/lib/GL/mesa/src/drv/mga/mgadepth.c @@ -43,20 +43,24 @@ #include "mgalib.h" #endif - +#define DEPTH_SCALE 65535.0F /* * Return the address of the Z-buffer value for window coordinate (x,y): */ -#define Z_SETUP \ - mgaContextPtr mmesa = MGA_CONTEXT(ctx); \ - __DRIscreenPrivate *sPriv = mmesa->driScreen; \ - mgaScreenPrivate *mgaScreen = mmesa->mgaScreen; \ - GLdepth *zbstart = (GLdepth *)(sPriv->pFB + mgaScreen->depthOffset);\ - GLint zbpitch = mgaScreen->depthPitch +#define Z_SETUP \ + __DRIscreenPrivate *sPriv = mmesa->driScreen; \ + __DRIdrawablePrivate *dPriv = mmesa->driDrawable; \ + GLuint height = dPriv->h; \ + mgaScreenPrivate *mgaScreen = mmesa->mgaScreen; \ + GLint zbpitch = mgaScreen->depthPitch; \ + char *zbstart = (char *)(sPriv->pFB + \ + mgaScreen->depthOffset + \ + dPriv->x * 2 + \ + dPriv->y * zbpitch) #define Z_ADDRESS( X, Y ) \ - (zbstart + zbpitch * (Y) + (X)) + (GLdepth *)(zbstart + zbpitch * (height - (Y)) + (X) * 2) /**********************************************************************/ @@ -84,16 +88,18 @@ static GLuint mga_depth_test_span_generic( GLcontext* ctx, const GLdepth z[], GLubyte mask[] ) { - Z_SETUP; - GLdepth *zptr = Z_ADDRESS( x, y ); + mgaContextPtr mmesa = MGA_CONTEXT(ctx); GLubyte *m = mask; GLuint i; GLuint passed = 0; - LOCK_HARDWARE(mmesa); + LOCK_HARDWARE_QUIESCENT(mmesa); + { + Z_SETUP; + GLdepth *zptr = Z_ADDRESS( x, y ); - /* switch cases ordered from most frequent to less frequent */ - switch (ctx->Depth.Func) { + /* switch cases ordered from most frequent to less frequent */ + switch (ctx->Depth.Func) { case GL_LESS: if (ctx->Depth.Mask) { /* Update Z buffer */ @@ -297,8 +303,8 @@ static GLuint mga_depth_test_span_generic( GLcontext* ctx, } break; default: + } } - UNLOCK_HARDWARE(mmesa); return passed; @@ -320,14 +326,16 @@ static void mga_depth_test_pixels_generic( GLcontext* ctx, const GLint x[], const GLint y[], const GLdepth z[], GLubyte mask[] ) { - Z_SETUP; - register GLdepth *zptr; - register GLuint i; + mgaContextPtr mmesa = MGA_CONTEXT(ctx); + LOCK_HARDWARE_QUIESCENT(mmesa); + { + Z_SETUP; + register GLdepth *zptr; + register GLuint i; - LOCK_HARDWARE(mmesa); - /* switch cases ordered from most frequent to less frequent */ - switch (ctx->Depth.Func) { + /* switch cases ordered from most frequent to less frequent */ + switch (ctx->Depth.Func) { case GL_LESS: if (ctx->Depth.Mask) { /* Update Z buffer */ @@ -547,8 +555,8 @@ static void mga_depth_test_pixels_generic( GLcontext* ctx, } break; default: - } - + } + } UNLOCK_HARDWARE(mmesa); } @@ -570,27 +578,29 @@ static void mga_read_depth_span_float( GLcontext* ctx, GLuint n, GLint x, GLint y, GLfloat depth[] ) { - Z_SETUP; - GLdepth *zptr; - GLfloat scale; - GLuint i; + mgaContextPtr mmesa = MGA_CONTEXT(ctx); + LOCK_HARDWARE_QUIESCENT(mmesa); + { - LOCK_HARDWARE(mmesa); + Z_SETUP; + GLdepth *zptr; + GLfloat scale; + GLuint i; - scale = 1.0F / DEPTH_SCALE; + scale = 1.0F / DEPTH_SCALE; - if (ctx->Buffer->Depth) { - zptr = Z_ADDRESS( x, y ); - for (i=0;i<n;i++) { - depth[i] = (GLfloat) zptr[i] * scale; + if (ctx->ReadBuffer->Depth) { + zptr = Z_ADDRESS( x, y ); + for (i=0;i<n;i++) { + depth[i] = (GLfloat) zptr[i] * scale; + } } - } - else { - for (i=0;i<n;i++) { - depth[i] = 0.0F; + else { + for (i=0;i<n;i++) { + depth[i] = 0.0F; + } } } - UNLOCK_HARDWARE(mmesa); } @@ -607,30 +617,32 @@ static void mga_read_depth_span_int( GLcontext* ctx, GLuint n, GLint x, GLint y, GLdepth depth[] ) { - Z_SETUP; + mgaContextPtr mmesa = MGA_CONTEXT(ctx); + LOCK_HARDWARE_QUIESCENT(mmesa); + { + Z_SETUP; - LOCK_HARDWARE(mmesa); - if (ctx->Buffer->Depth) { - GLdepth *zptr = Z_ADDRESS( x, y ); - MEMCPY( depth, zptr, n * sizeof(GLdepth) ); - } - else { - GLuint i; - for (i=0;i<n;i++) { - depth[i] = 0; + if (ctx->ReadBuffer->Depth) { + GLdepth *zptr = Z_ADDRESS( x, y ); + MEMCPY( depth, zptr, n * sizeof(GLdepth) ); + } + else { + GLuint i; + for (i=0;i<n;i++) { + depth[i] = 0; + } } } - UNLOCK_HARDWARE(mmesa); } void mgaDDInitDepthFuncs( GLcontext *ctx ) { - ctx->Driver.ReadDepthSpanFloat = mga_read_depth_span_float; - ctx->Driver.ReadDepthSpanInt = mga_read_depth_span_int; - ctx->Driver.DepthTestSpan = mga_depth_test_span_generic; - ctx->Driver.DepthTestPixels = mga_depth_test_pixels_generic; + ctx->Driver.ReadDepthSpan = mga_read_depth_span_float; + ctx->Driver.WriteDepthSpan = mga_read_depth_span_float; + ctx->Driver.ReadDepthPixels mga_read_depth_span_float; + ctx->Driver.WriteDepthPixels = mga_read_depth_span_float; } diff --git a/xc/lib/GL/mesa/src/drv/mga/mgafastpath.c b/xc/lib/GL/mesa/src/drv/mga/mgafastpath.c index 8017e7f02..5e237bb01 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgafastpath.c +++ b/xc/lib/GL/mesa/src/drv/mga/mgafastpath.c @@ -380,6 +380,8 @@ static void mga_project_vertices( struct vertex_buffer *VB ) GLmatrix *mat = &ctx->Viewport.WindowMap; GLfloat m[16]; + REFRESH_DRAWABLE_INFO(mmesa); + m[MAT_SX] = mat->m[MAT_SX]; m[MAT_TX] = mat->m[MAT_TX] + mmesa->drawX - .5; m[MAT_SY] = (- mat->m[MAT_SY]); @@ -401,6 +403,8 @@ static void mga_project_clipped_vertices( struct vertex_buffer *VB ) GLmatrix *mat = &ctx->Viewport.WindowMap; GLfloat m[16]; + REFRESH_DRAWABLE_INFO(mmesa); + m[MAT_SX] = mat->m[MAT_SX]; m[MAT_TX] = mat->m[MAT_TX] + mmesa->drawX - .5; m[MAT_SY] = (- mat->m[MAT_SY]); @@ -507,18 +511,12 @@ void mgaDDFastPath( struct vertex_buffer *VB ) ctx->CVA.elt_mode = gl_reduce_prim[prim]; VB->EltPtr = &(MGA_DRIVER_DATA(VB)->clipped_elements); - LOCK_HARDWARE( mmesa ); mga_project_clipped_vertices( VB ); /* clip->device space */ mga_render_elements_direct( VB ); /* render using new list */ - mgaFlushVerticesLocked( mmesa ); - UNLOCK_HARDWARE( mmesa ); } } else { - LOCK_HARDWARE( mmesa ); mga_project_vertices( VB ); /* clip->device space */ mga_render_elements_direct( VB ); /* render using orig list */ - mgaFlushVerticesLocked( mmesa ); - UNLOCK_HARDWARE( mmesa ); } /* This indicates that there is no cached data to reuse. diff --git a/xc/lib/GL/mesa/src/drv/mga/mgafasttmp.h b/xc/lib/GL/mesa/src/drv/mga/mgafasttmp.h index 43caddcac..1fb177694 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgafasttmp.h +++ b/xc/lib/GL/mesa/src/drv/mga/mgafasttmp.h @@ -87,6 +87,8 @@ static void TAG(mga_setup_full)( struct vertex_buffer *VB, GLuint do_cliptest ) STRIDE_F(tex0_data, tex0_stride); } if (TYPE & MGA_TEX1_BIT) { + /* Hits a second cache line. + */ f[CLIP_S1] = tex1_data[0]; f[CLIP_T1] = tex1_data[1]; STRIDE_F(tex1_data, tex1_stride); diff --git a/xc/lib/GL/mesa/src/drv/mga/mgaioctl.c b/xc/lib/GL/mesa/src/drv/mga/mgaioctl.c index c1819924d..f9ef24310 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgaioctl.c +++ b/xc/lib/GL/mesa/src/drv/mga/mgaioctl.c @@ -14,114 +14,137 @@ #include "mgalog.h" #include "mgavb.h" #include "mgatris.h" +#include "mgabuffers.h" + #include "drm.h" #include <sys/ioctl.h> +#define DEPTH_SCALE 65535.0F + static void mga_iload_dma_ioctl(mgaContextPtr mmesa, - int x1, int y1, int x2, int y2, - unsigned long dest, unsigned int maccess) + unsigned long dest, + int length) { int retcode; drm_mga_iload_t iload; - drmBufPtr buf = mmesa->dma_buffer; + drmBufPtr buf = mmesa->iload_buffer; iload.idx = buf->idx; iload.destOrg = dest; - iload.mAccess = maccess; - iload.texture.x1 = x1; - iload.texture.y1 = y1; - iload.texture.y2 = x2; - iload.texture.x2 = y2; + iload.length = length; + + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "DRM_IOCTL_MGA_ILOAD idx %d dst %x length %d\n", + iload.idx, iload.destOrg, iload.length); + if ((retcode = ioctl(mmesa->driFd, DRM_IOCTL_MGA_ILOAD, &iload))) { printf("send iload retcode = %d\n", retcode); exit(1); } -} + mmesa->iload_buffer = 0; + + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "finished iload dma put\n"); -static void mga_vertex_dma_ioctl(mgaContextPtr mmesa) +} + +int mgaUpdateLock( mgaContextPtr mmesa, drmLockFlags flags ) { - int retcode; - int size = MGA_DMA_BUF_SZ; - drmDMAReq dma; - drmBufPtr buf = mmesa->dma_buffer; + drm_lock_t lock; + + lock.flags = 0; - dma.context = mmesa->hHWContext; - dma.send_count = 1; - dma.send_list = &buf->idx; - dma.send_sizes = &size; - dma.flags = DRM_DMA_WAIT; - dma.request_count = 0; - dma.request_size = 0; - dma.request_list = 0; - dma.request_sizes = 0; - - if ((retcode = drmDMA(mmesa->driFd, &dma))) { - printf("send iload retcode = %d\n", retcode); - exit(1); + if (mmesa->sarea->last_quiescent != mmesa->sarea->last_enqueue && + flags & DRM_LOCK_QUIESCENT) { + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "mgaLockQuiescent\n"); + lock.flags |= _DRM_LOCK_QUIESCENT; + } + + if (flags & DRM_LOCK_FLUSH) lock.flags |= _DRM_LOCK_FLUSH; + if (flags & DRM_LOCK_FLUSH_ALL) lock.flags |= _DRM_LOCK_FLUSH_ALL; + + if (!lock.flags) + return 0; + + if(ioctl(mmesa->driFd, DRM_IOCTL_MGA_FLUSH, &lock)) { + printf("Lockupdate failed\n"); + return -1; } + + if(flags & DRM_LOCK_QUIESCENT) + mmesa->sarea->last_quiescent = mmesa->sarea->last_enqueue; + + return 0; } - -static void mga_get_buffer_ioctl( mgaContextPtr mmesa ) +static drmBufPtr mga_get_buffer_ioctl( mgaContextPtr mmesa ) { int idx = 0; int size = 0; drmDMAReq dma; int retcode; + drmBufPtr buf; - fprintf(stderr, "Getting dma buffer\n"); + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "Getting dma buffer\n"); dma.context = mmesa->hHWContext; dma.send_count = 0; dma.send_list = NULL; dma.send_sizes = NULL; - dma.flags = DRM_DMA_WAIT; + dma.flags = 0; dma.request_count = 1; dma.request_size = MGA_DMA_BUF_SZ; dma.request_list = &idx; dma.request_sizes = &size; - - if ((retcode = drmDMA(mmesa->driFd, &dma))) { - fprintf(stderr, "request drmDMA retcode = %d\n", retcode); - exit(1); - } + dma.granted_count = 0; - mmesa->dma_buffer = &mmesa->mgaScreen->bufs->list[idx]; -} -static void mga_swap_ioctl( mgaContextPtr mmesa ) -{ - int retcode; - drm_mga_swap_t swap; - - if((retcode = ioctl(mmesa->driFd, DRM_IOCTL_MGA_SWAP, &swap))) { - printf("send swap retcode = %d\n", retcode); - exit(1); - } -} + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "drmDMA (get) ctx %d count %d size 0x%x\n", + dma.context, dma.request_count, + dma.request_size); + while (1) { + retcode = drmDMA(mmesa->driFd, &dma); + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "retcode %d sz %d idx %d count %d\n", + retcode, + dma.request_sizes[0], + dma.request_list[0], + dma.granted_count); -static void mga_clear_ioctl( mgaContextPtr mmesa, int flags, int col, int zval ) -{ - int retcode; - drm_mga_clear_t clear; - - clear.flags = flags; - clear.clear_color = col; - clear.clear_depth = zval; - - if((retcode = ioctl(mmesa->driFd, DRM_IOCTL_MGA_CLEAR, &clear))) { - printf("send clear retcode = %d\n", retcode); - exit(1); + if (retcode == 0 && + dma.request_sizes[0] && + dma.granted_count) + break; + + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "\n\nflush"); + mgaUpdateLock( mmesa, DRM_LOCK_FLUSH ); } -} + buf = &(mmesa->mgaScreen->bufs->list[idx]); + buf->used = 0; + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, + "drmDMA (get) returns size[0] 0x%x idx[0] %d\n" + "dma_buffer now: buf idx: %d size: %d used: %d\n", + dma.request_sizes[0], dma.request_list[0], + buf->idx, buf->total, + buf->used); + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "finished getbuffer\n"); + + return buf; +} @@ -130,52 +153,57 @@ GLbitfield mgaClear( GLcontext *ctx, GLbitfield mask, GLboolean all, GLint cx, GLint cy, GLint cw, GLint ch ) { mgaContextPtr mmesa = MGA_CONTEXT( ctx ); - GLuint c = mmesa->ClearColor; - mgaUI32 zval = (mgaUI32) (ctx->Depth.Clear * DEPTH_SCALE); __DRIdrawablePrivate *dPriv = mmesa->driDrawable; - int flags = 0; + const GLuint colorMask = *((GLuint *) &ctx->Color.ColorMask); + drm_mga_clear_t clear; + int retcode; int i; + static int nrclears; - mgaMsg( 10, "mgaClear( %i, %i, %i, %i, %i )\n", - mask, x, y, width, height ); - - - mgaFlushVertices( mmesa ); + clear.flags = 0; + clear.clear_color = mmesa->ClearColor; + clear.clear_depth = (mgaUI32) (ctx->Depth.Clear * DEPTH_SCALE); + FLUSH_BATCH( mmesa ); + + if ((mask & DD_FRONT_LEFT_BIT) && colorMask == ~0) { + clear.flags |= MGA_FRONT; + mask &= ~DD_FRONT_LEFT_BIT; + } - if (mask & GL_COLOR_BUFFER_BIT) { - if (ctx->Color.DriverDrawBuffer == GL_FRONT_LEFT) { - flags |= MGA_CLEAR_FRONT; - mask &= ~GL_COLOR_BUFFER_BIT; - } else if (ctx->Color.DriverDrawBuffer == GL_BACK_LEFT) { - flags |= MGA_CLEAR_BACK; - mask &= ~GL_COLOR_BUFFER_BIT; - } + if ((mask & DD_BACK_LEFT_BIT) && colorMask == ~0) { + clear.flags |= MGA_BACK; + mask &= ~DD_BACK_LEFT_BIT; } - if ((flags & GL_DEPTH_BUFFER_BIT) && ctx->Depth.Mask) { - flags |= MGA_CLEAR_DEPTH; - mask &= ~GL_DEPTH_BUFFER_BIT; + if ((mask & DD_DEPTH_BIT) && ctx->Depth.Mask) { + clear.flags |= MGA_DEPTH; + mask &= ~DD_DEPTH_BIT; } - if (!flags) + if (!clear.flags) return mask; LOCK_HARDWARE( mmesa ); - + + if (mmesa->dirty_cliprects) + mgaUpdateRects( mmesa, (MGA_FRONT|MGA_BACK)); + /* flip top to bottom */ cy = dPriv->h-cy-ch; cx += mmesa->drawX; cy += mmesa->drawY; - for (i = 0 ; i < dPriv->numClipRects ; ) { + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "Clear, bufs %x nbox %d\n", + (int)clear.flags, (int)mmesa->numClipRects); - /* Use the cliprects for the current draw buffer - */ + for (i = 0 ; i < mmesa->numClipRects ; ) + { int nr = MIN2(i + MGA_NR_SAREA_CLIPRECTS, mmesa->numClipRects); XF86DRIClipRectRec *box = mmesa->pClipRects; - xf86drmClipRectRec *b = mmesa->sarea->boxes; - mmesa->sarea->nbox = nr - i; + drm_clip_rect_t *b = mmesa->sarea->boxes; + int n = 0; if (!all) { for ( ; i < nr ; i++) { @@ -196,16 +224,37 @@ GLbitfield mgaClear( GLcontext *ctx, GLbitfield mask, GLboolean all, b->x2 = x + w; b->y2 = y + h; b++; + n++; } } else { - for ( ; i < nr ; i++) - *b++ = *(xf86drmClipRectRec *)&box[i]; + for ( ; i < nr ; i++) { + *b++ = *(drm_clip_rect_t *)&box[i]; + n++; + } } - mga_clear_ioctl( mmesa, mask, c, zval ); + + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, + "DRM_IOCTL_MGA_CLEAR flag 0x%x color %x depth %x nbox %d\n", + clear.flags, clear.clear_color, + clear.clear_depth, mmesa->sarea->nbox); + + + mmesa->sarea->nbox = n; + + retcode = ioctl(mmesa->driFd, DRM_IOCTL_MGA_CLEAR, &clear); + if (retcode) { + printf("send clear retcode = %d\n", retcode); + exit(1); + } + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "finished clear %d\n", ++nrclears); } UNLOCK_HARDWARE( mmesa ); + mmesa->dirty |= MGA_UPLOAD_CLIPRECTS; + return mask; } @@ -218,50 +267,62 @@ GLbitfield mgaClear( GLcontext *ctx, GLbitfield mask, GLboolean all, void mgaSwapBuffers( mgaContextPtr mmesa ) { __DRIdrawablePrivate *dPriv = mmesa->driDrawable; + XF86DRIClipRectPtr pbox; + int nbox; + drm_mga_swap_t swap; + static int nrswaps; + int retcode; int i; + int tmp; - mgaFlushVertices( mmesa ); - LOCK_HARDWARE( mmesa ); - { - /* Use the frontbuffer cliprects - */ - XF86DRIClipRectPtr pbox = dPriv->pClipRects; - int nbox = dPriv->numClipRects; + FLUSH_BATCH( mmesa ); - for (i = 0 ; i < nbox ; ) - { - int nr = MIN2(i + MGA_NR_SAREA_CLIPRECTS, dPriv->numClipRects); - XF86DRIClipRectRec *b = (XF86DRIClipRectRec *)mmesa->sarea->boxes; - mmesa->sarea->nbox = nr - i; + LOCK_HARDWARE( mmesa ); + + /* Use the frontbuffer cliprects + */ + if (mmesa->dirty_cliprects & MGA_FRONT) + mgaUpdateRects( mmesa, MGA_FRONT ); + - for ( ; i < nr ; i++) - *b++ = pbox[i]; - - mga_swap_ioctl( mmesa ); - } - } + pbox = dPriv->pClipRects; + nbox = dPriv->numClipRects; + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "swap, nbox %d\n", nbox); -#if 1 - UNLOCK_HARDWARE(mmesa); -#else + for (i = 0 ; i < nbox ; ) { - last_enqueue = mmesa->sarea->lastEnqueue; - last_dispatch = mmesa->sarea->lastDispatch; - UNLOCK_HARDWARE; + int nr = MIN2(i + MGA_NR_SAREA_CLIPRECTS, dPriv->numClipRects); + XF86DRIClipRectRec *b = (XF86DRIClipRectRec *)mmesa->sarea->boxes; + + mmesa->sarea->nbox = nr - i; + + for ( ; i < nr ; i++) + *b++ = pbox[i]; - /* Throttle runaway apps - there should be an easier way to sleep - * on dma without locking out the rest of the system! - */ - if (mmesa->lastSwap > last_dispatch) { - drmGetLock(mmesa->driFd, mmesa->hHWContext, DRM_LOCK_QUIESCENT); - DRM_UNLOCK(mmesa->driFd, mmesa->driHwLock, mmesa->hHWContext); + if (0) + fprintf(stderr, "DRM_IOCTL_MGA_SWAP\n"); + + if((retcode = ioctl(mmesa->driFd, DRM_IOCTL_MGA_SWAP, &swap))) { + printf("send swap retcode = %d\n", retcode); + exit(1); } - mmesa->lastSwap = last_enqueue; + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "finished swap %d\n", ++nrswaps); } -#endif + + tmp = GET_ENQUEUE_AGE(mmesa); + + UNLOCK_HARDWARE( mmesa ); + + if (GET_DISPATCH_AGE(mmesa) < mmesa->lastSwap) + mgaWaitAge(mmesa, mmesa->lastSwap); + + mmesa->lastSwap = tmp; + mmesa->dirty |= MGA_UPLOAD_CLIPRECTS; } @@ -269,53 +330,243 @@ void mgaSwapBuffers( mgaContextPtr mmesa ) */ void mgaDDFinish( GLcontext *ctx ) { - mgaContextPtr mmesa = MGA_CONTEXT( ctx ); - drmGetLock(mmesa->driFd, mmesa->hHWContext, DRM_LOCK_QUIESCENT); - DRM_UNLOCK(mmesa->driFd, mmesa->driHwLock, mmesa->hHWContext); + mgaContextPtr mmesa = MGA_CONTEXT(ctx); + + if (mmesa->sarea->last_quiescent != mmesa->sarea->last_enqueue) { + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "mgaRegetLockQuiescent\n"); + + LOCK_HARDWARE( mmesa ); + mgaUpdateLock( mmesa, DRM_LOCK_QUIESCENT | DRM_LOCK_FLUSH); + UNLOCK_HARDWARE( mmesa ); + + mmesa->sarea->last_quiescent = mmesa->sarea->last_enqueue; + } } +void mgaWaitAgeLocked( mgaContextPtr mmesa, int age ) +{ + if (GET_DISPATCH_AGE(mmesa) < age) { + if (0) fprintf(stderr, "\n\n\nmgaWaitAgeLocked\n"); + mgaUpdateLock( mmesa, DRM_LOCK_FLUSH ); + } +} +void mgaWaitAge( mgaContextPtr mmesa, int age ) +{ + if (GET_DISPATCH_AGE(mmesa) < age) { + LOCK_HARDWARE(mmesa); + if (GET_DISPATCH_AGE(mmesa) < age) { + if (0) fprintf(stderr, "\n\n\nmgaWaitAge\n"); + mgaUpdateLock( mmesa, DRM_LOCK_FLUSH ); + } + UNLOCK_HARDWARE(mmesa); + } +} -void mgaFlushVertices( mgaContextPtr mmesa ) + +static int intersect_rect( drm_clip_rect_t *out, + drm_clip_rect_t *a, + drm_clip_rect_t *b ) { - LOCK_HARDWARE( mmesa ); - mgaFlushVerticesLocked( mmesa ); - UNLOCK_HARDWARE( mmesa ); + *out = *a; + if (b->x1 > out->x1) out->x1 = b->x1; + if (b->y1 > out->y1) out->y1 = b->y1; + if (b->x2 < out->x2) out->x2 = b->x2; + if (b->y2 < out->y2) out->y2 = b->y2; + if (out->x1 >= out->x2) return 0; + if (out->y1 >= out->y2) return 0; + return 1; } + + +static void age_mmesa( mgaContextPtr mmesa, int age ) +{ + if (mmesa->CurrentTexObj[0]) mmesa->CurrentTexObj[0]->age = age; + if (mmesa->CurrentTexObj[1]) mmesa->CurrentTexObj[1]->age = age; +} + void mgaFlushVerticesLocked( mgaContextPtr mmesa ) { - XF86DRIClipRectPtr pbox = mmesa->pClipRects; + drm_clip_rect_t *pbox = (drm_clip_rect_t *)mmesa->pClipRects; int nbox = mmesa->numClipRects; + drmBufPtr buffer = mmesa->vertex_dma_buffer; + drm_mga_vertex_t vertex; int i; - if (mmesa->dirty) + if (!buffer) + return; + + if (mmesa->dirty_cliprects & mmesa->draw_buffer) + mgaUpdateRects( mmesa, mmesa->draw_buffer ); + + if (mmesa->dirty & ~MGA_UPLOAD_CLIPRECTS) mgaEmitHwStateLocked( mmesa ); - for (i = 0 ; i < nbox ; ) + /* FIXME: Workaround bug in kernel module. + */ + mmesa->sarea->dirty |= MGA_UPLOAD_CTX; + + /* FIXME: dstorg bug + */ + if (0) + if (mmesa->lastX != mmesa->drawX || mmesa->lastY != mmesa->drawY) + fprintf(stderr, "****** last: %d,%d current: %d,%d\n", + mmesa->lastX, mmesa->lastY, + mmesa->drawX, mmesa->drawY); + + + mmesa->vertex_dma_buffer = 0; + vertex.idx = buffer->idx; + vertex.used = buffer->used; + vertex.discard = 0; + + if (!nbox) + vertex.used = 0; + + if (nbox >= MGA_NR_SAREA_CLIPRECTS) + mmesa->dirty |= MGA_UPLOAD_CLIPRECTS; + + if (!vertex.used || !(mmesa->dirty & MGA_UPLOAD_CLIPRECTS)) { - int nr = MIN2(i + MGA_NR_SAREA_CLIPRECTS, nbox); - XF86DRIClipRectRec *b = (XF86DRIClipRectRec *)mmesa->sarea->boxes; - mmesa->sarea->nbox = nr - i; + if (nbox == 1) + mmesa->sarea->nbox = 0; + else + mmesa->sarea->nbox = nbox; + + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "Firing vertex -- case a nbox %d\n", nbox); + + vertex.discard = 1; + ioctl(mmesa->driFd, DRM_IOCTL_MGA_VERTEX, &vertex); + age_mmesa(mmesa, mmesa->sarea->last_enqueue); + } + else + { + for (i = 0 ; i < nbox ; ) + { + int nr = MIN2(i + MGA_NR_SAREA_CLIPRECTS, nbox); + drm_clip_rect_t *b = mmesa->sarea->boxes; + + if (mmesa->scissor) { + mmesa->sarea->nbox = 0; + + for ( ; i < nr ; i++) { + *b = pbox[i]; + if (intersect_rect(b, b, &mmesa->scissor_rect)) { + mmesa->sarea->nbox++; + b++; + } + } + + /* Culled? + */ + if (!mmesa->sarea->nbox) { + if (nr < nbox) continue; + vertex.used = 0; + } + } else { + mmesa->sarea->nbox = nr - i; + for ( ; i < nr ; i++) + *b++ = pbox[i]; + } - for ( ; i < nr ; i++) - *b++ = pbox[i]; - - mga_vertex_dma_ioctl( mmesa ); + /* Finished with the buffer? + */ + if (nr == nbox) + vertex.discard = 1; + + mmesa->sarea->dirty |= MGA_UPLOAD_CLIPRECTS; + ioctl(mmesa->driFd, DRM_IOCTL_MGA_VERTEX, &vertex); + age_mmesa(mmesa, mmesa->sarea->last_enqueue); + } + } + + mmesa->dirty &= ~MGA_UPLOAD_CLIPRECTS; +} + +void mgaFlushVertices( mgaContextPtr mmesa ) +{ + LOCK_HARDWARE( mmesa ); + mgaFlushVerticesLocked( mmesa ); + UNLOCK_HARDWARE( mmesa ); +} + + +mgaUI32 *mgaAllocVertexDwords( mgaContextPtr mmesa, int dwords ) +{ + int bytes = dwords * 4; + mgaUI32 *head; + + if (!mmesa->vertex_dma_buffer) { + LOCK_HARDWARE( mmesa ); + mmesa->vertex_dma_buffer = mga_get_buffer_ioctl( mmesa ); + UNLOCK_HARDWARE( mmesa ); + } else if (mmesa->vertex_dma_buffer->used + bytes > + mmesa->vertex_dma_buffer->total) { + LOCK_HARDWARE( mmesa ); + mgaFlushVerticesLocked( mmesa ); + mmesa->vertex_dma_buffer = mga_get_buffer_ioctl( mmesa ); + UNLOCK_HARDWARE( mmesa ); + } + + head = (mgaUI32 *)((char *)mmesa->vertex_dma_buffer->address + + mmesa->vertex_dma_buffer->used); + + mmesa->vertex_dma_buffer->used += bytes; + return head; +} - break; /* fix dma multiple dispatch */ + +void mgaFireILoadLocked( mgaContextPtr mmesa, + GLuint offset, GLuint length ) +{ + if (!mmesa->iload_buffer) { + fprintf(stderr, "mgaFireILoad: no buffer\n"); + return; } - mga_get_buffer_ioctl( mmesa ); + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "mgaFireILoad idx %d ofs 0x%x length %d\n", + mmesa->iload_buffer->idx, (int)offset, (int)length ); + + mga_iload_dma_ioctl( mmesa, offset, length ); } +void mgaGetILoadBufferLocked( mgaContextPtr mmesa ) +{ + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) + fprintf(stderr, "mgaGetIloadBuffer (buffer now %p)\n", + mmesa->iload_buffer); + + mmesa->iload_buffer = mga_get_buffer_ioctl( mmesa ); +} + + +static void mgaDDFlush( GLcontext *ctx ) +{ + mgaContextPtr mmesa = MGA_CONTEXT( ctx ); + + FLUSH_BATCH( mmesa ); + + /* This may be called redundantly - dispatch_age may trail what + * has actually been sent and processed by the hardware. + */ + if (GET_DISPATCH_AGE( mmesa ) < mmesa->sarea->last_enqueue) { + LOCK_HARDWARE( mmesa ); + if (0) fprintf(stderr, "mgaDDFlush\n"); + mgaUpdateLock( mmesa, DRM_LOCK_FLUSH ); + UNLOCK_HARDWARE( mmesa ); + } +} void mgaDDInitIoctlFuncs( GLcontext *ctx ) { ctx->Driver.Clear = mgaClear; - ctx->Driver.Flush = 0; + ctx->Driver.Flush = mgaDDFlush; ctx->Driver.Finish = mgaDDFinish; } diff --git a/xc/lib/GL/mesa/src/drv/mga/mgaioctl.h b/xc/lib/GL/mesa/src/drv/mga/mgaioctl.h index 22ca26e17..13cec59d7 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgaioctl.h +++ b/xc/lib/GL/mesa/src/drv/mga/mgaioctl.h @@ -9,6 +9,21 @@ GLbitfield mgaClear( GLcontext *ctx, GLbitfield mask, GLboolean all, void mgaSwapBuffers( mgaContextPtr mmesa ); + + +mgaUI32 *mgaAllocVertexDwords( mgaContextPtr mmesa, int dwords ); + + +void mgaGetILoadBufferLocked( mgaContextPtr mmesa ); + + +void mgaFireILoadLocked( mgaContextPtr mmesa, + GLuint offset, GLuint length ); + +void mgaWaitAgeLocked( mgaContextPtr mmesa, int age ); +void mgaWaitAge( mgaContextPtr mmesa, int age ); +int mgaUpdateLock( mgaContextPtr mmesa, drmLockFlags flags ); + void mgaFlushVertices( mgaContextPtr mmesa ); void mgaFlushVerticesLocked( mgaContextPtr mmesa ); @@ -19,5 +34,11 @@ void mgaDDFinish( GLcontext *ctx ); void mgaDDInitIoctlFuncs( GLcontext *ctx ); +#define FLUSH_BATCH(mmesa) do { \ + if (MGA_DEBUG&DEBUG_VERBOSE_IOCTL) \ + fprintf(stderr, "FLUSH_BATCH in %s\n", __FUNCTION__); \ + if (mmesa->vertex_dma_buffer) mgaFlushVertices(mmesa); \ +} while (0) + #endif diff --git a/xc/lib/GL/mesa/src/drv/mga/mgalib.h b/xc/lib/GL/mesa/src/drv/mga/mgalib.h index 4600a69a0..176c126bd 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgalib.h +++ b/xc/lib/GL/mesa/src/drv/mga/mgalib.h @@ -36,6 +36,7 @@ #include "types.h" +#include "drm.h" #include "mgacommon.h" #include "mm.h" #include "mgalog.h" @@ -43,7 +44,6 @@ #include "mgatex.h" #include "mgavb.h" -#include "mga_drm_public.h" #include "mga_xmesa.h" @@ -51,11 +51,8 @@ #define MGA_FIELD(field,val) (((val) << (field ## _SHIFT)) & ~(field ## _MASK)) #define MGA_GET_FIELD(field, val) ((val & ~(field ## _MASK)) >> (field ## _SHIFT)) -#define MGA_CHIP_MGAG200 0 -#define MGA_CHIP_MGAG400 1 - -#define MGA_IS_G200(mmesa) (mmesa->mgaScreen->chipset == MGA_CHIP_MGAG200) -#define MGA_IS_G400(mmesa) (mmesa->mgaScreen->chipset == MGA_CHIP_MGAG400) +#define MGA_IS_G200(mmesa) (mmesa->mgaScreen->chipset == MGA_CARD_TYPE_G200) +#define MGA_IS_G400(mmesa) (mmesa->mgaScreen->chipset == MGA_CARD_TYPE_G400) /* SoftwareFallback @@ -65,6 +62,7 @@ */ #define MGA_FALLBACK_TEXTURE 0x1 #define MGA_FALLBACK_BUFFER 0x2 +#define MGA_FALLBACK_STIPPLE 0x3 /* For mgaCtx->new_state. @@ -97,17 +95,30 @@ typedef void (*mga_interp_func)( GLfloat t, #define MGA_PF_8888 (10 << 4) #define MGA_PF_HASALPHA (8 << 4) + + +/* Reasons why the GL_BLEND fallback mightn't work: + */ +#define MGA_BLEND_ENV_COLOR 0x1 +#define MGA_BLEND_MULTITEX 0x2 + + struct mga_context_t { GLcontext *glCtx; - /* Hardware state - moved from mgabuf.h - */ - mgaUI32 Setup[MGA_CTX_SETUP_SIZE]; - /* Variable sized vertices + /* Bookkeeping for texturing */ - mgaUI32 vertsize; + int lastTexHeap; + struct mga_texture_object_s TexObjList[MGA_NR_TEX_HEAPS]; + struct mga_texture_object_s SwappedOut; + struct mga_texture_object_s *CurrentTexObj[2]; + memHeap_t *texHeap[MGA_NR_TEX_HEAPS]; + int c_texupload; + int c_texusage; + int tex_thrash; + /* Map GL texture units onto hardware. */ @@ -116,68 +127,84 @@ struct mga_context_t { mgaUI32 tex_dest[2]; + /* Manage fallbacks + */ + mgaUI32 IndirectTriangles; + int Fallback; - /* bookkeeping for textureing */ - struct mga_texture_object_s TexObjList; - struct mga_texture_object_s SwappedOut; - struct mga_texture_object_s *CurrentTexObj[2]; - - - /* shared texture palette */ - mgaUI16 GlobalPalette[256]; - - int Fallback; /* or'ed values of FALLBACK_* */ - /* Support for CVA and the fast paths */ + /* Support for CVA and the fastpath + */ unsigned int setupdone; unsigned int setupindex; unsigned int renderindex; unsigned int using_fast_path; - unsigned int using_immediate_fast_path; mga_interp_func interp; - /* Shortcircuit some state changes */ + + /* Support for limited GL_BLEND fallback + */ + unsigned int blend_flags; + unsigned int envcolor; + + + /* Shortcircuit some state changes + */ points_func PointsFunc; line_func LineFunc; triangle_func TriangleFunc; quad_func QuadFunc; - /* Manage our own state */ + + /* Manage driver and hardware state + */ GLuint new_state; GLuint dirty; - - GLubyte clearcolor[4]; - GLushort MonoColor; - GLushort ClearColor; + GLuint Setup[MGA_CTX_SETUP_SIZE]; + GLuint warp_pipe; + GLuint vertsize; + GLushort MonoColor; + GLushort ClearColor; + GLuint poly_stipple; - /* DRI stuff + /* Dma buffers */ - drmBufPtr dma_buffer; + drmBufPtr vertex_dma_buffer; + drmBufPtr iload_buffer; - GLframebuffer *glBuffer; - memHeap_t *texHeap; + + /* Drawable, cliprect and scissor information + */ + int dirty_cliprects; /* which sets of cliprects are uptodate? */ + int draw_buffer; /* which buffer are we rendering to */ + int drawOffset; /* draw buffer address in space */ + int read_buffer; + int readOffset; + int drawX, drawY; /* origin of drawable in draw buffer */ + int lastX, lastY; /* detect DSTORG bug */ + GLuint numClipRects; /* cliprects for the draw buffer */ + XF86DRIClipRectPtr pClipRects; + XF86DRIClipRectRec draw_rect; + drm_clip_rect_t scissor_rect; + int scissor; - GLuint needClip; - GLuint warp_pipe; - /* These refer to the current draw (front vs. back) buffer: + /* Texture aging and DMA based aging. */ - int drawOffset; /* draw buffer address in agp space */ - int drawX; /* origin of drawable in draw buffer */ - int drawY; - GLuint numClipRects; /* cliprects for that buffer */ - XF86DRIClipRectPtr pClipRects; + unsigned int texAge[MGA_NR_TEX_HEAPS];/* texture LRU age */ + int dirtyAge; /* buffer age for synchronization */ + int lastSwap; /* throttling runaway apps */ - int texAge; - XF86DRIClipRectRec draw_rect; + /* Mirrors of some DRI state. + */ + GLframebuffer *glBuffer; drmContext hHWContext; drmLock *driHwLock; int driFd; Display *display; - __DRIdrawablePrivate *driDrawable; __DRIscreenPrivate *driScreen; mgaScreenPrivate *mgaScreen; @@ -191,16 +218,12 @@ typedef struct { /* dma stuff */ mgaUI32 systemTexture; - mgaUI32 noSetupDma; mgaUI32 default32BitTextures; - mgaUI32 swapBuffersCount; /* options */ mgaUI32 nullprims; /* skip all primitive generation */ - mgaUI32 noFallback; /* don't fall back to software, do - best-effort rendering */ - mgaUI32 skipDma; /* don't send anything to the hardware */ + mgaUI32 noFallback; /* performance counters */ mgaUI32 c_textureUtilization; @@ -240,10 +263,12 @@ extern mgaGlx_t mgaglx; extern int MGA_DEBUG; #endif -#define MGA_DEBUG_ALWAYS_SYNC 0x1 -#define MGA_DEBUG_VERBOSE_MSG 0x2 -#define MGA_DEBUG_VERBOSE_LRU 0x4 -#define MGA_DEBUG_VERBOSE_DRI 0x8 +#define DEBUG_ALWAYS_SYNC 0x1 +#define DEBUG_VERBOSE_MSG 0x2 +#define DEBUG_VERBOSE_LRU 0x4 +#define DEBUG_VERBOSE_DRI 0x8 +#define DEBUG_VERBOSE_IOCTL 0x10 +#define DEBUG_VERBOSE_2D 0x20 static __inline__ mgaUI32 mgaPackColor(mgaUI32 format, mgaUI8 r, mgaUI8 g, diff --git a/xc/lib/GL/mesa/src/drv/mga/mgaspan.c b/xc/lib/GL/mesa/src/drv/mga/mgaspan.c index 38e3cdde8..9bf62391c 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgaspan.c +++ b/xc/lib/GL/mesa/src/drv/mga/mgaspan.c @@ -5,70 +5,99 @@ #include "mgalog.h" #include "mgaspan.h" +#define DBG 0 + #define LOCAL_VARS \ - mgaContextPtr mmesa = MGA_CONTEXT( ctx ); \ __DRIdrawablePrivate *dPriv = mmesa->driDrawable; \ - __DRIscreenPrivate *sPriv = mmesa->driScreen; \ mgaScreenPrivate *mgaScreen = mmesa->mgaScreen; \ - GLuint pitch = mgaScreen->backPitch; \ + __DRIscreenPrivate *sPriv = mmesa->driScreen; \ + GLuint pitch = mgaScreen->frontPitch; \ GLuint height = dPriv->h; \ + char *read_buf = (char *)(sPriv->pFB + \ + mmesa->readOffset + \ + dPriv->x * 2 + \ + dPriv->y * pitch); \ char *buf = (char *)(sPriv->pFB + \ mmesa->drawOffset + \ dPriv->x * 2 + \ + dPriv->y * pitch); \ + GLushort p = MGA_CONTEXT( ctx )->MonoColor; \ + (void) read_buf; (void) buf; (void) p + + + +#define LOCAL_DEPTH_VARS \ + __DRIdrawablePrivate *dPriv = mmesa->driDrawable; \ + mgaScreenPrivate *mgaScreen = mmesa->mgaScreen; \ + __DRIscreenPrivate *sPriv = mmesa->driScreen; \ + GLuint pitch = mgaScreen->frontPitch; \ + GLuint height = dPriv->h; \ + char *buf = (char *)(sPriv->pFB + \ + mgaScreen->depthOffset + \ + dPriv->x * 2 + \ dPriv->y * pitch) -#define INIT_MONO_PIXEL(p) \ - GLushort p = MGA_CONTEXT( ctx )->MonoColor; +#define INIT_MONO_PIXEL(p) -#define CLIPPIXEL(_x,_y) (_x >= minx && _x <= maxx && \ - _y >= miny && _y <= maxy) +#define CLIPPIXEL(_x,_y) (_x >= minx && _x < maxx && \ + _y >= miny && _y < maxy) -#define CLIPSPAN(_x,_y,_n,_x1,_n1) \ +#define CLIPSPAN(_x,_y,_n,_x1,_n1,_i) \ if (_y < miny || _y >= maxy) _n1 = 0, _x1 = x; \ else { \ _n1 = _n; \ _x1 = _x; \ - if (_x1 < minx) _n1 -= (minx - _x1), _x1 = minx; \ - if (_x1 + _n1 > maxx) n1 -= (_x1 + n1 - maxx); \ + if (_x1 < minx) _i += (minx - _x1), _x1 = minx; \ + if (_x1 + _n1 >= maxx) n1 -= (_x1 + n1 - maxx) + 1; \ } - +#define HW_LOCK() \ + mgaContextPtr mmesa = MGA_CONTEXT(ctx); \ + LOCK_HARDWARE_QUIESCENT(mmesa); #define HW_CLIPLOOP() \ do { \ int _nc = mmesa->numClipRects; \ - LOCK_HARDWARE_QUIESCENT(mmesa); \ while (_nc--) { \ - int minx = mmesa->pClipRects[_nc].x1 - mmesa->drawX; \ - int miny = mmesa->pClipRects[_nc].y1 - mmesa->drawY; \ - int maxx = mmesa->pClipRects[_nc].x2 - mmesa->drawX; \ + int minx = mmesa->pClipRects[_nc].x1 - mmesa->drawX; \ + int miny = mmesa->pClipRects[_nc].y1 - mmesa->drawY; \ + int maxx = mmesa->pClipRects[_nc].x2 - mmesa->drawX; \ int maxy = mmesa->pClipRects[_nc].y2 - mmesa->drawY; - #define HW_ENDCLIPLOOP() \ } \ - UNLOCK_HARDWARE(mmesa); \ } while (0) +#define HW_UNLOCK() \ + UNLOCK_HARDWARE(mmesa); + + + -#define Y_FLIP(_y) (height - _y) + + + +/* 16 bit, 565 rgb color spanline and pixel functions + */ +#define Y_FLIP(_y) (height - _y - 1) #define WRITE_RGBA( _x, _y, r, g, b, a ) \ - *(GLushort *)(buf + _x*2 + _y*pitch) = ( ((r & 0x1f) << 11) | \ - ((g & 0x3f) << 5) | \ - ((b & 0x1f))) + *(GLushort *)(buf + _x*2 + _y*pitch) = ( (((int)r & 0xf8) << 8) | \ + (((int)g & 0xfc) << 3) | \ + (((int)b & 0xf8) >> 3)) + #define WRITE_PIXEL( _x, _y, p ) \ *(GLushort *)(buf + _x*2 + _y*pitch) = p #define READ_RGBA( rgba, _x, _y ) \ do { \ - GLushort p = *(GLushort *)(buf + _x*2 + _y*pitch); \ - rgba[0] = (p >> 11) & 0x1f; \ - rgba[1] = (p >> 5) & 0x3f; \ - rgba[2] = (p >> 0) & 0x1f; \ + GLushort p = *(GLushort *)(read_buf + _x*2 + _y*pitch); \ + rgba[0] = (p >> 8) & 0xf8; \ + rgba[1] = (p >> 3) & 0xfc; \ + rgba[2] = (p << 3) & 0xf8; \ rgba[3] = 0; /* or 255? */ \ } while(0) @@ -78,21 +107,21 @@ do { \ - -#define WRITE_RGBA( _x, _y, r, g, b, a ) \ - *(GLushort *)(buf + _x*2 + _y*pitch) = ( ((r & 0x1f) << 10) | \ - ((g & 0x1f) << 5) | \ - ((b & 0x1f))) - +/* 15 bit, 555 rgb color spanline and pixel functions + */ +#define WRITE_RGBA( _x, _y, r, g, b, a ) \ + *(GLushort *)(buf + _x*2 + _y*pitch) = (((r & 0xf8) << 7) | \ + ((g & 0xf8) << 3) | \ + ((b & 0xf8) >> 3)) #define WRITE_PIXEL( _x, _y, p ) \ *(GLushort *)(buf + _x*2 + _y*pitch) = p #define READ_RGBA( rgba, _x, _y ) \ do { \ - GLushort p = *(GLushort *)(buf + _x*2 + _y*pitch); \ - rgba[0] = (p >> 10) & 0x1f; \ - rgba[1] = (p >> 5) & 0x1f; \ - rgba[2] = (p >> 0) & 0x1f; \ + GLushort p = *(GLushort *)(read_buf + _x*2 + _y*pitch); \ + rgba[0] = (p >> 7) & 0xf8; \ + rgba[1] = (p >> 3) & 0xf8; \ + rgba[2] = (p << 3) & 0xf8; \ rgba[3] = 0; /* or 255? */ \ } while(0) @@ -101,27 +130,19 @@ do { \ -#if 0 -#define WRITE_RGBA( _x, _y, r, g, b, a ) \ - *(GLuint *)(buf + _x*4 + _y*pitch) = ( ((r) << 16) | \ - ((g) << 8) | \ - ((b))) +/* 16 bit depthbuffer functions. + */ +#define WRITE_DEPTH( _x, _y, d ) \ + *(GLdepth *)(buf + _x*2 + _y*pitch) = d; + +#define READ_DEPTH( d, _x, _y ) \ + d = *(GLdepth *)(buf + _x*2 + _y*pitch); + +#define TAG(x) mga##x##_16 +#include "depthtmp.h" -#define WRITE_PIXEL( _x, _y, p ) \ - *(GLuint *)(buf + _x*4 + _y*pitch) = p -#define READ_RGBA( rgba, _x, _y ) \ -do { \ - GLuint p = *(GLuint *)(buf + _x*4 + _y*pitch); \ - rgba[0] = (p >> 16) & 0xff; \ - rgba[1] = (p >> 8) & 0xff; \ - rgba[2] = (p >> 0) & 0xff; \ - rgba[3] = 0; /* or 255? */ \ -} while(0) -#define TAG(x) mga##x##_888 -#include "spantmp.h" -#endif void mgaDDInitSpanFuncs( GLcontext *ctx ) { @@ -143,6 +164,11 @@ void mgaDDInitSpanFuncs( GLcontext *ctx ) ctx->Driver.ReadRGBAPixels = mgaReadRGBAPixels_555; } + ctx->Driver.ReadDepthSpan = mgaReadDepthSpan_16; + ctx->Driver.WriteDepthSpan = mgaWriteDepthSpan_16; + ctx->Driver.ReadDepthPixels = mgaReadDepthPixels_16; + ctx->Driver.WriteDepthPixels = mgaWriteDepthPixels_16; + ctx->Driver.WriteCI8Span =NULL; ctx->Driver.WriteCI32Span =NULL; ctx->Driver.WriteMonoCISpan =NULL; diff --git a/xc/lib/GL/mesa/src/drv/mga/mgastate.c b/xc/lib/GL/mesa/src/drv/mga/mgastate.c index ff9063e0b..0dacd7646 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgastate.c +++ b/xc/lib/GL/mesa/src/drv/mga/mgastate.c @@ -16,7 +16,7 @@ #include "mgavb.h" #include "mgatris.h" #include "mgaregs.h" -#include "mga_drm_public.h" +#include "mgabuffers.h" static void mgaUpdateZMode(const GLcontext *ctx) { @@ -60,17 +60,20 @@ static void mgaUpdateZMode(const GLcontext *ctx) static void mgaDDAlphaFunc(GLcontext *ctx, GLenum func, GLclampf ref) { + FLUSH_BATCH( MGA_CONTEXT(ctx) ); MGA_CONTEXT(ctx)->new_state |= MGA_NEW_ALPHA; } static void mgaDDBlendEquation(GLcontext *ctx, GLenum mode) { + FLUSH_BATCH( MGA_CONTEXT(ctx) ); MGA_CONTEXT(ctx)->new_state |= MGA_NEW_ALPHA; } static void mgaDDBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor) { + FLUSH_BATCH( MGA_CONTEXT(ctx) ); MGA_CONTEXT(ctx)->new_state |= MGA_NEW_ALPHA; } @@ -78,6 +81,7 @@ static void mgaDDBlendFuncSeparate( GLcontext *ctx, GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorA, GLenum dfactorA ) { + FLUSH_BATCH( MGA_CONTEXT(ctx) ); MGA_CONTEXT(ctx)->new_state |= MGA_NEW_ALPHA; } @@ -87,6 +91,7 @@ static void mgaDDLightModelfv(GLcontext *ctx, GLenum pname, const GLfloat *param) { if (pname == GL_LIGHT_MODEL_COLOR_CONTROL) { + FLUSH_BATCH( MGA_CONTEXT(ctx) ); MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE; } } @@ -95,6 +100,7 @@ static void mgaDDLightModelfv(GLcontext *ctx, GLenum pname, static void mgaDDShadeModel(GLcontext *ctx, GLenum mode) { if (1) { + FLUSH_BATCH( MGA_CONTEXT(ctx) ); MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE; mgaMsg(8, "mgaDDShadeModel: %x\n", mode); } @@ -103,11 +109,13 @@ static void mgaDDShadeModel(GLcontext *ctx, GLenum mode) static void mgaDDDepthFunc(GLcontext *ctx, GLenum func) { + FLUSH_BATCH( MGA_CONTEXT(ctx) ); MGA_CONTEXT(ctx)->new_state |= MGA_NEW_DEPTH; } static void mgaDDDepthMask(GLcontext *ctx, GLboolean flag) { + FLUSH_BATCH( MGA_CONTEXT(ctx) ); MGA_CONTEXT(ctx)->new_state |= MGA_NEW_DEPTH; } @@ -134,6 +142,7 @@ static void mgaUpdateFogAttrib( GLcontext *ctx ) static void mgaDDFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param) { + FLUSH_BATCH( MGA_CONTEXT(ctx) ); MGA_CONTEXT(ctx)->new_state |= MGA_NEW_FOG; } @@ -148,10 +157,11 @@ static void mgaDDFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param) static void mgaUpdateAlphaMode(GLcontext *ctx) { mgaContextPtr mmesa = MGA_CONTEXT( ctx ); + mgaScreenPrivate *mgaScreen = mmesa->mgaScreen; int a = 0; /* determine source of alpha for blending and testing */ - if ( !ctx->Texture.Enabled || (mmesa->Fallback & MGA_FALLBACK_TEXTURE)) + if ( !ctx->Texture.Enabled ) a |= AC_alphasel_diffused; else { switch (ctx->Texture.Unit[0].EnvMode) { @@ -168,7 +178,7 @@ static void mgaUpdateAlphaMode(GLcontext *ctx) } - /* alpha test control - disabled by default. + /* alpha test control. */ if (ctx->Color.AlphaEnabled) { GLubyte ref = ctx->Color.AlphaRef; @@ -219,13 +229,13 @@ static void mgaUpdateAlphaMode(GLcontext *ctx) case GL_ONE_MINUS_SRC_ALPHA: a |= AC_src_om_src_alpha; break; case GL_DST_ALPHA: - if (0) /*(mgaScreen->Attrib & MGA_PF_HASALPHA)*/ + if (mgaScreen->Attrib & MGA_PF_HASALPHA) a |= AC_src_dst_alpha; else a |= AC_src_one; break; case GL_ONE_MINUS_DST_ALPHA: - if (0) /*(mgaScreen->Attrib & MGA_PF_HASALPHA)*/ + if (mgaScreen->Attrib & MGA_PF_HASALPHA) a |= AC_src_om_dst_alpha; else a |= AC_src_zero; @@ -250,13 +260,13 @@ static void mgaUpdateAlphaMode(GLcontext *ctx) case GL_ONE_MINUS_SRC_COLOR: a |= AC_dst_om_src_color; break; case GL_DST_ALPHA: - if (0) /*(mgaDB->Attrib & MGA_PF_HASALPHA)*/ + if (mgaScreen->Attrib & MGA_PF_HASALPHA) a |= AC_dst_dst_alpha; else a |= AC_dst_one; break; case GL_ONE_MINUS_DST_ALPHA: - if (0) /*(mgaScreen->Attrib & MGA_PF_HASALPHA)*/ + if (mgaScreen->Attrib & MGA_PF_HASALPHA) a |= AC_dst_om_dst_alpha; else a |= AC_dst_zero; @@ -282,50 +292,44 @@ static void mgaUpdateAlphaMode(GLcontext *ctx) * Hardware clipping */ -static void mgaUpdateClipping(const GLcontext *ctx) +void mgaUpdateClipping(const GLcontext *ctx) { -#if 0 - mgaContextPtr mmesa = MGA_CONTEXT( ctx ); - __DRIdrawablePrivate *dPriv = mmesa->driDrawable; - int x1,x2,y1,y2; - - if ( ctx->Scissor.Enabled) { - x1 = ctx->Scissor.X; - x2 = ctx->Scissor.X + ctx->Scissor.Width - 1; - y1 = dPriv->Height - ctx->Scissor.Y - ctx->Scissor.Height; - y2 = dPriv->Height - ctx->Scissor.Y - 1; - } else { - x1 = 0; - y1 = 0; - x2 = mgaDB->Width-1; - y2 = mgaDB->Height-1; - } - - if (x1 < 0) x1 = 0; - if (y1 < 0) y1 = 0; - if (x2 >= mgaDB->Width) x2 = mgaDB->Width-1; - if (y2 >= mgaDB->Height) y2 = mgaDB->Height-1; - - if (x1 > x2 || y1 > y2) { - x1 = 0; x2 = 0; - y2 = 0; y1 = 1; - } - - - mmesa->Setup[MGA_CTXREG_CXBNDRY] = (MGA_FIELD(CXB_cxright,x2) | - MGA_FIELD(CXB_cxleft,x1)); - mmesa->Setup[MGA_CTXREG_YTOP] = y1*mgaDB->Pitch; - mmesa->Setup[MGA_CTXREG_YBOT] = y2*mgaDB->Pitch; - + mgaContextPtr mmesa = MGA_CONTEXT(ctx); - mmesa->dirty |= MGA_UPLOAD_CTX; -#endif + if (mmesa->driDrawable) + { + int x1 = mmesa->driDrawable->x + ctx->Scissor.X; + int y1 = mmesa->driDrawable->y + mmesa->driDrawable->h - (ctx->Scissor.Y+ + ctx->Scissor.Height); + int x2 = mmesa->driDrawable->x + ctx->Scissor.X+ctx->Scissor.Width; + int y2 = mmesa->driDrawable->y + mmesa->driDrawable->h - ctx->Scissor.Y; + + if (x1 < 0) x1 = 0; + if (y1 < 0) y1 = 0; + if (x2 < 0) x2 = 0; + if (y2 < 0) y2 = 0; + + mmesa->scissor_rect.x1 = x1; + mmesa->scissor_rect.y1 = y1; + mmesa->scissor_rect.x2 = x2; + mmesa->scissor_rect.y2 = y2; + + if (MGA_DEBUG&DEBUG_VERBOSE_2D) + fprintf(stderr, "SET SCISSOR %d,%d-%d,%d\n", + mmesa->scissor_rect.x1, + mmesa->scissor_rect.y1, + mmesa->scissor_rect.x2, + mmesa->scissor_rect.y2); + + mmesa->dirty |= MGA_UPLOAD_CLIPRECTS; + } } static void mgaDDScissor( GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h ) { + FLUSH_BATCH( MGA_CONTEXT(ctx) ); MGA_CONTEXT(ctx)->new_state |= MGA_NEW_CLIP; } @@ -339,35 +343,6 @@ static void mgaDDDither(GLcontext *ctx, GLboolean enable) } -static GLboolean mgaDDSetBuffer(GLcontext *ctx, GLenum mode ) -{ - mgaContextPtr mmesa = MGA_CONTEXT(ctx); - - mmesa->Fallback &= ~MGA_FALLBACK_BUFFER; - - if (mode == GL_FRONT_LEFT) - { - mmesa->drawOffset = mmesa->mgaScreen->fbOffset; - mmesa->Setup[MGA_CTXREG_DSTORG] = mmesa->mgaScreen->fbOffset; - mmesa->dirty |= MGA_UPLOAD_CTX; - mgaXMesaSetFrontClipRects( mmesa ); - return GL_TRUE; - } - else if (mode == GL_BACK_LEFT) - { - mmesa->drawOffset = mmesa->mgaScreen->backOffset; - mmesa->Setup[MGA_CTXREG_DSTORG] = mmesa->mgaScreen->backOffset; - mmesa->dirty |= MGA_UPLOAD_CTX; - mgaXMesaSetBackClipRects( mmesa ); - return GL_TRUE; - } - else - { - mmesa->Fallback |= MGA_FALLBACK_BUFFER; - return GL_FALSE; - } -} - static void mgaDDSetColor(GLcontext *ctx, @@ -376,7 +351,7 @@ static void mgaDDSetColor(GLcontext *ctx, { mgaContextPtr mmesa = MGA_CONTEXT(ctx); - mmesa->MonoColor = mgaPackColor( mmesa->mgaScreen->fbFormat, + mmesa->MonoColor = mgaPackColor( mmesa->mgaScreen->Attrib, r, g, b, a ); } @@ -387,7 +362,7 @@ static void mgaDDClearColor(GLcontext *ctx, { mgaContextPtr mmesa = MGA_CONTEXT(ctx); - mmesa->ClearColor = mgaPackColor( mmesa->mgaScreen->fbFormat, + mmesa->ClearColor = mgaPackColor( mmesa->mgaScreen->Attrib, r, g, b, a ); } @@ -426,6 +401,7 @@ static void mgaUpdateCull( GLcontext *ctx ) static void mgaDDCullFaceFrontFace(GLcontext *ctx, GLenum mode) { + FLUSH_BATCH( MGA_CONTEXT(ctx) ); MGA_CONTEXT(ctx)->new_state |= MGA_NEW_CULL; } @@ -461,6 +437,7 @@ static GLboolean mgaDDColorMask(GLcontext *ctx, } if (mmesa->Setup[MGA_CTXREG_PLNWT] != mask) { + FLUSH_BATCH( MGA_CONTEXT(ctx) ); mmesa->Setup[MGA_CTXREG_PLNWT] = mask; MGA_CONTEXT(ctx)->new_state |= MGA_NEW_MASK; mmesa->dirty |= MGA_UPLOAD_CTX; @@ -470,6 +447,85 @@ static GLboolean mgaDDColorMask(GLcontext *ctx, } /* ============================================================= + * Polygon stipple + * + * The mga supports a subset of possible 4x4 stipples natively, GL + * wants 32x32. Fortunately stipple is usually a repeating pattern. + * Could also consider using a multitexturing mechanism for this, but + * that has real issues, too. + */ +static int mgaStipples[16] = { + 0xffff, + 0xa5a5, + 0x5a5a, + 0xa0a0, + 0x5050, + 0x0a0a, + 0x0505, + 0x8020, + 0x0401, + 0x1040, + 0x0208, + 0x0802, + 0x4010, + 0x0104, + 0x2080, + 0x0000 +}; + +static void mgaDDPolygonStipple( GLcontext *ctx, const GLubyte *mask ) +{ + mgaContextPtr mmesa = MGA_CONTEXT(ctx); + const GLubyte *m = mask; + GLubyte p[4]; + int i,j,k; + int active = (ctx->Polygon.StippleFlag && ctx->PB->primitive == GL_POLYGON); + GLuint stipple; + + FLUSH_BATCH(mmesa); + ctx->Driver.TriangleCaps |= DD_TRI_STIPPLE; + + if (active) { + mmesa->dirty |= MGA_UPLOAD_CTX; + mmesa->Setup[MGA_CTXREG_DWGCTL] &= ~(0xf<<20); + } + + p[0] = mask[0] & 0xf; p[0] |= p[0] << 4; + p[1] = mask[4] & 0xf; p[1] |= p[1] << 4; + p[2] = mask[8] & 0xf; p[2] |= p[2] << 4; + p[3] = mask[12] & 0xf; p[3] |= p[3] << 4; + + for (k = 0 ; k < 8 ; k++) + for (j = 0 ; j < 4; j++) + for (i = 0 ; i < 4 ; i++) + if (*m++ != p[j]) { + ctx->Driver.TriangleCaps &= ~DD_TRI_STIPPLE; + return; + } + + stipple = ( ((p[0] & 0xf) << 0) | + ((p[1] & 0xf) << 4) | + ((p[2] & 0xf) << 8) | + ((p[3] & 0xf) << 12) ); + + for (i = 0 ; i < 16 ; i++) + if (mgaStipples[i] == stipple) { + mmesa->poly_stipple = i<<20; + break; + } + + if (i == 16) { + ctx->Driver.TriangleCaps &= ~DD_TRI_STIPPLE; + return; + } + + if (active) { + mmesa->Setup[MGA_CTXREG_DWGCTL] &= ~(0xf<<20); + mmesa->Setup[MGA_CTXREG_DWGCTL] |= mmesa->poly_stipple; + } +} + +/* ============================================================= */ @@ -477,15 +533,16 @@ static GLboolean mgaDDColorMask(GLcontext *ctx, static void mgaDDPrintDirty( const char *msg, GLuint state ) { - fprintf(stderr, "%s (0x%x): %s%s%s%s%s%s\n", + fprintf(stderr, "%s (0x%x): %s%s%s%s%s%s%s\n", msg, (unsigned int) state, - (state & MGA_REQUIRE_QUIESCENT) ? "req-quiescent, " : "", + (state & MGA_WAIT_AGE) ? "wait-age, " : "", (state & MGA_UPLOAD_TEX0IMAGE) ? "upload-tex0-img, " : "", (state & MGA_UPLOAD_TEX1IMAGE) ? "upload-tex1-img, " : "", (state & MGA_UPLOAD_CTX) ? "upload-ctx, " : "", (state & MGA_UPLOAD_TEX0) ? "upload-tex0, " : "", - (state & MGA_UPLOAD_TEX1) ? "upload-tex1, " : "" + (state & MGA_UPLOAD_TEX1) ? "upload-tex1, " : "", + (state & MGA_UPLOAD_PIPE) ? "upload-pipe, " : "" ); } @@ -494,7 +551,7 @@ static void mgaDDPrintDirty( const char *msg, GLuint state ) */ void mgaEmitHwStateLocked( mgaContextPtr mmesa ) { - if (MGA_DEBUG & MGA_DEBUG_VERBOSE_MSG) + if (MGA_DEBUG & DEBUG_VERBOSE_MSG) mgaDDPrintDirty( "mgaEmitHwStateLocked", mmesa->dirty ); if ((mmesa->dirty & MGA_UPLOAD_TEX0IMAGE) && mmesa->CurrentTexObj[0]) @@ -503,27 +560,28 @@ void mgaEmitHwStateLocked( mgaContextPtr mmesa ) if ((mmesa->dirty & MGA_UPLOAD_TEX1IMAGE) && mmesa->CurrentTexObj[1]) mgaUploadTexImages(mmesa, mmesa->CurrentTexObj[1]); - if (mmesa->dirty & MGA_UPLOAD_CTX) { + if (mmesa->dirty & MGA_UPLOAD_CTX) memcpy( mmesa->sarea->ContextState, mmesa->Setup, sizeof(mmesa->Setup)); - if (mmesa->CurrentTexObj[0]) + if ((mmesa->dirty & MGA_UPLOAD_TEX0) && mmesa->CurrentTexObj[0]) memcpy(mmesa->sarea->TexState[0], mmesa->CurrentTexObj[0]->Setup, sizeof(mmesa->sarea->TexState[0])); - if (mmesa->CurrentTexObj[1]) + if ((mmesa->dirty & MGA_UPLOAD_TEX1) && mmesa->CurrentTexObj[1]) memcpy(mmesa->sarea->TexState[1], mmesa->CurrentTexObj[1]->Setup, sizeof(mmesa->sarea->TexState[1])); - } - if (mmesa->dirty & MGA_UPLOAD_PIPE) - mmesa->sarea->WarpPipe = mmesa->setupindex & MGA_WARP_T2GZSAF; - + mmesa->sarea->WarpPipe = mmesa->setupindex & MGA_WARP_T2GZSAF; mmesa->sarea->dirty |= mmesa->dirty; - mmesa->dirty = 0; +#if 0 + fprintf(stderr, "in mgaEmitHwStateLocked: dirty now %x\n", + mmesa->sarea->dirty); +#endif + mmesa->dirty &= (MGA_UPLOAD_CLIPRECTS|MGA_WAIT_AGE); } @@ -533,29 +591,50 @@ void mgaEmitHwStateLocked( mgaContextPtr mmesa ) static void mgaDDEnable(GLcontext *ctx, GLenum cap, GLboolean state) { + mgaContextPtr mmesa = MGA_CONTEXT( ctx ); + switch(cap) { case GL_ALPHA_TEST: - MGA_CONTEXT(ctx)->new_state |= MGA_NEW_ALPHA; + FLUSH_BATCH( mmesa ); + mmesa->new_state |= MGA_NEW_ALPHA; break; case GL_BLEND: - MGA_CONTEXT(ctx)->new_state |= MGA_NEW_ALPHA; + FLUSH_BATCH( mmesa ); + mmesa->new_state |= MGA_NEW_ALPHA; break; case GL_DEPTH_TEST: - MGA_CONTEXT(ctx)->new_state |= MGA_NEW_DEPTH; + FLUSH_BATCH( mmesa ); + mmesa->new_state |= MGA_NEW_DEPTH; break; case GL_SCISSOR_TEST: - MGA_CONTEXT(ctx)->new_state |= MGA_NEW_CLIP; + FLUSH_BATCH( mmesa ); + mmesa->scissor = state; + mmesa->new_state |= MGA_NEW_CLIP; break; case GL_FOG: - MGA_CONTEXT(ctx)->new_state |= MGA_NEW_FOG; + FLUSH_BATCH( mmesa ); + mmesa->new_state |= MGA_NEW_FOG; break; case GL_CULL_FACE: - MGA_CONTEXT(ctx)->new_state |= MGA_NEW_CULL; + FLUSH_BATCH( mmesa ); + mmesa->new_state |= MGA_NEW_CULL; break; case GL_TEXTURE_1D: case GL_TEXTURE_2D: case GL_TEXTURE_3D: - MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE; + FLUSH_BATCH( mmesa ); + mmesa->new_state |= MGA_NEW_TEXTURE; + break; + case GL_POLYGON_STIPPLE: + if ((ctx->Driver.TriangleCaps & DD_TRI_STIPPLE) && + ctx->PB->primitive == GL_POLYGON) + { + FLUSH_BATCH(mmesa); + mmesa->dirty |= MGA_UPLOAD_CTX; + mmesa->Setup[MGA_CTXREG_DWGCTL] &= ~(0xf<<20); + if (state) + mmesa->Setup[MGA_CTXREG_DWGCTL] |= mmesa->poly_stipple; + } break; default: ; @@ -581,6 +660,7 @@ static void mgaWarpUpdateState( GLcontext *ctx ) { mmesa->warp_pipe = index; mmesa->new_state |= MGA_NEW_WARP; + mmesa->dirty |= MGA_UPLOAD_PIPE; } } @@ -611,21 +691,15 @@ void mgaDDUpdateHwState( GLcontext *ctx ) if (new_state) { - mmesa->new_state = 0; + FLUSH_BATCH( mmesa ); - /* Emit any vertices for the current state. This will also - * push the current state into the sarea. - */ -/* mgaFlushVertices( mmesa ); */ + mmesa->new_state = 0; if (MESA_VERBOSE&VERBOSE_DRIVER) mgaDDPrintState("UpdateHwState", new_state); if (new_state & MGA_NEW_DEPTH) - { mgaUpdateZMode(ctx); - mgaDDInitDepthFuncs(ctx); - } if (new_state & MGA_NEW_ALPHA) mgaUpdateAlphaMode(ctx); @@ -641,8 +715,6 @@ void mgaDDUpdateHwState( GLcontext *ctx ) if (new_state & (MGA_NEW_WARP|MGA_NEW_TEXTURE)) mgaUpdateTextureState(ctx); - - mmesa->new_state = 0; /* tex uploads scribble newstate */ } } @@ -654,8 +726,17 @@ void mgaDDUpdateHwState( GLcontext *ctx ) void mgaDDReducedPrimitiveChange( GLcontext *ctx, GLenum prim ) { - mgaFlushVertices( MGA_CONTEXT(ctx) ); - mgaUpdateCull(ctx); + mgaContextPtr mmesa = MGA_CONTEXT(ctx); + + FLUSH_BATCH( mmesa ); + mgaUpdateCull(ctx); + + if (ctx->Polygon.StippleFlag && (ctx->Driver.TriangleCaps & DD_TRI_STIPPLE)) + { + mmesa->Setup[MGA_CTXREG_DWGCTL] &= ~(0xf<<20); + if (ctx->PB->primitive == GL_POLYGON) + mmesa->Setup[MGA_CTXREG_DWGCTL] |= mmesa->poly_stipple; + } } @@ -677,10 +758,16 @@ void mgaDDUpdateState( GLcontext *ctx ) /* Have to do this here to detect texture fallbacks in time: */ - if (MGA_CONTEXT(ctx)->new_state & MGA_NEW_TEXTURE) + if (mmesa->new_state & MGA_NEW_TEXTURE) mgaDDUpdateHwState( ctx ); - if (!mmesa->Fallback || mgaglx.noFallback) { + if (0) fprintf(stderr, "fallback %x indirect %x\n", mmesa->Fallback, + mmesa->IndirectTriangles); + + if (!mmesa->Fallback) { + ctx->IndirectTriangles &= ~DD_SW_RASTERIZE; + ctx->IndirectTriangles |= mmesa->IndirectTriangles; + ctx->Driver.PointsFunc=mmesa->PointsFunc; ctx->Driver.LineFunc=mmesa->LineFunc; ctx->Driver.TriangleFunc=mmesa->TriangleFunc; @@ -689,6 +776,60 @@ void mgaDDUpdateState( GLcontext *ctx ) } + +void mgaInitState( mgaContextPtr mmesa ) +{ + mgaScreenPrivate *mgaScreen = mmesa->mgaScreen; + GLcontext *ctx = mmesa->glCtx; + + if (ctx->Color.DriverDrawBuffer == GL_BACK_LEFT) { + mmesa->draw_buffer = MGA_BACK; + mmesa->read_buffer = MGA_BACK; + mmesa->drawOffset = mmesa->mgaScreen->backOffset; + mmesa->readOffset = mmesa->mgaScreen->backOffset; + mmesa->Setup[MGA_CTXREG_DSTORG] = mgaScreen->backOffset; + } else { + mmesa->drawOffset = mmesa->mgaScreen->frontOffset; + mmesa->readOffset = mmesa->mgaScreen->frontOffset; + mmesa->draw_buffer = MGA_FRONT; + mmesa->read_buffer = MGA_FRONT; + mmesa->Setup[MGA_CTXREG_DSTORG] = mgaScreen->frontOffset; + } + +/* mmesa->Setup[MGA_CTXREG_MACCESS] = mgaScreen->mAccess; */ +/* mmesa->Setup[MGA_CTXREG_DWGCTL] = ( DC_clipdis_disable | */ +/* (0xC << DC_bop_SHIFT) | */ +/* DC_shftzero_enable | */ +/* DC_zmode_nozcmp | */ +/* DC_atype_zi ); */ + + + mmesa->Setup[MGA_CTXREG_MACCESS] = 0x1; + mmesa->Setup[MGA_CTXREG_DWGCTL] = 0xc4074; + + + mmesa->Setup[MGA_CTXREG_PLNWT] = ~0; + mmesa->Setup[MGA_CTXREG_ALPHACTRL] = ( AC_src_one | + AC_dst_zero | + AC_amode_FCOL | + AC_astipple_disable | + AC_aten_disable | + AC_atmode_noacmp | + AC_alphasel_fromtex ); + + mmesa->Setup[MGA_CTXREG_FOGCOLOR] = + MGAPACKCOLOR888((GLubyte)(ctx->Fog.Color[0]*255.0F), + (GLubyte)(ctx->Fog.Color[1]*255.0F), + (GLubyte)(ctx->Fog.Color[2]*255.0F)); + + mmesa->Setup[MGA_CTXREG_WFLAG] = 0; + mmesa->Setup[MGA_CTXREG_TDUAL0] = 0; + mmesa->Setup[MGA_CTXREG_TDUAL1] = 0; + mmesa->Setup[MGA_CTXREG_FCOL] = 0; + mmesa->new_state = ~0; +} + + void mgaDDInitStateFuncs( GLcontext *ctx ) { ctx->Driver.UpdateState = mgaDDUpdateState; @@ -710,11 +851,14 @@ void mgaDDInitStateFuncs( GLcontext *ctx ) ctx->Driver.RenderStart = mgaDDUpdateHwState; ctx->Driver.RenderFinish = 0; - ctx->Driver.SetBuffer = mgaDDSetBuffer; + ctx->Driver.SetDrawBuffer = mgaDDSetDrawBuffer; + ctx->Driver.SetReadBuffer = mgaDDSetReadBuffer; ctx->Driver.Color = mgaDDSetColor; ctx->Driver.ClearColor = mgaDDClearColor; ctx->Driver.Dither = mgaDDDither; + ctx->Driver.PolygonStipple = mgaDDPolygonStipple; + ctx->Driver.Index = 0; ctx->Driver.ClearIndex = 0; ctx->Driver.IndexMask = 0; diff --git a/xc/lib/GL/mesa/src/drv/mga/mgastate.h b/xc/lib/GL/mesa/src/drv/mga/mgastate.h index 5ada1b23c..ac92cb0c2 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgastate.h +++ b/xc/lib/GL/mesa/src/drv/mga/mgastate.h @@ -7,9 +7,10 @@ extern void mgaDDUpdateHwState( GLcontext *ctx ); extern void mgaDDUpdateState( GLcontext *ctx ); extern void mgaDDReducedPrimitiveChange( GLcontext *ctx, GLenum prim ); -/* reprograms the current registers without updating them, used to -reset state after a dma buffer overflow */ -void mgaUpdateRegs( GLuint regs ); +extern void mgaInitState( mgaContextPtr mmesa ); + +extern void mgaUpdateClipping(const GLcontext *ctx); + #endif diff --git a/xc/lib/GL/mesa/src/drv/mga/mgatex.c b/xc/lib/GL/mesa/src/drv/mga/mgatex.c index be7ad6018..3afb70bad 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgatex.c +++ b/xc/lib/GL/mesa/src/drv/mga/mgatex.c @@ -47,22 +47,25 @@ * to it. */ static void mgaDestroyTexObj( mgaContextPtr mmesa, mgaTextureObjectPtr t ) { - int i; if ( !t ) return; /* free the texture memory */ - mmFreeMem( t->MemBlock ); + if (t->MemBlock) { + mmFreeMem( t->MemBlock ); + t->MemBlock = 0; + + if (t->age > mmesa->dirtyAge) + mmesa->dirtyAge = t->age; + } /* free mesa's link */ - t->tObj->DriverData = NULL; + if (t->tObj) + t->tObj->DriverData = NULL; /* see if it was the driver's current object */ - for ( i = 0 ; i < 2 ; i++ ) { - if ( mmesa->CurrentTexObj[i] == t ) { - mmesa->CurrentTexObj[i] = NULL; - } - } + if (t->bound) + mmesa->CurrentTexObj[t->bound - 1] = 0; remove_from_list(t); free( t ); @@ -73,6 +76,9 @@ static void mgaSwapOutTexObj(mgaContextPtr mmesa, mgaTextureObjectPtr t) if (t->MemBlock) { mmFreeMem(t->MemBlock); t->MemBlock = 0; + + if (t->age > mmesa->dirtyAge) + mmesa->dirtyAge = t->age; } t->dirty_images = ~0; @@ -80,22 +86,76 @@ static void mgaSwapOutTexObj(mgaContextPtr mmesa, mgaTextureObjectPtr t) } -void mgaResetGlobalLRU( mgaContextPtr mmesa ) +static void mgaPrintLocalLRU( mgaContextPtr mmesa, int heap ) +{ + mgaTextureObjectPtr t; + int sz = 1 << (mmesa->mgaScreen->logTextureGranularity[heap]); + + fprintf(stderr, "\nLocal LRU, heap %d:\n", heap); + + foreach( t, &(mmesa->TexObjList[heap]) ) { + if (!t->tObj) + fprintf(stderr, "Placeholder %d at %x sz %x\n", + t->MemBlock->ofs / sz, + t->MemBlock->ofs, + t->MemBlock->size); + else + fprintf(stderr, "Texture (bound %d) at %x sz %x\n", + t->bound, + t->MemBlock->ofs, + t->MemBlock->size); + + } + + fprintf(stderr, "\n\n"); +} + +static void mgaPrintGlobalLRU( mgaContextPtr mmesa, int heap ) +{ + int i, j; + drm_mga_tex_region_t *list = mmesa->sarea->texList[heap]; + + fprintf(stderr, "\nGlobal LRU, heap %d list %p:\n", heap, list); + + for (i = 0, j = MGA_NR_TEX_REGIONS ; i < MGA_NR_TEX_REGIONS ; i++) { + fprintf(stderr, "list[%d] age %d next %d prev %d\n", + j, list[j].age, list[j].next, list[j].prev); + j = list[j].next; + if (j == MGA_NR_TEX_REGIONS) break; + } + + if (j != MGA_NR_TEX_REGIONS) { + fprintf(stderr, "Loop detected in global LRU\n\n\n"); + for (i = 0 ; i < MGA_NR_TEX_REGIONS ; i++) { + fprintf(stderr, "list[%d] age %d next %d prev %d\n", + i, list[i].age, list[i].next, list[i].prev); + } + } + + fprintf(stderr, "\n\n"); +} + + +static void mgaResetGlobalLRU( mgaContextPtr mmesa, GLuint heap ) { - mgaTexRegion *list = mmesa->sarea->texList; - int sz = 1 << mmesa->mgaScreen->logTextureGranularity; + drm_mga_tex_region_t *list = mmesa->sarea->texList[heap]; + int sz = 1 << mmesa->mgaScreen->logTextureGranularity[heap]; int i; + mmesa->texAge[heap] = ++mmesa->sarea->texAge[heap]; + + if (0) fprintf(stderr, "mgaResetGlobalLRU %d\n", (int)heap); + /* (Re)initialize the global circular LRU list. The last element * in the array (MGA_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. */ - for (i = 0 ; (i+1) * sz < mmesa->mgaScreen->textureSize ; i++) { + for (i = 0 ; (i+1) * sz <= mmesa->mgaScreen->textureSize[heap] ; i++) { list[i].prev = i-1; list[i].next = i+1; - list[i].age = 0; + list[i].age = mmesa->sarea->texAge[heap]; } i--; @@ -104,30 +164,41 @@ void mgaResetGlobalLRU( mgaContextPtr mmesa ) list[i].next = MGA_NR_TEX_REGIONS; list[MGA_NR_TEX_REGIONS].prev = i; list[MGA_NR_TEX_REGIONS].next = 0; - mmesa->sarea->texAge = 0; + } static void mgaUpdateTexLRU( mgaContextPtr mmesa, mgaTextureObjectPtr t ) { int i; - int logsz = mmesa->mgaScreen->logTextureGranularity; + int heap = t->heap; + int logsz = mmesa->mgaScreen->logTextureGranularity[heap]; int start = t->MemBlock->ofs >> logsz; int end = (t->MemBlock->ofs + t->MemBlock->size - 1) >> logsz; - mgaTexRegion *list = mmesa->sarea->texList; + drm_mga_tex_region_t *list = mmesa->sarea->texList[heap]; - mmesa->texAge = ++mmesa->sarea->texAge; + mmesa->texAge[heap] = ++mmesa->sarea->texAge[heap]; + + if (!t->MemBlock) { + fprintf(stderr, "no memblock\n\n"); + return; + } /* Update our local LRU */ - move_to_head( &(mmesa->TexObjList), t ); + move_to_head( &(mmesa->TexObjList[heap]), t ); + + + if (0) + fprintf(stderr, "mgaUpdateTexLRU heap %d list %p\n", heap, list); + /* Update the global LRU */ for (i = start ; i <= end ; i++) { list[i].in_use = 1; - list[i].age = mmesa->texAge; + list[i].age = mmesa->texAge[heap]; /* remove_from_list(i) */ @@ -141,8 +212,12 @@ static void mgaUpdateTexLRU( mgaContextPtr mmesa, mgaTextureObjectPtr t ) list[(unsigned)list[MGA_NR_TEX_REGIONS].next].prev = i; list[MGA_NR_TEX_REGIONS].next = i; } -} + if (0) { + mgaPrintGlobalLRU(mmesa, t->heap); + mgaPrintLocalLRU(mmesa, t->heap); + } +} /* Called for every shared texture region which has increased in age * since we last held the lock. @@ -151,23 +226,29 @@ static void mgaUpdateTexLRU( mgaContextPtr mmesa, mgaTextureObjectPtr t ) * and pushes a placeholder texture onto the LRU list to represent * the other client's textures. */ -void mgaTexturesGone( mgaContextPtr mmesa, - GLuint offset, - GLuint size, - GLuint in_use ) +static void mgaTexturesGone( mgaContextPtr mmesa, + GLuint heap, + GLuint offset, + GLuint size, + GLuint in_use ) { mgaTextureObjectPtr t, tmp; - - foreach_s ( t, tmp, &mmesa->TexObjList ) { + + + + foreach_s ( t, tmp, &(mmesa->TexObjList[heap]) ) { if (t->MemBlock->ofs >= offset + size || t->MemBlock->ofs + t->MemBlock->size <= offset) continue; + + + /* It overlaps - kick it off. Need to hold onto the currently bound * objects, however. */ - if (t == mmesa->CurrentTexObj[0] || t == mmesa->CurrentTexObj[1]) + if (t->bound) mgaSwapOutTexObj( mmesa, t ); else mgaDestroyTexObj( mmesa, t ); @@ -178,12 +259,54 @@ void mgaTexturesGone( mgaContextPtr mmesa, t = (mgaTextureObjectPtr) calloc(1,sizeof(*t)); if (!t) return; - t->MemBlock = mmAllocMem( mmesa->texHeap, size, 0, offset); - insert_at_head( &mmesa->TexObjList, t ); + t->heap = heap; + t->MemBlock = mmAllocMem( mmesa->texHeap[heap], size, 0, offset); + if (!t->MemBlock) { + fprintf(stderr, "Couldn't alloc placeholder sz %x ofs %x\n", + (int)size, (int)offset); + mmDumpMemInfo( mmesa->texHeap[heap]); + return; + } + insert_at_head( &(mmesa->TexObjList[heap]), t ); } } +void mgaAgeTextures( mgaContextPtr mmesa, int heap ) +{ + drm_mga_sarea_t *sarea = mmesa->sarea; + int sz = 1 << (mmesa->mgaScreen->logTextureGranularity[heap]); + int idx, nr = 0; + + /* Have to go right round from the back to ensure stuff ends up + * LRU in our local list... Fix with a cursor pointer. + */ + for (idx = sarea->texList[heap][MGA_NR_TEX_REGIONS].prev ; + idx != MGA_NR_TEX_REGIONS && nr < MGA_NR_TEX_REGIONS ; + idx = sarea->texList[heap][idx].prev, nr++) + { + if (sarea->texList[heap][idx].age > mmesa->texAge[heap]) { + mgaTexturesGone(mmesa, heap, idx * sz, sz, 1); + } + } + + if (nr == MGA_NR_TEX_REGIONS) { + mgaTexturesGone(mmesa, heap, 0, + mmesa->mgaScreen->textureSize[heap], 0); + mgaResetGlobalLRU( mmesa, heap ); + } + + + if (0) { + mgaPrintGlobalLRU( mmesa, heap ); + mgaPrintLocalLRU( mmesa, heap ); + } + + mmesa->texAge[heap] = sarea->texAge[heap]; + mmesa->dirty |= MGA_UPLOAD_TEX0IMAGE | MGA_UPLOAD_TEX1IMAGE; +} + + /* * mgaSetTexWrappings */ @@ -281,22 +404,22 @@ static void mgaSetTexBorderColor(mgaTextureObjectPtr t, GLubyte color[4]) { /* - * mgaUploadSubImage + * mgaUploadSubImageLocked * * Perform an iload based update of a resident buffer. This is used for * both initial loading of the entire image, and texSubImage updates. * * Performed with the hardware lock held. */ -static void mgaUploadSubImage( mgaContextPtr mmesa, - mgaTextureObjectPtr t, - int level, - int x, int y, int width, int height ) { +static void mgaUploadSubImageLocked( mgaContextPtr mmesa, + mgaTextureObjectPtr t, + int level, + int x, int y, int width, int height ) { int x2; int dwords; - int dstorg; + int offset; struct gl_texture_image *image; - int texelBytes, texelsPerDword, texelMaccess; + int texelBytes, texelsPerDword, texelMaccess, length; if ( level < 0 || level >= MGA_TEX_MAXLEVELS ) { mgaMsg( 1, "mgaUploadSubImage: bad level: %i\n", level ); @@ -310,15 +433,9 @@ static void mgaUploadSubImage( mgaContextPtr mmesa, } /* find the proper destination offset for this level */ - dstorg = (mmesa->mgaScreen->textureOffset + t->MemBlock->ofs + + offset = (t->MemBlock->ofs + t->offsets[level]); - /* turn on PCI/AGP if needed - if ( textureHeapPhysical ) { - dstorg |= 1 | mgaglx.use_agp; - } - */ - texelBytes = t->texelBytes; switch( texelBytes ) { case 1: @@ -363,7 +480,7 @@ static void mgaUploadSubImage( mgaContextPtr mmesa, x = (x + (texelsPerDword-1)) & ~(texelsPerDword-1); width = x2 - x; } - + /* we may not be able to upload the entire texture in one batch due to register limits or dma buffer limits. Recursively split it up. */ @@ -374,7 +491,8 @@ static void mgaUploadSubImage( mgaContextPtr mmesa, } mgaMsg(10, "mgaUploadSubImage: recursively subdividing\n" ); - mgaUploadSubImage( mmesa, t, level, x, y, width, height >> 1 ); + mgaUploadSubImageLocked( mmesa, t, level, x, y, + width, height >> 1 ); y += ( height >> 1 ); height -= ( height >> 1 ); } @@ -385,31 +503,50 @@ static void mgaUploadSubImage( mgaContextPtr mmesa, /* bump the performance counter */ mgaglx.c_textureSwaps += ( dwords << 2 ); - -#if 0 - - /* fill in the secondary buffer with properly converted texels - from the mesa buffer */ - mgaConvertTexture( dest, texelBytes, image, x, y, width, height ); - - /* send the secondary data */ - mgaSecondaryDma( TT_BLIT, dest, dwords ); -#endif - + length = dwords * 4; + + /* Fill in the secondary buffer with properly converted texels + * from the mesa buffer. */ + if(t->heap == MGA_CARD_HEAP) { + mgaGetILoadBufferLocked( mmesa ); + mgaConvertTexture( (mgaUI32 *)mmesa->iload_buffer->address, + texelBytes, image, x, y, width, height ); + if(length < 64) length = 64; + mgaMsg(10, "TexelBytes : %d, offset: %d, length : %d\n", + texelBytes, + mmesa->mgaScreen->textureOffset[t->heap] + + offset + + y * width * 4/texelsPerDword, + length); + + mgaFireILoadLocked( mmesa, + mmesa->mgaScreen->textureOffset[t->heap] + + offset + + y * width * 4/texelsPerDword, + length); + } else { + /* This works, is slower for uploads to card space and needs + * additional synchronization with the dma stream. + */ + mgaConvertTexture( (mgaUI32 *) + (mmesa->mgaScreen->texVirtual[t->heap] + + offset + + y * width * 4/texelsPerDword), + texelBytes, image, x, y, width, height ); + } } - static void mgaUploadTexLevel( mgaContextPtr mmesa, - mgaTextureObjectPtr t, - int l ) + mgaTextureObjectPtr t, + int l ) { - mgaUploadSubImage( mmesa, - t, - l, - 0, 0, - t->tObj->Image[l]->Width, - t->tObj->Image[l]->Height); + mgaUploadSubImageLocked( mmesa, + t, + l, + 0, 0, + t->tObj->Image[l]->Width, + t->tObj->Image[l]->Height); } @@ -527,9 +664,11 @@ static void mgaCreateTexObj(mgaContextPtr mmesa, struct gl_texture_object *tObj) /* fill in our mga texture object */ t->tObj = tObj; t->ctx = mmesa; + t->age = 0; + t->bound = 0; - insert_at_tail(&(mmesa->TexObjList), t); + insert_at_tail(&(mmesa->SwappedOut), t); t->MemBlock = 0; @@ -596,34 +735,61 @@ static void mgaCreateTexObj(mgaContextPtr mmesa, struct gl_texture_object *tObj) tObj->DriverData = t; } +static void mgaMigrateTexture( mgaContextPtr mmesa, mgaTextureObjectPtr t ) +{ + /* NOT DONE */ +} -int mgaUploadTexImages( mgaContextPtr mmesa, mgaTextureObjectPtr t ) +static int mgaChooseTexHeap( mgaContextPtr mmesa, mgaTextureObjectPtr t ) { + return 0; +} + +int mgaUploadTexImages( mgaContextPtr mmesa, mgaTextureObjectPtr t ) +{ + int heap; int i; int ofs; mgaglx.c_textureSwaps++; + heap = t->heap = mgaChooseTexHeap( mmesa, t ); + /* Do we need to eject LRU texture objects? */ if (!t->MemBlock) { while (1) { - t->MemBlock = mmAllocMem( mmesa->texHeap, t->totalSize, 12, 0 ); + mgaTextureObjectPtr tmp = mmesa->TexObjList[heap].prev; + + t->MemBlock = mmAllocMem( mmesa->texHeap[heap], + t->totalSize, + 6, 0 ); if (t->MemBlock) break; - if (mmesa->TexObjList.prev == &(mmesa->TexObjList)) { - fprintf(stderr, "Failed to upload texture, sz %d\n", t->totalSize); - mmDumpMemInfo( mmesa->texHeap ); + if (mmesa->TexObjList[heap].prev->bound) { + fprintf(stderr, + "Hit bound texture in upload\n"); return -1; } - mgaDestroyTexObj( mmesa, mmesa->TexObjList.prev ); + if (mmesa->TexObjList[heap].prev == + &(mmesa->TexObjList[heap])) + { + fprintf(stderr, "Failed to upload texture, " + "sz %d\n", t->totalSize); + mmDumpMemInfo( mmesa->texHeap[heap] ); + return -1; + } + + mgaDestroyTexObj( mmesa, tmp ); } - ofs = t->MemBlock->ofs; + ofs = t->MemBlock->ofs + + mmesa->mgaScreen->textureOffset[heap] + ; t->Setup[MGA_TEXREG_ORG] = ofs; t->Setup[MGA_TEXREG_ORG1] = ofs + t->offsets[1]; @@ -638,8 +804,16 @@ int mgaUploadTexImages( mgaContextPtr mmesa, mgaTextureObjectPtr t ) */ mgaUpdateTexLRU( mmesa, t ); + + if (MGA_DEBUG&DEBUG_VERBOSE_LRU) + fprintf(stderr, "dispatch age: %d age freed memory: %d\n", + GET_DISPATCH_AGE(mmesa), mmesa->dirtyAge); + + if (mmesa->dirtyAge >= GET_DISPATCH_AGE(mmesa)) + mgaWaitAgeLocked( mmesa, mmesa->dirtyAge ); + if (t->dirty_images) { - if (MGA_DEBUG & MGA_DEBUG_VERBOSE_MSG) + if (MGA_DEBUG&DEBUG_VERBOSE_LRU) fprintf(stderr, "*"); for (i = 0 ; i <= t->lastLevel ; i++) @@ -692,12 +866,10 @@ static void mgaUpdateTextureEnvG200( GLcontext *ctx ) } } -/* I don't have the alpha values correct yet: - */ static void mgaUpdateTextureStage( GLcontext *ctx, int unit ) { mgaContextPtr mmesa = MGA_CONTEXT( ctx ); - mgaUI32 *reg = &mmesa->Setup[MGA_CTXREG_TDUAL0 + unit]; + GLuint *reg = &mmesa->Setup[MGA_CTXREG_TDUAL0 + unit]; GLuint source = mmesa->tmu_source[unit]; struct gl_texture_object *tObj = ctx->Texture.Unit[source].Current; @@ -725,13 +897,13 @@ static void mgaUpdateTextureStage( GLcontext *ctx, int unit ) *reg = ( TD0_color_arg2_diffuse | TD0_color_sel_mul | TD0_alpha_arg2_diffuse | - TD0_alpha_sel_arg1); + TD0_alpha_sel_mul); else *reg = ( TD0_color_arg2_prevstage | TD0_color_alpha_prevstage | TD0_color_sel_mul | TD0_alpha_arg2_prevstage | - TD0_alpha_sel_arg1); + TD0_alpha_sel_mul); break; case GL_DECAL: *reg = (TD0_color_arg2_fcol | @@ -751,20 +923,49 @@ static void mgaUpdateTextureStage( GLcontext *ctx, int unit ) TD0_color_add_add | TD0_color_sel_add | TD0_alpha_arg2_diffuse | - TD0_alpha_sel_arg1); + TD0_alpha_sel_add); else *reg = ( TD0_color_arg2_prevstage | TD0_color_alpha_prevstage | TD0_color_add_add | TD0_color_sel_add | TD0_alpha_arg2_prevstage | - TD0_alpha_sel_arg1); + TD0_alpha_sel_add); break; case GL_BLEND: - /* Use a multipass mechanism to do this: + if (0) + fprintf(stderr, "GL_BLEND unit %d flags %x\n", unit, + mmesa->blend_flags); + + if (mmesa->blend_flags) + mmesa->Fallback |= MGA_FALLBACK_TEXTURE; + return; + + /* Do singletexture GL_BLEND with 'all ones' env-color + * by using both texture units. Multitexture gl_blend + * is a fallback. */ - mmesa->Fallback |= MGA_FALLBACK_TEXTURE; + if (unit == 0) { + /* Part 1: R1 = Rf ( 1 - Rt ) + * A1 = Af At + */ + *reg = ( TD0_color_arg2_diffuse | + TD0_color_arg1_inv_enable | + TD0_color_sel_mul | + TD0_alpha_arg2_diffuse | + TD0_alpha_sel_arg1); + } else { + /* Part 2: R2 = R1 + Rt + * A2 = A1 + */ + *reg = ( TD0_color_arg2_prevstage | + TD0_color_add_add | + TD0_color_sel_add | + TD0_alpha_arg2_prevstage | + TD0_alpha_sel_arg2); + } + break; default: } @@ -782,9 +983,8 @@ static void mgaUpdateTextureObject( GLcontext *ctx, int unit ) { mgaMsg(15,"mgaUpdateTextureState %d\n", unit); /* disable texturing until it is known to be good */ - mmesa->Setup[MGA_CTXREG_DWGCTL] = - (( mmesa->Setup[MGA_CTXREG_DWGCTL] & DC_opcod_MASK ) | - DC_opcod_trap); + mmesa->Setup[MGA_CTXREG_DWGCTL] &= DC_opcod_MASK; + mmesa->Setup[MGA_CTXREG_DWGCTL] |= DC_opcod_trap; enabled = (ctx->Texture.Enabled>>(source*4))&TEXTURE0_ANY; if (enabled != TEXTURE0_2D) { @@ -804,7 +1004,6 @@ static void mgaUpdateTextureObject( GLcontext *ctx, int unit ) { if ( !tObj->DriverData ) { /* clear the current pointer so that texture object can be swapped out if necessary to make room */ - mmesa->CurrentTexObj[source] = NULL; mgaCreateTexObj( mmesa, tObj ); if ( !tObj->DriverData ) { @@ -815,9 +1014,8 @@ static void mgaUpdateTextureObject( GLcontext *ctx, int unit ) { } /* we definately have a valid texture now */ - mmesa->Setup[MGA_CTXREG_DWGCTL] = - (( mmesa->Setup[MGA_CTXREG_DWGCTL] & DC_opcod_MASK ) | - DC_opcod_texture_trap); + mmesa->Setup[MGA_CTXREG_DWGCTL] &= DC_opcod_MASK; + mmesa->Setup[MGA_CTXREG_DWGCTL] |= DC_opcod_texture_trap; t = (mgaTextureObjectPtr)tObj->DriverData; @@ -825,6 +1023,11 @@ static void mgaUpdateTextureObject( GLcontext *ctx, int unit ) { mmesa->dirty |= (MGA_UPLOAD_TEX0IMAGE << unit); mmesa->CurrentTexObj[unit] = t; + t->bound = unit+1; + + if (t->MemBlock) + mgaUpdateTexLRU( mmesa, t ); + t->Setup[MGA_TEXREG_CTL2] &= ~TMC_dualtex_enable; if (ctx->Texture.Enabled == (TEXTURE0_2D|TEXTURE1_2D)) @@ -848,23 +1051,31 @@ void mgaUpdateTextureState( GLcontext *ctx ) mgaContextPtr mmesa = MGA_CONTEXT( ctx ); mmesa->Fallback &= ~MGA_FALLBACK_TEXTURE; + if (mmesa->CurrentTexObj[0]) mmesa->CurrentTexObj[0]->bound = 0; + if (mmesa->CurrentTexObj[1]) mmesa->CurrentTexObj[1]->bound = 0; + mmesa->CurrentTexObj[0] = 0; + mmesa->CurrentTexObj[1] = 0; + if (MGA_IS_G400(mmesa)) { mgaUpdateTextureObject( ctx, 0 ); mgaUpdateTextureStage( ctx, 0 ); - mmesa->Setup[MGA_CTXREG_TDUAL1] = mmesa->Setup[MGA_CTXREG_TDUAL0]; + mmesa->Setup[MGA_CTXREG_TDUAL1] = + mmesa->Setup[MGA_CTXREG_TDUAL0]; if (mmesa->multitex) { mgaUpdateTextureObject( ctx, 1 ); mgaUpdateTextureStage( ctx, 1 ); } + + mmesa->dirty |= MGA_UPLOAD_TEX0 | MGA_UPLOAD_TEX1; } else { mgaUpdateTextureObject( ctx, 0 ); - mgaUpdateTextureEnvG200( ctx ); + mgaUpdateTextureEnvG200( ctx ); } /* schedule the register writes */ - mmesa->dirty |= MGA_UPLOAD_CTX; + mmesa->dirty |= MGA_UPLOAD_CTX | MGA_UPLOAD_TEX0; } @@ -880,14 +1091,57 @@ Driver functions called directly from mesa /* * mgaTexEnv */ -void mgaTexEnv( GLcontext *ctx, GLenum pname, const GLfloat *param ) { +void mgaTexEnv( GLcontext *ctx, GLenum pname, const GLfloat *param ) +{ + mgaContextPtr mmesa = MGA_CONTEXT(ctx); mgaMsg( 10, "mgaTexEnv( %i )\n", pname ); + if (pname == GL_TEXTURE_ENV_MODE) { /* force the texture state to be updated */ - MGA_CONTEXT(ctx)->CurrentTexObj[0] = 0; + FLUSH_BATCH( MGA_CONTEXT(ctx) ); MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE; } + else if (pname == GL_TEXTURE_ENV_COLOR) + { + struct gl_texture_unit *texUnit = + &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; + GLfloat *fc = texUnit->EnvColor; + GLubyte c[4]; + GLuint col; + + + c[0] = fc[0]; + c[1] = fc[1]; + c[2] = fc[2]; + c[3] = fc[3]; + + /* No alpha at 16bpp? + */ + col = mgaPackColor( mmesa->mgaScreen->Attrib, + c[0], c[1], c[2], c[3] ); + + mmesa->envcolor = (c[3]<<24) | (c[0]<<16) | (c[1]<<8) | (c[2]); + + if (mmesa->Setup[MGA_CTXREG_FCOL] != col) { + FLUSH_BATCH(mmesa); + mmesa->Setup[MGA_CTXREG_FCOL] = col; + mmesa->dirty |= MGA_UPLOAD_CTX; + + mmesa->blend_flags &= ~MGA_BLEND_ENV_COLOR; + + /* Actually just require all four components to be + * equal. This permits a single-pass GL_BLEND. + * + * More complex multitexture/multipass fallbacks + * for blend can be done later. + */ + if (mmesa->envcolor != 0x0 && + mmesa->envcolor != 0xffffffff) + mmesa->blend_flags |= MGA_BLEND_ENV_COLOR; + } + } + } /* @@ -907,6 +1161,7 @@ void mgaTexImage( GLcontext *ctx, GLenum target, mgaUpdateTextureState time. */ t = (mgaTextureObjectPtr) tObj->DriverData; if ( t ) { + if (t->bound) FLUSH_BATCH(mmesa); /* if this is the current object, it will force an update */ mgaDestroyTexObj( mmesa, t ); mmesa->new_state |= MGA_NEW_TEXTURE; @@ -936,6 +1191,7 @@ void mgaTexSubImage( GLcontext *ctx, GLenum target, mgaUpdateTextureState time. */ t = (mgaTextureObjectPtr) tObj->DriverData; if ( t ) { + if (t->bound) FLUSH_BATCH(mmesa); /* if this is the current object, it will force an update */ mgaDestroyTexObj( mmesa, t ); mmesa->new_state |= MGA_NEW_TEXTURE; @@ -956,7 +1212,9 @@ void mgaTexSubImage( GLcontext *ctx, GLenum target, */ void mgaTexParameter( GLcontext *ctx, GLenum target, struct gl_texture_object *tObj, - GLenum pname, const GLfloat *params ) { + GLenum pname, const GLfloat *params ) +{ + mgaContextPtr mmesa = MGA_CONTEXT( ctx ); mgaTextureObjectPtr t; mgaMsg( 10, "mgaTexParameter( %p, %i )\n", tObj, pname ); @@ -973,52 +1231,68 @@ void mgaTexParameter( GLcontext *ctx, GLenum target, switch (pname) { case GL_TEXTURE_MIN_FILTER: case GL_TEXTURE_MAG_FILTER: + if (t->bound) FLUSH_BATCH(mmesa); mgaSetTexFilter( t, tObj->MinFilter, tObj->MagFilter ); break; case GL_TEXTURE_WRAP_S: case GL_TEXTURE_WRAP_T: + if (t->bound) FLUSH_BATCH(mmesa); mgaSetTexWrapping(t,tObj->WrapS,tObj->WrapT); break; case GL_TEXTURE_BORDER_COLOR: + if (t->bound) FLUSH_BATCH(mmesa); mgaSetTexBorderColor(t,tObj->BorderColor); break; default: return; } - /* force the texture state to be updated */ - MGA_CONTEXT(ctx)->CurrentTexObj[0] = NULL; - MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE; + + mmesa->new_state |= MGA_NEW_TEXTURE; } /* * mgaBindTexture */ void mgaBindTexture( GLcontext *ctx, GLenum target, - struct gl_texture_object *tObj ) { + struct gl_texture_object *tObj ) +{ + mgaContextPtr mmesa = MGA_CONTEXT( ctx ); mgaMsg( 10, "mgaBindTexture( %p )\n", tObj ); - + + FLUSH_BATCH(mmesa); + + if (mmesa->CurrentTexObj[ctx->Texture.CurrentUnit]) { + mmesa->CurrentTexObj[ctx->Texture.CurrentUnit]->bound = 0; + mmesa->CurrentTexObj[ctx->Texture.CurrentUnit] = 0; + } + /* force the texture state to be updated */ - MGA_CONTEXT(ctx)->CurrentTexObj[0] = NULL; MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE; } /* * mgaDeleteTexture */ -void mgaDeleteTexture( GLcontext *ctx, struct gl_texture_object *tObj ) { +void mgaDeleteTexture( GLcontext *ctx, struct gl_texture_object *tObj ) +{ + mgaContextPtr mmesa = MGA_CONTEXT( ctx ); + mgaTextureObjectPtr t = (mgaTextureObjectPtr)tObj->DriverData; mgaMsg( 10, "mgaDeleteTexture( %p )\n", tObj ); - /* delete our driver data */ - if ( tObj->DriverData ) { - mgaContextPtr mmesa = MGA_CONTEXT( ctx ); - mgaDestroyTexObj( mmesa, - (mgaTextureObjectPtr)(tObj->DriverData) ); + if ( t ) { + if (t->bound) { + FLUSH_BATCH(mmesa); + mmesa->CurrentTexObj[t->bound-1] = 0; + mmesa->new_state |= MGA_NEW_TEXTURE; + } + + mgaDestroyTexObj( mmesa, t ); mmesa->new_state |= MGA_NEW_TEXTURE; } } diff --git a/xc/lib/GL/mesa/src/drv/mga/mgatex.h b/xc/lib/GL/mesa/src/drv/mga/mgatex.h index 1e8e7e86f..7873146c0 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgatex.h +++ b/xc/lib/GL/mesa/src/drv/mga/mgatex.h @@ -28,7 +28,6 @@ #ifndef MGATEX_INC #define MGATEX_INC -#include "mga_drm_public.h" #include "types.h" #include "mgacommon.h" #include "mm.h" @@ -48,7 +47,9 @@ typedef struct mga_texture_object_s { mgaUI32 dirty_images; mgaUI32 totalSize; int texelBytes; - mgaUI32 age; + mgaUI32 age; + int bound; + int heap; /* agp or card */ mgaUI32 Setup[MGA_TEX_SETUP_SIZE]; } mgaTextureObject_t; @@ -96,7 +97,7 @@ void mgaUpdateTexturePalette( GLcontext *ctx, struct gl_texture_object *tObj ); GLboolean mgaIsTextureResident( GLcontext *ctx, struct gl_texture_object *t ); -void mgaConvertTexture( mgaUI32 *destPtr, int texelBytes, +void mgaConvertTexture( mgaUI32 *dest, int texelBytes, struct gl_texture_image *image, int x, int y, int width, int height ); @@ -107,9 +108,7 @@ int mgaUploadTexImages( mgaContextPtr mmesa, mgaTextureObjectPtr t ); -void mgaResetGlobalLRU( mgaContextPtr mmesa ); -void mgaTexturesGone( mgaContextPtr mmesa, GLuint offset, - GLuint size, GLuint in_use ); +void mgaAgeTextures( mgaContextPtr mmesa, int heap ); void mgaDDInitTextureFuncs( GLcontext *ctx ); diff --git a/xc/lib/GL/mesa/src/drv/mga/mgatris.c b/xc/lib/GL/mesa/src/drv/mga/mgatris.c index bd8ef083f..b83aaf2ea 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgatris.c +++ b/xc/lib/GL/mesa/src/drv/mga/mgatris.c @@ -27,6 +27,7 @@ #include <stdio.h> #include <math.h> +#include "types.h" #include "vb.h" #include "pipeline.h" @@ -122,34 +123,14 @@ void mgaDDTrifuncInit() init_twoside_offset(); init_twoside_offset_flat(); - /* Hmmm... - */ - for (i = 0 ; i < 0x20 ; i++) { - if (i & ~MGA_FLAT_BIT) { - points_tab[i] = points_tab[i&MGA_FLAT_BIT]; - line_tab[i] = line_tab[i&MGA_FLAT_BIT]; - } - } - for (i = 0 ; i < 0x20 ; i++) - if ((i & (MGA_NODRAW_BIT|MGA_FALLBACK_BIT)) == MGA_NODRAW_BIT || - mgaglx.nullprims) + if ((i & (MGA_NODRAW_BIT|MGA_FALLBACK_BIT)) == MGA_NODRAW_BIT) { quad_tab[i] = mga_null_quad; tri_tab[i] = mga_null_triangle; line_tab[i] = mga_null_line; points_tab[i] = mga_null_points; } - - if (mgaglx.noFallback) { - for (i = 0 ; i < 0x10 ; i++) { - points_tab[i|MGA_FALLBACK_BIT] = points_tab[i]; - line_tab[i|MGA_FALLBACK_BIT] = line_tab[i]; - tri_tab[i|MGA_FALLBACK_BIT] = tri_tab[i]; - quad_tab[i|MGA_FALLBACK_BIT] = quad_tab[i]; - } - } - } @@ -162,50 +143,53 @@ void mgaDDChooseRenderState( GLcontext *ctx ) mgaContextPtr mmesa = MGA_CONTEXT( ctx ); GLuint flags = ctx->TriangleCaps; - ctx->IndirectTriangles &= ~DD_SW_RASTERIZE; + if (mmesa->Fallback) + return; + + mmesa->IndirectTriangles &= ~DD_SW_RASTERIZE; if (flags) { GLuint ind = 0; GLuint shared = 0; - GLuint fallback = MGA_FALLBACK_BIT; - - if (mgaglx.noFallback) fallback = 0; if (flags & DD_Z_NEVER) shared |= MGA_NODRAW_BIT; if (flags & DD_FLATSHADE) shared |= MGA_FLAT_BIT; - if (flags & DD_MULTIDRAW) shared |= fallback; - if (flags & (DD_SELECT|DD_FEEDBACK)) shared |= MGA_FALLBACK_BIT; + if (flags & (DD_MULTIDRAW| + DD_SELECT| + DD_FEEDBACK)) shared |= MGA_FALLBACK_BIT; if (flags & DD_STENCIL) shared |= MGA_FALLBACK_BIT; ind = shared; if (flags & DD_POINT_SMOOTH) ind |= MGA_ANTIALIAS_BIT; - if (flags & DD_POINT_ATTEN) ind |= fallback; mmesa->renderindex = ind; mmesa->PointsFunc = points_tab[ind]; if (ind & MGA_FALLBACK_BIT) - ctx->IndirectTriangles |= DD_POINT_SW_RASTERIZE; + mmesa->IndirectTriangles |= DD_POINT_SW_RASTERIZE; ind = shared; if (flags & DD_LINE_SMOOTH) ind |= MGA_ANTIALIAS_BIT; - if (flags & DD_LINE_STIPPLE) ind |= fallback; + if (flags & DD_LINE_STIPPLE) ind |= MGA_FALLBACK_BIT; mmesa->renderindex |= ind; mmesa->LineFunc = line_tab[ind]; if (ind & MGA_FALLBACK_BIT) - ctx->IndirectTriangles |= DD_LINE_SW_RASTERIZE; + mmesa->IndirectTriangles |= DD_LINE_SW_RASTERIZE; ind = shared; if (flags & DD_TRI_SMOOTH) ind |= MGA_ANTIALIAS_BIT; if (flags & DD_TRI_OFFSET) ind |= MGA_OFFSET_BIT; if (flags & DD_TRI_LIGHT_TWOSIDE) ind |= MGA_TWOSIDE_BIT; - if (flags & (DD_TRI_UNFILLED|DD_TRI_STIPPLE)) ind |= fallback; + if (flags & DD_TRI_UNFILLED) ind |= MGA_FALLBACK_BIT; + if ((flags & DD_TRI_STIPPLE) && + (ctx->IndirectTriangles & DD_TRI_STIPPLE)) ind |= MGA_FALLBACK_BIT; mmesa->renderindex |= ind; mmesa->TriangleFunc = tri_tab[ind]; mmesa->QuadFunc = quad_tab[ind]; if (ind & MGA_FALLBACK_BIT) - ctx->IndirectTriangles |= (DD_TRI_SW_RASTERIZE | DD_QUAD_SW_RASTERIZE); + mmesa->IndirectTriangles |= (DD_TRI_SW_RASTERIZE | + DD_QUAD_SW_RASTERIZE); } else if (mmesa->renderindex) { diff --git a/xc/lib/GL/mesa/src/drv/mga/mgatris.h b/xc/lib/GL/mesa/src/drv/mga/mgatris.h index 3b41900f1..dcf697409 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgatris.h +++ b/xc/lib/GL/mesa/src/drv/mga/mgatris.h @@ -34,26 +34,16 @@ extern void mgaDDTrifuncInit( void ); /* Todo: - * - multidraw, ... * - Antialiasing (?) * - line and polygon stipple - * - select and feedback * - stencil - * - point parameters - * - */ #define MGA_ANTIALIAS_BIT 0 /* ignored for now, no fallback */ -#define MGA_FLAT_BIT 0x1 -#define MGA_OFFSET_BIT 0x2 /* 3.1 only */ -#define MGA_TWOSIDE_BIT 0x4 /* 3.1 only */ -#define MGA_NODRAW_BIT 0x8 -#define MGA_FALLBACK_BIT 0x10 - -/* Not in use: - */ -#define MGA_FEEDBACK_BIT 0x20 -#define MGA_SELECT_BIT 0x40 -#define MGA_POINT_PARAM_BIT 0x80 /* not needed? */ +#define MGA_FLAT_BIT 0x1 +#define MGA_OFFSET_BIT 0x2 +#define MGA_TWOSIDE_BIT 0x4 +#define MGA_NODRAW_BIT 0x8 +#define MGA_FALLBACK_BIT 0x10 diff --git a/xc/lib/GL/mesa/src/drv/mga/mgatritmp.h b/xc/lib/GL/mesa/src/drv/mga/mgatritmp.h index ac5a545d2..ba2410914 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgatritmp.h +++ b/xc/lib/GL/mesa/src/drv/mga/mgatritmp.h @@ -98,8 +98,6 @@ static void TAG(quad)( GLcontext *ctx, GLuint v0, } -#if ((IND & ~MGA_FLAT_BIT) == 0) - static void TAG(line)( GLcontext *ctx, GLuint v0, GLuint v1, GLuint pv ) { mgaContextPtr mmesa = MGA_CONTEXT( ctx ); @@ -131,7 +129,6 @@ static void TAG(points)( GLcontext *ctx, GLuint first, GLuint last ) mga_draw_point( mmesa, &mgaVB[i], sz ); } -#endif static void TAG(init)( void ) @@ -139,10 +136,9 @@ static void TAG(init)( void ) tri_tab[IND] = TAG(triangle); quad_tab[IND] = TAG(quad); -#if ((IND & ~MGA_FLAT_BIT) == 0) line_tab[IND] = TAG(line); points_tab[IND] = TAG(points); -#endif + } diff --git a/xc/lib/GL/mesa/src/drv/mga/mgavb.c b/xc/lib/GL/mesa/src/drv/mga/mgavb.c index f78c542c8..0b703a184 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgavb.c +++ b/xc/lib/GL/mesa/src/drv/mga/mgavb.c @@ -260,11 +260,21 @@ void mgaChooseRasterSetupFunc(GLcontext *ctx) mmesa->tex_dest[0] = MGA_TEX0_BIT; mmesa->tex_dest[1] = MGA_TEX1_BIT; mmesa->multitex = 0; + mmesa->blend_flags &= ~MGA_BLEND_MULTITEX; if (ctx->Texture.Enabled & 0xf) { if (ctx->Texture.Unit[0].EnvMode == GL_REPLACE) funcindex &= ~MGA_RGBA_BIT; + if (ctx->Texture.Unit[0].EnvMode == GL_BLEND && + mmesa->envcolor) + { + mmesa->multitex = 1; + mmesa->vertsize = 10; + mmesa->tmu_source[1] = 0; + funcindex |= MGA_TEX1_BIT; + } + funcindex |= MGA_TEX0_BIT; } @@ -272,7 +282,8 @@ void mgaChooseRasterSetupFunc(GLcontext *ctx) if (ctx->Texture.Enabled & 0xf) { mmesa->multitex = 1; mmesa->vertsize = 10; - funcindex |= MGA_TEX1_BIT; + mmesa->blend_flags |= MGA_BLEND_MULTITEX; + funcindex |= MGA_TEX1_BIT; } else { /* Just a funny way of doing single texturing */ @@ -281,11 +292,25 @@ void mgaChooseRasterSetupFunc(GLcontext *ctx) if (ctx->Texture.Unit[1].EnvMode == GL_REPLACE) funcindex &= ~MGA_RGBA_BIT; + + if (ctx->Texture.Unit[0].EnvMode == GL_BLEND && + mmesa->envcolor) + { + mmesa->multitex = 1; + mmesa->vertsize = 10; + mmesa->tmu_source[1] = 1; + funcindex |= MGA_TEX1_BIT; + } funcindex |= MGA_TEX0_BIT; } } + /* Not really a good place to do this - need to make the mga state + * management code more event-driven so this can be calculated for + * free. + */ + if (ctx->Color.BlendEnabled) funcindex |= MGA_ALPHA_BIT; @@ -298,6 +323,7 @@ void mgaChooseRasterSetupFunc(GLcontext *ctx) if (0) mgaPrintSetupFlags("xsmesa: full setup function", funcindex); + mmesa->dirty |= MGA_UPLOAD_PIPE; mmesa->setupindex = funcindex; /* Called by mesa's clip functons: @@ -477,17 +503,3 @@ void mgaDDUnregisterVB( struct vertex_buffer *VB ) } -mgaUI32 *mgaAllocVertexDwords( mgaContextPtr mmesa, int dwords ) -{ - int bytes = dwords * 4; - mgaUI32 *head; - - if (mmesa->dma_buffer->used + bytes > mmesa->dma_buffer->total) - mgaFlushVertices( mmesa ); - - head = (mgaUI32 *)((char *)mmesa->dma_buffer->address + - mmesa->dma_buffer->used); - - mmesa->dma_buffer->used += bytes; - return head; -} diff --git a/xc/lib/GL/mesa/src/drv/mga/mgavb.h b/xc/lib/GL/mesa/src/drv/mga/mgavb.h index 8d7c65207..675c1779c 100644 --- a/xc/lib/GL/mesa/src/drv/mga/mgavb.h +++ b/xc/lib/GL/mesa/src/drv/mga/mgavb.h @@ -27,6 +27,7 @@ #ifndef MGAVB_INC #define MGAVB_INC +#include "types.h" #include "vb.h" #include "mgacommon.h" @@ -126,7 +127,4 @@ extern void mgaDDResizeVB( struct vertex_buffer *VB, GLuint size ); extern void mgaDDSetupInit( void ); -extern mgaUI32 *mgaAllocVertexDwords( mgaContextPtr mmesa, int dwords ); - - #endif diff --git a/xc/lib/GL/mesa/src/drv/tdfx/Imakefile b/xc/lib/GL/mesa/src/drv/tdfx/Imakefile index 982ca93e8..a8fe76fe7 100644 --- a/xc/lib/GL/mesa/src/drv/tdfx/Imakefile +++ b/xc/lib/GL/mesa/src/drv/tdfx/Imakefile @@ -278,7 +278,7 @@ XCOMM Disabling 3Dnow code for the time being. SRCS = $(DRISRCS) $(DRMSRCS) $(TDFXSRCS) $(MESASRCS) $(ASMSRCS) OBJS = $(DRIOBJS) $(DRMOBJS) $(TDFXOBJS) $(MESAOBJS) $(ASMOBJS) -REQUIREDLIBS += -lglide3x +REQUIREDLIBS += -lglide3x -lm #if !GlxUseBuiltInDRIDriver #undef DoNormalLib NormalLibGlx |