src/mesa/drivers/dri/radeon/radeon_context.c

   1 /* $XFree86: xc/lib/GL/mesa/src/drv/radeon/radeon_context.c,v 1.9 2003/09/24 02:43:12 dawes Exp $ */
   2 /**************************************************************************
   3
   4 Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and
   5                      VA Linux Systems Inc., Fremont, California.
   6
   7 All Rights Reserved.
   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  *   Kevin E. Martin <martin@valinux.com>
  34  *   Gareth Hughes <gareth@valinux.com>
  35  *   Keith Whitwell <keith@tungstengraphics.com>
  36  */
  37
  38 #include "glheader.h"
  39 #include "api_arrayelt.h"
  40 #include "context.h"
  41 #include "simple_list.h"
  42 #include "imports.h"
  43 #include "matrix.h"
  44 #include "extensions.h"
  45
  46 #include "swrast/swrast.h"
  47 #include "swrast_setup/swrast_setup.h"
  48 #include "array_cache/acache.h"
  49
  50 #include "tnl/tnl.h"
  51 #include "tnl/t_pipeline.h"
  52
  53 #include "drivers/common/driverfuncs.h"
  54
  55 #include "radeon_context.h"
  56 #include "radeon_ioctl.h"
  57 #include "radeon_state.h"
  58 #include "radeon_span.h"
  59 #include "radeon_tex.h"
  60 #include "radeon_swtcl.h"
  61 #include "radeon_tcl.h"
  62 #include "radeon_vtxfmt.h"
  63 #include "radeon_maos.h"
  64
  65 #define DRIVER_DATE     "20041207"
  66
  67 #include "vblank.h"
  68 #include "utils.h"
  69 #include "xmlpool.h" /* for symbolic values of enum-type options */
  70 #ifndef RADEON_DEBUG
  71 int RADEON_DEBUG = (0);
  72 #endif
  73
  74
  75 /* Return the width and height of the given buffer.
  76  */
  77 static void radeonGetBufferSize( GLframebuffer *buffer,
  78                                  GLuint *width, GLuint *height )
  79 {
  80    GET_CURRENT_CONTEXT(ctx);
  81    radeonContextPtr rmesa = RADEON_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 *radeonGetString( GLcontext *ctx, GLenum name )
  92 {
  93    radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
  94    static char buffer[128];
  95    unsigned   offset;
  96    GLuint agp_mode = rmesa->radeonScreen->IsPCI ? 0 :
  97       rmesa->radeonScreen->AGPMode;
  98
  99    switch ( name ) {
 100    case GL_VENDOR:
 101       return (GLubyte *)"Tungsten Graphics, Inc.";
 102
 103    case GL_RENDERER:
 104       offset = driGetRendererString( buffer, "Radeon", DRIVER_DATE,
 105                                      agp_mode );
 106
 107       sprintf( & buffer[ offset ], " %sTCL",
 108                !(rmesa->TclFallback & RADEON_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 R100 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_crossbar",
 130     "GL_ARB_texture_env_dot3",
 131     "GL_ARB_texture_mirrored_repeat",
 132     "GL_EXT_blend_logic_op",
 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_ATI_texture_env_combine3",
 143     "GL_ATI_texture_mirror_once",
 144     "GL_MESA_ycbcr_texture",
 145     "GL_NV_blend_square",
 146     "GL_SGIS_generate_mipmap",
 147     NULL
 148 };
 149
 150 extern const struct tnl_pipeline_stage _radeon_texrect_stage;
 151 extern const struct tnl_pipeline_stage _radeon_render_stage;
 152 extern const struct tnl_pipeline_stage _radeon_tcl_stage;
 153
 154 static const struct tnl_pipeline_stage *radeon_pipeline[] = {
 155
 156    /* Try and go straight to t&l
 157     */
 158    &_radeon_tcl_stage,
 159
 160    /* Catch any t&l fallbacks
 161     */
 162    &_tnl_vertex_transform_stage,
 163    &_tnl_normal_transform_stage,
 164    &_tnl_lighting_stage,
 165    &_tnl_fog_coordinate_stage,
 166    &_tnl_texgen_stage,
 167    &_tnl_texture_transform_stage,
 168
 169    /* Scale texture rectangle to 0..1.
 170     */
 171    &_radeon_texrect_stage,
 172
 173    &_radeon_render_stage,
 174    &_tnl_render_stage,          /* FALLBACK:  */
 175    0,
 176 };
 177
 178
 179
 180 /* Initialize the driver's misc functions.
 181  */
 182 static void radeonInitDriverFuncs( struct dd_function_table *functions )
 183 {
 184     functions->GetBufferSize    = radeonGetBufferSize;
 185     functions->ResizeBuffers    = _swrast_alloc_buffers;
 186     functions->GetString        = radeonGetString;
 187 }
 188
 189 static const struct dri_debug_control debug_control[] =
 190 {
 191     { "fall",  DEBUG_FALLBACKS },
 192     { "tex",   DEBUG_TEXTURE },
 193     { "ioctl", DEBUG_IOCTL },
 194     { "prim",  DEBUG_PRIMS },
 195     { "vert",  DEBUG_VERTS },
 196     { "state", DEBUG_STATE },
 197     { "code",  DEBUG_CODEGEN },
 198     { "vfmt",  DEBUG_VFMT },
 199     { "vtxf",  DEBUG_VFMT },
 200     { "verb",  DEBUG_VERBOSE },
 201     { "dri",   DEBUG_DRI },
 202     { "dma",   DEBUG_DMA },
 203     { "san",   DEBUG_SANITY },
 204     { "sync",  DEBUG_SYNC },
 205     { NULL,    0 }
 206 };
 207
 208
 209 static int
 210 get_ust_nop( int64_t * ust )
 211 {
 212    *ust = 1;
 213    return 0;
 214 }
 215
 216
 217 /* Create the device specific context.
 218  */
 219 GLboolean
 220 radeonCreateContext( const __GLcontextModes *glVisual,
 221                      __DRIcontextPrivate *driContextPriv,
 222                      void *sharedContextPrivate)
 223 {
 224    __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv;
 225    radeonScreenPtr screen = (radeonScreenPtr)(sPriv->private);
 226    struct dd_function_table functions;
 227    radeonContextPtr rmesa;
 228    GLcontext *ctx, *shareCtx;
 229    int i;
 230    int tcl_mode, fthrottle_mode;
 231
 232    assert(glVisual);
 233    assert(driContextPriv);
 234    assert(screen);
 235
 236    /* Allocate the Radeon context */
 237    rmesa = (radeonContextPtr) CALLOC( sizeof(*rmesa) );
 238    if ( !rmesa )
 239       return GL_FALSE;
 240
 241    /* Parse configuration files.
 242     * Do this here so that initialMaxAnisotropy is set before we create
 243     * the default textures.
 244     */
 245    driParseConfigFiles (&rmesa->optionCache, &screen->optionCache,
 246                         screen->driScreen->myNum, "radeon");
 247    rmesa->initialMaxAnisotropy = driQueryOptionf(&rmesa->optionCache,
 248                                                  "def_max_anisotropy");
 249
 250    if ( driQueryOptionb( &rmesa->optionCache, "hyperz" ) ) {
 251       if ( sPriv->drmMinor < 13 )
 252          fprintf( stderr, "DRM version 1.%d too old to support HyperZ, "
 253                           "disabling.\n",sPriv->drmMinor );
 254       else
 255          rmesa->using_hyperz = GL_TRUE;
 256    }
 257
 258    if ( sPriv->drmMinor >= 15 )
 259       rmesa->texmicrotile = GL_TRUE;
 260
 261    /* Init default driver functions then plug in our Radeon-specific functions
 262     * (the texture functions are especially important)
 263     */
 264    _mesa_init_driver_functions( &functions );
 265    radeonInitDriverFuncs( &functions );
 266    radeonInitTextureFuncs( &functions );
 267
 268    /* Allocate the Mesa context */
 269    if (sharedContextPrivate)
 270       shareCtx = ((radeonContextPtr) sharedContextPrivate)->glCtx;
 271    else
 272       shareCtx = NULL;
 273    rmesa->glCtx = _mesa_create_context(glVisual, shareCtx,
 274                                        &functions, (void *) rmesa);
 275    if (!rmesa->glCtx) {
 276       FREE(rmesa);
 277       return GL_FALSE;
 278    }
 279    driContextPriv->driverPrivate = rmesa;
 280
 281    /* Init radeon context data */
 282    rmesa->dri.context = driContextPriv;
 283    rmesa->dri.screen = sPriv;
 284    rmesa->dri.drawable = NULL; /* Set by XMesaMakeCurrent */
 285    rmesa->dri.hwContext = driContextPriv->hHWContext;
 286    rmesa->dri.hwLock = &sPriv->pSAREA->lock;
 287    rmesa->dri.fd = sPriv->fd;
 288    rmesa->dri.drmMinor = sPriv->drmMinor;
 289
 290    rmesa->radeonScreen = screen;
 291    rmesa->sarea = (drm_radeon_sarea_t *)((GLubyte *)sPriv->pSAREA +
 292                                        screen->sarea_priv_offset);
 293
 294
 295    rmesa->dma.buf0_address = rmesa->radeonScreen->buffers->list[0].address;
 296
 297    (void) memset( rmesa->texture_heaps, 0, sizeof( rmesa->texture_heaps ) );
 298    make_empty_list( & rmesa->swapped );
 299
 300    rmesa->nr_heaps = screen->numTexHeaps;
 301    for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
 302       rmesa->texture_heaps[i] = driCreateTextureHeap( i, rmesa,
 303             screen->texSize[i],
 304             12,
 305             RADEON_NR_TEX_REGIONS,
 306             (drmTextureRegionPtr)rmesa->sarea->tex_list[i],
 307             & rmesa->sarea->tex_age[i],
 308             & rmesa->swapped,
 309             sizeof( radeonTexObj ),
 310             (destroy_texture_object_t *) radeonDestroyTexObj );
 311
 312       driSetTextureSwapCounterLocation( rmesa->texture_heaps[i],
 313                                         & rmesa->c_textureSwaps );
 314    }
 315    rmesa->texture_depth = driQueryOptioni (&rmesa->optionCache,
 316                                            "texture_depth");
 317    if (rmesa->texture_depth == DRI_CONF_TEXTURE_DEPTH_FB)
 318       rmesa->texture_depth = ( screen->cpp == 4 ) ?
 319          DRI_CONF_TEXTURE_DEPTH_32 : DRI_CONF_TEXTURE_DEPTH_16;
 320
 321    rmesa->swtcl.RenderIndex = ~0;
 322    rmesa->hw.all_dirty = GL_TRUE;
 323
 324    /* Set the maximum texture size small enough that we can guarentee that
 325     * all texture units can bind a maximal texture and have them both in
 326     * texturable memory at once.
 327     */
 328
 329    ctx = rmesa->glCtx;
 330    ctx->Const.MaxTextureUnits = 2;
 331    ctx->Const.MaxTextureImageUnits = 2;
 332    ctx->Const.MaxTextureCoordUnits = 2;
 333
 334    driCalculateMaxTextureLevels( rmesa->texture_heaps,
 335                                  rmesa->nr_heaps,
 336                                  & ctx->Const,
 337                                  4,
 338                                  11, /* max 2D texture size is 2048x2048 */
 339                                  0,  /* 3D textures unsupported. */
 340                                  0,  /* cube textures unsupported. */
 341                                  11, /* max rect texture size is 2048x2048. */
 342                                  12,
 343                                  GL_FALSE );
 344
 345    ctx->Const.MaxTextureMaxAnisotropy = 16.0;
 346
 347    /* No wide points.
 348     */
 349    ctx->Const.MinPointSize = 1.0;
 350    ctx->Const.MinPointSizeAA = 1.0;
 351    ctx->Const.MaxPointSize = 1.0;
 352    ctx->Const.MaxPointSizeAA = 1.0;
 353
 354    ctx->Const.MinLineWidth = 1.0;
 355    ctx->Const.MinLineWidthAA = 1.0;
 356    ctx->Const.MaxLineWidth = 10.0;
 357    ctx->Const.MaxLineWidthAA = 10.0;
 358    ctx->Const.LineWidthGranularity = 0.0625;
 359
 360    /* Set maxlocksize (and hence vb size) small enough to avoid
 361     * fallbacks in radeon_tcl.c.  ie. guarentee that all vertices can
 362     * fit in a single dma buffer for indexed rendering of quad strips,
 363     * etc.
 364     */
 365    ctx->Const.MaxArrayLockSize =
 366       MIN2( ctx->Const.MaxArrayLockSize,
 367             RADEON_BUFFER_SIZE / RADEON_MAX_TCL_VERTSIZE );
 368
 369    rmesa->boxes = 0;
 370
 371    /* Initialize the software rasterizer and helper modules.
 372     */
 373    _swrast_CreateContext( ctx );
 374    _ac_CreateContext( ctx );
 375    _tnl_CreateContext( ctx );
 376    _swsetup_CreateContext( ctx );
 377    _ae_create_context( ctx );
 378
 379    /* Install the customized pipeline:
 380     */
 381    _tnl_destroy_pipeline( ctx );
 382    _tnl_install_pipeline( ctx, radeon_pipeline );
 383    ctx->Driver.FlushVertices = radeonFlushVertices;
 384
 385    /* Try and keep materials and vertices separate:
 386     */
 387    _tnl_isolate_materials( ctx, GL_TRUE );
 388
 389
 390 /*     _mesa_allow_light_in_model( ctx, GL_FALSE ); */
 391
 392    /* Try and keep materials and vertices separate:
 393     */
 394    _tnl_isolate_materials( ctx, GL_TRUE );
 395
 396
 397    /* Configure swrast and T&L to match hardware characteristics:
 398     */
 399    _swrast_allow_pixel_fog( ctx, GL_FALSE );
 400    _swrast_allow_vertex_fog( ctx, GL_TRUE );
 401    _tnl_allow_pixel_fog( ctx, GL_FALSE );
 402    _tnl_allow_vertex_fog( ctx, GL_TRUE );
 403
 404
 405    _math_matrix_ctr( &rmesa->TexGenMatrix[0] );
 406    _math_matrix_ctr( &rmesa->TexGenMatrix[1] );
 407    _math_matrix_ctr( &rmesa->tmpmat );
 408    _math_matrix_set_identity( &rmesa->TexGenMatrix[0] );
 409    _math_matrix_set_identity( &rmesa->TexGenMatrix[1] );
 410    _math_matrix_set_identity( &rmesa->tmpmat );
 411
 412    driInitExtensions( ctx, card_extensions, GL_TRUE );
 413    if (rmesa->glCtx->Mesa_DXTn) {
 414       _mesa_enable_extension( ctx, "GL_EXT_texture_compression_s3tc" );
 415       _mesa_enable_extension( ctx, "GL_S3_s3tc" );
 416    }
 417    else if (driQueryOptionb (&rmesa->optionCache, "force_s3tc_enable")) {
 418       _mesa_enable_extension( ctx, "GL_EXT_texture_compression_s3tc" );
 419    }
 420
 421    if (rmesa->dri.drmMinor >= 9)
 422       _mesa_enable_extension( ctx, "GL_NV_texture_rectangle");
 423
 424    /* XXX these should really go right after _mesa_init_driver_functions() */
 425    radeonInitIoctlFuncs( ctx );
 426    radeonInitStateFuncs( ctx );
 427    radeonInitSpanFuncs( ctx );
 428    radeonInitState( rmesa );
 429    radeonInitSwtcl( ctx );
 430
 431    _mesa_vector4f_alloc( &rmesa->tcl.ObjClean, 0,
 432                          ctx->Const.MaxArrayLockSize, 32 );
 433
 434    fthrottle_mode = driQueryOptioni(&rmesa->optionCache, "fthrottle_mode");
 435    rmesa->iw.irq_seq = -1;
 436    rmesa->irqsEmitted = 0;
 437    rmesa->do_irqs = (rmesa->radeonScreen->irq != 0 &&
 438                      fthrottle_mode == DRI_CONF_FTHROTTLE_IRQS);
 439
 440    rmesa->do_usleeps = (fthrottle_mode == DRI_CONF_FTHROTTLE_USLEEPS);
 441
 442    rmesa->vblank_flags = (rmesa->radeonScreen->irq != 0)
 443        ? driGetDefaultVBlankFlags(&rmesa->optionCache) : VBLANK_FLAG_NO_IRQ;
 444
 445    rmesa->get_ust = (PFNGLXGETUSTPROC) glXGetProcAddress( (const GLubyte *) "__glXGetUST" );
 446    if ( rmesa->get_ust == NULL ) {
 447       rmesa->get_ust = get_ust_nop;
 448    }
 449    (*rmesa->get_ust)( & rmesa->swap_ust );
 450
 451    if (rmesa->sarea->tiling_enabled != 0) fprintf(stderr, "color tiling enabled!\n");
 452
 453 #if DO_DEBUG
 454    RADEON_DEBUG = driParseDebugString( getenv( "RADEON_DEBUG" ),
 455                                        debug_control );
 456 #endif
 457
 458    tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
 459    if (driQueryOptionb(&rmesa->optionCache, "no_rast")) {
 460       fprintf(stderr, "disabling 3D acceleration\n");
 461       FALLBACK(rmesa, RADEON_FALLBACK_DISABLE, 1);
 462    } else if (tcl_mode == DRI_CONF_TCL_SW ||
 463               !(rmesa->radeonScreen->chipset & RADEON_CHIPSET_TCL)) {
 464       if (rmesa->radeonScreen->chipset & RADEON_CHIPSET_TCL) {
 465          rmesa->radeonScreen->chipset &= ~RADEON_CHIPSET_TCL;
 466          fprintf(stderr, "Disabling HW TCL support\n");
 467       }
 468       TCL_FALLBACK(rmesa->glCtx, RADEON_TCL_FALLBACK_TCL_DISABLE, 1);
 469    }
 470
 471    if (rmesa->radeonScreen->chipset & RADEON_CHIPSET_TCL) {
 472       if (tcl_mode >= DRI_CONF_TCL_VTXFMT)
 473          radeonVtxfmtInit( ctx, tcl_mode >= DRI_CONF_TCL_CODEGEN );
 474
 475       _tnl_need_dlist_norm_lengths( ctx, GL_FALSE );
 476    }
 477    return GL_TRUE;
 478 }
 479
 480
 481 /* Destroy the device specific context.
 482  */
 483 /* Destroy the Mesa and driver specific context data.
 484  */
 485 void radeonDestroyContext( __DRIcontextPrivate *driContextPriv )
 486 {
 487    GET_CURRENT_CONTEXT(ctx);
 488    radeonContextPtr rmesa = (radeonContextPtr) driContextPriv->driverPrivate;
 489    radeonContextPtr current = ctx ? RADEON_CONTEXT(ctx) : NULL;
 490
 491    /* check if we're deleting the currently bound context */
 492    if (rmesa == current) {
 493       RADEON_FIREVERTICES( rmesa );
 494       _mesa_make_current2(NULL, NULL, NULL);
 495    }
 496
 497    /* Free radeon context resources */
 498    assert(rmesa); /* should never be null */
 499    if ( rmesa ) {
 500       GLboolean   release_texture_heaps;
 501
 502
 503       release_texture_heaps = (rmesa->glCtx->Shared->RefCount == 1);
 504       _swsetup_DestroyContext( rmesa->glCtx );
 505       _tnl_DestroyContext( rmesa->glCtx );
 506       _ac_DestroyContext( rmesa->glCtx );
 507       _swrast_DestroyContext( rmesa->glCtx );
 508
 509       radeonDestroySwtcl( rmesa->glCtx );
 510       radeonReleaseArrays( rmesa->glCtx, ~0 );
 511       if (rmesa->dma.current.buf) {
 512          radeonReleaseDmaRegion( rmesa, &rmesa->dma.current, __FUNCTION__ );
 513          radeonFlushCmdBuf( rmesa, __FUNCTION__ );
 514       }
 515
 516       if (!(rmesa->TclFallback & RADEON_TCL_FALLBACK_TCL_DISABLE)) {
 517          int tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
 518          if (tcl_mode >= DRI_CONF_TCL_VTXFMT)
 519             radeonVtxfmtDestroy( rmesa->glCtx );
 520       }
 521
 522       /* free the Mesa context */
 523       rmesa->glCtx->DriverCtx = NULL;
 524       _mesa_destroy_context( rmesa->glCtx );
 525
 526       _mesa_vector4f_free( &rmesa->tcl.ObjClean );
 527
 528       if (rmesa->state.scissor.pClipRects) {
 529          FREE(rmesa->state.scissor.pClipRects);
 530          rmesa->state.scissor.pClipRects = 0;
 531       }
 532
 533       if ( release_texture_heaps ) {
 534          /* This share group is about to go away, free our private
 535           * texture object data.
 536           */
 537          int i;
 538
 539          for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
 540             driDestroyTextureHeap( rmesa->texture_heaps[ i ] );
 541             rmesa->texture_heaps[ i ] = NULL;
 542          }
 543
 544          assert( is_empty_list( & rmesa->swapped ) );
 545       }
 546
 547       /* free the option cache */
 548       driDestroyOptionCache (&rmesa->optionCache);
 549
 550       FREE( rmesa );
 551    }
 552 }
 553
 554
 555
 556
 557 void
 558 radeonSwapBuffers( __DRIdrawablePrivate *dPriv )
 559 {
 560
 561    if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
 562       radeonContextPtr rmesa;
 563       GLcontext *ctx;
 564       rmesa = (radeonContextPtr) dPriv->driContextPriv->driverPrivate;
 565       ctx = rmesa->glCtx;
 566       if (ctx->Visual.doubleBufferMode) {
 567          _mesa_notifySwapBuffers( ctx );  /* flush pending rendering comands */
 568
 569          if ( rmesa->doPageFlip ) {
 570             radeonPageFlip( dPriv );
 571          }
 572          else {
 573             radeonCopyBuffer( 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 radeonMakeCurrent( __DRIcontextPrivate *driContextPriv,
 589                    __DRIdrawablePrivate *driDrawPriv,
 590                    __DRIdrawablePrivate *driReadPriv )
 591 {
 592    if ( driContextPriv ) {
 593       radeonContextPtr newCtx =
 594          (radeonContextPtr) driContextPriv->driverPrivate;
 595
 596       if (RADEON_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          radeonUpdateWindow( newCtx->glCtx );
 603          radeonUpdateViewportOffset( newCtx->glCtx );
 604       }
 605
 606       _mesa_make_current2( newCtx->glCtx,
 607                            (GLframebuffer *) driDrawPriv->driverPrivate,
 608                            (GLframebuffer *) driReadPriv->driverPrivate );
 609
 610       if (newCtx->vb.enabled)
 611          radeonVtxfmtMakeCurrent( newCtx->glCtx );
 612
 613    } else {
 614       if (RADEON_DEBUG & DEBUG_DRI)
 615          fprintf(stderr, "%s ctx is null\n", __FUNCTION__);
 616       _mesa_make_current( 0, 0 );
 617    }
 618
 619    if (RADEON_DEBUG & DEBUG_DRI)
 620       fprintf(stderr, "End %s\n", __FUNCTION__);
 621    return GL_TRUE;
 622 }
 623
 624 /* Force the context `c' to be unbound from its buffer.
 625  */
 626 GLboolean
 627 radeonUnbindContext( __DRIcontextPrivate *driContextPriv )
 628 {
 629    radeonContextPtr rmesa = (radeonContextPtr) driContextPriv->driverPrivate;
 630
 631    if (RADEON_DEBUG & DEBUG_DRI)
 632       fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *) rmesa->glCtx);
 633
 634    return GL_TRUE;
 635 }