src/mesa/drivers/dri/r200/r200_context.c

   1 /* $XFree86: xc/lib/GL/mesa/src/drv/r200/r200_context.c,v 1.3 2003/05/06 23:52:08 daenzer Exp $ */
   2 /*
   3 Copyright (C) The Weather Channel, Inc.  2002.  All Rights Reserved.
   4
   5 The Weather Channel (TM) funded Tungsten Graphics to develop the
   6 initial release of the Radeon 8500 driver under the XFree86 license.
   7 This notice must be preserved.
   8
   9 Permission is hereby granted, free of charge, to any person obtaining
  10 a copy of this software and associated documentation files (the
  11 "Software"), to deal in the Software without restriction, including
  12 without limitation the rights to use, copy, modify, merge, publish,
  13 distribute, sublicense, and/or sell copies of the Software, and to
  14 permit persons to whom the Software is furnished to do so, subject to
  15 the following conditions:
  16
  17 The above copyright notice and this permission notice (including the
  18 next paragraph) shall be included in all copies or substantial
  19 portions of the Software.
  20
  21 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  24 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  25 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28
  29 **************************************************************************/
  30
  31 /*
  32  * Authors:
  33  *   Keith Whitwell <keith@tungstengraphics.com>
  34  */
  35
  36 #include "glheader.h"
  37 #include "api_arrayelt.h"
  38 #include "context.h"
  39 #include "simple_list.h"
  40 #include "imports.h"
  41 #include "matrix.h"
  42 #include "extensions.h"
  43 #include "state.h"
  44
  45 #include "swrast/swrast.h"
  46 #include "swrast_setup/swrast_setup.h"
  47 #include "array_cache/acache.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_vtxfmt.h"
  63 #include "r200_maos.h"
  64
  65 #define DRIVER_DATE     "20041007"
  66
  67 #include "vblank.h"
  68 #include "utils.h"
  69 #include "xmlpool.h" /* for symbolic values of enum-type options */
  70 #ifndef R200_DEBUG
  71 int R200_DEBUG = (0);
  72 #endif
  73
  74
  75 /* Return the width and height of the given buffer.
  76  */
  77 static void r200GetBufferSize( GLframebuffer *buffer,
  78                                GLuint *width, GLuint *height )
  79 {
  80    GET_CURRENT_CONTEXT(ctx);
  81    r200ContextPtr rmesa = R200_CONTEXT(ctx);
  82
  83    LOCK_HARDWARE( rmesa );
  84    *width  = rmesa->dri.drawable->w;
  85    *height = rmesa->dri.drawable->h;
  86    UNLOCK_HARDWARE( rmesa );
  87 }
  88
  89 /* Return various strings for glGetString().
  90  */
  91 static const GLubyte *r200GetString( GLcontext *ctx, GLenum name )
  92 {
  93    r200ContextPtr rmesa = R200_CONTEXT(ctx);
  94    static char buffer[128];
  95    unsigned   offset;
  96    GLuint agp_mode = rmesa->r200Screen->IsPCI ? 0 :
  97       rmesa->r200Screen->AGPMode;
  98
  99    switch ( name ) {
 100    case GL_VENDOR:
 101       return (GLubyte *)"Tungsten Graphics, Inc.";
 102
 103    case GL_RENDERER:
 104       offset = driGetRendererString( buffer, "R200", DRIVER_DATE,
 105                                      agp_mode );
 106
 107       sprintf( & buffer[ offset ], " %sTCL",
 108                !(rmesa->TclFallback & R200_TCL_FALLBACK_TCL_DISABLE)
 109                ? "" : "NO-" );
 110
 111       return (GLubyte *)buffer;
 112
 113    default:
 114       return NULL;
 115    }
 116 }
 117
 118
 119 /* Extension strings exported by the R200 driver.
 120  */
 121 static const char * const card_extensions[] =
 122 {
 123     "GL_ARB_multisample",
 124     "GL_ARB_multitexture",
 125     "GL_ARB_texture_border_clamp",
 126     "GL_ARB_texture_compression",
 127     "GL_ARB_texture_env_add",
 128     "GL_ARB_texture_env_combine",
 129     "GL_ARB_texture_env_dot3",
 130     "GL_ARB_texture_mirrored_repeat",
 131     "GL_ARB_vertex_buffer_object",
 132     "GL_EXT_blend_minmax",
 133     "GL_EXT_blend_subtract",
 134     "GL_EXT_secondary_color",
 135     "GL_EXT_stencil_wrap",
 136     "GL_EXT_texture_edge_clamp",
 137     "GL_EXT_texture_env_combine",
 138     "GL_EXT_texture_env_dot3",
 139     "GL_EXT_texture_filter_anisotropic",
 140     "GL_EXT_texture_lod_bias",
 141     "GL_EXT_texture_mirror_clamp",
 142     "GL_EXT_texture_rectangle",
 143     "GL_ATI_texture_env_combine3",
 144     "GL_ATI_texture_mirror_once",
 145     "GL_MESA_pack_invert",
 146     "GL_MESA_ycbcr_texture",
 147     "GL_NV_blend_square",
 148     "GL_SGIS_generate_mipmap",
 149     NULL
 150 };
 151
 152 extern const struct tnl_pipeline_stage _r200_render_stage;
 153 extern const struct tnl_pipeline_stage _r200_tcl_stage;
 154
 155 static const struct tnl_pipeline_stage *r200_pipeline[] = {
 156
 157    /* Try and go straight to t&l
 158     */
 159    &_r200_tcl_stage,
 160
 161    /* Catch any t&l fallbacks
 162     */
 163    &_tnl_vertex_transform_stage,
 164    &_tnl_normal_transform_stage,
 165    &_tnl_lighting_stage,
 166    &_tnl_fog_coordinate_stage,
 167    &_tnl_texgen_stage,
 168    &_tnl_texture_transform_stage,
 169    &_tnl_vertex_program_stage,
 170
 171    /* Try again to go to tcl?
 172     *     - no good for asymmetric-twoside (do with multipass)
 173     *     - no good for asymmetric-unfilled (do with multipass)
 174     *     - good for material
 175     *     - good for texgen
 176     *     - need to manipulate a bit of state
 177     *
 178     * - worth it/not worth it?
 179     */
 180
 181    /* Else do them here.
 182     */
 183 /*    &_r200_render_stage,  */ /* FIXME: bugs with ut2003 */
 184    &_tnl_render_stage,          /* FALLBACK:  */
 185    0,
 186 };
 187
 188
 189
 190 /* Initialize the driver's misc functions.
 191  */
 192 static void r200InitDriverFuncs( struct dd_function_table *functions )
 193 {
 194     functions->GetBufferSize            = r200GetBufferSize;
 195     functions->ResizeBuffers           = _swrast_alloc_buffers;
 196     functions->GetString                = r200GetString;
 197
 198     functions->Error                    = NULL;
 199     functions->DrawPixels               = NULL;
 200     functions->Bitmap                   = NULL;
 201 }
 202
 203 static const struct dri_debug_control debug_control[] =
 204 {
 205     { "fall",  DEBUG_FALLBACKS },
 206     { "tex",   DEBUG_TEXTURE },
 207     { "ioctl", DEBUG_IOCTL },
 208     { "prim",  DEBUG_PRIMS },
 209     { "vert",  DEBUG_VERTS },
 210     { "state", DEBUG_STATE },
 211     { "code",  DEBUG_CODEGEN },
 212     { "vfmt",  DEBUG_VFMT },
 213     { "vtxf",  DEBUG_VFMT },
 214     { "verb",  DEBUG_VERBOSE },
 215     { "dri",   DEBUG_DRI },
 216     { "dma",   DEBUG_DMA },
 217     { "san",   DEBUG_SANITY },
 218     { "sync",  DEBUG_SYNC },
 219     { "pix",   DEBUG_PIXEL },
 220     { "mem",   DEBUG_MEMORY },
 221     { NULL,    0 }
 222 };
 223
 224
 225 static int
 226 get_ust_nop( int64_t * ust )
 227 {
 228    *ust = 1;
 229    return 0;
 230 }
 231
 232
 233 /* Create the device specific rendering context.
 234  */
 235 GLboolean r200CreateContext( const __GLcontextModes *glVisual,
 236                              __DRIcontextPrivate *driContextPriv,
 237                              void *sharedContextPrivate)
 238 {
 239    __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv;
 240    r200ScreenPtr screen = (r200ScreenPtr)(sPriv->private);
 241    struct dd_function_table functions;
 242    r200ContextPtr rmesa;
 243    GLcontext *ctx, *shareCtx;
 244    int i;
 245    int tcl_mode, fthrottle_mode;
 246
 247    assert(glVisual);
 248    assert(driContextPriv);
 249    assert(screen);
 250
 251    /* Allocate the R200 context */
 252    rmesa = (r200ContextPtr) CALLOC( sizeof(*rmesa) );
 253    if ( !rmesa )
 254       return GL_FALSE;
 255
 256    /* Parse configuration files.
 257     * Do this here so that initialMaxAnisotropy is set before we create
 258     * the default textures.
 259     */
 260    driParseConfigFiles (&rmesa->optionCache, &screen->optionCache,
 261                         screen->driScreen->myNum, "r200");
 262    rmesa->initialMaxAnisotropy = driQueryOptionf(&rmesa->optionCache,
 263                                                  "def_max_anisotropy");
 264
 265    /* Init default driver functions then plug in our R200-specific functions
 266     * (the texture functions are especially important)
 267     */
 268    _mesa_init_driver_functions(&functions);
 269    r200InitDriverFuncs(&functions);
 270    r200InitIoctlFuncs(&functions);
 271    r200InitStateFuncs(&functions);
 272    r200InitTextureFuncs(&functions);
 273
 274    /* Allocate and initialize the Mesa context */
 275    if (sharedContextPrivate)
 276       shareCtx = ((r200ContextPtr) sharedContextPrivate)->glCtx;
 277    else
 278       shareCtx = NULL;
 279    rmesa->glCtx = _mesa_create_context(glVisual, shareCtx,
 280                                        &functions, (void *) rmesa);
 281    if (!rmesa->glCtx) {
 282       FREE(rmesa);
 283       return GL_FALSE;
 284    }
 285    driContextPriv->driverPrivate = rmesa;
 286
 287    /* Init r200 context data */
 288    rmesa->dri.context = driContextPriv;
 289    rmesa->dri.screen = sPriv;
 290    rmesa->dri.drawable = NULL; /* Set by XMesaMakeCurrent */
 291    rmesa->dri.hwContext = driContextPriv->hHWContext;
 292    rmesa->dri.hwLock = &sPriv->pSAREA->lock;
 293    rmesa->dri.fd = sPriv->fd;
 294    rmesa->dri.drmMinor = sPriv->drmMinor;
 295
 296    rmesa->r200Screen = screen;
 297    rmesa->sarea = (drm_radeon_sarea_t *)((GLubyte *)sPriv->pSAREA +
 298                                        screen->sarea_priv_offset);
 299
 300
 301    rmesa->dma.buf0_address = rmesa->r200Screen->buffers->list[0].address;
 302
 303    (void) memset( rmesa->texture_heaps, 0, sizeof( rmesa->texture_heaps ) );
 304    make_empty_list( & rmesa->swapped );
 305
 306    rmesa->nr_heaps = 1 /* screen->numTexHeaps */ ;
 307    assert(rmesa->nr_heaps < R200_NR_TEX_HEAPS);
 308    for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
 309       rmesa->texture_heaps[i] = driCreateTextureHeap( i, rmesa,
 310             screen->texSize[i],
 311             12,
 312             RADEON_NR_TEX_REGIONS,
 313             (drmTextureRegionPtr)rmesa->sarea->tex_list[i],
 314             & rmesa->sarea->tex_age[i],
 315             & rmesa->swapped,
 316             sizeof( r200TexObj ),
 317             (destroy_texture_object_t *) r200DestroyTexObj );
 318    }
 319    rmesa->texture_depth = driQueryOptioni (&rmesa->optionCache,
 320                                            "texture_depth");
 321    if (rmesa->texture_depth == DRI_CONF_TEXTURE_DEPTH_FB)
 322       rmesa->texture_depth = ( screen->cpp == 4 ) ?
 323          DRI_CONF_TEXTURE_DEPTH_32 : DRI_CONF_TEXTURE_DEPTH_16;
 324
 325    rmesa->swtcl.RenderIndex = ~0;
 326    rmesa->hw.all_dirty = 1;
 327
 328    /* Set the maximum texture size small enough that we can guarentee that
 329     * all texture units can bind a maximal texture and have them both in
 330     * texturable memory at once.
 331     */
 332
 333    ctx = rmesa->glCtx;
 334    ctx->Const.MaxTextureUnits = driQueryOptioni (&rmesa->optionCache,
 335                                                  "texture_units");
 336    ctx->Const.MaxTextureImageUnits = ctx->Const.MaxTextureUnits;
 337    ctx->Const.MaxTextureCoordUnits = ctx->Const.MaxTextureUnits;
 338
 339    driCalculateMaxTextureLevels( rmesa->texture_heaps,
 340                                  rmesa->nr_heaps,
 341                                  & ctx->Const,
 342                                  4,
 343                                  11, /* max 2D texture size is 2048x2048 */
 344 #if ENABLE_HW_3D_TEXTURE
 345                                  8,  /* max 3D texture size is 256^3 */
 346 #else
 347                                  0,  /* 3D textures unsupported */
 348 #endif
 349                                  11, /* max cube texture size is 2048x2048 */
 350                                  11, /* max texture rectangle size is 2048x2048 */
 351                                  12,
 352                                  GL_FALSE );
 353
 354    ctx->Const.MaxTextureMaxAnisotropy = 16.0;
 355
 356    /* No wide points.
 357     */
 358    ctx->Const.MinPointSize = 1.0;
 359    ctx->Const.MinPointSizeAA = 1.0;
 360    ctx->Const.MaxPointSize = 1.0;
 361    ctx->Const.MaxPointSizeAA = 1.0;
 362
 363    ctx->Const.MinLineWidth = 1.0;
 364    ctx->Const.MinLineWidthAA = 1.0;
 365    ctx->Const.MaxLineWidth = 10.0;
 366    ctx->Const.MaxLineWidthAA = 10.0;
 367    ctx->Const.LineWidthGranularity = 0.0625;
 368
 369    /* Initialize the software rasterizer and helper modules.
 370     */
 371    _swrast_CreateContext( ctx );
 372    _ac_CreateContext( ctx );
 373    _tnl_CreateContext( ctx );
 374    _swsetup_CreateContext( ctx );
 375    _ae_create_context( ctx );
 376
 377    /* Install the customized pipeline:
 378     */
 379    _tnl_destroy_pipeline( ctx );
 380    _tnl_install_pipeline( ctx, r200_pipeline );
 381    ctx->Driver.FlushVertices = r200FlushVertices;
 382
 383    /* Try and keep materials and vertices separate:
 384     */
 385    _tnl_isolate_materials( ctx, GL_TRUE );
 386
 387
 388    /* Configure swrast and TNL to match hardware characteristics:
 389     */
 390    _swrast_allow_pixel_fog( ctx, GL_FALSE );
 391    _swrast_allow_vertex_fog( ctx, GL_TRUE );
 392    _tnl_allow_pixel_fog( ctx, GL_FALSE );
 393    _tnl_allow_vertex_fog( ctx, GL_TRUE );
 394
 395
 396    for ( i = 0 ; i < R200_MAX_TEXTURE_UNITS ; i++ ) {
 397       _math_matrix_ctr( &rmesa->TexGenMatrix[i] );
 398       _math_matrix_set_identity( &rmesa->TexGenMatrix[i] );
 399    }
 400    _math_matrix_ctr( &rmesa->tmpmat );
 401    _math_matrix_set_identity( &rmesa->tmpmat );
 402
 403    driInitExtensions( ctx, card_extensions, GL_TRUE );
 404    if (rmesa->glCtx->Mesa_DXTn) {
 405       _mesa_enable_extension( ctx, "GL_EXT_texture_compression_s3tc" );
 406       _mesa_enable_extension( ctx, "GL_S3_s3tc" );
 407    }
 408    else if (driQueryOptionb (&rmesa->optionCache, "force_s3tc_enable")) {
 409       _mesa_enable_extension( ctx, "GL_EXT_texture_compression_s3tc" );
 410    }
 411
 412    if (rmesa->r200Screen->drmSupportsCubeMaps)
 413       _mesa_enable_extension( ctx, "GL_ARB_texture_cube_map" );
 414    if (rmesa->r200Screen->drmSupportsBlendColor) {
 415       _mesa_enable_extension( ctx, "GL_EXT_blend_equation_separate" );
 416       _mesa_enable_extension( ctx, "GL_EXT_blend_func_separate" );
 417    }
 418    if(driQueryOptionb(&rmesa->optionCache, "arb_vertex_program"))
 419       _mesa_enable_extension( ctx, "GL_ARB_vertex_program");
 420    if(driQueryOptionb(&rmesa->optionCache, "nv_vertex_program"))
 421       _mesa_enable_extension( ctx, "GL_NV_vertex_program");
 422
 423 #if 0
 424    r200InitDriverFuncs( ctx );
 425    r200InitIoctlFuncs( ctx );
 426    r200InitStateFuncs( ctx );
 427    r200InitTextureFuncs( ctx );
 428 #endif
 429    /* plug in a few more device driver functions */
 430    /* XXX these should really go right after _mesa_init_driver_functions() */
 431    r200InitPixelFuncs( ctx );
 432    r200InitSpanFuncs( ctx );
 433    r200InitTnlFuncs( ctx );
 434    r200InitState( rmesa );
 435    r200InitSwtcl( ctx );
 436
 437    fthrottle_mode = driQueryOptioni(&rmesa->optionCache, "fthrottle_mode");
 438    rmesa->iw.irq_seq = -1;
 439    rmesa->irqsEmitted = 0;
 440    rmesa->do_irqs = (rmesa->dri.drmMinor >= 6 &&
 441                      fthrottle_mode == DRI_CONF_FTHROTTLE_IRQS &&
 442                      rmesa->r200Screen->irq);
 443
 444    rmesa->do_usleeps = (fthrottle_mode == DRI_CONF_FTHROTTLE_USLEEPS);
 445
 446    if (!rmesa->do_irqs)
 447       fprintf(stderr,
 448               "IRQ's not enabled, falling back to %s: %d %d %d\n",
 449               rmesa->do_usleeps ? "usleeps" : "busy waits",
 450               rmesa->dri.drmMinor,
 451               fthrottle_mode,
 452               rmesa->r200Screen->irq);
 453
 454    rmesa->vblank_flags = (rmesa->r200Screen->irq != 0)
 455        ? driGetDefaultVBlankFlags(&rmesa->optionCache) : VBLANK_FLAG_NO_IRQ;
 456
 457    rmesa->prefer_gart_client_texturing =
 458       (getenv("R200_GART_CLIENT_TEXTURES") != 0);
 459
 460    rmesa->get_ust = (PFNGLXGETUSTPROC) glXGetProcAddress( (const GLubyte *) "__glXGetUST" );
 461    if ( rmesa->get_ust == NULL ) {
 462       rmesa->get_ust = get_ust_nop;
 463    }
 464    (*rmesa->get_ust)( & rmesa->swap_ust );
 465
 466
 467 #if DO_DEBUG
 468    R200_DEBUG  = driParseDebugString( getenv( "R200_DEBUG" ),
 469                                       debug_control );
 470    R200_DEBUG |= driParseDebugString( getenv( "RADEON_DEBUG" ),
 471                                       debug_control );
 472 #endif
 473
 474    tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
 475    if (driQueryOptionb(&rmesa->optionCache, "no_rast")) {
 476       fprintf(stderr, "disabling 3D acceleration\n");
 477       FALLBACK(rmesa, R200_FALLBACK_DISABLE, 1);
 478    }
 479    else if (tcl_mode == DRI_CONF_TCL_SW || getenv("R200_NO_TCL") ||
 480             !(rmesa->r200Screen->chipset & R200_CHIPSET_TCL)) {
 481       if (rmesa->r200Screen->chipset & R200_CHIPSET_TCL) {
 482          rmesa->r200Screen->chipset &= ~R200_CHIPSET_TCL;
 483          fprintf(stderr, "Disabling HW TCL support\n");
 484       }
 485       TCL_FALLBACK(rmesa->glCtx, R200_TCL_FALLBACK_TCL_DISABLE, 1);
 486    }
 487    if (rmesa->r200Screen->chipset & R200_CHIPSET_TCL) {
 488       if (tcl_mode >= DRI_CONF_TCL_VTXFMT && !getenv("R200_NO_VTXFMT")) {
 489          r200VtxfmtInit( ctx, tcl_mode >= DRI_CONF_TCL_CODEGEN );
 490       }
 491       _tnl_need_dlist_norm_lengths( ctx, GL_FALSE );
 492    }
 493    return GL_TRUE;
 494 }
 495
 496
 497 /* Destroy the device specific context.
 498  */
 499 /* Destroy the Mesa and driver specific context data.
 500  */
 501 void r200DestroyContext( __DRIcontextPrivate *driContextPriv )
 502 {
 503    GET_CURRENT_CONTEXT(ctx);
 504    r200ContextPtr rmesa = (r200ContextPtr) driContextPriv->driverPrivate;
 505    r200ContextPtr current = ctx ? R200_CONTEXT(ctx) : NULL;
 506
 507    /* check if we're deleting the currently bound context */
 508    if (rmesa == current) {
 509       R200_FIREVERTICES( rmesa );
 510       _mesa_make_current2(NULL, NULL, NULL);
 511    }
 512
 513    /* Free r200 context resources */
 514    assert(rmesa); /* should never be null */
 515    if ( rmesa ) {
 516       GLboolean   release_texture_heaps;
 517
 518
 519       release_texture_heaps = (rmesa->glCtx->Shared->RefCount == 1);
 520       _swsetup_DestroyContext( rmesa->glCtx );
 521       _tnl_DestroyContext( rmesa->glCtx );
 522       _ac_DestroyContext( rmesa->glCtx );
 523       _swrast_DestroyContext( rmesa->glCtx );
 524
 525       r200DestroySwtcl( rmesa->glCtx );
 526       r200ReleaseArrays( rmesa->glCtx, ~0 );
 527
 528       if (rmesa->dma.current.buf) {
 529          r200ReleaseDmaRegion( rmesa, &rmesa->dma.current, __FUNCTION__ );
 530          r200FlushCmdBuf( rmesa, __FUNCTION__ );
 531       }
 532
 533       if (!(rmesa->TclFallback & R200_TCL_FALLBACK_TCL_DISABLE)) {
 534          int tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
 535          if (tcl_mode >= DRI_CONF_TCL_VTXFMT)
 536             r200VtxfmtDestroy( rmesa->glCtx );
 537       }
 538
 539       /* free the Mesa context */
 540       rmesa->glCtx->DriverCtx = NULL;
 541       _mesa_destroy_context( rmesa->glCtx );
 542
 543       if (rmesa->state.scissor.pClipRects) {
 544          FREE(rmesa->state.scissor.pClipRects);
 545          rmesa->state.scissor.pClipRects = 0;
 546       }
 547
 548       if ( release_texture_heaps ) {
 549          /* This share group is about to go away, free our private
 550           * texture object data.
 551           */
 552          int i;
 553
 554          for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
 555             driDestroyTextureHeap( rmesa->texture_heaps[ i ] );
 556             rmesa->texture_heaps[ i ] = NULL;
 557          }
 558
 559          assert( is_empty_list( & rmesa->swapped ) );
 560       }
 561
 562       /* free the option cache */
 563       driDestroyOptionCache (&rmesa->optionCache);
 564
 565       FREE( rmesa );
 566    }
 567 }
 568
 569
 570
 571
 572 void
 573 r200SwapBuffers( __DRIdrawablePrivate *dPriv )
 574 {
 575    if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
 576       r200ContextPtr rmesa;
 577       GLcontext *ctx;
 578       rmesa = (r200ContextPtr) dPriv->driContextPriv->driverPrivate;
 579       ctx = rmesa->glCtx;
 580       if (ctx->Visual.doubleBufferMode) {
 581          _mesa_notifySwapBuffers( ctx );  /* flush pending rendering comands */
 582          if ( rmesa->doPageFlip ) {
 583             r200PageFlip( dPriv );
 584          }
 585          else {
 586             r200CopyBuffer( dPriv );
 587          }
 588       }
 589    }
 590    else {
 591       /* XXX this shouldn't be an error but we can't handle it for now */
 592       _mesa_problem(NULL, "%s: drawable has no context!", __FUNCTION__);
 593    }
 594 }
 595
 596
 597 /* Force the context `c' to be the current context and associate with it
 598  * buffer `b'.
 599  */
 600 GLboolean
 601 r200MakeCurrent( __DRIcontextPrivate *driContextPriv,
 602                    __DRIdrawablePrivate *driDrawPriv,
 603                    __DRIdrawablePrivate *driReadPriv )
 604 {
 605    if ( driContextPriv ) {
 606       r200ContextPtr newCtx =
 607          (r200ContextPtr) driContextPriv->driverPrivate;
 608
 609       if (R200_DEBUG & DEBUG_DRI)
 610          fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *)newCtx->glCtx);
 611
 612       if ( newCtx->dri.drawable != driDrawPriv ) {
 613          driDrawableInitVBlank( driDrawPriv, newCtx->vblank_flags );
 614          newCtx->dri.drawable = driDrawPriv;
 615          r200UpdateWindow( newCtx->glCtx );
 616          r200UpdateViewportOffset( newCtx->glCtx );
 617       }
 618
 619       _mesa_make_current2( newCtx->glCtx,
 620                            (GLframebuffer *) driDrawPriv->driverPrivate,
 621                            (GLframebuffer *) driReadPriv->driverPrivate );
 622
 623       if ( !newCtx->glCtx->Viewport.Width ) {
 624          _mesa_set_viewport( newCtx->glCtx, 0, 0,
 625                              driDrawPriv->w, driDrawPriv->h );
 626       }
 627
 628       if (newCtx->vb.enabled)
 629          r200VtxfmtMakeCurrent( newCtx->glCtx );
 630
 631       _mesa_update_state( newCtx->glCtx );
 632       r200ValidateState( newCtx->glCtx );
 633
 634    } else {
 635       if (R200_DEBUG & DEBUG_DRI)
 636          fprintf(stderr, "%s ctx is null\n", __FUNCTION__);
 637       _mesa_make_current( 0, 0 );
 638    }
 639
 640    if (R200_DEBUG & DEBUG_DRI)
 641       fprintf(stderr, "End %s\n", __FUNCTION__);
 642    return GL_TRUE;
 643 }
 644
 645 /* Force the context `c' to be unbound from its buffer.
 646  */
 647 GLboolean
 648 r200UnbindContext( __DRIcontextPrivate *driContextPriv )
 649 {
 650    r200ContextPtr rmesa = (r200ContextPtr) driContextPriv->driverPrivate;
 651
 652    if (R200_DEBUG & DEBUG_DRI)
 653       fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *)rmesa->glCtx);
 654
 655    r200VtxfmtUnbindContext( rmesa->glCtx );
 656    return GL_TRUE;
 657 }