src/mesa/drivers/dri/nouveau/nouveau_screen.c

   1 /**************************************************************************
   2
   3 Copyright 2006 Stephane Marchesin
   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 on the rights to use, copy, modify, merge, publish, distribute, sub
  10 license, and/or sell copies of the Software, and to permit persons to whom
  11 the 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 NON-INFRINGEMENT. IN NO EVENT SHALL
  20 ERIC ANHOLT OR SILICON INTEGRATED SYSTEMS CORP BE LIABLE FOR ANY CLAIM,
  21 DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  22 OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  23 USE OR OTHER DEALINGS IN THE SOFTWARE.
  24
  25 **************************************************************************/
  26
  27 #include "glheader.h"
  28 #include "imports.h"
  29 #include "mtypes.h"
  30 #include "framebuffer.h"
  31 #include "renderbuffer.h"
  32
  33 #include "nouveau_context.h"
  34 #include "nouveau_screen.h"
  35 #include "nouveau_object.h"
  36 #include "nouveau_span.h"
  37
  38 #include "utils.h"
  39 #include "context.h"
  40 #include "vblank.h"
  41 #include "drirenderbuffer.h"
  42
  43 #include "GL/internal/dri_interface.h"
  44
  45 #include "xmlpool.h"
  46
  47 PUBLIC const char __driConfigOptions[] =
  48 DRI_CONF_BEGIN
  49     DRI_CONF_SECTION_DEBUG
  50         DRI_CONF_NO_RAST(false)
  51     DRI_CONF_SECTION_END
  52 DRI_CONF_END;
  53 static const GLuint __driNConfigOptions = 1;
  54
  55 extern const struct dri_extension common_extensions[];
  56 extern const struct dri_extension nv10_extensions[];
  57 extern const struct dri_extension nv20_extensions[];
  58 extern const struct dri_extension nv30_extensions[];
  59 extern const struct dri_extension nv40_extensions[];
  60 extern const struct dri_extension nv50_extensions[];
  61
  62 static nouveauScreenPtr nouveauCreateScreen(__DRIscreenPrivate *sPriv)
  63 {
  64         nouveauScreenPtr screen;
  65         NOUVEAUDRIPtr dri_priv=(NOUVEAUDRIPtr)sPriv->pDevPriv;
  66
  67         /* allocate screen */
  68         screen = (nouveauScreenPtr) CALLOC( sizeof(*screen) );
  69         if ( !screen ) {
  70                 __driUtilMessage("%s: Could not allocate memory for screen structure",__FUNCTION__);
  71                 return NULL;
  72         }
  73
  74         screen->card=nouveau_card_lookup(dri_priv->device_id);
  75         if (!screen->card) {
  76                 __driUtilMessage("%s: Unknown card type 0x%04x:0x%04x\n",
  77                         __func__, dri_priv->device_id >> 16, dri_priv->device_id & 0xFFFF);
  78                 FREE(screen);
  79                 return NULL;
  80         }
  81
  82         /* parse information in __driConfigOptions */
  83         driParseOptionInfo (&screen->optionCache,__driConfigOptions, __driNConfigOptions);
  84
  85         screen->fbFormat    = dri_priv->bpp / 8;
  86         screen->frontOffset = dri_priv->front_offset;
  87         screen->frontPitch  = dri_priv->front_pitch;
  88         screen->backOffset  = dri_priv->back_offset;
  89         screen->backPitch   = dri_priv->back_pitch;
  90         screen->depthOffset = dri_priv->depth_offset;
  91         screen->depthPitch  = dri_priv->depth_pitch;
  92
  93         screen->driScreen = sPriv;
  94         return screen;
  95 }
  96
  97 static void
  98 nouveauDestroyScreen(__DRIscreenPrivate *sPriv)
  99 {
 100         nouveauScreenPtr screen = (nouveauScreenPtr)sPriv->private;
 101
 102         if (!screen) return;
 103
 104         /* free all option information */
 105         driDestroyOptionInfo (&screen->optionCache);
 106
 107         FREE(screen);
 108         sPriv->private = NULL;
 109 }
 110
 111 static GLboolean nouveauInitDriver(__DRIscreenPrivate *sPriv)
 112 {
 113         sPriv->private = (void *) nouveauCreateScreen( sPriv );
 114         if ( !sPriv->private ) {
 115                 nouveauDestroyScreen( sPriv );
 116                 return GL_FALSE;
 117         }
 118
 119         return GL_TRUE;
 120 }
 121
 122 /**
 123  * Create the Mesa framebuffer and renderbuffers for a given window/drawable.
 124  *
 125  * \todo This function (and its interface) will need to be updated to support
 126  * pbuffers.
 127  */
 128 static GLboolean
 129 nouveauCreateBuffer(__DRIscreenPrivate *driScrnPriv,
 130                     __DRIdrawablePrivate *driDrawPriv,
 131                     const __GLcontextModes *mesaVis,
 132                     GLboolean isPixmap)
 133 {
 134         nouveauScreenPtr screen = (nouveauScreenPtr) driScrnPriv->private;
 135         nouveau_renderbuffer_t *nrb;
 136         struct gl_framebuffer *fb;
 137         const GLboolean swAccum = mesaVis->accumRedBits > 0;
 138         const GLboolean swStencil = (mesaVis->stencilBits > 0 &&
 139                                      mesaVis->depthBits != 24);
 140         GLenum color_format = screen->fbFormat == 4 ? GL_RGBA8 : GL_RGB5;
 141
 142         if (isPixmap)
 143                 return GL_FALSE; /* not implemented */
 144
 145         fb = _mesa_create_framebuffer(mesaVis);
 146         if (!fb)
 147                 return GL_FALSE;
 148
 149         /* Front buffer */
 150         nrb = nouveau_renderbuffer_new(color_format);
 151         _mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &nrb->mesa);
 152
 153         if (mesaVis->doubleBufferMode) {
 154                 nrb = nouveau_renderbuffer_new(color_format);
 155                 _mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &nrb->mesa);
 156         }
 157
 158         if (mesaVis->depthBits == 24 && mesaVis->stencilBits == 8) {
 159                 nrb = nouveau_renderbuffer_new(GL_DEPTH24_STENCIL8_EXT);
 160                 _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &nrb->mesa);
 161                 _mesa_add_renderbuffer(fb, BUFFER_STENCIL, &nrb->mesa);
 162         } else
 163         if (mesaVis->depthBits == 24) {
 164                 nrb = nouveau_renderbuffer_new(GL_DEPTH_COMPONENT24);
 165                 _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &nrb->mesa);
 166         } else
 167         if (mesaVis->depthBits == 16) {
 168                 nrb = nouveau_renderbuffer_new(GL_DEPTH_COMPONENT16);
 169                 _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &nrb->mesa);
 170         }
 171
 172         _mesa_add_soft_renderbuffers(fb,
 173                                      GL_FALSE, /* color */
 174                                      GL_FALSE, /* depth */
 175                                      swStencil,
 176                                      swAccum,
 177                                      GL_FALSE, /* alpha */
 178                                      GL_FALSE  /* aux */);
 179
 180         driDrawPriv->driverPrivate = (void *) fb;
 181         return (driDrawPriv->driverPrivate != NULL);
 182 }
 183
 184
 185 static void
 186 nouveauDestroyBuffer(__DRIdrawablePrivate *driDrawPriv)
 187 {
 188         _mesa_unreference_framebuffer((GLframebuffer **)(&(driDrawPriv->driverPrivate)));
 189 }
 190
 191 static int
 192 nouveauGetSwapInfo(__DRIdrawablePrivate *dpriv, __DRIswapInfo *sInfo)
 193 {
 194         return -1;
 195 }
 196
 197 static const struct __DriverAPIRec nouveauAPI = {
 198         .InitDriver      = nouveauInitDriver,
 199         .DestroyScreen   = nouveauDestroyScreen,
 200         .CreateContext   = nouveauCreateContext,
 201         .DestroyContext  = nouveauDestroyContext,
 202         .CreateBuffer    = nouveauCreateBuffer,
 203         .DestroyBuffer   = nouveauDestroyBuffer,
 204         .SwapBuffers     = nouveauSwapBuffers,
 205         .MakeCurrent     = nouveauMakeCurrent,
 206         .UnbindContext   = nouveauUnbindContext,
 207         .GetSwapInfo     = nouveauGetSwapInfo,
 208         .GetMSC          = driGetMSC32,
 209         .WaitForMSC      = driWaitForMSC32,
 210         .WaitForSBC      = NULL,
 211         .SwapBuffersMSC  = NULL,
 212         .CopySubBuffer   = nouveauCopySubBuffer
 213 };
 214
 215
 216 static __GLcontextModes *
 217 nouveauFillInModes( unsigned pixel_bits, unsigned depth_bits,
 218                  unsigned stencil_bits, GLboolean have_back_buffer )
 219 {
 220         __GLcontextModes * modes;
 221         __GLcontextModes * m;
 222         unsigned num_modes;
 223         unsigned depth_buffer_factor;
 224         unsigned back_buffer_factor;
 225         int i;
 226
 227         static const struct {
 228                 GLenum format;
 229                 GLenum type;
 230         } fb_format_array[] = {
 231                 { GL_RGB , GL_UNSIGNED_SHORT_5_6_5     },
 232                 { GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV },
 233                 { GL_BGR , GL_UNSIGNED_INT_8_8_8_8_REV },
 234         };
 235
 236         /* GLX_SWAP_COPY_OML is only supported because the Intel driver doesn't
 237          * support pageflipping at all.
 238          */
 239         static const GLenum back_buffer_modes[] = {
 240                 GLX_NONE, GLX_SWAP_UNDEFINED_OML, GLX_SWAP_COPY_OML
 241         };
 242
 243         u_int8_t depth_bits_array[4]   = { 0, 16, 24, 24 };
 244         u_int8_t stencil_bits_array[4] = { 0,  0,  0,  8 };
 245
 246         depth_buffer_factor = 4;
 247         back_buffer_factor  = (have_back_buffer) ? 3 : 1;
 248
 249         num_modes = ((pixel_bits==16) ? 1 : 2) *
 250                 depth_buffer_factor * back_buffer_factor * 4;
 251         modes = (*dri_interface->createContextModes)(num_modes,
 252                                                      sizeof(__GLcontextModes));
 253         m = modes;
 254
 255         for (i=((pixel_bits==16)?0:1);i<((pixel_bits==16)?1:3);i++) {
 256                 if (!driFillInModes(&m, fb_format_array[i].format,
 257                                         fb_format_array[i].type,
 258                                         depth_bits_array,
 259                                         stencil_bits_array,
 260                                         depth_buffer_factor,
 261                                         back_buffer_modes,
 262                                         back_buffer_factor,
 263                                         GLX_TRUE_COLOR)) {
 264                 fprintf( stderr, "[%s:%u] Error creating FBConfig!\n",
 265                                 __func__, __LINE__ );
 266                 return NULL;
 267                 }
 268
 269                 if (!driFillInModes(&m, fb_format_array[i].format,
 270                                         fb_format_array[i].type,
 271                                         depth_bits_array,
 272                                         stencil_bits_array,
 273                                         depth_buffer_factor,
 274                                         back_buffer_modes,
 275                                         back_buffer_factor,
 276                                         GLX_DIRECT_COLOR)) {
 277                 fprintf( stderr, "[%s:%u] Error creating FBConfig!\n",
 278                                 __func__, __LINE__ );
 279                 return NULL;
 280                 }
 281         }
 282
 283         return modes;
 284 }
 285
 286
 287 /**
 288  * This is the bootstrap function for the driver.  libGL supplies all of the
 289  * requisite information about the system, and the driver initializes itself.
 290  * This routine also fills in the linked list pointed to by \c driver_modes
 291  * with the \c __GLcontextModes that the driver can support for windows or
 292  * pbuffers.
 293  *
 294  * \return A pointer to a \c __DRIscreenPrivate on success, or \c NULL on
 295  *         failure.
 296  */
 297 PUBLIC
 298 void * __driCreateNewScreen_20050727( __DRInativeDisplay *dpy, int scrn, __DRIscreen *psc,
 299                                      const __GLcontextModes * modes,
 300                                      const __DRIversion * ddx_version,
 301                                      const __DRIversion * dri_version,
 302                                      const __DRIversion * drm_version,
 303                                      const __DRIframebuffer * frame_buffer,
 304                                      drmAddress pSAREA, int fd,
 305                                      int internal_api_version,
 306                                      const __DRIinterfaceMethods * interface,
 307                                      __GLcontextModes ** driver_modes)
 308
 309 {
 310         __DRIscreenPrivate *psp;
 311         static const __DRIversion ddx_expected = { 1, 2, 0 };
 312         static const __DRIversion dri_expected = { 4, 0, 0 };
 313         static const __DRIversion drm_expected = { 0, 0, NOUVEAU_DRM_HEADER_PATCHLEVEL };
 314 #if NOUVEAU_DRM_HEADER_PATCHLEVEL != 10
 315 #error nouveau_drm.h version doesn't match expected version
 316 #endif
 317         dri_interface = interface;
 318
 319         if (!driCheckDriDdxDrmVersions2("nouveau",
 320                                         dri_version, & dri_expected,
 321                                         ddx_version, & ddx_expected,
 322                                         drm_version, & drm_expected)) {
 323                 return NULL;
 324         }
 325
 326         // temporary lock step versioning
 327         if (drm_expected.patch!=drm_version->patch) {
 328                 __driUtilMessage("%s: wrong DRM version, expected %d, got %d\n",
 329                                 __func__,
 330                                 drm_expected.patch, drm_version->patch);
 331                 return NULL;
 332         }
 333
 334         psp = __driUtilCreateNewScreen(dpy, scrn, psc, NULL,
 335                                        ddx_version, dri_version, drm_version,
 336                                        frame_buffer, pSAREA, fd,
 337                                        internal_api_version, &nouveauAPI);
 338         if ( psp != NULL ) {
 339                 NOUVEAUDRIPtr dri_priv = (NOUVEAUDRIPtr)psp->pDevPriv;
 340
 341                 *driver_modes = nouveauFillInModes(dri_priv->bpp,
 342                                                    (dri_priv->bpp == 16) ? 16 : 24,
 343                                                    (dri_priv->bpp == 16) ? 0  : 8,
 344                                                    1
 345                                                    );
 346
 347                 /* Calling driInitExtensions here, with a NULL context pointer, does not actually
 348                  * enable the extensions.  It just makes sure that all the dispatch offsets for all
 349                  * the extensions that *might* be enables are known.  This is needed because the
 350                  * dispatch offsets need to be known when _mesa_context_create is called, but we can't
 351                  * enable the extensions until we have a context pointer.
 352                  *
 353                  * Hello chicken.  Hello egg.  How are you two today?
 354                  */
 355                 driInitExtensions( NULL, common_extensions, GL_FALSE );
 356                 driInitExtensions( NULL,   nv10_extensions, GL_FALSE );
 357                 driInitExtensions( NULL,   nv10_extensions, GL_FALSE );
 358                 driInitExtensions( NULL,   nv30_extensions, GL_FALSE );
 359                 driInitExtensions( NULL,   nv40_extensions, GL_FALSE );
 360                 driInitExtensions( NULL,   nv50_extensions, GL_FALSE );
 361         }
 362
 363         return (void *) psp;
 364 }
 365