src/mesa/drivers/dri/i810/i810screen.c

   1 /**************************************************************************
   2
   3 Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
   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
   8 "Software"), to deal in the Software without restriction, including
   9 without limitation the rights to use, copy, modify, merge, publish,
  10 distribute, sub license, and/or sell copies of the Software, and to
  11 permit persons to whom the Software is furnished to do so, subject to
  12 the following conditions:
  13
  14 The above copyright notice and this permission notice (including the
  15 next paragraph) shall be included in all copies or substantial portions
  16 of the Software.
  17
  18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21 IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  22 ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26 **************************************************************************/
  27
  28 /*
  29  * Authors:
  30  *   Keith Whitwell <keith@tungstengraphics.com>
  31  *
  32  */
  33
  34
  35 #include "main/glheader.h"
  36 #include "main/imports.h"
  37 #include "main/context.h"
  38 #include "main/framebuffer.h"
  39 #include "main/fbobject.h"
  40 #include "main/matrix.h"
  41 #include "main/renderbuffer.h"
  42 #include "main/simple_list.h"
  43 #include "utils.h"
  44
  45 #include "i810screen.h"
  46 #include "i810_dri.h"
  47
  48 #include "i810state.h"
  49 #include "i810tex.h"
  50 #include "i810span.h"
  51 #include "i810tris.h"
  52 #include "i810ioctl.h"
  53
  54 #include "GL/internal/dri_interface.h"
  55
  56 static const __DRIconfig **
  57 i810FillInModes( __DRIscreenPrivate *psp,
  58                  unsigned pixel_bits, unsigned depth_bits,
  59                  unsigned stencil_bits, GLboolean have_back_buffer )
  60 {
  61     __DRIconfig **configs;
  62     __GLcontextModes * m;
  63     unsigned depth_buffer_factor;
  64     unsigned back_buffer_factor;
  65     unsigned i;
  66
  67     /* Right now GLX_SWAP_COPY_OML isn't supported, but it would be easy
  68      * enough to add support.  Basically, if a context is created with an
  69      * fbconfig where the swap method is GLX_SWAP_COPY_OML, pageflipping
  70      * will never be used.
  71      */
  72     static const GLenum back_buffer_modes[] = {
  73         GLX_NONE, GLX_SWAP_UNDEFINED_OML /*, GLX_SWAP_COPY_OML */
  74     };
  75
  76     uint8_t depth_bits_array[2];
  77     uint8_t stencil_bits_array[2];
  78     uint8_t msaa_samples_array[1];
  79
  80     depth_bits_array[0] = depth_bits;
  81     depth_bits_array[1] = depth_bits;
  82
  83     /* Just like with the accumulation buffer, always provide some modes
  84      * with a stencil buffer.  It will be a sw fallback, but some apps won't
  85      * care about that.
  86      */
  87     stencil_bits_array[0] = 0;
  88     stencil_bits_array[1] = (stencil_bits == 0) ? 8 : stencil_bits;
  89
  90     msaa_samples_array[0] = 0;
  91
  92     depth_buffer_factor = ((depth_bits != 0) || (stencil_bits != 0)) ? 2 : 1;
  93     back_buffer_factor  = (have_back_buffer) ? 2 : 1;
  94
  95     configs = driCreateConfigs(GL_RGB, GL_UNSIGNED_SHORT_5_6_5,
  96                                depth_bits_array, stencil_bits_array,
  97                                depth_buffer_factor,
  98                                back_buffer_modes, back_buffer_factor,
  99                                msaa_samples_array, 1);
 100     if (configs == NULL) {
 101         fprintf( stderr, "[%s:%u] Error creating FBConfig!\n",
 102                  __func__, __LINE__ );
 103         return NULL;
 104     }
 105
 106     /* Mark the visual as slow if there are "fake" stencil bits.
 107      */
 108     for (i = 0; configs[i]; i++) {
 109         m = &configs[i]->modes;
 110         if ((m->stencilBits != 0) && (m->stencilBits != stencil_bits)) {
 111             m->visualRating = GLX_SLOW_CONFIG;
 112         }
 113     }
 114
 115     return (const __DRIconfig **) configs;
 116 }
 117
 118
 119 /*  static int i810_malloc_proxy_buf(drmBufMapPtr buffers) */
 120 /*  { */
 121 /*     char *buffer; */
 122 /*     drmBufPtr buf; */
 123 /*     int i; */
 124
 125 /*     buffer = CALLOC(I810_DMA_BUF_SZ); */
 126 /*     if(buffer == NULL) return -1; */
 127 /*     for(i = 0; i < I810_DMA_BUF_NR; i++) { */
 128 /*        buf = &(buffers->list[i]); */
 129 /*        buf->address = (drmAddress)buffer; */
 130 /*     } */
 131 /*     return 0; */
 132 /*  } */
 133
 134 static drmBufMapPtr i810_create_empty_buffers(void)
 135 {
 136    drmBufMapPtr retval;
 137
 138    retval = (drmBufMapPtr)ALIGN_MALLOC(sizeof(drmBufMap), 32);
 139    if(retval == NULL) return NULL;
 140    memset(retval, 0, sizeof(drmBufMap));
 141    retval->list = (drmBufPtr)ALIGN_MALLOC(sizeof(drmBuf) * I810_DMA_BUF_NR, 32);
 142    if(retval->list == NULL) {
 143       ALIGN_FREE(retval);
 144       return NULL;
 145    }
 146    memset(retval->list, 0, sizeof(drmBuf) * I810_DMA_BUF_NR);
 147    return retval;
 148 }
 149
 150
 151 static const __DRIconfig **
 152 i810InitScreen(__DRIscreen *sPriv)
 153 {
 154    static const __DRIversion ddx_expected = { 1, 0, 0 };
 155    static const __DRIversion dri_expected = { 4, 0, 0 };
 156    static const __DRIversion drm_expected = { 1, 2, 0 };
 157    i810ScreenPrivate *i810Screen;
 158    I810DRIPtr         gDRIPriv = (I810DRIPtr)sPriv->pDevPriv;
 159
 160    if ( ! driCheckDriDdxDrmVersions2( "i810",
 161                                       &sPriv->dri_version, & dri_expected,
 162                                       &sPriv->ddx_version, & ddx_expected,
 163                                       &sPriv->drm_version, & drm_expected ) ) {
 164       return NULL;
 165    }
 166
 167    if (sPriv->devPrivSize != sizeof(I810DRIRec)) {
 168       fprintf(stderr,"\nERROR!  sizeof(I810DRIRec) does not match passed size from device driver\n");
 169       return GL_FALSE;
 170    }
 171
 172    /* Allocate the private area */
 173    i810Screen = (i810ScreenPrivate *)CALLOC(sizeof(i810ScreenPrivate));
 174    if (!i810Screen) {
 175       __driUtilMessage("i810InitDriver: alloc i810ScreenPrivate struct failed");
 176       return GL_FALSE;
 177    }
 178
 179    i810Screen->driScrnPriv = sPriv;
 180    sPriv->private = (void *)i810Screen;
 181
 182    i810Screen->deviceID=gDRIPriv->deviceID;
 183    i810Screen->width=gDRIPriv->width;
 184    i810Screen->height=gDRIPriv->height;
 185    i810Screen->mem=gDRIPriv->mem;
 186    i810Screen->cpp=gDRIPriv->cpp;
 187    i810Screen->fbStride=gDRIPriv->fbStride;
 188    i810Screen->fbOffset=gDRIPriv->fbOffset;
 189
 190    if (gDRIPriv->bitsPerPixel == 15)
 191       i810Screen->fbFormat = DV_PF_555;
 192    else
 193       i810Screen->fbFormat = DV_PF_565;
 194
 195    i810Screen->backOffset=gDRIPriv->backOffset;
 196    i810Screen->depthOffset=gDRIPriv->depthOffset;
 197    i810Screen->backPitch = gDRIPriv->auxPitch;
 198    i810Screen->backPitchBits = gDRIPriv->auxPitchBits;
 199    i810Screen->textureOffset=gDRIPriv->textureOffset;
 200    i810Screen->textureSize=gDRIPriv->textureSize;
 201    i810Screen->logTextureGranularity = gDRIPriv->logTextureGranularity;
 202
 203    i810Screen->bufs = i810_create_empty_buffers();
 204    if (i810Screen->bufs == NULL) {
 205       __driUtilMessage("i810InitDriver: i810_create_empty_buffers() failed");
 206       FREE(i810Screen);
 207       return GL_FALSE;
 208    }
 209
 210    i810Screen->back.handle = gDRIPriv->backbuffer;
 211    i810Screen->back.size = gDRIPriv->backbufferSize;
 212
 213    if (drmMap(sPriv->fd,
 214               i810Screen->back.handle,
 215               i810Screen->back.size,
 216               (drmAddress *)&i810Screen->back.map) != 0) {
 217       FREE(i810Screen);
 218       sPriv->private = NULL;
 219       __driUtilMessage("i810InitDriver: drmMap failed");
 220       return GL_FALSE;
 221    }
 222
 223    i810Screen->depth.handle = gDRIPriv->depthbuffer;
 224    i810Screen->depth.size = gDRIPriv->depthbufferSize;
 225
 226    if (drmMap(sPriv->fd,
 227               i810Screen->depth.handle,
 228               i810Screen->depth.size,
 229               (drmAddress *)&i810Screen->depth.map) != 0) {
 230       drmUnmap(i810Screen->back.map, i810Screen->back.size);
 231       FREE(i810Screen);
 232       sPriv->private = NULL;
 233       __driUtilMessage("i810InitDriver: drmMap (2) failed");
 234       return GL_FALSE;
 235    }
 236
 237    i810Screen->tex.handle = gDRIPriv->textures;
 238    i810Screen->tex.size = gDRIPriv->textureSize;
 239
 240    if (drmMap(sPriv->fd,
 241               i810Screen->tex.handle,
 242               i810Screen->tex.size,
 243               (drmAddress *)&i810Screen->tex.map) != 0) {
 244       drmUnmap(i810Screen->back.map, i810Screen->back.size);
 245       drmUnmap(i810Screen->depth.map, i810Screen->depth.size);
 246       FREE(i810Screen);
 247       sPriv->private = NULL;
 248       __driUtilMessage("i810InitDriver: drmMap (3) failed");
 249       return GL_FALSE;
 250    }
 251
 252    i810Screen->sarea_priv_offset = gDRIPriv->sarea_priv_offset;
 253
 254    return i810FillInModes(sPriv, 16, 16, 0, 1);
 255 }
 256
 257 static void
 258 i810DestroyScreen(__DRIscreenPrivate *sPriv)
 259 {
 260    i810ScreenPrivate *i810Screen = (i810ScreenPrivate *)sPriv->private;
 261
 262    /* Need to unmap all the bufs and maps here:
 263     */
 264    drmUnmap(i810Screen->back.map, i810Screen->back.size);
 265    drmUnmap(i810Screen->depth.map, i810Screen->depth.size);
 266    drmUnmap(i810Screen->tex.map, i810Screen->tex.size);
 267
 268    FREE(i810Screen);
 269    sPriv->private = NULL;
 270 }
 271
 272
 273 /**
 274  * Create a buffer which corresponds to the window.
 275  */
 276 static GLboolean
 277 i810CreateBuffer( __DRIscreenPrivate *driScrnPriv,
 278                   __DRIdrawablePrivate *driDrawPriv,
 279                   const __GLcontextModes *mesaVis,
 280                   GLboolean isPixmap )
 281 {
 282    i810ScreenPrivate *screen = (i810ScreenPrivate *) driScrnPriv->private;
 283
 284    if (isPixmap) {
 285       return GL_FALSE; /* not implemented */
 286    }
 287    else {
 288       struct gl_framebuffer *fb = _mesa_create_framebuffer(mesaVis);
 289
 290       {
 291          driRenderbuffer *frontRb
 292             = driNewRenderbuffer(MESA_FORMAT_ARGB8888,
 293                                  driScrnPriv->pFB,
 294                                  screen->cpp,
 295                                  /*screen->frontOffset*/0, screen->backPitch,
 296                                  driDrawPriv);
 297          i810SetSpanFunctions(frontRb, mesaVis);
 298          _mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &frontRb->Base);
 299       }
 300
 301       if (mesaVis->doubleBufferMode) {
 302          driRenderbuffer *backRb
 303             = driNewRenderbuffer(MESA_FORMAT_ARGB8888,
 304                                  screen->back.map,
 305                                  screen->cpp,
 306                                  screen->backOffset, screen->backPitch,
 307                                  driDrawPriv);
 308          i810SetSpanFunctions(backRb, mesaVis);
 309          _mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &backRb->Base);
 310       }
 311
 312       if (mesaVis->depthBits == 16) {
 313          driRenderbuffer *depthRb
 314             = driNewRenderbuffer(MESA_FORMAT_Z16,
 315                                  screen->depth.map,
 316                                  screen->cpp,
 317                                  screen->depthOffset, screen->backPitch,
 318                                  driDrawPriv);
 319          i810SetSpanFunctions(depthRb, mesaVis);
 320          _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &depthRb->Base);
 321       }
 322
 323       _mesa_add_soft_renderbuffers(fb,
 324                                    GL_FALSE, /* color */
 325                                    GL_FALSE, /* depth */
 326                                    mesaVis->stencilBits > 0,
 327                                    mesaVis->accumRedBits > 0,
 328                                    GL_FALSE, /* alpha */
 329                                    GL_FALSE /* aux */);
 330       driDrawPriv->driverPrivate = (void *) fb;
 331
 332       return (driDrawPriv->driverPrivate != NULL);
 333    }
 334 }
 335
 336
 337 static void
 338 i810DestroyBuffer(__DRIdrawablePrivate *driDrawPriv)
 339 {
 340    _mesa_reference_framebuffer((GLframebuffer **)(&(driDrawPriv->driverPrivate)), NULL);
 341 }
 342
 343 const struct __DriverAPIRec driDriverAPI = {
 344    .InitScreen      = i810InitScreen,
 345    .DestroyScreen   = i810DestroyScreen,
 346    .CreateContext   = i810CreateContext,
 347    .DestroyContext  = i810DestroyContext,
 348    .CreateBuffer    = i810CreateBuffer,
 349    .DestroyBuffer   = i810DestroyBuffer,
 350    .SwapBuffers     = i810SwapBuffers,
 351    .MakeCurrent     = i810MakeCurrent,
 352    .UnbindContext   = i810UnbindContext,
 353    .GetSwapInfo     = NULL,
 354    .GetDrawableMSC  = NULL,
 355    .WaitForMSC      = NULL,
 356    .WaitForSBC      = NULL,
 357    .SwapBuffersMSC  = NULL
 358 };