src/mesa/drivers/dri/mach64/mach64_screen.c

   1 /* -*- mode: c; c-basic-offset: 3 -*- */
   2 /*
   3  * Copyright 2000 Gareth Hughes
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the next
  14  * paragraph) shall be included in all copies or substantial portions of the
  15  * Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * GARETH HUGHES BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  21  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /*
  26  * Authors:
  27  *      Gareth Hughes <gareth@valinux.com>
  28  *      Leif Delgass <ldelgass@retinalburn.net>
  29  *      Jos�Fonseca <j_r_fonseca@yahoo.co.uk>
  30  */
  31
  32 #include "mach64_context.h"
  33 #include "mach64_ioctl.h"
  34 #include "mach64_tris.h"
  35 #include "mach64_vb.h"
  36 #include "mach64_span.h"
  37
  38 #include "main/context.h"
  39 #include "main/imports.h"
  40 #include "main/framebuffer.h"
  41 #include "main/renderbuffer.h"
  42
  43 #include "utils.h"
  44 #include "vblank.h"
  45
  46 #include "GL/internal/dri_interface.h"
  47
  48 /* Mach64 configuration
  49  */
  50 #include "xmlpool.h"
  51
  52 PUBLIC const char __driConfigOptions[] =
  53 DRI_CONF_BEGIN
  54     DRI_CONF_SECTION_PERFORMANCE
  55         DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_DEF_INTERVAL_0)
  56     DRI_CONF_SECTION_END
  57     DRI_CONF_SECTION_DEBUG
  58         DRI_CONF_NO_RAST(false)
  59 #if ENABLE_PERF_BOXES
  60         DRI_CONF_PERFORMANCE_BOXES(false)
  61 #endif
  62     DRI_CONF_SECTION_END
  63 DRI_CONF_END;
  64 #if ENABLE_PERF_BOXES
  65 static const GLuint __driNConfigOptions = 3;
  66 #else
  67 static const GLuint __driNConfigOptions = 2;
  68 #endif
  69
  70 extern const struct dri_extension card_extensions[];
  71
  72 static const __DRIconfig **
  73 mach64FillInModes( __DRIscreenPrivate *psp,
  74                    unsigned pixel_bits, unsigned depth_bits,
  75                    unsigned stencil_bits, GLboolean have_back_buffer )
  76 {
  77     __DRIconfig **configs;
  78     __GLcontextModes * m;
  79     GLenum fb_format;
  80     GLenum fb_type;
  81     unsigned depth_buffer_factor;
  82     unsigned back_buffer_factor;
  83     unsigned i;
  84
  85     /* Right now GLX_SWAP_COPY_OML isn't supported, but it would be easy
  86      * enough to add support.  Basically, if a context is created with an
  87      * fbconfig where the swap method is GLX_SWAP_COPY_OML, pageflipping
  88      * will never be used.
  89      */
  90     static const GLenum back_buffer_modes[] = {
  91         GLX_NONE, GLX_SWAP_UNDEFINED_OML /*, GLX_SWAP_COPY_OML */
  92     };
  93
  94     uint8_t depth_bits_array[2];
  95     uint8_t stencil_bits_array[2];
  96
  97     depth_bits_array[0] = depth_bits;
  98     depth_bits_array[1] = depth_bits;
  99
 100     /* Just like with the accumulation buffer, always provide some modes
 101      * with a stencil buffer.  It will be a sw fallback, but some apps won't
 102      * care about that.
 103      */
 104     stencil_bits_array[0] = 0;
 105     stencil_bits_array[1] = (stencil_bits == 0) ? 8 : stencil_bits;
 106
 107     depth_buffer_factor = ((depth_bits != 0) || (stencil_bits != 0)) ? 2 : 1;
 108     back_buffer_factor  = (have_back_buffer) ? 2 : 1;
 109
 110     if (pixel_bits == 16) {
 111        fb_format = GL_RGB;
 112        fb_type = GL_UNSIGNED_SHORT_5_6_5;
 113     }
 114     else {
 115        fb_format = GL_BGRA;
 116        fb_type = GL_UNSIGNED_INT_8_8_8_8_REV;
 117     }
 118
 119     configs = driCreateConfigs(fb_format, fb_type,
 120                                depth_bits_array, stencil_bits_array,
 121                                depth_buffer_factor, back_buffer_modes,
 122                                back_buffer_factor);
 123     if (configs == NULL) {
 124        fprintf(stderr, "[%s:%u] Error creating FBConfig!\n",
 125                __func__, __LINE__);
 126        return NULL;
 127     }
 128
 129     /* Mark the visual as slow if there are "fake" stencil bits.
 130      */
 131     for (i = 0; configs[i]; i++) {
 132        m = &configs[i]->modes;
 133        if ((m->stencilBits != 0) && (m->stencilBits != stencil_bits)) {
 134           m->visualRating = GLX_SLOW_CONFIG;
 135        }
 136     }
 137
 138     return (const __DRIconfig **) configs;
 139 }
 140
 141
 142 /* Create the device specific screen private data struct.
 143  */
 144 static mach64ScreenRec *
 145 mach64CreateScreen( __DRIscreenPrivate *sPriv )
 146 {
 147    mach64ScreenPtr mach64Screen;
 148    ATIDRIPtr serverInfo = (ATIDRIPtr)sPriv->pDevPriv;
 149    int i;
 150
 151    if (sPriv->devPrivSize != sizeof(ATIDRIRec)) {
 152       fprintf(stderr,"\nERROR!  sizeof(ATIDRIRec) does not match passed size from device driver\n");
 153       return GL_FALSE;
 154    }
 155
 156    if ( MACH64_DEBUG & DEBUG_VERBOSE_DRI )
 157       fprintf( stderr, "%s\n", __FUNCTION__ );
 158
 159    /* Allocate the private area */
 160    mach64Screen = (mach64ScreenPtr) CALLOC( sizeof(*mach64Screen) );
 161    if ( !mach64Screen ) return NULL;
 162
 163    /* parse information in __driConfigOptions */
 164    driParseOptionInfo (&mach64Screen->optionCache,
 165                        __driConfigOptions, __driNConfigOptions);
 166
 167    mach64Screen->IsPCI = serverInfo->IsPCI;
 168
 169    {
 170       drm_mach64_getparam_t gp;
 171       int ret;
 172
 173       gp.param = MACH64_PARAM_IRQ_NR;
 174       gp.value = (void *) &mach64Screen->irq;
 175
 176       ret = drmCommandWriteRead( sPriv->fd, DRM_MACH64_GETPARAM,
 177                                     &gp, sizeof(gp));
 178       if (ret) {
 179          fprintf(stderr, "DRM_MACH64_GETPARAM (MACH64_PARAM_IRQ_NR): %d\n", ret);
 180          FREE( mach64Screen );
 181          return NULL;
 182       }
 183    }
 184
 185    mach64Screen->mmio.handle = serverInfo->regs;
 186    mach64Screen->mmio.size   = serverInfo->regsSize;
 187    if ( drmMap( sPriv->fd,
 188                 mach64Screen->mmio.handle,
 189                 mach64Screen->mmio.size,
 190                 (drmAddressPtr)&mach64Screen->mmio.map ) != 0 ) {
 191       FREE( mach64Screen );
 192       return NULL;
 193    }
 194
 195    mach64Screen->buffers = drmMapBufs( sPriv->fd );
 196    if ( !mach64Screen->buffers ) {
 197       drmUnmap( (drmAddress)mach64Screen->mmio.map,
 198                 mach64Screen->mmio.size );
 199       FREE( mach64Screen );
 200       return NULL;
 201    }
 202
 203    if ( !mach64Screen->IsPCI ) {
 204       mach64Screen->agpTextures.handle = serverInfo->agp;
 205       mach64Screen->agpTextures.size   = serverInfo->agpSize;
 206       if ( drmMap( sPriv->fd,
 207                    mach64Screen->agpTextures.handle,
 208                    mach64Screen->agpTextures.size,
 209                    (drmAddressPtr)&mach64Screen->agpTextures.map ) ) {
 210          drmUnmapBufs( mach64Screen->buffers );
 211          drmUnmap( (drmAddress)mach64Screen->mmio.map, mach64Screen->mmio.size );
 212          FREE( mach64Screen );
 213          return NULL;
 214       }
 215    }
 216
 217    mach64Screen->AGPMode        = serverInfo->AGPMode;
 218
 219    mach64Screen->chipset        = serverInfo->chipset;
 220    mach64Screen->width          = serverInfo->width;
 221    mach64Screen->height         = serverInfo->height;
 222    mach64Screen->mem            = serverInfo->mem;
 223    mach64Screen->cpp            = serverInfo->cpp;
 224
 225    mach64Screen->frontOffset    = serverInfo->frontOffset;
 226    mach64Screen->frontPitch     = serverInfo->frontPitch;
 227    mach64Screen->backOffset     = serverInfo->backOffset;
 228    mach64Screen->backPitch      = serverInfo->backPitch;
 229    mach64Screen->depthOffset    = serverInfo->depthOffset;
 230    mach64Screen->depthPitch     = serverInfo->depthPitch;
 231
 232    mach64Screen->texOffset[MACH64_CARD_HEAP] = serverInfo->textureOffset;
 233    mach64Screen->texSize[MACH64_CARD_HEAP] = serverInfo->textureSize;
 234    mach64Screen->logTexGranularity[MACH64_CARD_HEAP] =
 235       serverInfo->logTextureGranularity;
 236
 237    if ( mach64Screen->IsPCI ) {
 238       mach64Screen->numTexHeaps = MACH64_NR_TEX_HEAPS - 1;
 239       mach64Screen->firstTexHeap = MACH64_CARD_HEAP;
 240       mach64Screen->texOffset[MACH64_AGP_HEAP] = 0;
 241       mach64Screen->texSize[MACH64_AGP_HEAP] = 0;
 242       mach64Screen->logTexGranularity[MACH64_AGP_HEAP] = 0;
 243    } else {
 244       if (serverInfo->textureSize > 0) {
 245          mach64Screen->numTexHeaps = MACH64_NR_TEX_HEAPS;
 246          mach64Screen->firstTexHeap = MACH64_CARD_HEAP;
 247       } else {
 248          mach64Screen->numTexHeaps = MACH64_NR_TEX_HEAPS - 1;
 249          mach64Screen->firstTexHeap = MACH64_AGP_HEAP;
 250       }
 251       mach64Screen->texOffset[MACH64_AGP_HEAP] = serverInfo->agpTextureOffset;
 252       mach64Screen->texSize[MACH64_AGP_HEAP] = serverInfo->agpSize;
 253       mach64Screen->logTexGranularity[MACH64_AGP_HEAP] = serverInfo->logAgpTextureGranularity;
 254    }
 255
 256    mach64Screen->driScreen = sPriv;
 257
 258    i = 0;
 259    mach64Screen->extensions[i++] = &driFrameTrackingExtension.base;
 260    if ( mach64Screen->irq != 0 ) {
 261       mach64Screen->extensions[i++] = &driSwapControlExtension.base;
 262       mach64Screen->extensions[i++] = &driMediaStreamCounterExtension.base;
 263    }
 264    mach64Screen->extensions[i++] = NULL;
 265    sPriv->extensions = mach64Screen->extensions;
 266
 267    return mach64Screen;
 268 }
 269
 270 /* Destroy the device specific screen private data struct.
 271  */
 272 static void
 273 mach64DestroyScreen( __DRIscreenPrivate *driScreen )
 274 {
 275    mach64ScreenRec *mach64Screen = (mach64ScreenRec *) driScreen->private;
 276
 277    if ( !mach64Screen )
 278       return;
 279
 280    if ( MACH64_DEBUG & DEBUG_VERBOSE_DRI )
 281       fprintf( stderr, "%s\n", __FUNCTION__ );
 282
 283    if ( !mach64Screen->IsPCI ) {
 284       drmUnmap( (drmAddress)mach64Screen->agpTextures.map,
 285                 mach64Screen->agpTextures.size );
 286    }
 287
 288    drmUnmapBufs( mach64Screen->buffers );
 289    drmUnmap( (drmAddress)mach64Screen->mmio.map, mach64Screen->mmio.size );
 290
 291    FREE( mach64Screen );
 292    driScreen->private = NULL;
 293 }
 294
 295
 296 /* Create and initialize the Mesa and driver specific pixmap buffer
 297  * data.
 298  */
 299 static GLboolean
 300 mach64CreateBuffer( __DRIscreenPrivate *driScrnPriv,
 301                     __DRIdrawablePrivate *driDrawPriv,
 302                     const __GLcontextModes *mesaVis,
 303                     GLboolean isPixmap )
 304 {
 305    mach64ScreenPtr screen = (mach64ScreenPtr) driScrnPriv->private;
 306
 307    if (isPixmap) {
 308       return GL_FALSE; /* not implemented */
 309    }
 310    else {
 311       struct gl_framebuffer *fb = _mesa_create_framebuffer(mesaVis);
 312
 313       {
 314          driRenderbuffer *frontRb
 315             = driNewRenderbuffer(GL_RGBA,
 316                                  NULL,
 317                                  screen->cpp,
 318                                  screen->frontOffset, screen->frontPitch,
 319                                  driDrawPriv);
 320          mach64SetSpanFunctions(frontRb, mesaVis);
 321          _mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &frontRb->Base);
 322       }
 323
 324       if (mesaVis->doubleBufferMode) {
 325          driRenderbuffer *backRb
 326             = driNewRenderbuffer(GL_RGBA,
 327                                  NULL,
 328                                  screen->cpp,
 329                                  screen->backOffset, screen->backPitch,
 330                                  driDrawPriv);
 331          mach64SetSpanFunctions(backRb, mesaVis);
 332          _mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &backRb->Base);
 333       }
 334
 335       if (mesaVis->depthBits == 16) {
 336          driRenderbuffer *depthRb
 337             = driNewRenderbuffer(GL_DEPTH_COMPONENT16,
 338                                  NULL, screen->cpp,
 339                                  screen->depthOffset, screen->depthPitch,
 340                                  driDrawPriv);
 341          mach64SetSpanFunctions(depthRb, mesaVis);
 342          _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &depthRb->Base);
 343       }
 344       else if (mesaVis->depthBits == 24) {
 345          /* XXX I don't think 24-bit Z is supported - so this isn't used */
 346          driRenderbuffer *depthRb
 347             = driNewRenderbuffer(GL_DEPTH_COMPONENT24,
 348                                  NULL,
 349                                  screen->cpp,
 350                                  screen->depthOffset, screen->depthPitch,
 351                                  driDrawPriv);
 352          mach64SetSpanFunctions(depthRb, mesaVis);
 353          _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &depthRb->Base);
 354       }
 355
 356       _mesa_add_soft_renderbuffers(fb,
 357                                    GL_FALSE, /* color */
 358                                    GL_FALSE, /* depth */
 359                                    mesaVis->stencilBits > 0,
 360                                    mesaVis->accumRedBits > 0,
 361                                    GL_FALSE, /* alpha */
 362                                    GL_FALSE /* aux */);
 363       driDrawPriv->driverPrivate = (void *) fb;
 364
 365       return (driDrawPriv->driverPrivate != NULL);
 366    }
 367 }
 368
 369
 370 static void
 371 mach64DestroyBuffer(__DRIdrawablePrivate *driDrawPriv)
 372 {
 373    _mesa_unreference_framebuffer((GLframebuffer **)(&(driDrawPriv->driverPrivate)));
 374 }
 375
 376
 377 /* Copy the back color buffer to the front color buffer */
 378 static void
 379 mach64SwapBuffers(__DRIdrawablePrivate *dPriv)
 380 {
 381    if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
 382       mach64ContextPtr mmesa;
 383       GLcontext *ctx;
 384       mmesa = (mach64ContextPtr) dPriv->driContextPriv->driverPrivate;
 385       ctx = mmesa->glCtx;
 386       if (ctx->Visual.doubleBufferMode) {
 387          _mesa_notifySwapBuffers( ctx );  /* flush pending rendering comands */
 388          mach64CopyBuffer( dPriv );
 389       }
 390    }
 391    else {
 392       /* XXX this shouldn't be an error but we can't handle it for now */
 393       _mesa_problem(NULL, "%s: drawable has no context!", __FUNCTION__);
 394    }
 395 }
 396
 397
 398 /* Initialize the driver specific screen private data.
 399  */
 400 static GLboolean
 401 mach64InitDriver( __DRIscreenPrivate *driScreen )
 402 {
 403    driScreen->private = (void *) mach64CreateScreen( driScreen );
 404
 405    if ( !driScreen->private ) {
 406       mach64DestroyScreen( driScreen );
 407       return GL_FALSE;
 408    }
 409
 410    return GL_TRUE;
 411 }
 412
 413 /**
 414  * This is the driver specific part of the createNewScreen entry point.
 415  *
 416  * \todo maybe fold this into intelInitDriver
 417  *
 418  * \return the __GLcontextModes supported by this driver
 419  */
 420 static const __DRIconfig **
 421 mach64InitScreen(__DRIscreenPrivate *psp)
 422 {
 423    static const __DRIversion ddx_expected = { 6, 4, 0 };
 424    static const __DRIversion dri_expected = { 4, 0, 0 };
 425    static const __DRIversion drm_expected = { 2, 0, 0 };
 426    ATIDRIPtr dri_priv = (ATIDRIPtr) psp->pDevPriv;
 427
 428    if ( ! driCheckDriDdxDrmVersions2( "Mach64",
 429                                       &psp->dri_version, & dri_expected,
 430                                       &psp->ddx_version, & ddx_expected,
 431                                       &psp->drm_version, & drm_expected ) ) {
 432       return NULL;
 433    }
 434
 435    /* Calling driInitExtensions here, with a NULL context pointer,
 436     * does not actually enable the extensions.  It just makes sure
 437     * that all the dispatch offsets for all the extensions that
 438     * *might* be enables are known.  This is needed because the
 439     * dispatch offsets need to be known when _mesa_context_create is
 440     * called, but we can't enable the extensions until we have a
 441     * context pointer.
 442     *
 443     * Hello chicken.  Hello egg.  How are you two today?
 444     */
 445    driInitExtensions( NULL, card_extensions, GL_FALSE );
 446
 447    if (!mach64InitDriver(psp))
 448       return NULL;
 449
 450    return  mach64FillInModes( psp, dri_priv->cpp * 8, 16, 0, 1);
 451 }
 452
 453 const struct __DriverAPIRec driDriverAPI = {
 454    .InitScreen      = mach64InitScreen,
 455    .DestroyScreen   = mach64DestroyScreen,
 456    .CreateContext   = mach64CreateContext,
 457    .DestroyContext  = mach64DestroyContext,
 458    .CreateBuffer    = mach64CreateBuffer,
 459    .DestroyBuffer   = mach64DestroyBuffer,
 460    .SwapBuffers     = mach64SwapBuffers,
 461    .MakeCurrent     = mach64MakeCurrent,
 462    .UnbindContext   = mach64UnbindContext,
 463    .GetSwapInfo     = NULL,
 464    .GetDrawableMSC  = driDrawableGetMSC32,
 465    .WaitForMSC      = driWaitForMSC32,
 466    .WaitForSBC      = NULL,
 467    .SwapBuffersMSC  = NULL
 468 };
 469