src/mesa/drivers/dri/r200/r200_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  * Authors:
  32  *   Keith Whitwell <keith@tungstengraphics.com>
  33  */
  34
  35 #include "main/glheader.h"
  36 #include "main/api_arrayelt.h"
  37 #include "main/context.h"
  38 #include "main/simple_list.h"
  39 #include "main/imports.h"
  40 #include "main/matrix.h"
  41 #include "main/extensions.h"
  42 #include "main/framebuffer.h"
  43 #include "main/state.h"
  44
  45 #include "swrast/swrast.h"
  46 #include "swrast_setup/swrast_setup.h"
  47 #include "vbo/vbo.h"
  48
  49 #include "tnl/tnl.h"
  50 #include "tnl/t_pipeline.h"
  51
  52 #include "drivers/common/driverfuncs.h"
  53
  54 #include "r200_context.h"
  55 #include "r200_ioctl.h"
  56 #include "r200_state.h"
  57 #include "r200_pixel.h"
  58 #include "r200_tex.h"
  59 #include "r200_swtcl.h"
  60 #include "r200_tcl.h"
  61 #include "r200_maos.h"
  62 #include "r200_vertprog.h"
  63
  64 #include "radeon_span.h"
  65
  66 #define need_GL_ARB_vertex_program
  67 #define need_GL_ATI_fragment_shader
  68 #define need_GL_EXT_blend_minmax
  69 #define need_GL_EXT_fog_coord
  70 #define need_GL_EXT_secondary_color
  71 #define need_GL_EXT_blend_equation_separate
  72 #define need_GL_EXT_blend_func_separate
  73 #define need_GL_NV_vertex_program
  74 #define need_GL_ARB_point_parameters
  75 #include "extension_helper.h"
  76
  77 #define DRIVER_DATE     "20060602"
  78
  79 #include "vblank.h"
  80 #include "utils.h"
  81 #include "xmlpool.h" /* for symbolic values of enum-type options */
  82
  83 /* Return various strings for glGetString().
  84  */
  85 static const GLubyte *r200GetString( GLcontext *ctx, GLenum name )
  86 {
  87    r200ContextPtr rmesa = R200_CONTEXT(ctx);
  88    static char buffer[128];
  89    unsigned   offset;
  90    GLuint agp_mode = (rmesa->radeon.radeonScreen->card_type == RADEON_CARD_PCI)? 0 :
  91       rmesa->radeon.radeonScreen->AGPMode;
  92
  93    switch ( name ) {
  94    case GL_VENDOR:
  95       return (GLubyte *)"Tungsten Graphics, Inc.";
  96
  97    case GL_RENDERER:
  98       offset = driGetRendererString( buffer, "R200", DRIVER_DATE,
  99                                      agp_mode );
 100
 101       sprintf( & buffer[ offset ], " %sTCL",
 102                !(rmesa->radeon.TclFallback & R200_TCL_FALLBACK_TCL_DISABLE)
 103                ? "" : "NO-" );
 104
 105       return (GLubyte *)buffer;
 106
 107    default:
 108       return NULL;
 109    }
 110 }
 111
 112
 113 /* Extension strings exported by the R200 driver.
 114  */
 115 const struct dri_extension card_extensions[] =
 116 {
 117     { "GL_ARB_multitexture",               NULL },
 118     { "GL_ARB_texture_border_clamp",       NULL },
 119     { "GL_ARB_texture_env_add",            NULL },
 120     { "GL_ARB_texture_env_combine",        NULL },
 121     { "GL_ARB_texture_env_dot3",           NULL },
 122     { "GL_ARB_texture_env_crossbar",       NULL },
 123     { "GL_ARB_texture_mirrored_repeat",    NULL },
 124     { "GL_EXT_blend_minmax",               GL_EXT_blend_minmax_functions },
 125     { "GL_EXT_blend_subtract",             NULL },
 126     { "GL_EXT_fog_coord",                  GL_EXT_fog_coord_functions },
 127     { "GL_EXT_secondary_color",            GL_EXT_secondary_color_functions },
 128     { "GL_EXT_stencil_wrap",               NULL },
 129     { "GL_EXT_texture_edge_clamp",         NULL },
 130     { "GL_EXT_texture_env_combine",        NULL },
 131     { "GL_EXT_texture_env_dot3",           NULL },
 132     { "GL_EXT_texture_filter_anisotropic", NULL },
 133     { "GL_EXT_texture_lod_bias",           NULL },
 134     { "GL_EXT_texture_mirror_clamp",       NULL },
 135     { "GL_EXT_texture_rectangle",          NULL },
 136     { "GL_ATI_texture_env_combine3",       NULL },
 137     { "GL_ATI_texture_mirror_once",        NULL },
 138     { "GL_MESA_pack_invert",               NULL },
 139     { "GL_NV_blend_square",                NULL },
 140     { "GL_SGIS_generate_mipmap",           NULL },
 141     { NULL,                                NULL }
 142 };
 143
 144 const struct dri_extension blend_extensions[] = {
 145     { "GL_EXT_blend_equation_separate",    GL_EXT_blend_equation_separate_functions },
 146     { "GL_EXT_blend_func_separate",        GL_EXT_blend_func_separate_functions },
 147     { NULL,                                NULL }
 148 };
 149
 150 const struct dri_extension ARB_vp_extension[] = {
 151     { "GL_ARB_vertex_program",             GL_ARB_vertex_program_functions }
 152 };
 153
 154 const struct dri_extension NV_vp_extension[] = {
 155     { "GL_NV_vertex_program",              GL_NV_vertex_program_functions }
 156 };
 157
 158 const struct dri_extension ATI_fs_extension[] = {
 159     { "GL_ATI_fragment_shader",            GL_ATI_fragment_shader_functions }
 160 };
 161
 162 const struct dri_extension point_extensions[] = {
 163     { "GL_ARB_point_sprite",               NULL },
 164     { "GL_ARB_point_parameters",           GL_ARB_point_parameters_functions },
 165     { NULL,                                NULL }
 166 };
 167
 168 extern const struct tnl_pipeline_stage _r200_render_stage;
 169 extern const struct tnl_pipeline_stage _r200_tcl_stage;
 170
 171 static const struct tnl_pipeline_stage *r200_pipeline[] = {
 172
 173    /* Try and go straight to t&l
 174     */
 175    &_r200_tcl_stage,
 176
 177    /* Catch any t&l fallbacks
 178     */
 179    &_tnl_vertex_transform_stage,
 180    &_tnl_normal_transform_stage,
 181    &_tnl_lighting_stage,
 182    &_tnl_fog_coordinate_stage,
 183    &_tnl_texgen_stage,
 184    &_tnl_texture_transform_stage,
 185    &_tnl_point_attenuation_stage,
 186    &_tnl_vertex_program_stage,
 187    /* Try again to go to tcl?
 188     *     - no good for asymmetric-twoside (do with multipass)
 189     *     - no good for asymmetric-unfilled (do with multipass)
 190     *     - good for material
 191     *     - good for texgen
 192     *     - need to manipulate a bit of state
 193     *
 194     * - worth it/not worth it?
 195     */
 196
 197    /* Else do them here.
 198     */
 199 /*    &_r200_render_stage,  */ /* FIXME: bugs with ut2003 */
 200    &_tnl_render_stage,          /* FALLBACK:  */
 201    NULL,
 202 };
 203
 204
 205
 206 /* Initialize the driver's misc functions.
 207  */
 208 static void r200InitDriverFuncs( struct dd_function_table *functions )
 209 {
 210     functions->GetBufferSize            = NULL; /* OBSOLETE */
 211     functions->GetString                = r200GetString;
 212 }
 213
 214 static const struct dri_debug_control debug_control[] =
 215 {
 216     { "fall",  DEBUG_FALLBACKS },
 217     { "tex",   DEBUG_TEXTURE },
 218     { "ioctl", DEBUG_IOCTL },
 219     { "prim",  DEBUG_PRIMS },
 220     { "vert",  DEBUG_VERTS },
 221     { "state", DEBUG_STATE },
 222     { "code",  DEBUG_CODEGEN },
 223     { "vfmt",  DEBUG_VFMT },
 224     { "vtxf",  DEBUG_VFMT },
 225     { "verb",  DEBUG_VERBOSE },
 226     { "dri",   DEBUG_DRI },
 227     { "dma",   DEBUG_DMA },
 228     { "san",   DEBUG_SANITY },
 229     { "sync",  DEBUG_SYNC },
 230     { "pix",   DEBUG_PIXEL },
 231     { "mem",   DEBUG_MEMORY },
 232     { NULL,    0 }
 233 };
 234
 235 static void r200_get_lock(radeonContextPtr radeon)
 236 {
 237    r200ContextPtr rmesa = (r200ContextPtr)radeon;
 238    drm_radeon_sarea_t *sarea = radeon->sarea;
 239    int i;
 240
 241    R200_STATECHANGE( rmesa, ctx );
 242    if (rmesa->radeon.sarea->tiling_enabled) {
 243       rmesa->hw.ctx.cmd[CTX_RB3D_COLORPITCH] |= R200_COLOR_TILE_ENABLE;
 244    }
 245    else rmesa->hw.ctx.cmd[CTX_RB3D_COLORPITCH] &= ~R200_COLOR_TILE_ENABLE;
 246
 247    if ( sarea->ctx_owner != rmesa->radeon.dri.hwContext ) {
 248       sarea->ctx_owner = rmesa->radeon.dri.hwContext;
 249    }
 250
 251    for ( i = 0 ; i < rmesa->radeon.nr_heaps ; i++ ) {
 252       DRI_AGE_TEXTURES( rmesa->radeon.texture_heaps[ i ] );
 253    }
 254 }
 255
 256 static void r200_vtbl_emit_cs_header(struct radeon_cs *cs, radeonContextPtr rmesa)
 257 {
 258 }
 259
 260
 261 static void r200_init_vtbl(radeonContextPtr radeon)
 262 {
 263    radeon->vtbl.get_lock = r200_get_lock;
 264    radeon->vtbl.update_viewport_offset = r200UpdateViewportOffset;
 265    radeon->vtbl.update_draw_buffer = r200UpdateDrawBuffer;
 266    radeon->vtbl.emit_cs_header = r200_vtbl_emit_cs_header;
 267    radeon->vtbl.swtcl_flush = r200_swtcl_flush;
 268 }
 269
 270
 271 /* Create the device specific rendering context.
 272  */
 273 GLboolean r200CreateContext( const __GLcontextModes *glVisual,
 274                              __DRIcontextPrivate *driContextPriv,
 275                              void *sharedContextPrivate)
 276 {
 277    __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv;
 278    radeonScreenPtr screen = (radeonScreenPtr)(sPriv->private);
 279    struct dd_function_table functions;
 280    r200ContextPtr rmesa;
 281    GLcontext *ctx;
 282    int i;
 283    int tcl_mode;
 284
 285    assert(glVisual);
 286    assert(driContextPriv);
 287    assert(screen);
 288
 289    /* Allocate the R200 context */
 290    rmesa = (r200ContextPtr) CALLOC( sizeof(*rmesa) );
 291    if ( !rmesa )
 292       return GL_FALSE;
 293
 294    r200_init_vtbl(&rmesa->radeon);
 295    /* init exp fog table data */
 296    r200InitStaticFogData();
 297
 298    /* Parse configuration files.
 299     * Do this here so that initialMaxAnisotropy is set before we create
 300     * the default textures.
 301     */
 302    driParseConfigFiles (&rmesa->radeon.optionCache, &screen->optionCache,
 303                         screen->driScreen->myNum, "r200");
 304    rmesa->radeon.initialMaxAnisotropy = driQueryOptionf(&rmesa->radeon.optionCache,
 305                                                         "def_max_anisotropy");
 306
 307    if ( driQueryOptionb( &rmesa->radeon.optionCache, "hyperz" ) ) {
 308       if ( sPriv->drm_version.minor < 13 )
 309          fprintf( stderr, "DRM version 1.%d too old to support HyperZ, "
 310                           "disabling.\n", sPriv->drm_version.minor );
 311       else
 312          rmesa->using_hyperz = GL_TRUE;
 313    }
 314
 315    if ( sPriv->drm_version.minor >= 15 )
 316       rmesa->texmicrotile = GL_TRUE;
 317
 318    /* Init default driver functions then plug in our R200-specific functions
 319     * (the texture functions are especially important)
 320     */
 321    _mesa_init_driver_functions(&functions);
 322    r200InitDriverFuncs(&functions);
 323    r200InitIoctlFuncs(&functions);
 324    r200InitStateFuncs(&functions);
 325    r200InitTextureFuncs(&functions);
 326    r200InitShaderFuncs(&functions);
 327
 328    if (!radeonInitContext(&rmesa->radeon, &functions,
 329                           glVisual, driContextPriv,
 330                           sharedContextPrivate)) {
 331      FREE(rmesa);
 332      return GL_FALSE;
 333    }
 334
 335
 336    (void) memset( rmesa->radeon.texture_heaps, 0, sizeof( rmesa->radeon.texture_heaps ) );
 337    make_empty_list( & rmesa->radeon.swapped );
 338
 339    rmesa->radeon.nr_heaps = 1 /* screen->numTexHeaps */ ;
 340    assert(rmesa->radeon.nr_heaps < RADEON_NR_TEX_HEAPS);
 341 #if 0
 342    for ( i = 0 ; i < rmesa->radeon.nr_heaps ; i++ ) {
 343       rmesa->radeon.texture_heaps[i] = driCreateTextureHeap( i, rmesa,
 344             screen->texSize[i],
 345             12,
 346             RADEON_NR_TEX_REGIONS,
 347             (drmTextureRegionPtr)rmesa->radeon.sarea->tex_list[i],
 348             & rmesa->radeon.sarea->tex_age[i],
 349             & rmesa->radeon.swapped,
 350             sizeof( radeonTexObj ),
 351             (destroy_texture_object_t *) r200DestroyTexObj );
 352    }
 353 #endif
 354    rmesa->radeon.texture_depth = driQueryOptioni (&rmesa->radeon.optionCache,
 355                                            "texture_depth");
 356    if (rmesa->radeon.texture_depth == DRI_CONF_TEXTURE_DEPTH_FB)
 357       rmesa->radeon.texture_depth = ( screen->cpp == 4 ) ?
 358          DRI_CONF_TEXTURE_DEPTH_32 : DRI_CONF_TEXTURE_DEPTH_16;
 359
 360    rmesa->radeon.swtcl.RenderIndex = ~0;
 361    rmesa->radeon.hw.all_dirty = 1;
 362
 363    /* Set the maximum texture size small enough that we can guarentee that
 364     * all texture units can bind a maximal texture and have all of them in
 365     * texturable memory at once. Depending on the allow_large_textures driconf
 366     * setting allow larger textures.
 367     */
 368
 369    ctx = rmesa->radeon.glCtx;
 370    ctx->Const.MaxTextureUnits = driQueryOptioni (&rmesa->radeon.optionCache,
 371                                                  "texture_units");
 372    ctx->Const.MaxTextureImageUnits = ctx->Const.MaxTextureUnits;
 373    ctx->Const.MaxTextureCoordUnits = ctx->Const.MaxTextureUnits;
 374
 375    i = driQueryOptioni( &rmesa->radeon.optionCache, "allow_large_textures");
 376
 377    driCalculateMaxTextureLevels( rmesa->radeon.texture_heaps,
 378                                  rmesa->radeon.nr_heaps,
 379                                  & ctx->Const,
 380                                  4,
 381                                  11, /* max 2D texture size is 2048x2048 */
 382 #if ENABLE_HW_3D_TEXTURE
 383                                  8,  /* max 3D texture size is 256^3 */
 384 #else
 385                                  0,  /* 3D textures unsupported */
 386 #endif
 387                                  11, /* max cube texture size is 2048x2048 */
 388                                  11, /* max texture rectangle size is 2048x2048 */
 389                                  12,
 390                                  GL_FALSE,
 391                                  i );
 392
 393    ctx->Const.MaxTextureMaxAnisotropy = 16.0;
 394
 395    /* No wide AA points.
 396     */
 397    ctx->Const.MinPointSize = 1.0;
 398    ctx->Const.MinPointSizeAA = 1.0;
 399    ctx->Const.MaxPointSizeAA = 1.0;
 400    ctx->Const.PointSizeGranularity = 0.0625;
 401    if (rmesa->radeon.radeonScreen->drmSupportsPointSprites)
 402       ctx->Const.MaxPointSize = 2047.0;
 403    else
 404       ctx->Const.MaxPointSize = 1.0;
 405
 406    /* mesa initialization problem - _mesa_init_point was already called */
 407    ctx->Point.MaxSize = ctx->Const.MaxPointSize;
 408
 409    ctx->Const.MinLineWidth = 1.0;
 410    ctx->Const.MinLineWidthAA = 1.0;
 411    ctx->Const.MaxLineWidth = 10.0;
 412    ctx->Const.MaxLineWidthAA = 10.0;
 413    ctx->Const.LineWidthGranularity = 0.0625;
 414
 415    ctx->Const.VertexProgram.MaxNativeInstructions = R200_VSF_MAX_INST;
 416    ctx->Const.VertexProgram.MaxNativeAttribs = 12;
 417    ctx->Const.VertexProgram.MaxNativeTemps = R200_VSF_MAX_TEMPS;
 418    ctx->Const.VertexProgram.MaxNativeParameters = R200_VSF_MAX_PARAM;
 419    ctx->Const.VertexProgram.MaxNativeAddressRegs = 1;
 420
 421    ctx->Const.MaxDrawBuffers = 1;
 422
 423    /* Initialize the software rasterizer and helper modules.
 424     */
 425    _swrast_CreateContext( ctx );
 426    _vbo_CreateContext( ctx );
 427    _tnl_CreateContext( ctx );
 428    _swsetup_CreateContext( ctx );
 429    _ae_create_context( ctx );
 430
 431    /* Install the customized pipeline:
 432     */
 433    _tnl_destroy_pipeline( ctx );
 434    _tnl_install_pipeline( ctx, r200_pipeline );
 435
 436    /* Try and keep materials and vertices separate:
 437     */
 438 /*    _tnl_isolate_materials( ctx, GL_TRUE ); */
 439
 440
 441    /* Configure swrast and TNL to match hardware characteristics:
 442     */
 443    _swrast_allow_pixel_fog( ctx, GL_FALSE );
 444    _swrast_allow_vertex_fog( ctx, GL_TRUE );
 445    _tnl_allow_pixel_fog( ctx, GL_FALSE );
 446    _tnl_allow_vertex_fog( ctx, GL_TRUE );
 447
 448
 449    for ( i = 0 ; i < R200_MAX_TEXTURE_UNITS ; i++ ) {
 450       _math_matrix_ctr( &rmesa->TexGenMatrix[i] );
 451       _math_matrix_set_identity( &rmesa->TexGenMatrix[i] );
 452    }
 453    _math_matrix_ctr( &rmesa->tmpmat );
 454    _math_matrix_set_identity( &rmesa->tmpmat );
 455
 456    driInitExtensions( ctx, card_extensions, GL_TRUE );
 457    if (!(rmesa->radeon.radeonScreen->chip_flags & R200_CHIPSET_YCBCR_BROKEN)) {
 458      /* yuv textures don't work with some chips - R200 / rv280 okay so far
 459         others get the bit ordering right but don't actually do YUV-RGB conversion */
 460       _mesa_enable_extension( ctx, "GL_MESA_ycbcr_texture" );
 461    }
 462    if (rmesa->radeon.glCtx->Mesa_DXTn) {
 463       _mesa_enable_extension( ctx, "GL_EXT_texture_compression_s3tc" );
 464       _mesa_enable_extension( ctx, "GL_S3_s3tc" );
 465    }
 466    else if (driQueryOptionb (&rmesa->radeon.optionCache, "force_s3tc_enable")) {
 467       _mesa_enable_extension( ctx, "GL_EXT_texture_compression_s3tc" );
 468    }
 469
 470    if (rmesa->radeon.radeonScreen->drmSupportsCubeMapsR200)
 471       _mesa_enable_extension( ctx, "GL_ARB_texture_cube_map" );
 472    if (rmesa->radeon.radeonScreen->drmSupportsBlendColor) {
 473        driInitExtensions( ctx, blend_extensions, GL_FALSE );
 474    }
 475    if(rmesa->radeon.radeonScreen->drmSupportsVertexProgram)
 476       driInitSingleExtension( ctx, ARB_vp_extension );
 477    if(driQueryOptionb(&rmesa->radeon.optionCache, "nv_vertex_program"))
 478       driInitSingleExtension( ctx, NV_vp_extension );
 479
 480    if ((ctx->Const.MaxTextureUnits == 6) && rmesa->radeon.radeonScreen->drmSupportsFragShader)
 481       driInitSingleExtension( ctx, ATI_fs_extension );
 482    if (rmesa->radeon.radeonScreen->drmSupportsPointSprites)
 483       driInitExtensions( ctx, point_extensions, GL_FALSE );
 484 #if 0
 485    r200InitDriverFuncs( ctx );
 486    r200InitIoctlFuncs( ctx );
 487    r200InitStateFuncs( ctx );
 488    r200InitTextureFuncs( ctx );
 489 #endif
 490    /* plug in a few more device driver functions */
 491    /* XXX these should really go right after _mesa_init_driver_functions() */
 492    radeonInitSpanFuncs( ctx );
 493    r200InitPixelFuncs( ctx );
 494    r200InitTnlFuncs( ctx );
 495    r200InitState( rmesa );
 496    r200InitSwtcl( ctx );
 497
 498    rmesa->prefer_gart_client_texturing =
 499       (getenv("R200_GART_CLIENT_TEXTURES") != 0);
 500
 501 #if DO_DEBUG
 502    R200_DEBUG  = driParseDebugString( getenv( "R200_DEBUG" ),
 503                                       debug_control );
 504    R200_DEBUG |= driParseDebugString( getenv( "RADEON_DEBUG" ),
 505                                       debug_control );
 506 #endif
 507
 508    tcl_mode = driQueryOptioni(&rmesa->radeon.optionCache, "tcl_mode");
 509    if (driQueryOptionb(&rmesa->radeon.optionCache, "no_rast")) {
 510       fprintf(stderr, "disabling 3D acceleration\n");
 511       FALLBACK(rmesa, R200_FALLBACK_DISABLE, 1);
 512    }
 513    else if (tcl_mode == DRI_CONF_TCL_SW || getenv("R200_NO_TCL") ||
 514             !(rmesa->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL)) {
 515       if (rmesa->radeon.radeonScreen->chip_flags & RADEON_CHIPSET_TCL) {
 516          rmesa->radeon.radeonScreen->chip_flags &= ~RADEON_CHIPSET_TCL;
 517          fprintf(stderr, "Disabling HW TCL support\n");
 518       }
 519       TCL_FALLBACK(rmesa->radeon.glCtx, R200_TCL_FALLBACK_TCL_DISABLE, 1);
 520    }
 521
 522    return GL_TRUE;
 523 }
 524
 525
 526 /* Destroy the device specific context.
 527  */
 528 /* Destroy the Mesa and driver specific context data.
 529  */
 530 void r200DestroyContext( __DRIcontextPrivate *driContextPriv )
 531 {
 532    GET_CURRENT_CONTEXT(ctx);
 533    r200ContextPtr rmesa = (r200ContextPtr) driContextPriv->driverPrivate;
 534    r200ContextPtr current = ctx ? R200_CONTEXT(ctx) : NULL;
 535
 536    /* check if we're deleting the currently bound context */
 537    if (rmesa == current) {
 538       radeon_firevertices(&rmesa->radeon);
 539       _mesa_make_current(NULL, NULL, NULL);
 540    }
 541
 542    /* Free r200 context resources */
 543    assert(rmesa); /* should never be null */
 544    if ( rmesa ) {
 545       GLboolean   release_texture_heaps;
 546
 547
 548       release_texture_heaps = (rmesa->radeon.glCtx->Shared->RefCount == 1);
 549       _swsetup_DestroyContext( rmesa->radeon.glCtx );
 550       _tnl_DestroyContext( rmesa->radeon.glCtx );
 551       _vbo_DestroyContext( rmesa->radeon.glCtx );
 552       _swrast_DestroyContext( rmesa->radeon.glCtx );
 553
 554       r200DestroySwtcl( rmesa->radeon.glCtx );
 555       r200ReleaseArrays( rmesa->radeon.glCtx, ~0 );
 556
 557       if (rmesa->radeon.dma.current) {
 558          radeonReleaseDmaRegion( &rmesa->radeon );
 559          rcommonFlushCmdBuf( &rmesa->radeon, __FUNCTION__ );
 560       }
 561
 562       if (rmesa->radeon.state.scissor.pClipRects) {
 563          FREE(rmesa->radeon.state.scissor.pClipRects);
 564          rmesa->radeon.state.scissor.pClipRects = NULL;
 565       }
 566
 567
 568       if ( release_texture_heaps ) {
 569          /* This share group is about to go away, free our private
 570           * texture object data.
 571           */
 572          int i;
 573
 574          for ( i = 0 ; i < rmesa->radeon.nr_heaps ; i++ ) {
 575             driDestroyTextureHeap( rmesa->radeon.texture_heaps[ i ] );
 576             rmesa->radeon.texture_heaps[ i ] = NULL;
 577          }
 578
 579          assert( is_empty_list( & rmesa->radeon.swapped ) );
 580       }
 581
 582       radeonCleanupContext(&rmesa->radeon);
 583
 584       FREE( rmesa );
 585    }
 586 }
 587
 588
 589
 590 /* Force the context `c' to be unbound from its buffer.
 591  */
 592 GLboolean
 593 r200UnbindContext( __DRIcontextPrivate *driContextPriv )
 594 {
 595    r200ContextPtr rmesa = (r200ContextPtr) driContextPriv->driverPrivate;
 596
 597    if (R200_DEBUG & DEBUG_DRI)
 598       fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *)rmesa->radeon.glCtx);
 599
 600    return GL_TRUE;
 601 }