Before calling _mesa_create_context(), initialize a dd_function_table struct

by calling _mesa_init_driver_functions() and then plugging in the driver-
specific functions.
In particular, make sure ctx->Driver.NewTextureObject points to the
appropriate driver function so that _all_ texture objects are augmented
with the driver-specific data.
Put in a bunch of assertions in the texture-related driver functions that
texObj->DriverData is valid.  Remove old dead code in near future.

10 files changed, 165 insertions, 113 deletions

diff --git a/src/mesa/drivers/dri/r200/Makefile.solo b/src/mesa/drivers/dri/r200/Makefile.solo
index e3fe696709b..b0959b2b7f8 100644
--- a/src/mesa/drivers/dri/r200/Makefile.solo
+++ b/src/mesa/drivers/dri/r200/Makefile.solo
@@ -28,6 +28,7 @@ DRIVER_SOURCES = r200_context.c \
 		 r200_screen.c \
 		 r200_state.c \
 		 r200_state_init.c \
+		 ../../common/driverfuncs.c \
 		 ../common/mm.c \
 		 ../common/utils.c \
 		 ../common/texmem.c \
diff --git a/src/mesa/drivers/dri/r200/r200_context.c b/src/mesa/drivers/dri/r200/r200_context.c
index efa658717b8..f8ab8d36972 100644
--- a/src/mesa/drivers/dri/r200/r200_context.c
+++ b/src/mesa/drivers/dri/r200/r200_context.c
@@ -49,6 +49,8 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "tnl/tnl.h"
 #include "tnl/t_pipeline.h"
 
+#include "drivers/common/driverfuncs.h"
+
 #include "r200_context.h"
 #include "r200_ioctl.h"
 #include "r200_state.h"
@@ -186,15 +188,15 @@ static const struct tnl_pipeline_stage *r200_pipeline[] = {
 
 /* Initialize the driver's misc functions.
  */
-static void r200InitDriverFuncs( GLcontext *ctx )
+static void r200InitDriverFuncs( struct dd_function_table *functions )
 {
-    ctx->Driver.GetBufferSize		= r200GetBufferSize;
-    ctx->Driver.ResizeBuffers           = _swrast_alloc_buffers;
-    ctx->Driver.GetString		= r200GetString;
+    functions->GetBufferSize		= r200GetBufferSize;
+    functions->ResizeBuffers           = _swrast_alloc_buffers;
+    functions->GetString		= r200GetString;
 
-    ctx->Driver.Error			= NULL;
-    ctx->Driver.DrawPixels		= NULL;
-    ctx->Driver.Bitmap			= NULL;
+    functions->Error			= NULL;
+    functions->DrawPixels		= NULL;
+    functions->Bitmap			= NULL;
 }
 
 static const struct dri_debug_control debug_control[] =
@@ -227,7 +229,7 @@ get_ust_nop( uint64_t * ust )
 }
 
 
-/* Create the device specific context.
+/* Create the device specific rendering context.
  */
 GLboolean r200CreateContext( const __GLcontextModes *glVisual,
 			     __DRIcontextPrivate *driContextPriv,
@@ -235,6 +237,7 @@ GLboolean r200CreateContext( const __GLcontextModes *glVisual,
 {
    __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv;
    r200ScreenPtr screen = (r200ScreenPtr)(sPriv->private);
+   struct dd_function_table functions;
    r200ContextPtr rmesa;
    GLcontext *ctx, *shareCtx;
    int i;
@@ -249,12 +252,31 @@ GLboolean r200CreateContext( const __GLcontextModes *glVisual,
    if ( !rmesa )
       return GL_FALSE;
 
-   /* Allocate the Mesa context */
+   /* Parse configuration files.
+    * Do this here so that initialMaxAnisotropy is set before we create
+    * the default textures.
+    */
+   driParseConfigFiles (&rmesa->optionCache, &screen->optionCache,
+			screen->driScreen->myNum, "r200");
+   rmesa->initialMaxAnisotropy = driQueryOptionf(&rmesa->optionCache,
+                                                 "def_max_anisotropy");
+
+   /* Init default driver functions then plug in our R200-specific functions
+    * (the texture functions are especially important)
+    */
+   _mesa_init_driver_functions(&functions);
+   r200InitDriverFuncs(&functions);
+   r200InitIoctlFuncs(&functions);
+   r200InitStateFuncs(&functions);
+   r200InitTextureFuncs(&functions);
+
+   /* Allocate and initialize the Mesa context */
    if (sharedContextPrivate)
       shareCtx = ((r200ContextPtr) sharedContextPrivate)->glCtx;
    else
       shareCtx = NULL;
-   rmesa->glCtx = _mesa_create_context(glVisual, shareCtx, (void *) rmesa, GL_TRUE);
+   rmesa->glCtx = _mesa_create_context(glVisual, shareCtx,
+                                       &functions, (void *) rmesa);
    if (!rmesa->glCtx) {
       FREE(rmesa);
       return GL_FALSE;
@@ -270,10 +292,6 @@ GLboolean r200CreateContext( const __GLcontextModes *glVisual,
    rmesa->dri.fd = sPriv->fd;
    rmesa->dri.drmMinor = sPriv->drmMinor;
 
-   /* Parse configuration files */
-   driParseConfigFiles (&rmesa->optionCache, &screen->optionCache,
-			screen->driScreen->myNum, "r200");
-
    rmesa->r200Screen = screen;
    rmesa->sarea = (RADEONSAREAPrivPtr)((GLubyte *)sPriv->pSAREA +
 				       screen->sarea_priv_offset);
@@ -285,6 +303,7 @@ GLboolean r200CreateContext( const __GLcontextModes *glVisual,
    make_empty_list( & rmesa->swapped );
 
    rmesa->nr_heaps = 1 /* screen->numTexHeaps */ ;
+   assert(rmesa->nr_heaps < R200_NR_TEX_HEAPS);
    for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
       rmesa->texture_heaps[i] = driCreateTextureHeap( i, rmesa,
 	    screen->texSize[i],
@@ -381,15 +400,25 @@ GLboolean r200CreateContext( const __GLcontextModes *glVisual,
    if (rmesa->r200Screen->drmSupportsCubeMaps)
       _mesa_enable_extension( ctx, "GL_ARB_texture_cube_map" );
 
+#if 0
    r200InitDriverFuncs( ctx );
    r200InitIoctlFuncs( ctx );
    r200InitStateFuncs( ctx );
-   r200InitSpanFuncs( ctx );
-   r200InitPixelFuncs( ctx );
    r200InitTextureFuncs( ctx );
+#endif
+   /* plug in a few more device driver functions */
+   /* XXX these should really go right after _mesa_init_driver_functions() */
+   r200InitPixelFuncs( ctx );
+   r200InitSpanFuncs( ctx );
+   r200InitTnlFuncs( ctx );
    r200InitState( rmesa );
    r200InitSwtcl( ctx );
 
+   /* used to be in r200InitTextureFuncs() */
+   driInitTextureObjects( ctx, & rmesa->swapped,
+			  DRI_TEXMGR_DO_TEXTURE_1D
+			  | DRI_TEXMGR_DO_TEXTURE_2D );
+
    fthrottle_mode = driQueryOptioni(&rmesa->optionCache, "fthrottle_mode");
    rmesa->iw.irq_seq = -1;
    rmesa->irqsEmitted = 0;
diff --git a/src/mesa/drivers/dri/r200/r200_context.h b/src/mesa/drivers/dri/r200/r200_context.h
index 066803f2367..029dfde6642 100644
--- a/src/mesa/drivers/dri/r200/r200_context.h
+++ b/src/mesa/drivers/dri/r200/r200_context.h
@@ -781,7 +781,7 @@ struct r200_context {
    driTexHeap          * texture_heaps[ R200_NR_TEX_HEAPS ];
    driTextureObject      swapped;
    int                   texture_depth;
-
+   float                 initialMaxAnisotropy;
 
    /* Rasterization and vertex state:
     */
diff --git a/src/mesa/drivers/dri/r200/r200_ioctl.c b/src/mesa/drivers/dri/r200/r200_ioctl.c
index 2abaa5a4281..2b5dd88cad6 100644
--- a/src/mesa/drivers/dri/r200/r200_ioctl.c
+++ b/src/mesa/drivers/dri/r200/r200_ioctl.c
@@ -917,10 +917,10 @@ GLuint r200GartOffsetFromVirtual( r200ContextPtr rmesa, const GLvoid *pointer )
 
 
 
-void r200InitIoctlFuncs( GLcontext *ctx )
+void r200InitIoctlFuncs( struct dd_function_table *functions )
 {
-    ctx->Driver.Clear = r200Clear;
-    ctx->Driver.Finish = r200Finish;
-    ctx->Driver.Flush = r200Flush;
+    functions->Clear = r200Clear;
+    functions->Finish = r200Finish;
+    functions->Flush = r200Flush;
 }
 
diff --git a/src/mesa/drivers/dri/r200/r200_ioctl.h b/src/mesa/drivers/dri/r200/r200_ioctl.h
index a76dbd2ad12..3c3ad3db547 100644
--- a/src/mesa/drivers/dri/r200/r200_ioctl.h
+++ b/src/mesa/drivers/dri/r200/r200_ioctl.h
@@ -103,7 +103,7 @@ extern void r200Flush( GLcontext *ctx );
 extern void r200Finish( GLcontext *ctx );
 extern void r200WaitForIdleLocked( r200ContextPtr rmesa );
 extern void r200WaitForVBlank( r200ContextPtr rmesa );
-extern void r200InitIoctlFuncs( GLcontext *ctx );
+extern void r200InitIoctlFuncs( struct dd_function_table *functions );
 
 extern void *r200AllocateMemoryMESA( GLsizei size, GLfloat readfreq,
 				   GLfloat writefreq, GLfloat priority );
diff --git a/src/mesa/drivers/dri/r200/r200_state.c b/src/mesa/drivers/dri/r200/r200_state.c
index 8b945a01478..f9501fd62b3 100644
--- a/src/mesa/drivers/dri/r200/r200_state.c
+++ b/src/mesa/drivers/dri/r200/r200_state.c
@@ -2146,57 +2146,61 @@ static void r200WrapRunPipeline( GLcontext *ctx )
 
 /* Initialize the driver's state functions.
  */
-void r200InitStateFuncs( GLcontext *ctx )
+void r200InitStateFuncs( struct dd_function_table *functions )
 {
-   ctx->Driver.UpdateState		= r200InvalidateState;
-   ctx->Driver.LightingSpaceChange      = r200LightingSpaceChange;
-
-   ctx->Driver.DrawBuffer		= r200DrawBuffer;
-   ctx->Driver.ReadBuffer		= r200ReadBuffer;
-
-   ctx->Driver.AlphaFunc		= r200AlphaFunc;
-   ctx->Driver.BlendEquation		= r200BlendEquation;
-   ctx->Driver.BlendFunc		= r200BlendFunc;
-   ctx->Driver.BlendFuncSeparate	= r200BlendFuncSeparate;
-   ctx->Driver.ClearColor		= r200ClearColor;
-   ctx->Driver.ClearDepth		= NULL;
-   ctx->Driver.ClearIndex		= NULL;
-   ctx->Driver.ClearStencil		= r200ClearStencil;
-   ctx->Driver.ClipPlane		= r200ClipPlane;
-   ctx->Driver.ColorMask		= r200ColorMask;
-   ctx->Driver.CullFace			= r200CullFace;
-   ctx->Driver.DepthFunc		= r200DepthFunc;
-   ctx->Driver.DepthMask		= r200DepthMask;
-   ctx->Driver.DepthRange		= r200DepthRange;
-   ctx->Driver.Enable			= r200Enable;
-   ctx->Driver.Fogfv			= r200Fogfv;
-   ctx->Driver.FrontFace		= r200FrontFace;
-   ctx->Driver.Hint			= NULL;
-   ctx->Driver.IndexMask		= NULL;
-   ctx->Driver.LightModelfv		= r200LightModelfv;
-   ctx->Driver.Lightfv			= r200Lightfv;
-   ctx->Driver.LineStipple              = r200LineStipple;
-   ctx->Driver.LineWidth                = r200LineWidth;
-   ctx->Driver.LogicOpcode		= r200LogicOpCode;
-   ctx->Driver.PolygonMode		= r200PolygonMode;
-   ctx->Driver.PolygonOffset		= r200PolygonOffset;
-   ctx->Driver.PolygonStipple		= r200PolygonStipple;
-   ctx->Driver.PointSize                = r200PointSize;
-   ctx->Driver.RenderMode		= r200RenderMode;
-   ctx->Driver.Scissor			= r200Scissor;
-   ctx->Driver.ShadeModel		= r200ShadeModel;
-   ctx->Driver.StencilFunc		= r200StencilFunc;
-   ctx->Driver.StencilMask		= r200StencilMask;
-   ctx->Driver.StencilOp		= r200StencilOp;
-   ctx->Driver.Viewport			= r200Viewport;
+   functions->UpdateState		= r200InvalidateState;
+   functions->LightingSpaceChange	= r200LightingSpaceChange;
+
+   functions->DrawBuffer		= r200DrawBuffer;
+   functions->ReadBuffer		= r200ReadBuffer;
+
+   functions->AlphaFunc			= r200AlphaFunc;
+   functions->BlendEquation		= r200BlendEquation;
+   functions->BlendFunc			= r200BlendFunc;
+   functions->BlendFuncSeparate		= r200BlendFuncSeparate;
+   functions->ClearColor		= r200ClearColor;
+   functions->ClearDepth		= NULL;
+   functions->ClearIndex		= NULL;
+   functions->ClearStencil		= r200ClearStencil;
+   functions->ClipPlane			= r200ClipPlane;
+   functions->ColorMask			= r200ColorMask;
+   functions->CullFace			= r200CullFace;
+   functions->DepthFunc			= r200DepthFunc;
+   functions->DepthMask			= r200DepthMask;
+   functions->DepthRange		= r200DepthRange;
+   functions->Enable			= r200Enable;
+   functions->Fogfv			= r200Fogfv;
+   functions->FrontFace			= r200FrontFace;
+   functions->Hint			= NULL;
+   functions->IndexMask			= NULL;
+   functions->LightModelfv		= r200LightModelfv;
+   functions->Lightfv			= r200Lightfv;
+   functions->LineStipple		= r200LineStipple;
+   functions->LineWidth			= r200LineWidth;
+   functions->LogicOpcode		= r200LogicOpCode;
+   functions->PolygonMode		= r200PolygonMode;
+   functions->PolygonOffset		= r200PolygonOffset;
+   functions->PolygonStipple		= r200PolygonStipple;
+   functions->PointSize			= r200PointSize;
+   functions->RenderMode		= r200RenderMode;
+   functions->Scissor			= r200Scissor;
+   functions->ShadeModel		= r200ShadeModel;
+   functions->StencilFunc		= r200StencilFunc;
+   functions->StencilMask		= r200StencilMask;
+   functions->StencilOp			= r200StencilOp;
+   functions->Viewport			= r200Viewport;
 
    /* Swrast hooks for imaging extensions:
     */
-   ctx->Driver.CopyColorTable		= _swrast_CopyColorTable;
-   ctx->Driver.CopyColorSubTable	= _swrast_CopyColorSubTable;
-   ctx->Driver.CopyConvolutionFilter1D	= _swrast_CopyConvolutionFilter1D;
-   ctx->Driver.CopyConvolutionFilter2D	= _swrast_CopyConvolutionFilter2D;
+   functions->CopyColorTable		= _swrast_CopyColorTable;
+   functions->CopyColorSubTable		= _swrast_CopyColorSubTable;
+   functions->CopyConvolutionFilter1D	= _swrast_CopyConvolutionFilter1D;
+   functions->CopyConvolutionFilter2D	= _swrast_CopyConvolutionFilter2D;
+}
+
 
+void r200InitTnlFuncs( GLcontext *ctx )
+{
    TNL_CONTEXT(ctx)->Driver.NotifyMaterialChange = r200UpdateMaterial;
    TNL_CONTEXT(ctx)->Driver.RunPipeline = r200WrapRunPipeline;
 }
diff --git a/src/mesa/drivers/dri/r200/r200_state.h b/src/mesa/drivers/dri/r200/r200_state.h
index 118712d8410..9d9de8e9a28 100644
--- a/src/mesa/drivers/dri/r200/r200_state.h
+++ b/src/mesa/drivers/dri/r200/r200_state.h
@@ -41,7 +41,8 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "r200_context.h"
 
 extern void r200InitState( r200ContextPtr rmesa );
-extern void r200InitStateFuncs( GLcontext *ctx );
+extern void r200InitStateFuncs( struct dd_function_table *functions );
+extern void r200InitTnlFuncs( GLcontext *ctx );
 
 extern void r200UpdateMaterial( GLcontext *ctx );
 
diff --git a/src/mesa/drivers/dri/r200/r200_swtcl.c b/src/mesa/drivers/dri/r200/r200_swtcl.c
index 231a3ed83f2..a66879fe75d 100644
--- a/src/mesa/drivers/dri/r200/r200_swtcl.c
+++ b/src/mesa/drivers/dri/r200/r200_swtcl.c
@@ -1226,7 +1226,7 @@ void r200InitSwtcl( GLcontext *ctx )
 {
    TNLcontext *tnl = TNL_CONTEXT(ctx);
    r200ContextPtr rmesa = R200_CONTEXT(ctx);
-   GLuint size = TNL_CONTEXT(ctx)->vb.Size;
+   GLuint size = tnl->vb.Size;
    static int firsttime = 1;
 
    if (firsttime) {
diff --git a/src/mesa/drivers/dri/r200/r200_tex.c b/src/mesa/drivers/dri/r200/r200_tex.c
index 91f2fd8cce5..1990d661919 100644
--- a/src/mesa/drivers/dri/r200/r200_tex.c
+++ b/src/mesa/drivers/dri/r200/r200_tex.c
@@ -554,6 +554,7 @@ static void r200TexImage1D( GLcontext *ctx, GLenum target, GLint level,
 {
    driTextureObject * t = (driTextureObject *) texObj->DriverData;
 
+   assert(t);
    if ( t ) {
       driSwapOutTextureObject( t );
    }
@@ -616,6 +617,8 @@ static void r200TexImage2D( GLcontext *ctx, GLenum target, GLint level,
    driTextureObject * t = (driTextureObject *) texObj->DriverData;
    GLuint face;
 
+   assert(t);
+
    /* which cube face or ordinary 2D image */
    switch (target) {
    case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
@@ -683,7 +686,6 @@ static void r200TexSubImage2D( GLcontext *ctx, GLenum target, GLint level,
    driTextureObject * t = (driTextureObject *) texObj->DriverData;
    GLuint face;
 
-
    /* which cube face or ordinary 2D image */
    switch (target) {
    case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
@@ -731,6 +733,8 @@ static void r200TexImage3D( GLcontext *ctx, GLenum target, GLint level,
 {
    driTextureObject * t = (driTextureObject *) texObj->DriverData;
 
+   assert(t);
+
    if ( t ) {
       driSwapOutTextureObject( t );
    }
@@ -934,6 +938,8 @@ static void r200TexParameter( GLcontext *ctx, GLenum target,
 
 
 
+#if 0
+/* not needed anymore */
 static void r200BindTexture( GLcontext *ctx, GLenum target,
 			       struct gl_texture_object *texObj )
 {
@@ -948,6 +954,8 @@ static void r200BindTexture( GLcontext *ctx, GLenum target,
       }
    }
 }
+#endif
+
 
 static void r200DeleteTexture( GLcontext *ctx,
 				 struct gl_texture_object *texObj )
@@ -955,6 +963,8 @@ static void r200DeleteTexture( GLcontext *ctx,
    r200ContextPtr rmesa = R200_CONTEXT(ctx);
    driTextureObject * t = (driTextureObject *) texObj->DriverData;
 
+   assert(t);
+
    if ( R200_DEBUG & (DEBUG_STATE|DEBUG_TEXTURE) ) {
       fprintf( stderr, "%s( %p (target = %s) )\n", __FUNCTION__, (void *)texObj,
 	       _mesa_lookup_enum_by_nr( texObj->Target ) );
@@ -991,59 +1001,65 @@ static void r200TexGen( GLcontext *ctx,
    rmesa->recheck_texgen[unit] = GL_TRUE;
 }
 
-/* Fixup MaxAnisotropy according to user preference.
- */
-static struct gl_texture_object *r200NewTextureObject ( GLcontext *ctx,
-							GLuint name,
-							GLenum target ) {
-    struct gl_texture_object *obj;
-    obj = _mesa_new_texture_object (ctx, name, target);
-    obj->MaxAnisotropy = driQueryOptionf (&R200_CONTEXT(ctx)->optionCache,
-					  "def_max_anisotropy");
-    return obj;
-}
 
-
-void r200InitTextureFuncs( GLcontext *ctx )
+/**
+ * Allocate a new texture object.
+ * Called via ctx->Driver.NewTextureObject.
+ * Note: this function will be called during context creation to
+ * allocate the default texture objects.
+ * Fixup MaxAnisotropy according to user preference.
+ */
+static struct gl_texture_object *
+r200NewTextureObject( GLcontext *ctx, GLuint name, GLenum target )
 {
    r200ContextPtr rmesa = R200_CONTEXT(ctx);
+   struct gl_texture_object *obj;
+   driTextureObject *t;
+   obj = _mesa_new_texture_object(ctx, name, target);
+   if (!obj)
+      return NULL;
+   obj->MaxAnisotropy = rmesa->initialMaxAnisotropy;
+   t = (driTextureObject *) r200AllocTexObj( obj );
+   if (!t) {
+      _mesa_delete_texture_object(ctx, obj);
+      return NULL;
+   }
+   return obj;
+}
 
 
-   ctx->Driver.ChooseTextureFormat	= r200ChooseTextureFormat;
-   ctx->Driver.TexImage1D		= r200TexImage1D;
-   ctx->Driver.TexImage2D		= r200TexImage2D;
+void r200InitTextureFuncs( struct dd_function_table *functions )
+{
+   /* Note: we only plug in the functions we implement in the driver
+    * since _mesa_init_driver_functions() was already called.
+    */
+   functions->ChooseTextureFormat	= r200ChooseTextureFormat;
+   functions->TexImage1D		= r200TexImage1D;
+   functions->TexImage2D		= r200TexImage2D;
 #if ENABLE_HW_3D_TEXTURE
-   ctx->Driver.TexImage3D		= r200TexImage3D;
+   functions->TexImage3D		= r200TexImage3D;
 #else
-   ctx->Driver.TexImage3D		= _mesa_store_teximage3d;
+   functions->TexImage3D		= _mesa_store_teximage3d;
 #endif
-   ctx->Driver.TexSubImage1D		= r200TexSubImage1D;
-   ctx->Driver.TexSubImage2D		= r200TexSubImage2D;
+   functions->TexSubImage1D		= r200TexSubImage1D;
+   functions->TexSubImage2D		= r200TexSubImage2D;
 #if ENABLE_HW_3D_TEXTURE
-   ctx->Driver.TexSubImage3D		= r200TexSubImage3D;
+   functions->TexSubImage3D		= r200TexSubImage3D;
 #else
-   ctx->Driver.TexSubImage3D		= _mesa_store_texsubimage3d;
+   functions->TexSubImage3D		= _mesa_store_texsubimage3d;
 #endif
-   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.NewTextureObject         = r200NewTextureObject;
-   ctx->Driver.BindTexture		= r200BindTexture;
-   ctx->Driver.CreateTexture		= NULL; /* FIXME: Is this used??? */
-   ctx->Driver.DeleteTexture		= r200DeleteTexture;
-   ctx->Driver.IsTextureResident	= driIsTextureResident;
-   ctx->Driver.PrioritizeTexture	= NULL;
-   ctx->Driver.ActiveTexture		= NULL;
-   ctx->Driver.UpdateTexturePalette	= NULL;
-
-   ctx->Driver.TexEnv			= r200TexEnv;
-   ctx->Driver.TexParameter		= r200TexParameter;
-   ctx->Driver.TexGen                   = r200TexGen;
+   functions->NewTextureObject		= r200NewTextureObject;
+   /*functions->BindTexture		= r200BindTexture;*/
+   functions->DeleteTexture		= r200DeleteTexture;
+   functions->IsTextureResident		= driIsTextureResident;
+
+   functions->TexEnv			= r200TexEnv;
+   functions->TexParameter		= r200TexParameter;
+   functions->TexGen			= r200TexGen;
 
+#if 000
+   /* moved or obsolete code */
+   r200ContextPtr rmesa = R200_CONTEXT(ctx);
    driInitTextureObjects( ctx, & rmesa->swapped,
 			  DRI_TEXMGR_DO_TEXTURE_1D
 			  | DRI_TEXMGR_DO_TEXTURE_2D );
@@ -1053,4 +1069,5 @@ void r200InitTextureFuncs( GLcontext *ctx )
     * default 2D texture now. */
    ctx->Shared->Default2D->MaxAnisotropy = driQueryOptionf (&rmesa->optionCache,
 							    "def_max_anisotropy");
+#endif
 }
diff --git a/src/mesa/drivers/dri/r200/r200_tex.h b/src/mesa/drivers/dri/r200/r200_tex.h
index a4301206ed8..7c507a7fd0b 100644
--- a/src/mesa/drivers/dri/r200/r200_tex.h
+++ b/src/mesa/drivers/dri/r200/r200_tex.h
@@ -44,7 +44,7 @@ extern int r200UploadTexImages( r200ContextPtr rmesa, r200TexObjPtr t, GLuint fa
 
 extern void r200DestroyTexObj( r200ContextPtr rmesa, r200TexObjPtr t );
 
-extern void r200InitTextureFuncs( GLcontext *ctx );
+extern void r200InitTextureFuncs( struct dd_function_table *functions );
 
 #endif
 #endif /* __R200_TEX_H__ */