francesco/fml13v01-buildroot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a2efe48b3191aed2dda2efe2361d74fed587aa75
fml13v01-buildroot/package/mesa3d/0001-Add-pvr-dri-driver.patch
T
Windsome Zeng fe38db9384 [mesa3d] Sync all patch files with DDK 1.17.
2022-08-16 17:38:05 +08:00

4693 lines
154 KiB
Diff
Raw Blame History

From 1546e69ae9fec54134bc06146143511b4374bf4a Mon Sep 17 00:00:00 2001
From: Frank Binns <frank.binns@imgtec.com>
Date: Tue, 14 Apr 2020 09:47:46 +0100
Subject: [PATCH 01/67] Add pvr dri driver
---
meson.build | 19 +-
meson_options.txt | 2 +-
src/mesa/drivers/dri/meson.build | 5 +
src/mesa/drivers/dri/pvr/dri_support.h | 581 +++++++++++++++
src/mesa/drivers/dri/pvr/img_drm_fourcc.h | 113 +++
src/mesa/drivers/dri/pvr/imgpixfmts.h | 307 ++++++++
src/mesa/drivers/dri/pvr/imgyuv.h | 58 ++
src/mesa/drivers/dri/pvr/mesa_context.c | 208 ++++++
src/mesa/drivers/dri/pvr/meson.build | 48 ++
src/mesa/drivers/dri/pvr/pvrcb.c | 328 +++++++++
src/mesa/drivers/dri/pvr/pvrcompat.c | 838 ++++++++++++++++++++++
src/mesa/drivers/dri/pvr/pvrdri.c | 613 ++++++++++++++++
src/mesa/drivers/dri/pvr/pvrdri.h | 188 +++++
src/mesa/drivers/dri/pvr/pvrdri_support.h | 206 ++++++
src/mesa/drivers/dri/pvr/pvrext.c | 704 ++++++++++++++++++
src/mesa/drivers/dri/pvr/pvrmesa.h | 36 +
src/mesa/drivers/dri/pvr/pvrutil.c | 239 ++++++
src/meson.build | 1 +
18 files changed, 4485 insertions(+), 9 deletions(-)
create mode 100644 src/mesa/drivers/dri/pvr/dri_support.h
create mode 100644 src/mesa/drivers/dri/pvr/img_drm_fourcc.h
create mode 100644 src/mesa/drivers/dri/pvr/imgpixfmts.h
create mode 100644 src/mesa/drivers/dri/pvr/imgyuv.h
create mode 100644 src/mesa/drivers/dri/pvr/mesa_context.c
create mode 100644 src/mesa/drivers/dri/pvr/meson.build
create mode 100644 src/mesa/drivers/dri/pvr/pvrcb.c
create mode 100644 src/mesa/drivers/dri/pvr/pvrcompat.c
create mode 100644 src/mesa/drivers/dri/pvr/pvrdri.c
create mode 100644 src/mesa/drivers/dri/pvr/pvrdri.h
create mode 100644 src/mesa/drivers/dri/pvr/pvrdri_support.h
create mode 100644 src/mesa/drivers/dri/pvr/pvrext.c
create mode 100644 src/mesa/drivers/dri/pvr/pvrmesa.h
create mode 100644 src/mesa/drivers/dri/pvr/pvrutil.c
diff --git a/meson.build b/meson.build
index 155db287796..968b4f5f499 100644
--- a/meson.build
+++ b/meson.build
@@ -171,11 +171,11 @@ if dri_drivers.contains('auto')
if system_has_kms_drm
# TODO: PPC, Sparc
if ['x86', 'x86_64'].contains(host_machine.cpu_family())
- dri_drivers = ['i915', 'i965', 'r100', 'r200', 'nouveau']
+ dri_drivers = ['i915', 'i965', 'r100', 'r200', 'nouveau', 'pvr']
elif ['arm', 'aarch64'].contains(host_machine.cpu_family())
- dri_drivers = []
+ dri_drivers = ['pvr']
elif ['mips', 'mips64', 'riscv32', 'riscv64'].contains(host_machine.cpu_family())
- dri_drivers = ['r100', 'r200', 'nouveau']
+ dri_drivers = ['r100', 'r200', 'nouveau', 'pvr']
else
error('Unknown architecture @0@. Please pass -Ddri-drivers to set driver options. Patches gladly accepted to fix this.'.format(
host_machine.cpu_family()))
@@ -194,6 +194,7 @@ with_dri_i965 = dri_drivers.contains('i965')
with_dri_r100 = dri_drivers.contains('r100')
with_dri_r200 = dri_drivers.contains('r200')
with_dri_nouveau = dri_drivers.contains('nouveau')
+with_dri_pvr = dri_drivers.contains('pvr')
with_dri = dri_drivers.length() != 0
@@ -1516,14 +1517,16 @@ _drm_amdgpu_ver = '2.4.107'
_drm_radeon_ver = '2.4.71'
_drm_nouveau_ver = '2.4.102'
_drm_intel_ver = '2.4.75'
+_drm_pvr_ver = '2.4.60'
_drm_ver = '2.4.81'
_libdrm_checks = [
- ['intel', with_dri_i915 or with_gallium_i915],
- ['amdgpu', (with_amd_vk and not with_platform_windows) or with_gallium_radeonsi],
+ ['intel', with_dri_i915 or with_gallium_i915, true],
+ ['amdgpu', (with_amd_vk and not with_platform_windows) or with_gallium_radeonsi, true],
['radeon', (with_gallium_radeonsi or with_dri_r100 or with_dri_r200 or
- with_gallium_r300 or with_gallium_r600)],
- ['nouveau', (with_gallium_nouveau or with_dri_nouveau)],
+ with_gallium_r300 or with_gallium_r600), true],
+ ['nouveau', (with_gallium_nouveau or with_dri_nouveau), true],
+ ['pvr', with_dri_pvr, false],
]
# VC4 only needs core libdrm support of this version, not a libdrm_vc4
@@ -1553,7 +1556,7 @@ endif
# Then get each libdrm module
foreach d : _libdrm_checks
- if d[1]
+ if d[1] and d[2]
set_variable(
'dep_libdrm_' + d[0],
dependency('libdrm_' + d[0], version : '>=' + _drm_ver)
diff --git a/meson_options.txt b/meson_options.txt
index 29c402c4844..dac791099a1 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -55,7 +55,7 @@ option(
'dri-drivers',
type : 'array',
value : ['auto'],
- choices : ['auto', 'i915', 'i965', 'r100', 'r200', 'nouveau'],
+ choices : ['auto', 'i915', 'i965', 'r100', 'r200', 'nouveau', 'pvr'],
description : 'List of dri drivers to build. If this is set to auto all drivers applicable to the target OS/architecture will be built'
)
option(
diff --git a/src/mesa/drivers/dri/meson.build b/src/mesa/drivers/dri/meson.build
index 239ca962c2a..88a973bb84f 100644
--- a/src/mesa/drivers/dri/meson.build
+++ b/src/mesa/drivers/dri/meson.build
@@ -48,6 +48,11 @@ if with_dri_nouveau
_dri_drivers += libnouveau_vieux
_dri_link += 'nouveau_vieux_dri.so'
endif
+if with_dri_pvr
+ subdir('pvr')
+ _dri_drivers += libpvr
+ _dri_link += 'pvr_dri.so'
+endif
if _dri_drivers != []
libmesa_dri_drivers = shared_library(
diff --git a/src/mesa/drivers/dri/pvr/dri_support.h b/src/mesa/drivers/dri/pvr/dri_support.h
new file mode 100644
index 00000000000..631410438fd
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/dri_support.h
@@ -0,0 +1,581 @@
+/* -*- mode: c; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* vi: set ts=8 sw=8 sts=8: */
+/*************************************************************************/ /*!
+@File
+@Title PVR DRI interface definition
+@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
+@License MIT
+
+The contents of this file are subject to the MIT license as set out below.
+
+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 without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS 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.
+*/ /**************************************************************************/
+
+#if !defined(__PVRDRIIFCE_H__)
+#define __PVRDRIIFCE_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+/* API type. */
+typedef enum
+{
+ PVRDRI_API_NONE = 0,
+ PVRDRI_API_GLES1 = 2,
+ PVRDRI_API_GLES2 = 3,
+ PVRDRI_API_CL = 4,
+ PVRDRI_API_GL_COMPAT = 5,
+ PVRDRI_API_GL_CORE = 6,
+} PVRDRIAPIType;
+
+typedef enum
+{
+ PVRDRI_CONFIG_ATTRIB_INVALID = 0,
+ PVRDRI_CONFIG_ATTRIB_RENDERABLE_TYPE = 1,
+ PVRDRI_CONFIG_ATTRIB_RGB_MODE = 2,
+ PVRDRI_CONFIG_ATTRIB_DOUBLE_BUFFER_MODE = 3,
+ PVRDRI_CONFIG_ATTRIB_RED_BITS = 4,
+ PVRDRI_CONFIG_ATTRIB_GREEN_BITS = 5,
+ PVRDRI_CONFIG_ATTRIB_BLUE_BITS = 6,
+ PVRDRI_CONFIG_ATTRIB_ALPHA_BITS = 7,
+ PVRDRI_CONFIG_ATTRIB_RGB_BITS = 8,
+ PVRDRI_CONFIG_ATTRIB_DEPTH_BITS = 9,
+ PVRDRI_CONFIG_ATTRIB_STENCIL_BITS = 10,
+ PVRDRI_CONFIG_ATTRIB_SAMPLE_BUFFERS = 11,
+ PVRDRI_CONFIG_ATTRIB_SAMPLES = 12,
+ PVRDRI_CONFIG_ATTRIB_BIND_TO_TEXTURE_RGB = 13,
+ PVRDRI_CONFIG_ATTRIB_BIND_TO_TEXTURE_RGBA = 14,
+ PVRDRI_CONFIG_ATTRIB_YUV_ORDER = 15,
+ PVRDRI_CONFIG_ATTRIB_YUV_NUM_OF_PLANES = 16,
+ PVRDRI_CONFIG_ATTRIB_YUV_SUBSAMPLE = 17,
+ PVRDRI_CONFIG_ATTRIB_YUV_DEPTH_RANGE = 18,
+ PVRDRI_CONFIG_ATTRIB_YUV_CSC_STANDARD = 19,
+ PVRDRI_CONFIG_ATTRIB_YUV_PLANE_BPP = 20,
+ PVRDRI_CONFIG_ATTRIB_RED_MASK = 21,
+ PVRDRI_CONFIG_ATTRIB_GREEN_MASK = 22,
+ PVRDRI_CONFIG_ATTRIB_BLUE_MASK = 23,
+ PVRDRI_CONFIG_ATTRIB_ALPHA_MASK = 24,
+ PVRDRI_CONFIG_ATTRIB_SRGB_CAPABLE = 25
+} PVRDRIConfigAttrib;
+
+/* EGL_RENDERABLE_TYPE mask bits */
+#define PVRDRI_API_BIT_GLES 0x0001
+#define PVRDRI_API_BIT_GLES2 0x0004
+#define PVRDRI_API_BIT_GL 0x0008
+#define PVRDRI_API_BIT_GLES3 0x0040
+
+/* Mesa config formats. These need not match their MESA_FORMAT counterparts */
+#define PVRDRI_MESA_FORMAT_NONE 0
+#define PVRDRI_MESA_FORMAT_B8G8R8A8_UNORM 1
+#define PVRDRI_MESA_FORMAT_B8G8R8X8_UNORM 2
+#define PVRDRI_MESA_FORMAT_B5G6R5_UNORM 3
+#define PVRDRI_MESA_FORMAT_R8G8B8A8_UNORM 4
+#define PVRDRI_MESA_FORMAT_R8G8B8X8_UNORM 5
+#define PVRDRI_MESA_FORMAT_YCBCR 6
+#define PVRDRI_MESA_FORMAT_YUV420_2PLANE 7
+#define PVRDRI_MESA_FORMAT_YVU420_2PLANE 8
+#define PVRDRI_MESA_FORMAT_B8G8R8A8_SRGB 9
+#define PVRDRI_MESA_FORMAT_R8G8B8A8_SRGB 10
+
+typedef struct __DRIimageRec __DRIimage;
+
+typedef struct PVRDRIConfigRec PVRDRIConfig;
+
+/* The PVRDRI_GL defines match their EGL_GL counterparts */
+#define PVRDRI_GL_RENDERBUFFER 0x30B9
+#define PVRDRI_GL_TEXTURE_2D 0x30B1
+#define PVRDRI_GL_TEXTURE_3D 0x30B2
+#define PVRDRI_GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x30B3
+#define PVRDRI_GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x30B4
+#define PVRDRI_GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x30B5
+#define PVRDRI_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x30B6
+#define PVRDRI_GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x30B7
+#define PVRDRI_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x30B8
+
+struct __DRIscreenRec;
+struct __DRIcontextRec;
+struct __DRIdrawableRec;
+
+struct __DRIconfigRec;
+
+struct DRISUPScreen;
+struct DRISUPContext;
+struct DRISUPDrawable;
+struct DRISUPBuffer;
+
+struct PVRDRIContextConfig
+{
+ unsigned int uMajorVersion;
+ unsigned int uMinorVersion;
+ uint32_t uFlags;
+
+ int iResetStrategy;
+ unsigned int uPriority;
+ int iReleaseBehavior;
+};
+
+/*
+ * PVR DRI Support interface V2.
+ * This structure may change over time, as older interfaces become obsolete.
+ * For example, the v0 interface may be removed if superseded by newer
+ * interfaces.
+ */
+struct PVRDRISupportInterfaceV2
+{
+ struct
+ {
+ struct DRISUPScreen *(*CreateScreen)
+ (struct __DRIscreenRec *psDRIScreen,
+ int iFD,
+ bool bUseInvalidate,
+ void *pvLoaderPrivate,
+ const struct __DRIconfigRec ***pppsConfigs,
+ int *piMaxGLES1Version,
+ int *piMaxGLES2Version);
+
+ void (*DestroyScreen)
+ (struct DRISUPScreen *psDRISUPScreen);
+
+ unsigned int (*CreateContext)
+ (PVRDRIAPIType eAPI,
+ PVRDRIConfig *psPVRDRIConfig,
+ struct PVRDRIContextConfig *psCtxConfig,
+ struct __DRIcontextRec *psDRIContext,
+ struct DRISUPContext *psDRISUPSharedContext,
+ struct DRISUPScreen *psDRISUPScreen,
+ struct DRISUPContext **ppsDRISUPContext);
+
+ void (*DestroyContext)
+ (struct DRISUPContext *psDRISUPContext);
+
+ struct DRISUPDrawable *(*CreateDrawable)
+ (struct __DRIdrawableRec *psDRIDrawable,
+ struct DRISUPScreen *psDRISUPDrawable,
+ void *pvLoaderPrivate,
+ PVRDRIConfig *psPVRDRIConfig);
+
+ void (*DestroyDrawable)
+ (struct DRISUPDrawable *psDRISUPDrawable);
+
+ bool (*MakeCurrent)
+ (struct DRISUPContext *psDRISUPContext,
+ struct DRISUPDrawable *psDRISUPWrite,
+ struct DRISUPDrawable *psDRISUPRead);
+
+ bool (*UnbindContext)
+ (struct DRISUPContext *psDRISUPContext);
+
+ struct DRISUPBuffer *(*AllocateBuffer)
+ (struct DRISUPScreen *psDRISUPScreen,
+ unsigned int uAttachment,
+ unsigned int uFormat,
+ int iWidth,
+ int iHeight,
+ unsigned int *puName,
+ unsigned int *puPitch,
+ unsigned int *puCPP,
+ unsigned int *puFlags);
+
+ void (*ReleaseBuffer)
+ (struct DRISUPScreen *psDRISUPScreen,
+ struct DRISUPBuffer *psDRISUPBuffer);
+
+ /* Functions to support the DRI TexBuffer extension */
+ void (*SetTexBuffer2)
+ (struct DRISUPContext *psDRISUPContext,
+ int iTarget,
+ int iFormat,
+ struct DRISUPDrawable *psDRISUPDrawable);
+
+ void (*ReleaseTexBuffer)
+ (struct DRISUPContext *psDRISUPContext,
+ int iTarget,
+ struct DRISUPDrawable *psDRISUPDrawable);
+
+ /* Functions to support the DRI Flush extension */
+ void (*Flush)
+ (struct DRISUPDrawable *psDRISUPDrawable);
+
+ void (*Invalidate)
+ (struct DRISUPDrawable *psDRISUPDrawable);
+
+ void (*FlushWithFlags)
+ (struct DRISUPContext *psDRISUPContext,
+ struct DRISUPDrawable *psDRISUPDrawable,
+ unsigned int uFlags,
+ unsigned int uThrottleReason);
+
+ /* Functions to support the DRI Image extension */
+ __DRIimage *(*CreateImageFromName)
+ (struct DRISUPScreen *psDRISUPScreen,
+ int iWidth,
+ int iHeight,
+ int iFourCC,
+ int iName,
+ int iPitch,
+ void *pvLoaderPrivate);
+
+ __DRIimage *(*CreateImageFromRenderbuffer)
+ (struct DRISUPContext *psDRISUPContext,
+ int iRenderBuffer,
+ void *pvLoaderPrivate);
+
+ void (*DestroyImage)
+ (__DRIimage *psImage);
+
+ __DRIimage *(*CreateImage)
+ (struct DRISUPScreen *psDRISUPScreen,
+ int iWidth,
+ int iHeight,
+ int iFourCC,
+ unsigned int uUse,
+ void *pvLoaderPrivate);
+
+ bool (*QueryImage)
+ (__DRIimage *psImage,
+ int iAttrib,
+ int *iValue);
+
+ __DRIimage *(*DupImage)
+ (__DRIimage *psImage,
+ void *pvLoaderPrivate);
+
+ bool (*ValidateImageUsage)
+ (__DRIimage *psImage,
+ unsigned int uUse);
+
+ __DRIimage *(*CreateImageFromNames)
+ (struct DRISUPScreen *psDRISUPScreen,
+ int iWidth,
+ int iHeight,
+ int iFourCC,
+ int *piNames,
+ int iNumNames,
+ int *piStrides,
+ int *piOffsets,
+ void *pvLoaderPrivate);
+ __DRIimage *(*FromPlanar)(__DRIimage *psImage,
+ int iPlane,
+ void *pvLoaderPrivate);
+
+ __DRIimage *(*CreateImageFromTexture)
+ (struct DRISUPContext *psDRISUPContext,
+ int iTarget,
+ unsigned int uTexture,
+ int iDepth,
+ int iLevel,
+ unsigned int *puError,
+ void *pvLoaderPrivate);
+
+ __DRIimage *(*CreateImageFromFDs)
+ (struct DRISUPScreen *psDRISUPcreen,
+ int iWidth,
+ int iHeight,
+ int iFourCC,
+ int *piFDs,
+ int iNumFDs,
+ int *piStrides,
+ int *piOffsets,
+ void *pvLoaderPrivate);
+
+ __DRIimage *(*CreateImageFromDMABufs)
+ (struct DRISUPScreen *psDRISUPScreen,
+ int iWidth,
+ int iHeight,
+ int iFourCC,
+ int *piFDs,
+ int iNumFDs,
+ int *piStrides,
+ int *piOffsets,
+ unsigned int uColorSpace,
+ unsigned int uSampleRange,
+ unsigned int uHorizSiting,
+ unsigned int uVertSiting,
+ unsigned int *puError,
+ void *pvLoaderPrivate);
+
+ int (*GetImageCapabilities)
+ (struct DRISUPScreen *psDRISUPScreen);
+
+ void (*BlitImage)
+ (struct DRISUPContext *psDRISUPContext,
+ __DRIimage *psDst,
+ __DRIimage *psSrc,
+ int iDstX0,
+ int iDstY0,
+ int iDstWidth,
+ int iDstHeight,
+ int iSrcX0, int
+ iSrcY0,
+ int iSrcWidth,
+ int iSrcHeight,
+ int iFlushFlag);
+
+ void *(*MapImage)
+ (struct DRISUPContext *psDRISUPContext,
+ __DRIimage *psImage,
+ int iX0,
+ int iY0,
+ int iWidth,
+ int iHeight,
+ unsigned int uFlags,
+ int *piStride,
+ void **ppvData);
+
+ void (*UnmapImage)
+ (struct DRISUPContext *psDRISUPContext,
+ __DRIimage *psImage,
+ void *pvData);
+
+ __DRIimage *(*CreateImageWithModifiers)
+ (struct DRISUPScreen *psDRISUPScreen,
+ int iWidth,
+ int iHeight,
+ int iFourCC,
+ const uint64_t *puModifiers,
+ const unsigned int uModifierCount,
+ void *pvLoaderPrivate);
+
+ __DRIimage *(*CreateImageFromDMABufs2)
+ (struct DRISUPScreen *psDRISUPScreen,
+ int iWidth,
+ int iHeight,
+ int iFourCC,
+ uint64_t uModifier,
+ int *piFDs,
+ int iNumFDs,
+ int *piStrides,
+ int *piOffsets,
+ unsigned int uColorSpace,
+ unsigned int uSampleRange,
+ unsigned int uHorizSiting,
+ unsigned int uVertSiting,
+ unsigned int *puError,
+ void *pvLoaderPrivate);
+
+ bool (*QueryDMABufFormats)
+ (struct DRISUPScreen *psDRISUPScreen,
+ int iMax,
+ int *piFormats,
+ int *piCount);
+
+ bool (*QueryDMABufModifiers)
+ (struct DRISUPScreen *psDRISUPScreen,
+ int iFourCC,
+ int iMax,
+ uint64_t *puModifiers,
+ unsigned int *piExternalOnly,
+ int *piCount);
+
+ bool (*QueryDMABufFormatModifierAttribs)
+ (struct DRISUPScreen *psDRISUPScreen,
+ uint32_t uFourcc,
+ uint64_t uModifier,
+ int iAttrib,
+ uint64_t *puValue);
+
+ __DRIimage *(*CreateImageFromRenderBuffer2)
+ (struct DRISUPContext *psDRISUPContext,
+ int iRenderBuffer,
+ void *pvLoaderPrivate,
+ unsigned int *puError);
+
+ __DRIimage *(*CreateImageFromBuffer)
+ (struct DRISUPContext *psDRISUPContext,
+ int iTarget,
+ void *pvBuffer,
+ unsigned int *puError,
+ void *pvLoaderPrivate);
+
+ /* Functions to support the DRI Renderer Query extension */
+ int (*QueryRendererInteger)
+ (struct DRISUPScreen *psDRISUPScreen,
+ int iAttribute,
+ unsigned int *puValue);
+
+ int (*QueryRendererString)
+ (struct DRISUPScreen *psDRISUPScreen,
+ int iAttribute,
+ const char **ppszValue);
+
+ /* Functions to support the DRI Fence extension */
+ void *(*CreateFence)
+ (struct DRISUPContext *psDRISUPContext);
+
+ void (*DestroyFence)
+ (struct DRISUPScreen *psDRISUPScreen,
+ void *pvFence);
+
+ bool (*ClientWaitSync)
+ (struct DRISUPContext *psDRISUPContext,
+ void *pvFence,
+ unsigned int uFlags,
+ uint64_t uTimeout);
+
+ void (*ServerWaitSync)
+ (struct DRISUPContext *psDRISUPContext,
+ void *pvFence,
+ unsigned int uFlags);
+
+ unsigned int (*GetFenceCapabilities)
+ (struct DRISUPScreen *psDRISUPScreen);
+
+ void *(*CreateFenceFD)
+ (struct DRISUPContext *psDRISUPContext,
+ int iFD);
+
+ int (*GetFenceFD)
+ (struct DRISUPScreen *psDRISUPScreen,
+ void *pvFence);
+
+ unsigned int (*GetNumAPIProcs)
+ (struct DRISUPScreen *psDRISUPScreen,
+ PVRDRIAPIType eAPI);
+
+ const char *(*GetAPIProcName)
+ (struct DRISUPScreen *psDRISUPScreen,
+ PVRDRIAPIType eAPI,
+ unsigned int uIndex);
+
+ void *(*GetAPIProcAddress)
+ (struct DRISUPScreen *psDRISUPScreen,
+ PVRDRIAPIType eAPI,
+ unsigned int uIndex);
+
+ void (*SetDamageRegion)
+ (struct DRISUPDrawable *psDRISUPDrawable,
+ unsigned int uNRects,
+ int *piRects);
+ } v0;
+ /* The v1 interface is an extension of v0, so v0 is required as well */
+ struct {
+ void *(*GetFenceFromCLEvent)
+ (struct DRISUPScreen *psDRISUPScreen,
+ intptr_t iCLEvent);
+ } v1;
+ /* The v2 interface is an extension of v1, so v1 is required as well */
+ struct {
+ int (*GetAPIVersion)
+ (struct DRISUPScreen *psDRISUPScreen,
+ PVRDRIAPIType eAPI);
+ } v2;
+ /*
+ * The v3 interface has no additional entry points. It indicates that
+ * OpenCL event based fences are available, provided the DDK is built
+ * with OpenCL support.
+ */
+ /* The v4 interface is an extension of v3, so v3 is required as well */
+ struct {
+ bool (*HaveGetFenceFromCLEvent)(void);
+ } v4;
+};
+
+struct PVRDRIImageList {
+ uint32_t uImageMask;
+ __DRIimage *psBack;
+ __DRIimage *psFront;
+ __DRIimage *psPrev;
+};
+
+/*
+ * PVR DRI Support callback interface V2.
+ * This structure may change over time, as older interfaces become obsolete.
+ * For example, the v0 interface may be removed if superseded by newer
+ * interfaces.
+ */
+struct PVRDRICallbacksV2
+{
+ struct {
+ bool (*RegisterSupportInterface)
+ (const void *psInterface,
+ unsigned int uVersion,
+ unsigned int uMinVersion);
+
+ int (*GetBuffers)
+ (struct __DRIdrawableRec *psDRIDrawable,
+ unsigned int uFourCC,
+ uint32_t *puStamp,
+ void *pvLoaderPrivate,
+ uint32_t uBufferMask,
+ struct PVRDRIImageList *psImageList);
+
+ bool (*CreateConfigs)
+ (struct __DRIconfigRec ***pppsConfigs,
+ struct __DRIscreenRec *psDRIScreen,
+ int iPVRDRIMesaFormat,
+ const uint8_t *puDepthBits,
+ const uint8_t *puStencilBits,
+ unsigned int uNumDepthStencilBits,
+ const unsigned int *puDBModes,
+ unsigned int uNumDBModes,
+ const uint8_t *puMSAASamples,
+ unsigned int uNumMSAAModes,
+ bool bEnableAccum,
+ bool bColorDepthMatch,
+ bool bMutableRenderBuffer,
+ int iYUVDepthRange,
+ int iYUVCSCStandard,
+ uint32_t uMaxPbufferWidth,
+ uint32_t uMaxPbufferHeight);
+
+ struct __DRIconfigRec **(*ConcatConfigs)
+ (struct __DRIscreenRec *psDRIScreen,
+ struct __DRIconfigRec **ppsConfigA,
+ struct __DRIconfigRec **ppsConfigB);
+
+ bool (*ConfigQuery)
+ (const PVRDRIConfig *psConfig,
+ PVRDRIConfigAttrib eConfigAttrib,
+ unsigned int *puValueOut);
+
+ __DRIimage *(*LookupEGLImage)
+ (struct __DRIscreenRec *psDRIScreen,
+ void *pvImage,
+ void *pvLoaderPrivate);
+
+ unsigned int (*GetCapability)
+ (struct __DRIscreenRec *psDRIScreen,
+ unsigned int uCapability);
+ } v0;
+ /* The v1 interface is an extension of v0, so v0 is required as well */
+ struct {
+ void (*FlushFrontBuffer)
+ (struct __DRIdrawableRec *psDRIDrawable,
+ void *pvLoaderPrivate);
+ } v1;
+ /* The v2 interface is an extension of v1, so v1 is required as well */
+ struct {
+ int (*GetDisplayFD)
+ (struct __DRIscreenRec *psDRIScreen,
+ void *pvLoaderPrivate);
+ } v2;
+ /* The v3 interface is an extension of v2, so v2 is required as well */
+ struct {
+ void *(*DrawableGetReferenceHandle)
+ (struct __DRIdrawableRec *psDRIDrawable);
+
+ void (*DrawableAddReference)
+ (void *pvReferenceHandle);
+
+ void (*DrawableRemoveReference)
+ (void *pvReferenceHandle);
+ } v3;
+};
+
+#endif /* defined(__PVRDRIIFCE_H__) */
diff --git a/src/mesa/drivers/dri/pvr/img_drm_fourcc.h b/src/mesa/drivers/dri/pvr/img_drm_fourcc.h
new file mode 100644
index 00000000000..8d570ff8f53
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/img_drm_fourcc.h
@@ -0,0 +1,113 @@
+/*************************************************************************/ /*!
+@File
+@Title Wrapper around drm_fourcc.h
+@Description FourCCs and DRM framebuffer modifiers that are not in the
+ Kernel's and libdrm's drm_fourcc.h can be added here.
+@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
+@License MIT
+
+The contents of this file are subject to the MIT license as set out below.
+
+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 without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS 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.
+*/ /**************************************************************************/
+
+#ifndef IMG_DRM_FOURCC_H
+#define IMG_DRM_FOURCC_H
+
+#if defined(__KERNEL__)
+#include <drm/drm_fourcc.h>
+#else
+/*
+ * Include types.h to workaround versions of libdrm older than 2.4.68
+ * not including the correct headers.
+ */
+#include <linux/types.h>
+
+#include <drm_fourcc.h>
+#endif
+
+/*
+ * Don't get too inspired by this example :)
+ * ADF doesn't support DRM modifiers, so the memory layout had to be
+ * included in the fourcc name, but the proper way to specify information
+ * additional to pixel formats is to use DRM modifiers.
+ *
+ * See upstream drm_fourcc.h for the proper naming convention.
+ */
+#ifndef DRM_FORMAT_BGRA8888_DIRECT_16x4
+#define DRM_FORMAT_BGRA8888_DIRECT_16x4 fourcc_code('I', 'M', 'G', '0')
+#endif
+
+/*
+ * Upstream doesn't have a floating point format yet, so let's make one
+ * up.
+ * Note: The kernel's core DRM needs to know about this format,
+ * otherwise it won't be supported and should not be exposed by our
+ * kernel modules either.
+ * Refer to the provided kernel patch adding this format.
+ */
+#if !defined(__KERNEL__)
+#define DRM_FORMAT_ABGR16_IMG fourcc_code('I', 'M', 'G', '1')
+#endif
+
+/*
+ * Upstream does not have a packed 10 Bits Per Channel YVU format yet,
+ * so let`s make one up.
+ * Note: at the moment this format is not intended to be used with
+ * a framebuffer, so the kernels core DRM doesn`t need to know
+ * about this format. This means that the kernel doesn`t need
+ * to be patched.
+ */
+#if !defined(__KERNEL__)
+#define DRM_FORMAT_YVU444_PACK10_IMG fourcc_code('I', 'M', 'G', '2')
+#define DRM_FORMAT_YUV422_2PLANE_PACK10_IMG fourcc_code('I', 'M', 'G', '3')
+#define DRM_FORMAT_YUV420_2PLANE_PACK10_IMG fourcc_code('I', 'M', 'G', '4')
+#endif
+
+/*
+ * Value chosen in the middle of 255 pool to minimise the chance of hitting
+ * the same value potentially defined by other vendors in the drm_fourcc.h
+ */
+#define DRM_FORMAT_MOD_VENDOR_PVR 0x92
+
+#ifndef DRM_FORMAT_MOD_VENDOR_NONE
+#define DRM_FORMAT_MOD_VENDOR_NONE 0
+#endif
+
+#ifndef DRM_FORMAT_RESERVED
+#define DRM_FORMAT_RESERVED ((1ULL << 56) - 1)
+#endif
+
+#ifndef fourcc_mod_code
+#define fourcc_mod_code(vendor, val) \
+ ((((__u64)DRM_FORMAT_MOD_VENDOR_## vendor) << 56) | (val & 0x00ffffffffffffffULL))
+#endif
+
+#ifndef DRM_FORMAT_MOD_INVALID
+#define DRM_FORMAT_MOD_INVALID fourcc_mod_code(NONE, DRM_FORMAT_RESERVED)
+#endif
+
+#ifndef DRM_FORMAT_MOD_LINEAR
+#define DRM_FORMAT_MOD_LINEAR fourcc_mod_code(NONE, 0)
+#endif
+
+#define DRM_FORMAT_MOD_PVR_FBCDC_8x8_V7 fourcc_mod_code(PVR, 6)
+#define DRM_FORMAT_MOD_PVR_FBCDC_16x4_V7 fourcc_mod_code(PVR, 12)
+
+#endif /* IMG_DRM_FOURCC_H */
diff --git a/src/mesa/drivers/dri/pvr/imgpixfmts.h b/src/mesa/drivers/dri/pvr/imgpixfmts.h
new file mode 100644
index 00000000000..da12a0fb5f6
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/imgpixfmts.h
@@ -0,0 +1,307 @@
+/*************************************************************************/ /*!
+@File imgpixfmts.h
+@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
+@License MIT
+
+The contents of this file are subject to the MIT license as set out below.
+
+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 without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS 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.
+*/ /**************************************************************************/
+
+/******************************************************************************
+ **
+ ** WARNING: File is autogenerated by parsesystable.py - DO NOT EDIT.
+ ** Use fmts_systable.txt to add new formats.
+ **
+ *****************************************************************************/
+
+#if !defined(IMGPIXFMTS_H)
+#define IMGPIXFMTS_H
+
+typedef enum _IMG_PIXFMT_
+{
+ IMG_PIXFMT_UNKNOWN = 0,
+ IMG_PIXFMT_RESERVED_1 = 1,
+ IMG_PIXFMT_RESERVED_2 = 2,
+ IMG_PIXFMT_RESERVED_3 = 3,
+ IMG_PIXFMT_RESERVED_4 = 4,
+ IMG_PIXFMT_RESERVED_5 = 5,
+ IMG_PIXFMT_RESERVED_6 = 6,
+ IMG_PIXFMT_RESERVED_7 = 7,
+ IMG_PIXFMT_RESERVED_8 = 8,
+ IMG_PIXFMT_RESERVED_9 = 9,
+ IMG_PIXFMT_RESERVED_10 = 10,
+ IMG_PIXFMT_RESERVED_11 = 11,
+ IMG_PIXFMT_RESERVED_12 = 12,
+ IMG_PIXFMT_RESERVED_13 = 13,
+ IMG_PIXFMT_RESERVED_14 = 14,
+ IMG_PIXFMT_RESERVED_15 = 15,
+ IMG_PIXFMT_RESERVED_16 = 16,
+ IMG_PIXFMT_RESERVED_17 = 17,
+ IMG_PIXFMT_RESERVED_18 = 18,
+ IMG_PIXFMT_RESERVED_19 = 19,
+ IMG_PIXFMT_RESERVED_20 = 20,
+ IMG_PIXFMT_RESERVED_21 = 21,
+ IMG_PIXFMT_RESERVED_22 = 22,
+ IMG_PIXFMT_RESERVED_23 = 23,
+ IMG_PIXFMT_RESERVED_24 = 24,
+ IMG_PIXFMT_R10G10B10A2_UNORM = 25,
+ IMG_PIXFMT_RESERVED_26 = 26,
+ IMG_PIXFMT_RESERVED_27 = 27,
+ IMG_PIXFMT_B10G10R10A2_UNORM = 28,
+ IMG_PIXFMT_RESERVED_29 = 29,
+ IMG_PIXFMT_RESERVED_30 = 30,
+ IMG_PIXFMT_RESERVED_31 = 31,
+ IMG_PIXFMT_R8G8B8A8_UNORM = 32,
+ IMG_PIXFMT_R8G8B8A8_UNORM_SRGB = 33,
+ IMG_PIXFMT_RESERVED_34 = 34,
+ IMG_PIXFMT_RESERVED_35 = 35,
+ IMG_PIXFMT_RESERVED_36 = 36,
+ IMG_PIXFMT_R8G8B8X8_UNORM = 37,
+ IMG_PIXFMT_RESERVED_38 = 38,
+ IMG_PIXFMT_RESERVED_39 = 39,
+ IMG_PIXFMT_RESERVED_40 = 40,
+ IMG_PIXFMT_RESERVED_41 = 41,
+ IMG_PIXFMT_RESERVED_42 = 42,
+ IMG_PIXFMT_RESERVED_43 = 43,
+ IMG_PIXFMT_RESERVED_44 = 44,
+ IMG_PIXFMT_RESERVED_45 = 45,
+ IMG_PIXFMT_RESERVED_46 = 46,
+ IMG_PIXFMT_RESERVED_47 = 47,
+ IMG_PIXFMT_RESERVED_48 = 48,
+ IMG_PIXFMT_RESERVED_49 = 49,
+ IMG_PIXFMT_RESERVED_50 = 50,
+ IMG_PIXFMT_D32_FLOAT = 51,
+ IMG_PIXFMT_RESERVED_52 = 52,
+ IMG_PIXFMT_RESERVED_53 = 53,
+ IMG_PIXFMT_RESERVED_54 = 54,
+ IMG_PIXFMT_RESERVED_55 = 55,
+ IMG_PIXFMT_RESERVED_56 = 56,
+ IMG_PIXFMT_RESERVED_57 = 57,
+ IMG_PIXFMT_D24_UNORM_X8_TYPELESS = 58,
+ IMG_PIXFMT_RESERVED_59 = 59,
+ IMG_PIXFMT_RESERVED_60 = 60,
+ IMG_PIXFMT_RESERVED_61 = 61,
+ IMG_PIXFMT_R8G8_UNORM = 62,
+ IMG_PIXFMT_RESERVED_63 = 63,
+ IMG_PIXFMT_RESERVED_64 = 64,
+ IMG_PIXFMT_RESERVED_65 = 65,
+ IMG_PIXFMT_RESERVED_66 = 66,
+ IMG_PIXFMT_RESERVED_67 = 67,
+ IMG_PIXFMT_RESERVED_68 = 68,
+ IMG_PIXFMT_D16_UNORM = 69,
+ IMG_PIXFMT_RESERVED_70 = 70,
+ IMG_PIXFMT_RESERVED_71 = 71,
+ IMG_PIXFMT_RESERVED_72 = 72,
+ IMG_PIXFMT_RESERVED_73 = 73,
+ IMG_PIXFMT_RESERVED_74 = 74,
+ IMG_PIXFMT_RESERVED_75 = 75,
+ IMG_PIXFMT_R8_UNORM = 76,
+ IMG_PIXFMT_RESERVED_77 = 77,
+ IMG_PIXFMT_RESERVED_78 = 78,
+ IMG_PIXFMT_RESERVED_79 = 79,
+ IMG_PIXFMT_RESERVED_80 = 80,
+ IMG_PIXFMT_S8_UINT = 81,
+ IMG_PIXFMT_RESERVED_82 = 82,
+ IMG_PIXFMT_RESERVED_83 = 83,
+ IMG_PIXFMT_RESERVED_84 = 84,
+ IMG_PIXFMT_B5G6R5_UNORM = 85,
+ IMG_PIXFMT_R5G6B5_UNORM = 86,
+ IMG_PIXFMT_B5G5R5A1_UNORM = 87,
+ IMG_PIXFMT_B5G5R5X1_UNORM = 88,
+ IMG_PIXFMT_B8G8R8A8_UNORM = 89,
+ IMG_PIXFMT_B8G8R8X8_UNORM = 90,
+ IMG_PIXFMT_B8G8R8A8_UINT = 91,
+ IMG_PIXFMT_B8G8R8A8_SNORM = 92,
+ IMG_PIXFMT_B8G8R8A8_SINT = 93,
+ IMG_PIXFMT_B8G8R8A8_UNORM_SRGB = 94,
+ IMG_PIXFMT_RESERVED_95 = 95,
+ IMG_PIXFMT_RESERVED_96 = 96,
+ IMG_PIXFMT_RESERVED_97 = 97,
+ IMG_PIXFMT_RESERVED_98 = 98,
+ IMG_PIXFMT_RESERVED_99 = 99,
+ IMG_PIXFMT_RESERVED_100 = 100,
+ IMG_PIXFMT_RESERVED_101 = 101,
+ IMG_PIXFMT_RESERVED_102 = 102,
+ IMG_PIXFMT_RESERVED_103 = 103,
+ IMG_PIXFMT_RESERVED_104 = 104,
+ IMG_PIXFMT_RESERVED_105 = 105,
+ IMG_PIXFMT_RESERVED_106 = 106,
+ IMG_PIXFMT_RESERVED_107 = 107,
+ IMG_PIXFMT_RESERVED_108 = 108,
+ IMG_PIXFMT_RESERVED_109 = 109,
+ IMG_PIXFMT_RESERVED_110 = 110,
+ IMG_PIXFMT_RESERVED_111 = 111,
+ IMG_PIXFMT_RESERVED_112 = 112,
+ IMG_PIXFMT_RESERVED_113 = 113,
+ IMG_PIXFMT_RESERVED_114 = 114,
+ IMG_PIXFMT_RESERVED_115 = 115,
+ IMG_PIXFMT_RESERVED_116 = 116,
+ IMG_PIXFMT_RESERVED_117 = 117,
+ IMG_PIXFMT_RESERVED_118 = 118,
+ IMG_PIXFMT_RESERVED_119 = 119,
+ IMG_PIXFMT_RESERVED_120 = 120,
+ IMG_PIXFMT_RESERVED_121 = 121,
+ IMG_PIXFMT_RESERVED_122 = 122,
+ IMG_PIXFMT_RESERVED_123 = 123,
+ IMG_PIXFMT_RESERVED_124 = 124,
+ IMG_PIXFMT_RESERVED_125 = 125,
+ IMG_PIXFMT_RESERVED_126 = 126,
+ IMG_PIXFMT_RESERVED_127 = 127,
+ IMG_PIXFMT_RESERVED_128 = 128,
+ IMG_PIXFMT_RESERVED_129 = 129,
+ IMG_PIXFMT_RESERVED_130 = 130,
+ IMG_PIXFMT_RESERVED_131 = 131,
+ IMG_PIXFMT_RESERVED_132 = 132,
+ IMG_PIXFMT_RESERVED_133 = 133,
+ IMG_PIXFMT_RESERVED_134 = 134,
+ IMG_PIXFMT_RESERVED_135 = 135,
+ IMG_PIXFMT_L8_UNORM = 136,
+ IMG_PIXFMT_RESERVED_137 = 137,
+ IMG_PIXFMT_L8A8_UNORM = 138,
+ IMG_PIXFMT_RESERVED_139 = 139,
+ IMG_PIXFMT_RESERVED_140 = 140,
+ IMG_PIXFMT_RESERVED_141 = 141,
+ IMG_PIXFMT_RESERVED_142 = 142,
+ IMG_PIXFMT_RESERVED_143 = 143,
+ IMG_PIXFMT_RESERVED_144 = 144,
+ IMG_PIXFMT_B4G4R4A4_UNORM = 145,
+ IMG_PIXFMT_RESERVED_146 = 146,
+ IMG_PIXFMT_RESERVED_147 = 147,
+ IMG_PIXFMT_RESERVED_148 = 148,
+ IMG_PIXFMT_RESERVED_149 = 149,
+ IMG_PIXFMT_RESERVED_150 = 150,
+ IMG_PIXFMT_RESERVED_151 = 151,
+ IMG_PIXFMT_RESERVED_152 = 152,
+ IMG_PIXFMT_RESERVED_153 = 153,
+ IMG_PIXFMT_RESERVED_154 = 154,
+ IMG_PIXFMT_RESERVED_155 = 155,
+ IMG_PIXFMT_RESERVED_156 = 156,
+ IMG_PIXFMT_RESERVED_157 = 157,
+ IMG_PIXFMT_RESERVED_158 = 158,
+ IMG_PIXFMT_RESERVED_159 = 159,
+ IMG_PIXFMT_R8G8B8_UNORM = 160,
+ IMG_PIXFMT_R8G8B8_UNORM_SRGB = 161,
+ IMG_PIXFMT_RESERVED_162 = 162,
+ IMG_PIXFMT_RESERVED_163 = 163,
+ IMG_PIXFMT_RESERVED_164 = 164,
+ IMG_PIXFMT_RESERVED_165 = 165,
+ IMG_PIXFMT_RESERVED_166 = 166,
+ IMG_PIXFMT_RESERVED_167 = 167,
+ IMG_PIXFMT_RESERVED_168 = 168,
+ IMG_PIXFMT_RESERVED_169 = 169,
+ IMG_PIXFMT_RESERVED_170 = 170,
+ IMG_PIXFMT_UYVY = 171,
+ IMG_PIXFMT_VYUY = 172,
+ IMG_PIXFMT_YUYV = 173,
+ IMG_PIXFMT_YVYU = 174,
+ IMG_PIXFMT_YVU420_2PLANE = 175,
+ IMG_PIXFMT_YUV420_2PLANE = 176,
+ IMG_PIXFMT_YVU420_2PLANE_MACRO_BLOCK = 177,
+ IMG_PIXFMT_YUV420_3PLANE = 178,
+ IMG_PIXFMT_YVU420_3PLANE = 179,
+ IMG_PIXFMT_RESERVED_180 = 180,
+ IMG_PIXFMT_RESERVED_181 = 181,
+ IMG_PIXFMT_RESERVED_182 = 182,
+ IMG_PIXFMT_RESERVED_183 = 183,
+ IMG_PIXFMT_RESERVED_184 = 184,
+ IMG_PIXFMT_RESERVED_185 = 185,
+ IMG_PIXFMT_RESERVED_186 = 186,
+ IMG_PIXFMT_RESERVED_187 = 187,
+ IMG_PIXFMT_RESERVED_188 = 188,
+ IMG_PIXFMT_RESERVED_189 = 189,
+ IMG_PIXFMT_RESERVED_190 = 190,
+ IMG_PIXFMT_RESERVED_191 = 191,
+ IMG_PIXFMT_RESERVED_192 = 192,
+ IMG_PIXFMT_RESERVED_193 = 193,
+ IMG_PIXFMT_RESERVED_194 = 194,
+ IMG_PIXFMT_RESERVED_195 = 195,
+ IMG_PIXFMT_RESERVED_196 = 196,
+ IMG_PIXFMT_RESERVED_197 = 197,
+ IMG_PIXFMT_RESERVED_198 = 198,
+ IMG_PIXFMT_RESERVED_199 = 199,
+ IMG_PIXFMT_RESERVED_200 = 200,
+ IMG_PIXFMT_YVU8_422_2PLANE_PACK8 = 201,
+ IMG_PIXFMT_RESERVED_202 = 202,
+ IMG_PIXFMT_YVU10_444_1PLANE_PACK10 = 203,
+ IMG_PIXFMT_RESERVED_204 = 204,
+ IMG_PIXFMT_RESERVED_205 = 205,
+ IMG_PIXFMT_RESERVED_206 = 206,
+ IMG_PIXFMT_YUV8_422_2PLANE_PACK8 = 207,
+ IMG_PIXFMT_YUV8_444_3PLANE_PACK8 = 208,
+ IMG_PIXFMT_RESERVED_209 = 209,
+ IMG_PIXFMT_RESERVED_210 = 210,
+ IMG_PIXFMT_RESERVED_211 = 211,
+ IMG_PIXFMT_RESERVED_212 = 212,
+ IMG_PIXFMT_RESERVED_213 = 213,
+ IMG_PIXFMT_RESERVED_214 = 214,
+ IMG_PIXFMT_RESERVED_215 = 215,
+ IMG_PIXFMT_RESERVED_216 = 216,
+ IMG_PIXFMT_RESERVED_217 = 217,
+ IMG_PIXFMT_RESERVED_218 = 218,
+ IMG_PIXFMT_RESERVED_219 = 219,
+ IMG_PIXFMT_RESERVED_220 = 220,
+ IMG_PIXFMT_RESERVED_221 = 221,
+ IMG_PIXFMT_RESERVED_222 = 222,
+ IMG_PIXFMT_RESERVED_223 = 223,
+ IMG_PIXFMT_RESERVED_224 = 224,
+ IMG_PIXFMT_RESERVED_225 = 225,
+ IMG_PIXFMT_RESERVED_226 = 226,
+ IMG_PIXFMT_RESERVED_227 = 227,
+ IMG_PIXFMT_RESERVED_228 = 228,
+ IMG_PIXFMT_RESERVED_229 = 229,
+ IMG_PIXFMT_RESERVED_230 = 230,
+ IMG_PIXFMT_RESERVED_231 = 231,
+ IMG_PIXFMT_RESERVED_232 = 232,
+ IMG_PIXFMT_RESERVED_233 = 233,
+ IMG_PIXFMT_RESERVED_234 = 234,
+ IMG_PIXFMT_RESERVED_235 = 235,
+ IMG_PIXFMT_RESERVED_236 = 236,
+ IMG_PIXFMT_RESERVED_237 = 237,
+ IMG_PIXFMT_RESERVED_238 = 238,
+ IMG_PIXFMT_RESERVED_239 = 239,
+ IMG_PIXFMT_RESERVED_240 = 240,
+ IMG_PIXFMT_RESERVED_241 = 241,
+ IMG_PIXFMT_RESERVED_242 = 242,
+ IMG_PIXFMT_RESERVED_243 = 243,
+ IMG_PIXFMT_RESERVED_244 = 244,
+ IMG_PIXFMT_YVU8_420_2PLANE_PACK8_P = 245,
+ IMG_PIXFMT_RESERVED_246 = 246,
+ IMG_PIXFMT_RESERVED_247 = 247,
+ IMG_PIXFMT_RESERVED_248 = 248,
+ IMG_PIXFMT_YUV8_420_2PLANE_PACK8_P = 249,
+ IMG_PIXFMT_RESERVED_250 = 250,
+ IMG_PIXFMT_RESERVED_251 = 251,
+ IMG_PIXFMT_UYVY10_422_1PLANE_PACK10_CUST1 = 252,
+ IMG_PIXFMT_RESERVED_253 = 253,
+ IMG_PIXFMT_RESERVED_254 = 254,
+ IMG_PIXFMT_RESERVED_255 = 255,
+ IMG_PIXFMT_RESERVED_256 = 256,
+ IMG_PIXFMT_RESERVED_257 = 257,
+ IMG_PIXFMT_RESERVED_258 = 258,
+ IMG_PIXFMT_RESERVED_259 = 259,
+ IMG_PIXFMT_RESERVED_260 = 260,
+ IMG_PIXFMT_RESERVED_261 = 261,
+ IMG_PIXFMT_RESERVED_262 = 262,
+ IMG_PIXFMT_RESERVED_263 = 263,
+ IMG_PIXFMT_RESERVED_264 = 264,
+#define IMG_PIXFMT_ENUM_COUNT 265
+} IMG_PIXFMT;
+
+#endif /* IMGPIXFMTS_H */
diff --git a/src/mesa/drivers/dri/pvr/imgyuv.h b/src/mesa/drivers/dri/pvr/imgyuv.h
new file mode 100644
index 00000000000..7ae8fd19ac0
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/imgyuv.h
@@ -0,0 +1,58 @@
+/*************************************************************************/ /*!
+@File
+@Title YUV defines
+@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
+@License MIT
+
+The contents of this file are subject to the MIT license as set out below.
+
+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 without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS 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.
+*/ /**************************************************************************/
+
+#if !defined(IMGYUV_H)
+#define IMGYUV_H
+
+typedef enum
+{
+ IMG_COLORSPACE_UNDEFINED = 0,
+ IMG_COLORSPACE_BT601_CONFORMANT_RANGE = 1,
+ IMG_COLORSPACE_BT601_FULL_RANGE = 2,
+ IMG_COLORSPACE_BT709_CONFORMANT_RANGE = 3,
+ IMG_COLORSPACE_BT709_FULL_RANGE = 4,
+ IMG_COLORSPACE_BT2020_CONFORMANT_RANGE = 5,
+ IMG_COLORSPACE_BT2020_FULL_RANGE = 6,
+ IMG_COLORSPACE_BT601_CONFORMANT_RANGE_INVERSE = 7,
+ IMG_COLORSPACE_BT601_FULL_RANGE_INVERSE = 8,
+ IMG_COLORSPACE_BT709_CONFORMANT_RANGE_INVERSE = 9,
+ IMG_COLORSPACE_BT709_FULL_RANGE_INVERSE = 10,
+ IMG_COLORSPACE_BT2020_CONFORMANT_RANGE_INVERSE = 11,
+ IMG_COLORSPACE_BT2020_FULL_RANGE_INVERSE = 12
+} IMG_YUV_COLORSPACE;
+
+typedef enum
+{
+ IMG_CHROMA_INTERP_UNDEFINED = 0,
+ IMG_CHROMA_INTERP_ZERO = 1,
+ IMG_CHROMA_INTERP_QUARTER = 2,
+ IMG_CHROMA_INTERP_HALF = 3,
+ IMG_CHROMA_INTERP_THREEQUARTERS = 4
+} IMG_YUV_CHROMA_INTERP;
+
+
+#endif /* IMGYUV_H */
diff --git a/src/mesa/drivers/dri/pvr/mesa_context.c b/src/mesa/drivers/dri/pvr/mesa_context.c
new file mode 100644
index 00000000000..d36bae5ac54
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/mesa_context.c
@@ -0,0 +1,208 @@
+/**
+ * \file context.c
+ * Mesa context/visual/framebuffer management functions.
+ * \author Brian Paul
+ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version: 7.1
+ *
+ * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
+ *
+ * The contents of this file are subject to the MIT license as set out below.
+ *
+ * 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 without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS 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 <stdlib.h>
+#include <assert.h>
+
+#include "main/version.h"
+#include "main/errors.h"
+
+#include "dri_support.h"
+#include "dri_util.h"
+#include "glapi.h"
+#include "dispatch.h"
+#include "pvrmesa.h"
+
+/**
+ * This is the default function we plug into all dispatch table slots This
+ * helps prevents a segfault when someone calls a GL function without first
+ * checking if the extension is supported.
+ */
+static int
+generic_nop(void)
+{
+ _mesa_warning(NULL, "User called no-op dispatch function (an unsupported extension function?)");
+
+ return 0;
+}
+
+/**
+ * Allocate and initialise a new dispatch table.
+ */
+static struct _glapi_table *
+pvrdri_alloc_dispatch_table(void)
+{
+ unsigned int numEntries = _glapi_get_dispatch_table_size();
+ _glapi_proc *table;
+
+ table = malloc(numEntries * sizeof(_glapi_proc));
+ if (table)
+ for (unsigned int i = 0; i < numEntries; i++)
+ table[i] = (_glapi_proc) generic_nop;
+
+ return (struct _glapi_table *) table;
+}
+
+/**
+ * Return a pointer to the pointer to the dispatch table of an API in
+ * PVRDRIScreen.
+ */
+static struct _glapi_table **
+pvrdri_get_dispatch_table_ptr(PVRDRIScreen *psPVRScreen, PVRDRIAPIType eAPI)
+{
+ switch (eAPI) {
+ case PVRDRI_API_GLES1:
+ return &psPVRScreen->psOGLES1Dispatch;
+ case PVRDRI_API_GLES2:
+ return &psPVRScreen->psOGLES2Dispatch;
+ case PVRDRI_API_GL_COMPAT:
+ case PVRDRI_API_GL_CORE:
+ return &psPVRScreen->psOGLDispatch;
+ default:
+ return NULL;
+ }
+}
+
+/**
+ * Return a pointer to the dispatch table of an API.
+ */
+static struct _glapi_table *
+pvrdri_get_dispatch_table(PVRDRIScreen *psPVRScreen, PVRDRIAPIType eAPI)
+{
+ struct _glapi_table **ppsTable =
+ pvrdri_get_dispatch_table_ptr(psPVRScreen, eAPI);
+
+ return ppsTable ? *ppsTable : NULL;
+}
+
+/**
+ * Free all dispatch tables.
+ */
+void
+pvrdri_free_dispatch_tables(PVRDRIScreen *psPVRScreen)
+{
+ if (psPVRScreen->psOGLES1Dispatch != NULL) {
+ free(psPVRScreen->psOGLES1Dispatch);
+ psPVRScreen->psOGLES1Dispatch = NULL;
+ }
+
+ if (psPVRScreen->psOGLES2Dispatch != NULL) {
+ free(psPVRScreen->psOGLES2Dispatch);
+ psPVRScreen->psOGLES2Dispatch = NULL;
+ }
+
+ if (psPVRScreen->psOGLDispatch != NULL) {
+ free(psPVRScreen->psOGLDispatch);
+ psPVRScreen->psOGLDispatch = NULL;
+ }
+}
+
+static void
+pvrdri_add_mesa_dispatch(struct _glapi_table *psTable, PVRDRIAPIType eAPI,
+ struct DRISUPScreen *psDRISUPScreen,
+ unsigned int uIdx)
+{
+ const char *asFunc[] = { NULL, NULL };
+ int iOffset;
+ const char *psFunc;
+ _glapi_proc pfFunc;
+
+ pfFunc = DRISUPGetAPIProcAddress(psDRISUPScreen, eAPI, uIdx);
+ if (pfFunc == NULL)
+ return;
+
+ psFunc = DRISUPGetAPIProcName(psDRISUPScreen, eAPI, uIdx);
+ assert(psFunc != NULL);
+
+ asFunc[0] = psFunc;
+ iOffset = _glapi_add_dispatch(asFunc, "");
+ if (iOffset == -1) {
+ _mesa_warning(NULL, "Couldn't add %s to the Mesa dispatch table",
+ psFunc);
+ } else {
+ SET_by_offset(psTable, iOffset, pfFunc);
+ }
+}
+
+static void
+pvrdri_set_mesa_dispatch(struct _glapi_table *psTable, PVRDRIAPIType eAPI,
+ struct DRISUPScreen *psDRISUPScreen,
+ unsigned int uNumFuncs)
+{
+ for (unsigned int i = 0; i < uNumFuncs; i++)
+ pvrdri_add_mesa_dispatch(psTable, eAPI, psDRISUPScreen, i);
+}
+
+bool
+pvrdri_create_dispatch_table(PVRDRIScreen *psPVRScreen, PVRDRIAPIType eAPI)
+{
+ struct DRISUPScreen *psDRISUPScreen = psPVRScreen->psDRISUPScreen;
+ struct _glapi_table **ppsTable;
+ unsigned int uNumFuncs;
+
+ ppsTable = pvrdri_get_dispatch_table_ptr(psPVRScreen, eAPI);
+ if (ppsTable == NULL)
+ return false;
+
+ if (*ppsTable != NULL)
+ return true;
+
+ uNumFuncs = DRISUPGetNumAPIProcs(psDRISUPScreen, eAPI);
+ if (!uNumFuncs)
+ return false;
+
+ *ppsTable = pvrdri_alloc_dispatch_table();
+ if (*ppsTable == NULL)
+ return false;
+
+ pvrdri_set_mesa_dispatch(*ppsTable, eAPI, psDRISUPScreen, uNumFuncs);
+
+ return true;
+}
+
+void
+pvrdri_set_null_dispatch_table(void)
+{
+ _glapi_set_dispatch(NULL);
+}
+
+void
+pvrdri_set_dispatch_table(PVRDRIContext *psPVRContext)
+{
+ struct _glapi_table *psTable;
+
+ psTable = pvrdri_get_dispatch_table(psPVRContext->psPVRScreen,
+ psPVRContext->eAPI);
+
+ _glapi_set_dispatch(psTable);
+}
diff --git a/src/mesa/drivers/dri/pvr/meson.build b/src/mesa/drivers/dri/pvr/meson.build
new file mode 100644
index 00000000000..59cccf8add4
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/meson.build
@@ -0,0 +1,48 @@
+# Copyright (c) Imagination Technologies Ltd.
+#
+# The contents of this file are subject to the MIT license as set out below.
+#
+# 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 without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS 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.
+
+files_pvr = files(
+ 'mesa_context.c',
+ 'pvrcb.c',
+ 'pvrcompat.c',
+ 'pvrdri.c',
+ 'pvrext.c',
+ 'pvrutil.c',
+)
+
+dep_libpvr = [
+ dep_libdrm,
+]
+
+if with_platform_tizen
+ dep_libpvr += dep_dlog
+endif
+
+libpvr = static_library(
+ 'pvr',
+ [files_pvr, main_dispatch_h],
+ include_directories : [inc_include, inc_src, inc_mapi, inc_mesa,
+ inc_dri_common, inc_util, inc_pvr],
+ c_args : [no_override_init_args],
+ gnu_symbol_visibility : 'hidden',
+ dependencies : [dep_libpvr],
+)
diff --git a/src/mesa/drivers/dri/pvr/pvrcb.c b/src/mesa/drivers/dri/pvr/pvrcb.c
new file mode 100644
index 00000000000..ea8911c64d5
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrcb.c
@@ -0,0 +1,328 @@
+/*
+ * Copyright (c) Imagination Technologies Ltd.
+ *
+ * The contents of this file are subject to the MIT license as set out below.
+ *
+ * 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 without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS 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 <assert.h>
+
+#include "utils.h"
+#include "pvrdri.h"
+
+int
+MODSUPGetBuffers(__DRIdrawable *psDRIDrawable, unsigned int uFourCC,
+ uint32_t *puStamp, void *pvLoaderPrivate,
+ uint32_t uBufferMask, struct PVRDRIImageList *psImageList)
+{
+ PVRDRIDrawable *psPVRDrawable = psDRIDrawable->driverPrivate;
+ __DRIscreen *psDRIScreen = psDRIDrawable->driScreenPriv;
+ struct __DRIimageList sDRIList;
+ int res;
+
+#if !defined(DRI_IMAGE_HAS_BUFFER_PREV)
+ uBufferMask &= ~PVRDRI_IMAGE_BUFFER_PREV;
+#endif
+
+ if (psPVRDrawable->uFourCC != uFourCC) {
+ psPVRDrawable->uDRIFormat = PVRDRIFourCCToDRIFormat(uFourCC);
+ psPVRDrawable->uFourCC = uFourCC;
+ }
+
+ res = psDRIScreen->image.loader->getBuffers(psDRIDrawable,
+ psPVRDrawable->uDRIFormat,
+ puStamp,
+ pvLoaderPrivate,
+ uBufferMask, &sDRIList);
+
+ if (res) {
+ psImageList->uImageMask = sDRIList.image_mask;
+ psImageList->psBack = sDRIList.back;
+ psImageList->psFront = sDRIList.front;
+ psImageList->psPrev = sDRIList.prev;
+ }
+
+ return res;
+}
+
+bool
+MODSUPCreateConfigs(__DRIconfig ***pppsConfigs, __DRIscreen *psDRIScreen,
+ int iPVRDRIMesaFormat, const uint8_t *puDepthBits,
+ const uint8_t *puStencilBits,
+ unsigned int uNumDepthStencilBits,
+ const unsigned int *puDBModes, unsigned int uNumDBModes,
+ const uint8_t *puMSAASamples, unsigned int uNumMSAAModes,
+ bool bEnableAccum, bool bColorDepthMatch,
+ UNUSED bool bMutableRenderBuffer,
+ int iYUVDepthRange, int iYUVCSCStandard,
+ uint32_t uMaxPbufferWidth, uint32_t uMaxPbufferHeight)
+{
+ __DRIconfig **ppsConfigs;
+ mesa_format eFormat = PVRDRIMesaFormatToMesaFormat(iPVRDRIMesaFormat);
+ unsigned int i;
+
+ (void) psDRIScreen;
+
+ switch (eFormat) {
+ case MESA_FORMAT_NONE:
+ __driUtilMessage("%s: Unknown PVR DRI format: %u",
+ __func__, iPVRDRIMesaFormat);
+ return false;
+ default:
+ break;
+ }
+
+ /*
+ * The double buffered modes array argument for driCreateConfigs has
+ * entries of type GLenum.
+ */
+ static_assert(sizeof(GLenum) == sizeof(unsigned int),
+ "Size mismatch between GLenum and unsigned int");
+
+ ppsConfigs = driCreateConfigs(eFormat, puDepthBits, puStencilBits,
+ uNumDepthStencilBits, (GLenum *) puDBModes,
+ uNumDBModes, puMSAASamples, uNumMSAAModes,
+ bEnableAccum, bColorDepthMatch,
+ iYUVDepthRange, iYUVCSCStandard);
+ if (!ppsConfigs)
+ return false;
+
+ for (i = 0; ppsConfigs[i]; i++) {
+ ppsConfigs[i]->modes.maxPbufferWidth = uMaxPbufferWidth;
+ ppsConfigs[i]->modes.maxPbufferHeight = uMaxPbufferHeight;
+ ppsConfigs[i]->modes.maxPbufferPixels =
+ uMaxPbufferWidth * uMaxPbufferHeight;
+ }
+
+ *pppsConfigs = ppsConfigs;
+
+ return true;
+}
+
+__DRIconfig **
+MODSUPConcatConfigs(__DRIscreen *psDRIScreen,
+ __DRIconfig **ppsConfigA, __DRIconfig **ppsConfigB)
+{
+ (void) psDRIScreen;
+
+ return driConcatConfigs(ppsConfigA, ppsConfigB);
+}
+
+struct __DRIimageRec *
+MODSUPLookupEGLImage(__DRIscreen *psDRIScreen, void *pvImage,
+ void *pvLoaderPrivate)
+{
+ return psDRIScreen->dri2.image->lookupEGLImage(psDRIScreen,
+ pvImage,
+ pvLoaderPrivate);
+}
+
+
+unsigned int
+MODSUPGetCapability(__DRIscreen *psDRIScreen, unsigned int uCapability)
+{
+ if (psDRIScreen->image.loader->base.version >= 2 &&
+ psDRIScreen->image.loader->getCapability) {
+ enum dri_loader_cap eCapability =
+ (enum dri_loader_cap) uCapability;
+
+ return psDRIScreen->image.loader->getCapability(
+ psDRIScreen->loaderPrivate,
+ eCapability);
+ }
+
+ return 0;
+}
+
+int
+MODSUPGetDisplayFD(__DRIscreen *psDRIScreen, void *pvLoaderPrivate)
+{
+#if __DRI_IMAGE_LOADER_VERSION >= 5
+ if (psDRIScreen->image.loader->base.version >= 5 &&
+ psDRIScreen->image.loader->getDisplayFD)
+ return psDRIScreen->image.loader->getDisplayFD(pvLoaderPrivate);
+#else
+ (void) psDRIScreen;
+ (void) pvLoaderPrivate;
+#endif
+
+ return -1;
+}
+
+static bool
+PVRDRIConfigQueryUnsigned(const PVRDRIConfig *psConfig,
+ PVRDRIConfigAttrib eConfigAttrib,
+ unsigned int *puValueOut)
+{
+ if (!psConfig || !puValueOut)
+ return false;
+
+ switch (eConfigAttrib) {
+ case PVRDRI_CONFIG_ATTRIB_RENDERABLE_TYPE:
+ *puValueOut = psConfig->iSupportedAPIs;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_RGB_MODE:
+ *puValueOut = psConfig->sGLMode.rgbMode;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_DOUBLE_BUFFER_MODE:
+ *puValueOut = psConfig->sGLMode.doubleBufferMode;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_RED_BITS:
+ *puValueOut = psConfig->sGLMode.redBits;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_GREEN_BITS:
+ *puValueOut = psConfig->sGLMode.greenBits;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_BLUE_BITS:
+ *puValueOut = psConfig->sGLMode.blueBits;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_ALPHA_BITS:
+ *puValueOut = psConfig->sGLMode.alphaBits;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_RGB_BITS:
+ *puValueOut = psConfig->sGLMode.rgbBits;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_DEPTH_BITS:
+ *puValueOut = psConfig->sGLMode.depthBits;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_STENCIL_BITS:
+ *puValueOut = psConfig->sGLMode.stencilBits;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_SAMPLE_BUFFERS:
+ *puValueOut = !!psConfig->sGLMode.samples;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_SAMPLES:
+ *puValueOut = psConfig->sGLMode.samples;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_BIND_TO_TEXTURE_RGB:
+ *puValueOut = GL_TRUE;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_BIND_TO_TEXTURE_RGBA:
+ *puValueOut = GL_TRUE;
+ return true;
+#if defined(__DRI_ATTRIB_YUV_BIT)
+ case PVRDRI_CONFIG_ATTRIB_YUV_ORDER:
+ *puValueOut = psConfig->sGLMode.YUVOrder;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_YUV_NUM_OF_PLANES:
+ *puValueOut = psConfig->sGLMode.YUVNumberOfPlanes;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_YUV_SUBSAMPLE:
+ *puValueOut = psConfig->sGLMode.YUVSubsample;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_YUV_DEPTH_RANGE:
+ *puValueOut = psConfig->sGLMode.YUVDepthRange;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_YUV_CSC_STANDARD:
+ *puValueOut = psConfig->sGLMode.YUVCSCStandard;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_YUV_PLANE_BPP:
+ *puValueOut = psConfig->sGLMode.YUVPlaneBPP;
+ return true;
+#endif
+#if !defined(__DRI_ATTRIB_YUV_BIT)
+ case PVRDRI_CONFIG_ATTRIB_YUV_ORDER:
+ case PVRDRI_CONFIG_ATTRIB_YUV_NUM_OF_PLANES:
+ case PVRDRI_CONFIG_ATTRIB_YUV_SUBSAMPLE:
+ case PVRDRI_CONFIG_ATTRIB_YUV_DEPTH_RANGE:
+ case PVRDRI_CONFIG_ATTRIB_YUV_CSC_STANDARD:
+ case PVRDRI_CONFIG_ATTRIB_YUV_PLANE_BPP:
+ return false;
+#endif
+ case PVRDRI_CONFIG_ATTRIB_RED_MASK:
+ *puValueOut = psConfig->sGLMode.redMask;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_GREEN_MASK:
+ *puValueOut = psConfig->sGLMode.greenMask;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_BLUE_MASK:
+ *puValueOut = psConfig->sGLMode.blueMask;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_ALPHA_MASK:
+ *puValueOut = psConfig->sGLMode.alphaMask;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_SRGB_CAPABLE:
+ *puValueOut = psConfig->sGLMode.sRGBCapable;
+ return true;
+ case PVRDRI_CONFIG_ATTRIB_INVALID:
+ errorMessage("%s: Invalid attribute", __func__);
+ assert(0);
+ return false;
+ default:
+ return false;
+ }
+}
+
+bool
+PVRDRIConfigQuery(const PVRDRIConfig *psConfig,
+ PVRDRIConfigAttrib eConfigAttrib, int *piValueOut)
+{
+ bool bRes;
+ unsigned int uValue;
+
+ bRes = PVRDRIConfigQueryUnsigned(psConfig, eConfigAttrib, &uValue);
+ if (bRes)
+ *piValueOut = (int) uValue;
+
+ return bRes;
+}
+
+bool
+MODSUPConfigQuery(const PVRDRIConfig *psConfig,
+ PVRDRIConfigAttrib eConfigAttrib, unsigned int *puValueOut)
+{
+ return PVRDRIConfigQueryUnsigned(psConfig, eConfigAttrib, puValueOut);
+}
+
+void
+MODSUPFlushFrontBuffer(struct __DRIdrawableRec *psDRIDrawable,
+ void *pvLoaderPrivate)
+{
+ PVRDRIDrawable *psPVRDrawable = psDRIDrawable->driverPrivate;
+ __DRIscreen *psDRIScreen = psDRIDrawable->driScreenPriv;
+
+ if (!psPVRDrawable->sConfig.sGLMode.doubleBufferMode)
+ psDRIScreen->image.loader->flushFrontBuffer(psDRIDrawable,
+ pvLoaderPrivate);
+}
+
+void *
+MODSUPDrawableGetReferenceHandle(struct __DRIdrawableRec *psDRIDrawable)
+{
+ PVRDRIDrawable *psPVRDrawable = psDRIDrawable->driverPrivate;
+
+ return psPVRDrawable;
+}
+
+void
+MODSUPDrawableAddReference(void *pvReferenceHandle)
+{
+ PVRDRIDrawable *psPVRDrawable = pvReferenceHandle;
+
+ PVRDRIDrawableAddReference(psPVRDrawable);
+}
+
+void
+MODSUPDrawableRemoveReference(void *pvReferenceHandle)
+{
+ PVRDRIDrawable *psPVRDrawable = pvReferenceHandle;
+
+ PVRDRIDrawableRemoveReference(psPVRDrawable);
+}
diff --git a/src/mesa/drivers/dri/pvr/pvrcompat.c b/src/mesa/drivers/dri/pvr/pvrcompat.c
new file mode 100644
index 00000000000..23a57dde682
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrcompat.c
@@ -0,0 +1,838 @@
+/*
+ * Copyright (c) Imagination Technologies Ltd.
+ *
+ * The contents of this file are subject to the MIT license as set out below.
+ *
+ * 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 without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS 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 <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dlfcn.h>
+#include <pthread.h>
+#include <assert.h>
+
+#include <drm_fourcc.h>
+
+#include "pvrdri.h"
+
+#ifndef DRM_FORMAT_MOD_INVALID
+#define DRM_FORMAT_MOD_INVALID ((1ULL << 56) - 1)
+#endif
+
+#define _MAKESTRING(x) # x
+#define MAKESTRING(x) _MAKESTRING(x)
+
+#define PVRDRI_SUPPORT_LIB "libpvr_dri_support.so"
+
+static void *gpvSupLib;
+static int giSupLibRef;
+
+static struct PVRDRISupportInterfaceV2 gsSupV2;
+
+static pthread_mutex_t gsCompatLock = PTHREAD_MUTEX_INITIALIZER;
+
+/* Lookup a function, and set the pointer to the function address */
+#define LookupFunc(func, ptr) \
+ do { \
+ ptr = dlsym(gpvSupLib, MAKESTRING(func)); \
+ } while(0)
+
+/* Call a function via the DRI Support interface structure */
+#define CallFuncV2(field, ...) \
+ do { \
+ if (gsSupV2.field) \
+ return gsSupV2.field(__VA_ARGS__); \
+ } while(0)
+
+/* Calculate the start of the PVRDRISupportInterfaceV2 structure */
+#define PVRDRIInterfaceV2Start(field) \
+ (offsetof(struct PVRDRISupportInterfaceV2, field))
+
+/* Calculate the end of the PVRDRISupportInterfaceV2 structure */
+#define PVRDRIInterfaceV2End(field) \
+ (offsetof(struct PVRDRISupportInterfaceV2, field) + \
+ sizeof((struct PVRDRISupportInterfaceV2 *)0)->field)
+
+static void
+CompatLock(void)
+{
+ int ret;
+
+ ret = pthread_mutex_lock(&gsCompatLock);
+ if (ret) {
+ errorMessage("%s: Failed to lock mutex (%d)", __func__, ret);
+ abort();
+ }
+}
+
+static void
+CompatUnlock(void)
+{
+ int ret;
+
+ ret = pthread_mutex_unlock(&gsCompatLock);
+ if (ret) {
+ errorMessage("%s: Failed to unlock mutex (%d)", __func__, ret);
+ abort();
+ }
+}
+
+static void *
+LoadLib(const char *path)
+{
+ void *handle;
+
+ /* Clear the error */
+ (void) dlerror();
+
+ handle = dlopen(path, RTLD_NOW);
+ if (handle) {
+ __driUtilMessage("Loaded %s", path);
+ } else {
+ const char *error;
+
+ error = dlerror();
+ if (!error)
+ error = "unknown error";
+
+ errorMessage("%s: Couldn't load %s: %s", __func__, path, error);
+ }
+
+ return handle;
+}
+
+static void
+UnloadLib(void *handle, const char *name)
+{
+ if (!handle)
+ return;
+
+ /* Clear the error */
+ (void) dlerror();
+
+ if (dlclose(handle)) {
+ const char *error;
+
+ error = dlerror();
+ if (!error)
+ error = "unknown error";
+
+ errorMessage("%s: Couldn't unload %s: %s", __func__, name, error);
+ } else {
+ __driUtilMessage("Unloaded %s", name);
+ }
+}
+
+static bool
+LoadSupportLib(void)
+{
+ gpvSupLib = LoadLib(PVRDRI_SUPPORT_LIB);
+
+ return gpvSupLib != NULL;
+}
+
+static void
+UnloadSupportLib(void)
+{
+ UnloadLib(gpvSupLib, PVRDRI_SUPPORT_LIB);
+ gpvSupLib = NULL;
+}
+
+static void
+CompatDeinit(void)
+{
+ UnloadSupportLib();
+ memset(&gsSupV2, 0, sizeof(gsSupV2));
+}
+
+bool
+PVRDRICompatInit(const struct PVRDRICallbacksV2 *psCallbacksV2,
+ unsigned int uVersionV2, unsigned int uMinVersionV2)
+{
+ bool (*pfRegisterVersionedCallbacksV2)(const void *pvCallbacks,
+ unsigned int uVersion,
+ unsigned int uMinVersion);
+ bool res;
+
+ CompatLock();
+ res = (giSupLibRef++ != 0);
+ if (res)
+ goto Exit;
+
+ res = LoadSupportLib();
+ if (!res)
+ goto Exit;
+
+ LookupFunc(PVRDRIRegisterVersionedCallbacksV2,
+ pfRegisterVersionedCallbacksV2);
+
+ res = (pfRegisterVersionedCallbacksV2 != NULL);
+ if (!res)
+ goto Exit;
+
+ res = pfRegisterVersionedCallbacksV2(psCallbacksV2,
+ uVersionV2, uMinVersionV2);
+
+Exit:
+ if (!res) {
+ CompatDeinit();
+ giSupLibRef--;
+ }
+ CompatUnlock();
+
+ return res;
+}
+
+void
+PVRDRICompatDeinit(void)
+{
+ CompatLock();
+ if (--giSupLibRef == 0)
+ CompatDeinit();
+ CompatUnlock();
+}
+
+bool
+MODSUPRegisterSupportInterfaceV2(const void *pvInterface,
+ unsigned int uVersion,
+ unsigned int uMinVersion)
+{
+ size_t uStart, uEnd;
+
+ memset(&gsSupV2, 0, sizeof(gsSupV2));
+
+ if (uVersion < uMinVersion)
+ return false;
+
+ /*
+ * Minimum versions we support. To prevent the accumulation of old unused
+ * interfaces in the PVRDRIInterfaceV2 structure, the caller specifies the
+ * minimum version it supports. This will be pointed to be the psInterface
+ * argument. Assuming we support that version, we must copy the structure
+ * passed to us into the correct place in our version of the interface
+ * structure.
+ */
+ switch (uMinVersion) {
+ case 0:
+ uStart = PVRDRIInterfaceV2Start(v0);
+ break;
+ case 1:
+ case 2:
+ case 3:
+ case 4:
+ /* These versions require version 0 */
+ return false;
+ default:
+ return false;
+ }
+
+ /* The "default" case should be associated with the latest version */
+ switch (uVersion) {
+ default:
+ case 4:
+ /* This version is an extension of versions 0 to 3 */
+ if (uMinVersion > 0)
+ return false;
+
+ uEnd = PVRDRIInterfaceV2End(v4);
+ break;
+ case 3:
+ /*
+ * This version is an extension of version 2, with no new
+ * entry points.
+ */
+ case 2:
+ /* This version is an extension of versions 0 and 1 */
+ if (uMinVersion > 0)
+ return false;
+
+ uEnd = PVRDRIInterfaceV2End(v2);
+ break;
+ case 1:
+ /* This version is an extension of version 0 */
+ if (uMinVersion > 0)
+ return false;
+
+ uEnd = PVRDRIInterfaceV2End(v1);
+ break;
+ case 0:
+ uEnd = PVRDRIInterfaceV2End(v0);
+ break;
+ }
+
+ memcpy(((char *) &gsSupV2) + uStart, pvInterface, uEnd - uStart);
+
+ PVRDRIAdjustExtensions(uVersion, uMinVersion);
+
+ return true;
+}
+
+struct DRISUPScreen *
+DRISUPCreateScreen(struct __DRIscreenRec *psDRIScreen, int iFD,
+ bool bUseInvalidate, void *pvLoaderPrivate,
+ const struct __DRIconfigRec ***pppsConfigs,
+ int *piMaxGLES1Version, int *piMaxGLES2Version)
+{
+ CallFuncV2(v0.CreateScreen,
+ psDRIScreen, iFD, bUseInvalidate, pvLoaderPrivate, pppsConfigs,
+ piMaxGLES1Version, piMaxGLES2Version);
+
+ return NULL;
+}
+
+void
+DRISUPDestroyScreen(struct DRISUPScreen *psDRISUPScreen)
+{
+ CallFuncV2(v0.DestroyScreen,
+ psDRISUPScreen);
+}
+
+unsigned int
+DRISUPCreateContext(PVRDRIAPIType eAPI, PVRDRIConfig *psPVRDRIConfig,
+ struct PVRDRIContextConfig *psCtxConfig,
+ struct __DRIcontextRec *psDRIContext,
+ struct DRISUPContext *psDRISUPSharedContext,
+ struct DRISUPScreen *psDRISUPScreen,
+ struct DRISUPContext **ppsDRISUPContext)
+{
+ CallFuncV2(v0.CreateContext,
+ eAPI, psPVRDRIConfig, psCtxConfig, psDRIContext,
+ psDRISUPSharedContext, psDRISUPScreen, ppsDRISUPContext);
+
+ return __DRI_CTX_ERROR_BAD_API;
+}
+
+void
+DRISUPDestroyContext(struct DRISUPContext *psDRISUPContext)
+{
+ CallFuncV2(v0.DestroyContext,
+ psDRISUPContext);
+}
+
+struct DRISUPDrawable *
+DRISUPCreateDrawable(struct __DRIdrawableRec *psDRIDrawable,
+ struct DRISUPScreen *psDRISUPScreen,
+ void *pvLoaderPrivate, PVRDRIConfig *psPVRDRIConfig)
+{
+ CallFuncV2(v0.CreateDrawable,
+ psDRIDrawable, psDRISUPScreen, pvLoaderPrivate, psPVRDRIConfig);
+
+ return NULL;
+}
+
+void
+DRISUPDestroyDrawable(struct DRISUPDrawable *psDRISUPDrawable)
+{
+ CallFuncV2(v0.DestroyDrawable,
+ psDRISUPDrawable);
+}
+
+bool
+DRISUPMakeCurrent(struct DRISUPContext *psDRISUPContext,
+ struct DRISUPDrawable *psDRISUPWrite,
+ struct DRISUPDrawable *psDRISUPRead)
+{
+ CallFuncV2(v0.MakeCurrent,
+ psDRISUPContext, psDRISUPWrite, psDRISUPRead);
+
+ return false;
+}
+
+bool
+DRISUPUnbindContext(struct DRISUPContext *psDRISUPContext)
+{
+ CallFuncV2(v0.UnbindContext,
+ psDRISUPContext);
+
+ return false;
+}
+
+struct DRISUPBuffer *
+DRISUPAllocateBuffer(struct DRISUPScreen *psDRISUPScreen,
+ unsigned int uAttachment, unsigned int uFormat,
+ int iWidth, int iHeight, unsigned int *puName,
+ unsigned int *puPitch, unsigned int *puCPP,
+ unsigned int *puFlags)
+{
+ CallFuncV2(v0.AllocateBuffer,
+ psDRISUPScreen, uAttachment, uFormat, iWidth, iHeight, puName,
+ puPitch, puCPP, puFlags);
+
+ return NULL;
+}
+
+void
+DRISUPReleaseBuffer(struct DRISUPScreen *psDRISUPScreen,
+ struct DRISUPBuffer *psDRISUPBuffer)
+{
+ CallFuncV2(v0.ReleaseBuffer,
+ psDRISUPScreen, psDRISUPBuffer);
+}
+
+void
+DRISUPSetTexBuffer2(struct DRISUPContext *psDRISUPContext, int iTarget,
+ int iFormat, struct DRISUPDrawable *psDRISUPDrawable)
+{
+ CallFuncV2(v0.SetTexBuffer2,
+ psDRISUPContext, iTarget, iFormat, psDRISUPDrawable);
+}
+
+void
+DRISUPReleaseTexBuffer(struct DRISUPContext *psDRISUPContext, int iTarget,
+ struct DRISUPDrawable *psDRISUPDrawable)
+{
+ CallFuncV2(v0.ReleaseTexBuffer,
+ psDRISUPContext, iTarget, psDRISUPDrawable);
+}
+
+void
+DRISUPFlush(struct DRISUPDrawable *psDRISUPDrawable)
+{
+ CallFuncV2(v0.Flush,
+ psDRISUPDrawable);
+}
+
+void
+DRISUPInvalidate(struct DRISUPDrawable *psDRISUPDrawable)
+{
+ CallFuncV2(v0.Invalidate,
+ psDRISUPDrawable);
+}
+
+void
+DRISUPFlushWithFlags(struct DRISUPContext *psDRISUPContext,
+ struct DRISUPDrawable *psDRISUPDrawable,
+ unsigned int uFlags, unsigned int uThrottleReason)
+{
+ CallFuncV2(v0.FlushWithFlags,
+ psDRISUPContext, psDRISUPDrawable, uFlags, uThrottleReason);
+}
+
+__DRIimage *
+DRISUPCreateImageFromName(struct DRISUPScreen *psDRISUPScreen,
+ int iWidth, int iHeight, int iFourCC, int iName,
+ int iPitch, void *pvLoaderPrivate)
+{
+ CallFuncV2(v0.CreateImageFromName,
+ psDRISUPScreen, iWidth, iHeight, iFourCC, iName, iPitch,
+ pvLoaderPrivate);
+
+ return NULL;
+}
+
+__DRIimage *
+DRISUPCreateImageFromRenderbuffer(struct DRISUPContext *psDRISUPContext,
+ int iRenderBuffer, void *pvLoaderPrivate)
+{
+ CallFuncV2(v0.CreateImageFromRenderbuffer,
+ psDRISUPContext, iRenderBuffer, pvLoaderPrivate);
+
+ return NULL;
+}
+
+void
+DRISUPDestroyImage(__DRIimage *psImage)
+{
+ CallFuncV2(v0.DestroyImage, psImage);
+}
+
+__DRIimage *
+DRISUPCreateImage(struct DRISUPScreen *psDRISUPScreen,
+ int iWidth, int iHeight, int iFourCC, unsigned int uUse,
+ void *pvLoaderPrivate)
+{
+ CallFuncV2(v0.CreateImage,
+ psDRISUPScreen, iWidth, iHeight, iFourCC, uUse, pvLoaderPrivate);
+
+ return NULL;
+}
+
+bool
+DRISUPQueryImage(__DRIimage *psImage, int iAttrib, int *piValue)
+{
+ CallFuncV2(v0.QueryImage,
+ psImage, iAttrib, piValue);
+
+ return false;
+}
+
+__DRIimage *
+DRISUPDupImage(__DRIimage *psImage, void *pvLoaderPrivate)
+{
+ CallFuncV2(v0.DupImage,
+ psImage, pvLoaderPrivate);
+
+ return NULL;
+}
+
+bool
+DRISUPValidateImageUsage(__DRIimage *psImage, unsigned int uUse)
+{
+ CallFuncV2(v0.ValidateImageUsage,
+ psImage, uUse);
+
+ return false;
+}
+
+__DRIimage *
+DRISUPCreateImageFromNames(struct DRISUPScreen *psDRISUPScreen,
+ int iWidth, int iHeight, int iFourCC,
+ int *piNames, int iNumNames,
+ int *piStrides, int *piOffsets,
+ void *pvLoaderPrivate)
+{
+ CallFuncV2(v0.CreateImageFromNames,
+ psDRISUPScreen, iWidth, iHeight, iFourCC, piNames, iNumNames,
+ piStrides, piOffsets, pvLoaderPrivate);
+
+ return NULL;
+}
+
+__DRIimage *
+DRISUPFromPlanar(__DRIimage *psImage, int iPlane, void *pvLoaderPrivate)
+{
+ CallFuncV2(v0.FromPlanar,
+ psImage, iPlane, pvLoaderPrivate);
+
+ return NULL;
+}
+
+__DRIimage *
+DRISUPCreateImageFromTexture(struct DRISUPContext *psDRISUPContext,
+ int iTarget, unsigned int uTexture, int iDepth,
+ int iLevel, unsigned int *puError,
+ void *pvLoaderPrivate)
+{
+ CallFuncV2(v0.CreateImageFromTexture,
+ psDRISUPContext, iTarget, uTexture, iDepth, iLevel, puError,
+ pvLoaderPrivate);
+
+ return NULL;
+}
+
+__DRIimage *
+DRISUPCreateImageFromFDs(struct DRISUPScreen *psDRISUPcreen,
+ int iWidth, int iHeight, int iFourCC,
+ int *piFDs, int iNumFDs, int *piStrides,
+ int *piOffsets, void *pvLoaderPrivate)
+{
+ CallFuncV2(v0.CreateImageFromFDs,
+ psDRISUPcreen, iWidth, iHeight, iFourCC, piFDs, iNumFDs,
+ piStrides, piOffsets, pvLoaderPrivate);
+
+ return NULL;
+}
+
+__DRIimage *
+DRISUPCreateImageFromDmaBufs(struct DRISUPScreen *psDRISUPScreen,
+ int iWidth, int iHeight, int iFourCC,
+ int *piFDs, int iNumFDs,
+ int *piStrides, int *piOffsets,
+ unsigned int uColorSpace,
+ unsigned int uSampleRange,
+ unsigned int uHorizSiting,
+ unsigned int uVertSiting,
+ unsigned int *puError,
+ void *pvLoaderPrivate)
+{
+ CallFuncV2(v0.CreateImageFromDMABufs,
+ psDRISUPScreen, iWidth, iHeight, iFourCC, piFDs, iNumFDs,
+ piStrides, piOffsets, uColorSpace, uSampleRange,
+ uHorizSiting, uVertSiting, puError, pvLoaderPrivate);
+
+ return NULL;
+}
+
+int
+DRISUPGetImageCapabilities(struct DRISUPScreen *psDRISUPScreen)
+{
+ CallFuncV2(v0.GetImageCapabilities,
+ psDRISUPScreen);
+
+ return 0;
+}
+
+void
+DRISUPBlitImage(struct DRISUPContext *psDRISUPContext,
+ __DRIimage *psDst, __DRIimage *psSrc, int iDstX0, int iDstY0,
+ int iDstWidth, int iDstHeight, int iSrcX0, int iSrcY0,
+ int iSrcWidth, int iSrcHeight, int iFlushFlag)
+{
+ CallFuncV2(v0.BlitImage,
+ psDRISUPContext, psDst, psSrc, iDstX0, iDstY0,
+ iDstWidth, iDstHeight, iSrcX0, iSrcY0,
+ iSrcWidth, iSrcHeight, iFlushFlag);
+}
+
+void *
+DRISUPMapImage(struct DRISUPContext *psDRISUPContext, __DRIimage* psImage,
+ int iX0, int iY0, int iWidth, int iHeight, unsigned int uFlags,
+ int *piStride, void **ppvData)
+{
+ CallFuncV2(v0.MapImage,
+ psDRISUPContext, psImage, iX0, iY0, iWidth, iHeight, uFlags,
+ piStride, ppvData);
+
+ return NULL;
+}
+
+void
+DRISUPUnmapImage(struct DRISUPContext *psDRISUPContext, __DRIimage *psImage,
+ void *pvData)
+{
+ CallFuncV2(v0.UnmapImage,
+ psDRISUPContext, psImage, pvData);
+}
+
+__DRIimage *
+DRISUPCreateImageWithModifiers(struct DRISUPScreen *psDRISUPScreen,
+ int iWidth, int iHeight, int iFourCC,
+ const uint64_t *puModifiers,
+ const unsigned int uModifierCount,
+ void *pvLoaderPrivate)
+{
+ CallFuncV2(v0.CreateImageWithModifiers,
+ psDRISUPScreen, iWidth, iHeight, iFourCC, puModifiers,
+ uModifierCount, pvLoaderPrivate);
+
+ return NULL;
+}
+
+__DRIimage *
+DRISUPCreateImageFromDMABufs2(struct DRISUPScreen *psDRISUPScreen,
+ int iWidth, int iHeight, int iFourCC,
+ uint64_t uModifier, int *piFDs, int iNumFDs,
+ int *piStrides, int *piOffsets,
+ unsigned int uColorSpace,
+ unsigned int uSampleRange,
+ unsigned int uHorizSiting,
+ unsigned int uVertSiting,
+ unsigned int *puError, void *pvLoaderPrivate)
+{
+ CallFuncV2(v0.CreateImageFromDMABufs2,
+ psDRISUPScreen, iWidth, iHeight, iFourCC, uModifier,
+ piFDs, iNumFDs, piStrides, piOffsets, uColorSpace, uSampleRange,
+ uHorizSiting, uVertSiting, puError, pvLoaderPrivate);
+
+ return NULL;
+}
+
+bool
+DRISUPQueryDMABufFormats(struct DRISUPScreen *psDRISUPScreen, int iMax,
+ int *piFormats, int *piCount)
+{
+ CallFuncV2(v0.QueryDMABufFormats,
+ psDRISUPScreen, iMax, piFormats, piCount);
+
+ return false;
+}
+
+bool
+DRISUPQueryDMABufModifiers(struct DRISUPScreen *psDRISUPScreen, int iFourCC,
+ int iMax, uint64_t *puModifiers,
+ unsigned int *piExternalOnly, int *piCount)
+{
+ CallFuncV2(v0.QueryDMABufModifiers,
+ psDRISUPScreen, iFourCC, iMax, puModifiers, piExternalOnly,
+ piCount);
+
+ return false;
+}
+
+bool
+DRISUPQueryDMABufFormatModifierAttribs(struct DRISUPScreen *psDRISUPScreen,
+ uint32_t iFourCC, uint64_t uModifier,
+ int iAttrib, uint64_t *puValue)
+{
+ CallFuncV2(v0.QueryDMABufFormatModifierAttribs,
+ psDRISUPScreen, iFourCC, uModifier, iAttrib, puValue);
+
+ return false;
+}
+
+__DRIimage *
+DRISUPCreateImageFromRenderBuffer2(struct DRISUPContext *psDRISUPContext,
+ int iRenderBuffer, void *pvLoaderPrivate,
+ unsigned int *puError)
+{
+ CallFuncV2(v0.CreateImageFromRenderBuffer2,
+ psDRISUPContext, iRenderBuffer, pvLoaderPrivate, puError);
+
+ return NULL;
+}
+
+__DRIimage *
+DRISUPCreateImageFromBuffer(struct DRISUPContext *psDRISUPContext,
+ int iTarget, void *pvBuffer,
+ unsigned int *puError, void *pvLoaderPrivate)
+{
+ CallFuncV2(v0.CreateImageFromBuffer,
+ psDRISUPContext, iTarget, pvBuffer, puError, pvLoaderPrivate);
+
+ return NULL;
+}
+
+int
+DRISUPQueryRendererInteger(struct DRISUPScreen *psDRISUPScreen,
+ int iAttribute, unsigned int *puValue)
+{
+ CallFuncV2(v0.QueryRendererInteger,
+ psDRISUPScreen, iAttribute, puValue);
+
+ return -1;
+}
+
+int
+DRISUPQueryRendererString(struct DRISUPScreen *psDRISUPScreen,
+ int iAttribute, const char **ppszValue)
+{
+ CallFuncV2(v0.QueryRendererString,
+ psDRISUPScreen, iAttribute, ppszValue);
+
+ return -1;
+}
+
+void *
+DRISUPCreateFence(struct DRISUPContext *psDRISUPContext)
+{
+ CallFuncV2(v0.CreateFence,
+ psDRISUPContext);
+
+ return NULL;
+}
+
+void
+DRISUPDestroyFence(struct DRISUPScreen *psDRISUPScreen, void *pvFence)
+{
+ CallFuncV2(v0.DestroyFence,
+ psDRISUPScreen, pvFence);
+}
+
+bool
+DRISUPClientWaitSync(struct DRISUPContext *psDRISUPContext, void *pvFence,
+ unsigned int uFlags, uint64_t uTimeout)
+{
+ CallFuncV2(v0.ClientWaitSync,
+ psDRISUPContext, pvFence, uFlags, uTimeout);
+
+ return false;
+}
+
+void
+DRISUPServerWaitSync(struct DRISUPContext *psDRISUPContext, void *pvFence,
+ unsigned int uFlags)
+{
+ CallFuncV2(v0.ServerWaitSync,
+ psDRISUPContext, pvFence, uFlags);
+}
+
+unsigned int
+DRISUPGetFenceCapabilities(struct DRISUPScreen *psDRISUPScreen)
+{
+ CallFuncV2(v0.GetFenceCapabilities,
+ psDRISUPScreen);
+
+ return 0;
+}
+
+void *
+DRISUPCreateFenceFD(struct DRISUPContext *psDRISUPContext, int iFD)
+{
+ CallFuncV2(v0.CreateFenceFD,
+ psDRISUPContext, iFD);
+
+ return NULL;
+}
+
+int
+DRISUPGetFenceFD(struct DRISUPScreen *psDRISUPScreen, void *pvFence)
+{
+ CallFuncV2(v0.GetFenceFD,
+ psDRISUPScreen, pvFence);
+
+ return -1;
+}
+
+void *
+DRISUPGetFenceFromCLEvent(struct DRISUPScreen *psDRISUPScreen,
+ intptr_t iCLEvent)
+{
+ CallFuncV2(v1.GetFenceFromCLEvent,
+ psDRISUPScreen, iCLEvent);
+
+ return NULL;
+}
+
+int
+DRISUPGetAPIVersion(struct DRISUPScreen *psDRISUPScreen,
+ PVRDRIAPIType eAPI)
+{
+ CallFuncV2(v2.GetAPIVersion,
+ psDRISUPScreen, eAPI);
+
+ return 0;
+}
+
+unsigned int
+DRISUPGetNumAPIProcs(struct DRISUPScreen *psDRISUPScreen,
+ PVRDRIAPIType eAPI)
+{
+ CallFuncV2(v0.GetNumAPIProcs,
+ psDRISUPScreen, eAPI);
+
+ return 0;
+}
+
+const char *
+DRISUPGetAPIProcName(struct DRISUPScreen *psDRISUPScreen, PVRDRIAPIType eAPI,
+ unsigned int uIndex)
+{
+ CallFuncV2(v0.GetAPIProcName,
+ psDRISUPScreen, eAPI, uIndex);
+
+ return NULL;
+}
+
+void *
+DRISUPGetAPIProcAddress(struct DRISUPScreen *psDRISUPScreen,
+ PVRDRIAPIType eAPI, unsigned int uIndex)
+{
+ CallFuncV2(v0.GetAPIProcAddress,
+ psDRISUPScreen, eAPI, uIndex);
+
+ return NULL;
+}
+
+void
+DRISUPSetDamageRegion(struct DRISUPDrawable *psDRISUPDrawable,
+ unsigned int uNRects, int *piRects)
+{
+ CallFuncV2(v0.SetDamageRegion,
+ psDRISUPDrawable, uNRects, piRects);
+}
+
+bool
+DRISUPHaveGetFenceFromCLEvent(void)
+{
+ CallFuncV2(v4.HaveGetFenceFromCLEvent);
+
+ return true;
+}
diff --git a/src/mesa/drivers/dri/pvr/pvrdri.c b/src/mesa/drivers/dri/pvr/pvrdri.c
new file mode 100644
index 00000000000..ab941f71567
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrdri.c
@@ -0,0 +1,613 @@
+/*
+ * Copyright (c) Imagination Technologies Ltd.
+ *
+ * The contents of this file are subject to the MIT license as set out below.
+ *
+ * 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 without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS 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 <string.h>
+#include <assert.h>
+
+#include "util/u_atomic.h"
+#include "utils.h"
+
+#include "pvrdri.h"
+#include "pvrmesa.h"
+
+#define PVR_IMAGE_LOADER_VER_MIN 1
+
+struct PVRBuffer {
+ __DRIbuffer sDRIBuffer;
+ struct DRISUPBuffer *psDRISUPBuffer;
+};
+
+/*************************************************************************//*!
+ Local functions
+ *//**************************************************************************/
+
+static bool
+PVRLoaderIsSupported(__DRIscreen *psDRIScreen)
+{
+ if (psDRIScreen->image.loader) {
+ if (psDRIScreen->image.loader->base.version < PVR_IMAGE_LOADER_VER_MIN) {
+ __driUtilMessage("%s: Image loader extension version %d but need %d",
+ __func__, psDRIScreen->image.loader->base.version,
+ PVR_IMAGE_LOADER_VER_MIN);
+ return false;
+ } else if (!psDRIScreen->image.loader->getBuffers) {
+ __driUtilMessage("%s: Image loader extension missing support for getBuffers",
+ __func__);
+ return false;
+ }
+ } else {
+ __driUtilMessage("%s: Image loader extension required", __func__);
+ return false;
+ }
+
+ return true;
+}
+
+static inline struct DRISUPContext *
+getSharedContextImpl(void *pvSharedContextPrivate)
+{
+ if (pvSharedContextPrivate == NULL)
+ return NULL;
+
+ return ((PVRDRIContext *) pvSharedContextPrivate)->psDRISUPContext;
+}
+
+static void
+PVRDRIScreenAddReference(PVRDRIScreen *psPVRScreen)
+{
+ int iRefCount = p_atomic_inc_return(&psPVRScreen->iRefCount);
+
+ (void) iRefCount;
+ assert(iRefCount > 1);
+}
+
+static void
+PVRDRIScreenRemoveReference(PVRDRIScreen *psPVRScreen)
+{
+ int iRefCount = p_atomic_dec_return(&psPVRScreen->iRefCount);
+
+ assert(iRefCount >= 0);
+
+ if (iRefCount != 0)
+ return;
+
+ pvrdri_free_dispatch_tables(psPVRScreen);
+ DRISUPDestroyScreen(psPVRScreen->psDRISUPScreen);
+ PVRDRICompatDeinit();
+ free(psPVRScreen);
+}
+
+void
+PVRDRIDrawableAddReference(PVRDRIDrawable *psPVRDrawable)
+{
+ int iRefCount = p_atomic_inc_return(&psPVRDrawable->iRefCount);
+
+ (void) iRefCount;
+ assert(iRefCount > 1);
+}
+
+void
+PVRDRIDrawableRemoveReference(PVRDRIDrawable *psPVRDrawable)
+{
+ int iRefCount = p_atomic_dec_return(&psPVRDrawable->iRefCount);
+
+ assert(iRefCount >= 0);
+
+ if (iRefCount != 0)
+ return;
+
+ DRISUPDestroyDrawable(psPVRDrawable->psDRISUPDrawable);
+
+#if defined(DEBUG)
+ p_atomic_dec(&psPVRDrawable->psPVRScreen->iDrawableAlloc);
+#endif
+
+ PVRDRIScreenRemoveReference(psPVRDrawable->psPVRScreen);
+ free(psPVRDrawable);
+}
+
+static void
+PVRScreenPrintExtensions(__DRIscreen *psDRIScreen)
+{
+ /* Don't attempt to print anything if LIBGL_DEBUG isn't in the environment */
+ if (getenv("LIBGL_DEBUG") == NULL)
+ return;
+
+ if (psDRIScreen->extensions) {
+ const __DRIextension *psScreenExtensionVersionInfo =
+ PVRDRIScreenExtensionVersionInfo();
+ int i;
+ int j;
+
+ __driUtilMessage("Supported screen extensions:");
+
+ for (i = 0; psDRIScreen->extensions[i]; i++) {
+ for (j = 0; psScreenExtensionVersionInfo[j].name; j++) {
+ if (strcmp(psDRIScreen->extensions[i]->name,
+ psScreenExtensionVersionInfo[j].name) == 0) {
+ __driUtilMessage("\t%s (supported version: %u - max version: %u)",
+ psDRIScreen->extensions[i]->name,
+ psDRIScreen->extensions[i]->version,
+ psScreenExtensionVersionInfo[j].version);
+ break;
+ }
+ }
+
+ if (psScreenExtensionVersionInfo[j].name == NULL) {
+ __driUtilMessage("\t%s (supported version: %u - max version: unknown)",
+ psDRIScreen->extensions[i]->name,
+ psDRIScreen->extensions[i]->version);
+ }
+ }
+ } else {
+ __driUtilMessage("No screen extensions found");
+ }
+}
+
+/*************************************************************************//*!
+ Mesa driver API functions
+ *//**************************************************************************/
+
+static const __DRIconfig **
+PVRDRIInitScreen(__DRIscreen *psDRIScreen)
+{
+ PVRDRIScreen *psPVRScreen;
+ const __DRIconfig **ppsConfigs;
+ int iMaxGLES1Version, iMaxGLES2Version;
+ const struct PVRDRICallbacksV2 sDRICallbacksV2 = {
+ /* Version 0 callbacks */
+ .v0.RegisterSupportInterface = MODSUPRegisterSupportInterfaceV2,
+ .v0.GetBuffers = MODSUPGetBuffers,
+ .v0.CreateConfigs = MODSUPCreateConfigs,
+ .v0.ConcatConfigs = MODSUPConcatConfigs,
+ .v0.ConfigQuery = MODSUPConfigQuery,
+ .v0.LookupEGLImage = MODSUPLookupEGLImage,
+ .v0.GetCapability = MODSUPGetCapability,
+ /* Version 1 callbacks */
+ .v1.FlushFrontBuffer = MODSUPFlushFrontBuffer,
+ /* Version 2 callbacks */
+ .v2.GetDisplayFD = MODSUPGetDisplayFD,
+ /* Version 3 callbacks */
+ .v3.DrawableGetReferenceHandle = MODSUPDrawableGetReferenceHandle,
+ .v3.DrawableAddReference = MODSUPDrawableAddReference,
+ .v3.DrawableRemoveReference = MODSUPDrawableRemoveReference,
+ };
+
+ if (!PVRLoaderIsSupported(psDRIScreen))
+ return NULL;
+
+ if (!PVRDRICompatInit(&sDRICallbacksV2, 3, 0))
+ return NULL;
+
+ psPVRScreen = calloc(1, sizeof(*psPVRScreen));
+ if (psPVRScreen == NULL) {
+ __driUtilMessage("%s: Couldn't allocate PVRDRIScreen", __func__);
+ goto ErrorCompatDeinit;
+ }
+
+ psDRIScreen->driverPrivate = psPVRScreen;
+ psPVRScreen->psDRIScreen = psDRIScreen;
+ psPVRScreen->iRefCount = 1;
+
+ psPVRScreen->psDRISUPScreen =
+ DRISUPCreateScreen(psDRIScreen, psDRIScreen->fd,
+ psDRIScreen->dri2.useInvalidate != NULL,
+ psDRIScreen->loaderPrivate,
+ &ppsConfigs, &iMaxGLES1Version, &iMaxGLES2Version);
+ if (!psPVRScreen->psDRISUPScreen)
+ goto ErrorScreenFree;
+
+ psDRIScreen->max_gl_es1_version = iMaxGLES1Version;
+ psDRIScreen->max_gl_es2_version = iMaxGLES2Version;
+
+ psDRIScreen->max_gl_compat_version =
+ DRISUPGetAPIVersion(psPVRScreen->psDRISUPScreen, PVRDRI_API_GL_COMPAT);
+ psDRIScreen->max_gl_core_version =
+ DRISUPGetAPIVersion(psPVRScreen->psDRISUPScreen, PVRDRI_API_GL_CORE);
+
+ psDRIScreen->extensions = PVRDRIScreenExtensions();
+
+ PVRScreenPrintExtensions(psDRIScreen);
+
+ return ppsConfigs;
+
+ErrorScreenFree:
+ psDRIScreen->driverPrivate = NULL;
+ free(psPVRScreen);
+
+ErrorCompatDeinit:
+ PVRDRICompatDeinit();
+
+ return NULL;
+}
+
+static void
+PVRDRIDestroyScreen(__DRIscreen *psDRIScreen)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+
+#if defined(DEBUG)
+ if (psPVRScreen->iBufferAlloc != 0 ||
+ psPVRScreen->iDrawableAlloc != 0 ||
+ psPVRScreen->iContextAlloc != 0) {
+ errorMessage("%s: Outstanding allocations: Contexts: %d Drawables: %d Buffers: %d",
+ __func__, psPVRScreen->iContextAlloc,
+ psPVRScreen->iDrawableAlloc, psPVRScreen->iBufferAlloc);
+
+ if (psPVRScreen->iRefCount > 1) {
+ errorMessage("%s: PVRDRIScreen resources will not be freed until its %d references are removed",
+ __func__, psPVRScreen->iRefCount - 1);
+ }
+ }
+#endif
+
+ PVRDRIScreenRemoveReference(psPVRScreen);
+}
+
+static int
+PVRDRIScreenSupportedAPIs(PVRDRIScreen *psPVRScreen)
+{
+ unsigned int api_mask = psPVRScreen->psDRIScreen->api_mask;
+ int supported = 0;
+
+ if ((api_mask & (1 << __DRI_API_GLES)) != 0)
+ supported |= PVRDRI_API_BIT_GLES;
+
+ if ((api_mask & (1 << __DRI_API_GLES2)) != 0)
+ supported |= PVRDRI_API_BIT_GLES2;
+
+ if ((api_mask & (1 << __DRI_API_GLES3)) != 0)
+ supported |= PVRDRI_API_BIT_GLES3;
+
+ if ((api_mask & (1 << __DRI_API_OPENGL)) != 0)
+ supported |= PVRDRI_API_BIT_GL;
+
+ if ((api_mask & (1 << __DRI_API_OPENGL_CORE)) != 0)
+ supported |= PVRDRI_API_BIT_GL;
+
+ return supported;
+}
+
+static GLboolean
+PVRDRICreateContext(gl_api eMesaAPI, const struct gl_config *psGLMode,
+ __DRIcontext *psDRIContext,
+ const struct __DriverContextConfig *psCtxConfig,
+ unsigned int *puError, void *pvSharedContextPrivate)
+{
+ __DRIscreen *psDRIScreen = psDRIContext->driScreenPriv;
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+ PVRDRIContext *psPVRContext;
+ struct DRISUPContext *psDRISUPContext;
+ struct DRISUPContext *psDRISUPSharedContext;
+ struct PVRDRIContextConfig sCtxConfig;
+ PVRDRIAPIType eAPI;
+
+ psDRISUPSharedContext = getSharedContextImpl(pvSharedContextPrivate);
+
+ sCtxConfig.uMajorVersion = psCtxConfig->major_version;
+ sCtxConfig.uMinorVersion = psCtxConfig->minor_version;
+ sCtxConfig.uFlags = psCtxConfig->flags;
+ sCtxConfig.iResetStrategy = __DRI_CTX_RESET_NO_NOTIFICATION;
+ sCtxConfig.uPriority = __DRI_CTX_PRIORITY_MEDIUM;
+ sCtxConfig.iReleaseBehavior = __DRI_CTX_RELEASE_BEHAVIOR_FLUSH;
+
+ psPVRContext = calloc(1, sizeof(*psPVRContext));
+ if (psPVRContext == NULL) {
+ __driUtilMessage("%s: Couldn't allocate PVRDRIContext", __func__);
+ *puError = __DRI_CTX_ERROR_NO_MEMORY;
+ return GL_FALSE;
+ }
+
+ psPVRContext->psDRIContext = psDRIContext;
+ psPVRContext->psPVRScreen = psPVRScreen;
+
+ if (psGLMode)
+ psPVRContext->sConfig.sGLMode = *psGLMode;
+
+ switch (eMesaAPI) {
+ case API_OPENGLES:
+ eAPI = PVRDRI_API_GLES1;
+ break;
+ case API_OPENGLES2:
+ eAPI = PVRDRI_API_GLES2;
+ break;
+ case API_OPENGL_COMPAT:
+ eAPI = PVRDRI_API_GL_COMPAT;
+ break;
+ case API_OPENGL_CORE:
+ eAPI = PVRDRI_API_GL_CORE;
+ break;
+ default:
+ __driUtilMessage("%s: Unsupported API: %d",
+ __func__, (int) eMesaAPI);
+ *puError = __DRI_CTX_ERROR_BAD_API;
+ goto ErrorContextFree;
+ }
+ psPVRContext->eAPI = eAPI;
+
+ if ((psCtxConfig->attribute_mask &
+ __DRIVER_CONTEXT_ATTRIB_RESET_STRATEGY) != 0) {
+ sCtxConfig.iResetStrategy = psCtxConfig->reset_strategy;
+ }
+
+ if ((psCtxConfig->attribute_mask &
+ __DRIVER_CONTEXT_ATTRIB_RELEASE_BEHAVIOR) != 0) {
+ sCtxConfig.iReleaseBehavior = psCtxConfig->release_behavior;
+ }
+
+ if ((psCtxConfig->attribute_mask &
+ __DRIVER_CONTEXT_ATTRIB_PRIORITY) != 0) {
+ sCtxConfig.uPriority = psCtxConfig->priority;
+ }
+
+ *puError = DRISUPCreateContext(eAPI, &psPVRContext->sConfig, &sCtxConfig,
+ psDRIContext, psDRISUPSharedContext,
+ psPVRScreen->psDRISUPScreen,
+ &psDRISUPContext);
+ if (*puError != __DRI_CTX_ERROR_SUCCESS)
+ goto ErrorContextFree;
+
+ psPVRContext->psDRISUPContext = psDRISUPContext;
+
+ if (!pvrdri_create_dispatch_table(psPVRScreen, eAPI)) {
+ __driUtilMessage("%s: Couldn't create dispatch table", __func__);
+ *puError = __DRI_CTX_ERROR_BAD_API;
+ goto ErrorContextDestroy;
+ }
+#if defined(DEBUG)
+ p_atomic_inc(&psPVRScreen->iContextAlloc);
+#endif
+
+ psDRIContext->driverPrivate = (void *) psPVRContext;
+ PVRDRIScreenAddReference(psPVRScreen);
+
+ *puError = __DRI_CTX_ERROR_SUCCESS;
+
+ return GL_TRUE;
+
+ErrorContextDestroy:
+ DRISUPDestroyContext(psPVRContext->psDRISUPContext);
+
+ErrorContextFree:
+ free(psPVRContext);
+
+ return GL_FALSE;
+}
+
+static void
+PVRDRIDestroyContext(__DRIcontext *psDRIContext)
+{
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+ PVRDRIScreen *psPVRScreen = psPVRContext->psPVRScreen;
+
+ DRISUPDestroyContext(psPVRContext->psDRISUPContext);
+
+#if defined(DEBUG)
+ p_atomic_dec(&psPVRScreen->iContextAlloc);
+#endif
+
+ PVRDRIScreenRemoveReference(psPVRScreen);
+ free(psPVRContext);
+}
+
+static GLboolean
+PVRDRICreateBuffer(__DRIscreen *psDRIScreen, __DRIdrawable *psDRIDrawable,
+ const struct gl_config *psGLMode, GLboolean bIsPixmap)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+ PVRDRIDrawable *psPVRDrawable = NULL;
+
+ /* No known callers ever set this to true */
+ if (bIsPixmap)
+ return GL_FALSE;
+
+ if (!psGLMode) {
+ __driUtilMessage("%s: Invalid GL config", __func__);
+ return GL_FALSE;
+ }
+
+ psPVRDrawable = calloc(1, sizeof(*psPVRDrawable));
+ if (!psPVRDrawable) {
+ __driUtilMessage("%s: Couldn't allocate PVR drawable", __func__);
+ goto ErrorDrawableFree;
+ }
+
+ psDRIDrawable->driverPrivate = (void *) psPVRDrawable;
+ psPVRDrawable->iRefCount = 1;
+ psPVRDrawable->psDRIDrawable = psDRIDrawable;
+ psPVRDrawable->psPVRScreen = psPVRScreen;
+ psPVRDrawable->sConfig.sGLMode = *psGLMode;
+ psPVRDrawable->sConfig.iSupportedAPIs =
+ PVRDRIScreenSupportedAPIs(psPVRScreen);
+
+ psPVRDrawable->psDRISUPDrawable =
+ DRISUPCreateDrawable(psDRIDrawable, psPVRScreen->psDRISUPScreen,
+ psDRIDrawable->loaderPrivate,
+ &psPVRDrawable->sConfig);
+ if (!psPVRDrawable->psDRISUPDrawable) {
+ __driUtilMessage("%s: Couldn't create DRI Support drawable",
+ __func__);
+ goto ErrorDrawableFree;
+ }
+
+ /* Initialisation is completed in MakeCurrent */
+#if defined(DEBUG)
+ p_atomic_inc(&psPVRScreen->iDrawableAlloc);
+#endif
+ PVRDRIScreenAddReference(psPVRScreen);
+ return GL_TRUE;
+
+ErrorDrawableFree:
+ DRISUPDestroyDrawable(psPVRDrawable->psDRISUPDrawable);
+ free(psPVRDrawable);
+ psDRIDrawable->driverPrivate = NULL;
+
+ return GL_FALSE;
+}
+
+static void
+PVRDRIDestroyBuffer(__DRIdrawable *psDRIDrawable)
+{
+ PVRDRIDrawable *psPVRDrawable = psDRIDrawable->driverPrivate;
+
+ PVRDRIDrawableRemoveReference(psPVRDrawable);
+}
+
+static GLboolean
+PVRDRIMakeCurrent(__DRIcontext *psDRIContext,
+ __DRIdrawable *psDRIWrite, __DRIdrawable *psDRIRead)
+{
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+ struct DRISUPDrawable *psDRISUPWrite;
+ struct DRISUPDrawable *psDRISUPRead;
+
+ if (psDRIWrite) {
+ PVRDRIDrawable *psPVRWrite = psDRIWrite->driverPrivate;
+
+ psDRISUPWrite = psPVRWrite->psDRISUPDrawable;
+ } else {
+ psDRISUPWrite = NULL;
+ }
+
+ if (psDRIRead) {
+ PVRDRIDrawable *psPVRRead = psDRIRead->driverPrivate;
+
+ psDRISUPRead = psPVRRead->psDRISUPDrawable;
+ } else {
+ psDRISUPRead = NULL;
+ }
+
+ if (!DRISUPMakeCurrent(psPVRContext->psDRISUPContext,
+ psDRISUPWrite, psDRISUPRead))
+ goto ErrorUnlock;
+
+ pvrdri_set_dispatch_table(psPVRContext);
+
+ return GL_TRUE;
+
+ErrorUnlock:
+ return GL_FALSE;
+}
+
+static GLboolean
+PVRDRIUnbindContext(__DRIcontext *psDRIContext)
+{
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+
+ pvrdri_set_null_dispatch_table();
+ DRISUPUnbindContext(psPVRContext->psDRISUPContext);
+
+ return GL_TRUE;
+}
+
+static __DRIbuffer *
+PVRDRIAllocateBuffer(__DRIscreen *psDRIScreen, unsigned int uAttachment,
+ unsigned int uFormat, int iWidth, int iHeight)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+ struct PVRBuffer *psBuffer;
+
+ psBuffer = calloc(1, sizeof(*psBuffer));
+ if (psBuffer == NULL) {
+ __driUtilMessage("%s: Failed to allocate buffer", __func__);
+ return NULL;
+ }
+
+ psBuffer->psDRISUPBuffer =
+ DRISUPAllocateBuffer(psPVRScreen->psDRISUPScreen, uAttachment, uFormat,
+ iWidth, iHeight, &psBuffer->sDRIBuffer.name,
+ &psBuffer->sDRIBuffer.pitch,
+ &psBuffer->sDRIBuffer.cpp,
+ &psBuffer->sDRIBuffer.flags);
+ if (!psBuffer->psDRISUPBuffer) {
+ __driUtilMessage("%s: Failed to create DRI Support buffer", __func__);
+ goto ErrorFreeDRIBuffer;
+ }
+
+ psBuffer->sDRIBuffer.attachment = uAttachment;
+
+#if defined(DEBUG)
+ p_atomic_inc(&psPVRScreen->iBufferAlloc);
+#endif
+
+ return &psBuffer->sDRIBuffer;
+
+ErrorFreeDRIBuffer:
+ free(psBuffer);
+
+ return NULL;
+}
+
+static void
+PVRDRIReleaseBuffer(__DRIscreen *psDRIScreen, __DRIbuffer *psDRIBuffer)
+{
+ struct PVRBuffer *psPVRBuffer = (struct PVRBuffer *) psDRIBuffer;
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+
+ DRISUPReleaseBuffer(psPVRScreen->psDRISUPScreen,
+ psPVRBuffer->psDRISUPBuffer);
+
+#if defined(DEBUG)
+ p_atomic_dec(&psPVRScreen->iBufferAlloc);
+#endif
+
+ free(psPVRBuffer);
+}
+
+static const struct __DriverAPIRec pvr_driver_api = {
+ .InitScreen = PVRDRIInitScreen,
+ .DestroyScreen = PVRDRIDestroyScreen,
+ .CreateContext = PVRDRICreateContext,
+ .DestroyContext = PVRDRIDestroyContext,
+ .CreateBuffer = PVRDRICreateBuffer,
+ .DestroyBuffer = PVRDRIDestroyBuffer,
+ .SwapBuffers = NULL,
+ .MakeCurrent = PVRDRIMakeCurrent,
+ .UnbindContext = PVRDRIUnbindContext,
+ .AllocateBuffer = PVRDRIAllocateBuffer,
+ .ReleaseBuffer = PVRDRIReleaseBuffer,
+};
+
+static const struct __DRIDriverVtableExtensionRec pvr_vtable = {
+ .base = {__DRI_DRIVER_VTABLE, 1},
+ .vtable = &pvr_driver_api,
+};
+
+static const __DRIextension *pvr_driver_extensions[] = {
+ &driCoreExtension.base,
+ &driImageDriverExtension.base,
+ &driDRI2Extension.base,
+ &pvr_vtable.base,
+ NULL
+};
+
+const __DRIextension **__driDriverGetExtensions_pvr(void);
+
+PUBLIC const __DRIextension **
+__driDriverGetExtensions_pvr(void)
+{
+ globalDriverAPI = &pvr_driver_api;
+
+ return pvr_driver_extensions;
+}
diff --git a/src/mesa/drivers/dri/pvr/pvrdri.h b/src/mesa/drivers/dri/pvr/pvrdri.h
new file mode 100644
index 00000000000..fd465bf7f5c
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrdri.h
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) Imagination Technologies Ltd.
+ *
+ * The contents of this file are subject to the MIT license as set out below.
+ *
+ * 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 without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
+
+#if !defined(__PVRDRI_H__)
+#define __PVRDRI_H__
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#include <glapi/glapi.h>
+
+#include "main/mtypes.h"
+#include "util/macros.h"
+#include "dri_util.h"
+#include "pvrdri_support.h"
+
+struct PVRDRIConfigRec {
+ struct gl_config sGLMode;
+ int iSupportedAPIs;
+};
+
+/* PVR screen data */
+typedef struct PVRDRIScreen_TAG {
+ /* DRI screen structure pointer */
+ __DRIscreen *psDRIScreen;
+
+ /* Opaque PVR DRI Support screen structure pointer */
+ struct DRISUPScreen *psDRISUPScreen;
+
+ /* Reference count */
+ int iRefCount;
+
+#if defined(DEBUG)
+ /* Counters of outstanding allocations */
+ int iContextAlloc;
+ int iDrawableAlloc;
+ int iBufferAlloc;
+#endif
+
+ /* PVR OGLES 1 dispatch table */
+ struct _glapi_table *psOGLES1Dispatch;
+ /* PVR OGLES 2/3 dispatch table */
+ struct _glapi_table *psOGLES2Dispatch;
+ /* PVR OGL dispatch table */
+ struct _glapi_table *psOGLDispatch;
+} PVRDRIScreen;
+
+/* PVR context data */
+typedef struct PVRDRIContext_TAG {
+ /* Pointer to DRI context */
+ __DRIcontext *psDRIContext;
+
+ /* Opaque PVR DRI Support context structure pointer */
+ struct DRISUPContext *psDRISUPContext;
+
+ /* Pointer to PVRDRIScreen structure */
+ PVRDRIScreen *psPVRScreen;
+
+ /* GL config */
+ PVRDRIConfig sConfig;
+
+ /* API */
+ PVRDRIAPIType eAPI;
+} PVRDRIContext;
+
+/* PVR drawable data */
+typedef struct PVRDRIDrawable_TAG {
+ PVRDRIScreen *psPVRScreen;
+ __DRIdrawable *psDRIDrawable;
+ int iRefCount;
+ PVRDRIConfig sConfig;
+ struct DRISUPDrawable *psDRISUPDrawable;
+ unsigned int uFourCC;
+ unsigned int uDRIFormat;
+} PVRDRIDrawable;
+
+/*************************************************************************//*!
+ pvrdri.c
+ *//**************************************************************************/
+void PVRDRIDrawableAddReference(PVRDRIDrawable *psPVRDrawable);
+void PVRDRIDrawableRemoveReference(PVRDRIDrawable *psPVRDrawable);
+
+/*************************************************************************//*!
+ pvrutil.c
+ *//**************************************************************************/
+
+void PRINTFLIKE(1, 2) __driUtilMessage(const char *f, ...);
+void PRINTFLIKE(1, 2) errorMessage(const char *f, ...);
+
+mesa_format PVRDRIMesaFormatToMesaFormat(int pvrdri_mesa_format);
+int PVRDRIFormatToFourCC(int dri_format);
+int PVRDRIFourCCToDRIFormat(int iFourCC);
+
+/*************************************************************************//*!
+ pvrext.c
+ *//**************************************************************************/
+
+const __DRIextension **PVRDRIScreenExtensions(void);
+const __DRIextension *PVRDRIScreenExtensionVersionInfo(void);
+
+void PVRDRIAdjustExtensions(unsigned int uVersion, unsigned int uMinVersion);
+
+/*************************************************************************//*!
+ pvrcompat.c
+ *//**************************************************************************/
+
+bool PVRDRICompatInit(const struct PVRDRICallbacksV2 *psCallbacksV2,
+ unsigned int uVersionV2, unsigned int uMinVersionV2);
+void PVRDRICompatDeinit(void);
+
+bool MODSUPRegisterSupportInterfaceV2(const void *pvInterface,
+ unsigned int uVersion,
+ unsigned int uMinVersion);
+
+/*************************************************************************//*!
+ pvrcb.c
+ *//**************************************************************************/
+
+int MODSUPGetBuffers(struct __DRIdrawableRec *psDRIDrawable,
+ unsigned int uFourCC, uint32_t *puStamp,
+ void *pvLoaderPrivate, uint32_t uBufferMask,
+ struct PVRDRIImageList *psImageList);
+
+bool MODSUPCreateConfigs(struct __DRIconfigRec ***psConfigs,
+ struct __DRIscreenRec *psDRIScreen,
+ int iPVRDRIMesaFormat, const uint8_t *puDepthBits,
+ const uint8_t *puStencilBits,
+ unsigned int uNumDepthStencilBits,
+ const unsigned int *puDBModes,
+ unsigned int uNumDBModes,
+ const uint8_t *puMSAASamples,
+ unsigned int uNumMSAAModes, bool bEnableAccum,
+ bool bColorDepthMatch, bool bMutableRenderBuffer,
+ int iYUVDepthRange, int iYUVCSCStandard,
+ uint32_t uMaxPbufferWidth, uint32_t uMaxPbufferHeight);
+
+struct __DRIconfigRec **MODSUPConcatConfigs(struct __DRIscreenRec *psDRIScreen,
+ struct __DRIconfigRec **ppsConfigA,
+ struct __DRIconfigRec **ppsConfigB);
+
+__DRIimage *MODSUPLookupEGLImage(struct __DRIscreenRec *psDRIScreen,
+ void *pvImage, void *pvLoaderPrivate);
+
+unsigned int MODSUPGetCapability(struct __DRIscreenRec *psDRIScreen,
+ unsigned int uCapability);
+
+int MODSUPGetDisplayFD(struct __DRIscreenRec *psDRIScreen,
+ void *pvLoaderPrivate);
+
+bool PVRDRIConfigQuery(const PVRDRIConfig *psConfig,
+ PVRDRIConfigAttrib eConfigAttrib, int *piValueOut);
+
+bool MODSUPConfigQuery(const PVRDRIConfig *psConfig,
+ PVRDRIConfigAttrib eConfigAttrib,
+ unsigned int *puValueOut);
+
+void MODSUPFlushFrontBuffer(struct __DRIdrawableRec *psDRIDrawable,
+ void *pvLoaderPrivate);
+
+void *MODSUPDrawableGetReferenceHandle(struct __DRIdrawableRec *psDRIDrawable);
+
+void MODSUPDrawableAddReference(void *pvReferenceHandle);
+
+void MODSUPDrawableRemoveReference(void *pvReferenceHandle);
+
+#endif /* defined(__PVRDRI_H__) */
diff --git a/src/mesa/drivers/dri/pvr/pvrdri_support.h b/src/mesa/drivers/dri/pvr/pvrdri_support.h
new file mode 100644
index 00000000000..58ea3505a4d
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrdri_support.h
@@ -0,0 +1,206 @@
+/*
+ * Copyright (c) Imagination Technologies Ltd.
+ *
+ * The contents of this file are subject to the MIT license as set out below.
+ *
+ * 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 without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
+
+#if !defined(__PVRDRI_SUPPORT_H__)
+#define __PVRDRI_SUPPORT_H__
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "dri_support.h"
+
+struct DRISUPScreen *DRISUPCreateScreen(struct __DRIscreenRec *psDRIScreen,
+ int iFD, bool bUseInvalidate,
+ void *pvLoaderPrivate,
+ const struct __DRIconfigRec ***pppsConfigs,
+ int *piMaxGLES1Version,
+ int *piMaxGLES2Version);
+void DRISUPDestroyScreen(struct DRISUPScreen *psDRISUPScreen);
+
+unsigned int DRISUPCreateContext(PVRDRIAPIType eAPI,
+ PVRDRIConfig *psPVRDRIConfig,
+ struct PVRDRIContextConfig *psCtxConfig,
+ struct __DRIcontextRec *psDRIContext,
+ struct DRISUPContext *psDRISUPSharedContext,
+ struct DRISUPScreen *psDRISUPScreen,
+ struct DRISUPContext **ppsDRISUPContext);
+void DRISUPDestroyContext(struct DRISUPContext *psDRISUPContext);
+
+struct DRISUPDrawable *DRISUPCreateDrawable(struct __DRIdrawableRec *psDRIDrawable,
+ struct DRISUPScreen *psDRISUPScreen,
+ void *pvLoaderPrivate,
+ PVRDRIConfig *psPVRDRIConfig);
+void DRISUPDestroyDrawable(struct DRISUPDrawable *psDRISUPDrawable);
+
+bool DRISUPMakeCurrent(struct DRISUPContext *psDRISUPContext,
+ struct DRISUPDrawable *psDRISUPWrite,
+ struct DRISUPDrawable *psDRISUPRead);
+bool DRISUPUnbindContext(struct DRISUPContext *psDRISUPContext);
+
+struct DRISUPBuffer *DRISUPAllocateBuffer(struct DRISUPScreen *psDRISUPScreen,
+ unsigned int uAttchment,
+ unsigned int uFormat,
+ int iWidth, int iHeight,
+ unsigned int *puName,
+ unsigned int *puPitch,
+ unsigned int *puCPP,
+ unsigned int *puFlags);
+void DRISUPReleaseBuffer(struct DRISUPScreen *psDRISUPScreen,
+ struct DRISUPBuffer *psDRISUPBuffer);
+void DRISUPSetTexBuffer2(struct DRISUPContext *psDRISUPContext,
+ int iTarget, int iFormat,
+ struct DRISUPDrawable *psDRISUPDrawable);
+void DRISUPReleaseTexBuffer(struct DRISUPContext *psDRISUPContext,
+ int iTarget,
+ struct DRISUPDrawable *psDRISUPDrawable);
+
+void DRISUPFlush(struct DRISUPDrawable *psDRISUPDrawable);
+void DRISUPInvalidate(struct DRISUPDrawable *psDRISUPDrawable);
+void DRISUPFlushWithFlags(struct DRISUPContext *psDRISUPContext,
+ struct DRISUPDrawable *psDRISUPDrawable,
+ unsigned int uFlags, unsigned int uThrottleReason);
+
+__DRIimage *DRISUPCreateImageFromName(struct DRISUPScreen *psDRISUPScreen,
+ int iWidth, int iHeight, int iFourCC,
+ int iName, int iPitch,
+ void *pvLoaderPrivate);
+__DRIimage *DRISUPCreateImageFromRenderbuffer(struct DRISUPContext *psDRISUPContext,
+ int iRenderBuffer,
+ void *pvLoaderPrivate);
+void DRISUPDestroyImage(__DRIimage *psImage);
+__DRIimage *DRISUPCreateImage(struct DRISUPScreen *psDRISUPScreen,
+ int iWidth, int iHeight, int iFourCC,
+ unsigned int uUse, void *pvLoaderPrivate);
+bool DRISUPQueryImage(__DRIimage *psImage, int iAttrib, int *piValue);
+__DRIimage *DRISUPDupImage(__DRIimage *psImage, void *pvLoaderPrivate);
+bool DRISUPValidateImageUsage(__DRIimage *psImage, unsigned int uUse);
+__DRIimage *DRISUPCreateImageFromNames(struct DRISUPScreen *psDRISUPScreen,
+ int iWidth, int iHeight, int iFourCC,
+ int *piNames, int iNumNames,
+ int *piStrides, int *piOffsets,
+ void *pvLoaderPrivate);
+__DRIimage *DRISUPFromPlanar(__DRIimage *psImage, int iPlane,
+ void *pvLoaderPrivate);
+__DRIimage *DRISUPCreateImageFromTexture(struct DRISUPContext *psDRISUPContext,
+ int iTarget, unsigned int uTexture,
+ int iDepth, int iLevel,
+ unsigned int *puError,
+ void *pvLoaderPrivate);
+__DRIimage *DRISUPCreateImageFromFDs(struct DRISUPScreen *psDRISUPcreen,
+ int iWidth, int iHeight, int iFourCC,
+ int *piFDs, int iNumFDs,
+ int *piStrides, int *piOffsets,
+ void *pvLoaderPrivate);
+__DRIimage *DRISUPCreateImageFromDmaBufs(struct DRISUPScreen *psDRISUPScreen,
+ int iWidth, int iHeight, int iFourCC,
+ int *piFDs, int iNumFDs,
+ int *piStrides, int *piOffsets,
+ unsigned int uColorSpace,
+ unsigned int uSampleRange,
+ unsigned int uHorizSiting,
+ unsigned int uVertSiting,
+ unsigned int *puError,
+ void *pvLoaderPrivate);
+int DRISUPGetImageCapabilities(struct DRISUPScreen *psDRISUPScreen);
+void DRISUPBlitImage(struct DRISUPContext *psDRISUPContext,
+ __DRIimage *psDst, __DRIimage *psSrc,
+ int iDstX0, int iDstY0, int iDstWidth, int iDstHeight,
+ int iSrcX0, int iSrcY0, int iSrcWidth, int iSrcHeight,
+ int iFlushFlag);
+void *DRISUPMapImage(struct DRISUPContext *psDRISUPContext,
+ __DRIimage *psImage,
+ int iX0, int iY0, int iWidth, int iHeight,
+ unsigned int uFlags, int *piStride, void **ppvData);
+void DRISUPUnmapImage(struct DRISUPContext *psDRISUPContext,
+ __DRIimage *psImage, void *pvData);
+__DRIimage *DRISUPCreateImageWithModifiers(struct DRISUPScreen *psDRISUPScreen,
+ int iWidth, int iHeight, int iFourCC,
+ const uint64_t *puModifiers,
+ const unsigned int uModifierCount,
+ void *pvLoaderPrivate);
+__DRIimage *DRISUPCreateImageFromDMABufs2(struct DRISUPScreen *psDRISUPScreen,
+ int iWidth, int iHeight,
+ int iFourCC, uint64_t uModifier,
+ int *piFDs, int iNumFDs,
+ int *piStrides, int *piOffsets,
+ unsigned int uColorSpace,
+ unsigned int uSampleRange,
+ unsigned int uHorizSiting,
+ unsigned int uVertSiting,
+ unsigned int *puError,
+ void *pvLoaderPrivate);
+
+bool DRISUPQueryDMABufFormats(struct DRISUPScreen *psDRISUPScreen, int iMax,
+ int *piFormats, int *piCount);
+bool DRISUPQueryDMABufModifiers(struct DRISUPScreen *psDRISUPScreen,
+ int iFourCC, int iMax, uint64_t *puModifiers,
+ unsigned int *piExternalOnly, int *piCount);
+bool DRISUPQueryDMABufFormatModifierAttribs(struct DRISUPScreen *psDRISUPScreen,
+ uint32_t uFourcc,
+ uint64_t uModifier,
+ int iAttrib, uint64_t *puValue);
+
+__DRIimage *DRISUPCreateImageFromRenderBuffer2(struct DRISUPContext *psDRISUPContext,
+ int iRenderBuffer,
+ void *pvLoaderPrivate,
+ unsigned int *puError);
+
+__DRIimage *DRISUPCreateImageFromBuffer(struct DRISUPContext *psDRISUPContext,
+ int iTarget, void *pvBuffer,
+ unsigned int *puError,
+ void *pvLoaderPrivate);
+
+int DRISUPQueryRendererInteger(struct DRISUPScreen *psDRISUPScreen,
+ int iAttribute, unsigned int *puValue);
+int DRISUPQueryRendererString(struct DRISUPScreen *psDRISUPScreen,
+ int iAttribute, const char **ppszValue);
+
+void *DRISUPCreateFence(struct DRISUPContext *psDRISUPContext);
+void DRISUPDestroyFence(struct DRISUPScreen *psDRISUPScreen, void *pvFence);
+bool DRISUPClientWaitSync(struct DRISUPContext *psDRISUPContext,
+ void *pvFence, unsigned int uFlags,
+ uint64_t uTimeout);
+void DRISUPServerWaitSync(struct DRISUPContext *psDRISUPContext,
+ void *pvFence, unsigned int uFlags);
+unsigned int DRISUPGetFenceCapabilities(struct DRISUPScreen *psDRISUPScreen);
+void *DRISUPCreateFenceFD(struct DRISUPContext *psDRISUPContext, int iFD);
+int DRISUPGetFenceFD(struct DRISUPScreen *psDRISUPScreen, void *pvFence);
+void *DRISUPGetFenceFromCLEvent(struct DRISUPScreen *psDRISUPScreen,
+ intptr_t iCLEvent);
+int DRISUPGetAPIVersion(struct DRISUPScreen *psDRISUPScreen,
+ PVRDRIAPIType eAPI);
+
+unsigned int DRISUPGetNumAPIProcs(struct DRISUPScreen *psDRISUPScreen,
+ PVRDRIAPIType eAPI);
+const char *DRISUPGetAPIProcName(struct DRISUPScreen *psDRISUPScreen,
+ PVRDRIAPIType eAPI, unsigned int uIndex);
+void *DRISUPGetAPIProcAddress(struct DRISUPScreen *psDRISUPScreen,
+ PVRDRIAPIType eAPI, unsigned int uIndex);
+
+void DRISUPSetDamageRegion(struct DRISUPDrawable *psDRISUPDrawable,
+ unsigned int uNRects, int *piRects);
+
+bool DRISUPHaveGetFenceFromCLEvent(void);
+
+#endif /* defined(__PVRDRI_SUPPORT_H__) */
diff --git a/src/mesa/drivers/dri/pvr/pvrext.c b/src/mesa/drivers/dri/pvr/pvrext.c
new file mode 100644
index 00000000000..478399618df
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrext.c
@@ -0,0 +1,704 @@
+/*
+ * Copyright (c) Imagination Technologies Ltd.
+ *
+ * The contents of this file are subject to the MIT license as set out below.
+ *
+ * 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 without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
+
+/*
+ * EXTENSION SUPPORT
+ *
+ * As the driver supports a range of Mesa versions it can be the case that it
+ * needs to support different extensions and extension versions depending on
+ * the version of Mesa that it's built against. As a guide the following rules
+ * should be followed:
+ *
+ * 1) If an extension appears in some supported versions of Mesa but not others
+ * then it should be protected by the extension define, e.g.:
+ * #if defined(__DRI_IMAGE)
+ * <code>
+ * #endif
+ *
+ * However, if it appears in all versions then there's no need for it to
+ * be protected.
+ *
+ * 2) Each driver supported extension should have a define for the maximum
+ * version supported by the driver. This should be used when initialising
+ * the corresponding extension structure. The Mesa extension version define
+ * should *NOT* be used.
+ *
+ * 3) If the driver supports a range of versions for a given extension then
+ * it should protect the extension code based on the Mesa extension version
+ * define. For example, if the driver has to support versions 7 to 8 of the
+ * __DRI_IMAGE extension then any fields, in the __DRIimageExtension
+ * structure, that appear in version 8 but not 7 should be protected as
+ * follows:
+ * #if (__DRI_IMAGE_VERSION >= 8)
+ * .createImageFromDmaBufs = PVRDRICreateImageFromDmaBufs,
+ * #endif
+ *
+ * Obviously any other associated code should also be protected in the same
+ * way.
+ */
+
+#include "dri_util.h"
+#include "utils.h"
+
+#include "dri_support.h"
+#include "pvrdri.h"
+
+#include "EGL/egl.h"
+#include "EGL/eglext.h"
+#include "EGL/eglmesaext.h"
+
+/* Maximum version numbers for each supported extension */
+#define PVR_DRI_TEX_BUFFER_VERSION 3
+#define PVR_DRI2_FLUSH_VERSION 4
+#define PVR_DRI_IMAGE_VERSION 17
+#define PVR_DRI2_ROBUSTNESS_VERSION 1
+#define PVR_DRI2_FENCE_VERSION 2
+#define PVR_DRI2_RENDERER_QUERY_VERSION 1
+#define PVR_DRI2_BUFFER_DAMAGE_VERSION 1
+
+static void
+PVRDRIExtSetTexBuffer(__DRIcontext *psDRIContext, GLint iTarget,
+ GLint iFormat, __DRIdrawable *psDRIDrawable)
+{
+ PVRDRIDrawable *psPVRDrawable = psDRIDrawable->driverPrivate;
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+
+ DRISUPSetTexBuffer2(psPVRContext->psDRISUPContext,
+ iTarget, iFormat, psPVRDrawable->psDRISUPDrawable);
+}
+
+static void
+PVRDRIExtReleaseTexBuffer(__DRIcontext *psDRIContext, GLint iTarget,
+ __DRIdrawable *psDRIDrawable)
+{
+ PVRDRIDrawable *psPVRDrawable = psDRIDrawable->driverPrivate;
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+
+ DRISUPReleaseTexBuffer(psPVRContext->psDRISUPContext,
+ iTarget, psPVRDrawable->psDRISUPDrawable);
+
+}
+
+static __DRItexBufferExtension pvrDRITexBufferExtension = {
+ .base = {
+ .name = __DRI_TEX_BUFFER,
+ .version = PVR_DRI_TEX_BUFFER_VERSION,
+ },
+ .setTexBuffer = NULL,
+ .setTexBuffer2 = PVRDRIExtSetTexBuffer,
+ .releaseTexBuffer = PVRDRIExtReleaseTexBuffer,
+};
+
+static void
+PVRDRI2Flush(__DRIdrawable *psDRIDrawable)
+{
+ PVRDRIDrawable *psPVRDrawable = psDRIDrawable->driverPrivate;
+
+ DRISUPFlush(psPVRDrawable->psDRISUPDrawable);
+}
+
+static void
+PVRDRI2Invalidate(__DRIdrawable *psDRIDrawable)
+{
+ PVRDRIDrawable *psPVRDrawable = psDRIDrawable->driverPrivate;
+
+ DRISUPInvalidate(psPVRDrawable->psDRISUPDrawable);
+}
+
+static void
+PVRDRI2FlushWithFlags(__DRIcontext *psDRIContext,
+ __DRIdrawable *psDRIDrawable,
+ unsigned int uFlags,
+ enum __DRI2throttleReason eThrottleReason)
+{
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+ struct DRISUPDrawable *psDRISUPDrawable;
+
+ if ((uFlags & __DRI2_FLUSH_DRAWABLE) != 0) {
+ PVRDRIDrawable *psPVRDrawable = psDRIDrawable->driverPrivate;
+
+ psDRISUPDrawable = psPVRDrawable->psDRISUPDrawable;
+ } else {
+ psDRISUPDrawable = NULL;
+ }
+
+ DRISUPFlushWithFlags(psPVRContext->psDRISUPContext, psDRISUPDrawable,
+ uFlags, (unsigned int) eThrottleReason);
+}
+
+static __DRI2flushExtension pvrDRI2FlushExtension = {
+ .base = {
+ .name = __DRI2_FLUSH,
+ .version = PVR_DRI2_FLUSH_VERSION,
+ },
+ .flush = PVRDRI2Flush,
+ .invalidate = PVRDRI2Invalidate,
+ .flush_with_flags = PVRDRI2FlushWithFlags,
+};
+
+static __DRIimage *
+PVRDRICreateImageFromName(__DRIscreen *psDRIScreen, int iWidth, int iHeight,
+ int iFormat, int iName, int iPitch,
+ void *pvLoaderPrivate)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+ int iFourCC = PVRDRIFormatToFourCC(iFormat);
+
+ return DRISUPCreateImageFromName(psPVRScreen->psDRISUPScreen,
+ iWidth, iHeight, iFourCC, iName, iPitch,
+ pvLoaderPrivate);
+}
+
+static __DRIimage *
+PVRDRICreateImageFromRenderbuffer(__DRIcontext *psDRIContext,
+ int iRenderBuffer, void *pvLoaderPrivate)
+{
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+
+ return DRISUPCreateImageFromRenderbuffer(psPVRContext->psDRISUPContext,
+ iRenderBuffer, pvLoaderPrivate);
+}
+
+static void
+PVRDRIDestroyImage(__DRIimage *psImage)
+{
+ DRISUPDestroyImage(psImage);
+}
+
+static __DRIimage *
+PVRDRICreateImage(__DRIscreen *psDRIScreen, int iWidth, int iHeight,
+ int iFormat, unsigned int uUse, void *pvLoaderPrivate)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+ int iFourCC = PVRDRIFormatToFourCC(iFormat);
+
+ return DRISUPCreateImage(psPVRScreen->psDRISUPScreen, iWidth, iHeight,
+ iFourCC, uUse, pvLoaderPrivate);
+}
+
+static GLboolean
+PVRDRIQueryImage(__DRIimage *psImage, int iAttrib, int *piValue)
+{
+ int iFourCC;
+
+ switch (iAttrib) {
+ case __DRI_IMAGE_ATTRIB_FORMAT:
+ if (DRISUPQueryImage(psImage,
+ __DRI_IMAGE_ATTRIB_FOURCC, &iFourCC)) {
+ *piValue = PVRDRIFourCCToDRIFormat(iFourCC);
+ return GL_TRUE;
+ }
+ return GL_FALSE;
+ default:
+ return DRISUPQueryImage(psImage, iAttrib, piValue);
+ }
+
+}
+
+static __DRIimage *
+PVRDRIDupImage(__DRIimage *psImage, void *pvLoaderPrivate)
+{
+ return DRISUPDupImage(psImage, pvLoaderPrivate);
+}
+
+static GLboolean
+PVRDRIValidateImageUsage(__DRIimage *psImage, unsigned int uUse)
+{
+ return DRISUPValidateImageUsage(psImage, uUse);
+}
+
+static __DRIimage *
+PVRDRICreateImageFromNames(__DRIscreen *psDRIScreen, int iWidth, int iHeight,
+ int iFourCC, int *piNames, int iNumNames,
+ int *piStrides, int *piOffsets,
+ void *pvLoaderPrivate)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+
+ return DRISUPCreateImageFromNames(psPVRScreen->psDRISUPScreen,
+ iWidth, iHeight, iFourCC,
+ piNames, iNumNames,
+ piStrides, piOffsets, pvLoaderPrivate);
+}
+
+static __DRIimage *
+PVRDRIFromPlanar(__DRIimage *psImage, int iPlane, void *pvLoaderPrivate)
+{
+ return DRISUPFromPlanar(psImage, iPlane, pvLoaderPrivate);
+}
+
+static __DRIimage *
+PVRDRICreateImageFromTexture(__DRIcontext *psDRIContext, int iTarget,
+ unsigned int uTexture, int iDepth, int iLevel,
+ unsigned int *puError, void *pvLoaderPrivate)
+{
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+ int iEGLTarget;
+
+ switch (iTarget) {
+ case GL_TEXTURE_2D:
+ iEGLTarget = PVRDRI_GL_TEXTURE_2D;
+ break;
+ case GL_TEXTURE_3D:
+ iEGLTarget = PVRDRI_GL_TEXTURE_3D;
+ break;
+ case GL_TEXTURE_CUBE_MAP:
+ iEGLTarget = PVRDRI_GL_TEXTURE_CUBE_MAP_POSITIVE_X;
+ break;
+ default:
+ errorMessage("%s: GL Target %d is not supported",
+ __func__, iTarget);
+ *puError = __DRI_IMAGE_ERROR_BAD_PARAMETER;
+ return NULL;
+ }
+
+ return DRISUPCreateImageFromTexture(psPVRContext->psDRISUPContext,
+ iEGLTarget, uTexture, iDepth, iLevel,
+ puError, pvLoaderPrivate);
+}
+
+static __DRIimage *
+PVRDRICreateImageFromFds(__DRIscreen *psDRIScreen, int iWidth, int iHeight,
+ int iFourCC, int *piFDs, int iNumFDs,
+ int *piStrides, int *piOffsets,
+ void *pvLoaderPrivate)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+
+ return DRISUPCreateImageFromFDs(psPVRScreen->psDRISUPScreen,
+ iWidth, iHeight, iFourCC, piFDs, iNumFDs,
+ piStrides, piOffsets, pvLoaderPrivate);
+}
+
+static __DRIimage *
+PVRDRICreateImageFromDmaBufs(__DRIscreen *psDRIScreen,
+ int iWidth, int iHeight, int iFourCC,
+ int *piFDs, int iNumFDs,
+ int *piStrides, int *piOffsets,
+ enum __DRIYUVColorSpace eColorSpace,
+ enum __DRISampleRange eSampleRange,
+ enum __DRIChromaSiting eHorizSiting,
+ enum __DRIChromaSiting eVertSiting,
+ unsigned int *puError, void *pvLoaderPrivate)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+
+ return DRISUPCreateImageFromDmaBufs(psPVRScreen->psDRISUPScreen,
+ iWidth, iHeight, iFourCC,
+ piFDs, iNumFDs, piStrides, piOffsets,
+ (unsigned int) eColorSpace,
+ (unsigned int) eSampleRange,
+ (unsigned int) eHorizSiting,
+ (unsigned int) eVertSiting,
+ puError, pvLoaderPrivate);
+}
+
+static void
+PVRDRIBlitImage(__DRIcontext *psDRIContext,
+ __DRIimage *psDst, __DRIimage *psSrc,
+ int iDstX0, int iDstY0, int iDstWidth, int iDstHeight,
+ int iSrcX0, int iSrcY0, int iSrcWidth, int iSrcHeight,
+ int iFlushFlag)
+{
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+
+ return DRISUPBlitImage(psPVRContext->psDRISUPContext,
+ psDst, psSrc,
+ iDstX0, iDstY0, iDstWidth, iDstHeight,
+ iSrcX0, iSrcY0, iSrcWidth, iSrcHeight,
+ iFlushFlag);
+}
+
+static int
+PVRDRIGetCapabilities(__DRIscreen *psDRIScreen)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+
+ return DRISUPGetImageCapabilities(psPVRScreen->psDRISUPScreen);
+}
+
+static void *
+PVRDRIMapImage(__DRIcontext *psDRIContext, __DRIimage *psImage,
+ int iX0, int iY0, int iWidth, int iHeight,
+ unsigned int iFlags, int *piStride, void **ppvData)
+{
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+
+ return DRISUPMapImage(psPVRContext->psDRISUPContext, psImage,
+ iX0, iY0, iWidth, iHeight, iFlags, piStride,
+ ppvData);
+}
+
+static void
+PVRDRIUnmapImage(__DRIcontext *psDRIContext, __DRIimage *psImage,
+ void *pvData)
+{
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+
+ return DRISUPUnmapImage(psPVRContext->psDRISUPContext, psImage, pvData);
+}
+
+static __DRIimage *
+PVRDRICreateImageWithModifiers(__DRIscreen *psDRIScreen,
+ int iWidth, int iHeight, int iFormat,
+ const uint64_t *puModifiers,
+ const unsigned int uModifierCount,
+ void *pvLoaderPrivate)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+ int iFourCC = PVRDRIFormatToFourCC(iFormat);
+
+ return DRISUPCreateImageWithModifiers(psPVRScreen->psDRISUPScreen,
+ iWidth, iHeight, iFourCC,
+ puModifiers, uModifierCount,
+ pvLoaderPrivate);
+}
+
+static __DRIimage *
+PVRDRICreateImageFromDmaBufs2(__DRIscreen *psDRIScreen,
+ int iWidth, int iHeight,
+ int iFourCC, uint64_t uModifier,
+ int *piFDs, int iNumFDs,
+ int *piStrides, int *piOffsets,
+ enum __DRIYUVColorSpace eColorSpace,
+ enum __DRISampleRange eSampleRange,
+ enum __DRIChromaSiting eHorizSiting,
+ enum __DRIChromaSiting eVertSiting,
+ unsigned int *puError, void *pvLoaderPrivate)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+
+ return DRISUPCreateImageFromDMABufs2(psPVRScreen->psDRISUPScreen,
+ iWidth, iHeight, iFourCC, uModifier,
+ piFDs, iNumFDs, piStrides, piOffsets,
+ (unsigned int) eColorSpace,
+ (unsigned int) eSampleRange,
+ (unsigned int) eHorizSiting,
+ (unsigned int) eVertSiting,
+ puError, pvLoaderPrivate);
+}
+
+static GLboolean
+PVRDRIQueryDmaBufFormats(__DRIscreen *psDRIScreen, int iMax,
+ int *piFormats, int *piCount)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+
+ return DRISUPQueryDMABufFormats(psPVRScreen->psDRISUPScreen, iMax,
+ piFormats, piCount);
+}
+
+static GLboolean
+PVRDRIQueryDmaBufModifiers(__DRIscreen *psDRIScreen, int iFourCC, int iMax,
+ uint64_t *puModifiers,
+ unsigned int *puExternalOnly, int *piCount)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+
+ return DRISUPQueryDMABufModifiers(psPVRScreen->psDRISUPScreen, iFourCC,
+ iMax,
+ puModifiers, puExternalOnly, piCount);
+}
+
+static GLboolean
+PVRDRIQueryDmaBufFormatModifierAttribs(__DRIscreen *psDRIScreen,
+ uint32_t uFourCC, uint64_t uModifier,
+ int iAttrib, uint64_t *puValue)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+ struct DRISUPScreen *psDRISUPScreen = psPVRScreen->psDRISUPScreen;
+
+ return DRISUPQueryDMABufFormatModifierAttribs(psDRISUPScreen, uFourCC,
+ uModifier, iAttrib, puValue);
+}
+
+static __DRIimage *
+PVRDRICreateImageFromRenderbuffer2(__DRIcontext *psDRIContext,
+ int iRenderBuffer, void *pvLoaderPrivate,
+ unsigned int *puError)
+{
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+ struct DRISUPContext *psDRISUPContext = psPVRContext->psDRISUPContext;
+
+ return DRISUPCreateImageFromRenderBuffer2(psDRISUPContext, iRenderBuffer,
+ pvLoaderPrivate, puError);
+}
+
+#if defined(EGL_IMG_cl_image)
+static __DRIimage *
+PVRDRICreateImageFromBuffer(__DRIcontext *psDRIContext, int iTarget,
+ void *pvBuffer, unsigned int *puError,
+ void *pvLoaderPrivate)
+{
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+
+ return DRISUPCreateImageFromBuffer(psPVRContext->psDRISUPContext, iTarget,
+ pvBuffer, puError, pvLoaderPrivate);
+}
+#endif
+
+static __DRIimageExtension pvrDRIImage = {
+ .base = {
+ .name = __DRI_IMAGE,
+ .version = PVR_DRI_IMAGE_VERSION,
+ },
+ .createImageFromName = PVRDRICreateImageFromName,
+ .createImageFromRenderbuffer = PVRDRICreateImageFromRenderbuffer,
+ .destroyImage = PVRDRIDestroyImage,
+ .createImage = PVRDRICreateImage,
+ .queryImage = PVRDRIQueryImage,
+ .dupImage = PVRDRIDupImage,
+ .validateUsage = PVRDRIValidateImageUsage,
+ .createImageFromNames = PVRDRICreateImageFromNames,
+ .fromPlanar = PVRDRIFromPlanar,
+ .createImageFromTexture = PVRDRICreateImageFromTexture,
+ .createImageFromFds = PVRDRICreateImageFromFds,
+ .createImageFromDmaBufs = PVRDRICreateImageFromDmaBufs,
+ .blitImage = PVRDRIBlitImage,
+ .getCapabilities = PVRDRIGetCapabilities,
+ .mapImage = PVRDRIMapImage,
+ .unmapImage = PVRDRIUnmapImage,
+ .createImageWithModifiers = PVRDRICreateImageWithModifiers,
+ .createImageFromDmaBufs2 = PVRDRICreateImageFromDmaBufs2,
+ .queryDmaBufFormats = PVRDRIQueryDmaBufFormats,
+ .queryDmaBufModifiers = PVRDRIQueryDmaBufModifiers,
+ .queryDmaBufFormatModifierAttribs =
+ PVRDRIQueryDmaBufFormatModifierAttribs,
+ .createImageFromRenderbuffer2 = PVRDRICreateImageFromRenderbuffer2,
+#if defined(EGL_IMG_cl_image)
+ .createImageFromBuffer = PVRDRICreateImageFromBuffer,
+#endif
+};
+
+static __DRIrobustnessExtension pvrDRIRobustness = {
+ .base = {
+ .name = __DRI2_ROBUSTNESS,
+ .version = PVR_DRI2_ROBUSTNESS_VERSION,
+ }
+};
+
+static int
+PVRDRIQueryRendererInteger(__DRIscreen *psDRIScreen, int iAttribute,
+ unsigned int *puValue)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+ int res;
+
+ res = DRISUPQueryRendererInteger(psPVRScreen->psDRISUPScreen,
+ iAttribute, puValue);
+ if (res == -1)
+ return driQueryRendererIntegerCommon(psDRIScreen, iAttribute, puValue);
+
+ return res;
+}
+
+static int
+PVRDRIQueryRendererString(__DRIscreen *psDRIScreen, int iAttribute,
+ const char **ppszValue)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+
+ return DRISUPQueryRendererString(psPVRScreen->psDRISUPScreen, iAttribute,
+ ppszValue);
+}
+
+static const __DRI2rendererQueryExtension pvrDRIRendererQueryExtension = {
+ .base = {
+ .name = __DRI2_RENDERER_QUERY,
+ .version = PVR_DRI2_RENDERER_QUERY_VERSION,
+ },
+ .queryInteger = PVRDRIQueryRendererInteger,
+ .queryString = PVRDRIQueryRendererString,
+};
+
+
+static void *
+PVRDRICreateFenceEXT(__DRIcontext *psDRIContext)
+{
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+
+ return DRISUPCreateFence(psPVRContext->psDRISUPContext);
+}
+
+static void
+PVRDRIDestroyFenceEXT(__DRIscreen *psDRIScreen, void *pvFence)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+
+ return DRISUPDestroyFence(psPVRScreen->psDRISUPScreen, pvFence);
+}
+
+static GLboolean
+PVRDRIClientWaitSyncEXT(__DRIcontext *psDRIContext, void *pvFence,
+ unsigned int uFlags, uint64_t uTimeout)
+{
+ struct DRISUPContext *psDRISUPContext;
+
+ if (psDRIContext) {
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+
+ psDRISUPContext = psPVRContext->psDRISUPContext;
+ } else {
+ psDRISUPContext = NULL;
+ }
+
+ return DRISUPClientWaitSync(psDRISUPContext, pvFence, uFlags, uTimeout);
+}
+
+static void
+PVRDRIServerWaitSyncEXT(__DRIcontext *psDRIContext, void *pvFence,
+ unsigned int uFlags)
+{
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+
+ return DRISUPServerWaitSync(psPVRContext->psDRISUPContext, pvFence, uFlags);
+}
+
+static unsigned int
+PVRDRIGetFenceCapabilitiesEXT(__DRIscreen *psDRIScreen)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+
+ return DRISUPGetFenceCapabilities(psPVRScreen->psDRISUPScreen);
+}
+
+static void *
+PVRDRICreateFenceFdEXT(__DRIcontext *psDRIContext, int iFD)
+{
+ PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+
+ return DRISUPCreateFenceFD(psPVRContext->psDRISUPContext, iFD);
+}
+
+static int
+PVRDRIGetFenceFdEXT(__DRIscreen *psDRIScreen, void *pvFence)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+
+ return DRISUPGetFenceFD(psPVRScreen->psDRISUPScreen, pvFence);
+}
+
+static void *
+PVRDRIGetFenceFromClEventEXT(__DRIscreen *psDRIScreen, intptr_t iClEvent)
+{
+ PVRDRIScreen *psPVRScreen = psDRIScreen->driverPrivate;
+
+ return DRISUPGetFenceFromCLEvent(psPVRScreen->psDRISUPScreen, iClEvent);
+}
+
+__DRI2fenceExtension pvrDRIFenceExtension = {
+ .base = {
+ .name = __DRI2_FENCE,
+ .version = PVR_DRI2_FENCE_VERSION,
+ },
+ .create_fence = PVRDRICreateFenceEXT,
+ .get_fence_from_cl_event = PVRDRIGetFenceFromClEventEXT,
+ .destroy_fence = PVRDRIDestroyFenceEXT,
+ .client_wait_sync = PVRDRIClientWaitSyncEXT,
+ .server_wait_sync = PVRDRIServerWaitSyncEXT,
+ .get_capabilities = PVRDRIGetFenceCapabilitiesEXT,
+ .create_fence_fd = PVRDRICreateFenceFdEXT,
+ .get_fence_fd = PVRDRIGetFenceFdEXT,
+};
+
+static void
+PVRDRISetDamageRegion(__DRIdrawable *psDRIDrawable,
+ unsigned int uNRects, int *piRects)
+{
+ PVRDRIDrawable *psPVRDrawable = psDRIDrawable->driverPrivate;
+
+ DRISUPSetDamageRegion(psPVRDrawable->psDRISUPDrawable, uNRects, piRects);
+}
+
+const __DRI2bufferDamageExtension pvrDRIbufferDamageExtension = {
+ .base = {
+ .name = __DRI2_BUFFER_DAMAGE,
+ .version = PVR_DRI2_BUFFER_DAMAGE_VERSION,
+ },
+ .set_damage_region = PVRDRISetDamageRegion,
+};
+
+/*
+ * Extension lists
+ *
+ * NOTE: When adding a new screen extension asScreenExtensionVersionInfo
+ * should also be updated accordingly.
+ */
+static const __DRIextension *apsScreenExtensions[] = {
+ &pvrDRITexBufferExtension.base,
+ &pvrDRI2FlushExtension.base,
+ &pvrDRIImage.base,
+ &pvrDRIRobustness.base,
+ &pvrDRIRendererQueryExtension.base,
+ &pvrDRIFenceExtension.base,
+ &pvrDRIbufferDamageExtension.base,
+ &dri2ConfigQueryExtension.base,
+ NULL
+};
+
+static const __DRIextension asScreenExtensionVersionInfo[] = {
+ {.name = __DRI_TEX_BUFFER,.version = __DRI_TEX_BUFFER_VERSION},
+ {.name = __DRI2_FLUSH,.version = __DRI2_FLUSH_VERSION},
+ {.name = __DRI_IMAGE,.version = __DRI_IMAGE_VERSION},
+ {.name = __DRI2_ROBUSTNESS,.version = __DRI2_ROBUSTNESS_VERSION},
+ {.name = __DRI2_RENDERER_QUERY,.version = __DRI2_RENDERER_QUERY_VERSION},
+ {.name = __DRI2_FENCE,.version = __DRI2_FENCE_VERSION},
+ {.name = __DRI2_BUFFER_DAMAGE,.version = __DRI2_BUFFER_DAMAGE_VERSION},
+ {.name = __DRI2_CONFIG_QUERY,.version = __DRI2_CONFIG_QUERY_VERSION},
+ {.name = NULL,.version = 0},
+};
+
+const __DRIextension **
+PVRDRIScreenExtensions(void)
+{
+ return apsScreenExtensions;
+}
+
+const __DRIextension *
+PVRDRIScreenExtensionVersionInfo(void)
+{
+ return asScreenExtensionVersionInfo;
+}
+
+void
+PVRDRIAdjustExtensions(unsigned int uVersion, unsigned int uMinVersion)
+{
+ switch (uVersion) {
+ default:
+ case 4:
+ /* Is the KHR_cl_event2 EGL extension supported? */
+ if (!DRISUPHaveGetFenceFromCLEvent())
+ pvrDRIFenceExtension.get_fence_from_cl_event = NULL;
+
+ break;
+ case 3:
+ break;
+ case 2:
+ case 1:
+ case 0:
+ /* The KHR_cl_event2 EGL extension is not supported */
+ pvrDRIFenceExtension.get_fence_from_cl_event = NULL;
+ break;
+ }
+}
diff --git a/src/mesa/drivers/dri/pvr/pvrmesa.h b/src/mesa/drivers/dri/pvr/pvrmesa.h
new file mode 100644
index 00000000000..5e1c9c1b2e6
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrmesa.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) Imagination Technologies Ltd.
+ *
+ * The contents of this file are subject to the MIT license as set out below.
+ *
+ * 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 without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS 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.
+ */
+
+#if !defined(__PVRMESA_H__)
+#define __PVRMESA_H__
+
+#include "pvrdri.h"
+
+void pvrdri_free_dispatch_tables(PVRDRIScreen *psPVRScreen);
+bool pvrdri_create_dispatch_table(PVRDRIScreen *psPVRScreen,
+ PVRDRIAPIType eAPI);
+void pvrdri_set_null_dispatch_table(void);
+void pvrdri_set_dispatch_table(PVRDRIContext *psPVRContext);
+
+#endif /* !defined(__PVRMESA_H__) */
diff --git a/src/mesa/drivers/dri/pvr/pvrutil.c b/src/mesa/drivers/dri/pvr/pvrutil.c
new file mode 100644
index 00000000000..945e18cf220
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrutil.c
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) Imagination Technologies Ltd.
+ *
+ * The contents of this file are subject to the MIT license as set out below.
+ *
+ * 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 without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS 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 <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+
+#include "drm-uapi/drm_fourcc.h"
+
+#include "utils.h"
+#include "dri_util.h"
+#include "pvrdri.h"
+
+#define MESSAGE_LENGTH_MAX 1024
+
+/*
+ * Define before including android/log.h and dlog.h as this is used by these
+ * headers.
+ */
+#define LOG_TAG "PVR-MESA"
+
+#if defined(HAVE_ANDROID_PLATFORM)
+#include <android/log.h>
+#define err_printf(f, args...) ((void)__android_log_print(ANDROID_LOG_ERROR, LOG_TAG, f, ##args))
+#define dbg_printf(f, args...) ((void)__android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, f, ##args))
+#elif defined(HAVE_TIZEN_PLATFORM)
+#include <dlog.h>
+#define err_printf(f, args...) LOGE(f, ##args)
+#define dbg_printf(f, args...) LOGD(f, ##args)
+#else
+#define err_printf(f, args...) fprintf(stderr, f "\n", ##args)
+#define dbg_printf(f, args...) fprintf(stderr, "LibGL: " f "\n", ##args)
+#endif /* HAVE_ANDROID_PLATFORM */
+
+/* Standard error message */
+void PRINTFLIKE(1, 2)
+errorMessage(const char *f, ...)
+{
+ char message[MESSAGE_LENGTH_MAX];
+ va_list args;
+
+ va_start(args, f);
+ vsnprintf(message, sizeof message, f, args);
+ va_end(args);
+
+ err_printf("%s", message);
+}
+
+void PRINTFLIKE(1, 2)
+__driUtilMessage(const char *f, ...)
+{
+ char message[MESSAGE_LENGTH_MAX];
+ va_list args;
+
+ /*
+ * On Android and Tizen, always print messages; otherwise, only print if
+ * the environment variable LIBGL_DEBUG=verbose.
+ */
+#if !defined(HAVE_ANDROID_PLATFORM) && !defined(HAVE_TIZEN_PLATFORM)
+ char *ev = getenv("LIBGL_DEBUG");
+
+ if (!ev || strcmp(ev, "verbose") != 0)
+ return;
+#endif
+
+ va_start(args, f);
+ vsnprintf(message, sizeof message, f, args);
+ va_end(args);
+
+ dbg_printf("%s", message);
+}
+
+mesa_format
+PVRDRIMesaFormatToMesaFormat(int pvrdri_mesa_format)
+{
+ switch (pvrdri_mesa_format) {
+ case PVRDRI_MESA_FORMAT_NONE:
+ return MESA_FORMAT_NONE;
+ case PVRDRI_MESA_FORMAT_B8G8R8A8_UNORM:
+ return MESA_FORMAT_B8G8R8A8_UNORM;
+ case PVRDRI_MESA_FORMAT_B8G8R8X8_UNORM:
+ return MESA_FORMAT_B8G8R8X8_UNORM;
+ case PVRDRI_MESA_FORMAT_B5G6R5_UNORM:
+ return MESA_FORMAT_B5G6R5_UNORM;
+ case PVRDRI_MESA_FORMAT_R8G8B8A8_UNORM:
+ return MESA_FORMAT_R8G8B8A8_UNORM;
+ case PVRDRI_MESA_FORMAT_R8G8B8X8_UNORM:
+ return MESA_FORMAT_R8G8B8X8_UNORM;
+ case PVRDRI_MESA_FORMAT_YCBCR:
+ return MESA_FORMAT_YCBCR;
+ case PVRDRI_MESA_FORMAT_YUV420_2PLANE:
+ return MESA_FORMAT_YUV420_2PLANE;
+ case PVRDRI_MESA_FORMAT_YVU420_2PLANE:
+ return MESA_FORMAT_YVU420_2PLANE;
+ case PVRDRI_MESA_FORMAT_B8G8R8A8_SRGB:
+ return MESA_FORMAT_B8G8R8A8_SRGB;
+ case PVRDRI_MESA_FORMAT_R8G8B8A8_SRGB:
+ return MESA_FORMAT_R8G8B8A8_SRGB;
+ default:
+ __driUtilMessage("%s: Unknown format: %d", __func__, pvrdri_mesa_format);
+ break;
+ }
+
+ return MESA_FORMAT_NONE;
+}
+
+int
+PVRDRIFormatToFourCC(int dri_format)
+{
+ switch (dri_format) {
+ case __DRI_IMAGE_FORMAT_RGB565:
+ return DRM_FORMAT_RGB565;
+ case __DRI_IMAGE_FORMAT_XRGB8888:
+ return DRM_FORMAT_XRGB8888;
+ case __DRI_IMAGE_FORMAT_ARGB8888:
+ return DRM_FORMAT_ARGB8888;
+ case __DRI_IMAGE_FORMAT_ABGR8888:
+ return DRM_FORMAT_ABGR8888;
+ case __DRI_IMAGE_FORMAT_XBGR8888:
+ return DRM_FORMAT_XBGR8888;
+ case __DRI_IMAGE_FORMAT_R8:
+ return DRM_FORMAT_R8;
+ case __DRI_IMAGE_FORMAT_GR88:
+ return DRM_FORMAT_GR88;
+ case __DRI_IMAGE_FORMAT_NONE:
+ return 0;
+ case __DRI_IMAGE_FORMAT_XRGB2101010:
+ return DRM_FORMAT_XRGB2101010;
+ case __DRI_IMAGE_FORMAT_ARGB2101010:
+ return DRM_FORMAT_ARGB2101010;
+ case __DRI_IMAGE_FORMAT_SARGB8:
+ return __DRI_IMAGE_FOURCC_SARGB8888;
+ case __DRI_IMAGE_FORMAT_ARGB1555:
+ return DRM_FORMAT_ARGB1555;
+ case __DRI_IMAGE_FORMAT_R16:
+ return DRM_FORMAT_R16;
+ case __DRI_IMAGE_FORMAT_GR1616:
+ return DRM_FORMAT_GR1616;
+ case __DRI_IMAGE_FORMAT_YUYV:
+ return DRM_FORMAT_YUYV;
+ case __DRI_IMAGE_FORMAT_XBGR2101010:
+ return DRM_FORMAT_XBGR2101010;
+ case __DRI_IMAGE_FORMAT_ABGR2101010:
+ return DRM_FORMAT_ABGR2101010;
+ case __DRI_IMAGE_FORMAT_SABGR8:
+ return __DRI_IMAGE_FOURCC_SABGR8888;
+ case __DRI_IMAGE_FORMAT_UYVY:
+ return DRM_FORMAT_UYVY;
+ case __DRI_IMAGE_FORMAT_ARGB4444:
+ return DRM_FORMAT_ARGB4444;
+ case __DRI_IMAGE_FORMAT_YVU444_PACK10_IMG:
+ return DRM_FORMAT_YVU444_PACK10_IMG;
+ case __DRI_IMAGE_FORMAT_BGR888:
+ return DRM_FORMAT_BGR888;
+ default:
+ __driUtilMessage("%s: Unknown format: %d", __func__, dri_format);
+ break;
+ }
+
+ return 0;
+}
+
+int
+PVRDRIFourCCToDRIFormat(int iFourCC)
+{
+ switch (iFourCC) {
+ case 0:
+ return __DRI_IMAGE_FORMAT_NONE;
+ case DRM_FORMAT_RGB565:
+ return __DRI_IMAGE_FORMAT_RGB565;
+ case DRM_FORMAT_XRGB8888:
+ return __DRI_IMAGE_FORMAT_XRGB8888;
+ case DRM_FORMAT_ARGB8888:
+ return __DRI_IMAGE_FORMAT_ARGB8888;
+ case DRM_FORMAT_ABGR8888:
+ return __DRI_IMAGE_FORMAT_ABGR8888;
+ case DRM_FORMAT_XBGR8888:
+ return __DRI_IMAGE_FORMAT_XBGR8888;
+ case DRM_FORMAT_R8:
+ return __DRI_IMAGE_FORMAT_R8;
+ case DRM_FORMAT_GR88:
+ return __DRI_IMAGE_FORMAT_GR88;
+ case DRM_FORMAT_XRGB2101010:
+ return __DRI_IMAGE_FORMAT_XRGB2101010;
+ case DRM_FORMAT_ARGB2101010:
+ return __DRI_IMAGE_FORMAT_ARGB2101010;
+ case __DRI_IMAGE_FOURCC_SARGB8888:
+ return __DRI_IMAGE_FORMAT_SARGB8;
+ case DRM_FORMAT_ARGB1555:
+ return __DRI_IMAGE_FORMAT_ARGB1555;
+ case DRM_FORMAT_R16:
+ return __DRI_IMAGE_FORMAT_R16;
+ case DRM_FORMAT_GR1616:
+ return __DRI_IMAGE_FORMAT_GR1616;
+ case DRM_FORMAT_YUYV:
+ return __DRI_IMAGE_FORMAT_YUYV;
+ case DRM_FORMAT_XBGR2101010:
+ return __DRI_IMAGE_FORMAT_XBGR2101010;
+ case DRM_FORMAT_ABGR2101010:
+ return __DRI_IMAGE_FORMAT_ABGR2101010;
+ case __DRI_IMAGE_FOURCC_SABGR8888:
+ return __DRI_IMAGE_FORMAT_SABGR8;
+ case DRM_FORMAT_UYVY:
+ return __DRI_IMAGE_FORMAT_UYVY;
+ case DRM_FORMAT_ARGB4444:
+ return __DRI_IMAGE_FORMAT_ARGB4444;
+ case DRM_FORMAT_YVU444_PACK10_IMG:
+ return __DRI_IMAGE_FORMAT_YVU444_PACK10_IMG;
+ case DRM_FORMAT_BGR888:
+ return __DRI_IMAGE_FORMAT_BGR888;
+ default:
+ __driUtilMessage("%s: Unknown format: %d", __func__, iFourCC);
+ break;
+ }
+
+ return 0;
+}
diff --git a/src/meson.build b/src/meson.build
index acc7fe94abb..c3bab27718d 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -25,6 +25,7 @@ inc_gallium = include_directories('gallium/include')
inc_gallium_aux = include_directories('gallium/auxiliary')
inc_amd_common = include_directories('amd/common')
inc_amd_common_llvm = include_directories('amd/llvm')
+inc_pvr = include_directories('mesa/main', 'mapi/glapi')
inc_tool = include_directories('tool')
pps_datasources = []
pps_includes = []
--
2.25.1
Reference in New Issue View Git Blame Copy Permalink