drivers/gpu/pvr/pvr_bridge_k.c - kernel/omap.git - Git at Google

 /**********************************************************************
  *
  * Copyright (C) Imagination Technologies Ltd. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms and conditions of the GNU General Public License,
  * version 2, as published by the Free Software Foundation.
  *
  * This program is distributed in the hope it will be useful but, except
  * as otherwise stated in writing, without any warranty; without even the
  * implied warranty of merchantability or fitness for a particular purpose.
  * See the GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * this program; if not, write to the Free Software Foundation, Inc.,
  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * The full GNU General Public License is included in this distribution in
  * the file called "COPYING".
  *
  * Contact Information:
  * Imagination Technologies Ltd. <gpl-support@imgtec.com>
  * Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
  *
  ******************************************************************************/

 #include "img_defs.h"
 #include "services.h"
 #include "pvr_bridge.h"
 #include "perproc.h"
 #include "mutex.h"
 #include "syscommon.h"
 #include "pvr_debug.h"
 #include "proc.h"
 #include "private_data.h"
 #include "linkage.h"
 #include "pvr_bridge_km.h"
 #include "pvr_uaccess.h"
 #include "refcount.h"

 #if defined(SUPPORT_DRI_DRM)
 #include <drm/drmP.h>
 #include "pvr_drm.h"
 #if defined(PVR_SECURE_DRM_AUTH_EXPORT)
 #include "env_perproc.h"
 #endif
 #endif

 #if defined(SUPPORT_VGX)
 #include "vgx_bridge.h"
 #endif

 #if defined(SUPPORT_SGX)
 #include "sgx_bridge.h"
 #endif

 #include "bridged_pvr_bridge.h"

 #if defined(SUPPORT_DRI_DRM)
 #define	PRIVATE_DATA(pFile) ((pFile)->driver_priv)
 #else
 #define	PRIVATE_DATA(pFile) ((pFile)->private_data)
 #endif

 #if defined(DEBUG_BRIDGE_KM)

 static struct proc_dir_entry *g_ProcBridgeStats =0;
 static void* ProcSeqNextBridgeStats(struct seq_file *sfile,void* el,loff_t off);
 static void ProcSeqShowBridgeStats(struct seq_file *sfile,void* el);
 static void* ProcSeqOff2ElementBridgeStats(struct seq_file * sfile, loff_t off);
 static void ProcSeqStartstopBridgeStats(struct seq_file *sfile,IMG_BOOL start);

 #endif

 extern PVRSRV_LINUX_MUTEX gPVRSRVLock;

 #if defined(SUPPORT_MEMINFO_IDS)
 static IMG_UINT64 ui64Stamp;
 #endif

 PVRSRV_ERROR
 LinuxBridgeInit(IMG_VOID)
 {
 #if defined(DEBUG_BRIDGE_KM)
 	{
 		g_ProcBridgeStats = CreateProcReadEntrySeq(
 												  "bridge_stats",
 												  NULL,
 												  ProcSeqNextBridgeStats,
 												  ProcSeqShowBridgeStats,
 												  ProcSeqOff2ElementBridgeStats,
 												  ProcSeqStartstopBridgeStats
 						  						 );
 		if(!g_ProcBridgeStats)
 		{
 			return PVRSRV_ERROR_OUT_OF_MEMORY;
 		}
 	}
 #endif
 	return CommonBridgeInit();
 }

 IMG_VOID
 LinuxBridgeDeInit(IMG_VOID)
 {
 #if defined(DEBUG_BRIDGE_KM)
     RemoveProcEntrySeq(g_ProcBridgeStats);
 #endif
 }

 #if defined(DEBUG_BRIDGE_KM)

 static void ProcSeqStartstopBridgeStats(struct seq_file *sfile,IMG_BOOL start)
 {
 	if(start)
 	{
 		LinuxLockMutex(&gPVRSRVLock);
 	}
 	else
 	{
 		LinuxUnLockMutex(&gPVRSRVLock);
 	}
 }


 static void* ProcSeqOff2ElementBridgeStats(struct seq_file *sfile, loff_t off)
 {
 	if(!off)
 	{
 		return PVR_PROC_SEQ_START_TOKEN;
 	}

 	if(off > BRIDGE_DISPATCH_TABLE_ENTRY_COUNT)
 	{
 		return (void*)0;
 	}


 	return (void*)&g_BridgeDispatchTable[off-1];
 }

 static void* ProcSeqNextBridgeStats(struct seq_file *sfile,void* el,loff_t off)
 {
 	return ProcSeqOff2ElementBridgeStats(sfile,off);
 }


 static void ProcSeqShowBridgeStats(struct seq_file *sfile,void* el)
 {
 	PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY *psEntry = (	PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY*)el;

 	if(el == PVR_PROC_SEQ_START_TOKEN)
 	{
 		seq_printf(sfile,
 						  "Total ioctl call count = %u\n"
 						  "Total number of bytes copied via copy_from_user = %u\n"
 						  "Total number of bytes copied via copy_to_user = %u\n"
 						  "Total number of bytes copied via copy_*_user = %u\n\n"
 						  "%-45s | %-40s | %10s | %20s | %10s\n",
 						  g_BridgeGlobalStats.ui32IOCTLCount,
 						  g_BridgeGlobalStats.ui32TotalCopyFromUserBytes,
 						  g_BridgeGlobalStats.ui32TotalCopyToUserBytes,
 						  g_BridgeGlobalStats.ui32TotalCopyFromUserBytes+g_BridgeGlobalStats.ui32TotalCopyToUserBytes,
 						  "Bridge Name",
 						  "Wrapper Function",
 						  "Call Count",
 						  "copy_from_user Bytes",
 						  "copy_to_user Bytes"
 						 );
 		return;
 	}

 	seq_printf(sfile,
 				   "%-45s   %-40s   %-10u   %-20u   %-10u\n",
 				   psEntry->pszIOCName,
 				   psEntry->pszFunctionName,
 				   psEntry->ui32CallCount,
 				   psEntry->ui32CopyFromUserTotalBytes,
 				   psEntry->ui32CopyToUserTotalBytes);
 }

 #endif


 #if defined(SUPPORT_DRI_DRM)
 int
 PVRSRV_BridgeDispatchKM(struct drm_device unref__ *dev, void *arg, struct drm_file *pFile)
 #else
 long
 PVRSRV_BridgeDispatchKM(struct file *pFile, unsigned int unref__ ioctlCmd, unsigned long arg)
 #endif
 {
 	IMG_UINT32 cmd;
 #if !defined(SUPPORT_DRI_DRM)
 	PVRSRV_BRIDGE_PACKAGE *psBridgePackageUM = (PVRSRV_BRIDGE_PACKAGE *)arg;
 	PVRSRV_BRIDGE_PACKAGE sBridgePackageKM;
 #endif
 	PVRSRV_BRIDGE_PACKAGE *psBridgePackageKM;
 	IMG_UINT32 ui32PID = OSGetCurrentProcessIDKM();
 	PVRSRV_PER_PROCESS_DATA *psPerProc;
 	IMG_INT err = -EFAULT;

 	LinuxLockMutex(&gPVRSRVLock);

 #if defined(SUPPORT_DRI_DRM)
 	psBridgePackageKM = (PVRSRV_BRIDGE_PACKAGE *)arg;
 	PVR_ASSERT(psBridgePackageKM != IMG_NULL);
 #else
 	psBridgePackageKM = &sBridgePackageKM;

 	if(!OSAccessOK(PVR_VERIFY_WRITE,
 				   psBridgePackageUM,
 				   sizeof(PVRSRV_BRIDGE_PACKAGE)))
 	{
 		PVR_DPF((PVR_DBG_ERROR, "%s: Received invalid pointer to function arguments",
 				 __FUNCTION__));

 		goto unlock_and_return;
 	}


 	if(OSCopyFromUser(IMG_NULL,
 					  psBridgePackageKM,
 					  psBridgePackageUM,
 					  sizeof(PVRSRV_BRIDGE_PACKAGE))
 	  != PVRSRV_OK)
 	{
 		goto unlock_and_return;
 	}
 #endif

 	cmd = psBridgePackageKM->ui32BridgeID;

 	if(cmd != PVRSRV_BRIDGE_CONNECT_SERVICES)
 	{
 		PVRSRV_ERROR eError;

 		eError = PVRSRVLookupHandle(KERNEL_HANDLE_BASE,
 									(IMG_PVOID *)&psPerProc,
 									psBridgePackageKM->hKernelServices,
 									PVRSRV_HANDLE_TYPE_PERPROC_DATA);
 		if(eError != PVRSRV_OK)
 		{
 			PVR_DPF((PVR_DBG_ERROR, "%s: Invalid kernel services handle (%d)",
 					 __FUNCTION__, eError));
 			goto unlock_and_return;
 		}

 		if(psPerProc->ui32PID != ui32PID)
 		{
 			PVR_DPF((PVR_DBG_ERROR, "%s: Process %d tried to access data "
 					 "belonging to process %d", __FUNCTION__, ui32PID,
 					 psPerProc->ui32PID));
 			goto unlock_and_return;
 		}
 	}
 	else
 	{

 		psPerProc = PVRSRVPerProcessData(ui32PID);
 		if(psPerProc == IMG_NULL)
 		{
 			PVR_DPF((PVR_DBG_ERROR, "PVRSRV_BridgeDispatchKM: "
 					 "Couldn't create per-process data area"));
 			goto unlock_and_return;
 		}
 	}

 	psBridgePackageKM->ui32BridgeID = PVRSRV_GET_BRIDGE_ID(psBridgePackageKM->ui32BridgeID);

 	switch(cmd)
 	{
 		case PVRSRV_BRIDGE_EXPORT_DEVICEMEM_2:
 		{
 			PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);

 			if(psPrivateData->hKernelMemInfo)
 			{
 				PVR_DPF((PVR_DBG_ERROR, "%s: Can only export one MemInfo "
 						 "per file descriptor", __FUNCTION__));
 				err = -EINVAL;
 				goto unlock_and_return;
 			}
 			break;
 		}

 		case PVRSRV_BRIDGE_MAP_DEV_MEMORY_2:
 		{
 			PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *psMapDevMemIN =
 				(PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *)psBridgePackageKM->pvParamIn;
 			PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);

 			if(!psPrivateData->hKernelMemInfo)
 			{
 				PVR_DPF((PVR_DBG_ERROR, "%s: File descriptor has no "
 						 "associated MemInfo handle", __FUNCTION__));
 				err = -EINVAL;
 				goto unlock_and_return;
 			}

 			if (pvr_put_user(psPrivateData->hKernelMemInfo, &psMapDevMemIN->hKernelMemInfo) != 0)
 			{
 				err = -EFAULT;
 				goto unlock_and_return;
 			}
 			break;
 		}

 		default:
 		{
 			PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);

 			if(psPrivateData->hKernelMemInfo)
 			{
 				PVR_DPF((PVR_DBG_ERROR, "%s: Import/Export handle tried "
 						 "to use privileged service", __FUNCTION__));
 				goto unlock_and_return;
 			}
 			break;
 		}
 	}

 #if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
 	switch(cmd)
 	{
 		case PVRSRV_BRIDGE_MAP_DEV_MEMORY:
 		case PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY:
 		{
 			PVRSRV_FILE_PRIVATE_DATA *psPrivateData;
 			int authenticated = pFile->authenticated;
 			PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc;

 			if (authenticated)
 			{
 				break;
 			}


 			psEnvPerProc = (PVRSRV_ENV_PER_PROCESS_DATA *)PVRSRVProcessPrivateData(psPerProc);
 			if (psEnvPerProc == IMG_NULL)
 			{
 				PVR_DPF((PVR_DBG_ERROR, "%s: Process private data not allocated", __FUNCTION__));
 				err = -EFAULT;
 				goto unlock_and_return;
 			}

 			list_for_each_entry(psPrivateData, &psEnvPerProc->sDRMAuthListHead, sDRMAuthListItem)
 			{
 				struct drm_file *psDRMFile = psPrivateData->psDRMFile;

 				if (pFile->master == psDRMFile->master)
 				{
 					authenticated |= psDRMFile->authenticated;
 					if (authenticated)
 					{
 						break;
 					}
 				}
 			}

 			if (!authenticated)
 			{
 				PVR_DPF((PVR_DBG_ERROR, "%s: Not authenticated for mapping device or device class memory", __FUNCTION__));
 				err = -EPERM;
 				goto unlock_and_return;
 			}
 			break;
 		}
 		default:
 			break;
 	}
 #endif

 	err = BridgedDispatchKM(psPerProc, psBridgePackageKM);
 	if(err != PVRSRV_OK)
 		goto unlock_and_return;

 	switch(cmd)
 	{
 		case PVRSRV_BRIDGE_EXPORT_DEVICEMEM_2:
 		{
 			PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM *psExportDeviceMemOUT =
 				(PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM *)psBridgePackageKM->pvParamOut;
 			PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
 			PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;


 			if(PVRSRVLookupHandle(KERNEL_HANDLE_BASE,
 								  (IMG_PVOID *)&psKernelMemInfo,
 								  psExportDeviceMemOUT->hMemInfo,
 								  PVRSRV_HANDLE_TYPE_MEM_INFO) != PVRSRV_OK)
 			{
 				PVR_DPF((PVR_DBG_ERROR, "%s: Failed to look up export handle", __FUNCTION__));
 				err = -EFAULT;
 				goto unlock_and_return;
 			}


 			PVRSRVKernelMemInfoIncRef(psKernelMemInfo);

 			psPrivateData->hKernelMemInfo = psExportDeviceMemOUT->hMemInfo;
 #if defined(SUPPORT_MEMINFO_IDS)
 			psPrivateData->ui64Stamp = ++ui64Stamp;

 			psKernelMemInfo->ui64Stamp = psPrivateData->ui64Stamp;
 			if (pvr_put_user(psPrivateData->ui64Stamp, &psExportDeviceMemOUT->ui64Stamp) != 0)
 			{
 				err = -EFAULT;
 				goto unlock_and_return;
 			}
 #endif
 			break;
 		}

 #if defined(SUPPORT_MEMINFO_IDS)
 		case PVRSRV_BRIDGE_MAP_DEV_MEMORY:
 		case PVRSRV_BRIDGE_MAP_DEV_MEMORY_2:
 		{
 			PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY *psMapDeviceMemoryOUT =
 				(PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY *)psBridgePackageKM->pvParamOut;
 			PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
 			if (pvr_put_user(psPrivateData->ui64Stamp, &psMapDeviceMemoryOUT->sDstClientMemInfo.ui64Stamp) != 0)
 			{
 				err = -EFAULT;
 				goto unlock_and_return;
 			}
 			break;
 		}

 		case PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY:
 		{
 			PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY *psDeviceClassMemoryOUT =
 				(PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY *)psBridgePackageKM->pvParamOut;
 			if (pvr_put_user(++ui64Stamp, &psDeviceClassMemoryOUT->sClientMemInfo.ui64Stamp) != 0)
 			{
 				err = -EFAULT;
 				goto unlock_and_return;
 			}
 			break;
 		}
 #endif

 		default:
 			break;
 	}

 unlock_and_return:
 	LinuxUnLockMutex(&gPVRSRVLock);
 	return err;
 }
	/**********************************************************************
	*
	* Copyright (C) Imagination Technologies Ltd. All rights reserved.
	*
	* This program is free software; you can redistribute it and/or modify it
	* under the terms and conditions of the GNU General Public License,
	* version 2, as published by the Free Software Foundation.
	*
	* This program is distributed in the hope it will be useful but, except
	* as otherwise stated in writing, without any warranty; without even the
	* implied warranty of merchantability or fitness for a particular purpose.
	* See the GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License along with
	* this program; if not, write to the Free Software Foundation, Inc.,
	* 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* The full GNU General Public License is included in this distribution in
	* the file called "COPYING".
	*
	* Contact Information:
	* Imagination Technologies Ltd. <gpl-support@imgtec.com>
	* Home Park Estate, Kings Langley, Herts, WD4 8LZ, UK
	*
	******************************************************************************/

	#include "img_defs.h"
	#include "services.h"
	#include "pvr_bridge.h"
	#include "perproc.h"
	#include "mutex.h"
	#include "syscommon.h"
	#include "pvr_debug.h"
	#include "proc.h"
	#include "private_data.h"
	#include "linkage.h"
	#include "pvr_bridge_km.h"
	#include "pvr_uaccess.h"
	#include "refcount.h"

	#if defined(SUPPORT_DRI_DRM)
	#include <drm/drmP.h>
	#include "pvr_drm.h"
	#if defined(PVR_SECURE_DRM_AUTH_EXPORT)
	#include "env_perproc.h"
	#endif
	#endif

	#if defined(SUPPORT_VGX)
	#include "vgx_bridge.h"
	#endif

	#if defined(SUPPORT_SGX)
	#include "sgx_bridge.h"
	#endif

	#include "bridged_pvr_bridge.h"

	#if defined(SUPPORT_DRI_DRM)
	#define PRIVATE_DATA(pFile) ((pFile)->driver_priv)
	#else
	#define PRIVATE_DATA(pFile) ((pFile)->private_data)
	#endif

	#if defined(DEBUG_BRIDGE_KM)

	static struct proc_dir_entry *g_ProcBridgeStats =0;
	static void* ProcSeqNextBridgeStats(struct seq_file sfile,void el,loff_t off);
	static void ProcSeqShowBridgeStats(struct seq_file sfile,void el);
	static void* ProcSeqOff2ElementBridgeStats(struct seq_file * sfile, loff_t off);
	static void ProcSeqStartstopBridgeStats(struct seq_file *sfile,IMG_BOOL start);

	#endif

	extern PVRSRV_LINUX_MUTEX gPVRSRVLock;

	#if defined(SUPPORT_MEMINFO_IDS)
	static IMG_UINT64 ui64Stamp;
	#endif

	PVRSRV_ERROR
	LinuxBridgeInit(IMG_VOID)
	{
	#if defined(DEBUG_BRIDGE_KM)
	{
	g_ProcBridgeStats = CreateProcReadEntrySeq(
	"bridge_stats",
	NULL,
	ProcSeqNextBridgeStats,
	ProcSeqShowBridgeStats,
	ProcSeqOff2ElementBridgeStats,
	ProcSeqStartstopBridgeStats
	);
	if(!g_ProcBridgeStats)
	{
	return PVRSRV_ERROR_OUT_OF_MEMORY;
	}
	}
	#endif
	return CommonBridgeInit();
	}

	IMG_VOID
	LinuxBridgeDeInit(IMG_VOID)
	{
	#if defined(DEBUG_BRIDGE_KM)
	RemoveProcEntrySeq(g_ProcBridgeStats);
	#endif
	}

	#if defined(DEBUG_BRIDGE_KM)

	static void ProcSeqStartstopBridgeStats(struct seq_file *sfile,IMG_BOOL start)
	{
	if(start)
	{
	LinuxLockMutex(&gPVRSRVLock);
	}
	else
	{
	LinuxUnLockMutex(&gPVRSRVLock);
	}
	}


	static void* ProcSeqOff2ElementBridgeStats(struct seq_file *sfile, loff_t off)
	{
	if(!off)
	{
	return PVR_PROC_SEQ_START_TOKEN;
	}

	if(off > BRIDGE_DISPATCH_TABLE_ENTRY_COUNT)
	{
	return (void*)0;
	}


	return (void*)&g_BridgeDispatchTable[off-1];
	}

	static void* ProcSeqNextBridgeStats(struct seq_file sfile,void el,loff_t off)
	{
	return ProcSeqOff2ElementBridgeStats(sfile,off);
	}


	static void ProcSeqShowBridgeStats(struct seq_file sfile,void el)
	{
	PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY psEntry = ( PVRSRV_BRIDGE_DISPATCH_TABLE_ENTRY)el;

	if(el == PVR_PROC_SEQ_START_TOKEN)
	{
	seq_printf(sfile,
	"Total ioctl call count = %u\n"
	"Total number of bytes copied via copy_from_user = %u\n"
	"Total number of bytes copied via copy_to_user = %u\n"
	"Total number of bytes copied via copy_*_user = %u\n\n"
	"%-45s \| %-40s \| %10s \| %20s \| %10s\n",
	g_BridgeGlobalStats.ui32IOCTLCount,
	g_BridgeGlobalStats.ui32TotalCopyFromUserBytes,
	g_BridgeGlobalStats.ui32TotalCopyToUserBytes,
	g_BridgeGlobalStats.ui32TotalCopyFromUserBytes+g_BridgeGlobalStats.ui32TotalCopyToUserBytes,
	"Bridge Name",
	"Wrapper Function",
	"Call Count",
	"copy_from_user Bytes",
	"copy_to_user Bytes"
	);
	return;
	}

	seq_printf(sfile,
	"%-45s %-40s %-10u %-20u %-10u\n",
	psEntry->pszIOCName,
	psEntry->pszFunctionName,
	psEntry->ui32CallCount,
	psEntry->ui32CopyFromUserTotalBytes,
	psEntry->ui32CopyToUserTotalBytes);
	}

	#endif


	#if defined(SUPPORT_DRI_DRM)
	int
	PVRSRV_BridgeDispatchKM(struct drm_device unref__ dev, void arg, struct drm_file *pFile)
	#else
	long
	PVRSRV_BridgeDispatchKM(struct file *pFile, unsigned int unref__ ioctlCmd, unsigned long arg)
	#endif
	{
	IMG_UINT32 cmd;
	#if !defined(SUPPORT_DRI_DRM)
	PVRSRV_BRIDGE_PACKAGE psBridgePackageUM = (PVRSRV_BRIDGE_PACKAGE )arg;
	PVRSRV_BRIDGE_PACKAGE sBridgePackageKM;
	#endif
	PVRSRV_BRIDGE_PACKAGE *psBridgePackageKM;
	IMG_UINT32 ui32PID = OSGetCurrentProcessIDKM();
	PVRSRV_PER_PROCESS_DATA *psPerProc;
	IMG_INT err = -EFAULT;

	LinuxLockMutex(&gPVRSRVLock);

	#if defined(SUPPORT_DRI_DRM)
	psBridgePackageKM = (PVRSRV_BRIDGE_PACKAGE *)arg;
	PVR_ASSERT(psBridgePackageKM != IMG_NULL);
	#else
	psBridgePackageKM = &sBridgePackageKM;

	if(!OSAccessOK(PVR_VERIFY_WRITE,
	psBridgePackageUM,
	sizeof(PVRSRV_BRIDGE_PACKAGE)))
	{
	PVR_DPF((PVR_DBG_ERROR, "%s: Received invalid pointer to function arguments",
	__FUNCTION__));

	goto unlock_and_return;
	}


	if(OSCopyFromUser(IMG_NULL,
	psBridgePackageKM,
	psBridgePackageUM,
	sizeof(PVRSRV_BRIDGE_PACKAGE))
	!= PVRSRV_OK)
	{
	goto unlock_and_return;
	}
	#endif

	cmd = psBridgePackageKM->ui32BridgeID;

	if(cmd != PVRSRV_BRIDGE_CONNECT_SERVICES)
	{
	PVRSRV_ERROR eError;

	eError = PVRSRVLookupHandle(KERNEL_HANDLE_BASE,
	(IMG_PVOID *)&psPerProc,
	psBridgePackageKM->hKernelServices,
	PVRSRV_HANDLE_TYPE_PERPROC_DATA);
	if(eError != PVRSRV_OK)
	{
	PVR_DPF((PVR_DBG_ERROR, "%s: Invalid kernel services handle (%d)",
	__FUNCTION__, eError));
	goto unlock_and_return;
	}

	if(psPerProc->ui32PID != ui32PID)
	{
	PVR_DPF((PVR_DBG_ERROR, "%s: Process %d tried to access data "
	"belonging to process %d", __FUNCTION__, ui32PID,
	psPerProc->ui32PID));
	goto unlock_and_return;
	}
	}
	else
	{

	psPerProc = PVRSRVPerProcessData(ui32PID);
	if(psPerProc == IMG_NULL)
	{
	PVR_DPF((PVR_DBG_ERROR, "PVRSRV_BridgeDispatchKM: "
	"Couldn't create per-process data area"));
	goto unlock_and_return;
	}
	}

	psBridgePackageKM->ui32BridgeID = PVRSRV_GET_BRIDGE_ID(psBridgePackageKM->ui32BridgeID);

	switch(cmd)
	{
	case PVRSRV_BRIDGE_EXPORT_DEVICEMEM_2:
	{
	PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);

	if(psPrivateData->hKernelMemInfo)
	{
	PVR_DPF((PVR_DBG_ERROR, "%s: Can only export one MemInfo "
	"per file descriptor", __FUNCTION__));
	err = -EINVAL;
	goto unlock_and_return;
	}
	break;
	}

	case PVRSRV_BRIDGE_MAP_DEV_MEMORY_2:
	{
	PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *psMapDevMemIN =
	(PVRSRV_BRIDGE_IN_MAP_DEV_MEMORY *)psBridgePackageKM->pvParamIn;
	PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);

	if(!psPrivateData->hKernelMemInfo)
	{
	PVR_DPF((PVR_DBG_ERROR, "%s: File descriptor has no "
	"associated MemInfo handle", __FUNCTION__));
	err = -EINVAL;
	goto unlock_and_return;
	}

	if (pvr_put_user(psPrivateData->hKernelMemInfo, &psMapDevMemIN->hKernelMemInfo) != 0)
	{
	err = -EFAULT;
	goto unlock_and_return;
	}
	break;
	}

	default:
	{
	PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);

	if(psPrivateData->hKernelMemInfo)
	{
	PVR_DPF((PVR_DBG_ERROR, "%s: Import/Export handle tried "
	"to use privileged service", __FUNCTION__));
	goto unlock_and_return;
	}
	break;
	}
	}

	#if defined(SUPPORT_DRI_DRM) && defined(PVR_SECURE_DRM_AUTH_EXPORT)
	switch(cmd)
	{
	case PVRSRV_BRIDGE_MAP_DEV_MEMORY:
	case PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY:
	{
	PVRSRV_FILE_PRIVATE_DATA *psPrivateData;
	int authenticated = pFile->authenticated;
	PVRSRV_ENV_PER_PROCESS_DATA *psEnvPerProc;

	if (authenticated)
	{
	break;
	}


	psEnvPerProc = (PVRSRV_ENV_PER_PROCESS_DATA *)PVRSRVProcessPrivateData(psPerProc);
	if (psEnvPerProc == IMG_NULL)
	{
	PVR_DPF((PVR_DBG_ERROR, "%s: Process private data not allocated", __FUNCTION__));
	err = -EFAULT;
	goto unlock_and_return;
	}

	list_for_each_entry(psPrivateData, &psEnvPerProc->sDRMAuthListHead, sDRMAuthListItem)
	{
	struct drm_file *psDRMFile = psPrivateData->psDRMFile;

	if (pFile->master == psDRMFile->master)
	{
	authenticated \|= psDRMFile->authenticated;
	if (authenticated)
	{
	break;
	}
	}
	}

	if (!authenticated)
	{
	PVR_DPF((PVR_DBG_ERROR, "%s: Not authenticated for mapping device or device class memory", __FUNCTION__));
	err = -EPERM;
	goto unlock_and_return;
	}
	break;
	}
	default:
	break;
	}
	#endif

	err = BridgedDispatchKM(psPerProc, psBridgePackageKM);
	if(err != PVRSRV_OK)
	goto unlock_and_return;

	switch(cmd)
	{
	case PVRSRV_BRIDGE_EXPORT_DEVICEMEM_2:
	{
	PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM *psExportDeviceMemOUT =
	(PVRSRV_BRIDGE_OUT_EXPORTDEVICEMEM *)psBridgePackageKM->pvParamOut;
	PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
	PVRSRV_KERNEL_MEM_INFO *psKernelMemInfo;


	if(PVRSRVLookupHandle(KERNEL_HANDLE_BASE,
	(IMG_PVOID *)&psKernelMemInfo,
	psExportDeviceMemOUT->hMemInfo,
	PVRSRV_HANDLE_TYPE_MEM_INFO) != PVRSRV_OK)
	{
	PVR_DPF((PVR_DBG_ERROR, "%s: Failed to look up export handle", __FUNCTION__));
	err = -EFAULT;
	goto unlock_and_return;
	}


	PVRSRVKernelMemInfoIncRef(psKernelMemInfo);

	psPrivateData->hKernelMemInfo = psExportDeviceMemOUT->hMemInfo;
	#if defined(SUPPORT_MEMINFO_IDS)
	psPrivateData->ui64Stamp = ++ui64Stamp;

	psKernelMemInfo->ui64Stamp = psPrivateData->ui64Stamp;
	if (pvr_put_user(psPrivateData->ui64Stamp, &psExportDeviceMemOUT->ui64Stamp) != 0)
	{
	err = -EFAULT;
	goto unlock_and_return;
	}
	#endif
	break;
	}

	#if defined(SUPPORT_MEMINFO_IDS)
	case PVRSRV_BRIDGE_MAP_DEV_MEMORY:
	case PVRSRV_BRIDGE_MAP_DEV_MEMORY_2:
	{
	PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY *psMapDeviceMemoryOUT =
	(PVRSRV_BRIDGE_OUT_MAP_DEV_MEMORY *)psBridgePackageKM->pvParamOut;
	PVRSRV_FILE_PRIVATE_DATA *psPrivateData = PRIVATE_DATA(pFile);
	if (pvr_put_user(psPrivateData->ui64Stamp, &psMapDeviceMemoryOUT->sDstClientMemInfo.ui64Stamp) != 0)
	{
	err = -EFAULT;
	goto unlock_and_return;
	}
	break;
	}

	case PVRSRV_BRIDGE_MAP_DEVICECLASS_MEMORY:
	{
	PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY *psDeviceClassMemoryOUT =
	(PVRSRV_BRIDGE_OUT_MAP_DEVICECLASS_MEMORY *)psBridgePackageKM->pvParamOut;
	if (pvr_put_user(++ui64Stamp, &psDeviceClassMemoryOUT->sClientMemInfo.ui64Stamp) != 0)
	{
	err = -EFAULT;
	goto unlock_and_return;
	}
	break;
	}
	#endif

	default:
	break;
	}

	unlock_and_return:
	LinuxUnLockMutex(&gPVRSRVLock);
	return err;
	}