IKXCLOCK-1501 Upgrade to TI SGX Android OpenGL 1.12@2701748

  Initial codes of TI SGX DDK 1.12@2701748

Change-Id: I75a8f6521968346ea1b2ea9fa54817ba186442ce

1 files changed, 401 insertions, 461 deletions

diff --git a/drivers/gpu/pvr/services4/srvkm/env/linux/osfunc.c b/drivers/gpu/pvr/services4/srvkm/env/linux/osfunc.c
index ca405828173..f2803abc024 100644..100755
--- a/drivers/gpu/pvr/services4/srvkm/env/linux/osfunc.c
+++ b/drivers/gpu/pvr/services4/srvkm/env/linux/osfunc.c
@@ -49,7 +49,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 #include <asm/io.h>
 #include <asm/page.h>
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22))
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)) && (LINUX_VERSION_CODE < KERNEL_VERSION(3,2,0))
 #include <asm/system.h>
 #endif
 #include <asm/cacheflush.h>
@@ -66,6 +66,9 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include <linux/interrupt.h>
 #include <asm/hardirq.h>
 #include <linux/timer.h>
+#if defined(MEM_TRACK_INFO_DEBUG)
+#include <linux/time.h>
+#endif
 #include <linux/capability.h>
 #include <asm/uaccess.h>
 #include <linux/spinlock.h>
@@ -83,22 +86,19 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #include "pvrmmap.h"
 #include "mmap.h"
 #include "env_data.h"
-#include "proc.h"
 #include "mutex.h"
 #include "event.h"
 #include "linkage.h"
 #include "pvr_uaccess.h"
 #include "lock.h"
-#include <syslocal.h>
+#if defined(PVR_ANDROID_NATIVE_WINDOW_HAS_SYNC)
+#include "pvr_sync.h"
+#endif
 
 #if defined (SUPPORT_ION)
 #include "ion.h"
 #endif
 
-#if defined (CONFIG_X86_PAE)
-#error Physical Address Extension not supported with the driver
-#endif
-
 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27))
 #define ON_EACH_CPU(func, info, wait) on_each_cpu(func, info, wait)
 #else
@@ -123,21 +123,21 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #endif /* EMULATOR */
 
 #if !defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
-PVRSRV_ERROR OSAllocMem_Impl(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID *ppvCpuVAddr, IMG_HANDLE *phBlockAlloc)
+PVRSRV_ERROR OSAllocMem_Impl(IMG_UINT32 ui32Flags, IMG_SIZE_T uiSize, IMG_PVOID *ppvCpuVAddr, IMG_HANDLE *phBlockAlloc)
 #else
-PVRSRV_ERROR OSAllocMem_Impl(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID *ppvCpuVAddr, IMG_HANDLE *phBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line)
+PVRSRV_ERROR OSAllocMem_Impl(IMG_UINT32 ui32Flags, IMG_SIZE_T uiSize, IMG_PVOID *ppvCpuVAddr, IMG_HANDLE *phBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line)
 #endif
 {
     PVR_UNREFERENCED_PARAMETER(ui32Flags);
     PVR_UNREFERENCED_PARAMETER(phBlockAlloc);
 
-    if (ui32Size > PAGE_SIZE)
+    if (uiSize > PAGE_SIZE)
     {
         /* Try to allocate the memory using vmalloc */
 #if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
-        *ppvCpuVAddr = _VMallocWrapper(ui32Size, PVRSRV_HAP_CACHED, pszFilename, ui32Line);
+        *ppvCpuVAddr = _VMallocWrapper(uiSize, PVRSRV_HAP_CACHED, pszFilename, ui32Line);
 #else
-        *ppvCpuVAddr = VMallocWrapper(ui32Size, PVRSRV_HAP_CACHED);
+        *ppvCpuVAddr = VMallocWrapper(uiSize, PVRSRV_HAP_CACHED);
 #endif
         if (*ppvCpuVAddr)
         {
@@ -146,9 +146,9 @@ PVRSRV_ERROR OSAllocMem_Impl(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOI
     }
 
 #if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
-    *ppvCpuVAddr = _KMallocWrapper(ui32Size, GFP_KERNEL | __GFP_NOWARN, pszFilename, ui32Line);
+    *ppvCpuVAddr = _KMallocWrapper(uiSize, GFP_KERNEL | __GFP_NOWARN, pszFilename, ui32Line);
 #else
-    *ppvCpuVAddr = KMallocWrapper(ui32Size, GFP_KERNEL | __GFP_NOWARN);
+    *ppvCpuVAddr = KMallocWrapper(uiSize, GFP_KERNEL | __GFP_NOWARN);
 #endif
     if (!*ppvCpuVAddr)
     {
@@ -169,13 +169,13 @@ static inline int is_vmalloc_addr(const void *pvCpuVAddr)
 #endif /* (LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,24)) */
 
 #if !defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
-PVRSRV_ERROR OSFreeMem_Impl(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID pvCpuVAddr, IMG_HANDLE hBlockAlloc)
+PVRSRV_ERROR OSFreeMem_Impl(IMG_UINT32 ui32Flags, IMG_SIZE_T uiSize, IMG_PVOID pvCpuVAddr, IMG_HANDLE hBlockAlloc)
 #else
-PVRSRV_ERROR OSFreeMem_Impl(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID pvCpuVAddr, IMG_HANDLE hBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line)
+PVRSRV_ERROR OSFreeMem_Impl(IMG_UINT32 ui32Flags, IMG_SIZE_T uiSize, IMG_PVOID pvCpuVAddr, IMG_HANDLE hBlockAlloc, IMG_CHAR *pszFilename, IMG_UINT32 ui32Line)
 #endif
 {	
     PVR_UNREFERENCED_PARAMETER(ui32Flags);
-    PVR_UNREFERENCED_PARAMETER(ui32Size);
+    PVR_UNREFERENCED_PARAMETER(uiSize);
     PVR_UNREFERENCED_PARAMETER(hBlockAlloc);
 
     if (is_vmalloc_addr(pvCpuVAddr))
@@ -201,7 +201,7 @@ PVRSRV_ERROR OSFreeMem_Impl(IMG_UINT32 ui32Flags, IMG_UINT32 ui32Size, IMG_PVOID
 
 PVRSRV_ERROR
 OSAllocPages_Impl(IMG_UINT32 ui32AllocFlags,
-				  IMG_UINT32 ui32Size,
+				  IMG_SIZE_T uiSize,
 				  IMG_UINT32 ui32PageSize,
 				  IMG_PVOID pvPrivData,
 				  IMG_UINT32 ui32PrivDataLength,
@@ -223,27 +223,11 @@ OSAllocPages_Impl(IMG_UINT32 ui32AllocFlags,
     }
 #endif
 
-    if(ui32AllocFlags & PVRSRV_MEM_ION)
-    {
-        /* We'll only see HAP_SINGLE_PROCESS with MEM_ION */
-        BUG_ON((ui32AllocFlags & PVRSRV_HAP_MAPTYPE_MASK) != PVRSRV_HAP_SINGLE_PROCESS);
-
-        psLinuxMemArea = NewIONLinuxMemArea(ui32Size, ui32AllocFlags,
-											pvPrivData, ui32PrivDataLength);
-        if(!psLinuxMemArea)
-        {
-            return PVRSRV_ERROR_OUT_OF_MEMORY;
-        }
-
-        PVRMMapRegisterArea(psLinuxMemArea);
-        goto ExitSkipSwitch;
-    }
-
     switch(ui32AllocFlags & PVRSRV_HAP_MAPTYPE_MASK)
     {
         case PVRSRV_HAP_KERNEL_ONLY:
         {
-            psLinuxMemArea = NewVMallocLinuxMemArea(ui32Size, ui32AllocFlags);
+            psLinuxMemArea = NewVMallocLinuxMemArea(uiSize, ui32AllocFlags);
             if(!psLinuxMemArea)
             {
                 return PVRSRV_ERROR_OUT_OF_MEMORY;
@@ -255,7 +239,7 @@ OSAllocPages_Impl(IMG_UINT32 ui32AllocFlags,
             /* Currently PVRSRV_HAP_SINGLE_PROCESS implies that we dont need a
              * kernel virtual mapping, but will need a user space virtual mapping */
 
-            psLinuxMemArea = NewAllocPagesLinuxMemArea(ui32Size, ui32AllocFlags);
+            psLinuxMemArea = NewAllocPagesLinuxMemArea(uiSize, ui32AllocFlags);
             if(!psLinuxMemArea)
             {
                 return PVRSRV_ERROR_OUT_OF_MEMORY;
@@ -279,7 +263,7 @@ OSAllocPages_Impl(IMG_UINT32 ui32AllocFlags,
              * VIPT architectures. */
             ui32AllocFlags &= ~PVRSRV_HAP_CACHED;
 #endif
-            psLinuxMemArea = NewVMallocLinuxMemArea(ui32Size, ui32AllocFlags);
+            psLinuxMemArea = NewVMallocLinuxMemArea(uiSize, ui32AllocFlags);
             if(!psLinuxMemArea)
             {
                 return PVRSRV_ERROR_OUT_OF_MEMORY;
@@ -303,7 +287,6 @@ OSAllocPages_Impl(IMG_UINT32 ui32AllocFlags,
 		psLinuxMemArea->hBMHandle = hBMHandle;
 	}
 
-ExitSkipSwitch:
     *ppvCpuVAddr = LinuxMemAreaToCpuVAddr(psLinuxMemArea);
     *phOSMemHandle = psLinuxMemArea;
     
@@ -314,12 +297,12 @@ ExitSkipSwitch:
 
 
 PVRSRV_ERROR
-OSFreePages(IMG_UINT32 ui32AllocFlags, IMG_UINT32 ui32Bytes, IMG_VOID *pvCpuVAddr, IMG_HANDLE hOSMemHandle)
+OSFreePages(IMG_UINT32 ui32AllocFlags, IMG_SIZE_T uiBytes, IMG_VOID *pvCpuVAddr, IMG_HANDLE hOSMemHandle)
 {   
     LinuxMemArea *psLinuxMemArea;
     PVRSRV_ERROR eError;
     
-    PVR_UNREFERENCED_PARAMETER(ui32Bytes);
+    PVR_UNREFERENCED_PARAMETER(uiBytes);
     PVR_UNREFERENCED_PARAMETER(pvCpuVAddr);
     
     psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
@@ -334,9 +317,9 @@ OSFreePages(IMG_UINT32 ui32AllocFlags, IMG_UINT32 ui32Bytes, IMG_VOID *pvCpuVAdd
             if (eError != PVRSRV_OK)
             {
                 PVR_DPF((PVR_DBG_ERROR,
-                         "OSFreePages(ui32AllocFlags=0x%08X, ui32Bytes=%d, "
+                         "OSFreePages(ui32AllocFlags=0x%08X, ui32Bytes=%" SIZE_T_FMT_LEN "u, "
                                         "pvCpuVAddr=%p, hOSMemHandle=%p) FAILED!",
-                         ui32AllocFlags, ui32Bytes, pvCpuVAddr, hOSMemHandle));
+                         ui32AllocFlags, uiBytes, pvCpuVAddr, hOSMemHandle));
                 return eError;
             }
             break;
@@ -351,31 +334,11 @@ OSFreePages(IMG_UINT32 ui32AllocFlags, IMG_UINT32 ui32Bytes, IMG_VOID *pvCpuVAdd
     return PVRSRV_OK;
 }
 
-IMG_INT32
-OSGetMemMultiPlaneInfo(IMG_HANDLE hOSMemHandle, IMG_UINT32* pui32AddressOffsets,
-		IMG_UINT32* ui32NumAddrOffsets)
-{
-	LinuxMemArea *psLinuxMemArea  = (LinuxMemArea *)hOSMemHandle;
-
-	if(!ui32NumAddrOffsets)
-		return -1;
-
-	if(psLinuxMemArea->eAreaType == LINUX_MEM_AREA_ION)
-		return GetIONLinuxMemAreaInfo(psLinuxMemArea, pui32AddressOffsets, ui32NumAddrOffsets);
-
-	if(!pui32AddressOffsets)
-		return -1;
-
-	*pui32AddressOffsets = 0;
-	*ui32NumAddrOffsets = 1;
-
-	return psLinuxMemArea->ui32ByteSize;
-}
 
 PVRSRV_ERROR
 OSGetSubMemHandle(IMG_HANDLE hOSMemHandle,
-                  IMG_UINT32 ui32ByteOffset,
-                  IMG_UINT32 ui32Bytes,
+                  IMG_UINTPTR_T uiByteOffset,
+                  IMG_SIZE_T uiBytes,
                   IMG_UINT32 ui32Flags,
                   IMG_HANDLE *phOSMemHandleRet)
 {
@@ -384,7 +347,7 @@ OSGetSubMemHandle(IMG_HANDLE hOSMemHandle,
 
     psParentLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
     
-    psLinuxMemArea = NewSubLinuxMemArea(psParentLinuxMemArea, ui32ByteOffset, ui32Bytes);
+    psLinuxMemArea = NewSubLinuxMemArea(psParentLinuxMemArea, uiByteOffset, uiBytes);
     if(!psLinuxMemArea)
     {
         *phOSMemHandleRet = NULL;
@@ -436,11 +399,11 @@ OSReleaseSubMemHandle(IMG_VOID *hOSMemHandle, IMG_UINT32 ui32Flags)
 
 
 IMG_CPU_PHYADDR
-OSMemHandleToCpuPAddr(IMG_VOID *hOSMemHandle, IMG_UINT32 ui32ByteOffset)
+OSMemHandleToCpuPAddr(IMG_VOID *hOSMemHandle, IMG_UINTPTR_T uiByteOffset)
 {
     PVR_ASSERT(hOSMemHandle);
 
-    return LinuxMemAreaToCpuPAddr(hOSMemHandle, ui32ByteOffset);
+    return LinuxMemAreaToCpuPAddr(hOSMemHandle, uiByteOffset);
 }
 
 
@@ -471,7 +434,7 @@ IMG_BOOL OSMemHandleIsPhysContig(IMG_VOID *hOSMemHandle)
  @Return  none
 
 ******************************************************************************/
-IMG_VOID OSMemCopy(IMG_VOID *pvDst, IMG_VOID *pvSrc, IMG_UINT32 ui32Size)
+IMG_VOID OSMemCopy(IMG_VOID *pvDst, IMG_VOID *pvSrc, IMG_SIZE_T uiSize)
 {
 #if defined(USE_UNOPTIMISED_MEMCPY)
     IMG_UINT8 *Src,*Dst;
@@ -479,12 +442,12 @@ IMG_VOID OSMemCopy(IMG_VOID *pvDst, IMG_VOID *pvSrc, IMG_UINT32 ui32Size)
 
     Src=(IMG_UINT8 *)pvSrc;
     Dst=(IMG_UINT8 *)pvDst;
-    for(i=0;i<ui32Size;i++)
+    for(i=0;i<uiSize;i++)
     {
         Dst[i]=Src[i];
     }
 #else
-    memcpy(pvDst, pvSrc, ui32Size);
+    memcpy(pvDst, pvSrc, uiSize);
 #endif
 }
 
@@ -505,19 +468,19 @@ IMG_VOID OSMemCopy(IMG_VOID *pvDst, IMG_VOID *pvSrc, IMG_UINT32 ui32Size)
  @Return   IMG_VOID
 
 ******************************************************************************/
-IMG_VOID OSMemSet(IMG_VOID *pvDest, IMG_UINT8 ui8Value, IMG_UINT32 ui32Size)
+IMG_VOID OSMemSet(IMG_VOID *pvDest, IMG_UINT8 ui8Value, IMG_SIZE_T uiSize)
 {
 #if defined(USE_UNOPTIMISED_MEMSET)
     IMG_UINT8 *Buff;
     IMG_INT i;
 
     Buff=(IMG_UINT8 *)pvDest;
-    for(i=0;i<ui32Size;i++)
+    for(i=0;i<uiSize;i++)
     {
         Buff[i]=ui8Value;
     }
 #else
-    memset(pvDest, (IMG_INT) ui8Value, (size_t) ui32Size);
+    memset(pvDest, (IMG_INT) ui8Value, (size_t) uiSize);
 #endif
 }
 
@@ -537,13 +500,13 @@ IMG_CHAR *OSStringCopy(IMG_CHAR *pszDest, const IMG_CHAR *pszSrc)
  @Function	OSSNPrintf
  @Description snprintf
 ******************************************************************************/
-IMG_INT32 OSSNPrintf(IMG_CHAR *pStr, IMG_UINT32 ui32Size, const IMG_CHAR *pszFormat, ...)
+IMG_INT32 OSSNPrintf(IMG_CHAR *pStr, IMG_SIZE_T uiSize, const IMG_CHAR *pszFormat, ...)
 {
     va_list argList;
     IMG_INT32 iCount;
 
     va_start(argList, pszFormat);
-    iCount = vsnprintf(pStr, (size_t)ui32Size, pszFormat, argList);
+    iCount = vsnprintf(pStr, (size_t)uiSize, pszFormat, argList);
     va_end(argList);
 
     return iCount;
@@ -839,59 +802,22 @@ IMG_UINT32 OSGetCurrentProcessIDKM(IMG_VOID)
 #endif
 }
 
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0))
-int OSGetProcCmdline(IMG_UINT32 ui32PID, char * buffer, int buff_size)
-{
-	int res = 0;
-	unsigned int len;
-	struct task_struct *task = pid_task(find_vpid(ui32PID), PIDTYPE_PID);
-	struct mm_struct *mm = task ? get_task_mm(task) : IMG_NULL;
-	if (!mm)
-		goto out;
-	if (!mm->arg_end)
-		goto out_mm;	/* Shh! No looking before we're done */
-
-	len = mm->arg_end - mm->arg_start;
-
-	if (len > buff_size)
-		len = buff_size;
+#if defined(MEM_TRACK_INFO_DEBUG)
+/*!
+******************************************************************************
 
-	res = pvr_access_process_vm(task, mm->arg_start, buffer, len, 0);
+  @Function            OSGetCurrentTimeInUSecsKM
+ 
+  @Description Returns current time in usecs
 
-	// If the nul at the end of args has been overwritten, then
-	// assume application is using setproctitle(3).
-	if (res > 0 && buffer[res-1] != '\0' && len < buff_size) {
-		len = strnlen(buffer, res);
-		if (len < res) {
-		    res = len;
-		} else {
-			len = mm->env_end - mm->env_start;
-			if (len > buff_size - res)
-				len = buff_size - res;
-			res += pvr_access_process_vm(task, mm->env_start, buffer+res, len, 0);
-			res = strnlen(buffer, res);
-		}
-	}
-out_mm:
-	mmput(mm);
-out:
-	return res;
-}
+  @Return    ID of current process
 
-const char* OSGetPathBaseName(char * buffer, int buff_size)
+*****************************************************************************/
+IMG_UINT32 OSGetCurrentTimeInUSecsKM(IMG_VOID)
 {
-	const char *base_name = buffer;
-	while (1)
-	{
-		const char *next = strnchr(base_name, buff_size, '/');
-		if (!next)
-			break;
-
-		buff_size -= (next - base_name -1);
-		base_name = (next + 1);
-
-	}
-	return base_name;
+	struct timeval          tv;
+	do_gettimeofday(&tv);
+	return (tv.tv_sec * 1000000 + tv.tv_usec);
 }
 #endif
 
@@ -1197,6 +1123,10 @@ static void MISRWrapper(
 	SYS_DATA *psSysData  = (SYS_DATA *)psEnvData->pvMISRData;
 
 	PVRSRVMISR(psSysData);
+
+#if defined(PVR_ANDROID_NATIVE_WINDOW_HAS_SYNC)
+	PVRSyncUpdateAllSyncs();
+#endif
 }
 
 
@@ -1703,7 +1633,7 @@ IMG_CPU_PHYADDR OSMapLinToCPUPhys(IMG_HANDLE hOSMemHandle,
  ******************************************************************************/
 IMG_VOID *
 OSMapPhysToLin(IMG_CPU_PHYADDR BasePAddr,
-               IMG_UINT32 ui32Bytes,
+               IMG_SIZE_T uiBytes,
                IMG_UINT32 ui32MappingFlags,
                IMG_HANDLE *phOSMemHandle)
 {
@@ -1717,7 +1647,7 @@ OSMapPhysToLin(IMG_CPU_PHYADDR BasePAddr,
 	if(phOSMemHandle == IMG_NULL)
 	{
 		IMG_VOID *pvIORemapCookie;
-		pvIORemapCookie = IORemapWrapper(BasePAddr, ui32Bytes, ui32MappingFlags);
+		pvIORemapCookie = IORemapWrapper(BasePAddr, uiBytes, ui32MappingFlags);
 		if(pvIORemapCookie == IMG_NULL)
 		{
 		    return IMG_NULL;
@@ -1726,7 +1656,7 @@ OSMapPhysToLin(IMG_CPU_PHYADDR BasePAddr,
 	}
 	else
 	{
-		LinuxMemArea *psLinuxMemArea = NewIORemapLinuxMemArea(BasePAddr, ui32Bytes, ui32MappingFlags);
+		LinuxMemArea *psLinuxMemArea = NewIORemapLinuxMemArea(BasePAddr, uiBytes, ui32MappingFlags);
 
 		if(psLinuxMemArea == IMG_NULL)
 		{
@@ -1752,9 +1682,9 @@ OSMapPhysToLin(IMG_CPU_PHYADDR BasePAddr,
  @Return TRUE on success, else FALSE
 ******************************************************************************/
 IMG_BOOL
-OSUnMapPhysToLin(IMG_VOID *pvLinAddr, IMG_UINT32 ui32Bytes, IMG_UINT32 ui32MappingFlags, IMG_HANDLE hOSMemHandle)
+OSUnMapPhysToLin(IMG_VOID *pvLinAddr, IMG_SIZE_T uiBytes, IMG_UINT32 ui32MappingFlags, IMG_HANDLE hOSMemHandle)
 {
-    PVR_UNREFERENCED_PARAMETER(ui32Bytes);	
+    PVR_UNREFERENCED_PARAMETER(uiBytes);	
 
     if(ui32MappingFlags & PVRSRV_HAP_KERNEL_ONLY)
     {
@@ -1868,19 +1798,19 @@ RegisterExternalMem(IMG_SYS_PHYADDR *pBasePAddr,
 PVRSRV_ERROR
 OSRegisterMem(IMG_CPU_PHYADDR BasePAddr,
               IMG_VOID *pvCPUVAddr,
-              IMG_UINT32 ui32Bytes,
+              IMG_SIZE_T uiBytes,
               IMG_UINT32 ui32MappingFlags,
               IMG_HANDLE *phOSMemHandle)
 {
     IMG_SYS_PHYADDR SysPAddr = SysCpuPAddrToSysPAddr(BasePAddr);
 
-    return RegisterExternalMem(&SysPAddr, pvCPUVAddr, ui32Bytes, IMG_TRUE, ui32MappingFlags, phOSMemHandle);
+    return RegisterExternalMem(&SysPAddr, pvCPUVAddr, uiBytes, IMG_TRUE, ui32MappingFlags, phOSMemHandle);
 }
 
 
-PVRSRV_ERROR OSRegisterDiscontigMem(IMG_SYS_PHYADDR *pBasePAddr, IMG_VOID *pvCPUVAddr, IMG_UINT32 ui32Bytes, IMG_UINT32 ui32MappingFlags, IMG_HANDLE *phOSMemHandle)
+PVRSRV_ERROR OSRegisterDiscontigMem(IMG_SYS_PHYADDR *pBasePAddr, IMG_VOID *pvCPUVAddr, IMG_SIZE_T uBytes, IMG_UINT32 ui32MappingFlags, IMG_HANDLE *phOSMemHandle)
 {
-    return RegisterExternalMem(pBasePAddr, pvCPUVAddr, ui32Bytes, IMG_FALSE, ui32MappingFlags, phOSMemHandle);
+    return RegisterExternalMem(pBasePAddr, pvCPUVAddr, uBytes, IMG_FALSE, ui32MappingFlags, phOSMemHandle);
 }
 
 
@@ -1892,7 +1822,7 @@ PVRSRV_ERROR OSRegisterDiscontigMem(IMG_SYS_PHYADDR *pBasePAddr, IMG_VOID *pvCPU
 ******************************************************************************/
 PVRSRV_ERROR
 OSUnRegisterMem (IMG_VOID *pvCpuVAddr,
-                IMG_UINT32 ui32Bytes,
+                IMG_SIZE_T uiBytes,
                 IMG_UINT32 ui32MappingFlags,
                 IMG_HANDLE hOSMemHandle)
 {
@@ -1900,7 +1830,7 @@ OSUnRegisterMem (IMG_VOID *pvCpuVAddr,
     PVRSRV_ERROR eError;
 
     PVR_UNREFERENCED_PARAMETER(pvCpuVAddr);
-    PVR_UNREFERENCED_PARAMETER(ui32Bytes);
+    PVR_UNREFERENCED_PARAMETER(uiBytes);
 
     switch(ui32MappingFlags & PVRSRV_HAP_MAPTYPE_MASK)
     {
@@ -1912,8 +1842,8 @@ OSUnRegisterMem (IMG_VOID *pvCpuVAddr,
             eError = PVRMMapRemoveRegisteredArea(psLinuxMemArea);
             if (eError != PVRSRV_OK)
             {
-                 PVR_DPF((PVR_DBG_ERROR, "%s(%p, %d, 0x%08X, %p) FAILED!",
-                          __FUNCTION__, pvCpuVAddr, ui32Bytes,
+                 PVR_DPF((PVR_DBG_ERROR, "%s(%p, %" SIZE_T_FMT_LEN "u, 0x%08X, %p) FAILED!",
+                          __FUNCTION__, pvCpuVAddr, uiBytes,
                           ui32MappingFlags, hOSMemHandle));
                 return eError;
             }
@@ -1931,9 +1861,9 @@ OSUnRegisterMem (IMG_VOID *pvCpuVAddr,
     return PVRSRV_OK;
 }
 
-PVRSRV_ERROR OSUnRegisterDiscontigMem(IMG_VOID *pvCpuVAddr, IMG_UINT32 ui32Bytes, IMG_UINT32 ui32Flags, IMG_HANDLE hOSMemHandle)
+PVRSRV_ERROR OSUnRegisterDiscontigMem(IMG_VOID *pvCpuVAddr, IMG_SIZE_T uBytes, IMG_UINT32 ui32Flags, IMG_HANDLE hOSMemHandle)
 {
-    return OSUnRegisterMem(pvCpuVAddr, ui32Bytes, ui32Flags, hOSMemHandle);
+    return OSUnRegisterMem(pvCpuVAddr, uBytes, ui32Flags, hOSMemHandle);
 }
 
 /*!
@@ -1946,7 +1876,7 @@ PVRSRV_ERROR OSUnRegisterDiscontigMem(IMG_VOID *pvCpuVAddr, IMG_UINT32 ui32Bytes
 ******************************************************************************/
 PVRSRV_ERROR
 OSReservePhys(IMG_CPU_PHYADDR BasePAddr,
-              IMG_UINT32 ui32Bytes,
+              IMG_SIZE_T uiBytes,
               IMG_UINT32 ui32MappingFlags,
               IMG_HANDLE hBMHandle,
               IMG_VOID **ppvCpuVAddr,
@@ -1972,7 +1902,7 @@ OSReservePhys(IMG_CPU_PHYADDR BasePAddr,
              * mapping is required for the allocation and no user virtual
              * mappings are allowed: Note these eat into our limited kernel
              * virtual address space */
-            psLinuxMemArea = NewIORemapLinuxMemArea(BasePAddr, ui32Bytes, ui32MappingFlags);
+            psLinuxMemArea = NewIORemapLinuxMemArea(BasePAddr, uiBytes, ui32MappingFlags);
             if(!psLinuxMemArea)
             {
                 return PVRSRV_ERROR_BAD_MAPPING;
@@ -1983,7 +1913,7 @@ OSReservePhys(IMG_CPU_PHYADDR BasePAddr,
         {
             /* Currently this implies that we dont need a kernel virtual
              * mapping, but will need a user space virtual mapping */
-            psLinuxMemArea = NewIOLinuxMemArea(BasePAddr, ui32Bytes, ui32MappingFlags);
+            psLinuxMemArea = NewIOLinuxMemArea(BasePAddr, uiBytes, ui32MappingFlags);
             if(!psLinuxMemArea)
             {
                 return PVRSRV_ERROR_BAD_MAPPING;
@@ -2007,7 +1937,7 @@ OSReservePhys(IMG_CPU_PHYADDR BasePAddr,
              */
             ui32MappingFlags &= ~PVRSRV_HAP_CACHED;
 #endif
-            psLinuxMemArea = NewIORemapLinuxMemArea(BasePAddr, ui32Bytes, ui32MappingFlags);
+            psLinuxMemArea = NewIORemapLinuxMemArea(BasePAddr, uiBytes, ui32MappingFlags);
             if(!psLinuxMemArea)
             {
                 return PVRSRV_ERROR_BAD_MAPPING;
@@ -2048,7 +1978,7 @@ OSReservePhys(IMG_CPU_PHYADDR BasePAddr,
 ******************************************************************************/
 PVRSRV_ERROR
 OSUnReservePhys(IMG_VOID *pvCpuVAddr,
-                IMG_UINT32 ui32Bytes,
+                IMG_SIZE_T uiBytes,
                 IMG_UINT32 ui32MappingFlags,
                 IMG_HANDLE hOSMemHandle)
 {
@@ -2056,7 +1986,7 @@ OSUnReservePhys(IMG_VOID *pvCpuVAddr,
     PVRSRV_ERROR eError;
 
     PVR_UNREFERENCED_PARAMETER(pvCpuVAddr);
-    PVR_UNREFERENCED_PARAMETER(ui32Bytes);
+    PVR_UNREFERENCED_PARAMETER(uiBytes);
 
     psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
     
@@ -2070,8 +2000,8 @@ OSUnReservePhys(IMG_VOID *pvCpuVAddr,
             eError = PVRMMapRemoveRegisteredArea(psLinuxMemArea);
             if (eError != PVRSRV_OK)
             {
-                 PVR_DPF((PVR_DBG_ERROR, "%s(%p, %d, 0x%08X, %p) FAILED!",
-                          __FUNCTION__, pvCpuVAddr, ui32Bytes,
+                 PVR_DPF((PVR_DBG_ERROR, "%s(%p, %" SIZE_T_FMT_LEN "u, 0x%08X, %p) FAILED!",
+                          __FUNCTION__, pvCpuVAddr, uiBytes,
                           ui32MappingFlags, hOSMemHandle));
                 return eError;
             }
@@ -2098,10 +2028,10 @@ OSUnReservePhys(IMG_VOID *pvCpuVAddr,
  @Output    ppvLinAddr - pointer to variable that will receive the linear address of buffer
  @Return PVRSRV_OK if allocation successed else returns PVRSRV_ERROR_OUT_OF_MEMORY
  **************************************************************************/
-PVRSRV_ERROR OSBaseAllocContigMemory(IMG_UINT32 ui32Size, IMG_CPU_VIRTADDR *pvLinAddr, IMG_CPU_PHYADDR *psPhysAddr)
+PVRSRV_ERROR OSBaseAllocContigMemory(IMG_SIZE_T uiSize, IMG_CPU_VIRTADDR *pvLinAddr, IMG_CPU_PHYADDR *psPhysAddr)
 {
 #if !defined(NO_HARDWARE)
-    PVR_UNREFERENCED_PARAMETER(ui32Size);
+    PVR_UNREFERENCED_PARAMETER(uiSize);
     PVR_UNREFERENCED_PARAMETER(pvLinAddr);
     PVR_UNREFERENCED_PARAMETER(psPhysAddr);
     PVR_DPF((PVR_DBG_ERROR, "%s: Not available", __FUNCTION__));
@@ -2118,9 +2048,9 @@ PVRSRV_ERROR OSBaseAllocContigMemory(IMG_UINT32 ui32Size, IMG_CPU_VIRTADDR *pvLi
     IMG_VOID *pvKernLinAddr;
 
 #if defined(DEBUG_LINUX_MEMORY_ALLOCATIONS)
-    pvKernLinAddr = _KMallocWrapper(ui32Size, GFP_KERNEL, __FILE__, __LINE__);
+    pvKernLinAddr = _KMallocWrapper(uiSize, GFP_KERNEL, __FILE__, __LINE__);
 #else
-    pvKernLinAddr = KMallocWrapper(ui32Size, GFP_KERNEL);
+    pvKernLinAddr = KMallocWrapper(uiSize, GFP_KERNEL);
 #endif
     if (!pvKernLinAddr)
     {
@@ -2142,16 +2072,16 @@ PVRSRV_ERROR OSBaseAllocContigMemory(IMG_UINT32 ui32Size, IMG_CPU_VIRTADDR *pvLi
  @Description Frees memory allocated with OSBaseAllocContigMemory
  @Input     LinAddr - pointer to buffer allocated with OSBaseAllocContigMemory
  **************************************************************************/
-PVRSRV_ERROR OSBaseFreeContigMemory(IMG_UINT32 ui32Size, IMG_CPU_VIRTADDR pvLinAddr, IMG_CPU_PHYADDR psPhysAddr)
+PVRSRV_ERROR OSBaseFreeContigMemory(IMG_SIZE_T uiSize, IMG_CPU_VIRTADDR pvLinAddr, IMG_CPU_PHYADDR psPhysAddr)
 {
 #if !defined(NO_HARDWARE)
-    PVR_UNREFERENCED_PARAMETER(ui32Size);
+    PVR_UNREFERENCED_PARAMETER(uiSize);
     PVR_UNREFERENCED_PARAMETER(pvLinAddr);
     PVR_UNREFERENCED_PARAMETER(psPhysAddr.uiAddr);
 
     PVR_DPF((PVR_DBG_WARNING, "%s: Not available", __FUNCTION__));
 #else
-    PVR_UNREFERENCED_PARAMETER(ui32Size);
+    PVR_UNREFERENCED_PARAMETER(uiSize);
     PVR_UNREFERENCED_PARAMETER(psPhysAddr.uiAddr);
 
     KFreeWrapper(pvLinAddr);
@@ -2762,9 +2692,9 @@ static void OSTimerCallbackBody(TIMER_CALLBACK_DATA *psTimerCBData)
  @Return   NONE
 
 ******************************************************************************/
-static IMG_VOID OSTimerCallbackWrapper(IMG_UINT32 ui32Data)
+static IMG_VOID OSTimerCallbackWrapper(IMG_UINTPTR_T uiData)
 {
-    TIMER_CALLBACK_DATA	*psTimerCBData = (TIMER_CALLBACK_DATA*)ui32Data;
+    TIMER_CALLBACK_DATA	*psTimerCBData = (TIMER_CALLBACK_DATA*)uiData;
     
 #if defined(PVR_LINUX_TIMERS_USING_WORKQUEUES) || defined(PVR_LINUX_TIMERS_USING_SHARED_WORKQUEUE)
     int res;
@@ -2814,7 +2744,7 @@ static void OSTimerWorkQueueCallBack(struct work_struct *psWork)
 IMG_HANDLE OSAddTimer(PFN_TIMER_FUNC pfnTimerFunc, IMG_VOID *pvData, IMG_UINT32 ui32MsTimeout)
 {
     TIMER_CALLBACK_DATA	*psTimerCBData;
-    IMG_UINT32		ui32i;
+    IMG_UINTPTR_T		ui;
 #if !(defined(PVR_LINUX_TIMERS_USING_WORKQUEUES) || defined(PVR_LINUX_TIMERS_USING_SHARED_WORKQUEUE))
     unsigned long		ulLockFlags;
 #endif
@@ -2832,9 +2762,9 @@ IMG_HANDLE OSAddTimer(PFN_TIMER_FUNC pfnTimerFunc, IMG_VOID *pvData, IMG_UINT32
 #else
     spin_lock_irqsave(&sTimerStructLock, ulLockFlags);
 #endif
-    for (ui32i = 0; ui32i < OS_MAX_TIMERS; ui32i++)
+    for (ui = 0; ui < OS_MAX_TIMERS; ui++)
     {
-        psTimerCBData = &sTimers[ui32i];
+        psTimerCBData = &sTimers[ui];
         if (!psTimerCBData->bInUse)
         {
             psTimerCBData->bInUse = IMG_TRUE;
@@ -2846,7 +2776,7 @@ IMG_HANDLE OSAddTimer(PFN_TIMER_FUNC pfnTimerFunc, IMG_VOID *pvData, IMG_UINT32
 #else
     spin_unlock_irqrestore(&sTimerStructLock, ulLockFlags);
 #endif
-    if (ui32i >= OS_MAX_TIMERS)
+    if (ui >= OS_MAX_TIMERS)
     {
         PVR_DPF((PVR_DBG_ERROR, "OSAddTimer: all timers are in use"));		
         return IMG_NULL;	
@@ -2870,19 +2800,19 @@ IMG_HANDLE OSAddTimer(PFN_TIMER_FUNC pfnTimerFunc, IMG_VOID *pvData, IMG_UINT32
     /* setup timer object */
     /* PRQA S 0307,0563 1 */ /* ignore warning about inconpartible ptr casting */
     psTimerCBData->sTimer.function = (IMG_VOID *)OSTimerCallbackWrapper;
-    psTimerCBData->sTimer.data = (IMG_UINT32)psTimerCBData;
+    psTimerCBData->sTimer.data = (IMG_UINTPTR_T)psTimerCBData;
     
-    return (IMG_HANDLE)(ui32i + 1);
+    return (IMG_HANDLE)(ui + 1);
 }
 
 
 static inline TIMER_CALLBACK_DATA *GetTimerStructure(IMG_HANDLE hTimer)
 {
-    IMG_UINT32 ui32i = ((IMG_UINT32)hTimer) - 1;
+    IMG_UINTPTR_T ui = ((IMG_UINTPTR_T)hTimer) - 1;
 
-    PVR_ASSERT(ui32i < OS_MAX_TIMERS);
+    PVR_ASSERT(ui < OS_MAX_TIMERS);
 
-    return &sTimers[ui32i];
+    return &sTimers[ui];
 }
 
 /*!
@@ -3016,11 +2946,7 @@ PVRSRV_ERROR OSDisableTimer (IMG_HANDLE hTimer)
  @Return   PVRSRV_ERROR  : 
 
 ******************************************************************************/
-#if defined (SUPPORT_SID_INTERFACE)
-PVRSRV_ERROR OSEventObjectCreateKM(const IMG_CHAR *pszName, PVRSRV_EVENTOBJECT_KM *psEventObject)
-#else
 PVRSRV_ERROR OSEventObjectCreateKM(const IMG_CHAR *pszName, PVRSRV_EVENTOBJECT *psEventObject)
-#endif
 {
 
     PVRSRV_ERROR eError = PVRSRV_OK;
@@ -3036,11 +2962,7 @@ PVRSRV_ERROR OSEventObjectCreateKM(const IMG_CHAR *pszName, PVRSRV_EVENTOBJECT *
         {
             /* autogenerate a name */	
             static IMG_UINT16 ui16NameIndex = 0;			
-#if defined (SUPPORT_SID_INTERFACE)
-            snprintf(psEventObject->szName, EVENTOBJNAME_MAXLENGTH, "PVRSRV_EVENTOBJECT_KM_%d", ui16NameIndex++);
-#else
             snprintf(psEventObject->szName, EVENTOBJNAME_MAXLENGTH, "PVRSRV_EVENTOBJECT_%d", ui16NameIndex++);
-#endif
         }
         
         if(LinuxEventObjectListCreate(&psEventObject->hOSEventKM) != PVRSRV_OK)
@@ -3074,11 +2996,7 @@ PVRSRV_ERROR OSEventObjectCreateKM(const IMG_CHAR *pszName, PVRSRV_EVENTOBJECT *
  @Return   PVRSRV_ERROR  : 
 
 ******************************************************************************/
-#if defined (SUPPORT_SID_INTERFACE)
-PVRSRV_ERROR OSEventObjectDestroyKM(PVRSRV_EVENTOBJECT_KM *psEventObject)
-#else
 PVRSRV_ERROR OSEventObjectDestroyKM(PVRSRV_EVENTOBJECT *psEventObject)
-#endif
 {
     PVRSRV_ERROR eError = PVRSRV_OK;
 
@@ -3149,11 +3067,7 @@ PVRSRV_ERROR OSEventObjectWaitKM(IMG_HANDLE hOSEventKM)
  @Return   PVRSRV_ERROR  : 
 
 ******************************************************************************/
-#if defined (SUPPORT_SID_INTERFACE)
-PVRSRV_ERROR OSEventObjectOpenKM(PVRSRV_EVENTOBJECT_KM *psEventObject,
-#else
 PVRSRV_ERROR OSEventObjectOpenKM(PVRSRV_EVENTOBJECT *psEventObject,
-#endif
                                             IMG_HANDLE *phOSEvent)
 {
     PVRSRV_ERROR eError = PVRSRV_OK;
@@ -3192,11 +3106,7 @@ PVRSRV_ERROR OSEventObjectOpenKM(PVRSRV_EVENTOBJECT *psEventObject,
  @Return   PVRSRV_ERROR  : 
 
 ******************************************************************************/
-#if defined (SUPPORT_SID_INTERFACE)
-PVRSRV_ERROR OSEventObjectCloseKM(PVRSRV_EVENTOBJECT_KM *psEventObject,
-#else
 PVRSRV_ERROR OSEventObjectCloseKM(PVRSRV_EVENTOBJECT *psEventObject,
-#endif
                                             IMG_HANDLE hOSEventKM)
 {
     PVRSRV_ERROR eError = PVRSRV_OK;
@@ -3291,11 +3201,11 @@ IMG_BOOL OSProcHasPrivSrvInit(IMG_VOID)
 PVRSRV_ERROR OSCopyToUser(IMG_PVOID pvProcess, 
                           IMG_VOID *pvDest, 
                           IMG_VOID *pvSrc, 
-                          IMG_UINT32 ui32Bytes)
+                          IMG_SIZE_T uiBytes)
 {
     PVR_UNREFERENCED_PARAMETER(pvProcess);
 
-    if(pvr_copy_to_user(pvDest, pvSrc, ui32Bytes)==0)
+    if(pvr_copy_to_user(pvDest, pvSrc, uiBytes)==0)
         return PVRSRV_OK;
     else
         return PVRSRV_ERROR_FAILED_TO_COPY_VIRT_MEMORY;
@@ -3322,11 +3232,11 @@ PVRSRV_ERROR OSCopyToUser(IMG_PVOID pvProcess,
 PVRSRV_ERROR OSCopyFromUser( IMG_PVOID pvProcess, 
                              IMG_VOID *pvDest, 
                              IMG_VOID *pvSrc, 
-                             IMG_UINT32 ui32Bytes)
+                             IMG_SIZE_T uiBytes)
 {
     PVR_UNREFERENCED_PARAMETER(pvProcess);
 
-    if(pvr_copy_from_user(pvDest, pvSrc, ui32Bytes)==0)
+    if(pvr_copy_from_user(pvDest, pvSrc, uiBytes)==0)
         return PVRSRV_OK;
     else
         return PVRSRV_ERROR_FAILED_TO_COPY_VIRT_MEMORY;
@@ -3350,7 +3260,7 @@ PVRSRV_ERROR OSCopyFromUser( IMG_PVOID pvProcess,
  @Return   IMG_BOOL :
 
 ******************************************************************************/
-IMG_BOOL OSAccessOK(IMG_VERIFY_TEST eVerification, IMG_VOID *pvUserPtr, IMG_UINT32 ui32Bytes)
+IMG_BOOL OSAccessOK(IMG_VERIFY_TEST eVerification, IMG_VOID *pvUserPtr, IMG_SIZE_T uiBytes)
 {
     IMG_INT linuxType;
 
@@ -3364,7 +3274,7 @@ IMG_BOOL OSAccessOK(IMG_VERIFY_TEST eVerification, IMG_VOID *pvUserPtr, IMG_UINT
         linuxType = VERIFY_WRITE;
     }
 
-    return access_ok(linuxType, pvUserPtr, ui32Bytes);
+    return access_ok(linuxType, pvUserPtr, uiBytes);
 }
 
 typedef enum _eWrapMemType_
@@ -3383,8 +3293,8 @@ typedef struct _sWrapMemInfo_
     IMG_SYS_PHYADDR *psPhysAddr;
     IMG_INT iPageOffset;
 #if defined(DEBUG)
-    IMG_UINT32 ulStartAddr;
-    IMG_UINT32 ulBeyondEndAddr;
+    IMG_UINTPTR_T uStartAddr;
+    IMG_UINTPTR_T uBeyondEndAddr;
     struct vm_area_struct *psVMArea;
 #endif
 } sWrapMemInfo;
@@ -3403,16 +3313,16 @@ typedef struct _sWrapMemInfo_
  and must be writable.  A get_page is done on the returned page structure.
  
  @Input    psVMArea - pointer to VM area structure
-       ulCPUVAddr - CPU virtual address
-       pulPFN - Pointer to returned PFN.
+       uCPUVAddr - CPU virtual address
+       pui32PFN - Pointer to returned PFN.
        ppsPAge - Pointer to returned page structure pointer.
 
- @Output   *pulPFN - Set to PFN
+ @Output   *pui32PFN - Set to PFN
  	   *ppsPage - Pointer to the page structure if present, else NULL.
  @Return   IMG_TRUE if PFN lookup was succesful.
 
 ******************************************************************************/
-static IMG_BOOL CPUVAddrToPFN(struct vm_area_struct *psVMArea, IMG_UINT32 ulCPUVAddr, IMG_UINT32 *pulPFN, struct page **ppsPage)
+static IMG_BOOL CPUVAddrToPFN(struct vm_area_struct *psVMArea, IMG_UINTPTR_T uCPUVAddr, IMG_UINT32 *pui32PFN, struct page **ppsPage)
 {
 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,10))
     pgd_t *psPGD;
@@ -3423,31 +3333,31 @@ static IMG_BOOL CPUVAddrToPFN(struct vm_area_struct *psVMArea, IMG_UINT32 ulCPUV
     spinlock_t *psPTLock;
     IMG_BOOL bRet = IMG_FALSE;
 
-    *pulPFN = 0;
+    *pui32PFN = 0;
     *ppsPage = NULL;
 
-    psPGD = pgd_offset(psMM, ulCPUVAddr);
+    psPGD = pgd_offset(psMM, uCPUVAddr);
     if (pgd_none(*psPGD) || pgd_bad(*psPGD))
         return bRet;
 
-    psPUD = pud_offset(psPGD, ulCPUVAddr);
+    psPUD = pud_offset(psPGD, uCPUVAddr);
     if (pud_none(*psPUD) || pud_bad(*psPUD))
         return bRet;
 
-    psPMD = pmd_offset(psPUD, ulCPUVAddr);
+    psPMD = pmd_offset(psPUD, uCPUVAddr);
     if (pmd_none(*psPMD) || pmd_bad(*psPMD))
         return bRet;
 
-    psPTE = (pte_t *)pte_offset_map_lock(psMM, psPMD, ulCPUVAddr, &psPTLock);
+    psPTE = (pte_t *)pte_offset_map_lock(psMM, psPMD, uCPUVAddr, &psPTLock);
 
     if ((pte_none(*psPTE) == 0) && (pte_present(*psPTE) != 0) && (pte_write(*psPTE) != 0))
     {
-        *pulPFN = pte_pfn(*psPTE);
+        *pui32PFN = pte_pfn(*psPTE);
 	bRet = IMG_TRUE;
 
-        if (pfn_valid(*pulPFN))
+        if (pfn_valid(*pui32PFN))
         {
-            *ppsPage = pfn_to_page(*pulPFN);
+            *ppsPage = pfn_to_page(*pui32PFN);
 
             get_page(*ppsPage);
         }
@@ -3600,7 +3510,7 @@ err_out:
 	return ui32PhysAddr;
 }
 
-#endif /* defined(CONFIG_TI_TILER) || defined(CONFIG_DRM_OMAP_DMM_TILER) */
+#endif /* defined(CONFIG_TI_TILER) && defined(CONFIG_DRM_OMAP_DMM_TILER) */
 
 /*!
 ******************************************************************************
@@ -3613,17 +3523,17 @@ err_out:
 
 ******************************************************************************/
 PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID *pvCPUVAddr, 
-                                    IMG_UINT32 ui32Bytes, 
+                                    IMG_SIZE_T uiBytes, 
                                     IMG_SYS_PHYADDR *psSysPAddr,
                                     IMG_HANDLE *phOSWrapMem)
 {
-    IMG_UINT32 ulStartAddrOrig = (IMG_UINT32) pvCPUVAddr;
-    IMG_UINT32 ulAddrRangeOrig = (IMG_UINT32) ui32Bytes;
-    IMG_UINT32 ulBeyondEndAddrOrig = ulStartAddrOrig + ulAddrRangeOrig;
-    IMG_UINT32 ulStartAddr;
-    IMG_UINT32 ulAddrRange;
-    IMG_UINT32 ulBeyondEndAddr;
-    IMG_UINT32 ulAddr;
+    IMG_UINTPTR_T uStartAddrOrig = (IMG_UINTPTR_T) pvCPUVAddr;
+    IMG_SIZE_T uAddrRangeOrig = uiBytes;
+    IMG_UINTPTR_T uBeyondEndAddrOrig = uStartAddrOrig + uAddrRangeOrig;
+    IMG_UINTPTR_T uStartAddr;
+    IMG_SIZE_T uAddrRange;
+    IMG_UINTPTR_T uBeyondEndAddr;
+    IMG_UINTPTR_T uAddr;
     IMG_INT i;
     struct vm_area_struct *psVMArea;
     sWrapMemInfo *psInfo = NULL;
@@ -3633,19 +3543,19 @@ PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID *pvCPUVAddr,
     PVRSRV_ERROR eError = PVRSRV_ERROR_OUT_OF_MEMORY;
 
     /* Align start and end addresses to page boundaries */
-    ulStartAddr = ulStartAddrOrig & PAGE_MASK;
-    ulBeyondEndAddr = PAGE_ALIGN(ulBeyondEndAddrOrig);
-    ulAddrRange = ulBeyondEndAddr - ulStartAddr;
+    uStartAddr = uStartAddrOrig & PAGE_MASK;
+    uBeyondEndAddr = PAGE_ALIGN(uBeyondEndAddrOrig);
+    uAddrRange = uBeyondEndAddr - uStartAddr;
 
     /*
      * Check for address range calculation overflow, and attempts to wrap
      * zero bytes.
      */
-    if (ulBeyondEndAddr <= ulStartAddr)
+    if (uBeyondEndAddr <= uStartAddr)
     {
         PVR_DPF((PVR_DBG_ERROR,
-            "OSAcquirePhysPageAddr: Invalid address range (start %x, length %x)",
-		ulStartAddrOrig, ulAddrRangeOrig));
+            "OSAcquirePhysPageAddr: Invalid address range (start " UINTPTR_FMT  ", length %" SIZE_T_FMT_LEN "x)",
+		uStartAddrOrig, uAddrRangeOrig));
         goto error;
     }
 
@@ -3660,12 +3570,12 @@ PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID *pvCPUVAddr,
     memset(psInfo, 0, sizeof(*psInfo));
 
 #if defined(DEBUG)
-    psInfo->ulStartAddr = ulStartAddrOrig;
-    psInfo->ulBeyondEndAddr = ulBeyondEndAddrOrig;
+    psInfo->uStartAddr = uStartAddrOrig;
+    psInfo->uBeyondEndAddr = uBeyondEndAddrOrig;
 #endif
 
-    psInfo->iNumPages = (IMG_INT)(ulAddrRange >> PAGE_SHIFT);
-    psInfo->iPageOffset = (IMG_INT)(ulStartAddrOrig & ~PAGE_MASK);
+    psInfo->iNumPages = (IMG_INT)(uAddrRange >> PAGE_SHIFT);
+    psInfo->iPageOffset = (IMG_INT)(uStartAddrOrig & ~PAGE_MASK);
 
     /* Allocate physical address array */
     psInfo->psPhysAddr = kmalloc((size_t)psInfo->iNumPages * sizeof(*psInfo->psPhysAddr), GFP_KERNEL);
@@ -3698,7 +3608,7 @@ PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID *pvCPUVAddr,
     bMMapSemHeld = IMG_TRUE;
 
     /* Get page list */
-    psInfo->iNumPagesMapped = get_user_pages(current, current->mm, ulStartAddr, psInfo->iNumPages, 1, 0, psInfo->ppsPages, NULL);
+    psInfo->iNumPagesMapped = get_user_pages(current, current->mm, uStartAddr, psInfo->iNumPages, 1, 0, psInfo->ppsPages, NULL);
 
     if (psInfo->iNumPagesMapped >= 0)
     {
@@ -3714,14 +3624,14 @@ PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID *pvCPUVAddr,
         for (i = 0; i < psInfo->iNumPages; i++)
         {
             IMG_CPU_PHYADDR CPUPhysAddr;
-	    IMG_UINT32 ulPFN;
+			IMG_UINT32 ui32PFN;
 
-            ulPFN = page_to_pfn(psInfo->ppsPages[i]);
-            CPUPhysAddr.uiAddr = ulPFN << PAGE_SHIFT;
-	    if ((CPUPhysAddr.uiAddr >> PAGE_SHIFT) != ulPFN)
+            ui32PFN = page_to_pfn(psInfo->ppsPages[i]);
+            CPUPhysAddr.uiAddr = ui32PFN << PAGE_SHIFT;
+	    if ((CPUPhysAddr.uiAddr >> PAGE_SHIFT) != ui32PFN)
 	    {
                 PVR_DPF((PVR_DBG_ERROR,
-		    "OSAcquirePhysPageAddr: Page frame number out of range (%x)", ulPFN));
+		    "OSAcquirePhysPageAddr: Page frame number out of range (%x)", ui32PFN));
 
 		    goto error;
 	    }
@@ -3749,11 +3659,12 @@ PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID *pvCPUVAddr,
     /* Set the mapping type to aid clean up */
     psInfo->eType = WRAP_TYPE_FIND_VMA;
 
-    psVMArea = find_vma(current->mm, ulStartAddrOrig);
+    psVMArea = find_vma(current->mm, uStartAddrOrig);
     if (psVMArea == NULL)
     {
         PVR_DPF((PVR_DBG_ERROR,
-            "OSAcquirePhysPageAddr: Couldn't find memory region containing start address %x", ulStartAddrOrig));
+            "OSAcquirePhysPageAddr: Couldn't find memory region containing start address " UINTPTR_FMT, 
+            uStartAddrOrig));
         
         goto error;
     }
@@ -3765,27 +3676,24 @@ PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID *pvCPUVAddr,
      * find_vma locates a region with an end point past a given
      * virtual address.  So check the address is actually in the region.
      */
-    if (ulStartAddrOrig < psVMArea->vm_start)
+    if (uStartAddrOrig < psVMArea->vm_start)
     {
         PVR_DPF((PVR_DBG_ERROR,
-            "OSAcquirePhysPageAddr: Start address %x is outside of the region returned by find_vma", ulStartAddrOrig));
+            "OSAcquirePhysPageAddr: Start address " UINTPTR_FMT " is outside of the region returned by find_vma", 
+            uStartAddrOrig));
         goto error;
     }
 
     /* Now check the end address is in range */
-    if (ulBeyondEndAddrOrig > psVMArea->vm_end)
+    if (uBeyondEndAddrOrig > psVMArea->vm_end)
     {
         PVR_DPF((PVR_DBG_ERROR,
-            "OSAcquirePhysPageAddr: End address %x is outside of the region returned by find_vma", ulBeyondEndAddrOrig));
+            "OSAcquirePhysPageAddr: End address " UINTPTR_FMT " is outside of the region returned by find_vma", uBeyondEndAddrOrig));
         goto error;
     }
 
     /* Does the region represent memory mapped I/O? */
-#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0))
-    if ((psVMArea->vm_flags & (VM_IO | VM_RESERVED)) != (VM_IO | VM_RESERVED))
-#else
-    if ((psVMArea->vm_flags & (VM_IO | VM_DONTEXPAND | VM_DONTDUMP)) != (VM_IO | VM_DONTEXPAND | VM_DONTDUMP))
-#endif
+    if (!(psVMArea->vm_flags & VM_IO))
     {
         PVR_DPF((PVR_DBG_ERROR,
             "OSAcquirePhysPageAddr: Memory region does not represent memory mapped I/O (VMA flags: 0x%lx)", psVMArea->vm_flags));
@@ -3800,14 +3708,14 @@ PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID *pvCPUVAddr,
         goto error;
     }
 
-    for (ulAddr = ulStartAddrOrig, i = 0; ulAddr < ulBeyondEndAddrOrig; ulAddr += PAGE_SIZE, i++)
+    for (uAddr = uStartAddrOrig, i = 0; uAddr < uBeyondEndAddrOrig; uAddr += PAGE_SIZE, i++)
     {
 	IMG_CPU_PHYADDR CPUPhysAddr;
-	IMG_UINT32 ulPFN = 0;
+	IMG_UINT32 ui32PFN = 0;
 
 	PVR_ASSERT(i < psInfo->iNumPages);
 
-	if (!CPUVAddrToPFN(psVMArea, ulAddr, &ulPFN, &psInfo->ppsPages[i]))
+	if (!CPUVAddrToPFN(psVMArea, uAddr, &ui32PFN, &psInfo->ppsPages[i]))
 	{
             PVR_DPF((PVR_DBG_ERROR,
 	       "OSAcquirePhysPageAddr: Invalid CPU virtual address"));
@@ -3818,7 +3726,7 @@ PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID *pvCPUVAddr,
 	{
 #if defined(CONFIG_TI_TILER) || defined(CONFIG_DRM_OMAP_DMM_TILER)
 		/* This could be tiler memory.*/
-		IMG_UINT32 ui32TilerAddr = CPUAddrToTilerPhy(ulAddr);
+		IMG_UINT32 ui32TilerAddr = CPUAddrToTilerPhy(uAddr);
 		if (ui32TilerAddr)
 		{
 			bHavePageStructs = IMG_TRUE;
@@ -3837,14 +3745,14 @@ PVRSRV_ERROR OSAcquirePhysPageAddr(IMG_VOID *pvCPUVAddr,
 
 	    psInfo->iNumPagesMapped++;
 
-	    PVR_ASSERT(ulPFN == page_to_pfn(psInfo->ppsPages[i]));
+	    PVR_ASSERT(ui32PFN == page_to_pfn(psInfo->ppsPages[i]));
 	}
 
-        CPUPhysAddr.uiAddr = ulPFN << PAGE_SHIFT;
-	if ((CPUPhysAddr.uiAddr >> PAGE_SHIFT) != ulPFN)
+        CPUPhysAddr.uiAddr = ui32PFN << PAGE_SHIFT;
+	if ((CPUPhysAddr.uiAddr >> PAGE_SHIFT) != ui32PFN)
 	{
                 PVR_DPF((PVR_DBG_ERROR,
-		    "OSAcquirePhysPageAddr: Page frame number out of range (%x)", ulPFN));
+		    "OSAcquirePhysPageAddr: Page frame number out of range (%x)", ui32PFN));
 
 		    goto error;
 	}
@@ -3912,64 +3820,105 @@ error:
     return eError;
 }
 
-typedef void (*InnerCacheOp_t)(const void *pvStart, const void *pvEnd);
-
-#if defined(__arm__) && (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39))
-typedef void (*OuterCacheOp_t)(phys_addr_t uStart, phys_addr_t uEnd);
+#if ! defined(__arm__)
+# define USE_VIRTUAL_CACHE_OP
+#elif LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0)
+# define USE_VIRTUAL_CACHE_OP
+# if defined(CONFIG_OUTER_CACHE)
+#  define USE_PHYSICAL_CACHE_OP
+# endif
 #else
-typedef void (*OuterCacheOp_t)(unsigned long ulStart, unsigned long ulEnd);
+# define USE_PHYSICAL_CACHE_OP
 #endif
 
-#if defined(CONFIG_OUTER_CACHE)
+extern PVRSRV_LINUX_MUTEX g_sMMapMutex;
+
+/* g_sMMapMutex must be held while this function is called */
+static
+IMG_VOID *FindMMapBaseVAddr(struct list_head *psMMapOffsetStructList,
+							IMG_VOID *pvRangeAddrStart, IMG_UINT32 ui32Length)
+{
+	PKV_OFFSET_STRUCT psOffsetStruct;
+	IMG_VOID *pvMinVAddr;
+
+	/* There's no kernel-virtual for this type of allocation, so if
+	 * we're flushing it, it must be user-virtual, and therefore
+	 * have a mapping.
+	 */
+	list_for_each_entry(psOffsetStruct, psMMapOffsetStructList, sAreaItem)
+	{
+		if(OSGetCurrentProcessIDKM() != psOffsetStruct->ui32PID)
+			continue;
+
+		pvMinVAddr = (IMG_VOID *)psOffsetStruct->uiUserVAddr;
 
+		/* Within permissible range */
+		if(pvRangeAddrStart >= pvMinVAddr &&
+		   ui32Length <= psOffsetStruct->uiRealByteSize)
+			return pvMinVAddr;
+	}
+
+	return IMG_NULL;
+}
+
+#if defined(USE_PHYSICAL_CACHE_OP)
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39)
+typedef void (*PhysicalCacheOp_t)(phys_addr_t uStart, phys_addr_t uEnd);
+#else
+typedef void (*PhysicalCacheOp_t)(unsigned long ulStart, unsigned long ulEnd);
+#endif
+
+/* 
+	Note: use IMG_CPU_PHYADDR to return CPU Phys Addresses, and not just 'unsigned long',
+	as this is not big enough to hold physical addresses on 32-bit PAE devices.
+*/
 typedef IMG_BOOL (*MemAreaToPhys_t)(LinuxMemArea *psLinuxMemArea,
-										 IMG_VOID *pvRangeAddrStart,
-										 IMG_UINT32 ui32PageNumOffset,
-										 IMG_UINT32 ui32PageNum,
-										 unsigned long *pulStart);
+                                    IMG_VOID *pvRangeAddrStart,
+                                    IMG_UINT32 ui32PageNumOffset,
+                                    IMG_UINT32 ui32PageNum,
+                                    IMG_CPU_PHYADDR *psStart);
 
 static IMG_BOOL VMallocAreaToPhys(LinuxMemArea *psLinuxMemArea,
-								  IMG_VOID *pvRangeAddrStart,
-								  IMG_UINT32 ui32PageNumOffset,
-								  IMG_UINT32 ui32PageNum,
-								  unsigned long *pulStart)
+                                  IMG_VOID *pvRangeAddrStart,
+                                  IMG_UINT32 ui32PageNumOffset,
+                                  IMG_UINT32 ui32PageNum,
+                                  IMG_CPU_PHYADDR *psStart)
 {
-	*pulStart = vmalloc_to_pfn(pvRangeAddrStart + ui32PageNum * PAGE_SIZE) << PAGE_SHIFT;
+	psStart->uiAddr = vmalloc_to_pfn(pvRangeAddrStart + ui32PageNum * PAGE_SIZE) << PAGE_SHIFT;
 	return IMG_TRUE;
 }
 
 static IMG_BOOL ExternalKVAreaToPhys(LinuxMemArea *psLinuxMemArea,
-									 IMG_VOID *pvRangeAddrStart,
-									 IMG_UINT32 ui32PageNumOffset,
-									 IMG_UINT32 ui32PageNum,
-									 unsigned long *pulStart)
+                                     IMG_VOID *pvRangeAddrStart,
+                                     IMG_UINT32 ui32PageNumOffset,
+                                     IMG_UINT32 ui32PageNum,
+                                     IMG_CPU_PHYADDR *psStart)
 {
 	IMG_SYS_PHYADDR SysPAddr;
-	IMG_CPU_PHYADDR CpuPAddr;
 	SysPAddr = psLinuxMemArea->uData.sExternalKV.uPhysAddr.pSysPhysAddr[ui32PageNumOffset + ui32PageNum];
-	CpuPAddr = SysSysPAddrToCpuPAddr(SysPAddr);
-	*pulStart = CpuPAddr.uiAddr;
+	*psStart = SysSysPAddrToCpuPAddr(SysPAddr);
 	return IMG_TRUE;
 }
 
 static IMG_BOOL AllocPagesAreaToPhys(LinuxMemArea *psLinuxMemArea,
-									 IMG_VOID *pvRangeAddrStart,
-									 IMG_UINT32 ui32PageNumOffset,
-									 IMG_UINT32 ui32PageNum,
-									 unsigned long *pulStart)
+                                     IMG_VOID *pvRangeAddrStart,
+                                     IMG_UINT32 ui32PageNumOffset,
+                                     IMG_UINT32 ui32PageNum,
+                                     IMG_CPU_PHYADDR *psStart)
 {
 	struct page *pPage;
 
 	pPage = psLinuxMemArea->uData.sPageList.ppsPageList[ui32PageNumOffset + ui32PageNum];
-	*pulStart = page_to_pfn(pPage) << PAGE_SHIFT;
+	psStart->uiAddr = page_to_pfn(pPage) << PAGE_SHIFT;
 	return IMG_TRUE;
 }
 
 static IMG_BOOL AllocPagesSparseAreaToPhys(LinuxMemArea *psLinuxMemArea,
-										   IMG_VOID *pvRangeAddrStart,
-										   IMG_UINT32 ui32PageNumOffset,
-										   IMG_UINT32 ui32PageNum,
-										   unsigned long *pulStart)
+                                           IMG_VOID *pvRangeAddrStart,
+                                           IMG_UINT32 ui32PageNumOffset,
+                                           IMG_UINT32 ui32PageNum,
+                                           IMG_CPU_PHYADDR *psStart)
 {
 	IMG_UINT32 ui32VirtOffset = (ui32PageNumOffset + ui32PageNum) << PAGE_SHIFT;
 	IMG_UINT32 ui32PhysOffset;
@@ -3979,82 +3928,80 @@ static IMG_BOOL AllocPagesSparseAreaToPhys(LinuxMemArea *psLinuxMemArea,
 	{
 		PVR_ASSERT(ui32PhysOffset <= ui32VirtOffset);
 		pPage = psLinuxMemArea->uData.sPageList.ppsPageList[ui32PhysOffset >> PAGE_SHIFT];
-		*pulStart = page_to_pfn(pPage) << PAGE_SHIFT;
+		psStart->uiAddr = page_to_pfn(pPage) << PAGE_SHIFT;
 		return IMG_TRUE;
 	}
 
 	return IMG_FALSE;
 }
 
-
-static IMG_BOOL IONAreaToPhys(LinuxMemArea *psLinuxMemArea,
-							  IMG_VOID *pvRangeAddrStart,
-							  IMG_UINT32 ui32PageNumOffset,
-							  IMG_UINT32 ui32PageNum,
-							  unsigned long *pulStart)
+static inline void DoPhysicalCacheOp(LinuxMemArea *psLinuxMemArea,
+                                     IMG_VOID *pvRangeAddrStart,
+                                     IMG_SIZE_T uiLength,
+                                     IMG_UINTPTR_T uPageNumOffset,
+                                     MemAreaToPhys_t pfnMemAreaToPhys,
+                                     PhysicalCacheOp_t pfnPhysicalCacheOp)
 {
-	IMG_CPU_PHYADDR CpuPAddr;
-	CpuPAddr = psLinuxMemArea->uData.sIONTilerAlloc.pCPUPhysAddrs[ui32PageNumOffset + ui32PageNum];
-	*pulStart = CpuPAddr.uiAddr;
-	return IMG_TRUE;
-}
-
-#endif /* defined(CONFIG_OUTER_CACHE) */
+	IMG_CPU_PHYADDR sStart, sEnd;
+	unsigned long ulLength, ulStartOffset, ulEndOffset;
+	IMG_UINT32 i, ui32NumPages;
+	IMG_BOOL bValidPage;
 
-/* g_sMMapMutex must be held while this function is called */
+	/* Length and offsets of flush region WRT page alignment */
+	ulLength = (unsigned long)uiLength;
+	ulStartOffset = ((unsigned long)pvRangeAddrStart) & (PAGE_SIZE - 1);
+	ulEndOffset = ((unsigned long)pvRangeAddrStart + ulLength) & (PAGE_SIZE - 1);
 
-static
-IMG_VOID *FindMMapBaseVAddr(struct list_head *psMMapOffsetStructList,
-							IMG_VOID *pvRangeAddrStart, IMG_UINT32 ui32Length)
-{
-	PKV_OFFSET_STRUCT psOffsetStruct;
-	IMG_VOID *pvMinVAddr;
+	/* The affected pages, rounded up */
+	ui32NumPages = (ulStartOffset + ulLength + PAGE_SIZE - 1) >> PAGE_SHIFT;
 
-	/* There's no kernel-virtual for this type of allocation, so if
-	 * we're flushing it, it must be user-virtual, and therefore
-	 * have a mapping.
-	 */
-	list_for_each_entry(psOffsetStruct, psMMapOffsetStructList, sAreaItem)
+	for(i = 0; i < ui32NumPages; i++)
 	{
-		if(OSGetCurrentProcessIDKM() != psOffsetStruct->ui32PID)
-			continue;
+		bValidPage = pfnMemAreaToPhys(psLinuxMemArea, pvRangeAddrStart,
+					      uPageNumOffset, i, &sStart);
+		if (bValidPage)
+		{
+			sEnd.uiAddr = sStart.uiAddr + PAGE_SIZE;
 
-		pvMinVAddr = (IMG_VOID *)psOffsetStruct->ui32UserVAddr;
+			if(i == ui32NumPages - 1 && ulEndOffset != 0)
+				sEnd.uiAddr = sStart.uiAddr + ulEndOffset;
 
-		/* Within permissible range */
-		if(pvRangeAddrStart >= pvMinVAddr &&
-		   ui32Length <= psOffsetStruct->ui32RealByteSize)
-			return pvMinVAddr;
-	}
+			if(i == 0)
+				sStart.uiAddr += ulStartOffset;
 
-	return IMG_NULL;
+			pfnPhysicalCacheOp(sStart.uiAddr, sEnd.uiAddr);
+		}
+	}
 }
 
-extern PVRSRV_LINUX_MUTEX g_sMMapMutex;
+#endif /* defined(USE_PHYSICAL_CACHE_OP) */
 
-static inline void DoInnerCacheOp(IMG_HANDLE hOSMemHandle,
-								  IMG_UINT32 ui32ByteOffset,
-								  IMG_VOID *pvRangeAddrStart,
-								  IMG_UINT32 ui32Length,
-								  InnerCacheOp_t pfnInnerCacheOp)
+#if defined(USE_VIRTUAL_CACHE_OP)
+typedef void (*VirtualCacheOp_t)(const void *pvStart, const void *pvEnd);
+
+static inline void DoVirtualCacheOp(IMG_HANDLE hOSMemHandle,
+                                    IMG_UINT32 ui32ByteOffset,
+                                    IMG_VOID *pvRangeAddrStart,
+                                    IMG_UINT32 ui32Length,
+                                    VirtualCacheOp_t pfnVirtualCacheOp)
 {
 	LinuxMemArea *psLinuxMemArea = hOSMemHandle;
 
 	if (!psLinuxMemArea->hBMHandle)
 	{
-		pfnInnerCacheOp(pvRangeAddrStart, pvRangeAddrStart + ui32Length);
+		pfnVirtualCacheOp(pvRangeAddrStart, pvRangeAddrStart + ui32Length);
 	}
 	else
 	{
 		IMG_UINT32 ui32ByteRemain = ui32Length;
-		IMG_UINT32 ui32BytesToDo = PAGE_SIZE - (((IMG_UINT32) pvRangeAddrStart) & (~PAGE_MASK));
+		IMG_UINT32 ui32BytesToDo = PAGE_SIZE - (((IMG_UINTPTR_T) pvRangeAddrStart) & (~PAGE_MASK));
 		IMG_UINT8 *pbDo = (IMG_UINT8 *) pvRangeAddrStart;
 	
 		while(ui32ByteRemain)
 		{
 			if (BM_MapPageAtOffset(psLinuxMemArea->hBMHandle, ui32ByteOffset + (ui32Length - ui32ByteRemain)))
 			{
-				pfnInnerCacheOp(pbDo, pbDo + ui32BytesToDo);
+				pfnVirtualCacheOp(pbDo, pbDo + ui32BytesToDo);
 			}
 			pbDo += ui32BytesToDo;
 			ui32ByteRemain -= ui32BytesToDo;
@@ -4062,31 +4009,36 @@ static inline void DoInnerCacheOp(IMG_HANDLE hOSMemHandle,
 		}
 	}
 }
+#endif /* defined(USE_VIRTUAL_CACHE_OP) */
 
 static
 IMG_BOOL CheckExecuteCacheOp(IMG_HANDLE hOSMemHandle,
-							 IMG_UINT32 ui32ByteOffset,
-							 IMG_VOID *pvRangeAddrStart,
-							 IMG_UINT32 ui32Length,
-							 InnerCacheOp_t pfnInnerCacheOp,
-							 OuterCacheOp_t pfnOuterCacheOp)
+                             IMG_UINT32 ui32ByteOffset,
+                             IMG_VOID *pvVirtRangeStart,
+                             IMG_SIZE_T uiLength
+#if defined(USE_VIRTUAL_CACHE_OP)
+                             , VirtualCacheOp_t pfnVirtualCacheOp
+#endif
+#if defined(USE_PHYSICAL_CACHE_OP)
+                             , PhysicalCacheOp_t pfnPhysicalCacheOp
+#endif
+                             )
 {
 	LinuxMemArea *psLinuxMemArea = (LinuxMemArea *)hOSMemHandle;
-	IMG_UINT32 ui32AreaLength, ui32AreaOffset = 0;
+	IMG_UINTPTR_T uiAreaOffset = 0;
 	struct list_head *psMMapOffsetStructList;
 	IMG_VOID *pvMinVAddr;
-
-#if defined(CONFIG_OUTER_CACHE)
+#if defined(USE_PHYSICAL_CACHE_OP)
 	MemAreaToPhys_t pfnMemAreaToPhys = IMG_NULL;
-	IMG_UINT32 ui32PageNumOffset = 0;
+	IMG_UINTPTR_T uPageNumOffset = 0;
+	IMG_VOID *pvPhysRangeStart = pvVirtRangeStart;
 #endif
 
 	PVR_ASSERT(psLinuxMemArea != IMG_NULL);
 
-	LinuxLockMutex(&g_sMMapMutex);
+	LinuxLockMutexNested(&g_sMMapMutex, PVRSRV_LOCK_CLASS_MMAP);
 
 	psMMapOffsetStructList = &psLinuxMemArea->sMMapOffsetStructList;
-	ui32AreaLength = psLinuxMemArea->ui32ByteSize;
 
 	/*
 		Don't check the length in the case of sparse mappings as
@@ -4094,12 +4046,12 @@ IMG_BOOL CheckExecuteCacheOp(IMG_HANDLE hOSMemHandle,
 	*/
 	if (!psLinuxMemArea->hBMHandle)
 	{
-		PVR_ASSERT(ui32Length <= ui32AreaLength);
+		PVR_ASSERT(uiLength <= psLinuxMemArea->uiByteSize);
 	}
 
 	if(psLinuxMemArea->eAreaType == LINUX_MEM_AREA_SUB_ALLOC)
 	{
-		ui32AreaOffset = psLinuxMemArea->uData.sSubAlloc.ui32ByteOffset;
+		uiAreaOffset = psLinuxMemArea->uData.sSubAlloc.uiByteOffset;
 		psLinuxMemArea = psLinuxMemArea->uData.sSubAlloc.psParentLinuxMemArea;
 	}
 
@@ -4110,19 +4062,13 @@ IMG_BOOL CheckExecuteCacheOp(IMG_HANDLE hOSMemHandle,
 	{
 		case LINUX_MEM_AREA_VMALLOC:
 		{
-			if(is_vmalloc_addr(pvRangeAddrStart))
+			if(is_vmalloc_addr(pvVirtRangeStart))
 			{
-				pvMinVAddr = psLinuxMemArea->uData.sVmalloc.pvVmallocAddress + ui32AreaOffset;
+				pvMinVAddr = psLinuxMemArea->uData.sVmalloc.pvVmallocAddress + uiAreaOffset;
 
 				/* Outside permissible range */
-				if(pvRangeAddrStart < pvMinVAddr)
+				if(pvVirtRangeStart < pvMinVAddr)
 					goto err_blocked;
-
-				DoInnerCacheOp(hOSMemHandle,
-							   ui32ByteOffset,
-							   pvRangeAddrStart,
-							   ui32Length,
-							   pfnInnerCacheOp);
 			}
 			else
 			{
@@ -4132,17 +4078,11 @@ IMG_BOOL CheckExecuteCacheOp(IMG_HANDLE hOSMemHandle,
 				 */
 
 				pvMinVAddr = FindMMapBaseVAddr(psMMapOffsetStructList,
-											   pvRangeAddrStart, ui32Length);
+				                               pvVirtRangeStart, uiLength);
 				if(!pvMinVAddr)
 					goto err_blocked;
 
-				DoInnerCacheOp(hOSMemHandle,
-							   ui32ByteOffset,
-							   pvRangeAddrStart,
-							   ui32Length,
-							   pfnInnerCacheOp);
-
-#if defined(CONFIG_OUTER_CACHE)
+#if defined(USE_PHYSICAL_CACHE_OP)
 				/*
 				 * We don't need to worry about cache aliasing here because
 				 * we have already flushed the virtually-indexed caches (L1
@@ -4151,14 +4091,10 @@ IMG_BOOL CheckExecuteCacheOp(IMG_HANDLE hOSMemHandle,
 				 * The vmalloc address will only be used to determine
 				 * affected physical pages for outer cache flushing.
 				 */
-				pvRangeAddrStart = psLinuxMemArea->uData.sVmalloc.pvVmallocAddress +
-								   (ui32AreaOffset & PAGE_MASK) + (pvRangeAddrStart - pvMinVAddr);
-			}
-
-			pfnMemAreaToPhys = VMallocAreaToPhys;
-#else /* defined(CONFIG_OUTER_CACHE) */
+				pvPhysRangeStart = psLinuxMemArea->uData.sVmalloc.pvVmallocAddress +
+						(uiAreaOffset & PAGE_MASK) + (pvVirtRangeStart - pvMinVAddr);
+#endif
 			}
-#endif /* defined(CONFIG_OUTER_CACHE) */
 			break;
 		}
 
@@ -4183,111 +4119,80 @@ IMG_BOOL CheckExecuteCacheOp(IMG_HANDLE hOSMemHandle,
 			}
 
 			pvMinVAddr = FindMMapBaseVAddr(psMMapOffsetStructList,
-										   pvRangeAddrStart, ui32Length);
+			                               pvVirtRangeStart, uiLength);
 			if(!pvMinVAddr)
 				goto err_blocked;
 
-			DoInnerCacheOp(hOSMemHandle,
-						   ui32ByteOffset,
-						   pvRangeAddrStart,
-						   ui32Length,
-						   pfnInnerCacheOp);
-
-#if defined(CONFIG_OUTER_CACHE)
-			ui32PageNumOffset = ((ui32AreaOffset & PAGE_MASK) + (pvRangeAddrStart - pvMinVAddr)) >> PAGE_SHIFT;
-			pfnMemAreaToPhys = ExternalKVAreaToPhys;
-#endif
 			break;
 		}
 
-		case LINUX_MEM_AREA_ION:
+		case LINUX_MEM_AREA_ALLOC_PAGES:
 		{
 			pvMinVAddr = FindMMapBaseVAddr(psMMapOffsetStructList,
-										   pvRangeAddrStart, ui32Length);
+			                               pvVirtRangeStart, uiLength);
 			if(!pvMinVAddr)
 				goto err_blocked;
 
-			DoInnerCacheOp(hOSMemHandle,
-						   ui32ByteOffset,
-						   pvRangeAddrStart,
-						   ui32Length,
-						   pfnInnerCacheOp);
+			break;
+		}
 
-#if defined(CONFIG_OUTER_CACHE)
-			ui32PageNumOffset = ((ui32AreaOffset & PAGE_MASK) + (pvRangeAddrStart - pvMinVAddr)) >> PAGE_SHIFT;
-			pfnMemAreaToPhys = IONAreaToPhys;
-#endif
+		default:
+			PVR_DBG_BREAK;
+			goto err_blocked;
+	}
+
+#if defined(USE_PHYSICAL_CACHE_OP)
+	switch(psLinuxMemArea->eAreaType)
+	{
+		case LINUX_MEM_AREA_VMALLOC:
+		{
+			pfnMemAreaToPhys = VMallocAreaToPhys;
 			break;
 		}
 
-		case LINUX_MEM_AREA_ALLOC_PAGES:
+		case LINUX_MEM_AREA_EXTERNAL_KV:
 		{
-			pvMinVAddr = FindMMapBaseVAddr(psMMapOffsetStructList,
-										   pvRangeAddrStart, ui32Length);
-			if(!pvMinVAddr)
-				goto err_blocked;
+			uPageNumOffset = ((uiAreaOffset & PAGE_MASK) + (pvPhysRangeStart - pvMinVAddr)) >> PAGE_SHIFT;
+			pfnMemAreaToPhys = ExternalKVAreaToPhys;
+			break;
+		}
 
-			DoInnerCacheOp(hOSMemHandle,
-						   ui32ByteOffset,
-						   pvRangeAddrStart,
-						   ui32Length,
-						   pfnInnerCacheOp);
+		case LINUX_MEM_AREA_ALLOC_PAGES:
+		{
+			uPageNumOffset = ((uiAreaOffset & PAGE_MASK) + (pvPhysRangeStart - pvMinVAddr)) >> PAGE_SHIFT;
 
-#if defined(CONFIG_OUTER_CACHE)
-			ui32PageNumOffset = ((ui32AreaOffset & PAGE_MASK) + (pvRangeAddrStart - pvMinVAddr)) >> PAGE_SHIFT;
 			if (psLinuxMemArea->hBMHandle)
-			{
 				pfnMemAreaToPhys = AllocPagesSparseAreaToPhys;
-			}
 			else
-			{
 				pfnMemAreaToPhys = AllocPagesAreaToPhys;
-			}
-#endif
+
 			break;
 		}
 
 		default:
 			PVR_DBG_BREAK;
 	}
+#endif
+
+#if defined(USE_VIRTUAL_CACHE_OP)
+	DoVirtualCacheOp(hOSMemHandle,
+	                 ui32ByteOffset,
+	                 pvVirtRangeStart,
+	                 uiLength,
+	                 pfnVirtualCacheOp);
+#endif
 
 	LinuxUnLockMutex(&g_sMMapMutex);
 
-#if defined(CONFIG_OUTER_CACHE)
+#if defined(USE_PHYSICAL_CACHE_OP)
 	PVR_ASSERT(pfnMemAreaToPhys != IMG_NULL);
 
-	/* Outer caches need some more work, to get a list of physical addresses */
-	{
-		unsigned long ulStart, ulEnd, ulLength, ulStartOffset, ulEndOffset;
-		IMG_UINT32 i, ui32NumPages;
-		IMG_BOOL bValidPage;
-
-		/* Length and offsets of flush region WRT page alignment */
-		ulLength = (unsigned long)ui32Length;
-		ulStartOffset = ((unsigned long)pvRangeAddrStart) & (PAGE_SIZE - 1);
-		ulEndOffset = ((unsigned long)pvRangeAddrStart + ulLength) & (PAGE_SIZE - 1);
-
-		/* The affected pages, rounded up */
-		ui32NumPages = (ulStartOffset + ulLength + PAGE_SIZE - 1) >> PAGE_SHIFT;
-
-		for(i = 0; i < ui32NumPages; i++)
-		{
-			bValidPage = pfnMemAreaToPhys(psLinuxMemArea, pvRangeAddrStart,
-									   ui32PageNumOffset, i, &ulStart);
-			if (bValidPage)
-			{
-				ulEnd = ulStart + PAGE_SIZE;
-	
-				if(i == ui32NumPages - 1 && ulEndOffset != 0)
-					ulEnd = ulStart + ulEndOffset;
-	
-				if(i == 0)
-					ulStart += ulStartOffset;
-	
-				pfnOuterCacheOp(ulStart, ulEnd);
-			}
-		}
-	}
+	DoPhysicalCacheOp(psLinuxMemArea,
+	                  pvPhysRangeStart,
+	                  uiLength,
+	                  uPageNumOffset,
+	                  pfnMemAreaToPhys,
+	                  pfnPhysicalCacheOp);
 #endif
 
 	return IMG_TRUE;
@@ -4295,13 +4200,13 @@ IMG_BOOL CheckExecuteCacheOp(IMG_HANDLE hOSMemHandle,
 err_blocked:
 	PVR_DPF((PVR_DBG_WARNING, "%s: Blocked cache op on virtual range "
 							  "%p-%p (type %d)", __func__,
-			 pvRangeAddrStart, pvRangeAddrStart + ui32Length,
+			 pvVirtRangeStart, pvVirtRangeStart + uiLength,
 			 psLinuxMemArea->eAreaType));
 	LinuxUnLockMutex(&g_sMMapMutex);
 	return IMG_FALSE;
 }
 
-#if defined(__i386__)
+#if defined(__i386__) || defined (__x86_64__)
 
 #define ROUND_UP(x,a) (((x) + (a) - 1) & ~((a) - 1))
 
@@ -4346,7 +4251,7 @@ IMG_BOOL OSFlushCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
 {
 	/* Write-back and invalidate */
 	return CheckExecuteCacheOp(hOSMemHandle, ui32ByteOffset, pvRangeAddrStart, ui32Length,
-							   x86_flush_cache_range, IMG_NULL);
+							   x86_flush_cache_range);
 }
 
 IMG_BOOL OSCleanCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
@@ -4356,7 +4261,7 @@ IMG_BOOL OSCleanCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
 {
 	/* No clean feature on x86 */
 	return CheckExecuteCacheOp(hOSMemHandle, ui32ByteOffset, pvRangeAddrStart, ui32Length,
-							   x86_flush_cache_range, IMG_NULL);
+							   x86_flush_cache_range);
 }
 
 IMG_BOOL OSInvalidateCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
@@ -4366,12 +4271,10 @@ IMG_BOOL OSInvalidateCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
 {
 	/* No invalidate-only support */
 	return CheckExecuteCacheOp(hOSMemHandle, ui32ByteOffset, pvRangeAddrStart, ui32Length,
-							   x86_flush_cache_range, IMG_NULL);
+							   x86_flush_cache_range);
 }
 
-#else /* defined(__i386__) */
-
-#if defined(__arm__)
+#elif defined(__arm__)
 
 static void per_cpu_cache_flush(void *arg)
 {
@@ -4411,6 +4314,8 @@ static inline size_t pvr_dmac_range_len(const void *pvStart, const void *pvEnd)
 }
 #endif
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0)
+
 static void pvr_dmac_inv_range(const void *pvStart, const void *pvEnd)
 {
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,34))
@@ -4429,14 +4334,41 @@ static void pvr_dmac_clean_range(const void *pvStart, const void *pvEnd)
 #endif
 }
 
+#else /* LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0) */
+
+static void pvr_flush_range(phys_addr_t pStart, phys_addr_t pEnd)
+{
+	arm_dma_ops.sync_single_for_device(NULL, pStart, pEnd - pStart, DMA_TO_DEVICE);
+	arm_dma_ops.sync_single_for_cpu(NULL, pStart, pEnd - pStart, DMA_FROM_DEVICE);
+}
+
+static void pvr_clean_range(phys_addr_t pStart, phys_addr_t pEnd)
+{
+	arm_dma_ops.sync_single_for_device(NULL, pStart, pEnd - pStart, DMA_TO_DEVICE);
+}
+
+static void pvr_invalidate_range(phys_addr_t pStart, phys_addr_t pEnd)
+{
+	arm_dma_ops.sync_single_for_cpu(NULL, pStart, pEnd - pStart, DMA_FROM_DEVICE);
+}
+
+#endif /* LINUX_VERSION_CODE < KERNEL_VERSION(3,7,0) */
+
 IMG_BOOL OSFlushCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
 								IMG_UINT32 ui32ByteOffset,
 								IMG_VOID *pvRangeAddrStart,
 								IMG_UINT32 ui32Length)
 {
 	return CheckExecuteCacheOp(hOSMemHandle, ui32ByteOffset,
-							   pvRangeAddrStart, ui32Length,
-							   dmac_flush_range, outer_flush_range);
+	                           pvRangeAddrStart, ui32Length,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+	                           pvr_flush_range
+#elif defined(CONFIG_OUTER_CACHE)
+	                           dmac_flush_range, outer_flush_range
+#else
+	                           dmac_flush_range
+#endif
+	                           );
 }
 
 IMG_BOOL OSCleanCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
@@ -4445,8 +4377,15 @@ IMG_BOOL OSCleanCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
 								IMG_UINT32 ui32Length)
 {
 	return CheckExecuteCacheOp(hOSMemHandle, ui32ByteOffset,
-							   pvRangeAddrStart, ui32Length,
-							   pvr_dmac_clean_range, outer_clean_range);
+	                           pvRangeAddrStart, ui32Length,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+	                           pvr_clean_range
+#elif defined(CONFIG_OUTER_CACHE)
+	                           pvr_dmac_clean_range, outer_clean_range
+#else
+	                           pvr_dmac_clean_range
+#endif
+	                           );
 }
 
 IMG_BOOL OSInvalidateCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
@@ -4455,13 +4394,18 @@ IMG_BOOL OSInvalidateCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
 									 IMG_UINT32 ui32Length)
 {
 	return CheckExecuteCacheOp(hOSMemHandle, ui32ByteOffset,
-							   pvRangeAddrStart, ui32Length,
-							   pvr_dmac_inv_range, outer_inv_range);
+	                           pvRangeAddrStart, ui32Length,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,7,0)
+	                           pvr_invalidate_range
+#elif defined(CONFIG_OUTER_CACHE)
+	                           pvr_dmac_inv_range, outer_inv_range
+#else
+	                           pvr_dmac_inv_range
+#endif
+	                           );
 }
 
-#else /* defined(__arm__) */
-
-#if defined(__mips__)
+#elif defined(__mips__)
 /* 
  * dmac cache functions are supposed to be used for dma 
  * memory which comes from dma-able memory. However examining
@@ -4524,7 +4468,7 @@ IMG_BOOL OSFlushCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
 {
 	return CheckExecuteCacheOp(hOSMemHandle, ui32ByteOffset,
 							   pvRangeAddrStart, ui32Length,
-							   pvr_dma_cache_wback_inv, IMG_NULL);
+							   pvr_dma_cache_wback_inv);
 }
 
 IMG_BOOL OSCleanCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
@@ -4534,7 +4478,7 @@ IMG_BOOL OSCleanCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
 {
 	return CheckExecuteCacheOp(hOSMemHandle, ui32ByteOffset,
 							   pvRangeAddrStart, ui32Length,
-							   pvr_dma_cache_wback, IMG_NULL);
+							   pvr_dma_cache_wback);
 }
 
 IMG_BOOL OSInvalidateCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
@@ -4544,18 +4488,14 @@ IMG_BOOL OSInvalidateCPUCacheRangeKM(IMG_HANDLE hOSMemHandle,
 {
 	return CheckExecuteCacheOp(hOSMemHandle, ui32ByteOffset,
 							   pvRangeAddrStart, ui32Length,
-							   pvr_dma_cache_inv, IMG_NULL);
+							   pvr_dma_cache_inv);
 }
 
-#else /* defined(__mips__) */
+#else
 
 #error "Implement CPU cache flush/clean/invalidate primitives for this CPU!"
 
-#endif /* defined(__mips__) */
-
-#endif /* defined(__arm__) */
-
-#endif /* defined(__i386__) */
+#endif
 
 typedef struct _AtomicStruct
 {
@@ -4613,7 +4553,7 @@ IMG_VOID OSReleaseBridgeLock(IMG_VOID)
 
 IMG_VOID OSReacquireBridgeLock(IMG_VOID)
 {
-       LinuxLockMutex(&gPVRSRVLock);
+       LinuxLockMutexNested(&gPVRSRVLock, PVRSRV_LOCK_CLASS_BRIDGE);
 }
 
 typedef struct _OSTime
@@ -4631,7 +4571,7 @@ PVRSRV_ERROR OSTimeCreateWithUSOffset(IMG_PVOID *pvRet, IMG_UINT32 ui32USOffset)
 		return PVRSRV_ERROR_OUT_OF_MEMORY;
 	}
 
-	psOSTime->ulTime = usecs_to_jiffies(jiffies_to_usecs(jiffies) + ui32USOffset);
+	psOSTime->ulTime = jiffies + usecs_to_jiffies(ui32USOffset);
 	*pvRet = psOSTime;
 	return PVRSRV_OK;
 }