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     "20030328"
  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
 170    /* Try again to go to tcl?
 171     *     - no good for asymmetric-twoside (do with multipass)
 172     *     - no good for asymmetric-unfilled (do with multipass)
 173     *     - good for material
 174     *     - good for texgen
 175     *     - need to manipulate a bit of state
 176     *
 177     * - worth it/not worth it?
 178     */
 179
 180    /* Else do them here.
 181     */
 182 /*    &_r200_render_stage,  */ /* FIXME: bugs with ut2003 */
 183    &_tnl_render_stage,          /* FALLBACK:  */
 184    0,
 185 };
 186
 187
 188
 189 /* Initialize the driver's misc functions.
 190  */
 191 static void r200InitDriverFuncs( struct dd_function_table *functions )
 192 {
 193     functions->GetBufferSize            = r200GetBufferSize;
 194     functions->ResizeBuffers           = _swrast_alloc_buffers;
 195     functions->GetString                = r200GetString;
 196
 197     functions->Error                    = NULL;
 198     functions->DrawPixels               = NULL;
 199     functions->Bitmap                   = NULL;
 200 }
 201
 202 static const struct dri_debug_control debug_control[] =
 203 {
 204     { "fall",  DEBUG_FALLBACKS },
 205     { "tex",   DEBUG_TEXTURE },
 206     { "ioctl", DEBUG_IOCTL },
 207     { "prim",  DEBUG_PRIMS },
 208     { "vert",  DEBUG_VERTS },
 209     { "state", DEBUG_STATE },
 210     { "code",  DEBUG_CODEGEN },
 211     { "vfmt",  DEBUG_VFMT },
 212     { "vtxf",  DEBUG_VFMT },
 213     { "verb",  DEBUG_VERBOSE },
 214     { "dri",   DEBUG_DRI },
 215     { "dma",   DEBUG_DMA },
 216     { "san",   DEBUG_SANITY },
 217     { "sync",  DEBUG_SYNC },
 218     { "pix",   DEBUG_PIXEL },
 219     { "mem",   DEBUG_MEMORY },
 220     { NULL,    0 }
 221 };
 222
 223
 224 static int
 225 get_ust_nop( int64_t * ust )
 226 {
 227    *ust = 1;
 228    return 0;
 229 }
 230
 231
 232 /* Create the device specific rendering context.
 233  */
 234 GLboolean r200CreateContext( const __GLcontextModes *glVisual,
 235                              __DRIcontextPrivate *driContextPriv,
 236                              void *sharedContextPrivate)
 237 {
 238    __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv;
 239    r200ScreenPtr screen = (r200ScreenPtr)(sPriv->private);
 240    struct dd_function_table functions;
 241    r200ContextPtr rmesa;
 242    GLcontext *ctx, *shareCtx;
 243    int i;
 244    int tcl_mode, fthrottle_mode;
 245
 246    assert(glVisual);
 247    assert(driContextPriv);
 248    assert(screen);
 249
 250    /* Allocate the R200 context */
 251    rmesa = (r200ContextPtr) CALLOC( sizeof(*rmesa) );
 252    if ( !rmesa )
 253       return GL_FALSE;
 254
 255    /* Parse configuration files.
 256     * Do this here so that initialMaxAnisotropy is set before we create
 257     * the default textures.
 258     */
 259    driParseConfigFiles (&rmesa->optionCache, &screen->optionCache,
 260                         screen->driScreen->myNum, "r200");
 261    rmesa->initialMaxAnisotropy = driQueryOptionf(&rmesa->optionCache,
 262                                                  "def_max_anisotropy");
 263
 264    /* Init default driver functions then plug in our R200-specific functions
 265     * (the texture functions are especially important)
 266     */
 267    _mesa_init_driver_functions(&functions);
 268    r200InitDriverFuncs(&functions);
 269    r200InitIoctlFuncs(&functions);
 270    r200InitStateFuncs(&functions);
 271    r200InitTextureFuncs(&functions);
 272
 273    /* Allocate and initialize the Mesa context */
 274    if (sharedContextPrivate)
 275       shareCtx = ((r200ContextPtr) sharedContextPrivate)->glCtx;
 276    else
 277       shareCtx = NULL;
 278    rmesa->glCtx = _mesa_create_context(glVisual, shareCtx,
 279                                        &functions, (void *) rmesa);
 280    if (!rmesa->glCtx) {
 281       FREE(rmesa);
 282       return GL_FALSE;
 283    }
 284    driContextPriv->driverPrivate = rmesa;
 285
 286    /* Init r200 context data */
 287    rmesa->dri.context = driContextPriv;
 288    rmesa->dri.screen = sPriv;
 289    rmesa->dri.drawable = NULL; /* Set by XMesaMakeCurrent */
 290    rmesa->dri.hwContext = driContextPriv->hHWContext;
 291    rmesa->dri.hwLock = &sPriv->pSAREA->lock;
 292    rmesa->dri.fd = sPriv->fd;
 293    rmesa->dri.drmMinor = sPriv->drmMinor;
 294
 295    rmesa->r200Screen = screen;
 296    rmesa->sarea = (drm_radeon_sarea_t *)((GLubyte *)sPriv->pSAREA +
 297                                        screen->sarea_priv_offset);
 298
 299
 300    rmesa->dma.buf0_address = rmesa->r200Screen->buffers->list[0].address;
 301
 302    (void) memset( rmesa->texture_heaps, 0, sizeof( rmesa->texture_heaps ) );
 303    make_empty_list( & rmesa->swapped );
 304
 305    rmesa->nr_heaps = 1 /* screen->numTexHeaps */ ;
 306    assert(rmesa->nr_heaps < R200_NR_TEX_HEAPS);
 307    for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
 308       rmesa->texture_heaps[i] = driCreateTextureHeap( i, rmesa,
 309             screen->texSize[i],
 310             12,
 311             RADEON_NR_TEX_REGIONS,
 312             (drmTextureRegionPtr)rmesa->sarea->tex_list[i],
 313             & rmesa->sarea->tex_age[i],
 314             & rmesa->swapped,
 315             sizeof( r200TexObj ),
 316             (destroy_texture_object_t *) r200DestroyTexObj );
 317    }
 318    rmesa->texture_depth = driQueryOptioni (&rmesa->optionCache,
 319                                            "texture_depth");
 320    if (rmesa->texture_depth == DRI_CONF_TEXTURE_DEPTH_FB)
 321       rmesa->texture_depth = ( screen->cpp == 4 ) ?
 322          DRI_CONF_TEXTURE_DEPTH_32 : DRI_CONF_TEXTURE_DEPTH_16;
 323
 324    rmesa->swtcl.RenderIndex = ~0;
 325    rmesa->lost_context = 1;
 326
 327    /* Set the maximum texture size small enough that we can guarentee that
 328     * all texture units can bind a maximal texture and have them both in
 329     * texturable memory at once.
 330     */
 331
 332    ctx = rmesa->glCtx;
 333    ctx->Const.MaxTextureUnits = driQueryOptioni (&rmesa->optionCache,
 334                                                  "texture_units");
 335    ctx->Const.MaxTextureImageUnits = ctx->Const.MaxTextureUnits;
 336    ctx->Const.MaxTextureCoordUnits = ctx->Const.MaxTextureUnits;
 337
 338    driCalculateMaxTextureLevels( rmesa->texture_heaps,
 339                                  rmesa->nr_heaps,
 340                                  & ctx->Const,
 341                                  4,
 342                                  11, /* max 2D texture size is 2048x2048 */
 343 #if ENABLE_HW_3D_TEXTURE
 344                                  8,  /* max 3D texture size is 256^3 */
 345 #else
 346                                  0,  /* 3D textures unsupported */
 347 #endif
 348                                  11, /* max cube texture size is 2048x2048 */
 349                                  11, /* max texture rectangle size is 2048x2048 */
 350                                  12,
 351                                  GL_FALSE );
 352
 353    ctx->Const.MaxTextureMaxAnisotropy = 16.0;
 354
 355    /* No wide points.
 356     */
 357    ctx->Const.MinPointSize = 1.0;
 358    ctx->Const.MinPointSizeAA = 1.0;
 359    ctx->Const.MaxPointSize = 1.0;
 360    ctx->Const.MaxPointSizeAA = 1.0;
 361
 362    ctx->Const.MinLineWidth = 1.0;
 363    ctx->Const.MinLineWidthAA = 1.0;
 364    ctx->Const.MaxLineWidth = 10.0;
 365    ctx->Const.MaxLineWidthAA = 10.0;
 366    ctx->Const.LineWidthGranularity = 0.0625;
 367
 368    /* Initialize the software rasterizer and helper modules.
 369     */
 370    _swrast_CreateContext( ctx );
 371    _ac_CreateContext( ctx );
 372    _tnl_CreateContext( ctx );
 373    _swsetup_CreateContext( ctx );
 374    _ae_create_context( ctx );
 375
 376    /* Install the customized pipeline:
 377     */
 378    _tnl_destroy_pipeline( ctx );
 379    _tnl_install_pipeline( ctx, r200_pipeline );
 380    ctx->Driver.FlushVertices = r200FlushVertices;
 381
 382    /* Try and keep materials and vertices separate:
 383     */
 384    _tnl_isolate_materials( ctx, GL_TRUE );
 385
 386
 387    /* Configure swrast and TNL to match hardware characteristics:
 388     */
 389    _swrast_allow_pixel_fog( ctx, GL_FALSE );
 390    _swrast_allow_vertex_fog( ctx, GL_TRUE );
 391    _tnl_allow_pixel_fog( ctx, GL_FALSE );
 392    _tnl_allow_vertex_fog( ctx, GL_TRUE );
 393
 394
 395    for ( i = 0 ; i < R200_MAX_TEXTURE_UNITS ; i++ ) {
 396       _math_matrix_ctr( &rmesa->TexGenMatrix[i] );
 397       _math_matrix_set_identity( &rmesa->TexGenMatrix[i] );
 398    }
 399    _math_matrix_ctr( &rmesa->tmpmat );
 400    _math_matrix_set_identity( &rmesa->tmpmat );
 401
 402    driInitExtensions( ctx, card_extensions, GL_TRUE );
 403    if (rmesa->r200Screen->drmSupportsCubeMaps)
 404       _mesa_enable_extension( ctx, "GL_ARB_texture_cube_map" );
 405    if (rmesa->r200Screen->drmSupportsBlendColor) {
 406       _mesa_enable_extension( ctx, "GL_EXT_blend_equation_separate" );
 407       _mesa_enable_extension( ctx, "GL_EXT_blend_func_separate" );
 408    }
 409
 410 #if 0
 411    r200InitDriverFuncs( ctx );
 412    r200InitIoctlFuncs( ctx );
 413    r200InitStateFuncs( ctx );
 414    r200InitTextureFuncs( ctx );
 415 #endif
 416    /* plug in a few more device driver functions */
 417    /* XXX these should really go right after _mesa_init_driver_functions() */
 418    r200InitPixelFuncs( ctx );
 419    r200InitSpanFuncs( ctx );
 420    r200InitTnlFuncs( ctx );
 421    r200InitState( rmesa );
 422    r200InitSwtcl( ctx );
 423
 424    fthrottle_mode = driQueryOptioni(&rmesa->optionCache, "fthrottle_mode");
 425    rmesa->iw.irq_seq = -1;
 426    rmesa->irqsEmitted = 0;
 427    rmesa->do_irqs = (rmesa->dri.drmMinor >= 6 &&
 428                      fthrottle_mode == DRI_CONF_FTHROTTLE_IRQS &&
 429                      rmesa->r200Screen->irq);
 430
 431    rmesa->do_usleeps = (fthrottle_mode == DRI_CONF_FTHROTTLE_USLEEPS);
 432
 433    if (!rmesa->do_irqs)
 434       fprintf(stderr,
 435               "IRQ's not enabled, falling back to %s: %d %d %d\n",
 436               rmesa->do_usleeps ? "usleeps" : "busy waits",
 437               rmesa->dri.drmMinor,
 438               fthrottle_mode,
 439               rmesa->r200Screen->irq);
 440
 441    rmesa->vblank_flags = (rmesa->r200Screen->irq != 0)
 442        ? driGetDefaultVBlankFlags(&rmesa->optionCache) : VBLANK_FLAG_NO_IRQ;
 443
 444    rmesa->prefer_gart_client_texturing =
 445       (getenv("R200_GART_CLIENT_TEXTURES") != 0);
 446
 447    rmesa->get_ust = (PFNGLXGETUSTPROC) glXGetProcAddress( (const GLubyte *) "__glXGetUST" );
 448    if ( rmesa->get_ust == NULL ) {
 449       rmesa->get_ust = get_ust_nop;
 450    }
 451    (*rmesa->get_ust)( & rmesa->swap_ust );
 452
 453
 454 #if DO_DEBUG
 455    R200_DEBUG  = driParseDebugString( getenv( "R200_DEBUG" ),
 456                                       debug_control );
 457    R200_DEBUG |= driParseDebugString( getenv( "RADEON_DEBUG" ),
 458                                       debug_control );
 459 #endif
 460
 461    tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
 462    if (driQueryOptionb(&rmesa->optionCache, "no_rast")) {
 463       fprintf(stderr, "disabling 3D acceleration\n");
 464       FALLBACK(rmesa, R200_FALLBACK_DISABLE, 1);
 465    }
 466    else if (tcl_mode == DRI_CONF_TCL_SW || getenv("R200_NO_TCL") ||
 467             !(rmesa->r200Screen->chipset & R200_CHIPSET_TCL)) {
 468       if (rmesa->r200Screen->chipset & R200_CHIPSET_TCL) {
 469          rmesa->r200Screen->chipset &= ~R200_CHIPSET_TCL;
 470          fprintf(stderr, "Disabling HW TCL support\n");
 471       }
 472       TCL_FALLBACK(rmesa->glCtx, R200_TCL_FALLBACK_TCL_DISABLE, 1);
 473    }
 474    if (rmesa->r200Screen->chipset & R200_CHIPSET_TCL) {
 475       if (tcl_mode >= DRI_CONF_TCL_VTXFMT && !getenv("R200_NO_VTXFMT")) {
 476          r200VtxfmtInit( ctx, tcl_mode >= DRI_CONF_TCL_CODEGEN );
 477       }
 478       _tnl_need_dlist_norm_lengths( ctx, GL_FALSE );
 479    }
 480    return GL_TRUE;
 481 }
 482
 483
 484 /* Destroy the device specific context.
 485  */
 486 /* Destroy the Mesa and driver specific context data.
 487  */
 488 void r200DestroyContext( __DRIcontextPrivate *driContextPriv )
 489 {
 490    GET_CURRENT_CONTEXT(ctx);
 491    r200ContextPtr rmesa = (r200ContextPtr) driContextPriv->driverPrivate;
 492    r200ContextPtr current = ctx ? R200_CONTEXT(ctx) : NULL;
 493
 494    /* check if we're deleting the currently bound context */
 495    if (rmesa == current) {
 496       R200_FIREVERTICES( rmesa );
 497       _mesa_make_current2(NULL, NULL, NULL);
 498    }
 499
 500    /* Free r200 context resources */
 501    assert(rmesa); /* should never be null */
 502    if ( rmesa ) {
 503       GLboolean   release_texture_heaps;
 504
 505
 506       release_texture_heaps = (rmesa->glCtx->Shared->RefCount == 1);
 507       _swsetup_DestroyContext( rmesa->glCtx );
 508       _tnl_DestroyContext( rmesa->glCtx );
 509       _ac_DestroyContext( rmesa->glCtx );
 510       _swrast_DestroyContext( rmesa->glCtx );
 511
 512       r200DestroySwtcl( rmesa->glCtx );
 513       r200ReleaseArrays( rmesa->glCtx, ~0 );
 514
 515       if (rmesa->dma.current.buf) {
 516          r200ReleaseDmaRegion( rmesa, &rmesa->dma.current, __FUNCTION__ );
 517          r200FlushCmdBuf( rmesa, __FUNCTION__ );
 518       }
 519
 520       if (!(rmesa->TclFallback & R200_TCL_FALLBACK_TCL_DISABLE)) {
 521          int tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
 522          if (tcl_mode >= DRI_CONF_TCL_VTXFMT)
 523             r200VtxfmtDestroy( rmesa->glCtx );
 524       }
 525
 526       /* free the Mesa context */
 527       rmesa->glCtx->DriverCtx = NULL;
 528       _mesa_destroy_context( rmesa->glCtx );
 529
 530       if (rmesa->state.scissor.pClipRects) {
 531          FREE(rmesa->state.scissor.pClipRects);
 532          rmesa->state.scissor.pClipRects = 0;
 533       }
 534
 535       if ( release_texture_heaps ) {
 536          /* This share group is about to go away, free our private
 537           * texture object data.
 538           */
 539          int i;
 540
 541          for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
 542             driDestroyTextureHeap( rmesa->texture_heaps[ i ] );
 543             rmesa->texture_heaps[ i ] = NULL;
 544          }
 545
 546          assert( is_empty_list( & rmesa->swapped ) );
 547       }
 548
 549       /* free the option cache */
 550       driDestroyOptionCache (&rmesa->optionCache);
 551
 552       FREE( rmesa );
 553    }
 554 }
 555
 556
 557
 558
 559 void
 560 r200SwapBuffers( __DRIdrawablePrivate *dPriv )
 561 {
 562    if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
 563       r200ContextPtr rmesa;
 564       GLcontext *ctx;
 565       rmesa = (r200ContextPtr) dPriv->driContextPriv->driverPrivate;
 566       ctx = rmesa->glCtx;
 567       if (ctx->Visual.doubleBufferMode) {
 568          _mesa_notifySwapBuffers( ctx );  /* flush pending rendering comands */
 569          if ( rmesa->doPageFlip ) {
 570             r200PageFlip( dPriv );
 571          }
 572          else {
 573             r200CopyBuffer( dPriv );
 574          }
 575       }
 576    }
 577    else {
 578       /* XXX this shouldn't be an error but we can't handle it for now */
 579       _mesa_problem(NULL, "%s: drawable has no context!", __FUNCTION__);
 580    }
 581 }
 582
 583
 584 /* Force the context `c' to be the current context and associate with it
 585  * buffer `b'.
 586  */
 587 GLboolean
 588 r200MakeCurrent( __DRIcontextPrivate *driContextPriv,
 589                    __DRIdrawablePrivate *driDrawPriv,
 590                    __DRIdrawablePrivate *driReadPriv )
 591 {
 592    if ( driContextPriv ) {
 593       r200ContextPtr newCtx =
 594          (r200ContextPtr) driContextPriv->driverPrivate;
 595
 596       if (R200_DEBUG & DEBUG_DRI)
 597          fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *)newCtx->glCtx);
 598
 599       if ( newCtx->dri.drawable != driDrawPriv ) {
 600          driDrawableInitVBlank( driDrawPriv, newCtx->vblank_flags );
 601          newCtx->dri.drawable = driDrawPriv;
 602          r200UpdateWindow( newCtx->glCtx );
 603          r200UpdateViewportOffset( newCtx->glCtx );
 604       }
 605
 606       _mesa_make_current2( newCtx->glCtx,
 607                            (GLframebuffer *) driDrawPriv->driverPrivate,
 608                            (GLframebuffer *) driReadPriv->driverPrivate );
 609
 610       if ( !newCtx->glCtx->Viewport.Width ) {
 611          _mesa_set_viewport( newCtx->glCtx, 0, 0,
 612                              driDrawPriv->w, driDrawPriv->h );
 613       }
 614
 615       if (newCtx->vb.enabled)
 616          r200VtxfmtMakeCurrent( newCtx->glCtx );
 617
 618       _mesa_update_state( newCtx->glCtx );
 619       r200ValidateState( newCtx->glCtx );
 620
 621    } else {
 622       if (R200_DEBUG & DEBUG_DRI)
 623          fprintf(stderr, "%s ctx is null\n", __FUNCTION__);
 624       _mesa_make_current( 0, 0 );
 625    }
 626
 627    if (R200_DEBUG & DEBUG_DRI)
 628       fprintf(stderr, "End %s\n", __FUNCTION__);
 629    return GL_TRUE;
 630 }
 631
 632 /* Force the context `c' to be unbound from its buffer.
 633  */
 634 GLboolean
 635 r200UnbindContext( __DRIcontextPrivate *driContextPriv )
 636 {
 637    r200ContextPtr rmesa = (r200ContextPtr) driContextPriv->driverPrivate;
 638
 639    if (R200_DEBUG & DEBUG_DRI)
 640       fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *)rmesa->glCtx);
 641
 642    r200VtxfmtUnbindContext( rmesa->glCtx );
 643    return GL_TRUE;
 644 }