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

   1 /**************************************************************************
   2
   3 Copyright 2000, 2001 ATI Technologies Inc., Ontario, Canada, and
   4                      VA Linux Systems Inc., Fremont, California.
   5
   6 All Rights Reserved.
   7
   8 Permission is hereby granted, free of charge, to any person obtaining
   9 a copy of this software and associated documentation files (the
  10 "Software"), to deal in the Software without restriction, including
  11 without limitation the rights to use, copy, modify, merge, publish,
  12 distribute, sublicense, and/or sell copies of the Software, and to
  13 permit persons to whom the Software is furnished to do so, subject to
  14 the following conditions:
  15
  16 The above copyright notice and this permission notice (including the
  17 next paragraph) shall be included in all copies or substantial
  18 portions of the Software.
  19
  20 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  23 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  24 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27
  28 **************************************************************************/
  29
  30 /*
  31  * Authors:
  32  *   Kevin E. Martin <martin@valinux.com>
  33  *   Gareth Hughes <gareth@valinux.com>
  34  *   Keith Whitwell <keith@tungstengraphics.com>
  35  */
  36
  37 #include "main/glheader.h"
  38 #include "main/api_arrayelt.h"
  39 #include "main/context.h"
  40 #include "main/simple_list.h"
  41 #include "main/imports.h"
  42 #include "main/matrix.h"
  43 #include "main/extensions.h"
  44 #include "main/framebuffer.h"
  45 #include "main/state.h"
  46
  47 #include "swrast/swrast.h"
  48 #include "swrast_setup/swrast_setup.h"
  49 #include "vbo/vbo.h"
  50
  51 #include "tnl/tnl.h"
  52 #include "tnl/t_pipeline.h"
  53
  54 #include "drivers/common/driverfuncs.h"
  55
  56 #include "radeon_context.h"
  57 #include "radeon_ioctl.h"
  58 #include "radeon_state.h"
  59 #include "radeon_span.h"
  60 #include "radeon_tex.h"
  61 #include "radeon_swtcl.h"
  62 #include "radeon_tcl.h"
  63 #include "radeon_maos.h"
  64
  65 #define need_GL_ARB_vertex_buffer_object
  66 #define need_GL_EXT_blend_minmax
  67 #define need_GL_EXT_fog_coord
  68 #define need_GL_EXT_secondary_color
  69 #include "extension_helper.h"
  70
  71 #define DRIVER_DATE     "20061018"
  72
  73 #include "vblank.h"
  74 #include "utils.h"
  75 #include "xmlpool.h" /* for symbolic values of enum-type options */
  76 #ifndef RADEON_DEBUG
  77 int RADEON_DEBUG = (0);
  78 #endif
  79
  80
  81 /* Return various strings for glGetString().
  82  */
  83 static const GLubyte *radeonGetString( GLcontext *ctx, GLenum name )
  84 {
  85    radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
  86    static char buffer[128];
  87    unsigned   offset;
  88    GLuint agp_mode = (rmesa->radeonScreen->card_type==RADEON_CARD_PCI) ? 0 :
  89       rmesa->radeonScreen->AGPMode;
  90
  91    switch ( name ) {
  92    case GL_VENDOR:
  93       return (GLubyte *)"Tungsten Graphics, Inc.";
  94
  95    case GL_RENDERER:
  96       offset = driGetRendererString( buffer, "Radeon", DRIVER_DATE,
  97                                      agp_mode );
  98
  99       sprintf( & buffer[ offset ], " %sTCL",
 100                !(rmesa->TclFallback & RADEON_TCL_FALLBACK_TCL_DISABLE)
 101                ? "" : "NO-" );
 102
 103       return (GLubyte *)buffer;
 104
 105    default:
 106       return NULL;
 107    }
 108 }
 109
 110
 111 /* Extension strings exported by the R100 driver.
 112  */
 113 const struct dri_extension card_extensions[] =
 114 {
 115     { "GL_ARB_multitexture",               NULL },
 116     { "GL_ARB_texture_border_clamp",       NULL },
 117     { "GL_ARB_texture_env_add",            NULL },
 118     { "GL_ARB_texture_env_combine",        NULL },
 119     { "GL_ARB_texture_env_crossbar",       NULL },
 120     { "GL_ARB_texture_env_dot3",           NULL },
 121     { "GL_ARB_texture_mirrored_repeat",    NULL },
 122     { "GL_ARB_vertex_buffer_object",       GL_ARB_vertex_buffer_object_functions },
 123     { "GL_EXT_blend_logic_op",             NULL },
 124     { "GL_EXT_blend_subtract",             GL_EXT_blend_minmax_functions },
 125     { "GL_EXT_fog_coord",                  GL_EXT_fog_coord_functions },
 126     { "GL_EXT_secondary_color",            GL_EXT_secondary_color_functions },
 127     { "GL_EXT_stencil_wrap",               NULL },
 128     { "GL_EXT_texture_edge_clamp",         NULL },
 129     { "GL_EXT_texture_env_combine",        NULL },
 130     { "GL_EXT_texture_env_dot3",           NULL },
 131     { "GL_EXT_texture_filter_anisotropic", NULL },
 132     { "GL_EXT_texture_lod_bias",           NULL },
 133     { "GL_EXT_texture_mirror_clamp",       NULL },
 134     { "GL_ATI_texture_env_combine3",       NULL },
 135     { "GL_ATI_texture_mirror_once",        NULL },
 136     { "GL_MESA_ycbcr_texture",             NULL },
 137     { "GL_NV_blend_square",                NULL },
 138     { "GL_SGIS_generate_mipmap",           NULL },
 139     { NULL,                                NULL }
 140 };
 141
 142 extern const struct tnl_pipeline_stage _radeon_render_stage;
 143 extern const struct tnl_pipeline_stage _radeon_tcl_stage;
 144
 145 static const struct tnl_pipeline_stage *radeon_pipeline[] = {
 146
 147    /* Try and go straight to t&l
 148     */
 149    &_radeon_tcl_stage,
 150
 151    /* Catch any t&l fallbacks
 152     */
 153    &_tnl_vertex_transform_stage,
 154    &_tnl_normal_transform_stage,
 155    &_tnl_lighting_stage,
 156    &_tnl_fog_coordinate_stage,
 157    &_tnl_texgen_stage,
 158    &_tnl_texture_transform_stage,
 159
 160    &_radeon_render_stage,
 161    &_tnl_render_stage,          /* FALLBACK:  */
 162    NULL,
 163 };
 164
 165
 166
 167 /* Initialize the driver's misc functions.
 168  */
 169 static void radeonInitDriverFuncs( struct dd_function_table *functions )
 170 {
 171     functions->GetString        = radeonGetString;
 172 }
 173
 174 static const struct dri_debug_control debug_control[] =
 175 {
 176     { "fall",  DEBUG_FALLBACKS },
 177     { "tex",   DEBUG_TEXTURE },
 178     { "ioctl", DEBUG_IOCTL },
 179     { "prim",  DEBUG_PRIMS },
 180     { "vert",  DEBUG_VERTS },
 181     { "state", DEBUG_STATE },
 182     { "code",  DEBUG_CODEGEN },
 183     { "vfmt",  DEBUG_VFMT },
 184     { "vtxf",  DEBUG_VFMT },
 185     { "verb",  DEBUG_VERBOSE },
 186     { "dri",   DEBUG_DRI },
 187     { "dma",   DEBUG_DMA },
 188     { "san",   DEBUG_SANITY },
 189     { "sync",  DEBUG_SYNC },
 190     { NULL,    0 }
 191 };
 192
 193
 194 /* Create the device specific context.
 195  */
 196 GLboolean
 197 radeonCreateContext( const __GLcontextModes *glVisual,
 198                      __DRIcontextPrivate *driContextPriv,
 199                      void *sharedContextPrivate)
 200 {
 201    __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv;
 202    radeonScreenPtr screen = (radeonScreenPtr)(sPriv->private);
 203    struct dd_function_table functions;
 204    radeonContextPtr rmesa;
 205    GLcontext *ctx, *shareCtx;
 206    int i;
 207    int tcl_mode, fthrottle_mode;
 208
 209    assert(glVisual);
 210    assert(driContextPriv);
 211    assert(screen);
 212
 213    /* Allocate the Radeon context */
 214    rmesa = (radeonContextPtr) CALLOC( sizeof(*rmesa) );
 215    if ( !rmesa )
 216       return GL_FALSE;
 217
 218    /* init exp fog table data */
 219    radeonInitStaticFogData();
 220
 221    /* Parse configuration files.
 222     * Do this here so that initialMaxAnisotropy is set before we create
 223     * the default textures.
 224     */
 225    driParseConfigFiles (&rmesa->optionCache, &screen->optionCache,
 226                         screen->driScreen->myNum, "radeon");
 227    rmesa->initialMaxAnisotropy = driQueryOptionf(&rmesa->optionCache,
 228                                                  "def_max_anisotropy");
 229
 230    if ( driQueryOptionb( &rmesa->optionCache, "hyperz" ) ) {
 231       if ( sPriv->drm_version.minor < 13 )
 232          fprintf( stderr, "DRM version 1.%d too old to support HyperZ, "
 233                           "disabling.\n", sPriv->drm_version.minor );
 234       else
 235          rmesa->using_hyperz = GL_TRUE;
 236    }
 237
 238    if ( sPriv->drm_version.minor >= 15 )
 239       rmesa->texmicrotile = GL_TRUE;
 240
 241    /* Init default driver functions then plug in our Radeon-specific functions
 242     * (the texture functions are especially important)
 243     */
 244    _mesa_init_driver_functions( &functions );
 245    radeonInitDriverFuncs( &functions );
 246    radeonInitTextureFuncs( &functions );
 247
 248    /* Allocate the Mesa context */
 249    if (sharedContextPrivate)
 250       shareCtx = ((radeonContextPtr) sharedContextPrivate)->glCtx;
 251    else
 252       shareCtx = NULL;
 253    rmesa->glCtx = _mesa_create_context(glVisual, shareCtx,
 254                                        &functions, (void *) rmesa);
 255    if (!rmesa->glCtx) {
 256       FREE(rmesa);
 257       return GL_FALSE;
 258    }
 259    driContextPriv->driverPrivate = rmesa;
 260
 261    /* Init radeon context data */
 262    rmesa->dri.context = driContextPriv;
 263    rmesa->dri.screen = sPriv;
 264    rmesa->dri.drawable = NULL;
 265    rmesa->dri.readable = NULL;
 266    rmesa->dri.hwContext = driContextPriv->hHWContext;
 267    rmesa->dri.hwLock = &sPriv->pSAREA->lock;
 268    rmesa->dri.fd = sPriv->fd;
 269    rmesa->dri.drmMinor = sPriv->drm_version.minor;
 270
 271    rmesa->radeonScreen = screen;
 272    rmesa->sarea = (drm_radeon_sarea_t *)((GLubyte *)sPriv->pSAREA +
 273                                        screen->sarea_priv_offset);
 274
 275
 276    rmesa->dma.buf0_address = rmesa->radeonScreen->buffers->list[0].address;
 277
 278    (void) memset( rmesa->texture_heaps, 0, sizeof( rmesa->texture_heaps ) );
 279    make_empty_list( & rmesa->swapped );
 280
 281    rmesa->nr_heaps = screen->numTexHeaps;
 282    for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
 283       rmesa->texture_heaps[i] = driCreateTextureHeap( i, rmesa,
 284             screen->texSize[i],
 285             12,
 286             RADEON_NR_TEX_REGIONS,
 287             (drmTextureRegionPtr)rmesa->sarea->tex_list[i],
 288             & rmesa->sarea->tex_age[i],
 289             & rmesa->swapped,
 290             sizeof( radeonTexObj ),
 291             (destroy_texture_object_t *) radeonDestroyTexObj );
 292
 293       driSetTextureSwapCounterLocation( rmesa->texture_heaps[i],
 294                                         & rmesa->c_textureSwaps );
 295    }
 296    rmesa->texture_depth = driQueryOptioni (&rmesa->optionCache,
 297                                            "texture_depth");
 298    if (rmesa->texture_depth == DRI_CONF_TEXTURE_DEPTH_FB)
 299       rmesa->texture_depth = ( screen->cpp == 4 ) ?
 300          DRI_CONF_TEXTURE_DEPTH_32 : DRI_CONF_TEXTURE_DEPTH_16;
 301
 302    rmesa->swtcl.RenderIndex = ~0;
 303    rmesa->hw.all_dirty = GL_TRUE;
 304
 305    /* Set the maximum texture size small enough that we can guarentee that
 306     * all texture units can bind a maximal texture and have all of them in
 307     * texturable memory at once. Depending on the allow_large_textures driconf
 308     * setting allow larger textures.
 309     */
 310
 311    ctx = rmesa->glCtx;
 312    ctx->Const.MaxTextureUnits = driQueryOptioni (&rmesa->optionCache,
 313                                                  "texture_units");
 314    ctx->Const.MaxTextureImageUnits = ctx->Const.MaxTextureUnits;
 315    ctx->Const.MaxTextureCoordUnits = ctx->Const.MaxTextureUnits;
 316
 317    i = driQueryOptioni( &rmesa->optionCache, "allow_large_textures");
 318
 319    driCalculateMaxTextureLevels( rmesa->texture_heaps,
 320                                  rmesa->nr_heaps,
 321                                  & ctx->Const,
 322                                  4,
 323                                  11, /* max 2D texture size is 2048x2048 */
 324                                  8,  /* 256^3 */
 325                                  9,  /* \todo: max cube texture size seems to be 512x512(x6) */
 326                                  11, /* max rect texture size is 2048x2048. */
 327                                  12,
 328                                  GL_FALSE,
 329                                  i );
 330
 331
 332    ctx->Const.MaxTextureMaxAnisotropy = 16.0;
 333
 334    /* No wide points.
 335     */
 336    ctx->Const.MinPointSize = 1.0;
 337    ctx->Const.MinPointSizeAA = 1.0;
 338    ctx->Const.MaxPointSize = 1.0;
 339    ctx->Const.MaxPointSizeAA = 1.0;
 340
 341    ctx->Const.MinLineWidth = 1.0;
 342    ctx->Const.MinLineWidthAA = 1.0;
 343    ctx->Const.MaxLineWidth = 10.0;
 344    ctx->Const.MaxLineWidthAA = 10.0;
 345    ctx->Const.LineWidthGranularity = 0.0625;
 346
 347    /* Set maxlocksize (and hence vb size) small enough to avoid
 348     * fallbacks in radeon_tcl.c.  ie. guarentee that all vertices can
 349     * fit in a single dma buffer for indexed rendering of quad strips,
 350     * etc.
 351     */
 352    ctx->Const.MaxArrayLockSize =
 353       MIN2( ctx->Const.MaxArrayLockSize,
 354             RADEON_BUFFER_SIZE / RADEON_MAX_TCL_VERTSIZE );
 355
 356    rmesa->boxes = 0;
 357
 358    /* Initialize the software rasterizer and helper modules.
 359     */
 360    _swrast_CreateContext( ctx );
 361    _vbo_CreateContext( ctx );
 362    _tnl_CreateContext( ctx );
 363    _swsetup_CreateContext( ctx );
 364    _ae_create_context( ctx );
 365
 366    /* Install the customized pipeline:
 367     */
 368    _tnl_destroy_pipeline( ctx );
 369    _tnl_install_pipeline( ctx, radeon_pipeline );
 370
 371    /* Try and keep materials and vertices separate:
 372     */
 373 /*    _tnl_isolate_materials( ctx, GL_TRUE ); */
 374
 375    /* Configure swrast and T&L to match hardware characteristics:
 376     */
 377    _swrast_allow_pixel_fog( ctx, GL_FALSE );
 378    _swrast_allow_vertex_fog( ctx, GL_TRUE );
 379    _tnl_allow_pixel_fog( ctx, GL_FALSE );
 380    _tnl_allow_vertex_fog( ctx, GL_TRUE );
 381
 382
 383    for ( i = 0 ; i < RADEON_MAX_TEXTURE_UNITS ; i++ ) {
 384       _math_matrix_ctr( &rmesa->TexGenMatrix[i] );
 385       _math_matrix_ctr( &rmesa->tmpmat[i] );
 386       _math_matrix_set_identity( &rmesa->TexGenMatrix[i] );
 387       _math_matrix_set_identity( &rmesa->tmpmat[i] );
 388    }
 389
 390    driInitExtensions( ctx, card_extensions, GL_TRUE );
 391    if (rmesa->radeonScreen->drmSupportsCubeMapsR100)
 392       _mesa_enable_extension( ctx, "GL_ARB_texture_cube_map" );
 393    if (rmesa->glCtx->Mesa_DXTn) {
 394       _mesa_enable_extension( ctx, "GL_EXT_texture_compression_s3tc" );
 395       _mesa_enable_extension( ctx, "GL_S3_s3tc" );
 396    }
 397    else if (driQueryOptionb (&rmesa->optionCache, "force_s3tc_enable")) {
 398       _mesa_enable_extension( ctx, "GL_EXT_texture_compression_s3tc" );
 399    }
 400
 401    if (rmesa->dri.drmMinor >= 9)
 402       _mesa_enable_extension( ctx, "GL_NV_texture_rectangle");
 403
 404    /* XXX these should really go right after _mesa_init_driver_functions() */
 405    radeonInitIoctlFuncs( ctx );
 406    radeonInitStateFuncs( ctx );
 407    radeonInitSpanFuncs( ctx );
 408    radeonInitState( rmesa );
 409    radeonInitSwtcl( ctx );
 410
 411    _mesa_vector4f_alloc( &rmesa->tcl.ObjClean, 0,
 412                          ctx->Const.MaxArrayLockSize, 32 );
 413
 414    fthrottle_mode = driQueryOptioni(&rmesa->optionCache, "fthrottle_mode");
 415    rmesa->iw.irq_seq = -1;
 416    rmesa->irqsEmitted = 0;
 417    rmesa->do_irqs = (rmesa->radeonScreen->irq != 0 &&
 418                      fthrottle_mode == DRI_CONF_FTHROTTLE_IRQS);
 419
 420    rmesa->do_usleeps = (fthrottle_mode == DRI_CONF_FTHROTTLE_USLEEPS);
 421
 422    (*sPriv->systemTime->getUST)( & rmesa->swap_ust );
 423
 424
 425 #if DO_DEBUG
 426    RADEON_DEBUG = driParseDebugString( getenv( "RADEON_DEBUG" ),
 427                                        debug_control );
 428 #endif
 429
 430    tcl_mode = driQueryOptioni(&rmesa->optionCache, "tcl_mode");
 431    if (driQueryOptionb(&rmesa->optionCache, "no_rast")) {
 432       fprintf(stderr, "disabling 3D acceleration\n");
 433       FALLBACK(rmesa, RADEON_FALLBACK_DISABLE, 1);
 434    } else if (tcl_mode == DRI_CONF_TCL_SW ||
 435               !(rmesa->radeonScreen->chip_flags & RADEON_CHIPSET_TCL)) {
 436       if (rmesa->radeonScreen->chip_flags & RADEON_CHIPSET_TCL) {
 437          rmesa->radeonScreen->chip_flags &= ~RADEON_CHIPSET_TCL;
 438          fprintf(stderr, "Disabling HW TCL support\n");
 439       }
 440       TCL_FALLBACK(rmesa->glCtx, RADEON_TCL_FALLBACK_TCL_DISABLE, 1);
 441    }
 442
 443    if (rmesa->radeonScreen->chip_flags & RADEON_CHIPSET_TCL) {
 444 /*       _tnl_need_dlist_norm_lengths( ctx, GL_FALSE ); */
 445    }
 446    return GL_TRUE;
 447 }
 448
 449
 450 /* Destroy the device specific context.
 451  */
 452 /* Destroy the Mesa and driver specific context data.
 453  */
 454 void radeonDestroyContext( __DRIcontextPrivate *driContextPriv )
 455 {
 456    GET_CURRENT_CONTEXT(ctx);
 457    radeonContextPtr rmesa = (radeonContextPtr) driContextPriv->driverPrivate;
 458    radeonContextPtr current = ctx ? RADEON_CONTEXT(ctx) : NULL;
 459
 460    /* check if we're deleting the currently bound context */
 461    if (rmesa == current) {
 462       RADEON_FIREVERTICES( rmesa );
 463       _mesa_make_current(NULL, NULL, NULL);
 464    }
 465
 466    /* Free radeon context resources */
 467    assert(rmesa); /* should never be null */
 468    if ( rmesa ) {
 469       GLboolean   release_texture_heaps;
 470
 471
 472       release_texture_heaps = (rmesa->glCtx->Shared->RefCount == 1);
 473       _swsetup_DestroyContext( rmesa->glCtx );
 474       _tnl_DestroyContext( rmesa->glCtx );
 475       _vbo_DestroyContext( rmesa->glCtx );
 476       _swrast_DestroyContext( rmesa->glCtx );
 477
 478       radeonDestroySwtcl( rmesa->glCtx );
 479       radeonReleaseArrays( rmesa->glCtx, ~0 );
 480       if (rmesa->dma.current.buf) {
 481          radeonReleaseDmaRegion( rmesa, &rmesa->dma.current, __FUNCTION__ );
 482          radeonFlushCmdBuf( rmesa, __FUNCTION__ );
 483       }
 484
 485       _mesa_vector4f_free( &rmesa->tcl.ObjClean );
 486
 487       if (rmesa->state.scissor.pClipRects) {
 488          FREE(rmesa->state.scissor.pClipRects);
 489          rmesa->state.scissor.pClipRects = NULL;
 490       }
 491
 492       if ( release_texture_heaps ) {
 493          /* This share group is about to go away, free our private
 494           * texture object data.
 495           */
 496          int i;
 497
 498          for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
 499             driDestroyTextureHeap( rmesa->texture_heaps[ i ] );
 500             rmesa->texture_heaps[ i ] = NULL;
 501          }
 502
 503          assert( is_empty_list( & rmesa->swapped ) );
 504       }
 505
 506       /* free the Mesa context */
 507       rmesa->glCtx->DriverCtx = NULL;
 508       _mesa_destroy_context( rmesa->glCtx );
 509
 510       /* free the option cache */
 511       driDestroyOptionCache (&rmesa->optionCache);
 512
 513       FREE( rmesa );
 514    }
 515 }
 516
 517
 518
 519
 520 void
 521 radeonSwapBuffers( __DRIdrawablePrivate *dPriv )
 522 {
 523
 524    if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
 525       radeonContextPtr rmesa;
 526       GLcontext *ctx;
 527       rmesa = (radeonContextPtr) dPriv->driContextPriv->driverPrivate;
 528       ctx = rmesa->glCtx;
 529       if (ctx->Visual.doubleBufferMode) {
 530          _mesa_notifySwapBuffers( ctx );  /* flush pending rendering comands */
 531
 532          if ( rmesa->doPageFlip ) {
 533             radeonPageFlip( dPriv );
 534          }
 535          else {
 536              radeonCopyBuffer( dPriv, NULL );
 537          }
 538       }
 539    }
 540    else {
 541       /* XXX this shouldn't be an error but we can't handle it for now */
 542       _mesa_problem(NULL, "%s: drawable has no context!", __FUNCTION__);
 543    }
 544 }
 545
 546 void radeonCopySubBuffer(__DRIdrawablePrivate * dPriv,
 547                          int x, int y, int w, int h )
 548 {
 549     if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
 550         radeonContextPtr radeon;
 551         GLcontext *ctx;
 552
 553         radeon = (radeonContextPtr) dPriv->driContextPriv->driverPrivate;
 554         ctx = radeon->glCtx;
 555
 556         if (ctx->Visual.doubleBufferMode) {
 557             drm_clip_rect_t rect;
 558             rect.x1 = x + dPriv->x;
 559             rect.y1 = (dPriv->h - y - h) + dPriv->y;
 560             rect.x2 = rect.x1 + w;
 561             rect.y2 = rect.y1 + h;
 562             _mesa_notifySwapBuffers(ctx);       /* flush pending rendering comands */
 563             radeonCopyBuffer(dPriv, &rect);
 564         }
 565     } else {
 566         /* XXX this shouldn't be an error but we can't handle it for now */
 567         _mesa_problem(NULL, "%s: drawable has no context!",
 568                       __FUNCTION__);
 569     }
 570 }
 571
 572 /* Make context `c' the current context and bind it to the given
 573  * drawing and reading surfaces.
 574  */
 575 GLboolean
 576 radeonMakeCurrent( __DRIcontextPrivate *driContextPriv,
 577                    __DRIdrawablePrivate *driDrawPriv,
 578                    __DRIdrawablePrivate *driReadPriv )
 579 {
 580    if ( driContextPriv ) {
 581       radeonContextPtr newCtx =
 582          (radeonContextPtr) driContextPriv->driverPrivate;
 583
 584       if (RADEON_DEBUG & DEBUG_DRI)
 585          fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *) newCtx->glCtx);
 586
 587       newCtx->dri.readable = driReadPriv;
 588
 589       if ( (newCtx->dri.drawable != driDrawPriv) ||
 590            newCtx->lastStamp != driDrawPriv->lastStamp ) {
 591          if (driDrawPriv->swap_interval == (unsigned)-1) {
 592             driDrawPriv->vblFlags = (newCtx->radeonScreen->irq != 0)
 593                ? driGetDefaultVBlankFlags(&newCtx->optionCache)
 594                : VBLANK_FLAG_NO_IRQ;
 595
 596             driDrawableInitVBlank( driDrawPriv );
 597          }
 598
 599          newCtx->dri.drawable = driDrawPriv;
 600
 601          radeonSetCliprects(newCtx);
 602          radeonUpdateViewportOffset( newCtx->glCtx );
 603       }
 604
 605       _mesa_make_current( newCtx->glCtx,
 606                           (GLframebuffer *) driDrawPriv->driverPrivate,
 607                           (GLframebuffer *) driReadPriv->driverPrivate );
 608
 609       _mesa_update_state( newCtx->glCtx );
 610    } else {
 611       if (RADEON_DEBUG & DEBUG_DRI)
 612          fprintf(stderr, "%s ctx is null\n", __FUNCTION__);
 613       _mesa_make_current( NULL, NULL, NULL );
 614    }
 615
 616    if (RADEON_DEBUG & DEBUG_DRI)
 617       fprintf(stderr, "End %s\n", __FUNCTION__);
 618    return GL_TRUE;
 619 }
 620
 621 /* Force the context `c' to be unbound from its buffer.
 622  */
 623 GLboolean
 624 radeonUnbindContext( __DRIcontextPrivate *driContextPriv )
 625 {
 626    radeonContextPtr rmesa = (radeonContextPtr) driContextPriv->driverPrivate;
 627
 628    if (RADEON_DEBUG & DEBUG_DRI)
 629       fprintf(stderr, "%s ctx %p\n", __FUNCTION__, (void *) rmesa->glCtx);
 630
 631    return GL_TRUE;
 632 }