intel_screen.c revision bf8644e64daa4e1d59d1e399355b349406438d7a 
1/**************************************************************************
2 *
3 * Copyright 2003 Tungsten Graphics, 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 TUNGSTEN GRAPHICS 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#include <errno.h>
29#include "main/glheader.h"
30#include "main/context.h"
31#include "main/framebuffer.h"
32#include "main/renderbuffer.h"
33#include "main/hash.h"
34#include "main/fbobject.h"
35#include "main/mfeatures.h"
36#include "main/version.h"
37#include "swrast/s_renderbuffer.h"
38
39#include "utils.h"
40#include "xmlpool.h"
41
42PUBLIC const char __driConfigOptions[] =
43   DRI_CONF_BEGIN
44   DRI_CONF_SECTION_PERFORMANCE
45      DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_ALWAYS_SYNC)
46      /* Options correspond to DRI_CONF_BO_REUSE_DISABLED,
47       * DRI_CONF_BO_REUSE_ALL
48       */
49      DRI_CONF_OPT_BEGIN_V(bo_reuse, enum, 1, "0:1")
50	 DRI_CONF_DESC_BEGIN(en, "Buffer object reuse")
51	    DRI_CONF_ENUM(0, "Disable buffer object reuse")
52	    DRI_CONF_ENUM(1, "Enable reuse of all sizes of buffer objects")
53	 DRI_CONF_DESC_END
54      DRI_CONF_OPT_END
55
56      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   switch (api) {
667   case API_OPENGL:
668   case API_OPENGLES:
669      break;
670   case API_OPENGLES2:
671#ifdef I915
672      if (!IS_9XX(intelScreen->deviceID)) {
673         *error = __DRI_CTX_ERROR_BAD_API;
674         return false;
675      }
676#endif
677      break;
678   case API_OPENGL_CORE:
679      *error = __DRI_CTX_ERROR_BAD_API;
680      return GL_FALSE;
681   }
682
683#ifdef I915
684   if (IS_9XX(intelScreen->deviceID)) {
685      success = i915CreateContext(api, mesaVis, driContextPriv,
686                                  major_version, minor_version, error,
687                                  sharedContextPrivate);
688   } else {
689      switch (api) {
690      case API_OPENGL:
691         if (major_version > 1 || minor_version > 3) {
692            *error = __DRI_CTX_ERROR_BAD_VERSION;
693            return false;
694         }
695         break;
696      case API_OPENGLES:
697         break;
698      default:
699         *error = __DRI_CTX_ERROR_BAD_API;
700         return false;
701      }
702
703      intelScreen->no_vbo = true;
704      success = i830CreateContext(mesaVis, driContextPriv,
705				  sharedContextPrivate);
706      if (!success) {
707         *error = __DRI_CTX_ERROR_NO_MEMORY;
708         return false;
709      }
710   }
711#else
712   success = brwCreateContext(api, mesaVis,
713                              driContextPriv,
714                              major_version, minor_version, flags,
715                              error, sharedContextPrivate);
716#endif
717
718   if (success) {
719      struct gl_context *ctx =
720	 (struct gl_context *) driContextPriv->driverPrivate;
721
722      _mesa_compute_version(ctx);
723      if (ctx->Version >= major_version * 10 + minor_version) {
724	 return true;
725      }
726
727      *error = __DRI_CTX_ERROR_BAD_VERSION;
728      intelDestroyContext(driContextPriv);
729   } else {
730      *error = __DRI_CTX_ERROR_NO_MEMORY;
731      fprintf(stderr, "Unrecognized deviceID 0x%x\n", intelScreen->deviceID);
732   }
733
734   return false;
735}
736
737static bool
738intel_init_bufmgr(struct intel_screen *intelScreen)
739{
740   __DRIscreen *spriv = intelScreen->driScrnPriv;
741   int num_fences = 0;
742
743   intelScreen->no_hw = getenv("INTEL_NO_HW") != NULL;
744
745   intelScreen->bufmgr = intel_bufmgr_gem_init(spriv->fd, BATCH_SZ);
746   if (intelScreen->bufmgr == NULL) {
747      fprintf(stderr, "[%s:%u] Error initializing buffer manager.\n",
748	      __func__, __LINE__);
749      return false;
750   }
751
752   if (!intel_get_param(spriv, I915_PARAM_NUM_FENCES_AVAIL, &num_fences) ||
753       num_fences == 0) {
754      fprintf(stderr, "[%s: %u] Kernel 2.6.29 required.\n", __func__, __LINE__);
755      return false;
756   }
757
758   drm_intel_bufmgr_gem_enable_fenced_relocs(intelScreen->bufmgr);
759
760   intelScreen->named_regions = _mesa_NewHashTable();
761
762   intelScreen->relaxed_relocations = 0;
763   intelScreen->relaxed_relocations |=
764      intel_get_boolean(spriv, I915_PARAM_HAS_RELAXED_DELTA) << 0;
765
766   return true;
767}
768
769/**
770 * Override intel_screen.hw_has_separate_stencil with environment variable
771 * INTEL_SEPARATE_STENCIL.
772 *
773 * Valid values for INTEL_SEPARATE_STENCIL are "0" and "1". If an invalid
774 * valid value is encountered, a warning is emitted and INTEL_SEPARATE_STENCIL
775 * is ignored.
776 */
777static void
778intel_override_separate_stencil(struct intel_screen *screen)
779{
780   const char *s = getenv("INTEL_SEPARATE_STENCIL");
781   if (!s) {
782      return;
783   } else if (!strncmp("0", s, 2)) {
784      screen->hw_has_separate_stencil = false;
785   } else if (!strncmp("1", s, 2)) {
786      screen->hw_has_separate_stencil = true;
787   } else {
788      fprintf(stderr,
789	      "warning: env variable INTEL_SEPARATE_STENCIL=\"%s\" has "
790	      "invalid value and is ignored", s);
791   }
792}
793
794static bool
795intel_detect_swizzling(struct intel_screen *screen)
796{
797   drm_intel_bo *buffer;
798   unsigned long flags = 0;
799   unsigned long aligned_pitch;
800   uint32_t tiling = I915_TILING_X;
801   uint32_t swizzle_mode = 0;
802
803   buffer = drm_intel_bo_alloc_tiled(screen->bufmgr, "swizzle test",
804				     64, 64, 4,
805				     &tiling, &aligned_pitch, flags);
806   if (buffer == NULL)
807      return false;
808
809   drm_intel_bo_get_tiling(buffer, &tiling, &swizzle_mode);
810   drm_intel_bo_unreference(buffer);
811
812   if (swizzle_mode == I915_BIT_6_SWIZZLE_NONE)
813      return false;
814   else
815      return true;
816}
817
818static __DRIconfig**
819intel_screen_make_configs(__DRIscreen *dri_screen)
820{
821   static const GLenum back_buffer_modes[] = {
822       GLX_NONE, GLX_SWAP_UNDEFINED_OML, GLX_SWAP_COPY_OML
823   };
824
825   static const uint8_t singlesample_samples[1] = {0};
826   static const uint8_t multisample_samples[2]  = {4, 8};
827
828   struct intel_screen *screen = dri_screen->driverPrivate;
829   GLenum fb_format[3];
830   GLenum fb_type[3];
831   uint8_t depth_bits[4], stencil_bits[4];
832   __DRIconfig **configs = NULL;
833
834   fb_format[0] = GL_RGB;
835   fb_type[0] = GL_UNSIGNED_SHORT_5_6_5;
836
837   fb_format[1] = GL_BGR;
838   fb_type[1] = GL_UNSIGNED_INT_8_8_8_8_REV;
839
840   fb_format[2] = GL_BGRA;
841   fb_type[2] = GL_UNSIGNED_INT_8_8_8_8_REV;
842
843   /* Generate singlesample configs without accumulation buffer. */
844   for (int i = 0; i < ARRAY_SIZE(fb_format); i++) {
845      __DRIconfig **new_configs;
846      const int num_depth_stencil_bits = 2;
847
848      /* Starting with DRI2 protocol version 1.1 we can request a depth/stencil
849       * buffer that has a different number of bits per pixel than the color
850       * buffer.  This isn't yet supported here.
851       */
852      depth_bits[0] = 0;
853      stencil_bits[0] = 0;
854
855      if (fb_type[i] == GL_UNSIGNED_SHORT_5_6_5) {
856         depth_bits[1] = 16;
857         stencil_bits[1] = 0;
858      } else {
859         depth_bits[1] = 24;
860         stencil_bits[1] = 8;
861      }
862
863      new_configs = driCreateConfigs(fb_format[i], fb_type[i],
864                                     depth_bits,
865                                     stencil_bits,
866                                     num_depth_stencil_bits,
867                                     back_buffer_modes,
868                                     ARRAY_SIZE(back_buffer_modes),
869                                     singlesample_samples, 1,
870                                     false);
871      configs = driConcatConfigs(configs, new_configs);
872   }
873
874   /* Generate the minimum possible set of configs that include an
875    * accumulation buffer.
876    */
877   for (int i = 0; i < ARRAY_SIZE(fb_format); i++) {
878      __DRIconfig **new_configs;
879
880      if (fb_type[i] == GL_UNSIGNED_SHORT_5_6_5) {
881         depth_bits[0] = 16;
882         stencil_bits[0] = 0;
883      } else {
884         depth_bits[0] = 24;
885         stencil_bits[0] = 8;
886      }
887
888      new_configs = driCreateConfigs(fb_format[i], fb_type[i],
889                                     depth_bits, stencil_bits, 1,
890                                     back_buffer_modes + 1, 1,
891                                     singlesample_samples, 1,
892                                     true);
893      configs = driConcatConfigs(configs, new_configs);
894   }
895
896   /* Generate multisample configs.
897    *
898    * This loop breaks early, and hence is a no-op, on gen < 6.
899    *
900    * Multisample configs must follow the singlesample configs in order to
901    * work around an X server bug present in 1.12. The X server chooses to
902    * associate the first listed RGBA888-Z24S8 config, regardless of its
903    * sample count, with the 32-bit depth visual used for compositing.
904    *
905    * Only doublebuffer configs with GLX_SWAP_UNDEFINED_OML behavior are
906    * supported.  Singlebuffer configs are not supported because no one wants
907    * them. GLX_SWAP_COPY_OML is not supported due to page flipping.
908    */
909   for (int i = 0; i < ARRAY_SIZE(fb_format); i++) {
910      if (screen->gen < 6)
911         break;
912
913      __DRIconfig **new_configs;
914      const int num_depth_stencil_bits = 2;
915      int num_msaa_modes = 0;
916
917      depth_bits[0] = 0;
918      stencil_bits[0] = 0;
919
920      if (fb_type[i] == GL_UNSIGNED_SHORT_5_6_5) {
921         depth_bits[1] = 16;
922         stencil_bits[1] = 0;
923      } else {
924         depth_bits[1] = 24;
925         stencil_bits[1] = 8;
926      }
927
928      if (screen->gen >= 7)
929         num_msaa_modes = 2;
930      else if (screen->gen == 6)
931         num_msaa_modes = 1;
932
933      new_configs = driCreateConfigs(fb_format[i], fb_type[i],
934                                     depth_bits,
935                                     stencil_bits,
936                                     num_depth_stencil_bits,
937                                     back_buffer_modes + 1, 1,
938                                     multisample_samples,
939                                     num_msaa_modes,
940                                     false);
941      configs = driConcatConfigs(configs, new_configs);
942   }
943
944   if (configs == NULL) {
945      fprintf(stderr, "[%s:%u] Error creating FBConfig!\n", __func__,
946              __LINE__);
947      return NULL;
948   }
949
950   return configs;
951}
952
953/**
954 * This is the driver specific part of the createNewScreen entry point.
955 * Called when using DRI2.
956 *
957 * \return the struct gl_config supported by this driver
958 */
959static const
960__DRIconfig **intelInitScreen2(__DRIscreen *psp)
961{
962   struct intel_screen *intelScreen;
963   unsigned int api_mask;
964
965   if (psp->dri2.loader->base.version <= 2 ||
966       psp->dri2.loader->getBuffersWithFormat == NULL) {
967      fprintf(stderr,
968	      "\nERROR!  DRI2 loader with getBuffersWithFormat() "
969	      "support required\n");
970      return false;
971   }
972
973   /* Allocate the private area */
974   intelScreen = CALLOC(sizeof *intelScreen);
975   if (!intelScreen) {
976      fprintf(stderr, "\nERROR!  Allocating private area failed\n");
977      return false;
978   }
979   /* parse information in __driConfigOptions */
980   driParseOptionInfo(&intelScreen->optionCache,
981                      __driConfigOptions, __driNConfigOptions);
982
983   intelScreen->driScrnPriv = psp;
984   psp->driverPrivate = (void *) intelScreen;
985
986   if (!intel_init_bufmgr(intelScreen))
987       return false;
988
989   intelScreen->deviceID = drm_intel_bufmgr_gem_get_devid(intelScreen->bufmgr);
990
991   intelScreen->kernel_has_gen7_sol_reset =
992      intel_get_boolean(intelScreen->driScrnPriv,
993			I915_PARAM_HAS_GEN7_SOL_RESET);
994
995   if (IS_GEN7(intelScreen->deviceID)) {
996      intelScreen->gen = 7;
997   } else if (IS_GEN6(intelScreen->deviceID)) {
998      intelScreen->gen = 6;
999   } else if (IS_GEN5(intelScreen->deviceID)) {
1000      intelScreen->gen = 5;
1001   } else if (IS_965(intelScreen->deviceID)) {
1002      intelScreen->gen = 4;
1003   } else if (IS_9XX(intelScreen->deviceID)) {
1004      intelScreen->gen = 3;
1005   } else {
1006      intelScreen->gen = 2;
1007   }
1008
1009   intelScreen->hw_has_separate_stencil = intelScreen->gen >= 6;
1010   intelScreen->hw_must_use_separate_stencil = intelScreen->gen >= 7;
1011
1012   int has_llc = 0;
1013   bool success = intel_get_param(intelScreen->driScrnPriv, I915_PARAM_HAS_LLC,
1014				  &has_llc);
1015   if (success && has_llc)
1016      intelScreen->hw_has_llc = true;
1017   else if (!success && intelScreen->gen >= 6)
1018      intelScreen->hw_has_llc = true;
1019
1020   intel_override_separate_stencil(intelScreen);
1021
1022   api_mask = (1 << __DRI_API_OPENGL);
1023#if FEATURE_ES1
1024   api_mask |= (1 << __DRI_API_GLES);
1025#endif
1026#if FEATURE_ES2
1027   api_mask |= (1 << __DRI_API_GLES2);
1028#endif
1029
1030   if (IS_9XX(intelScreen->deviceID) || IS_965(intelScreen->deviceID))
1031      psp->api_mask = api_mask;
1032
1033   intelScreen->hw_has_swizzling = intel_detect_swizzling(intelScreen);
1034
1035   psp->extensions = intelScreenExtensions;
1036
1037   return (const __DRIconfig**) intel_screen_make_configs(psp);
1038}
1039
1040struct intel_buffer {
1041   __DRIbuffer base;
1042   struct intel_region *region;
1043};
1044
1045static __DRIbuffer *
1046intelAllocateBuffer(__DRIscreen *screen,
1047		    unsigned attachment, unsigned format,
1048		    int width, int height)
1049{
1050   struct intel_buffer *intelBuffer;
1051   struct intel_screen *intelScreen = screen->driverPrivate;
1052
1053   assert(attachment == __DRI_BUFFER_FRONT_LEFT ||
1054          attachment == __DRI_BUFFER_BACK_LEFT);
1055
1056   intelBuffer = CALLOC(sizeof *intelBuffer);
1057   if (intelBuffer == NULL)
1058      return NULL;
1059
1060   /* The front and back buffers are color buffers, which are X tiled. */
1061   intelBuffer->region = intel_region_alloc(intelScreen,
1062                                            I915_TILING_X,
1063                                            format / 8,
1064                                            width,
1065                                            height,
1066                                            true);
1067
1068   if (intelBuffer->region == NULL) {
1069	   FREE(intelBuffer);
1070	   return NULL;
1071   }
1072
1073   intel_region_flink(intelBuffer->region, &intelBuffer->base.name);
1074
1075   intelBuffer->base.attachment = attachment;
1076   intelBuffer->base.cpp = intelBuffer->region->cpp;
1077   intelBuffer->base.pitch =
1078         intelBuffer->region->pitch * intelBuffer->region->cpp;
1079
1080   return &intelBuffer->base;
1081}
1082
1083static void
1084intelReleaseBuffer(__DRIscreen *screen, __DRIbuffer *buffer)
1085{
1086   struct intel_buffer *intelBuffer = (struct intel_buffer *) buffer;
1087
1088   intel_region_release(&intelBuffer->region);
1089   free(intelBuffer);
1090}
1091
1092
1093const struct __DriverAPIRec driDriverAPI = {
1094   .InitScreen		 = intelInitScreen2,
1095   .DestroyScreen	 = intelDestroyScreen,
1096   .CreateContext	 = intelCreateContext,
1097   .DestroyContext	 = intelDestroyContext,
1098   .CreateBuffer	 = intelCreateBuffer,
1099   .DestroyBuffer	 = intelDestroyBuffer,
1100   .MakeCurrent		 = intelMakeCurrent,
1101   .UnbindContext	 = intelUnbindContext,
1102   .AllocateBuffer       = intelAllocateBuffer,
1103   .ReleaseBuffer        = intelReleaseBuffer
1104};
1105
1106/* This is the table of extensions that the loader will dlsym() for. */
1107PUBLIC const __DRIextension *__driDriverExtensions[] = {
1108    &driCoreExtension.base,
1109    &driDRI2Extension.base,
1110    NULL
1111};
1112