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 "r200_context.h"
  53 #include "r200_ioctl.h"
  54 #include "r200_state.h"
  55 #include "r200_span.h"
  56 #include "r200_pixel.h"
  57 #include "r200_tex.h"
  58 #include "r200_swtcl.h"
  59 #include "r200_tcl.h"
  60 #include "r200_vtxfmt.h"
  61 #include "r200_maos.h"
  62
  63 #define DRIVER_DATE     "20030328"
  64
  65 #include "vblank.h"
  66 #include "utils.h"
  67 #include "xmlpool.h" /* for symbolic values of enum-type options */
  68 #ifndef R200_DEBUG
  69 int R200_DEBUG = (0);
  70 #endif
  71
  72
  73 /* Return the width and height of the given buffer.
  74  */
  75 static void r200GetBufferSize( GLframebuffer *buffer,
  76                                GLuint *width, GLuint *height )
  77 {
  78    GET_CURRENT_CONTEXT(ctx);
  79    r200ContextPtr rmesa = R200_CONTEXT(ctx);
  80
  81    LOCK_HARDWARE( rmesa );
  82    *width  = rmesa->dri.drawable->w;
  83    *height = rmesa->dri.drawable->h;
  84    UNLOCK_HARDWARE( rmesa );
  85 }
  86
  87 /* Return various strings for glGetString().
  88  */
  89 static const GLubyte *r200GetString( GLcontext *ctx, GLenum name )
  90 {
  91    r200ContextPtr rmesa = R200_CONTEXT(ctx);
  92    static char buffer[128];
  93    unsigned   offset;
  94    GLuint agp_mode = rmesa->r200Screen->IsPCI ? 0 :
  95       rmesa->r200Screen->AGPMode;
  96
  97    switch ( name ) {
  98    case GL_VENDOR:
  99       return (GLubyte *)"Tungsten Graphics, Inc.";
 100
 101    case GL_RENDERER:
 102       offset = driGetRendererString( buffer, "R200", DRIVER_DATE,
 103                                      agp_mode );
 104
 105       sprintf( & buffer[ offset ], " %sTCL",
 106                !(rmesa->TclFallback & R200_TCL_FALLBACK_TCL_DISABLE)
 107                ? "" : "NO-" );
 108
 109       return (GLubyte *)buffer;
 110
 111    default:
 112       return NULL;
 113    }
 114 }
 115
 116
 117 /* Extension strings exported by the R200 driver.
 118  */
 119 static const char * const card_extensions[] =
 120 {
 121     "GL_ARB_multisample",
 122     "GL_ARB_multitexture",
 123     "GL_ARB_texture_border_clamp",
 124     "GL_ARB_texture_compression",
 125     "GL_ARB_texture_env_add",
 126     "GL_ARB_texture_env_combine",
 127     "GL_ARB_texture_env_dot3",
 128     "GL_ARB_texture_mirrored_repeat",
 129     "GL_EXT_blend_logic_op",
 130     "GL_EXT_blend_minmax",
 131     "GL_EXT_blend_subtract",
 132     "GL_EXT_secondary_color",
 133     "GL_EXT_stencil_wrap",
 134     "GL_EXT_texture_edge_clamp",
 135     "GL_EXT_texture_env_add",
 136     "GL_EXT_texture_env_combine",
 137     "GL_EXT_texture_env_dot3",
 138     "GL_EXT_texture_filter_anisotropic",
 139     "GL_EXT_texture_lod_bias",
 140     "GL_ATI_texture_env_combine3",
 141     "GL_ATI_texture_mirror_once",
 142     "GL_IBM_texture_mirrored_repeat",
 143     "GL_MESA_pack_invert",
 144     "GL_MESA_ycbcr_texture",
 145     "GL_NV_blend_square",
 146     "GL_NV_texture_rectangle",
 147     "GL_SGIS_generate_mipmap",
 148     "GL_SGIS_texture_border_clamp",
 149     "GL_SGIS_texture_edge_clamp",
 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( GLcontext *ctx )
 193 {
 194     ctx->Driver.GetBufferSize           = r200GetBufferSize;
 195     ctx->Driver.ResizeBuffers           = _swrast_alloc_buffers;
 196     ctx->Driver.GetString               = r200GetString;
 197
 198     ctx->Driver.Error                   = NULL;
 199     ctx->Driver.DrawPixels              = NULL;
 200     ctx->Driver.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 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    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    /* Allocate the Mesa context */
 256    if (sharedContextPrivate)
 257       shareCtx = ((r200ContextPtr) sharedContextPrivate)->glCtx;
 258    else
 259       shareCtx = NULL;
 260    rmesa->glCtx = _mesa_create_context(glVisual, shareCtx, (void *) rmesa, GL_TRUE);
 261    if (!rmesa->glCtx) {
 262       FREE(rmesa);
 263       return GL_FALSE;
 264    }
 265    driContextPriv->driverPrivate = rmesa;
 266
 267    /* Init r200 context data */
 268    rmesa->dri.context = driContextPriv;
 269    rmesa->dri.screen = sPriv;
 270    rmesa->dri.drawable = NULL; /* Set by XMesaMakeCurrent */
 271    rmesa->dri.hwContext = driContextPriv->hHWContext;
 272    rmesa->dri.hwLock = &sPriv->pSAREA->lock;
 273    rmesa->dri.fd = sPriv->fd;
 274    rmesa->dri.drmMinor = sPriv->drmMinor;
 275
 276    /* Parse configuration files */
 277    driParseConfigFiles (&rmesa->optionCache, &screen->optionCache,
 278                         screen->driScreen->myNum, "r200");
 279
 280    rmesa->r200Screen = screen;
 281    rmesa->sarea = (RADEONSAREAPrivPtr)((GLubyte *)sPriv->pSAREA +
 282                                        screen->sarea_priv_offset);
 283
 284
 285    rmesa->dma.buf0_address = rmesa->r200Screen->buffers->list[0].address;
 286
 287    (void) memset( rmesa->texture_heaps, 0, sizeof( rmesa->texture_heaps ) );
 288    make_empty_list( & rmesa->swapped );
 289
 290    rmesa->nr_heaps = 1 /* screen->numTexHeaps */ ;
 291    for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
 292       rmesa->texture_heaps[i] = driCreateTextureHeap( i, rmesa,
 293             screen->texSize[i],
 294             12,
 295             RADEON_NR_TEX_REGIONS,
 296             rmesa->sarea->texList[i],
 297             & rmesa->sarea->texAge[i],
 298             & rmesa->swapped,
 299             sizeof( r200TexObj ),
 300             (destroy_texture_object_t *) r200DestroyTexObj );
 301    }
 302    rmesa->texture_depth = driQueryOptioni (&rmesa->optionCache,
 303                                            "texture_depth");
 304    if (rmesa->texture_depth == DRI_CONF_TEXTURE_DEPTH_FB)
 305       rmesa->texture_depth = ( screen->cpp == 4 ) ?
 306          DRI_CONF_TEXTURE_DEPTH_32 : DRI_CONF_TEXTURE_DEPTH_16;
 307
 308    rmesa->swtcl.RenderIndex = ~0;
 309    rmesa->lost_context = 1;
 310
 311    /* Set the maximum texture size small enough that we can guarentee that
 312     * all texture units can bind a maximal texture and have them both in
 313     * texturable memory at once.
 314     */
 315
 316    ctx = rmesa->glCtx;
 317    ctx->Const.MaxTextureUnits = 2;
 318    ctx->Const.MaxTextureImageUnits = 2;
 319    ctx->Const.MaxTextureCoordUnits = 2;
 320
 321    driCalculateMaxTextureLevels( rmesa->texture_heaps,
 322                                  rmesa->nr_heaps,
 323                                  & ctx->Const,
 324                                  4,
 325                                  11, /* max 2D texture size is 2048x2048 */
 326 #if ENABLE_HW_3D_TEXTURE
 327                                  8,  /* max 3D texture size is 256^3 */
 328 #else
 329                                  0,  /* 3D textures unsupported */
 330 #endif
 331                                  11, /* max cube texture size is 2048x2048 */
 332                                  11, /* max texture rectangle size is 2048x2048 */
 333                                  12,
 334                                  GL_FALSE );
 335
 336    ctx->Const.MaxTextureMaxAnisotropy = 16.0;
 337
 338    /* No wide points.
 339     */
 340    ctx->Const.MinPointSize = 1.0;
 341    ctx->Const.MinPointSizeAA = 1.0;
 342    ctx->Const.MaxPointSize = 1.0;
 343    ctx->Const.MaxPointSizeAA = 1.0;
 344
 345    ctx->Const.MinLineWidth = 1.0;
 346    ctx->Const.MinLineWidthAA = 1.0;
 347    ctx->Const.MaxLineWidth = 10.0;
 348    ctx->Const.MaxLineWidthAA = 10.0;
 349    ctx->Const.LineWidthGranularity = 0.0625;
 350
 351    /* Initialize the software rasterizer and helper modules.
 352     */
 353    _swrast_CreateContext( ctx );
 354    _ac_CreateContext( ctx );
 355    _tnl_CreateContext( ctx );
 356    _swsetup_CreateContext( ctx );
 357    _ae_create_context( ctx );
 358
 359    /* Install the customized pipeline:
 360     */
 361    _tnl_destroy_pipeline( ctx );
 362    _tnl_install_pipeline( ctx, r200_pipeline );
 363    ctx->Driver.FlushVertices = r200FlushVertices;
 364
 365    /* Try and keep materials and vertices separate:
 366     */
 367    _tnl_isolate_materials( ctx, GL_TRUE );
 368
 369
 370    /* Configure swrast to match hardware characteristics:
 371     */
 372    _swrast_allow_pixel_fog( ctx, GL_FALSE );
 373    _swrast_allow_vertex_fog( ctx, GL_TRUE );
 374
 375
 376    _math_matrix_ctr( &rmesa->TexGenMatrix[0] );
 377    _math_matrix_ctr( &rmesa->TexGenMatrix[1] );
 378    _math_matrix_ctr( &rmesa->tmpmat );
 379    _math_matrix_set_identity( &rmesa->TexGenMatrix[0] );
 380    _math_matrix_set_identity( &rmesa->TexGenMatrix[1] );
 381    _math_matrix_set_identity( &rmesa->tmpmat );
 382
 383    driInitExtensions( ctx, card_extensions, GL_TRUE );
 384    if (rmesa->r200Screen->drmSupportsCubeMaps)
 385       _mesa_enable_extension( ctx, "GL_ARB_texture_cube_map" );
 386
 387    r200InitDriverFuncs( ctx );
 388    r200InitIoctlFuncs( ctx );
 389    r200InitStateFuncs( ctx );
 390    r200InitSpanFuncs( ctx );
 391    r200InitPixelFuncs( ctx );
 392    r200InitTextureFuncs( ctx );
 393    r200InitState( rmesa );
 394    r200InitSwtcl( ctx );
 395
 396    fthrottle_mode = driQueryOptioni(&rmesa->optionCache, "fthrottle_mode");
 397    rmesa->iw.irq_seq = -1;
 398    rmesa->irqsEmitted = 0;
 399    rmesa->do_irqs = (rmesa->dri.drmMinor >= 6 &&
 400                      fthrottle_mode == DRI_CONF_FTHROTTLE_IRQS &&
 401                      rmesa->r200Screen->irq);
 402
 403    rmesa->do_usleeps = (fthrottle_mode == DRI_CONF_FTHROTTLE_USLEEPS);
 404
 405    if (!rmesa->do_irqs)
 406       fprintf(stderr,
 407               "IRQ's not enabled, falling back to %s: %d %d %d\n",
 408               rmesa->do_usleeps ? "usleeps" : "busy waits",
 409               rmesa->dri.drmMinor,
 410               fthrottle_mode,
 411               rmesa->r200Screen->irq);
 412
 413    rmesa->vblank_flags = (rmesa->r200Screen->irq != 0)
 414        ? driGetDefaultVBlankFlags(&rmesa->optionCache) : VBLANK_FLAG_NO_IRQ;
 415
 416    rmesa->prefer_gart_client_texturing =
 417       (getenv("R200_GART_CLIENT_TEXTURES") != 0);
 418 #ifndef _SOLO
 419    rmesa->get_ust = (PFNGLXGETUSTPROC) glXGetProcAddress( (const GLubyte *) "__glXGetUST" );
 420    if ( rmesa->get_ust == NULL ) {
 421       rmesa->get_ust = get_ust_nop;
 422    }
 423 #else
 424    rmesa->get_ust = get_ust_nop;
 425 #endif
 426    (*rmesa->get_ust)( & rmesa->swap_ust );
 427
 428
 429 #if DO_DEBUG
 430    R200_DEBUG  = driParseDebugString( getenv( "R200_DEBUG" ),
 431                                       debug_control );
 432    R200_DEBUG |= driParseDebugString( getenv( "RADEON_DEBUG" ),
 433                                       debug_control );
 434 #endif
 435
 436    tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
 437    if (driQueryOptionb(&rmesa->optionCache, "no_rast")) {
 438       fprintf(stderr, "disabling 3D acceleration\n");
 439       FALLBACK(rmesa, R200_FALLBACK_DISABLE, 1);
 440    }
 441    else if (tcl_mode == DRI_CONF_TCL_SW || getenv("R200_NO_TCL")) {
 442       fprintf(stderr, "disabling TCL support\n");
 443       TCL_FALLBACK(rmesa->glCtx, R200_TCL_FALLBACK_TCL_DISABLE, 1);
 444    }
 445    else {
 446       if (tcl_mode >= DRI_CONF_TCL_VTXFMT && !getenv("R200_NO_VTXFMT")) {
 447          r200VtxfmtInit( ctx, tcl_mode >= DRI_CONF_TCL_CODEGEN );
 448       }
 449       _tnl_need_dlist_norm_lengths( ctx, GL_FALSE );
 450    }
 451    return GL_TRUE;
 452 }
 453
 454
 455 /* Destroy the device specific context.
 456  */
 457 /* Destroy the Mesa and driver specific context data.
 458  */
 459 void r200DestroyContext( __DRIcontextPrivate *driContextPriv )
 460 {
 461    GET_CURRENT_CONTEXT(ctx);
 462    r200ContextPtr rmesa = (r200ContextPtr) driContextPriv->driverPrivate;
 463    r200ContextPtr current = ctx ? R200_CONTEXT(ctx) : NULL;
 464
 465    /* check if we're deleting the currently bound context */
 466    if (rmesa == current) {
 467       R200_FIREVERTICES( rmesa );
 468       _mesa_make_current2(NULL, NULL, NULL);
 469    }
 470
 471    /* Free r200 context resources */
 472    assert(rmesa); /* should never be null */
 473    if ( rmesa ) {
 474       GLboolean   release_texture_heaps;
 475
 476
 477       release_texture_heaps = (rmesa->glCtx->Shared->RefCount == 1);
 478       _swsetup_DestroyContext( rmesa->glCtx );
 479       _tnl_DestroyContext( rmesa->glCtx );
 480       _ac_DestroyContext( rmesa->glCtx );
 481       _swrast_DestroyContext( rmesa->glCtx );
 482
 483       r200DestroySwtcl( rmesa->glCtx );
 484       r200ReleaseArrays( rmesa->glCtx, ~0 );
 485
 486       if (rmesa->dma.current.buf) {
 487          r200ReleaseDmaRegion( rmesa, &rmesa->dma.current, __FUNCTION__ );
 488          r200FlushCmdBuf( rmesa, __FUNCTION__ );
 489       }
 490
 491       if (!(rmesa->TclFallback & R200_TCL_FALLBACK_TCL_DISABLE)) {
 492          int tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
 493          if (tcl_mode >= DRI_CONF_TCL_VTXFMT)
 494             r200VtxfmtDestroy( rmesa->glCtx );
 495       }
 496
 497       /* free the Mesa context */
 498       rmesa->glCtx->DriverCtx = NULL;
 499       _mesa_destroy_context( rmesa->glCtx );
 500
 501       if (rmesa->state.scissor.pClipRects) {
 502          FREE(rmesa->state.scissor.pClipRects);
 503          rmesa->state.scissor.pClipRects = 0;
 504       }
 505
 506       if ( release_texture_heaps ) {
 507          /* This share group is about to go away, free our private
 508           * texture object data.
 509           */
 510          int i;
 511
 512          for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
 513             driDestroyTextureHeap( rmesa->texture_heaps[ i ] );
 514             rmesa->texture_heaps[ i ] = NULL;
 515          }
 516
 517          assert( is_empty_list( & rmesa->swapped ) );
 518       }
 519
 520       /* free the option cache */
 521       driDestroyOptionCache (&rmesa->optionCache);
 522
 523       FREE( rmesa );
 524    }
 525 }
 526
 527
 528
 529
 530 void
 531 r200SwapBuffers( __DRIdrawablePrivate *dPriv )
 532 {
 533    if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
 534       r200ContextPtr rmesa;
 535       GLcontext *ctx;
 536       rmesa = (r200ContextPtr) dPriv->driContextPriv->driverPrivate;
 537       ctx = rmesa->glCtx;
 538       if (ctx->Visual.doubleBufferMode) {
 539          _mesa_notifySwapBuffers( ctx );  /* flush pending rendering comands */
 540          if ( rmesa->doPageFlip ) {
 541             r200PageFlip( dPriv );
 542          }
 543          else {
 544             r200CopyBuffer( dPriv );
 545          }
 546       }
 547    }
 548    else {
 549       /* XXX this shouldn't be an error but we can't handle it for now */
 550       _mesa_problem(NULL, "%s: drawable has no context!", __FUNCTION__);
 551    }
 552 }
 553
 554
 555 /* Force the context `c' to be the current context and associate with it
 556  * buffer `b'.
 557  */
 558 GLboolean
 559 r200MakeCurrent( __DRIcontextPrivate *driContextPriv,
 560                    __DRIdrawablePrivate *driDrawPriv,
 561                    __DRIdrawablePrivate *driReadPriv )
 562 {
 563    if ( driContextPriv ) {
 564       r200ContextPtr newCtx =
 565          (r200ContextPtr) driContextPriv->driverPrivate;
 566
 567       if (R200_DEBUG & DEBUG_DRI)
 568          fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *)newCtx->glCtx);
 569
 570       if ( newCtx->dri.drawable != driDrawPriv ) {
 571          driDrawableInitVBlank( driDrawPriv, newCtx->vblank_flags );
 572          newCtx->dri.drawable = driDrawPriv;
 573          r200UpdateWindow( newCtx->glCtx );
 574          r200UpdateViewportOffset( newCtx->glCtx );
 575       }
 576
 577       _mesa_make_current2( newCtx->glCtx,
 578                            (GLframebuffer *) driDrawPriv->driverPrivate,
 579                            (GLframebuffer *) driReadPriv->driverPrivate );
 580
 581       if ( !newCtx->glCtx->Viewport.Width ) {
 582          _mesa_set_viewport( newCtx->glCtx, 0, 0,
 583                              driDrawPriv->w, driDrawPriv->h );
 584       }
 585
 586       if (newCtx->vb.enabled)
 587          r200VtxfmtMakeCurrent( newCtx->glCtx );
 588
 589       _mesa_update_state( newCtx->glCtx );
 590       r200ValidateState( newCtx->glCtx );
 591
 592    } else {
 593       if (R200_DEBUG & DEBUG_DRI)
 594          fprintf(stderr, "%s ctx is null\n", __FUNCTION__);
 595       _mesa_make_current( 0, 0 );
 596    }
 597
 598    if (R200_DEBUG & DEBUG_DRI)
 599       fprintf(stderr, "End %s\n", __FUNCTION__);
 600    return GL_TRUE;
 601 }
 602
 603 /* Force the context `c' to be unbound from its buffer.
 604  */
 605 GLboolean
 606 r200UnbindContext( __DRIcontextPrivate *driContextPriv )
 607 {
 608    r200ContextPtr rmesa = (r200ContextPtr) driContextPriv->driverPrivate;
 609
 610    if (R200_DEBUG & DEBUG_DRI)
 611       fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *)rmesa->glCtx);
 612
 613    r200VtxfmtUnbindContext( rmesa->glCtx );
 614    return GL_TRUE;
 615 }