From e85a3db324dd8be32bb5d9028e2f90b0a1aab21d Mon Sep 17 00:00:00 2001
From: Frank Binns <frank.binns@imgtec.com>
Date: Wed, 3 Jul 2019 10:48:29 +0100
Subject: [PATCH 01/11] dri/pvr: Introduce PowerVR DRI driver.

Change-Id: Ied94552937389a736124347d2f068b7066eff198
---
 configure.ac                              |    7 +
 meson.build                               |   19 +-
 meson_options.txt                         |    4 +-
 src/mesa/drivers/dri/Makefile.am          |    6 +
 src/mesa/drivers/dri/meson.build          |    3 +
 src/mesa/drivers/dri/pvr/Makefile.am      |   44 +
 src/mesa/drivers/dri/pvr/Makefile.sources |   36 +
 src/mesa/drivers/dri/pvr/dri_support.h    |  969 ++++++++++++++
 src/mesa/drivers/dri/pvr/img_drm_fourcc.h |  110 ++
 src/mesa/drivers/dri/pvr/imgpixfmts.h     |   80 ++
 src/mesa/drivers/dri/pvr/imgyuv.h         |   58 +
 src/mesa/drivers/dri/pvr/mesa_context.c   |  258 ++++
 src/mesa/drivers/dri/pvr/meson.build      |   48 +
 src/mesa/drivers/dri/pvr/pvrcompat.c      | 1383 ++++++++++++++++++++
 src/mesa/drivers/dri/pvr/pvrdrawable.c    |  542 ++++++++
 src/mesa/drivers/dri/pvr/pvrdri.c         | 1018 +++++++++++++++
 src/mesa/drivers/dri/pvr/pvrdri.h         |  388 ++++++
 src/mesa/drivers/dri/pvr/pvrext.c         |  440 +++++++
 src/mesa/drivers/dri/pvr/pvrimage.c       | 1420 +++++++++++++++++++++
 src/mesa/drivers/dri/pvr/pvrimage.h       |  131 ++
 src/mesa/drivers/dri/pvr/pvrmesa.h        |   41 +
 src/mesa/drivers/dri/pvr/pvrutil.c        | 1067 ++++++++++++++++
 src/meson.build                           |    1 +
 23 files changed, 8064 insertions(+), 9 deletions(-)
 create mode 100644 src/mesa/drivers/dri/pvr/Makefile.am
 create mode 100644 src/mesa/drivers/dri/pvr/Makefile.sources
 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/pvrcompat.c
 create mode 100644 src/mesa/drivers/dri/pvr/pvrdrawable.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/pvrext.c
 create mode 100644 src/mesa/drivers/dri/pvr/pvrimage.c
 create mode 100644 src/mesa/drivers/dri/pvr/pvrimage.h
 create mode 100644 src/mesa/drivers/dri/pvr/pvrmesa.h
 create mode 100644 src/mesa/drivers/dri/pvr/pvrutil.c

diff --git a/configure.ac b/configure.ac
index d169223094f..4d9053bddfa 100644
--- a/configure.ac
+++ b/configure.ac
@@ -89,6 +89,7 @@ LIBDRM_REQUIRED=2.4.75
 LIBDRM_RADEON_REQUIRED=2.4.71
 LIBDRM_AMDGPU_REQUIRED=2.4.97
 LIBDRM_INTEL_REQUIRED=2.4.75
+LIBDRM_PVR_REQUIRED=2.4.60
 LIBDRM_NVVIEUX_REQUIRED=2.4.66
 LIBDRM_NOUVEAU_REQUIRED=2.4.66
 LIBDRM_ETNAVIV_REQUIRED=2.4.89
@@ -2081,6 +2082,10 @@ if test -n "$with_dri_drivers"; then
             HAVE_R200_DRI=yes
             PKG_CHECK_MODULES([RADEON], [libdrm >= $LIBDRM_RADEON_REQUIRED libdrm_radeon >= $LIBDRM_RADEON_REQUIRED])
             ;;
+        xpvr)
+            HAVE_PVR_DRI=yes;
+            PKG_CHECK_MODULES([PVR], [libdrm >= $LIBDRM_PVR_REQUIRED])
+            ;;
         xswrast)
             HAVE_SWRAST_DRI=yes
             ;;
@@ -2993,6 +2998,7 @@ AM_CONDITIONAL(HAVE_I965_DRI, test x$HAVE_I965_DRI = xyes)
 AM_CONDITIONAL(HAVE_NOUVEAU_DRI, test x$HAVE_NOUVEAU_DRI = xyes)
 AM_CONDITIONAL(HAVE_R200_DRI, test x$HAVE_R200_DRI = xyes)
 AM_CONDITIONAL(HAVE_RADEON_DRI, test x$HAVE_RADEON_DRI = xyes)
+AM_CONDITIONAL(HAVE_PVR_DRI, test x$HAVE_PVR_DRI = xyes)
 AM_CONDITIONAL(HAVE_SWRAST_DRI, test x$HAVE_SWRAST_DRI = xyes)
 
 AM_CONDITIONAL(HAVE_RADEON_VULKAN, test "x$HAVE_RADEON_VULKAN" = xyes)
@@ -3192,6 +3198,7 @@ AC_CONFIG_FILES([Makefile
                  src/mesa/drivers/dri/nouveau/Makefile
                  src/mesa/drivers/dri/r200/Makefile
                  src/mesa/drivers/dri/radeon/Makefile
+                 src/mesa/drivers/dri/pvr/Makefile
                  src/mesa/drivers/dri/swrast/Makefile
                  src/mesa/drivers/osmesa/Makefile
                  src/mesa/drivers/osmesa/osmesa.pc
diff --git a/meson.build b/meson.build
index bfff862c3c8..648233f15ce 100644
--- a/meson.build
+++ b/meson.build
@@ -96,9 +96,9 @@ if _drivers.contains('auto')
   if system_has_kms_drm
     # TODO: PPC, Sparc
     if ['x86', 'x86_64'].contains(host_machine.cpu_family())
-      _drivers = ['i915', 'i965', 'r100', 'r200', 'nouveau']
+      _drivers = ['i915', 'i965', 'r100', 'r200', 'nouveau', 'pvr']
     elif ['arm', 'aarch64'].contains(host_machine.cpu_family())
-      _drivers = []
+      _drivers = ['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()))
@@ -118,6 +118,7 @@ with_dri_r100 = _drivers.contains('r100')
 with_dri_r200 = _drivers.contains('r200')
 with_dri_nouveau = _drivers.contains('nouveau')
 with_dri_swrast = _drivers.contains('swrast')
+with_dri_pvr = _drivers.contains('pvr')
 
 with_dri = _drivers.length() != 0 and _drivers != ['']
 
@@ -1118,15 +1119,17 @@ _drm_radeon_ver = '2.4.71'
 _drm_nouveau_ver = '2.4.66'
 _drm_etnaviv_ver = '2.4.89'
 _drm_intel_ver = '2.4.75'
+_drm_pvr_ver = '2.4.60'
 _drm_ver = '2.4.75'
 
 _libdrm_checks = [
-  ['intel', with_dri_i915 or with_gallium_i915],
-  ['amdgpu', with_amd_vk or with_gallium_radeonsi],
+  ['intel', with_dri_i915 or with_gallium_i915, true],
+  ['amdgpu', with_amd_vk 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)],
-  ['etnaviv', with_gallium_etnaviv],
+              with_gallium_r300 or with_gallium_r600), true],
+  ['nouveau', (with_gallium_nouveau or with_dri_nouveau), true],
+  ['etnaviv', with_gallium_etnaviv, true],
+  ['pvr', with_dri_pvr, false],
 ]
 
 # VC4 only needs core libdrm support of this version, not a libdrm_vc4
@@ -1151,7 +1154,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 ccf70659ff7..0a2e80294f2 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -38,7 +38,9 @@ option(
   'dri-drivers',
   type : 'array',
   value : ['auto'],
-  choices : ['', 'auto', 'i915', 'i965', 'r100', 'r200', 'nouveau', 'swrast'],
+  choices : [
+    '', 'auto', 'i915', 'i965', 'r100', 'r200', 'nouveau', 'swrast', '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/Makefile.am b/src/mesa/drivers/dri/Makefile.am
index 3876d7c4192..15b0d5391d2 100644
--- a/src/mesa/drivers/dri/Makefile.am
+++ b/src/mesa/drivers/dri/Makefile.am
@@ -36,6 +36,12 @@ MEGADRIVERS_DEPS += radeon/libradeon_dri.la
 MEGADRIVERS += radeon_dri.so
 endif
 
+if HAVE_PVR_DRI
+SUBDIRS += pvr
+MEGADRIVERS_DEPS += pvr/libpvr_dri.la
+MEGADRIVERS += pvr_dri.so
+endif
+
 if HAVE_SWRAST_DRI
 SUBDIRS += swrast
 MEGADRIVERS_DEPS += swrast/libswrast_dri.la
diff --git a/src/mesa/drivers/dri/meson.build b/src/mesa/drivers/dri/meson.build
index d98c823f5fe..27213f7f660 100644
--- a/src/mesa/drivers/dri/meson.build
+++ b/src/mesa/drivers/dri/meson.build
@@ -40,6 +40,9 @@ endif
 if with_dri_nouveau
   subdir('nouveau')
 endif
+if with_dri_pvr
+  subdir('pvr')
+endif
 
 if dri_drivers != []
   libmesa_dri_drivers = shared_library(
diff --git a/src/mesa/drivers/dri/pvr/Makefile.am b/src/mesa/drivers/dri/pvr/Makefile.am
new file mode 100644
index 00000000000..681c13e6102
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/Makefile.am
@@ -0,0 +1,44 @@
+#
+# 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 Makefile.sources
+
+AM_CFLAGS = \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/src \
+	-I$(top_srcdir)/src/mapi \
+	-I$(top_srcdir)/src/mapi/glapi \
+	-I$(top_srcdir)/src/mesa \
+	-I$(top_srcdir)/src/mesa/main \
+	-I$(top_srcdir)/src/mesa/drivers/dri/common \
+	-I$(top_builddir)/src/mesa/main \
+	$(DEFINES) \
+	$(VISIBILITY_CFLAGS) \
+	$(PVR_CFLAGS)
+
+AM_CXXFLAGS = $(AM_CFLAGS)
+
+noinst_LTLIBRARIES = libpvr_dri.la
+libpvr_dri_la_SOURCES = $(pvr_FILES)
+libpvr_dri_la_LIBADD = $(PVR_LIBS)
diff --git a/src/mesa/drivers/dri/pvr/Makefile.sources b/src/mesa/drivers/dri/pvr/Makefile.sources
new file mode 100644
index 00000000000..6e0c8eb39f9
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/Makefile.sources
@@ -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.
+#
+
+pvr_INCLUDES = \
+	$(MESA_TOP)/src \
+	$(MESA_TOP)/src/mesa/drivers/dri/pvr
+
+pvr_FILES = \
+ mesa_context.c \
+ pvrcompat.c \
+ pvrdrawable.c \
+ pvrdri.c \
+ pvrext.c \
+ pvrimage.c \
+ pvrutil.c
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..fc5a8c47410
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/dri_support.h
@@ -0,0 +1,969 @@
+/* -*- 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>
+
+#include "imgpixfmts.h"
+#include "imgyuv.h"
+
+typedef enum
+{
+	PVRDRI_DEVICE_TYPE_INVALID = 0,
+	PVRDRI_DEVICE_TYPE_UNKNOWN,
+	PVRDRI_DEVICE_TYPE_DISPLAY,
+	PVRDRI_DEVICE_TYPE_RENDER,
+} PVRDRIDeviceType;
+
+/* API type. */
+typedef enum
+{
+	PVRDRI_API_NONE = 0,
+	PVRDRI_API_GLES1 = 2,
+	PVRDRI_API_GLES2 = 3,
+	PVRDRI_API_CL = 4,
+} PVRDRIAPIType;
+
+/* API sub type. */
+typedef enum
+{
+	PVRDRI_API_SUB_NONE,
+} PVRDRIAPISubType;
+
+typedef enum
+{
+	PVRDRI_DRAWABLE_NONE = 0,
+	PVRDRI_DRAWABLE_WINDOW = 1,
+	PVRDRI_DRAWABLE_PIXMAP = 2,
+	PVRDRI_DRAWABLE_PBUFFER = 3,
+} PVRDRIDrawableType;
+
+typedef enum
+{
+	PVRDRI_IMAGE = 1,
+	PVRDRI_IMAGE_FROM_NAMES,
+	PVRDRI_IMAGE_FROM_EGLIMAGE,
+	PVRDRI_IMAGE_FROM_DMABUFS,
+	PVRDRI_IMAGE_SUBIMAGE,
+} PVRDRIImageType;
+
+typedef enum
+{
+	PVRDRI_EGLIMAGE_NONE = 0,
+	PVRDRI_EGLIMAGE_IMGEGL,
+	PVRDRI_EGLIMAGE_IMGOCL,
+} PVRDRIEGLImageType;
+
+typedef enum
+{
+	/* Since PVRDRICallbacks version 2 */
+	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,
+} PVRDRIConfigAttrib;
+
+typedef enum
+{
+	/* Since PVRDRICallbacks version 2 */
+	PVRDRI_BUFFER_ATTRIB_INVALID = 0,
+	PVRDRI_BUFFER_ATTRIB_TYPE = 1,
+	PVRDRI_BUFFER_ATTRIB_WIDTH = 2,
+	PVRDRI_BUFFER_ATTRIB_HEIGHT = 3,
+	PVRDRI_BUFFER_ATTRIB_STRIDE = 4,
+	PVRDRI_BUFFER_ATTRIB_PIXEL_FORMAT = 5,
+} PVRDRIBufferAttrib;
+
+/* The context flags match their __DRI_CTX_FLAG and EGL_CONTEXT counterparts */
+#define PVRDRI_CONTEXT_FLAG_DEBUG			0x00000001
+#define PVRDRI_CONTEXT_FLAG_FORWARD_COMPATIBLE		0x00000002
+#define PVRDRI_CONTEXT_FLAG_ROBUST_BUFFER_ACCESS	0x00000004
+
+/* The context error codes match their __DRI_CTX_ERROR counterparts */
+#define PVRDRI_CONTEXT_ERROR_SUCCESS			0
+/* Out of memory */
+#define PVRDRI_CONTEXT_ERROR_NO_MEMORY			1
+/* Unsupported API */
+#define PVRDRI_CONTEXT_ERROR_BAD_API			2
+/* Unsupported version of API */
+#define PVRDRI_CONTEXT_ERROR_BAD_VERSION		3
+/* Unsupported context flag or combination of flags */
+#define PVRDRI_CONTEXT_ERROR_BAD_FLAG			4
+/* Unrecognised context attribute */
+#define PVRDRI_CONTEXT_ERROR_UNKNOWN_ATTRIBUTE		5
+/* Unrecognised context flag */
+#define PVRDRI_CONTEXT_ERROR_UNKNOWN_FLAG		6
+
+/*
+ * The context priority defines match their __DRI_CTX counterparts, and
+ * the context priority values used by the DDK.
+ */
+#define PVRDRI_CONTEXT_PRIORITY_LOW	0
+#define PVRDRI_CONTEXT_PRIORITY_MEDIUM	1
+#define PVRDRI_CONTEXT_PRIORITY_HIGH	2
+
+/* The image error flags match their __DRI_IMAGE_ERROR counterparts */
+#define PVRDRI_IMAGE_ERROR_SUCCESS		0
+#define PVRDRI_IMAGE_ERROR_BAD_ALLOC		1
+#define PVRDRI_IMAGE_ERROR_BAD_MATCH		2
+#define PVRDRI_IMAGE_ERROR_BAD_PARAMETER	3
+#define PVRDRI_IMAGE_ERROR_BAD_ACCESS		4
+
+/* The buffer flags match their __DRI_IMAGE_USE counterparts */
+#define PVDRI_BUFFER_USE_SHARE		0x0001
+#define PVDRI_BUFFER_USE_SCANOUT	0x0002
+#define PVDRI_BUFFER_USE_CURSOR		0x0004
+#define PVDRI_BUFFER_USE_LINEAR		0x0008
+
+/* EGL_RENDERABLE_TYPE mask bits */
+#define PVRDRI_API_BIT_GLES		0x0001
+#define PVRDRI_API_BIT_GLES2		0x0004
+#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
+
+/* The blit flags match their DRI counterparts */
+#define PVRDRI_BLIT_FLAG_FLUSH		0x0001
+#define PVRDRI_BLIT_FLAG_FINISH		0x0002
+
+/* The image mapping flags match their DRI counterparts */
+#define	PVRDRI_IMAGE_TRANSFER_READ		0x1
+#define	PVRDRI_IMAGE_TRANSFER_WRITE		0x2
+#define	PVRDRI_IMAGE_TRANSFER_READ_WRITE	\
+		(PVRDRI_IMAGE_TRANSFER_READ | PVRDRI_IMAGE_TRANSFER_WRITE)
+
+/* The YUV defines match their DRI counterparts */
+#define PVRDRI_YUV_ORDER_NONE 0x0
+#define PVRDRI_YUV_ORDER_YUV  0x1
+#define PVRDRI_YUV_ORDER_YVU  0x2
+#define PVRDRI_YUV_ORDER_YUYV 0x4
+#define PVRDRI_YUV_ORDER_UYVY 0x8
+#define PVRDRI_YUV_ORDER_YVYU 0x10
+#define PVRDRI_YUV_ORDER_VYUY 0x20
+#define PVRDRI_YUV_ORDER_AYUV 0x40
+
+#define PVRDRI_YUV_SUBSAMPLE_NONE  0x0
+#define PVRDRI_YUV_SUBSAMPLE_4_2_0 0x1
+#define PVRDRI_YUV_SUBSAMPLE_4_2_2 0x2
+#define PVRDRI_YUV_SUBSAMPLE_4_4_4 0x4
+
+#define PVRDRI_YUV_DEPTH_RANGE_NONE    0x0
+#define PVRDRI_YUV_DEPTH_RANGE_LIMITED 0x1
+#define PVRDRI_YUV_DEPTH_RANGE_FULL    0x2
+
+#define PVRDRI_YUV_CSC_STANDARD_NONE 0x0
+#define PVRDRI_YUV_CSC_STANDARD_601  0x1
+#define PVRDRI_YUV_CSC_STANDARD_709  0x2
+#define PVRDRI_YUV_CSC_STANDARD_2020 0x4
+
+#define PVRDRI_YUV_PLANE_BPP_NONE 0x0
+#define PVRDRI_YUV_PLANE_BPP_0    0x1
+#define PVRDRI_YUV_PLANE_BPP_8    0x2
+#define PVRDRI_YUV_PLANE_BPP_10   0x4
+
+/* Flags for PVRDRICallbacks.DrawableGetParametersV2 */
+/* Since callback interface version 2 */
+#define PVRDRI_GETPARAMS_FLAG_ALLOW_RECREATE	0x1
+/* Since callback interface version 3 */
+#define PVRDRI_GETPARAMS_FLAG_NO_UPDATE		0x2
+
+/*
+ * Capabilities that might be returned by PVRDRIInterface.GetFenceCapabilities.
+ * These match their _DRI_FENCE_CAP counterparts.
+ *
+ * Since PVRDRIInterface version 2.
+ */
+#define	PVRDRI_FENCE_CAP_NATIVE_FD 0x1
+
+typedef struct 
+{
+	IMG_PIXFMT          ePixFormat;
+	uint32_t            uiWidth;
+	uint32_t            uiHeight;
+	uint32_t            uiStrideInBytes;
+} PVRDRIBufferAttribs;
+
+typedef struct
+{
+	int sampleBuffers;
+	int samples;
+
+	int redBits;
+	int greenBits;
+	int blueBits;
+	int alphaBits;
+
+	int rgbBits;
+	int depthBits;
+	int stencilBits;
+
+	bool doubleBufferMode;
+
+	int bindToTextureRgb;
+	int bindToTextureRgba;
+} PVRDRIConfigInfo;
+
+typedef struct IMGEGLImageRec IMGEGLImage;
+typedef struct __DRIimageRec __DRIimage;
+
+/* PVRDRI interface opaque types */
+typedef struct PVRDRIScreenImplRec PVRDRIScreenImpl;
+typedef struct PVRDRIContextImplRec PVRDRIContextImpl;
+typedef struct PVRDRIDrawableImplRec PVRDRIDrawableImpl;
+typedef struct PVRDRIBufferImplRec PVRDRIBufferImpl;
+
+typedef struct PVRDRIDrawable_TAG PVRDRIDrawable;
+
+typedef void (*PVRDRIGLAPIProc)(void);
+
+/* Since PVRDRICallbacks version 2 */
+typedef struct PVRDRIConfigRec PVRDRIConfig;
+
+typedef struct {
+	/**********************************************************************
+	 * Version 0 interface
+	 **********************************************************************/
+
+	PVRDRIDeviceType     (*GetDeviceTypeFromFd)(int iFd);
+
+	bool                 (*IsFirstScreen)(PVRDRIScreenImpl *psScreenImpl);
+
+	uint32_t             (*PixFmtGetDepth)(IMG_PIXFMT eFmt);
+	uint32_t             (*PixFmtGetBPP)(IMG_PIXFMT eFmt);
+	uint32_t             (*PixFmtGetBlockSize)(IMG_PIXFMT eFmt);
+
+	/* ScreenImpl functions */
+	PVRDRIScreenImpl    *(*CreateScreen)(int iFd);
+	void                 (*DestroyScreen)(PVRDRIScreenImpl *psScreenImpl);
+
+	int                  (*APIVersion)(PVRDRIAPIType eAPI,
+	                                   PVRDRIAPISubType eAPISub,
+	                                   PVRDRIScreenImpl *psScreenImpl);
+
+	void                *(*EGLGetLibHandle)(PVRDRIAPIType eAPI,
+	                                        PVRDRIScreenImpl *psScreenImpl);
+
+	PVRDRIGLAPIProc      (*EGLGetProcAddress)(PVRDRIAPIType eAPI,
+	                                          PVRDRIScreenImpl *psScreenImpl,
+	                                          const char *psProcName);
+
+	bool                 (*EGLFlushBuffers)(PVRDRIAPIType eAPI,
+	                                        PVRDRIScreenImpl *psScreenImpl,
+	                                        PVRDRIContextImpl *psContextImpl,
+	                                        PVRDRIDrawableImpl *psDrawableImpl,
+	                                        bool bFlushAllSurfaces,
+	                                        bool bSwapBuffers,
+	                                        bool bWaitForHW);
+	/* EGLFreeResources is deprecated */
+	bool                 (*EGLFreeResources)(PVRDRIScreenImpl *psPVRScreenImpl);
+	void                 (*EGLMarkRendersurfaceInvalid)(PVRDRIAPIType eAPI,
+	                                                    PVRDRIScreenImpl *psScreenImpl,
+	                                                    PVRDRIContextImpl *psContextImpl);
+	/* EGLSetFrontBufferCallback is deprecated */
+	void                 (*EGLSetFrontBufferCallback)(PVRDRIAPIType eAPI,
+	                                                  PVRDRIScreenImpl *psScreenImpl,
+	                                                  PVRDRIDrawableImpl *psDrawableImpl,
+	                                                  void (*pfnCallback)(PVRDRIDrawable *));
+
+	/* Deprecated in version 1 (since 1.10) */
+	unsigned             (*CreateContext)(PVRDRIContextImpl **ppsContextImpl,
+	                                          PVRDRIAPIType eAPI,
+	                                          PVRDRIAPISubType eAPISub,
+	                                          PVRDRIScreenImpl *psScreenImpl,
+	                                          const PVRDRIConfigInfo *psConfigInfo,
+	                                          unsigned uMajorVersion,
+	                                          unsigned uMinorVersion,
+	                                          uint32_t uFlags,
+	                                          bool bNotifyReset,
+	                                          unsigned uPriority,
+	                                          PVRDRIContextImpl *psSharedContextImpl);
+
+	void                 (*DestroyContext)(PVRDRIContextImpl *psContextImpl,
+	                                           PVRDRIAPIType eAPI,
+	                                           PVRDRIScreenImpl *psScreenImpl);
+
+	bool                 (*MakeCurrentGC)(PVRDRIAPIType eAPI,
+	                                      PVRDRIScreenImpl *psScreenImpl,
+	                                      PVRDRIContextImpl *psContextImpl,
+	                                      PVRDRIDrawableImpl *psWriteImpl,
+	                                      PVRDRIDrawableImpl *psReadImpl);
+
+	void                 (*MakeUnCurrentGC)(PVRDRIAPIType eAPI,
+	                                        PVRDRIScreenImpl *psScreenImpl);
+
+	unsigned             (*GetImageSource)(PVRDRIAPIType eAPI,
+	                                       PVRDRIScreenImpl *psScreenImpl,
+	                                       PVRDRIContextImpl *psContextImpl,
+	                                       uint32_t  uiTarget,
+	                                       uintptr_t uiBuffer,
+	                                       uint32_t  uiLevel,
+	                                       IMGEGLImage *psEGLImage);
+
+	bool                 (*BindTexImage)(PVRDRIAPIType eAPI,
+	                                     PVRDRIScreenImpl *psScreenImpl,
+	                                     PVRDRIContextImpl *psContextImpl,
+	                                     PVRDRIDrawableImpl *psDrawableImpl);
+
+	void                 (*ReleaseTexImage)(PVRDRIAPIType eAPI,
+	                                        PVRDRIScreenImpl *psScreenImpl,
+	                                        PVRDRIContextImpl *psContextImpl,
+	                                        PVRDRIDrawableImpl *psDrawableImpl);
+
+	/* Deprecated in version 1 (since 1.10) */
+	PVRDRIDrawableImpl  *(*CreateDrawable)(PVRDRIDrawable *psPVRDrawable);
+
+	void                 (*DestroyDrawable)(PVRDRIDrawableImpl *psScreenImpl);
+	bool                 (*EGLDrawableCreate)(PVRDRIScreenImpl *psScreenImpl,
+	                                          PVRDRIDrawableImpl *psDrawableImpl);
+	bool                 (*EGLDrawableRecreate)(PVRDRIScreenImpl *psScreenImpl,
+	                                            PVRDRIDrawableImpl *psDrawableImpl);
+	bool                 (*EGLDrawableDestroy)(PVRDRIScreenImpl *psScreenImpl,
+	                                           PVRDRIDrawableImpl *psDrawableImpl);
+	void                 (*EGLDrawableDestroyConfig)(PVRDRIDrawableImpl *psDrawableImpl);
+
+	/* Buffer functions */
+	PVRDRIBufferImpl    *(*BufferCreate)(PVRDRIScreenImpl *psScreenImpl,
+	                                     int iWidth,
+	                                     int iHeight,
+	                                     unsigned int uiBpp,
+	                                     unsigned int uiUseFlags,
+	                                     unsigned int *puiStride);
+
+	PVRDRIBufferImpl    *(*BufferCreateWithModifiers)(PVRDRIScreenImpl *psScreenImpl,
+	                                                  int iWidth,
+	                                                  int iHeight,
+	                                                  int iFormat,
+	                                                  IMG_PIXFMT eIMGPixelFormat,
+	                                                  const uint64_t *puiModifiers,
+	                                                  unsigned int uiModifierCount,
+	                                                  unsigned int *puiStride);
+
+	PVRDRIBufferImpl    *(*BufferCreateFromNames)(PVRDRIScreenImpl *psScreenImpl,
+	                                              int iWidth,
+	                                              int iHeight,
+	                                              unsigned uiNumPlanes,
+	                                              const int *piName,
+	                                              const int *piStride,
+	                                              const int *piOffset,
+	                                              const unsigned int *puiWidthShift,
+	                                              const unsigned int *puiHeightShift);
+
+	PVRDRIBufferImpl    *(*BufferCreateFromName)(PVRDRIScreenImpl *psScreenImpl,
+	                                             int iName,
+	                                             int iWidth,
+	                                             int iHeight,
+	                                             int iStride,
+	                                             int iOffset);
+
+	/* BufferCreateFromFds is deprecated */
+	PVRDRIBufferImpl    *(*BufferCreateFromFds)(PVRDRIScreenImpl *psScreenImpl,
+	                                            int iWidth,
+	                                            int iHeight,
+	                                            unsigned uiNumPlanes,
+	                                            const int *piFd,
+	                                            const int *piStride,
+	                                            const int *piOffset,
+	                                            const unsigned int *puiWidthShift,
+	                                            const unsigned int *puiHeightShift);
+
+	PVRDRIBufferImpl    *(*BufferCreateFromFdsWithModifier)(PVRDRIScreenImpl *psScreenImpl,
+	                                                        int iWidth,
+	                                                        int iHeight,
+	                                                        uint64_t uiModifier,
+	                                                        unsigned uiNumPlanes,
+	                                                        const int *piFd,
+	                                                        const int *piStride,
+	                                                        const int *piOffset,
+	                                                        const unsigned int *puiWidthShift,
+	                                                        const unsigned int *puiHeightShift);
+
+	PVRDRIBufferImpl    *(*SubBufferCreate)(PVRDRIScreenImpl *psScreen,
+	                                        PVRDRIBufferImpl *psParent,
+	                                        int plane);
+
+	void                 (*BufferDestroy)(PVRDRIBufferImpl *psBuffer);
+
+	int                  (*BufferGetFd)(PVRDRIBufferImpl *psBuffer);
+
+	int                  (*BufferGetHandle)(PVRDRIBufferImpl *psBuffer);
+
+	uint64_t             (*BufferGetModifier)(PVRDRIBufferImpl *psBuffer);
+
+	int                  (*BufferGetName)(PVRDRIBufferImpl *psBuffer);
+
+	int                  (*BufferGetOffset)(PVRDRIBufferImpl *psBuffer);
+
+	/* Image functions */
+	IMGEGLImage         *(*EGLImageCreate)(void);
+	IMGEGLImage         *(*EGLImageCreateFromBuffer)(int iWidth,
+	                                                 int iHeight,
+	                                                 int iStride,
+	                                                 IMG_PIXFMT ePixelFormat,
+	                                                 IMG_YUV_COLORSPACE eColourSpace,
+	                                                 IMG_YUV_CHROMA_INTERP eChromaUInterp,
+	                                                 IMG_YUV_CHROMA_INTERP eChromaVInterp,
+	                                                 PVRDRIBufferImpl *psBuffer);
+
+	IMGEGLImage         *(*EGLImageCreateFromSubBuffer)(IMG_PIXFMT ePixelFormat,
+	                                                    PVRDRIBufferImpl *psSubBuffer);
+
+	IMGEGLImage         *(*EGLImageDup)(IMGEGLImage *psIn);
+
+	void                 (*EGLImageSetCallbackData)(IMGEGLImage *psEGLImage, __DRIimage *image);
+
+	void                 (*EGLImageDestroyExternal)(PVRDRIScreenImpl *psScreenImpl,
+	                                                IMGEGLImage *psEGLImage,
+	                                                PVRDRIEGLImageType eglImageType);
+	void                 (*EGLImageFree)(IMGEGLImage *psEGLImage);
+
+	void                 (*EGLImageGetAttribs)(IMGEGLImage *psEGLImage,
+	                                           PVRDRIBufferAttribs *psAttribs);
+
+	/* Sync functions */
+	void                *(*CreateFence)(PVRDRIAPIType eAPI,
+	                                    PVRDRIScreenImpl *psScreenImpl,
+	                                    PVRDRIContextImpl *psContextImpl);
+
+	void                 (*DestroyFence)(void *psDRIFence);
+
+	/*
+	 * Support for flushing commands in ClientWaitSync is deprecated
+	 * in version 2 (since 1.11), with the caller being responsible
+	 * for the flush. A context and API need not be supplied if a flush
+	 * isn't requested.
+	 */
+	bool                 (*ClientWaitSync)(PVRDRIAPIType eAPI,
+	                                       PVRDRIContextImpl *psContextImpl,
+	                                       void *psDRIFence,
+	                                       bool bFlushCommands,
+	                                       bool bTimeout,
+	                                       uint64_t uiTimeout);
+
+	bool                 (*ServerWaitSync)(PVRDRIAPIType eAPI,
+	                                       PVRDRIContextImpl *psContextImpl,
+	                                       void *psDRIFence);
+
+	/* Deprecated in version 2 (since 1.11) */
+	void                 (*DestroyFences)(PVRDRIScreenImpl *psScreenImpl);
+
+	/* EGL interface functions */
+	/* Deprecated in version 1 (since 1.10) */
+	bool                 (*EGLDrawableConfigFromGLMode)(PVRDRIDrawableImpl *psPVRDrawable,
+	                                                    PVRDRIConfigInfo *psConfigInfo,
+	                                                    int supportedAPIs,
+	                                                    IMG_PIXFMT ePixFmt);
+
+	/* Blit functions */
+	bool                 (*BlitEGLImage)(PVRDRIScreenImpl *psScreenImpl,
+	                                     PVRDRIContextImpl *psContextImpl,
+	                                     IMGEGLImage *psDstImage,
+	                                     PVRDRIBufferImpl *psDstBuffer,
+	                                     IMGEGLImage *psSrcImage,
+	                                     PVRDRIBufferImpl *psSrcBuffer,
+	                                     int iDstX, int iDstY,
+	                                     int iDstWidth, int iDstHeight,
+	                                     int iSrcX, int iSrcY,
+	                                     int iSrcWidth, int iSrcHeight,
+	                                     int iFlushFlag);
+
+	/* Mapping functions */
+	void                 *(*MapEGLImage)(PVRDRIScreenImpl *psScreenImpl,
+	                                     PVRDRIContextImpl *psContextImpl,
+	                                     IMGEGLImage *psImage,
+	                                     PVRDRIBufferImpl *psBuffer,
+	                                     int iX, int iY,
+	                                     int iWidth, int iHeight,
+	                                     unsigned iFlags,
+	                                     int *piStride,
+	                                     void **ppvData);
+
+	bool                 (*UnmapEGLImage)(PVRDRIScreenImpl *psScreenImpl,
+	                                      PVRDRIContextImpl *psContextImpl,
+	                                      IMGEGLImage *psImage, PVRDRIBufferImpl *psBuffer,
+	                                      void *pvData);
+
+	/* PVR utility support functions */
+	bool                 (*MesaFormatSupported)(unsigned fmt);
+	unsigned             (*DepthStencilBitArraySize)(void);
+	const uint8_t       *(*DepthBitsArray)(void);
+	const uint8_t       *(*StencilBitsArray)(void);
+	unsigned             (*MSAABitArraySize)(void);
+	const uint8_t       *(*MSAABitsArray)(void);
+	uint32_t             (*MaxPBufferWidth)(void);
+	uint32_t             (*MaxPBufferHeight)(void);
+
+	unsigned             (*GetNumAPIFuncs)(PVRDRIAPIType eAPI);
+	const char          *(*GetAPIFunc)(PVRDRIAPIType eAPI, unsigned index);
+
+	int                  (*QuerySupportedFormats)(PVRDRIScreenImpl *psScreenImpl,
+	                                              unsigned uNumFormats,
+	                                              const int *piFormats,
+	                                              const IMG_PIXFMT *peImgFormats,
+	                                              bool *pbSupported);
+
+	int                  (*QueryModifiers)(PVRDRIScreenImpl *psScreenImpl,
+	                                       int iFormat,
+	                                       IMG_PIXFMT eImgFormat,
+	                                       uint64_t *puModifiers,
+	                                       unsigned *puExternalOnly);
+
+	/**********************************************************************
+	 * Version 1 functions
+	 **********************************************************************/
+
+	unsigned             (*CreateContextV1)(PVRDRIScreenImpl *psScreenImpl,
+						PVRDRIContextImpl *psSharedContextImpl,
+						PVRDRIConfig *psConfig,
+						PVRDRIAPIType eAPI,
+						PVRDRIAPISubType eAPISub,
+						unsigned uMajorVersion,
+						unsigned uMinorVersion,
+						uint32_t uFlags,
+						bool bNotifyReset,
+						unsigned uPriority,
+						PVRDRIContextImpl **ppsContextImpl);
+
+	PVRDRIDrawableImpl  *(*CreateDrawableWithConfig)(PVRDRIDrawable *psPVRDrawable,
+							 PVRDRIConfig *psConfig);
+
+	/**********************************************************************
+	 * Version 2 functions
+	 **********************************************************************/
+
+	unsigned             (*GetFenceCapabilities)(PVRDRIScreenImpl *psScreenImpl);
+
+	void                *(*CreateFenceFd)(PVRDRIAPIType eAPI,
+	                                      PVRDRIScreenImpl *psScreenImpl,
+	                                      PVRDRIContextImpl *psContextImpl,
+                                              int iFd);
+
+	int                  (*GetFenceFd)(void *psDRIFence);
+} PVRDRISupportInterface;
+
+/* Callbacks into non-impl layer */
+typedef struct
+{
+	/**********************************************************************
+	 * Version 0 callbacks
+	 **********************************************************************/
+
+	/*
+	 * DrawableRecreate and DrawableGetParameters are deprecated in
+	 * version 1.
+	 */
+	bool                 (*DrawableRecreate)(PVRDRIDrawable *psPVRDrawable);
+	bool                 (*DrawableGetParameters)(PVRDRIDrawable *psPVRDrawable,
+	                                              PVRDRIBufferImpl **ppsDstBuffer,
+	                                              PVRDRIBufferImpl **ppsAccumBuffer,
+	                                              PVRDRIBufferAttribs *psAttribs,
+	                                              bool *pbDoubleBuffered);
+
+	PVRDRIImageType      (*ImageGetSharedType)(__DRIimage *image);
+	PVRDRIBufferImpl    *(*ImageGetSharedBuffer)(__DRIimage *image);
+	IMGEGLImage           *(*ImageGetSharedEGLImage)(__DRIimage *image);
+	IMGEGLImage           *(*ImageGetEGLImage)(__DRIimage *image);
+	__DRIimage          *(*ScreenGetDRIImage)(void *hEGLImage);
+	void                 (*RefImage)(__DRIimage *image);
+	void                 (*UnrefImage)(__DRIimage *image);
+
+	/*
+	 * If the DRI module calls PVRDRIRegisterCallbacks, or
+	 * PVRDRIRegisterVersionedCallbacks with any version number,
+	 * the DRI support library can use the callbacks above.
+	 * The callbacks below can only be called if
+	 * PVRDRIRegisterVersionedCallbacks is called with a suitable
+	 * version number.
+	 */
+
+	/**********************************************************************
+	 * Version 1 callbacks
+	 **********************************************************************/
+
+	/*
+	 * Deprecated in version 2 (since 1.10).
+	 *
+	 * DrawableGetParametersV1 is a replacement for DrawableRecreate
+	 * and DrawableGetParameters. The DRI Support library must use one
+	 * interface or the other, otherwise the results are undefined.
+	 */
+	bool                 (*DrawableGetParametersV1)(PVRDRIDrawable *psPVRDrawable,
+                                                        bool bAllowRecreate,
+	                                                PVRDRIBufferImpl **ppsDstBuffer,
+	                                                PVRDRIBufferImpl **ppsAccumBuffer,
+	                                                PVRDRIBufferAttribs *psAttribs,
+	                                                bool *pbDoubleBuffered);
+
+	/*
+	 * Register the DRI Support interface with the DRI module.
+	 * The caller is not required to preserve the PVRDRICallbacks structure
+	 * after the call, so the callee must make a copy.
+	 */
+	bool                 (*RegisterSupportInterfaceV1)(const PVRDRISupportInterface *psInterface,
+							   unsigned uVersion);
+
+	/**********************************************************************
+	 * Version 2 callbacks
+	 **********************************************************************/
+
+	bool                 (*ConfigQuery)(const PVRDRIConfig *psConfig,
+	                                    PVRDRIConfigAttrib eConfigAttrib,
+	                                    int *piValueOut);
+	/*
+	 * DrawableGetParametersV2 is a replacement for DrawableGetParametersV1.
+	 * Unlike earlier versions, the caller is expected to query drawable
+	 * information (via DrawableQuery) instead of this information being
+	 * returned by the callback.
+	 */
+	bool                 (*DrawableGetParametersV2)(PVRDRIDrawable *psPVRDrawable,
+	                                                uint32_t uiFlags,
+	                                                PVRDRIBufferImpl **ppsDstBuffer,
+	                                                PVRDRIBufferImpl **ppsAccumBuffer);
+	bool                 (*DrawableQuery)(const PVRDRIDrawable *psPVRDrawable,
+	                                      PVRDRIBufferAttrib eBufferAttrib,
+	                                      uint32_t *uiValueOut);
+
+	/**********************************************************************
+	 * Version 3 callbacks
+	 **********************************************************************/
+} PVRDRICallbacks;
+
+/*
+ * Older versions of the DRI support library don't support
+ * PVRDRIRegisterVersionedCallbacks.
+ * The caller is not required to preserve the PVRDRICallbacks structure
+ * after the call, so the callee must make a copy.
+ */
+bool PVRDRIRegisterVersionedCallbacks(const PVRDRICallbacks *psCallbacks,
+				      unsigned uVersion);
+
+/******************************************************************************
+ * Everything beyond this point is deprecated
+ ******************************************************************************/
+
+/*
+ * Calling PVRDRIRegisterCallbacks is equivalent to calling
+ * PVRDRIRegisterVersionedCallbacks with a version number of zero.
+ * The caller is not required to preserve the PVRDRICallbacks structure
+ * after the call, so the callee must make a copy.
+ */
+void PVRDRIRegisterCallbacks(PVRDRICallbacks *callbacks);
+
+PVRDRIDeviceType PVRDRIGetDeviceTypeFromFd(int iFd);
+
+bool PVRDRIIsFirstScreen(PVRDRIScreenImpl *psScreenImpl);
+
+uint32_t PVRDRIPixFmtGetDepth(IMG_PIXFMT eFmt);
+uint32_t PVRDRIPixFmtGetBPP(IMG_PIXFMT eFmt);
+uint32_t PVRDRIPixFmtGetBlockSize(IMG_PIXFMT eFmt);
+
+/* ScreenImpl functions */
+PVRDRIScreenImpl *PVRDRICreateScreenImpl(int iFd);
+void PVRDRIDestroyScreenImpl(PVRDRIScreenImpl *psScreenImpl);
+
+int PVRDRIAPIVersion(PVRDRIAPIType eAPI,
+		     PVRDRIAPISubType eAPISub,
+		     PVRDRIScreenImpl *psScreenImpl);
+
+void *PVRDRIEGLGetLibHandle(PVRDRIAPIType eAPI,
+			    PVRDRIScreenImpl *psScreenImpl);
+
+PVRDRIGLAPIProc PVRDRIEGLGetProcAddress(PVRDRIAPIType eAPI,
+					  PVRDRIScreenImpl *psScreenImpl,
+					  const char *psProcName);
+
+bool PVRDRIEGLFlushBuffers(PVRDRIAPIType eAPI,
+                           PVRDRIScreenImpl *psScreenImpl,
+                           PVRDRIContextImpl *psContextImpl,
+                           PVRDRIDrawableImpl *psDrawableImpl,
+                           bool bFlushAllSurfaces,
+                           bool bSwapBuffers,
+                           bool bWaitForHW);
+bool PVRDRIEGLFreeResources(PVRDRIScreenImpl *psPVRScreenImpl);
+void PVRDRIEGLMarkRendersurfaceInvalid(PVRDRIAPIType eAPI,
+                                       PVRDRIScreenImpl *psScreenImpl,
+                                       PVRDRIContextImpl *psContextImpl);
+void PVRDRIEGLSetFrontBufferCallback(PVRDRIAPIType eAPI,
+                                        PVRDRIScreenImpl *psScreenImpl,
+                                        PVRDRIDrawableImpl *psDrawableImpl,
+                                        void (*pfnCallback)(PVRDRIDrawable *));
+
+unsigned PVRDRICreateContextImpl(PVRDRIContextImpl **ppsContextImpl,
+				 PVRDRIAPIType eAPI,
+				 PVRDRIAPISubType eAPISub,
+				 PVRDRIScreenImpl *psScreenImpl,
+				 const PVRDRIConfigInfo *psConfigInfo,
+				 unsigned uMajorVersion,
+				 unsigned uMinorVersion,
+				 uint32_t uFlags,
+				 bool bNotifyReset,
+				 unsigned uPriority,
+				 PVRDRIContextImpl *psSharedContextImpl);
+
+void PVRDRIDestroyContextImpl(PVRDRIContextImpl *psContextImpl,
+			      PVRDRIAPIType eAPI,
+			      PVRDRIScreenImpl *psScreenImpl);
+
+bool PVRDRIMakeCurrentGC(PVRDRIAPIType eAPI,
+			 PVRDRIScreenImpl *psScreenImpl,
+			 PVRDRIContextImpl *psContextImpl,
+			 PVRDRIDrawableImpl *psWriteImpl,
+			 PVRDRIDrawableImpl *psReadImpl);
+
+void PVRDRIMakeUnCurrentGC(PVRDRIAPIType eAPI,
+			   PVRDRIScreenImpl *psScreenImpl);
+
+unsigned PVRDRIGetImageSource(PVRDRIAPIType eAPI,
+			      PVRDRIScreenImpl *psScreenImpl,
+			      PVRDRIContextImpl *psContextImpl,
+			      uint32_t  uiTarget,
+			      uintptr_t uiBuffer,
+			      uint32_t  uiLevel,
+			      IMGEGLImage *psEGLImage);
+
+bool PVRDRI2BindTexImage(PVRDRIAPIType eAPI,
+			 PVRDRIScreenImpl *psScreenImpl,
+			 PVRDRIContextImpl *psContextImpl,
+			 PVRDRIDrawableImpl *psDrawableImpl);
+
+void PVRDRI2ReleaseTexImage(PVRDRIAPIType eAPI,
+			    PVRDRIScreenImpl *psScreenImpl,
+			    PVRDRIContextImpl *psContextImpl,
+			    PVRDRIDrawableImpl *psDrawableImpl);
+
+/* DrawableImpl functions */
+PVRDRIDrawableImpl *PVRDRICreateDrawableImpl(PVRDRIDrawable *psPVRDrawable);
+void PVRDRIDestroyDrawableImpl(PVRDRIDrawableImpl *psScreenImpl);
+bool PVREGLDrawableCreate(PVRDRIScreenImpl *psScreenImpl,
+                          PVRDRIDrawableImpl *psDrawableImpl);
+bool PVREGLDrawableRecreate(PVRDRIScreenImpl *psScreenImpl,
+                            PVRDRIDrawableImpl *psDrawableImpl);
+bool PVREGLDrawableDestroy(PVRDRIScreenImpl *psScreenImpl,
+                           PVRDRIDrawableImpl *psDrawableImpl);
+void PVREGLDrawableDestroyConfig(PVRDRIDrawableImpl *psDrawableImpl);
+
+/* Buffer functions */
+PVRDRIBufferImpl *PVRDRIBufferCreate(PVRDRIScreenImpl *psScreenImpl,
+				     int iWidth,
+				     int iHeight,
+				     unsigned int uiBpp,
+				     unsigned int uiUseFlags,
+				     unsigned int *puiStride);
+
+PVRDRIBufferImpl *
+PVRDRIBufferCreateWithModifiers(PVRDRIScreenImpl *psScreenImpl,
+			        int iWidth,
+			        int iHeight,
+			        int iFormat,
+				IMG_PIXFMT eIMGPixelFormat,
+			        const uint64_t *puiModifiers,
+			        unsigned int uiModifierCount,
+			        unsigned int *puiStride);
+
+PVRDRIBufferImpl *PVRDRIBufferCreateFromNames(PVRDRIScreenImpl *psScreenImpl,
+					   int iWidth,
+					   int iHeight,
+					   unsigned uiNumPlanes,
+					   const int *piName,
+					   const int *piStride,
+					   const int *piOffset,
+					   const unsigned int *puiWidthShift,
+					   const unsigned int *puiHeightShift);
+
+PVRDRIBufferImpl *PVRDRIBufferCreateFromName(PVRDRIScreenImpl *psScreenImpl,
+					     int iName,
+					     int iWidth,
+					     int iHeight,
+					     int iStride,
+					     int iOffset);
+
+PVRDRIBufferImpl *PVRDRIBufferCreateFromFds(PVRDRIScreenImpl *psScreenImpl,
+					   int iWidth,
+					   int iHeight,
+					   unsigned uiNumPlanes,
+					   const int *piFd,
+					   const int *piStride,
+					   const int *piOffset,
+					   const unsigned int *puiWidthShift,
+					   const unsigned int *puiHeightShift);
+
+PVRDRIBufferImpl *
+PVRDRIBufferCreateFromFdsWithModifier(PVRDRIScreenImpl *psScreenImpl,
+				      int iWidth,
+				      int iHeight,
+				      uint64_t uiModifier,
+				      unsigned uiNumPlanes,
+				      const int *piFd,
+				      const int *piStride,
+				      const int *piOffset,
+				      const unsigned int *puiWidthShift,
+				      const unsigned int *puiHeightShift);
+
+PVRDRIBufferImpl *PVRDRISubBufferCreate(PVRDRIScreenImpl *psScreen,
+					PVRDRIBufferImpl *psParent,
+					int plane);
+
+void PVRDRIBufferDestroy(PVRDRIBufferImpl *psBuffer);
+
+int PVRDRIBufferGetFd(PVRDRIBufferImpl *psBuffer);
+
+int PVRDRIBufferGetHandle(PVRDRIBufferImpl *psBuffer);
+
+uint64_t PVRDRIBufferGetModifier(PVRDRIBufferImpl *psBuffer);
+
+int PVRDRIBufferGetName(PVRDRIBufferImpl *psBuffer);
+
+int PVRDRIBufferGetOffset(PVRDRIBufferImpl *psBuffer);
+
+/* Image functions */
+IMGEGLImage *PVRDRIEGLImageCreate(void);
+IMGEGLImage *PVRDRIEGLImageCreateFromBuffer(int iWidth,
+					   int iHeight,
+					   int iStride,
+					   IMG_PIXFMT ePixelFormat,
+					   IMG_YUV_COLORSPACE eColourSpace,
+					   IMG_YUV_CHROMA_INTERP eChromaUInterp,
+					   IMG_YUV_CHROMA_INTERP eChromaVInterp,
+					   PVRDRIBufferImpl *psBuffer);
+
+IMGEGLImage *PVRDRIEGLImageCreateFromSubBuffer(IMG_PIXFMT ePixelFormat,
+					       PVRDRIBufferImpl *psSubBuffer);
+
+IMGEGLImage *PVRDRIEGLImageDup(IMGEGLImage *psIn);
+
+void PVRDRIEGLImageSetCallbackData(IMGEGLImage *psEGLImage, __DRIimage *image);
+
+void PVRDRIEGLImageDestroyExternal(PVRDRIScreenImpl *psScreenImpl,
+                                   IMGEGLImage *psEGLImage,
+				   PVRDRIEGLImageType eglImageType);
+void PVRDRIEGLImageFree(IMGEGLImage *psEGLImage);
+
+void PVRDRIEGLImageGetAttribs(IMGEGLImage *psEGLImage, PVRDRIBufferAttribs *psAttribs);
+
+/* Sync functions */
+void *PVRDRICreateFenceImpl(PVRDRIAPIType eAPI,
+			    PVRDRIScreenImpl *psScreenImpl,
+			    PVRDRIContextImpl *psContextImpl);
+
+void PVRDRIDestroyFenceImpl(void *psDRIFence);
+
+bool PVRDRIClientWaitSyncImpl(PVRDRIAPIType eAPI,
+			      PVRDRIContextImpl *psContextImpl,
+			      void *psDRIFence,
+			      bool bFlushCommands,
+			      bool bTimeout,
+			      uint64_t uiTimeout);
+
+bool PVRDRIServerWaitSyncImpl(PVRDRIAPIType eAPI,
+			      PVRDRIContextImpl *psContextImpl,
+			      void *psDRIFence);
+
+void PVRDRIDestroyFencesImpl(PVRDRIScreenImpl *psScreenImpl);
+
+/* EGL interface functions */
+bool PVRDRIEGLDrawableConfigFromGLMode(PVRDRIDrawableImpl *psPVRDrawable,
+				       PVRDRIConfigInfo *psConfigInfo,
+				       int supportedAPIs,
+				       IMG_PIXFMT ePixFmt);
+
+/* Blit functions */
+bool PVRDRIBlitEGLImage(PVRDRIScreenImpl *psScreenImpl,
+		        PVRDRIContextImpl *psContextImpl,
+			IMGEGLImage *psDstImage, PVRDRIBufferImpl *psDstBuffer,
+			IMGEGLImage *psSrcImage, PVRDRIBufferImpl *psSrcBuffer,
+			int iDstX, int iDstY, int iDstWidth, int iDstHeight,
+			int iSrcX, int iSrcY, int iSrcWidth, int iSrcHeight,
+			int iFlushFlag);
+
+/* Mapping functions */
+void *PVRDRIMapEGLImage(PVRDRIScreenImpl *psScreenImpl,
+			PVRDRIContextImpl *psContextImpl,
+			IMGEGLImage *psImage, PVRDRIBufferImpl *psBuffer,
+			int iX, int iY, int iWidth, int iHeight,
+			unsigned uiFlags, int *piStride, void **ppvData);
+
+bool PVRDRIUnmapEGLImage(PVRDRIScreenImpl *psScreenImpl,
+			 PVRDRIContextImpl *psContextImpl,
+			 IMGEGLImage *psImage, PVRDRIBufferImpl *psBuffer,
+			 void *pvData);
+
+/* PVR utility support functions */
+bool PVRDRIMesaFormatSupported(unsigned fmt);
+unsigned PVRDRIDepthStencilBitArraySize(void);
+const uint8_t *PVRDRIDepthBitsArray(void);
+const uint8_t *PVRDRIStencilBitsArray(void);
+unsigned PVRDRIMSAABitArraySize(void);
+const uint8_t *PVRDRIMSAABitsArray(void);
+uint32_t PVRDRIMaxPBufferWidth(void);
+uint32_t PVRDRIMaxPBufferHeight(void);
+
+unsigned PVRDRIGetNumAPIFuncs(PVRDRIAPIType eAPI);
+const char *PVRDRIGetAPIFunc(PVRDRIAPIType eAPI, unsigned index);
+
+int PVRDRIQuerySupportedFormats(PVRDRIScreenImpl *psScreenImpl,
+				unsigned uNumFormats,
+				const int *piFormats,
+				const IMG_PIXFMT *peImgFormats,
+				bool *pbSupported);
+
+int PVRDRIQueryModifiers(PVRDRIScreenImpl *psScreenImpl,
+			 int iFormat,
+			 IMG_PIXFMT eImgFormat,
+			 uint64_t *puModifiers,
+			 unsigned *puExternalOnly);
+
+#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..b023ef231cc
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/img_drm_fourcc.h
@@ -0,0 +1,110 @@
+/*************************************************************************/ /*!
+@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 we invent one.
+ * 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 we invent one.
+ * 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')
+#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..9e70a960636
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/imgpixfmts.h
@@ -0,0 +1,80 @@
+/*************************************************************************/ /*!
+@File
+@Title          Pixel formats
+@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: This file is autogenerated - DO NOT EDIT.
+ **
+ ** See fmts_systable.txt to add new formats.
+ ****************************************************************************/
+
+#if !defined(_IMGPIXFMTS_H_)
+#define _IMGPIXFMTS_H_
+
+typedef enum _IMG_PIXFMT_
+{
+	IMG_PIXFMT_UNKNOWN = 0,
+	IMG_PIXFMT_R10G10B10A2_UNORM = 25,
+	IMG_PIXFMT_R8G8B8A8_UNORM = 32,
+	IMG_PIXFMT_R8G8B8X8_UNORM = 37,
+	IMG_PIXFMT_D32_FLOAT = 51,
+	IMG_PIXFMT_D24_UNORM_X8_TYPELESS = 58,
+	IMG_PIXFMT_R8G8_UNORM = 62,
+	IMG_PIXFMT_D16_UNORM = 69,
+	IMG_PIXFMT_R8_UNORM = 76,
+	IMG_PIXFMT_S8_UINT = 81,
+	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_L8_UNORM = 136,
+	IMG_PIXFMT_L8A8_UNORM = 138,
+	IMG_PIXFMT_B4G4R4A4_UNORM = 145,
+	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_V8U8Y8A8 = 184,
+	IMG_PIXFMT_YVU8_422_2PLANE_PACK8 = 201,
+	IMG_PIXFMT_YVU10_444_1PLANE_PACK10 = 203,
+	IMG_PIXFMT_YUV8_422_2PLANE_PACK8 = 207,
+	IMG_PIXFMT_YUV8_444_3PLANE_PACK8 = 208,
+	IMG_PIXFMT_YVU8_420_2PLANE_PACK8_P = 245,
+	IMG_PIXFMT_YUV8_420_2PLANE_PACK8_P = 249,
+	IMG_PIXFMT_UYVY10_422_1PLANE_PACK10_CUST1 = 252,
+} 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..a91ee10d3f3
--- /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..064135222b6
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/mesa_context.c
@@ -0,0 +1,258 @@
+/* -*- mode: c; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* vi: set ts=8 sw=8 sts=8: */
+/**
+ * \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 <dlfcn.h>
+#include <assert.h>
+
+#include "main/version.h"
+#include "main/errors.h"
+
+#include "imports.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 numEntries = _glapi_get_dispatch_table_size();
+	_glapi_proc *table = malloc(numEntries * sizeof(_glapi_proc));
+
+	if (table)
+	{
+		unsigned i;
+
+		for (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;
+			break;
+		case PVRDRI_API_GLES2:
+			return &psPVRScreen->psOGLES2Dispatch;
+			break;
+		case PVRDRI_API_CL:
+			assert(!"OpenCL doesn't have a dispatch table");
+			break;
+		case PVRDRI_API_NONE:
+			assert(!"invalid API");
+			break;
+	}
+	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;
+	}
+}
+
+static void
+pvrdri_add_mesa_dispatch(struct _glapi_table *psTable,
+			 PVRDRIAPIType eAPI,
+			 PVRDRIScreenImpl *psScreenImpl,
+			 void *pvLibHandle,
+			 const char *psFunc)
+{
+	int iOffset;
+	const char *asFunc[] = {NULL, NULL};
+	_glapi_proc pfFunc;
+	const char *error;
+
+	(void) dlerror();
+	pfFunc = dlsym(pvLibHandle, psFunc);
+	error = dlerror();
+	if (error != NULL)
+	{
+		pfFunc = PVRDRIEGLGetProcAddress(eAPI, psScreenImpl, psFunc);
+		if (pfFunc == NULL)
+		{
+#if 0
+			/*
+			 * Not all extensions are supported, so there may
+			 * be quite a lot of lookup failures.
+			 */
+			_mesa_warning(NULL, "Couldn't get address of %s", psFunc);
+#endif
+			return;
+		}
+	}
+
+	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,
+			 PVRDRIScreenImpl *psScreenImpl,
+			 void *pvLibHandle,
+			 unsigned uNumFuncs)
+{
+	unsigned i;
+
+	for (i = 0; i < uNumFuncs; i++)
+	{
+		const char *psFunc = PVRDRIGetAPIFunc(eAPI, i);
+
+		assert(psFunc);
+
+		pvrdri_add_mesa_dispatch(psTable,
+					 eAPI,
+					 psScreenImpl,
+					 pvLibHandle,
+					 psFunc);
+	}
+}
+
+bool
+pvrdri_create_dispatch_table(PVRDRIScreen *psPVRScreen, PVRDRIAPIType eAPI)
+{
+	PVRDRIScreenImpl *psScreenImpl = psPVRScreen->psImpl;
+	struct _glapi_table **ppsTable = pvrdri_get_dispatch_table_ptr(psPVRScreen, eAPI);
+	void *pvLibHandle;
+	unsigned uNumFuncs;
+
+	if (ppsTable == NULL)
+	{
+		return false;
+	}
+
+	if (*ppsTable != NULL)
+	{
+		return true;
+	}
+
+	pvLibHandle = PVRDRIEGLGetLibHandle(eAPI, psScreenImpl);;
+	uNumFuncs = PVRDRIGetNumAPIFuncs(eAPI);
+	if (!pvLibHandle || !uNumFuncs)
+	{
+		return false;
+	}
+
+	*ppsTable = pvrdri_alloc_dispatch_table();
+	if (*ppsTable == NULL)
+	{
+		return false;
+	}
+
+	pvrdri_set_mesa_dispatch(*ppsTable,
+				 eAPI,
+				 psScreenImpl,
+				 pvLibHandle,
+				 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 = 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..768731a3761
--- /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',
+  'pvrcompat.c',
+  'pvrdrawable.c',
+  'pvrdri.c',
+  'pvrext.c',
+  'pvrimage.c',
+  'pvrutil.c',
+)
+
+dep_libpvr = [
+  dep_libdrm,
+  dependency('pvrdri', required : false),
+]
+
+libpvr = static_library(
+  'pvr',
+  [files_pvr, xmlpool_options_h, main_dispatch_h],
+  include_directories : [inc_common, inc_dri_common, inc_util, inc_pvr],
+  c_args : [c_vis_args, no_override_init_args],
+  cpp_args : [cpp_vis_args],
+  dependencies : [dep_libpvr],
+)
+
+dri_drivers += libpvr
+dri_link += 'pvr_dri.so'
diff --git a/src/mesa/drivers/dri/pvr/pvrcompat.c b/src/mesa/drivers/dri/pvr/pvrcompat.c
new file mode 100644
index 00000000000..e429e0cc135
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrcompat.c
@@ -0,0 +1,1383 @@
+/* -*- mode: c; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* vi: set ts=8 sw=8 sts=8: */
+/*
+ * 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 PVRDRISupportInterface gsSup;
+static unsigned guSupVer;
+
+static pthread_mutex_t gsCompatLock = PTHREAD_MUTEX_INITIALIZER;
+
+static void DumSupFunc(void) { abort(); }
+
+/* Call a function via the DRI Support interface structure */
+#define CallFunc(field, ver, ...) 					\
+	do { 								\
+		if (guSupVer >= ver && gsSup.field)			\
+			return gsSup.field(__VA_ARGS__);		\
+	} while(0)
+
+/* Define a function to test for a given DRI Support function */
+#define DefineFunc_IsSupported(func, field, ver)			\
+	bool func ## _IsSupported(void)					\
+	{ return guSupVer >= ver && gsSup.field; }
+
+
+/*
+ * Lookup a function, and set the pointer to the function address.
+ * If lookup fails, the pointer is set to the address of the dummy
+ * support function, DumSupFunc.
+ */
+#define LookupFunc(func, ptr)						\
+	do {								\
+		if (!ptr)						\
+		{							\
+			ptr = dlsym(gpvSupLib, MAKESTRING(func));	\
+			if (!ptr)					\
+				ptr = (void *)DumSupFunc; 		\
+		}							\
+	} while(0)
+
+/*
+ * Lookup a legacy DRI support function, and set the function pointer
+ * in the support interface structure, gsSup.
+ * If lookup fails, the function pointer is set to the address of the
+ * dummy support function, DumSupFunc.
+ */
+#define LookupLegacyFunc(func, field)					\
+	LookupFunc(func, gsSup.field)
+
+/*
+ * This legacy version of CallFunc should only be used for functions that
+ * used to be called directly in older versions of the DRI Support library.
+ * Do not use this macro for functions that have only ever been available
+ * via the PVRDRISupportInterface structure.
+ * In summary, if you are modifying this file to support a new version of
+ * the PVRDRISupportInterface structure, use CallFunc rather than this
+ * macro.
+ */
+#define CallFuncLegacy(func, field, ...) 				\
+	do { 								\
+		LookupLegacyFunc(func, field);				\
+									\
+		if (gsSup.field != (void *)DumSupFunc)			\
+			return gsSup.field(__VA_ARGS__);		\
+	} while(0)
+
+/*
+ * Legacy version of DefineFunc_IsSupported.
+ * See the comments for CallFuncLegacy.
+ */
+#define DefineFunc_IsSupportedLegacy(func, field) 			\
+	bool func ## _IsSupported(void) 				\
+	{ 								\
+		LookupLegacyFunc(func, field);				\
+									\
+		return gsSup.field != (void *)DumSupFunc;		\
+	}
+
+/*
+ * Calculate the size of a particular version of the PVRDRISupportInterface
+ * structure from the name of the last field in that version of the
+ * structure.
+ */
+#define PVRDRIInterfaceSize(field) \
+				(offsetof(PVRDRISupportInterface, field) + \
+				sizeof((PVRDRISupportInterface *)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\n", path);
+	}
+	else
+	{
+		const char *error = dlerror();
+
+		if (!error)
+		{
+			error = "unknown error";
+		}
+
+		errorMessage("%s: Couldn't load %s: %s\n",
+		             __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 = dlerror();
+
+		if (!error)
+		{
+			error = "unknown error";
+		}
+
+		errorMessage("%s: Couldn't unload %s: %s\n",
+		             __func__, name, error);
+	}
+	else
+	{
+		__driUtilMessage("Unloaded %s\n", 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 bool
+RegisterCallbacksCompat(const PVRDRICallbacks *psCallbacks)
+{
+	void (*pfRegisterCallbacks)(PVRDRICallbacks *psCallbacks) = NULL;
+
+	LookupFunc(PVRDRIRegisterCallbacks, pfRegisterCallbacks);
+
+	if (pfRegisterCallbacks != (void *)&DumSupFunc)
+	{
+		PVRDRICallbacks sCallbacks = *psCallbacks;
+
+		pfRegisterCallbacks(&sCallbacks);
+
+		return true;
+	}
+
+	return false;
+}
+
+static void
+CompatDeinit(void)
+{
+	UnloadSupportLib();
+	memset(&gsSup, 0, sizeof(gsSup));
+	guSupVer = 0;
+}
+
+bool
+PVRDRICompatInit(const PVRDRICallbacks *psCallbacks, unsigned uVersion)
+{
+	bool res;
+
+	bool (*pfRegisterVersionedCallbacks)(const PVRDRICallbacks *psCallbacks,
+						    unsigned uVersion) = NULL;
+
+	CompatLock();
+	res = (giSupLibRef++ != 0);
+	if (res)
+	{
+		goto Exit;
+	}
+
+	res = LoadSupportLib();
+	if (!res)
+	{
+		goto Exit;
+	}
+
+	LookupFunc(PVRDRIRegisterVersionedCallbacks, pfRegisterVersionedCallbacks);
+
+	if (pfRegisterVersionedCallbacks != (void *)&DumSupFunc)
+	{
+		res = pfRegisterVersionedCallbacks(psCallbacks, uVersion);
+	}
+	else
+	{
+		res = RegisterCallbacksCompat(psCallbacks);
+	}
+Exit:
+	if (!res)
+	{
+		CompatDeinit();
+		giSupLibRef--;
+	}
+	CompatUnlock();
+
+	return res;
+}
+
+void
+PVRDRICompatDeinit(void)
+{
+	CompatLock();
+
+	if (--giSupLibRef == 0)
+	{
+		CompatDeinit();
+	}
+
+	CompatUnlock();
+}
+
+bool
+PVRDRIRegisterSupportInterfaceV1(const PVRDRISupportInterface *psInterface,
+				 unsigned uVersion)
+{
+	size_t uSize;
+
+	/* The "default" case should be associated with the latest version */
+	switch (uVersion)
+	{
+		default:
+		case 2:
+			uSize = PVRDRIInterfaceSize(GetFenceFd);
+			break;
+		case 1:
+			uSize = PVRDRIInterfaceSize(CreateDrawableWithConfig);
+			break;
+		case 0:
+			uSize = PVRDRIInterfaceSize(QueryModifiers);
+			break;
+	}
+
+	memcpy(&gsSup, psInterface, uSize);
+
+	guSupVer = uVersion;
+
+	return true;
+}
+
+PVRDRIDeviceType
+PVRDRIGetDeviceTypeFromFd(int iFd)
+{
+	CallFuncLegacy(PVRDRIGetDeviceTypeFromFd,
+		       GetDeviceTypeFromFd,
+		       iFd);
+
+	return PVRDRI_DEVICE_TYPE_INVALID;
+}
+
+
+bool
+PVRDRIIsFirstScreen(PVRDRIScreenImpl *psScreenImpl)
+{
+	CallFuncLegacy(PVRDRIIsFirstScreen,
+		       IsFirstScreen,
+		       psScreenImpl);
+
+	return false;
+}
+
+
+uint32_t
+PVRDRIPixFmtGetDepth(IMG_PIXFMT eFmt)
+{
+	CallFuncLegacy(PVRDRIPixFmtGetDepth,
+		       PixFmtGetDepth,
+		       eFmt);
+
+	return 0;
+}
+
+uint32_t
+PVRDRIPixFmtGetBPP(IMG_PIXFMT eFmt)
+{
+	CallFuncLegacy(PVRDRIPixFmtGetBPP,
+		       PixFmtGetBPP,
+		       eFmt);
+
+	return 0;
+}
+
+uint32_t
+PVRDRIPixFmtGetBlockSize(IMG_PIXFMT eFmt)
+{
+	CallFuncLegacy(PVRDRIPixFmtGetBlockSize,
+		       PixFmtGetBlockSize,
+		       eFmt);
+
+	return 0;
+}
+
+PVRDRIScreenImpl *
+PVRDRICreateScreenImpl(int iFd)
+{
+	CallFuncLegacy(PVRDRICreateScreenImpl,
+		       CreateScreen,
+		       iFd);
+
+	return NULL;
+}
+
+void
+PVRDRIDestroyScreenImpl(PVRDRIScreenImpl *psScreenImpl)
+{
+	CallFuncLegacy(PVRDRIDestroyScreenImpl,
+		       DestroyScreen,
+		       psScreenImpl);
+}
+
+int
+PVRDRIAPIVersion(PVRDRIAPIType eAPI,
+		 PVRDRIAPISubType eAPISub,
+		 PVRDRIScreenImpl *psScreenImpl)
+{
+	CallFuncLegacy(PVRDRIAPIVersion,
+		       APIVersion,
+		       eAPI,
+		       eAPISub,
+		       psScreenImpl);
+
+	return 0;
+}
+
+void *
+PVRDRIEGLGetLibHandle(PVRDRIAPIType eAPI,
+		      PVRDRIScreenImpl *psScreenImpl)
+{
+	CallFuncLegacy(PVRDRIEGLGetLibHandle,
+		       EGLGetLibHandle,
+		       eAPI,
+		       psScreenImpl);
+
+	return NULL;
+}
+
+PVRDRIGLAPIProc
+PVRDRIEGLGetProcAddress(PVRDRIAPIType eAPI,
+			PVRDRIScreenImpl *psScreenImpl,
+			const char *psProcName)
+{
+	CallFuncLegacy(PVRDRIEGLGetProcAddress,
+		       EGLGetProcAddress,
+		       eAPI,
+		       psScreenImpl,
+		       psProcName);
+
+	return (PVRDRIGLAPIProc)NULL;
+}
+
+bool
+PVRDRIEGLFlushBuffers(PVRDRIAPIType eAPI,
+		      PVRDRIScreenImpl *psScreenImpl,
+		      PVRDRIContextImpl *psContextImpl,
+		      PVRDRIDrawableImpl *psDrawableImpl,
+		      bool bFlushAllSurfaces,
+		      bool bSwapBuffers,
+		      bool bWaitForHW)
+{
+	CallFuncLegacy(PVRDRIEGLFlushBuffers,
+		       EGLFlushBuffers,
+		       eAPI,
+		       psScreenImpl,
+		       psContextImpl,
+		       psDrawableImpl,
+		       bFlushAllSurfaces,
+		       bSwapBuffers,
+		       bWaitForHW);
+
+	return false;
+}
+
+void
+PVRDRIEGLMarkRendersurfaceInvalid(PVRDRIAPIType eAPI,
+				  PVRDRIScreenImpl *psScreenImpl,
+				  PVRDRIContextImpl *psContextImpl)
+{
+	CallFuncLegacy(PVRDRIEGLMarkRendersurfaceInvalid,
+		       EGLMarkRendersurfaceInvalid,
+		       eAPI,
+		       psScreenImpl,
+		       psContextImpl);
+}
+
+static inline void PVRDRIConfigFromMesa(PVRDRIConfigInfo *psConfigInfo,
+					const struct gl_config *psGLMode)
+{
+	memset(psConfigInfo, 0, sizeof(*psConfigInfo));
+
+	if (psGLMode)
+	{
+		psConfigInfo->samples           = psGLMode->samples;
+		psConfigInfo->redBits           = psGLMode->redBits;
+		psConfigInfo->greenBits         = psGLMode->greenBits;
+		psConfigInfo->blueBits          = psGLMode->blueBits;
+		psConfigInfo->alphaBits         = psGLMode->alphaBits;
+		psConfigInfo->rgbBits           = psGLMode->rgbBits;
+		psConfigInfo->depthBits         = psGLMode->depthBits;
+		psConfigInfo->stencilBits       = psGLMode->stencilBits;
+		psConfigInfo->doubleBufferMode  = psGLMode->doubleBufferMode;
+
+		psConfigInfo->sampleBuffers     = psGLMode->sampleBuffers;
+		psConfigInfo->bindToTextureRgb  = psGLMode->bindToTextureRgb;
+		psConfigInfo->bindToTextureRgba = psGLMode->bindToTextureRgba;
+	}
+}
+
+unsigned
+PVRDRISupportCreateContext(PVRDRIScreenImpl *psScreenImpl,
+			   PVRDRIContextImpl *psSharedContextImpl,
+			   PVRDRIConfig *psConfig,
+			   PVRDRIAPIType eAPI,
+			   PVRDRIAPISubType eAPISub,
+			   unsigned uMajorVersion,
+			   unsigned uMinorVersion,
+			   uint32_t uFlags,
+			   bool bNotifyReset,
+			   unsigned uPriority,
+			   PVRDRIContextImpl **ppsContextImpl)
+{
+	PVRDRIConfigInfo sConfigInfo;
+
+	CallFunc(CreateContextV1, 1,
+		 psScreenImpl, psSharedContextImpl, psConfig, eAPI, eAPISub,
+		 uMajorVersion, uMinorVersion, uFlags, bNotifyReset, uPriority,
+		 ppsContextImpl);
+
+	PVRDRIConfigFromMesa(&sConfigInfo, &psConfig->sGLMode);
+
+	CallFuncLegacy(PVRDRICreateContextImpl,
+		       CreateContext,
+		       ppsContextImpl,
+		       eAPI,
+		       eAPISub,
+		       psScreenImpl,
+		       &sConfigInfo,
+		       uMajorVersion,
+		       uMinorVersion,
+		       uFlags,
+		       bNotifyReset,
+		       uPriority,
+		       psSharedContextImpl);
+
+	return PVRDRI_CONTEXT_ERROR_BAD_API;
+}
+
+void
+PVRDRIDestroyContextImpl(PVRDRIContextImpl *psContextImpl,
+			 PVRDRIAPIType eAPI,
+			 PVRDRIScreenImpl *psScreenImpl)
+{
+	CallFuncLegacy(PVRDRIDestroyContextImpl,
+		       DestroyContext,
+		       psContextImpl,
+		       eAPI,
+		       psScreenImpl);
+}
+
+bool
+PVRDRIMakeCurrentGC(PVRDRIAPIType eAPI,
+		    PVRDRIScreenImpl *psScreenImpl,
+		    PVRDRIContextImpl *psContextImpl,
+		    PVRDRIDrawableImpl *psWriteImpl,
+		    PVRDRIDrawableImpl *psReadImpl)
+{
+	CallFuncLegacy(PVRDRIMakeCurrentGC,
+		       MakeCurrentGC,
+		       eAPI,
+		       psScreenImpl,
+		       psContextImpl,
+		       psWriteImpl,
+		       psReadImpl);
+
+	return false;
+}
+
+void
+PVRDRIMakeUnCurrentGC(PVRDRIAPIType eAPI,
+		      PVRDRIScreenImpl *psScreenImpl)
+{
+	CallFuncLegacy(PVRDRIMakeUnCurrentGC,
+		       MakeUnCurrentGC,
+		       eAPI,
+		       psScreenImpl);
+}
+
+unsigned
+PVRDRIGetImageSource(PVRDRIAPIType eAPI,
+		     PVRDRIScreenImpl *psScreenImpl,
+		     PVRDRIContextImpl *psContextImpl,
+		     uint32_t  uiTarget,
+		     uintptr_t uiBuffer,
+		     uint32_t  uiLevel,
+		     IMGEGLImage *psEGLImage)
+{
+	CallFuncLegacy(PVRDRIGetImageSource,
+		       GetImageSource,
+		       eAPI,
+		       psScreenImpl,
+		       psContextImpl,
+		       uiTarget,
+		       uiBuffer,
+		       uiLevel,
+		       psEGLImage);
+
+	return PVRDRI_IMAGE_ERROR_BAD_MATCH;
+}
+
+bool
+PVRDRI2BindTexImage(PVRDRIAPIType eAPI,
+		    PVRDRIScreenImpl *psScreenImpl,
+		    PVRDRIContextImpl *psContextImpl,
+		    PVRDRIDrawableImpl *psDrawableImpl)
+{
+	CallFuncLegacy(PVRDRI2BindTexImage,
+		       BindTexImage,
+		       eAPI,
+		       psScreenImpl,
+		       psContextImpl,
+		       psDrawableImpl);
+
+	return false;
+}
+
+void
+PVRDRI2ReleaseTexImage(PVRDRIAPIType eAPI,
+		       PVRDRIScreenImpl *psScreenImpl,
+		       PVRDRIContextImpl *psContextImpl,
+		       PVRDRIDrawableImpl *psDrawableImpl)
+{
+	CallFuncLegacy(PVRDRI2ReleaseTexImage,
+		       ReleaseTexImage,
+		       eAPI,
+		       psScreenImpl,
+		       psContextImpl,
+		       psDrawableImpl);
+}
+
+PVRDRIDrawableImpl *
+PVRDRICreateDrawableImpl(PVRDRIDrawable *psPVRDrawable)
+{
+	CallFuncLegacy(PVRDRICreateDrawableImpl,
+		       CreateDrawable,
+		       psPVRDrawable);
+
+	return NULL;
+}
+
+PVRDRIDrawableImpl *
+PVRDRISupportCreateDrawable(PVRDRIDrawable *psPVRDrawable,
+			    PVRDRIConfig *psConfig)
+{
+	PVRDRIDrawableImpl *psDrawableImpl;
+	PVRDRIConfigInfo sConfigInfo;
+	IMG_PIXFMT ePixelFormat;
+
+	CallFunc(CreateDrawableWithConfig, 1,
+		 psPVRDrawable,
+		 psConfig);
+
+	ePixelFormat = PVRDRIGetPixelFormat(&psConfig->sGLMode);
+	if (ePixelFormat == IMG_PIXFMT_UNKNOWN)
+	{
+		__driUtilMessage("%s: Couldn't work out pixel format", __func__);
+		return NULL;
+	}
+
+	psDrawableImpl = PVRDRICreateDrawableImpl(psPVRDrawable);
+	if (!psDrawableImpl)
+	{
+		return NULL;
+	}
+
+	PVRDRIConfigFromMesa(&sConfigInfo, &psConfig->sGLMode);
+	if (!PVRDRIEGLDrawableConfigFromGLMode(psDrawableImpl,
+	                                       &sConfigInfo,
+	                                       psConfig->iSupportedAPIs,
+	                                       ePixelFormat))
+	{
+		__driUtilMessage("%s: Couldn't derive EGL config", __func__);
+		PVRDRIDestroyDrawableImpl(psDrawableImpl);
+		return NULL;
+	}
+
+	return psDrawableImpl;
+}
+
+void
+PVRDRIDestroyDrawableImpl(PVRDRIDrawableImpl *psScreenImpl)
+{
+	CallFuncLegacy(PVRDRIDestroyDrawableImpl,
+		       DestroyDrawable,
+		       psScreenImpl);
+}
+
+bool
+PVREGLDrawableCreate(PVRDRIScreenImpl *psScreenImpl,
+		     PVRDRIDrawableImpl *psDrawableImpl)
+{
+	CallFuncLegacy(PVREGLDrawableCreate,
+		       EGLDrawableCreate,
+		       psScreenImpl,
+		       psDrawableImpl);
+
+	return false;
+}
+
+bool
+PVREGLDrawableRecreate(PVRDRIScreenImpl *psScreenImpl,
+		       PVRDRIDrawableImpl *psDrawableImpl)
+{
+	CallFuncLegacy(PVREGLDrawableRecreate,
+		       EGLDrawableRecreate,
+		       psScreenImpl,
+		       psDrawableImpl);
+
+	return false;
+}
+
+bool
+PVREGLDrawableDestroy(PVRDRIScreenImpl *psScreenImpl,
+		      PVRDRIDrawableImpl *psDrawableImpl)
+{
+	CallFuncLegacy(PVREGLDrawableDestroy,
+		       EGLDrawableDestroy,
+		       psScreenImpl,
+		       psDrawableImpl);
+
+	return false;
+}
+
+void
+PVREGLDrawableDestroyConfig(PVRDRIDrawableImpl *psDrawableImpl)
+{
+	CallFuncLegacy(PVREGLDrawableDestroyConfig,
+		       EGLDrawableDestroyConfig,
+		       psDrawableImpl);
+}
+
+PVRDRIBufferImpl *
+PVRDRIBufferCreate(PVRDRIScreenImpl *psScreenImpl,
+		   int iWidth,
+		   int iHeight,
+		   unsigned int uiBpp,
+		   unsigned int uiUseFlags,
+		   unsigned int *puiStride)
+{
+	CallFuncLegacy(PVRDRIBufferCreate,
+		       BufferCreate,
+		       psScreenImpl,
+		       iWidth,
+		       iHeight,
+		       uiBpp,
+		       uiUseFlags,
+		       puiStride);
+
+	return NULL;
+}
+
+DefineFunc_IsSupportedLegacy(PVRDRIBufferCreateWithModifiers,
+			     BufferCreateWithModifiers)
+
+PVRDRIBufferImpl *
+PVRDRIBufferCreateWithModifiers(PVRDRIScreenImpl *psScreenImpl,
+				int iWidth,
+				int iHeight,
+				int format,
+				IMG_PIXFMT eIMGPixelFormat,
+				const uint64_t *puiModifiers,
+				unsigned int uiModifierCount,
+				unsigned int *puiStride)
+{
+	CallFuncLegacy(PVRDRIBufferCreateWithModifiers,
+		       BufferCreateWithModifiers,
+		       psScreenImpl,
+		       iWidth,
+		       iHeight,
+		       format,
+		       eIMGPixelFormat,
+		       puiModifiers,
+		       uiModifierCount,
+		       puiStride);
+
+	return NULL;
+}
+
+PVRDRIBufferImpl *
+PVRDRIBufferCreateFromNames(PVRDRIScreenImpl *psScreenImpl,
+			    int iWidth,
+			    int iHeight,
+			    unsigned uiNumPlanes,
+			    const int *piName,
+			    const int *piStride,
+			    const int *piOffset,
+			    const unsigned int *puiWidthShift,
+			    const unsigned int *puiHeightShift)
+{
+	CallFuncLegacy(PVRDRIBufferCreateFromNames,
+		       BufferCreateFromNames,
+		       psScreenImpl,
+		       iWidth,
+		       iHeight,
+		       uiNumPlanes,
+		       piName,
+		       piStride,
+		       piOffset,
+		       puiWidthShift,
+		       puiHeightShift);
+
+	return NULL;
+}
+
+PVRDRIBufferImpl *
+PVRDRIBufferCreateFromName(PVRDRIScreenImpl *psScreenImpl,
+			   int iName,
+			   int iWidth,
+			   int iHeight,
+			   int iStride,
+			   int iOffset)
+{
+	CallFuncLegacy(PVRDRIBufferCreateFromName,
+		       BufferCreateFromName,
+		       psScreenImpl,
+		       iName,
+		       iWidth,
+		       iHeight,
+		       iStride,
+		       iOffset);
+
+	return NULL;
+}
+
+PVRDRIBufferImpl *
+PVRDRIBufferCreateFromFds(PVRDRIScreenImpl *psScreenImpl,
+			  int iWidth,
+			  int iHeight,
+			  unsigned uiNumPlanes,
+			  const int *piFd,
+			  const int *piStride,
+			  const int *piOffset,
+			  const unsigned int *puiWidthShift,
+			  const unsigned int *puiHeightShift)
+{
+	CallFuncLegacy(PVRDRIBufferCreateFromFds,
+		       BufferCreateFromFds,
+		       psScreenImpl,
+		       iWidth,
+		       iHeight,
+		       uiNumPlanes,
+		       piFd,
+		       piStride,
+		       piOffset,
+		       puiWidthShift,
+		       puiHeightShift);
+
+	return NULL;
+}
+
+DefineFunc_IsSupportedLegacy(PVRDRIBufferCreateFromFdsWithModifier,
+			     BufferCreateFromFdsWithModifier)
+
+PVRDRIBufferImpl *
+PVRDRIBufferCreateFromFdsWithModifier(PVRDRIScreenImpl *psScreenImpl,
+				      int iWidth,
+				      int iHeight,
+				      uint64_t uiModifier,
+				      unsigned uiNumPlanes,
+				      const int *piFd,
+				      const int *piStride,
+				      const int *piOffset,
+				      const unsigned int *puiWidthShift,
+				      const unsigned int *puiHeightShift)
+{
+	CallFuncLegacy(PVRDRIBufferCreateFromFdsWithModifier,
+		       BufferCreateFromFdsWithModifier,
+		       psScreenImpl,
+		       iWidth,
+		       iHeight,
+		       uiModifier,
+		       uiNumPlanes,
+		       piFd,
+		       piStride,
+		       piOffset,
+		       puiWidthShift,
+		       puiHeightShift);
+
+	if (uiModifier == DRM_FORMAT_MOD_INVALID)
+	{
+		CallFuncLegacy(PVRDRIBufferCreateFromFds,
+			       BufferCreateFromFds,
+			       psScreenImpl,
+			       iWidth,
+			       iHeight,
+			       uiNumPlanes,
+			       piFd,
+			       piStride,
+			       piOffset,
+			       puiWidthShift,
+			       puiHeightShift);
+	}
+
+	return NULL;
+}
+
+PVRDRIBufferImpl *
+PVRDRISubBufferCreate(PVRDRIScreenImpl *psScreen,
+		      PVRDRIBufferImpl *psParentBuffer,
+		      int plane)
+{
+	CallFuncLegacy(PVRDRISubBufferCreate,
+		       SubBufferCreate,
+		       psScreen,
+		       psParentBuffer,
+		       plane);
+
+	return NULL;
+}
+
+void
+PVRDRIBufferDestroy(PVRDRIBufferImpl *psBuffer)
+{
+	CallFuncLegacy(PVRDRIBufferDestroy,
+		       BufferDestroy,
+		       psBuffer);
+}
+
+int
+PVRDRIBufferGetFd(PVRDRIBufferImpl *psBuffer)
+{
+	CallFuncLegacy(PVRDRIBufferGetFd,
+		       BufferGetFd,
+		       psBuffer);
+
+	return -1;
+}
+
+int
+PVRDRIBufferGetHandle(PVRDRIBufferImpl *psBuffer)
+{
+	CallFuncLegacy(PVRDRIBufferGetHandle,
+		       BufferGetHandle,
+		       psBuffer);
+
+	return 0;
+}
+
+uint64_t
+PVRDRIBufferGetModifier(PVRDRIBufferImpl *psBuffer)
+{
+	CallFuncLegacy(PVRDRIBufferGetModifier,
+		       BufferGetModifier,
+		       psBuffer);
+
+	return DRM_FORMAT_MOD_INVALID;
+}
+
+int
+PVRDRIBufferGetName(PVRDRIBufferImpl *psBuffer)
+{
+	CallFuncLegacy(PVRDRIBufferGetName,
+		       BufferGetName,
+		       psBuffer);
+
+	return 0;
+}
+
+DefineFunc_IsSupportedLegacy(PVRDRIBufferGetOffset, BufferGetOffset)
+
+int
+PVRDRIBufferGetOffset(PVRDRIBufferImpl *psBuffer)
+{
+	CallFuncLegacy(PVRDRIBufferGetOffset,
+		       BufferGetOffset,
+		       psBuffer);
+
+	return 0;
+}
+
+IMGEGLImage *
+PVRDRIEGLImageCreate(void)
+{
+	CallFuncLegacy(PVRDRIEGLImageCreate,
+		       EGLImageCreate);
+
+	return NULL;
+}
+
+IMGEGLImage *
+PVRDRIEGLImageCreateFromBuffer(int iWidth,
+			       int iHeight,
+			       int iStride,
+			       IMG_PIXFMT ePixelFormat,
+			       IMG_YUV_COLORSPACE eColourSpace,
+			       IMG_YUV_CHROMA_INTERP eChromaUInterp,
+			       IMG_YUV_CHROMA_INTERP eChromaVInterp,
+			       PVRDRIBufferImpl *psBuffer)
+{
+	CallFuncLegacy(PVRDRIEGLImageCreateFromBuffer,
+		       EGLImageCreateFromBuffer,
+		       iWidth,
+		       iHeight,
+		       iStride,
+		       ePixelFormat,
+		       eColourSpace,
+		       eChromaUInterp,
+		       eChromaVInterp,
+		       psBuffer);
+
+	return NULL;
+}
+
+IMGEGLImage *
+PVRDRIEGLImageCreateFromSubBuffer(IMG_PIXFMT ePixelFormat,
+				  PVRDRIBufferImpl *psSubBuffer)
+{
+	CallFuncLegacy(PVRDRIEGLImageCreateFromSubBuffer,
+		       EGLImageCreateFromSubBuffer,
+		       ePixelFormat,
+		       psSubBuffer);
+
+	return NULL;
+}
+
+IMGEGLImage *
+PVRDRIEGLImageDup(IMGEGLImage *psIn)
+{
+	CallFuncLegacy(PVRDRIEGLImageDup,
+		       EGLImageDup,
+		       psIn);
+
+	return NULL;
+}
+
+void
+PVRDRIEGLImageSetCallbackData(IMGEGLImage *psEGLImage, __DRIimage *image)
+{
+	CallFuncLegacy(PVRDRIEGLImageSetCallbackData,
+		       EGLImageSetCallbackData,
+		       psEGLImage,
+		       image);
+}
+
+void
+PVRDRIEGLImageDestroyExternal(PVRDRIScreenImpl *psScreenImpl,
+			      IMGEGLImage *psEGLImage,
+			      PVRDRIEGLImageType eglImageType)
+{
+	CallFuncLegacy(PVRDRIEGLImageDestroyExternal,
+		       EGLImageDestroyExternal,
+		       psScreenImpl,
+		       psEGLImage,
+		       eglImageType);
+}
+
+void
+PVRDRIEGLImageFree(IMGEGLImage *psEGLImage)
+{
+	CallFuncLegacy(PVRDRIEGLImageFree,
+		       EGLImageFree,
+		       psEGLImage);
+}
+
+void
+PVRDRIEGLImageGetAttribs(IMGEGLImage *psEGLImage,
+			 PVRDRIBufferAttribs *psAttribs)
+{
+	CallFuncLegacy(PVRDRIEGLImageGetAttribs,
+		       EGLImageGetAttribs,
+		       psEGLImage,
+		       psAttribs);
+}
+
+void *
+PVRDRICreateFenceImpl(PVRDRIAPIType eAPI,
+		      PVRDRIScreenImpl *psScreenImpl,
+		      PVRDRIContextImpl *psContextImpl)
+{
+	CallFuncLegacy(PVRDRICreateFenceImpl,
+		       CreateFence,
+		       eAPI,
+		       psScreenImpl,
+		       psContextImpl);
+
+	return NULL;
+}
+
+void *
+PVRDRICreateFenceFdImpl(PVRDRIAPIType eAPI,
+		      PVRDRIScreenImpl *psScreenImpl,
+		      PVRDRIContextImpl *psContextImpl,
+		      int iFd)
+{
+	CallFunc(CreateFenceFd, 2,
+		 eAPI,
+	         psScreenImpl,
+		 psContextImpl,
+		 iFd);
+
+	return NULL;
+}
+
+unsigned PVRDRIGetFenceCapabilitiesImpl(PVRDRIScreenImpl *psScreenImpl)
+{
+	CallFunc(GetFenceCapabilities, 2,
+		 psScreenImpl);
+
+	return 0;
+}
+
+int PVRDRIGetFenceFdImpl(void *psDRIFence)
+{
+	CallFunc(GetFenceFd, 2,
+		 psDRIFence);
+
+	return -1;
+}
+
+void
+PVRDRIDestroyFenceImpl(void *psDRIFence)
+{
+	CallFuncLegacy(PVRDRIDestroyFenceImpl,
+		       DestroyFence,
+		       psDRIFence);
+}
+
+bool
+PVRDRIClientWaitSyncImpl(PVRDRIAPIType eAPI,
+			 PVRDRIContextImpl *psContextImpl,
+			 void *psDRIFence,
+			 bool bFlushCommands,
+			 bool bTimeout,
+			 uint64_t uiTimeout)
+{
+	CallFuncLegacy(PVRDRIClientWaitSyncImpl,
+		       ClientWaitSync,
+		       eAPI,
+		       psContextImpl,
+		       psDRIFence,
+		       bFlushCommands,
+		       bTimeout,
+		       uiTimeout);
+
+	return false;
+}
+
+bool
+PVRDRIServerWaitSyncImpl(PVRDRIAPIType eAPI,
+			 PVRDRIContextImpl *psContextImpl,
+			 void *psDRIFence)
+{
+	CallFuncLegacy(PVRDRIServerWaitSyncImpl,
+		       ServerWaitSync,
+		       eAPI,
+		       psContextImpl,
+		       psDRIFence);
+
+	return false;
+}
+
+void
+PVRDRIDestroyFencesImpl(PVRDRIScreenImpl *psScreenImpl)
+{
+	CallFuncLegacy(PVRDRIDestroyFencesImpl,
+		       DestroyFences,
+		       psScreenImpl);
+}
+
+bool
+PVRDRIEGLDrawableConfigFromGLMode(PVRDRIDrawableImpl *psPVRDrawable,
+				  PVRDRIConfigInfo *psConfigInfo,
+				  int supportedAPIs,
+				  IMG_PIXFMT ePixFmt)
+{
+	CallFuncLegacy(PVRDRIEGLDrawableConfigFromGLMode,
+		       EGLDrawableConfigFromGLMode,
+		       psPVRDrawable,
+		       psConfigInfo,
+		       supportedAPIs,
+		       ePixFmt);
+
+	return false;
+}
+
+DefineFunc_IsSupportedLegacy(PVRDRIBlitEGLImage, BlitEGLImage)
+
+bool
+PVRDRIBlitEGLImage(PVRDRIScreenImpl *psScreenImpl,
+		   PVRDRIContextImpl *psContextImpl,
+		   IMGEGLImage *psDstImage,
+		   PVRDRIBufferImpl *psDstBuffer,
+		   IMGEGLImage *psSrcImage,
+		   PVRDRIBufferImpl *psSrcBuffer,
+		   int iDstX, int iDstY,
+		   int iDstWidth, int iDstHeight,
+		   int iSrcX, int iSrcY,
+		   int iSrcWidth, int iSrcHeight,
+		   int iFlushFlag)
+{
+	CallFuncLegacy(PVRDRIBlitEGLImage,
+		       BlitEGLImage,
+		       psScreenImpl,
+		       psContextImpl,
+		       psDstImage, psDstBuffer,
+		       psSrcImage, psSrcBuffer,
+		       iDstX, iDstY,
+		       iDstWidth, iDstHeight,
+		       iSrcX, iSrcY,
+		       iSrcWidth, iSrcHeight,
+		       iFlushFlag);
+
+	return false;
+}
+
+DefineFunc_IsSupportedLegacy(PVRDRIMapEGLImage, MapEGLImage)
+
+void *
+PVRDRIMapEGLImage(PVRDRIScreenImpl *psScreenImpl,
+		  PVRDRIContextImpl *psContextImpl,
+		  IMGEGLImage *psImage,
+		  PVRDRIBufferImpl *psBuffer,
+		  int iX, int iY, int iWidth, int iHeight,
+		  unsigned uiFlags, int *iStride, void **ppvData)
+{
+	CallFuncLegacy(PVRDRIMapEGLImage,
+		       MapEGLImage,
+		       psScreenImpl,
+		       psContextImpl,
+		       psImage, psBuffer,
+		       iX, iY, iWidth, iHeight,
+		       uiFlags, iStride, ppvData);
+
+	return false;
+}
+
+bool
+PVRDRIUnmapEGLImage(PVRDRIScreenImpl *psScreenImpl,
+		    PVRDRIContextImpl *psContextImpl,
+		    IMGEGLImage *psImage,
+		    PVRDRIBufferImpl *psBuffer,
+		    void *pvData)
+{
+	CallFuncLegacy(PVRDRIUnmapEGLImage,
+		       UnmapEGLImage,
+		       psScreenImpl,
+		       psContextImpl,
+		       psImage, psBuffer,
+		       pvData);
+
+	return false;
+}
+
+bool
+PVRDRIMesaFormatSupported(unsigned fmt)
+{
+	CallFuncLegacy(PVRDRIMesaFormatSupported,
+		       MesaFormatSupported,
+		       fmt);
+
+	return false;
+}
+
+unsigned
+PVRDRIDepthStencilBitArraySize(void)
+{
+	CallFuncLegacy(PVRDRIDepthStencilBitArraySize,
+		       DepthStencilBitArraySize);
+
+	return 0;
+}
+
+const uint8_t *
+PVRDRIDepthBitsArray(void)
+{
+	CallFuncLegacy(PVRDRIDepthBitsArray,
+		       DepthBitsArray);
+
+	return NULL;
+}
+
+const uint8_t *
+PVRDRIStencilBitsArray(void)
+{
+	CallFuncLegacy(PVRDRIStencilBitsArray,
+		       StencilBitsArray);
+
+	return NULL;
+}
+
+unsigned
+PVRDRIMSAABitArraySize(void)
+{
+	CallFuncLegacy(PVRDRIMSAABitArraySize,
+		       MSAABitArraySize);
+
+	return 0;
+}
+
+const uint8_t *
+PVRDRIMSAABitsArray(void)
+{
+	CallFuncLegacy(PVRDRIMSAABitsArray,
+		       MSAABitsArray);
+
+	return NULL;
+}
+
+uint32_t
+PVRDRIMaxPBufferWidth(void)
+{
+	CallFuncLegacy(PVRDRIMaxPBufferWidth,
+		       MaxPBufferWidth);
+
+	return 0;
+}
+
+uint32_t
+PVRDRIMaxPBufferHeight(void)
+{
+	CallFuncLegacy(PVRDRIMaxPBufferHeight,
+		       MaxPBufferHeight);
+
+	return 0;
+}
+
+
+unsigned
+PVRDRIGetNumAPIFuncs(PVRDRIAPIType eAPI)
+{
+	CallFuncLegacy(PVRDRIGetNumAPIFuncs,
+		       GetNumAPIFuncs,
+		       eAPI);
+
+	return 0;
+}
+
+const char *
+PVRDRIGetAPIFunc(PVRDRIAPIType eAPI, unsigned index)
+{
+	CallFuncLegacy(PVRDRIGetAPIFunc,
+		       GetAPIFunc,
+		       eAPI,
+		       index);
+
+	return NULL;
+}
+
+int
+PVRDRIQuerySupportedFormats(PVRDRIScreenImpl *psScreenImpl,
+			    unsigned uNumFormats,
+			    const int *iFormats,
+			    const IMG_PIXFMT *peImgFormats,
+			    bool *bSupported)
+{
+	CallFuncLegacy(PVRDRIQuerySupportedFormats,
+		       QuerySupportedFormats,
+		       psScreenImpl,
+		       uNumFormats,
+		       iFormats,
+		       peImgFormats,
+		       bSupported);
+
+	return -1;
+}
+
+int
+PVRDRIQueryModifiers(PVRDRIScreenImpl *psScreenImpl,
+		     int iFormat,
+		     IMG_PIXFMT eImgFormat,
+		     uint64_t *puModifiers,
+		     unsigned *puExternalOnly)
+{
+	CallFuncLegacy(PVRDRIQueryModifiers,
+		       QueryModifiers,
+		       psScreenImpl,
+		       iFormat,
+		       eImgFormat,
+		       puModifiers,
+		       puExternalOnly);
+
+	return -1;
+}
diff --git a/src/mesa/drivers/dri/pvr/pvrdrawable.c b/src/mesa/drivers/dri/pvr/pvrdrawable.c
new file mode 100644
index 00000000000..a725645f7b6
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrdrawable.c
@@ -0,0 +1,542 @@
+/* -*- mode: c; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* vi: set ts=8 sw=8 sts=8: */
+/*
+ * 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 "util/u_atomic.h"
+
+#include "dri_util.h"
+
+#include "pvrdri.h"
+#include "pvrimage.h"
+
+static inline void PVRDRIMarkRenderSurfaceAsInvalid(PVRDRIDrawable *psPVRDrawable)
+{
+	PVRDRIContext *psPVRContext = psPVRDrawable->psPVRContext;
+
+	if (psPVRContext)
+	{
+
+		PVRDRIEGLMarkRendersurfaceInvalid(psPVRContext->eAPI,
+						  psPVRContext->psPVRScreen->psImpl,
+						  psPVRContext->psImpl);
+	}
+}
+
+/*************************************************************************/ /*!
+ PVR drawable local functions (image driver loader)
+*/ /**************************************************************************/
+
+static inline void PVRDrawableImageDestroy(PVRDRIDrawable *psPVRDrawable)
+{
+	if (psPVRDrawable->psImage)
+	{
+		PVRDRIUnrefImage(psPVRDrawable->psImage);
+		psPVRDrawable->psImage = NULL;
+	}
+}
+
+static inline void PVRDrawableImageAccumDestroy(PVRDRIDrawable *psPVRDrawable)
+{
+	if (psPVRDrawable->psImageAccum)
+	{
+		PVRDRIUnrefImage(psPVRDrawable->psImageAccum);
+		psPVRDrawable->psImageAccum = NULL;
+	}
+}
+
+static void PVRDrawableImageUpdate(PVRDRIDrawable *psPVRDrawable)
+{
+	if (psPVRDrawable->psImage != psPVRDrawable->psDRI)
+	{
+		assert(PVRDRIImageGetSharedBuffer(psPVRDrawable->psDRI) != NULL);
+
+		PVRDrawableImageDestroy(psPVRDrawable);
+
+		PVRDRIRefImage(psPVRDrawable->psDRI);
+		psPVRDrawable->psImage = psPVRDrawable->psDRI;
+	}
+
+	if (psPVRDrawable->psImageAccum != psPVRDrawable->psDRIAccum)
+	{
+		PVRDrawableImageAccumDestroy(psPVRDrawable);
+
+		if (psPVRDrawable->psDRIAccum)
+		{
+			PVRDRIRefImage(psPVRDrawable->psDRIAccum);
+			psPVRDrawable->psImageAccum = psPVRDrawable->psDRIAccum;
+		}
+	}
+}
+
+/*************************************************************************/ /*!
+ Function Name		: PVRImageDrawableGetNativeInfo
+ Inputs			: psPVRDrawable
+ Returns		: Boolean
+ Description		: Update native drawable information.
+*/ /**************************************************************************/
+static bool PVRImageDrawableGetNativeInfo(PVRDRIDrawable *psPVRDrawable)
+{
+	__DRIdrawable *psDRIDrawable = psPVRDrawable->psDRIDrawable;
+	__DRIscreen *psDRIScreen = psPVRDrawable->psPVRScreen->psDRIScreen;
+	struct __DRIimageList sImages;
+	uint32_t uiBufferMask;
+	const PVRDRIImageFormat *psFormat;
+
+	assert(psDRIScreen->image.loader != NULL);
+	assert(psDRIScreen->image.loader->getBuffers);
+
+	psFormat = PVRDRIIMGPixelFormatToImageFormat(psPVRDrawable->psPVRScreen,
+						     psPVRDrawable->ePixelFormat);
+	if (!psFormat)
+	{
+		errorMessage("%s: Unsupported format (format = %u)\n",
+			     __func__, psPVRDrawable->ePixelFormat);
+		return false;
+	}
+
+	if (psPVRDrawable->sConfig.sGLMode.doubleBufferMode)
+	{
+		uiBufferMask = __DRI_IMAGE_BUFFER_BACK;
+	}
+	else
+	{
+		uiBufferMask = __DRI_IMAGE_BUFFER_FRONT;
+	}
+
+#if defined(DRI_IMAGE_HAS_BUFFER_PREV)
+	uiBufferMask |= __DRI_IMAGE_BUFFER_PREV;
+#endif
+
+	if (!psDRIScreen->image.loader->getBuffers(psDRIDrawable,
+						   psFormat->iDRIFormat,
+						   NULL,
+						   psDRIDrawable->loaderPrivate,
+						   uiBufferMask,
+						   &sImages))
+	{
+		errorMessage("%s: Image get buffers call failed\n", __func__);
+		return false;
+	}
+
+	psPVRDrawable->psDRI =
+		(sImages.image_mask & __DRI_IMAGE_BUFFER_BACK) ?
+			sImages.back : sImages.front;
+
+#if defined(DRI_IMAGE_HAS_BUFFER_PREV)
+	if (sImages.image_mask & __DRI_IMAGE_BUFFER_PREV)
+	{
+		psPVRDrawable->psDRIAccum = sImages.prev;
+	}
+	else
+#endif
+	{
+		psPVRDrawable->psDRIAccum = NULL;
+	}
+
+	return true;
+}
+
+/*************************************************************************/ /*!
+ Function Name		: PVRImageDrawableCreate
+ Inputs			: psPVRDrawable
+ Returns		: Boolean
+ Description		: Create drawable
+*/ /**************************************************************************/
+static bool PVRImageDrawableCreate(PVRDRIDrawable *psPVRDrawable)
+{
+	__DRIdrawable *psDRIDrawable = psPVRDrawable->psDRIDrawable;
+	uint32_t uBytesPerPixel;
+	PVRDRIBufferAttribs sBufferAttribs;
+
+	if (!PVRImageDrawableGetNativeInfo(psPVRDrawable))
+	{
+		return false;
+	}
+
+	PVRDRIEGLImageGetAttribs(
+		PVRDRIImageGetEGLImage(psPVRDrawable->psDRI),
+					&sBufferAttribs);
+	uBytesPerPixel = PVRDRIPixFmtGetBlockSize(sBufferAttribs.ePixFormat);
+
+	psDRIDrawable->w = sBufferAttribs.uiWidth;
+	psDRIDrawable->h = sBufferAttribs.uiHeight;
+	psPVRDrawable->uStride = sBufferAttribs.uiStrideInBytes;
+	psPVRDrawable->uBytesPerPixel = uBytesPerPixel;
+
+	PVRDrawableImageUpdate(psPVRDrawable);
+
+	if (!PVREGLDrawableCreate(psPVRDrawable->psPVRScreen->psImpl,
+				  psPVRDrawable->psImpl))
+	{
+		errorMessage("%s: Couldn't create EGL drawable\n", __func__);
+		return false;
+	}
+
+	return true;
+}
+
+/*************************************************************************/ /*!
+ Function Name		: PVRImageDrawableUpdate
+ Inputs			: psPVRDrawable
+ Returns		: Boolean
+ Description		: Update drawable
+*/ /**************************************************************************/
+static bool PVRImageDrawableUpdate(PVRDRIDrawable *psPVRDrawable,
+				   bool bAllowRecreate)
+{
+	__DRIdrawable *psDRIDrawable = psPVRDrawable->psDRIDrawable;
+	uint32_t uBytesPerPixel;
+	PVRDRIBufferAttribs sBufferAttribs;
+	bool bRecreate;
+
+	PVRDRIEGLImageGetAttribs(
+		PVRDRIImageGetEGLImage(psPVRDrawable->psDRI),
+					&sBufferAttribs);
+	uBytesPerPixel = PVRDRIPixFmtGetBlockSize(sBufferAttribs.ePixFormat);
+
+	bRecreate = (!psPVRDrawable->sConfig.sGLMode.doubleBufferMode &&
+			psPVRDrawable->psImage !=
+				psPVRDrawable->psDRI) ||
+			(psDRIDrawable->w != sBufferAttribs.uiWidth) ||
+			(psDRIDrawable->h != sBufferAttribs.uiHeight) ||
+			(psPVRDrawable->uStride !=
+				sBufferAttribs.uiStrideInBytes) ||
+			(psPVRDrawable->uBytesPerPixel != uBytesPerPixel);
+
+	if (bRecreate)
+	{
+		if (bAllowRecreate)
+		{
+			PVRDRIMarkRenderSurfaceAsInvalid(psPVRDrawable);
+
+			psDRIDrawable->w = sBufferAttribs.uiWidth;
+			psDRIDrawable->h = sBufferAttribs.uiHeight;
+			psPVRDrawable->uStride = sBufferAttribs.uiStrideInBytes;
+			psPVRDrawable->uBytesPerPixel = uBytesPerPixel;
+		}
+		else
+		{
+			return false;
+		}
+	}
+
+	PVRDrawableImageUpdate(psPVRDrawable);
+
+	if (bRecreate)
+	{
+		if (!PVREGLDrawableRecreate(psPVRDrawable->psPVRScreen->psImpl,
+		                            psPVRDrawable->psImpl))
+		{
+			errorMessage("%s: Couldn't recreate EGL drawable\n",
+				     __func__);
+			return false;
+		}
+	}
+
+	return true;
+}
+
+/*************************************************************************/ /*!
+ PVR drawable local functions
+*/ /**************************************************************************/
+
+/*************************************************************************/ /*!
+ Function Name	: PVRDRIDrawableUpdate
+ Inputs		: psPVRDrawable
+ Description	: Update drawable
+*/ /**************************************************************************/
+static bool PVRDRIDrawableUpdate(PVRDRIDrawable *psPVRDrawable,
+				 bool bAllowRecreate)
+{
+	bool bRes;
+	int iInfoInvalid = 0;
+
+	/*
+	 * The test for bDrawableUpdating is needed because drawable
+	 * parameters are fetched (via KEGLGetDrawableParameters) when
+	 * a drawable is recreated.
+	 * The test for bFlushInProgress is to prevent the drawable
+	 * information being updated during a flush, which could result
+	 * in a call back into the Mesa platform code during the
+	 * processing for a buffer swap, which could corrupt the platform
+	 * state.
+	 */
+	if (psPVRDrawable->bDrawableUpdating ||
+	    psPVRDrawable->bFlushInProgress)
+	{
+		return false;
+	}
+	psPVRDrawable->bDrawableUpdating = true;
+
+	if (psPVRDrawable->psPVRScreen->bUseInvalidate)
+	{
+		iInfoInvalid = p_atomic_read(&psPVRDrawable->iInfoInvalid);
+		bRes = !iInfoInvalid;
+		if (bRes)
+		{
+			goto ExitNotUpdating;
+		}
+	}
+
+	bRes = PVRImageDrawableGetNativeInfo(psPVRDrawable);
+	if (!bRes)
+	{
+		goto ExitNotUpdating;
+	}
+
+	bRes = PVRImageDrawableUpdate(psPVRDrawable, bAllowRecreate);
+	if (bRes && iInfoInvalid)
+	{
+		p_atomic_add(&psPVRDrawable->iInfoInvalid, -iInfoInvalid);
+	}
+
+ExitNotUpdating:
+	psPVRDrawable->bDrawableUpdating = false;
+	return bRes;
+}
+
+/*************************************************************************/ /*!
+ Function Name	: PVRDRIDrawableRecreateV0
+ Inputs		: psPVRDrawable
+ Description	: Recreate drawable
+*/ /**************************************************************************/
+bool PVRDRIDrawableRecreateV0(PVRDRIDrawable *psPVRDrawable)
+{
+	return PVRDRIDrawableUpdate(psPVRDrawable, true);
+}
+
+/*************************************************************************/ /*!
+ PVR drawable interface
+*/ /**************************************************************************/
+bool PVRDRIDrawableInit(PVRDRIDrawable *psPVRDrawable)
+{
+	if (psPVRDrawable->bInitialised)
+	{
+		return true;
+	}
+
+	if (!PVRImageDrawableCreate(psPVRDrawable))
+	{
+		return false;
+	}
+
+	psPVRDrawable->bInitialised = true;
+
+	return true;
+}
+
+void PVRDRIDrawableDeinit(PVRDRIDrawable *psPVRDrawable)
+{
+	(void) PVREGLDrawableDestroy(psPVRDrawable->psPVRScreen->psImpl,
+	                             psPVRDrawable->psImpl);
+
+	PVRDrawableImageDestroy(psPVRDrawable);
+	PVRDrawableImageAccumDestroy(psPVRDrawable);
+
+	psPVRDrawable->bInitialised = false;
+}
+
+static bool PVRDRIDrawableGetParameters(PVRDRIDrawable *psPVRDrawable,
+					PVRDRIBufferImpl **ppsDstBuffer,
+					PVRDRIBufferImpl **ppsAccumBuffer)
+{
+	if (ppsDstBuffer || ppsAccumBuffer)
+	{
+		PVRDRIBufferImpl *psDstBuffer;
+		PVRDRIBufferImpl *psAccumBuffer;
+
+		psDstBuffer = PVRDRIImageGetSharedBuffer(psPVRDrawable->psImage);
+		if (!psDstBuffer)
+		{
+			errorMessage("%s: Couldn't get backing buffer\n",
+				     __func__);
+			return false;
+		}
+
+		if (psPVRDrawable->psImageAccum)
+		{
+			psAccumBuffer =
+				PVRDRIImageGetSharedBuffer(psPVRDrawable->psImageAccum);
+			if (!psAccumBuffer)
+			{
+				psAccumBuffer = psDstBuffer;
+			}
+		}
+		else
+		{
+			psAccumBuffer = psDstBuffer;
+		}
+
+		if (ppsDstBuffer)
+		{
+			*ppsDstBuffer = psDstBuffer;
+		}
+
+		if (ppsAccumBuffer)
+		{
+			*ppsAccumBuffer = psAccumBuffer;
+		}
+	}
+
+	return true;
+}
+
+bool PVRDRIDrawableGetParametersV0(PVRDRIDrawable *psPVRDrawable,
+				   PVRDRIBufferImpl **ppsDstBuffer,
+				   PVRDRIBufferImpl **ppsAccumBuffer,
+				   PVRDRIBufferAttribs *psAttribs,
+				   bool *pbDoubleBuffered)
+{
+	/*
+	 * Some drawable updates may be required, which stop short of
+	 * recreating the drawable.
+	 */
+	(void) PVRDRIDrawableUpdate(psPVRDrawable, false);
+
+	if (!PVRDRIDrawableGetParameters(psPVRDrawable,
+					 ppsDstBuffer,
+					 ppsAccumBuffer))
+	{
+		return false;
+	}
+
+	if (psAttribs)
+	{
+		psAttribs->uiWidth           = psPVRDrawable->psDRIDrawable->w;
+		psAttribs->uiHeight          = psPVRDrawable->psDRIDrawable->h;
+		psAttribs->ePixFormat        = psPVRDrawable->ePixelFormat;
+		psAttribs->uiStrideInBytes   = psPVRDrawable->uStride;
+	}
+
+	if (pbDoubleBuffered)
+	{
+		*pbDoubleBuffered =
+			psPVRDrawable->sConfig.sGLMode.doubleBufferMode;
+	}
+
+	return true;
+}
+
+bool PVRDRIDrawableGetParametersV1(PVRDRIDrawable *psPVRDrawable,
+				   bool bAllowRecreate,
+				   PVRDRIBufferImpl **ppsDstBuffer,
+				   PVRDRIBufferImpl **ppsAccumBuffer,
+				   PVRDRIBufferAttribs *psAttribs,
+				   bool *pbDoubleBuffered)
+{
+	if (!PVRDRIDrawableUpdate(psPVRDrawable, bAllowRecreate))
+	{
+		if (bAllowRecreate)
+		{
+			return false;
+		}
+	}
+
+	if (!PVRDRIDrawableGetParameters(psPVRDrawable,
+					 ppsDstBuffer,
+					 ppsAccumBuffer))
+	{
+		return false;
+	}
+
+	if (psAttribs)
+	{
+		psAttribs->uiWidth           = psPVRDrawable->psDRIDrawable->w;
+		psAttribs->uiHeight          = psPVRDrawable->psDRIDrawable->h;
+		psAttribs->ePixFormat        = psPVRDrawable->ePixelFormat;
+		psAttribs->uiStrideInBytes   = psPVRDrawable->uStride;
+	}
+
+	if (pbDoubleBuffered)
+	{
+		*pbDoubleBuffered =
+			psPVRDrawable->sConfig.sGLMode.doubleBufferMode;
+	}
+
+	return true;
+}
+
+bool PVRDRIDrawableQuery(const PVRDRIDrawable *psPVRDrawable,
+			 PVRDRIBufferAttrib eBufferAttrib,
+			 uint32_t *uiValueOut)
+{
+	if (!psPVRDrawable || !uiValueOut)
+	{
+		return false;
+	}
+
+	switch (eBufferAttrib)
+	{
+		case PVRDRI_BUFFER_ATTRIB_TYPE:
+			*uiValueOut = (uint32_t) psPVRDrawable->eType;
+			return true;
+		case PVRDRI_BUFFER_ATTRIB_WIDTH:
+			*uiValueOut = (uint32_t) psPVRDrawable->psDRIDrawable->w;
+			return true;
+		case PVRDRI_BUFFER_ATTRIB_HEIGHT:
+			*uiValueOut = (uint32_t) psPVRDrawable->psDRIDrawable->h;
+			return true;
+		case PVRDRI_BUFFER_ATTRIB_STRIDE:
+			*uiValueOut = (uint32_t) psPVRDrawable->uStride;
+			return true;
+		case PVRDRI_BUFFER_ATTRIB_PIXEL_FORMAT:
+			STATIC_ASSERT(sizeof(psPVRDrawable->ePixelFormat) <= sizeof(*uiValueOut));
+			*uiValueOut = (uint32_t) psPVRDrawable->ePixelFormat;
+			return true;
+		case PVRDRI_BUFFER_ATTRIB_INVALID:
+			errorMessage("%s: Invalid attribute", __func__);
+			assert(0);
+			break;
+	}
+
+	return false;
+}
+
+bool PVRDRIDrawableGetParametersV2(PVRDRIDrawable *psPVRDrawable,
+				   uint32_t uiFlags,
+				   PVRDRIBufferImpl **ppsDstBuffer,
+				   PVRDRIBufferImpl **ppsAccumBuffer)
+{
+	const bool bNoUpdate = uiFlags & PVRDRI_GETPARAMS_FLAG_NO_UPDATE;
+
+	if (!bNoUpdate)
+	{
+		const bool bAllowRecreate =
+			uiFlags & PVRDRI_GETPARAMS_FLAG_ALLOW_RECREATE;
+
+		if (!PVRDRIDrawableUpdate(psPVRDrawable, bAllowRecreate))
+		{
+			if (bAllowRecreate)
+			{
+				return false;
+			}
+		}
+	}
+
+	return PVRDRIDrawableGetParameters(psPVRDrawable,
+					   ppsDstBuffer, ppsAccumBuffer);
+}
diff --git a/src/mesa/drivers/dri/pvr/pvrdri.c b/src/mesa/drivers/dri/pvr/pvrdri.c
new file mode 100644
index 00000000000..b53ddc5c621
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrdri.c
@@ -0,0 +1,1018 @@
+/* -*- mode: c; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* vi: set ts=8 sw=8 sts=8: */
+/*
+ * 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 <pthread.h>
+#include <string.h>
+#include <xf86drm.h>
+
+#include "EGL/egl.h"
+#include "EGL/eglext.h"
+
+#include "util/u_atomic.h"
+#include "dri_util.h"
+
+#include "pvrdri.h"
+#include "pvrimage.h"
+
+#include "pvrmesa.h"
+
+#define PVR_IMAGE_LOADER_VER_MIN 1
+
+#define PVRDRI_FLUSH_WAIT_FOR_HW        (1U << 0)
+#define PVRDRI_FLUSH_NEW_EXTERNAL_FRAME (1U << 1)
+#define PVRDRI_FLUSH_ALL_SURFACES       (1U << 2)
+
+typedef struct PVRBufferRec
+{
+	__DRIbuffer sDRIBuffer;
+	PVRDRIBufferImpl *psImpl;
+} PVRBuffer;
+
+/* We need to know the current screen in order to lookup EGL images. */
+static __thread PVRDRIScreen *gpsPVRScreen;
+
+/*************************************************************************/ /*!
+ 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 bool
+PVRDRIFlushBuffers(PVRDRIContext *psPVRContext,
+		   PVRDRIDrawable *psPVRDrawable,
+		   uint32_t uiFlags)
+{
+	assert(!(uiFlags & ~(PVRDRI_FLUSH_WAIT_FOR_HW |
+			     PVRDRI_FLUSH_NEW_EXTERNAL_FRAME |
+			     PVRDRI_FLUSH_ALL_SURFACES)));
+
+	return PVRDRIEGLFlushBuffers(psPVRContext->eAPI,
+	                             psPVRContext->psPVRScreen->psImpl,
+	                             psPVRContext->psImpl,
+	                             psPVRDrawable ? psPVRDrawable->psImpl : NULL,
+	                             uiFlags & PVRDRI_FLUSH_ALL_SURFACES,
+	                             uiFlags & PVRDRI_FLUSH_NEW_EXTERNAL_FRAME,
+	                             uiFlags & PVRDRI_FLUSH_WAIT_FOR_HW);
+}
+
+void
+PVRDRIFlushBuffersForSwap(PVRDRIContext *psPVRContext,
+                          PVRDRIDrawable *psPVRDrawable)
+{
+	if (psPVRContext)
+	{
+		/*
+		 * The bFlushInProgress flag is intended to prevent new
+		 * buffers being fetched whilst a flush is in progress,
+		 * which may corrupt the state maintained by the Mesa
+		 * platform code.
+		 */
+		psPVRDrawable->bFlushInProgress = true;
+
+		(void) PVRDRIFlushBuffers(psPVRContext,
+					  psPVRDrawable,
+					  PVRDRI_FLUSH_NEW_EXTERNAL_FRAME);
+
+		psPVRDrawable->bFlushInProgress = false;
+	}
+}
+
+static void
+PVRDRIFlushBuffersGC(PVRDRIContext *psPVRContext, PVRDRIDrawable *psPVRDrawable)
+{
+	(void) PVRDRIFlushBuffers(psPVRContext,
+				  psPVRDrawable,
+				  PVRDRI_FLUSH_WAIT_FOR_HW |
+				  PVRDRI_FLUSH_ALL_SURFACES);
+}
+
+static void PVRContextUnbind(PVRDRIContext *psPVRContext,
+			     bool bMakeUnCurrent,
+			     bool bMarkSurfaceInvalid)
+{
+	PVRDRIDrawable *psPVRDrawable = psPVRContext->psPVRDrawable;
+
+	if (bMakeUnCurrent)
+	{
+		uint32_t uiFlags = PVRDRI_FLUSH_ALL_SURFACES;
+
+		(void) PVRDRIFlushBuffers(psPVRContext, psPVRDrawable, uiFlags);
+	}
+	else if (psPVRDrawable)
+	{
+		PVRDRIFlushBuffersGC(psPVRContext, psPVRDrawable);
+	}
+
+	if (bMakeUnCurrent)
+	{
+		PVRDRIMakeUnCurrentGC(psPVRContext->eAPI,
+		                      psPVRContext->psPVRScreen->psImpl);
+	}
+
+	if (psPVRDrawable != NULL)
+	{
+		if (bMarkSurfaceInvalid)
+		{
+			PVRDRIEGLMarkRendersurfaceInvalid(psPVRContext->eAPI,
+			                                  psPVRContext->psPVRScreen->psImpl,
+			                                  psPVRContext->psImpl);
+		}
+
+		psPVRContext->psPVRDrawable = NULL;
+		psPVRDrawable->psPVRContext = NULL;
+	}
+}
+
+static inline PVRDRIContextImpl *
+getSharedContextImpl(void *pvSharedContextPrivate)
+{
+	if (pvSharedContextPrivate == NULL)
+	{
+		return NULL;
+	}
+	return ((PVRDRIContext *)pvSharedContextPrivate)->psImpl;
+}
+
+
+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);
+
+	PVRDRIDestroyFencesImpl(psPVRScreen->psImpl);
+
+	PVRDRIDestroyFormatInfo(psPVRScreen);
+
+	PVRDRIDestroyScreenImpl(psPVRScreen->psImpl);
+
+	free(psPVRScreen);
+}
+
+static inline void PVRDrawableUnbindContext(PVRDRIDrawable *psPVRDrawable)
+{
+	PVRDRIContext *psPVRContext = psPVRDrawable->psPVRContext;
+
+	if (psPVRContext)
+	{
+		PVRContextUnbind(psPVRContext, false, true);
+	}
+}
+
+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");
+	}
+}
+
+static bool PVRDRIConfigQuery(const PVRDRIConfig *psConfig,
+			      PVRDRIConfigAttrib eConfigAttrib,
+			      int *piValueOut)
+{
+	if (!psConfig || !piValueOut)
+	{
+		return false;
+	}
+
+	switch (eConfigAttrib)
+	{
+		case PVRDRI_CONFIG_ATTRIB_RENDERABLE_TYPE:
+			*piValueOut = psConfig->iSupportedAPIs;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_RGB_MODE:
+			*piValueOut = psConfig->sGLMode.rgbMode;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_DOUBLE_BUFFER_MODE:
+			*piValueOut = psConfig->sGLMode.doubleBufferMode;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_RED_BITS:
+			*piValueOut = psConfig->sGLMode.redBits;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_GREEN_BITS:
+			*piValueOut = psConfig->sGLMode.greenBits;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_BLUE_BITS:
+			*piValueOut = psConfig->sGLMode.blueBits;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_ALPHA_BITS:
+			*piValueOut = psConfig->sGLMode.alphaBits;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_RGB_BITS:
+			*piValueOut = psConfig->sGLMode.rgbBits;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_DEPTH_BITS:
+			*piValueOut = psConfig->sGLMode.depthBits;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_STENCIL_BITS:
+			*piValueOut = psConfig->sGLMode.stencilBits;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_SAMPLE_BUFFERS:
+			*piValueOut = psConfig->sGLMode.sampleBuffers;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_SAMPLES:
+			*piValueOut = psConfig->sGLMode.samples;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_BIND_TO_TEXTURE_RGB:
+			*piValueOut = psConfig->sGLMode.bindToTextureRgb;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_BIND_TO_TEXTURE_RGBA:
+			*piValueOut = psConfig->sGLMode.bindToTextureRgba;
+			return true;
+#if defined(__DRI_ATTRIB_YUV_BIT)
+		case PVRDRI_CONFIG_ATTRIB_YUV_ORDER:
+			*piValueOut = psConfig->sGLMode.YUVOrder;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_YUV_NUM_OF_PLANES:
+			*piValueOut = psConfig->sGLMode.YUVNumberOfPlanes;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_YUV_SUBSAMPLE:
+			*piValueOut = psConfig->sGLMode.YUVSubsample;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_YUV_DEPTH_RANGE:
+			*piValueOut = psConfig->sGLMode.YUVDepthRange;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_YUV_CSC_STANDARD:
+			*piValueOut = psConfig->sGLMode.YUVCSCStandard;
+			return true;
+		case PVRDRI_CONFIG_ATTRIB_YUV_PLANE_BPP:
+			*piValueOut = psConfig->sGLMode.YUVPlaneBPP;
+			return true;
+#endif
+		case PVRDRI_CONFIG_ATTRIB_INVALID:
+			errorMessage("%s: Invalid attribute", __func__);
+			assert(0);
+			/* fallthrough */
+#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
+	}
+
+	return false;
+}
+
+/*************************************************************************/ /*!
+ Mesa driver API functions
+*/ /**************************************************************************/
+static const __DRIconfig **PVRDRIInitScreen(__DRIscreen *psDRIScreen)
+{
+	PVRDRIScreen *psPVRScreen;
+	const __DRIconfig **configs;
+	const PVRDRICallbacks sDRICallbacks = {
+		/* Version 0 callbacks */
+		.DrawableRecreate            = PVRDRIDrawableRecreateV0,
+		.DrawableGetParameters       = PVRDRIDrawableGetParametersV0,
+		.ImageGetSharedType          = PVRDRIImageGetSharedType,
+		.ImageGetSharedBuffer        = PVRDRIImageGetSharedBuffer,
+		.ImageGetSharedEGLImage      = PVRDRIImageGetSharedEGLImage,
+		.ImageGetEGLImage            = PVRDRIImageGetEGLImage,
+		.ScreenGetDRIImage           = PVRDRIScreenGetDRIImage,
+		.RefImage                    = PVRDRIRefImage,
+		.UnrefImage                  = PVRDRIUnrefImage,
+
+		/* Version 1 callbacks */
+		.DrawableGetParametersV1     = PVRDRIDrawableGetParametersV1,
+		.RegisterSupportInterfaceV1  = PVRDRIRegisterSupportInterfaceV1,
+
+		/* Version 2 callbacks */
+		.ConfigQuery                 = PVRDRIConfigQuery,
+		.DrawableGetParametersV2     = PVRDRIDrawableGetParametersV2,
+		.DrawableQuery               = PVRDRIDrawableQuery,
+	};
+
+	if (!PVRLoaderIsSupported(psDRIScreen))
+	{
+		return NULL;
+	}
+
+	if (!PVRDRICompatInit(&sDRICallbacks, 3))
+	{
+		return NULL;
+	}
+
+	psPVRScreen = calloc(1, sizeof(*psPVRScreen));
+	if (psPVRScreen == NULL)
+	{
+		__driUtilMessage("%s: Couldn't allocate PVRDRIScreen",
+				 __func__);
+		goto ErrorCompatDeinit;
+	}
+
+	DRIScreenPrivate(psDRIScreen) = psPVRScreen;
+	psPVRScreen->psDRIScreen = psDRIScreen;
+
+	psPVRScreen->iRefCount = 1;
+	psPVRScreen->bUseInvalidate = (psDRIScreen->dri2.useInvalidate != NULL);
+
+	psDRIScreen->extensions = PVRDRIScreenExtensions();
+
+	psPVRScreen->psImpl = PVRDRICreateScreenImpl(psDRIScreen->fd);
+	if (psPVRScreen->psImpl == NULL)
+	{
+		goto ErrorScreenFree;
+	}
+
+	if (!PVRDRIGetSupportedFormats(psPVRScreen))
+	{
+		goto ErrorScreenImplDeinit;
+	}
+
+	psDRIScreen->max_gl_es1_version =
+				PVRDRIAPIVersion(PVRDRI_API_GLES1,
+					         PVRDRI_API_SUB_NONE,
+					         psPVRScreen->psImpl);
+
+	psDRIScreen->max_gl_es2_version =
+				PVRDRIAPIVersion(PVRDRI_API_GLES2,
+					         PVRDRI_API_SUB_NONE,
+					         psPVRScreen->psImpl);
+
+	configs = PVRDRICreateConfigs();
+	if (configs == NULL)
+	{
+		__driUtilMessage("%s: No framebuffer configs", __func__);
+		goto ErrorDestroyFormatInfo;
+	}
+
+	PVRScreenPrintExtensions(psDRIScreen);
+
+	return configs;
+
+ErrorDestroyFormatInfo:
+	PVRDRIDestroyFormatInfo(psPVRScreen);
+
+ErrorScreenImplDeinit:
+	PVRDRIDestroyScreenImpl(psPVRScreen->psImpl);
+
+ErrorScreenFree:
+	free(psPVRScreen);
+
+ErrorCompatDeinit:
+	PVRDRICompatDeinit();
+
+	return NULL;
+}
+
+static void PVRDRIDestroyScreen(__DRIscreen *psDRIScreen)
+{
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(psDRIScreen);
+
+#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);
+
+	PVRDRICompatDeinit();
+}
+
+static int PVRDRIScreenSupportedAPIs(PVRDRIScreen *psPVRScreen)
+{
+	unsigned 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;
+	}
+
+	return supported;
+}
+
+static GLboolean PVRDRICreateContext(gl_api eMesaAPI,
+                                     const struct gl_config *psGLMode,
+                                     __DRIcontext *psDRIContext,
+                                     const struct __DriverContextConfig *psCtxConfig,
+                                     unsigned *puError,
+                                     void *pvSharedContextPrivate)
+{
+	__DRIscreen *psDRIScreen = psDRIContext->driScreenPriv;
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(psDRIScreen);
+	PVRDRIContext *psPVRContext;
+	PVRDRIAPISubType eAPISub = PVRDRI_API_SUB_NONE;
+	bool notify_reset = false;
+	unsigned uPriority = PVRDRI_CONTEXT_PRIORITY_MEDIUM;
+	bool bResult;
+
+	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:
+			psPVRContext->eAPI = PVRDRI_API_GLES1;
+			break;
+		case API_OPENGLES2:
+			psPVRContext->eAPI = PVRDRI_API_GLES2;
+			break;
+		default:
+			__driUtilMessage("%s: Unsupported API: %d",
+					 __func__,
+					 (int)eMesaAPI);
+			goto ErrorContextFree;
+	}
+
+	if (psCtxConfig->attribute_mask & __DRIVER_CONTEXT_ATTRIB_RESET_STRATEGY)
+	{
+		switch (psCtxConfig->reset_strategy)
+		{
+			case __DRI_CTX_RESET_LOSE_CONTEXT:
+				notify_reset = true;
+				break;
+			default:
+				__driUtilMessage("%s: Unsupported reset strategy: %d",
+						 __func__,
+						 (int)psCtxConfig->reset_strategy);
+				goto ErrorContextFree;
+		}
+	}
+
+	if (psCtxConfig->attribute_mask & __DRIVER_CONTEXT_ATTRIB_PRIORITY)
+	{
+		uPriority = psCtxConfig->priority;
+	}
+
+	*puError = PVRDRISupportCreateContext(psPVRScreen->psImpl,
+					      getSharedContextImpl(pvSharedContextPrivate),
+					      &psPVRContext->sConfig,
+					      psPVRContext->eAPI,
+					      eAPISub,
+                                              psCtxConfig->major_version,
+                                              psCtxConfig->minor_version,
+                                              psCtxConfig->flags,
+					      notify_reset,
+					      uPriority,
+					      &psPVRContext->psImpl);
+	if (*puError != __DRI_CTX_ERROR_SUCCESS)
+	{
+		goto ErrorContextFree;
+	}
+
+	/*
+	 * The dispatch table must be created after the context, because
+	 * PVRDRIContextCreate loads the API library, and we need the
+	 * library handle to populate the dispatch table.
+	 */
+	bResult = pvrdri_create_dispatch_table(psPVRScreen, psPVRContext->eAPI);
+
+	if (!bResult)
+	{
+		__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:
+	PVRDRIDestroyContextImpl(psPVRContext->psImpl,
+				 psPVRContext->eAPI,
+				 psPVRScreen->psImpl);
+ErrorContextFree:
+	free(psPVRContext);
+
+	return GL_FALSE;
+}
+
+static void PVRDRIDestroyContext(__DRIcontext *psDRIContext)
+{
+	PVRDRIContext *psPVRContext = (PVRDRIContext *)psDRIContext->driverPrivate;
+	PVRDRIScreen *psPVRScreen = psPVRContext->psPVRScreen;
+
+	PVRContextUnbind(psPVRContext, false, false);
+
+	PVRDRIDestroyContextImpl(psPVRContext->psImpl,
+				 psPVRContext->eAPI,
+				 psPVRScreen->psImpl);
+
+	free(psPVRContext);
+
+#if defined(DEBUG)
+	p_atomic_dec(&psPVRScreen->iContextAlloc);
+#endif
+
+	PVRDRIScreenRemoveReference(psPVRScreen);
+}
+
+IMG_PIXFMT PVRDRIGetPixelFormat(const struct gl_config *psGLMode)
+{
+	switch (psGLMode->rgbBits)
+	{
+		case 32:
+		case 24:
+			if (psGLMode->redMask   == 0x00FF0000 &&
+			    psGLMode->greenMask == 0x0000FF00 &&
+			    psGLMode->blueMask  == 0x000000FF)
+			{
+				if (psGLMode->alphaMask == 0xFF000000)
+				{
+					return IMG_PIXFMT_B8G8R8A8_UNORM;
+				}
+				else if (psGLMode->alphaMask == 0)
+				{
+					return IMG_PIXFMT_B8G8R8X8_UNORM;
+				}
+			}
+
+			if (psGLMode->redMask   == 0x000000FF &&
+			    psGLMode->greenMask == 0x0000FF00 &&
+			    psGLMode->blueMask  == 0x00FF0000)
+			{
+				if (psGLMode->alphaMask == 0xFF000000)
+				{
+					return IMG_PIXFMT_R8G8B8A8_UNORM;
+				}
+				else if (psGLMode->alphaMask == 0)
+				{
+					return IMG_PIXFMT_R8G8B8X8_UNORM;
+				}
+			}
+
+			__driUtilMessage("%s: Unsupported buffer format", __func__);
+			return IMG_PIXFMT_UNKNOWN;
+
+		case 16:
+			if (psGLMode->redMask   == 0xF800 &&
+			    psGLMode->greenMask == 0x07E0 &&
+			    psGLMode->blueMask  == 0x001F)
+			{
+				return IMG_PIXFMT_B5G6R5_UNORM;
+			}
+
+		default:
+			errorMessage("%s: Unsupported screen format\n", __func__);
+			return IMG_PIXFMT_UNKNOWN;
+	}
+}
+
+static GLboolean PVRDRICreateBuffer(__DRIscreen *psDRIScreen,
+                                    __DRIdrawable *psDRIDrawable,
+                                    const struct gl_config *psGLMode,
+                                    GLboolean bIsPixmap)
+{
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(psDRIScreen);
+	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->psDRIDrawable = psDRIDrawable;
+	psPVRDrawable->psPVRScreen = psPVRScreen;
+	psPVRDrawable->sConfig.sGLMode = *psGLMode;
+	psPVRDrawable->sConfig.iSupportedAPIs =
+		PVRDRIScreenSupportedAPIs(psPVRScreen);
+
+	psPVRDrawable->ePixelFormat = PVRDRIGetPixelFormat(psGLMode);
+	if (psPVRDrawable->ePixelFormat == IMG_PIXFMT_UNKNOWN)
+	{
+		__driUtilMessage("%s: Couldn't work out pixel format", __func__);
+		goto ErrorDrawableFree;
+	}
+
+	/*
+	 * Mesa doesn't tell us the drawable type so treat double buffered
+	 * drawables as windows (although GLX supports double buffered pbuffers)
+	 * and single buffered drawables as pixmaps (although these could
+	 * actually be pbuffers).
+	 */
+	if (psPVRDrawable->sConfig.sGLMode.doubleBufferMode)
+	{
+		psPVRDrawable->eType = PVRDRI_DRAWABLE_WINDOW;
+	}
+	else
+	{
+		psPVRDrawable->eType = PVRDRI_DRAWABLE_PIXMAP;
+	}
+
+	psPVRDrawable->psImpl =
+		PVRDRISupportCreateDrawable(psPVRDrawable,
+					    &psPVRDrawable->sConfig);
+	if (!psPVRDrawable->psImpl)
+	{
+		__driUtilMessage("%s: Couldn't allocate PVR drawable", __func__);
+		goto ErrorDrawableFree;
+	}
+
+	/* Initialisation is completed in MakeCurrent */
+#if defined(DEBUG)
+	p_atomic_inc(&psPVRScreen->iDrawableAlloc);
+#endif
+	PVRDRIScreenAddReference(psPVRScreen);
+	return GL_TRUE;
+
+ErrorDrawableFree:
+	PVRDRIDestroyDrawableImpl(psPVRDrawable->psImpl);
+	free(psPVRDrawable);
+	psDRIDrawable->driverPrivate = NULL;
+
+	return GL_FALSE;
+}
+
+static void PVRDRIDestroyBuffer(__DRIdrawable *psDRIDrawable)
+{
+	PVRDRIDrawable *psPVRDrawable = (PVRDRIDrawable *)psDRIDrawable->driverPrivate;
+	PVRDRIScreen *psPVRScreen = psPVRDrawable->psPVRScreen;
+
+	PVRDrawableUnbindContext(psPVRDrawable);
+
+	PVRDRIDrawableDeinit(psPVRDrawable);
+
+	PVREGLDrawableDestroyConfig(psPVRDrawable->psImpl);
+
+	PVRDRIDestroyDrawableImpl(psPVRDrawable->psImpl);
+
+	free(psPVRDrawable);
+
+#if defined(DEBUG)
+	p_atomic_dec(&psPVRScreen->iDrawableAlloc);
+#endif
+
+	PVRDRIScreenRemoveReference(psPVRScreen);
+}
+
+static GLboolean PVRDRIMakeCurrent(__DRIcontext *psDRIContext,
+				   __DRIdrawable *psDRIWrite,
+				   __DRIdrawable *psDRIRead)
+{
+	PVRDRIContext *psPVRContext = (PVRDRIContext *)psDRIContext->driverPrivate;
+	PVRDRIDrawable *psPVRWrite = (psDRIWrite) ? (PVRDRIDrawable *)psDRIWrite->driverPrivate : NULL;
+	PVRDRIDrawable *psPVRRead = (psDRIRead) ? (PVRDRIDrawable *)psDRIRead->driverPrivate : NULL;
+	PVRDRIDrawable *psPVRDrawableOld = psPVRContext->psPVRDrawable;
+
+	if (psPVRWrite != NULL)
+	{
+		if (!PVRDRIDrawableInit(psPVRWrite))
+		{
+			__driUtilMessage("%s: Couldn't initialise write drawable",
+					 __func__);
+			goto ErrorUnlock;
+		}
+	}
+
+	if (psPVRRead != NULL)
+	{
+		if (!PVRDRIDrawableInit(psPVRRead))
+		{
+			__driUtilMessage("%s: Couldn't initialise read drawable",
+					 __func__);
+			goto ErrorUnlock;
+		}
+	}
+
+	if (!PVRDRIMakeCurrentGC(psPVRContext->eAPI,
+	                         psPVRContext->psPVRScreen->psImpl,
+	                         psPVRContext->psImpl,
+	                         psPVRWrite == NULL ? NULL : psPVRWrite->psImpl,
+	                         psPVRRead  == NULL ? NULL : psPVRRead->psImpl))
+	{
+		goto ErrorUnlock;
+	}
+
+	if (psPVRDrawableOld != NULL)
+	{
+		psPVRDrawableOld->psPVRContext = NULL;
+	}
+
+
+	if (psPVRWrite != NULL)
+	{
+		psPVRWrite->psPVRContext = psPVRContext;
+	}
+
+	psPVRContext->psPVRDrawable = psPVRWrite;
+
+	pvrdri_set_dispatch_table(psPVRContext);
+
+	PVRDRIThreadSetCurrentScreen(psPVRContext->psPVRScreen);
+
+	return GL_TRUE;
+
+ErrorUnlock:
+	return GL_FALSE;
+}
+
+static GLboolean PVRDRIUnbindContext(__DRIcontext *psDRIContext)
+{
+	PVRDRIContext *psPVRContext = (PVRDRIContext *)psDRIContext->driverPrivate;
+
+	pvrdri_set_null_dispatch_table();
+
+	PVRContextUnbind(psPVRContext, true, false);
+	PVRDRIThreadSetCurrentScreen(NULL);
+
+	return GL_TRUE;
+}
+
+static __DRIbuffer *PVRDRIAllocateBuffer(__DRIscreen *psDRIScreen,
+					 unsigned int uAttachment,
+					 unsigned int uFormat,
+					 int iWidth,
+					 int iHeight)
+{
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(psDRIScreen);
+	PVRBuffer *psBuffer;
+	unsigned int uiBpp;
+
+	/* GEM names are only supported on primary nodes */
+	if (drmGetNodeTypeFromFd(psDRIScreen->fd) != DRM_NODE_PRIMARY)
+	{
+		__driUtilMessage("%s: Cannot allocate buffer", __func__);
+		return NULL;
+	}
+
+	/* This is based upon PVRDRIGetPixelFormat */
+	switch (uFormat)
+	{
+		case 32:
+		case 16:
+			/* Format (depth) and bpp match */
+			uiBpp = uFormat;
+			break;
+		case 24:
+			uiBpp = 32;
+			break;
+		default:
+			__driUtilMessage("%s: Unsupported format '%u'",
+					 __func__, uFormat);
+			return NULL;
+	}
+
+	psBuffer = calloc(1, sizeof(*psBuffer));
+	if (psBuffer == NULL)
+	{
+		__driUtilMessage("%s: Failed to allocate buffer", __func__);
+		return NULL;
+	}
+
+	psBuffer->psImpl = PVRDRIBufferCreate(psPVRScreen->psImpl,
+					      iWidth,
+					      iHeight,
+					      uiBpp,
+					      PVDRI_BUFFER_USE_SHARE,
+					      &psBuffer->sDRIBuffer.pitch);
+	if (!psBuffer->psImpl)
+	{
+		__driUtilMessage("%s: Failed to create backing buffer",
+				 __func__);
+		goto ErrorFreeDRIBuffer;
+	}
+
+	psBuffer->sDRIBuffer.attachment = uAttachment;
+	psBuffer->sDRIBuffer.name = PVRDRIBufferGetName(psBuffer->psImpl);
+	psBuffer->sDRIBuffer.cpp = uiBpp / 8;
+
+#if defined(DEBUG)
+	p_atomic_inc(&psPVRScreen->iBufferAlloc);
+#endif
+
+	return &psBuffer->sDRIBuffer;
+
+ErrorFreeDRIBuffer:
+	free(psBuffer);
+
+	return NULL;
+}
+
+static void PVRDRIReleaseBuffer(__DRIscreen *psDRIScreen,
+				__DRIbuffer *psDRIBuffer)
+{
+	PVRBuffer *psBuffer = (PVRBuffer *)psDRIBuffer;
+#if defined(DEBUG)
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(psDRIScreen);
+#endif
+
+	(void)psDRIScreen;
+
+	PVRDRIBufferDestroy(psBuffer->psImpl);
+	free(psBuffer);
+
+#if defined(DEBUG)
+	p_atomic_dec(&psPVRScreen->iBufferAlloc);
+#endif
+}
+
+/* Publish our driver implementation to the world. */
+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;
+}
+
+/*************************************************************************/ /*!
+ Global functions
+*/ /**************************************************************************/
+
+void PVRDRIThreadSetCurrentScreen(PVRDRIScreen *psPVRScreen)
+{
+	gpsPVRScreen = psPVRScreen;
+}
+
+PVRDRIScreen *PVRDRIThreadGetCurrentScreen(void)
+{
+	return gpsPVRScreen;
+}
diff --git a/src/mesa/drivers/dri/pvr/pvrdri.h b/src/mesa/drivers/dri/pvr/pvrdri.h
new file mode 100644
index 00000000000..50d930a59c2
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrdri.h
@@ -0,0 +1,388 @@
+/* -*- mode: c; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* vi: set ts=8 sw=8 sts=8: */
+/*
+ * 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(__PVRDRI2_H__)
+#define __PVRDRI2_H__
+#include <stdbool.h>
+
+#include <glapi/glapi.h>
+
+#include "main/mtypes.h"
+#include "GL/internal/dri_interface.h"
+
+#include "util/macros.h"
+
+#include "dri_support.h"
+
+/* This should match EGL_MAX_PLANES */
+#define DRI_PLANES_MAX 3
+
+#define	DRI2_BUFFERS_MAX (3)
+
+#define	DRIScreenPrivate(pScreen)	((pScreen)->driverPrivate)
+
+struct PVRDRIConfigRec
+{
+	struct gl_config sGLMode;
+	int iSupportedAPIs;
+};
+
+struct PVRDRIModifiers
+{
+	/* Number of modifiers for a given format */
+	int         iNumModifiers;
+	/* Array of modifiers */
+	uint64_t    *puModifiers;
+	/*
+	 * Array of booleans that indicates which modifiers in the above array
+	 * can only be used for EGL Image External (and so not for scanout).
+	 */
+	unsigned    *puExternalOnly;
+};
+
+/** Our PVR related screen data */
+typedef struct PVRDRIScreen_TAG
+{
+	/* DRI screen structure pointer */
+	__DRIscreen        *psDRIScreen;
+	/* X Server sends invalidate events */
+	bool                bUseInvalidate;
+	/* Reference count */
+	int iRefCount;
+
+#if defined(DEBUG)
+	/* Counters of outstanding allocations */
+	int iContextAlloc, iDrawableAlloc, iBufferAlloc;
+#endif
+
+	/* PVR OGLES 1 dispatch table */
+	struct _glapi_table *psOGLES1Dispatch;
+	/* PVR OGLES 2/3 dispatch table */
+	struct _glapi_table *psOGLES2Dispatch;
+
+	PVRDRIScreenImpl    *psImpl;
+
+	/*
+	 * Number of supported formats:
+	 * -1 -> couldn't be queried (pvr_dri_support too old)
+	 *  0 -> uninitialised or initialisation failed
+	 */
+	int                 iNumFormats;
+	/* Indicates which entries in the image format array are supported */
+	bool                *pbHasFormat;
+	/* Array of modifiers for each image format array entry */
+	struct PVRDRIModifiers *psModifiers;
+} PVRDRIScreen;
+
+/** Our PVR related context data */
+typedef struct PVRDRIContext_TAG
+{
+	/* Pointer to DRI context */
+	__DRIcontext              *psDRIContext;
+	/* Pointer to PVRDRIScreen structure */
+	PVRDRIScreen              *psPVRScreen;
+
+	PVRDRIConfig               sConfig;
+
+	/* Pointer to currently bound drawable */
+	struct PVRDRIDrawable_TAG *psPVRDrawable;
+
+	/* API */
+	PVRDRIAPIType             eAPI;
+
+	PVRDRIContextImpl         *psImpl;
+} PVRDRIContext;
+
+/** Our PVR related drawable data */
+typedef struct PVRDRIDrawable_TAG
+{
+	/** Ptr to PVR screen, that spawned this drawable */
+	PVRDRIScreen       *psPVRScreen;
+
+	/** DRI drawable data */
+	__DRIdrawable      *psDRIDrawable;
+
+	PVRDRIDrawableType  eType;
+
+	PVRDRIConfig        sConfig;
+
+	/** Are surface/buffers created? */
+	bool                bInitialised;
+
+	/** Buffer stride */
+	unsigned            uStride;
+
+	/* Number of bytes per pixel */
+	unsigned int        uBytesPerPixel;
+
+	/* Context bound to this drawable */
+	PVRDRIContext       *psPVRContext;
+
+	/* IMG Pixel format for this drawable */
+	IMG_PIXFMT          ePixelFormat;
+
+	/* Indicates the drawable info is invalid */
+	int                 iInfoInvalid;
+
+	/* Indicates the drawable is currently being updated */
+	bool                bDrawableUpdating;
+
+	/* Indicates a flush is in progress */
+	bool                bFlushInProgress;
+
+	__DRIimage *psDRI;
+	__DRIimage *psImage;
+
+	__DRIimage *psDRIAccum;
+	__DRIimage *psImageAccum;
+
+	PVRDRIDrawableImpl *psImpl;
+} PVRDRIDrawable;
+
+typedef struct PVRDRIImageFormat_TAG
+{
+	/*
+	 * IMG pixel format for the entire/overall image, e.g.
+	 * IMG_PIXFMT_B8G8R8A8_UNORM or IMG_PIXFMT_YUV420_2PLANE.
+	 */
+	IMG_PIXFMT eIMGPixelFormat;
+
+	/*
+	 * DRI fourcc for the entire/overall image (defined by dri_interface.h),
+	 * e.g. __DRI_IMAGE_FOURCC_ARGB8888 or __DRI_IMAGE_FOURCC_NV12.
+	 */
+	int iDRIFourCC;
+
+	/*
+	 * DRI format for the entire/overall image (defined by dri_interface.h),
+	 * e.g. __DRI_IMAGE_FORMAT_ARGB8888. This isn't applicable for YUV
+	 * formats and should be set to __DRI_IMAGE_FORMAT_NONE.
+	 */
+	int iDRIFormat;
+
+	/*
+	 * DRI components for the entire/overall image (defined by
+	 * dri_interface.h), e.g. __DRI_IMAGE_COMPONENTS_RGBA or
+	 * __DRI_IMAGE_COMPONENTS_Y_UV.
+	 *
+	 * This specifies the image components and their groupings, in terms of
+	 * sub-images/planes, but not the order in which they appear.
+	 *
+	 * For example:
+	 * - any combination of BGRA channels would correspond to
+	 *   __DRI_IMAGE_COMPONENTS_RGBA
+	 * - any combination of BGR or BGRX would correspond to
+	 *   __DRI_IMAGE_COMPONENTS_RGB
+	 * - any combination of YUV with 2 planes would correspond to
+	 *   __DRI_IMAGE_COMPONENTS_Y_UV
+	 */
+	int iDRIComponents;
+
+	/* The number of sub-images/planes that make up the overall image */
+	unsigned uiNumPlanes;
+
+	/*
+	 * Don't return the format when the queryDmaBufFormats DRI Image
+	 * extension function is called. Some DRM formats map to multiple
+	 * IMG formats. The query should return just one of them.
+	 */
+	bool bQueryDmaBufFormatsExclude;
+
+	/* Per-plane information */
+	struct
+	{
+		/* IMG pixel format for the plane */
+		IMG_PIXFMT eIMGPixelFormat;
+
+		/*
+		 * This is the amount that the image width should be bit-shifted
+		 * in order to give the plane width. This value can be determined
+		 * from the YUV sub-sampling ratios and should either be 0 (full
+		 * width), 1 (half width) or 2 (quarter width).
+		 */
+		unsigned int uiWidthShift;
+
+		/*
+		 * This is the amount that the image height should be bit-shifted
+		 * in order to give the plane height. This value can be determined
+		 * from the YUV sub-sampling ratios and should either be 0 (full
+		 * height) or 1 (half height).
+		 */
+		unsigned int uiHeightShift;
+	} sPlanes[DRI_PLANES_MAX];
+} PVRDRIImageFormat;
+
+
+/*************************************************************************/ /*!
+ pvrdri.c
+*/ /**************************************************************************/
+
+IMG_PIXFMT PVRDRIGetPixelFormat(const struct gl_config *psGLMode);
+PVRDRIScreen *PVRDRIThreadGetCurrentScreen(void);
+void PVRDRIThreadSetCurrentScreen(PVRDRIScreen *psPVRScreen);
+
+void PVRDRIFlushBuffersForSwap(PVRDRIContext *psPVRContext,
+                               PVRDRIDrawable *psPVRDrawable);
+
+
+/*************************************************************************/ /*!
+ pvrutil.c
+*/ /**************************************************************************/
+
+void PRINTFLIKE(1, 2) __driUtilMessage(const char *f, ...);
+void PRINTFLIKE(1, 2) errorMessage(const char *f, ...);
+
+const __DRIconfig **PVRDRICreateConfigs(void);
+
+const PVRDRIImageFormat *PVRDRIFormatToImageFormat(PVRDRIScreen *psPVRScreen,
+						   int iDRIFormat);
+const PVRDRIImageFormat *PVRDRIFourCCToImageFormat(PVRDRIScreen *psPVRScreen,
+						   int iDRIFourCC);
+const PVRDRIImageFormat *PVRDRIIMGPixelFormatToImageFormat(PVRDRIScreen *psPVRScreen,
+							   IMG_PIXFMT eIMGPixelFormat);
+
+IMG_YUV_COLORSPACE PVRDRIToIMGColourSpace(const PVRDRIImageFormat *psFormat,
+					  enum __DRIYUVColorSpace eDRIColourSpace,
+					  enum __DRISampleRange eDRISampleRange);
+IMG_YUV_CHROMA_INTERP PVRDRIChromaSittingToIMGInterp(const PVRDRIImageFormat *psFormat,
+						     enum __DRIChromaSiting eChromaSitting);
+
+bool PVRDRIGetSupportedFormats(PVRDRIScreen *psPVRScreen);
+
+GLboolean PVRDRIQueryDmaBufFormats(__DRIscreen *screen, int max,
+				   int *formats, int *count);
+
+GLboolean PVRDRIQueryDmaBufModifiers(__DRIscreen *screen, int fourcc,
+				     int max, uint64_t *modifiers,
+				     unsigned int *external_only,
+				     int *count);
+
+GLboolean PVRDRIQueryDmaBufFormatModifierAttribs(__DRIscreen *screen,
+						 uint32_t fourcc,
+						 uint64_t modifier,
+						 int attrib,
+						 uint64_t *value);
+
+void PVRDRIDestroyFormatInfo(PVRDRIScreen *psPVRScreen);
+
+/*************************************************************************/ /*!
+ pvrdrawable.c
+*/ /**************************************************************************/
+
+bool PVRDRIDrawableInit(PVRDRIDrawable *psPVRDrawable);
+void PVRDRIDrawableDeinit(PVRDRIDrawable *psPVRDrawable);
+
+/* Callbacks into non-impl layer */
+
+/* Version 0 callbacks (deprecated) */
+bool PVRDRIDrawableRecreateV0(PVRDRIDrawable *psPVRDrawable);
+bool PVRDRIDrawableGetParametersV0(PVRDRIDrawable *psPVRDrawable,
+				   PVRDRIBufferImpl **ppsDstBuffer,
+				   PVRDRIBufferImpl **ppsAccumBuffer,
+				   PVRDRIBufferAttribs *psAttribs,
+				   bool *pbDoubleBuffered);
+
+/* Version 1 callbacks (deprecated) */
+bool PVRDRIDrawableGetParametersV1(PVRDRIDrawable *psPVRDrawable,
+				   bool bAllowRecreate,
+				   PVRDRIBufferImpl **ppsDstBuffer,
+				   PVRDRIBufferImpl **ppsAccumBuffer,
+				   PVRDRIBufferAttribs *psAttribs,
+				   bool *pbDoubleBuffered);
+
+/* Version 2 callbacks */
+bool PVRDRIDrawableQuery(const PVRDRIDrawable *psPVRDrawable,
+			 PVRDRIBufferAttrib eBufferAttrib,
+			 uint32_t *uiValueOut);
+bool PVRDRIDrawableGetParametersV2(PVRDRIDrawable *psPVRDrawable,
+				   uint32_t uiFlags,
+				   PVRDRIBufferImpl **ppsDstBuffer,
+				   PVRDRIBufferImpl **ppsAccumBuffer);
+
+/*************************************************************************/ /*!
+ pvrimage.c
+*/ /**************************************************************************/
+
+__DRIimage *PVRDRIScreenGetDRIImage(void *hEGLImage);
+void PVRDRIRefImage(__DRIimage *image);
+void PVRDRIUnrefImage(__DRIimage *image);
+
+/* Callbacks into non-impl layer */
+PVRDRIImageType PVRDRIImageGetSharedType(__DRIimage *image);
+PVRDRIBufferImpl *PVRDRIImageGetSharedBuffer(__DRIimage *image);
+IMGEGLImage *PVRDRIImageGetSharedEGLImage(__DRIimage *image);
+IMGEGLImage *PVRDRIImageGetEGLImage(__DRIimage *image);
+
+/*************************************************************************/ /*!
+ pvrext.c
+*/ /**************************************************************************/
+
+const __DRIextension **PVRDRIScreenExtensions(void);
+const __DRIextension *PVRDRIScreenExtensionVersionInfo(void);
+
+/*************************************************************************/ /*!
+ pvrcompat.c
+*/ /**************************************************************************/
+
+bool PVRDRICompatInit(const PVRDRICallbacks *psCallbacks, unsigned uVersion);
+void PVRDRICompatDeinit(void);
+
+bool PVRDRIRegisterSupportInterfaceV1(const PVRDRISupportInterface *psInterface,
+				      unsigned uVersion);
+
+unsigned PVRDRISupportCreateContext(PVRDRIScreenImpl *psScreenImpl,
+				    PVRDRIContextImpl *psSharedContextImpl,
+				    PVRDRIConfig *psConfig,
+				    PVRDRIAPIType eAPI,
+				    PVRDRIAPISubType eAPISub,
+				    unsigned uMajorVersion,
+				    unsigned uMinorVersion,
+				    uint32_t uFlags,
+				    bool bNotifyReset,
+				    unsigned uPriority,
+				    PVRDRIContextImpl **ppsContextImpl);
+
+PVRDRIDrawableImpl *PVRDRISupportCreateDrawable(PVRDRIDrawable *psPVRDrawable,
+						PVRDRIConfig *psConfig);
+
+bool PVRDRIBlitEGLImage_IsSupported(void);
+bool PVRDRIMapEGLImage_IsSupported(void);
+bool PVRDRIBufferGetOffset_IsSupported(void);
+bool PVRDRIBufferCreateWithModifiers_IsSupported(void);
+bool PVRDRIBufferCreateFromFdsWithModifier_IsSupported(void);
+
+void *PVRDRICreateFenceFdImpl(PVRDRIAPIType eAPI,
+			      PVRDRIScreenImpl *psScreenImpl,
+			      PVRDRIContextImpl *psContextImpl,
+			      int fd);
+
+unsigned PVRDRIGetFenceCapabilitiesImpl(PVRDRIScreenImpl *psScreenImpl);
+
+int PVRDRIGetFenceFdImpl(void *psDRIFence);
+
+bool PVRDRIValidateImageModifier(PVRDRIScreen *psPVRScreen, const int iFourcc,
+				 const uint64_t uiModifier);
+#endif /* defined(__PVRDRI2_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..c3782b6592b
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrext.c
@@ -0,0 +1,440 @@
+/* -*- mode: c; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* vi: set ts=8 sw=8 sts=8: */
+/*
+ * 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 "util/u_atomic.h"
+
+#include "dri_util.h"
+#include "utils.h"
+
+#include "dri_support.h"
+#include "pvrdri.h"
+#include "pvrimage.h"
+
+#include "EGL/egl.h"
+#include "EGL/eglext.h"
+
+/* Maximum version numbers for each supported extension */
+#define PVR_DRI_TEX_BUFFER_VERSION	2
+#define PVR_DRI2_FLUSH_VERSION		4
+#define PVR_DRI_IMAGE_VERSION		17
+#define PVR_DRI2_ROBUSTNESS_VERSION	1
+#define PVR_DRI2_FENCE_VERSION		2
+
+static void PVRDRIFlushDrawableContext(PVRDRIDrawable *psPVRDrawable,
+				       PVRDRIContext *psPVRContext)
+{
+	PVRDRIContext *psPVRDrawContext = psPVRDrawable->psPVRContext;
+
+	if (psPVRDrawContext)
+	{
+		PVRDRIEGLFlushBuffers(psPVRDrawContext->eAPI,
+		                      psPVRDrawContext->psPVRScreen->psImpl,
+		                      psPVRDrawContext->psImpl,
+		                      psPVRDrawable->psImpl,
+		                      false,
+		                      false,
+		                      (psPVRDrawContext != psPVRContext));
+	}
+}
+
+static void PVRDRIExtSetTexBuffer(__DRIcontext  *psDRIContext,
+				  GLint          target,
+				  GLint          format,
+				  __DRIdrawable *psDRIDrawable)
+{
+	PVRDRIDrawable *psPVRDrawable = (PVRDRIDrawable *)psDRIDrawable->driverPrivate;
+	PVRDRIContext *psPVRContext = (PVRDRIContext *)psDRIContext->driverPrivate;
+
+	(void)target;
+	(void)format;
+
+	if (!psPVRDrawable->bInitialised)
+	{
+		if (!PVRDRIDrawableInit(psPVRDrawable))
+		{
+			__driUtilMessage("%s: Couldn't initialise pixmap", __func__);
+			return;
+		}
+	}
+
+	PVRDRIFlushDrawableContext(psPVRDrawable, psPVRContext);
+	PVRDRI2BindTexImage(psPVRContext->eAPI,
+	                    psPVRContext->psPVRScreen->psImpl,
+	                    psPVRContext->psImpl,
+	                    psPVRDrawable->psImpl);
+}
+
+static void PVRDRIExtReleaseTexBuffer(__DRIcontext  *psDRIContext,
+				      GLint          target,
+				      __DRIdrawable *psDRIDrawable)
+{
+	PVRDRIDrawable *psPVRDrawable = (PVRDRIDrawable *)psDRIDrawable->driverPrivate;
+	PVRDRIContext *psPVRContext = (PVRDRIContext *)psDRIContext->driverPrivate;
+
+	(void)target;
+
+	PVRDRI2ReleaseTexImage(psPVRContext->eAPI,
+	                       psPVRContext->psPVRScreen->psImpl,
+	                       psPVRContext->psImpl,
+	                       psPVRDrawable->psImpl);
+}
+
+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 = (PVRDRIDrawable *)psDRIDrawable->driverPrivate;
+	PVRDRIContext *psPVRContext = psPVRDrawable->psPVRContext;
+
+	PVRDRIFlushBuffersForSwap(psPVRContext, psPVRDrawable);
+}
+
+static void PVRDRI2Invalidate(__DRIdrawable *psDRIDrawable)
+{
+	PVRDRIDrawable *psPVRDrawable = (PVRDRIDrawable *)psDRIDrawable->driverPrivate;
+
+	if (psPVRDrawable->psPVRScreen->bUseInvalidate)
+	{
+		p_atomic_inc(&psPVRDrawable->iInfoInvalid);
+	}
+}
+
+static void PVRDRI2FlushWithFlags(__DRIcontext *psDRIContext,
+				  __DRIdrawable *psDRIDrawable,
+				  unsigned uFlags,
+				  enum __DRI2throttleReason eThrottleReason)
+{
+	PVRDRIContext *psPVRContext = (PVRDRIContext *)psDRIContext->driverPrivate;
+
+	(void)eThrottleReason;
+
+	if ((uFlags & __DRI2_FLUSH_DRAWABLE) != 0)
+	{
+		PVRDRIDrawable *psPVRDrawable = psDRIDrawable->driverPrivate;
+
+		PVRDRIFlushBuffersForSwap(psPVRContext, psPVRDrawable);
+	}
+	else if ((uFlags & __DRI2_FLUSH_CONTEXT) != 0)
+	{
+		/*
+		 * __DRI2_FLUSH__CONTEXT means "glFlush". Most callers
+		 * also specify __DRI2_FLUSH_DRAWABLE. An exception is
+		 * GBM, which flushes after an unmap, when there doesn't
+		 * appear to be a need to flush outstanding GPU operations.
+		 */
+	}
+}
+
+static __DRI2flushExtension pvrDRI2FlushExtension =
+{
+	.base			= { .name = __DRI2_FLUSH, .version = PVR_DRI2_FLUSH_VERSION },
+	.flush			= PVRDRI2Flush,
+	.invalidate		= PVRDRI2Invalidate,
+	.flush_with_flags	= PVRDRI2FlushWithFlags,
+};
+
+
+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			= PVRDRIValidateUsage,
+	.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 *dri_screen,
+                           int param, unsigned int *value)
+{
+	switch (param)
+	{
+		case __DRI2_RENDERER_HAS_CONTEXT_PRIORITY:
+			value[0] = 0;
+			value[0] |= __DRI2_RENDERER_HAS_CONTEXT_PRIORITY_HIGH;
+			value[0] |= __DRI2_RENDERER_HAS_CONTEXT_PRIORITY_MEDIUM;
+			value[0] |= __DRI2_RENDERER_HAS_CONTEXT_PRIORITY_LOW;
+			return 0;
+
+		default:
+			return driQueryRendererIntegerCommon(dri_screen, param, value);
+	}
+}
+
+static int
+PVRDRIQueryRendererString(__DRIscreen *dri_screen,
+                          int param, const char **value)
+{
+	return -1;
+}
+
+static const __DRI2rendererQueryExtension pvrDRIRendererQueryExtension = {
+   .base = { __DRI2_RENDERER_QUERY, 1 },
+
+   .queryInteger = PVRDRIQueryRendererInteger,
+   .queryString = PVRDRIQueryRendererString,
+};
+
+
+#if defined(__DRI2_FENCE)
+static void *PVRDRICreateFenceEXT(__DRIcontext *psDRIContext)
+{
+	PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+	PVRDRIScreen *psPVRScreen = psPVRContext->psPVRScreen;
+
+	return PVRDRICreateFenceImpl(psPVRContext->eAPI,
+				     psPVRScreen->psImpl,
+				     psPVRContext->psImpl);
+}
+
+static void PVRDRIDestroyFenceEXT(__DRIscreen *psDRIScreen, void *psDRIFence)
+{
+	(void)psDRIScreen;
+
+	PVRDRIDestroyFenceImpl(psDRIFence);
+}
+
+static GLboolean PVRDRIClientWaitSyncEXT(__DRIcontext *psDRIContext,
+					 void *psDRIFence,
+					 unsigned uFlags,
+					 uint64_t uiTimeout)
+{
+	bool bFlushCommands = (uFlags & __DRI2_FENCE_FLAG_FLUSH_COMMANDS);
+	bool bTimeout = (uiTimeout != __DRI2_FENCE_TIMEOUT_INFINITE);
+
+	if (psDRIContext && bFlushCommands)
+	{
+		PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+		PVRDRIDrawable *psPVRDrawable = psPVRContext->psPVRDrawable;
+
+		(void) PVRDRIEGLFlushBuffers(psPVRContext->eAPI,
+					     psPVRContext->psPVRScreen->psImpl,
+					     psPVRContext->psImpl,
+					     psPVRDrawable ? psPVRDrawable->psImpl : NULL,
+					     true, false, false);
+	}
+
+	return PVRDRIClientWaitSyncImpl(PVRDRI_API_NONE,
+					NULL,
+					psDRIFence,
+					false,
+					bTimeout,
+					uiTimeout);
+}
+
+static void PVRDRIServerWaitSyncEXT(__DRIcontext *psDRIContext,
+				    void *psDRIFence,
+				    unsigned uFlags)
+{
+	(void)uFlags;
+	assert(uFlags == 0);
+
+	if (psDRIFence)
+	{
+		PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+
+		if (!PVRDRIServerWaitSyncImpl(psPVRContext->eAPI,
+					      psPVRContext->psImpl,
+					      psDRIFence))
+		{
+			__driUtilMessage("%s: Server wait sync failed",
+					 __func__);
+		}
+	}
+}
+
+static unsigned PVRDRIGetFenceCapabilitiesEXT(__DRIscreen *psDRIScreen)
+{
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(psDRIScreen);
+
+	return PVRDRIGetFenceCapabilitiesImpl(psPVRScreen->psImpl);
+}
+
+static void *PVRDRICreateFenceFdEXT(__DRIcontext *psDRIContext, int iFd)
+{
+	PVRDRIContext *psPVRContext = psDRIContext->driverPrivate;
+	PVRDRIScreen *psPVRScreen = psPVRContext->psPVRScreen;
+
+	return PVRDRICreateFenceFdImpl(psPVRContext->eAPI,
+				       psPVRScreen->psImpl,
+				       psPVRContext->psImpl,
+				       iFd);
+}
+
+static int PVRDRIGetFenceFdEXT(__DRIscreen *psDRIScreen, void *psDRIFence)
+{
+	(void)psDRIScreen;
+
+	return PVRDRIGetFenceFdImpl(psDRIFence);
+}
+
+const __DRI2fenceExtension pvrDRIFenceExtension =
+{
+	.base				= { .name = __DRI2_FENCE, .version = PVR_DRI2_FENCE_VERSION },
+	.create_fence			= PVRDRICreateFenceEXT,
+	/* Not currently supported */
+	.get_fence_from_cl_event	= NULL,
+	.destroy_fence			= PVRDRIDestroyFenceEXT,
+	.client_wait_sync		= PVRDRIClientWaitSyncEXT,
+	.server_wait_sync		= PVRDRIServerWaitSyncEXT,
+	.get_capabilities		= PVRDRIGetFenceCapabilitiesEXT,
+	.create_fence_fd		= PVRDRICreateFenceFdEXT,
+	.get_fence_fd			= PVRDRIGetFenceFdEXT,
+};
+#endif /* defined(__DRI2_FENCE) */
+
+/*
+ * 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,
+#if defined(__DRI2_FENCE)
+	&pvrDRIFenceExtension.base,
+#endif
+	&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 },
+#if defined(__DRI2_FENCE)
+	{ .name = __DRI2_FENCE, .version = __DRI2_FENCE_VERSION },
+#endif
+	{ .name = __DRI2_CONFIG_QUERY, .version = __DRI2_CONFIG_QUERY_VERSION },
+	{ .name = NULL, .version = 0 },
+};
+
+const __DRIextension **PVRDRIScreenExtensions(void)
+{
+	if (!PVRDRIBlitEGLImage_IsSupported())
+	{
+		pvrDRIImage.base.version = 8;
+	}
+	else if (!PVRDRIMapEGLImage_IsSupported())
+	{
+		pvrDRIImage.base.version = 11;
+	}
+	else if (!PVRDRIBufferGetOffset_IsSupported())
+	{
+		pvrDRIImage.base.version = 12;
+	}
+	else if (!PVRDRIBufferCreateWithModifiers_IsSupported())
+	{
+		pvrDRIImage.base.version = 13;
+	}
+	else if (!PVRDRIBufferCreateFromFdsWithModifier_IsSupported())
+	{
+		pvrDRIImage.base.version = 14;
+	}
+
+	return apsScreenExtensions;
+}
+
+const __DRIextension *PVRDRIScreenExtensionVersionInfo(void)
+{
+	return asScreenExtensionVersionInfo;
+}
diff --git a/src/mesa/drivers/dri/pvr/pvrimage.c b/src/mesa/drivers/dri/pvr/pvrimage.c
new file mode 100644
index 00000000000..873c852cf9e
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrimage.c
@@ -0,0 +1,1420 @@
+/* -*- mode: c; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* vi: set ts=8 sw=8 sts=8: */
+/*
+ * 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 <xf86drm.h>
+
+#include "util/u_atomic.h"
+#include "dri_util.h"
+
+#include "img_drm_fourcc.h"
+#include "pvrdri.h"
+#include "pvrimage.h"
+#include "EGL/egl.h"
+#include "EGL/eglext.h"
+
+struct PVRDRIImageShared
+{
+	int iRefCount;
+
+	PVRDRIScreen *psPVRScreen;
+
+	PVRDRIImageType eType;
+	const PVRDRIImageFormat *psFormat;
+	IMG_YUV_COLORSPACE eColourSpace;
+	IMG_YUV_CHROMA_INTERP eChromaUInterp;
+	IMG_YUV_CHROMA_INTERP eChromaVInterp;
+
+	PVRDRIBufferImpl *psBuffer;
+	IMGEGLImage *psEGLImage;
+	PVRDRIEGLImageType eglImageType;
+	struct PVRDRIImageShared *psAncestor;
+};
+
+struct __DRIimageRec
+{
+	int iRefCount;
+
+	void *loaderPrivate;
+
+	struct PVRDRIImageShared *psShared;
+
+	IMGEGLImage *psEGLImage;
+};
+
+
+static struct PVRDRIImageShared *
+CommonImageSharedSetup(PVRDRIScreen *psPVRScreen, PVRDRIImageType eType)
+{
+	struct PVRDRIImageShared *shared;
+
+	shared = calloc(1, sizeof(*shared));
+	if (!shared)
+	{
+		return NULL;
+	}
+
+	shared->psPVRScreen = psPVRScreen;
+	shared->eType = eType;
+	shared->iRefCount = 1;
+
+	assert(shared->eColourSpace == IMG_COLORSPACE_UNDEFINED &&
+	       shared->eChromaUInterp == IMG_CHROMA_INTERP_UNDEFINED &&
+	       shared->eChromaVInterp == IMG_CHROMA_INTERP_UNDEFINED);
+
+	return shared;
+}
+
+static void DestroyImageShared(struct PVRDRIImageShared *shared)
+{
+	int iRefCount = p_atomic_dec_return(&shared->iRefCount);
+
+	assert(iRefCount >= 0);
+
+	if (iRefCount > 0)
+	{
+		return;
+	}
+
+	switch (shared->eType)
+	{
+		case PVRDRI_IMAGE_FROM_NAMES:
+		case PVRDRI_IMAGE_FROM_DMABUFS:
+		case PVRDRI_IMAGE:
+			if (shared->psBuffer)
+			{
+				PVRDRIBufferDestroy(shared->psBuffer);
+			}
+			assert(!shared->psAncestor);
+			free(shared);
+			return;
+		case PVRDRI_IMAGE_FROM_EGLIMAGE:
+			PVRDRIEGLImageDestroyExternal(shared->psPVRScreen->psImpl,
+			                              shared->psEGLImage,
+						      shared->eglImageType);
+			free(shared);
+			return;
+		case PVRDRI_IMAGE_SUBIMAGE:
+			if (shared->psBuffer)
+			{
+				PVRDRIBufferDestroy(shared->psBuffer);
+			}
+			if (shared->psAncestor)
+			{
+				DestroyImageShared(shared->psAncestor);
+			}
+			free(shared);
+			return;
+	}
+
+	assert(!"unknown image type");
+	free(shared);
+}
+
+static struct PVRDRIImageShared *
+CreateImageSharedFromEGLImage(__DRIscreen *screen,
+                              IMGEGLImage *psEGLImage,
+			      PVRDRIEGLImageType eglImageType)
+{
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(screen);
+	struct PVRDRIImageShared *shared;
+	PVRDRIBufferAttribs sAttribs;
+	const PVRDRIImageFormat *psFormat;
+
+	PVRDRIEGLImageGetAttribs(psEGLImage, &sAttribs);
+
+	psFormat = PVRDRIIMGPixelFormatToImageFormat(psPVRScreen,
+						     sAttribs.ePixFormat);
+	if (!psFormat)
+	{
+		return NULL;
+	}
+
+	shared = CommonImageSharedSetup(psPVRScreen, PVRDRI_IMAGE_FROM_EGLIMAGE);
+	if (!shared)
+	{
+		return NULL;
+	}
+
+	shared->psEGLImage = psEGLImage;
+	shared->psFormat = psFormat;
+	shared->eglImageType = eglImageType;
+
+	return shared;
+}
+
+static struct PVRDRIImageShared *
+CreateImageSharedFromNames(__DRIscreen *screen,
+			   int width,
+			   int height,
+			   int fourcc,
+			   int *names,
+			   int num_names,
+			   int *strides,
+			   int *offsets)
+{
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(screen);
+	struct PVRDRIImageShared *shared;
+	const PVRDRIImageFormat *psFormat;
+	unsigned auiWidthShift[DRI_PLANES_MAX];
+	unsigned auiHeightShift[DRI_PLANES_MAX];
+	int i;
+
+	psFormat = PVRDRIFourCCToImageFormat(psPVRScreen, fourcc);
+	if (!psFormat)
+	{
+		errorMessage("%s: Unsupported DRI FourCC (fourcc = 0x%X)\n",
+			     __func__, fourcc);
+		return NULL;
+	}
+
+	if (psFormat->uiNumPlanes < num_names)
+	{
+		errorMessage("%s: Unexpected number of names for DRI FourCC (names = %d, fourcc = 0x%X)\n",
+			     __func__, num_names, fourcc);
+		return NULL;
+	}
+
+	for (i = 0; i < num_names; i++)
+	{
+		if (offsets[i] < 0)
+		{
+			errorMessage("%s: Offset %d unsupported (value = %d)\n",
+				     __func__, i, offsets[i]);
+			return NULL;
+		}
+
+		auiWidthShift[i] = psFormat->sPlanes[i].uiWidthShift;
+		auiHeightShift[i] = psFormat->sPlanes[i].uiHeightShift;
+	}
+
+	shared = CommonImageSharedSetup(psPVRScreen, PVRDRI_IMAGE_FROM_NAMES);
+	if (!shared)
+	{
+		return NULL;
+	}
+
+	shared->psBuffer = PVRDRIBufferCreateFromNames(psPVRScreen->psImpl,
+						        width,
+						        height,
+						        num_names,
+						        names,
+						        strides,
+						        offsets,
+						        auiWidthShift,
+						        auiHeightShift);
+
+	if (!shared->psBuffer)
+	{
+		errorMessage("%s: Failed to create buffer for shared image\n", __func__);
+		goto ErrorDestroyImage;
+	}
+
+	shared->psFormat = psFormat;
+	shared->eColourSpace =
+		PVRDRIToIMGColourSpace(psFormat,
+				       __DRI_YUV_COLOR_SPACE_UNDEFINED,
+				       __DRI_YUV_RANGE_UNDEFINED);
+	shared->eChromaUInterp =
+		PVRDRIChromaSittingToIMGInterp(psFormat,
+					       __DRI_YUV_CHROMA_SITING_UNDEFINED);
+	shared->eChromaVInterp =
+		PVRDRIChromaSittingToIMGInterp(psFormat,
+					       __DRI_YUV_CHROMA_SITING_UNDEFINED);
+
+	return shared;
+
+ErrorDestroyImage:
+	DestroyImageShared(shared);
+
+	return NULL;
+}
+
+static struct PVRDRIImageShared *
+CreateImageSharedFromDmaBufs(__DRIscreen *screen,
+			     int width,
+			     int height,
+			     int fourcc,
+			     uint64_t modifier,
+			     int *fds,
+			     int num_fds,
+			     int *strides,
+			     int *offsets,
+			     enum __DRIYUVColorSpace color_space,
+			     enum __DRISampleRange sample_range,
+			     enum __DRIChromaSiting horiz_siting,
+			     enum __DRIChromaSiting vert_siting,
+			     unsigned *error)
+{
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(screen);
+	struct PVRDRIImageShared *shared;
+	const PVRDRIImageFormat *psFormat;
+	unsigned auiWidthShift[DRI_PLANES_MAX];
+	unsigned auiHeightShift[DRI_PLANES_MAX];
+	int i;
+
+	psFormat = PVRDRIFourCCToImageFormat(psPVRScreen, fourcc);
+	if (!psFormat)
+	{
+		errorMessage("%s: Unsupported DRI FourCC (fourcc = 0x%X)\n",
+			     __func__, fourcc);
+		*error = __DRI_IMAGE_ERROR_BAD_MATCH;
+		return NULL;
+	}
+
+	/* When a modifier isn't specified, skip the validation */
+	if (modifier != DRM_FORMAT_MOD_INVALID)
+	{
+		/*
+		 * The modifier validation has to be done in this "higher" level
+		 * function instead of pvr_dri_support. The support for
+		 * modifiers is done on per format basis, but there is no way
+		 * to pass the format information down to the plane creation API
+		 * in pvr_dri_support.
+		 */
+		if (!PVRDRIValidateImageModifier(psPVRScreen, fourcc, modifier))
+		{
+			errorMessage("%s: Unsupported mod (fmt = %#x, mod = %"PRIx64")\n",
+				     __func__, fourcc, modifier);
+			*error = __DRI_IMAGE_ERROR_BAD_MATCH;
+			return NULL;
+		}
+	}
+
+	if (psFormat->uiNumPlanes < num_fds)
+	{
+		errorMessage("%s: Unexpected number of fds for format (fds = %d, fourcc = 0x%X)\n",
+			     __func__, num_fds, fourcc);
+		*error = __DRI_IMAGE_ERROR_BAD_MATCH;
+		return NULL;
+	}
+
+	for (i = 0; i < num_fds; i++)
+	{
+		if (offsets[i] < 0)
+		{
+			errorMessage("%s: Offset %d unsupported (value = %d)\n",
+				     __func__, i, offsets[i]);
+			*error = __DRI_IMAGE_ERROR_BAD_ACCESS;
+			return NULL;
+		}
+
+		auiWidthShift[i] = psFormat->sPlanes[i].uiWidthShift;
+		auiHeightShift[i] = psFormat->sPlanes[i].uiHeightShift;
+	}
+
+	shared = CommonImageSharedSetup(psPVRScreen, PVRDRI_IMAGE_FROM_DMABUFS);
+	if (!shared)
+	{
+		*error = __DRI_IMAGE_ERROR_BAD_ALLOC;
+		return NULL;
+	}
+
+	shared->psBuffer = PVRDRIBufferCreateFromFdsWithModifier(psPVRScreen->psImpl,
+								  width,
+								  height,
+								  modifier,
+								  num_fds,
+								  fds,
+								  strides,
+								  offsets,
+								  auiWidthShift,
+								  auiHeightShift);
+
+	if (!shared->psBuffer)
+	{
+		errorMessage("%s: Failed to create buffer for shared image\n", __func__);
+		*error = __DRI_IMAGE_ERROR_BAD_ALLOC;
+		goto ErrorDestroyImage;
+	}
+
+	shared->psFormat = psFormat;
+	shared->eColourSpace = PVRDRIToIMGColourSpace(psFormat, color_space, sample_range);
+	shared->eChromaUInterp = PVRDRIChromaSittingToIMGInterp(psFormat, horiz_siting);
+	shared->eChromaVInterp = PVRDRIChromaSittingToIMGInterp(psFormat, vert_siting);
+
+	return shared;
+
+ErrorDestroyImage:
+	DestroyImageShared(shared);
+
+	return NULL;
+}
+
+static struct PVRDRIImageShared *
+CreateImageShared(__DRIscreen *screen,
+                  int width,
+                  int height,
+                  int format,
+                  unsigned int use,
+                  int *piStride)
+{
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(screen);
+	struct PVRDRIImageShared *shared;
+	const PVRDRIImageFormat *psFormat;
+	unsigned int uiStride;
+
+	if ((use & __DRI_IMAGE_USE_CURSOR) && (use & __DRI_IMAGE_USE_SCANOUT))
+	{
+		return NULL;
+	}
+
+	psFormat = PVRDRIFormatToImageFormat(psPVRScreen, format);
+	if (!psFormat)
+	{
+		errorMessage("%s: Unsupported DRI image format (format = 0x%X)\n",
+			     __func__, format);
+		return NULL;
+	}
+
+	if (psFormat->uiNumPlanes != 1)
+	{
+		errorMessage("%s: Only single plane formats are supported (format 0x%X has %u planes)\n",
+			     __func__, format, psFormat->uiNumPlanes);
+		return NULL;
+	}
+
+	shared = CommonImageSharedSetup(psPVRScreen, PVRDRI_IMAGE);
+	if (!shared)
+	{
+		return NULL;
+	}
+
+	shared->psBuffer =
+		PVRDRIBufferCreate(psPVRScreen->psImpl,
+				   width,
+				   height,
+				   PVRDRIPixFmtGetBPP(psFormat->eIMGPixelFormat),
+				   use,
+				   &uiStride);
+	if (!shared->psBuffer)
+	{
+		errorMessage("%s: Failed to create buffer\n", __func__);
+		goto ErrorDestroyImage;
+	}
+
+	shared->psFormat = psFormat;
+
+	*piStride = uiStride;
+
+	return shared;
+
+ErrorDestroyImage:
+	DestroyImageShared(shared);
+
+	return NULL;
+}
+
+static struct PVRDRIImageShared *
+CreateImageSharedWithModifiers(__DRIscreen *screen,
+			       int width,
+			       int height,
+			       int format,
+			       const uint64_t *modifiers,
+			       unsigned int modifier_count,
+			       int *piStride)
+{
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(screen);
+	struct PVRDRIImageShared *shared;
+	const PVRDRIImageFormat *psFormat;
+	unsigned int uiStride;
+
+	psFormat = PVRDRIFormatToImageFormat(psPVRScreen, format);
+	if (!psFormat)
+	{
+		errorMessage("%s: Unsupported DRI image format (format = 0x%X)\n",
+			     __func__, format);
+		return NULL;
+	}
+
+	shared = CommonImageSharedSetup(psPVRScreen, PVRDRI_IMAGE);
+	if (!shared)
+	{
+		return NULL;
+	}
+
+	shared->psBuffer = PVRDRIBufferCreateWithModifiers(psPVRScreen->psImpl,
+							   width,
+							   height,
+							   psFormat->iDRIFourCC,
+							   psFormat->eIMGPixelFormat,
+							   modifiers,
+							   modifier_count,
+							   &uiStride);
+	if (!shared->psBuffer)
+	{
+		errorMessage("%s: Failed to create buffer\n", __func__);
+		goto ErrorDestroyImage;
+	}
+
+	shared->psFormat = psFormat;
+
+	*piStride = uiStride;
+
+	return shared;
+
+ErrorDestroyImage:
+	DestroyImageShared(shared);
+
+	return NULL;
+}
+
+static struct PVRDRIImageShared *RefImageShared(struct PVRDRIImageShared *shared)
+{
+	int iRefCount = p_atomic_inc_return(&shared->iRefCount);
+
+	(void)iRefCount;
+	assert(iRefCount > 1);
+
+	return shared;
+}
+
+static struct PVRDRIImageShared *
+CreateImageSharedForSubImage(struct PVRDRIImageShared *psParent, int plane)
+{
+	struct PVRDRIImageShared *shared;
+	struct PVRDRIImageShared *psAncestor;
+	PVRDRIBufferImpl *psBuffer = NULL;
+
+	/* Sub-images represent a single plane in the parent image */
+	if (!psParent->psBuffer)
+	{
+		return NULL;
+	}
+
+	/*
+	 * The ancestor image is the owner of the original buffer that will
+	 * back the new image. The parent image may be a child of that image
+	 * itself. The ancestor image must not be destroyed until all the
+	 * child images that refer to it have been destroyed. A reference
+	 * will be taken on the ancestor to ensure that is the case.
+	 * We must distinguish between the parent's buffer and the ancestor's
+	 * buffer. For example, plane 0 in the parent is not necessarily plane
+	 * 0 in the ancestor.
+	 */
+	psAncestor = psParent;
+	if (psAncestor->psAncestor)
+	{
+		psAncestor = psAncestor->psAncestor;
+
+		assert(!psAncestor->psAncestor);
+	}
+
+	psBuffer = PVRDRISubBufferCreate(psParent->psPVRScreen->psImpl,
+					 psParent->psBuffer,
+					 plane);
+	/*
+	 * Older versions of PVR DRI Support don't support
+	 * PVRDRISubBufferCreate.
+	 */
+	if (!psBuffer)
+	{
+		return NULL;
+	}
+
+	shared = CommonImageSharedSetup(NULL, PVRDRI_IMAGE_SUBIMAGE);
+	if (!shared)
+	{
+		goto ErrorDestroyBuffer;
+	}
+
+	shared->psAncestor = RefImageShared(psAncestor);
+	shared->psBuffer = psBuffer;
+	shared->psPVRScreen = psParent->psPVRScreen;
+
+	shared->psFormat = PVRDRIIMGPixelFormatToImageFormat(psParent->psPVRScreen,
+							     psParent->psFormat->sPlanes[plane].eIMGPixelFormat);
+	assert(shared->psFormat);
+
+	return shared;
+
+ErrorDestroyBuffer:
+	PVRDRIBufferDestroy(psBuffer);
+	return NULL;
+}
+
+static __DRIimage *CommonImageSetup(void *loaderPrivate)
+{
+	__DRIimage *image;
+
+	image = calloc(1, sizeof(*image));
+	if (!image)
+	{
+		return NULL;
+	}
+
+	image->loaderPrivate = loaderPrivate;
+	image->iRefCount = 1;
+
+	return image;
+}
+
+void PVRDRIDestroyImage(__DRIimage *image)
+{
+	int iRefCount = p_atomic_dec_return(&image->iRefCount);
+
+	assert(iRefCount >= 0);
+
+	if (iRefCount > 0)
+	{
+		return;
+	}
+
+	if (image->psShared)
+	{
+		DestroyImageShared(image->psShared);
+	}
+
+	PVRDRIEGLImageFree(image->psEGLImage);
+
+	free(image);
+}
+
+__DRIimage *PVRDRICreateImageFromName(__DRIscreen *screen,
+				      int width, int height, int format,
+				      int name, int pitch,
+				      void *loaderPrivate)
+{
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(screen);
+	const PVRDRIImageFormat *psFormat;
+	int iStride;
+	int iOffset;
+
+	psFormat = PVRDRIFormatToImageFormat(psPVRScreen, format);
+	if (!psFormat)
+	{
+		errorMessage("%s: Unsupported DRI image format (format = 0x%X)\n",
+			     __func__, format);
+		return NULL;
+	}
+
+	iStride = pitch * PVRDRIPixFmtGetBlockSize(psFormat->eIMGPixelFormat);
+	iOffset = 0;
+
+	return PVRDRICreateImageFromNames(screen, width, height, psFormat->iDRIFourCC,
+					  &name, 1, &iStride, &iOffset, loaderPrivate);
+}
+
+__DRIimage *PVRDRICreateImageFromRenderbuffer2(__DRIcontext *context,
+					      int           renderbuffer,
+                                              void         *loaderPrivate,
+					      unsigned     *error)
+{
+	PVRDRIContext *psPVRContext = context->driverPrivate;
+	__DRIscreen *screen = psPVRContext->psPVRScreen->psDRIScreen;
+	unsigned e;
+	IMGEGLImage *psEGLImage;
+	__DRIimage *image;
+
+	image = CommonImageSetup(loaderPrivate);
+	if (!image)
+	{
+		*error = __DRI_IMAGE_ERROR_BAD_ALLOC;
+		return NULL;
+	}
+
+	psEGLImage = PVRDRIEGLImageCreate();
+	if (!psEGLImage)
+	{
+		PVRDRIDestroyImage(image);
+
+		*error = __DRI_IMAGE_ERROR_BAD_ALLOC;
+		return NULL;
+	}
+
+	e = PVRDRIGetImageSource(psPVRContext->eAPI,
+	                         psPVRContext->psPVRScreen->psImpl,
+	                         psPVRContext->psImpl,
+	                         EGL_GL_RENDERBUFFER_KHR,
+	                         (uintptr_t)renderbuffer,
+	                         0,
+	                         psEGLImage);
+
+	if (e != PVRDRI_IMAGE_ERROR_SUCCESS)
+	{
+		PVRDRIEGLImageFree(psEGLImage);
+		PVRDRIDestroyImage(image);
+
+		*error = e;
+		return NULL;
+	}
+
+	PVRDRIEGLImageSetCallbackData(psEGLImage, image);
+	
+	/*
+	 * We can't destroy the image after this point, as the
+	 * renderbuffer now has a reference to it.
+	 */
+	image->psShared = CreateImageSharedFromEGLImage(screen,
+							psEGLImage,
+							PVRDRI_EGLIMAGE_IMGEGL);
+	if (!image->psShared)
+	{
+		*error = __DRI_IMAGE_ERROR_BAD_ALLOC;
+		return NULL;
+	}
+
+	image->psEGLImage = PVRDRIEGLImageDup(image->psShared->psEGLImage);
+	if (!image->psEGLImage)
+	{
+		*error = __DRI_IMAGE_ERROR_BAD_ALLOC;
+		return NULL;
+	}
+
+	image->iRefCount++;
+
+	*error = __DRI_IMAGE_ERROR_SUCCESS;
+	return image;
+}
+
+__DRIimage *PVRDRICreateImageFromRenderbuffer(__DRIcontext *context,
+                                              int           renderbuffer,
+                                              void         *loaderPrivate)
+{
+	unsigned error;
+
+	return PVRDRICreateImageFromRenderbuffer2(context,
+						  renderbuffer,
+						  loaderPrivate,
+						  &error);
+}
+
+__DRIimage *PVRDRICreateImage(__DRIscreen *screen,
+			      int width, int height, int format,
+			      unsigned int use,
+			      void *loaderPrivate)
+{
+	__DRIimage *image;
+	int iStride;
+
+	image = CommonImageSetup(loaderPrivate);
+	if (!image)
+	{
+		return NULL;
+	}
+
+	image->psShared = CreateImageShared(screen, width, height, format, use, &iStride);
+	if (!image->psShared)
+	{
+		PVRDRIDestroyImage(image);
+		return NULL;
+	}
+
+	image->psEGLImage = PVRDRIEGLImageCreateFromBuffer(width, height, iStride,
+							    image->psShared->psFormat->eIMGPixelFormat,
+							    image->psShared->eColourSpace,
+							    image->psShared->eChromaUInterp,
+							    image->psShared->eChromaVInterp,
+							    image->psShared->psBuffer);
+	if (!image->psEGLImage)
+	{
+		PVRDRIDestroyImage(image);
+		return NULL;
+	}
+
+	PVRDRIEGLImageSetCallbackData(image->psEGLImage, image);
+
+	return image;
+}
+
+__DRIimage *PVRDRICreateImageWithModifiers(__DRIscreen *screen,
+					   int width, int height, int format,
+					   const uint64_t *modifiers,
+					   const unsigned int modifier_count,
+					   void *loaderPrivate)
+{
+	__DRIimage *image;
+	int iStride;
+
+	image = CommonImageSetup(loaderPrivate);
+	if (!image)
+	{
+		return NULL;
+	}
+
+	image->psShared = CreateImageSharedWithModifiers(screen, width, height, format,
+							 modifiers, modifier_count,
+							 &iStride);
+	if (!image->psShared)
+	{
+		PVRDRIDestroyImage(image);
+		return NULL;
+	}
+
+	image->psEGLImage = PVRDRIEGLImageCreateFromBuffer(width, height, iStride,
+							    image->psShared->psFormat->eIMGPixelFormat,
+							    image->psShared->eColourSpace,
+							    image->psShared->eChromaUInterp,
+							    image->psShared->eChromaVInterp,
+							    image->psShared->psBuffer);
+	if (!image->psEGLImage)
+	{
+		PVRDRIDestroyImage(image);
+		return NULL;
+	}
+
+	PVRDRIEGLImageSetCallbackData(image->psEGLImage, image);
+
+	return image;
+}
+
+GLboolean PVRDRIQueryImage(__DRIimage *image, int attrib, int *value_ptr)
+{
+	struct PVRDRIImageShared *shared = image->psShared;
+	PVRDRIBufferAttribs sAttribs;
+	int value;
+	uint64_t ulValue;
+
+	PVRDRIEGLImageGetAttribs(image->psEGLImage, &sAttribs);
+
+	if (attrib == __DRI_IMAGE_ATTRIB_HANDLE ||
+	    attrib == __DRI_IMAGE_ATTRIB_NAME ||
+	    attrib == __DRI_IMAGE_ATTRIB_FD ||
+	    attrib == __DRI_IMAGE_ATTRIB_OFFSET)
+	{
+		if (!shared->psFormat)
+		{
+			return GL_FALSE;
+		}
+
+		switch (shared->psFormat->iDRIComponents)
+		{
+			case __DRI_IMAGE_COMPONENTS_R:
+			case __DRI_IMAGE_COMPONENTS_RG:
+			case __DRI_IMAGE_COMPONENTS_RGB:
+			case __DRI_IMAGE_COMPONENTS_RGBA:
+#if defined(__DRI_IMAGE_COMPONENTS_EXTERNAL)
+			case __DRI_IMAGE_COMPONENTS_EXTERNAL:
+#endif
+				break;
+			default:
+				return GL_FALSE;
+		}
+	}
+
+	switch (attrib)
+	{
+		case __DRI_IMAGE_ATTRIB_STRIDE:
+			*value_ptr = sAttribs.uiStrideInBytes;
+			break;
+		case __DRI_IMAGE_ATTRIB_HANDLE:
+			value = PVRDRIBufferGetHandle(shared->psBuffer);
+			if (value == -1)
+			{
+				return GL_FALSE;
+			}
+
+			*value_ptr = value;
+			break;
+		case __DRI_IMAGE_ATTRIB_NAME:
+			value = PVRDRIBufferGetName(shared->psBuffer);
+			if (value == -1)
+			{
+				return GL_FALSE;
+			}
+
+			*value_ptr = value;
+			break;
+		case __DRI_IMAGE_ATTRIB_FORMAT:
+			if (!shared->psFormat)
+			{
+				return GL_FALSE;
+			}
+
+			*value_ptr = shared->psFormat->iDRIFormat;
+			break;
+		case __DRI_IMAGE_ATTRIB_WIDTH:
+			*value_ptr = sAttribs.uiWidth;
+			break;
+		case __DRI_IMAGE_ATTRIB_HEIGHT:
+			*value_ptr = sAttribs.uiHeight;
+			break;
+		case __DRI_IMAGE_ATTRIB_COMPONENTS:
+			if (!shared->psFormat || !shared->psFormat->iDRIComponents)
+			{
+				return GL_FALSE;
+			}
+
+			*value_ptr = shared->psFormat->iDRIComponents;
+			break;
+		case __DRI_IMAGE_ATTRIB_FD:
+			value = PVRDRIBufferGetFd(shared->psBuffer);
+			if (value == -1)
+			{
+				return GL_FALSE;
+			}
+
+			*value_ptr = value;
+			break;
+		case __DRI_IMAGE_ATTRIB_FOURCC:
+			*value_ptr = shared->psFormat->iDRIFourCC;
+			break;
+		case __DRI_IMAGE_ATTRIB_NUM_PLANES:
+			*value_ptr = (int)shared->psFormat->uiNumPlanes;
+			break;
+		case __DRI_IMAGE_ATTRIB_OFFSET:
+			*value_ptr = PVRDRIBufferGetOffset(shared->psBuffer);
+			break;
+		case __DRI_IMAGE_ATTRIB_MODIFIER_LOWER:
+			ulValue = PVRDRIBufferGetModifier(shared->psBuffer);
+			*value_ptr = (int)(ulValue & 0xffffffff);
+			break;
+		case __DRI_IMAGE_ATTRIB_MODIFIER_UPPER:
+			ulValue = PVRDRIBufferGetModifier(shared->psBuffer);
+			*value_ptr = (int)((ulValue >> 32) & 0xffffffff);
+			break;
+		default:
+			return GL_FALSE;
+	}
+
+	return GL_TRUE;
+}
+
+__DRIimage *PVRDRIDupImage(__DRIimage *srcImage, void *loaderPrivate)
+{
+	__DRIimage *image;
+
+	image = CommonImageSetup(loaderPrivate);
+	if (!image)
+	{
+		return NULL;
+	}
+
+	image->psShared = RefImageShared(srcImage->psShared);
+
+	image->psEGLImage = PVRDRIEGLImageDup(srcImage->psEGLImage);
+	if (!image->psEGLImage)
+	{
+		PVRDRIDestroyImage(image);
+		return NULL;
+	}
+
+	PVRDRIEGLImageSetCallbackData(image->psEGLImage, image);
+
+	return image;
+}
+
+GLboolean PVRDRIValidateUsage(__DRIimage *image, unsigned int use)
+{
+	struct PVRDRIImageShared *shared = image->psShared;
+	__DRIscreen *screen = shared->psPVRScreen->psDRIScreen;
+
+	if (use & (__DRI_IMAGE_USE_SCANOUT | __DRI_IMAGE_USE_CURSOR))
+	{
+		uint64_t modifier;
+
+		/*
+		 * We are extra strict in this case as an application may ask for a
+		 * handle so that the memory can be wrapped as a framebuffer/used as
+		 * a cursor and this can only be done on a card node.
+		 */
+		if (drmGetNodeTypeFromFd(screen->fd) != DRM_NODE_PRIMARY)
+		{
+			return GL_FALSE;
+		}
+
+		modifier = PVRDRIBufferGetModifier(shared->psBuffer);
+
+		if (modifier != DRM_FORMAT_MOD_INVALID &&
+			modifier != DRM_FORMAT_MOD_LINEAR)
+		{
+			return GL_FALSE;
+		}
+	}
+	else if (use & (__DRI_IMAGE_USE_SHARE))
+	{
+		/*
+		 * We are less strict in this case as it's possible to share buffers
+		 * using prime (but not flink) on a render node so we only need to know
+		 * whether or not the fd belongs to the display.
+		 */
+		if (PVRDRIGetDeviceTypeFromFd(screen->fd) != PVRDRI_DEVICE_TYPE_DISPLAY)
+		{
+			return GL_FALSE;
+		}
+	}
+
+	return GL_TRUE;
+}
+
+__DRIimage *PVRDRICreateImageFromNames(__DRIscreen *screen,
+				       int width, int height, int fourcc,
+				       int *names, int num_names,
+				       int *strides, int *offsets,
+				       void *loaderPrivate)
+{
+	__DRIimage *image;
+	int iStride;
+
+	image = CommonImageSetup(loaderPrivate);
+	if (!image)
+	{
+		return NULL;
+	}
+
+	image->psShared = CreateImageSharedFromNames(screen, width, height, fourcc,
+						     names, num_names, strides, offsets);
+	if (!image->psShared)
+	{
+		PVRDRIDestroyImage(image);
+		return NULL;
+	}
+
+	if (image->psShared->psFormat->uiNumPlanes == 1)
+	{
+		iStride = strides[0];
+	}
+	else
+	{
+		iStride = width * PVRDRIPixFmtGetBlockSize(image->psShared->psFormat->eIMGPixelFormat);
+	}
+
+	image->psEGLImage = PVRDRIEGLImageCreateFromBuffer(width, height,
+							    iStride,
+							    image->psShared->psFormat->eIMGPixelFormat,
+							    image->psShared->eColourSpace,
+							    image->psShared->eChromaUInterp,
+							    image->psShared->eChromaVInterp,
+							    image->psShared->psBuffer);
+	if (!image->psEGLImage)
+	{
+		PVRDRIDestroyImage(image);
+		return NULL;
+	}
+
+	PVRDRIEGLImageSetCallbackData(image->psEGLImage, image);
+
+	return image;
+}
+
+__DRIimage *PVRDRIFromPlanar(__DRIimage *srcImage, int plane,
+			     void *loaderPrivate)
+{
+	__DRIimage *image;
+
+	image = CommonImageSetup(loaderPrivate);
+	if (!image)
+	{
+		return NULL;
+	}
+
+	image->psShared = CreateImageSharedForSubImage(srcImage->psShared,
+						       plane);
+
+	if (!image->psShared)
+	{
+		if (plane != 0)
+		{
+			errorMessage("%s: plane %d not supported\n",
+				     __func__, plane);
+		}
+
+		image->psShared = RefImageShared(srcImage->psShared);
+
+		image->psEGLImage = PVRDRIEGLImageDup(srcImage->psEGLImage);
+	}
+	else
+	{
+		image->psEGLImage = PVRDRIEGLImageCreateFromSubBuffer(
+					image->psShared->psFormat->eIMGPixelFormat,
+					image->psShared->psBuffer);
+	}
+
+	if (!image->psEGLImage)
+	{
+		PVRDRIDestroyImage(image);
+		return NULL;
+	}
+
+	PVRDRIEGLImageSetCallbackData(image->psEGLImage, image);
+
+	return image;
+}
+
+__DRIimage *
+PVRDRICreateImageFromTexture(__DRIcontext *context,
+                             int glTarget,
+                             unsigned texture,
+                             int depth,
+                             int level,
+                             unsigned *error,
+                             void *loaderPrivate)
+{
+	PVRDRIContext *psPVRContext = context->driverPrivate;
+	__DRIscreen *screen = psPVRContext->psPVRScreen->psDRIScreen;
+	IMGEGLImage *psEGLImage;
+	__DRIimage *image;
+	uint32_t eglTarget;
+	unsigned e;
+
+	switch (glTarget)
+	{
+		case GL_TEXTURE_2D:
+			eglTarget = EGL_GL_TEXTURE_2D_KHR;
+			break;
+		case GL_TEXTURE_CUBE_MAP:
+			eglTarget = EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR + depth;
+			break;
+		default:
+			errorMessage("%s: GL Target %d is not supported\n", __func__, glTarget);
+			*error = __DRI_IMAGE_ERROR_BAD_PARAMETER;
+			return NULL;
+	}
+
+	image = CommonImageSetup(loaderPrivate);
+	if (!image)
+	{
+		return NULL;
+	}
+
+	psEGLImage = PVRDRIEGLImageCreate();
+	if (!psEGLImage)
+	{
+		PVRDRIDestroyImage(image);
+		return NULL;
+	}
+
+	e = PVRDRIGetImageSource(psPVRContext->eAPI,
+	                         psPVRContext->psPVRScreen->psImpl,
+	                         psPVRContext->psImpl,
+	                         eglTarget,
+	                         (uintptr_t)texture,
+	                         (uint32_t)level,
+	                         psEGLImage);
+	*error = e;
+
+	if (e != PVRDRI_IMAGE_ERROR_SUCCESS)
+	{
+		PVRDRIEGLImageFree(psEGLImage);
+		PVRDRIDestroyImage(image);
+		return NULL;
+	}
+
+	PVRDRIEGLImageSetCallbackData(psEGLImage, image);
+
+	/*
+	 * We can't destroy the image after this point, as the
+	 * texture now has a reference to it.
+	 */
+	image->psShared = CreateImageSharedFromEGLImage(screen,
+							psEGLImage,
+							PVRDRI_EGLIMAGE_IMGEGL);
+	if (!image->psShared)
+	{
+		return NULL;
+	}
+
+	image->psEGLImage = PVRDRIEGLImageDup(image->psShared->psEGLImage);
+	if (!image->psEGLImage)
+	{
+		return NULL;
+	}
+
+	image->iRefCount++;
+
+	return image;
+}
+
+__DRIimage *PVRDRICreateImageFromFds(__DRIscreen *screen,
+				     int width, int height, int fourcc,
+				     int *fds, int num_fds,
+				     int *strides, int *offsets,
+				     void *loaderPrivate)
+{
+	unsigned error;
+
+	return PVRDRICreateImageFromDmaBufs(screen, width, height, fourcc,
+					    fds, num_fds, strides, offsets,
+					    __DRI_YUV_COLOR_SPACE_UNDEFINED,
+					    __DRI_YUV_RANGE_UNDEFINED,
+					    __DRI_YUV_CHROMA_SITING_UNDEFINED,
+					    __DRI_YUV_CHROMA_SITING_UNDEFINED,
+					    &error,
+					    loaderPrivate);
+}
+
+__DRIimage *
+PVRDRICreateImageFromBuffer(__DRIcontext *context,
+                            int target,
+                            void *buffer,
+                            unsigned *error,
+                            void *loaderPrivate)
+{
+	PVRDRIContext *psPVRContext = context->driverPrivate;
+	__DRIscreen *screen = psPVRContext->psPVRScreen->psDRIScreen;
+	IMGEGLImage *psEGLImage;
+	__DRIimage *image;
+
+	switch (target)
+	{
+#if defined(EGL_CL_IMAGE_IMG)
+		case EGL_CL_IMAGE_IMG:
+			break;
+#endif
+		default:
+			errorMessage("%s: Target %d is not supported\n", __func__, target);
+			*error = __DRI_IMAGE_ERROR_BAD_PARAMETER;
+			return NULL;
+	}
+
+	image = CommonImageSetup(loaderPrivate);
+	if (!image)
+	{
+		return NULL;
+	}
+
+	psEGLImage = PVRDRIEGLImageCreate();
+	if (!psEGLImage)
+	{
+		PVRDRIDestroyImage(image);
+		return NULL;
+	}
+
+	*error = PVRDRIGetImageSource(PVRDRI_API_CL,
+				      psPVRContext->psPVRScreen->psImpl,
+				      psPVRContext->psImpl,
+				      target,
+				      (uintptr_t)buffer,
+				      0,
+				      psEGLImage);
+	if (*error != __DRI_IMAGE_ERROR_SUCCESS)
+	{
+		PVRDRIEGLImageFree(psEGLImage);
+		PVRDRIDestroyImage(image);
+		return NULL;
+	}
+
+	PVRDRIEGLImageSetCallbackData(psEGLImage, image);
+
+	/*
+	 * We can't destroy the image after this point, as the
+	 * OCL image now has a reference to it.
+	 */
+	image->psShared = CreateImageSharedFromEGLImage(screen,
+							psEGLImage,
+							PVRDRI_EGLIMAGE_IMGOCL);
+	if (!image->psShared)
+	{
+		return NULL;
+	}
+
+	image->psEGLImage = PVRDRIEGLImageDup(image->psShared->psEGLImage);
+	if (!image->psEGLImage)
+	{
+		return NULL;
+	}
+
+	image->iRefCount++;
+
+	return image;
+}
+
+__DRIimage *PVRDRICreateImageFromDmaBufs2(__DRIscreen *screen,
+					  int width, int height, int fourcc,
+					  uint64_t modifier,
+					  int *fds, int num_fds,
+					  int *strides, int *offsets,
+					  enum __DRIYUVColorSpace color_space,
+					  enum __DRISampleRange sample_range,
+					  enum __DRIChromaSiting horiz_siting,
+					  enum __DRIChromaSiting vert_siting,
+					  unsigned *error,
+					  void *loaderPrivate)
+{
+	__DRIimage *image;
+
+	image = CommonImageSetup(loaderPrivate);
+	if (!image)
+	{
+		*error = __DRI_IMAGE_ERROR_BAD_ALLOC;
+		return NULL;
+	}
+
+	image->psShared = CreateImageSharedFromDmaBufs(screen, width, height, fourcc,
+						       modifier,
+						       fds, num_fds, strides, offsets,
+						       color_space, sample_range,
+						       horiz_siting, vert_siting,
+						       error);
+	if (!image->psShared)
+	{
+		PVRDRIDestroyImage(image);
+		return NULL;
+	}
+
+	image->psEGLImage = PVRDRIEGLImageCreateFromBuffer(width, height,
+							    strides[0],
+							    image->psShared->psFormat->eIMGPixelFormat,
+							    image->psShared->eColourSpace,
+							    image->psShared->eChromaUInterp,
+							    image->psShared->eChromaVInterp,
+							    image->psShared->psBuffer);
+	if (!image->psEGLImage)
+	{
+		PVRDRIDestroyImage(image);
+		*error = __DRI_IMAGE_ERROR_BAD_ALLOC;
+		return NULL;
+	}
+
+	PVRDRIEGLImageSetCallbackData(image->psEGLImage, image);
+
+	*error = __DRI_IMAGE_ERROR_SUCCESS;
+
+	return image;
+}
+
+__DRIimage *PVRDRICreateImageFromDmaBufs(__DRIscreen *screen,
+                                         int width, int height, int fourcc,
+                                         int *fds, int num_fds,
+                                         int *strides, int *offsets,
+                                         enum __DRIYUVColorSpace color_space,
+                                         enum __DRISampleRange sample_range,
+                                         enum __DRIChromaSiting horiz_siting,
+                                         enum __DRIChromaSiting vert_siting,
+                                         unsigned *error,
+                                         void *loaderPrivate)
+{
+	return PVRDRICreateImageFromDmaBufs2(screen,
+					     width, height, fourcc,
+					     DRM_FORMAT_MOD_INVALID,
+					     fds, num_fds,
+					     strides, offsets,
+					     color_space,
+					     sample_range,
+					     horiz_siting,
+					     vert_siting,
+					     error,
+					     loaderPrivate);
+}
+
+void PVRDRIRefImage(__DRIimage *image)
+{
+	int iRefCount = p_atomic_inc_return(&image->iRefCount);
+
+	(void)iRefCount;
+	assert(iRefCount > 1);
+}
+
+void PVRDRIUnrefImage(__DRIimage *image)
+{
+	PVRDRIDestroyImage(image);
+}
+
+PVRDRIImageType PVRDRIImageGetSharedType(__DRIimage *image)
+{
+	return image->psShared->eType;
+}
+
+PVRDRIBufferImpl *PVRDRIImageGetSharedBuffer(__DRIimage *pImage)
+{
+	assert(pImage->psShared->eType != PVRDRI_IMAGE_FROM_EGLIMAGE);
+
+	return pImage->psShared->psBuffer;
+}
+
+IMGEGLImage *PVRDRIImageGetSharedEGLImage(__DRIimage *pImage)
+{
+	assert(pImage->psShared->eType == PVRDRI_IMAGE_FROM_EGLIMAGE);
+	return pImage->psShared->psEGLImage;
+}
+
+IMGEGLImage *PVRDRIImageGetEGLImage(__DRIimage *pImage)
+{
+	return pImage->psEGLImage;
+}
+
+__DRIimage *PVRDRIScreenGetDRIImage(void *hEGLImage)
+{
+	PVRDRIScreen *psPVRScreen = PVRDRIThreadGetCurrentScreen();
+
+	if (!psPVRScreen)
+	{
+		return NULL;
+	}
+
+	return psPVRScreen->psDRIScreen->dri2.image->lookupEGLImage(
+	      psPVRScreen->psDRIScreen,
+	      hEGLImage,
+	      psPVRScreen->psDRIScreen->loaderPrivate);
+}
+
+void PVRDRIBlitImage(__DRIcontext *context,
+		     __DRIimage *dst, __DRIimage *src,
+		     int dstx0, int dsty0, int dstwidth, int dstheight,
+		     int srcx0, int srcy0, int srcwidth, int srcheight,
+		     int flush_flag)
+{
+	PVRDRIContext *psPVRContext = context->driverPrivate;
+	bool res;
+
+	res = PVRDRIBlitEGLImage(psPVRContext->psPVRScreen->psImpl,
+			psPVRContext->psImpl,
+			dst->psEGLImage, dst->psShared->psBuffer,
+			src->psEGLImage, src->psShared->psBuffer,
+			dstx0, dsty0, dstwidth, dstheight,
+			srcx0, srcy0, srcwidth, srcheight,
+			flush_flag);
+	
+
+	if (!res)
+	{
+		__driUtilMessage("%s: PVRDRIBlitEGLImage failed\n", __func__);
+	}
+}
+
+int PVRDRIGetCapabilities(__DRIscreen *screen)
+{
+	(void) screen;
+
+	return __DRI_IMAGE_CAP_GLOBAL_NAMES;
+}
+
+void *PVRDRIMapImage(__DRIcontext *context, __DRIimage *image,
+		    int x0, int y0, int width, int height,
+		    unsigned int flags, int *stride, void **data)
+{
+	PVRDRIContext *psPVRContext = context->driverPrivate;
+
+	return PVRDRIMapEGLImage(psPVRContext->psPVRScreen->psImpl,
+				 psPVRContext->psImpl,
+				 image->psEGLImage, image->psShared->psBuffer,
+				 x0, y0, width, height, flags, stride, data);
+}
+
+void PVRDRIUnmapImage(__DRIcontext *context, __DRIimage *image, void *data)
+{
+	PVRDRIContext *psPVRContext = context->driverPrivate;
+	bool res;
+
+	res = PVRDRIUnmapEGLImage(psPVRContext->psPVRScreen->psImpl,
+			      psPVRContext->psImpl,
+			      image->psEGLImage, image->psShared->psBuffer,
+			      data);
+	if (!res)
+	{
+		__driUtilMessage("%s: PVRDRIUnmapEGLImage failed\n", __func__);
+	}
+}
diff --git a/src/mesa/drivers/dri/pvr/pvrimage.h b/src/mesa/drivers/dri/pvr/pvrimage.h
new file mode 100644
index 00000000000..9316ea3bedf
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrimage.h
@@ -0,0 +1,131 @@
+/* -*- mode: c; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* vi: set ts=8 sw=8 sts=8: */
+/*
+ * 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(__PVRIMAGE_H__)
+#define __PVRIMAGE_H__
+
+#include "dri_support.h"
+
+__DRIimage *PVRDRICreateImageFromName(__DRIscreen *screen,
+				      int width, int height, int format,
+				      int name, int pitch,
+				      void *loaderPrivate);
+
+__DRIimage *PVRDRICreateImageFromRenderbuffer(__DRIcontext *context,
+					      int renderbuffer,
+					      void *loaderPrivate);
+
+void PVRDRIDestroyImage(__DRIimage *image);
+
+__DRIimage *PVRDRICreateImage(__DRIscreen *screen,
+			      int width, int height, int format,
+			      unsigned int use,
+			      void *loaderPrivate);
+
+__DRIimage *PVRDRICreateImageWithModifiers(__DRIscreen *screen,
+			      int width, int height, int format,
+			      const uint64_t *modifiers,
+			      const unsigned int modifier_count,
+			      void *loaderPrivate);
+
+GLboolean PVRDRIQueryImage(__DRIimage *image, int attrib, int *value);
+
+__DRIimage *PVRDRIDupImage(__DRIimage *image, void *loaderPrivate);
+
+GLboolean PVRDRIValidateUsage(__DRIimage *image, unsigned int use);
+
+__DRIimage *PVRDRICreateImageFromNames(__DRIscreen *screen,
+				       int width, int height, int fourcc,
+				       int *names, int num_names,
+				       int *strides, int *offsets,
+				       void *loaderPrivate);
+
+__DRIimage *PVRDRIFromPlanar(__DRIimage *image, int plane,
+			     void *loaderPrivate);
+
+__DRIimage *PVRDRICreateImageFromTexture(__DRIcontext *context,
+					 int glTarget,
+					 unsigned texture,
+					 int depth,
+					 int level,
+					 unsigned *error,
+					 void *loaderPrivate);
+
+__DRIimage *PVRDRICreateImageFromFds(__DRIscreen *screen,
+				     int width, int height, int fourcc,
+				     int *fds, int num_fds,
+				     int *strides, int *offsets,
+				     void *loaderPrivate);
+
+__DRIimage *PVRDRICreateImageFromBuffer(__DRIcontext *context,
+					int target,
+					void *buffer,
+					unsigned *error,
+					void *loaderPrivate);
+
+__DRIimage *PVRDRICreateImageFromDmaBufs(__DRIscreen *screen,
+                                         int width, int height, int fourcc,
+                                         int *fds, int num_fds,
+                                         int *strides, int *offsets,
+                                         enum __DRIYUVColorSpace color_space,
+                                         enum __DRISampleRange sample_range,
+                                         enum __DRIChromaSiting horiz_siting,
+                                         enum __DRIChromaSiting vert_siting,
+                                         unsigned *error,
+                                         void *loaderPrivate);
+
+__DRIimage *PVRDRICreateImageFromDmaBufs2(__DRIscreen *screen,
+					  int width, int height, int fourcc,
+					  uint64_t modifier,
+					  int *fds, int num_fds,
+					  int *strides, int *offsets,
+					  enum __DRIYUVColorSpace color_space,
+					  enum __DRISampleRange sample_range,
+					  enum __DRIChromaSiting horiz_siting,
+					  enum __DRIChromaSiting vert_siting,
+					  unsigned *error,
+					  void *loaderPrivate);
+
+void PVRDRIBlitImage(__DRIcontext *context,
+		     __DRIimage *dst, __DRIimage *src,
+		     int dstx0, int dsty0, int dstwidth, int dstheight,
+		     int srcx0, int srcy0, int srcwidth, int srcheight,
+		     int flush_flag);
+
+int PVRDRIGetCapabilities(__DRIscreen *screen);
+
+void *PVRDRIMapImage(__DRIcontext *context, __DRIimage *image,
+		    int x0, int y0, int width, int height,
+		    unsigned int flags, int *stride, void **data);
+
+void PVRDRIUnmapImage(__DRIcontext *context, __DRIimage *image, void *data);
+
+__DRIimage *PVRDRICreateImageFromRenderbuffer2(__DRIcontext *context,
+					       int renderbuffer,
+					       void *loaderPrivate,
+					       unsigned *error);
+
+#endif /* !defined(__PVRIMAGE_H__) */
diff --git a/src/mesa/drivers/dri/pvr/pvrmesa.h b/src/mesa/drivers/dri/pvr/pvrmesa.h
new file mode 100644
index 00000000000..6e0fd8d296a
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrmesa.h
@@ -0,0 +1,41 @@
+/* -*- mode: c; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* vi: set ts=8 sw=8 sts=8: */
+/*
+ * 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..b0e5d260341
--- /dev/null
+++ b/src/mesa/drivers/dri/pvr/pvrutil.c
@@ -0,0 +1,1067 @@
+/* -*- mode: c; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* vi: set ts=8 sw=8 sts=8: */
+/*
+ * 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 <stdarg.h>
+#include <stdio.h>
+#include <stdlib.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, ##args)
+#define dbg_printf(f, args...) fprintf(stderr, "LibGL: " f "\n", ##args)
+#endif /* HAVE_ANDROID_PLATFORM */
+
+#define	PVRDRIMesaFormatEntry(f) {f, PVRDRI_ ## f }
+
+static const struct
+{
+	mesa_format eMesa;
+	unsigned uPVRDRI;
+} g_asMesaFormats[] = {
+	PVRDRIMesaFormatEntry(MESA_FORMAT_B8G8R8A8_UNORM),
+	PVRDRIMesaFormatEntry(MESA_FORMAT_B8G8R8X8_UNORM),
+#ifdef HAVE_ANDROID_PLATFORM
+	PVRDRIMesaFormatEntry(MESA_FORMAT_R8G8B8A8_UNORM),
+	PVRDRIMesaFormatEntry(MESA_FORMAT_R8G8B8X8_UNORM),
+#endif
+	PVRDRIMesaFormatEntry(MESA_FORMAT_B5G6R5_UNORM),
+};
+
+/* See pvrdri.h for documentation on PVRDRIImageFormat */
+static const PVRDRIImageFormat g_asFormats[] =
+{
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_R10G10B10A2_UNORM,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_ABGR2101010,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_ABGR2101010,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_RGBA,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+			.eIMGPixelFormat = IMG_PIXFMT_R10G10B10A2_UNORM,
+			.uiWidthShift = 0,
+			.uiHeightShift = 0
+		},
+	},
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_B8G8R8A8_UNORM,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_ARGB8888,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_ARGB8888,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_RGBA,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_B8G8R8A8_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_R8G8B8A8_UNORM,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_ABGR8888,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_ABGR8888,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_RGBA,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8G8B8A8_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_B8G8R8X8_UNORM,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_XRGB8888,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_XRGB8888,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_RGB,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_B8G8R8X8_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_R8G8B8X8_UNORM,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_XBGR8888,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_XBGR8888,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_RGB,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8G8B8X8_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_B5G6R5_UNORM,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_RGB565,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_RGB565,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_RGB,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_B5G6R5_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_R8G8_UNORM,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_GR88,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_GR88,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_RG,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8G8_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_R8_UNORM,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_R8,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_R8,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_R,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+		{
+		.eIMGPixelFormat = IMG_PIXFMT_L8A8_UNORM,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_GR88,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_GR88,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_RG,
+		.bQueryDmaBufFormatsExclude = true,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_L8A8_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_L8_UNORM,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_R8,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_R8,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_R,
+		.bQueryDmaBufFormatsExclude = true,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_L8_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_D32_FLOAT,
+		.iDRIFourCC = 0,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_NONE,
+		.iDRIComponents = 0,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_D32_FLOAT,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_S8_UINT,
+		.iDRIFourCC = 0,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_NONE,
+		.iDRIComponents = 0,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_S8_UINT,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+#if defined(__DRI_IMAGE_FORMAT_ARGB4444)
+	/* We patch this format into Mesa */
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_B4G4R4A4_UNORM,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_ARGB4444,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_ARGB4444,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_RGBA,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_B4G4R4A4_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+#endif
+#if defined(__DRI_IMAGE_FORMAT_ARGB1555)
+	/* We patch this format into Mesa */
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_B5G5R5A1_UNORM,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_ARGB1555,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_ARGB1555,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_RGBA,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_B5G5R5A1_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+#endif
+#if defined(__DRI_IMAGE_COMPONENTS_EXTERNAL)
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_YUYV,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_YUYV,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_YUYV,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_EXTERNAL,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+			.eIMGPixelFormat = IMG_PIXFMT_YUYV,
+			.uiWidthShift = 0,
+			.uiHeightShift = 0
+		},
+	},
+#if defined(__DRI_IMAGE_FOURCC_YVU444_PACK10_IMG)
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_YVU10_444_1PLANE_PACK10,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_YVU444_PACK10_IMG,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_YVU444_PACK10_IMG,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_EXTERNAL,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+			.eIMGPixelFormat = IMG_PIXFMT_YVU10_444_1PLANE_PACK10,
+			.uiWidthShift = 0,
+			.uiHeightShift = 0,
+		},
+	},
+#endif
+#endif
+#if defined(__DRI_IMAGE_FOURCC_MT21)
+	/* We patch this format into Mesa */
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_YVU8_420_2PLANE_PACK8_P,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_MT21,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_NONE,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_Y_UV,
+		.uiNumPlanes = 2,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+		.sPlanes[1] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8G8_UNORM,
+				.uiWidthShift = 1,
+				.uiHeightShift = 1
+		},
+	},
+#endif
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_YUV420_2PLANE,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_NV12,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_NONE,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_Y_UV,
+		.uiNumPlanes = 2,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+		.sPlanes[1] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8G8_UNORM,
+				.uiWidthShift = 1,
+				.uiHeightShift = 1
+		},
+	},
+#if defined(__DRI_IMAGE_FOURCC_NV21)
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_YVU420_2PLANE,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_NV21,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_NONE,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_Y_UV,
+		.uiNumPlanes = 2,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+		.sPlanes[1] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8G8_UNORM,
+				.uiWidthShift = 1,
+				.uiHeightShift = 1
+		},
+	},
+#endif
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_YUV420_3PLANE,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_YUV420,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_NONE,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_Y_U_V,
+		.uiNumPlanes = 3,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+		.sPlanes[1] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8_UNORM,
+				.uiWidthShift = 1,
+				.uiHeightShift = 1
+		},
+		.sPlanes[2] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8_UNORM,
+				.uiWidthShift = 1,
+				.uiHeightShift = 1
+		},
+	},
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_YVU420_3PLANE,
+		.iDRIFourCC = __DRI_IMAGE_FOURCC_YVU420,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_NONE,
+		.iDRIComponents = __DRI_IMAGE_COMPONENTS_Y_U_V,
+		.uiNumPlanes = 3,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+		.sPlanes[1] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8_UNORM,
+				.uiWidthShift = 1,
+				.uiHeightShift = 1
+		},
+		.sPlanes[2] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_R8_UNORM,
+				.uiWidthShift = 1,
+				.uiHeightShift = 1
+		},
+	},
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_D16_UNORM,
+		.iDRIFourCC = 0,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_NONE,
+		.iDRIComponents = 0,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_D16_UNORM,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+	{
+		.eIMGPixelFormat = IMG_PIXFMT_D24_UNORM_X8_TYPELESS,
+		.iDRIFourCC = 0,
+		.iDRIFormat = __DRI_IMAGE_FORMAT_NONE,
+		.iDRIComponents = 0,
+		.uiNumPlanes = 1,
+		.sPlanes[0] =
+		{
+				.eIMGPixelFormat = IMG_PIXFMT_D24_UNORM_X8_TYPELESS,
+				.uiWidthShift = 0,
+				.uiHeightShift = 0
+		},
+	},
+};
+
+/*
+ * Check if a PVR Screen has support for a particular format based upon its
+ * position in g_asFormats. If querying of this information isn't supported
+ * by pvr_dri_support then assume the format is supported.
+ */
+static inline bool
+PVRDRIScreenHasFormatFromIdx(const PVRDRIScreen * const psPVRScreen,
+			     const unsigned int uiFormatIdx)
+{
+	if (psPVRScreen->iNumFormats > 0)
+	{
+		if (uiFormatIdx < ARRAY_SIZE(g_asFormats))
+		{
+			return psPVRScreen->pbHasFormat[uiFormatIdx];
+		}
+
+		return false;
+	}
+
+	assert(psPVRScreen->iNumFormats == -1);
+
+	return true;
+}
+
+/* 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);
+}
+
+const __DRIconfig **PVRDRICreateConfigs(void)
+{
+	static const GLenum asBackBufferModes[]	= { __DRI_ATTRIB_SWAP_NONE, __DRI_ATTRIB_SWAP_UNDEFINED };
+	const uint8_t *puDepthBits = PVRDRIDepthBitsArray();
+	const uint8_t *puStencilBits = PVRDRIStencilBitsArray();
+	const uint8_t *puMSAASamples = PVRDRIMSAABitsArray();
+	const unsigned uNumBackBufferModes = ARRAY_SIZE(asBackBufferModes);
+	const unsigned uNumDepthStencilBits = PVRDRIDepthStencilBitArraySize();
+	const unsigned uNumMSAASamples = PVRDRIMSAABitArraySize();
+	__DRIconfig **ppsConfigs = NULL;
+	__DRIconfig **ppsNewConfigs;
+	unsigned i;
+
+	for (i = 0; i < ARRAY_SIZE(g_asMesaFormats); i++)
+	{
+		if (!PVRDRIMesaFormatSupported(g_asMesaFormats[i].uPVRDRI))
+			continue;
+
+		ppsNewConfigs = driCreateConfigs(g_asMesaFormats[i].eMesa,
+						 puDepthBits,
+						 puStencilBits,
+						 uNumDepthStencilBits, 
+						 asBackBufferModes,
+						 uNumBackBufferModes, 
+						 puMSAASamples,
+						 uNumMSAASamples,
+						 GL_FALSE,
+						 GL_FALSE,
+						 GL_FALSE
+#if defined(__DRI_ATTRIB_YUV_BIT)
+						 , __DRI_ATTRIB_YUV_DEPTH_RANGE_NONE,
+						 __DRI_ATTRIB_YUV_CSC_STANDARD_NONE
+#endif
+						 );
+
+		ppsConfigs = driConcatConfigs(ppsConfigs, ppsNewConfigs);
+	}
+
+	if (ppsConfigs)
+	{
+		for (i = 0; ppsConfigs[i]; i++)
+		{
+			ppsConfigs[i]->modes.maxPbufferWidth =
+						PVRDRIMaxPBufferWidth();
+			ppsConfigs[i]->modes.maxPbufferHeight =
+						PVRDRIMaxPBufferHeight();
+
+			ppsConfigs[i]->modes.maxPbufferPixels =
+						PVRDRIMaxPBufferWidth() *
+						PVRDRIMaxPBufferHeight();
+		}
+	}
+
+	return (const __DRIconfig **)ppsConfigs;
+}
+
+const PVRDRIImageFormat *PVRDRIFormatToImageFormat(PVRDRIScreen *psPVRScreen,
+						   int iDRIFormat)
+{
+	unsigned i;
+
+	assert(iDRIFormat != __DRI_IMAGE_FORMAT_NONE);
+
+	for (i = 0; i < ARRAY_SIZE(g_asFormats); i++)
+	{
+		if (g_asFormats[i].iDRIFormat != iDRIFormat)
+		{
+			continue;
+		}
+
+		if (!PVRDRIScreenHasFormatFromIdx(psPVRScreen, i))
+		{
+			break;
+		}
+
+		return &g_asFormats[i];
+	}
+
+	return NULL;
+}
+
+const PVRDRIImageFormat *PVRDRIFourCCToImageFormat(PVRDRIScreen *psPVRScreen,
+						   int iDRIFourCC)
+{
+	unsigned i;
+
+	if (!iDRIFourCC)
+	{
+		return NULL;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(g_asFormats); i++)
+	{
+		if (g_asFormats[i].iDRIFourCC != iDRIFourCC)
+		{
+			continue;
+		}
+
+		if (!PVRDRIScreenHasFormatFromIdx(psPVRScreen, i))
+		{
+			break;
+		}
+
+		return &g_asFormats[i];
+	}
+
+	return NULL;
+}
+
+const PVRDRIImageFormat *PVRDRIIMGPixelFormatToImageFormat(PVRDRIScreen *psPVRScreen,
+							   IMG_PIXFMT eIMGPixelFormat)
+{
+	unsigned i;
+
+	assert(eIMGPixelFormat != IMG_PIXFMT_UNKNOWN);
+
+	for (i = 0; i < ARRAY_SIZE(g_asFormats); i++)
+	{
+		if (g_asFormats[i].eIMGPixelFormat != eIMGPixelFormat)
+		{
+			continue;
+		}
+
+		/*
+		 * Assume that the screen has the format, i.e. it's supported by
+		 * the HW+SW, since we can only have an IMG_PIXFMT from having
+		 * called one of the other PVRDRI*ToImageFormat functions or
+		 * one of the pvr_dri_support functions.
+		 */
+		assert(PVRDRIScreenHasFormatFromIdx(psPVRScreen, i));
+
+		return &g_asFormats[i];
+	}
+
+	return NULL;
+}
+
+/*
+ * The EGL_EXT_image_dma_buf_import says that if a hint is unspecified then
+ * the implementation may guess based on the pixel format or may fallback
+ * to some default value. Furthermore, if a hint is unsupported then the
+ * implementation may use whichever settings it wants to achieve the closest
+ * match.
+ */
+IMG_YUV_COLORSPACE PVRDRIToIMGColourSpace(const PVRDRIImageFormat *psFormat,
+					  enum __DRIYUVColorSpace eDRIColourSpace,
+					  enum __DRISampleRange eDRISampleRange)
+{
+	switch (psFormat->iDRIComponents)
+	{
+		case __DRI_IMAGE_COMPONENTS_R:
+		case __DRI_IMAGE_COMPONENTS_RG:
+		case __DRI_IMAGE_COMPONENTS_RGB:
+		case __DRI_IMAGE_COMPONENTS_RGBA:
+			return IMG_COLORSPACE_UNDEFINED;
+		case __DRI_IMAGE_COMPONENTS_Y_U_V:
+		case __DRI_IMAGE_COMPONENTS_Y_UV:
+		case __DRI_IMAGE_COMPONENTS_Y_XUXV:
+#if defined(__DRI_IMAGE_COMPONENTS_EXTERNAL)
+		case __DRI_IMAGE_COMPONENTS_EXTERNAL:
+#endif
+			break;
+		default:
+			errorMessage("Unrecognised DRI components (components = 0x%X)\n",
+				     psFormat->iDRIComponents);
+			unreachable("unhandled DRI component");
+			return IMG_COLORSPACE_UNDEFINED;
+	}
+
+	switch (eDRIColourSpace)
+	{
+		case __DRI_YUV_COLOR_SPACE_UNDEFINED:
+		case __DRI_YUV_COLOR_SPACE_ITU_REC601:
+			switch (eDRISampleRange)
+			{
+				case __DRI_YUV_RANGE_UNDEFINED:
+				case __DRI_YUV_NARROW_RANGE:
+					return IMG_COLORSPACE_BT601_CONFORMANT_RANGE;
+				case __DRI_YUV_FULL_RANGE:
+					return IMG_COLORSPACE_BT601_FULL_RANGE;
+				default:
+					errorMessage("Unrecognised DRI sample range (sample range = 0x%X)\n",
+						     eDRISampleRange);
+					unreachable("unhandled sample range");
+					return IMG_COLORSPACE_UNDEFINED;
+			}
+		case __DRI_YUV_COLOR_SPACE_ITU_REC709:
+			switch (eDRISampleRange)
+			{
+				case __DRI_YUV_RANGE_UNDEFINED:
+				case __DRI_YUV_NARROW_RANGE:
+					return IMG_COLORSPACE_BT709_CONFORMANT_RANGE;
+				case __DRI_YUV_FULL_RANGE:
+					return IMG_COLORSPACE_BT709_FULL_RANGE;
+				default:
+					errorMessage("Unrecognised DRI sample range (sample range = 0x%X)\n",
+						     eDRISampleRange);
+					unreachable("unhandled sample range");
+					return IMG_COLORSPACE_UNDEFINED;
+			}
+		case __DRI_YUV_COLOR_SPACE_ITU_REC2020:
+			switch (eDRISampleRange)
+			{
+				case __DRI_YUV_RANGE_UNDEFINED:
+				case __DRI_YUV_NARROW_RANGE:
+					return IMG_COLORSPACE_BT2020_CONFORMANT_RANGE;
+				case __DRI_YUV_FULL_RANGE:
+					return IMG_COLORSPACE_BT2020_FULL_RANGE;
+				default:
+					errorMessage("Unrecognised DRI sample range (sample range = 0x%X)\n",
+						     eDRISampleRange);
+					assert(0);
+					return IMG_COLORSPACE_UNDEFINED;
+			}
+		default:
+			errorMessage("Unrecognised DRI colour space (colour space = 0x%X)\n",
+				     eDRIColourSpace);
+			unreachable("unhandled color space");
+			return IMG_COLORSPACE_UNDEFINED;
+	}
+}
+
+IMG_YUV_CHROMA_INTERP PVRDRIChromaSittingToIMGInterp(const PVRDRIImageFormat *psFormat,
+						     enum __DRIChromaSiting eChromaSitting)
+{
+	switch (psFormat->iDRIComponents)
+	{
+		case __DRI_IMAGE_COMPONENTS_R:
+		case __DRI_IMAGE_COMPONENTS_RG:
+		case __DRI_IMAGE_COMPONENTS_RGB:
+		case __DRI_IMAGE_COMPONENTS_RGBA:
+			return IMG_CHROMA_INTERP_UNDEFINED;
+		case __DRI_IMAGE_COMPONENTS_Y_U_V:
+		case __DRI_IMAGE_COMPONENTS_Y_UV:
+		case __DRI_IMAGE_COMPONENTS_Y_XUXV:
+#if defined(__DRI_IMAGE_COMPONENTS_EXTERNAL)
+		case __DRI_IMAGE_COMPONENTS_EXTERNAL:
+#endif
+			break;
+		default:
+			errorMessage("Unrecognised DRI components (components = 0x%X)\n",
+				     psFormat->iDRIComponents);
+			unreachable("unhandled dri component");
+			return IMG_CHROMA_INTERP_UNDEFINED;
+	}
+
+	switch (eChromaSitting)
+	{
+		case __DRI_YUV_CHROMA_SITING_UNDEFINED:
+		case __DRI_YUV_CHROMA_SITING_0:
+			return IMG_CHROMA_INTERP_ZERO;
+		case __DRI_YUV_CHROMA_SITING_0_5:
+			return IMG_CHROMA_INTERP_HALF;
+		default:
+			errorMessage("Unrecognised DRI chroma sitting (chroma sitting = 0x%X)\n",
+				     eChromaSitting);
+			unreachable("unhandled chroma sitting");
+			return IMG_CHROMA_INTERP_UNDEFINED;
+	}
+}
+
+bool PVRDRIGetSupportedFormats(PVRDRIScreen *psPVRScreen)
+{
+	int *piFormats;
+	IMG_PIXFMT *peImgFormats;
+	bool bRet = false;
+	unsigned i;
+
+	piFormats = malloc(ARRAY_SIZE(g_asFormats) * sizeof(*piFormats));
+	peImgFormats = malloc(ARRAY_SIZE(g_asFormats) * sizeof(*peImgFormats));
+
+	psPVRScreen->pbHasFormat = malloc(ARRAY_SIZE(g_asFormats) *
+					  sizeof(*psPVRScreen->pbHasFormat));
+
+	psPVRScreen->psModifiers = calloc(ARRAY_SIZE(g_asFormats),
+					   sizeof(*psPVRScreen->psModifiers));
+
+	if (!piFormats || !peImgFormats ||
+	    !psPVRScreen->pbHasFormat || !psPVRScreen->psModifiers)
+	{
+		errorMessage("Out of memory\n");
+
+		goto err_free;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(g_asFormats); i++)
+	{
+		piFormats[i] = g_asFormats[i].bQueryDmaBufFormatsExclude ?
+			       0 : g_asFormats[i].iDRIFourCC;
+
+		peImgFormats[i] = g_asFormats[i].eIMGPixelFormat;
+
+		psPVRScreen->psModifiers[i].iNumModifiers = -1;
+	}
+
+	psPVRScreen->iNumFormats =
+			PVRDRIQuerySupportedFormats(psPVRScreen->psImpl,
+						    ARRAY_SIZE(g_asFormats),
+						    piFormats,
+						    peImgFormats,
+						    psPVRScreen->pbHasFormat);
+	if (psPVRScreen->iNumFormats == 0)
+	{
+		__driUtilMessage("Couldn't query supported pixel formats\n");
+		goto err_free;
+	}
+
+	bRet = true;
+	goto cleanup;
+
+err_free:
+	free(psPVRScreen->psModifiers);
+	psPVRScreen->psModifiers = NULL;
+
+	free(psPVRScreen->pbHasFormat);
+	psPVRScreen->pbHasFormat = NULL;
+cleanup:
+	free(peImgFormats);
+	free(piFormats);
+	return bRet;
+}
+
+GLboolean PVRDRIQueryDmaBufFormats(__DRIscreen *screen, int max,
+				   int *formats, int *count)
+{
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(screen);
+	int i, j;
+
+	assert(psPVRScreen->iNumFormats != 0);
+
+	if (psPVRScreen->iNumFormats < 0)
+	{
+		return GL_FALSE;
+	}
+
+	if (!max)
+	{
+		*count = psPVRScreen->iNumFormats;
+		return GL_TRUE;
+	}
+
+	for (i = 0, j = 0; i < ARRAY_SIZE(g_asFormats) && j < max; i++)
+	{
+		if (psPVRScreen->pbHasFormat[i])
+		{
+			formats[j++] = g_asFormats[i].iDRIFourCC;
+		}
+	}
+
+	*count = j;
+
+	return GL_TRUE;
+}
+
+static bool PVRDRIGetSupportedModifiers(PVRDRIScreen *psPVRScreen,
+					struct PVRDRIModifiers *psModifiers,
+					const PVRDRIImageFormat *psFormat)
+{
+	int iNumModifiers;
+
+	iNumModifiers = PVRDRIQueryModifiers(psPVRScreen->psImpl,
+					     psFormat->iDRIFourCC,
+					     psFormat->eIMGPixelFormat,
+					     NULL, NULL);
+	if (iNumModifiers < 0)
+	{
+		errorMessage("Couldn't query modifiers for format 0x%x\n",
+			     psFormat->iDRIFourCC);
+		return false;
+	}
+
+	psModifiers->puModifiers = malloc(iNumModifiers *
+					  sizeof(*psModifiers->puModifiers));
+	psModifiers->puExternalOnly = malloc(iNumModifiers *
+					  sizeof(*psModifiers->puExternalOnly));
+	if (!psModifiers->puModifiers || !psModifiers->puExternalOnly)
+	{
+		free(psModifiers->puModifiers);
+		psModifiers->puModifiers = NULL;
+
+		free(psModifiers->puExternalOnly);
+		psModifiers->puExternalOnly = NULL;
+
+		errorMessage("Out of memory\n");
+
+		return false;
+	}
+	psModifiers->iNumModifiers = iNumModifiers;
+
+	iNumModifiers = PVRDRIQueryModifiers(psPVRScreen->psImpl,
+					    psFormat->iDRIFourCC,
+					    psFormat->eIMGPixelFormat,
+					    psModifiers->puModifiers,
+					    psModifiers->puExternalOnly);
+
+	assert(iNumModifiers == psModifiers->iNumModifiers);
+
+	return true;
+}
+
+static bool PVRDRIGetModifiersForFormat(PVRDRIScreen *psPVRScreen,
+					int fourcc,
+					const PVRDRIImageFormat **ppsFormat,
+					const struct PVRDRIModifiers **ppsModifiers)
+{
+	const PVRDRIImageFormat *psFormat;
+	struct PVRDRIModifiers *psModifiers;
+	unsigned uIdx;
+
+	assert(psPVRScreen->iNumFormats != 0);
+
+	if (psPVRScreen->iNumFormats < 0)
+	{
+		return false;
+	}
+
+	psFormat = PVRDRIFourCCToImageFormat(psPVRScreen, fourcc);
+	if (!psFormat)
+	{
+		return false;
+	}
+
+	uIdx = psFormat - g_asFormats;
+	psModifiers = &psPVRScreen->psModifiers[uIdx];
+
+	if (psModifiers->iNumModifiers < 0)
+	{
+		if (!PVRDRIGetSupportedModifiers(psPVRScreen,
+						 psModifiers,
+						 psFormat))
+		{
+			return false;
+		}
+	}
+
+	*ppsFormat = psFormat;
+	*ppsModifiers = psModifiers;
+
+	return true;
+}
+
+bool PVRDRIValidateImageModifier(PVRDRIScreen *psPVRScreen, const int iFourcc,
+				 const uint64_t uiModifier)
+{
+	const PVRDRIImageFormat *psFormat;
+	const struct PVRDRIModifiers *psModifiers;
+
+	if (!PVRDRIGetModifiersForFormat(psPVRScreen, iFourcc, &psFormat,
+					 &psModifiers))
+	{
+		return false;
+	}
+
+	for (unsigned i = 0; i < psModifiers->iNumModifiers; i++)
+	{
+		if (psModifiers->puModifiers[i] == uiModifier)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+GLboolean PVRDRIQueryDmaBufModifiers(__DRIscreen *screen, int fourcc,
+				     int max, uint64_t *modifiers,
+				     unsigned int *external_only,
+				     int *count)
+{
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(screen);
+	const PVRDRIImageFormat *psFormat;
+	const struct PVRDRIModifiers *psModifiers;
+	int num_copy;
+
+	if (!PVRDRIGetModifiersForFormat(psPVRScreen,
+					fourcc,
+					&psFormat,
+					&psModifiers))
+	{
+		return GL_FALSE;
+	}
+
+	if (!max)
+	{
+		*count = psModifiers->iNumModifiers;
+		return GL_TRUE;
+	}
+
+	num_copy = (max < psModifiers->iNumModifiers) ?
+			max : psModifiers->iNumModifiers;
+
+	if (modifiers)
+	{
+		(void) memcpy(modifiers,
+			      psModifiers->puModifiers,
+			      sizeof(*modifiers) * num_copy);
+	}
+
+	if (external_only)
+	{
+		(void) memcpy(external_only,
+			      psModifiers->puExternalOnly,
+			      sizeof(*external_only) * num_copy);
+	}
+
+	*count = num_copy;
+
+	return GL_TRUE;
+}
+
+GLboolean PVRDRIQueryDmaBufFormatModifierAttribs(__DRIscreen *screen,
+						 uint32_t fourcc,
+						 uint64_t modifier,
+						 int attrib,
+						 uint64_t *value)
+{
+	PVRDRIScreen *psPVRScreen = DRIScreenPrivate(screen);
+	const PVRDRIImageFormat *psFormat;
+	const struct PVRDRIModifiers *psModifiers;
+	int i;
+
+	if (!PVRDRIGetModifiersForFormat(psPVRScreen,
+					fourcc,
+					&psFormat,
+					&psModifiers))
+	{
+		return GL_FALSE;
+	}
+
+	for (i = 0; i < psModifiers->iNumModifiers; i++)
+	{
+		if (psModifiers->puModifiers[i] == modifier)
+		{
+			break;
+		}
+	}
+	if (i == psModifiers->iNumModifiers)
+	{
+		return GL_FALSE;
+	}
+
+	switch (attrib)
+	{
+		case __DRI_IMAGE_FORMAT_MODIFIER_ATTRIB_PLANE_COUNT:
+			*value = psFormat->uiNumPlanes;
+			break;
+		default:
+			return GL_FALSE;
+	}
+
+	return GL_TRUE;
+}
+
+void PVRDRIDestroyFormatInfo(PVRDRIScreen *psPVRScreen)
+{
+	unsigned i;
+
+	if (psPVRScreen->psModifiers)
+	{
+		for (i = 0; i < ARRAY_SIZE(g_asFormats); i++)
+		{
+			free(psPVRScreen->psModifiers[i].puModifiers);
+			free(psPVRScreen->psModifiers[i].puExternalOnly);
+		}
+		free(psPVRScreen->psModifiers);
+	}
+
+	free(psPVRScreen->pbHasFormat);
+}
diff --git a/src/meson.build b/src/meson.build
index ae094fccf6c..e5865ac2a9d 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -26,6 +26,7 @@ inc_src = include_directories('.')
 inc_gallium = include_directories('gallium/include')
 inc_gallium_aux = include_directories('gallium/auxiliary')
 inc_amd_common = include_directories('amd/common')
+inc_pvr = include_directories('mesa/main', 'mapi/glapi')
 
 libglsl_util = static_library(
   'glsl_util',
-- 
2.22.0