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