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
  48 #include "swrast/swrast.h"
  49 #include "swrast_setup/swrast_setup.h"
  50 #include "vbo/vbo.h"
  51
  52 #include "tnl/tnl.h"
  53 #include "tnl/t_pipeline.h"
  54 #include "tnl/t_vp_build.h"
  55
  56 #include "drivers/common/driverfuncs.h"
  57
  58 #include "radeon_ioctl.h"
  59 #include "radeon_span.h"
  60 #include "r300_context.h"
  61 #include "r300_cmdbuf.h"
  62 #include "r300_state.h"
  63 #include "r300_ioctl.h"
  64 #include "r300_tex.h"
  65 #include "r300_emit.h"
  66 #include "r300_swtcl.h"
  67
  68 #ifdef USER_BUFFERS
  69 #include "r300_mem.h"
  70 #endif
  71
  72 #include "vblank.h"
  73 #include "utils.h"
  74 #include "xmlpool.h"            /* for symbolic values of enum-type options */
  75
  76 /* hw_tcl_on derives from future_hw_tcl_on when its safe to change it. */
  77 int future_hw_tcl_on = 1;
  78 int hw_tcl_on = 1;
  79
  80 #define need_GL_VERSION_2_0
  81 #define need_GL_ARB_point_parameters
  82 #define need_GL_ARB_vertex_program
  83 #define need_GL_EXT_blend_equation_separate
  84 #define need_GL_EXT_blend_func_separate
  85 #define need_GL_EXT_blend_minmax
  86 #define need_GL_EXT_fog_coord
  87 #define need_GL_EXT_gpu_program_parameters
  88 #define need_GL_EXT_secondary_color
  89 #define need_GL_EXT_stencil_two_side
  90 #define need_GL_ATI_separate_stencil
  91 #define need_GL_NV_vertex_program
  92 #include "extension_helper.h"
  93
  94 const struct dri_extension card_extensions[] = {
  95   /* *INDENT-OFF* */
  96   {"GL_ARB_depth_texture",              NULL},
  97   {"GL_ARB_fragment_program",           NULL},
  98   {"GL_ARB_multitexture",               NULL},
  99   {"GL_ARB_point_parameters",           GL_ARB_point_parameters_functions},
 100   {"GL_ARB_shadow",                     NULL},
 101   {"GL_ARB_shadow_ambient",             NULL},
 102   {"GL_ARB_texture_border_clamp",       NULL},
 103   {"GL_ARB_texture_cube_map",           NULL},
 104   {"GL_ARB_texture_env_add",            NULL},
 105   {"GL_ARB_texture_env_combine",        NULL},
 106   {"GL_ARB_texture_env_crossbar",       NULL},
 107   {"GL_ARB_texture_env_dot3",           NULL},
 108   {"GL_ARB_texture_mirrored_repeat",    NULL},
 109   {"GL_ARB_vertex_program",             GL_ARB_vertex_program_functions},
 110   {"GL_EXT_blend_equation_separate",    GL_EXT_blend_equation_separate_functions},
 111   {"GL_EXT_blend_func_separate",        GL_EXT_blend_func_separate_functions},
 112   {"GL_EXT_blend_minmax",               GL_EXT_blend_minmax_functions},
 113   {"GL_EXT_blend_subtract",             NULL},
 114   {"GL_EXT_fog_coord",                  GL_EXT_fog_coord_functions },
 115   {"GL_EXT_gpu_program_parameters",     GL_EXT_gpu_program_parameters_functions},
 116   {"GL_EXT_secondary_color",            GL_EXT_secondary_color_functions},
 117   {"GL_EXT_shadow_funcs",               NULL},
 118   {"GL_EXT_stencil_two_side",           GL_EXT_stencil_two_side_functions},
 119   {"GL_EXT_stencil_wrap",               NULL},
 120   {"GL_EXT_texture_edge_clamp",         NULL},
 121   {"GL_EXT_texture_env_combine",        NULL},
 122   {"GL_EXT_texture_env_dot3",           NULL},
 123   {"GL_EXT_texture_filter_anisotropic", NULL},
 124   {"GL_EXT_texture_lod_bias",           NULL},
 125   {"GL_EXT_texture_mirror_clamp",       NULL},
 126   {"GL_EXT_texture_rectangle",          NULL},
 127   {"GL_ATI_separate_stencil",           GL_ATI_separate_stencil_functions},
 128   {"GL_ATI_texture_env_combine3",       NULL},
 129   {"GL_ATI_texture_mirror_once",        NULL},
 130   {"GL_MESA_pack_invert",               NULL},
 131   {"GL_MESA_ycbcr_texture",             NULL},
 132   {"GL_MESAX_texture_float",            NULL},
 133   {"GL_NV_blend_square",                NULL},
 134   {"GL_NV_vertex_program",              GL_NV_vertex_program_functions},
 135   {"GL_SGIS_generate_mipmap",           NULL},
 136   {NULL,                                NULL}
 137   /* *INDENT-ON* */
 138 };
 139
 140
 141 /**
 142  * The GL 2.0 functions are needed to make display lists work with
 143  * functions added by GL_ATI_separate_stencil.
 144  */
 145 const struct dri_extension gl_20_extension[] = {
 146   {"GL_VERSION_2_0",                    GL_VERSION_2_0_functions },
 147 };
 148
 149
 150 extern struct tnl_pipeline_stage _r300_render_stage;
 151 extern const struct tnl_pipeline_stage _r300_tcl_stage;
 152
 153 static const struct tnl_pipeline_stage *r300_pipeline[] = {
 154
 155         /* Try and go straight to t&l
 156          */
 157         &_r300_tcl_stage,
 158
 159         /* Catch any t&l fallbacks
 160          */
 161         &_tnl_vertex_transform_stage,
 162         &_tnl_normal_transform_stage,
 163         &_tnl_lighting_stage,
 164         &_tnl_fog_coordinate_stage,
 165         &_tnl_texgen_stage,
 166         &_tnl_texture_transform_stage,
 167         &_tnl_vertex_program_stage,
 168
 169         /* Try again to go to tcl?
 170          *     - no good for asymmetric-twoside (do with multipass)
 171          *     - no good for asymmetric-unfilled (do with multipass)
 172          *     - good for material
 173          *     - good for texgen
 174          *     - need to manipulate a bit of state
 175          *
 176          * - worth it/not worth it?
 177          */
 178
 179         /* Else do them here.
 180          */
 181         &_r300_render_stage,
 182         &_tnl_render_stage,     /* FALLBACK  */
 183         0,
 184 };
 185
 186 /* Create the device specific rendering context.
 187  */
 188 GLboolean r300CreateContext(const __GLcontextModes * glVisual,
 189                             __DRIcontextPrivate * driContextPriv,
 190                             void *sharedContextPrivate)
 191 {
 192         __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv;
 193         radeonScreenPtr screen = (radeonScreenPtr) (sPriv->private);
 194         struct dd_function_table functions;
 195         r300ContextPtr r300;
 196         GLcontext *ctx;
 197         int tcl_mode, i;
 198
 199         assert(glVisual);
 200         assert(driContextPriv);
 201         assert(screen);
 202
 203         /* Allocate the R300 context */
 204         r300 = (r300ContextPtr) CALLOC(sizeof(*r300));
 205         if (!r300)
 206                 return GL_FALSE;
 207
 208         if (!(screen->chip_flags & RADEON_CHIPSET_TCL))
 209                 hw_tcl_on = future_hw_tcl_on = 0;
 210
 211         /* Parse configuration files.
 212          * Do this here so that initialMaxAnisotropy is set before we create
 213          * the default textures.
 214          */
 215         driParseConfigFiles(&r300->radeon.optionCache, &screen->optionCache,
 216                             screen->driScreen->myNum, "r300");
 217         r300->initialMaxAnisotropy = driQueryOptionf(&r300->radeon.optionCache,
 218                                                      "def_max_anisotropy");
 219
 220         /* Init default driver functions then plug in our R300-specific functions
 221          * (the texture functions are especially important)
 222          */
 223         _mesa_init_driver_functions(&functions);
 224         r300InitIoctlFuncs(&functions);
 225         r300InitStateFuncs(&functions);
 226         r300InitTextureFuncs(&functions);
 227         r300InitShaderFuncs(&functions);
 228
 229 #ifdef USER_BUFFERS
 230         r300_mem_init(r300);
 231 #endif
 232
 233         if (!radeonInitContext(&r300->radeon, &functions,
 234                                glVisual, driContextPriv,
 235                                sharedContextPrivate)) {
 236                 FREE(r300);
 237                 return GL_FALSE;
 238         }
 239
 240         /* Init r300 context data */
 241         r300->dma.buf0_address =
 242             r300->radeon.radeonScreen->buffers->list[0].address;
 243
 244         (void)memset(r300->texture_heaps, 0, sizeof(r300->texture_heaps));
 245         make_empty_list(&r300->swapped);
 246
 247         r300->nr_heaps = 1 /* screen->numTexHeaps */ ;
 248         assert(r300->nr_heaps < RADEON_NR_TEX_HEAPS);
 249         for (i = 0; i < r300->nr_heaps; i++) {
 250                 /* *INDENT-OFF* */
 251                 r300->texture_heaps[i] = driCreateTextureHeap(i, r300,
 252                                                                screen->
 253                                                                texSize[i], 12,
 254                                                                RADEON_NR_TEX_REGIONS,
 255                                                                (drmTextureRegionPtr)
 256                                                                r300->radeon.sarea->
 257                                                                tex_list[i],
 258                                                                &r300->radeon.sarea->
 259                                                                tex_age[i],
 260                                                                &r300->swapped,
 261                                                                sizeof
 262                                                                (r300TexObj),
 263                                                                (destroy_texture_object_t
 264                                                                 *)
 265                                                                r300DestroyTexObj);
 266                 /* *INDENT-ON* */
 267         }
 268         r300->texture_depth = driQueryOptioni(&r300->radeon.optionCache,
 269                                               "texture_depth");
 270         if (r300->texture_depth == DRI_CONF_TEXTURE_DEPTH_FB)
 271                 r300->texture_depth = (screen->cpp == 4) ?
 272                     DRI_CONF_TEXTURE_DEPTH_32 : DRI_CONF_TEXTURE_DEPTH_16;
 273
 274         /* Set the maximum texture size small enough that we can guarentee that
 275          * all texture units can bind a maximal texture and have them both in
 276          * texturable memory at once.
 277          */
 278
 279         ctx = r300->radeon.glCtx;
 280
 281         ctx->Const.MaxTextureImageUnits =
 282             driQueryOptioni(&r300->radeon.optionCache, "texture_image_units");
 283         ctx->Const.MaxTextureCoordUnits =
 284             driQueryOptioni(&r300->radeon.optionCache, "texture_coord_units");
 285         ctx->Const.MaxTextureUnits =
 286             MIN2(ctx->Const.MaxTextureImageUnits,
 287                  ctx->Const.MaxTextureCoordUnits);
 288         ctx->Const.MaxTextureMaxAnisotropy = 16.0;
 289         ctx->Const.MaxTextureLodBias = 16.0;
 290
 291         if (screen->chip_family >= CHIP_FAMILY_RV515) {
 292             ctx->Const.MaxTextureLevels = 13;
 293             ctx->Const.MaxTextureRectSize = 4096;
 294         }
 295
 296         ctx->Const.MinPointSize = 1.0;
 297         ctx->Const.MinPointSizeAA = 1.0;
 298         ctx->Const.MaxPointSize = R300_POINTSIZE_MAX;
 299         ctx->Const.MaxPointSizeAA = R300_POINTSIZE_MAX;
 300
 301         ctx->Const.MinLineWidth = 1.0;
 302         ctx->Const.MinLineWidthAA = 1.0;
 303         ctx->Const.MaxLineWidth = R300_LINESIZE_MAX;
 304         ctx->Const.MaxLineWidthAA = R300_LINESIZE_MAX;
 305
 306 #ifdef USER_BUFFERS
 307         /* Needs further modifications */
 308 #if 0
 309         ctx->Const.MaxArrayLockSize =
 310             ( /*512 */ RADEON_BUFFER_SIZE * 16 * 1024) / (4 * 4);
 311 #endif
 312 #endif
 313
 314         ctx->Const.MaxDrawBuffers = 1;
 315
 316         /* Initialize the software rasterizer and helper modules.
 317          */
 318         _swrast_CreateContext(ctx);
 319         _vbo_CreateContext(ctx);
 320         _tnl_CreateContext(ctx);
 321         _swsetup_CreateContext(ctx);
 322         _swsetup_Wakeup(ctx);
 323         _ae_create_context(ctx);
 324
 325         /* Install the customized pipeline:
 326          */
 327         _tnl_destroy_pipeline(ctx);
 328         _tnl_install_pipeline(ctx, r300_pipeline);
 329
 330         /* Try and keep materials and vertices separate:
 331          */
 332 /*      _tnl_isolate_materials(ctx, GL_TRUE); */
 333
 334         /* Configure swrast and TNL to match hardware characteristics:
 335          */
 336         _swrast_allow_pixel_fog(ctx, GL_FALSE);
 337         _swrast_allow_vertex_fog(ctx, GL_TRUE);
 338         _tnl_allow_pixel_fog(ctx, GL_FALSE);
 339         _tnl_allow_vertex_fog(ctx, GL_TRUE);
 340
 341         /* currently bogus data */
 342         if (screen->chip_flags & RADEON_CHIPSET_TCL) {
 343                 ctx->Const.VertexProgram.MaxInstructions = VSF_MAX_FRAGMENT_LENGTH / 4;
 344                 ctx->Const.VertexProgram.MaxNativeInstructions =
 345                   VSF_MAX_FRAGMENT_LENGTH / 4;
 346                 ctx->Const.VertexProgram.MaxNativeAttribs = 16; /* r420 */
 347                 ctx->Const.VertexProgram.MaxTemps = 32;
 348                 ctx->Const.VertexProgram.MaxNativeTemps =
 349                   /*VSF_MAX_FRAGMENT_TEMPS */ 32;
 350                 ctx->Const.VertexProgram.MaxNativeParameters = 256;     /* r420 */
 351                 ctx->Const.VertexProgram.MaxNativeAddressRegs = 1;
 352         }
 353
 354         ctx->Const.FragmentProgram.MaxNativeTemps = PFS_NUM_TEMP_REGS;
 355         ctx->Const.FragmentProgram.MaxNativeAttribs = 11;       /* copy i915... */
 356         ctx->Const.FragmentProgram.MaxNativeParameters = PFS_NUM_CONST_REGS;
 357         ctx->Const.FragmentProgram.MaxNativeAluInstructions = PFS_MAX_ALU_INST;
 358         ctx->Const.FragmentProgram.MaxNativeTexInstructions = PFS_MAX_TEX_INST;
 359         ctx->Const.FragmentProgram.MaxNativeInstructions =
 360             PFS_MAX_ALU_INST + PFS_MAX_TEX_INST;
 361         ctx->Const.FragmentProgram.MaxNativeTexIndirections =
 362             PFS_MAX_TEX_INDIRECT;
 363         ctx->Const.FragmentProgram.MaxNativeAddressRegs = 0;    /* and these are?? */
 364         ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
 365         ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
 366
 367         driInitExtensions(ctx, card_extensions, GL_TRUE);
 368
 369         if (driQueryOptionb
 370             (&r300->radeon.optionCache, "disable_stencil_two_side"))
 371                 _mesa_disable_extension(ctx, "GL_EXT_stencil_two_side");
 372
 373         if (r300->radeon.glCtx->Mesa_DXTn
 374             && !driQueryOptionb(&r300->radeon.optionCache, "disable_s3tc")) {
 375                 _mesa_enable_extension(ctx, "GL_EXT_texture_compression_s3tc");
 376                 _mesa_enable_extension(ctx, "GL_S3_s3tc");
 377         } else
 378             if (driQueryOptionb(&r300->radeon.optionCache, "force_s3tc_enable"))
 379         {
 380                 _mesa_enable_extension(ctx, "GL_EXT_texture_compression_s3tc");
 381         }
 382
 383         r300->disable_lowimpact_fallback =
 384             driQueryOptionb(&r300->radeon.optionCache,
 385                             "disable_lowimpact_fallback");
 386
 387         radeonInitSpanFuncs(ctx);
 388         r300InitCmdBuf(r300);
 389         r300InitState(r300);
 390         if (!(screen->chip_flags & RADEON_CHIPSET_TCL))
 391                 r300InitSwtcl(ctx);
 392
 393         TNL_CONTEXT(ctx)->Driver.RunPipeline = _tnl_run_pipeline;
 394
 395         tcl_mode = driQueryOptioni(&r300->radeon.optionCache, "tcl_mode");
 396         if (driQueryOptionb(&r300->radeon.optionCache, "no_rast")) {
 397                 fprintf(stderr, "disabling 3D acceleration\n");
 398 #if R200_MERGED
 399                 FALLBACK(&r300->radeon, RADEON_FALLBACK_DISABLE, 1);
 400 #endif
 401         }
 402         if (tcl_mode == DRI_CONF_TCL_SW ||
 403             !(r300->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL)) {
 404                 if (r300->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL) {
 405                         r300->radeon.radeonScreen->chip_flags &=
 406                             ~RADEON_CHIPSET_TCL;
 407                         fprintf(stderr, "Disabling HW TCL support\n");
 408                 }
 409                 TCL_FALLBACK(r300->radeon.glCtx,
 410                              RADEON_TCL_FALLBACK_TCL_DISABLE, 1);
 411         }
 412
 413         return GL_TRUE;
 414 }
 415
 416 static void r300FreeGartAllocations(r300ContextPtr r300)
 417 {
 418         int i, ret, tries = 0, done_age, in_use = 0;
 419         drm_radeon_mem_free_t memfree;
 420
 421         memfree.region = RADEON_MEM_REGION_GART;
 422
 423 #ifdef USER_BUFFERS
 424         for (i = r300->rmm->u_last; i > 0; i--) {
 425                 if (r300->rmm->u_list[i].ptr == NULL) {
 426                         continue;
 427                 }
 428
 429                 /* check whether this buffer is still in use */
 430                 if (r300->rmm->u_list[i].pending) {
 431                         in_use++;
 432                 }
 433         }
 434         /* Cannot flush/lock if no context exists. */
 435         if (in_use)
 436                 r300FlushCmdBuf(r300, __FUNCTION__);
 437
 438         done_age = radeonGetAge((radeonContextPtr) r300);
 439
 440         for (i = r300->rmm->u_last; i > 0; i--) {
 441                 if (r300->rmm->u_list[i].ptr == NULL) {
 442                         continue;
 443                 }
 444
 445                 /* check whether this buffer is still in use */
 446                 if (!r300->rmm->u_list[i].pending) {
 447                         continue;
 448                 }
 449
 450                 assert(r300->rmm->u_list[i].h_pending == 0);
 451
 452                 tries = 0;
 453                 while (r300->rmm->u_list[i].age > done_age && tries++ < 1000) {
 454                         usleep(10);
 455                         done_age = radeonGetAge((radeonContextPtr) r300);
 456                 }
 457                 if (tries >= 1000) {
 458                         WARN_ONCE("Failed to idle region!");
 459                 }
 460
 461                 memfree.region_offset = (char *)r300->rmm->u_list[i].ptr -
 462                     (char *)r300->radeon.radeonScreen->gartTextures.map;
 463
 464                 ret = drmCommandWrite(r300->radeon.radeonScreen->driScreen->fd,
 465                                       DRM_RADEON_FREE, &memfree,
 466                                       sizeof(memfree));
 467                 if (ret) {
 468                         fprintf(stderr, "Failed to free at %p\nret = %s\n",
 469                                 r300->rmm->u_list[i].ptr, strerror(-ret));
 470                 } else {
 471                         if (i == r300->rmm->u_last)
 472                                 r300->rmm->u_last--;
 473
 474                         r300->rmm->u_list[i].pending = 0;
 475                         r300->rmm->u_list[i].ptr = NULL;
 476                 }
 477         }
 478         r300->rmm->u_head = i;
 479 #endif                          /* USER_BUFFERS */
 480 }
 481
 482 /* Destroy the device specific context.
 483  */
 484 void r300DestroyContext(__DRIcontextPrivate * driContextPriv)
 485 {
 486         GET_CURRENT_CONTEXT(ctx);
 487         r300ContextPtr r300 = (r300ContextPtr) driContextPriv->driverPrivate;
 488         radeonContextPtr radeon = (radeonContextPtr) r300;
 489         radeonContextPtr current = ctx ? RADEON_CONTEXT(ctx) : NULL;
 490
 491         if (RADEON_DEBUG & DEBUG_DRI) {
 492                 fprintf(stderr, "Destroying context !\n");
 493         }
 494
 495         /* check if we're deleting the currently bound context */
 496         if (&r300->radeon == current) {
 497                 radeonFlush(r300->radeon.glCtx);
 498                 _mesa_make_current(NULL, NULL, NULL);
 499         }
 500
 501         /* Free r300 context resources */
 502         assert(r300);           /* should never be null */
 503
 504         if (r300) {
 505                 GLboolean release_texture_heaps;
 506
 507                 release_texture_heaps =
 508                     (r300->radeon.glCtx->Shared->RefCount == 1);
 509                 _swsetup_DestroyContext(r300->radeon.glCtx);
 510                 _tnl_DestroyContext(r300->radeon.glCtx);
 511                 _vbo_DestroyContext(r300->radeon.glCtx);
 512                 _swrast_DestroyContext(r300->radeon.glCtx);
 513
 514                 if (r300->dma.current.buf) {
 515                         r300ReleaseDmaRegion(r300, &r300->dma.current,
 516                                              __FUNCTION__);
 517 #ifndef USER_BUFFERS
 518                         r300FlushCmdBuf(r300, __FUNCTION__);
 519 #endif
 520                 }
 521                 r300FreeGartAllocations(r300);
 522                 r300DestroyCmdBuf(r300);
 523
 524                 if (radeon->state.scissor.pClipRects) {
 525                         FREE(radeon->state.scissor.pClipRects);
 526                         radeon->state.scissor.pClipRects = NULL;
 527                 }
 528
 529                 if (release_texture_heaps) {
 530                         /* This share group is about to go away, free our private
 531                          * texture object data.
 532                          */
 533                         int i;
 534
 535                         for (i = 0; i < r300->nr_heaps; i++) {
 536                                 driDestroyTextureHeap(r300->texture_heaps[i]);
 537                                 r300->texture_heaps[i] = NULL;
 538                         }
 539
 540                         assert(is_empty_list(&r300->swapped));
 541                 }
 542
 543                 radeonCleanupContext(&r300->radeon);
 544
 545 #ifdef USER_BUFFERS
 546                 /* the memory manager might be accessed when Mesa frees the shared
 547                  * state, so don't destroy it earlier
 548                  */
 549                 r300_mem_destroy(r300);
 550 #endif
 551
 552                 /* free the option cache */
 553                 driDestroyOptionCache(&r300->radeon.optionCache);
 554
 555                 FREE(r300);
 556         }
 557 }