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_EXT_blend_logic_op",
 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 = (RADEONSAREAPrivPtr)((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             rmesa->sarea->texList[i],
 313             & rmesa->sarea->texAge[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 = 2;
 334    ctx->Const.MaxTextureImageUnits = 2;
 335    ctx->Const.MaxTextureCoordUnits = 2;
 336
 337    driCalculateMaxTextureLevels( rmesa->texture_heaps,
 338                                  rmesa->nr_heaps,
 339                                  & ctx->Const,
 340                                  4,
 341                                  11, /* max 2D texture size is 2048x2048 */
 342 #if ENABLE_HW_3D_TEXTURE
 343                                  8,  /* max 3D texture size is 256^3 */
 344 #else
 345                                  0,  /* 3D textures unsupported */
 346 #endif
 347                                  11, /* max cube texture size is 2048x2048 */
 348                                  11, /* max texture rectangle size is 2048x2048 */
 349                                  12,
 350                                  GL_FALSE );
 351
 352    ctx->Const.MaxTextureMaxAnisotropy = 16.0;
 353
 354    /* No wide points.
 355     */
 356    ctx->Const.MinPointSize = 1.0;
 357    ctx->Const.MinPointSizeAA = 1.0;
 358    ctx->Const.MaxPointSize = 1.0;
 359    ctx->Const.MaxPointSizeAA = 1.0;
 360
 361    ctx->Const.MinLineWidth = 1.0;
 362    ctx->Const.MinLineWidthAA = 1.0;
 363    ctx->Const.MaxLineWidth = 10.0;
 364    ctx->Const.MaxLineWidthAA = 10.0;
 365    ctx->Const.LineWidthGranularity = 0.0625;
 366
 367    /* Initialize the software rasterizer and helper modules.
 368     */
 369    _swrast_CreateContext( ctx );
 370    _ac_CreateContext( ctx );
 371    _tnl_CreateContext( ctx );
 372    _swsetup_CreateContext( ctx );
 373    _ae_create_context( ctx );
 374
 375    /* Install the customized pipeline:
 376     */
 377    _tnl_destroy_pipeline( ctx );
 378    _tnl_install_pipeline( ctx, r200_pipeline );
 379    ctx->Driver.FlushVertices = r200FlushVertices;
 380
 381    /* Try and keep materials and vertices separate:
 382     */
 383    _tnl_isolate_materials( ctx, GL_TRUE );
 384
 385
 386    /* Configure swrast to match hardware characteristics:
 387     */
 388    _swrast_allow_pixel_fog( ctx, GL_FALSE );
 389    _swrast_allow_vertex_fog( ctx, GL_TRUE );
 390
 391
 392    _math_matrix_ctr( &rmesa->TexGenMatrix[0] );
 393    _math_matrix_ctr( &rmesa->TexGenMatrix[1] );
 394    _math_matrix_ctr( &rmesa->tmpmat );
 395    _math_matrix_set_identity( &rmesa->TexGenMatrix[0] );
 396    _math_matrix_set_identity( &rmesa->TexGenMatrix[1] );
 397    _math_matrix_set_identity( &rmesa->tmpmat );
 398
 399    driInitExtensions( ctx, card_extensions, GL_TRUE );
 400    if (rmesa->r200Screen->drmSupportsCubeMaps)
 401       _mesa_enable_extension( ctx, "GL_ARB_texture_cube_map" );
 402
 403 #if 0
 404    r200InitDriverFuncs( ctx );
 405    r200InitIoctlFuncs( ctx );
 406    r200InitStateFuncs( ctx );
 407    r200InitTextureFuncs( ctx );
 408 #endif
 409    /* plug in a few more device driver functions */
 410    /* XXX these should really go right after _mesa_init_driver_functions() */
 411    r200InitPixelFuncs( ctx );
 412    r200InitSpanFuncs( ctx );
 413    r200InitTnlFuncs( ctx );
 414    r200InitState( rmesa );
 415    r200InitSwtcl( ctx );
 416
 417    fthrottle_mode = driQueryOptioni(&rmesa->optionCache, "fthrottle_mode");
 418    rmesa->iw.irq_seq = -1;
 419    rmesa->irqsEmitted = 0;
 420    rmesa->do_irqs = (rmesa->dri.drmMinor >= 6 &&
 421                      fthrottle_mode == DRI_CONF_FTHROTTLE_IRQS &&
 422                      rmesa->r200Screen->irq);
 423
 424    rmesa->do_usleeps = (fthrottle_mode == DRI_CONF_FTHROTTLE_USLEEPS);
 425
 426    if (!rmesa->do_irqs)
 427       fprintf(stderr,
 428               "IRQ's not enabled, falling back to %s: %d %d %d\n",
 429               rmesa->do_usleeps ? "usleeps" : "busy waits",
 430               rmesa->dri.drmMinor,
 431               fthrottle_mode,
 432               rmesa->r200Screen->irq);
 433
 434    rmesa->vblank_flags = (rmesa->r200Screen->irq != 0)
 435        ? driGetDefaultVBlankFlags(&rmesa->optionCache) : VBLANK_FLAG_NO_IRQ;
 436
 437    rmesa->prefer_gart_client_texturing =
 438       (getenv("R200_GART_CLIENT_TEXTURES") != 0);
 439 #ifndef _SOLO
 440    rmesa->get_ust = (PFNGLXGETUSTPROC) glXGetProcAddress( (const GLubyte *) "__glXGetUST" );
 441    if ( rmesa->get_ust == NULL ) {
 442       rmesa->get_ust = get_ust_nop;
 443    }
 444 #else
 445    rmesa->get_ust = get_ust_nop;
 446 #endif
 447    (*rmesa->get_ust)( & rmesa->swap_ust );
 448
 449
 450 #if DO_DEBUG
 451    R200_DEBUG  = driParseDebugString( getenv( "R200_DEBUG" ),
 452                                       debug_control );
 453    R200_DEBUG |= driParseDebugString( getenv( "RADEON_DEBUG" ),
 454                                       debug_control );
 455 #endif
 456
 457    tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
 458    if (driQueryOptionb(&rmesa->optionCache, "no_rast")) {
 459       fprintf(stderr, "disabling 3D acceleration\n");
 460       FALLBACK(rmesa, R200_FALLBACK_DISABLE, 1);
 461    }
 462    else if (tcl_mode == DRI_CONF_TCL_SW || getenv("R200_NO_TCL") ||
 463             !(rmesa->r200Screen->chipset & R200_CHIPSET_TCL)) {
 464       rmesa->r200Screen->chipset &= ~R200_CHIPSET_TCL;
 465       fprintf(stderr, "disabling TCL support\n");
 466       TCL_FALLBACK(rmesa->glCtx, R200_TCL_FALLBACK_TCL_DISABLE, 1);
 467    }
 468    if (rmesa->r200Screen->chipset & R200_CHIPSET_TCL) {
 469       if (tcl_mode >= DRI_CONF_TCL_VTXFMT && !getenv("R200_NO_VTXFMT")) {
 470          r200VtxfmtInit( ctx, tcl_mode >= DRI_CONF_TCL_CODEGEN );
 471       }
 472       _tnl_need_dlist_norm_lengths( ctx, GL_FALSE );
 473    }
 474    return GL_TRUE;
 475 }
 476
 477
 478 /* Destroy the device specific context.
 479  */
 480 /* Destroy the Mesa and driver specific context data.
 481  */
 482 void r200DestroyContext( __DRIcontextPrivate *driContextPriv )
 483 {
 484    GET_CURRENT_CONTEXT(ctx);
 485    r200ContextPtr rmesa = (r200ContextPtr) driContextPriv->driverPrivate;
 486    r200ContextPtr current = ctx ? R200_CONTEXT(ctx) : NULL;
 487
 488    /* check if we're deleting the currently bound context */
 489    if (rmesa == current) {
 490       R200_FIREVERTICES( rmesa );
 491       _mesa_make_current2(NULL, NULL, NULL);
 492    }
 493
 494    /* Free r200 context resources */
 495    assert(rmesa); /* should never be null */
 496    if ( rmesa ) {
 497       GLboolean   release_texture_heaps;
 498
 499
 500       release_texture_heaps = (rmesa->glCtx->Shared->RefCount == 1);
 501       _swsetup_DestroyContext( rmesa->glCtx );
 502       _tnl_DestroyContext( rmesa->glCtx );
 503       _ac_DestroyContext( rmesa->glCtx );
 504       _swrast_DestroyContext( rmesa->glCtx );
 505
 506       r200DestroySwtcl( rmesa->glCtx );
 507       r200ReleaseArrays( rmesa->glCtx, ~0 );
 508
 509       if (rmesa->dma.current.buf) {
 510          r200ReleaseDmaRegion( rmesa, &rmesa->dma.current, __FUNCTION__ );
 511          r200FlushCmdBuf( rmesa, __FUNCTION__ );
 512       }
 513
 514       if (!(rmesa->TclFallback & R200_TCL_FALLBACK_TCL_DISABLE)) {
 515          int tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
 516          if (tcl_mode >= DRI_CONF_TCL_VTXFMT)
 517             r200VtxfmtDestroy( rmesa->glCtx );
 518       }
 519
 520       /* free the Mesa context */
 521       rmesa->glCtx->DriverCtx = NULL;
 522       _mesa_destroy_context( rmesa->glCtx );
 523
 524       if (rmesa->state.scissor.pClipRects) {
 525          FREE(rmesa->state.scissor.pClipRects);
 526          rmesa->state.scissor.pClipRects = 0;
 527       }
 528
 529       if ( release_texture_heaps ) {
 530          /* This share group is about to go away, free our private
 531           * texture object data.
 532           */
 533          int i;
 534
 535          for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
 536             driDestroyTextureHeap( rmesa->texture_heaps[ i ] );
 537             rmesa->texture_heaps[ i ] = NULL;
 538          }
 539
 540          assert( is_empty_list( & rmesa->swapped ) );
 541       }
 542
 543       /* free the option cache */
 544       driDestroyOptionCache (&rmesa->optionCache);
 545
 546       FREE( rmesa );
 547    }
 548 }
 549
 550
 551
 552
 553 void
 554 r200SwapBuffers( __DRIdrawablePrivate *dPriv )
 555 {
 556    if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
 557       r200ContextPtr rmesa;
 558       GLcontext *ctx;
 559       rmesa = (r200ContextPtr) dPriv->driContextPriv->driverPrivate;
 560       ctx = rmesa->glCtx;
 561       if (ctx->Visual.doubleBufferMode) {
 562          _mesa_notifySwapBuffers( ctx );  /* flush pending rendering comands */
 563          if ( rmesa->doPageFlip ) {
 564             r200PageFlip( dPriv );
 565          }
 566          else {
 567             r200CopyBuffer( dPriv );
 568          }
 569       }
 570    }
 571    else {
 572       /* XXX this shouldn't be an error but we can't handle it for now */
 573       _mesa_problem(NULL, "%s: drawable has no context!", __FUNCTION__);
 574    }
 575 }
 576
 577
 578 /* Force the context `c' to be the current context and associate with it
 579  * buffer `b'.
 580  */
 581 GLboolean
 582 r200MakeCurrent( __DRIcontextPrivate *driContextPriv,
 583                    __DRIdrawablePrivate *driDrawPriv,
 584                    __DRIdrawablePrivate *driReadPriv )
 585 {
 586    if ( driContextPriv ) {
 587       r200ContextPtr newCtx =
 588          (r200ContextPtr) driContextPriv->driverPrivate;
 589
 590       if (R200_DEBUG & DEBUG_DRI)
 591          fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *)newCtx->glCtx);
 592
 593       if ( newCtx->dri.drawable != driDrawPriv ) {
 594          driDrawableInitVBlank( driDrawPriv, newCtx->vblank_flags );
 595          newCtx->dri.drawable = driDrawPriv;
 596          r200UpdateWindow( newCtx->glCtx );
 597          r200UpdateViewportOffset( newCtx->glCtx );
 598       }
 599
 600       _mesa_make_current2( newCtx->glCtx,
 601                            (GLframebuffer *) driDrawPriv->driverPrivate,
 602                            (GLframebuffer *) driReadPriv->driverPrivate );
 603
 604       if ( !newCtx->glCtx->Viewport.Width ) {
 605          _mesa_set_viewport( newCtx->glCtx, 0, 0,
 606                              driDrawPriv->w, driDrawPriv->h );
 607       }
 608
 609       if (newCtx->vb.enabled)
 610          r200VtxfmtMakeCurrent( newCtx->glCtx );
 611
 612       _mesa_update_state( newCtx->glCtx );
 613       r200ValidateState( newCtx->glCtx );
 614
 615    } else {
 616       if (R200_DEBUG & DEBUG_DRI)
 617          fprintf(stderr, "%s ctx is null\n", __FUNCTION__);
 618       _mesa_make_current( 0, 0 );
 619    }
 620
 621    if (R200_DEBUG & DEBUG_DRI)
 622       fprintf(stderr, "End %s\n", __FUNCTION__);
 623    return GL_TRUE;
 624 }
 625
 626 /* Force the context `c' to be unbound from its buffer.
 627  */
 628 GLboolean
 629 r200UnbindContext( __DRIcontextPrivate *driContextPriv )
 630 {
 631    r200ContextPtr rmesa = (r200ContextPtr) driContextPriv->driverPrivate;
 632
 633    if (R200_DEBUG & DEBUG_DRI)
 634       fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *)rmesa->glCtx);
 635
 636    r200VtxfmtUnbindContext( rmesa->glCtx );
 637    return GL_TRUE;
 638 }