intel_screen.c File Reference

Include dependency graph for intel_screen.c:

Go to the source code of this file.

Functions
static void	intelCreateSurface (struct intel_screen *intelScreen, struct pipe_winsys *winsys, unsigned handle)
static void	intelPrintDRIInfo (struct intel_screen *intelScreen, __DRIscreenPrivate *sPriv, I830DRIPtr gDRIPriv)
void	intelUpdateScreenRotation (__DRIscreenPrivate *sPriv, drmI830Sarea *sarea)
	Use the information in the sarea to update the screen parameters related to screen rotation.
boolean	intelCreatePools (__DRIscreenPrivate *sPriv)
static const char *	intel_get_name (struct pipe_winsys *winsys)
static void	intel_flush_frontbuffer (struct pipe_winsys *winsys, struct pipe_surface *surf, void *context_private)
static boolean	intelInitDriver (__DRIscreenPrivate *sPriv)
static void	intelDestroyScreen (__DRIscreenPrivate *sPriv)
static boolean	intelCreateBuffer (__DRIscreenPrivate *driScrnPriv, __DRIdrawablePrivate *driDrawPriv, const __GLcontextModes *visual, boolean isPixmap)
	This is called when we need to set up GL rendering to a new X window.
static void	intelDestroyBuffer (__DRIdrawablePrivate *driDrawPriv)
static int	intelGetSwapInfo (__DRIdrawablePrivate *dPriv, __DRIswapInfo *sInfo)
	Get information about previous buffer swaps.
static void	intelSetTexOffset (__DRIcontext *pDRICtx, int texname, unsigned long long offset, int depth, uint pitch)
static __GLcontextModes *	intelFillInModes (unsigned pixel_bits, unsigned depth_bits, unsigned stencil_bits, boolean have_back_buffer)
PUBLIC void *	__driCreateNewScreen_20050727 (__DRInativeDisplay *dpy, int scrn, __DRIscreen *psc, const __GLcontextModes *modes, const __DRIversion *ddx_version, const __DRIversion *dri_version, const __DRIversion *drm_version, const __DRIframebuffer *frame_buffer, drmAddress pSAREA, int fd, int internal_api_version, const __DRIinterfaceMethods *interface, __GLcontextModes **driver_modes)
	This is the bootstrap function for the driver.
Variables
PUBLIC const char	__driConfigOptions []
const uint	__driNConfigOptions = 3
struct dri_extension	card_extensions []
	Extension strings exported by the intel driver.
static struct __DriverAPIRec	intelAPI

---

Function Documentation

PUBLIC void* __driCreateNewScreen_20050727	(	__DRInativeDisplay *	dpy,
		int	scrn,
		__DRIscreen *	psc,
		const __GLcontextModes *	modes,
		const __DRIversion *	ddx_version,
		const __DRIversion *	dri_version,
		const __DRIversion *	drm_version,
		const __DRIframebuffer *	frame_buffer,
		drmAddress	pSAREA,
		int	fd,
		int	internal_api_version,
		const __DRIinterfaceMethods *	interface,
		__GLcontextModes **	driver_modes
	)

This is the bootstrap function for the driver.

libGL supplies all of the requisite information about the system, and the driver initializes itself. This routine also fills in the linked list pointed to by driver_modes with the __GLcontextModes that the driver can support for windows or pbuffers.

Returns:

A pointer to a __DRIscreenPrivate on success, or NULL on failure.

Definition at line 555 of file intel_screen.c.

References card_extensions, _I830DRIRec::cpp, and intelFillInModes().

{
   __DRIscreenPrivate *psp;
   static const __DRIversion ddx_expected = { 1, 7, 0 };
   static const __DRIversion dri_expected = { 4, 0, 0 };
   static const __DRIversion drm_expected = { 1, 7, 0 };

   dri_interface = interface;

   if (!driCheckDriDdxDrmVersions2("i915",
                                   dri_version, &dri_expected,
                                   ddx_version, &ddx_expected,
                                   drm_version, &drm_expected)) {
      return NULL;
   }

   psp = __driUtilCreateNewScreen(dpy, scrn, psc, NULL,
                                  ddx_version, dri_version, drm_version,
                                  frame_buffer, pSAREA, fd,
                                  internal_api_version, &intelAPI);

   if (psp != NULL) {
      I830DRIPtr dri_priv = (I830DRIPtr) psp->pDevPriv;
      *driver_modes = intelFillInModes(dri_priv->cpp * 8,
                                       (dri_priv->cpp == 2) ? 16 : 24,
                                       (dri_priv->cpp == 2) ? 0 : 8, 1);

      /* Calling driInitExtensions here, with a NULL context pointer,
       * does not actually enable the extensions.  It just makes sure
       * that all the dispatch offsets for all the extensions that
       * *might* be enables are known.  This is needed because the
       * dispatch offsets need to be known when _mesa_context_create
       * is called, but we can't enable the extensions until we have a
       * context pointer.
       *
       * Hello chicken.  Hello egg.  How are you two today?
       */
      driInitExtensions(NULL, card_extensions, GL_FALSE);
   }

   return (void *) psp;
}

static void intel_flush_frontbuffer	(	struct pipe_winsys *	winsys,
		struct pipe_surface *	surf,
		void *	context_private
	)			[static]

Definition at line 252 of file intel_screen.c.

References intel_context::driDrawable, and intelDisplaySurface().

{
   struct intel_context *intel = (struct intel_context *) context_private;
   __DRIdrawablePrivate *dPriv = intel->driDrawable;

   intelDisplaySurface(dPriv, surf, NULL);
}

static const char* intel_get_name

(

struct pipe_winsys *

winsys

)

[static]

Definition at line 241 of file intel_screen.c.

{
   return "Intel/DRI/ttm";
}

static boolean intelCreateBuffer	(	__DRIscreenPrivate *	driScrnPriv,
		__DRIdrawablePrivate *	driDrawPriv,
		const __GLcontextModes *	visual,
		boolean	isPixmap
	)			[static]

This is called when we need to set up GL rendering to a new X window.

Definition at line 337 of file intel_screen.c.

References CALLOC_STRUCT, PIPE_FORMAT_A8R8G8B8_UNORM, PIPE_FORMAT_NONE, PIPE_FORMAT_R5G6B5_UNORM, PIPE_FORMAT_S8Z24_UNORM, PIPE_FORMAT_Z16_UNORM, st_create_framebuffer(), and intel_framebuffer::stfb.

{
   if (isPixmap) {
      return GL_FALSE;          /* not implemented */
   }
   else {
      enum pipe_format colorFormat, depthFormat, stencilFormat;
      struct intel_framebuffer *intelfb = CALLOC_STRUCT(intel_framebuffer);

      if (!intelfb)
         return GL_FALSE;

      if (visual->redBits == 5)
         colorFormat = PIPE_FORMAT_R5G6B5_UNORM;
      else
         colorFormat = PIPE_FORMAT_A8R8G8B8_UNORM;

      if (visual->depthBits == 16)
         depthFormat = PIPE_FORMAT_Z16_UNORM;
      else if (visual->depthBits == 24)
         depthFormat = PIPE_FORMAT_S8Z24_UNORM;
      else
         depthFormat = PIPE_FORMAT_NONE;

      if (visual->stencilBits == 8)
         stencilFormat = PIPE_FORMAT_S8Z24_UNORM;
      else
         stencilFormat = PIPE_FORMAT_NONE;

      intelfb->stfb = st_create_framebuffer(visual,
                                            colorFormat,
                                            depthFormat,
                                            stencilFormat,
                                            driDrawPriv->w,
                                            driDrawPriv->h,
                                            (void*) intelfb);
      if (!intelfb->stfb) {
         free(intelfb);
         return GL_FALSE;
      }

      driDrawPriv->driverPrivate = (void *) intelfb;
      return GL_TRUE;
   }
}

boolean intelCreatePools

(

__DRIscreenPrivate *

sPriv

)

Definition at line 225 of file intel_screen.c.

References intel_screen::havePools, intel_screen(), intelUpdateScreenRotation(), and intel_screen::sarea.

{
   //unsigned batchPoolSize = 1024*1024;
   struct intel_screen *intelScreen = intel_screen(sPriv);

   if (intelScreen->havePools)
      return GL_TRUE;

   intelScreen->havePools = GL_TRUE;

   intelUpdateScreenRotation(sPriv, intelScreen->sarea);

   return GL_TRUE;
}

static void intelCreateSurface	(	struct intel_screen *	intelScreen,
		struct pipe_winsys *	winsys,
		unsigned	handle
	)			[static]

Definition at line 50 of file intel_screen.c.

References assert, intel_screen::base, pipe_texture::block, intel_screen::buffer, intel_screen::cpp, pipe_texture::depth, dri_bo(), pipe_texture::format, intel_screen::front, pipe_screen::get_tex_surface, intel_screen::height, pipe_texture::height, intel_be_buffer_from_handle(), pipe_texture::last_level, pf_get_block(), pipe_buffer_reference(), PIPE_BUFFER_USAGE_GPU_WRITE, PIPE_FORMAT_A8R8G8B8_UNORM, PIPE_TEXTURE_2D, PIPE_TEXTURE_USAGE_DISPLAY_TARGET, intel_screen::pitch, intel_be_device::screen, intel_screen::surface, pipe_texture::target, pipe_texture::tex_usage, intel_screen::texture, pipe_screen::texture_blanket, intel_screen::width, and pipe_texture::width.

{
   struct pipe_screen *screen = intelScreen->base.screen;
   struct pipe_texture *texture;
   struct pipe_texture templat;
   struct pipe_surface *surface;
   struct pipe_buffer *buffer;
   unsigned pitch;

   assert(intelScreen->front.cpp == 4);

   buffer = intel_be_buffer_from_handle(&intelScreen->base,
                                        "front", handle);

   if (!buffer)
      return;

   intelScreen->front.buffer = dri_bo(buffer);

   memset(&templat, 0, sizeof(templat));
   templat.tex_usage |= PIPE_TEXTURE_USAGE_DISPLAY_TARGET;
   templat.target = PIPE_TEXTURE_2D;
   templat.last_level = 0;
   templat.depth[0] = 1;
   templat.format = PIPE_FORMAT_A8R8G8B8_UNORM;
   templat.width[0] = intelScreen->front.width;
   templat.height[0] = intelScreen->front.height;
   pf_get_block(templat.format, &templat.block);
   pitch = intelScreen->front.pitch;

   texture = screen->texture_blanket(screen,
                                     &templat,
                                     &pitch,
                                     buffer);

   /* Unref the buffer we don't need it anyways */
   pipe_buffer_reference(screen, &buffer, NULL);

   surface = screen->get_tex_surface(screen,
                                     texture,
                                     0,
                                     0,
                                     0,
                                     PIPE_BUFFER_USAGE_GPU_WRITE);

   intelScreen->front.texture = texture;
   intelScreen->front.surface = surface;
}

static void intelDestroyBuffer

(

__DRIdrawablePrivate *

driDrawPriv

)

[static]

Definition at line 386 of file intel_screen.c.

References assert, intel_framebuffer(), st_unreference_framebuffer(), and intel_framebuffer::stfb.

{
   struct intel_framebuffer *intelfb = intel_framebuffer(driDrawPriv);
   assert(intelfb->stfb);
   st_unreference_framebuffer(&intelfb->stfb);
   free(intelfb);
}

static void intelDestroyScreen

(

__DRIscreenPrivate *

sPriv

)

[static]

Definition at line 321 of file intel_screen.c.

References intel_screen::base, FREE, intel_be_destroy_device(), and intel_screen().

{
   struct intel_screen *intelScreen = intel_screen(sPriv);

   intel_be_destroy_device(&intelScreen->base);
   /*  intelUnmapScreenRegions(intelScreen); */

   FREE(intelScreen);
   sPriv->private = NULL;
}

static __GLcontextModes* intelFillInModes	(	unsigned	pixel_bits,
		unsigned	depth_bits,
		unsigned	stencil_bits,
		boolean	have_back_buffer
	)			[static]

Definition at line 458 of file intel_screen.c.

{
   __GLcontextModes *modes;
   __GLcontextModes *m;
   unsigned num_modes;
   unsigned depth_buffer_factor;
   unsigned back_buffer_factor;
   GLenum fb_format;
   GLenum fb_type;

   /* GLX_SWAP_COPY_OML is only supported because the Intel driver doesn't
    * support pageflipping at all.
    */
   static const GLenum back_buffer_modes[] = {
      GLX_NONE, GLX_SWAP_UNDEFINED_OML, GLX_SWAP_COPY_OML
   };

   uint8_t depth_bits_array[3];
   uint8_t stencil_bits_array[3];
   uint8_t msaa_samples_array[1];


   depth_bits_array[0] = 0;
   depth_bits_array[1] = depth_bits;
   depth_bits_array[2] = depth_bits;
   msaa_samples_array[0] = 0;

   /* Just like with the accumulation buffer, always provide some modes
    * with a stencil buffer.  It will be a sw fallback, but some apps won't
    * care about that.
    */
   stencil_bits_array[0] = 0;
   stencil_bits_array[1] = 0;
   if (depth_bits == 24)
      stencil_bits_array[1] = (stencil_bits == 0) ? 8 : stencil_bits;

   stencil_bits_array[2] = (stencil_bits == 0) ? 8 : stencil_bits;

   depth_buffer_factor = ((depth_bits != 0) || (stencil_bits != 0)) ? 3 : 1;
   back_buffer_factor = (have_back_buffer) ? 3 : 1;

   num_modes = depth_buffer_factor * back_buffer_factor * 4;

   if (pixel_bits == 16) {
      fb_format = GL_RGB;
      fb_type = GL_UNSIGNED_SHORT_5_6_5;
   }
   else {
      fb_format = GL_BGRA;
      fb_type = GL_UNSIGNED_INT_8_8_8_8_REV;
   }

   modes =
      (*dri_interface->createContextModes) (num_modes,
                                            sizeof(__GLcontextModes));
   m = modes;
   if (!driFillInModes(&m, fb_format, fb_type,
                       depth_bits_array, stencil_bits_array,
                       depth_buffer_factor, back_buffer_modes,
                       back_buffer_factor, msaa_samples_array, 1, GLX_TRUE_COLOR)) {
      fprintf(stderr, "[%s:%u] Error creating FBConfig!\n", __func__,
              __LINE__);
      return NULL;
   }
   if (!driFillInModes(&m, fb_format, fb_type,
                       depth_bits_array, stencil_bits_array,
                       depth_buffer_factor, back_buffer_modes,
                       back_buffer_factor, msaa_samples_array, 1, GLX_DIRECT_COLOR)) {
      fprintf(stderr, "[%s:%u] Error creating FBConfig!\n", __func__,
              __LINE__);
      return NULL;
   }

   /* Mark the visual as slow if there are "fake" stencil bits.
    */
   for (m = modes; m != NULL; m = m->next) {
      if ((m->stencilBits != 0) && (m->stencilBits != stencil_bits)) {
         m->visualRating = GLX_SLOW_CONFIG;
      }
   }

   return modes;
}

static int intelGetSwapInfo	(	__DRIdrawablePrivate *	dPriv,
		__DRIswapInfo *	sInfo
	)			[static]

Get information about previous buffer swaps.

Definition at line 399 of file intel_screen.c.

{
   if ((dPriv == NULL) || (dPriv->driverPrivate == NULL)
       || (sInfo == NULL)) {
      return -1;
   }

   return 0;
}

static boolean intelInitDriver

(

__DRIscreenPrivate *

sPriv

)

[static]

Definition at line 263 of file intel_screen.c.

References __driConfigOptions, assert, intel_be_device::base, intel_screen::base, _I830DRIRec::bitsPerPixel, CALLOC_STRUCT, _I830DRIRec::cpp, intel_screen::cpp, _I830DRIRec::deviceID, intel_screen::deviceID, intel_screen::drmMinor, intel_be_device::fd, pipe_winsys::flush_frontbuffer, intel_screen::front, pipe_winsys::get_name, intel_be_init_device(), intel_flush_frontbuffer(), intel_get_name(), intelPrintDRIInfo(), intelUpdateScreenRotation(), intel_screen::optionCache, intel_screen::sarea, and _I830DRIRec::sarea_priv_offset.

{
   struct intel_screen *intelScreen;
   I830DRIPtr gDRIPriv = (I830DRIPtr) sPriv->pDevPriv;

   PFNGLXSCRENABLEEXTENSIONPROC glx_enable_extension =
      (PFNGLXSCRENABLEEXTENSIONPROC) (*dri_interface->
                                      getProcAddress("glxEnableExtension"));
   void *const psc = sPriv->psc->screenConfigs;

   if (sPriv->devPrivSize != sizeof(I830DRIRec)) {
      fprintf(stderr,
              "\nERROR!  sizeof(I830DRIRec) does not match passed size from device driver\n");
      return GL_FALSE;
   }

   /* Allocate the private area */
   intelScreen = CALLOC_STRUCT(intel_screen);
   if (!intelScreen)
      return GL_FALSE;

   /* parse information in __driConfigOptions */
   driParseOptionInfo(&intelScreen->optionCache,
                      __driConfigOptions, __driNConfigOptions);

   sPriv->private = (void *) intelScreen;

   intelScreen->sarea = (drmI830Sarea *) (((GLubyte *) sPriv->pSAREA) +
                                          gDRIPriv->sarea_priv_offset);
   intelScreen->deviceID = gDRIPriv->deviceID;
   intelScreen->front.cpp = gDRIPriv->cpp;
   intelScreen->drmMinor = sPriv->drmMinor;

   assert(gDRIPriv->bitsPerPixel == 16 ||
          gDRIPriv->bitsPerPixel == 32);

   intelUpdateScreenRotation(sPriv, intelScreen->sarea);

   if (0)
      intelPrintDRIInfo(intelScreen, sPriv, gDRIPriv);

   if (glx_enable_extension != NULL) {
      (*glx_enable_extension) (psc, "GLX_SGI_swap_control");
      (*glx_enable_extension) (psc, "GLX_SGI_video_sync");
      (*glx_enable_extension) (psc, "GLX_MESA_swap_control");
      (*glx_enable_extension) (psc, "GLX_MESA_swap_frame_usage");
      (*glx_enable_extension) (psc, "GLX_SGI_make_current_read");
   }

   intelScreen->base.base.flush_frontbuffer = intel_flush_frontbuffer;
   intelScreen->base.base.get_name = intel_get_name;
   intel_be_init_device(&intelScreen->base, sPriv->fd, intelScreen->deviceID);

   return GL_TRUE;
}

static void intelPrintDRIInfo	(	struct intel_screen *	intelScreen,
		__DRIscreenPrivate *	sPriv,
		I830DRIPtr	gDRIPriv
	)			[static]

Definition at line 120 of file intel_screen.c.

References intel_screen::front, _I830DRIRec::mem, intel_screen::offset, intel_screen::pitch, and intel_screen::size.

{
   fprintf(stderr, "*** Front size:   0x%x  offset: 0x%x  pitch: %d\n",
           intelScreen->front.size, intelScreen->front.offset,
           intelScreen->front.pitch);
   fprintf(stderr, "*** Memory : 0x%x\n", gDRIPriv->mem);
}

static void intelSetTexOffset	(	__DRIcontext *	pDRICtx,
		int	texname,
		unsigned long long	offset,
		int	depth,
		uint	pitch
	)			[static]

Definition at line 411 of file intel_screen.c.

References st_context::pipe, st_texture_object::pt, intel_context::st, and st_texture_object().

{
   abort();
#if 0
   struct intel_context *intel = (struct intel_context*)
      ((__DRIcontextPrivate*)pDRICtx->private)->driverPrivate;
   struct gl_texture_object *tObj = _mesa_lookup_texture(&intel->ctx, texname);
   struct st_texture_object *stObj = st_texture_object(tObj);

   if (!stObj)
      return;

   if (stObj->pt)
      st->pipe->texture_release(intel->st->pipe, &stObj->pt);

   stObj->imageOverride = GL_TRUE;
   stObj->depthOverride = depth;
   stObj->pitchOverride = pitch;

   if (offset)
      stObj->textureOffset = offset;
#endif
}

void intelUpdateScreenRotation	(	__DRIscreenPrivate *	sPriv,
		drmI830Sarea *	sarea
	)

Use the information in the sarea to update the screen parameters related to screen rotation.

Needs to be called locked.

Definition at line 164 of file intel_screen.c.

References assert, intel_be_device::base, intel_screen::base, intel_screen::buffer, intel_screen::cpp, driBOUnReference(), driDeleteBuffers(), driGenBuffers(), intel_screen::front, drmI830Sarea::front_bo_handle, drmI830Sarea::front_handle, drmI830Sarea::front_offset, drmI830Sarea::front_size, intel_screen::handle, drmI830Sarea::height, intel_screen::height, intel_screen(), intelCreateSurface(), intel_screen::map, intel_screen::offset, pipe_surface_reference(), pipe_texture_reference(), drmI830Sarea::pitch, intel_screen::pitch, intel_screen::size, intel_be_device::staticPool, intel_screen::surface, intel_screen::texture, drmI830Sarea::width, and intel_screen::width.

{
   struct intel_screen *intelScreen = intel_screen(sPriv);

   if (intelScreen->front.map) {
      drmUnmap(intelScreen->front.map, intelScreen->front.size);
      intelScreen->front.map = NULL;
   }

   if (intelScreen->front.buffer)
      driDeleteBuffers(1, &intelScreen->front.buffer);

   intelScreen->front.width = sarea->width;
   intelScreen->front.height = sarea->height;
   intelScreen->front.offset = sarea->front_offset;
   intelScreen->front.pitch = sarea->pitch * intelScreen->front.cpp;
   intelScreen->front.size = sarea->front_size;
   intelScreen->front.handle = sarea->front_handle;

   assert( sarea->front_size >=
           intelScreen->front.pitch * intelScreen->front.height );

#if 0 /* JB not important */
   if (!sarea->front_handle)
      return;

   if (drmMap(sPriv->fd,
              sarea->front_handle,
              intelScreen->front.size,
              (drmAddress *) & intelScreen->front.map) != 0) {
      fprintf(stderr, "drmMap(frontbuffer) failed!\n");
      return;
   }
#endif

#if 0 /* JB */
   if (intelScreen->staticPool) {
      driGenBuffers(intelScreen->staticPool, "static region", 1,
                    &intelScreen->front.buffer, 64,
                    DRM_BO_FLAG_MEM_TT | DRM_BO_FLAG_NO_MOVE |
                    DRM_BO_FLAG_READ | DRM_BO_FLAG_WRITE, 0);

      driBOSetStatic(intelScreen->front.buffer,
                     intelScreen->front.offset,
                     intelScreen->front.pitch * intelScreen->front.height,
                     intelScreen->front.map, 0);
   }
#else
   if (intelScreen->base.staticPool) {
      if (intelScreen->front.buffer) {
         driBOUnReference(intelScreen->front.buffer);
         pipe_surface_reference(&intelScreen->front.surface, NULL);
         pipe_texture_reference(&intelScreen->front.texture, NULL);
      }
      intelCreateSurface(intelScreen, &intelScreen->base.base, sarea->front_bo_handle);
   }
#endif
}

---

Variable Documentation

PUBLIC const char __driConfigOptions[]

Initial value:

   DRI_CONF_BEGIN DRI_CONF_SECTION_PERFORMANCE


   DRI_CONF_SECTION_END DRI_CONF_SECTION_QUALITY


   DRI_CONF_SECTION_END DRI_CONF_END

Definition at line 99 of file intel_screen.c.

const uint __driNConfigOptions = 3

Definition at line 108 of file intel_screen.c.

struct dri_extension card_extensions[]

Extension strings exported by the intel driver.

Note:

It appears that ARB_texture_env_crossbar has "disappeared" compared to the old i830-specific driver.

Definition at line 78 of file intel_context.c.

struct __DriverAPIRec intelAPI [static]

Initial value:

 {
   .InitDriver = intelInitDriver,
   .DestroyScreen = intelDestroyScreen,
   .CreateContext = intelCreateContext,
   .DestroyContext = intelDestroyContext,
   .CreateBuffer = intelCreateBuffer,
   .DestroyBuffer = intelDestroyBuffer,
   .SwapBuffers = intelSwapBuffers,
   .MakeCurrent = intelMakeCurrent,
   .UnbindContext = intelUnbindContext,
   .GetSwapInfo = intelGetSwapInfo,
   .GetMSC = driGetMSC32,
   .WaitForMSC = driWaitForMSC32,
   .WaitForSBC = NULL,
   .SwapBuffersMSC = NULL,
   .CopySubBuffer = intelCopySubBuffer,
   .setTexOffset = intelSetTexOffset,
}

Definition at line 437 of file intel_screen.c.

---