patch to import Jon Smirl's work from Bitkeeper

23 files changed, 2676 insertions, 2163 deletions

diff --git a/src/mesa/drivers/dri/mga/Doxyfile b/src/mesa/drivers/dri/mga/Doxyfile
new file mode 100644
index 00000000000..0d0c134a728
--- /dev/null
+++ b/src/mesa/drivers/dri/mga/Doxyfile
@@ -0,0 +1,234 @@
+# Doxyfile 1.3.3-Gideon
+
+#---------------------------------------------------------------------------
+# General configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME           = mga
+PROJECT_NUMBER         = $VERSION$
+OUTPUT_DIRECTORY       = 
+OUTPUT_LANGUAGE        = English
+USE_WINDOWS_ENCODING   = NO
+EXTRACT_ALL            = NO
+EXTRACT_PRIVATE        = NO
+EXTRACT_STATIC         = NO
+EXTRACT_LOCAL_CLASSES  = YES
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+HIDE_FRIEND_COMPOUNDS  = NO
+HIDE_IN_BODY_DOCS      = NO
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = NO
+STRIP_FROM_PATH        = 
+INTERNAL_DOCS          = NO
+CASE_SENSE_NAMES       = YES
+SHORT_NAMES            = NO
+HIDE_SCOPE_NAMES       = NO
+SHOW_INCLUDE_FILES     = YES
+JAVADOC_AUTOBRIEF      = NO
+MULTILINE_CPP_IS_BRIEF = NO
+DETAILS_AT_TOP         = NO
+INHERIT_DOCS           = YES
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = YES
+DISTRIBUTE_GROUP_DOC   = NO
+TAB_SIZE               = 8
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+GENERATE_DEPRECATEDLIST= YES
+ALIASES                = 
+ENABLED_SECTIONS       = 
+MAX_INITIALIZER_LINES  = 30
+OPTIMIZE_OUTPUT_FOR_C  = NO
+OPTIMIZE_OUTPUT_JAVA   = NO
+SHOW_USED_FILES        = YES
+SUBGROUPING            = YES
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = NO
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_DOC_ERROR      = YES
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           = 
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  = /home/newtree/temp/src/mesa/drivers/dri/mga
+FILE_PATTERNS          = *.c \
+                         *.cc \
+                         *.cxx \
+                         *.cpp \
+                         *.c++ \
+                         *.java \
+                         *.ii \
+                         *.ixx \
+                         *.ipp \
+                         *.i++ \
+                         *.inl \
+                         *.h \
+                         *.hh \
+                         *.hxx \
+                         *.hpp \
+                         *.h++ \
+                         *.idl \
+                         *.odl \
+                         *.cs \
+                         *.C \
+                         *.H \
+                         *.tlh \
+                         *.diff \
+                         *.patch \
+                         *.moc \
+                         *.xpm \
+                         *.dox
+RECURSIVE              = yes
+EXCLUDE                = 
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       = 
+EXAMPLE_PATH           = 
+EXAMPLE_PATTERNS       = *
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             = 
+INPUT_FILTER           = 
+FILTER_SOURCE_FILES    = NO
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = NO
+INLINE_SOURCES         = NO
+STRIP_CODE_COMMENTS    = YES
+REFERENCED_BY_RELATION = YES
+REFERENCES_RELATION    = YES
+VERBATIM_HEADERS       = YES
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = NO
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          = 
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = html
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            = 
+HTML_FOOTER            = 
+HTML_STYLESHEET        = 
+HTML_ALIGN_MEMBERS     = YES
+GENERATE_HTMLHELP      = NO
+CHM_FILE               = 
+HHC_LOCATION           = 
+GENERATE_CHI           = NO
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+DISABLE_INDEX          = NO
+ENUM_VALUES_PER_LINE   = 4
+GENERATE_TREEVIEW      = NO
+TREEVIEW_WIDTH         = 250
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = YES
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         = latex
+MAKEINDEX_CMD_NAME     = makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4wide
+EXTRA_PACKAGES         = 
+LATEX_HEADER           = 
+PDF_HYPERLINKS         = NO
+USE_PDFLATEX           = NO
+LATEX_BATCHMODE        = NO
+LATEX_HIDE_INDICES     = NO
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = NO
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = NO
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    = 
+RTF_EXTENSIONS_FILE    = 
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_LINKS              = NO
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = yes
+XML_OUTPUT             = xml
+XML_SCHEMA             = 
+XML_DTD                = 
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+GENERATE_PERLMOD       = NO
+PERLMOD_LATEX          = NO
+PERLMOD_PRETTY         = YES
+PERLMOD_MAKEVAR_PREFIX = 
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = NO
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = 
+INCLUDE_FILE_PATTERNS  = 
+PREDEFINED             = 
+EXPAND_AS_DEFINED      = 
+SKIP_FUNCTION_MACROS   = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to external references   
+#---------------------------------------------------------------------------
+TAGFILES               = 
+GENERATE_TAGFILE       = 
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+PERL_PATH              = /usr/bin/perl
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = YES
+HIDE_UNDOC_RELATIONS   = YES
+HAVE_DOT               = NO
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+UML_LOOK               = NO
+TEMPLATE_RELATIONS     = NO
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+CALL_GRAPH             = NO
+GRAPHICAL_HIERARCHY    = YES
+DOT_IMAGE_FORMAT       = png
+DOT_PATH               = 
+DOTFILE_DIRS           = 
+MAX_DOT_GRAPH_WIDTH    = 1024
+MAX_DOT_GRAPH_HEIGHT   = 1024
+MAX_DOT_GRAPH_DEPTH    = 1000
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES
+#---------------------------------------------------------------------------
+# Configuration::addtions related to the search engine   
+#---------------------------------------------------------------------------
+SEARCHENGINE           = NO
+CGI_NAME               = search.cgi
+CGI_URL                = 
+DOC_URL                = 
+DOC_ABSPATH            = 
+BIN_ABSPATH            = /usr/local/bin/
+EXT_DOC_PATHS          = 
diff --git a/src/mesa/drivers/dri/mga/Makefile.X11 b/src/mesa/drivers/dri/mga/Makefile.X11
index c69d6e5989e..0dce6e7b1a7 100644
--- a/src/mesa/drivers/dri/mga/Makefile.X11
+++ b/src/mesa/drivers/dri/mga/Makefile.X11
@@ -1,4 +1,4 @@
-# $Id: Makefile.X11,v 1.1 2003/08/06 18:01:13 keithw Exp $
+# $Id: Makefile.X11,v 1.2 2003/08/22 20:11:44 brianp Exp $
 
 # Mesa 3-D graphics library
 # Version:  5.0
@@ -6,8 +6,10 @@
 
 TOP = ../../../../..
 
+default: linux-solo
+
 SHARED_INCLUDES = $(INCLUDE_DIRS) -I. -I../common -Iserver
-MINIGLX_INCLUDES = -I$(TOP)/src/miniglx 
+MINIGLX_INCLUDES = -I$(TOP)/src/glx/mini
 
 DEFINES += \
 	-D_HAVE_SWRAST=1 \
@@ -16,24 +18,27 @@ DEFINES += \
 	-D_HAVE_CODEGEN=1 \
 	-D_HAVE_LIGHTING=1 \
 	-D_HAVE_TEXGEN=1 \
-	-D_HAVE_USERCLIP=1
+	-D_HAVE_USERCLIP=1 \
+	-DGLX_DIRECT_RENDERING
 
 MINIGLX_SOURCES = server/mga_dri.c 
 
-DRIVER_SOURCES = mgabuffers.c \
-		 mgadd.c \
+DRIVER_SOURCES = mgadd.c \
 		 mgaioctl.c \
 		 mgarender.c \
 		 mgastate.c \
 		 mgatris.c \
-		 ../common/mm.c 
+		 ../common/mm.c \
+		 ../common/utils.c \
+		 ../common/texmem.c \
+		 ../common/vblank.c
 
 FULL_DRIVER_SOURCES = 	\
 		 mgapixel.c \
 		 mgaspan.c \
 		 mgatex.c \
-		 mgatexcnv.c \
 		 mgatexmem.c \
+		 mga_texstate.c \
 		 mgavb.c \
 		 mga_xmesa.c
 
@@ -54,7 +59,7 @@ WINOBJ=$(MESABUILDDIR)/dri/dri.a
 WINLIB=
 else
 WINOBJ=
-WINLIB=-L$(MESA)/src/miniglx
+WINLIB=-L$(MESA)/src/glx/mini
 endif
 
 ASM_SOURCES = 
@@ -87,7 +92,7 @@ INCLUDE_DIRS = \
 
 ##### TARGETS #####
 
-targets: mga_dri.so
+targets: depend mga_dri.so
 
 mga_dri.so:  $(OBJECTS) $(MESA_MODULES) $(WINOBJ) Makefile.X11
 	rm -f $@ && gcc -o $@ -shared $(OBJECTS) $(MESA_MODULES) $(WINOBJ) $(WINLIB) -lc -lm
@@ -96,7 +101,7 @@ mga_dri.so:  $(OBJECTS) $(MESA_MODULES) $(WINOBJ) Makefile.X11
 
 # Run 'make -f Makefile.X11 dep' to update the dependencies if you change
 # what's included by any source file.
-dep: $(C_SOURCES) $(ASM_SOURCES)
+depend: $(C_SOURCES) $(ASM_SOURCES)
 	makedepend -fdepend -Y $(SHARED_INCLUDES) \
 		$(C_SOURCES) $(ASM_SOURCES)
 
@@ -108,7 +113,7 @@ tags:
 
 # Remove .o and backup files
 clean:
-	-rm -f *.o *~ *.o *~ *.so
+	-rm -f *.o *~ *.o *~ *.so server/*.o
 
 
 include $(TOP)/Make-config
diff --git a/src/mesa/drivers/dri/mga/mga_texstate.c b/src/mesa/drivers/dri/mga/mga_texstate.c
new file mode 100644
index 00000000000..fc1406cab9e
--- /dev/null
+++ b/src/mesa/drivers/dri/mga/mga_texstate.c
@@ -0,0 +1,747 @@
+/*
+ * Copyright 2000-2001 VA Linux Systems, Inc.
+ * (c) Copyright IBM Corporation 2002
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on the rights to use, copy, modify, merge, publish, distribute, sub
+ * license, and/or sell copies of the Software, and to permit persons to whom
+ * the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+ * VA LINUX SYSTEMS, IBM AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Ian Romanick <[email protected]>
+ *    Keith Whitwell <[email protected]>
+ */
+/* $XFree86:$ */
+
+#include "mm.h"
+#include "mgacontext.h"
+#include "mgatex.h"
+#include "mgaregs.h"
+#include "mgatris.h"
+#include "mgaioctl.h"
+
+#include "context.h"
+#include "enums.h"
+#include "macros.h"
+#include "imports.h"
+
+#include "simple_list.h"
+#include "texformat.h"
+
+#define MGA_USE_TABLE_FOR_FORMAT
+#ifdef MGA_USE_TABLE_FOR_FORMAT
+#define TMC_nr_tformat (MESA_FORMAT_YCBCR_REV + 1)
+static const unsigned TMC_tformat[ TMC_nr_tformat ] =
+{
+    [MESA_FORMAT_ARGB8888] = TMC_tformat_tw32 | TMC_takey_1 | TMC_tamask_0,
+    [MESA_FORMAT_RGB565]   = TMC_tformat_tw16 | TMC_takey_1 | TMC_tamask_0,
+    [MESA_FORMAT_ARGB4444] = TMC_tformat_tw12 | TMC_takey_1 | TMC_tamask_0,
+    [MESA_FORMAT_ARGB1555] = TMC_tformat_tw15 | TMC_takey_1 | TMC_tamask_0,
+    [MESA_FORMAT_CI8]      = TMC_tformat_tw8  | TMC_takey_1 | TMC_tamask_0,
+    [MESA_FORMAT_YCBCR]     = TMC_tformat_tw422uyvy | TMC_takey_1 | TMC_tamask_0,
+    [MESA_FORMAT_YCBCR_REV] = TMC_tformat_tw422 | TMC_takey_1 | TMC_tamask_0,
+};
+#endif
+
+static void
+mgaSetTexImages( mgaContextPtr mmesa,
+		 const struct gl_texture_object * tObj )
+{
+    mgaTextureObjectPtr t = (mgaTextureObjectPtr) tObj->DriverData;
+    struct gl_texture_image *baseImage = tObj->Image[ tObj->BaseLevel ];
+    GLint totalSize;
+    GLint width, height;
+    GLint i;
+    GLint firstLevel, lastLevel, numLevels;
+    GLint log2Width, log2Height;
+    GLuint txformat = 0;
+    GLint ofs;
+
+    /* Set the hardware texture format
+     */
+#ifndef MGA_USE_TABLE_FOR_FORMAT
+    switch (baseImage->TexFormat->MesaFormat) {
+
+	case MESA_FORMAT_ARGB8888: txformat = TMC_tformat_tw32;	break;
+	case MESA_FORMAT_RGB565:   txformat = TMC_tformat_tw16; break;
+	case MESA_FORMAT_ARGB4444: txformat = TMC_tformat_tw12;	break;
+	case MESA_FORMAT_ARGB1555: txformat = TMC_tformat_tw15; break;
+	case MESA_FORMAT_CI8:      txformat = TMC_tformat_tw8;  break;
+        case MESA_FORMAT_YCBCR:    txformat  = TMC_tformat_tw422uyvy; break;
+        case MESA_FORMAT_YCBCR_REV: txformat = TMC_tformat_tw422; break;
+
+	default:
+	_mesa_problem(NULL, "unexpected texture format in %s", __FUNCTION__);
+	return;
+    }
+#else
+    if ( (baseImage->TexFormat->MesaFormat >= TMC_nr_tformat)
+	 || (TMC_tformat[ baseImage->TexFormat->MesaFormat ] == 0) )
+    {
+	_mesa_problem(NULL, "unexpected texture format in %s", __FUNCTION__);
+	return;
+    }
+
+    txformat = TMC_tformat[ baseImage->TexFormat->MesaFormat ];
+
+#endif /* MGA_USE_TABLE_FOR_FORMAT */
+
+   if (tObj->MinFilter == GL_NEAREST || tObj->MinFilter == GL_LINEAR) {
+      /* GL_NEAREST and GL_LINEAR only care about GL_TEXTURE_BASE_LEVEL.
+       */
+
+      firstLevel = lastLevel = tObj->BaseLevel;
+   } else {
+      /* Compute which mipmap levels we really want to send to the hardware.
+       * This depends on the base image size, GL_TEXTURE_MIN_LOD,
+       * GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, and GL_TEXTURE_MAX_LEVEL.
+       * Yes, this looks overly complicated, but it's all needed.
+       */
+
+      firstLevel = tObj->BaseLevel + (GLint)(tObj->MinLod + 0.5);
+      firstLevel = MAX2(firstLevel, tObj->BaseLevel);
+      lastLevel = tObj->BaseLevel + (GLint)(tObj->MaxLod + 0.5);
+      lastLevel = MAX2(lastLevel, tObj->BaseLevel);
+      lastLevel = MIN2(lastLevel, tObj->BaseLevel + baseImage->MaxLog2);
+      lastLevel = MIN2(lastLevel, tObj->MaxLevel);
+      lastLevel = MAX2(firstLevel, lastLevel); /* need at least one level */
+   }
+
+   log2Width = tObj->Image[firstLevel]->WidthLog2;
+   log2Height = tObj->Image[firstLevel]->HeightLog2;
+   width = tObj->Image[firstLevel]->Width;
+   height = tObj->Image[firstLevel]->Height;
+
+   numLevels = MIN2( lastLevel - firstLevel + 1,
+                     MGA_IS_G200(mmesa) ? G200_TEX_MAXLEVELS : G400_TEX_MAXLEVELS);
+
+
+   totalSize = 0;
+   for ( i = 0 ; i < numLevels ; i++ ) {
+      const struct gl_texture_image * const texImage = tObj->Image[i+firstLevel];
+
+      if ( (texImage == NULL)
+	   || ((i != 0)
+	       && ((texImage->Width < 8) || (texImage->Height < 8))) ) {
+	 break;
+      }
+
+      t->offsets[i] = totalSize;
+      t->base.dirty_images[0] |= (1<<i);
+
+      totalSize += ((MAX2( texImage->Width, 8 ) *
+                     MAX2( texImage->Height, 8 ) *
+                     baseImage->TexFormat->TexelBytes) + 31) & ~31;
+   }
+
+   numLevels = i;
+   lastLevel = firstLevel + numLevels - 1;
+
+   /* save these values */
+   t->base.firstLevel = firstLevel;
+   t->base.lastLevel = lastLevel;
+
+   t->base.totalSize = totalSize;
+
+   /* setup hardware register values */
+   t->setup.texctl &= (TMC_tformat_MASK & TMC_tpitch_MASK 
+		       & TMC_tpitchext_MASK);
+   t->setup.texctl |= txformat;
+
+
+   /* Set the texture width.  In order to support non-power of 2 textures and
+    * textures larger than 1024 texels wide, "linear" pitch must be used.  For
+    * the linear pitch, if the width is 2048, a value of zero is used.
+    */
+
+   t->setup.texctl |= TMC_tpitchlin_enable;
+   t->setup.texctl |= (width & (2048 - 1)) << TMC_tpitchext_SHIFT;
+
+
+   /* G400 specifies the number of mip levels in a strange way.  Since there
+    * are up to 12 levels, it requires 4 bits.  Three of the bits are at the
+    * high end of TEXFILTER.  The other bit is in the middle.  Weird.
+    */
+
+   t->setup.texfilter &= TF_mapnb_MASK & TF_mapnbhigh_MASK & TF_reserved_MASK;
+   t->setup.texfilter |= (((numLevels-1) & 0x07) << (TF_mapnb_SHIFT));
+   t->setup.texfilter |= (((numLevels-1) & 0x08) << (TF_mapnbhigh_SHIFT - 3));
+
+   /* warp texture registers */
+   ofs = MGA_IS_G200(mmesa) ? 28 : 11;
+
+   t->setup.texwidth = (MGA_FIELD(TW_twmask, width - 1) |
+			MGA_FIELD(TW_rfw, (10 - log2Width - 8) & 63 ) |
+			MGA_FIELD(TW_tw, (log2Width + ofs ) | 0x40 ));
+
+   t->setup.texheight = (MGA_FIELD(TH_thmask, height - 1) |
+			 MGA_FIELD(TH_rfh, (10 - log2Height - 8) & 63 ) |
+			 MGA_FIELD(TH_th, (log2Height + ofs ) | 0x40 ));
+
+   mgaUploadTexImages( mmesa, t );
+}
+
+
+/* ================================================================
+ * Texture unit state management
+ */
+
+static void mgaUpdateTextureEnvG200( GLcontext *ctx, GLuint unit )
+{
+   struct gl_texture_object *tObj = ctx->Texture.Unit[0]._Current;
+   mgaTextureObjectPtr t;
+
+   if (!tObj || !tObj->DriverData)
+      return;
+
+   t = (mgaTextureObjectPtr)tObj->DriverData;
+
+   t->setup.texctl2 &= ~TMC_decalblend_enable;
+
+   switch (ctx->Texture.Unit[0].EnvMode) {
+   case GL_REPLACE:
+      t->setup.texctl &= ~TMC_tmodulate_enable;
+      break;
+   case GL_MODULATE:
+      t->setup.texctl |= TMC_tmodulate_enable;
+      break;
+   case GL_DECAL:
+      t->setup.texctl &= ~TMC_tmodulate_enable;
+      t->setup.texctl2 |= TMC_decalblend_enable;
+      break;
+   case GL_BLEND:
+      FALLBACK( ctx, MGA_FALLBACK_TEXTURE, GL_TRUE );
+      break;
+   default:
+      break;
+   }
+}
+
+
+#define MGA_DISABLE		0
+#define MGA_REPLACE		1
+#define MGA_MODULATE		2
+#define MGA_DECAL		3
+#define MGA_BLEND		4
+#define MGA_ADD			5
+#define MGA_MAX_COMBFUNC	6
+
+static const GLuint g400_color_combine[][MGA_MAX_COMBFUNC] =
+{
+   /* Unit 0:
+    */
+   {
+      /* Disable combiner stage
+       */
+      (0),
+
+      /* GL_REPLACE
+       */
+      (TD0_color_sel_arg1 |
+       TD0_alpha_arg2_diffuse |
+       TD0_alpha_sel_arg2 ),
+      
+      /* GL_MODULATE
+       */
+      (TD0_color_arg2_diffuse |
+       TD0_color_sel_mul |
+       TD0_alpha_arg2_diffuse |
+       TD0_alpha_sel_mul),
+      
+      /* GL_DECAL
+       */
+      (TD0_color_sel_arg1 |
+       TD0_alpha_arg2_diffuse |
+       TD0_alpha_sel_arg2),
+      
+      /* GL_BLEND
+       */
+      (0),
+      
+      /* GL_ADD
+       */
+      (TD0_color_arg2_diffuse |
+       TD0_color_add_add |
+       TD0_color_sel_add |
+       TD0_alpha_arg2_diffuse |
+       TD0_alpha_sel_mul),
+   },
+   
+   /* Unit 1:
+    */
+   {
+      /* Disable combiner stage
+       */
+      (0),
+       
+      /* GL_REPLACE
+       */
+      (TD0_color_sel_arg1 |
+       TD0_alpha_arg2_diffuse |
+       TD0_alpha_sel_arg2 ),
+      
+      /* GL_MODULATE
+       */
+      (TD0_color_arg2_prevstage |
+       TD0_color_alpha_prevstage |
+       TD0_color_sel_mul |
+       TD0_alpha_arg2_prevstage |
+       TD0_alpha_sel_mul),
+
+      /* GL_DECAL
+       */
+      (TD0_color_sel_arg1 |
+       TD0_alpha_arg2_prevstage |
+       TD0_alpha_sel_arg2 ),
+      
+      /* GL_BLEND
+       */
+      (0),
+      
+      /* GL_ADD
+       */
+      (TD0_color_arg2_prevstage |
+       TD0_color_alpha_prevstage |
+       TD0_color_add_add |
+       TD0_color_sel_add |
+       TD0_alpha_arg2_prevstage |
+       TD0_alpha_sel_mul),
+   },
+};
+
+static const GLuint g400_alpha_combine[][MGA_MAX_COMBFUNC] =
+{
+   /* Unit 0:
+    */
+   {
+      /* Disable combiner stage
+       */
+      (0),
+
+      /* GL_REPLACE
+       */
+      (TD0_color_sel_arg2 |
+       TD0_color_arg2_diffuse |
+       TD0_alpha_sel_arg1 ),
+      
+      /* GL_MODULATE
+       * FIXME: Is this correct?
+       */
+      (TD0_color_arg2_diffuse |
+       TD0_color_sel_mul |
+       TD0_alpha_arg2_diffuse |
+       TD0_alpha_sel_mul),
+
+      /* GL_DECAL
+       */
+      (TD0_color_arg2_diffuse |
+       TD0_color_sel_arg2 |
+       TD0_alpha_arg2_diffuse |
+       TD0_alpha_sel_arg2),
+
+      /* GL_BLEND
+       */
+      (TD0_color_arg2_diffuse |
+       TD0_color_sel_mul |
+       TD0_alpha_arg2_diffuse |
+       TD0_alpha_sel_mul),
+
+      /* GL_ADD
+       */
+      (TD0_color_arg2_diffuse |
+       TD0_color_sel_mul |
+       TD0_alpha_arg2_diffuse |
+       TD0_alpha_sel_mul),
+   },
+
+   /* Unit 1:
+    */
+   {
+      /* Disable combiner stage
+       */
+      (0),
+
+      /* GL_REPLACE
+       */
+      (TD0_color_sel_arg2 |
+       TD0_color_arg2_diffuse |
+       TD0_alpha_sel_arg1 ),
+      
+      /* GL_MODULATE
+       * FIXME: Is this correct?
+       */
+      (TD0_color_arg2_prevstage |
+       TD0_color_alpha_prevstage |
+       TD0_color_sel_mul |
+       TD0_alpha_arg2_prevstage |
+       TD0_alpha_sel_mul),
+
+      /* GL_DECAL
+       */
+      (TD0_color_arg2_prevstage |
+       TD0_color_sel_arg2 |
+       TD0_alpha_arg2_prevstage |
+       TD0_alpha_sel_arg2),
+
+      /* GL_BLEND
+       */
+      (TD0_color_arg2_diffuse |
+       TD0_color_sel_mul |
+       TD0_alpha_arg2_diffuse |
+       TD0_alpha_sel_mul),
+
+      /* GL_ADD
+       */
+      (TD0_color_arg2_prevstage |
+       TD0_color_sel_mul |
+       TD0_alpha_arg2_prevstage |
+       TD0_alpha_sel_mul),
+   },
+};
+
+static void mgaUpdateTextureEnvG400( GLcontext *ctx, GLuint unit )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   const int source = mmesa->tmu_source[unit];
+   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[source];
+   const struct gl_texture_object *tObj = texUnit->_Current;
+   GLuint *reg = ((GLuint *)&mmesa->setup.tdualstage0 + unit);
+   GLenum format;
+
+   if ( tObj != ctx->Texture.Unit[source].Current2D || !tObj ) 
+      return;
+
+   format = tObj->Image[tObj->BaseLevel]->Format;
+
+   switch (ctx->Texture.Unit[source].EnvMode) {
+   case GL_REPLACE:
+      if (format == GL_RGB || format == GL_LUMINANCE) {
+	 *reg = g400_color_combine[unit][MGA_REPLACE];
+      }
+      else if (format == GL_ALPHA) {
+         *reg = g400_alpha_combine[unit][MGA_REPLACE];
+      }
+      else {
+         *reg = (TD0_color_sel_arg1 |
+                 TD0_alpha_sel_arg1 );
+      }
+      break;
+
+   case GL_MODULATE:
+      *reg = g400_color_combine[unit][MGA_MODULATE];
+      break;
+   case GL_DECAL:
+      if (format == GL_RGB) {
+	 *reg = g400_color_combine[unit][MGA_DECAL];
+      }
+      else if ( format == GL_RGBA ) {
+#if 0
+         if (unit == 0) {
+            /* this doesn't work */
+            *reg = (TD0_color_arg2_diffuse |
+                    TD0_color_alpha_currtex |
+                    TD0_color_alpha2inv_enable |
+                    TD0_color_arg2mul_alpha2 |
+                    TD0_color_arg1mul_alpha1 |
+                    TD0_color_blend_enable |
+                    TD0_color_arg1add_mulout |
+                    TD0_color_arg2add_mulout |
+                    TD0_color_add_add |
+                    TD0_color_sel_mul |
+                    TD0_alpha_arg2_diffuse |
+                    TD0_alpha_sel_arg2 );
+         }
+         else {
+            *reg = (TD0_color_arg2_prevstage |
+                    TD0_color_alpha_currtex |
+                    TD0_color_alpha2inv_enable |
+                    TD0_color_arg2mul_alpha2 |
+                    TD0_color_arg1mul_alpha1 |
+                    TD0_color_add_add |
+                    TD0_color_sel_add |
+                    TD0_alpha_arg2_prevstage |
+                    TD0_alpha_sel_arg2 );
+         }
+#else
+         /* s/w fallback, pretty sure we can't do in h/w */
+	 FALLBACK( ctx, MGA_FALLBACK_TEXTURE, GL_TRUE );
+	 if ( MGA_DEBUG & DEBUG_VERBOSE_FALLBACK )
+	    fprintf( stderr, "FALLBACK: GL_DECAL RGBA texture, unit=%d\n",
+		     unit );
+#endif
+      }
+      else {
+	*reg = g400_alpha_combine[unit][MGA_DECAL];
+      }
+      break;
+
+   case GL_ADD:
+     if (format == GL_INTENSITY) {
+	if (unit == 0) {
+	   *reg = ( TD0_color_arg2_diffuse |
+		   TD0_color_add_add |
+		   TD0_color_sel_add |
+		   TD0_alpha_arg2_diffuse |
+		   TD0_alpha_add_enable |
+		   TD0_alpha_sel_add);
+	}
+	else {
+	   *reg = ( TD0_color_arg2_prevstage |
+		   TD0_color_add_add |
+		   TD0_color_sel_add |
+		   TD0_alpha_arg2_prevstage |
+		   TD0_alpha_add_enable |
+		   TD0_alpha_sel_add);
+	}
+     }      
+     else if (format == GL_ALPHA) {
+	*reg = g400_alpha_combine[unit][MGA_ADD];
+     }
+     else {
+	*reg = g400_color_combine[unit][MGA_ADD];
+     }
+     break;
+
+   case GL_BLEND:
+      if (format == GL_ALPHA) {
+	 *reg = g400_alpha_combine[unit][MGA_BLEND];
+      }
+      else {
+	 FALLBACK( ctx, MGA_FALLBACK_TEXTURE, GL_TRUE );
+	 if ( MGA_DEBUG & DEBUG_VERBOSE_FALLBACK )
+	    fprintf( stderr, "FALLBACK: GL_BLEND envcolor=0x%08x\n",
+		     mmesa->envcolor );
+
+         /* Do singletexture GL_BLEND with 'all ones' env-color
+          * by using both texture units.  Multitexture gl_blend
+          * is a fallback.
+          */
+         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:
+      break;
+   }
+}
+
+
+static void disable_tex( GLcontext *ctx, int unit )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+
+   /* Texture unit disabled */
+
+   if ( mmesa->CurrentTexObj[unit] != NULL ) {
+      /* The old texture is no longer bound to this texture unit.
+       * Mark it as such.
+       */
+
+      mmesa->CurrentTexObj[unit]->base.bound &= ~(1UL << unit);
+      mmesa->CurrentTexObj[unit] = NULL;
+   }
+
+   if ( unit != 0 ) {
+      mmesa->setup.tdualstage1 = mmesa->setup.tdualstage0;
+   }
+
+   if ( ctx->Texture._EnabledUnits == 0 ) {
+      mmesa->setup.dwgctl &= DC_opcod_MASK;
+      mmesa->setup.dwgctl |= DC_opcod_trap;
+      mmesa->hw.alpha_sel = AC_alphasel_diffused;
+   }
+
+   mmesa->dirty |= MGA_UPLOAD_CONTEXT | (MGA_UPLOAD_TEX0 << unit);
+}
+
+static GLboolean enable_tex_2d( GLcontext *ctx, int unit )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+   const int source = mmesa->tmu_source[unit];
+   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[source];
+   const struct gl_texture_object *tObj = texUnit->_Current;
+   mgaTextureObjectPtr t = (mgaTextureObjectPtr) tObj->DriverData;
+
+   /* Upload teximages (not pipelined)
+    */
+   if (t->base.dirty_images[0]) {
+      FLUSH_BATCH( mmesa );
+      mgaSetTexImages( mmesa, tObj );
+      if ( t->base.memBlock == NULL ) {
+	 return GL_FALSE;
+      }
+   }
+
+   return GL_TRUE;
+}
+
+static GLboolean update_tex_common( GLcontext *ctx, int unit )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+   const int source = mmesa->tmu_source[unit];
+   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[source];
+   struct gl_texture_object	*tObj = texUnit->_Current;
+   mgaTextureObjectPtr t = (mgaTextureObjectPtr) tObj->DriverData;
+
+   /* Fallback if there's a texture border */
+   if ( tObj->Image[tObj->BaseLevel]->Border > 0 ) {
+      return GL_FALSE;
+   }
+
+
+   /* Update state if this is a different texture object to last
+    * time.
+    */
+   if ( mmesa->CurrentTexObj[unit] != t ) {
+      if ( mmesa->CurrentTexObj[unit] != NULL ) {
+	 /* The old texture is no longer bound to this texture unit.
+	  * Mark it as such.
+	  */
+
+	 mmesa->CurrentTexObj[unit]->base.bound &= ~(1UL << unit);
+      }
+
+      mmesa->CurrentTexObj[unit] = t;
+      t->base.bound |= (1UL << unit);
+
+      driUpdateTextureLRU( (driTextureObject *) t ); /* done too often */
+   }
+
+   /* register setup */
+   if ( unit == 1 ) {
+      mmesa->setup.tdualstage1 = mmesa->setup.tdualstage0;
+   }
+
+   t->setup.texctl2 &= TMC_dualtex_MASK;
+   if (ctx->Texture._EnabledUnits == 0x03) {
+      t->setup.texctl2 |= TMC_dualtex_enable;
+   }
+
+   /* FIXME: The Radeon has some cached state so that it can avoid calling
+    * FIXME: UpdateTextureEnv in some cases.  Is that possible here?
+    */
+   if (MGA_IS_G400(mmesa)) {
+      /* G400: Regardless of texture env mode, we use the alpha from the
+       * texture unit (AC_alphasel_fromtex) since it will have already
+       * been modulated by the incoming fragment color, if needed.
+       * We don't want (AC_alphasel_modulate) since that'll effectively
+       * do the modulation twice.
+       */
+      mmesa->hw.alpha_sel = AC_alphasel_fromtex;
+
+      mgaUpdateTextureEnvG400( ctx, unit );
+   } else {
+      mmesa->hw.alpha_sel = 0;
+      switch (ctx->Texture.Unit[0].EnvMode) {
+      case GL_DECAL:
+	 mmesa->hw.alpha_sel |= AC_alphasel_diffused;
+      case GL_REPLACE:
+	 mmesa->hw.alpha_sel |= AC_alphasel_fromtex;
+	 break;
+      case GL_BLEND:
+      case GL_MODULATE:
+	 mmesa->hw.alpha_sel |= AC_alphasel_modulated;
+	 break;
+      default:
+	 break;
+      }
+
+      mgaUpdateTextureEnvG200( ctx, unit );
+   }
+
+   mmesa->setup.dwgctl &= DC_opcod_MASK;
+   mmesa->setup.dwgctl |= DC_opcod_texture_trap;
+   mmesa->dirty |= MGA_UPLOAD_CONTEXT | (MGA_UPLOAD_TEX0 << unit);
+
+   FALLBACK( ctx, MGA_FALLBACK_BORDER_MODE, t->border_fallback );
+   return !t->border_fallback;
+}
+
+
+static GLboolean updateTextureUnit( GLcontext *ctx, int unit )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   const int source = mmesa->tmu_source[unit];
+   const struct gl_texture_unit *texUnit = &ctx->Texture.Unit[source];
+
+
+   if ( texUnit->_ReallyEnabled == TEXTURE_2D_BIT) {
+      return(enable_tex_2d( ctx, unit ) &&
+	     update_tex_common( ctx, unit ));
+   }
+   else if ( texUnit->_ReallyEnabled ) {
+      return GL_FALSE;
+   }
+   else {
+      disable_tex( ctx, unit );
+      return GL_TRUE;
+   }
+}
+
+/* The G400 is now programmed quite differently wrt texture environment.
+ */
+void mgaUpdateTextureState( GLcontext *ctx )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   GLboolean ok;
+   unsigned  i;
+
+
+   /* This works around a quirk with the MGA hardware.  If only OpenGL 
+    * TEXTURE1 is enabled, then the hardware TEXTURE0 must be used.  The
+    * hardware TEXTURE1 can ONLY be used when hardware TEXTURE0 is also used.
+    */
+
+   mmesa->tmu_source[0] = 0;
+   mmesa->tmu_source[1] = 1;
+
+   if ((ctx->Texture._EnabledUnits & 0x03) == 0x02) {
+      /* only texture 1 enabled */
+      mmesa->tmu_source[0] = 1;
+      mmesa->tmu_source[1] = 0;
+   }
+
+   for ( i = 0, ok = GL_TRUE 
+	 ; (i < ctx->Const.MaxTextureUnits) && ok
+	 ; i++ ) {
+      ok = updateTextureUnit( ctx, i );
+   }
+
+   FALLBACK( ctx, MGA_FALLBACK_TEXTURE, !ok );
+   
+   /* FIXME: I believe that ChooseVertexState should be called here instead of
+    * FIXME: in mgaDDValidateState.
+    */
+}
diff --git a/src/mesa/drivers/dri/mga/mga_xmesa.c b/src/mesa/drivers/dri/mga/mga_xmesa.c
index de1bcc2a0f7..16dc349cace 100644
--- a/src/mesa/drivers/dri/mga/mga_xmesa.c
+++ b/src/mesa/drivers/dri/mga/mga_xmesa.c
@@ -1,4 +1,4 @@
-/* $XFree86: xc/lib/GL/mesa/src/drv/mga/mga_xmesa.c,v 1.19 2003/03/26 20:43:49 tsi Exp $ */
+/* $XFree86: xc/lib/GL/mesa/src/drv/mga/mga_xmesa.c,v 1.18 2002/12/16 16:18:52 dawes Exp $ */
 /*
  * Copyright 2000-2001 VA Linux Systems, Inc.
  * All Rights Reserved.
@@ -26,15 +26,14 @@
  *    Keith Whitwell <[email protected]>
  */
 
-#include <stdio.h>
+#ifdef GLX_DIRECT_RENDERING
 
 #include "mga_common.h"
 #include "mga_xmesa.h"
 #include "context.h"
 #include "matrix.h"
-/*#include "mmath.h"*/
 #include "simple_list.h"
-/*#include "mem.h"*/
+#include "imports.h"
 
 #include "swrast/swrast.h"
 #include "swrast_setup/swrast_setup.h"
@@ -50,26 +49,23 @@
 #include "mgaioctl.h"
 #include "mgatris.h"
 #include "mgavb.h"
-#include "mgabuffers.h"
 #include "mgapixel.h"
-
 #include "mga_xmesa.h"
-
 #include "mga_dri.h"
 
 
+#include "utils.h"
+#include "vblank.h"
+#include "dri_util.h"
+#ifndef _SOLO
+#include "glxextensions.h"
+#endif
+
 #ifndef MGA_DEBUG
-int MGA_DEBUG = (0
-/*		 | DEBUG_ALWAYS_SYNC */
-/*		 | DEBUG_VERBOSE_MSG */
-/*		 | DEBUG_VERBOSE_LRU */
-/*		 | DEBUG_VERBOSE_DRI */
-/*		 | DEBUG_VERBOSE_IOCTL */
-/*		 | DEBUG_VERBOSE_2D */
-/*		 | DEBUG_VERBOSE_FALLBACK */
-   );
+int MGA_DEBUG = 0;
 #endif
 
+static int getSwapInfo( __DRIdrawablePrivate *dPriv, __DRIswapInfo * sInfo );
 
 static GLboolean
 mgaInitDriver(__DRIscreenPrivate *sPriv)
@@ -77,16 +73,8 @@ mgaInitDriver(__DRIscreenPrivate *sPriv)
    mgaScreenPrivate *mgaScreen;
    MGADRIPtr         serverInfo = (MGADRIPtr)sPriv->pDevPriv;
 
-   if (MGA_DEBUG&DEBUG_VERBOSE_DRI)
-      fprintf(stderr, "mgaInitDriver\n");
-
-   /* Check that the DRM driver version is compatible */
-   if (sPriv->drmMajor != 3 ||
-       sPriv->drmMinor < 0) {
-      __driUtilMessage("MGA DRI driver expected DRM driver version 3.0.x but got version %d.%d.%d", sPriv->drmMajor, sPriv->drmMinor, sPriv->drmPatch);
+   if ( ! driCheckDriDdxDrmVersions( sPriv, "MGA", 4, 0, 1, 0, 3, 0 ) )
       return GL_FALSE;
-   }
-
 
    /* Allocate the private area */
    mgaScreen = (mgaScreenPrivate *)MALLOC(sizeof(mgaScreenPrivate));
@@ -103,21 +91,37 @@ mgaInitDriver(__DRIscreenPrivate *sPriv)
       drmMGAGetParam gp;
 
       gp.param = MGA_PARAM_IRQ_NR;
-      gp.value = (int *) &mgaScreen->irq;
+      gp.value = &mgaScreen->irq;
 
       ret = drmCommandWriteRead( sPriv->fd, DRM_MGA_GETPARAM,
 				    &gp, sizeof(gp));
       if (ret) {
 	    fprintf(stderr, "drmMgaGetParam (MGA_PARAM_IRQ_NR): %d\n", ret);
-	    FREE(mgaScreen);
+	    free(mgaScreen);
 	    sPriv->private = NULL;
 	    return GL_FALSE;
       }
    }
    
+   mgaScreen->linecomp_sane = (sPriv->ddxMajor > 1) || (sPriv->ddxMinor > 1)
+       || ((sPriv->ddxMinor == 1) && (sPriv->ddxPatch > 0));
+#ifndef _SOLO   
+   if ( ! mgaScreen->linecomp_sane ) {
+      PFNGLXDISABLEEXTENSIONPROC glx_disable_extension;
+
+      glx_disable_extension = (PFNGLXDISABLEEXTENSIONPROC)
+	  glXGetProcAddress( "__glXDisableExtension" );
+
+      if ( glx_disable_extension != NULL ) {
+	 (*glx_disable_extension)( "GLX_SGI_swap_control" );
+	 (*glx_disable_extension)( "GLX_SGI_video_sync" );
+	 (*glx_disable_extension)( "GLX_MESA_swap_control" );
+      }
+   }
+#endif
    if (serverInfo->chipset != MGA_CARD_TYPE_G200 &&
        serverInfo->chipset != MGA_CARD_TYPE_G400) {
-      FREE(mgaScreen);
+      free(mgaScreen);
       sPriv->private = NULL;
       __driUtilMessage("Unrecognized chipset");
       return GL_FALSE;
@@ -164,7 +168,7 @@ mgaInitDriver(__DRIscreenPrivate *sPriv)
 	      mgaScreen->agp.size,
 	      (drmAddress *)&mgaScreen->agp.map) != 0)
    {
-      Xfree(mgaScreen);
+      free(mgaScreen);
       sPriv->private = NULL;
       __driUtilMessage("Couldn't map agp region");
       return GL_FALSE;
@@ -210,7 +214,7 @@ mgaInitDriver(__DRIscreenPrivate *sPriv)
    mgaScreen->bufs = drmMapBufs(sPriv->fd);
    if (!mgaScreen->bufs) {
       /*drmUnmap(mgaScreen->agp_tex.map, mgaScreen->agp_tex.size);*/
-      FREE(mgaScreen);
+      free(mgaScreen);
       sPriv->private = NULL;
       __driUtilMessage("Couldn't map dma buffers");
       return GL_FALSE;
@@ -254,12 +258,63 @@ static const struct gl_pipeline_stage *mga_pipeline[] = {
 };
 
 
+static const char * const g400_extensions[] =
+{
+   "GL_ARB_multitexture",
+   "GL_ARB_texture_env_add",
+   "GL_EXT_texture_env_add",
+   "GL_EXT_texture_edge_clamp",
+   "GL_SGIS_texture_edge_clamp",
+#if defined (MESA_packed_depth_stencil)
+   "GL_MESA_packed_depth_stencil",
+#endif
+   NULL
+};
+
+static const char * const card_extensions[] =
+{
+   "GL_ARB_multisample",
+   "GL_ARB_texture_compression",
+   "GL_EXT_fog_coord",
+   /* paletted_textures currently doesn't work, but we could fix them later */
+#if 0
+   "GL_EXT_shared_texture_palette",
+   "GL_EXT_paletted_texture",
+#endif
+   "GL_EXT_secondary_color",
+   "GL_EXT_stencil_wrap",
+   "GL_MESA_ycbcr_texture",
+   "GL_SGIS_generate_mipmap",
+   "GL_SGIS_texture_lod",
+   NULL
+};
+
+static const struct dri_debug_control debug_control[] =
+{
+    { "fall",  DEBUG_VERBOSE_FALLBACK },
+    { "tex",   DEBUG_VERBOSE_TEXTURE },
+    { "ioctl", DEBUG_VERBOSE_IOCTL },
+    { "verb",  DEBUG_VERBOSE_MSG },
+    { "dri",   DEBUG_VERBOSE_DRI },
+    { NULL,    0 }
+};
+
+
+static int
+get_ust_nop( uint64_t * ust )
+{
+   *ust = 1;
+   return 0;
+}
+
+
 static GLboolean
 mgaCreateContext( const __GLcontextModes *mesaVis,
                   __DRIcontextPrivate *driContextPriv,
                   void *sharedContextPrivate )
 {
    int i;
+   unsigned   maxlevels;
    GLcontext *ctx, *shareCtx;
    mgaContextPtr mmesa;
    __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv;
@@ -281,7 +336,7 @@ mgaCreateContext( const __GLcontextModes *mesaVis,
       shareCtx = ((mgaContextPtr) sharedContextPrivate)->glCtx;
    else 
       shareCtx = NULL;
-   mmesa->glCtx = _mesa_create_context(mesaVis, shareCtx, mmesa, GL_TRUE);
+   mmesa->glCtx = _mesa_create_context(mesaVis, shareCtx, (void *) mmesa, GL_TRUE);
    if (!mmesa->glCtx) {
       FREE(mmesa);
       return GL_FALSE;
@@ -298,13 +353,20 @@ mgaCreateContext( const __GLcontextModes *mesaVis,
    mmesa->sarea = (void *)saPriv;
    mmesa->glBuffer = NULL;
 
-   make_empty_list(&mmesa->SwappedOut);
-
-   mmesa->lastTexHeap = mgaScreen->texVirtual[MGA_AGP_HEAP] ? 2 : 1;
-
-   for (i = 0 ; i < mmesa->lastTexHeap ; i++) {
-      mmesa->texHeap[i] = mmInit( 0, mgaScreen->textureSize[i]);
-      make_empty_list(&mmesa->TexObjList[i]);
+   (void) memset( mmesa->texture_heaps, 0, sizeof( mmesa->texture_heaps ) );
+   make_empty_list( & mmesa->swapped );
+
+   mmesa->nr_heaps = mgaScreen->texVirtual[MGA_AGP_HEAP] ? 2 : 1;
+   for ( i = 0 ; i < mmesa->nr_heaps ; i++ ) {
+      mmesa->texture_heaps[i] = driCreateTextureHeap( i, mmesa,
+	    mgaScreen->textureSize[i],
+	    6,
+	    MGA_NR_TEX_REGIONS,
+	    mmesa->sarea->texList[i],
+	    & mmesa->sarea->texAge[i],
+	    & mmesa->swapped,
+	    sizeof( mgaTextureObject_t ),
+	    (destroy_texture_object_t *) mgaDestroyTexObj );
    }
 
    /* Set the maximum texture size small enough that we can guarentee
@@ -312,22 +374,26 @@ mgaCreateContext( const __GLcontextModes *mesaVis,
     * on the card at once.
     */
    ctx = mmesa->glCtx;
-   { 
-      int nr = 2;
-
-      if (mgaScreen->chipset == MGA_CARD_TYPE_G200)
-	 nr = 1;
-
-      if (mgaScreen->textureSize[0] < nr*1024*1024) {
-	 ctx->Const.MaxTextureLevels = 9;
-      } else if (mgaScreen->textureSize[0] < nr*4*1024*1024) {
-	 ctx->Const.MaxTextureLevels = 10;
-      } else {
-	 ctx->Const.MaxTextureLevels = 11;
-      }
+   if ( mgaScreen->chipset == MGA_CARD_TYPE_G200 ) {
+      ctx->Const.MaxTextureUnits = 1;
+      maxlevels = G200_TEX_MAXLEVELS;
 
-      ctx->Const.MaxTextureUnits = nr;
    }
+   else {
+      ctx->Const.MaxTextureUnits = 2;
+      maxlevels = G400_TEX_MAXLEVELS;
+   }
+
+   driCalculateMaxTextureLevels( mmesa->texture_heaps,
+				 mmesa->nr_heaps,
+				 & ctx->Const,
+				 4,
+				 11, /* max 2D texture size is 1024x1024 */
+				 0,  /* 3D textures unsupported. */
+				 0,  /* cube textures unsupported. */
+				 0,  /* texture rectangles unsupported. */
+				 maxlevels,
+				 GL_FALSE );
 
    ctx->Const.MinLineWidth = 1.0;
    ctx->Const.MinLineWidthAA = 1.0;
@@ -335,6 +401,7 @@ mgaCreateContext( const __GLcontextModes *mesaVis,
    ctx->Const.MaxLineWidthAA = 10.0;
    ctx->Const.LineWidthGranularity = 1.0;
 
+   mmesa->default32BitTextures = (mesaVis->rgbBits >= 24);
    mmesa->hw_stencil = mesaVis->stencilBits && mesaVis->depthBits == 24;
 
    switch (mesaVis->depthBits) {
@@ -361,7 +428,6 @@ mgaCreateContext( const __GLcontextModes *mesaVis,
 
    mmesa->haveHwStipple = GL_FALSE;
    mmesa->RenderIndex = -1;		/* impossible value */
-   mmesa->new_state = ~0;
    mmesa->dirty = ~0;
    mmesa->vertex_format = 0;   
    mmesa->CurrentTexObj[0] = 0;
@@ -395,7 +461,11 @@ mgaCreateContext( const __GLcontextModes *mesaVis,
    ctx->DriverCtx = (void *) mmesa;
    mmesa->glCtx = ctx;
 
-   mgaDDExtensionsInit( ctx );
+   driInitExtensions( ctx, card_extensions, GL_FALSE );
+
+   if (MGA_IS_G400(MGA_CONTEXT(ctx))) {
+      driInitExtensions( ctx, g400_extensions, GL_FALSE );
+   }
 
    mgaDDInitStateFuncs( ctx );
    mgaDDInitTextureFuncs( ctx );
@@ -410,6 +480,24 @@ mgaCreateContext( const __GLcontextModes *mesaVis,
 
    driContextPriv->driverPrivate = (void *) mmesa;
 
+#if DO_DEBUG
+   MGA_DEBUG = driParseDebugString( getenv( "MGA_DEBUG" ),
+				    debug_control );
+#endif
+
+   mmesa->vblank_flags = ((mmesa->mgaScreen->irq == 0) 
+			  || !mmesa->mgaScreen->linecomp_sane)
+       ? VBLANK_FLAG_NO_IRQ : driGetDefaultVBlankFlags();
+#ifndef _SOLO
+   mmesa->get_ust = (PFNGLXGETUSTPROC) glXGetProcAddress( "__glXGetUST" );
+   if ( mmesa->get_ust == NULL ) 
+#endif
+   {
+      mmesa->get_ust = get_ust_nop;
+   }
+
+   (*mmesa->get_ust)( & mmesa->swap_ust );
+
    return GL_TRUE;
 }
 
@@ -419,10 +507,15 @@ mgaDestroyContext(__DRIcontextPrivate *driContextPriv)
    mgaContextPtr mmesa = (mgaContextPtr) driContextPriv->driverPrivate;
 
    if (MGA_DEBUG&DEBUG_VERBOSE_DRI)
-      fprintf(stderr, "mgaDestroyContext\n");
+      fprintf( stderr, "[%s:%d] mgaDestroyContext start\n",
+	       __FILE__, __LINE__ );
 
    assert(mmesa); /* should never be null */
    if (mmesa) {
+      GLboolean   release_texture_heaps;
+
+
+      release_texture_heaps = (mmesa->glCtx->Shared->RefCount == 1);
       _swsetup_DestroyContext( mmesa->glCtx );
       _tnl_DestroyContext( mmesa->glCtx );
       _ac_DestroyContext( mmesa->glCtx );
@@ -433,9 +526,27 @@ mgaDestroyContext(__DRIcontextPrivate *driContextPriv)
       /* free the Mesa context */
       mmesa->glCtx->DriverCtx = NULL;
       _mesa_destroy_context(mmesa->glCtx);
-      /* free the mga context */
+       
+      if ( release_texture_heaps ) {
+         /* This share group is about to go away, free our private
+          * texture object data.
+          */
+         int i;
+
+	 assert( is_empty_list( & mmesa->swapped ) );
+
+         for ( i = 0 ; i < mmesa->nr_heaps ; i++ ) {
+	    driDestroyTextureHeap( mmesa->texture_heaps[ i ] );
+	    mmesa->texture_heaps[ i ] = NULL;
+         }
+      }
+
       FREE(mmesa);
    }
+
+   if (MGA_DEBUG&DEBUG_VERBOSE_DRI)
+      fprintf( stderr, "[%s:%d] mgaDestroyContext done\n",
+	       __FILE__, __LINE__ );
 }
 
 
@@ -482,13 +593,7 @@ mgaUnbindContext(__DRIcontextPrivate *driContextPriv)
 }
 
 static GLboolean
-mgaOpenFullScreen(__DRIcontextPrivate *driContextPriv)
-{
-    return GL_TRUE;
-}
-
-static GLboolean
-mgaCloseFullScreen(__DRIcontextPrivate *driContextPriv)
+mgaOpenCloseFullScreen(__DRIcontextPrivate *driContextPriv)
 {
     return GL_TRUE;
 }
@@ -505,8 +610,6 @@ mgaMakeCurrent(__DRIcontextPrivate *driContextPriv,
                __DRIdrawablePrivate *driDrawPriv,
                __DRIdrawablePrivate *driReadPriv)
 {
-   fprintf(stderr, "%s\n", __FUNCTION__);
-
    if (driContextPriv) {
       mgaContextPtr mmesa = (mgaContextPtr) driContextPriv->driverPrivate;
 
@@ -532,6 +635,7 @@ mgaMakeCurrent(__DRIcontextPrivate *driContextPriv,
    return GL_TRUE;
 }
 
+
 void mgaGetLock( mgaContextPtr mmesa, GLuint flags )
 {
    __DRIdrawablePrivate *dPriv = mmesa->driDrawable;
@@ -539,29 +643,10 @@ void mgaGetLock( mgaContextPtr mmesa, GLuint flags )
    int me = mmesa->hHWContext;
    int i;
 
-   fprintf(stderr, "%s\n", __FUNCTION__);
-
    drmGetLock(mmesa->driFd, mmesa->hHWContext, flags);
-   
-   fprintf(stderr, 
-	   "mmesa->lastStamp %d dpriv->lastStamp %d *(dpriv->pStamp) %d\n",
-	   mmesa->lastStamp, 
-	   dPriv->lastStamp,
-	   *(dPriv->pStamp));
-   
-   /* The window might have moved, so we might need to get new clip
-    * rects.
-    *
-    * NOTE: This releases and regrabs the hw lock to allow the X server
-    * to respond to the DRI protocol request for new drawable info.
-    * Since the hardware state depends on having the latest drawable
-    * clip rects, all state checking must be done _after_ this call.
-    */
-   DRI_VALIDATE_DRAWABLE_INFO( sPriv, dPriv );
 
-   if ( mmesa->lastStamp == 0 ||
-	mmesa->lastStamp != dPriv->lastStamp ) {
-      mmesa->lastStamp = dPriv->lastStamp;
+   if (*(dPriv->pStamp) != mmesa->lastStamp) {
+      mmesa->lastStamp = *(dPriv->pStamp);
       mmesa->SetupNewInputs |= VERT_BIT_CLIP;
       mmesa->dirty_cliprects = (MGA_FRONT|MGA_BACK);
       mgaUpdateRects( mmesa, (MGA_FRONT|MGA_BACK) );
@@ -569,7 +654,7 @@ void mgaGetLock( mgaContextPtr mmesa, GLuint flags )
 
    mmesa->dirty |= MGA_UPLOAD_CONTEXT | MGA_UPLOAD_CLIPRECTS;
 
-   mmesa->sarea->dirty |= MGA_UPLOAD_CONTEXT;
+    mmesa->sarea->dirty |= MGA_UPLOAD_CONTEXT;
 
    if (sarea->ctxOwner != me) {
       mmesa->dirty |= (MGA_UPLOAD_CONTEXT | MGA_UPLOAD_TEX0 |
@@ -577,36 +662,48 @@ void mgaGetLock( mgaContextPtr mmesa, GLuint flags )
       sarea->ctxOwner=me;
    }
 
-   for (i = 0 ; i < mmesa->lastTexHeap ; i++)
-      if (sarea->texAge[i] != mmesa->texAge[i])
-	 mgaAgeTextures( mmesa, i );
+   for ( i = 0 ; i < mmesa->nr_heaps ; i++ ) {
+      DRI_AGE_TEXTURES( mmesa->texture_heaps[ i ] );
+   }
 
    sarea->last_quiescent = -1;	/* just kill it for now */
 }
 
 
-
 static const struct __DriverAPIRec mgaAPI = {
-   mgaInitDriver,
-   mgaDestroyScreen,
-   mgaCreateContext,
-   mgaDestroyContext,
-   mgaCreateBuffer,
-   mgaDestroyBuffer,
-   mgaSwapBuffers,
-   mgaMakeCurrent,
-   mgaUnbindContext,
-   mgaOpenFullScreen,
-   mgaCloseFullScreen
+   .InitDriver      = mgaInitDriver,
+   .DestroyScreen   = mgaDestroyScreen,
+   .CreateContext   = mgaCreateContext,
+   .DestroyContext  = mgaDestroyContext,
+   .CreateBuffer    = mgaCreateBuffer,
+   .DestroyBuffer   = mgaDestroyBuffer,
+   .SwapBuffers     = mgaSwapBuffers,
+   .MakeCurrent     = mgaMakeCurrent,
+   .UnbindContext   = mgaUnbindContext,
+   .OpenFullScreen  = mgaOpenCloseFullScreen,
+   .CloseFullScreen = mgaOpenCloseFullScreen,
+   .GetSwapInfo     = getSwapInfo,
+   .GetMSC          = driGetMSC32,
+   .WaitForMSC      = driWaitForMSC32,
+   .WaitForSBC      = NULL,
+   .SwapBuffersMSC  = NULL
 };
 
 
-
 /*
  * This is the bootstrap function for the driver.
  * The __driCreateScreen name is the symbol that libGL.so fetches.
  * Return:  pointer to a __DRIscreenPrivate.
  */
+#ifndef _SOLO
+void *__driCreateScreen(Display *dpy, int scrn, __DRIscreen *psc,
+                        int numConfigs, __GLXvisualConfig *config)
+{
+   __DRIscreenPrivate *psp;
+   psp = __driUtilCreateScreen(dpy, scrn, psc, numConfigs, config, &mgaAPI);
+   return (void *) psp;
+}
+#else
 void *__driCreateScreen(struct DRIDriverRec *driver,
                         struct DRIDriverContextRec *driverContext)
 {
@@ -614,3 +711,56 @@ void *__driCreateScreen(struct DRIDriverRec *driver,
    psp = __driUtilCreateScreen(driver, driverContext, &mgaAPI);
    return (void *) psp;
 }
+#endif
+
+
+#ifndef _SOLO
+/* This function is called by libGL.so as soon as libGL.so is loaded.
+ * This is where we'd register new extension functions with the dispatcher.
+ */
+void
+__driRegisterExtensions( void )
+{
+   PFNGLXENABLEEXTENSIONPROC glx_enable_extension;
+
+
+   if ( driCompareGLXAPIVersion( 20030317 ) >= 0 ) {
+      glx_enable_extension = (PFNGLXENABLEEXTENSIONPROC)
+	  glXGetProcAddress( "__glXEnableExtension" );
+
+      if ( glx_enable_extension != NULL ) {
+	 (*glx_enable_extension)( "GLX_SGI_swap_control", GL_FALSE );
+	 (*glx_enable_extension)( "GLX_SGI_video_sync", GL_FALSE );
+	 (*glx_enable_extension)( "GLX_MESA_swap_control", GL_FALSE );
+	 (*glx_enable_extension)( "GLX_MESA_swap_frame_usage", GL_FALSE );
+      }
+   }
+}
+#endif
+
+/**
+ * Get information about previous buffer swaps.
+ */
+static int
+getSwapInfo( __DRIdrawablePrivate *dPriv, __DRIswapInfo * sInfo )
+{
+   mgaContextPtr  mmesa;
+
+   if ( (dPriv == NULL) || (dPriv->driContextPriv == NULL)
+	|| (dPriv->driContextPriv->driverPrivate == NULL)
+	|| (sInfo == NULL) ) {
+      return -1;
+   }
+
+   mmesa = (mgaContextPtr) dPriv->driContextPriv->driverPrivate;
+   sInfo->swap_count = mmesa->swap_count;
+   sInfo->swap_ust = mmesa->swap_ust;
+   sInfo->swap_missed_count = mmesa->swap_missed_count;
+
+   sInfo->swap_missed_usage = (sInfo->swap_missed_count != 0)
+       ? driCalculateSwapUsage( dPriv, 0, mmesa->swap_missed_ust )
+       : 0.0;
+
+   return 0;
+}
+#endif
diff --git a/src/mesa/drivers/dri/mga/mga_xmesa.h b/src/mesa/drivers/dri/mga/mga_xmesa.h
index eda996f5a44..de349da0895 100644
--- a/src/mesa/drivers/dri/mga/mga_xmesa.h
+++ b/src/mesa/drivers/dri/mga/mga_xmesa.h
@@ -29,8 +29,9 @@
 #ifndef _MGA_INIT_H_
 #define _MGA_INIT_H_
 
+#ifdef GLX_DIRECT_RENDERING
+
 #include <sys/time.h>
-#include <linux/types.h>
 #include "dri_util.h"
 #include "mtypes.h"
 #include "mgaregs.h"
@@ -46,6 +47,9 @@ typedef struct mga_screen_private_s {
    int cpp;			/* for front and back buffers */
    GLint agpMode;
    unsigned int irq;		/* IRQ number (0 means none) */
+   GLboolean  linecomp_sane;    /* GL_TRUE if line comp. programmed correctly
+				 * by the DDX driver.
+				 */
 
    unsigned int mAccess;
 
@@ -136,8 +140,9 @@ do {						\
 #define MGA_BASE( reg )		((unsigned long)(mmesa->mgaScreen->mmio.map))
 #define MGA_ADDR( reg )		(MGA_BASE(reg) + reg)
 
-#define MGA_DEREF( reg )	*(volatile __u32 *)MGA_ADDR( reg )
+#define MGA_DEREF( reg )	*(volatile CARD32 *)MGA_ADDR( reg )
 #define MGA_READ( reg )		MGA_DEREF( reg )
 #define MGA_WRITE( reg, val )	do { MGA_DEREF( reg ) = val; } while (0)
 
 #endif
+#endif
diff --git a/src/mesa/drivers/dri/mga/mgacontext.h b/src/mesa/drivers/dri/mga/mgacontext.h
index 3065ea9fd1f..7188f6d9552 100644
--- a/src/mesa/drivers/dri/mga/mgacontext.h
+++ b/src/mesa/drivers/dri/mga/mgacontext.h
@@ -29,14 +29,15 @@
 #ifndef MGALIB_INC
 #define MGALIB_INC
 
-/*#include <X11/Xlibint.h>*/
+#include <inttypes.h>
 #include "dri_util.h"
 #include "mtypes.h"
+#include "colormac.h"
 #include "xf86drm.h"
 #include "mm.h"
-/*#include "mem.h"*/
 #include "mga_sarea.h"
-
+#include "texmem.h"
+#include "macros.h"
 
 #define MGA_SET_FIELD(reg,mask,val)  reg = ((reg) & (mask)) | ((val) & ~(mask))
 #define MGA_FIELD(field,val) (((val) << (field ## _SHIFT)) & ~(field ## _MASK))
@@ -59,19 +60,9 @@
 #define MGA_FALLBACK_RENDERMODE     0x10
 #define MGA_FALLBACK_STENCIL        0x20
 #define MGA_FALLBACK_DEPTH          0x40
+#define MGA_FALLBACK_BORDER_MODE    0x80
 
 
-/* For mgaCtx->new_state.
- */
-#define MGA_NEW_DEPTH   0x1
-#define MGA_NEW_ALPHA   0x2
-#define MGA_NEW_CLIP    0x8
-#define MGA_NEW_TEXTURE 0x20
-#define MGA_NEW_CULL    0x40
-#define MGA_NEW_WARP    0x80
-#define MGA_NEW_STENCIL 0x100
-#define MGA_NEW_CONTEXT 0x200
-
 /* Use the templated vertex formats:
  */
 #define TAG(x) mga##x
@@ -96,43 +87,103 @@ typedef void (*mga_point_func)( mgaContextPtr, mgaVertex * );
 struct mga_texture_object_s;
 struct mga_screen_private_s;
 
-#define MGA_TEX_MAXLEVELS 5
+#define G200_TEX_MAXLEVELS 5
+#define G400_TEX_MAXLEVELS 11
 
 typedef struct mga_texture_object_s
 {
-   struct mga_texture_object_s *next;
-   struct mga_texture_object_s *prev;
-   struct gl_texture_object *tObj;
-   struct mga_context_t *ctx;
-   PMemBlock	MemBlock;
-   GLuint		offsets[MGA_TEX_MAXLEVELS];
-   int             lastLevel;
-   GLuint         dirty_images;
-   GLuint		totalSize;
-   int		texelBytes;
-   GLuint 	age;
-   int             bound;
-   int             heap;	/* agp or card */
+   driTextureObject   base;
+
+   /* The G200 only has the ability to use 5 mipmap levels (including the
+    * base level).  The G400 does not have this restriction, but it still
+    * only has 5 offset pointers in the hardware.  The trick on the G400 is
+    * upto the first 4 offset pointers point to mipmap levels.  The last
+    * offset pointer tells how large the preceeding mipmap is.  This value is
+    * then used to determine where the remaining mipmaps are.
+    * 
+    * For example, if the first offsets[0] through offsets[2] are used as
+    * pointers, then offset[3] will be the size of the mipmap pointed to by
+    * offsets[2].  So mipmap level 3 will be at (offsets[2]+offsets[3]).  For
+    * each successive mipmap level, offsets[3] is divided by 4 and added to
+    * the previous address.  So mipmap level 4 will be at 
+    * (offsets[2]+offsets[3]+(offsets[3] / 4)).
+    * 
+    * The last pointer is selected by setting TO_texorgoffsetsel in its
+    * pointer.  In the previous example, offset[2] would have
+    * TO_texorgoffsetsel or'ed in before writing it to the hardware.
+    * 
+    * In the current driver all of the mipmaps are packed together linearly
+    * with mipmap level 0.  Therefore offsets[0] points to the base of the
+    * texture (and has TO_texorgoffsetsel or'ed in), and offsets[1] is the
+    * size of the base texture.
+    *
+    * There is a possible optimization available here.  At times the driver
+    * may not be able to allocate a single block of memory for the complete
+    * texture without ejecting some other textures from memory.  It may be
+    * possible to put some of the lower mipmap levels (i.e., the larger
+    * mipmaps) in memory separate from the higher levels.
+    *
+    * The implementation should be fairly obvious, but getting "right" would
+    * likely be non-trivial.  A first allocation for the entire texture would
+    * be attempted with a flag that says "don't eject other textures."  If
+    * that failed, an additional allocation would be attmpted for just the
+    * base map.  The process would repeat with the block of lower maps.  The
+    * tricky parts would be in detecting when some of the levels had been
+    * ejected from texture memory by other textures and preventing the
+    * 4th allocation (for all the smallest mipmap levels) from kicking out
+    * any of the first three.
+    * 
+    * This array holds G400_TEX_MAXLEVELS pointers to remove an if-statement
+    * in a loop in mgaSetTexImages.  Values past G200_TEX_MAXLEVELS are not
+    * used.
+    */
+   GLuint             offsets[G400_TEX_MAXLEVELS];
+
+   int                texelBytes;
+   GLuint             age;
 
    mga_texture_regs_t setup;
+
+   /* If one texture dimension wraps with GL_CLAMP and the other with
+    * GL_CLAMP_TO_EDGE, we have to fallback to software.  We would also have
+    * to fallback for GL_CLAMP_TO_BORDER.
+    */
+   GLboolean          border_fallback;
 } mgaTextureObject_t;
 
+struct mga_hw_state {
+   GLuint   specen;
+   GLuint   cull;
+   GLuint   cull_dualtex;
+   GLuint   stencil;
+   GLuint   stencilctl;
+   GLuint   stencil_enable;
+   GLuint   zmode;
+   GLuint   rop;
+   GLuint   alpha_func;
+   GLuint   alpha_func_enable;
+   GLuint   blend_func;
+   GLuint   blend_func_enable;
+   GLuint   alpha_sel;
+};
+
 struct mga_context_t {
 
    GLcontext *glCtx;
-   unsigned int lastStamp;	/* fullscreen breaks dpriv->laststamp,
-				 * need to shadow it here. */
+   unsigned int lastStamp;		/* fullscreen breaks dpriv->laststamp,
+					 * need to shadow it here. */
+
+   /* Hardware state management
+    */
+   struct mga_hw_state hw;
 
    /* Bookkeeping for texturing
     */
-   int lastTexHeap;
-   struct mga_texture_object_s TexObjList[MGA_NR_TEX_HEAPS];
-   struct mga_texture_object_s SwappedOut;
+   unsigned           nr_heaps;
+   driTexHeap       * texture_heaps[ MGA_NR_TEX_HEAPS ];
+   driTextureObject   swapped;
+
    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.
@@ -166,7 +217,7 @@ struct mga_context_t {
    GLenum raster_primitive;
    GLenum render_primitive;
 
-   char *verts;
+   GLubyte *verts;
    GLint vertex_stride_shift;
    GLuint vertex_format;		
    GLuint vertex_size;
@@ -180,8 +231,7 @@ struct mga_context_t {
 
    /* Manage driver and hardware state
     */
-   GLuint        new_gl_state; 
-   GLuint        new_state; 
+   GLuint        NewGLState; 
    GLuint        dirty;
 
    mga_context_regs_t setup;
@@ -205,13 +255,21 @@ struct mga_context_t {
    /* VBI
     */
    GLuint vbl_seq;
+   GLuint vblank_flags;
+
+   uint64_t swap_ust;
+   uint64_t swap_missed_ust;
+
+   GLuint swap_count;
+   GLuint swap_missed_count;
+
+   PFNGLXGETUSTPROC get_ust;
 
    /* Drawable, cliprect and scissor information
     */
    int dirty_cliprects;		/* which sets of cliprects are uptodate? */
    int draw_buffer;		/* which buffer are we rendering to */
    unsigned 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 */
@@ -245,51 +303,38 @@ struct mga_context_t {
 
 #define MGA_CONTEXT(ctx) ((mgaContextPtr)(ctx->DriverCtx))
 
-#define MGAPACKCOLOR555(r,g,b,a) \
-  ((((r) & 0xf8) << 7) | (((g) & 0xf8) << 2) | (((b) & 0xf8) >> 3) | \
-    ((a) ? 0x8000 : 0))
 
-#define MGAPACKCOLOR565(r,g,b) \
-  ((((r) & 0xf8) << 8) | (((g) & 0xfc) << 3) | (((b) & 0xf8) >> 3))
 
-#define MGAPACKCOLOR88(l, a) \
-  (((l) << 8) | (a))
-
-#define MGAPACKCOLOR888(r,g,b) \
-  (((r) << 16) | ((g) << 8) | (b))
-
-#define MGAPACKCOLOR8888(r,g,b,a) \
-  (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))
-
-#define MGAPACKCOLOR4444(r,g,b,a) \
-  ((((a) & 0xf0) << 8) | (((r) & 0xf0) << 4) | ((g) & 0xf0) | ((b) >> 4))
 
+/* ================================================================
+ * Debugging:
+ */
+#define DO_DEBUG		1
 
-#define MGA_DEBUG 0
-#ifndef MGA_DEBUG
+#if DO_DEBUG
 extern int MGA_DEBUG;
+#else
+#define MGA_DEBUG		0
 #endif
 
-#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
-#define DEBUG_VERBOSE_FALLBACK	0x40
+#define DEBUG_VERBOSE_MSG	0x01
+#define DEBUG_VERBOSE_DRI	0x02
+#define DEBUG_VERBOSE_IOCTL	0x04
+#define DEBUG_VERBOSE_TEXTURE   0x08
+#define DEBUG_VERBOSE_FALLBACK	0x10
 
 static __inline__ GLuint mgaPackColor(GLuint cpp,
 				      GLubyte r, GLubyte g,
 				      GLubyte b, GLubyte a)
 {
-  switch (cpp) {
-  case 2:
-    return MGAPACKCOLOR565(r,g,b);
-  case 4:
-    return MGAPACKCOLOR8888(r,g,b,a);
-  default:
-    return 0;
-  }
+   switch (cpp) {
+   case 2:
+      return PACK_COLOR_565( r, g, b );
+   case 4:
+      return PACK_COLOR_8888( a, r, g, b );
+   default:
+      return 0;
+   }
 }
 
 
diff --git a/src/mesa/drivers/dri/mga/mgadd.c b/src/mesa/drivers/dri/mga/mgadd.c
index 6ce50e6726e..d2f11d8d457 100644
--- a/src/mesa/drivers/dri/mga/mgadd.c
+++ b/src/mesa/drivers/dri/mga/mgadd.c
@@ -29,10 +29,6 @@
 
 #include "mtypes.h"
 
-
-#include <stdio.h>
-#include <stdlib.h>
-
 #include "mm.h"
 #include "mgacontext.h"
 #include "mgadd.h"
@@ -42,12 +38,9 @@
 #include "mgatris.h"
 #include "mgavb.h"
 #include "mga_xmesa.h"
-#include "extensions.h"
-#if defined(USE_X86_ASM)
-#include "X86/common_x86_asm.h"
-#endif
+#include "utils.h"
 
-#define MGA_DATE	"20020221"
+#define DRIVER_DATE	"20030328"
 
 
 /***************************************
@@ -59,52 +52,19 @@ static const GLubyte *mgaDDGetString( GLcontext *ctx, GLenum name )
 {
    mgaContextPtr mmesa = MGA_CONTEXT( ctx );
    static char buffer[128];
+   unsigned   offset;
 
    switch ( name ) {
    case GL_VENDOR:
       return (GLubyte *) "VA Linux Systems Inc.";
 
    case GL_RENDERER:
-      sprintf( buffer, "Mesa DRI %s " MGA_DATE,
-	       MGA_IS_G400(mmesa) ? "G400" :
-	       MGA_IS_G200(mmesa) ? "G200" : "MGA" );
-
-      /* Append any AGP-specific information.
-       */
-      switch ( mmesa->mgaScreen->agpMode ) {
-      case 1:
-	 strncat( buffer, " AGP 1x", 7 );
-	 break;
-      case 2:
-	 strncat( buffer, " AGP 2x", 7 );
-	 break;
-      case 4:
-	 strncat( buffer, " AGP 4x", 7 );
-	 break;
-      }
-
-      /* Append any CPU-specific information.
-       */
-#ifdef USE_X86_ASM
-      if ( _mesa_x86_cpu_features ) {
-	 strncat( buffer, " x86", 4 );
-      }
-#endif
-#ifdef USE_MMX_ASM
-      if ( cpu_has_mmx ) {
-	 strncat( buffer, "/MMX", 4 );
-      }
-#endif
-#ifdef USE_3DNOW_ASM
-      if ( cpu_has_3dnow ) {
-	 strncat( buffer, "/3DNow!", 7 );
-      }
-#endif
-#ifdef USE_SSE_ASM
-      if ( cpu_has_xmm ) {
-	 strncat( buffer, "/SSE", 4 );
-      }
-#endif
+      offset = driGetRendererString( buffer, 
+				     MGA_IS_G400(mmesa) ? "G400" :
+				     MGA_IS_G200(mmesa) ? "G200" : "MGA",
+				     DRIVER_DATE,
+				     mmesa->mgaScreen->agpMode );
+
       return (GLubyte *)buffer;
 
    default:
@@ -129,40 +89,6 @@ static void mgaBufferSize(GLframebuffer *buffer, GLuint *width, GLuint *height)
    UNLOCK_HARDWARE( mmesa );
 }
 
-void mgaDDExtensionsInit( GLcontext *ctx )
-{
-   /* paletted_textures currently doesn't work, but we could fix them later */
-   /*
-   _mesa_enable_extension( ctx, "GL_EXT_shared_texture_palette" );
-   _mesa_enable_extension( ctx, "GL_EXT_paletted_texture" );
-   */
-
-   _mesa_enable_extension( ctx, "GL_ARB_texture_compression" );
-   _mesa_enable_extension( ctx, "GL_ARB_multisample" );
-
-   _mesa_enable_extension( ctx, "GL_SGIS_generate_mipmap" );
-
-   /* Turn on multitexture and texenv_add for the G400.
-    */
-   if (MGA_IS_G400(MGA_CONTEXT(ctx))) {
-      _mesa_enable_extension( ctx, "GL_ARB_multitexture" );
-      _mesa_enable_extension( ctx, "GL_ARB_texture_env_add" );
-
-      _mesa_enable_extension( ctx, "GL_EXT_texture_env_add" );
-
-#if defined (MESA_packed_depth_stencil)
-      _mesa_enable_extension( ctx, "GL_MESA_packed_depth_stencil" );
-#endif
-
-#if defined (MESA_experimetal_agp_allocator)
-      if (!getenv("MGA_DISABLE_AGP_ALLOCATOR"))  
-	 _mesa_enable_extension( ctx, "GL_MESA_experimental_agp_allocator" );
-#endif
-   }
-}
-
-
-
 void mgaDDInitDriverFuncs( GLcontext *ctx )
 {
    ctx->Driver.GetBufferSize = mgaBufferSize;
diff --git a/src/mesa/drivers/dri/mga/mgadd.h b/src/mesa/drivers/dri/mga/mgadd.h
index 6072e6cfc9f..919fd742d61 100644
--- a/src/mesa/drivers/dri/mga/mgadd.h
+++ b/src/mesa/drivers/dri/mga/mgadd.h
@@ -32,6 +32,5 @@
 #include "context.h"
 
 void mgaDDInitDriverFuncs( GLcontext *ctx );
-void mgaDDExtensionsInit( GLcontext *ctx );
 
 #endif
diff --git a/src/mesa/drivers/dri/mga/mgaioctl.c b/src/mesa/drivers/dri/mga/mgaioctl.c
index f88c8780607..6b50af202a8 100644
--- a/src/mesa/drivers/dri/mga/mgaioctl.c
+++ b/src/mesa/drivers/dri/mga/mgaioctl.c
@@ -27,7 +27,7 @@
  */
 /* $XFree86: xc/lib/GL/mesa/src/drv/mga/mgaioctl.c,v 1.16 2002/12/16 16:18:52 dawes Exp $ */
 
-#include <stdio.h>
+#include <sched.h>
 #include <errno.h>
 
 #include "mtypes.h"
@@ -43,11 +43,10 @@
 #include "mgavb.h"
 #include "mgaioctl.h"
 #include "mgatris.h"
-#include "mgabuffers.h"
+#include "mga_common.h"
 
+#include "vblank.h"
 
-#include "xf86drm.h"
-#include "mga_common.h"
 
 static void mga_iload_dma_ioctl(mgaContextPtr mmesa,
 				unsigned long dest,
@@ -61,6 +60,13 @@ static void mga_iload_dma_ioctl(mgaContextPtr mmesa,
       fprintf(stderr, "DRM_IOCTL_MGA_ILOAD idx %d dst %x length %d\n",
 	      buf->idx, (int) dest, length);
 
+   if ( (length & MGA_ILOAD_MASK) != 0 ) {
+      UNLOCK_HARDWARE( mmesa );
+      fprintf( stderr, "%s: Invalid ILOAD datasize (%d), must be "
+	       "multiple of %u.\n", __FUNCTION__, length, MGA_ILOAD_ALIGN );
+      exit( 1 );
+   }
+
    iload.idx = buf->idx;
    iload.dstorg = dest;
    iload.length = length;
@@ -278,65 +284,11 @@ mgaDDClear( GLcontext *ctx, GLbitfield mask, GLboolean all,
 }
 
 
-int nrswaps;
-
-
-void mgaWaitForVBlank( mgaContextPtr mmesa )
-{
-#if 0
-    drmVBlank vbl;
-    int ret;
-
-    if ( !mmesa->mgaScreen->irq )
-	return;
-
-    if ( getenv("LIBGL_SYNC_REFRESH") ) {
-	/* Wait for until the next vertical blank */
-	vbl.request.type = DRM_VBLANK_RELATIVE;
-	vbl.request.sequence = 1;
-    } else if ( getenv("LIBGL_THROTTLE_REFRESH") ) {
-	/* Wait for at least one vertical blank since the last call */
-	vbl.request.type = DRM_VBLANK_ABSOLUTE;
-	vbl.request.sequence = mmesa->vbl_seq + 1;
-    } else {
-	return;
-    }
-
-    if ((ret = drmWaitVBlank( mmesa->driFd, &vbl ))) {
-	fprintf(stderr, "%s: drmWaitVBlank returned %d, IRQs don't seem to be"
-		" working correctly.\nTry running with LIBGL_THROTTLE_REFRESH"
-		" and LIBL_SYNC_REFRESH unset.\n", __FUNCTION__, ret);
-	exit(1);
-    }
-
-    mmesa->vbl_seq = vbl.reply.sequence;
-#endif
-}
-
-
-/*
- * Copy the back buffer to the front buffer.
- */
-void mgaSwapBuffers(__DRIdrawablePrivate *dPriv)
+static void mgaWaitForFrameCompletion( mgaContextPtr mmesa )
 {
-   mgaContextPtr mmesa;
-   XF86DRIClipRectPtr pbox;
-   GLint nbox;
-   GLint ret, wait = 0;
-   GLint i;
+   unsigned wait = 0;
    GLuint last_frame, last_wrap;
 
-   assert(dPriv);
-   assert(dPriv->driContextPriv);
-   assert(dPriv->driContextPriv->driverPrivate);
-
-   mmesa = (mgaContextPtr) dPriv->driContextPriv->driverPrivate;
-
-   FLUSH_BATCH( mmesa );
-
-   mgaWaitForVBlank( mmesa );
-
-   LOCK_HARDWARE( mmesa );
 
    last_frame = mmesa->sarea->last_frame.head;
    last_wrap = mmesa->sarea->last_frame.wrap;
@@ -360,12 +312,46 @@ void mgaSwapBuffers(__DRIdrawablePrivate *dPriv)
       }
       UPDATE_LOCK( mmesa, DRM_LOCK_FLUSH );
 
-      for ( i = 0 ; i < 1024 ; i++ ) {
-	 /* Don't just hammer the register... */
-      }
+      UNLOCK_HARDWARE( mmesa );
+      DO_USLEEP( 1 );
+      LOCK_HARDWARE( mmesa );
    }
    if ( wait )
       fprintf( stderr, "\n" );
+}
+
+
+/*
+ * Copy the back buffer to the front buffer.
+ */
+void mgaSwapBuffers( __DRIdrawablePrivate *dPriv )
+{
+   mgaContextPtr mmesa;
+   XF86DRIClipRectPtr pbox;
+   GLint nbox;
+   GLint ret;
+   GLint i;
+   GLboolean   missed_target;
+
+
+   assert(dPriv);
+   assert(dPriv->driContextPriv);
+   assert(dPriv->driContextPriv->driverPrivate);
+
+   mmesa = (mgaContextPtr) dPriv->driContextPriv->driverPrivate;
+
+   FLUSH_BATCH( mmesa );
+
+   LOCK_HARDWARE( mmesa );
+   mgaWaitForFrameCompletion( mmesa );
+   UNLOCK_HARDWARE( mmesa );
+   driWaitForVBlank( dPriv, & mmesa->vbl_seq, mmesa->vblank_flags,
+		     & missed_target );
+   if ( missed_target ) {
+      mmesa->swap_missed_count++;
+      (void) (*mmesa->get_ust)( & mmesa->swap_missed_ust );
+   }
+   LOCK_HARDWARE( mmesa );
 
    /* Use the frontbuffer cliprects
     */
@@ -399,6 +385,8 @@ void mgaSwapBuffers(__DRIdrawablePrivate *dPriv)
    UNLOCK_HARDWARE( mmesa );
 
    mmesa->dirty |= MGA_UPLOAD_CLIPRECTS;
+   mmesa->swap_count++;
+   (void) (*mmesa->get_ust)( & mmesa->swap_ust );
 }
 
 
@@ -442,18 +430,17 @@ void mgaWaitAge( mgaContextPtr mmesa, int age  )
 }
 
 
-static int intersect_rect( XF86DRIClipRectPtr out,
-			   XF86DRIClipRectPtr a,
-			   XF86DRIClipRectPtr b )
+static GLboolean intersect_rect( XF86DRIClipRectPtr out,
+				 const XF86DRIClipRectPtr a,
+				 const XF86DRIClipRectPtr 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;
+
+   return ((out->x1 < out->x2) && (out->y1 < out->y2));
 }
 
 
@@ -559,7 +546,7 @@ void mgaFlushVerticesLocked( mgaContextPtr mmesa )
          vertex.idx = buffer->idx;
          vertex.used = buffer->used;
          vertex.discard = discard;
-         drmCommandWrite( mmesa->driFd, DRM_MGA_VERTEX, 
+         drmCommandWrite( mmesa->driFd, DRM_MGA_VERTEX,
                           &vertex, sizeof(drmMGAVertex) );
 
 	 age_mmesa(mmesa, mmesa->sarea->last_enqueue);
diff --git a/src/mesa/drivers/dri/mga/mgaioctl.h b/src/mesa/drivers/dri/mga/mgaioctl.h
index b7cf44d6ff9..2d959d8246d 100644
--- a/src/mesa/drivers/dri/mga/mgaioctl.h
+++ b/src/mesa/drivers/dri/mga/mgaioctl.h
@@ -34,6 +34,7 @@
 #include "mga_xmesa.h"
 
 void mgaSwapBuffers( __DRIdrawablePrivate *dPriv );
+void mgaWaitForVBlank( mgaContextPtr mmesa );
 
 GLuint *mgaAllocVertexDwords( mgaContextPtr mmesa, int dwords );
 
@@ -41,7 +42,6 @@ GLuint *mgaAllocVertexDwords( mgaContextPtr mmesa, int dwords );
 void mgaGetILoadBufferLocked( mgaContextPtr mmesa );
 drmBufPtr mgaGetBufferLocked( mgaContextPtr mmesa );
 
-void mgaWaitForVBlank( mgaContextPtr mmesa );
 
 void mgaFireILoadLocked( mgaContextPtr mmesa,
 			 GLuint offset, GLuint length );
@@ -104,8 +104,9 @@ do {									\
    if ( ret < 0 ) {							\
       drmCommandNone( mmesa->driFd, DRM_MGA_RESET );			\
       UNLOCK_HARDWARE( mmesa );						\
-      fprintf( stderr, "%s: flush ret=%d\n", __FUNCTION__, ret );	\
-      /*fprintf( stderr, "drmMGAFlushDMA: return = %d\n", ret );*/	\
+      fprintf( stderr, "%s: flush return = %s (%d), flags = 0x%08x\n",	\
+	       __FUNCTION__, strerror( -ret ), -ret,			\
+	       (unsigned)(flags) );					\
       exit( 1 );							\
    }									\
 } while (0)
diff --git a/src/mesa/drivers/dri/mga/mgapixel.c b/src/mesa/drivers/dri/mga/mgapixel.c
index 0bc4b3fac5f..07e0c3a7563 100644
--- a/src/mesa/drivers/dri/mga/mgapixel.c
+++ b/src/mesa/drivers/dri/mga/mgapixel.c
@@ -35,12 +35,12 @@
 #include "mgacontext.h"
 #include "mgaioctl.h"
 #include "mgapixel.h"
-#include "mgabuffers.h"
+#include "mgastate.h"
 
-#include "xf86drm.h"
 #include "mga_common.h"
 
 #include "swrast/swrast.h"
+#include "imports.h"
 
 #define IS_AGP_MEM( mmesa, p )						  \
    ((unsigned long)mmesa->mgaScreen->buffers.map <= ((unsigned long)p) && \
@@ -134,7 +134,7 @@ check_color_per_fragment_ops( const GLcontext *ctx )
 		    !ctx->Color.ColorMask[2] ||
 		    !ctx->Color.ColorMask[3] ||
 		    ctx->Color.ColorLogicOpEnabled ||
-		    ctx->Texture.Unit[0]._ReallyEnabled ||
+		    ctx->Texture._EnabledUnits ||
 		    ctx->Depth.OcclusionTest
            ) &&
 	   ctx->Current.RasterPosValid &&
@@ -596,7 +596,7 @@ mgaTryDrawPixels( GLcontext *ctx,
 	    }
 	 }
 #else
-	 memcpy( address, pixels, rows*bufferpitch );
+	 MEMCPY( address, pixels, rows*bufferpitch );
 #endif
 
 	 do_draw_pix( ctx, x, y, width, rows,
@@ -639,42 +639,8 @@ mgaDDDrawPixels( GLcontext *ctx,
  * the same block of agp space which isn't used for anything else at
  * present.
  */
-#if defined(MESA_hacked_agp_allocator)
-static void mgaDDFreeAgpMemory( GLcontext *ctx, void *ptr )
-{
-   (void) ptr;
-}
-
-static void *mgaDDAllocateAgpMemory( GLcontext *ctx, GLsizei size )
-{
-   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
-
-   if (size < mmesa->mgaScreen->textureSize[MGA_AGP_HEAP])
-      return mmesa->mgaScreen->texVirtual[MGA_AGP_HEAP];
-   else
-      return 0;
-}
-
-static GLint mgaDDGetAgpOffset( GLcontext *ctx, const void *ptr )
-{
-   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
-
-   if (!IS_AGP_MEM(mmesa, ptr))
-      return -1;
-
-   return AGP_OFFSET(mmesa, ptr);
-}
-#endif
-
-
 void mgaDDInitPixelFuncs( GLcontext *ctx )
 {
-#if defined (MESA_experimetal_agp_allocator)
-   ctx->Driver.AllocateAgpMemory = mgaDDAllocateAgpMemory;
-   ctx->Driver.GetAgpOffset = mgaDDGetAgpOffset;
-   ctx->Driver.FreeAgpMemory = mgaDDFreeAgpMemory;
-#endif
-
    /* Pixel path fallbacks.
     */
    ctx->Driver.Accum = _swrast_Accum;
diff --git a/src/mesa/drivers/dri/mga/mgaregs.h b/src/mesa/drivers/dri/mga/mgaregs.h
index f07dc2de0be..e1291ca01bd 100644
--- a/src/mesa/drivers/dri/mga/mgaregs.h
+++ b/src/mesa/drivers/dri/mga/mgaregs.h
@@ -1052,6 +1052,7 @@
 #    define TMC_tformat_tw8a 		0x7 		/* val 7, shift 0 */
 #    define TMC_tformat_tw8al 		0x8 		/* val 8, shift 0 */
 #    define TMC_tformat_tw422 		0xa 		/* val 10, shift 0 */
+#    define TMC_tformat_tw422uyvy	0xb 		/* val 11, shift 0 */
 #    define TMC_tpitchlin_MASK 		0xfffffeff 	/* bit 8 */
 #    define TMC_tpitchlin_disable 	0x0 		
 #    define TMC_tpitchlin_enable 	0x100 		
@@ -1137,6 +1138,13 @@
 #    define TF_magfilter_nrst 		0x0 		/* val 0, shift 4 */
 #    define TF_magfilter_bilin 		0x20 		/* val 2, shift 4 */
 #    define TF_magfilter_cnst 		0x30 		/* val 3, shift 4 */
+#    define TF_uvoffset_SHIFT		17
+#    define TF_uvoffset_OGL		(0U << TF_uvoffset_SHIFT)
+#    define TF_uvoffset_D3D		(1U << TF_uvoffset_SHIFT)
+#    define TF_uvoffset_MASK		(~(1U << TF_uvoffset_SHIFT))
+#    define TF_reserved_MASK		(~0x1ff00)	/* bits 8-16 */
+#    define TF_mapnbhigh_SHIFT 		18
+#    define TF_mapnbhigh_MASK 		(~(1U << TF_mapnbhigh_SHIFT))
 #    define TF_avgstride_MASK 		0xfff7ffff 	/* bit 19 */
 #    define TF_avgstride_disable 	0x0 		
 #    define TF_avgstride_enable 	0x80000 	
@@ -1377,5 +1385,11 @@
 
 /**************** (END) AUTOMATICLY GENERATED REGISTER FILE ******************/
 
+/* Copied from mga_drv.h kernel file.
+ */
+
+#define MGA_ILOAD_ALIGN		64
+#define MGA_ILOAD_MASK		(MGA_ILOAD_ALIGN - 1)
+
 #endif 	/* _MGAREGS_H_ */
 
diff --git a/src/mesa/drivers/dri/mga/mgarender.c b/src/mesa/drivers/dri/mga/mgarender.c
index 53614c223fc..516a99099fd 100644
--- a/src/mesa/drivers/dri/mga/mgarender.c
+++ b/src/mesa/drivers/dri/mga/mgarender.c
@@ -42,9 +42,8 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "glheader.h"
 #include "context.h"
 #include "macros.h"
-/*//#include "mem.h"*/
+#include "imports.h"
 #include "mtypes.h"
-/*#include "mmath.h" */
 
 #include "tnl/t_context.h"
 
@@ -165,7 +164,7 @@ static GLboolean mga_run_render( GLcontext *ctx,
 
 static void mga_check_render( GLcontext *ctx, struct gl_pipeline_stage *stage )
 {
-   GLuint inputs = VERT_BIT_POS | VERT_BIT_CLIP | VERT_BIT_COLOR0;
+   GLuint inputs = VERT_BIT_CLIP | VERT_BIT_COLOR0;
 
    if (ctx->RenderMode == GL_RENDER) {
       if (ctx->_TriangleCaps & DD_SEPARATE_SPECULAR) 
diff --git a/src/mesa/drivers/dri/mga/mgaspan.c b/src/mesa/drivers/dri/mga/mgaspan.c
index 8dc971cfc57..684239865f7 100644
--- a/src/mesa/drivers/dri/mga/mgaspan.c
+++ b/src/mesa/drivers/dri/mga/mgaspan.c
@@ -116,7 +116,7 @@
 
 #undef INIT_MONO_PIXEL
 #define INIT_MONO_PIXEL(p, color) \
-  p = MGAPACKCOLOR565( color[0], color[1], color[2] )
+  p = PACK_COLOR_565( color[0], color[1], color[2] )
 
 
 #define WRITE_RGBA( _x, _y, r, g, b, a )				\
@@ -148,7 +148,7 @@ do {								\
 
 #undef INIT_MONO_PIXEL
 #define INIT_MONO_PIXEL(p, color) \
-  p = MGAPACKCOLOR8888( color[0], color[1], color[2], color[3] )
+  p = PACK_COLOR_8888( color[3], color[0], color[1], color[2] )
 
 
 #define WRITE_RGBA(_x, _y, r, g, b, a)			\
@@ -233,11 +233,38 @@ do {								\
 
 
 
+/*
+ * This function is called to specify which buffer to read and write
+ * for software rasterization (swrast) fallbacks.  This doesn't necessarily
+ * correspond to glDrawBuffer() or glReadBuffer() calls.
+ */
+static void mgaDDSetBuffer(GLcontext *ctx, GLframebuffer *buffer,
+                           GLuint bufferBit)
+{
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+
+   if (bufferBit == FRONT_LEFT_BIT) 
+   {
+      mmesa->drawOffset = mmesa->mgaScreen->frontOffset;
+      mmesa->readOffset = mmesa->mgaScreen->frontOffset;
+   } 
+   else if (bufferBit == BACK_LEFT_BIT)
+   {
+      mmesa->drawOffset = mmesa->mgaScreen->backOffset;
+      mmesa->readOffset = mmesa->mgaScreen->backOffset;
+   }
+   else {
+      assert(0);
+   }
+}
+
 void mgaDDInitSpanFuncs( GLcontext *ctx )
 {
    mgaContextPtr mmesa = MGA_CONTEXT(ctx);
    struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference(ctx);
 
+   swdd->SetBuffer = mgaDDSetBuffer;
+
    switch (mmesa->mgaScreen->cpp) {
    case 2:
       swdd->WriteRGBASpan = mgaWriteRGBASpan_565;
diff --git a/src/mesa/drivers/dri/mga/mgastate.c b/src/mesa/drivers/dri/mga/mgastate.c
index 02b98fdb766..0d304966d7e 100644
--- a/src/mesa/drivers/dri/mga/mgastate.c
+++ b/src/mesa/drivers/dri/mga/mgastate.c
@@ -26,9 +26,9 @@
  */
 /* $XFree86: xc/lib/GL/mesa/src/drv/mga/mgastate.c,v 1.13 2002/10/30 12:51:36 alanh Exp $ */
 
-#include <stdio.h>
 
 #include "mtypes.h"
+#include "colormac.h"
 #include "dd.h"
 
 #include "mm.h"
@@ -40,19 +40,22 @@
 #include "mgatris.h"
 #include "mgaioctl.h"
 #include "mgaregs.h"
-#include "mgabuffers.h"
 
 #include "swrast/swrast.h"
 #include "array_cache/acache.h"
 #include "tnl/tnl.h"
+#include "tnl/t_context.h"
+#include "tnl/t_pipeline.h"
 #include "swrast_setup/swrast_setup.h"
 
 
+static void updateSpecularLighting( GLcontext *ctx );
+
 
 /* Some outstanding problems with accelerating logic ops...
  */
 #if defined(ACCEL_ROP)
-static GLuint mgarop_NoBLK[16] = {
+static const GLuint mgarop_NoBLK[16] = {
    DC_atype_rpl  | 0x00000000, DC_atype_rstr | 0x00080000,
    DC_atype_rstr | 0x00040000, DC_atype_rpl  | 0x000c0000,
    DC_atype_rstr | 0x00020000, DC_atype_rstr | 0x000a0000,
@@ -65,221 +68,57 @@ static GLuint mgarop_NoBLK[16] = {
 #endif
 
 
-static void mgaUpdateStencil(const GLcontext *ctx)
-{
-   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
-   GLuint stencil = 0, stencilctl = 0;
-
-   if (ctx->Stencil.Enabled)
-   {
-      stencil = ctx->Stencil.Ref[0] |
-	 ( ctx->Stencil.ValueMask[0] << 8 ) |
-	 ( ctx->Stencil.WriteMask[0] << 16 );
-
-      switch (ctx->Stencil.Function[0])
-      {
-      case GL_NEVER:
-	 MGA_SET_FIELD(stencilctl, SC_smode_MASK, SC_smode_snever);
-	 break;
-      case GL_LESS:
-	 MGA_SET_FIELD(stencilctl, SC_smode_MASK, SC_smode_slt);
-	 break;
-      case GL_LEQUAL:
-	 MGA_SET_FIELD(stencilctl, SC_smode_MASK, SC_smode_slte);
-	 break;
-      case GL_GREATER:
-	 MGA_SET_FIELD(stencilctl, SC_smode_MASK, SC_smode_sgt);
-	 break;
-      case GL_GEQUAL:
-	 MGA_SET_FIELD(stencilctl, SC_smode_MASK, SC_smode_sgte);
-	 break;
-      case GL_NOTEQUAL:
-	 MGA_SET_FIELD(stencilctl, SC_smode_MASK, SC_smode_sne);
-	 break;
-      case GL_EQUAL:
-	 MGA_SET_FIELD(stencilctl, SC_smode_MASK, SC_smode_se);
-	 break;
-      case GL_ALWAYS:
-	 MGA_SET_FIELD(stencilctl, SC_smode_MASK, SC_smode_salways);
-      default:
-	 break;
-      }
-
-      switch (ctx->Stencil.FailFunc[0])
-      {
-      case GL_KEEP:
-	 MGA_SET_FIELD(stencilctl, SC_sfailop_MASK, SC_sfailop_keep);
-	 break;
-      case GL_ZERO:
-	 MGA_SET_FIELD(stencilctl, SC_sfailop_MASK, SC_sfailop_zero);
-	 break;
-      case GL_REPLACE:
-	 MGA_SET_FIELD(stencilctl, SC_sfailop_MASK, SC_sfailop_replace);
-	 break;
-      case GL_INCR:
-	 MGA_SET_FIELD(stencilctl, SC_sfailop_MASK, SC_sfailop_incrsat);
-	 break;
-      case GL_DECR:
-	 MGA_SET_FIELD(stencilctl, SC_sfailop_MASK, SC_sfailop_decrsat);
-	 break;
-      case GL_INVERT:
-	 MGA_SET_FIELD(stencilctl, SC_sfailop_MASK, SC_sfailop_invert);
-	 break;
-      default:
-	 break;
-      }
-
-      switch (ctx->Stencil.ZFailFunc[0])
-      {
-      case GL_KEEP:
-	 MGA_SET_FIELD(stencilctl, SC_szfailop_MASK, SC_szfailop_keep);
-	 break;
-      case GL_ZERO:
-	 MGA_SET_FIELD(stencilctl, SC_szfailop_MASK, SC_szfailop_zero);
-	 break;
-      case GL_REPLACE:
-	 MGA_SET_FIELD(stencilctl, SC_szfailop_MASK, SC_szfailop_replace);
-	 break;
-      case GL_INCR:
-	 MGA_SET_FIELD(stencilctl, SC_szfailop_MASK, SC_szfailop_incrsat);
-	 break;
-      case GL_DECR:
-	 MGA_SET_FIELD(stencilctl, SC_szfailop_MASK, SC_szfailop_decrsat);
-	 break;
-      case GL_INVERT:
-	 MGA_SET_FIELD(stencilctl, SC_szfailop_MASK, SC_szfailop_invert);
-	 break;
-      default:
-	 break;
-      }
-
-      switch (ctx->Stencil.ZPassFunc[0])
-      {
-      case GL_KEEP:
-	 MGA_SET_FIELD(stencilctl, SC_szpassop_MASK, SC_szpassop_keep);
-	 break;
-      case GL_ZERO:
-	 MGA_SET_FIELD(stencilctl, SC_szpassop_MASK, SC_szpassop_zero);
-	 break;
-      case GL_REPLACE:
-	 MGA_SET_FIELD(stencilctl, SC_szpassop_MASK, SC_szpassop_replace);
-	 break;
-      case GL_INCR:
-	 MGA_SET_FIELD(stencilctl, SC_szpassop_MASK, SC_szpassop_incrsat);
-	 break;
-      case GL_DECR:
-	 MGA_SET_FIELD(stencilctl, SC_szpassop_MASK, SC_szpassop_decrsat);
-	 break;
-      case GL_INVERT:
-	 MGA_SET_FIELD(stencilctl, SC_szpassop_MASK, SC_szpassop_invert);
-	 break;
-      default:
-	 break;
-      }
-   }
-
-   mmesa->setup.stencil = stencil;
-   mmesa->setup.stencilctl = stencilctl;
-   mmesa->dirty |= MGA_UPLOAD_CONTEXT;
-}
-
-static void mgaDDStencilFunc(GLcontext *ctx, GLenum func, GLint ref,
-			     GLuint mask)
-{
-   FLUSH_BATCH( MGA_CONTEXT(ctx) );
-   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_STENCIL;
-}
-
-static void mgaDDStencilMask(GLcontext *ctx, GLuint mask)
-{
-   FLUSH_BATCH( MGA_CONTEXT(ctx) );
-   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_STENCIL;
-}
-
-static void mgaDDStencilOp(GLcontext *ctx, GLenum fail, GLenum zfail,
-			   GLenum zpass)
-{
-   FLUSH_BATCH( MGA_CONTEXT(ctx) );
-   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_STENCIL;
-}
+/* =============================================================
+ * Alpha blending
+ */
 
-static void mgaDDClearDepth(GLcontext *ctx, GLclampd d)
+static void mgaDDAlphaFunc(GLcontext *ctx, GLenum func, GLfloat ref)
 {
    mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+   GLubyte refByte;
+   GLuint  a;
 
-   /* KW: should the ~ be there? */
-   switch (mmesa->setup.maccess & ~MA_zwidth_MASK) {
-   case MA_zwidth_16: mmesa->ClearDepth = d * 0x0000ffff; break;
-   case MA_zwidth_24: mmesa->ClearDepth = d * 0xffffff00; break;
-   case MA_zwidth_32: mmesa->ClearDepth = d * 0xffffffff; break;
-   default: return;
-   }
-}
-
-static void mgaUpdateZMode(const GLcontext *ctx)
-{
-   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
-   int zmode = 0;
-
-   if (ctx->Depth.Test) {
-      switch(ctx->Depth.Func)  {
-      case GL_NEVER:
-         /* can't do this in h/w, we'll use a s/w fallback */
-	 zmode = DC_zmode_nozcmp;
-         break;
-      case GL_ALWAYS:
-	 zmode = DC_zmode_nozcmp; break;
-      case GL_LESS:
-	 zmode = DC_zmode_zlt; break;
-      case GL_LEQUAL:
-	 zmode = DC_zmode_zlte; break;
-      case GL_EQUAL:
-	 zmode = DC_zmode_ze; break;
-      case GL_GREATER:
-	 zmode = DC_zmode_zgt; break;
-      case GL_GEQUAL:
-	 zmode = DC_zmode_zgte; break;
-      case GL_NOTEQUAL:
-	 zmode = DC_zmode_zne; break;
-      default:
-	 break;
-      }
+   CLAMPED_FLOAT_TO_UBYTE(refByte, ref);
 
-      if (ctx->Depth.Mask)
-         zmode |= DC_atype_zi;
-      else
-         zmode |= DC_atype_i;
-   }
-   else {
-      zmode |= DC_zmode_nozcmp;
-      zmode |= DC_atype_i;  /* don't write to zbuffer */
+   switch ( func ) {
+   case GL_NEVER:
+      a = AC_atmode_alt;
+      refByte = 0;
+      break;
+   case GL_LESS:
+      a = AC_atmode_alt;
+      break;
+   case GL_GEQUAL:
+      a = AC_atmode_agte;
+      break;
+   case GL_LEQUAL:
+      a = AC_atmode_alte;
+      break;
+   case GL_GREATER:
+      a = AC_atmode_agt;
+      break;
+   case GL_NOTEQUAL:
+      a = AC_atmode_ane;
+      break;
+   case GL_EQUAL:
+      a = AC_atmode_ae;
+      break;
+   case GL_ALWAYS:
+      a = AC_atmode_noacmp;
+      break;
+   default:
+      a = 0;
+      break;
    }
 
-#if defined(ACCEL_ROP)
-   mmesa->setup.dwgctl &= DC_bop_MASK;
-   if (ctx->Color.ColorLogicOpEnabled)
-      zmode |= mgarop_NoBLK[(ctx->Color.LogicOp)&0xf];
-   else
-      zmode |= mgarop_NoBLK[GL_COPY & 0xf];
-#endif
-
-   mmesa->setup.dwgctl &= DC_zmode_MASK & DC_atype_MASK;
-   mmesa->setup.dwgctl |= zmode;
+   FLUSH_BATCH( mmesa );
+   mmesa->hw.alpha_func = a | MGA_FIELD( AC_atref, refByte );
    mmesa->dirty |= MGA_UPLOAD_CONTEXT;
 }
 
-
-static void mgaDDAlphaFunc(GLcontext *ctx, GLenum func, GLfloat 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;
 
    /* BlendEquation sets ColorLogicOpEnabled in an unexpected 
     * manner.  
@@ -291,247 +130,169 @@ static void mgaDDBlendEquation(GLcontext *ctx, GLenum mode)
 
 static void mgaDDBlendFunc(GLcontext *ctx, GLenum sfactor, GLenum dfactor)
 {
-   FLUSH_BATCH( MGA_CONTEXT(ctx) );
-   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_ALPHA;
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+   mgaScreenPrivate *mgaScreen = mmesa->mgaScreen;
+   GLuint   src;
+   GLuint   dst;
+
+   switch (ctx->Color.BlendSrcRGB) {
+   case GL_ZERO:
+      src = AC_src_zero; break;
+   case GL_SRC_ALPHA:
+      src = AC_src_src_alpha; break;
+   case GL_ONE:
+   default:		/* never happens */
+      src = AC_src_one; break;
+   case GL_DST_COLOR:
+      src = AC_src_dst_color; break;
+   case GL_ONE_MINUS_DST_COLOR:
+      src = AC_src_om_dst_color; break;
+   case GL_ONE_MINUS_SRC_ALPHA:
+      src = AC_src_om_src_alpha; break;
+   case GL_DST_ALPHA:
+      src = (mgaScreen->cpp == 4) 
+	  ? AC_src_dst_alpha : AC_src_one;
+      break;
+   case GL_ONE_MINUS_DST_ALPHA:
+      src = (mgaScreen->cpp == 4)
+	  ? AC_src_om_dst_alpha : AC_src_zero;
+      break;
+   case GL_SRC_ALPHA_SATURATE:
+      src = (ctx->Visual.alphaBits > 0)
+	  ? AC_src_src_alpha_sat : AC_src_zero;
+      break;
+   }
+
+   switch (ctx->Color.BlendDstRGB) {
+   case GL_SRC_ALPHA:
+      dst = AC_dst_src_alpha; break;
+   case GL_ONE_MINUS_SRC_ALPHA:
+      dst = AC_dst_om_src_alpha; break;
+   default:		/* never happens */
+   case GL_ZERO:
+      dst = AC_dst_zero; break;
+   case GL_ONE:
+      dst = AC_dst_one; break;
+   case GL_SRC_COLOR:
+      dst = AC_dst_src_color; break;
+   case GL_ONE_MINUS_SRC_COLOR:
+      dst = AC_dst_om_src_color; break;
+   case GL_DST_ALPHA:
+      dst = (mgaScreen->cpp == 4)
+	  ? AC_dst_dst_alpha : AC_dst_one;
+      break;
+   case GL_ONE_MINUS_DST_ALPHA:
+      dst = (mgaScreen->cpp == 4)
+	  ? AC_dst_om_dst_alpha : AC_dst_zero;
+      break;
+   }
+
+   FLUSH_BATCH( mmesa );
+   mmesa->hw.blend_func = (src | dst);
+   mmesa->dirty |= MGA_UPLOAD_CONTEXT;
 }
 
 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;
+   mgaDDBlendFunc( ctx, sfactorRGB, dfactorRGB );
 }
 
 
+/* =============================================================
+ * Depth testing
+ */
 
-static void mgaDDLightModelfv(GLcontext *ctx, GLenum pname,
-			      const GLfloat *param)
+static void mgaDDDepthFunc(GLcontext *ctx, GLenum func)
 {
-   if (pname == GL_LIGHT_MODEL_COLOR_CONTROL) {
-      FLUSH_BATCH( MGA_CONTEXT(ctx) );
-      MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE;
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   int zmode;
+
+   switch (func) {
+   case GL_NEVER:
+      /* can't do this in h/w, we'll use a s/w fallback */
+      FALLBACK (ctx, MGA_FALLBACK_DEPTH, ctx->Depth.Test);
+
+      /* FALLTHROUGH */
+   case GL_ALWAYS:
+      zmode = DC_zmode_nozcmp; break;
+   case GL_LESS:
+      zmode = DC_zmode_zlt; break;
+   case GL_LEQUAL:
+      zmode = DC_zmode_zlte; break;
+   case GL_EQUAL:
+      zmode = DC_zmode_ze; break;
+   case GL_GREATER:
+      zmode = DC_zmode_zgt; break;
+   case GL_GEQUAL:
+      zmode = DC_zmode_zgte; break;
+   case GL_NOTEQUAL:
+      zmode = DC_zmode_zne; break;
+   default:
+      zmode = 0; break;
    }
-}
-
 
-static void mgaDDShadeModel(GLcontext *ctx, GLenum mode)
-{
-   FLUSH_BATCH( MGA_CONTEXT(ctx) );
-   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE;
-}
-
-
-static void mgaDDDepthFunc(GLcontext *ctx, GLenum func)
-{
-   FLUSH_BATCH( MGA_CONTEXT(ctx) );
-   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_DEPTH;
+   FLUSH_BATCH( mmesa );
+   mmesa->hw.zmode &= DC_zmode_MASK;
+   mmesa->hw.zmode |= zmode;
+   mmesa->dirty |= MGA_UPLOAD_CONTEXT;
 }
 
 static void mgaDDDepthMask(GLcontext *ctx, GLboolean flag)
 {
-   FLUSH_BATCH( MGA_CONTEXT(ctx) );
-   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_DEPTH;
-}
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
 
-#if defined(ACCEL_ROP)
-static void mgaDDLogicOp( GLcontext *ctx, GLenum opcode )
-{
-   FLUSH_BATCH( MGA_CONTEXT(ctx) );
-   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_DEPTH;
-}
-#else
-static void mgaDDLogicOp( GLcontext *ctx, GLenum opcode )
-{
-   FLUSH_BATCH( MGA_CONTEXT(ctx) );
-   FALLBACK( ctx, MGA_FALLBACK_LOGICOP, 
-	     (ctx->Color.ColorLogicOpEnabled && opcode != GL_COPY) );
-}
-#endif
 
+   FLUSH_BATCH( mmesa );
+   mmesa->hw.zmode &= DC_atype_MASK;
+   mmesa->hw.zmode |= (flag) ? DC_atype_zi : DC_atype_i;
+   mmesa->dirty |= MGA_UPLOAD_CONTEXT;
+}
 
 
-static void mgaDDFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param)
+static void mgaDDClearDepth(GLcontext *ctx, GLclampd d)
 {
    mgaContextPtr mmesa = MGA_CONTEXT(ctx);
 
-   if (pname == GL_FOG_COLOR) {
-      GLuint color = MGAPACKCOLOR888((GLubyte)(ctx->Fog.Color[0]*255.0F), 
-				     (GLubyte)(ctx->Fog.Color[1]*255.0F), 
-				     (GLubyte)(ctx->Fog.Color[2]*255.0F));
-
-      MGA_STATECHANGE(mmesa, MGA_UPLOAD_CONTEXT);   
-      mmesa->setup.fogcolor = color;
+   /* Select the Z depth.  The ~ is used because the _MASK values in the
+    * MGA driver are used to mask OFF the selected bits.  In this case,
+    * we want to mask off everything except the MA_zwidth bits.
+    */
+   switch (mmesa->setup.maccess & ~MA_zwidth_MASK) {
+   case MA_zwidth_16: mmesa->ClearDepth = d * 0x0000ffff; break;
+   case MA_zwidth_24: mmesa->ClearDepth = d * 0xffffff00; break;
+   case MA_zwidth_32: mmesa->ClearDepth = d * 0xffffffff; break;
+   default: return;
    }
 }
 
 
-
-
 /* =============================================================
- * Alpha blending
+ * Fog
  */
 
 
-static void mgaUpdateAlphaMode(GLcontext *ctx)
+static void mgaDDFogfv(GLcontext *ctx, GLenum pname, const GLfloat *param)
 {
-   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
-   mgaScreenPrivate *mgaScreen = mmesa->mgaScreen;
-   int a = 0;
-
-   /* determine source of alpha for blending and testing */
-   if ( !ctx->Texture.Unit[0]._ReallyEnabled ) {
-      a |= AC_alphasel_diffused;
-   }
-   else {
-      /* G400: Regardless of texture env mode, we use the alpha from the
-       * texture unit (AC_alphasel_fromtex) since it will have already
-       * been modulated by the incoming fragment color, if needed.
-       * We don't want (AC_alphasel_modulate) since that'll effectively
-       * do the modulation twice.
-       */
-      if (MGA_IS_G400(mmesa)) {
-         a |= AC_alphasel_fromtex;
-      }
-      else {
-         /* G200 */
-         switch (ctx->Texture.Unit[0].EnvMode) {
-         case GL_DECAL:
-            a |= AC_alphasel_diffused;
-         case GL_REPLACE:
-            a |= AC_alphasel_fromtex;
-            break;
-         case GL_BLEND:
-         case GL_MODULATE:
-            a |= AC_alphasel_modulated;
-            break;
-         default:
-            break;
-         }
-      }
-   }
-
-
-   /* alpha test control.
-    */
-   if (ctx->Color.AlphaEnabled) {
-      GLubyte ref = ctx->Color.AlphaRef;
-      switch (ctx->Color.AlphaFunc) {
-      case GL_NEVER:
-	 a |= AC_atmode_alt;
-	 ref = 0;
-	 break;
-      case GL_LESS:
-	 a |= AC_atmode_alt;
-	 break;
-      case GL_GEQUAL:
-	 a |= AC_atmode_agte;
-	 break;
-      case GL_LEQUAL:
-	 a |= AC_atmode_alte;
-	 break;
-      case GL_GREATER:
-	 a |= AC_atmode_agt;
-	 break;
-      case GL_NOTEQUAL:
-	 a |= AC_atmode_ane;
-	 break;
-      case GL_EQUAL:
-	 a |= AC_atmode_ae;
-	 break;
-      case GL_ALWAYS:
-	 a |= AC_atmode_noacmp;
-	 break;
-      default:
-	 break;
-      }
-      a |= MGA_FIELD(AC_atref,ref);
-   }
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
 
-   /* blending control */
-   if (ctx->Color.BlendEnabled) {
-      switch (ctx->Color.BlendSrcRGB) {
-      case GL_ZERO:
-	 a |= AC_src_zero; break;
-      case GL_SRC_ALPHA:
-	 a |= AC_src_src_alpha; break;
-      case GL_ONE:
-	 a |= AC_src_one; break;
-      case GL_DST_COLOR:
-	 a |= AC_src_dst_color; break;
-      case GL_ONE_MINUS_DST_COLOR:
-	 a |= AC_src_om_dst_color; break;
-      case GL_ONE_MINUS_SRC_ALPHA:
-	 a |= AC_src_om_src_alpha; break;
-      case GL_DST_ALPHA:
-	 if (mgaScreen->cpp == 4)
-	    a |= AC_src_dst_alpha;
-	 else
-	    a |= AC_src_one;
-	 break;
-      case GL_ONE_MINUS_DST_ALPHA:
-	 if (mgaScreen->cpp == 4)
-	    a |= AC_src_om_dst_alpha;
-	 else
-	    a |= AC_src_zero;
-	 break;
-      case GL_SRC_ALPHA_SATURATE:
-         if (ctx->Visual.alphaBits > 0)
-            a |= AC_src_src_alpha_sat;
-         else
-            a |= AC_src_zero;
-	 break;
-      default:		/* never happens */
-	 break;
-      }
+   if (pname == GL_FOG_COLOR) {
+      GLuint color = PACK_COLOR_888((GLubyte)(ctx->Fog.Color[0]*255.0F), 
+				    (GLubyte)(ctx->Fog.Color[1]*255.0F), 
+				    (GLubyte)(ctx->Fog.Color[2]*255.0F));
 
-      switch (ctx->Color.BlendDstRGB) {
-      case GL_SRC_ALPHA:
-	 a |= AC_dst_src_alpha; break;
-      case GL_ONE_MINUS_SRC_ALPHA:
-	 a |= AC_dst_om_src_alpha; break;
-      case GL_ZERO:
-	 a |= AC_dst_zero; break;
-      case GL_ONE:
-	 a |= AC_dst_one; break;
-      case GL_SRC_COLOR:
-	 a |= AC_dst_src_color; break;
-      case GL_ONE_MINUS_SRC_COLOR:
-	 a |= AC_dst_om_src_color; break;
-      case GL_DST_ALPHA:
-	 if (mgaScreen->cpp == 4)
-	    a |= AC_dst_dst_alpha;
-	 else
-	    a |= AC_dst_one;
-	 break;
-      case GL_ONE_MINUS_DST_ALPHA:
-	 if (mgaScreen->cpp == 4)
-	    a |= AC_dst_om_dst_alpha;
-	 else
-	    a |= AC_dst_zero;
-	 break;
-      default:		/* never happens */
-	 break;
-      }
-   } else {
-      a |= AC_src_one|AC_dst_zero;
+      MGA_STATECHANGE(mmesa, MGA_UPLOAD_CONTEXT);   
+      mmesa->setup.fogcolor = color;
    }
-
-   mmesa->setup.alphactrl = (AC_amode_alpha_channel |
-			     AC_astipple_disable |
-			     AC_aten_disable |
-			     AC_atmode_noacmp |
-			     a);
-
-   mmesa->dirty |= MGA_UPLOAD_CONTEXT;
 }
 
 
-
 /* =============================================================
- * Hardware clipping
+ * Scissoring
  */
 
+
 void mgaUpdateClipping(const GLcontext *ctx)
 {
    mgaContextPtr mmesa = MGA_CONTEXT(ctx);
@@ -554,13 +315,6 @@ void mgaUpdateClipping(const GLcontext *ctx)
       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;
    }
 }
@@ -569,19 +323,10 @@ void mgaUpdateClipping(const GLcontext *ctx)
 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;
-}
-
-
-static void mgaDDClearColor(GLcontext *ctx, 
-			    const GLfloat color[4] )
-{
-   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
-
-   mmesa->ClearColor = mgaPackColor( mmesa->mgaScreen->cpp,
-				     color[0], color[1], 
-				     color[2], color[3]);
+   if ( ctx->Scissor.Enabled ) {
+      FLUSH_BATCH( MGA_CONTEXT(ctx) );	/* don't pipeline cliprect changes */
+      mgaUpdateClipping( ctx );
+   }
 }
 
 
@@ -589,46 +334,42 @@ static void mgaDDClearColor(GLcontext *ctx,
  * Culling
  */
 
+
 #define _CULL_DISABLE 0
 #define _CULL_NEGATIVE ((1<<11)|(1<<5)|(1<<16))
 #define _CULL_POSITIVE (1<<11)
 
-
-void mgaUpdateCull( GLcontext *ctx )
+static void mgaDDCullFaceFrontFace(GLcontext *ctx, GLenum unused)
 {
    mgaContextPtr mmesa = MGA_CONTEXT(ctx);
-   GLuint mode = _CULL_DISABLE;
 
+
+   FLUSH_BATCH( mmesa );
    if (ctx->Polygon.CullFlag && 
-       mmesa->raster_primitive == GL_TRIANGLES &&       
        ctx->Polygon.CullFaceMode != GL_FRONT_AND_BACK) 
    {
-      mode = _CULL_NEGATIVE;
+      mmesa->hw.cull = _CULL_NEGATIVE;
+
       if (ctx->Polygon.CullFaceMode == GL_FRONT)
-	 mode ^= (_CULL_POSITIVE ^ _CULL_NEGATIVE);
+	 mmesa->hw.cull ^= (_CULL_POSITIVE ^ _CULL_NEGATIVE);
+
       if (ctx->Polygon.FrontFace != GL_CCW)
-	 mode ^= (_CULL_POSITIVE ^ _CULL_NEGATIVE);
-      if ((ctx->Texture.Unit[0]._ReallyEnabled & TEXTURE_2D_BIT) &&
-          (ctx->Texture.Unit[1]._ReallyEnabled & TEXTURE_2D_BIT))
-	 mode ^= (_CULL_POSITIVE ^ _CULL_NEGATIVE); /* warp bug? */
+	 mmesa->hw.cull ^= (_CULL_POSITIVE ^ _CULL_NEGATIVE);
+
+      mmesa->hw.cull_dualtex = mmesa->hw.cull ^
+	  (_CULL_POSITIVE ^ _CULL_NEGATIVE); /* warp bug? */
+   }
+   else {
+      mmesa->hw.cull = _CULL_DISABLE;
+      mmesa->hw.cull_dualtex = _CULL_DISABLE;
    }
 
-   mmesa->setup.wflag = mode;
    mmesa->dirty |= MGA_UPLOAD_CONTEXT;
 }
 
 
-static void mgaDDCullFaceFrontFace(GLcontext *ctx, GLenum mode)
-{
-   FLUSH_BATCH( MGA_CONTEXT(ctx) );
-   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_CULL;
-}
-
-
-
-
 /* =============================================================
- * Color masks
+ * Masks
  */
 
 static void mgaDDColorMask(GLcontext *ctx, 
@@ -654,15 +395,11 @@ static void 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.
- *
- * Note: the fully opaque pattern (0xffff) has been disabled in order
- * to work around a conformance issue.
+ * Polygon state
  */
+
 static int mgaStipples[16] = {
    0xffff1,  /* See above note */
    0xa5a5,
@@ -682,6 +419,17 @@ static int mgaStipples[16] = {
    0x0000
 };
 
+/**
+ * The MGA supports a subset of possible 4x4 stipples natively, GL
+ * wants 32x32.  Fortunately stipple is usually a repeating pattern.
+ *
+ * \param ctx GL rendering context to be affected
+ * \param mask Pointer to the 32x32 stipple mask
+ *
+ * \note the fully opaque pattern (0xffff) has been disabled in order
+ * to work around a conformance issue.
+ */
+
 static void mgaDDPolygonStipple( GLcontext *ctx, const GLubyte *mask )
 {
    mgaContextPtr mmesa = MGA_CONTEXT(ctx);
@@ -730,93 +478,216 @@ static void mgaDDPolygonStipple( GLcontext *ctx, const GLubyte *mask )
    }
 }
 
+
 /* =============================================================
+ * Rendering attributes
+ *
+ * We really don't want to recalculate all this every time we bind a
+ * texture.  These things shouldn't change all that often, so it makes
+ * sense to break them out of the core texture state update routines.
  */
 
-static void mgaDDPrintDirty( const char *msg, GLuint state )
+static void updateSpecularLighting( GLcontext *ctx )
 {
-   fprintf(stderr, "%s (0x%x): %s%s%s%s%s%s%s\n",
-	   msg,
-	   (unsigned int) state,
-	   (state & MGA_WAIT_AGE) ? "wait-age, " : "",
-	   (state & MGA_UPLOAD_TEX0IMAGE)  ? "upload-tex0-img, " : "",
-	   (state & MGA_UPLOAD_TEX1IMAGE)  ? "upload-tex1-img, " : "",
-	   (state & MGA_UPLOAD_CONTEXT)        ? "upload-ctx, " : "",
-	   (state & MGA_UPLOAD_TEX0)       ? "upload-tex0, " : "",
-	   (state & MGA_UPLOAD_TEX1)       ? "upload-tex1, " : "",
-	   (state & MGA_UPLOAD_PIPE)       ? "upload-pipe, " : ""
-      );
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+   unsigned int specen;
+
+   specen = (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR &&
+	     ctx->Light.Enabled) ? TMC_specen_enable : 0;
+
+   if ( specen != mmesa->hw.specen ) {
+      mmesa->hw.specen = specen;
+      mmesa->dirty |= MGA_UPLOAD_TEX0 | MGA_UPLOAD_TEX1;
+      
+      mgaChooseVertexState( ctx );
+   }
 }
 
-/* Push the state into the sarea and/or texture memory.
+
+/* =============================================================
+ * Materials
  */
-void mgaEmitHwStateLocked( mgaContextPtr mmesa )
-{
-   MGASAREAPrivPtr sarea = mmesa->sarea;
 
-   if (MGA_DEBUG & DEBUG_VERBOSE_MSG)
-      mgaDDPrintDirty( "mgaEmitHwStateLocked", mmesa->dirty );
 
-   if ((mmesa->dirty & MGA_UPLOAD_TEX0IMAGE) && mmesa->CurrentTexObj[0])
-      mgaUploadTexImages(mmesa, mmesa->CurrentTexObj[0]);
+static void mgaDDLightModelfv(GLcontext *ctx, GLenum pname,
+			      const GLfloat *param)
+{
+   if (pname == GL_LIGHT_MODEL_COLOR_CONTROL) {
+      FLUSH_BATCH( MGA_CONTEXT(ctx) );
+      updateSpecularLighting( ctx );
+   }
+}
 
-   if ((mmesa->dirty & MGA_UPLOAD_TEX1IMAGE) && mmesa->CurrentTexObj[1])
-      mgaUploadTexImages(mmesa, mmesa->CurrentTexObj[1]);
 
-   if (mmesa->dirty & MGA_UPLOAD_CONTEXT) {
-      memcpy( &sarea->ContextState, &mmesa->setup, sizeof(mmesa->setup));
-   }
+static void mgaDDShadeModel(GLcontext *ctx, GLenum mode)
+{
+   /* FIXME: This used to FLUSH_BATCH and set MGA_NEW_TEXTURE in new_state,
+    * FIXME: so I'm not sure what to do here now.
+    */
+}
 
-   if ((mmesa->dirty & MGA_UPLOAD_TEX0) && mmesa->CurrentTexObj[0]) {
-      memcpy(&sarea->TexState[0],
-	     &mmesa->CurrentTexObj[0]->setup,
-	     sizeof(sarea->TexState[0]));
-   }
 
-   if ((mmesa->dirty & MGA_UPLOAD_TEX1) && mmesa->CurrentTexObj[1]) {
-      memcpy(&sarea->TexState[1],
-	     &mmesa->CurrentTexObj[1]->setup,
-	     sizeof(sarea->TexState[1]));
-   }
+/* =============================================================
+ * Stencil
+ */
 
-   if (sarea->TexState[0].texctl2 !=
-       sarea->TexState[1].texctl2) {
-      memcpy(&sarea->TexState[1],
-	     &sarea->TexState[0],
-	     sizeof(sarea->TexState[0]));
-      mmesa->dirty |= MGA_UPLOAD_TEX1|MGA_UPLOAD_TEX0;
-   }
 
-   if (mmesa->dirty & MGA_UPLOAD_PIPE) {
-/*        mmesa->sarea->wacceptseq = mmesa->hw_primitive; */
-      mmesa->sarea->WarpPipe = mmesa->vertex_format;
-      mmesa->sarea->vertsize = mmesa->vertex_size;
+static void mgaDDStencilFunc(GLcontext *ctx, GLenum func, GLint ref,
+			     GLuint mask)
+{
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+   GLuint  stencil;
+   GLuint  stencilctl;
+
+   stencil = (ref << S_sref_SHIFT) | (mask << S_smsk_SHIFT);
+   switch (func)
+   {
+   case GL_NEVER:
+      stencilctl = SC_smode_snever;
+      break;
+   case GL_LESS:
+      stencilctl = SC_smode_slt;
+      break;
+   case GL_LEQUAL:
+      stencilctl = SC_smode_slte;
+      break;
+   case GL_GREATER:
+      stencilctl = SC_smode_sgt;
+      break;
+   case GL_GEQUAL:
+      stencilctl = SC_smode_sgte;
+      break;
+   case GL_NOTEQUAL:
+      stencilctl = SC_smode_sne;
+      break;
+   case GL_EQUAL:
+      stencilctl = SC_smode_se;
+      break;
+   case GL_ALWAYS:
+   default:
+      stencilctl = SC_smode_salways;
+      break;
    }
 
-   mmesa->sarea->dirty |= mmesa->dirty;
+   FLUSH_BATCH( mmesa );
+   mmesa->hw.stencil &= (S_sref_MASK & S_smsk_MASK);
+   mmesa->hw.stencil |= stencil;
+   mmesa->hw.stencilctl &= SC_smode_MASK;
+   mmesa->hw.stencilctl |= stencilctl;
+   mmesa->dirty |= MGA_UPLOAD_CONTEXT;
+}
 
-   mmesa->dirty &= (MGA_UPLOAD_CLIPRECTS|MGA_WAIT_AGE);
+static void mgaDDStencilMask(GLcontext *ctx, GLuint mask)
+{
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
 
-   /* This is a bit of a hack but seems to be the best place to ensure
-    * that separate specular is disabled when not needed.
-    */
-   if (mmesa->glCtx->Texture.Unit[0]._ReallyEnabled == 0 ||
-       !mmesa->glCtx->Light.Enabled ||
-       mmesa->glCtx->Light.Model.ColorControl == GL_SINGLE_COLOR) {
-      sarea->TexState[0].texctl2 &= ~TMC_specen_enable;
-      sarea->TexState[1].texctl2 &= ~TMC_specen_enable;
-   }
+   FLUSH_BATCH( mmesa );
+   mmesa->hw.stencil &= S_swtmsk_MASK;
+   mmesa->hw.stencil |= (mask << S_swtmsk_SHIFT);
+   mmesa->dirty |= MGA_UPLOAD_CONTEXT;
 }
 
-/* Fallback to swrast for select and feedback.
- */
-static void mgaRenderMode( GLcontext *ctx, GLenum mode )
+static void mgaDDStencilOp(GLcontext *ctx, GLenum fail, GLenum zfail,
+			   GLenum zpass)
 {
-   FALLBACK( ctx, MGA_FALLBACK_RENDERMODE, (mode != GL_RENDER) );
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+   GLuint  stencilctl;
+
+   stencilctl = 0;
+   switch (ctx->Stencil.FailFunc[0])
+   {
+   case GL_KEEP:
+      stencilctl |= SC_sfailop_keep;
+      break;
+   case GL_ZERO:
+      stencilctl |= SC_sfailop_zero;
+      break;
+   case GL_REPLACE:
+      stencilctl |= SC_sfailop_replace;
+      break;
+   case GL_INCR:
+      stencilctl |= SC_sfailop_incrsat;
+      break;
+   case GL_DECR:
+      stencilctl |= SC_sfailop_decrsat;
+      break;
+   case GL_INCR_WRAP:
+      stencilctl |= SC_sfailop_incr;
+      break;
+   case GL_DECR_WRAP:
+      stencilctl |= SC_sfailop_decr;
+      break;
+   case GL_INVERT:
+      stencilctl |= SC_sfailop_invert;
+      break;
+   default:
+      break;
+   }
+
+   switch (ctx->Stencil.ZFailFunc[0])
+   {
+   case GL_KEEP:
+      stencilctl |= SC_szfailop_keep;
+      break;
+   case GL_ZERO:
+      stencilctl |= SC_szfailop_zero;
+      break;
+   case GL_REPLACE:
+      stencilctl |= SC_szfailop_replace;
+      break;
+   case GL_INCR:
+      stencilctl |= SC_szfailop_incrsat;
+      break;
+   case GL_DECR:
+      stencilctl |= SC_szfailop_decrsat;
+      break;
+   case GL_INCR_WRAP:
+      stencilctl |= SC_szfailop_incr;
+      break;
+   case GL_DECR_WRAP:
+      stencilctl |= SC_szfailop_decr;
+      break;
+   case GL_INVERT:
+      stencilctl |= SC_szfailop_invert;
+      break;
+   default:
+      break;
+   }
+
+   switch (ctx->Stencil.ZPassFunc[0])
+   {
+   case GL_KEEP:
+      stencilctl |= SC_szpassop_keep;
+      break;
+   case GL_ZERO:
+      stencilctl |= SC_szpassop_zero;
+      break;
+   case GL_REPLACE:
+      stencilctl |= SC_szpassop_replace;
+      break;
+   case GL_INCR:
+      stencilctl |= SC_szpassop_incrsat;
+      break;
+   case GL_DECR:
+      stencilctl |= SC_szpassop_decrsat;
+      break;
+   case GL_INVERT:
+      stencilctl |= SC_szpassop_invert;
+      break;
+   default:
+      break;
+   }
+
+   FLUSH_BATCH( mmesa );
+   mmesa->hw.stencilctl &= (SC_sfailop_MASK & SC_szfailop_MASK 
+			    & SC_szpassop_MASK);
+   mmesa->hw.stencilctl |= stencilctl;
+   mmesa->dirty |= MGA_UPLOAD_CONTEXT;
 }
 
 
 /* =============================================================
+ * Window position and viewport transformation
  */
 
 void mgaCalcViewport( GLcontext *ctx )
@@ -850,8 +721,167 @@ static void mgaDepthRange( GLcontext *ctx,
    mgaCalcViewport( ctx );
 }
 
+
 /* =============================================================
+ * Miscellaneous
+ */
+
+static void mgaDDClearColor(GLcontext *ctx, 
+			    const GLfloat color[4] )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+   GLubyte c[4];
+   CLAMPED_FLOAT_TO_UBYTE(c[0], color[0]);
+   CLAMPED_FLOAT_TO_UBYTE(c[1], color[1]);
+   CLAMPED_FLOAT_TO_UBYTE(c[2], color[2]);
+   CLAMPED_FLOAT_TO_UBYTE(c[3], color[3]);
+
+   mmesa->ClearColor = mgaPackColor( mmesa->mgaScreen->cpp,
+				     c[0], c[1], c[2], c[3]);
+}
+
+
+/* Fallback to swrast for select and feedback.
  */
+static void mgaRenderMode( GLcontext *ctx, GLenum mode )
+{
+   FALLBACK( ctx, MGA_FALLBACK_RENDERMODE, (mode != GL_RENDER) );
+}
+
+
+static void mgaDDLogicOp( GLcontext *ctx, GLenum opcode )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+
+   FLUSH_BATCH( mmesa );
+#if defined(ACCEL_ROP)
+   mmesa->hw.rop = mgarop_NoBLK[ opcode & 0x0f ];
+   mmesa->dirty |= MGA_UPLOAD_CONTEXT;
+#else
+   FALLBACK( ctx, MGA_FALLBACK_LOGICOP,
+	     (ctx->Color.ColorLogicOpEnabled && opcode != GL_COPY) );
+#endif
+}
+
+
+static void mgaXMesaSetFrontClipRects( mgaContextPtr mmesa )
+{
+   __DRIdrawablePrivate *driDrawable = mmesa->driDrawable;
+
+   if (driDrawable->numClipRects == 0) {
+       static XF86DRIClipRectRec zeroareacliprect = {0,0,0,0};
+       mmesa->numClipRects = 1;
+       mmesa->pClipRects = &zeroareacliprect;
+   } else {
+       mmesa->numClipRects = driDrawable->numClipRects;
+       mmesa->pClipRects = driDrawable->pClipRects;
+   }
+   mmesa->drawX = driDrawable->x;
+   mmesa->drawY = driDrawable->y;
+
+   mmesa->setup.dstorg = mmesa->drawOffset;
+   mmesa->dirty |= MGA_UPLOAD_CONTEXT | MGA_UPLOAD_CLIPRECTS;
+}
+
+
+static void mgaXMesaSetBackClipRects( mgaContextPtr mmesa )
+{
+   __DRIdrawablePrivate *driDrawable = mmesa->driDrawable;
+
+   if (driDrawable->numBackClipRects == 0)
+   {
+      if (driDrawable->numClipRects == 0) {
+	  static XF86DRIClipRectRec zeroareacliprect = {0,0,0,0};
+	  mmesa->numClipRects = 1;
+	  mmesa->pClipRects = &zeroareacliprect;
+      } else {
+	  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->setup.dstorg = mmesa->drawOffset;
+   mmesa->dirty |= MGA_UPLOAD_CONTEXT | MGA_UPLOAD_CLIPRECTS;
+}
+
+
+void mgaUpdateRects( mgaContextPtr mmesa, GLuint buffers )
+{
+   __DRIdrawablePrivate *driDrawable = mmesa->driDrawable;
+   MGASAREAPrivPtr sarea = mmesa->sarea;
+
+
+   DRI_VALIDATE_DRAWABLE_INFO(mmesa->driScreen, driDrawable); 
+   mmesa->dirty_cliprects = 0;	
+
+   if (mmesa->draw_buffer == MGA_FRONT)
+      mgaXMesaSetFrontClipRects( mmesa );
+   else
+      mgaXMesaSetBackClipRects( mmesa );
+
+   sarea->req_draw_buffer = mmesa->draw_buffer;
+
+   mgaUpdateClipping( mmesa->glCtx );
+   mgaCalcViewport( mmesa->glCtx );
+
+   mmesa->dirty |= MGA_UPLOAD_CLIPRECTS;
+}
+
+
+static void mgaDDDrawBuffer(GLcontext *ctx, GLenum mode )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+
+   FLUSH_BATCH( mmesa );
+
+   /*
+    * _DrawDestMask is easier to cope with than <mode>.
+    */
+   switch ( ctx->Color._DrawDestMask ) {
+   case FRONT_LEFT_BIT:
+      mmesa->setup.dstorg = mmesa->mgaScreen->frontOffset;
+      mmesa->dirty |= MGA_UPLOAD_CONTEXT;
+      mmesa->draw_buffer = MGA_FRONT;
+      mgaXMesaSetFrontClipRects( mmesa );
+      FALLBACK( ctx, MGA_FALLBACK_DRAW_BUFFER, GL_FALSE );
+      break;
+   case BACK_LEFT_BIT:
+      mmesa->setup.dstorg = mmesa->mgaScreen->backOffset;
+      mmesa->draw_buffer = MGA_BACK;
+      mmesa->dirty |= MGA_UPLOAD_CONTEXT;
+      mgaXMesaSetBackClipRects( mmesa );
+      FALLBACK( ctx, MGA_FALLBACK_DRAW_BUFFER, GL_FALSE );
+      break;
+   default:
+      /* GL_NONE or GL_FRONT_AND_BACK or stereo left&right, etc */
+      FALLBACK( ctx, MGA_FALLBACK_DRAW_BUFFER, GL_TRUE );
+      return;
+   }
+
+   /* We want to update the s/w rast state too so that r200SetBuffer()
+    * gets called.
+    */
+   _swrast_DrawBuffer(ctx, mode);
+}
+
+
+static void mgaDDReadBuffer(GLcontext *ctx, GLenum mode )
+{
+   /* nothing, until we implement h/w glRead/CopyPixels or CopyTexImage */
+}
+
+
+/* =============================================================
+ * State enable/disable
+ */
+
 
 static void mgaDDEnable(GLcontext *ctx, GLenum cap, GLboolean state)
 {
@@ -860,11 +890,11 @@ static void mgaDDEnable(GLcontext *ctx, GLenum cap, GLboolean state)
    switch(cap) {
    case GL_ALPHA_TEST:
       FLUSH_BATCH( mmesa );
-      mmesa->new_state |= MGA_NEW_ALPHA;
+      mmesa->hw.alpha_func_enable = (state) ? ~0 : 0;
       break;
    case GL_BLEND:
       FLUSH_BATCH( mmesa );
-      mmesa->new_state |= MGA_NEW_ALPHA;
+      mmesa->hw.blend_func_enable = (state) ? ~0 : 0;
 
       /* For some reason enable(GL_BLEND) affects ColorLogicOpEnabled.
        */
@@ -874,31 +904,31 @@ static void mgaDDEnable(GLcontext *ctx, GLenum cap, GLboolean state)
       break;
    case GL_DEPTH_TEST:
       FLUSH_BATCH( mmesa );
-      mmesa->new_state |= MGA_NEW_DEPTH;
       FALLBACK (ctx, MGA_FALLBACK_DEPTH,
 		ctx->Depth.Func == GL_NEVER && ctx->Depth.Test);
       break;
+
    case GL_SCISSOR_TEST:
       FLUSH_BATCH( mmesa );
       mmesa->scissor = state;
-      mmesa->new_state |= MGA_NEW_CLIP;
+      mgaUpdateClipping( ctx );
       break;
+
    case GL_FOG:
       MGA_STATECHANGE( mmesa, MGA_UPLOAD_CONTEXT );
       if (ctx->Fog.Enabled) 
 	 mmesa->setup.maccess |= MA_fogen_enable;
       else
 	 mmesa->setup.maccess &= ~MA_fogen_enable;
+      
+      mgaChooseVertexState( ctx );
       break;
    case GL_CULL_FACE:
-      FLUSH_BATCH( mmesa );
-      mmesa->new_state |= MGA_NEW_CULL;
+      mgaDDCullFaceFrontFace( ctx, 0 );
       break;
    case GL_TEXTURE_1D:
    case GL_TEXTURE_2D:
    case GL_TEXTURE_3D:
-      FLUSH_BATCH( mmesa );
-      mmesa->new_state |= (MGA_NEW_TEXTURE|MGA_NEW_ALPHA);
       break;
    case GL_POLYGON_STIPPLE:
       if (mmesa->haveHwStipple && mmesa->raster_primitive == GL_TRIANGLES) {
@@ -914,16 +944,16 @@ static void mgaDDEnable(GLcontext *ctx, GLenum cap, GLboolean state)
 #if !defined(ACCEL_ROP)
       FALLBACK( ctx, MGA_FALLBACK_LOGICOP, 
 		(state && ctx->Color.LogicOp != GL_COPY));
-#else
-      mmesa->new_state |= MGA_NEW_DEPTH;
 #endif
       break;
    case GL_STENCIL_TEST:
       FLUSH_BATCH( mmesa );
-      if (mmesa->hw_stencil)
-	 mmesa->new_state |= MGA_NEW_STENCIL;
-      else
+      if (mmesa->hw_stencil) {
+	 mmesa->hw.stencil_enable = ( state ) ? ~0 : 0;
+      }
+      else {
 	 FALLBACK( ctx, MGA_FALLBACK_STENCIL, state );
+      }
    default:
       break;
    }
@@ -933,56 +963,150 @@ static void mgaDDEnable(GLcontext *ctx, GLenum cap, GLboolean state)
 /* =============================================================
  */
 
-
-
-/* =============================================================
- */
-
-static void mgaDDPrintState( const char *msg, GLuint state )
+static void mgaDDPrintDirty( const char *msg, GLuint state )
 {
-   fprintf(stderr, "%s (0x%x): %s%s%s%s%s%s\n",
+   fprintf(stderr, "%s (0x%03x): %s%s%s%s%s%s%s\n",
 	   msg,
-	   state,
-	   (state & MGA_NEW_DEPTH)   ? "depth, " : "",
-	   (state & MGA_NEW_ALPHA)   ? "alpha, " : "",
-	   (state & MGA_NEW_CLIP)    ? "clip, " : "",
-	   (state & MGA_NEW_CULL)    ? "cull, " : "",
-	   (state & MGA_NEW_TEXTURE) ? "texture, " : "",
-	   (state & MGA_NEW_CONTEXT) ? "context, " : "");
+	   (unsigned int) state,
+	   (state & MGA_WAIT_AGE)          ? "wait-age " : "",
+	   (state & MGA_UPLOAD_TEX0IMAGE)  ? "upload-tex0-img " : "",
+	   (state & MGA_UPLOAD_TEX1IMAGE)  ? "upload-tex1-img " : "",
+	   (state & MGA_UPLOAD_CONTEXT)    ? "upload-ctx " : "",
+	   (state & MGA_UPLOAD_TEX0)       ? "upload-tex0 " : "",
+	   (state & MGA_UPLOAD_TEX1)       ? "upload-tex1 " : "",
+	   (state & MGA_UPLOAD_PIPE)       ? "upload-pipe " : ""
+      );
 }
 
-void mgaDDUpdateHwState( GLcontext *ctx )
+/* Push the state into the sarea and/or texture memory.
+ */
+void mgaEmitHwStateLocked( mgaContextPtr mmesa )
 {
-   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
-   int new_state = mmesa->new_state;
+   MGASAREAPrivPtr sarea = mmesa->sarea;
+   GLcontext * ctx = mmesa->glCtx;
 
-   if (new_state)
-   {
-      FLUSH_BATCH( mmesa );
+   if (MGA_DEBUG & DEBUG_VERBOSE_MSG)
+      mgaDDPrintDirty( __FUNCTION__, mmesa->dirty );
 
-      mmesa->new_state = 0;
+   if (mmesa->dirty & MGA_UPLOAD_CONTEXT) {
+      mmesa->setup.wflag = _CULL_DISABLE;
+      if (mmesa->raster_primitive == GL_TRIANGLES) {
+	 if ((ctx->Texture.Unit[0]._ReallyEnabled == TEXTURE_2D_BIT &&
+	      ctx->Texture.Unit[1]._ReallyEnabled == TEXTURE_2D_BIT)) {
+	    mmesa->setup.wflag = mmesa->hw.cull_dualtex;
+	 }
+	 else {
+	    mmesa->setup.wflag = mmesa->hw.cull;
+	 }
+      }
 
-      if (MESA_VERBOSE&VERBOSE_DRIVER)
-	 mgaDDPrintState("UpdateHwState", new_state);
+      mmesa->setup.stencil = mmesa->hw.stencil 
+	  & mmesa->hw.stencil_enable;
+      mmesa->setup.stencilctl = mmesa->hw.stencilctl
+	  & mmesa->hw.stencil_enable;
 
-      if (new_state & MGA_NEW_DEPTH)
-	 mgaUpdateZMode(ctx);
+      /* If depth testing is not enabled, then use the no Z-compare / no
+       * Z-write mode.  Otherwise, use whatever is set in hw.zmode.
+       */
+      mmesa->setup.dwgctl &= (DC_zmode_MASK & DC_atype_MASK);
+      mmesa->setup.dwgctl |= (ctx->Depth.Test)
+	  ? mmesa->hw.zmode : (DC_zmode_nozcmp | DC_atype_i);
 
-      if (new_state & MGA_NEW_ALPHA)
-	 mgaUpdateAlphaMode(ctx);
+#if defined(ACCEL_ROP)
+      mmesa->setup.dwgctl &= DC_bop_MASK;
+      mmesa->setup.dwgctl |= (ctx->Color.ColorLogicOpEnabled)
+	  ? mmesa->hw.rop : mgarop_NoBLK[ GL_COPY & 0x0f ];
+#endif
 
-      if (new_state & MGA_NEW_CLIP)
-	 mgaUpdateClipping(ctx);
+      mmesa->setup.alphactrl &= AC_src_MASK & AC_dst_MASK & AC_atmode_MASK
+	  & AC_atref_MASK & AC_alphasel_MASK;
+      mmesa->setup.alphactrl |= 
+	  ((mmesa->hw.alpha_func & mmesa->hw.alpha_func_enable)
+	   | ((mmesa->hw.blend_func & mmesa->hw.blend_func_enable)
+	      | ((AC_src_one | AC_dst_zero) & ~mmesa->hw.blend_func_enable))
+	   | mmesa->hw.alpha_sel
+	   | (AC_amode_alpha_channel
+	      | AC_astipple_disable 
+	      | AC_aten_disable 
+	      | AC_atmode_noacmp));
 
-      if (new_state & MGA_NEW_STENCIL)
-	 mgaUpdateStencil(ctx);
+      memcpy( &sarea->ContextState, &mmesa->setup, sizeof(mmesa->setup));
+   }
 
-      if (new_state & (MGA_NEW_WARP|MGA_NEW_CULL))
-	 mgaUpdateCull(ctx);
+   if ((mmesa->dirty & MGA_UPLOAD_TEX0) && mmesa->CurrentTexObj[0]) {
+      mmesa->CurrentTexObj[0]->setup.texctl2 &= ~TMC_specen_enable;
+      mmesa->CurrentTexObj[0]->setup.texctl2 |= mmesa->hw.specen;
 
-      if (new_state & (MGA_NEW_WARP|MGA_NEW_TEXTURE))
-	 mgaUpdateTextureState(ctx);
+      memcpy(&sarea->TexState[0],
+	     &mmesa->CurrentTexObj[0]->setup,
+	     sizeof(sarea->TexState[0]));
    }
+
+   if ((mmesa->dirty & MGA_UPLOAD_TEX1) && mmesa->CurrentTexObj[1]) {
+      mmesa->CurrentTexObj[1]->setup.texctl2 &= ~TMC_specen_enable;
+      mmesa->CurrentTexObj[1]->setup.texctl2 |= mmesa->hw.specen;
+
+      memcpy(&sarea->TexState[1],
+	     &mmesa->CurrentTexObj[1]->setup,
+	     sizeof(sarea->TexState[1]));
+   }
+
+   if ( (sarea->TexState[0].texctl2 & TMC_borderen_MASK) !=
+	(sarea->TexState[1].texctl2 & TMC_borderen_MASK) ) {
+      const int borderen = sarea->TexState[1].texctl2 & ~TMC_borderen_MASK;
+
+      memcpy( &sarea->TexState[1], &sarea->TexState[0],
+	      sizeof(sarea->TexState[0]) );
+      sarea->TexState[1].texctl2 |= borderen;
+      mmesa->dirty |= MGA_UPLOAD_TEX1|MGA_UPLOAD_TEX0;
+   }
+
+   if (mmesa->dirty & MGA_UPLOAD_PIPE) {
+/*        mmesa->sarea->wacceptseq = mmesa->hw_primitive; */
+      mmesa->sarea->WarpPipe = mmesa->vertex_format;
+      mmesa->sarea->vertsize = mmesa->vertex_size;
+   }
+
+   mmesa->sarea->dirty |= mmesa->dirty;
+   mmesa->dirty &= MGA_UPLOAD_CLIPRECTS;
+
+   /* This is a bit of a hack but seems to be the best place to ensure
+    * that separate specular is disabled when not needed.
+    */
+   if (ctx->Texture._EnabledUnits == 0 ||
+       !ctx->Light.Enabled ||
+       ctx->Light.Model.ColorControl == GL_SINGLE_COLOR) {
+      sarea->TexState[0].texctl2 &= ~TMC_specen_enable;
+      sarea->TexState[1].texctl2 &= ~TMC_specen_enable;
+   }
+}
+
+
+/* =============================================================
+ */
+
+
+static void mgaDDValidateState( GLcontext *ctx )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   int new_state = mmesa->NewGLState;
+
+
+   FLUSH_BATCH( mmesa );
+
+   if (mmesa->NewGLState & _MGA_NEW_RASTERSETUP) {
+      mgaChooseVertexState( ctx );
+   }
+
+   if (mmesa->NewGLState & _MGA_NEW_RENDERSTATE) {
+      mgaChooseRenderState( ctx );
+   }
+
+   if (new_state & _NEW_TEXTURE) {
+      mgaUpdateTextureState(ctx);
+   }
+
+   mmesa->NewGLState = 0;
 }
 
 
@@ -992,25 +1116,40 @@ static void mgaDDInvalidateState( GLcontext *ctx, GLuint new_state )
    _swsetup_InvalidateState( ctx, new_state );
    _ac_InvalidateState( ctx, new_state );
    _tnl_InvalidateState( ctx, new_state );
-   MGA_CONTEXT(ctx)->new_gl_state |= new_state;
+   MGA_CONTEXT(ctx)->NewGLState |= new_state;
 }
 
 
+static void mgaRunPipeline( GLcontext *ctx )
+{
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+
+   if (mmesa->NewGLState) {
+      mgaDDValidateState( ctx );
+   }
+
+   if (mmesa->dirty) {
+       mgaEmitHwStateLocked( mmesa );
+   }
+
+   _tnl_run_pipeline( ctx );
+}
+
 
 void mgaInitState( mgaContextPtr mmesa )
 {
    mgaScreenPrivate *mgaScreen = mmesa->mgaScreen;
    GLcontext *ctx = mmesa->glCtx;
 
-   if (ctx->Color._DrawDestMask == BACK_LEFT_BIT) {
+   if (ctx->Visual.doubleBufferMode) {
+      /* use back buffer by default */
       mmesa->draw_buffer = MGA_BACK;
-      mmesa->read_buffer = MGA_BACK;
       mmesa->drawOffset = mmesa->mgaScreen->backOffset;
       mmesa->readOffset = mmesa->mgaScreen->backOffset;
       mmesa->setup.dstorg = mgaScreen->backOffset;
    } else {
+      /* use front buffer by default */
       mmesa->draw_buffer = MGA_FRONT;
-      mmesa->read_buffer = MGA_FRONT;
       mmesa->drawOffset = mmesa->mgaScreen->frontOffset;
       mmesa->readOffset = mmesa->mgaScreen->frontOffset;
       mmesa->setup.dstorg = mgaScreen->frontOffset;
@@ -1043,14 +1182,21 @@ void mgaInitState( mgaContextPtr mmesa )
       mmesa->setup.maccess |= MA_zwidth_24;
       break;
    case 32:
-      mmesa->setup.maccess |= MA_pwidth_32;
+      mmesa->setup.maccess |= MA_zwidth_32;
       break;
    }
 
+   mmesa->hw.zmode = DC_zmode_zlt | DC_atype_zi;
+   mmesa->hw.stencil = (0x0ff << S_smsk_SHIFT) | (0x0ff << S_swtmsk_SHIFT);
+   mmesa->hw.stencilctl = SC_smode_salways | SC_sfailop_keep 
+       | SC_szfailop_keep | SC_szpassop_keep;
+   mmesa->hw.stencil_enable = 0;
+   mmesa->hw.cull = _CULL_NEGATIVE;
+   mmesa->hw.cull_dualtex = _CULL_POSITIVE;
+   mmesa->hw.specen = 0;
+
    mmesa->setup.dwgctl = (DC_opcod_trap |
-			  DC_atype_i |
 			  DC_linear_xy |
-			  DC_zmode_nozcmp |
 			  DC_solid_disable |
 			  DC_arzero_disable |
 			  DC_sgnzero_disable |
@@ -1072,16 +1218,15 @@ void mgaInitState( mgaContextPtr mmesa )
 			      AC_atmode_noacmp |
 			      AC_alphasel_fromtex );
 
-   mmesa->setup.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.fogcolor = PACK_COLOR_888((GLubyte)(ctx->Fog.Color[0]*255.0F),
+					  (GLubyte)(ctx->Fog.Color[1]*255.0F),
+					  (GLubyte)(ctx->Fog.Color[2]*255.0F));
 
    mmesa->setup.wflag = 0;
    mmesa->setup.tdualstage0 = 0;
    mmesa->setup.tdualstage1 = 0;
    mmesa->setup.fcol = 0;
-   mmesa->new_state = ~0;
+   mmesa->dirty |= MGA_UPLOAD_CONTEXT;
 }
 
 
@@ -1103,8 +1248,8 @@ void mgaDDInitStateFuncs( GLcontext *ctx )
    ctx->Driver.FrontFace = mgaDDCullFaceFrontFace;
    ctx->Driver.ColorMask = mgaDDColorMask;
 
-   ctx->Driver.DrawBuffer = mgaDDSetDrawBuffer;
-   ctx->Driver.ReadBuffer = mgaDDSetReadBuffer;
+   ctx->Driver.DrawBuffer = mgaDDDrawBuffer;
+   ctx->Driver.ReadBuffer = mgaDDReadBuffer;
    ctx->Driver.ClearColor = mgaDDClearColor;
    ctx->Driver.ClearDepth = mgaDDClearDepth;
    ctx->Driver.LogicOpcode = mgaDDLogicOp;
@@ -1128,4 +1273,6 @@ void mgaDDInitStateFuncs( GLcontext *ctx )
    ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable;
    ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
    ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
+
+   TNL_CONTEXT(ctx)->Driver.RunPipeline = mgaRunPipeline;
 }
diff --git a/src/mesa/drivers/dri/mga/mgastate.h b/src/mesa/drivers/dri/mga/mgastate.h
index a9f1039d760..afbe0aaf904 100644
--- a/src/mesa/drivers/dri/mga/mgastate.h
+++ b/src/mesa/drivers/dri/mga/mgastate.h
@@ -29,14 +29,11 @@
 #ifndef _MGA_STATE_H
 #define _MGA_STATE_H
 
-
 extern void mgaInitState( mgaContextPtr mmesa );
 extern void mgaDDInitStateFuncs(GLcontext *ctx);
-extern void mgaDDUpdateHwState( GLcontext *ctx );
 extern void mgaUpdateClipping(const GLcontext *ctx);
 extern void mgaUpdateCull( GLcontext *ctx );
 extern void mgaCalcViewport( GLcontext *ctx );
-
-
+extern void mgaUpdateRects( mgaContextPtr mmesa, GLuint buffers );
 
 #endif
diff --git a/src/mesa/drivers/dri/mga/mgatex.c b/src/mesa/drivers/dri/mga/mgatex.c
index b4ee787e0b8..82eccc81498 100644
--- a/src/mesa/drivers/dri/mga/mgatex.c
+++ b/src/mesa/drivers/dri/mga/mgatex.c
@@ -26,10 +26,7 @@
  */
 /* $XFree86: xc/lib/GL/mesa/src/drv/mga/mgatex.c,v 1.14 2002/10/30 12:51:36 alanh Exp $ */
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <GL/gl.h>
-
+#include "glheader.h"
 #include "mm.h"
 #include "mgacontext.h"
 #include "mgatex.h"
@@ -37,9 +34,11 @@
 #include "mgatris.h"
 #include "mgaioctl.h"
 
+#include "colormac.h"
+#include "context.h"
 #include "enums.h"
 #include "simple_list.h"
-/*#include "mem.h"*/
+#include "imports.h"
 #include "macros.h"
 #include "texformat.h"
 #include "texstore.h"
@@ -47,67 +46,72 @@
 
 #include "swrast/swrast.h"
 
-#define TEX_0 1
-#define TEX_1 2
-
-/*
- * mgaDestroyTexObj
- * Free all memory associated with a texture and NULL any pointers
- * to it.
+/**
+ * Set the texture wrap modes.
+ * Currently \c GL_REPEAT, \c GL_CLAMP and \c GL_CLAMP_TO_EDGE are supported.
+ * 
+ * \param t Texture object whose wrap modes are to be set
+ * \param swrap Wrap mode for the \a s texture coordinate
+ * \param twrap Wrap mode for the \a t texture coordinate
  */
-void
-mgaDestroyTexObj( mgaContextPtr mmesa, mgaTextureObjectPtr t )
+
+static void 
+mgaSetTexWrapping( mgaTextureObjectPtr t, GLenum swrap, GLenum twrap )
 {
-   if ( !t ) return;
+   GLboolean  is_clamp = GL_FALSE;
+   GLboolean  is_clamp_to_edge = GL_FALSE;
 
-   /* free the texture memory */
-   if (t->MemBlock) {
-      mmFreeMem( t->MemBlock );
-      t->MemBlock = 0;
+   t->setup.texctl &= (TMC_clampu_MASK & TMC_clampv_MASK);
+   t->setup.texctl2 &= (TMC_borderen_MASK);
 
-      if (mmesa && t->age > mmesa->dirtyAge)
-	 mmesa->dirtyAge = t->age;
+   switch( swrap ) {
+   case GL_REPEAT:
+      break;
+   case GL_CLAMP:
+      t->setup.texctl |= TMC_clampu_enable;
+      is_clamp = GL_TRUE;
+      break;
+   case GL_CLAMP_TO_EDGE:
+      t->setup.texctl |= TMC_clampu_enable;
+      is_clamp_to_edge = GL_TRUE;
+      break;
+   default:
+      _mesa_problem(NULL, "bad S wrap mode in %s", __FUNCTION__);
    }
 
-   /* free mesa's link */
-   if (t->tObj)
-      t->tObj->DriverData = NULL;
-
-   /* see if it was the driver's current object */
-   if (mmesa) {
-      if (t->bound & TEX_0) mmesa->CurrentTexObj[0] = 0;
-      if (t->bound & TEX_1) mmesa->CurrentTexObj[1] = 0;
+   switch( twrap ) {
+   case GL_REPEAT:
+      break;
+   case GL_CLAMP:
+      t->setup.texctl |= TMC_clampv_enable;
+      is_clamp = GL_TRUE;
+      break;
+   case GL_CLAMP_TO_EDGE:
+      t->setup.texctl |= TMC_clampv_enable;
+      is_clamp_to_edge = GL_TRUE;
+      break;
+   default:
+      _mesa_problem(NULL, "bad T wrap mode in %s", __FUNCTION__);
    }
-	
-   remove_from_list(t);
-   free( t );
-}
 
+   if ( is_clamp ) {
+      t->setup.texctl2 |= TMC_borderen_enable;
+   }
 
-/*
- * mgaSetTexWrappings
- */
-static void mgaSetTexWrapping( mgaTextureObjectPtr t,
-			       GLenum sWrap,
-			       GLenum tWrap )
-{
-   GLuint val = 0;
-
-   if (sWrap != GL_REPEAT)
-      val |= TMC_clampu_enable;
-
-   if (tWrap != GL_REPEAT)
-      val |= TMC_clampv_enable;
-
-   t->setup.texctl &= ~(TMC_clampu_enable|TMC_clampv_enable);
-   t->setup.texctl |= val;
+   t->border_fallback = (is_clamp && is_clamp_to_edge);
 }
 
 
-/*
- * mgaSetTexFilter
+/**
+ * Set the texture magnification and minification modes.
+ * 
+ * \param t Texture whose filter modes are to be set
+ * \param minf Texture minification mode
+ * \param magf Texture magnification mode
  */
-static void mgaSetTexFilter(mgaTextureObjectPtr t, GLenum minf, GLenum magf)
+
+static void
+mgaSetTexFilter( mgaTextureObjectPtr t, GLenum minf, GLenum magf )
 {
    GLuint val = 0;
 
@@ -136,123 +140,79 @@ static void mgaSetTexFilter(mgaTextureObjectPtr t, GLenum minf, GLenum magf)
    }
 
 
-   t->setup.texfilter &= (TF_minfilter_MASK |
-			  TF_magfilter_MASK |
+   /* Mask off the bits for the fields we are setting.  Remember, the MGA mask
+    * defines have 0s for the bits in the named fields.  This is the opposite
+    * of most of the other drivers.
+    */
+
+   t->setup.texfilter &= (TF_minfilter_MASK &
+			  TF_magfilter_MASK &
 			  TF_fthres_MASK);
    t->setup.texfilter |= val;
 }
 
-/*
- * mgaSetTexBorderColor
- */
 static void mgaSetTexBorderColor(mgaTextureObjectPtr t, GLubyte color[4])
 {
-   t->setup.texbordercol = MGAPACKCOLOR8888(color[0],color[1],
-					    color[2],color[3]);
+   t->setup.texbordercol = PACK_COLOR_8888(color[3], color[0], 
+					   color[1], color[2] );
 }
 
 
-static GLint mgaChooseTexFormat( mgaContextPtr mmesa,
-				 struct gl_texture_image *texImage,
-				 GLenum format, GLenum type )
+static const struct gl_texture_format *
+mgaChooseTextureFormat( GLcontext *ctx, GLint internalFormat,
+		        GLenum format, GLenum type )
 {
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
    const GLboolean do32bpt = mmesa->default32BitTextures;
-   const struct gl_texture_format *texFormat;
-   GLint ret;
-
-   if ( 0 )
-      fprintf( stderr, "internal=%s format=%s type=%s\n",
-	       texImage->IntFormat == 3 ? "GL_RGB (3)" :
-	       texImage->IntFormat == 4 ? "GL_RGBA (4)" :
-	       _mesa_lookup_enum_by_nr( texImage->IntFormat ),
-	       _mesa_lookup_enum_by_nr( format ),
-	       _mesa_lookup_enum_by_nr( type ) );
-
-#define SET_FORMAT( r, gl )						\
-   do {									\
-      ret = (r);							\
-      texFormat = &(gl);						\
-   } while (0)
-
-#define SET_FORMAT_32BPT( r32, gl32, r16, gl16 )			\
-   do {									\
-      if ( do32bpt ) {							\
-	 ret = (r32);							\
-	 texFormat = &(gl32);						\
-      } else {								\
-	 ret = (r16);							\
-	 texFormat = &(gl16);						\
-      }									\
-   } while (0)
-
-   switch ( texImage->IntFormat ) {
-      /* GH: Bias towards GL_RGB, GL_RGBA texture formats.  This has
-       * got to be better than sticking them way down the end of this
-       * huge list.
-       */
+
+   switch ( internalFormat ) {
    case 4:
    case GL_RGBA:
    case GL_COMPRESSED_RGBA:
       if ( format == GL_BGRA ) {
 	 if ( type == GL_UNSIGNED_INT_8_8_8_8_REV ) {
-	    SET_FORMAT( TMC_tformat_tw32, _mesa_texformat_argb8888 );
-	    break;
-	 } else if ( type == GL_UNSIGNED_SHORT_4_4_4_4_REV ) {
-	    SET_FORMAT( TMC_tformat_tw12, _mesa_texformat_argb4444 );
-	    break;
-	 } else if ( type == GL_UNSIGNED_SHORT_1_5_5_5_REV ) {
-	    SET_FORMAT( TMC_tformat_tw15, _mesa_texformat_argb1555 );
-	    break;
+	    return &_mesa_texformat_argb8888;
+	 }
+         else if ( type == GL_UNSIGNED_SHORT_4_4_4_4_REV ) {
+            return &_mesa_texformat_argb4444;
+	 }
+         else if ( type == GL_UNSIGNED_SHORT_1_5_5_5_REV ) {
+	    return &_mesa_texformat_argb1555;
 	 }
       }
-      SET_FORMAT_32BPT( TMC_tformat_tw32, _mesa_texformat_argb8888,
-			TMC_tformat_tw12, _mesa_texformat_argb4444 );
-      break;
+      return do32bpt ? &_mesa_texformat_argb8888 : &_mesa_texformat_argb4444;
 
    case 3:
    case GL_RGB:
    case GL_COMPRESSED_RGB:
       if ( format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5 ) {
-	 SET_FORMAT( TMC_tformat_tw16, _mesa_texformat_rgb565 );
-	 break;
+	 return &_mesa_texformat_rgb565;
       }
-      SET_FORMAT_32BPT( TMC_tformat_tw32, _mesa_texformat_argb8888,
-			TMC_tformat_tw16, _mesa_texformat_rgb565 );
-      break;
+      return do32bpt ? &_mesa_texformat_argb8888 : &_mesa_texformat_rgb565;
 
-      /* GH: Okay, keep checking as normal.  Still test for GL_RGB,
-       * GL_RGBA formats first.
-       */
    case GL_RGBA8:
    case GL_RGB10_A2:
    case GL_RGBA12:
    case GL_RGBA16:
-      SET_FORMAT_32BPT( TMC_tformat_tw32, _mesa_texformat_argb8888,
-			TMC_tformat_tw12, _mesa_texformat_argb4444 );
-      break;
+      return do32bpt ? &_mesa_texformat_argb8888 : &_mesa_texformat_argb4444;
 
    case GL_RGBA4:
    case GL_RGBA2:
-      SET_FORMAT( TMC_tformat_tw12, _mesa_texformat_argb4444 );
-      break;
+      return &_mesa_texformat_argb4444;
 
    case GL_RGB5_A1:
-      SET_FORMAT( TMC_tformat_tw15, _mesa_texformat_argb1555 );
-      break;
+      return &_mesa_texformat_argb1555;
 
    case GL_RGB8:
    case GL_RGB10:
    case GL_RGB12:
    case GL_RGB16:
-      SET_FORMAT_32BPT( TMC_tformat_tw32, _mesa_texformat_argb8888,
-			TMC_tformat_tw16, _mesa_texformat_rgb565 );
-      break;
+      return do32bpt ? &_mesa_texformat_argb8888 : &_mesa_texformat_rgb565;
 
    case GL_RGB5:
    case GL_RGB4:
    case GL_R3_G3_B2:
-      SET_FORMAT( TMC_tformat_tw16, _mesa_texformat_rgb565 );
-      break;
+      return &_mesa_texformat_rgb565;
 
    case GL_ALPHA:
    case GL_ALPHA4:
@@ -261,8 +221,7 @@ static GLint mgaChooseTexFormat( mgaContextPtr mmesa,
    case GL_ALPHA16:
    case GL_COMPRESSED_ALPHA:
       /* FIXME: This will report incorrect component sizes... */
-      SET_FORMAT( TMC_tformat_tw12, _mesa_texformat_argb4444 );
-      break;
+      return &_mesa_texformat_argb4444;
 
    case 1:
    case GL_LUMINANCE:
@@ -272,8 +231,7 @@ static GLint mgaChooseTexFormat( mgaContextPtr mmesa,
    case GL_LUMINANCE16:
    case GL_COMPRESSED_LUMINANCE:
       /* FIXME: This will report incorrect component sizes... */
-      SET_FORMAT( TMC_tformat_tw16, _mesa_texformat_rgb565 );
-      break;
+      return &_mesa_texformat_rgb565;
 
    case 2:
    case GL_LUMINANCE_ALPHA:
@@ -285,8 +243,7 @@ static GLint mgaChooseTexFormat( mgaContextPtr mmesa,
    case GL_LUMINANCE16_ALPHA16:
    case GL_COMPRESSED_LUMINANCE_ALPHA:
       /* FIXME: This will report incorrect component sizes... */
-      SET_FORMAT( TMC_tformat_tw12, _mesa_texformat_argb4444 );
-      break;
+      return &_mesa_texformat_argb4444;
 
    case GL_INTENSITY:
    case GL_INTENSITY4:
@@ -295,8 +252,15 @@ static GLint mgaChooseTexFormat( mgaContextPtr mmesa,
    case GL_INTENSITY16:
    case GL_COMPRESSED_INTENSITY:
       /* FIXME: This will report incorrect component sizes... */
-      SET_FORMAT( TMC_tformat_tw12, _mesa_texformat_argb4444 );
-      break;
+      return &_mesa_texformat_argb4444;
+
+   case GL_YCBCR_MESA:
+      if (MGA_IS_G400(mmesa) &&
+          (type == GL_UNSIGNED_SHORT_8_8_APPLE ||
+           type == GL_UNSIGNED_BYTE))
+         return &_mesa_texformat_ycbcr;
+      else
+         return &_mesa_texformat_ycbcr_rev;
 
    case GL_COLOR_INDEX:
    case GL_COLOR_INDEX1_EXT:
@@ -305,502 +269,78 @@ static GLint mgaChooseTexFormat( mgaContextPtr mmesa,
    case GL_COLOR_INDEX8_EXT:
    case GL_COLOR_INDEX12_EXT:
    case GL_COLOR_INDEX16_EXT:
-      SET_FORMAT( TMC_tformat_tw8, _mesa_texformat_ci8 );
-      break;
+      return &_mesa_texformat_ci8;
 
    default:
-      fprintf( stderr, "bad texture format in mgaChooseTexFormat() %d",
-	       texImage->IntFormat );
-      return -1;
+      _mesa_problem( ctx, "unexpected texture format in %s", __FUNCTION__ );
+      return NULL;
    }
 
-   texImage->TexFormat = texFormat;
-
-   return ret;
+   return NULL; /* never get here */
 }
 
 
-/*
- * mgaCreateTexObj
+
+
+/**
  * Allocate space for and load the mesa images into the texture memory block.
  * This will happen before drawing with a new texture, or drawing with a
  * texture after it was swapped out or teximaged again.
  */
-static void mgaCreateTexObj(mgaContextPtr mmesa,
-			    struct gl_texture_object *tObj)
-{
-   const GLint baseLevel = tObj->BaseLevel;
-   struct gl_texture_image *image = tObj->Image[baseLevel];
-   mgaTextureObjectPtr t;
-   int i, ofs;
-   int LastLevel;
-   int s, s2;
-   int tformat;
-
-   if (!image) return;
-
-   tObj->DriverData = t = calloc( 1, sizeof( *t ) );
-   if (!t) {
-      fprintf(stderr, "mgaCreateTexObj: Failed to malloc mgaTextureObject\n" );
-      return;
-   }
-
-   /* FIXME: Use the real DD interface...
-    */
-   tformat = mgaChooseTexFormat( mmesa, image, image->Format,
-				 GL_UNSIGNED_BYTE );
-   t->texelBytes = image->TexFormat->TexelBytes;
-
-   /* We are going to upload all levels that are present, even if
-    * later levels wouldn't be used by the current filtering mode.  This
-    * allows the filtering mode to change without forcing another upload
-    * of the images.
-    */
-   LastLevel = MGA_TEX_MAXLEVELS-1;
-
-   ofs = 0;
-   for ( i = 0 ; i <= LastLevel ; i++ ) {
-      if ( !tObj->Image[i] ) {
-	 LastLevel = i - 1;
-	 break;
-      }
-
-      t->offsets[i] = ofs;
-      t->dirty_images |= (1<<i);
-
-      ofs += ((MAX2( tObj->Image[i]->Width, 8 ) *
-	       MAX2( tObj->Image[i]->Height, 8 ) *
-	       t->texelBytes) + 31) & ~31;
-   }
-   t->totalSize = ofs;
-   t->lastLevel = LastLevel;
-   t->tObj = tObj;
-   t->ctx = mmesa;
-   t->age = 0;
-   t->bound = 0;
-   t->MemBlock = 0;
-
-   insert_at_tail(&(mmesa->SwappedOut), t);
-
-
-   /* setup hardware register values */
-   t->setup.texctl = TMC_takey_1 | TMC_tamask_0 | tformat;
-
-   if (image->WidthLog2 >= 3)
-      t->setup.texctl |= ((image->WidthLog2 - 3) << TMC_tpitch_SHIFT);
-   else
-      t->setup.texctl |= (TMC_tpitchlin_enable |
-			  (image->Width << TMC_tpitchext_SHIFT));
-
-
-   t->setup.texctl2 = TMC_ckstransdis_enable;
-
-   if ( mmesa->glCtx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR )
-      t->setup.texctl2 |= TMC_specen_enable;
-
-
-   t->setup.texfilter = (TF_minfilter_nrst |
-			 TF_magfilter_nrst |
-			 TF_filteralpha_enable |
-			 (0x10 << TF_fthres_SHIFT) |
-			 (LastLevel << TF_mapnb_SHIFT));
-
-   /* warp texture registers */
-   ofs = MGA_IS_G200(mmesa) ? 28 : 11;
-   s = image->Width;
-   s2 = image->WidthLog2;
-   t->setup.texwidth = (MGA_FIELD(TW_twmask, s - 1) |
-			MGA_FIELD(TW_rfw, (10 - s2 - 8) & 63 ) |
-			MGA_FIELD(TW_tw, (s2 + ofs ) | 0x40 ));
-
 
-   s = image->Height;
-   s2 = image->HeightLog2;
-   t->setup.texheight = (MGA_FIELD(TH_thmask, s - 1) |
-			 MGA_FIELD(TH_rfh, (10 - s2 - 8) & 63 ) |
-			 MGA_FIELD(TH_th, (s2 + ofs ) | 0x40 ));
-
-
-   /* set all the register values for filtering, border, etc */
-   mgaSetTexWrapping( t, tObj->WrapS, tObj->WrapT );
-   mgaSetTexFilter( t, tObj->MinFilter, tObj->MagFilter );
-   mgaSetTexBorderColor( t, tObj->_BorderChan );
-}
-
-
-
-
-static void mgaUpdateTextureEnvG200( GLcontext *ctx )
+static mgaTextureObjectPtr
+mgaAllocTexObj( struct gl_texture_object *tObj )
 {
-   struct gl_texture_object *tObj = ctx->Texture.Unit[0]._Current;
    mgaTextureObjectPtr t;
 
-   if (!tObj || !tObj->DriverData)
-      return;
-
-   t = (mgaTextureObjectPtr)tObj->DriverData;
-
-   t->setup.texctl2 &= ~TMC_decalblend_enable;
-
-   switch (ctx->Texture.Unit[0].EnvMode) {
-   case GL_REPLACE:
-      t->setup.texctl &= ~TMC_tmodulate_enable;
-      break;
-   case GL_MODULATE:
-      t->setup.texctl |= TMC_tmodulate_enable;
-      break;
-   case GL_DECAL:
-      t->setup.texctl &= ~TMC_tmodulate_enable;
-      t->setup.texctl2 |= TMC_decalblend_enable;
-      break;
-   case GL_BLEND:
-      FALLBACK( ctx, MGA_FALLBACK_TEXTURE, GL_TRUE );
-      break;
-   default:
-      break;
-   }
-}
-
-static void mgaUpdateTextureEnvG400( GLcontext *ctx, int unit )
-{
-   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
-   GLuint *reg = ((GLuint *)&mmesa->setup.tdualstage0 + unit);
-   GLuint source = mmesa->tmu_source[unit];
-   struct gl_texture_object *tObj = ctx->Texture.Unit[source]._Current;
-   GLenum format;
-
-   if ( tObj != ctx->Texture.Unit[source].Current2D || !tObj ) 
-      return;
-
-   format = tObj->Image[tObj->BaseLevel]->Format;
-
-   switch (ctx->Texture.Unit[source].EnvMode) {
-   case GL_REPLACE:
-      if (format == GL_RGB || format == GL_LUMINANCE) {
-	 *reg = (TD0_color_sel_arg1 |
-                 TD0_alpha_arg2_diffuse |
-		 TD0_alpha_sel_arg2 );
-      }
-      else if (format == GL_ALPHA) {
-         *reg = (TD0_color_sel_arg2 |
-                 TD0_color_arg2_diffuse |
-                 TD0_alpha_sel_arg1 );
-      }
-      else {
-         *reg = (TD0_color_sel_arg1 |
-                 TD0_alpha_sel_arg1 );
-      }
-      break;
-
-   case GL_MODULATE:
-      if (unit == 0) {
-	 *reg = ( TD0_color_arg2_diffuse |
-		  TD0_color_sel_mul |
-		  TD0_alpha_arg2_diffuse |
-		  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_mul);
-      }
-      break;
-   case GL_DECAL:
-      if (format == GL_RGB) {
-         if (unit == 0) {
-            *reg = (TD0_color_sel_arg1 |
-                    TD0_alpha_arg2_diffuse |
-                    TD0_alpha_sel_arg2 );
-         }
-         else {
-            *reg = (TD0_color_sel_arg1 |
-                    TD0_alpha_arg2_prevstage |
-                    TD0_alpha_sel_arg2 );
-         }
-      }
-      else if ( format == GL_RGBA ) {
-#if 0
-         if (unit == 0) {
-            /* this doesn't work */
-            *reg = (TD0_color_arg2_diffuse |
-                    TD0_color_alpha_currtex |
-                    TD0_color_alpha2inv_enable |
-                    TD0_color_arg2mul_alpha2 |
-                    TD0_color_arg1mul_alpha1 |
-                    TD0_color_blend_enable |
-                    TD0_color_arg1add_mulout |
-                    TD0_color_arg2add_mulout |
-                    TD0_color_add_add |
-                    TD0_color_sel_mul |
-                    TD0_alpha_arg2_diffuse |
-                    TD0_alpha_sel_arg2 );
-         }
-         else {
-            *reg = (TD0_color_arg2_prevstage |
-                    TD0_color_alpha_currtex |
-                    TD0_color_alpha2inv_enable |
-                    TD0_color_arg2mul_alpha2 |
-                    TD0_color_arg1mul_alpha1 |
-                    TD0_color_add_add |
-                    TD0_color_sel_add |
-                    TD0_alpha_arg2_prevstage |
-                    TD0_alpha_sel_arg2 );
-         }
-#else
-         /* s/w fallback, pretty sure we can't do in h/w */
-	 FALLBACK( ctx, MGA_FALLBACK_TEXTURE, GL_TRUE );
-	 if ( MGA_DEBUG & DEBUG_VERBOSE_FALLBACK )
-	    fprintf( stderr, "FALLBACK: GL_DECAL RGBA texture, unit=%d\n",
-		     unit );
-#endif
-      }
-      else {
-	 if (unit == 0) {
-	    *reg = ( TD0_color_arg2_diffuse |
-		     TD0_color_sel_arg2 |
-		     TD0_alpha_arg2_diffuse |
-		     TD0_alpha_sel_arg2);
-	 }
-	 else {
-	    *reg = ( TD0_color_arg2_prevstage |
-		     TD0_color_sel_arg2 |
-		     TD0_alpha_arg2_prevstage |
-		     TD0_alpha_sel_arg2);
-	 }
-      }
-      break;
-
-   case GL_ADD:
-      if (unit == 0) {
-         if (format == GL_INTENSITY)
-            *reg = ( TD0_color_arg2_diffuse |
-                     TD0_color_add_add |
-                     TD0_color_sel_add |
-                     TD0_alpha_arg2_diffuse |
-                     TD0_alpha_add_enable |
-                     TD0_alpha_sel_add);
-         else if (format == GL_ALPHA)
-            *reg = ( TD0_color_arg2_diffuse |
-                     TD0_color_sel_mul |
-                     TD0_alpha_arg2_diffuse |
-                     TD0_alpha_sel_mul);
-         else
-            *reg = ( TD0_color_arg2_diffuse |
-                     TD0_color_add_add |
-                     TD0_color_sel_add |
-                     TD0_alpha_arg2_diffuse |
-                     TD0_alpha_sel_mul);
-      }
-      else {
-         if (format == GL_INTENSITY) {
-            *reg = ( TD0_color_arg2_prevstage |
-                     TD0_color_add_add |
-                     TD0_color_sel_add |
-                     TD0_alpha_arg2_prevstage |
-                     TD0_alpha_add_enable |
-                     TD0_alpha_sel_add);
-         }
-         else if (format == GL_ALPHA) {
-            *reg = ( TD0_color_arg2_prevstage |
-                     TD0_color_sel_mul |
-                     TD0_alpha_arg2_prevstage |
-                     TD0_alpha_sel_mul);
-         }
-         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_mul);
-         }
-      }
-      break;
-
-   case GL_BLEND:
-      if (format == GL_ALPHA) {
-	 *reg = ( TD0_color_arg2_diffuse |
-		  TD0_color_sel_mul |
-		  TD0_alpha_arg2_diffuse |
-		  TD0_alpha_sel_mul);
-      }
-      else {
-	 FALLBACK( ctx, MGA_FALLBACK_TEXTURE, GL_TRUE );
-	 if ( MGA_DEBUG & DEBUG_VERBOSE_FALLBACK )
-	    fprintf( stderr, "FALLBACK: GL_BLEND envcolor=0x%08x\n",
-		     mmesa->envcolor );
-
-         /* Do singletexture GL_BLEND with 'all ones' env-color
-          * by using both texture units.  Multitexture gl_blend
-          * is a fallback.
-          */
-         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:
-      break;
-   }
-}
-
-
-
-static void mgaUpdateTextureObject( GLcontext *ctx, int hw_unit )
-{
-   mgaTextureObjectPtr t;
-   struct gl_texture_object	*tObj;
-   GLuint enabled;
-   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
-   GLuint gl_unit = mmesa->tmu_source[hw_unit];
-
-
-   enabled = ctx->Texture.Unit[gl_unit]._ReallyEnabled;
-   tObj = ctx->Texture.Unit[gl_unit]._Current;
-
-   if (enabled != TEXTURE_2D_BIT) {
-      if (enabled)
-	 FALLBACK( ctx, MGA_FALLBACK_TEXTURE, GL_TRUE );
-      return;
-   }
-
-   if (tObj->Image[tObj->BaseLevel]->Border > 0) {
-      FALLBACK( ctx, MGA_FALLBACK_TEXTURE, GL_TRUE );
-      if ( MGA_DEBUG & DEBUG_VERBOSE_FALLBACK )
-	 fprintf( stderr, "FALLBACK: texture border\n" );
-      return;
-   }
-
-   if ( !tObj->DriverData ) {
-      mgaCreateTexObj( mmesa, tObj );
-      if ( !tObj->DriverData ) {
-	 FALLBACK( ctx, MGA_FALLBACK_TEXTURE, GL_TRUE );
-	 return;		
-      }
-   }
-
-   t = (mgaTextureObjectPtr)tObj->DriverData;
-
-   if (t->dirty_images)
-      mmesa->dirty |= (MGA_UPLOAD_TEX0IMAGE << hw_unit);
-
-   mmesa->CurrentTexObj[hw_unit] = t;
-   t->bound |= hw_unit+1;
-
-/*     if (t->MemBlock) */
-/*        mgaUpdateTexLRU( mmesa, t ); */
-
-   t->setup.texctl2 &= ~TMC_dualtex_enable;
-   if ((ctx->Texture.Unit[0]._ReallyEnabled == TEXTURE_2D_BIT) &&
-       (ctx->Texture.Unit[1]._ReallyEnabled == TEXTURE_2D_BIT)) 
-      t->setup.texctl2 |= TMC_dualtex_enable;
-
-   t->setup.texctl2 &= ~TMC_specen_enable;
-   if (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR)
-      t->setup.texctl2 |= TMC_specen_enable;
-}
-
-
 
+   t = CALLOC( sizeof( *t ) );
+   tObj->DriverData = t;
+   if ( t != NULL ) {
+      /* Initialize non-image-dependent parts of the state:
+       */
+      t->base.tObj = tObj;
 
+      t->setup.texctl = TMC_takey_1 | TMC_tamask_0;
+      t->setup.texctl2 = TMC_ckstransdis_enable;
+      t->setup.texfilter = (TF_minfilter_nrst 
+			    | TF_magfilter_nrst
+			    | TF_filteralpha_enable
+			    | TF_uvoffset_OGL);
 
+      t->border_fallback = GL_FALSE;
 
-/* The G400 is now programmed quite differently wrt texture environment.
- */
-void mgaUpdateTextureState( GLcontext *ctx )
-{
-   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
-   FALLBACK( ctx, MGA_FALLBACK_TEXTURE, GL_FALSE );
+      make_empty_list( & t->base );
 
-   if (mmesa->CurrentTexObj[0]) {
-      mmesa->CurrentTexObj[0]->bound = 0;
-      mmesa->CurrentTexObj[0] = 0;
-   }
-
-   if (mmesa->CurrentTexObj[1]) {
-      mmesa->CurrentTexObj[1]->bound = 0;
-      mmesa->CurrentTexObj[1] = 0;
-   }
-
-   if (ctx->Texture.Unit[1]._ReallyEnabled == TEXTURE_2D_BIT) {
-      mmesa->tmu_source[0] = 1;
-   } else {
-      mmesa->tmu_source[0] = 0;
-   }
-
-   if (MGA_IS_G400(mmesa)) {
-      mgaUpdateTextureObject( ctx, 0 );
-      mgaUpdateTextureEnvG400( ctx, 0 );
-
-      mmesa->setup.tdualstage1 = mmesa->setup.tdualstage0;
-      
-      if ((ctx->Texture.Unit[0]._ReallyEnabled == TEXTURE_2D_BIT) &&
-          (ctx->Texture.Unit[1]._ReallyEnabled == TEXTURE_2D_BIT)) {
-	 mgaUpdateTextureObject( ctx, 1 );	
-	 mgaUpdateTextureEnvG400( ctx, 1 );
-	 mmesa->dirty |= MGA_UPLOAD_TEX1;
-      }
-   } else {
-      mgaUpdateTextureObject( ctx, 0 );
-      mgaUpdateTextureEnvG200( ctx );
+      mgaSetTexWrapping( t, tObj->WrapS, tObj->WrapT );
+      mgaSetTexFilter( t, tObj->MinFilter, tObj->MagFilter );
+      mgaSetTexBorderColor( t, tObj->_BorderChan );
    }
 
-   mmesa->dirty |= MGA_UPLOAD_CONTEXT | MGA_UPLOAD_TEX0;
-
-   mmesa->setup.dwgctl &= DC_opcod_MASK;
-   mmesa->setup.dwgctl |= (ctx->Texture.Unit[0]._ReallyEnabled
-			   ? DC_opcod_texture_trap
-			   : DC_opcod_trap);
+   return( t );
 }
 
 
-
-
 static void mgaDDTexEnv( GLcontext *ctx, GLenum target,
 			 GLenum pname, const GLfloat *param )
 {
+   GLuint unit = ctx->Texture.CurrentUnit;
+   struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
    mgaContextPtr mmesa = MGA_CONTEXT(ctx);
 
 
-   if (pname == GL_TEXTURE_ENV_MODE) {
-      /* force the texture state to be updated */
-      FLUSH_BATCH( MGA_CONTEXT(ctx) );
-      MGA_CONTEXT(ctx)->new_state |= (MGA_NEW_TEXTURE |
-				      MGA_NEW_ALPHA);
-   }
-   else if (pname == GL_TEXTURE_ENV_COLOR)
-   {
-      struct gl_texture_unit *texUnit =
-	 &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
-      GLfloat *fc = texUnit->EnvColor;
+   switch( pname ) {
+   case GL_TEXTURE_ENV_COLOR: {
       GLubyte c[4];
-      GLuint col;
+      GLuint envColor;
 
-      COPY_4V(c, fc);
-      col = mgaPackColor( mmesa->mgaScreen->cpp, c[0], c[1], c[2], c[3] );
-      mmesa->envcolor = (c[3]<<24) | (c[0]<<16) | (c[1]<<8) | (c[2]);
+      UNCLAMPED_FLOAT_TO_RGBA_CHAN( c, texUnit->EnvColor );
+      envColor = mgaPackColor( mmesa->mgaScreen->cpp, c[0], c[1], c[2], c[3] );
+      mmesa->envcolor = PACK_COLOR_8888( c[3], c[0], c[1], c[2] );
 
-      if (mmesa->setup.fcol != col) {
+      if (mmesa->setup.fcol != envColor) {
 	 FLUSH_BATCH(mmesa);
-	 mmesa->setup.fcol = col;
+	 mmesa->setup.fcol = envColor;
 	 mmesa->dirty |= MGA_UPLOAD_CONTEXT;
 
 	 mmesa->blend_flags &= ~MGA_BLEND_ENV_COLOR;
@@ -814,6 +354,8 @@ static void mgaDDTexEnv( GLcontext *ctx, GLenum target,
 	 if (mmesa->envcolor != 0x0 && mmesa->envcolor != 0xffffffff)
 	    mmesa->blend_flags |= MGA_BLEND_ENV_COLOR;
       }
+      break;
+   }
    }
 }
 
@@ -826,14 +368,26 @@ static void mgaTexImage2D( GLcontext *ctx, GLenum target, GLint level,
 			    struct gl_texture_object *texObj,
 			    struct gl_texture_image *texImage )
 {
-   mgaTextureObjectPtr t = (mgaTextureObjectPtr) texObj->DriverData;
-   if (t) {
-      mgaDestroyTexObj( MGA_CONTEXT(ctx), t );
-      texObj->DriverData = 0;
+   driTextureObject * t = (driTextureObject *) texObj->DriverData;
+
+
+   if ( t != NULL ) {
+      driSwapOutTextureObject( t );
+   } 
+   else {
+      t = (driTextureObject *) mgaAllocTexObj( texObj );
+      if ( t == NULL ) {
+	 _mesa_error( ctx, GL_OUT_OF_MEMORY, "glTexImage2D" );
+	 return;
+      }
    }
+
    _mesa_store_teximage2d( ctx, target, level, internalFormat,
 			   width, height, border, format, type,
 			   pixels, packing, texObj, texImage );
+   level -= t->firstLevel;
+   if (level >= 0)
+      t->dirty_images[0] |= (1UL << level);
 }
 
 static void mgaTexSubImage2D( GLcontext *ctx, 
@@ -847,44 +401,59 @@ static void mgaTexSubImage2D( GLcontext *ctx,
 			       struct gl_texture_object *texObj,
 			       struct gl_texture_image *texImage )
 {
-   mgaTextureObjectPtr t = (mgaTextureObjectPtr) texObj->DriverData;
-   if (t) {
-      mgaDestroyTexObj( MGA_CONTEXT(ctx), t );
-      texObj->DriverData = 0;
+   driTextureObject * t = (driTextureObject *) texObj->DriverData;
+
+
+   assert( t != NULL ); /* this _should_ be true */
+   if ( t != NULL ) {
+      driSwapOutTextureObject( t );
+   } 
+   else {
+      t = (driTextureObject *) mgaAllocTexObj( texObj );
+      if ( t == NULL ) {
+	 _mesa_error( ctx, GL_OUT_OF_MEMORY, "glTexImage2D" );
+	 return;
+      }
    }
+
    _mesa_store_texsubimage2d(ctx, target, level, xoffset, yoffset, width, 
 			     height, format, type, pixels, packing, texObj,
 			     texImage);
-
+   level -= t->firstLevel;
+   if (level >= 0)
+      t->dirty_images[0] |= (1UL << level);
 }
 
 
-
-
-/*
- * mgaTexParameter
- * This just changes variables and flags for a state update, which
- * will happen at the next mgaUpdateTextureState
+/**
+ * Changes variables and flags for a state update, which will happen at the
+ * next UpdateTextureState
  */
+
 static void
 mgaDDTexParameter( GLcontext *ctx, GLenum target,
 		   struct gl_texture_object *tObj,
 		   GLenum pname, const GLfloat *params )
 {
-   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
+   mgaContextPtr       mmesa = MGA_CONTEXT( ctx );
    mgaTextureObjectPtr t;
 
    t = (mgaTextureObjectPtr) tObj->DriverData;
 
-   /* if we don't have a hardware texture, it will be automatically
-      created with current state before it is used, so we don't have
-      to do anything now */
-   if ( !t || !t->bound || target != GL_TEXTURE_2D ) {
+   /* If we don't have a hardware texture, it will be automatically
+    * created with current state before it is used, so we don't have
+    * to do anything now 
+    */
+
+   if ( (t == NULL)
+        || (target != GL_TEXTURE_2D) ) {
       return;
    }
 
    switch (pname) {
    case GL_TEXTURE_MIN_FILTER:
+      driSwapOutTextureObject( (driTextureObject *) t );
+      /* FALLTHROUGH */
    case GL_TEXTURE_MAG_FILTER:
       FLUSH_BATCH(mmesa);
       mgaSetTexFilter( t, tObj->MinFilter, tObj->MagFilter );
@@ -898,14 +467,24 @@ mgaDDTexParameter( GLcontext *ctx, GLenum target,
 
    case GL_TEXTURE_BORDER_COLOR:
       FLUSH_BATCH(mmesa);
-      mgaSetTexBorderColor(t,tObj->_BorderChan);
+      mgaSetTexBorderColor(t, tObj->_BorderChan);
+      break;
+
+   case GL_TEXTURE_BASE_LEVEL:
+   case GL_TEXTURE_MAX_LEVEL:
+   case GL_TEXTURE_MIN_LOD:
+   case GL_TEXTURE_MAX_LOD:
+      /* This isn't the most efficient solution but there doesn't appear to
+       * be a nice alternative.  Since there's no LOD clamping,
+       * we just have to rely on loading the right subset of mipmap levels
+       * to simulate a clamped LOD.
+       */
+      driSwapOutTextureObject( (driTextureObject *) t );
       break;
 
    default:
       return;
    }
-
-   mmesa->new_state |= MGA_NEW_TEXTURE;
 }
 
 
@@ -913,19 +492,11 @@ static void
 mgaDDBindTexture( GLcontext *ctx, GLenum target,
 		  struct gl_texture_object *tObj )
 {
-   mgaContextPtr mmesa = MGA_CONTEXT( ctx );
-   int unit = ctx->Texture.CurrentUnit;
-
-   FLUSH_BATCH(mmesa);
-
-   if (mmesa->CurrentTexObj[unit]) {
-      mmesa->CurrentTexObj[unit]->bound &= ~(unit+1);
-      mmesa->CurrentTexObj[unit] = 0;
+   if ( target == GL_TEXTURE_2D ) {
+      if ( tObj->DriverData == NULL ) {
+	 mgaAllocTexObj( tObj );
+      }
    }
-
-   /* force the texture state to be updated
-    */
-   MGA_CONTEXT(ctx)->new_state |= MGA_NEW_TEXTURE;
 }
 
 
@@ -933,53 +504,48 @@ static void
 mgaDDDeleteTexture( GLcontext *ctx, struct gl_texture_object *tObj )
 {
    mgaContextPtr mmesa = MGA_CONTEXT( ctx );
-   mgaTextureObjectPtr t = (mgaTextureObjectPtr)tObj->DriverData;
+   driTextureObject * t = (driTextureObject *) tObj->DriverData;
 
    if ( t ) {
-      if (mmesa) {
-         if (t->bound) {
-            FLUSH_BATCH(mmesa);
-            if (t->bound & TEX_0) mmesa->CurrentTexObj[0] = 0;
-            if (t->bound & TEX_1) mmesa->CurrentTexObj[1] = 0;
-         }
-         mmesa->new_state |= MGA_NEW_TEXTURE;
+      if ( mmesa ) {
+	 FLUSH_BATCH( mmesa );
       }
 
-      mgaDestroyTexObj( mmesa, t );
+      driDestroyTextureObject( t );
    }
 }
 
 
-static GLboolean
-mgaDDIsTextureResident( GLcontext *ctx, struct gl_texture_object *t )
-{
-   mgaTextureObjectPtr mt = (mgaTextureObjectPtr)t->DriverData;
-   return mt && mt->MemBlock;
-}
-
-
 void
 mgaDDInitTextureFuncs( GLcontext *ctx )
 {
-   ctx->Driver.TexEnv = mgaDDTexEnv;
-
-   ctx->Driver.ChooseTextureFormat = _mesa_choose_tex_format;
-   ctx->Driver.TexImage1D = _mesa_store_teximage1d;
-   ctx->Driver.TexImage2D = mgaTexImage2D;
-   ctx->Driver.TexImage3D = _mesa_store_teximage3d;
-   ctx->Driver.TexSubImage1D = _mesa_store_texsubimage1d;
-   ctx->Driver.TexSubImage2D = mgaTexSubImage2D;
-   ctx->Driver.TexSubImage3D = _mesa_store_texsubimage3d;
-   ctx->Driver.CopyTexImage1D = _swrast_copy_teximage1d;
-   ctx->Driver.CopyTexImage2D = _swrast_copy_teximage2d;
-   ctx->Driver.CopyTexSubImage1D = _swrast_copy_texsubimage1d;
-   ctx->Driver.CopyTexSubImage2D = _swrast_copy_texsubimage2d;
-   ctx->Driver.CopyTexSubImage3D = _swrast_copy_texsubimage3d;
-   ctx->Driver.TestProxyTexImage = _mesa_test_proxy_teximage;
-
-   ctx->Driver.BindTexture = mgaDDBindTexture;
-   ctx->Driver.DeleteTexture = mgaDDDeleteTexture;
-   ctx->Driver.TexParameter = mgaDDTexParameter;
-   ctx->Driver.UpdateTexturePalette = 0;
-   ctx->Driver.IsTextureResident = mgaDDIsTextureResident;
+   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
+
+
+   ctx->Driver.ChooseTextureFormat	= mgaChooseTextureFormat;
+   ctx->Driver.TexImage1D		= _mesa_store_teximage1d;
+   ctx->Driver.TexImage2D		= mgaTexImage2D;
+   ctx->Driver.TexImage3D		= _mesa_store_teximage3d;
+   ctx->Driver.TexSubImage1D		= _mesa_store_texsubimage1d;
+   ctx->Driver.TexSubImage2D		= mgaTexSubImage2D;
+   ctx->Driver.TexSubImage3D		= _mesa_store_texsubimage3d;
+   ctx->Driver.CopyTexImage1D		= _swrast_copy_teximage1d;
+   ctx->Driver.CopyTexImage2D		= _swrast_copy_teximage2d;
+   ctx->Driver.CopyTexSubImage1D	= _swrast_copy_texsubimage1d;
+   ctx->Driver.CopyTexSubImage2D	= _swrast_copy_texsubimage2d;
+   ctx->Driver.CopyTexSubImage3D	= _swrast_copy_texsubimage3d;
+   ctx->Driver.TestProxyTexImage	= _mesa_test_proxy_teximage;
+
+   ctx->Driver.BindTexture		= mgaDDBindTexture;
+   ctx->Driver.CreateTexture		= NULL; /* FIXME: Is this used??? */
+   ctx->Driver.DeleteTexture		= mgaDDDeleteTexture;
+   ctx->Driver.IsTextureResident	= driIsTextureResident;
+   ctx->Driver.PrioritizeTexture	= NULL;
+   ctx->Driver.ActiveTexture		= NULL;
+   ctx->Driver.UpdateTexturePalette	= NULL;
+
+   ctx->Driver.TexEnv			= mgaDDTexEnv;
+   ctx->Driver.TexParameter		= mgaDDTexParameter;
+
+   driInitTextureObjects( ctx, & mmesa->swapped, DRI_TEXMGR_DO_TEXTURE_2D );
 }
diff --git a/src/mesa/drivers/dri/mga/mgatex.h b/src/mesa/drivers/dri/mga/mgatex.h
index c9f87d997e2..282577e9f80 100644
--- a/src/mesa/drivers/dri/mga/mgatex.h
+++ b/src/mesa/drivers/dri/mga/mgatex.h
@@ -40,23 +40,10 @@ typedef struct mga_texture_object_s *mgaTextureObjectPtr;
  */
 void mgaUpdateTextureState( GLcontext *ctx );
 
-void mgaConvertTexture( GLuint *dest, int texelBytes,
-			struct gl_texture_image *image,
-			int x, int y, int width, int height );
-
-
-void mgaUploadSubImageLocked( mgaContextPtr mmesa,
-			      mgaTextureObjectPtr t,
-			      int level,
-			      int x, int y, int width, int height );
-
 int mgaUploadTexImages( mgaContextPtr mmesa, mgaTextureObjectPtr t );
 
 void mgaDestroyTexObj( mgaContextPtr mmesa, mgaTextureObjectPtr t );
 
-void mgaAgeTextures( mgaContextPtr mmesa, int heap );
-
 void mgaDDInitTextureFuncs( GLcontext *ctx );
 
-
 #endif
diff --git a/src/mesa/drivers/dri/mga/mgatexmem.c b/src/mesa/drivers/dri/mga/mgatexmem.c
index 7dbdbc582fa..4e7fd6b24b3 100644
--- a/src/mesa/drivers/dri/mga/mgatexmem.c
+++ b/src/mesa/drivers/dri/mga/mgatexmem.c
@@ -26,539 +26,257 @@
  */
 /* $XFree86: xc/lib/GL/mesa/src/drv/mga/mgatexmem.c,v 1.7 2002/10/30 12:51:36 alanh Exp $ */
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <GL/gl.h>
+#include "glheader.h"
 
 #include "mm.h"
 #include "mgacontext.h"
 #include "mgatex.h"
 #include "mgaregs.h"
 #include "mgaioctl.h"
+#include "mga_xmesa.h"
 
-/*#include "mem.h" */
+#include "imports.h"
 #include "simple_list.h"
 
-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;
-   move_to_tail(&(mmesa->SwappedOut), t);
-}
-
-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 )
+/**
+ * Destroy any device-dependent state associated with the texture.  This may
+ * include NULLing out hardware state that points to the texture.
+ */
+void
+mgaDestroyTexObj( mgaContextPtr mmesa, mgaTextureObjectPtr t )
 {
-   int i, j;
-   drmTextureRegion *list = mmesa->sarea->texList[heap];
+    unsigned   i;
 
-   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;
-   }
+    /* See if it was the driver's current object.
+     */
 
-   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);
-      }
-   }
+    if ( mmesa != NULL )
+    { 
+	if ( t->age > mmesa->dirtyAge )
+	    mmesa->dirtyAge = t->age;
 
-   fprintf(stderr, "\n\n");
+	for ( i = 0 ; i < mmesa->glCtx->Const.MaxTextureUnits ; i++ )
+	{
+	    if ( t == mmesa->CurrentTexObj[ i ] ) {
+		mmesa->CurrentTexObj[ i ] = NULL;
+	    }
+	}
+    }
 }
 
 
-static void mgaResetGlobalLRU( mgaContextPtr mmesa, GLuint heap )
+/**
+ * Upload a texture image from system memory to either on-card or AGP
+ * memory.  Uploads to on-card memory are performed using an ILOAD operation.
+ * This is used for both initial loading of the entire image, and texSubImage
+ * updates.
+ *
+ * Performed with the hardware lock held.
+ * 
+ * Even though this function is named "upload subimage," the entire image
+ * is uploaded.
+ * 
+ * \param mmesa  Driver context.
+ * \param t      Texture to be uploaded.
+ * \param hwlevel  Mipmap level of the texture to be uploaded.
+ * 
+ * \bug As mentioned above, this fuction actually copies the entier mipmap
+ *      level.  There should be a version of this function that performs
+ *      sub-rectangle uploads.  This will perform quite a bit better if only
+ *      a small portion of a larger texture has been updated.  Care would
+ *      need to be take with such an implementation once glCopyTexImage has
+ *      been hardware accelerated.
+ */
+static void mgaUploadSubImage( mgaContextPtr mmesa,
+			       mgaTextureObjectPtr t, GLint hwlevel )
 {
-   drmTextureRegion *list = mmesa->sarea->texList[heap];
-   int sz = 1 << mmesa->mgaScreen->logTextureGranularity[heap];
-   int i;
-
-   mmesa->texAge[heap] = ++mmesa->sarea->texAge[heap];
+   struct gl_texture_image * texImage;
+   unsigned     offset;
+   unsigned     texelBytes;
+   unsigned     length;
+   const int level = hwlevel + t->base.firstLevel;
 
-   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[heap] ; i++) {
-      list[i].prev = i-1;
-      list[i].next = i+1;
-      list[i].age = mmesa->sarea->texAge[heap];
+   if ( (hwlevel < 0) 
+	|| (hwlevel >= (MGA_IS_G200(mmesa) 
+		      ? G200_TEX_MAXLEVELS : G400_TEX_MAXLEVELS)) ) {
+      fprintf( stderr, "[%s:%d] level = %d\n", __FILE__, __LINE__, level );
+      return;
    }
 
-   i--;
-   list[0].prev = MGA_NR_TEX_REGIONS;
-   list[i].prev = i-1;
-   list[i].next = MGA_NR_TEX_REGIONS;
-   list[MGA_NR_TEX_REGIONS].prev = i;
-   list[MGA_NR_TEX_REGIONS].next = 0;
-
-}
-
-
-static void mgaUpdateTexLRU( mgaContextPtr mmesa, mgaTextureObjectPtr t )
-{
-   int i;
-   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;
-   drmTextureRegion *list = mmesa->sarea->texList[heap];
-
-   mmesa->texAge[heap] = ++mmesa->sarea->texAge[heap];
-
-   if (!t->MemBlock) {
-      fprintf(stderr, "no memblock\n\n");
+   texImage = t->base.tObj->Image[level];
+   if ( texImage == NULL ) {
+      fprintf( stderr, "[%s:%d] Image[%d] = NULL\n", __FILE__, __LINE__,
+	       level );
       return;
    }
 
-   /* Update our local LRU
-    */
-   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[heap];
-
-      /* 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 = MGA_NR_TEX_REGIONS;
-      list[i].next = list[MGA_NR_TEX_REGIONS].next;
-      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);
+   if (texImage->Data == NULL) {
+      fprintf(stderr, "null texture image data tObj %p level %d\n",
+	      t->base.tObj, level);
+      return;
    }
-}
-
-/* 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.
- */
-static void mgaTexturesGone( mgaContextPtr mmesa,
-			     GLuint heap,
-			     GLuint offset,
-			     GLuint size,
-			     GLuint in_use )
-{
-   mgaTextureObjectPtr t, tmp;
-
-
 
-   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->bound)
-	 mgaSwapOutTexObj( mmesa, t );
-      else
-	 mgaDestroyTexObj( mmesa, t );
+   /* find the proper destination offset for this level */
+   if ( MGA_IS_G200(mmesa) ) {
+      offset = (t->base.memBlock->ofs + t->offsets[hwlevel]);
    }
+   else {
+      unsigned  i;
 
-
-   if (in_use) {
-      t = (mgaTextureObjectPtr) calloc(1, sizeof(*t));
-      if (!t) return;
-
-      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;
+      offset = t->base.memBlock->ofs;
+      for ( i = 0 ; i < hwlevel ; i++ ) {
+	 offset += (t->offsets[1] >> (i * 2));
       }
-      insert_at_head( &(mmesa->TexObjList[heap]), t );
-   }
-}
-
-
-void mgaAgeTextures( mgaContextPtr mmesa, int heap )
-{
-   MGASAREAPrivPtr 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 switching texturing schemes, then the SAREA might not
-       * have been properly cleared, so we need to reset the
-       * global texture LRU.
+      /* Each mipmap must be DWORD aligned.
        */
-      if ( idx * sz > mmesa->mgaScreen->textureSize[heap] ) {
-         nr = MGA_NR_TEX_REGIONS;
-         break;
-      }
-
-      if (sarea->texList[heap][idx].age > mmesa->texAge[heap]) {
-        mgaTexturesGone(mmesa, heap, idx * sz, sz,
-                        sarea->texList[heap][idx].in_use);
-      }
-   }
-
-   if (nr == MGA_NR_TEX_REGIONS) {
-      mgaTexturesGone(mmesa, heap, 0,
-		      mmesa->mgaScreen->textureSize[heap], 0);
-      mgaResetGlobalLRU( mmesa, heap );
+      offset &= ~0x03;
    }
 
 
-   if (0) {
-      mgaPrintGlobalLRU( mmesa, heap );
-      mgaPrintLocalLRU( mmesa, heap );
-   }
-
-   mmesa->texAge[heap] = sarea->texAge[heap];
-   mmesa->dirty |= MGA_UPLOAD_TEX0IMAGE | MGA_UPLOAD_TEX1IMAGE;
-}
-
-/*
- * 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.
- */
-void mgaUploadSubImageLocked( mgaContextPtr mmesa,
-			      mgaTextureObjectPtr t,
-			      int level,
-			      int x, int y, int width, int height )
-{
-   int		x2;
-   int		dwords;
-   int		offset;
-   struct gl_texture_image *image;
-   int		texelBytes, texelsPerDword, texelMaccess, length;
-
-   if ( level < 0 || level >= MGA_TEX_MAXLEVELS )
-      return;
+   /* Copy the texture from system memory to a memory space that can be
+    * directly used by the hardware for texturing.
+    */
 
-   image = t->tObj->Image[level];
-   if ( !image ) return;
+   texelBytes = texImage->TexFormat->TexelBytes;
+   length = texImage->Width * texImage->Height * texelBytes;
+   if ( t->base.heap->heapId == MGA_CARD_HEAP ) {
+      unsigned  tex_offset = 0;
+      unsigned  to_copy;
 
 
-   if (image->Data == 0) {
-      fprintf(stderr, "null texture image data tObj %p level %d\n",
-	      t->tObj, level);
-      return;
-   }
+      /* We may not be able to upload the entire texture in one batch due to
+       * register limits or dma buffer limits.  Split the copy up into maximum
+       * sized chunks.
+       */
 
+      offset += mmesa->mgaScreen->textureOffset[ t->base.heap->heapId ];
+      while ( length != 0 ) {
+	 mgaGetILoadBufferLocked( mmesa );
 
-   /* find the proper destination offset for this level */
-   offset = (t->MemBlock->ofs +
-	     t->offsets[level]);
-
-
-   texelBytes = t->texelBytes;
-   switch( texelBytes ) {
-   case 1:
-      texelsPerDword = 4;
-      texelMaccess = 0;
-      break;
-   case 2:
-      texelsPerDword = 2;
-      texelMaccess = 1;
-      break;
-   case 4:
-      texelsPerDword = 1;
-      texelMaccess = 2;
-      break;
-   default:
-      return;
-   }
+	 /* The kernel ILOAD ioctl requires that the lenght be an even multiple
+	  * of MGA_ILOAD_ALIGN.
+	  */
+	 length = ((length) + MGA_ILOAD_MASK) & ~MGA_ILOAD_MASK;
 
+	 to_copy = MIN2( length, MGA_BUFFER_SIZE );
+	 (void) memcpy( mmesa->iload_buffer->address,
+			(GLubyte *) texImage->Data + tex_offset, to_copy );
 
-   /* We can't do a subimage update if pitch is < 32 texels due
-    * to hardware XY addressing limits, so we will need to
-    * linearly upload all modified rows.
-    */
-   if ( image->Width < 32 ) {
-      x = 0;
-      width = image->Width * height;
-      height = 1;
-
-      /* Assume that 1x1 textures aren't going to cause a
-       * bus error if we read up to four texels from that
-       * location:
-       */
-/*        if ( width < texelsPerDword ) { */
-/*  	 width = texelsPerDword; */
-/*        } */
-   } else {
-      /* pad the size out to dwords.  The image is a pointer
-	 to the entire image, so we can safely reference
-	 outside the x,y,width,height bounds if we need to */
-      x2 = x + width;
-      x2 = (x2 + (texelsPerDword-1)) & ~(texelsPerDword-1);
-      x = (x + (texelsPerDword-1)) & ~(texelsPerDword-1);
-      width = x2 - x;
-   }
+	 if ( MGA_DEBUG & DEBUG_VERBOSE_TEXTURE )
+	     fprintf(stderr, "[%s:%d] address/size = 0x%08lx/%d\n",
+		     __FILE__, __LINE__,
+		     (long) (offset + tex_offset),
+		     to_copy );
 
-   /* 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. */
-   while ( 1 ) {
-      dwords = height * width / texelsPerDword;
-      if ( dwords * 4 <= MGA_BUFFER_SIZE ) {
-	 break;
+	 mgaFireILoadLocked( mmesa, offset + tex_offset, to_copy );
+	 tex_offset += to_copy;
+	 length -= to_copy;
       }
-
-      mgaUploadSubImageLocked( mmesa, t, level, x, y,
-			       width, height >> 1 );
-      y += ( height >> 1 );
-      height -= ( height >> 1 );
-   }
-
-   length = dwords * 4;
-
-   /* Fill in the secondary buffer with properly converted texels
-    * from the mesa buffer. */
-   /* FIXME: the sync for direct copy reduces speed.. */
-   if(t->heap == MGA_CARD_HEAP  ) {
-      mgaGetILoadBufferLocked( mmesa );
-      mgaConvertTexture( (GLuint *)mmesa->iload_buffer->address,
-			 texelBytes, image, x, y, width, height );
-      if(length < 64) length = 64;
-
-      if (0)
-	 fprintf(stderr, "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 {
+      /* FIXME: the sync for direct copy reduces speed.. */
       /* This works, is slower for uploads to card space and needs
        * additional synchronization with the dma stream.
        */
        
       UPDATE_LOCK(mmesa, DRM_LOCK_FLUSH | DRM_LOCK_QUIESCENT);
-      mgaConvertTexture( (GLuint *)
-			 (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 )
-{
-   mgaUploadSubImageLocked( mmesa,
-			    t,
-			    l,
-			    0, 0,
-			    t->tObj->Image[l]->Width,
-			    t->tObj->Image[l]->Height);
-}
-
-
-
-
-#if 0
-static void mgaMigrateTexture( mgaContextPtr mmesa, mgaTextureObjectPtr t )
-{
-	/* NOT DONE */
-}
-#endif
-
-
-static int mgaChooseTexHeap( mgaContextPtr mmesa, mgaTextureObjectPtr t )
-{
-   int freeagp, freecard;
-   int fitincard, fitinagp;
-   int totalcard, totalagp;
-   TMemBlock *b;
-
-   totalcard = totalagp = fitincard = fitinagp = freeagp = freecard = 0;
-
-   b = mmesa->texHeap[0];
-   while(b)
-   {
-     totalcard += b->size;
-     if(b->free) if(t->totalSize <= b->size)fitincard = 1;
-     b = b->next;
-   }
-
-   b = mmesa->texHeap[1];
-   while(b)
-   {
-     totalagp += b->size;
-     if(b->free)  if(t->totalSize <= b->size)fitinagp = 1;
-     b = b->next;
-   }
 
-   if(fitincard)return 0;
-   if(fitinagp)return 1;
+      memcpy( mmesa->mgaScreen->texVirtual[t->base.heap->heapId] + offset,
+	      texImage->Data, length );
 
-   if(totalcard && totalagp)
-   {
-     int ages;
-     int ratio = (totalcard > totalagp) ? totalcard / totalagp : totalagp / totalcard;
-     ages = mmesa->sarea->texAge[0] + mmesa->sarea->texAge[1];
-     if( (ages % ratio) == 0)return totalcard > totalagp ? 1 : 0;
-     else return totalcard > totalagp ? 0 : 1;
+      if ( MGA_DEBUG & DEBUG_VERBOSE_TEXTURE )
+	 fprintf(stderr, "[%s:%d] address/size = 0x%08lx/%d\n",
+		 __FILE__, __LINE__,
+		 (long) (mmesa->mgaScreen->texVirtual[t->base.heap->heapId] 
+			 + offset),
+		 length);
    }
-
-   if(totalagp) return 1;
-   return 0;
 }
 
 
+/**
+ * Upload the texture images associated with texture \a t.  This might
+ * require the allocation of texture memory.
+ * 
+ * \param mmesa Context pointer
+ * \param t Texture to be uploaded
+ */
+
 int mgaUploadTexImages( mgaContextPtr mmesa, mgaTextureObjectPtr t )
 {
-   int heap;
    int i;
    int ofs;
 
-   heap = t->heap = mgaChooseTexHeap( mmesa, t );
 
-   /* Do we need to eject LRU texture objects?
-    */
-   if (!t->MemBlock) {
-      while (1)
-      {
-	 mgaTextureObjectPtr tmp = mmesa->TexObjList[heap].prev;
-
-	 t->MemBlock = mmAllocMem( mmesa->texHeap[heap],
-				   t->totalSize,
-				   6, 0 );
-	 if (t->MemBlock)
-	    break;
-
-	 if (mmesa->TexObjList[heap].prev->bound) {
-	    fprintf(stderr, "Hit bound texture in upload\n");
-	    return -1;
-	 }
+   if ( (t == NULL) || (t->base.totalSize == 0) )
+      return 0;
 
-	 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;
-	 }
+   LOCK_HARDWARE( mmesa );
 
-	 mgaDestroyTexObj( mmesa, tmp );
+   if (t->base.memBlock == NULL ) {
+      int heap;
+
+      heap = driAllocateTexture( mmesa->texture_heaps, mmesa->nr_heaps,
+				 (driTextureObject *) t );
+      if ( heap == -1 ) {
+	 UNLOCK_HARDWARE( mmesa );
+	 return -1;
       }
 
-      ofs = t->MemBlock->ofs
-	 + mmesa->mgaScreen->textureOffset[heap]
-	 ;
+      ofs = mmesa->mgaScreen->textureOffset[ heap ]
+	   + t->base.memBlock->ofs;
 
-      t->setup.texorg  = ofs;
-      t->setup.texorg1 = ofs + t->offsets[1];
-      t->setup.texorg2 = ofs + t->offsets[2];
-      t->setup.texorg3 = ofs + t->offsets[3];
-      t->setup.texorg4 = ofs + t->offsets[4];
+      if ( MGA_IS_G200(mmesa) ) {
+	 t->setup.texorg  = ofs;
+	 t->setup.texorg1 = ofs + t->offsets[1];
+	 t->setup.texorg2 = ofs + t->offsets[2];
+	 t->setup.texorg3 = ofs + t->offsets[3];
+	 t->setup.texorg4 = ofs + t->offsets[4];
+      }
+      else {
+	 t->setup.texorg  = ofs | TO_texorgoffsetsel;
+	 t->setup.texorg1 = t->offsets[1];
+	 t->setup.texorg2 = 0;
+	 t->setup.texorg3 = 0;
+	 t->setup.texorg4 = 0;
+      }
 
       mmesa->dirty |= MGA_UPLOAD_CONTEXT;
    }
 
    /* Let the world know we've used this memory recently.
     */
-   mgaUpdateTexLRU( mmesa, t );
-
+   driUpdateTextureLRU( (driTextureObject *) t );
 
-   if (MGA_DEBUG&DEBUG_VERBOSE_LRU)
-      fprintf(stderr, "dispatch age: %d age freed memory: %d\n",
+   if (MGA_DEBUG&DEBUG_VERBOSE_TEXTURE)
+      fprintf(stderr, "[%s:%d] dispatch age: %d age freed memory: %d\n",
+	      __FILE__, __LINE__,
 	      GET_DISPATCH_AGE(mmesa), mmesa->dirtyAge);
 
    if (mmesa->dirtyAge >= GET_DISPATCH_AGE(mmesa))
       mgaWaitAgeLocked( mmesa, mmesa->dirtyAge );
 
-   if (t->dirty_images) {
-      if (MGA_DEBUG&DEBUG_VERBOSE_LRU)
-	 fprintf(stderr, "*");
+   if (t->base.dirty_images[0]) {
+      const int numLevels = t->base.lastLevel - t->base.firstLevel + 1;
 
-      for (i = 0 ; i <= t->lastLevel ; i++)
-	 if (t->dirty_images & (1<<i))
-	    mgaUploadTexLevel( mmesa, t, i );
+      if (MGA_DEBUG&DEBUG_VERBOSE_TEXTURE)
+	 fprintf(stderr, "[%s:%d] dirty_images[0] = 0x%04x\n",
+		 __FILE__, __LINE__, t->base.dirty_images[0] );
+
+      for (i = 0 ; i < numLevels ; i++) {
+	 if ( (t->base.dirty_images[0] & (1U << i)) != 0 ) {
+	    mgaUploadSubImage( mmesa, t, i );
+	 }
+      }
+      t->base.dirty_images[0] = 0;
    }
 
 
-   t->dirty_images = 0;
+   UNLOCK_HARDWARE( mmesa );
+
    return 0;
 }
diff --git a/src/mesa/drivers/dri/mga/mgatris.c b/src/mesa/drivers/dri/mga/mgatris.c
index e47cfc171fd..054c7f0635d 100644
--- a/src/mesa/drivers/dri/mga/mgatris.c
+++ b/src/mesa/drivers/dri/mga/mgatris.c
@@ -26,9 +26,6 @@
  */
 /* $XFree86: xc/lib/GL/mesa/src/drv/mga/mgatris.c,v 1.10 2002/10/30 12:51:36 alanh Exp $ */
 
-#include <stdio.h>
-#include <math.h>
-
 #include "mtypes.h"
 #include "macros.h"
 #include "colormac.h"
@@ -676,15 +673,6 @@ static void mgaFastRenderClippedPoly( GLcontext *ctx, const GLuint *elts,
 /**********************************************************************/
 
 
-
-#define _MGA_NEW_RENDERSTATE (_DD_NEW_LINE_STIPPLE |		\
-			       _DD_NEW_TRI_UNFILLED |		\
-			       _DD_NEW_TRI_LIGHT_TWOSIDE |	\
-			       _DD_NEW_TRI_OFFSET |		\
-			       _DD_NEW_TRI_STIPPLE |		\
-			       _NEW_POLYGONSTIPPLE)
-
-
 #define POINT_FALLBACK (DD_POINT_SMOOTH)
 #define LINE_FALLBACK (DD_LINE_SMOOTH | DD_LINE_STIPPLE)
 #define TRI_FALLBACK (DD_TRI_SMOOTH | DD_TRI_UNFILLED)
@@ -693,7 +681,7 @@ static void mgaFastRenderClippedPoly( GLcontext *ctx, const GLuint *elts,
 #define ANY_RASTER_FLAGS (DD_FLATSHADE|DD_TRI_LIGHT_TWOSIDE|DD_TRI_OFFSET| \
                           DD_TRI_UNFILLED)
 
-static void mgaChooseRenderState(GLcontext *ctx)
+void mgaChooseRenderState(GLcontext *ctx)
 {
    TNLcontext *tnl = TNL_CONTEXT(ctx);
    mgaContextPtr mmesa = MGA_CONTEXT(ctx);
@@ -759,36 +747,6 @@ static void mgaChooseRenderState(GLcontext *ctx)
 /**********************************************************************/
 
 
-static void mgaRunPipeline( GLcontext *ctx )
-{
-   mgaContextPtr mmesa = MGA_CONTEXT(ctx);
-
-   if (mmesa->new_state) {
-      mgaDDUpdateHwState( ctx );
-   }
-
-   if (!mmesa->Fallback && mmesa->new_gl_state) {
-      if (mmesa->new_gl_state & _MGA_NEW_RASTERSETUP)
-	 mgaChooseVertexState( ctx );
-      
-      if (mmesa->new_gl_state & _MGA_NEW_RENDERSTATE)
-	 mgaChooseRenderState( ctx );
-      
-      mmesa->new_gl_state = 0;
-
-      /* Circularity: mgaDDUpdateHwState can affect mmesa->Fallback,
-       * but mgaChooseVertexState can affect mmesa->new_state.  Hence
-       * the second check.  (Fix this...)
-       */
-      if (mmesa->new_state) {
-	 mgaDDUpdateHwState( ctx );
-      }
-   }
-
-   _tnl_run_pipeline( ctx );
-}
-
-
 static GLenum reduced_prim[GL_POLYGON+1] = {
    GL_POINTS,
    GL_LINES,
@@ -812,10 +770,14 @@ void mgaRasterPrimitive( GLcontext *ctx, GLenum prim, GLuint hwprim )
    mgaContextPtr mmesa = MGA_CONTEXT( ctx );
 
    FLUSH_BATCH( mmesa );
+
+   /* Update culling */
+   if (mmesa->raster_primitive != prim)
+      mmesa->dirty |= MGA_UPLOAD_CONTEXT;
+
    mmesa->raster_primitive = prim;
 /*     mmesa->hw_primitive = hwprim; */
    mmesa->hw_primitive = MGA_WA_TRIANGLES; /* disable mgarender.c for now */
-   mgaUpdateCull(ctx);   
 
    if (ctx->Polygon.StippleFlag && mmesa->haveHwStipple)
    {
@@ -864,6 +826,28 @@ static void mgaRenderFinish( GLcontext *ctx )
 /*               Manage total rasterization fallbacks                 */
 /**********************************************************************/
 
+static const char * const fallbackStrings[] = {
+   "Texture mode",
+   "glDrawBuffer(GL_FRONT_AND_BACK)",
+   "read buffer",
+   "LogicOp != GL_COPY",
+   "glRenderMode(selection or feedback)",
+   "No hardware stencil",
+   "glDepthFunc( GL_NEVER )",
+   "Mixing GL_CLAMP_TO_EDGE and GL_CLAMP"
+};
+
+static const char *getFallbackString(GLuint bit)
+{
+   int i = 0;
+   while (bit > 1) {
+      i++;
+      bit >>= 1;
+   }
+   return fallbackStrings[i];
+}
+
+
 void mgaFallback( GLcontext *ctx, GLuint bit, GLboolean mode )
 {
    TNLcontext *tnl = TNL_CONTEXT(ctx);
@@ -876,6 +860,10 @@ void mgaFallback( GLcontext *ctx, GLuint bit, GLboolean mode )
 	 FLUSH_BATCH(mmesa);
 	 _swsetup_Wakeup( ctx );
 	 mmesa->RenderIndex = ~0;
+         if (MGA_DEBUG & DEBUG_VERBOSE_FALLBACK) {
+            fprintf(stderr, "MGA begin rasterization fallback: 0x%x %s\n",
+                    bit, getFallbackString(bit));
+         }
       }
    }
    else {
@@ -886,8 +874,12 @@ void mgaFallback( GLcontext *ctx, GLuint bit, GLboolean mode )
 	 tnl->Driver.Render.PrimitiveNotify = mgaRenderPrimitive;
 	 tnl->Driver.Render.Finish = mgaRenderFinish;
 	 tnl->Driver.Render.BuildVertices = mgaBuildVertices;
-	 mmesa->new_gl_state |= (_MGA_NEW_RENDERSTATE |
-				 _MGA_NEW_RASTERSETUP);
+	 mmesa->NewGLState |= (_MGA_NEW_RENDERSTATE |
+			       _MGA_NEW_RASTERSETUP);
+         if (MGA_DEBUG & DEBUG_VERBOSE_FALLBACK) {
+            fprintf(stderr, "MGA end rasterization fallback: 0x%x %s\n",
+                    bit, getFallbackString(bit));
+         }
       }
    }
 }
@@ -905,7 +897,6 @@ void mgaDDInitTriFuncs( GLcontext *ctx )
 
    mmesa->RenderIndex = ~0;
 	
-   tnl->Driver.RunPipeline               = mgaRunPipeline;
    tnl->Driver.Render.Start              = mgaCheckTexSizes;
    tnl->Driver.Render.Finish             = mgaRenderFinish; 
    tnl->Driver.Render.PrimitiveNotify    = mgaRenderPrimitive;
diff --git a/src/mesa/drivers/dri/mga/mgatris.h b/src/mesa/drivers/dri/mga/mgatris.h
index 88eda91e13b..a8c0b8936b7 100644
--- a/src/mesa/drivers/dri/mga/mgatris.h
+++ b/src/mesa/drivers/dri/mga/mgatris.h
@@ -32,12 +32,17 @@
 #include "mtypes.h"
 
 extern void mgaDDInitTriFuncs( GLcontext *ctx );
-
+extern void mgaChooseRenderState( GLcontext *ctx );
 extern void mgaRasterPrimitive( GLcontext *ctx, GLenum prim, GLuint hwprim );
 
 extern void mgaFallback( GLcontext *ctx, GLuint bit, GLboolean mode );
 #define FALLBACK( ctx, bit, mode ) mgaFallback( ctx, bit, mode )
 
-
+#define _MGA_NEW_RENDERSTATE (_DD_NEW_LINE_STIPPLE |		\
+			       _DD_NEW_TRI_UNFILLED |		\
+			       _DD_NEW_TRI_LIGHT_TWOSIDE |	\
+			       _DD_NEW_TRI_OFFSET |		\
+			       _DD_NEW_TRI_STIPPLE |		\
+			       _NEW_POLYGONSTIPPLE)
 
 #endif
diff --git a/src/mesa/drivers/dri/mga/mgavb.c b/src/mesa/drivers/dri/mga/mgavb.c
index d354fa43d2e..34906865e8d 100644
--- a/src/mesa/drivers/dri/mga/mgavb.c
+++ b/src/mesa/drivers/dri/mga/mgavb.c
@@ -24,7 +24,7 @@
  * Authors:
  *    Keith Whitwell <[email protected]>
  */
-/* $XFree86: xc/lib/GL/mesa/src/drv/mga/mgavb.c,v 1.15 2003/03/26 20:43:49 tsi Exp $ */
+/* $XFree86: xc/lib/GL/mesa/src/drv/mga/mgavb.c,v 1.14 2002/10/30 12:51:36 alanh Exp $ */
 
 #include "mgacontext.h"
 #include "mgavb.h"
@@ -34,18 +34,14 @@
 
 #include "glheader.h"
 #include "mtypes.h"
-/*#include "mem.h" */
+#include "imports.h"
 #include "macros.h"
 #include "colormac.h"
-/*#include "mmath.h"*/
 
 #include "tnl/t_context.h"
 #include "swrast_setup/swrast_setup.h"
 #include "swrast/swrast.h"
 
-#include <stdio.h>
-#include <stdlib.h>
-
 
 #define MGA_TEX1_BIT       0x1
 #define MGA_TEX0_BIT       0x2	
@@ -93,7 +89,7 @@ static struct {
 #define GET_VIEWPORT_MAT() mmesa->hw_viewport
 #define GET_TEXSOURCE(n)  mmesa->tmu_source[n]
 #define GET_VERTEX_FORMAT() mmesa->vertex_format
-#define GET_VERTEX_STORE() ((GLubyte *)mmesa->verts)
+#define GET_VERTEX_STORE() mmesa->verts
 #define GET_VERTEX_STRIDE_SHIFT() mmesa->vertex_stride_shift
 #define GET_UBYTE_COLOR_STORE() &mmesa->UbyteColor
 #define GET_UBYTE_SPEC_COLOR_STORE() &mmesa->UbyteSecondaryColor
@@ -407,15 +403,18 @@ void mgaChooseVertexState( GLcontext *ctx )
    if (ctx->Fog.Enabled) 
       ind |= MGA_FOG_BIT;
    
-   if (ctx->Texture.Unit[1]._ReallyEnabled & (TEXTURE_1D_BIT|TEXTURE_2D_BIT)) {
-      if (ctx->Texture.Unit[0]._ReallyEnabled & (TEXTURE_1D_BIT|TEXTURE_2D_BIT)) {
+   if (ctx->Texture._EnabledUnits & 0x2) {
+      /* unit 1 enabled */
+      if (ctx->Texture._EnabledUnits & 0x1) {
+         /* unit 0 enabled */
 	 ind |= MGA_TEX1_BIT|MGA_TEX0_BIT;
       }
       else {
 	 ind |= MGA_TEX0_BIT;
       }
    }
-   else if (ctx->Texture.Unit[0]._ReallyEnabled & (TEXTURE_1D_BIT|TEXTURE_2D_BIT)) {
+   else if (ctx->Texture._EnabledUnits & 0x1) {
+      /* unit 0 enabled */
       ind |= MGA_TEX0_BIT;
    }
    
@@ -431,7 +430,6 @@ void mgaChooseVertexState( GLcontext *ctx )
 
    if (setup_tab[ind].vertex_format != mmesa->vertex_format) {
       FLUSH_BATCH(mmesa);      
-      mmesa->new_state |= MGA_NEW_WARP;
       mmesa->dirty |= MGA_UPLOAD_PIPE;
       mmesa->vertex_format = setup_tab[ind].vertex_format;
       mmesa->vertex_size = setup_tab[ind].vertex_size;
@@ -458,7 +456,7 @@ void mgaInitVB( GLcontext *ctx )
    mgaContextPtr mmesa = MGA_CONTEXT(ctx);
    GLuint size = TNL_CONTEXT(ctx)->vb.Size;
 
-   mmesa->verts = (char *)ALIGN_MALLOC(size * sizeof(mgaVertex), 32);
+   mmesa->verts = ALIGN_MALLOC(size * sizeof(mgaVertex), 32);
 
    {
       static int firsttime = 1;
@@ -468,7 +466,6 @@ void mgaInitVB( GLcontext *ctx )
       }
    }
 
-   mmesa->new_state |= MGA_NEW_WARP;
    mmesa->dirty |= MGA_UPLOAD_PIPE;
    mmesa->vertex_format = setup_tab[0].vertex_format;
    mmesa->vertex_size = setup_tab[0].vertex_size;
diff --git a/src/mesa/drivers/dri/mga/server/mga_common.h b/src/mesa/drivers/dri/mga/server/mga_common.h
index 90f6b37f4e6..dcc260a1a59 100644
--- a/src/mesa/drivers/dri/mga/server/mga_common.h
+++ b/src/mesa/drivers/dri/mga/server/mga_common.h
@@ -146,7 +146,7 @@ typedef struct {
 
 typedef struct {
 	int param;
-	int *value;
+	void *value;
 } drmMGAGetParam;
 
 #endif