src/mesa/drivers/dri/r128/r128_context.c

   1 /* $XFree86: xc/lib/GL/mesa/src/drv/r128/r128_context.c,v 1.8 2002/10/30 12:51:38 alanh Exp $ */
   2 /**************************************************************************
   3
   4 Copyright 1999, 2000 ATI Technologies Inc. and Precision Insight, Inc.,
   5                                                Cedar Park, Texas.
   6 All Rights Reserved.
   7
   8 Permission is hereby granted, free of charge, to any person obtaining a
   9 copy of this software and associated documentation files (the "Software"),
  10 to deal in the Software without restriction, including without limitation
  11 on the rights to use, copy, modify, merge, publish, distribute, sub
  12 license, and/or sell copies of the Software, and to permit persons to whom
  13 the Software is furnished to do so, subject to the following conditions:
  14
  15 The above copyright notice and this permission notice (including the next
  16 paragraph) shall be included in all copies or substantial portions of the
  17 Software.
  18
  19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21 FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  22 ATI, PRECISION INSIGHT AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  23 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  24 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  25 USE OR OTHER DEALINGS IN THE SOFTWARE.
  26
  27 **************************************************************************/
  28
  29 /*
  30  * Authors:
  31  *   Kevin E. Martin <martin@valinux.com>
  32  *   Gareth Hughes <gareth@valinux.com>
  33  *
  34  */
  35
  36 #include "glheader.h"
  37 #include "context.h"
  38 #include "simple_list.h"
  39 #include "imports.h"
  40 #include "matrix.h"
  41 #include "extensions.h"
  42
  43 #include "swrast/swrast.h"
  44 #include "swrast_setup/swrast_setup.h"
  45 #include "array_cache/acache.h"
  46
  47 #include "tnl/tnl.h"
  48 #include "tnl/t_pipeline.h"
  49
  50 #include "drivers/common/driverfuncs.h"
  51
  52 #include "r128_context.h"
  53 #include "r128_ioctl.h"
  54 #include "r128_dd.h"
  55 #include "r128_state.h"
  56 #include "r128_span.h"
  57 #include "r128_tex.h"
  58 #include "r128_tris.h"
  59 #include "r128_vb.h"
  60
  61 #include "vblank.h"
  62 #include "utils.h"
  63 #include "texmem.h"
  64 #include "xmlpool.h" /* for symbolic values of enum-type options */
  65
  66 #ifndef R128_DEBUG
  67 int R128_DEBUG = 0;
  68 #endif
  69
  70 static const char * const card_extensions[] =
  71 {
  72    "GL_ARB_multisample",
  73    "GL_ARB_multitexture",
  74    "GL_ARB_texture_compression",
  75    "GL_ARB_texture_env_add",
  76    "GL_ARB_texture_mirrored_repeat",
  77    "GL_EXT_blend_subtract",
  78    "GL_EXT_texture_edge_clamp",
  79    "GL_MESA_ycbcr_texture",
  80    "GL_NV_blend_square",
  81    "GL_SGIS_generate_mipmap",
  82    NULL
  83 };
  84
  85 static const struct dri_debug_control debug_control[] =
  86 {
  87     { "ioctl", DEBUG_VERBOSE_IOCTL },
  88     { "verb",  DEBUG_VERBOSE_MSG },
  89     { "dri",   DEBUG_VERBOSE_DRI },
  90     { "2d",    DEBUG_VERBOSE_2D },
  91     { "sync",  DEBUG_ALWAYS_SYNC },
  92     { "api",   DEBUG_VERBOSE_API },
  93     { NULL,    0 }
  94 };
  95
  96 /* Create the device specific context.
  97  */
  98 GLboolean r128CreateContext( const __GLcontextModes *glVisual,
  99                              __DRIcontextPrivate *driContextPriv,
 100                              void *sharedContextPrivate )
 101 {
 102    GLcontext *ctx, *shareCtx;
 103    __DRIscreenPrivate *sPriv = driContextPriv->driScreenPriv;
 104    struct dd_function_table functions;
 105    r128ContextPtr rmesa;
 106    r128ScreenPtr r128scrn;
 107    int i;
 108
 109    /* Allocate the r128 context */
 110    rmesa = (r128ContextPtr) CALLOC( sizeof(*rmesa) );
 111    if ( !rmesa )
 112       return GL_FALSE;
 113
 114    /* Init default driver functions then plug in our Radeon-specific functions
 115     * (the texture functions are especially important)
 116     */
 117    _mesa_init_driver_functions( &functions );
 118    r128InitDriverFuncs( &functions );
 119    r128InitIoctlFuncs( &functions );
 120    r128InitTextureFuncs( &functions );
 121
 122    /* Allocate the Mesa context */
 123    if (sharedContextPrivate)
 124       shareCtx = ((r128ContextPtr) sharedContextPrivate)->glCtx;
 125    else
 126       shareCtx = NULL;
 127    rmesa->glCtx = _mesa_create_context(glVisual, shareCtx,
 128                                        &functions, (void *) rmesa);
 129    if (!rmesa->glCtx) {
 130       FREE(rmesa);
 131       return GL_FALSE;
 132    }
 133    driContextPriv->driverPrivate = rmesa;
 134    ctx = rmesa->glCtx;
 135
 136    rmesa->driContext = driContextPriv;
 137    rmesa->driScreen = sPriv;
 138    rmesa->driDrawable = NULL;
 139    rmesa->hHWContext = driContextPriv->hHWContext;
 140    rmesa->driHwLock = &sPriv->pSAREA->lock;
 141    rmesa->driFd = sPriv->fd;
 142
 143    r128scrn = rmesa->r128Screen = (r128ScreenPtr)(sPriv->private);
 144
 145    /* Parse configuration files */
 146    driParseConfigFiles (&rmesa->optionCache, &r128scrn->optionCache,
 147                         r128scrn->driScreen->myNum, "r128");
 148
 149    rmesa->sarea = (drm_r128_sarea_t *)((char *)sPriv->pSAREA +
 150                                      r128scrn->sarea_priv_offset);
 151
 152    rmesa->CurrentTexObj[0] = NULL;
 153    rmesa->CurrentTexObj[1] = NULL;
 154
 155    (void) memset( rmesa->texture_heaps, 0, sizeof( rmesa->texture_heaps ) );
 156    make_empty_list( & rmesa->swapped );
 157
 158    rmesa->nr_heaps = r128scrn->numTexHeaps;
 159    for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
 160       rmesa->texture_heaps[i] = driCreateTextureHeap( i, rmesa,
 161             r128scrn->texSize[i],
 162             12,
 163             R128_NR_TEX_REGIONS,
 164             (drmTextureRegionPtr)rmesa->sarea->tex_list[i],
 165             &rmesa->sarea->tex_age[i],
 166             &rmesa->swapped,
 167             sizeof( r128TexObj ),
 168             (destroy_texture_object_t *) r128DestroyTexObj );
 169
 170       driSetTextureSwapCounterLocation( rmesa->texture_heaps[i],
 171                                         & rmesa->c_textureSwaps );
 172    }
 173    rmesa->texture_depth = driQueryOptioni (&rmesa->optionCache,
 174                                            "texture_depth");
 175    if (rmesa->texture_depth == DRI_CONF_TEXTURE_DEPTH_FB)
 176       rmesa->texture_depth = ( r128scrn->cpp == 4 ) ?
 177          DRI_CONF_TEXTURE_DEPTH_32 : DRI_CONF_TEXTURE_DEPTH_16;
 178
 179
 180    rmesa->RenderIndex = -1;             /* Impossible value */
 181    rmesa->vert_buf = NULL;
 182    rmesa->num_verts = 0;
 183
 184    /* Set the maximum texture size small enough that we can guarentee that
 185     * all texture units can bind a maximal texture and have them both in
 186     * texturable memory at once.
 187     */
 188
 189    ctx->Const.MaxTextureUnits = 2;
 190    ctx->Const.MaxTextureImageUnits = 2;
 191    ctx->Const.MaxTextureCoordUnits = 2;
 192
 193    driCalculateMaxTextureLevels( rmesa->texture_heaps,
 194                                  rmesa->nr_heaps,
 195                                  & ctx->Const,
 196                                  4,
 197                                  10, /* max 2D texture size is 1024x1024 */
 198                                  0,  /* 3D textures unsupported. */
 199                                  0,  /* cube textures unsupported. */
 200                                  0,  /* texture rectangles unsupported. */
 201                                  11,
 202                                  GL_FALSE );
 203
 204    /* No wide points.
 205     */
 206    ctx->Const.MinPointSize = 1.0;
 207    ctx->Const.MinPointSizeAA = 1.0;
 208    ctx->Const.MaxPointSize = 1.0;
 209    ctx->Const.MaxPointSizeAA = 1.0;
 210
 211    /* No wide lines.
 212     */
 213    ctx->Const.MinLineWidth = 1.0;
 214    ctx->Const.MinLineWidthAA = 1.0;
 215    ctx->Const.MaxLineWidth = 1.0;
 216    ctx->Const.MaxLineWidthAA = 1.0;
 217    ctx->Const.LineWidthGranularity = 1.0;
 218
 219 #if ENABLE_PERF_BOXES
 220    rmesa->boxes = driQueryOptionb(&rmesa->optionCache, "performance_boxes");
 221 #endif
 222
 223    /* Initialize the software rasterizer and helper modules.
 224     */
 225    _swrast_CreateContext( ctx );
 226    _ac_CreateContext( ctx );
 227    _tnl_CreateContext( ctx );
 228    _swsetup_CreateContext( ctx );
 229
 230    /* Install the customized pipeline:
 231     */
 232 /*     _tnl_destroy_pipeline( ctx ); */
 233 /*     _tnl_install_pipeline( ctx, r128_pipeline ); */
 234
 235    /* Configure swrast and T&L to match hardware characteristics:
 236     */
 237    _swrast_allow_pixel_fog( ctx, GL_FALSE );
 238    _swrast_allow_vertex_fog( ctx, GL_TRUE );
 239    _tnl_allow_pixel_fog( ctx, GL_FALSE );
 240    _tnl_allow_vertex_fog( ctx, GL_TRUE );
 241
 242    driInitExtensions( ctx, card_extensions, GL_TRUE );
 243    if (sPriv->drmMinor >= 4)
 244       _mesa_enable_extension( ctx, "GL_MESA_ycbcr_texture" );
 245
 246    r128InitVB( ctx );
 247    r128InitTriFuncs( ctx );
 248    r128DDInitStateFuncs( ctx );
 249    r128DDInitSpanFuncs( ctx );
 250    r128DDInitState( rmesa );
 251
 252    rmesa->vblank_flags = (rmesa->r128Screen->irq != 0)
 253        ? driGetDefaultVBlankFlags(&rmesa->optionCache) : VBLANK_FLAG_NO_IRQ;
 254
 255    driContextPriv->driverPrivate = (void *)rmesa;
 256
 257 #if DO_DEBUG
 258    R128_DEBUG = driParseDebugString( getenv( "R128_DEBUG" ),
 259                                      debug_control );
 260 #endif
 261
 262    return GL_TRUE;
 263 }
 264
 265 /* Destroy the device specific context.
 266  */
 267 void r128DestroyContext( __DRIcontextPrivate *driContextPriv  )
 268 {
 269    r128ContextPtr rmesa = (r128ContextPtr) driContextPriv->driverPrivate;
 270
 271    assert(rmesa);  /* should never be null */
 272    if ( rmesa ) {
 273       GLboolean   release_texture_heaps;
 274
 275
 276       release_texture_heaps = (rmesa->glCtx->Shared->RefCount == 1);
 277
 278       _swsetup_DestroyContext( rmesa->glCtx );
 279       _tnl_DestroyContext( rmesa->glCtx );
 280       _ac_DestroyContext( rmesa->glCtx );
 281       _swrast_DestroyContext( rmesa->glCtx );
 282
 283       r128FreeVB( rmesa->glCtx );
 284
 285       /* free the Mesa context */
 286       rmesa->glCtx->DriverCtx = NULL;
 287       _mesa_destroy_context(rmesa->glCtx);
 288
 289       if ( release_texture_heaps ) {
 290          /* This share group is about to go away, free our private
 291           * texture object data.
 292           */
 293          int i;
 294
 295          for ( i = 0 ; i < rmesa->nr_heaps ; i++ ) {
 296             driDestroyTextureHeap( rmesa->texture_heaps[ i ] );
 297             rmesa->texture_heaps[ i ] = NULL;
 298          }
 299
 300          assert( is_empty_list( & rmesa->swapped ) );
 301       }
 302
 303       /* free the option cache */
 304       driDestroyOptionCache (&rmesa->optionCache);
 305
 306       FREE( rmesa );
 307    }
 308
 309 #if 0
 310    /* Use this to force shared object profiling. */
 311    glx_fini_prof();
 312 #endif
 313 }
 314
 315
 316 /* Force the context `c' to be the current context and associate with it
 317  * buffer `b'.
 318  */
 319 GLboolean
 320 r128MakeCurrent( __DRIcontextPrivate *driContextPriv,
 321                  __DRIdrawablePrivate *driDrawPriv,
 322                  __DRIdrawablePrivate *driReadPriv )
 323 {
 324    if ( driContextPriv ) {
 325       GET_CURRENT_CONTEXT(ctx);
 326       r128ContextPtr oldR128Ctx = ctx ? R128_CONTEXT(ctx) : NULL;
 327       r128ContextPtr newR128Ctx = (r128ContextPtr) driContextPriv->driverPrivate;
 328
 329       if ( newR128Ctx != oldR128Ctx ) {
 330          newR128Ctx->new_state |= R128_NEW_CONTEXT;
 331          newR128Ctx->dirty = R128_UPLOAD_ALL;
 332       }
 333
 334       driDrawableInitVBlank( driDrawPriv, newR128Ctx->vblank_flags );
 335       newR128Ctx->driDrawable = driDrawPriv;
 336
 337       _mesa_make_current2( newR128Ctx->glCtx,
 338                            (GLframebuffer *) driDrawPriv->driverPrivate,
 339                            (GLframebuffer *) driReadPriv->driverPrivate );
 340
 341
 342       newR128Ctx->new_state |= R128_NEW_WINDOW | R128_NEW_CLIP;
 343
 344       if ( !newR128Ctx->glCtx->Viewport.Width ) {
 345          _mesa_set_viewport(newR128Ctx->glCtx, 0, 0,
 346                             driDrawPriv->w, driDrawPriv->h);
 347       }
 348    } else {
 349       _mesa_make_current( 0, 0 );
 350    }
 351
 352    return GL_TRUE;
 353 }
 354
 355
 356 /* Force the context `c' to be unbound from its buffer.
 357  */
 358 GLboolean
 359 r128UnbindContext( __DRIcontextPrivate *driContextPriv )
 360 {
 361    return GL_TRUE;
 362 }