/**************************************************************************
- *
- * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
+ *
+ * Copyright 2003 VMware, Inc.
* All Rights Reserved.
- *
+ *
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
- *
+ *
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
- *
+ *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
- * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
+ * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
+ *
**************************************************************************/
#include <errno.h>
#include <time.h>
+#include <unistd.h>
#include "main/glheader.h"
#include "main/context.h"
#include "main/framebuffer.h"
#include "main/fbobject.h"
#include "main/version.h"
#include "swrast/s_renderbuffer.h"
+#include "util/ralloc.h"
+#include "brw_shader.h"
+#include "glsl/nir/nir.h"
#include "utils.h"
#include "xmlpool.h"
-PUBLIC const char __driConfigOptions[] =
- DRI_CONF_BEGIN
+static const __DRIconfigOptionsExtension brw_config_options = {
+ .base = { __DRI_CONFIG_OPTIONS, 1 },
+ .xml =
+DRI_CONF_BEGIN
DRI_CONF_SECTION_PERFORMANCE
DRI_CONF_VBLANK_MODE(DRI_CONF_VBLANK_ALWAYS_SYNC)
/* Options correspond to DRI_CONF_BO_REUSE_DISABLED,
DRI_CONF_OPT_BEGIN_B(hiz, "true")
DRI_CONF_DESC(en, "Enable Hierarchical Z on gen6+")
DRI_CONF_OPT_END
-
- DRI_CONF_OPT_BEGIN_B(early_z, "false")
- DRI_CONF_DESC(en, "Enable early Z in classic mode (unstable, 945-only).")
- DRI_CONF_OPT_END
-
DRI_CONF_SECTION_END
+
DRI_CONF_SECTION_QUALITY
DRI_CONF_FORCE_S3TC_ENABLE("false")
- DRI_CONF_ALLOW_LARGE_TEXTURES(2)
+
+ DRI_CONF_OPT_BEGIN(clamp_max_samples, int, -1)
+ DRI_CONF_DESC(en, "Clamp the value of GL_MAX_SAMPLES to the "
+ "given integer. If negative, then do not clamp.")
+ DRI_CONF_OPT_END
DRI_CONF_SECTION_END
+
DRI_CONF_SECTION_DEBUG
DRI_CONF_NO_RAST("false")
DRI_CONF_ALWAYS_FLUSH_BATCH("false")
DRI_CONF_FORCE_GLSL_EXTENSIONS_WARN("false")
DRI_CONF_DISABLE_GLSL_LINE_CONTINUATIONS("false")
DRI_CONF_DISABLE_BLEND_FUNC_EXTENDED("false")
+ DRI_CONF_ALLOW_GLSL_EXTENSION_DIRECTIVE_MIDSHADER("false")
DRI_CONF_OPT_BEGIN_B(shader_precompile, "true")
DRI_CONF_DESC(en, "Perform code generation at shader link time.")
DRI_CONF_OPT_END
DRI_CONF_SECTION_END
-DRI_CONF_END;
-
-const GLuint __driNConfigOptions = 14;
+DRI_CONF_END
+};
#include "intel_batchbuffer.h"
#include "intel_buffers.h"
#include "intel_bufmgr.h"
-#include "intel_chipset.h"
#include "intel_fbo.h"
#include "intel_mipmap_tree.h"
#include "intel_screen.h"
#include "intel_tex.h"
-#include "intel_regions.h"
+#include "intel_image.h"
#include "brw_context.h"
#include "i915_drm.h"
-#ifdef USE_NEW_INTERFACE
-static PFNGLXCREATECONTEXTMODES create_context_modes = NULL;
-#endif /*USE_NEW_INTERFACE */
-
/**
* For debugging purposes, this returns a time in seconds.
*/
enum aub_dump_bmp_format format;
switch (irb->Base.Base.Format) {
- case MESA_FORMAT_ARGB8888:
- case MESA_FORMAT_XRGB8888:
+ case MESA_FORMAT_B8G8R8A8_UNORM:
+ case MESA_FORMAT_B8G8R8X8_UNORM:
format = AUB_DUMP_BMP_FORMAT_ARGB_8888;
break;
default:
continue;
}
- assert(irb->mt->region->pitch % irb->mt->region->cpp == 0);
- drm_intel_gem_bo_aub_dump_bmp(irb->mt->region->bo,
+ drm_intel_gem_bo_aub_dump_bmp(irb->mt->bo,
irb->draw_x,
irb->draw_y,
irb->Base.Base.Width,
irb->Base.Base.Height,
format,
- irb->mt->region->pitch,
+ irb->mt->pitch,
0);
}
}
}
static const __DRItexBufferExtension intelTexBufferExtension = {
- .base = { __DRI_TEX_BUFFER, __DRI_TEX_BUFFER_VERSION },
+ .base = { __DRI_TEX_BUFFER, 3 },
.setTexBuffer = intelSetTexBuffer,
.setTexBuffer2 = intelSetTexBuffer2,
};
static void
-intelDRI2Flush(__DRIdrawable *drawable)
+intel_dri2_flush_with_flags(__DRIcontext *cPriv,
+ __DRIdrawable *dPriv,
+ unsigned flags,
+ enum __DRI2throttleReason reason)
{
- GET_CURRENT_CONTEXT(ctx);
- struct intel_context *intel = intel_context(ctx);
- if (intel == NULL)
+ struct brw_context *brw = cPriv->driverPrivate;
+
+ if (!brw)
return;
- intel_resolve_for_dri2_flush(intel, drawable);
- intel->need_throttle = true;
+ struct gl_context *ctx = &brw->ctx;
+
+ FLUSH_VERTICES(ctx, 0);
+
+ if (flags & __DRI2_FLUSH_DRAWABLE)
+ intel_resolve_for_dri2_flush(brw, dPriv);
+
+ if (reason == __DRI2_THROTTLE_SWAPBUFFER)
+ brw->need_swap_throttle = true;
+ if (reason == __DRI2_THROTTLE_FLUSHFRONT)
+ brw->need_flush_throttle = true;
- if (intel->batch.used)
- intel_batchbuffer_flush(intel);
+ intel_batchbuffer_flush(brw);
if (INTEL_DEBUG & DEBUG_AUB) {
aub_dump_bmp(ctx);
}
}
+/**
+ * Provides compatibility with loaders that only support the older (version
+ * 1-3) flush interface.
+ *
+ * That includes libGL up to Mesa 9.0, and the X Server at least up to 1.13.
+ */
+static void
+intel_dri2_flush(__DRIdrawable *drawable)
+{
+ intel_dri2_flush_with_flags(drawable->driContextPriv, drawable,
+ __DRI2_FLUSH_DRAWABLE,
+ __DRI2_THROTTLE_SWAPBUFFER);
+}
+
static const struct __DRI2flushExtensionRec intelFlushExtension = {
- .base = { __DRI2_FLUSH, 3 },
+ .base = { __DRI2_FLUSH, 4 },
- .flush = intelDRI2Flush,
+ .flush = intel_dri2_flush,
.invalidate = dri2InvalidateDrawable,
+ .flush_with_flags = intel_dri2_flush_with_flags,
};
static struct intel_image_format intel_image_formats[] = {
{ __DRI_IMAGE_FOURCC_ARGB8888, __DRI_IMAGE_COMPONENTS_RGBA, 1,
{ { 0, 0, 0, __DRI_IMAGE_FORMAT_ARGB8888, 4 } } },
+ { __DRI_IMAGE_FOURCC_ABGR8888, __DRI_IMAGE_COMPONENTS_RGBA, 1,
+ { { 0, 0, 0, __DRI_IMAGE_FORMAT_ABGR8888, 4 } } },
+
+ { __DRI_IMAGE_FOURCC_SARGB8888, __DRI_IMAGE_COMPONENTS_RGBA, 1,
+ { { 0, 0, 0, __DRI_IMAGE_FORMAT_SARGB8, 4 } } },
+
{ __DRI_IMAGE_FOURCC_XRGB8888, __DRI_IMAGE_COMPONENTS_RGB, 1,
{ { 0, 0, 0, __DRI_IMAGE_FORMAT_XRGB8888, 4 }, } },
+ { __DRI_IMAGE_FOURCC_XBGR8888, __DRI_IMAGE_COMPONENTS_RGB, 1,
+ { { 0, 0, 0, __DRI_IMAGE_FORMAT_XBGR8888, 4 }, } },
+
+ { __DRI_IMAGE_FOURCC_RGB565, __DRI_IMAGE_COMPONENTS_RGB, 1,
+ { { 0, 0, 0, __DRI_IMAGE_FORMAT_RGB565, 2 } } },
+
{ __DRI_IMAGE_FOURCC_YUV410, __DRI_IMAGE_COMPONENTS_Y_U_V, 3,
{ { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
{ 1, 2, 2, __DRI_IMAGE_FORMAT_R8, 1 },
{ 0, 1, 0, __DRI_IMAGE_FORMAT_ARGB8888, 4 } } }
};
+static void
+intel_image_warn_if_unaligned(__DRIimage *image, const char *func)
+{
+ uint32_t tiling, swizzle;
+ drm_intel_bo_get_tiling(image->bo, &tiling, &swizzle);
+
+ if (tiling != I915_TILING_NONE && (image->offset & 0xfff)) {
+ _mesa_warning(NULL, "%s: offset 0x%08x not on tile boundary",
+ func, image->offset);
+ }
+}
+
+static struct intel_image_format *
+intel_image_format_lookup(int fourcc)
+{
+ struct intel_image_format *f = NULL;
+
+ for (unsigned i = 0; i < ARRAY_SIZE(intel_image_formats); i++) {
+ if (intel_image_formats[i].fourcc == fourcc) {
+ f = &intel_image_formats[i];
+ break;
+ }
+ }
+
+ return f;
+}
+
+static boolean intel_lookup_fourcc(int dri_format, int *fourcc)
+{
+ for (unsigned i = 0; i < ARRAY_SIZE(intel_image_formats); i++) {
+ if (intel_image_formats[i].planes[0].dri_format == dri_format) {
+ *fourcc = intel_image_formats[i].fourcc;
+ return true;
+ }
+ }
+ return false;
+}
+
static __DRIimage *
intel_allocate_image(int dri_format, void *loaderPrivate)
{
image->dri_format = dri_format;
image->offset = 0;
- switch (dri_format) {
- case __DRI_IMAGE_FORMAT_RGB565:
- image->format = MESA_FORMAT_RGB565;
- break;
- case __DRI_IMAGE_FORMAT_XRGB8888:
- image->format = MESA_FORMAT_XRGB8888;
- break;
- case __DRI_IMAGE_FORMAT_ARGB8888:
- image->format = MESA_FORMAT_ARGB8888;
- break;
- case __DRI_IMAGE_FORMAT_ABGR8888:
- image->format = MESA_FORMAT_RGBA8888_REV;
- break;
- case __DRI_IMAGE_FORMAT_XBGR8888:
- image->format = MESA_FORMAT_RGBX8888_REV;
- break;
- case __DRI_IMAGE_FORMAT_R8:
- image->format = MESA_FORMAT_R8;
- break;
- case __DRI_IMAGE_FORMAT_GR88:
- image->format = MESA_FORMAT_GR88;
- break;
- case __DRI_IMAGE_FORMAT_NONE:
- image->format = MESA_FORMAT_NONE;
- break;
- default:
+ image->format = driImageFormatToGLFormat(dri_format);
+ if (dri_format != __DRI_IMAGE_FORMAT_NONE &&
+ image->format == MESA_FORMAT_NONE) {
free(image);
return NULL;
}
}
/**
- * Sets up a DRIImage structure to point to our shared image in a region
+ * Sets up a DRIImage structure to point to a slice out of a miptree.
*/
static void
-intel_setup_image_from_mipmap_tree(struct intel_context *intel, __DRIimage *image,
+intel_setup_image_from_mipmap_tree(struct brw_context *brw, __DRIimage *image,
struct intel_mipmap_tree *mt, GLuint level,
GLuint zoffset)
{
- unsigned int draw_x, draw_y;
- uint32_t mask_x, mask_y;
-
- intel_miptree_make_shareable(intel, mt);
+ intel_miptree_make_shareable(brw, mt);
intel_miptree_check_level_layer(mt, level, zoffset);
- intel_region_get_tile_masks(mt->region, &mask_x, &mask_y, false);
- intel_miptree_get_image_offset(mt, level, zoffset, &draw_x, &draw_y);
-
- image->width = mt->level[level].width;
- image->height = mt->level[level].height;
- image->tile_x = draw_x & mask_x;
- image->tile_y = draw_y & mask_y;
-
- image->offset = intel_region_get_aligned_offset(mt->region,
- draw_x & ~mask_x,
- draw_y & ~mask_y,
- false);
-
- intel_region_reference(&image->region, mt->region);
-}
-
-static void
-intel_setup_image_from_dimensions(__DRIimage *image)
-{
- image->width = image->region->width;
- image->height = image->region->height;
- image->tile_x = 0;
- image->tile_y = 0;
- image->has_depthstencil = false;
-}
+ image->width = minify(mt->physical_width0, level - mt->first_level);
+ image->height = minify(mt->physical_height0, level - mt->first_level);
+ image->pitch = mt->pitch;
-static inline uint32_t
-intel_dri_format(GLuint format)
-{
- switch (format) {
- case MESA_FORMAT_RGB565:
- return __DRI_IMAGE_FORMAT_RGB565;
- case MESA_FORMAT_XRGB8888:
- return __DRI_IMAGE_FORMAT_XRGB8888;
- case MESA_FORMAT_ARGB8888:
- return __DRI_IMAGE_FORMAT_ARGB8888;
- case MESA_FORMAT_RGBA8888_REV:
- return __DRI_IMAGE_FORMAT_ABGR8888;
- case MESA_FORMAT_R8:
- return __DRI_IMAGE_FORMAT_R8;
- case MESA_FORMAT_RG88:
- return __DRI_IMAGE_FORMAT_GR88;
- }
+ image->offset = intel_miptree_get_tile_offsets(mt, level, zoffset,
+ &image->tile_x,
+ &image->tile_y);
- return MESA_FORMAT_NONE;
+ drm_intel_bo_unreference(image->bo);
+ image->bo = mt->bo;
+ drm_intel_bo_reference(mt->bo);
}
static __DRIimage *
cpp = 1;
else
cpp = _mesa_get_format_bytes(image->format);
- image->region = intel_region_alloc_for_handle(intelScreen,
- cpp, width, height,
- pitch * cpp, name, "image");
- if (image->region == NULL) {
+
+ image->width = width;
+ image->height = height;
+ image->pitch = pitch * cpp;
+ image->bo = drm_intel_bo_gem_create_from_name(intelScreen->bufmgr, "image",
+ name);
+ if (!image->bo) {
free(image);
return NULL;
}
- intel_setup_image_from_dimensions(image);
-
return image;
}
int renderbuffer, void *loaderPrivate)
{
__DRIimage *image;
- struct intel_context *intel = context->driverPrivate;
+ struct brw_context *brw = context->driverPrivate;
+ struct gl_context *ctx = &brw->ctx;
struct gl_renderbuffer *rb;
struct intel_renderbuffer *irb;
- rb = _mesa_lookup_renderbuffer(&intel->ctx, renderbuffer);
+ rb = _mesa_lookup_renderbuffer(ctx, renderbuffer);
if (!rb) {
- _mesa_error(&intel->ctx,
- GL_INVALID_OPERATION, "glRenderbufferExternalMESA");
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glRenderbufferExternalMESA");
return NULL;
}
irb = intel_renderbuffer(rb);
- intel_miptree_make_shareable(intel, irb->mt);
+ intel_miptree_make_shareable(brw, irb->mt);
image = calloc(1, sizeof *image);
if (image == NULL)
return NULL;
image->format = rb->Format;
image->offset = 0;
image->data = loaderPrivate;
- intel_region_reference(&image->region, irb->mt->region);
- intel_setup_image_from_dimensions(image);
- image->dri_format = intel_dri_format(image->format);
+ drm_intel_bo_unreference(image->bo);
+ image->bo = irb->mt->bo;
+ drm_intel_bo_reference(irb->mt->bo);
+ image->width = rb->Width;
+ image->height = rb->Height;
+ image->pitch = irb->mt->pitch;
+ image->dri_format = driGLFormatToImageFormat(image->format);
image->has_depthstencil = irb->mt->stencil_mt? true : false;
rb->NeedsFinishRenderTexture = true;
void *loaderPrivate)
{
__DRIimage *image;
- struct intel_context *intel = context->driverPrivate;
+ struct brw_context *brw = context->driverPrivate;
struct gl_texture_object *obj;
struct intel_texture_object *iobj;
GLuint face = 0;
- obj = _mesa_lookup_texture(&intel->ctx, texture);
+ obj = _mesa_lookup_texture(&brw->ctx, texture);
if (!obj || obj->Target != target) {
*error = __DRI_IMAGE_ERROR_BAD_PARAMETER;
return NULL;
if (target == GL_TEXTURE_CUBE_MAP)
face = zoffset;
- _mesa_test_texobj_completeness(&intel->ctx, obj);
+ _mesa_test_texobj_completeness(&brw->ctx, obj);
iobj = intel_texture_object(obj);
if (!obj->_BaseComplete || (level > 0 && !obj->_MipmapComplete)) {
*error = __DRI_IMAGE_ERROR_BAD_PARAMETER;
image->internal_format = obj->Image[face][level]->InternalFormat;
image->format = obj->Image[face][level]->TexFormat;
image->data = loaderPrivate;
- intel_setup_image_from_mipmap_tree(intel, image, iobj->mt, level, zoffset);
- image->dri_format = intel_dri_format(image->format);
+ intel_setup_image_from_mipmap_tree(brw, image, iobj->mt, level, zoffset);
+ image->dri_format = driGLFormatToImageFormat(image->format);
image->has_depthstencil = iobj->mt->stencil_mt? true : false;
if (image->dri_format == MESA_FORMAT_NONE) {
*error = __DRI_IMAGE_ERROR_BAD_PARAMETER;
static void
intel_destroy_image(__DRIimage *image)
{
- intel_region_release(&image->region);
- free(image);
+ drm_intel_bo_unreference(image->bo);
+ free(image);
}
static __DRIimage *
struct intel_screen *intelScreen = screen->driverPrivate;
uint32_t tiling;
int cpp;
+ unsigned long pitch;
tiling = I915_TILING_X;
if (use & __DRI_IMAGE_USE_CURSOR) {
tiling = I915_TILING_NONE;
}
+ if (use & __DRI_IMAGE_USE_LINEAR)
+ tiling = I915_TILING_NONE;
+
image = intel_allocate_image(format, loaderPrivate);
if (image == NULL)
return NULL;
+
cpp = _mesa_get_format_bytes(image->format);
- image->region =
- intel_region_alloc(intelScreen, tiling, cpp, width, height, true);
- if (image->region == NULL) {
+ image->bo = drm_intel_bo_alloc_tiled(intelScreen->bufmgr, "image",
+ width, height, cpp, &tiling,
+ &pitch, 0);
+ if (image->bo == NULL) {
free(image);
return NULL;
}
-
- intel_setup_image_from_dimensions(image);
+ image->width = width;
+ image->height = height;
+ image->pitch = pitch;
return image;
}
{
switch (attrib) {
case __DRI_IMAGE_ATTRIB_STRIDE:
- *value = image->region->pitch;
+ *value = image->pitch;
return true;
case __DRI_IMAGE_ATTRIB_HANDLE:
- *value = image->region->bo->handle;
+ *value = image->bo->handle;
return true;
case __DRI_IMAGE_ATTRIB_NAME:
- return intel_region_flink(image->region, (uint32_t *) value);
+ return !drm_intel_bo_flink(image->bo, (uint32_t *) value);
case __DRI_IMAGE_ATTRIB_FORMAT:
*value = image->dri_format;
return true;
case __DRI_IMAGE_ATTRIB_WIDTH:
- *value = image->region->width;
+ *value = image->width;
return true;
case __DRI_IMAGE_ATTRIB_HEIGHT:
- *value = image->region->height;
+ *value = image->height;
return true;
case __DRI_IMAGE_ATTRIB_COMPONENTS:
if (image->planar_format == NULL)
*value = image->planar_format->components;
return true;
case __DRI_IMAGE_ATTRIB_FD:
- if (drm_intel_bo_gem_export_to_prime(image->region->bo, value) == 0)
+ if (drm_intel_bo_gem_export_to_prime(image->bo, value) == 0)
return true;
return false;
+ case __DRI_IMAGE_ATTRIB_FOURCC:
+ if (intel_lookup_fourcc(image->dri_format, value))
+ return true;
+ return false;
+ case __DRI_IMAGE_ATTRIB_NUM_PLANES:
+ *value = 1;
+ return true;
+
default:
return false;
}
if (image == NULL)
return NULL;
- intel_region_reference(&image->region, orig_image->region);
- if (image->region == NULL) {
- free(image);
- return NULL;
- }
-
+ drm_intel_bo_reference(orig_image->bo);
+ image->bo = orig_image->bo;
image->internal_format = orig_image->internal_format;
image->planar_format = orig_image->planar_format;
image->dri_format = orig_image->dri_format;
image->offset = orig_image->offset;
image->width = orig_image->width;
image->height = orig_image->height;
+ image->pitch = orig_image->pitch;
image->tile_x = orig_image->tile_x;
image->tile_y = orig_image->tile_y;
image->has_depthstencil = orig_image->has_depthstencil;
intel_validate_usage(__DRIimage *image, unsigned int use)
{
if (use & __DRI_IMAGE_USE_CURSOR) {
- if (image->region->width != 64 || image->region->height != 64)
+ if (image->width != 64 || image->height != 64)
return GL_FALSE;
}
if (screen == NULL || names == NULL || num_names != 1)
return NULL;
- for (i = 0; i < ARRAY_SIZE(intel_image_formats); i++) {
- if (intel_image_formats[i].fourcc == fourcc) {
- f = &intel_image_formats[i];
- }
- }
-
+ f = intel_image_format_lookup(fourcc);
if (f == NULL)
return NULL;
void *loaderPrivate)
{
struct intel_screen *intelScreen = screen->driverPrivate;
- struct intel_image_format *f = NULL;
+ struct intel_image_format *f;
__DRIimage *image;
int i, index;
if (fds == NULL || num_fds != 1)
return NULL;
- for (i = 0; i < ARRAY_SIZE(intel_image_formats); i++) {
- if (intel_image_formats[i].fourcc == fourcc) {
- f = &intel_image_formats[i];
- }
- }
-
+ f = intel_image_format_lookup(fourcc);
if (f == NULL)
return NULL;
- image = intel_allocate_image(__DRI_IMAGE_FORMAT_NONE, loaderPrivate);
+ if (f->nplanes == 1)
+ image = intel_allocate_image(f->planes[0].dri_format, loaderPrivate);
+ else
+ image = intel_allocate_image(__DRI_IMAGE_FORMAT_NONE, loaderPrivate);
+
if (image == NULL)
return NULL;
- image->region = intel_region_alloc_for_fd(intelScreen,
- 1, width, height,
- strides[0], fds[0], "image");
- if (image->region == NULL) {
+ image->bo = drm_intel_bo_gem_create_from_prime(intelScreen->bufmgr,
+ fds[0],
+ height * strides[0]);
+ if (image->bo == NULL) {
free(image);
return NULL;
}
+ image->width = width;
+ image->height = height;
+ image->pitch = strides[0];
image->planar_format = f;
for (i = 0; i < f->nplanes; i++) {
image->strides[index] = strides[index];
}
+ if (f->nplanes == 1) {
+ image->offset = image->offsets[0];
+ intel_image_warn_if_unaligned(image, __func__);
+ }
+
return image;
}
+static __DRIimage *
+intel_create_image_from_dma_bufs(__DRIscreen *screen,
+ int width, int height, int fourcc,
+ int *fds, int num_fds,
+ int *strides, int *offsets,
+ enum __DRIYUVColorSpace yuv_color_space,
+ enum __DRISampleRange sample_range,
+ enum __DRIChromaSiting horizontal_siting,
+ enum __DRIChromaSiting vertical_siting,
+ unsigned *error,
+ void *loaderPrivate)
+{
+ __DRIimage *image;
+ struct intel_image_format *f = intel_image_format_lookup(fourcc);
+
+ /* For now only packed formats that have native sampling are supported. */
+ if (!f || f->nplanes != 1) {
+ *error = __DRI_IMAGE_ERROR_BAD_MATCH;
+ return NULL;
+ }
+
+ image = intel_create_image_from_fds(screen, width, height, fourcc, fds,
+ num_fds, strides, offsets,
+ loaderPrivate);
+
+ /*
+ * Invalid parameters and any inconsistencies between are assumed to be
+ * checked by the caller. Therefore besides unsupported formats one can fail
+ * only in allocation.
+ */
+ if (!image) {
+ *error = __DRI_IMAGE_ERROR_BAD_ALLOC;
+ return NULL;
+ }
+
+ image->dma_buf_imported = true;
+ image->yuv_color_space = yuv_color_space;
+ image->sample_range = sample_range;
+ image->horizontal_siting = horizontal_siting;
+ image->vertical_siting = vertical_siting;
+
+ *error = __DRI_IMAGE_ERROR_SUCCESS;
+ return image;
+}
static __DRIimage *
intel_from_planar(__DRIimage *parent, int plane, void *loaderPrivate)
{
int width, height, offset, stride, dri_format, index;
struct intel_image_format *f;
- uint32_t mask_x, mask_y;
__DRIimage *image;
if (parent == NULL || parent->planar_format == NULL)
if (plane >= f->nplanes)
return NULL;
- width = parent->region->width >> f->planes[plane].width_shift;
- height = parent->region->height >> f->planes[plane].height_shift;
+ width = parent->width >> f->planes[plane].width_shift;
+ height = parent->height >> f->planes[plane].height_shift;
dri_format = f->planes[plane].dri_format;
index = f->planes[plane].buffer_index;
offset = parent->offsets[index];
if (image == NULL)
return NULL;
- if (offset + height * stride > parent->region->bo->size) {
+ if (offset + height * stride > parent->bo->size) {
_mesa_warning(NULL, "intel_create_sub_image: subimage out of bounds");
free(image);
return NULL;
}
- image->region = calloc(sizeof(*image->region), 1);
- if (image->region == NULL) {
- free(image);
- return NULL;
- }
+ image->bo = parent->bo;
+ drm_intel_bo_reference(parent->bo);
- image->region->cpp = _mesa_get_format_bytes(image->format);
- image->region->width = width;
- image->region->height = height;
- image->region->pitch = stride;
- image->region->refcount = 1;
- image->region->bo = parent->region->bo;
- drm_intel_bo_reference(image->region->bo);
- image->region->tiling = parent->region->tiling;
+ image->width = width;
+ image->height = height;
+ image->pitch = stride;
image->offset = offset;
- intel_setup_image_from_dimensions(image);
- intel_region_get_tile_masks(image->region, &mask_x, &mask_y, false);
- if (offset & mask_x)
- _mesa_warning(NULL,
- "intel_create_sub_image: offset not on tile boundary");
+ intel_image_warn_if_unaligned(image, __func__);
return image;
}
-static struct __DRIimageExtensionRec intelImageExtension = {
- .base = { __DRI_IMAGE, 7 },
+static const __DRIimageExtension intelImageExtension = {
+ .base = { __DRI_IMAGE, 11 },
.createImageFromName = intel_create_image_from_name,
.createImageFromRenderbuffer = intel_create_image_from_renderbuffer,
.createImageFromNames = intel_create_image_from_names,
.fromPlanar = intel_from_planar,
.createImageFromTexture = intel_create_image_from_texture,
- .createImageFromFds = intel_create_image_from_fds
+ .createImageFromFds = intel_create_image_from_fds,
+ .createImageFromDmaBufs = intel_create_image_from_dma_bufs,
+ .blitImage = NULL,
+ .getCapabilities = NULL
+};
+
+static int
+brw_query_renderer_integer(__DRIscreen *psp, int param, unsigned int *value)
+{
+ const struct intel_screen *const intelScreen =
+ (struct intel_screen *) psp->driverPrivate;
+
+ switch (param) {
+ case __DRI2_RENDERER_VENDOR_ID:
+ value[0] = 0x8086;
+ return 0;
+ case __DRI2_RENDERER_DEVICE_ID:
+ value[0] = intelScreen->deviceID;
+ return 0;
+ case __DRI2_RENDERER_ACCELERATED:
+ value[0] = 1;
+ return 0;
+ case __DRI2_RENDERER_VIDEO_MEMORY: {
+ /* Once a batch uses more than 75% of the maximum mappable size, we
+ * assume that there's some fragmentation, and we start doing extra
+ * flushing, etc. That's the big cliff apps will care about.
+ */
+ size_t aper_size;
+ size_t mappable_size;
+
+ drm_intel_get_aperture_sizes(psp->fd, &mappable_size, &aper_size);
+
+ const unsigned gpu_mappable_megabytes =
+ (aper_size / (1024 * 1024)) * 3 / 4;
+
+ const long system_memory_pages = sysconf(_SC_PHYS_PAGES);
+ const long system_page_size = sysconf(_SC_PAGE_SIZE);
+
+ if (system_memory_pages <= 0 || system_page_size <= 0)
+ return -1;
+
+ const uint64_t system_memory_bytes = (uint64_t) system_memory_pages
+ * (uint64_t) system_page_size;
+
+ const unsigned system_memory_megabytes =
+ (unsigned) (system_memory_bytes / (1024 * 1024));
+
+ value[0] = MIN2(system_memory_megabytes, gpu_mappable_megabytes);
+ return 0;
+ }
+ case __DRI2_RENDERER_UNIFIED_MEMORY_ARCHITECTURE:
+ value[0] = 1;
+ return 0;
+ default:
+ return driQueryRendererIntegerCommon(psp, param, value);
+ }
+
+ return -1;
+}
+
+static int
+brw_query_renderer_string(__DRIscreen *psp, int param, const char **value)
+{
+ const struct intel_screen *intelScreen =
+ (struct intel_screen *) psp->driverPrivate;
+
+ switch (param) {
+ case __DRI2_RENDERER_VENDOR_ID:
+ value[0] = brw_vendor_string;
+ return 0;
+ case __DRI2_RENDERER_DEVICE_ID:
+ value[0] = brw_get_renderer_string(intelScreen->deviceID);
+ return 0;
+ default:
+ break;
+ }
+
+ return -1;
+}
+
+static const __DRI2rendererQueryExtension intelRendererQueryExtension = {
+ .base = { __DRI2_RENDERER_QUERY, 1 },
+
+ .queryInteger = brw_query_renderer_integer,
+ .queryString = brw_query_renderer_string
+};
+
+static const __DRIrobustnessExtension dri2Robustness = {
+ .base = { __DRI2_ROBUSTNESS, 1 }
};
static const __DRIextension *intelScreenExtensions[] = {
&intelTexBufferExtension.base,
+ &intelFenceExtension.base,
&intelFlushExtension.base,
&intelImageExtension.base,
+ &intelRendererQueryExtension.base,
&dri2ConfigQueryExtension.base,
NULL
};
+static const __DRIextension *intelRobustScreenExtensions[] = {
+ &intelTexBufferExtension.base,
+ &intelFenceExtension.base,
+ &intelFlushExtension.base,
+ &intelImageExtension.base,
+ &intelRendererQueryExtension.base,
+ &dri2ConfigQueryExtension.base,
+ &dri2Robustness.base,
+ NULL
+};
+
static bool
intel_get_param(__DRIscreen *psp, int param, int *value)
{
dri_bufmgr_destroy(intelScreen->bufmgr);
driDestroyOptionInfo(&intelScreen->optionCache);
- free(intelScreen);
+ ralloc_free(intelScreen);
sPriv->driverPrivate = NULL;
}
{
struct intel_renderbuffer *rb;
struct intel_screen *screen = (struct intel_screen*) driScrnPriv->driverPrivate;
- gl_format rgbFormat;
+ mesa_format rgbFormat;
unsigned num_samples = intel_quantize_num_samples(screen, mesaVis->samples);
struct gl_framebuffer *fb;
_mesa_initialize_window_framebuffer(fb, mesaVis);
+ if (screen->winsys_msaa_samples_override != -1) {
+ num_samples = screen->winsys_msaa_samples_override;
+ fb->Visual.samples = num_samples;
+ }
+
if (mesaVis->redBits == 5)
- rgbFormat = MESA_FORMAT_RGB565;
+ rgbFormat = MESA_FORMAT_B5G6R5_UNORM;
else if (mesaVis->sRGBCapable)
- rgbFormat = MESA_FORMAT_SARGB8;
+ rgbFormat = MESA_FORMAT_B8G8R8A8_SRGB;
else if (mesaVis->alphaBits == 0)
- rgbFormat = MESA_FORMAT_XRGB8888;
+ rgbFormat = MESA_FORMAT_B8G8R8X8_UNORM;
else {
- rgbFormat = MESA_FORMAT_SARGB8;
+ rgbFormat = MESA_FORMAT_B8G8R8A8_SRGB;
fb->Visual.sRGBCapable = true;
}
if (mesaVis->depthBits == 24) {
assert(mesaVis->stencilBits == 8);
- if (screen->hw_has_separate_stencil) {
- rb = intel_create_private_renderbuffer(MESA_FORMAT_X8_Z24,
+ if (screen->devinfo->has_hiz_and_separate_stencil) {
+ rb = intel_create_private_renderbuffer(MESA_FORMAT_Z24_UNORM_X8_UINT,
num_samples);
_mesa_add_renderbuffer(fb, BUFFER_DEPTH, &rb->Base.Base);
- rb = intel_create_private_renderbuffer(MESA_FORMAT_S8,
+ rb = intel_create_private_renderbuffer(MESA_FORMAT_S_UINT8,
num_samples);
_mesa_add_renderbuffer(fb, BUFFER_STENCIL, &rb->Base.Base);
} else {
* Use combined depth/stencil. Note that the renderbuffer is
* attached to two attachment points.
*/
- rb = intel_create_private_renderbuffer(MESA_FORMAT_S8_Z24,
+ rb = intel_create_private_renderbuffer(MESA_FORMAT_Z24_UNORM_S8_UINT,
num_samples);
_mesa_add_renderbuffer(fb, BUFFER_DEPTH, &rb->Base.Base);
_mesa_add_renderbuffer(fb, BUFFER_STENCIL, &rb->Base.Base);
}
else if (mesaVis->depthBits == 16) {
assert(mesaVis->stencilBits == 0);
- rb = intel_create_private_renderbuffer(MESA_FORMAT_Z16,
+ rb = intel_create_private_renderbuffer(MESA_FORMAT_Z_UNORM16,
num_samples);
_mesa_add_renderbuffer(fb, BUFFER_DEPTH, &rb->Base.Base);
}
intelDestroyBuffer(__DRIdrawable * driDrawPriv)
{
struct gl_framebuffer *fb = driDrawPriv->driverPrivate;
-
- _mesa_reference_framebuffer(&fb, NULL);
-}
-
-/* There are probably better ways to do this, such as an
- * init-designated function to register chipids and createcontext
- * functions.
- */
-
-static GLboolean
-intelCreateContext(gl_api api,
- const struct gl_config * mesaVis,
- __DRIcontext * driContextPriv,
- unsigned major_version,
- unsigned minor_version,
- uint32_t flags,
- unsigned *error,
- void *sharedContextPrivate)
-{
- bool success = false;
-
- success = brwCreateContext(api, mesaVis,
- driContextPriv,
- major_version, minor_version, flags,
- error, sharedContextPrivate);
-
- if (success)
- return true;
-
- if (driContextPriv->driverPrivate != NULL)
- intelDestroyContext(driContextPriv);
- return false;
+ _mesa_reference_framebuffer(&fb, NULL);
}
static bool
return true;
}
-/**
- * Override intel_screen.hw_has_separate_stencil with environment variable
- * INTEL_SEPARATE_STENCIL.
- *
- * Valid values for INTEL_SEPARATE_STENCIL are "0" and "1". If an invalid
- * valid value is encountered, a warning is emitted and INTEL_SEPARATE_STENCIL
- * is ignored.
- */
-static void
-intel_override_separate_stencil(struct intel_screen *screen)
-{
- const char *s = getenv("INTEL_SEPARATE_STENCIL");
- if (!s) {
- return;
- } else if (!strncmp("0", s, 2)) {
- screen->hw_has_separate_stencil = false;
- } else if (!strncmp("1", s, 2)) {
- screen->hw_has_separate_stencil = true;
- } else {
- fprintf(stderr,
- "warning: env variable INTEL_SEPARATE_STENCIL=\"%s\" has "
- "invalid value and is ignored", s);
- }
-}
-
static bool
intel_detect_swizzling(struct intel_screen *screen)
{
return true;
}
+static bool
+intel_detect_timestamp(struct intel_screen *screen)
+{
+ uint64_t dummy = 0;
+ int loop = 10;
+
+ /*
+ * On 32bit systems, some old kernels trigger a hw bug resulting in the
+ * TIMESTAMP register being shifted and the low 32bits always zero. Detect
+ * this by repeating the read a few times and check the register is
+ * incrementing every 80ns as expected and not stuck on zero (as would be
+ * the case with the buggy kernel/hw.).
+ */
+ do {
+ if (drm_intel_reg_read(screen->bufmgr, TIMESTAMP, &dummy))
+ return false;
+ } while ((dummy & 0xffffffff) == 0 && --loop);
+
+ return loop > 0;
+}
+
+/**
+ * Return array of MSAA modes supported by the hardware. The array is
+ * zero-terminated and sorted in decreasing order.
+ */
+const int*
+intel_supported_msaa_modes(const struct intel_screen *screen)
+{
+ static const int gen8_modes[] = {8, 4, 2, 0, -1};
+ static const int gen7_modes[] = {8, 4, 0, -1};
+ static const int gen6_modes[] = {4, 0, -1};
+ static const int gen4_modes[] = {0, -1};
+
+ if (screen->devinfo->gen >= 8) {
+ return gen8_modes;
+ } else if (screen->devinfo->gen >= 7) {
+ return gen7_modes;
+ } else if (screen->devinfo->gen == 6) {
+ return gen6_modes;
+ } else {
+ return gen4_modes;
+ }
+}
+
static __DRIconfig**
intel_screen_make_configs(__DRIscreen *dri_screen)
{
- static const gl_format formats[] = {
- MESA_FORMAT_RGB565,
- MESA_FORMAT_ARGB8888
+ static const mesa_format formats[] = {
+ MESA_FORMAT_B5G6R5_UNORM,
+ MESA_FORMAT_B8G8R8A8_UNORM,
+ MESA_FORMAT_B8G8R8X8_UNORM
};
/* GLX_SWAP_COPY_OML is not supported due to page flipping. */
static const uint8_t multisample_samples[2] = {4, 8};
struct intel_screen *screen = dri_screen->driverPrivate;
+ const struct brw_device_info *devinfo = screen->devinfo;
uint8_t depth_bits[4], stencil_bits[4];
__DRIconfig **configs = NULL;
depth_bits[0] = 0;
stencil_bits[0] = 0;
- if (formats[i] == MESA_FORMAT_RGB565) {
+ if (formats[i] == MESA_FORMAT_B5G6R5_UNORM) {
depth_bits[1] = 16;
stencil_bits[1] = 0;
- if (screen->gen >= 6) {
+ if (devinfo->gen >= 6) {
depth_bits[2] = 24;
stencil_bits[2] = 8;
num_depth_stencil_bits = 3;
for (int i = 0; i < ARRAY_SIZE(formats); i++) {
__DRIconfig **new_configs;
- if (formats[i] == MESA_FORMAT_RGB565) {
+ if (formats[i] == MESA_FORMAT_B5G6R5_UNORM) {
depth_bits[0] = 16;
stencil_bits[0] = 0;
} else {
* them.
*/
for (int i = 0; i < ARRAY_SIZE(formats); i++) {
- if (screen->gen < 6)
+ if (devinfo->gen < 6)
break;
__DRIconfig **new_configs;
depth_bits[0] = 0;
stencil_bits[0] = 0;
- if (formats[i] == MESA_FORMAT_RGB565) {
+ if (formats[i] == MESA_FORMAT_B5G6R5_UNORM) {
depth_bits[1] = 16;
stencil_bits[1] = 0;
} else {
stencil_bits[1] = 8;
}
- if (screen->gen >= 7)
+ if (devinfo->gen >= 7)
num_msaa_modes = 2;
- else if (screen->gen == 6)
+ else if (devinfo->gen == 6)
num_msaa_modes = 1;
new_configs = driCreateConfigs(formats[i],
static void
set_max_gl_versions(struct intel_screen *screen)
{
- int gl_version_override = _mesa_get_gl_version_override();
+ __DRIscreen *psp = screen->driScrnPriv;
- switch (screen->gen) {
+ switch (screen->devinfo->gen) {
+ case 9:
+ case 8:
case 7:
- screen->max_gl_core_version = 31;
- screen->max_gl_compat_version = 30;
- screen->max_gl_es1_version = 11;
- screen->max_gl_es2_version = 30;
- break;
case 6:
- screen->max_gl_core_version = 31;
- screen->max_gl_compat_version = 30;
- screen->max_gl_es1_version = 11;
- screen->max_gl_es2_version = 30;
+ psp->max_gl_core_version = 33;
+ psp->max_gl_compat_version = 30;
+ psp->max_gl_es1_version = 11;
+ psp->max_gl_es2_version = 30;
break;
case 5:
case 4:
- screen->max_gl_core_version = 0;
- screen->max_gl_compat_version = 21;
- screen->max_gl_es1_version = 11;
- screen->max_gl_es2_version = 20;
- break;
- case 3: {
- screen->max_gl_core_version = 0;
- screen->max_gl_es1_version = 11;
- screen->max_gl_compat_version = 21;
- screen->max_gl_es2_version = 20;
-
- break;
- }
- case 2:
- screen->max_gl_core_version = 0;
- screen->max_gl_compat_version = 13;
- screen->max_gl_es1_version = 11;
- screen->max_gl_es2_version = 0;
+ psp->max_gl_core_version = 0;
+ psp->max_gl_compat_version = 21;
+ psp->max_gl_es1_version = 11;
+ psp->max_gl_es2_version = 20;
break;
default:
- assert(!"unrecognized intel_screen::gen");
- break;
+ unreachable("unrecognized intel_screen::gen");
}
+}
- if (gl_version_override >= 31) {
- screen->max_gl_core_version = MAX2(screen->max_gl_core_version,
- gl_version_override);
- } else {
- screen->max_gl_compat_version = MAX2(screen->max_gl_compat_version,
- gl_version_override);
- }
+static int
+brw_get_revision(int fd)
+{
+ struct drm_i915_getparam gp;
+ int revision;
+ int ret;
-#ifndef FEATURE_ES1
- screen->max_gl_es1_version = 0;
-#endif
+ memset(&gp, 0, sizeof(gp));
+ gp.param = I915_PARAM_REVISION;
+ gp.value = &revision;
-#ifndef FEATURE_ES2
- screen->max_gl_es2_version = 0;
-#endif
+ ret = drmCommandWriteRead(fd, DRM_I915_GETPARAM, &gp, sizeof(gp));
+ if (ret)
+ revision = -1;
+
+ return revision;
}
+/* Drop when RS headers get pulled to libdrm */
+#ifndef I915_PARAM_HAS_RESOURCE_STREAMER
+#define I915_PARAM_HAS_RESOURCE_STREAMER 36
+#endif
+
/**
* This is the driver specific part of the createNewScreen entry point.
* Called when using DRI2.
{
struct intel_screen *intelScreen;
- if (psp->dri2.loader->base.version <= 2 ||
+ if (psp->image.loader) {
+ } else if (psp->dri2.loader->base.version <= 2 ||
psp->dri2.loader->getBuffersWithFormat == NULL) {
fprintf(stderr,
"\nERROR! DRI2 loader with getBuffersWithFormat() "
}
/* Allocate the private area */
- intelScreen = calloc(1, sizeof *intelScreen);
+ intelScreen = rzalloc(NULL, struct intel_screen);
if (!intelScreen) {
fprintf(stderr, "\nERROR! Allocating private area failed\n");
return false;
}
/* parse information in __driConfigOptions */
- driParseOptionInfo(&intelScreen->optionCache,
- __driConfigOptions, __driNConfigOptions);
+ driParseOptionInfo(&intelScreen->optionCache, brw_config_options.xml);
intelScreen->driScrnPriv = psp;
psp->driverPrivate = (void *) intelScreen;
return false;
intelScreen->deviceID = drm_intel_bufmgr_gem_get_devid(intelScreen->bufmgr);
+ intelScreen->devinfo = brw_get_device_info(intelScreen->deviceID,
+ brw_get_revision(psp->fd));
+ if (!intelScreen->devinfo)
+ return false;
+
+ brw_process_intel_debug_variable(intelScreen);
+
+ intelScreen->hw_must_use_separate_stencil = intelScreen->devinfo->gen >= 7;
- if (IS_GEN7(intelScreen->deviceID)) {
- intelScreen->gen = 7;
- } else if (IS_GEN6(intelScreen->deviceID)) {
- intelScreen->gen = 6;
- } else if (IS_GEN5(intelScreen->deviceID)) {
- intelScreen->gen = 5;
- } else if (IS_965(intelScreen->deviceID)) {
- intelScreen->gen = 4;
- } else if (IS_9XX(intelScreen->deviceID)) {
- intelScreen->gen = 3;
+ intelScreen->hw_has_swizzling = intel_detect_swizzling(intelScreen);
+ intelScreen->hw_has_timestamp = intel_detect_timestamp(intelScreen);
+
+ const char *force_msaa = getenv("INTEL_FORCE_MSAA");
+ if (force_msaa) {
+ intelScreen->winsys_msaa_samples_override =
+ intel_quantize_num_samples(intelScreen, atoi(force_msaa));
+ printf("Forcing winsys sample count to %d\n",
+ intelScreen->winsys_msaa_samples_override);
} else {
- intelScreen->gen = 2;
+ intelScreen->winsys_msaa_samples_override = -1;
}
- intelScreen->hw_has_separate_stencil = intelScreen->gen >= 6;
- intelScreen->hw_must_use_separate_stencil = intelScreen->gen >= 7;
+ set_max_gl_versions(intelScreen);
- int has_llc = 0;
- bool success = intel_get_param(intelScreen->driScrnPriv, I915_PARAM_HAS_LLC,
- &has_llc);
- if (success && has_llc)
- intelScreen->hw_has_llc = true;
- else if (!success && intelScreen->gen >= 6)
- intelScreen->hw_has_llc = true;
+ /* Notification of GPU resets requires hardware contexts and a kernel new
+ * enough to support DRM_IOCTL_I915_GET_RESET_STATS. If the ioctl is
+ * supported, calling it with a context of 0 will either generate EPERM or
+ * no error. If the ioctl is not supported, it always generate EINVAL.
+ * Use this to determine whether to advertise the __DRI2_ROBUSTNESS
+ * extension to the loader.
+ *
+ * Don't even try on pre-Gen6, since we don't attempt to use contexts there.
+ */
+ if (intelScreen->devinfo->gen >= 6) {
+ struct drm_i915_reset_stats stats;
+ memset(&stats, 0, sizeof(stats));
- intel_override_separate_stencil(intelScreen);
+ const int ret = drmIoctl(psp->fd, DRM_IOCTL_I915_GET_RESET_STATS, &stats);
- intelScreen->hw_has_swizzling = intel_detect_swizzling(intelScreen);
+ intelScreen->has_context_reset_notification =
+ (ret != -1 || errno != EINVAL);
+ }
- set_max_gl_versions(intelScreen);
+ struct drm_i915_getparam getparam;
+ getparam.param = I915_PARAM_CMD_PARSER_VERSION;
+ getparam.value = &intelScreen->cmd_parser_version;
+ const int ret = drmIoctl(psp->fd, DRM_IOCTL_I915_GETPARAM, &getparam);
+ if (ret == -1)
+ intelScreen->cmd_parser_version = 0;
- psp->api_mask = (1 << __DRI_API_OPENGL);
- if (intelScreen->max_gl_core_version > 0)
- psp->api_mask |= (1 << __DRI_API_OPENGL_CORE);
- if (intelScreen->max_gl_es1_version > 0)
- psp->api_mask |= (1 << __DRI_API_GLES);
- if (intelScreen->max_gl_es2_version > 0)
- psp->api_mask |= (1 << __DRI_API_GLES2);
- if (intelScreen->max_gl_es2_version >= 30)
- psp->api_mask |= (1 << __DRI_API_GLES3);
+ psp->extensions = !intelScreen->has_context_reset_notification
+ ? intelScreenExtensions : intelRobustScreenExtensions;
- psp->extensions = intelScreenExtensions;
+ intelScreen->compiler = brw_compiler_create(intelScreen,
+ intelScreen->devinfo);
+
+ if (intelScreen->devinfo->has_resource_streamer) {
+ int val = -1;
+ getparam.param = I915_PARAM_HAS_RESOURCE_STREAMER;
+ getparam.value = &val;
+
+ drmIoctl(psp->fd, DRM_IOCTL_I915_GETPARAM, &getparam);
+ intelScreen->has_resource_streamer = val > 0;
+ }
return (const __DRIconfig**) intel_screen_make_configs(psp);
}
struct intel_buffer {
__DRIbuffer base;
- struct intel_region *region;
+ drm_intel_bo *bo;
};
static __DRIbuffer *
return NULL;
/* The front and back buffers are color buffers, which are X tiled. */
- intelBuffer->region = intel_region_alloc(intelScreen,
- I915_TILING_X,
- format / 8,
- width,
- height,
- true);
-
- if (intelBuffer->region == NULL) {
+ uint32_t tiling = I915_TILING_X;
+ unsigned long pitch;
+ int cpp = format / 8;
+ intelBuffer->bo = drm_intel_bo_alloc_tiled(intelScreen->bufmgr,
+ "intelAllocateBuffer",
+ width,
+ height,
+ cpp,
+ &tiling, &pitch,
+ BO_ALLOC_FOR_RENDER);
+
+ if (intelBuffer->bo == NULL) {
free(intelBuffer);
return NULL;
}
-
- intel_region_flink(intelBuffer->region, &intelBuffer->base.name);
+
+ drm_intel_bo_flink(intelBuffer->bo, &intelBuffer->base.name);
intelBuffer->base.attachment = attachment;
- intelBuffer->base.cpp = intelBuffer->region->cpp;
- intelBuffer->base.pitch = intelBuffer->region->pitch;
+ intelBuffer->base.cpp = cpp;
+ intelBuffer->base.pitch = pitch;
return &intelBuffer->base;
}
{
struct intel_buffer *intelBuffer = (struct intel_buffer *) buffer;
- intel_region_release(&intelBuffer->region);
+ drm_intel_bo_unreference(intelBuffer->bo);
free(intelBuffer);
}
-
-const struct __DriverAPIRec driDriverAPI = {
+static const struct __DriverAPIRec brw_driver_api = {
.InitScreen = intelInitScreen2,
.DestroyScreen = intelDestroyScreen,
- .CreateContext = intelCreateContext,
+ .CreateContext = brwCreateContext,
.DestroyContext = intelDestroyContext,
.CreateBuffer = intelCreateBuffer,
.DestroyBuffer = intelDestroyBuffer,
.ReleaseBuffer = intelReleaseBuffer
};
-/* This is the table of extensions that the loader will dlsym() for. */
-PUBLIC const __DRIextension *__driDriverExtensions[] = {
+static const struct __DRIDriverVtableExtensionRec brw_vtable = {
+ .base = { __DRI_DRIVER_VTABLE, 1 },
+ .vtable = &brw_driver_api,
+};
+
+static const __DRIextension *brw_driver_extensions[] = {
&driCoreExtension.base,
+ &driImageDriverExtension.base,
&driDRI2Extension.base,
+ &brw_vtable.base,
+ &brw_config_options.base,
NULL
};
+
+PUBLIC const __DRIextension **__driDriverGetExtensions_i965(void)
+{
+ globalDriverAPI = &brw_driver_api;
+
+ return brw_driver_extensions;
+}
projects / mesa.git / blobdiff