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_logic_op",
 133     "GL_EXT_blend_minmax",
 134     "GL_EXT_blend_subtract",
 135     "GL_EXT_secondary_color",
 136     "GL_EXT_stencil_wrap",
 137     "GL_EXT_texture_edge_clamp",
 138     "GL_EXT_texture_env_combine",
 139     "GL_EXT_texture_env_dot3",
 140     "GL_EXT_texture_filter_anisotropic",
 141     "GL_EXT_texture_lod_bias",
 142     "GL_EXT_texture_mirror_clamp",
 143     "GL_EXT_texture_rectangle",
 144     "GL_ATI_texture_env_combine3",
 145     "GL_ATI_texture_mirror_once",
 146     "GL_MESA_pack_invert",
 147     "GL_MESA_ycbcr_texture",
 148     "GL_NV_blend_square",
 149     "GL_SGIS_generate_mipmap",
 150     NULL
 151 };
 152
 153 extern const struct tnl_pipeline_stage _r200_render_stage;
 154 extern const struct tnl_pipeline_stage _r200_tcl_stage;
 155
 156 static const struct tnl_pipeline_stage *r200_pipeline[] = {
 157
 158    /* Try and go straight to t&l
 159     */
 160    &_r200_tcl_stage,
 161
 162    /* Catch any t&l fallbacks
 163     */
 164    &_tnl_vertex_transform_stage,
 165    &_tnl_normal_transform_stage,
 166    &_tnl_lighting_stage,
 167    &_tnl_fog_coordinate_stage,
 168    &_tnl_texgen_stage,
 169    &_tnl_texture_transform_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->lost_context = 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 = 2;
 335    ctx->Const.MaxTextureImageUnits = 2;
 336    ctx->Const.MaxTextureCoordUnits = 2;
 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    _math_matrix_ctr( &rmesa->TexGenMatrix[0] );
 396    _math_matrix_ctr( &rmesa->TexGenMatrix[1] );
 397    _math_matrix_ctr( &rmesa->tmpmat );
 398    _math_matrix_set_identity( &rmesa->TexGenMatrix[0] );
 399    _math_matrix_set_identity( &rmesa->TexGenMatrix[1] );
 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
 406 #if 0
 407    r200InitDriverFuncs( ctx );
 408    r200InitIoctlFuncs( ctx );
 409    r200InitStateFuncs( ctx );
 410    r200InitTextureFuncs( ctx );
 411 #endif
 412    /* plug in a few more device driver functions */
 413    /* XXX these should really go right after _mesa_init_driver_functions() */
 414    r200InitPixelFuncs( ctx );
 415    r200InitSpanFuncs( ctx );
 416    r200InitTnlFuncs( ctx );
 417    r200InitState( rmesa );
 418    r200InitSwtcl( ctx );
 419
 420    fthrottle_mode = driQueryOptioni(&rmesa->optionCache, "fthrottle_mode");
 421    rmesa->iw.irq_seq = -1;
 422    rmesa->irqsEmitted = 0;
 423    rmesa->do_irqs = (rmesa->dri.drmMinor >= 6 &&
 424                      fthrottle_mode == DRI_CONF_FTHROTTLE_IRQS &&
 425                      rmesa->r200Screen->irq);
 426
 427    rmesa->do_usleeps = (fthrottle_mode == DRI_CONF_FTHROTTLE_USLEEPS);
 428
 429    if (!rmesa->do_irqs)
 430       fprintf(stderr,
 431               "IRQ's not enabled, falling back to %s: %d %d %d\n",
 432               rmesa->do_usleeps ? "usleeps" : "busy waits",
 433               rmesa->dri.drmMinor,
 434               fthrottle_mode,
 435               rmesa->r200Screen->irq);
 436
 437    rmesa->vblank_flags = (rmesa->r200Screen->irq != 0)
 438        ? driGetDefaultVBlankFlags(&rmesa->optionCache) : VBLANK_FLAG_NO_IRQ;
 439
 440    rmesa->prefer_gart_client_texturing =
 441       (getenv("R200_GART_CLIENT_TEXTURES") != 0);
 442 #ifndef _SOLO
 443    rmesa->get_ust = (PFNGLXGETUSTPROC) glXGetProcAddress( (const GLubyte *) "__glXGetUST" );
 444    if ( rmesa->get_ust == NULL ) {
 445       rmesa->get_ust = get_ust_nop;
 446    }
 447 #else
 448    rmesa->get_ust = get_ust_nop;
 449 #endif
 450    (*rmesa->get_ust)( & rmesa->swap_ust );
 451
 452
 453 #if DO_DEBUG
 454    R200_DEBUG  = driParseDebugString( getenv( "R200_DEBUG" ),
 455                                       debug_control );
 456    R200_DEBUG |= driParseDebugString( getenv( "RADEON_DEBUG" ),
 457                                       debug_control );
 458 #endif
 459
 460    tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
 461    if (driQueryOptionb(&rmesa->optionCache, "no_rast")) {
 462       fprintf(stderr, "disabling 3D acceleration\n");
 463       FALLBACK(rmesa, R200_FALLBACK_DISABLE, 1);
 464    }
 465    else if (tcl_mode == DRI_CONF_TCL_SW || getenv("R200_NO_TCL") ||
 466             !(rmesa->r200Screen->chipset & R200_CHIPSET_TCL)) {
 467       if (rmesa->r200Screen->chipset & R200_CHIPSET_TCL) {
 468          rmesa->r200Screen->chipset &= ~R200_CHIPSET_TCL;
 469          fprintf(stderr, "Disabling HW TCL support\n");
 470       }
 471       TCL_FALLBACK(rmesa->glCtx, R200_TCL_FALLBACK_TCL_DISABLE, 1);
 472    }
 473    if (rmesa->r200Screen->chipset & R200_CHIPSET_TCL) {
 474       if (tcl_mode >= DRI_CONF_TCL_VTXFMT && !getenv("R200_NO_VTXFMT")) {
 475          r200VtxfmtInit( ctx, tcl_mode >= DRI_CONF_TCL_CODEGEN );
 476       }
 477       _tnl_need_dlist_norm_lengths( ctx, GL_FALSE );
 478    }
 479    return GL_TRUE;
 480 }
 481
 482
 483 /* Destroy the device specific context.
 484  */
 485 /* Destroy the Mesa and driver specific context data.
 486  */
 487 void r200DestroyContext( __DRIcontextPrivate *driContextPriv )
 488 {
 489    GET_CURRENT_CONTEXT(ctx);
 490    r200ContextPtr rmesa = (r200ContextPtr) driContextPriv->driverPrivate;
 491    r200ContextPtr current = ctx ? R200_CONTEXT(ctx) : NULL;
 492
 493    /* check if we're deleting the currently bound context */
 494    if (rmesa == current) {
 495       R200_FIREVERTICES( rmesa );
 496       _mesa_make_current2(NULL, NULL, NULL);
 497    }
 498
 499    /* Free r200 context resources */
 500    assert(rmesa); /* should never be null */
 501    if ( rmesa ) {
 502       GLboolean   release_texture_heaps;
 503
 504
 505       release_texture_heaps = (rmesa->glCtx->Shared->RefCount == 1);
 506       _swsetup_DestroyContext( rmesa->glCtx );
 507       _tnl_DestroyContext( rmesa->glCtx );
 508       _ac_DestroyContext( rmesa->glCtx );
 509       _swrast_DestroyContext( rmesa->glCtx );
 510
 511       r200DestroySwtcl( rmesa->glCtx );
 512       r200ReleaseArrays( rmesa->glCtx, ~0 );
 513
 514       if (rmesa->dma.current.buf) {
 515          r200ReleaseDmaRegion( rmesa, &rmesa->dma.current, __FUNCTION__ );
 516          r200FlushCmdBuf( rmesa, __FUNCTION__ );
 517       }
 518
 519       if (!(rmesa->TclFallback & R200_TCL_FALLBACK_TCL_DISABLE)) {
 520          int tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
 521          if (tcl_mode >= DRI_CONF_TCL_VTXFMT)
 522             r200VtxfmtDestroy( rmesa->glCtx );
 523       }
 524
 525       /* free the Mesa context */
 526       rmesa->glCtx->DriverCtx = NULL;
 527       _mesa_destroy_context( rmesa->glCtx );
 528
 529       if (rmesa->state.scissor.pClipRects) {
 530          FREE(rmesa->state.scissor.pClipRects);
 531          rmesa->state.scissor.pClipRects = 0;
 532       }
 533
 534       if ( release_texture_heaps ) {
 535          /* This share group is about to go away, free our private
 536           * texture object data.
 537           */
 538          int i;
 539
 540          for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
 541             driDestroyTextureHeap( rmesa->texture_heaps[ i ] );
 542             rmesa->texture_heaps[ i ] = NULL;
 543          }
 544
 545          assert( is_empty_list( & rmesa->swapped ) );
 546       }
 547
 548       /* free the option cache */
 549       driDestroyOptionCache (&rmesa->optionCache);
 550
 551       FREE( rmesa );
 552    }
 553 }
 554
 555
 556
 557
 558 void
 559 r200SwapBuffers( __DRIdrawablePrivate *dPriv )
 560 {
 561    if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
 562       r200ContextPtr rmesa;
 563       GLcontext *ctx;
 564       rmesa = (r200ContextPtr) dPriv->driContextPriv->driverPrivate;
 565       ctx = rmesa->glCtx;
 566       if (ctx->Visual.doubleBufferMode) {
 567          _mesa_notifySwapBuffers( ctx );  /* flush pending rendering comands */
 568          if ( rmesa->doPageFlip ) {
 569             r200PageFlip( dPriv );
 570          }
 571          else {
 572             r200CopyBuffer( dPriv );
 573          }
 574       }
 575    }
 576    else {
 577       /* XXX this shouldn't be an error but we can't handle it for now */
 578       _mesa_problem(NULL, "%s: drawable has no context!", __FUNCTION__);
 579    }
 580 }
 581
 582
 583 /* Force the context `c' to be the current context and associate with it
 584  * buffer `b'.
 585  */
 586 GLboolean
 587 r200MakeCurrent( __DRIcontextPrivate *driContextPriv,
 588                    __DRIdrawablePrivate *driDrawPriv,
 589                    __DRIdrawablePrivate *driReadPriv )
 590 {
 591    if ( driContextPriv ) {
 592       r200ContextPtr newCtx =
 593          (r200ContextPtr) driContextPriv->driverPrivate;
 594
 595       if (R200_DEBUG & DEBUG_DRI)
 596          fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *)newCtx->glCtx);
 597
 598       if ( newCtx->dri.drawable != driDrawPriv ) {
 599          driDrawableInitVBlank( driDrawPriv, newCtx->vblank_flags );
 600          newCtx->dri.drawable = driDrawPriv;
 601          r200UpdateWindow( newCtx->glCtx );
 602          r200UpdateViewportOffset( newCtx->glCtx );
 603       }
 604
 605       _mesa_make_current2( newCtx->glCtx,
 606                            (GLframebuffer *) driDrawPriv->driverPrivate,
 607                            (GLframebuffer *) driReadPriv->driverPrivate );
 608
 609       if ( !newCtx->glCtx->Viewport.Width ) {
 610          _mesa_set_viewport( newCtx->glCtx, 0, 0,
 611                              driDrawPriv->w, driDrawPriv->h );
 612       }
 613
 614       if (newCtx->vb.enabled)
 615          r200VtxfmtMakeCurrent( newCtx->glCtx );
 616
 617       _mesa_update_state( newCtx->glCtx );
 618       r200ValidateState( newCtx->glCtx );
 619
 620    } else {
 621       if (R200_DEBUG & DEBUG_DRI)
 622          fprintf(stderr, "%s ctx is null\n", __FUNCTION__);
 623       _mesa_make_current( 0, 0 );
 624    }
 625
 626    if (R200_DEBUG & DEBUG_DRI)
 627       fprintf(stderr, "End %s\n", __FUNCTION__);
 628    return GL_TRUE;
 629 }
 630
 631 /* Force the context `c' to be unbound from its buffer.
 632  */
 633 GLboolean
 634 r200UnbindContext( __DRIcontextPrivate *driContextPriv )
 635 {
 636    r200ContextPtr rmesa = (r200ContextPtr) driContextPriv->driverPrivate;
 637
 638    if (R200_DEBUG & DEBUG_DRI)
 639       fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *)rmesa->glCtx);
 640
 641    r200VtxfmtUnbindContext( rmesa->glCtx );
 642    return GL_TRUE;
 643 }