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