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