src/mesa/drivers/dri/r300/r300_context.c

   1 /*
   2 Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.
   3
   4 The Weather Channel (TM) funded Tungsten Graphics to develop the
   5 initial release of the Radeon 8500 driver under the XFree86 license.
   6 This notice must be preserved.
   7
   8 Permission is hereby granted, free of charge, to any person obtaining
   9 a copy of this software and associated documentation files (the
  10 "Software"), to deal in the Software without restriction, including
  11 without limitation the rights to use, copy, modify, merge, publish,
  12 distribute, sublicense, and/or sell copies of the Software, and to
  13 permit persons to whom the Software is furnished to do so, subject to
  14 the following conditions:
  15
  16 The above copyright notice and this permission notice (including the
  17 next paragraph) shall be included in all copies or substantial
  18 portions of the Software.
  19
  20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  23 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  24 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27
  28 **************************************************************************/
  29
  30 /**
  31  * \file
  32  *
  33  * \author Keith Whitwell <keith@tungstengraphics.com>
  34  *
  35  * \author Nicolai Haehnle <prefect_@gmx.net>
  36  */
  37
  38 #include "main/glheader.h"
  39 #include "main/api_arrayelt.h"
  40 #include "main/context.h"
  41 #include "main/simple_list.h"
  42 #include "main/imports.h"
  43 #include "main/matrix.h"
  44 #include "main/extensions.h"
  45 #include "main/state.h"
  46 #include "main/bufferobj.h"
  47 #include "main/texobj.h"
  48
  49 #include "swrast/swrast.h"
  50 #include "swrast_setup/swrast_setup.h"
  51 #include "vbo/vbo.h"
  52
  53 #include "tnl/tnl.h"
  54 #include "tnl/t_pipeline.h"
  55 #include "tnl/t_vp_build.h"
  56
  57 #include "drivers/common/driverfuncs.h"
  58
  59 #include "r300_context.h"
  60 #include "radeon_context.h"
  61 #include "radeon_span.h"
  62 #include "r300_cmdbuf.h"
  63 #include "r300_state.h"
  64 #include "r300_ioctl.h"
  65 #include "r300_tex.h"
  66 #include "r300_emit.h"
  67 #include "r300_swtcl.h"
  68 #include "radeon_bocs_wrapper.h"
  69
  70
  71 #include "vblank.h"
  72 #include "utils.h"
  73 #include "xmlpool.h"            /* for symbolic values of enum-type options */
  74
  75 /* hw_tcl_on derives from future_hw_tcl_on when its safe to change it. */
  76 int future_hw_tcl_on = 1;
  77 int hw_tcl_on = 1;
  78
  79 #define need_GL_VERSION_2_0
  80 #define need_GL_ARB_point_parameters
  81 #define need_GL_ARB_vertex_program
  82 #define need_GL_EXT_blend_equation_separate
  83 #define need_GL_EXT_blend_func_separate
  84 #define need_GL_EXT_blend_minmax
  85 #define need_GL_EXT_fog_coord
  86 #define need_GL_EXT_gpu_program_parameters
  87 #define need_GL_EXT_secondary_color
  88 #define need_GL_EXT_stencil_two_side
  89 #define need_GL_ATI_separate_stencil
  90 #define need_GL_NV_vertex_program
  91 #include "extension_helper.h"
  92
  93 const struct dri_extension card_extensions[] = {
  94   /* *INDENT-OFF* */
  95   {"GL_ARB_depth_texture",              NULL},
  96   {"GL_ARB_fragment_program",           NULL},
  97   {"GL_ARB_multitexture",               NULL},
  98   {"GL_ARB_point_parameters",           GL_ARB_point_parameters_functions},
  99   {"GL_ARB_shadow",                     NULL},
 100   {"GL_ARB_shadow_ambient",             NULL},
 101   {"GL_ARB_texture_border_clamp",       NULL},
 102   {"GL_ARB_texture_cube_map",           NULL},
 103   {"GL_ARB_texture_env_add",            NULL},
 104   {"GL_ARB_texture_env_combine",        NULL},
 105   {"GL_ARB_texture_env_crossbar",       NULL},
 106   {"GL_ARB_texture_env_dot3",           NULL},
 107   {"GL_ARB_texture_mirrored_repeat",    NULL},
 108   {"GL_ARB_vertex_program",             GL_ARB_vertex_program_functions},
 109   {"GL_EXT_blend_equation_separate",    GL_EXT_blend_equation_separate_functions},
 110   {"GL_EXT_blend_func_separate",        GL_EXT_blend_func_separate_functions},
 111   {"GL_EXT_blend_minmax",               GL_EXT_blend_minmax_functions},
 112   {"GL_EXT_blend_subtract",             NULL},
 113   {"GL_EXT_fog_coord",                  GL_EXT_fog_coord_functions },
 114   {"GL_EXT_gpu_program_parameters",     GL_EXT_gpu_program_parameters_functions},
 115   {"GL_EXT_secondary_color",            GL_EXT_secondary_color_functions},
 116   {"GL_EXT_shadow_funcs",               NULL},
 117   {"GL_EXT_stencil_two_side",           GL_EXT_stencil_two_side_functions},
 118   {"GL_EXT_stencil_wrap",               NULL},
 119   {"GL_EXT_texture_edge_clamp",         NULL},
 120   {"GL_EXT_texture_env_combine",        NULL},
 121   {"GL_EXT_texture_env_dot3",           NULL},
 122   {"GL_EXT_texture_filter_anisotropic", NULL},
 123   {"GL_EXT_texture_lod_bias",           NULL},
 124   {"GL_EXT_texture_mirror_clamp",       NULL},
 125   {"GL_EXT_texture_rectangle",          NULL},
 126   {"GL_ATI_separate_stencil",           GL_ATI_separate_stencil_functions},
 127   {"GL_ATI_texture_env_combine3",       NULL},
 128   {"GL_ATI_texture_mirror_once",        NULL},
 129   {"GL_MESA_pack_invert",               NULL},
 130   {"GL_MESA_ycbcr_texture",             NULL},
 131   {"GL_MESAX_texture_float",            NULL},
 132   {"GL_NV_blend_square",                NULL},
 133   {"GL_NV_vertex_program",              GL_NV_vertex_program_functions},
 134   {"GL_SGIS_generate_mipmap",           NULL},
 135   {NULL,                                NULL}
 136   /* *INDENT-ON* */
 137 };
 138
 139
 140 /**
 141  * The GL 2.0 functions are needed to make display lists work with
 142  * functions added by GL_ATI_separate_stencil.
 143  */
 144 const struct dri_extension gl_20_extension[] = {
 145   {"GL_VERSION_2_0",                    GL_VERSION_2_0_functions },
 146 };
 147
 148
 149 extern struct tnl_pipeline_stage _r300_render_stage;
 150 extern const struct tnl_pipeline_stage _r300_tcl_stage;
 151
 152 static const struct tnl_pipeline_stage *r300_pipeline[] = {
 153
 154         /* Try and go straight to t&l
 155          */
 156         &_r300_tcl_stage,
 157
 158         /* Catch any t&l fallbacks
 159          */
 160         &_tnl_vertex_transform_stage,
 161         &_tnl_normal_transform_stage,
 162         &_tnl_lighting_stage,
 163         &_tnl_fog_coordinate_stage,
 164         &_tnl_texgen_stage,
 165         &_tnl_texture_transform_stage,
 166         &_tnl_vertex_program_stage,
 167
 168         /* Try again to go to tcl?
 169          *     - no good for asymmetric-twoside (do with multipass)
 170          *     - no good for asymmetric-unfilled (do with multipass)
 171          *     - good for material
 172          *     - good for texgen
 173          *     - need to manipulate a bit of state
 174          *
 175          * - worth it/not worth it?
 176          */
 177
 178         /* Else do them here.
 179          */
 180         &_r300_render_stage,
 181         &_tnl_render_stage,     /* FALLBACK  */
 182         0,
 183 };
 184
 185 static void r300RunPipeline(GLcontext * ctx)
 186 {
 187     _mesa_lock_context_textures(ctx);
 188
 189     if (ctx->NewState)
 190         _mesa_update_state_locked(ctx);
 191
 192     _tnl_run_pipeline(ctx);
 193     _mesa_unlock_context_textures(ctx);
 194 }
 195
 196 static void r300_get_lock(radeonContextPtr rmesa)
 197 {
 198         drm_radeon_sarea_t *sarea = rmesa->sarea;
 199
 200         if (sarea->ctx_owner != rmesa->dri.hwContext) {
 201                 sarea->ctx_owner = rmesa->dri.hwContext;
 202                 if (!rmesa->radeonScreen->kernel_mm)
 203                         radeon_bo_legacy_texture_age(rmesa->radeonScreen->bom);
 204         }
 205 }
 206
 207 static void r300_vtbl_emit_cs_header(struct radeon_cs *cs, radeonContextPtr rmesa)
 208 {
 209     /* please flush pipe do all pending work */
 210     radeon_cs_write_dword(cs, cmdpacket0(rmesa->radeonScreen,
 211                                   R300_SC_SCREENDOOR, 1));
 212     radeon_cs_write_dword(cs, 0x0);
 213     radeon_cs_write_dword(cs, cmdpacket0(rmesa->radeonScreen,
 214                                   R300_SC_SCREENDOOR, 1));
 215     radeon_cs_write_dword(cs, 0x00FFFFFF);
 216     radeon_cs_write_dword(cs, cmdpacket0(rmesa->radeonScreen,
 217                                   R300_SC_HYPERZ, 1));
 218     radeon_cs_write_dword(cs, 0x0);
 219     radeon_cs_write_dword(cs, cmdpacket0(rmesa->radeonScreen,
 220                                   R300_US_CONFIG, 1));
 221     radeon_cs_write_dword(cs, 0x0);
 222     radeon_cs_write_dword(cs, cmdpacket0(rmesa->radeonScreen,
 223                                   R300_ZB_CNTL, 1));
 224     radeon_cs_write_dword(cs, 0x0);
 225     radeon_cs_write_dword(cs, cmdwait(rmesa->radeonScreen, R300_WAIT_3D));
 226     radeon_cs_write_dword(cs, cmdpacket0(rmesa->radeonScreen,
 227                                   R300_RB3D_DSTCACHE_CTLSTAT, 1));
 228     radeon_cs_write_dword(cs, R300_RB3D_DSTCACHE_CTLSTAT_DC_FLUSH_FLUSH_DIRTY_3D);
 229     radeon_cs_write_dword(cs, cmdpacket0(rmesa->radeonScreen,
 230                                   R300_ZB_ZCACHE_CTLSTAT, 1));
 231     radeon_cs_write_dword(cs, R300_ZB_ZCACHE_CTLSTAT_ZC_FLUSH_FLUSH_AND_FREE);
 232     radeon_cs_write_dword(cs, cmdwait(rmesa->radeonScreen,
 233                                R300_WAIT_3D | R300_WAIT_3D_CLEAN));
 234 }
 235
 236 static void r300_vtbl_pre_emit_atoms(radeonContextPtr radeon)
 237 {
 238         r300ContextPtr r300 = (r300ContextPtr)radeon;
 239         BATCH_LOCALS(radeon);
 240
 241         r300->vap_flush_needed = GL_TRUE;
 242
 243         cp_wait(radeon, R300_WAIT_3D | R300_WAIT_3D_CLEAN);
 244         BEGIN_BATCH_NO_AUTOSTATE(2);
 245         OUT_BATCH_REGVAL(R300_TX_INVALTAGS, R300_TX_FLUSH);
 246         END_BATCH();
 247         end_3d(radeon);
 248 }
 249
 250 static void r300_fallback(GLcontext *ctx, GLuint bit, GLboolean mode)
 251 {
 252         r300ContextPtr r300 = R300_CONTEXT(ctx);
 253         if (mode)
 254                 r300->radeon.Fallback |= bit;
 255         else
 256                 r300->radeon.Fallback &= ~bit;
 257 }
 258
 259 static void r300_init_vtbl(radeonContextPtr radeon)
 260 {
 261         radeon->vtbl.get_lock = r300_get_lock;
 262         radeon->vtbl.update_viewport_offset = r300UpdateViewportOffset;
 263         radeon->vtbl.emit_cs_header = r300_vtbl_emit_cs_header;
 264         radeon->vtbl.swtcl_flush = r300_swtcl_flush;
 265         radeon->vtbl.pre_emit_atoms = r300_vtbl_pre_emit_atoms;
 266         radeon->vtbl.fallback = r300_fallback;
 267 }
 268
 269
 270 /* Create the device specific rendering context.
 271  */
 272 GLboolean r300CreateContext(const __GLcontextModes * glVisual,
 273                             __DRIcontextPrivate * driContextPriv,
 274                             void *sharedContextPrivate)
 275 {
 276         __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv;
 277         radeonScreenPtr screen = (radeonScreenPtr) (sPriv->private);
 278         struct dd_function_table functions;
 279         r300ContextPtr r300;
 280         GLcontext *ctx;
 281         int tcl_mode;
 282
 283         assert(glVisual);
 284         assert(driContextPriv);
 285         assert(screen);
 286
 287         /* Allocate the R300 context */
 288         r300 = (r300ContextPtr) CALLOC(sizeof(*r300));
 289         if (!r300)
 290                 return GL_FALSE;
 291
 292         if (!(screen->chip_flags & RADEON_CHIPSET_TCL))
 293                 hw_tcl_on = future_hw_tcl_on = 0;
 294
 295         r300_init_vtbl(&r300->radeon);
 296         /* Parse configuration files.
 297          * Do this here so that initialMaxAnisotropy is set before we create
 298          * the default textures.
 299          */
 300         driParseConfigFiles(&r300->radeon.optionCache, &screen->optionCache,
 301                             screen->driScreen->myNum, "r300");
 302         r300->radeon.initialMaxAnisotropy = driQueryOptionf(&r300->radeon.optionCache,
 303                                                      "def_max_anisotropy");
 304
 305         /* Init default driver functions then plug in our R300-specific functions
 306          * (the texture functions are especially important)
 307          */
 308         _mesa_init_driver_functions(&functions);
 309         r300InitIoctlFuncs(&functions);
 310         r300InitStateFuncs(&functions);
 311         r300InitTextureFuncs(&functions);
 312         r300InitShaderFuncs(&functions);
 313
 314         if (!radeonInitContext(&r300->radeon, &functions,
 315                                glVisual, driContextPriv,
 316                                sharedContextPrivate)) {
 317                 FREE(r300);
 318                 return GL_FALSE;
 319         }
 320
 321         /* Init r300 context data */
 322         r300->radeon.texture_depth = driQueryOptioni(&r300->radeon.optionCache,
 323                                               "texture_depth");
 324         if (r300->radeon.texture_depth == DRI_CONF_TEXTURE_DEPTH_FB)
 325                 r300->radeon.texture_depth = (screen->cpp == 4) ?
 326                     DRI_CONF_TEXTURE_DEPTH_32 : DRI_CONF_TEXTURE_DEPTH_16;
 327
 328         /* Set the maximum texture size small enough that we can guarentee that
 329          * all texture units can bind a maximal texture and have them both in
 330          * texturable memory at once.
 331          */
 332
 333         ctx = r300->radeon.glCtx;
 334
 335         ctx->Const.MaxTextureImageUnits =
 336             driQueryOptioni(&r300->radeon.optionCache, "texture_image_units");
 337         ctx->Const.MaxTextureCoordUnits =
 338             driQueryOptioni(&r300->radeon.optionCache, "texture_coord_units");
 339         ctx->Const.MaxTextureUnits =
 340             MIN2(ctx->Const.MaxTextureImageUnits,
 341                  ctx->Const.MaxTextureCoordUnits);
 342         ctx->Const.MaxTextureMaxAnisotropy = 16.0;
 343         ctx->Const.MaxTextureLodBias = 16.0;
 344
 345         if (screen->chip_family >= CHIP_FAMILY_RV515) {
 346             ctx->Const.MaxTextureLevels = 13;
 347             ctx->Const.MaxTextureRectSize = 4096;
 348         }
 349
 350         ctx->Const.MinPointSize = 1.0;
 351         ctx->Const.MinPointSizeAA = 1.0;
 352         ctx->Const.MaxPointSize = R300_POINTSIZE_MAX;
 353         ctx->Const.MaxPointSizeAA = R300_POINTSIZE_MAX;
 354
 355         ctx->Const.MinLineWidth = 1.0;
 356         ctx->Const.MinLineWidthAA = 1.0;
 357         ctx->Const.MaxLineWidth = R300_LINESIZE_MAX;
 358         ctx->Const.MaxLineWidthAA = R300_LINESIZE_MAX;
 359
 360         /* Needs further modifications */
 361 #if 0
 362         ctx->Const.MaxArrayLockSize =
 363             ( /*512 */ RADEON_BUFFER_SIZE * 16 * 1024) / (4 * 4);
 364 #endif
 365
 366         ctx->Const.MaxDrawBuffers = 1;
 367
 368         /* Initialize the software rasterizer and helper modules.
 369          */
 370         _swrast_CreateContext(ctx);
 371         _vbo_CreateContext(ctx);
 372         _tnl_CreateContext(ctx);
 373         _swsetup_CreateContext(ctx);
 374         _swsetup_Wakeup(ctx);
 375         _ae_create_context(ctx);
 376
 377         /* Install the customized pipeline:
 378          */
 379         _tnl_destroy_pipeline(ctx);
 380         _tnl_install_pipeline(ctx, r300_pipeline);
 381
 382         /* Try and keep materials and vertices separate:
 383          */
 384 /*      _tnl_isolate_materials(ctx, GL_TRUE); */
 385
 386         /* Configure swrast and TNL to match hardware characteristics:
 387          */
 388         _swrast_allow_pixel_fog(ctx, GL_FALSE);
 389         _swrast_allow_vertex_fog(ctx, GL_TRUE);
 390         _tnl_allow_pixel_fog(ctx, GL_FALSE);
 391         _tnl_allow_vertex_fog(ctx, GL_TRUE);
 392
 393         /* currently bogus data */
 394         if (screen->chip_flags & RADEON_CHIPSET_TCL) {
 395                 ctx->Const.VertexProgram.MaxInstructions = VSF_MAX_FRAGMENT_LENGTH / 4;
 396                 ctx->Const.VertexProgram.MaxNativeInstructions =
 397                   VSF_MAX_FRAGMENT_LENGTH / 4;
 398                 ctx->Const.VertexProgram.MaxNativeAttribs = 16; /* r420 */
 399                 ctx->Const.VertexProgram.MaxTemps = 32;
 400                 ctx->Const.VertexProgram.MaxNativeTemps =
 401                   /*VSF_MAX_FRAGMENT_TEMPS */ 32;
 402                 ctx->Const.VertexProgram.MaxNativeParameters = 256;     /* r420 */
 403                 ctx->Const.VertexProgram.MaxNativeAddressRegs = 1;
 404         }
 405
 406         ctx->Const.FragmentProgram.MaxNativeTemps = PFS_NUM_TEMP_REGS;
 407         ctx->Const.FragmentProgram.MaxNativeAttribs = 11;       /* copy i915... */
 408         ctx->Const.FragmentProgram.MaxNativeParameters = PFS_NUM_CONST_REGS;
 409         ctx->Const.FragmentProgram.MaxNativeAluInstructions = PFS_MAX_ALU_INST;
 410         ctx->Const.FragmentProgram.MaxNativeTexInstructions = PFS_MAX_TEX_INST;
 411         ctx->Const.FragmentProgram.MaxNativeInstructions =
 412             PFS_MAX_ALU_INST + PFS_MAX_TEX_INST;
 413         ctx->Const.FragmentProgram.MaxNativeTexIndirections =
 414             PFS_MAX_TEX_INDIRECT;
 415         ctx->Const.FragmentProgram.MaxNativeAddressRegs = 0;    /* and these are?? */
 416         ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
 417         ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
 418
 419         driInitExtensions(ctx, card_extensions, GL_TRUE);
 420
 421         if (driQueryOptionb
 422             (&r300->radeon.optionCache, "disable_stencil_two_side"))
 423                 _mesa_disable_extension(ctx, "GL_EXT_stencil_two_side");
 424
 425         if (r300->radeon.glCtx->Mesa_DXTn
 426             && !driQueryOptionb(&r300->radeon.optionCache, "disable_s3tc")) {
 427                 _mesa_enable_extension(ctx, "GL_EXT_texture_compression_s3tc");
 428                 _mesa_enable_extension(ctx, "GL_S3_s3tc");
 429         } else
 430             if (driQueryOptionb(&r300->radeon.optionCache, "force_s3tc_enable"))
 431         {
 432                 _mesa_enable_extension(ctx, "GL_EXT_texture_compression_s3tc");
 433         }
 434
 435         r300->disable_lowimpact_fallback =
 436             driQueryOptionb(&r300->radeon.optionCache,
 437                             "disable_lowimpact_fallback");
 438
 439         radeonInitSpanFuncs( ctx );
 440         r300InitCmdBuf(r300);
 441         r300InitState(r300);
 442         if (!(screen->chip_flags & RADEON_CHIPSET_TCL))
 443                 r300InitSwtcl(ctx);
 444
 445         TNL_CONTEXT(ctx)->Driver.RunPipeline = r300RunPipeline;
 446
 447         tcl_mode = driQueryOptioni(&r300->radeon.optionCache, "tcl_mode");
 448         if (driQueryOptionb(&r300->radeon.optionCache, "no_rast")) {
 449                 fprintf(stderr, "disabling 3D acceleration\n");
 450 #if R200_MERGED
 451                 FALLBACK(&r300->radeon, RADEON_FALLBACK_DISABLE, 1);
 452 #endif
 453         }
 454         if (tcl_mode == DRI_CONF_TCL_SW ||
 455             !(r300->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL)) {
 456                 if (r300->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL) {
 457                         r300->radeon.radeonScreen->chip_flags &=
 458                             ~RADEON_CHIPSET_TCL;
 459                         fprintf(stderr, "Disabling HW TCL support\n");
 460                 }
 461                 TCL_FALLBACK(r300->radeon.glCtx,
 462                              RADEON_TCL_FALLBACK_TCL_DISABLE, 1);
 463         }
 464
 465         return GL_TRUE;
 466 }
 467
 468 /* Destroy the device specific context.
 469  */
 470 void r300DestroyContext(__DRIcontextPrivate * driContextPriv)
 471 {
 472         GET_CURRENT_CONTEXT(ctx);
 473         r300ContextPtr r300 = (r300ContextPtr) driContextPriv->driverPrivate;
 474         radeonContextPtr radeon = (radeonContextPtr) r300;
 475         radeonContextPtr current = ctx ? RADEON_CONTEXT(ctx) : NULL;
 476
 477         if (RADEON_DEBUG & DEBUG_DRI) {
 478                 fprintf(stderr, "Destroying context !\n");
 479         }
 480
 481         /* check if we're deleting the currently bound context */
 482         if (&r300->radeon == current) {
 483                 radeonFlush(r300->radeon.glCtx);
 484                 _mesa_make_current(NULL, NULL, NULL);
 485         }
 486
 487         /* Free r300 context resources */
 488         assert(r300);           /* should never be null */
 489
 490         if (r300) {
 491                 _swsetup_DestroyContext(r300->radeon.glCtx);
 492                 _tnl_DestroyContext(r300->radeon.glCtx);
 493                 _vbo_DestroyContext(r300->radeon.glCtx);
 494                 _swrast_DestroyContext(r300->radeon.glCtx);
 495
 496                 rcommonFlushCmdBuf(&r300->radeon, __FUNCTION__);
 497
 498                 if (radeon->state.scissor.pClipRects) {
 499                         FREE(radeon->state.scissor.pClipRects);
 500                         radeon->state.scissor.pClipRects = NULL;
 501                 }
 502
 503                 r300DestroyCmdBuf(r300);
 504
 505                 radeonCleanupContext(&r300->radeon);
 506
 507
 508                 /* the memory manager might be accessed when Mesa frees the shared
 509                  * state, so don't destroy it earlier
 510                  */
 511
 512
 513                 FREE(r300);
 514         }
 515 }