intel_screen.c revision 91473485fcf3e2cef465784ae5581787a2a8a3b3 
1f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)/**************************************************************************
2f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) *
3f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
4f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * All Rights Reserved.
5f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) *
6f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * Permission is hereby granted, free of charge, to any person obtaining a
7f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * copy of this software and associated documentation files (the
8f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * "Software"), to deal in the Software without restriction, including
9f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * without limitation the rights to use, copy, modify, merge, publish,
10f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * distribute, sub license, and/or sell copies of the Software, and to
11f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * permit persons to whom the Software is furnished to do so, subject to
12f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * the following conditions:
13f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) *
14f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * The above copyright notice and this permission notice (including the
15f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * next paragraph) shall be included in all copies or substantial portions
16f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * of the Software.
17f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) *
18f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) *
26f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles) **************************************************************************/
27f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)
28f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)#include <errno.h>
29f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)#include "main/glheader.h"
30f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)#include "main/context.h"
31f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)#include "main/framebuffer.h"
32f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)#include "main/renderbuffer.h"
33f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)#include "main/hash.h"
34f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)#include "main/fbobject.h"
35f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)#include "main/mfeatures.h"
36f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)#include "main/version.h"
37f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)#include "swrast/s_renderbuffer.h"
38f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)
39f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)#include "utils.h"
40f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)#include "xmlpool.h"
41f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)
42f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)PUBLIC const char __driConfigOptions[] =
43f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)   DRI_CONF_BEGIN
44f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)   DRI_CONF_SECTION_PERFORMANCE
45f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)      DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_ALWAYS_SYNC)
46f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)      /* Options correspond to DRI_CONF_BO_REUSE_DISABLED,
47f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)       * DRI_CONF_BO_REUSE_ALL
48f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)       */
49f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)      DRI_CONF_OPT_BEGIN_V(bo_reuse, enum, 1, "0:1")
50f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)	 DRI_CONF_DESC_BEGIN(en, "Buffer object reuse")
51f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)	    DRI_CONF_ENUM(0, "Disable buffer object reuse")
52f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)	    DRI_CONF_ENUM(1, "Enable reuse of all sizes of buffer objects")
53f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)	 DRI_CONF_DESC_END
54f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)      DRI_CONF_OPT_END
55f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)
56f4ed1cf5d184064c4cf0e4359c6d5d8aadb50afaTorne (Richard Coles)      DRI_CONF_OPT_BEGIN(texture_tiling, bool, true)
57	 DRI_CONF_DESC(en, "Enable texture tiling")
58      DRI_CONF_OPT_END
59
60      DRI_CONF_OPT_BEGIN(hiz, bool, true)
61	 DRI_CONF_DESC(en, "Enable Hierarchical Z on gen6+")
62      DRI_CONF_OPT_END
63
64      DRI_CONF_OPT_BEGIN(early_z, bool, false)
65	 DRI_CONF_DESC(en, "Enable early Z in classic mode (unstable, 945-only).")
66      DRI_CONF_OPT_END
67
68      DRI_CONF_OPT_BEGIN(fragment_shader, bool, true)
69	 DRI_CONF_DESC(en, "Enable limited ARB_fragment_shader support on 915/945.")
70      DRI_CONF_OPT_END
71
72   DRI_CONF_SECTION_END
73   DRI_CONF_SECTION_QUALITY
74      DRI_CONF_FORCE_S3TC_ENABLE(false)
75      DRI_CONF_ALLOW_LARGE_TEXTURES(2)
76   DRI_CONF_SECTION_END
77   DRI_CONF_SECTION_DEBUG
78     DRI_CONF_NO_RAST(false)
79     DRI_CONF_ALWAYS_FLUSH_BATCH(false)
80     DRI_CONF_ALWAYS_FLUSH_CACHE(false)
81     DRI_CONF_FORCE_GLSL_EXTENSIONS_WARN(false)
82     DRI_CONF_DISABLE_BLEND_FUNC_EXTENDED(false)
83
84      DRI_CONF_OPT_BEGIN(stub_occlusion_query, bool, false)
85	 DRI_CONF_DESC(en, "Enable stub ARB_occlusion_query support on 915/945.")
86      DRI_CONF_OPT_END
87
88      DRI_CONF_OPT_BEGIN(shader_precompile, bool, true)
89	 DRI_CONF_DESC(en, "Perform code generation at shader link time.")
90      DRI_CONF_OPT_END
91   DRI_CONF_SECTION_END
92DRI_CONF_END;
93
94const GLuint __driNConfigOptions = 15;
95
96#include "intel_batchbuffer.h"
97#include "intel_buffers.h"
98#include "intel_bufmgr.h"
99#include "intel_chipset.h"
100#include "intel_fbo.h"
101#include "intel_mipmap_tree.h"
102#include "intel_screen.h"
103#include "intel_tex.h"
104#include "intel_regions.h"
105
106#include "i915_drm.h"
107
108#ifdef USE_NEW_INTERFACE
109static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
110#endif /*USE_NEW_INTERFACE */
111
112/**
113 * For debugging purposes, this returns a time in seconds.
114 */
115double
116get_time(void)
117{
118   struct timespec tp;
119
120   clock_gettime(CLOCK_MONOTONIC, &tp);
121
122   return tp.tv_sec + tp.tv_nsec / 1000000000.0;
123}
124
125void
126aub_dump_bmp(struct gl_context *ctx)
127{
128   struct gl_framebuffer *fb = ctx->DrawBuffer;
129
130   for (int i = 0; i < fb->_NumColorDrawBuffers; i++) {
131      struct intel_renderbuffer *irb =
132	 intel_renderbuffer(fb->_ColorDrawBuffers[i]);
133
134      if (irb && irb->mt) {
135	 enum aub_dump_bmp_format format;
136
137	 switch (irb->Base.Base.Format) {
138	 case MESA_FORMAT_ARGB8888:
139	 case MESA_FORMAT_XRGB8888:
140	    format = AUB_DUMP_BMP_FORMAT_ARGB_8888;
141	    break;
142	 default:
143	    continue;
144	 }
145
146	 drm_intel_gem_bo_aub_dump_bmp(irb->mt->region->bo,
147				       irb->draw_x,
148				       irb->draw_y,
149				       irb->Base.Base.Width,
150				       irb->Base.Base.Height,
151				       format,
152				       irb->mt->region->pitch *
153				       irb->mt->region->cpp,
154				       0);
155      }
156   }
157}
158
159static const __DRItexBufferExtension intelTexBufferExtension = {
160    { __DRI_TEX_BUFFER, __DRI_TEX_BUFFER_VERSION },
161   intelSetTexBuffer,
162   intelSetTexBuffer2,
163};
164
165static void
166intelDRI2Flush(__DRIdrawable *drawable)
167{
168   GET_CURRENT_CONTEXT(ctx);
169   struct intel_context *intel = intel_context(ctx);
170   if (intel == NULL)
171      return;
172
173   if (intel->gen < 4)
174      INTEL_FIREVERTICES(intel);
175
176   intel_downsample_for_dri2_flush(intel, drawable);
177   intel->need_throttle = true;
178
179   if (intel->batch.used)
180      intel_batchbuffer_flush(intel);
181
182   if (INTEL_DEBUG & DEBUG_AUB) {
183      aub_dump_bmp(ctx);
184   }
185}
186
187static const struct __DRI2flushExtensionRec intelFlushExtension = {
188    { __DRI2_FLUSH, __DRI2_FLUSH_VERSION },
189    intelDRI2Flush,
190    dri2InvalidateDrawable,
191};
192
193static __DRIimage *
194intel_allocate_image(int dri_format, void *loaderPrivate)
195{
196    __DRIimage *image;
197
198    image = CALLOC(sizeof *image);
199    if (image == NULL)
200	return NULL;
201
202    image->dri_format = dri_format;
203    image->offset = 0;
204
205    switch (dri_format) {
206    case __DRI_IMAGE_FORMAT_RGB565:
207       image->format = MESA_FORMAT_RGB565;
208       break;
209    case __DRI_IMAGE_FORMAT_XRGB8888:
210       image->format = MESA_FORMAT_XRGB8888;
211       break;
212    case __DRI_IMAGE_FORMAT_ARGB8888:
213       image->format = MESA_FORMAT_ARGB8888;
214       break;
215    case __DRI_IMAGE_FORMAT_ABGR8888:
216       image->format = MESA_FORMAT_RGBA8888_REV;
217       break;
218    case __DRI_IMAGE_FORMAT_XBGR8888:
219       image->format = MESA_FORMAT_RGBX8888_REV;
220       break;
221    case __DRI_IMAGE_FORMAT_R8:
222       image->format = MESA_FORMAT_R8;
223       break;
224    case __DRI_IMAGE_FORMAT_GR88:
225       image->format = MESA_FORMAT_GR88;
226       break;
227    case __DRI_IMAGE_FORMAT_NONE:
228       image->format = MESA_FORMAT_NONE;
229       break;
230    default:
231       free(image);
232       return NULL;
233    }
234
235    image->internal_format = _mesa_get_format_base_format(image->format);
236    image->data = loaderPrivate;
237
238    return image;
239}
240
241static __DRIimage *
242intel_create_image_from_name(__DRIscreen *screen,
243			     int width, int height, int format,
244			     int name, int pitch, void *loaderPrivate)
245{
246    struct intel_screen *intelScreen = screen->driverPrivate;
247    __DRIimage *image;
248    int cpp;
249
250    image = intel_allocate_image(format, loaderPrivate);
251    if (image->format == MESA_FORMAT_NONE)
252       cpp = 0;
253    else
254       cpp = _mesa_get_format_bytes(image->format);
255    image->region = intel_region_alloc_for_handle(intelScreen,
256						  cpp, width, height,
257						  pitch, name, "image");
258    if (image->region == NULL) {
259       FREE(image);
260       return NULL;
261    }
262
263    return image;
264}
265
266static __DRIimage *
267intel_create_image_from_renderbuffer(__DRIcontext *context,
268				     int renderbuffer, void *loaderPrivate)
269{
270   __DRIimage *image;
271   struct intel_context *intel = context->driverPrivate;
272   struct gl_renderbuffer *rb;
273   struct intel_renderbuffer *irb;
274
275   rb = _mesa_lookup_renderbuffer(&intel->ctx, renderbuffer);
276   if (!rb) {
277      _mesa_error(&intel->ctx,
278		  GL_INVALID_OPERATION, "glRenderbufferExternalMESA");
279      return NULL;
280   }
281
282   irb = intel_renderbuffer(rb);
283   image = CALLOC(sizeof *image);
284   if (image == NULL)
285      return NULL;
286
287   image->internal_format = rb->InternalFormat;
288   image->format = rb->Format;
289   image->offset = 0;
290   image->data = loaderPrivate;
291   intel_region_reference(&image->region, irb->mt->region);
292
293   switch (image->format) {
294   case MESA_FORMAT_RGB565:
295      image->dri_format = __DRI_IMAGE_FORMAT_RGB565;
296      break;
297   case MESA_FORMAT_XRGB8888:
298      image->dri_format = __DRI_IMAGE_FORMAT_XRGB8888;
299      break;
300   case MESA_FORMAT_ARGB8888:
301      image->dri_format = __DRI_IMAGE_FORMAT_ARGB8888;
302      break;
303   case MESA_FORMAT_RGBA8888_REV:
304      image->dri_format = __DRI_IMAGE_FORMAT_ABGR8888;
305      break;
306   case MESA_FORMAT_R8:
307      image->dri_format = __DRI_IMAGE_FORMAT_R8;
308      break;
309   case MESA_FORMAT_RG88:
310      image->dri_format = __DRI_IMAGE_FORMAT_GR88;
311      break;
312   }
313
314   return image;
315}
316
317static void
318intel_destroy_image(__DRIimage *image)
319{
320    intel_region_release(&image->region);
321    FREE(image);
322}
323
324static __DRIimage *
325intel_create_image(__DRIscreen *screen,
326		   int width, int height, int format,
327		   unsigned int use,
328		   void *loaderPrivate)
329{
330   __DRIimage *image;
331   struct intel_screen *intelScreen = screen->driverPrivate;
332   uint32_t tiling;
333   int cpp;
334
335   tiling = I915_TILING_X;
336   if (use & __DRI_IMAGE_USE_CURSOR) {
337      if (width != 64 || height != 64)
338	 return NULL;
339      tiling = I915_TILING_NONE;
340   }
341
342   image = intel_allocate_image(format, loaderPrivate);
343   cpp = _mesa_get_format_bytes(image->format);
344   image->region =
345      intel_region_alloc(intelScreen, tiling, cpp, width, height, true);
346   if (image->region == NULL) {
347      FREE(image);
348      return NULL;
349   }
350
351   return image;
352}
353
354static GLboolean
355intel_query_image(__DRIimage *image, int attrib, int *value)
356{
357   switch (attrib) {
358   case __DRI_IMAGE_ATTRIB_STRIDE:
359      *value = image->region->pitch * image->region->cpp;
360      return true;
361   case __DRI_IMAGE_ATTRIB_HANDLE:
362      *value = image->region->bo->handle;
363      return true;
364   case __DRI_IMAGE_ATTRIB_NAME:
365      return intel_region_flink(image->region, (uint32_t *) value);
366   case __DRI_IMAGE_ATTRIB_FORMAT:
367      *value = image->dri_format;
368      return true;
369   case __DRI_IMAGE_ATTRIB_WIDTH:
370      *value = image->region->width;
371      return true;
372   case __DRI_IMAGE_ATTRIB_HEIGHT:
373      *value = image->region->height;
374      return true;
375  default:
376      return false;
377   }
378}
379
380static __DRIimage *
381intel_dup_image(__DRIimage *orig_image, void *loaderPrivate)
382{
383   __DRIimage *image;
384
385   image = CALLOC(sizeof *image);
386   if (image == NULL)
387      return NULL;
388
389   intel_region_reference(&image->region, orig_image->region);
390   if (image->region == NULL) {
391      FREE(image);
392      return NULL;
393   }
394
395   image->internal_format = orig_image->internal_format;
396   image->dri_format      = orig_image->dri_format;
397   image->format          = orig_image->format;
398   image->offset          = orig_image->offset;
399   image->data            = loaderPrivate;
400
401   return image;
402}
403
404static GLboolean
405intel_validate_usage(__DRIimage *image, unsigned int use)
406{
407   if (use & __DRI_IMAGE_USE_CURSOR) {
408      if (image->region->width != 64 || image->region->height != 64)
409	 return GL_FALSE;
410   }
411
412   return GL_TRUE;
413}
414
415static __DRIimage *
416intel_create_sub_image(__DRIimage *parent,
417                       int width, int height, int dri_format,
418                       int offset, int pitch, void *loaderPrivate)
419{
420    __DRIimage *image;
421    int cpp;
422    uint32_t mask_x, mask_y;
423
424    image = intel_allocate_image(dri_format, loaderPrivate);
425    cpp = _mesa_get_format_bytes(image->format);
426    if (offset + height * cpp * pitch > parent->region->bo->size) {
427       _mesa_warning(NULL, "intel_create_sub_image: subimage out of bounds");
428       FREE(image);
429       return NULL;
430    }
431
432    image->region = calloc(sizeof(*image->region), 1);
433    if (image->region == NULL) {
434       FREE(image);
435       return NULL;
436    }
437
438    image->region->cpp = _mesa_get_format_bytes(image->format);
439    image->region->width = width;
440    image->region->height = height;
441    image->region->pitch = pitch;
442    image->region->refcount = 1;
443    image->region->bo = parent->region->bo;
444    drm_intel_bo_reference(image->region->bo);
445    image->region->tiling = parent->region->tiling;
446    image->region->screen = parent->region->screen;
447    image->offset = offset;
448
449    intel_region_get_tile_masks(image->region, &mask_x, &mask_y);
450    if (offset & mask_x)
451       _mesa_warning(NULL,
452                     "intel_create_sub_image: offset not on tile boundary");
453
454    return image;
455}
456
457static struct __DRIimageExtensionRec intelImageExtension = {
458    { __DRI_IMAGE, 5 },
459    intel_create_image_from_name,
460    intel_create_image_from_renderbuffer,
461    intel_destroy_image,
462    intel_create_image,
463    intel_query_image,
464    intel_dup_image,
465    intel_validate_usage,
466    intel_create_sub_image
467};
468
469static const __DRIextension *intelScreenExtensions[] = {
470    &intelTexBufferExtension.base,
471    &intelFlushExtension.base,
472    &intelImageExtension.base,
473    &dri2ConfigQueryExtension.base,
474    NULL
475};
476
477static bool
478intel_get_param(__DRIscreen *psp, int param, int *value)
479{
480   int ret;
481   struct drm_i915_getparam gp;
482
483   memset(&gp, 0, sizeof(gp));
484   gp.param = param;
485   gp.value = value;
486
487   ret = drmCommandWriteRead(psp->fd, DRM_I915_GETPARAM, &gp, sizeof(gp));
488   if (ret) {
489      if (ret != -EINVAL)
490	 _mesa_warning(NULL, "drm_i915_getparam: %d", ret);
491      return false;
492   }
493
494   return true;
495}
496
497static bool
498intel_get_boolean(__DRIscreen *psp, int param)
499{
500   int value = 0;
501   return intel_get_param(psp, param, &value) && value;
502}
503
504static void
505nop_callback(GLuint key, void *data, void *userData)
506{
507}
508
509static void
510intelDestroyScreen(__DRIscreen * sPriv)
511{
512   struct intel_screen *intelScreen = sPriv->driverPrivate;
513
514   dri_bufmgr_destroy(intelScreen->bufmgr);
515   driDestroyOptionInfo(&intelScreen->optionCache);
516
517   /* Some regions may still have references to them at this point, so
518    * flush the hash table to prevent _mesa_DeleteHashTable() from
519    * complaining about the hash not being empty; */
520   _mesa_HashDeleteAll(intelScreen->named_regions, nop_callback, NULL);
521   _mesa_DeleteHashTable(intelScreen->named_regions);
522
523   FREE(intelScreen);
524   sPriv->driverPrivate = NULL;
525}
526
527
528/**
529 * This is called when we need to set up GL rendering to a new X window.
530 */
531static GLboolean
532intelCreateBuffer(__DRIscreen * driScrnPriv,
533                  __DRIdrawable * driDrawPriv,
534                  const struct gl_config * mesaVis, GLboolean isPixmap)
535{
536   struct intel_renderbuffer *rb;
537   struct intel_screen *screen = (struct intel_screen*) driScrnPriv->driverPrivate;
538   gl_format rgbFormat;
539   unsigned num_samples = intel_quantize_num_samples(screen, mesaVis->samples);
540   struct gl_framebuffer *fb;
541
542   if (isPixmap)
543      return false;
544
545   fb = CALLOC_STRUCT(gl_framebuffer);
546   if (!fb)
547      return false;
548
549   _mesa_initialize_window_framebuffer(fb, mesaVis);
550
551   if (mesaVis->redBits == 5)
552      rgbFormat = MESA_FORMAT_RGB565;
553   else if (mesaVis->alphaBits == 0)
554      rgbFormat = MESA_FORMAT_XRGB8888;
555   else
556      rgbFormat = MESA_FORMAT_ARGB8888;
557
558   /* setup the hardware-based renderbuffers */
559   rb = intel_create_renderbuffer(rgbFormat, num_samples);
560   _mesa_add_renderbuffer(fb, BUFFER_FRONT_LEFT, &rb->Base.Base);
561
562   if (mesaVis->doubleBufferMode) {
563      rb = intel_create_renderbuffer(rgbFormat, num_samples);
564      _mesa_add_renderbuffer(fb, BUFFER_BACK_LEFT, &rb->Base.Base);
565   }
566
567   /*
568    * Assert here that the gl_config has an expected depth/stencil bit
569    * combination: one of d24/s8, d16/s0, d0/s0. (See intelInitScreen2(),
570    * which constructs the advertised configs.)
571    */
572   if (mesaVis->depthBits == 24) {
573      assert(mesaVis->stencilBits == 8);
574
575      if (screen->hw_has_separate_stencil) {
576         rb = intel_create_private_renderbuffer(MESA_FORMAT_X8_Z24,
577                                                num_samples);
578         _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &rb->Base.Base);
579         rb = intel_create_private_renderbuffer(MESA_FORMAT_S8,
580                                                num_samples);
581         _mesa_add_renderbuffer(fb, BUFFER_STENCIL, &rb->Base.Base);
582      } else {
583         /*
584          * Use combined depth/stencil. Note that the renderbuffer is
585          * attached to two attachment points.
586          */
587         rb = intel_create_private_renderbuffer(MESA_FORMAT_S8_Z24,
588                                                num_samples);
589         _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &rb->Base.Base);
590         _mesa_add_renderbuffer(fb, BUFFER_STENCIL, &rb->Base.Base);
591      }
592   }
593   else if (mesaVis->depthBits == 16) {
594      assert(mesaVis->stencilBits == 0);
595      rb = intel_create_private_renderbuffer(MESA_FORMAT_Z16,
596                                             num_samples);
597      _mesa_add_renderbuffer(fb, BUFFER_DEPTH, &rb->Base.Base);
598   }
599   else {
600      assert(mesaVis->depthBits == 0);
601      assert(mesaVis->stencilBits == 0);
602   }
603
604   /* now add any/all software-based renderbuffers we may need */
605   _swrast_add_soft_renderbuffers(fb,
606                                  false, /* never sw color */
607                                  false, /* never sw depth */
608                                  false, /* never sw stencil */
609                                  mesaVis->accumRedBits > 0,
610                                  false, /* never sw alpha */
611                                  false  /* never sw aux */ );
612   driDrawPriv->driverPrivate = fb;
613
614   return true;
615}
616
617static void
618intelDestroyBuffer(__DRIdrawable * driDrawPriv)
619{
620    struct gl_framebuffer *fb = driDrawPriv->driverPrivate;
621
622    _mesa_reference_framebuffer(&fb, NULL);
623}
624
625/* There are probably better ways to do this, such as an
626 * init-designated function to register chipids and createcontext
627 * functions.
628 */
629extern bool
630i830CreateContext(const struct gl_config *mesaVis,
631		  __DRIcontext *driContextPriv,
632		  void *sharedContextPrivate);
633
634extern bool
635i915CreateContext(int api,
636		  const struct gl_config *mesaVis,
637		  __DRIcontext *driContextPriv,
638                  unsigned major_version,
639                  unsigned minor_version,
640                  unsigned *error,
641		  void *sharedContextPrivate);
642extern bool
643brwCreateContext(int api,
644	         const struct gl_config *mesaVis,
645	         __DRIcontext *driContextPriv,
646                 unsigned major_version,
647                 unsigned minor_version,
648                 uint32_t flags,
649                 unsigned *error,
650		 void *sharedContextPrivate);
651
652static GLboolean
653intelCreateContext(gl_api api,
654		   const struct gl_config * mesaVis,
655                   __DRIcontext * driContextPriv,
656		   unsigned major_version,
657		   unsigned minor_version,
658		   uint32_t flags,
659		   unsigned *error,
660                   void *sharedContextPrivate)
661{
662   __DRIscreen *sPriv = driContextPriv->driScreenPriv;
663   struct intel_screen *intelScreen = sPriv->driverPrivate;
664   bool success = false;
665
666#ifdef I915
667   if (IS_9XX(intelScreen->deviceID)) {
668      success = i915CreateContext(api, mesaVis, driContextPriv,
669                                  major_version, minor_version, error,
670                                  sharedContextPrivate);
671   } else {
672      switch (api) {
673      case API_OPENGL:
674         if (major_version > 1 || minor_version > 3) {
675            *error = __DRI_CTX_ERROR_BAD_VERSION;
676            success = false;
677         }
678         break;
679      case API_OPENGLES:
680         break;
681      default:
682         *error = __DRI_CTX_ERROR_BAD_API;
683         success = false;
684      }
685
686      if (success) {
687         intelScreen->no_vbo = true;
688         success = i830CreateContext(mesaVis, driContextPriv,
689                                     sharedContextPrivate);
690         if (!success)
691            *error = __DRI_CTX_ERROR_NO_MEMORY;
692      }
693   }
694#else
695   success = brwCreateContext(api, mesaVis,
696                              driContextPriv,
697                              major_version, minor_version, flags,
698                              error, sharedContextPrivate);
699#endif
700
701   if (success)
702      return true;
703
704   intelDestroyContext(driContextPriv);
705   return false;
706}
707
708static bool
709intel_init_bufmgr(struct intel_screen *intelScreen)
710{
711   __DRIscreen *spriv = intelScreen->driScrnPriv;
712   int num_fences = 0;
713
714   intelScreen->no_hw = getenv("INTEL_NO_HW") != NULL;
715
716   intelScreen->bufmgr = intel_bufmgr_gem_init(spriv->fd, BATCH_SZ);
717   if (intelScreen->bufmgr == NULL) {
718      fprintf(stderr, "[%s:%u] Error initializing buffer manager.\n",
719	      __func__, __LINE__);
720      return false;
721   }
722
723   if (!intel_get_param(spriv, I915_PARAM_NUM_FENCES_AVAIL, &num_fences) ||
724       num_fences == 0) {
725      fprintf(stderr, "[%s: %u] Kernel 2.6.29 required.\n", __func__, __LINE__);
726      return false;
727   }
728
729   drm_intel_bufmgr_gem_enable_fenced_relocs(intelScreen->bufmgr);
730
731   intelScreen->named_regions = _mesa_NewHashTable();
732
733   intelScreen->relaxed_relocations = 0;
734   intelScreen->relaxed_relocations |=
735      intel_get_boolean(spriv, I915_PARAM_HAS_RELAXED_DELTA) << 0;
736
737   return true;
738}
739
740/**
741 * Override intel_screen.hw_has_separate_stencil with environment variable
742 * INTEL_SEPARATE_STENCIL.
743 *
744 * Valid values for INTEL_SEPARATE_STENCIL are "0" and "1". If an invalid
745 * valid value is encountered, a warning is emitted and INTEL_SEPARATE_STENCIL
746 * is ignored.
747 */
748static void
749intel_override_separate_stencil(struct intel_screen *screen)
750{
751   const char *s = getenv("INTEL_SEPARATE_STENCIL");
752   if (!s) {
753      return;
754   } else if (!strncmp("0", s, 2)) {
755      screen->hw_has_separate_stencil = false;
756   } else if (!strncmp("1", s, 2)) {
757      screen->hw_has_separate_stencil = true;
758   } else {
759      fprintf(stderr,
760	      "warning: env variable INTEL_SEPARATE_STENCIL=\"%s\" has "
761	      "invalid value and is ignored", s);
762   }
763}
764
765static bool
766intel_detect_swizzling(struct intel_screen *screen)
767{
768   drm_intel_bo *buffer;
769   unsigned long flags = 0;
770   unsigned long aligned_pitch;
771   uint32_t tiling = I915_TILING_X;
772   uint32_t swizzle_mode = 0;
773
774   buffer = drm_intel_bo_alloc_tiled(screen->bufmgr, "swizzle test",
775				     64, 64, 4,
776				     &tiling, &aligned_pitch, flags);
777   if (buffer == NULL)
778      return false;
779
780   drm_intel_bo_get_tiling(buffer, &tiling, &swizzle_mode);
781   drm_intel_bo_unreference(buffer);
782
783   if (swizzle_mode == I915_BIT_6_SWIZZLE_NONE)
784      return false;
785   else
786      return true;
787}
788
789static __DRIconfig**
790intel_screen_make_configs(__DRIscreen *dri_screen)
791{
792   static const GLenum back_buffer_modes[] = {
793       GLX_NONE, GLX_SWAP_UNDEFINED_OML, GLX_SWAP_COPY_OML
794   };
795
796   static const uint8_t singlesample_samples[1] = {0};
797   static const uint8_t multisample_samples[2]  = {4, 8};
798
799   struct intel_screen *screen = dri_screen->driverPrivate;
800   GLenum fb_format[3];
801   GLenum fb_type[3];
802   uint8_t depth_bits[4], stencil_bits[4];
803   __DRIconfig **configs = NULL;
804
805   fb_format[0] = GL_RGB;
806   fb_type[0] = GL_UNSIGNED_SHORT_5_6_5;
807
808   fb_format[1] = GL_BGR;
809   fb_type[1] = GL_UNSIGNED_INT_8_8_8_8_REV;
810
811   fb_format[2] = GL_BGRA;
812   fb_type[2] = GL_UNSIGNED_INT_8_8_8_8_REV;
813
814   /* Generate singlesample configs without accumulation buffer. */
815   for (int i = 0; i < ARRAY_SIZE(fb_format); i++) {
816      __DRIconfig **new_configs;
817      const int num_depth_stencil_bits = 2;
818
819      /* Starting with DRI2 protocol version 1.1 we can request a depth/stencil
820       * buffer that has a different number of bits per pixel than the color
821       * buffer.  This isn't yet supported here.
822       */
823      depth_bits[0] = 0;
824      stencil_bits[0] = 0;
825
826      if (fb_type[i] == GL_UNSIGNED_SHORT_5_6_5) {
827         depth_bits[1] = 16;
828         stencil_bits[1] = 0;
829      } else {
830         depth_bits[1] = 24;
831         stencil_bits[1] = 8;
832      }
833
834      new_configs = driCreateConfigs(fb_format[i], fb_type[i],
835                                     depth_bits,
836                                     stencil_bits,
837                                     num_depth_stencil_bits,
838                                     back_buffer_modes,
839                                     ARRAY_SIZE(back_buffer_modes),
840                                     singlesample_samples, 1,
841                                     false);
842      configs = driConcatConfigs(configs, new_configs);
843   }
844
845   /* Generate the minimum possible set of configs that include an
846    * accumulation buffer.
847    */
848   for (int i = 0; i < ARRAY_SIZE(fb_format); i++) {
849      __DRIconfig **new_configs;
850
851      if (fb_type[i] == GL_UNSIGNED_SHORT_5_6_5) {
852         depth_bits[0] = 16;
853         stencil_bits[0] = 0;
854      } else {
855         depth_bits[0] = 24;
856         stencil_bits[0] = 8;
857      }
858
859      new_configs = driCreateConfigs(fb_format[i], fb_type[i],
860                                     depth_bits, stencil_bits, 1,
861                                     back_buffer_modes + 1, 1,
862                                     singlesample_samples, 1,
863                                     true);
864      configs = driConcatConfigs(configs, new_configs);
865   }
866
867   /* Generate multisample configs.
868    *
869    * This loop breaks early, and hence is a no-op, on gen < 6.
870    *
871    * Multisample configs must follow the singlesample configs in order to
872    * work around an X server bug present in 1.12. The X server chooses to
873    * associate the first listed RGBA888-Z24S8 config, regardless of its
874    * sample count, with the 32-bit depth visual used for compositing.
875    *
876    * Only doublebuffer configs with GLX_SWAP_UNDEFINED_OML behavior are
877    * supported.  Singlebuffer configs are not supported because no one wants
878    * them. GLX_SWAP_COPY_OML is not supported due to page flipping.
879    */
880   for (int i = 0; i < ARRAY_SIZE(fb_format); i++) {
881      if (screen->gen < 6)
882         break;
883
884      __DRIconfig **new_configs;
885      const int num_depth_stencil_bits = 2;
886      int num_msaa_modes = 0;
887
888      depth_bits[0] = 0;
889      stencil_bits[0] = 0;
890
891      if (fb_type[i] == GL_UNSIGNED_SHORT_5_6_5) {
892         depth_bits[1] = 16;
893         stencil_bits[1] = 0;
894      } else {
895         depth_bits[1] = 24;
896         stencil_bits[1] = 8;
897      }
898
899      if (screen->gen >= 7)
900         num_msaa_modes = 2;
901      else if (screen->gen == 6)
902         num_msaa_modes = 1;
903
904      new_configs = driCreateConfigs(fb_format[i], fb_type[i],
905                                     depth_bits,
906                                     stencil_bits,
907                                     num_depth_stencil_bits,
908                                     back_buffer_modes + 1, 1,
909                                     multisample_samples,
910                                     num_msaa_modes,
911                                     false);
912      configs = driConcatConfigs(configs, new_configs);
913   }
914
915   if (configs == NULL) {
916      fprintf(stderr, "[%s:%u] Error creating FBConfig!\n", __func__,
917              __LINE__);
918      return NULL;
919   }
920
921   return configs;
922}
923
924/**
925 * This is the driver specific part of the createNewScreen entry point.
926 * Called when using DRI2.
927 *
928 * \return the struct gl_config supported by this driver
929 */
930static const
931__DRIconfig **intelInitScreen2(__DRIscreen *psp)
932{
933   struct intel_screen *intelScreen;
934   unsigned int api_mask;
935
936   if (psp->dri2.loader->base.version <= 2 ||
937       psp->dri2.loader->getBuffersWithFormat == NULL) {
938      fprintf(stderr,
939	      "\nERROR!  DRI2 loader with getBuffersWithFormat() "
940	      "support required\n");
941      return false;
942   }
943
944   /* Allocate the private area */
945   intelScreen = CALLOC(sizeof *intelScreen);
946   if (!intelScreen) {
947      fprintf(stderr, "\nERROR!  Allocating private area failed\n");
948      return false;
949   }
950   /* parse information in __driConfigOptions */
951   driParseOptionInfo(&intelScreen->optionCache,
952                      __driConfigOptions, __driNConfigOptions);
953
954   intelScreen->driScrnPriv = psp;
955   psp->driverPrivate = (void *) intelScreen;
956
957   if (!intel_init_bufmgr(intelScreen))
958       return false;
959
960   intelScreen->deviceID = drm_intel_bufmgr_gem_get_devid(intelScreen->bufmgr);
961
962   intelScreen->kernel_has_gen7_sol_reset =
963      intel_get_boolean(intelScreen->driScrnPriv,
964			I915_PARAM_HAS_GEN7_SOL_RESET);
965
966   if (IS_GEN7(intelScreen->deviceID)) {
967      intelScreen->gen = 7;
968   } else if (IS_GEN6(intelScreen->deviceID)) {
969      intelScreen->gen = 6;
970   } else if (IS_GEN5(intelScreen->deviceID)) {
971      intelScreen->gen = 5;
972   } else if (IS_965(intelScreen->deviceID)) {
973      intelScreen->gen = 4;
974   } else if (IS_9XX(intelScreen->deviceID)) {
975      intelScreen->gen = 3;
976   } else {
977      intelScreen->gen = 2;
978   }
979
980   intelScreen->hw_has_separate_stencil = intelScreen->gen >= 6;
981   intelScreen->hw_must_use_separate_stencil = intelScreen->gen >= 7;
982
983   int has_llc = 0;
984   bool success = intel_get_param(intelScreen->driScrnPriv, I915_PARAM_HAS_LLC,
985				  &has_llc);
986   if (success && has_llc)
987      intelScreen->hw_has_llc = true;
988   else if (!success && intelScreen->gen >= 6)
989      intelScreen->hw_has_llc = true;
990
991   intel_override_separate_stencil(intelScreen);
992
993   api_mask = (1 << __DRI_API_OPENGL);
994#if FEATURE_ES1
995   api_mask |= (1 << __DRI_API_GLES);
996#endif
997#if FEATURE_ES2
998   api_mask |= (1 << __DRI_API_GLES2);
999#endif
1000
1001   if (IS_9XX(intelScreen->deviceID) || IS_965(intelScreen->deviceID))
1002      psp->api_mask = api_mask;
1003
1004   intelScreen->hw_has_swizzling = intel_detect_swizzling(intelScreen);
1005
1006   psp->extensions = intelScreenExtensions;
1007
1008   return (const __DRIconfig**) intel_screen_make_configs(psp);
1009}
1010
1011struct intel_buffer {
1012   __DRIbuffer base;
1013   struct intel_region *region;
1014};
1015
1016static __DRIbuffer *
1017intelAllocateBuffer(__DRIscreen *screen,
1018		    unsigned attachment, unsigned format,
1019		    int width, int height)
1020{
1021   struct intel_buffer *intelBuffer;
1022   struct intel_screen *intelScreen = screen->driverPrivate;
1023
1024   assert(attachment == __DRI_BUFFER_FRONT_LEFT ||
1025          attachment == __DRI_BUFFER_BACK_LEFT);
1026
1027   intelBuffer = CALLOC(sizeof *intelBuffer);
1028   if (intelBuffer == NULL)
1029      return NULL;
1030
1031   /* The front and back buffers are color buffers, which are X tiled. */
1032   intelBuffer->region = intel_region_alloc(intelScreen,
1033                                            I915_TILING_X,
1034                                            format / 8,
1035                                            width,
1036                                            height,
1037                                            true);
1038
1039   if (intelBuffer->region == NULL) {
1040	   FREE(intelBuffer);
1041	   return NULL;
1042   }
1043
1044   intel_region_flink(intelBuffer->region, &intelBuffer->base.name);
1045
1046   intelBuffer->base.attachment = attachment;
1047   intelBuffer->base.cpp = intelBuffer->region->cpp;
1048   intelBuffer->base.pitch =
1049         intelBuffer->region->pitch * intelBuffer->region->cpp;
1050
1051   return &intelBuffer->base;
1052}
1053
1054static void
1055intelReleaseBuffer(__DRIscreen *screen, __DRIbuffer *buffer)
1056{
1057   struct intel_buffer *intelBuffer = (struct intel_buffer *) buffer;
1058
1059   intel_region_release(&intelBuffer->region);
1060   free(intelBuffer);
1061}
1062
1063
1064const struct __DriverAPIRec driDriverAPI = {
1065   .InitScreen		 = intelInitScreen2,
1066   .DestroyScreen	 = intelDestroyScreen,
1067   .CreateContext	 = intelCreateContext,
1068   .DestroyContext	 = intelDestroyContext,
1069   .CreateBuffer	 = intelCreateBuffer,
1070   .DestroyBuffer	 = intelDestroyBuffer,
1071   .MakeCurrent		 = intelMakeCurrent,
1072   .UnbindContext	 = intelUnbindContext,
1073   .AllocateBuffer       = intelAllocateBuffer,
1074   .ReleaseBuffer        = intelReleaseBuffer
1075};
1076
1077/* This is the table of extensions that the loader will dlsym() for. */
1078PUBLIC const __DRIextension *__driDriverExtensions[] = {
1079    &driCoreExtension.base,
1080    &driDRI2Extension.base,
1081    NULL
1082};
1083