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