merge 1.4_ED3632227 DDK code.
ifeq ($(BUILD),debug)
PVR_RI_DEBUG ?= 1
+SUPPORT_PAGE_FAULT_DEBUG ?= 1
$(eval $(call BothConfigC,DEBUG,))
$(eval $(call KernelConfigC,DEBUG_LINUX_MEMORY_ALLOCATIONS,))
$(eval $(call KernelConfigC,DEBUG_LINUX_MEM_AREAS,))
resource allocations with annotation to help indicate their use._\
))
+$(eval $(call TunableBothConfigMake,SUPPORT_PAGE_FAULT_DEBUG,))
+$(eval $(call TunableBothConfigC,SUPPORT_PAGE_FAULT_DEBUG,,\
+Collect information about allocations such as descriptive strings_\
+and timing data for more detailed page fault analysis._\
+))
+
$(eval $(call TunableKernelConfigC,PVRSRV_ENABLE_MEMORY_STATS,,\
Enable Memory allocations to be recorded and published via Process Statistics._\
))
--- /dev/null
+/*************************************************************************/ /*!
+@Title Direct client bridge for devicememhistory
+@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
+@License Dual MIT/GPLv2
+
+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.
+
+Alternatively, the contents of this file may be used under the terms of
+the GNU General Public License Version 2 ("GPL") in which case the provisions
+of GPL are applicable instead of those above.
+
+If you wish to allow use of your version of this file only under the terms of
+GPL, and not to allow others to use your version of this file under the terms
+of the MIT license, indicate your decision by deleting the provisions above
+and replace them with the notice and other provisions required by GPL as set
+out in the file called "GPL-COPYING" included in this distribution. If you do
+not delete the provisions above, a recipient may use your version of this file
+under the terms of either the MIT license or GPL.
+
+This License is also included in this distribution in the file called
+"MIT-COPYING".
+
+EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) 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; AND (B) 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 "client_devicememhistory_bridge.h"
+#include "img_defs.h"
+#include "pvr_debug.h"
+
+/* Module specific includes */
+#include "img_types.h"
+#include "mm_common.h"
+
+#include "devicemem_history_server.h"
+
+
+IMG_INTERNAL PVRSRV_ERROR IMG_CALLCONV BridgeDevicememHistoryMap(IMG_HANDLE hBridge,
+ IMG_DEV_VIRTADDR sDevVAddr,
+ IMG_DEVMEM_SIZE_T uiSize,
+ const IMG_CHAR *puiText)
+{
+ PVRSRV_ERROR eError;
+ PVR_UNREFERENCED_PARAMETER(hBridge);
+
+
+ eError =
+ DevicememHistoryMapKM(
+ sDevVAddr,
+ uiSize,
+ puiText);
+
+ return eError;
+}
+
+IMG_INTERNAL PVRSRV_ERROR IMG_CALLCONV BridgeDevicememHistoryUnmap(IMG_HANDLE hBridge,
+ IMG_DEV_VIRTADDR sDevVAddr,
+ IMG_DEVMEM_SIZE_T uiSize,
+ const IMG_CHAR *puiText)
+{
+ PVRSRV_ERROR eError;
+ PVR_UNREFERENCED_PARAMETER(hBridge);
+
+
+ eError =
+ DevicememHistoryUnmapKM(
+ sDevVAddr,
+ uiSize,
+ puiText);
+
+ return eError;
+}
+
--- /dev/null
+/*************************************************************************/ /*!
+@File
+@Title Client bridge header for devicememhistory
+@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
+@Description Exports the client bridge functions for devicememhistory
+@License Dual MIT/GPLv2
+
+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.
+
+Alternatively, the contents of this file may be used under the terms of
+the GNU General Public License Version 2 ("GPL") in which case the provisions
+of GPL are applicable instead of those above.
+
+If you wish to allow use of your version of this file only under the terms of
+GPL, and not to allow others to use your version of this file under the terms
+of the MIT license, indicate your decision by deleting the provisions above
+and replace them with the notice and other provisions required by GPL as set
+out in the file called "GPL-COPYING" included in this distribution. If you do
+not delete the provisions above, a recipient may use your version of this file
+under the terms of either the MIT license or GPL.
+
+This License is also included in this distribution in the file called
+"MIT-COPYING".
+
+EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) 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; AND (B) 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 CLIENT_DEVICEMEMHISTORY_BRIDGE_H
+#define CLIENT_DEVICEMEMHISTORY_BRIDGE_H
+
+#include "pvr_bridge_client.h"
+#include "pvr_bridge.h"
+
+#include "common_devicememhistory_bridge.h"
+
+IMG_INTERNAL PVRSRV_ERROR IMG_CALLCONV BridgeDevicememHistoryMap(IMG_HANDLE hBridge,
+ IMG_DEV_VIRTADDR sDevVAddr,
+ IMG_DEVMEM_SIZE_T uiSize,
+ const IMG_CHAR *puiText);
+
+IMG_INTERNAL PVRSRV_ERROR IMG_CALLCONV BridgeDevicememHistoryUnmap(IMG_HANDLE hBridge,
+ IMG_DEV_VIRTADDR sDevVAddr,
+ IMG_DEVMEM_SIZE_T uiSize,
+ const IMG_CHAR *puiText);
+
+
+#endif /* CLIENT_DEVICEMEMHISTORY_BRIDGE_H */
--- /dev/null
+/*************************************************************************/ /*!
+@File
+@Title Common bridge header for devicememhistory
+@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
+@Description Declares common defines and structures that are used by both
+ the client and sever side of the bridge for devicememhistory
+@License Dual MIT/GPLv2
+
+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.
+
+Alternatively, the contents of this file may be used under the terms of
+the GNU General Public License Version 2 ("GPL") in which case the provisions
+of GPL are applicable instead of those above.
+
+If you wish to allow use of your version of this file only under the terms of
+GPL, and not to allow others to use your version of this file under the terms
+of the MIT license, indicate your decision by deleting the provisions above
+and replace them with the notice and other provisions required by GPL as set
+out in the file called "GPL-COPYING" included in this distribution. If you do
+not delete the provisions above, a recipient may use your version of this file
+under the terms of either the MIT license or GPL.
+
+This License is also included in this distribution in the file called
+"MIT-COPYING".
+
+EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) 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; AND (B) 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 COMMON_DEVICEMEMHISTORY_BRIDGE_H
+#define COMMON_DEVICEMEMHISTORY_BRIDGE_H
+
+#include "img_types.h"
+#include "mm_common.h"
+
+
+#include "pvr_bridge_io.h"
+
+#define PVRSRV_BRIDGE_DEVICEMEMHISTORY_CMD_FIRST (PVRSRV_BRIDGE_DEVICEMEMHISTORY_START)
+#define PVRSRV_BRIDGE_DEVICEMEMHISTORY_DEVICEMEMHISTORYMAP PVRSRV_IOWR(PVRSRV_BRIDGE_DEVICEMEMHISTORY_CMD_FIRST+0)
+#define PVRSRV_BRIDGE_DEVICEMEMHISTORY_DEVICEMEMHISTORYUNMAP PVRSRV_IOWR(PVRSRV_BRIDGE_DEVICEMEMHISTORY_CMD_FIRST+1)
+#define PVRSRV_BRIDGE_DEVICEMEMHISTORY_CMD_LAST (PVRSRV_BRIDGE_DEVICEMEMHISTORY_CMD_FIRST+1)
+
+
+/*******************************************
+ DevicememHistoryMap
+ *******************************************/
+
+/* Bridge in structure for DevicememHistoryMap */
+typedef struct PVRSRV_BRIDGE_IN_DEVICEMEMHISTORYMAP_TAG
+{
+ IMG_DEV_VIRTADDR sDevVAddr;
+ IMG_DEVMEM_SIZE_T uiSize;
+ const IMG_CHAR * puiText;
+} PVRSRV_BRIDGE_IN_DEVICEMEMHISTORYMAP;
+
+
+/* Bridge out structure for DevicememHistoryMap */
+typedef struct PVRSRV_BRIDGE_OUT_DEVICEMEMHISTORYMAP_TAG
+{
+ PVRSRV_ERROR eError;
+} PVRSRV_BRIDGE_OUT_DEVICEMEMHISTORYMAP;
+
+/*******************************************
+ DevicememHistoryUnmap
+ *******************************************/
+
+/* Bridge in structure for DevicememHistoryUnmap */
+typedef struct PVRSRV_BRIDGE_IN_DEVICEMEMHISTORYUNMAP_TAG
+{
+ IMG_DEV_VIRTADDR sDevVAddr;
+ IMG_DEVMEM_SIZE_T uiSize;
+ const IMG_CHAR * puiText;
+} PVRSRV_BRIDGE_IN_DEVICEMEMHISTORYUNMAP;
+
+
+/* Bridge out structure for DevicememHistoryUnmap */
+typedef struct PVRSRV_BRIDGE_OUT_DEVICEMEMHISTORYUNMAP_TAG
+{
+ PVRSRV_ERROR eError;
+} PVRSRV_BRIDGE_OUT_DEVICEMEMHISTORYUNMAP;
+
+#endif /* COMMON_DEVICEMEMHISTORY_BRIDGE_H */
--- /dev/null
+/*************************************************************************/ /*!
+@File
+@Title Server bridge for devicememhistory
+@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
+@Description Implements the server side of the bridge for devicememhistory
+@License Dual MIT/GPLv2
+
+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.
+
+Alternatively, the contents of this file may be used under the terms of
+the GNU General Public License Version 2 ("GPL") in which case the provisions
+of GPL are applicable instead of those above.
+
+If you wish to allow use of your version of this file only under the terms of
+GPL, and not to allow others to use your version of this file under the terms
+of the MIT license, indicate your decision by deleting the provisions above
+and replace them with the notice and other provisions required by GPL as set
+out in the file called "GPL-COPYING" included in this distribution. If you do
+not delete the provisions above, a recipient may use your version of this file
+under the terms of either the MIT license or GPL.
+
+This License is also included in this distribution in the file called
+"MIT-COPYING".
+
+EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) 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; AND (B) 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 <asm/uaccess.h>
+
+#include "img_defs.h"
+
+#include "devicemem_history_server.h"
+
+
+#include "common_devicememhistory_bridge.h"
+
+#include "allocmem.h"
+#include "pvr_debug.h"
+#include "connection_server.h"
+#include "pvr_bridge.h"
+#include "rgx_bridge.h"
+#include "srvcore.h"
+#include "handle.h"
+
+#if defined (SUPPORT_AUTH)
+#include "osauth.h"
+#endif
+
+#include <linux/slab.h>
+
+/* ***************************************************************************
+ * Bridge proxy functions
+ */
+
+
+
+/* ***************************************************************************
+ * Server-side bridge entry points
+ */
+
+static IMG_INT
+PVRSRVBridgeDevicememHistoryMap(IMG_UINT32 ui32BridgeID,
+ PVRSRV_BRIDGE_IN_DEVICEMEMHISTORYMAP *psDevicememHistoryMapIN,
+ PVRSRV_BRIDGE_OUT_DEVICEMEMHISTORYMAP *psDevicememHistoryMapOUT,
+ CONNECTION_DATA *psConnection)
+{
+ IMG_CHAR *uiTextInt = IMG_NULL;
+
+ PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_DEVICEMEMHISTORY_DEVICEMEMHISTORYMAP);
+
+ PVR_UNREFERENCED_PARAMETER(psConnection);
+
+
+
+
+ {
+ uiTextInt = OSAllocMem(DEVICEMEM_HISTORY_TEXT_BUFSZ * sizeof(IMG_CHAR));
+ if (!uiTextInt)
+ {
+ psDevicememHistoryMapOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto DevicememHistoryMap_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psDevicememHistoryMapIN->puiText, DEVICEMEM_HISTORY_TEXT_BUFSZ * sizeof(IMG_CHAR))
+ || (OSCopyFromUser(NULL, uiTextInt, psDevicememHistoryMapIN->puiText,
+ DEVICEMEM_HISTORY_TEXT_BUFSZ * sizeof(IMG_CHAR)) != PVRSRV_OK) )
+ {
+ psDevicememHistoryMapOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto DevicememHistoryMap_exit;
+ }
+
+ psDevicememHistoryMapOUT->eError =
+ DevicememHistoryMapKM(
+ psDevicememHistoryMapIN->sDevVAddr,
+ psDevicememHistoryMapIN->uiSize,
+ uiTextInt);
+
+
+
+DevicememHistoryMap_exit:
+ if (uiTextInt)
+ OSFreeMem(uiTextInt);
+
+ return 0;
+}
+
+static IMG_INT
+PVRSRVBridgeDevicememHistoryUnmap(IMG_UINT32 ui32BridgeID,
+ PVRSRV_BRIDGE_IN_DEVICEMEMHISTORYUNMAP *psDevicememHistoryUnmapIN,
+ PVRSRV_BRIDGE_OUT_DEVICEMEMHISTORYUNMAP *psDevicememHistoryUnmapOUT,
+ CONNECTION_DATA *psConnection)
+{
+ IMG_CHAR *uiTextInt = IMG_NULL;
+
+ PVRSRV_BRIDGE_ASSERT_CMD(ui32BridgeID, PVRSRV_BRIDGE_DEVICEMEMHISTORY_DEVICEMEMHISTORYUNMAP);
+
+ PVR_UNREFERENCED_PARAMETER(psConnection);
+
+
+
+
+ {
+ uiTextInt = OSAllocMem(DEVICEMEM_HISTORY_TEXT_BUFSZ * sizeof(IMG_CHAR));
+ if (!uiTextInt)
+ {
+ psDevicememHistoryUnmapOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto DevicememHistoryUnmap_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psDevicememHistoryUnmapIN->puiText, DEVICEMEM_HISTORY_TEXT_BUFSZ * sizeof(IMG_CHAR))
+ || (OSCopyFromUser(NULL, uiTextInt, psDevicememHistoryUnmapIN->puiText,
+ DEVICEMEM_HISTORY_TEXT_BUFSZ * sizeof(IMG_CHAR)) != PVRSRV_OK) )
+ {
+ psDevicememHistoryUnmapOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto DevicememHistoryUnmap_exit;
+ }
+
+ psDevicememHistoryUnmapOUT->eError =
+ DevicememHistoryUnmapKM(
+ psDevicememHistoryUnmapIN->sDevVAddr,
+ psDevicememHistoryUnmapIN->uiSize,
+ uiTextInt);
+
+
+
+DevicememHistoryUnmap_exit:
+ if (uiTextInt)
+ OSFreeMem(uiTextInt);
+
+ return 0;
+}
+
+
+
+/* ***************************************************************************
+ * Server bridge dispatch related glue
+ */
+
+PVRSRV_ERROR RegisterDEVICEMEMHISTORYFunctions(IMG_VOID);
+IMG_VOID UnregisterDEVICEMEMHISTORYFunctions(IMG_VOID);
+
+/*
+ * Register all DEVICEMEMHISTORY functions with services
+ */
+PVRSRV_ERROR RegisterDEVICEMEMHISTORYFunctions(IMG_VOID)
+{
+ SetDispatchTableEntry(PVRSRV_BRIDGE_DEVICEMEMHISTORY_DEVICEMEMHISTORYMAP, PVRSRVBridgeDevicememHistoryMap);
+ SetDispatchTableEntry(PVRSRV_BRIDGE_DEVICEMEMHISTORY_DEVICEMEMHISTORYUNMAP, PVRSRVBridgeDevicememHistoryUnmap);
+
+ return PVRSRV_OK;
+}
+
+/*
+ * Unregister all devicememhistory functions with services
+ */
+IMG_VOID UnregisterDEVICEMEMHISTORYFunctions(IMG_VOID)
+{
+}
{
IMG_HANDLE hComputeContext;
IMG_UINT32 ui32ClientFenceCount;
- PRGXFWIF_UFO_ADDR * psClientFenceUFOAddress;
+ IMG_HANDLE * phClientFenceUFOSyncPrimBlock;
+ IMG_UINT32 * pui32ClientFenceSyncOffset;
IMG_UINT32 * pui32ClientFenceValue;
IMG_UINT32 ui32ClientUpdateCount;
- PRGXFWIF_UFO_ADDR * psClientUpdateUFOAddress;
+ IMG_HANDLE * phClientUpdateUFOSyncPrimBlock;
+ IMG_UINT32 * pui32ClientUpdateSyncOffset;
IMG_UINT32 * pui32ClientUpdateValue;
IMG_UINT32 ui32ServerSyncCount;
IMG_UINT32 * pui32ServerSyncFlags;
{
IMG_HANDLE hComputeContext;
IMG_UINT32 ui32ClientFenceCount;
- PRGXFWIF_UFO_ADDR * psClientFenceUFOAddress;
+ IMG_HANDLE * phClientFenceUFOSyncPrimBlock;
+ IMG_UINT32 * pui32ClientFenceSyncOffset;
IMG_UINT32 * pui32ClientFenceValue;
IMG_UINT32 ui32ClientUpdateCount;
- PRGXFWIF_UFO_ADDR * psClientUpdateUFOAddress;
+ IMG_HANDLE * phClientUpdateUFOSyncPrimBlock;
+ IMG_UINT32 * pui32ClientUpdateSyncOffset;
IMG_UINT32 * pui32ClientUpdateValue;
IMG_UINT32 ui32ServerSyncCount;
IMG_UINT32 * pui32ServerSyncFlags;
{
RGX_SERVER_COMPUTE_CONTEXT * psComputeContextInt = IMG_NULL;
IMG_HANDLE hComputeContextInt2 = IMG_NULL;
- PRGXFWIF_UFO_ADDR *sClientFenceUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * *psClientFenceUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE *hClientFenceUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 *ui32ClientFenceSyncOffsetInt = IMG_NULL;
IMG_UINT32 *ui32ClientFenceValueInt = IMG_NULL;
- PRGXFWIF_UFO_ADDR *sClientUpdateUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * *psClientUpdateUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE *hClientUpdateUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 *ui32ClientUpdateSyncOffsetInt = IMG_NULL;
IMG_UINT32 *ui32ClientUpdateValueInt = IMG_NULL;
IMG_UINT32 *ui32ServerSyncFlagsInt = IMG_NULL;
SERVER_SYNC_PRIMITIVE * *psServerSyncsInt = IMG_NULL;
if (psRGXKickCDMIN->ui32ClientFenceCount != 0)
{
- sClientFenceUFOAddressInt = OSAllocMem(psRGXKickCDMIN->ui32ClientFenceCount * sizeof(PRGXFWIF_UFO_ADDR));
- if (!sClientFenceUFOAddressInt)
+ psClientFenceUFOSyncPrimBlockInt = OSAllocMem(psRGXKickCDMIN->ui32ClientFenceCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
+ if (!psClientFenceUFOSyncPrimBlockInt)
+ {
+ psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickCDM_exit;
+ }
+ hClientFenceUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_HANDLE));
+ if (!hClientFenceUFOSyncPrimBlockInt2)
+ {
+ psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickCDM_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->phClientFenceUFOSyncPrimBlock, psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_HANDLE))
+ || (OSCopyFromUser(NULL, hClientFenceUFOSyncPrimBlockInt2, psRGXKickCDMIN->phClientFenceUFOSyncPrimBlock,
+ psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
+ {
+ psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXKickCDM_exit;
+ }
+ if (psRGXKickCDMIN->ui32ClientFenceCount != 0)
+ {
+ ui32ClientFenceSyncOffsetInt = OSAllocMem(psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32));
+ if (!ui32ClientFenceSyncOffsetInt)
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->psClientFenceUFOAddress, psRGXKickCDMIN->ui32ClientFenceCount * sizeof(PRGXFWIF_UFO_ADDR))
- || (OSCopyFromUser(NULL, sClientFenceUFOAddressInt, psRGXKickCDMIN->psClientFenceUFOAddress,
- psRGXKickCDMIN->ui32ClientFenceCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->pui32ClientFenceSyncOffset, psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32))
+ || (OSCopyFromUser(NULL, ui32ClientFenceSyncOffsetInt, psRGXKickCDMIN->pui32ClientFenceSyncOffset,
+ psRGXKickCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
if (psRGXKickCDMIN->ui32ClientUpdateCount != 0)
{
- sClientUpdateUFOAddressInt = OSAllocMem(psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(PRGXFWIF_UFO_ADDR));
- if (!sClientUpdateUFOAddressInt)
+ psClientUpdateUFOSyncPrimBlockInt = OSAllocMem(psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
+ if (!psClientUpdateUFOSyncPrimBlockInt)
+ {
+ psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickCDM_exit;
+ }
+ hClientUpdateUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE));
+ if (!hClientUpdateUFOSyncPrimBlockInt2)
+ {
+ psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickCDM_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->phClientUpdateUFOSyncPrimBlock, psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE))
+ || (OSCopyFromUser(NULL, hClientUpdateUFOSyncPrimBlockInt2, psRGXKickCDMIN->phClientUpdateUFOSyncPrimBlock,
+ psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
+ {
+ psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXKickCDM_exit;
+ }
+ if (psRGXKickCDMIN->ui32ClientUpdateCount != 0)
+ {
+ ui32ClientUpdateSyncOffsetInt = OSAllocMem(psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32));
+ if (!ui32ClientUpdateSyncOffsetInt)
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->psClientUpdateUFOAddress, psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(PRGXFWIF_UFO_ADDR))
- || (OSCopyFromUser(NULL, sClientUpdateUFOAddressInt, psRGXKickCDMIN->psClientUpdateUFOAddress,
- psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickCDMIN->pui32ClientUpdateSyncOffset, psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32))
+ || (OSCopyFromUser(NULL, ui32ClientUpdateSyncOffsetInt, psRGXKickCDMIN->pui32ClientUpdateSyncOffset,
+ psRGXKickCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
}
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXKickCDMIN->ui32ClientFenceCount;i++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXKickCDMOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hClientFenceUFOSyncPrimBlockInt2[i],
+ hClientFenceUFOSyncPrimBlockInt2[i],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickCDMOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickCDM_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickCDMOUT->eError = ResManFindPrivateDataByPtr(hClientFenceUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClientFenceUFOSyncPrimBlockInt[i]);
+
+ if(psRGXKickCDMOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickCDM_exit;
+ }
+ }
+ }
+ }
+
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXKickCDMIN->ui32ClientUpdateCount;i++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXKickCDMOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hClientUpdateUFOSyncPrimBlockInt2[i],
+ hClientUpdateUFOSyncPrimBlockInt2[i],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickCDMOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickCDM_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickCDMOUT->eError = ResManFindPrivateDataByPtr(hClientUpdateUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClientUpdateUFOSyncPrimBlockInt[i]);
+
+ if(psRGXKickCDMOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickCDM_exit;
+ }
+ }
+ }
+ }
+
{
IMG_UINT32 i;
PVRSRVRGXKickCDMKM(
psComputeContextInt,
psRGXKickCDMIN->ui32ClientFenceCount,
- sClientFenceUFOAddressInt,
+ psClientFenceUFOSyncPrimBlockInt,
+ ui32ClientFenceSyncOffsetInt,
ui32ClientFenceValueInt,
psRGXKickCDMIN->ui32ClientUpdateCount,
- sClientUpdateUFOAddressInt,
+ psClientUpdateUFOSyncPrimBlockInt,
+ ui32ClientUpdateSyncOffsetInt,
ui32ClientUpdateValueInt,
psRGXKickCDMIN->ui32ServerSyncCount,
ui32ServerSyncFlagsInt,
RGXKickCDM_exit:
- if (sClientFenceUFOAddressInt)
- OSFreeMem(sClientFenceUFOAddressInt);
+ if (psClientFenceUFOSyncPrimBlockInt)
+ OSFreeMem(psClientFenceUFOSyncPrimBlockInt);
+ if (hClientFenceUFOSyncPrimBlockInt2)
+ OSFreeMem(hClientFenceUFOSyncPrimBlockInt2);
+ if (ui32ClientFenceSyncOffsetInt)
+ OSFreeMem(ui32ClientFenceSyncOffsetInt);
if (ui32ClientFenceValueInt)
OSFreeMem(ui32ClientFenceValueInt);
- if (sClientUpdateUFOAddressInt)
- OSFreeMem(sClientUpdateUFOAddressInt);
+ if (psClientUpdateUFOSyncPrimBlockInt)
+ OSFreeMem(psClientUpdateUFOSyncPrimBlockInt);
+ if (hClientUpdateUFOSyncPrimBlockInt2)
+ OSFreeMem(hClientUpdateUFOSyncPrimBlockInt2);
+ if (ui32ClientUpdateSyncOffsetInt)
+ OSFreeMem(ui32ClientUpdateSyncOffsetInt);
if (ui32ClientUpdateValueInt)
OSFreeMem(ui32ClientUpdateValueInt);
if (ui32ServerSyncFlagsInt)
{
RGX_SERVER_COMPUTE_CONTEXT * psComputeContextInt = IMG_NULL;
IMG_HANDLE hComputeContextInt2 = IMG_NULL;
- PRGXFWIF_UFO_ADDR *sClientFenceUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * *psClientFenceUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE *hClientFenceUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 *ui32ClientFenceSyncOffsetInt = IMG_NULL;
IMG_UINT32 *ui32ClientFenceValueInt = IMG_NULL;
- PRGXFWIF_UFO_ADDR *sClientUpdateUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * *psClientUpdateUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE *hClientUpdateUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 *ui32ClientUpdateSyncOffsetInt = IMG_NULL;
IMG_UINT32 *ui32ClientUpdateValueInt = IMG_NULL;
IMG_UINT32 *ui32ServerSyncFlagsInt = IMG_NULL;
SERVER_SYNC_PRIMITIVE * *psServerSyncsInt = IMG_NULL;
if (psRGXKickSyncCDMIN->ui32ClientFenceCount != 0)
{
- sClientFenceUFOAddressInt = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(PRGXFWIF_UFO_ADDR));
- if (!sClientFenceUFOAddressInt)
+ psClientFenceUFOSyncPrimBlockInt = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
+ if (!psClientFenceUFOSyncPrimBlockInt)
+ {
+ psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncCDM_exit;
+ }
+ hClientFenceUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_HANDLE));
+ if (!hClientFenceUFOSyncPrimBlockInt2)
+ {
+ psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncCDM_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->phClientFenceUFOSyncPrimBlock, psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_HANDLE))
+ || (OSCopyFromUser(NULL, hClientFenceUFOSyncPrimBlockInt2, psRGXKickSyncCDMIN->phClientFenceUFOSyncPrimBlock,
+ psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
+ {
+ psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXKickSyncCDM_exit;
+ }
+ if (psRGXKickSyncCDMIN->ui32ClientFenceCount != 0)
+ {
+ ui32ClientFenceSyncOffsetInt = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32));
+ if (!ui32ClientFenceSyncOffsetInt)
{
psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->psClientFenceUFOAddress, psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(PRGXFWIF_UFO_ADDR))
- || (OSCopyFromUser(NULL, sClientFenceUFOAddressInt, psRGXKickSyncCDMIN->psClientFenceUFOAddress,
- psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->pui32ClientFenceSyncOffset, psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32))
+ || (OSCopyFromUser(NULL, ui32ClientFenceSyncOffsetInt, psRGXKickSyncCDMIN->pui32ClientFenceSyncOffset,
+ psRGXKickSyncCDMIN->ui32ClientFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
if (psRGXKickSyncCDMIN->ui32ClientUpdateCount != 0)
{
- sClientUpdateUFOAddressInt = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(PRGXFWIF_UFO_ADDR));
- if (!sClientUpdateUFOAddressInt)
+ psClientUpdateUFOSyncPrimBlockInt = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
+ if (!psClientUpdateUFOSyncPrimBlockInt)
+ {
+ psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncCDM_exit;
+ }
+ hClientUpdateUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE));
+ if (!hClientUpdateUFOSyncPrimBlockInt2)
+ {
+ psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncCDM_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->phClientUpdateUFOSyncPrimBlock, psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE))
+ || (OSCopyFromUser(NULL, hClientUpdateUFOSyncPrimBlockInt2, psRGXKickSyncCDMIN->phClientUpdateUFOSyncPrimBlock,
+ psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
+ {
+ psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXKickSyncCDM_exit;
+ }
+ if (psRGXKickSyncCDMIN->ui32ClientUpdateCount != 0)
+ {
+ ui32ClientUpdateSyncOffsetInt = OSAllocMem(psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32));
+ if (!ui32ClientUpdateSyncOffsetInt)
{
psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->psClientUpdateUFOAddress, psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(PRGXFWIF_UFO_ADDR))
- || (OSCopyFromUser(NULL, sClientUpdateUFOAddressInt, psRGXKickSyncCDMIN->psClientUpdateUFOAddress,
- psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncCDMIN->pui32ClientUpdateSyncOffset, psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32))
+ || (OSCopyFromUser(NULL, ui32ClientUpdateSyncOffsetInt, psRGXKickSyncCDMIN->pui32ClientUpdateSyncOffset,
+ psRGXKickSyncCDMIN->ui32ClientUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickSyncCDMOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
}
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXKickSyncCDMIN->ui32ClientFenceCount;i++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXKickSyncCDMOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hClientFenceUFOSyncPrimBlockInt2[i],
+ hClientFenceUFOSyncPrimBlockInt2[i],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickSyncCDMOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncCDM_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickSyncCDMOUT->eError = ResManFindPrivateDataByPtr(hClientFenceUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClientFenceUFOSyncPrimBlockInt[i]);
+
+ if(psRGXKickSyncCDMOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncCDM_exit;
+ }
+ }
+ }
+ }
+
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXKickSyncCDMIN->ui32ClientUpdateCount;i++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXKickSyncCDMOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hClientUpdateUFOSyncPrimBlockInt2[i],
+ hClientUpdateUFOSyncPrimBlockInt2[i],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickSyncCDMOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncCDM_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickSyncCDMOUT->eError = ResManFindPrivateDataByPtr(hClientUpdateUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClientUpdateUFOSyncPrimBlockInt[i]);
+
+ if(psRGXKickSyncCDMOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncCDM_exit;
+ }
+ }
+ }
+ }
+
{
IMG_UINT32 i;
PVRSRVRGXKickSyncCDMKM(
psComputeContextInt,
psRGXKickSyncCDMIN->ui32ClientFenceCount,
- sClientFenceUFOAddressInt,
+ psClientFenceUFOSyncPrimBlockInt,
+ ui32ClientFenceSyncOffsetInt,
ui32ClientFenceValueInt,
psRGXKickSyncCDMIN->ui32ClientUpdateCount,
- sClientUpdateUFOAddressInt,
+ psClientUpdateUFOSyncPrimBlockInt,
+ ui32ClientUpdateSyncOffsetInt,
ui32ClientUpdateValueInt,
psRGXKickSyncCDMIN->ui32ServerSyncCount,
ui32ServerSyncFlagsInt,
RGXKickSyncCDM_exit:
- if (sClientFenceUFOAddressInt)
- OSFreeMem(sClientFenceUFOAddressInt);
+ if (psClientFenceUFOSyncPrimBlockInt)
+ OSFreeMem(psClientFenceUFOSyncPrimBlockInt);
+ if (hClientFenceUFOSyncPrimBlockInt2)
+ OSFreeMem(hClientFenceUFOSyncPrimBlockInt2);
+ if (ui32ClientFenceSyncOffsetInt)
+ OSFreeMem(ui32ClientFenceSyncOffsetInt);
if (ui32ClientFenceValueInt)
OSFreeMem(ui32ClientFenceValueInt);
- if (sClientUpdateUFOAddressInt)
- OSFreeMem(sClientUpdateUFOAddressInt);
+ if (psClientUpdateUFOSyncPrimBlockInt)
+ OSFreeMem(psClientUpdateUFOSyncPrimBlockInt);
+ if (hClientUpdateUFOSyncPrimBlockInt2)
+ OSFreeMem(hClientUpdateUFOSyncPrimBlockInt2);
+ if (ui32ClientUpdateSyncOffsetInt)
+ OSFreeMem(ui32ClientUpdateSyncOffsetInt);
if (ui32ClientUpdateValueInt)
OSFreeMem(ui32ClientUpdateValueInt);
if (ui32ServerSyncFlagsInt)
{
IMG_HANDLE hRenderContext;
IMG_UINT32 ui32ClientTAFenceCount;
- PRGXFWIF_UFO_ADDR * psClientTAFenceUFOAddress;
+ IMG_HANDLE * phClientTAFenceUFOSyncPrimBlock;
+ IMG_UINT32 * pui32ClientTAFenceSyncOffset;
IMG_UINT32 * pui32ClientTAFenceValue;
IMG_UINT32 ui32ClientTAUpdateCount;
- PRGXFWIF_UFO_ADDR * psClientTAUpdateUFOAddress;
+ IMG_HANDLE * phClientTAUpdateUFOSyncPrimBlock;
+ IMG_UINT32 * pui32ClientTAUpdateSyncOffset;
IMG_UINT32 * pui32ClientTAUpdateValue;
IMG_UINT32 ui32ServerTASyncPrims;
IMG_UINT32 * pui32ServerTASyncFlags;
IMG_HANDLE * phServerTASyncs;
IMG_UINT32 ui32Client3DFenceCount;
- PRGXFWIF_UFO_ADDR * psClient3DFenceUFOAddress;
+ IMG_HANDLE * phClient3DFenceUFOSyncPrimBlock;
+ IMG_UINT32 * pui32Client3DFenceSyncOffset;
IMG_UINT32 * pui32Client3DFenceValue;
IMG_UINT32 ui32Client3DUpdateCount;
- PRGXFWIF_UFO_ADDR * psClient3DUpdateUFOAddress;
+ IMG_HANDLE * phClient3DUpdateUFOSyncPrimBlock;
+ IMG_UINT32 * pui32Client3DUpdateSyncOffset;
IMG_UINT32 * pui32Client3DUpdateValue;
IMG_UINT32 ui32Server3DSyncPrims;
IMG_UINT32 * pui32Server3DSyncFlags;
IMG_HANDLE * phServer3DSyncs;
- PRGXFWIF_UFO_ADDR sPRFenceUFOAddress;
+ IMG_HANDLE hPRFenceUFOSyncPrimBlock;
+ IMG_UINT32 ui32FRFenceUFOSyncOffset;
IMG_UINT32 ui32FRFenceValue;
IMG_UINT32 ui32NumFenceFds;
IMG_INT32 * pi32FenceFds;
{
IMG_HANDLE hRenderContext;
IMG_UINT32 ui32ClientTAFenceCount;
- PRGXFWIF_UFO_ADDR * psClientTAFenceUFOAddress;
+ IMG_HANDLE * phClientTAFenceUFOSyncPrimBlock;
+ IMG_UINT32 * pui32ClientTAFenceSyncOffset;
IMG_UINT32 * pui32ClientTAFenceValue;
IMG_UINT32 ui32ClientTAUpdateCount;
- PRGXFWIF_UFO_ADDR * psClientTAUpdateUFOAddress;
+ IMG_HANDLE * phClientTAUpdateUFOSyncPrimBlock;
+ IMG_UINT32 * pui32ClientTAUpdateSyncOffset;
IMG_UINT32 * pui32ClientTAUpdateValue;
IMG_UINT32 ui32ServerTASyncPrims;
IMG_UINT32 * pui32ServerTASyncFlags;
IMG_HANDLE * phServerTASyncs;
IMG_UINT32 ui32Client3DFenceCount;
- PRGXFWIF_UFO_ADDR * psClient3DFenceUFOAddress;
+ IMG_HANDLE * phClient3DFenceUFOSyncPrimBlock;
+ IMG_UINT32 * pui32Client3DFenceSyncOffset;
IMG_UINT32 * pui32Client3DFenceValue;
IMG_UINT32 ui32Client3DUpdateCount;
- PRGXFWIF_UFO_ADDR * psClient3DUpdateUFOAddress;
+ IMG_HANDLE * phClient3DUpdateUFOSyncPrimBlock;
+ IMG_UINT32 * pui32Client3DUpdateSyncOffset;
IMG_UINT32 * pui32Client3DUpdateValue;
IMG_UINT32 ui32Server3DSyncPrims;
IMG_UINT32 * pui32Server3DSyncFlags;
{
RGX_SERVER_RENDER_CONTEXT * psRenderContextInt = IMG_NULL;
IMG_HANDLE hRenderContextInt2 = IMG_NULL;
- PRGXFWIF_UFO_ADDR *sClientTAFenceUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * *psClientTAFenceUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE *hClientTAFenceUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 *ui32ClientTAFenceSyncOffsetInt = IMG_NULL;
IMG_UINT32 *ui32ClientTAFenceValueInt = IMG_NULL;
- PRGXFWIF_UFO_ADDR *sClientTAUpdateUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * *psClientTAUpdateUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE *hClientTAUpdateUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 *ui32ClientTAUpdateSyncOffsetInt = IMG_NULL;
IMG_UINT32 *ui32ClientTAUpdateValueInt = IMG_NULL;
IMG_UINT32 *ui32ServerTASyncFlagsInt = IMG_NULL;
SERVER_SYNC_PRIMITIVE * *psServerTASyncsInt = IMG_NULL;
IMG_HANDLE *hServerTASyncsInt2 = IMG_NULL;
- PRGXFWIF_UFO_ADDR *sClient3DFenceUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * *psClient3DFenceUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE *hClient3DFenceUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 *ui32Client3DFenceSyncOffsetInt = IMG_NULL;
IMG_UINT32 *ui32Client3DFenceValueInt = IMG_NULL;
- PRGXFWIF_UFO_ADDR *sClient3DUpdateUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * *psClient3DUpdateUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE *hClient3DUpdateUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 *ui32Client3DUpdateSyncOffsetInt = IMG_NULL;
IMG_UINT32 *ui32Client3DUpdateValueInt = IMG_NULL;
IMG_UINT32 *ui32Server3DSyncFlagsInt = IMG_NULL;
SERVER_SYNC_PRIMITIVE * *psServer3DSyncsInt = IMG_NULL;
IMG_HANDLE *hServer3DSyncsInt2 = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * psPRFenceUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE hPRFenceUFOSyncPrimBlockInt2 = IMG_NULL;
IMG_INT32 *i32FenceFdsInt = IMG_NULL;
IMG_BYTE *psTACmdInt = IMG_NULL;
IMG_BYTE *ps3DPRCmdInt = IMG_NULL;
if (psRGXKickTA3DIN->ui32ClientTAFenceCount != 0)
{
- sClientTAFenceUFOAddressInt = OSAllocMem(psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(PRGXFWIF_UFO_ADDR));
- if (!sClientTAFenceUFOAddressInt)
+ psClientTAFenceUFOSyncPrimBlockInt = OSAllocMem(psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
+ if (!psClientTAFenceUFOSyncPrimBlockInt)
+ {
+ psRGXKickTA3DOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickTA3D_exit;
+ }
+ hClientTAFenceUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_HANDLE));
+ if (!hClientTAFenceUFOSyncPrimBlockInt2)
+ {
+ psRGXKickTA3DOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickTA3D_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickTA3DIN->phClientTAFenceUFOSyncPrimBlock, psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_HANDLE))
+ || (OSCopyFromUser(NULL, hClientTAFenceUFOSyncPrimBlockInt2, psRGXKickTA3DIN->phClientTAFenceUFOSyncPrimBlock,
+ psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
+ {
+ psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXKickTA3D_exit;
+ }
+ if (psRGXKickTA3DIN->ui32ClientTAFenceCount != 0)
+ {
+ ui32ClientTAFenceSyncOffsetInt = OSAllocMem(psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_UINT32));
+ if (!ui32ClientTAFenceSyncOffsetInt)
{
psRGXKickTA3DOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickTA3DIN->psClientTAFenceUFOAddress, psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(PRGXFWIF_UFO_ADDR))
- || (OSCopyFromUser(NULL, sClientTAFenceUFOAddressInt, psRGXKickTA3DIN->psClientTAFenceUFOAddress,
- psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickTA3DIN->pui32ClientTAFenceSyncOffset, psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_UINT32))
+ || (OSCopyFromUser(NULL, ui32ClientTAFenceSyncOffsetInt, psRGXKickTA3DIN->pui32ClientTAFenceSyncOffset,
+ psRGXKickTA3DIN->ui32ClientTAFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
if (psRGXKickTA3DIN->ui32ClientTAUpdateCount != 0)
{
- sClientTAUpdateUFOAddressInt = OSAllocMem(psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(PRGXFWIF_UFO_ADDR));
- if (!sClientTAUpdateUFOAddressInt)
+ psClientTAUpdateUFOSyncPrimBlockInt = OSAllocMem(psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
+ if (!psClientTAUpdateUFOSyncPrimBlockInt)
+ {
+ psRGXKickTA3DOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickTA3D_exit;
+ }
+ hClientTAUpdateUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_HANDLE));
+ if (!hClientTAUpdateUFOSyncPrimBlockInt2)
{
psRGXKickTA3DOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickTA3DIN->psClientTAUpdateUFOAddress, psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(PRGXFWIF_UFO_ADDR))
- || (OSCopyFromUser(NULL, sClientTAUpdateUFOAddressInt, psRGXKickTA3DIN->psClientTAUpdateUFOAddress,
- psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickTA3DIN->phClientTAUpdateUFOSyncPrimBlock, psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_HANDLE))
+ || (OSCopyFromUser(NULL, hClientTAUpdateUFOSyncPrimBlockInt2, psRGXKickTA3DIN->phClientTAUpdateUFOSyncPrimBlock,
+ psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
+ {
+ psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXKickTA3D_exit;
+ }
+ if (psRGXKickTA3DIN->ui32ClientTAUpdateCount != 0)
+ {
+ ui32ClientTAUpdateSyncOffsetInt = OSAllocMem(psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_UINT32));
+ if (!ui32ClientTAUpdateSyncOffsetInt)
+ {
+ psRGXKickTA3DOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickTA3D_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickTA3DIN->pui32ClientTAUpdateSyncOffset, psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_UINT32))
+ || (OSCopyFromUser(NULL, ui32ClientTAUpdateSyncOffsetInt, psRGXKickTA3DIN->pui32ClientTAUpdateSyncOffset,
+ psRGXKickTA3DIN->ui32ClientTAUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
if (psRGXKickTA3DIN->ui32Client3DFenceCount != 0)
{
- sClient3DFenceUFOAddressInt = OSAllocMem(psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(PRGXFWIF_UFO_ADDR));
- if (!sClient3DFenceUFOAddressInt)
+ psClient3DFenceUFOSyncPrimBlockInt = OSAllocMem(psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
+ if (!psClient3DFenceUFOSyncPrimBlockInt)
+ {
+ psRGXKickTA3DOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickTA3D_exit;
+ }
+ hClient3DFenceUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_HANDLE));
+ if (!hClient3DFenceUFOSyncPrimBlockInt2)
{
psRGXKickTA3DOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickTA3DIN->psClient3DFenceUFOAddress, psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(PRGXFWIF_UFO_ADDR))
- || (OSCopyFromUser(NULL, sClient3DFenceUFOAddressInt, psRGXKickTA3DIN->psClient3DFenceUFOAddress,
- psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickTA3DIN->phClient3DFenceUFOSyncPrimBlock, psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_HANDLE))
+ || (OSCopyFromUser(NULL, hClient3DFenceUFOSyncPrimBlockInt2, psRGXKickTA3DIN->phClient3DFenceUFOSyncPrimBlock,
+ psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
+ {
+ psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXKickTA3D_exit;
+ }
+ if (psRGXKickTA3DIN->ui32Client3DFenceCount != 0)
+ {
+ ui32Client3DFenceSyncOffsetInt = OSAllocMem(psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_UINT32));
+ if (!ui32Client3DFenceSyncOffsetInt)
+ {
+ psRGXKickTA3DOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickTA3D_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickTA3DIN->pui32Client3DFenceSyncOffset, psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_UINT32))
+ || (OSCopyFromUser(NULL, ui32Client3DFenceSyncOffsetInt, psRGXKickTA3DIN->pui32Client3DFenceSyncOffset,
+ psRGXKickTA3DIN->ui32Client3DFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
if (psRGXKickTA3DIN->ui32Client3DUpdateCount != 0)
{
- sClient3DUpdateUFOAddressInt = OSAllocMem(psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(PRGXFWIF_UFO_ADDR));
- if (!sClient3DUpdateUFOAddressInt)
+ psClient3DUpdateUFOSyncPrimBlockInt = OSAllocMem(psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
+ if (!psClient3DUpdateUFOSyncPrimBlockInt)
+ {
+ psRGXKickTA3DOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickTA3D_exit;
+ }
+ hClient3DUpdateUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_HANDLE));
+ if (!hClient3DUpdateUFOSyncPrimBlockInt2)
+ {
+ psRGXKickTA3DOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickTA3D_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickTA3DIN->phClient3DUpdateUFOSyncPrimBlock, psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_HANDLE))
+ || (OSCopyFromUser(NULL, hClient3DUpdateUFOSyncPrimBlockInt2, psRGXKickTA3DIN->phClient3DUpdateUFOSyncPrimBlock,
+ psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
+ {
+ psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXKickTA3D_exit;
+ }
+ if (psRGXKickTA3DIN->ui32Client3DUpdateCount != 0)
+ {
+ ui32Client3DUpdateSyncOffsetInt = OSAllocMem(psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_UINT32));
+ if (!ui32Client3DUpdateSyncOffsetInt)
{
psRGXKickTA3DOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickTA3DIN->psClient3DUpdateUFOAddress, psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(PRGXFWIF_UFO_ADDR))
- || (OSCopyFromUser(NULL, sClient3DUpdateUFOAddressInt, psRGXKickTA3DIN->psClient3DUpdateUFOAddress,
- psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickTA3DIN->pui32Client3DUpdateSyncOffset, psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_UINT32))
+ || (OSCopyFromUser(NULL, ui32Client3DUpdateSyncOffsetInt, psRGXKickTA3DIN->pui32Client3DUpdateSyncOffset,
+ psRGXKickTA3DIN->ui32Client3DUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickTA3DOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
}
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXKickTA3DIN->ui32ClientTAFenceCount;i++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXKickTA3DOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hClientTAFenceUFOSyncPrimBlockInt2[i],
+ hClientTAFenceUFOSyncPrimBlockInt2[i],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickTA3D_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickTA3DOUT->eError = ResManFindPrivateDataByPtr(hClientTAFenceUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClientTAFenceUFOSyncPrimBlockInt[i]);
+
+ if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickTA3D_exit;
+ }
+ }
+ }
+ }
+
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXKickTA3DIN->ui32ClientTAUpdateCount;i++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXKickTA3DOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hClientTAUpdateUFOSyncPrimBlockInt2[i],
+ hClientTAUpdateUFOSyncPrimBlockInt2[i],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickTA3D_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickTA3DOUT->eError = ResManFindPrivateDataByPtr(hClientTAUpdateUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClientTAUpdateUFOSyncPrimBlockInt[i]);
+
+ if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickTA3D_exit;
+ }
+ }
+ }
+ }
+
{
IMG_UINT32 i;
}
}
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXKickTA3DIN->ui32Client3DFenceCount;i++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXKickTA3DOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hClient3DFenceUFOSyncPrimBlockInt2[i],
+ hClient3DFenceUFOSyncPrimBlockInt2[i],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickTA3D_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickTA3DOUT->eError = ResManFindPrivateDataByPtr(hClient3DFenceUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClient3DFenceUFOSyncPrimBlockInt[i]);
+
+ if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickTA3D_exit;
+ }
+ }
+ }
+ }
+
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXKickTA3DIN->ui32Client3DUpdateCount;i++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXKickTA3DOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hClient3DUpdateUFOSyncPrimBlockInt2[i],
+ hClient3DUpdateUFOSyncPrimBlockInt2[i],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickTA3D_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickTA3DOUT->eError = ResManFindPrivateDataByPtr(hClient3DUpdateUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClient3DUpdateUFOSyncPrimBlockInt[i]);
+
+ if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickTA3D_exit;
+ }
+ }
+ }
+ }
+
{
IMG_UINT32 i;
}
}
+ {
+ /* Look up the address from the handle */
+ psRGXKickTA3DOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hPRFenceUFOSyncPrimBlockInt2,
+ psRGXKickTA3DIN->hPRFenceUFOSyncPrimBlock,
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickTA3D_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickTA3DOUT->eError = ResManFindPrivateDataByPtr(hPRFenceUFOSyncPrimBlockInt2, (IMG_VOID **) &psPRFenceUFOSyncPrimBlockInt);
+
+ if(psRGXKickTA3DOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickTA3D_exit;
+ }
+ }
+
if (psRGXKickTA3DIN->hRTDataCleanup)
{
/* Look up the address from the handle */
PVRSRVRGXKickTA3DKM(
psRenderContextInt,
psRGXKickTA3DIN->ui32ClientTAFenceCount,
- sClientTAFenceUFOAddressInt,
+ psClientTAFenceUFOSyncPrimBlockInt,
+ ui32ClientTAFenceSyncOffsetInt,
ui32ClientTAFenceValueInt,
psRGXKickTA3DIN->ui32ClientTAUpdateCount,
- sClientTAUpdateUFOAddressInt,
+ psClientTAUpdateUFOSyncPrimBlockInt,
+ ui32ClientTAUpdateSyncOffsetInt,
ui32ClientTAUpdateValueInt,
psRGXKickTA3DIN->ui32ServerTASyncPrims,
ui32ServerTASyncFlagsInt,
psServerTASyncsInt,
psRGXKickTA3DIN->ui32Client3DFenceCount,
- sClient3DFenceUFOAddressInt,
+ psClient3DFenceUFOSyncPrimBlockInt,
+ ui32Client3DFenceSyncOffsetInt,
ui32Client3DFenceValueInt,
psRGXKickTA3DIN->ui32Client3DUpdateCount,
- sClient3DUpdateUFOAddressInt,
+ psClient3DUpdateUFOSyncPrimBlockInt,
+ ui32Client3DUpdateSyncOffsetInt,
ui32Client3DUpdateValueInt,
psRGXKickTA3DIN->ui32Server3DSyncPrims,
ui32Server3DSyncFlagsInt,
psServer3DSyncsInt,
- psRGXKickTA3DIN->sPRFenceUFOAddress,
+ psPRFenceUFOSyncPrimBlockInt,
+ psRGXKickTA3DIN->ui32FRFenceUFOSyncOffset,
psRGXKickTA3DIN->ui32FRFenceValue,
psRGXKickTA3DIN->ui32NumFenceFds,
i32FenceFdsInt,
RGXKickTA3D_exit:
- if (sClientTAFenceUFOAddressInt)
- OSFreeMem(sClientTAFenceUFOAddressInt);
+ if (psClientTAFenceUFOSyncPrimBlockInt)
+ OSFreeMem(psClientTAFenceUFOSyncPrimBlockInt);
+ if (hClientTAFenceUFOSyncPrimBlockInt2)
+ OSFreeMem(hClientTAFenceUFOSyncPrimBlockInt2);
+ if (ui32ClientTAFenceSyncOffsetInt)
+ OSFreeMem(ui32ClientTAFenceSyncOffsetInt);
if (ui32ClientTAFenceValueInt)
OSFreeMem(ui32ClientTAFenceValueInt);
- if (sClientTAUpdateUFOAddressInt)
- OSFreeMem(sClientTAUpdateUFOAddressInt);
+ if (psClientTAUpdateUFOSyncPrimBlockInt)
+ OSFreeMem(psClientTAUpdateUFOSyncPrimBlockInt);
+ if (hClientTAUpdateUFOSyncPrimBlockInt2)
+ OSFreeMem(hClientTAUpdateUFOSyncPrimBlockInt2);
+ if (ui32ClientTAUpdateSyncOffsetInt)
+ OSFreeMem(ui32ClientTAUpdateSyncOffsetInt);
if (ui32ClientTAUpdateValueInt)
OSFreeMem(ui32ClientTAUpdateValueInt);
if (ui32ServerTASyncFlagsInt)
OSFreeMem(psServerTASyncsInt);
if (hServerTASyncsInt2)
OSFreeMem(hServerTASyncsInt2);
- if (sClient3DFenceUFOAddressInt)
- OSFreeMem(sClient3DFenceUFOAddressInt);
+ if (psClient3DFenceUFOSyncPrimBlockInt)
+ OSFreeMem(psClient3DFenceUFOSyncPrimBlockInt);
+ if (hClient3DFenceUFOSyncPrimBlockInt2)
+ OSFreeMem(hClient3DFenceUFOSyncPrimBlockInt2);
+ if (ui32Client3DFenceSyncOffsetInt)
+ OSFreeMem(ui32Client3DFenceSyncOffsetInt);
if (ui32Client3DFenceValueInt)
OSFreeMem(ui32Client3DFenceValueInt);
- if (sClient3DUpdateUFOAddressInt)
- OSFreeMem(sClient3DUpdateUFOAddressInt);
+ if (psClient3DUpdateUFOSyncPrimBlockInt)
+ OSFreeMem(psClient3DUpdateUFOSyncPrimBlockInt);
+ if (hClient3DUpdateUFOSyncPrimBlockInt2)
+ OSFreeMem(hClient3DUpdateUFOSyncPrimBlockInt2);
+ if (ui32Client3DUpdateSyncOffsetInt)
+ OSFreeMem(ui32Client3DUpdateSyncOffsetInt);
if (ui32Client3DUpdateValueInt)
OSFreeMem(ui32Client3DUpdateValueInt);
if (ui32Server3DSyncFlagsInt)
{
RGX_SERVER_RENDER_CONTEXT * psRenderContextInt = IMG_NULL;
IMG_HANDLE hRenderContextInt2 = IMG_NULL;
- PRGXFWIF_UFO_ADDR *sClientTAFenceUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * *psClientTAFenceUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE *hClientTAFenceUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 *ui32ClientTAFenceSyncOffsetInt = IMG_NULL;
IMG_UINT32 *ui32ClientTAFenceValueInt = IMG_NULL;
- PRGXFWIF_UFO_ADDR *sClientTAUpdateUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * *psClientTAUpdateUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE *hClientTAUpdateUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 *ui32ClientTAUpdateSyncOffsetInt = IMG_NULL;
IMG_UINT32 *ui32ClientTAUpdateValueInt = IMG_NULL;
IMG_UINT32 *ui32ServerTASyncFlagsInt = IMG_NULL;
SERVER_SYNC_PRIMITIVE * *psServerTASyncsInt = IMG_NULL;
IMG_HANDLE *hServerTASyncsInt2 = IMG_NULL;
- PRGXFWIF_UFO_ADDR *sClient3DFenceUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * *psClient3DFenceUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE *hClient3DFenceUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 *ui32Client3DFenceSyncOffsetInt = IMG_NULL;
IMG_UINT32 *ui32Client3DFenceValueInt = IMG_NULL;
- PRGXFWIF_UFO_ADDR *sClient3DUpdateUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * *psClient3DUpdateUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE *hClient3DUpdateUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 *ui32Client3DUpdateSyncOffsetInt = IMG_NULL;
IMG_UINT32 *ui32Client3DUpdateValueInt = IMG_NULL;
IMG_UINT32 *ui32Server3DSyncFlagsInt = IMG_NULL;
SERVER_SYNC_PRIMITIVE * *psServer3DSyncsInt = IMG_NULL;
if (psRGXKickSyncTAIN->ui32ClientTAFenceCount != 0)
{
- sClientTAFenceUFOAddressInt = OSAllocMem(psRGXKickSyncTAIN->ui32ClientTAFenceCount * sizeof(PRGXFWIF_UFO_ADDR));
- if (!sClientTAFenceUFOAddressInt)
+ psClientTAFenceUFOSyncPrimBlockInt = OSAllocMem(psRGXKickSyncTAIN->ui32ClientTAFenceCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
+ if (!psClientTAFenceUFOSyncPrimBlockInt)
+ {
+ psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncTA_exit;
+ }
+ hClientTAFenceUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickSyncTAIN->ui32ClientTAFenceCount * sizeof(IMG_HANDLE));
+ if (!hClientTAFenceUFOSyncPrimBlockInt2)
+ {
+ psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncTA_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTAIN->phClientTAFenceUFOSyncPrimBlock, psRGXKickSyncTAIN->ui32ClientTAFenceCount * sizeof(IMG_HANDLE))
+ || (OSCopyFromUser(NULL, hClientTAFenceUFOSyncPrimBlockInt2, psRGXKickSyncTAIN->phClientTAFenceUFOSyncPrimBlock,
+ psRGXKickSyncTAIN->ui32ClientTAFenceCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
+ {
+ psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXKickSyncTA_exit;
+ }
+ if (psRGXKickSyncTAIN->ui32ClientTAFenceCount != 0)
+ {
+ ui32ClientTAFenceSyncOffsetInt = OSAllocMem(psRGXKickSyncTAIN->ui32ClientTAFenceCount * sizeof(IMG_UINT32));
+ if (!ui32ClientTAFenceSyncOffsetInt)
{
psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTAIN->psClientTAFenceUFOAddress, psRGXKickSyncTAIN->ui32ClientTAFenceCount * sizeof(PRGXFWIF_UFO_ADDR))
- || (OSCopyFromUser(NULL, sClientTAFenceUFOAddressInt, psRGXKickSyncTAIN->psClientTAFenceUFOAddress,
- psRGXKickSyncTAIN->ui32ClientTAFenceCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTAIN->pui32ClientTAFenceSyncOffset, psRGXKickSyncTAIN->ui32ClientTAFenceCount * sizeof(IMG_UINT32))
+ || (OSCopyFromUser(NULL, ui32ClientTAFenceSyncOffsetInt, psRGXKickSyncTAIN->pui32ClientTAFenceSyncOffset,
+ psRGXKickSyncTAIN->ui32ClientTAFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
if (psRGXKickSyncTAIN->ui32ClientTAUpdateCount != 0)
{
- sClientTAUpdateUFOAddressInt = OSAllocMem(psRGXKickSyncTAIN->ui32ClientTAUpdateCount * sizeof(PRGXFWIF_UFO_ADDR));
- if (!sClientTAUpdateUFOAddressInt)
+ psClientTAUpdateUFOSyncPrimBlockInt = OSAllocMem(psRGXKickSyncTAIN->ui32ClientTAUpdateCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
+ if (!psClientTAUpdateUFOSyncPrimBlockInt)
+ {
+ psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncTA_exit;
+ }
+ hClientTAUpdateUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickSyncTAIN->ui32ClientTAUpdateCount * sizeof(IMG_HANDLE));
+ if (!hClientTAUpdateUFOSyncPrimBlockInt2)
+ {
+ psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncTA_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTAIN->phClientTAUpdateUFOSyncPrimBlock, psRGXKickSyncTAIN->ui32ClientTAUpdateCount * sizeof(IMG_HANDLE))
+ || (OSCopyFromUser(NULL, hClientTAUpdateUFOSyncPrimBlockInt2, psRGXKickSyncTAIN->phClientTAUpdateUFOSyncPrimBlock,
+ psRGXKickSyncTAIN->ui32ClientTAUpdateCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
+ {
+ psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXKickSyncTA_exit;
+ }
+ if (psRGXKickSyncTAIN->ui32ClientTAUpdateCount != 0)
+ {
+ ui32ClientTAUpdateSyncOffsetInt = OSAllocMem(psRGXKickSyncTAIN->ui32ClientTAUpdateCount * sizeof(IMG_UINT32));
+ if (!ui32ClientTAUpdateSyncOffsetInt)
{
psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTAIN->psClientTAUpdateUFOAddress, psRGXKickSyncTAIN->ui32ClientTAUpdateCount * sizeof(PRGXFWIF_UFO_ADDR))
- || (OSCopyFromUser(NULL, sClientTAUpdateUFOAddressInt, psRGXKickSyncTAIN->psClientTAUpdateUFOAddress,
- psRGXKickSyncTAIN->ui32ClientTAUpdateCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTAIN->pui32ClientTAUpdateSyncOffset, psRGXKickSyncTAIN->ui32ClientTAUpdateCount * sizeof(IMG_UINT32))
+ || (OSCopyFromUser(NULL, ui32ClientTAUpdateSyncOffsetInt, psRGXKickSyncTAIN->pui32ClientTAUpdateSyncOffset,
+ psRGXKickSyncTAIN->ui32ClientTAUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
if (psRGXKickSyncTAIN->ui32Client3DFenceCount != 0)
{
- sClient3DFenceUFOAddressInt = OSAllocMem(psRGXKickSyncTAIN->ui32Client3DFenceCount * sizeof(PRGXFWIF_UFO_ADDR));
- if (!sClient3DFenceUFOAddressInt)
+ psClient3DFenceUFOSyncPrimBlockInt = OSAllocMem(psRGXKickSyncTAIN->ui32Client3DFenceCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
+ if (!psClient3DFenceUFOSyncPrimBlockInt)
+ {
+ psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncTA_exit;
+ }
+ hClient3DFenceUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickSyncTAIN->ui32Client3DFenceCount * sizeof(IMG_HANDLE));
+ if (!hClient3DFenceUFOSyncPrimBlockInt2)
+ {
+ psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncTA_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTAIN->phClient3DFenceUFOSyncPrimBlock, psRGXKickSyncTAIN->ui32Client3DFenceCount * sizeof(IMG_HANDLE))
+ || (OSCopyFromUser(NULL, hClient3DFenceUFOSyncPrimBlockInt2, psRGXKickSyncTAIN->phClient3DFenceUFOSyncPrimBlock,
+ psRGXKickSyncTAIN->ui32Client3DFenceCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
+ {
+ psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXKickSyncTA_exit;
+ }
+ if (psRGXKickSyncTAIN->ui32Client3DFenceCount != 0)
+ {
+ ui32Client3DFenceSyncOffsetInt = OSAllocMem(psRGXKickSyncTAIN->ui32Client3DFenceCount * sizeof(IMG_UINT32));
+ if (!ui32Client3DFenceSyncOffsetInt)
{
psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTAIN->psClient3DFenceUFOAddress, psRGXKickSyncTAIN->ui32Client3DFenceCount * sizeof(PRGXFWIF_UFO_ADDR))
- || (OSCopyFromUser(NULL, sClient3DFenceUFOAddressInt, psRGXKickSyncTAIN->psClient3DFenceUFOAddress,
- psRGXKickSyncTAIN->ui32Client3DFenceCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTAIN->pui32Client3DFenceSyncOffset, psRGXKickSyncTAIN->ui32Client3DFenceCount * sizeof(IMG_UINT32))
+ || (OSCopyFromUser(NULL, ui32Client3DFenceSyncOffsetInt, psRGXKickSyncTAIN->pui32Client3DFenceSyncOffset,
+ psRGXKickSyncTAIN->ui32Client3DFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
if (psRGXKickSyncTAIN->ui32Client3DUpdateCount != 0)
{
- sClient3DUpdateUFOAddressInt = OSAllocMem(psRGXKickSyncTAIN->ui32Client3DUpdateCount * sizeof(PRGXFWIF_UFO_ADDR));
- if (!sClient3DUpdateUFOAddressInt)
+ psClient3DUpdateUFOSyncPrimBlockInt = OSAllocMem(psRGXKickSyncTAIN->ui32Client3DUpdateCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
+ if (!psClient3DUpdateUFOSyncPrimBlockInt)
+ {
+ psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncTA_exit;
+ }
+ hClient3DUpdateUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickSyncTAIN->ui32Client3DUpdateCount * sizeof(IMG_HANDLE));
+ if (!hClient3DUpdateUFOSyncPrimBlockInt2)
{
psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTAIN->psClient3DUpdateUFOAddress, psRGXKickSyncTAIN->ui32Client3DUpdateCount * sizeof(PRGXFWIF_UFO_ADDR))
- || (OSCopyFromUser(NULL, sClient3DUpdateUFOAddressInt, psRGXKickSyncTAIN->psClient3DUpdateUFOAddress,
- psRGXKickSyncTAIN->ui32Client3DUpdateCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTAIN->phClient3DUpdateUFOSyncPrimBlock, psRGXKickSyncTAIN->ui32Client3DUpdateCount * sizeof(IMG_HANDLE))
+ || (OSCopyFromUser(NULL, hClient3DUpdateUFOSyncPrimBlockInt2, psRGXKickSyncTAIN->phClient3DUpdateUFOSyncPrimBlock,
+ psRGXKickSyncTAIN->ui32Client3DUpdateCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
+ {
+ psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXKickSyncTA_exit;
+ }
+ if (psRGXKickSyncTAIN->ui32Client3DUpdateCount != 0)
+ {
+ ui32Client3DUpdateSyncOffsetInt = OSAllocMem(psRGXKickSyncTAIN->ui32Client3DUpdateCount * sizeof(IMG_UINT32));
+ if (!ui32Client3DUpdateSyncOffsetInt)
+ {
+ psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncTA_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTAIN->pui32Client3DUpdateSyncOffset, psRGXKickSyncTAIN->ui32Client3DUpdateCount * sizeof(IMG_UINT32))
+ || (OSCopyFromUser(NULL, ui32Client3DUpdateSyncOffsetInt, psRGXKickSyncTAIN->pui32Client3DUpdateSyncOffset,
+ psRGXKickSyncTAIN->ui32Client3DUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickSyncTAOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
}
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXKickSyncTAIN->ui32ClientTAFenceCount;i++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXKickSyncTAOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hClientTAFenceUFOSyncPrimBlockInt2[i],
+ hClientTAFenceUFOSyncPrimBlockInt2[i],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickSyncTAOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncTA_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickSyncTAOUT->eError = ResManFindPrivateDataByPtr(hClientTAFenceUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClientTAFenceUFOSyncPrimBlockInt[i]);
+
+ if(psRGXKickSyncTAOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncTA_exit;
+ }
+ }
+ }
+ }
+
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXKickSyncTAIN->ui32ClientTAUpdateCount;i++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXKickSyncTAOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hClientTAUpdateUFOSyncPrimBlockInt2[i],
+ hClientTAUpdateUFOSyncPrimBlockInt2[i],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickSyncTAOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncTA_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickSyncTAOUT->eError = ResManFindPrivateDataByPtr(hClientTAUpdateUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClientTAUpdateUFOSyncPrimBlockInt[i]);
+
+ if(psRGXKickSyncTAOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncTA_exit;
+ }
+ }
+ }
+ }
+
{
IMG_UINT32 i;
}
}
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXKickSyncTAIN->ui32Client3DFenceCount;i++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXKickSyncTAOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hClient3DFenceUFOSyncPrimBlockInt2[i],
+ hClient3DFenceUFOSyncPrimBlockInt2[i],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickSyncTAOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncTA_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickSyncTAOUT->eError = ResManFindPrivateDataByPtr(hClient3DFenceUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClient3DFenceUFOSyncPrimBlockInt[i]);
+
+ if(psRGXKickSyncTAOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncTA_exit;
+ }
+ }
+ }
+ }
+
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXKickSyncTAIN->ui32Client3DUpdateCount;i++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXKickSyncTAOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hClient3DUpdateUFOSyncPrimBlockInt2[i],
+ hClient3DUpdateUFOSyncPrimBlockInt2[i],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickSyncTAOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncTA_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickSyncTAOUT->eError = ResManFindPrivateDataByPtr(hClient3DUpdateUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClient3DUpdateUFOSyncPrimBlockInt[i]);
+
+ if(psRGXKickSyncTAOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncTA_exit;
+ }
+ }
+ }
+ }
+
{
IMG_UINT32 i;
PVRSRVRGXKickSyncTAKM(
psRenderContextInt,
psRGXKickSyncTAIN->ui32ClientTAFenceCount,
- sClientTAFenceUFOAddressInt,
+ psClientTAFenceUFOSyncPrimBlockInt,
+ ui32ClientTAFenceSyncOffsetInt,
ui32ClientTAFenceValueInt,
psRGXKickSyncTAIN->ui32ClientTAUpdateCount,
- sClientTAUpdateUFOAddressInt,
+ psClientTAUpdateUFOSyncPrimBlockInt,
+ ui32ClientTAUpdateSyncOffsetInt,
ui32ClientTAUpdateValueInt,
psRGXKickSyncTAIN->ui32ServerTASyncPrims,
ui32ServerTASyncFlagsInt,
psServerTASyncsInt,
psRGXKickSyncTAIN->ui32Client3DFenceCount,
- sClient3DFenceUFOAddressInt,
+ psClient3DFenceUFOSyncPrimBlockInt,
+ ui32Client3DFenceSyncOffsetInt,
ui32Client3DFenceValueInt,
psRGXKickSyncTAIN->ui32Client3DUpdateCount,
- sClient3DUpdateUFOAddressInt,
+ psClient3DUpdateUFOSyncPrimBlockInt,
+ ui32Client3DUpdateSyncOffsetInt,
ui32Client3DUpdateValueInt,
psRGXKickSyncTAIN->ui32Server3DSyncPrims,
ui32Server3DSyncFlagsInt,
RGXKickSyncTA_exit:
- if (sClientTAFenceUFOAddressInt)
- OSFreeMem(sClientTAFenceUFOAddressInt);
+ if (psClientTAFenceUFOSyncPrimBlockInt)
+ OSFreeMem(psClientTAFenceUFOSyncPrimBlockInt);
+ if (hClientTAFenceUFOSyncPrimBlockInt2)
+ OSFreeMem(hClientTAFenceUFOSyncPrimBlockInt2);
+ if (ui32ClientTAFenceSyncOffsetInt)
+ OSFreeMem(ui32ClientTAFenceSyncOffsetInt);
if (ui32ClientTAFenceValueInt)
OSFreeMem(ui32ClientTAFenceValueInt);
- if (sClientTAUpdateUFOAddressInt)
- OSFreeMem(sClientTAUpdateUFOAddressInt);
+ if (psClientTAUpdateUFOSyncPrimBlockInt)
+ OSFreeMem(psClientTAUpdateUFOSyncPrimBlockInt);
+ if (hClientTAUpdateUFOSyncPrimBlockInt2)
+ OSFreeMem(hClientTAUpdateUFOSyncPrimBlockInt2);
+ if (ui32ClientTAUpdateSyncOffsetInt)
+ OSFreeMem(ui32ClientTAUpdateSyncOffsetInt);
if (ui32ClientTAUpdateValueInt)
OSFreeMem(ui32ClientTAUpdateValueInt);
if (ui32ServerTASyncFlagsInt)
OSFreeMem(psServerTASyncsInt);
if (hServerTASyncsInt2)
OSFreeMem(hServerTASyncsInt2);
- if (sClient3DFenceUFOAddressInt)
- OSFreeMem(sClient3DFenceUFOAddressInt);
+ if (psClient3DFenceUFOSyncPrimBlockInt)
+ OSFreeMem(psClient3DFenceUFOSyncPrimBlockInt);
+ if (hClient3DFenceUFOSyncPrimBlockInt2)
+ OSFreeMem(hClient3DFenceUFOSyncPrimBlockInt2);
+ if (ui32Client3DFenceSyncOffsetInt)
+ OSFreeMem(ui32Client3DFenceSyncOffsetInt);
if (ui32Client3DFenceValueInt)
OSFreeMem(ui32Client3DFenceValueInt);
- if (sClient3DUpdateUFOAddressInt)
- OSFreeMem(sClient3DUpdateUFOAddressInt);
+ if (psClient3DUpdateUFOSyncPrimBlockInt)
+ OSFreeMem(psClient3DUpdateUFOSyncPrimBlockInt);
+ if (hClient3DUpdateUFOSyncPrimBlockInt2)
+ OSFreeMem(hClient3DUpdateUFOSyncPrimBlockInt2);
+ if (ui32Client3DUpdateSyncOffsetInt)
+ OSFreeMem(ui32Client3DUpdateSyncOffsetInt);
if (ui32Client3DUpdateValueInt)
OSFreeMem(ui32Client3DUpdateValueInt);
if (ui32Server3DSyncFlagsInt)
IMG_HANDLE hTransferContext;
IMG_UINT32 ui32PrepareCount;
IMG_UINT32 * pui32ClientFenceCount;
- PRGXFWIF_UFO_ADDR* * psFenceUFOAddress;
+ IMG_HANDLE* * phFenceUFOSyncPrimBlock;
+ IMG_UINT32* * pui32FenceSyncOffset;
IMG_UINT32* * pui32FenceValue;
IMG_UINT32 * pui32ClientUpdateCount;
- PRGXFWIF_UFO_ADDR* * psUpdateUFOAddress;
+ IMG_HANDLE* * phUpdateUFOSyncPrimBlock;
+ IMG_UINT32* * pui32UpdateSyncOffset;
IMG_UINT32* * pui32UpdateValue;
IMG_UINT32 * pui32ServerSyncCount;
IMG_UINT32* * pui32ServerSyncFlags;
{
IMG_HANDLE hTransferContext;
IMG_UINT32 ui32ClientFenceCount;
- PRGXFWIF_UFO_ADDR * psClientFenceUFOAddress;
+ IMG_HANDLE * phClientFenceUFOSyncPrimBlock;
+ IMG_UINT32 * pui32ClientFenceSyncOffset;
IMG_UINT32 * pui32ClientFenceValue;
IMG_UINT32 ui32ClientUpdateCount;
- PRGXFWIF_UFO_ADDR * psClientUpdateUFOAddress;
+ IMG_HANDLE * phClientUpdateUFOSyncPrimBlock;
+ IMG_UINT32 * pui32ClientUpdateSyncOffset;
IMG_UINT32 * pui32ClientUpdateValue;
IMG_UINT32 ui32ServerSyncCount;
IMG_UINT32 * pui32ServerSyncFlags;
RGX_SERVER_TQ_CONTEXT * psTransferContextInt = IMG_NULL;
IMG_HANDLE hTransferContextInt2 = IMG_NULL;
IMG_UINT32 *ui32ClientFenceCountInt = IMG_NULL;
- PRGXFWIF_UFO_ADDR **sFenceUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * **psFenceUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE **hFenceUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 **ui32FenceSyncOffsetInt = IMG_NULL;
IMG_UINT32 **ui32FenceValueInt = IMG_NULL;
IMG_UINT32 *ui32ClientUpdateCountInt = IMG_NULL;
- PRGXFWIF_UFO_ADDR **sUpdateUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * **psUpdateUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE **hUpdateUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 **ui32UpdateSyncOffsetInt = IMG_NULL;
IMG_UINT32 **ui32UpdateValueInt = IMG_NULL;
IMG_UINT32 *ui32ServerSyncCountInt = IMG_NULL;
IMG_UINT32 **ui32ServerSyncFlagsInt = IMG_NULL;
IMG_UINT32 ui32AllocSize=0;
IMG_UINT32 ui32Size;
IMG_UINT8 *pui8Ptr = IMG_NULL;
+ IMG_UINT32 ui32AllocSize2=0;
+ IMG_UINT32 ui32Size2;
+ IMG_UINT8 *pui8Ptr2 = IMG_NULL;
/*
Two pass loop, 1st find out the size and 2nd allocation and set offsets.
*/
for (ui32Pass=0;ui32Pass<2;ui32Pass++)
{
- ui32Size = psRGXSubmitTransferIN->ui32PrepareCount * sizeof(PRGXFWIF_UFO_ADDR *);
+ ui32Size = psRGXSubmitTransferIN->ui32PrepareCount * sizeof(SYNC_PRIMITIVE_BLOCK * *);
+ ui32Size2 = psRGXSubmitTransferIN->ui32PrepareCount * sizeof(IMG_HANDLE *);
if (ui32Pass == 0)
{
ui32AllocSize += ui32Size;
+ ui32AllocSize2 += ui32Size2;
}
else
{
psRGXSubmitTransferOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXSubmitTransfer_exit;
}
- sFenceUFOAddressInt = (PRGXFWIF_UFO_ADDR **) pui8Ptr;
+ psFenceUFOSyncPrimBlockInt = (SYNC_PRIMITIVE_BLOCK * **) pui8Ptr;
pui8Ptr += ui32Size;
+ pui8Ptr2 = OSAllocMem(ui32AllocSize2);
+ if (pui8Ptr2 == IMG_NULL)
+ {
+ psRGXSubmitTransferOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+ goto RGXSubmitTransfer_exit;
+ }
+ hFenceUFOSyncPrimBlockInt2 = (IMG_HANDLE **) pui8Ptr2;
+ pui8Ptr2 += ui32Size2;
}
for (i=0;i<psRGXSubmitTransferIN->ui32PrepareCount;i++)
{
- ui32Size = ui32ClientFenceCountInt[i] * sizeof(PRGXFWIF_UFO_ADDR);
+ ui32Size = ui32ClientFenceCountInt[i] * sizeof(SYNC_PRIMITIVE_BLOCK *);
+ ui32Size2 = ui32ClientFenceCountInt[i] * sizeof(IMG_HANDLE);
if (ui32Size)
{
if (ui32Pass == 0)
{
ui32AllocSize += ui32Size;
+ ui32AllocSize2 += ui32Size2;
}
else
{
- sFenceUFOAddressInt[i] = (PRGXFWIF_UFO_ADDR *) pui8Ptr;
+ psFenceUFOSyncPrimBlockInt[i] = (SYNC_PRIMITIVE_BLOCK * *) pui8Ptr;
pui8Ptr += ui32Size;
+ hFenceUFOSyncPrimBlockInt2[i] = (IMG_HANDLE *) pui8Ptr2;
+ pui8Ptr2 += ui32Size2;
}
}
}
{
IMG_UINT32 i;
- PRGXFWIF_UFO_ADDR **psPtr;
+ IMG_HANDLE **psPtr;
/* Loop over all the pointers in the array copying the data into the kernel */
for (i=0;i<psRGXSubmitTransferIN->ui32PrepareCount;i++)
{
/* Copy the pointer over from the client side */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) &psRGXSubmitTransferIN->psFenceUFOAddress[i], sizeof(PRGXFWIF_UFO_ADDR **))
- || (OSCopyFromUser(NULL, &psPtr, &psRGXSubmitTransferIN->psFenceUFOAddress[i],
- sizeof(PRGXFWIF_UFO_ADDR **)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) &psRGXSubmitTransferIN->phFenceUFOSyncPrimBlock[i], sizeof(IMG_HANDLE **))
+ || (OSCopyFromUser(NULL, &psPtr, &psRGXSubmitTransferIN->phFenceUFOSyncPrimBlock[i],
+ sizeof(IMG_HANDLE **)) != PVRSRV_OK) )
{
psRGXSubmitTransferOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXSubmitTransfer_exit;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psPtr, (psRGXSubmitTransferIN->pui32ClientFenceCount[i] * sizeof(PRGXFWIF_UFO_ADDR)))
- || (OSCopyFromUser(NULL, (sFenceUFOAddressInt[i]), psPtr,
- (psRGXSubmitTransferIN->pui32ClientFenceCount[i] * sizeof(PRGXFWIF_UFO_ADDR))) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psPtr, (psRGXSubmitTransferIN->pui32ClientFenceCount[i] * sizeof(IMG_HANDLE)))
+ || (OSCopyFromUser(NULL, (hFenceUFOSyncPrimBlockInt2[i]), psPtr,
+ (psRGXSubmitTransferIN->pui32ClientFenceCount[i] * sizeof(IMG_HANDLE))) != PVRSRV_OK) )
+ {
+ psRGXSubmitTransferOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXSubmitTransfer_exit;
+ }
+ }
+ }
+ if (psRGXSubmitTransferIN->ui32PrepareCount != 0)
+ {
+ IMG_UINT32 ui32Pass=0;
+ IMG_UINT32 i;
+ IMG_UINT32 ui32AllocSize=0;
+ IMG_UINT32 ui32Size;
+ IMG_UINT8 *pui8Ptr = IMG_NULL;
+
+ /*
+ Two pass loop, 1st find out the size and 2nd allocation and set offsets.
+ Keeps allocation cost down and simplifies the free path
+ */
+ for (ui32Pass=0;ui32Pass<2;ui32Pass++)
+ {
+ ui32Size = psRGXSubmitTransferIN->ui32PrepareCount * sizeof(IMG_UINT32 *);
+ if (ui32Pass == 0)
+ {
+ ui32AllocSize += ui32Size;
+ }
+ else
+ {
+ pui8Ptr = OSAllocMem(ui32AllocSize);
+ if (pui8Ptr == IMG_NULL)
+ {
+ psRGXSubmitTransferOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+ goto RGXSubmitTransfer_exit;
+ }
+ ui32FenceSyncOffsetInt = (IMG_UINT32 **) pui8Ptr;
+ pui8Ptr += ui32Size;
+ }
+
+ for (i=0;i<psRGXSubmitTransferIN->ui32PrepareCount;i++)
+ {
+ ui32Size = ui32ClientFenceCountInt[i] * sizeof(IMG_UINT32);
+ if (ui32Size)
+ {
+ if (ui32Pass == 0)
+ {
+ ui32AllocSize += ui32Size;
+ }
+ else
+ {
+ ui32FenceSyncOffsetInt[i] = (IMG_UINT32 *) pui8Ptr;
+ pui8Ptr += ui32Size;
+ }
+ }
+ }
+ }
+ }
+
+ {
+ IMG_UINT32 i;
+ IMG_UINT32 **psPtr;
+
+ /* Loop over all the pointers in the array copying the data into the kernel */
+ for (i=0;i<psRGXSubmitTransferIN->ui32PrepareCount;i++)
+ {
+ /* Copy the pointer over from the client side */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) &psRGXSubmitTransferIN->pui32FenceSyncOffset[i], sizeof(IMG_UINT32 **))
+ || (OSCopyFromUser(NULL, &psPtr, &psRGXSubmitTransferIN->pui32FenceSyncOffset[i],
+ sizeof(IMG_UINT32 **)) != PVRSRV_OK) )
+ {
+ psRGXSubmitTransferOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXSubmitTransfer_exit;
+ }
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psPtr, (psRGXSubmitTransferIN->pui32ClientFenceCount[i] * sizeof(IMG_UINT32)))
+ || (OSCopyFromUser(NULL, (ui32FenceSyncOffsetInt[i]), psPtr,
+ (psRGXSubmitTransferIN->pui32ClientFenceCount[i] * sizeof(IMG_UINT32))) != PVRSRV_OK) )
{
psRGXSubmitTransferOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXSubmitTransfer_exit;
}
if (psRGXSubmitTransferIN->ui32PrepareCount != 0)
+ {
+ IMG_UINT32 ui32Pass=0;
+ IMG_UINT32 i;
+ IMG_UINT32 ui32AllocSize=0;
+ IMG_UINT32 ui32Size;
+ IMG_UINT8 *pui8Ptr = IMG_NULL;
+ IMG_UINT32 ui32AllocSize2=0;
+ IMG_UINT32 ui32Size2;
+ IMG_UINT8 *pui8Ptr2 = IMG_NULL;
+
+ /*
+ Two pass loop, 1st find out the size and 2nd allocation and set offsets.
+ Keeps allocation cost down and simplifies the free path
+ */
+ for (ui32Pass=0;ui32Pass<2;ui32Pass++)
+ {
+ ui32Size = psRGXSubmitTransferIN->ui32PrepareCount * sizeof(SYNC_PRIMITIVE_BLOCK * *);
+ ui32Size2 = psRGXSubmitTransferIN->ui32PrepareCount * sizeof(IMG_HANDLE *);
+ if (ui32Pass == 0)
+ {
+ ui32AllocSize += ui32Size;
+ ui32AllocSize2 += ui32Size2;
+ }
+ else
+ {
+ pui8Ptr = OSAllocMem(ui32AllocSize);
+ if (pui8Ptr == IMG_NULL)
+ {
+ psRGXSubmitTransferOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+ goto RGXSubmitTransfer_exit;
+ }
+ psUpdateUFOSyncPrimBlockInt = (SYNC_PRIMITIVE_BLOCK * **) pui8Ptr;
+ pui8Ptr += ui32Size;
+ pui8Ptr2 = OSAllocMem(ui32AllocSize2);
+ if (pui8Ptr2 == IMG_NULL)
+ {
+ psRGXSubmitTransferOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+ goto RGXSubmitTransfer_exit;
+ }
+ hUpdateUFOSyncPrimBlockInt2 = (IMG_HANDLE **) pui8Ptr2;
+ pui8Ptr2 += ui32Size2;
+ }
+
+ for (i=0;i<psRGXSubmitTransferIN->ui32PrepareCount;i++)
+ {
+ ui32Size = ui32ClientUpdateCountInt[i] * sizeof(SYNC_PRIMITIVE_BLOCK *);
+ ui32Size2 = ui32ClientUpdateCountInt[i] * sizeof(IMG_HANDLE);
+ if (ui32Size)
+ {
+ if (ui32Pass == 0)
+ {
+ ui32AllocSize += ui32Size;
+ ui32AllocSize2 += ui32Size2;
+ }
+ else
+ {
+ psUpdateUFOSyncPrimBlockInt[i] = (SYNC_PRIMITIVE_BLOCK * *) pui8Ptr;
+ pui8Ptr += ui32Size;
+ hUpdateUFOSyncPrimBlockInt2[i] = (IMG_HANDLE *) pui8Ptr2;
+ pui8Ptr2 += ui32Size2;
+ }
+ }
+ }
+ }
+ }
+
+ {
+ IMG_UINT32 i;
+ IMG_HANDLE **psPtr;
+
+ /* Loop over all the pointers in the array copying the data into the kernel */
+ for (i=0;i<psRGXSubmitTransferIN->ui32PrepareCount;i++)
+ {
+ /* Copy the pointer over from the client side */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) &psRGXSubmitTransferIN->phUpdateUFOSyncPrimBlock[i], sizeof(IMG_HANDLE **))
+ || (OSCopyFromUser(NULL, &psPtr, &psRGXSubmitTransferIN->phUpdateUFOSyncPrimBlock[i],
+ sizeof(IMG_HANDLE **)) != PVRSRV_OK) )
+ {
+ psRGXSubmitTransferOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXSubmitTransfer_exit;
+ }
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psPtr, (psRGXSubmitTransferIN->pui32ClientUpdateCount[i] * sizeof(IMG_HANDLE)))
+ || (OSCopyFromUser(NULL, (hUpdateUFOSyncPrimBlockInt2[i]), psPtr,
+ (psRGXSubmitTransferIN->pui32ClientUpdateCount[i] * sizeof(IMG_HANDLE))) != PVRSRV_OK) )
+ {
+ psRGXSubmitTransferOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXSubmitTransfer_exit;
+ }
+ }
+ }
+ if (psRGXSubmitTransferIN->ui32PrepareCount != 0)
{
IMG_UINT32 ui32Pass=0;
IMG_UINT32 i;
*/
for (ui32Pass=0;ui32Pass<2;ui32Pass++)
{
- ui32Size = psRGXSubmitTransferIN->ui32PrepareCount * sizeof(PRGXFWIF_UFO_ADDR *);
+ ui32Size = psRGXSubmitTransferIN->ui32PrepareCount * sizeof(IMG_UINT32 *);
if (ui32Pass == 0)
{
ui32AllocSize += ui32Size;
psRGXSubmitTransferOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
goto RGXSubmitTransfer_exit;
}
- sUpdateUFOAddressInt = (PRGXFWIF_UFO_ADDR **) pui8Ptr;
+ ui32UpdateSyncOffsetInt = (IMG_UINT32 **) pui8Ptr;
pui8Ptr += ui32Size;
}
for (i=0;i<psRGXSubmitTransferIN->ui32PrepareCount;i++)
{
- ui32Size = ui32ClientUpdateCountInt[i] * sizeof(PRGXFWIF_UFO_ADDR);
+ ui32Size = ui32ClientUpdateCountInt[i] * sizeof(IMG_UINT32);
if (ui32Size)
{
if (ui32Pass == 0)
}
else
{
- sUpdateUFOAddressInt[i] = (PRGXFWIF_UFO_ADDR *) pui8Ptr;
+ ui32UpdateSyncOffsetInt[i] = (IMG_UINT32 *) pui8Ptr;
pui8Ptr += ui32Size;
}
}
{
IMG_UINT32 i;
- PRGXFWIF_UFO_ADDR **psPtr;
+ IMG_UINT32 **psPtr;
/* Loop over all the pointers in the array copying the data into the kernel */
for (i=0;i<psRGXSubmitTransferIN->ui32PrepareCount;i++)
{
/* Copy the pointer over from the client side */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) &psRGXSubmitTransferIN->psUpdateUFOAddress[i], sizeof(PRGXFWIF_UFO_ADDR **))
- || (OSCopyFromUser(NULL, &psPtr, &psRGXSubmitTransferIN->psUpdateUFOAddress[i],
- sizeof(PRGXFWIF_UFO_ADDR **)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) &psRGXSubmitTransferIN->pui32UpdateSyncOffset[i], sizeof(IMG_UINT32 **))
+ || (OSCopyFromUser(NULL, &psPtr, &psRGXSubmitTransferIN->pui32UpdateSyncOffset[i],
+ sizeof(IMG_UINT32 **)) != PVRSRV_OK) )
{
psRGXSubmitTransferOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
goto RGXSubmitTransfer_exit;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psPtr, (psRGXSubmitTransferIN->pui32ClientUpdateCount[i] * sizeof(PRGXFWIF_UFO_ADDR)))
- || (OSCopyFromUser(NULL, (sUpdateUFOAddressInt[i]), psPtr,
- (psRGXSubmitTransferIN->pui32ClientUpdateCount[i] * sizeof(PRGXFWIF_UFO_ADDR))) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psPtr, (psRGXSubmitTransferIN->pui32ClientUpdateCount[i] * sizeof(IMG_UINT32)))
+ || (OSCopyFromUser(NULL, (ui32UpdateSyncOffsetInt[i]), psPtr,
+ (psRGXSubmitTransferIN->pui32ClientUpdateCount[i] * sizeof(IMG_UINT32))) != PVRSRV_OK) )
{
psRGXSubmitTransferOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
}
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXSubmitTransferIN->ui32PrepareCount;i++)
+ {
+ IMG_UINT32 j;
+ for (j=0;j<ui32ClientFenceCountInt[i];j++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXSubmitTransferOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hFenceUFOSyncPrimBlockInt2[i][j],
+ hFenceUFOSyncPrimBlockInt2[i][j],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXSubmitTransferOUT->eError != PVRSRV_OK)
+ {
+ goto RGXSubmitTransfer_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXSubmitTransferOUT->eError = ResManFindPrivateDataByPtr(hFenceUFOSyncPrimBlockInt2[i][j], (IMG_VOID **) &psFenceUFOSyncPrimBlockInt[i][j]);
+
+ if(psRGXSubmitTransferOUT->eError != PVRSRV_OK)
+ {
+ goto RGXSubmitTransfer_exit;
+ }
+ }
+ }
+ }
+ }
+
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXSubmitTransferIN->ui32PrepareCount;i++)
+ {
+ IMG_UINT32 j;
+ for (j=0;j<ui32ClientUpdateCountInt[i];j++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXSubmitTransferOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hUpdateUFOSyncPrimBlockInt2[i][j],
+ hUpdateUFOSyncPrimBlockInt2[i][j],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXSubmitTransferOUT->eError != PVRSRV_OK)
+ {
+ goto RGXSubmitTransfer_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXSubmitTransferOUT->eError = ResManFindPrivateDataByPtr(hUpdateUFOSyncPrimBlockInt2[i][j], (IMG_VOID **) &psUpdateUFOSyncPrimBlockInt[i][j]);
+
+ if(psRGXSubmitTransferOUT->eError != PVRSRV_OK)
+ {
+ goto RGXSubmitTransfer_exit;
+ }
+ }
+ }
+ }
+ }
+
{
IMG_UINT32 i;
psTransferContextInt,
psRGXSubmitTransferIN->ui32PrepareCount,
ui32ClientFenceCountInt,
- sFenceUFOAddressInt,
+ psFenceUFOSyncPrimBlockInt,
+ ui32FenceSyncOffsetInt,
ui32FenceValueInt,
ui32ClientUpdateCountInt,
- sUpdateUFOAddressInt,
+ psUpdateUFOSyncPrimBlockInt,
+ ui32UpdateSyncOffsetInt,
ui32UpdateValueInt,
ui32ServerSyncCountInt,
ui32ServerSyncFlagsInt,
RGXSubmitTransfer_exit:
if (ui32ClientFenceCountInt)
OSFreeMem(ui32ClientFenceCountInt);
- if (sFenceUFOAddressInt)
- OSFreeMem(sFenceUFOAddressInt);
+ if (psFenceUFOSyncPrimBlockInt)
+ OSFreeMem(psFenceUFOSyncPrimBlockInt);
+ if (hFenceUFOSyncPrimBlockInt2)
+ OSFreeMem(hFenceUFOSyncPrimBlockInt2);
+ if (ui32FenceSyncOffsetInt)
+ OSFreeMem(ui32FenceSyncOffsetInt);
if (ui32FenceValueInt)
OSFreeMem(ui32FenceValueInt);
if (ui32ClientUpdateCountInt)
OSFreeMem(ui32ClientUpdateCountInt);
- if (sUpdateUFOAddressInt)
- OSFreeMem(sUpdateUFOAddressInt);
+ if (psUpdateUFOSyncPrimBlockInt)
+ OSFreeMem(psUpdateUFOSyncPrimBlockInt);
+ if (hUpdateUFOSyncPrimBlockInt2)
+ OSFreeMem(hUpdateUFOSyncPrimBlockInt2);
+ if (ui32UpdateSyncOffsetInt)
+ OSFreeMem(ui32UpdateSyncOffsetInt);
if (ui32UpdateValueInt)
OSFreeMem(ui32UpdateValueInt);
if (ui32ServerSyncCountInt)
{
RGX_SERVER_TQ_CONTEXT * psTransferContextInt = IMG_NULL;
IMG_HANDLE hTransferContextInt2 = IMG_NULL;
- PRGXFWIF_UFO_ADDR *sClientFenceUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * *psClientFenceUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE *hClientFenceUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 *ui32ClientFenceSyncOffsetInt = IMG_NULL;
IMG_UINT32 *ui32ClientFenceValueInt = IMG_NULL;
- PRGXFWIF_UFO_ADDR *sClientUpdateUFOAddressInt = IMG_NULL;
+ SYNC_PRIMITIVE_BLOCK * *psClientUpdateUFOSyncPrimBlockInt = IMG_NULL;
+ IMG_HANDLE *hClientUpdateUFOSyncPrimBlockInt2 = IMG_NULL;
+ IMG_UINT32 *ui32ClientUpdateSyncOffsetInt = IMG_NULL;
IMG_UINT32 *ui32ClientUpdateValueInt = IMG_NULL;
IMG_UINT32 *ui32ServerSyncFlagsInt = IMG_NULL;
SERVER_SYNC_PRIMITIVE * *psServerSyncsInt = IMG_NULL;
if (psRGXKickSyncTransferIN->ui32ClientFenceCount != 0)
{
- sClientFenceUFOAddressInt = OSAllocMem(psRGXKickSyncTransferIN->ui32ClientFenceCount * sizeof(PRGXFWIF_UFO_ADDR));
- if (!sClientFenceUFOAddressInt)
+ psClientFenceUFOSyncPrimBlockInt = OSAllocMem(psRGXKickSyncTransferIN->ui32ClientFenceCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
+ if (!psClientFenceUFOSyncPrimBlockInt)
+ {
+ psRGXKickSyncTransferOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncTransfer_exit;
+ }
+ hClientFenceUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickSyncTransferIN->ui32ClientFenceCount * sizeof(IMG_HANDLE));
+ if (!hClientFenceUFOSyncPrimBlockInt2)
{
psRGXKickSyncTransferOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTransferIN->psClientFenceUFOAddress, psRGXKickSyncTransferIN->ui32ClientFenceCount * sizeof(PRGXFWIF_UFO_ADDR))
- || (OSCopyFromUser(NULL, sClientFenceUFOAddressInt, psRGXKickSyncTransferIN->psClientFenceUFOAddress,
- psRGXKickSyncTransferIN->ui32ClientFenceCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTransferIN->phClientFenceUFOSyncPrimBlock, psRGXKickSyncTransferIN->ui32ClientFenceCount * sizeof(IMG_HANDLE))
+ || (OSCopyFromUser(NULL, hClientFenceUFOSyncPrimBlockInt2, psRGXKickSyncTransferIN->phClientFenceUFOSyncPrimBlock,
+ psRGXKickSyncTransferIN->ui32ClientFenceCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
+ {
+ psRGXKickSyncTransferOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXKickSyncTransfer_exit;
+ }
+ if (psRGXKickSyncTransferIN->ui32ClientFenceCount != 0)
+ {
+ ui32ClientFenceSyncOffsetInt = OSAllocMem(psRGXKickSyncTransferIN->ui32ClientFenceCount * sizeof(IMG_UINT32));
+ if (!ui32ClientFenceSyncOffsetInt)
+ {
+ psRGXKickSyncTransferOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncTransfer_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTransferIN->pui32ClientFenceSyncOffset, psRGXKickSyncTransferIN->ui32ClientFenceCount * sizeof(IMG_UINT32))
+ || (OSCopyFromUser(NULL, ui32ClientFenceSyncOffsetInt, psRGXKickSyncTransferIN->pui32ClientFenceSyncOffset,
+ psRGXKickSyncTransferIN->ui32ClientFenceCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickSyncTransferOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
if (psRGXKickSyncTransferIN->ui32ClientUpdateCount != 0)
{
- sClientUpdateUFOAddressInt = OSAllocMem(psRGXKickSyncTransferIN->ui32ClientUpdateCount * sizeof(PRGXFWIF_UFO_ADDR));
- if (!sClientUpdateUFOAddressInt)
+ psClientUpdateUFOSyncPrimBlockInt = OSAllocMem(psRGXKickSyncTransferIN->ui32ClientUpdateCount * sizeof(SYNC_PRIMITIVE_BLOCK *));
+ if (!psClientUpdateUFOSyncPrimBlockInt)
+ {
+ psRGXKickSyncTransferOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncTransfer_exit;
+ }
+ hClientUpdateUFOSyncPrimBlockInt2 = OSAllocMem(psRGXKickSyncTransferIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE));
+ if (!hClientUpdateUFOSyncPrimBlockInt2)
+ {
+ psRGXKickSyncTransferOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
+
+ goto RGXKickSyncTransfer_exit;
+ }
+ }
+
+ /* Copy the data over */
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTransferIN->phClientUpdateUFOSyncPrimBlock, psRGXKickSyncTransferIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE))
+ || (OSCopyFromUser(NULL, hClientUpdateUFOSyncPrimBlockInt2, psRGXKickSyncTransferIN->phClientUpdateUFOSyncPrimBlock,
+ psRGXKickSyncTransferIN->ui32ClientUpdateCount * sizeof(IMG_HANDLE)) != PVRSRV_OK) )
+ {
+ psRGXKickSyncTransferOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
+
+ goto RGXKickSyncTransfer_exit;
+ }
+ if (psRGXKickSyncTransferIN->ui32ClientUpdateCount != 0)
+ {
+ ui32ClientUpdateSyncOffsetInt = OSAllocMem(psRGXKickSyncTransferIN->ui32ClientUpdateCount * sizeof(IMG_UINT32));
+ if (!ui32ClientUpdateSyncOffsetInt)
{
psRGXKickSyncTransferOUT->eError = PVRSRV_ERROR_OUT_OF_MEMORY;
}
/* Copy the data over */
- if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTransferIN->psClientUpdateUFOAddress, psRGXKickSyncTransferIN->ui32ClientUpdateCount * sizeof(PRGXFWIF_UFO_ADDR))
- || (OSCopyFromUser(NULL, sClientUpdateUFOAddressInt, psRGXKickSyncTransferIN->psClientUpdateUFOAddress,
- psRGXKickSyncTransferIN->ui32ClientUpdateCount * sizeof(PRGXFWIF_UFO_ADDR)) != PVRSRV_OK) )
+ if ( !OSAccessOK(PVR_VERIFY_READ, (IMG_VOID*) psRGXKickSyncTransferIN->pui32ClientUpdateSyncOffset, psRGXKickSyncTransferIN->ui32ClientUpdateCount * sizeof(IMG_UINT32))
+ || (OSCopyFromUser(NULL, ui32ClientUpdateSyncOffsetInt, psRGXKickSyncTransferIN->pui32ClientUpdateSyncOffset,
+ psRGXKickSyncTransferIN->ui32ClientUpdateCount * sizeof(IMG_UINT32)) != PVRSRV_OK) )
{
psRGXKickSyncTransferOUT->eError = PVRSRV_ERROR_INVALID_PARAMS;
}
}
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXKickSyncTransferIN->ui32ClientFenceCount;i++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXKickSyncTransferOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hClientFenceUFOSyncPrimBlockInt2[i],
+ hClientFenceUFOSyncPrimBlockInt2[i],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickSyncTransferOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncTransfer_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickSyncTransferOUT->eError = ResManFindPrivateDataByPtr(hClientFenceUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClientFenceUFOSyncPrimBlockInt[i]);
+
+ if(psRGXKickSyncTransferOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncTransfer_exit;
+ }
+ }
+ }
+ }
+
+ {
+ IMG_UINT32 i;
+
+ for (i=0;i<psRGXKickSyncTransferIN->ui32ClientUpdateCount;i++)
+ {
+ {
+ /* Look up the address from the handle */
+ psRGXKickSyncTransferOUT->eError =
+ PVRSRVLookupHandle(psConnection->psHandleBase,
+ (IMG_HANDLE *) &hClientUpdateUFOSyncPrimBlockInt2[i],
+ hClientUpdateUFOSyncPrimBlockInt2[i],
+ PVRSRV_HANDLE_TYPE_SYNC_PRIMITIVE_BLOCK);
+ if(psRGXKickSyncTransferOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncTransfer_exit;
+ }
+
+ /* Look up the data from the resman address */
+ psRGXKickSyncTransferOUT->eError = ResManFindPrivateDataByPtr(hClientUpdateUFOSyncPrimBlockInt2[i], (IMG_VOID **) &psClientUpdateUFOSyncPrimBlockInt[i]);
+
+ if(psRGXKickSyncTransferOUT->eError != PVRSRV_OK)
+ {
+ goto RGXKickSyncTransfer_exit;
+ }
+ }
+ }
+ }
+
{
IMG_UINT32 i;
PVRSRVRGXKickSyncTransferKM(
psTransferContextInt,
psRGXKickSyncTransferIN->ui32ClientFenceCount,
- sClientFenceUFOAddressInt,
+ psClientFenceUFOSyncPrimBlockInt,
+ ui32ClientFenceSyncOffsetInt,
ui32ClientFenceValueInt,
psRGXKickSyncTransferIN->ui32ClientUpdateCount,
- sClientUpdateUFOAddressInt,
+ psClientUpdateUFOSyncPrimBlockInt,
+ ui32ClientUpdateSyncOffsetInt,
ui32ClientUpdateValueInt,
psRGXKickSyncTransferIN->ui32ServerSyncCount,
ui32ServerSyncFlagsInt,
RGXKickSyncTransfer_exit:
- if (sClientFenceUFOAddressInt)
- OSFreeMem(sClientFenceUFOAddressInt);
+ if (psClientFenceUFOSyncPrimBlockInt)
+ OSFreeMem(psClientFenceUFOSyncPrimBlockInt);
+ if (hClientFenceUFOSyncPrimBlockInt2)
+ OSFreeMem(hClientFenceUFOSyncPrimBlockInt2);
+ if (ui32ClientFenceSyncOffsetInt)
+ OSFreeMem(ui32ClientFenceSyncOffsetInt);
if (ui32ClientFenceValueInt)
OSFreeMem(ui32ClientFenceValueInt);
- if (sClientUpdateUFOAddressInt)
- OSFreeMem(sClientUpdateUFOAddressInt);
+ if (psClientUpdateUFOSyncPrimBlockInt)
+ OSFreeMem(psClientUpdateUFOSyncPrimBlockInt);
+ if (hClientUpdateUFOSyncPrimBlockInt2)
+ OSFreeMem(hClientUpdateUFOSyncPrimBlockInt2);
+ if (ui32ClientUpdateSyncOffsetInt)
+ OSFreeMem(ui32ClientUpdateSyncOffsetInt);
if (ui32ClientUpdateValueInt)
OSFreeMem(ui32ClientUpdateValueInt);
if (ui32ServerSyncFlagsInt)
typedef char _impl_JOIN(build_assertion_failed_##file##_,line)[2*!!(expr)-1];
/*! Macro to calculate the n-byte aligned value from that supplied rounding up.
- * n must be a power of two. */
+ * n must be a power of two.
+ *
+ * Both arguments should be of a type with the same size otherwise the macro may
+ * cut off digits, e.g. imagine a 64 bit address in _x and a 32 bit value in _n.
+ */
#define PVR_ALIGN(_x, _n) (((_x)+((_n)-1)) & ~((_n)-1))
* merge 1.4_ED3573678 DDK code
* L 0.18:
* If fix freq,then don't force to drop freq to the lowest.
+ * L 0.22:
+ * merge 1.4_ED3632227 DDK code
*/
#define PVR_STR(X) #X
#define PVRVERSION_FAMILY "rogueddk"
#define PVRVERSION_BRANCHNAME "1.4"
-#define PVRVERSION_BUILD 3573678
+#define PVRVERSION_BUILD 3632227
#define PVRVERSION_BSCONTROL "Rogue_DDK_Android_RSCompute"
#define PVRVERSION_STRING "Rogue_DDK_Android_RSCompute rogueddk 1.4@" PVR_STR2(PVRVERSION_BUILD)
#define COPYRIGHT_TXT "Copyright (c) Imagination Technologies Ltd. All Rights Reserved."
-#define PVRVERSION_BUILD_HI 357
-#define PVRVERSION_BUILD_LO 3678
+#define PVRVERSION_BUILD_HI 363
+#define PVRVERSION_BUILD_LO 2227
#define PVRVERSION_STRING_NUMERIC PVR_STR2(PVRVERSION_MAJ) "." PVR_STR2(PVRVERSION_MIN) "." PVR_STR2(PVRVERSION_BUILD_HI) "." PVR_STR2(PVRVERSION_BUILD_LO)
#define PVRVERSION_PACK(MAJ,MIN) ((((MAJ)&0xFFFF) << 16) | (((MIN)&0xFFFF) << 0))
#define PVRVERSION_UNPACK_MIN(VERSION) (((VERSION) >> 0) & 0xFFFF)
//chenli:define rockchip version
-#define RKVERSION "Rogue L 0.18"
+#define RKVERSION "Rogue L 0.22"
#endif /* _PVRVERSION_H_ */
#define PVRSRV_4K_PAGE_SIZE 4096UL /*!< Size of a 4K Page */
#define PVRSRV_4K_PAGE_SIZE_ALIGNSHIFT 12 /*!< Amount to shift an address by so that
it is always page-aligned */
+/*! 16k page size definition */
+#define PVRSRV_16K_PAGE_SIZE 16384UL /*!< Size of a 16K Page */
+#define PVRSRV_16K_PAGE_SIZE_ALIGNSHIFT 14 /*!< Amount to shift an address by so that
+ it is always page-aligned */
+/*! 64k page size definition */
+#define PVRSRV_64K_PAGE_SIZE 65536UL /*!< Size of a 64K Page */
+#define PVRSRV_64K_PAGE_SIZE_ALIGNSHIFT 16 /*!< Amount to shift an address by so that
+ it is always page-aligned */
+/*! 256k page size definition */
+#define PVRSRV_256K_PAGE_SIZE 262144UL /*!< Size of a 256K Page */
+#define PVRSRV_256K_PAGE_SIZE_ALIGNSHIFT 18 /*!< Amount to shift an address by so that
+ it is always page-aligned */
+/*! 1MB page size definition */
+#define PVRSRV_1M_PAGE_SIZE 1048576UL /*!< Size of a 1M Page */
+#define PVRSRV_1M_PAGE_SIZE_ALIGNSHIFT 20 /*!< Amount to shift an address by so that
+ it is always page-aligned */
+/*! 2MB page size definition */
+#define PVRSRV_2M_PAGE_SIZE 2097152UL /*!< Size of a 2M Page */
+#define PVRSRV_2M_PAGE_SIZE_ALIGNSHIFT 21 /*!< Amount to shift an address by so that
+ it is always page-aligned */
#define EVENTOBJNAME_MAXLENGTH (50) /*!< Max length of an event object name */
--- /dev/null
+/*************************************************************************/ /*!
+@File
+@Title Common memory management definitions
+@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
+@Description Common memory management definitions
+@License Dual MIT/GPLv2
+
+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.
+
+Alternatively, the contents of this file may be used under the terms of
+the GNU General Public License Version 2 ("GPL") in which case the provisions
+of GPL are applicable instead of those above.
+
+If you wish to allow use of your version of this file only under the terms of
+GPL, and not to allow others to use your version of this file under the terms
+of the MIT license, indicate your decision by deleting the provisions above
+and replace them with the notice and other provisions required by GPL as set
+out in the file called "GPL-COPYING" included in this distribution. If you do
+not delete the provisions above, a recipient may use your version of this file
+under the terms of either the MIT license or GPL.
+
+This License is also included in this distribution in the file called
+"MIT-COPYING".
+
+EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) 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; AND (B) 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 MM_COMMON_H
+#define MM_COMMON_H
+
+#define DEVICEMEM_HISTORY_TEXT_BUFSZ 40
+
+#endif
+
#include "common_ri_bridge.h"
#endif
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+#include "common_devicememhistory_bridge.h"
+#endif
+
#include "pvr_bridge_io.h"
/*
* Bridge Cmd Ids
#define PVRSRV_BRIDGE_RI_CMD_LAST (PVRSRV_BRIDGE_RI_START - 1)
#endif
+#define PVRSRV_BRIDGE_DEVICEMEMHISTORY_START (PVRSRV_BRIDGE_RI_CMD_LAST + 1)
+#if !defined(SUPPORT_PAGE_FAULT_DEBUG)
+#define PVRSRV_BRIDGE_DEVICEMEMHISTORY_CMD_LAST (PVRSRV_BRIDGE_DEVICEMEMHISTORY_START - 1)
+#endif
/* For rgx_bridge.h. "last" below means last+1 (first beyond last) */
-#define PVRSRV_BRIDGE_LAST_NON_DEVICE_CMD (PVRSRV_BRIDGE_RI_CMD_LAST)
+#define PVRSRV_BRIDGE_LAST_NON_DEVICE_CMD (PVRSRV_BRIDGE_DEVICEMEMHISTORY_CMD_LAST)
/******************************************************************************
* Generic bridge structures
{
IMG_UINT64 RGXFW_ALIGN ui64BIFReqStatus;
IMG_UINT64 RGXFW_ALIGN ui64BIFMMUStatus;
+ IMG_UINT64 RGXFW_ALIGN ui64PCAddress; /*!< phys address of the page catalogue */
} RGX_BIFINFO;
typedef struct _RGX_MMUINFO_
RGXFWIF_DEV_VIRTADDR n;} RGXFWIF_DLLIST_NODE;
#endif /* RGX_FIRMWARE */
+/*!
+ * This number is used to represent an invalid page catalogue physical address
+ */
+#define RGXFWIF_INVALID_PC_PHYADDR 0xFFFFFFFFFFFFFFFFLLU
/*!
Firmware memory context.
--- /dev/null
+/*************************************************************************/ /*!
+@File
+@Title Devicemem history functions
+@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
+@Description Devicemem history functions
+@License Dual MIT/GPLv2
+
+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.
+
+Alternatively, the contents of this file may be used under the terms of
+the GNU General Public License Version 2 ("GPL") in which case the provisions
+of GPL are applicable instead of those above.
+
+If you wish to allow use of your version of this file only under the terms of
+GPL, and not to allow others to use your version of this file under the terms
+of the MIT license, indicate your decision by deleting the provisions above
+and replace them with the notice and other provisions required by GPL as set
+out in the file called "GPL-COPYING" included in this distribution. If you do
+not delete the provisions above, a recipient may use your version of this file
+under the terms of either the MIT license or GPL.
+
+This License is also included in this distribution in the file called
+"MIT-COPYING".
+
+EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) 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; AND (B) 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 "allocmem.h"
+#include "pmr.h"
+#include "pvrsrv.h"
+#include "pvrsrv_device.h"
+#include "pvr_debug.h"
+#include "dllist.h"
+#include "syscommon.h"
+#include "devicemem_server.h"
+#include "lock.h"
+#include "devicemem_history_server.h"
+
+/* a device memory allocation */
+typedef struct _DEVICEMEM_HISTORY_ALLOCATION_
+{
+ IMG_DEV_VIRTADDR sDevVAddr;
+ IMG_DEVMEM_SIZE_T uiSize;
+ IMG_CHAR szString[DEVICEMEM_HISTORY_TEXT_BUFSZ];
+ IMG_UINT64 ui64Time;
+ /* FALSE if this allocation has been freed */
+ IMG_BOOL bAllocated;
+ IMG_PID uiPID;
+} DEVICEMEM_HISTORY_ALLOCATION;
+
+/* this number of entries makes the history buffer allocation just under 2MB */
+#define DEVICEMEM_HISTORY_ALLOCATION_HISTORY_LEN 29127
+
+#define DECREMENT_WITH_WRAP(value, sz) ((value) ? ((value) - 1) : ((sz) - 1))
+
+typedef struct _DEVICEMEM_HISTORY_DATA_
+{
+ IMG_UINT32 ui32Head;
+ DEVICEMEM_HISTORY_ALLOCATION *psAllocations;
+ POS_LOCK hLock;
+} DEVICEMEM_HISTORY_DATA;
+
+static DEVICEMEM_HISTORY_DATA gsDevicememHistoryData = { 0 };
+
+/* given a time stamp, calculate the age in nanoseconds (relative to now) */
+static IMG_UINT64 _CalculateAge(IMG_UINT64 ui64Then)
+{
+ IMG_UINT64 ui64Now;
+
+ ui64Now = OSClockns64();
+
+ if(ui64Now >= ui64Then)
+ {
+ /* no clock wrap */
+ return ui64Now - ui64Then;
+ }
+ else
+ {
+ /* clock has wrapped */
+ return ((~(IMG_UINT64) 0) - ui64Then) + ui64Now + 1;
+ }
+}
+
+static void DeviceMemHistoryFmt(IMG_UINT32 ui32Off, IMG_CHAR szBuffer[PVR_MAX_DEBUG_MESSAGE_LEN])
+{
+ DEVICEMEM_HISTORY_ALLOCATION *psAlloc;
+
+ psAlloc = &gsDevicememHistoryData.psAllocations[ui32Off % DEVICEMEM_HISTORY_ALLOCATION_HISTORY_LEN];
+
+ szBuffer[PVR_MAX_DEBUG_MESSAGE_LEN - 1] = '\0';
+ OSSNPrintf(szBuffer, PVR_MAX_DEBUG_MESSAGE_LEN,
+ /* PID NAME MAP/UNMAP MIN-MAX SIZE AbsUS AgeUS*/
+ "%04u %-40s %-6s "
+ IMG_DEV_VIRTADDR_FMTSPEC "-" IMG_DEV_VIRTADDR_FMTSPEC" "
+ "0x%08llX "
+ "%013llu", /* 13 digits is over 2 hours of ns */
+ psAlloc->uiPID,
+ psAlloc->szString,
+ psAlloc->bAllocated ? "MAP" : "UNMAP",
+ psAlloc->sDevVAddr.uiAddr,
+ psAlloc->sDevVAddr.uiAddr + psAlloc->uiSize - 1,
+ psAlloc->uiSize,
+ psAlloc->ui64Time);
+}
+
+static void DeviceMemHistoryFmtHeader(IMG_CHAR szBuffer[PVR_MAX_DEBUG_MESSAGE_LEN])
+{
+ OSSNPrintf(szBuffer, PVR_MAX_DEBUG_MESSAGE_LEN,
+ "%-4s %-40s %-6s %10s %10s %8s %13s",
+ "PID",
+ "NAME",
+ "ACTION",
+ "ADDR MIN",
+ "ADDR MAX",
+ "SIZE",
+ "ABS NS");
+}
+
+static void DevicememHistoryPrintAll(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf)
+{
+ IMG_CHAR szBuffer[PVR_MAX_DEBUG_MESSAGE_LEN];
+ IMG_UINT32 ui32Iter;
+
+ DeviceMemHistoryFmtHeader(szBuffer);
+ pfnDumpDebugPrintf("%s\n", szBuffer);
+
+ for(ui32Iter = DECREMENT_WITH_WRAP(gsDevicememHistoryData.ui32Head, DEVICEMEM_HISTORY_ALLOCATION_HISTORY_LEN);
+ ;
+ ui32Iter = DECREMENT_WITH_WRAP(ui32Iter, DEVICEMEM_HISTORY_ALLOCATION_HISTORY_LEN))
+ {
+ DEVICEMEM_HISTORY_ALLOCATION *psAlloc;
+
+ psAlloc = &gsDevicememHistoryData.psAllocations[ui32Iter];
+
+ /* no more written elements */
+ if(psAlloc->sDevVAddr.uiAddr == 0)
+ {
+ break;
+ }
+
+ DeviceMemHistoryFmt(ui32Iter, szBuffer);
+ pfnDumpDebugPrintf("%s\n", szBuffer);
+
+ if(ui32Iter == gsDevicememHistoryData.ui32Head)
+ {
+ break;
+ }
+ }
+ pfnDumpDebugPrintf("\nTimestamp reference: %013llu\n", OSClockns64());
+}
+
+static INLINE IMG_VOID DevicememHistoryLock(IMG_VOID)
+{
+ OSLockAcquire(gsDevicememHistoryData.hLock);
+}
+
+static INLINE IMG_VOID DevicememHistoryUnlock(IMG_VOID)
+{
+ OSLockRelease(gsDevicememHistoryData.hLock);
+}
+
+void DevicememHistoryPrintAllWrapper(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf)
+{
+ DevicememHistoryLock();
+ DevicememHistoryPrintAll(pfnDumpDebugPrintf);
+ DevicememHistoryUnlock();
+}
+
+PVRSRV_ERROR DevicememHistoryInitKM(IMG_VOID)
+{
+ PVRSRV_ERROR eError;
+
+ eError = OSLockCreate(&gsDevicememHistoryData.hLock, LOCK_TYPE_PASSIVE);
+
+ if(eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "DevicememHistoryInitKM: Failed to create lock"));
+ goto err_lock;
+ }
+
+ gsDevicememHistoryData.psAllocations = OSAllocZMem(sizeof(DEVICEMEM_HISTORY_ALLOCATION) * DEVICEMEM_HISTORY_ALLOCATION_HISTORY_LEN);
+
+ if(gsDevicememHistoryData.psAllocations == IMG_NULL)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "DevicememHistoryInitKM: Failed to allocate space for allocations list"));
+ goto err_allocations;
+ }
+
+ return PVRSRV_OK;
+
+err_allocations:
+ OSLockDestroy(gsDevicememHistoryData.hLock);
+err_lock:
+ return eError;
+}
+
+IMG_VOID DevicememHistoryDeInitKM(IMG_VOID)
+{
+ OSFREEMEM(gsDevicememHistoryData.psAllocations);
+ OSLockDestroy(gsDevicememHistoryData.hLock);
+}
+
+static PVRSRV_ERROR DevicememHistoryWrite(IMG_DEV_VIRTADDR sDevVAddr, IMG_SIZE_T uiSize,
+ const char szString[DEVICEMEM_HISTORY_TEXT_BUFSZ],
+ IMG_BOOL bAlloc)
+{
+ DEVICEMEM_HISTORY_ALLOCATION *psAlloc;
+
+ PVR_ASSERT(gsDevicememHistoryData.psAllocations != IMG_NULL);
+
+ DevicememHistoryLock();
+
+ psAlloc = &gsDevicememHistoryData.psAllocations[gsDevicememHistoryData.ui32Head];
+ PVR_ASSERT(gsDevicememHistoryData.ui32Head < DEVICEMEM_HISTORY_ALLOCATION_HISTORY_LEN);
+
+ gsDevicememHistoryData.ui32Head = (gsDevicememHistoryData.ui32Head + 1) % DEVICEMEM_HISTORY_ALLOCATION_HISTORY_LEN;
+
+ psAlloc->sDevVAddr = sDevVAddr;
+ psAlloc->uiSize = uiSize;
+ psAlloc->uiPID = OSGetCurrentProcessIDKM();
+ OSStringNCopy(psAlloc->szString, szString, sizeof(psAlloc->szString));
+ psAlloc->szString[sizeof(psAlloc->szString) - 1] = '\0';
+ psAlloc->bAllocated = bAlloc;
+ psAlloc->ui64Time = OSClockns64();
+
+ DevicememHistoryUnlock();
+
+ return PVRSRV_OK;
+}
+
+PVRSRV_ERROR DevicememHistoryMapKM(IMG_DEV_VIRTADDR sDevVAddr, IMG_SIZE_T uiSize, const char szString[DEVICEMEM_HISTORY_TEXT_BUFSZ])
+{
+ return DevicememHistoryWrite(sDevVAddr, uiSize, szString, IMG_TRUE);
+}
+
+PVRSRV_ERROR DevicememHistoryUnmapKM(IMG_DEV_VIRTADDR sDevVAddr, IMG_SIZE_T uiSize, const char szString[DEVICEMEM_HISTORY_TEXT_BUFSZ])
+{
+ return DevicememHistoryWrite(sDevVAddr, uiSize, szString, IMG_FALSE);
+}
+
+IMG_BOOL DevicememHistoryQuery(DEVICEMEM_HISTORY_QUERY_IN *psQueryIn, DEVICEMEM_HISTORY_QUERY_OUT *psQueryOut)
+{
+ IMG_UINT32 ui32Entry;
+
+ /* initialise the results count for the caller */
+ psQueryOut->ui32NumResults = 0;
+
+ DevicememHistoryLock();
+
+ /* search from newest to oldest */
+
+ ui32Entry = gsDevicememHistoryData.ui32Head;
+
+ do
+ {
+ DEVICEMEM_HISTORY_ALLOCATION *psAlloc;
+
+ /* searching backwards (from newest to oldest)
+ * wrap around backwards when going past zero
+ */
+ ui32Entry = (ui32Entry != 0) ? ui32Entry - 1 : DEVICEMEM_HISTORY_ALLOCATION_HISTORY_LEN - 1;
+ psAlloc = &gsDevicememHistoryData.psAllocations[ui32Entry];
+
+ if(((psAlloc->uiPID == psQueryIn->uiPID) || (psQueryIn->uiPID == DEVICEMEM_HISTORY_PID_ANY)) &&
+ (psQueryIn->sDevVAddr.uiAddr >= psAlloc->sDevVAddr.uiAddr) &&
+ (psQueryIn->sDevVAddr.uiAddr < psAlloc->sDevVAddr.uiAddr + psAlloc->uiSize))
+ {
+ DEVICEMEM_HISTORY_QUERY_OUT_RESULT *psResult = &psQueryOut->sResults[psQueryOut->ui32NumResults];
+
+ OSStringNCopy(psResult->szString, psAlloc->szString, sizeof(psResult->szString));
+ psResult->szString[DEVICEMEM_HISTORY_TEXT_BUFSZ - 1] = '\0';
+ psResult->sBaseDevVAddr = psAlloc->sDevVAddr;
+ psResult->uiSize = psAlloc->uiSize;
+ psResult->bAllocated = psAlloc->bAllocated;
+ psResult->ui64Age = _CalculateAge(psAlloc->ui64Time);
+ psResult->ui64When = psAlloc->ui64Time;
+ /* write the responsible PID in the placeholder */
+ psResult->sProcessInfo.uiPID = psAlloc->uiPID;
+
+ psQueryOut->ui32NumResults++;
+ }
+ } while((psQueryOut->ui32NumResults < DEVICEMEM_HISTORY_QUERY_OUT_MAX_RESULTS) &&
+ (ui32Entry != gsDevicememHistoryData.ui32Head));
+
+ DevicememHistoryUnlock();
+
+ return psQueryOut->ui32NumResults > 0;
+}
/*! Base level info structure. Must be last member in structure */
MMU_Levelx_INFO sBaseLevelInfo;
+
+ /*! Lock to ensure exclusive access when manipulating the MMU context or
+ * reading and using its content
+ */
+ POS_LOCK hLock;
};
/* useful macros */
psMMUContext->sBaseLevelInfo.ui32NumOfEntries = ui32BaseObjects;
psMMUContext->sBaseLevelInfo.ui32RefCount = 0;
+ eError = OSLockCreate(&psMMUContext->hLock, LOCK_TYPE_PASSIVE);
+
+ if(eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "MMU_ContextCreate: Failed to create lock for MMU_CONTEXT"));
+ goto e5;
+ }
+
/* return context */
*ppsMMUContext = psMMUContext;
return PVRSRV_OK;
+e5:
+ _PxMemFree(psMMUContext, &psMMUContext->sBaseLevelInfo.sMemDesc, psDevAttrs->eTopLevel);
e4:
RA_Delete(psCtx->psPhysMemRA);
e3:
OSFreeMem(psMMUContext->psPhysMemCtx);
+ OSLockDestroy(psMMUContext->hLock);
+
/* free the context itself. */
OSFreeMem(psMMUContext);
/*not nulling pointer, copy on stack*/
sDevVAddrEnd = *psDevVAddr;
sDevVAddrEnd.uiAddr += uSize;
+
+ OSLockAcquire(psMMUContext->hLock);
eError = _AllocPageTables(psMMUContext, *psDevVAddr, sDevVAddrEnd, uiProtFlags, uiLog2PageSize);
+ OSLockRelease(psMMUContext->hLock);
if (eError != PVRSRV_OK)
{
sDevVAddrEnd = sDevVAddr;
sDevVAddrEnd.uiAddr += uiSize;
+ OSLockAcquire(psMMUContext->hLock);
+
_FreePageTables(psMMUContext, sDevVAddr, sDevVAddrEnd, uiLog2PageSize);
+
+ OSLockRelease(psMMUContext->hLock);
}
/*
PDUMPCOMMENT("Invalidate the entry in %d page tables for virtual range: 0x%010llX to 0x%010llX",
ui32PageCount, (IMG_UINT64)sDevVAddr.uiAddr, ((IMG_UINT64)sDevVAddr.uiAddr)+(uiPageSize*ui32PageCount));
#endif
+
+ OSLockAcquire(psMMUContext->hLock);
+
while (ui32PageCount !=0)
{
_MMU_UnmapPage(psMMUContext, sDevVAddr, uiLog2PageSize);
sDevVAddr.uiAddr += uiPageSize;
ui32PageCount--;
}
+
+ OSLockRelease(psMMUContext->hLock);
}
/*
PDUMPCOMMENT("Wire up Page Table entries to point to the Data Pages (%lld bytes)", uiSizeBytes);
#endif
+ OSLockAcquire(psMMUContext->hLock);
+
for (i=0, uiCount=0;
uiCount<uiSizeBytes;
i++, uiCount+=uiPageSize)
*/
sDevVAddr.uiAddr += uiPageSize;
}
+
+ OSLockRelease(psMMUContext->hLock);
+
#if defined(PDUMP)
PDUMPCOMMENT("Wired up %d Page Table entries (out of %d)", ui32MappedCount, i);
#endif
IMG_UINT32 ui32PTIndex;
IMG_UINT32 ui32Log2PageSize;
+ OSLockAcquire(psMMUContext->hLock);
+
/*
At this point we don't know the page size so assume it's 4K.
When we get the the PD level (MMU_LEVEL_2) we can check to see
PVR_LOG(("Unsupported MMU setup"));
break;
}
+
+ OSLockRelease(psMMUContext->hLock);
}
#if defined(PDUMP)
IMG_INT32* pi32StatData,
IMG_CHAR** ppszStatFmtText)
{
+ static IMG_UINT32 ui32LastStatNumber = 0;
+ static IMG_BOOL bLastStatus = IMG_TRUE;
+
PVR_ASSERT(psRIMemoryStats != IMG_NULL);
PVR_UNREFERENCED_PARAMETER(pi32StatData);
+ if (ui32StatNumber > 0 && ui32LastStatNumber == ui32StatNumber)
+ return bLastStatus;
+ ui32LastStatNumber = ui32StatNumber;
+
/*
* If this request is for the first item then set the handle to null.
* If it is not the first request, then the handle should not be null
}
else if (psRIMemoryStats->pRIHandle == IMG_NULL)
{
+ ui32LastStatNumber = 0;
return IMG_FALSE;
}
-
- return RIGetListEntryKM(psRIMemoryStats->pid,
- &psRIMemoryStats->pRIHandle,
- ppszStatFmtText);
+
+ bLastStatus = RIGetListEntryKM(psRIMemoryStats->pid,
+ &psRIMemoryStats->pRIHandle,
+ ppszStatFmtText);
+ return bLastStatus;
} /* _ObtainRIMemoryStatistic */
#endif
#if defined(PVRSRV_ENABLE_PROCESS_STATS)
#include "process_stats.h"
#endif
+
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+#include "devicemem_history_server.h"
+#endif
+
/*! Wait 100ms before retrying deferred clean-up again */
#define CLEANUP_THREAD_WAIT_RETRY_TIMEOUT 0x00000064
goto Error;
}
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ eError = DevicememHistoryInitKM();
+
+ if(eError != PVRSRV_OK)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "Failed to initialise DevicememHistory"));
+ goto Error;
+ }
+#endif
+
eError = PVRSRVConnectionInit();
if(eError != PVRSRV_OK)
{
RIDeInitKM();
#endif
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ DevicememHistoryDeInitKM();
+#endif
+
eError = PVRSRVConnectionDeInit();
if (eError != PVRSRV_OK)
{
POS_LOCK hLock;
DLLIST_NODE sConnectionNode;
SYNC_CONNECTION_DATA *psSyncConnectionData; /*!< Link back to the sync connection data if there is one */
+ PRGXFWIF_UFO_ADDR uiFWAddr; /*!< The firmware address of the sync prim block */
};
struct _SERVER_SYNC_PRIMITIVE_
#define SYNC_UPDATES_PRINT(fmt, ...)
#endif
+/*!
+*****************************************************************************
+ @Function : SyncPrimitiveBlockToFWAddr
+
+ @Description : Given a pointer to a sync primitive block and an offset,
+ returns the firmware address of the sync.
+
+ @Input psSyncPrimBlock : Sync primitive block which contains the sync
+ @Input ui32Offset : Offset of sync within the sync primitive block
+ @Output psAddrOut : Absolute FW address of the sync is written out through
+ this pointer
+ @Return : PVRSRV_OK on success. PVRSRV_ERROR_INVALID_PARAMS if input
+ parameters are invalid.
+*****************************************************************************/
+
+PVRSRV_ERROR
+SyncPrimitiveBlockToFWAddr(SYNC_PRIMITIVE_BLOCK *psSyncPrimBlock,
+ IMG_UINT32 ui32Offset,
+ PRGXFWIF_UFO_ADDR *psAddrOut)
+{
+ /* check offset is legal */
+ if((ui32Offset >= psSyncPrimBlock->ui32BlockSize) ||
+ (ui32Offset % sizeof(IMG_UINT32)))
+ {
+ PVR_DPF((PVR_DBG_ERROR, "PVRSRVSyncPrimitiveBlockToFWAddr: parameters check failed"));
+ return PVRSRV_ERROR_INVALID_PARAMS;
+ }
+
+ psAddrOut->ui32Addr = psSyncPrimBlock->uiFWAddr.ui32Addr + ui32Offset;
+
+ return PVRSRV_OK;
+}
+
+/*!
+*****************************************************************************
+ @Function : SyncAddrListGrow
+
+ @Description : Grow the SYNC_ADDR_LIST so it can accommodate the given
+ number of syncs
+
+ @Input psList : The SYNC_ADDR_LIST to grow
+ @Input ui32NumSyncs : The number of sync addresses to be able to hold
+ @Return : PVRSRV_OK on success
+*****************************************************************************/
+
+static PVRSRV_ERROR SyncAddrListGrow(SYNC_ADDR_LIST *psList, IMG_UINT32 ui32NumSyncs)
+{
+ if(ui32NumSyncs > psList->ui32NumSyncs)
+ {
+ OSFreeMem(psList->pasFWAddrs);
+ psList->pasFWAddrs = OSAllocMem(sizeof(PRGXFWIF_UFO_ADDR) * ui32NumSyncs);
+ if(psList->pasFWAddrs == IMG_NULL)
+ {
+ return PVRSRV_ERROR_OUT_OF_MEMORY;
+ }
+
+ psList->ui32NumSyncs = ui32NumSyncs;
+ }
+
+ return PVRSRV_OK;
+}
+
+/*!
+*****************************************************************************
+ @Function : SyncAddrListInit
+
+ @Description : Initialise a SYNC_ADDR_LIST structure ready for use
+
+ @Input psList : The SYNC_ADDR_LIST structure to initialise
+ @Return : None
+*****************************************************************************/
+
+IMG_VOID
+SyncAddrListInit(SYNC_ADDR_LIST *psList)
+{
+ psList->ui32NumSyncs = 0;
+}
+
+/*!
+*****************************************************************************
+ @Function : SyncAddrListDeinit
+
+ @Description : Frees any resources associated with the given SYNC_ADDR_LIST
+
+ @Input psList : The SYNC_ADDR_LIST structure to deinitialise
+ @Return : None
+*****************************************************************************/
+
+IMG_VOID
+SyncAddrListDeinit(SYNC_ADDR_LIST *psList)
+{
+ if(psList->ui32NumSyncs != 0)
+ {
+ OSFreeMem(psList->pasFWAddrs);
+ }
+}
+
+/*!
+*****************************************************************************
+ @Function : SyncAddrListPopulate
+
+ @Description : Populate the given SYNC_ADDR_LIST with the FW addresses
+ of the syncs given by the SYNC_PRIMITIVE_BLOCKs and sync offsets
+
+ @Input ui32NumSyncs : The number of syncs being passed in
+ @Input apsSyncPrimBlock: Array of pointers to SYNC_PRIMITIVE_BLOCK structures
+ in which the syncs are based
+ @Input paui32SyncOffset: Array of offsets within each of the sync primitive blocks
+ where the syncs are located
+ @Return : PVRSRV_OK on success. PVRSRV_ERROR_INVALID_PARAMS if input
+ parameters are invalid.
+*****************************************************************************/
+
+PVRSRV_ERROR
+SyncAddrListPopulate(SYNC_ADDR_LIST *psList,
+ IMG_UINT32 ui32NumSyncs,
+ SYNC_PRIMITIVE_BLOCK **apsSyncPrimBlock,
+ IMG_UINT32 *paui32SyncOffset)
+{
+ IMG_UINT32 i;
+ PVRSRV_ERROR eError;
+
+ if(ui32NumSyncs > psList->ui32NumSyncs)
+ {
+ eError = SyncAddrListGrow(psList, ui32NumSyncs);
+
+ if(eError != PVRSRV_OK)
+ {
+ return eError;
+ }
+ }
+
+ for(i = 0; i < ui32NumSyncs; i++)
+ {
+ eError = SyncPrimitiveBlockToFWAddr(apsSyncPrimBlock[i],
+ paui32SyncOffset[i],
+ &psList->pasFWAddrs[i]);
+
+ if(eError != PVRSRV_OK)
+ {
+ return eError;
+ }
+ }
+
+ return PVRSRV_OK;
+}
+
#if defined(PVRSRV_ENABLE_FULL_SYNC_TRACKING)
PVRSRV_ERROR
PVRSRVSyncRecordAddKM(
eError = psDevNode->pfnAllocUFOBlock(psDevNode,
&psNewSyncBlk->psMemDesc,
- puiSyncPrimVAddr,
+ &psNewSyncBlk->uiFWAddr.ui32Addr,
&psNewSyncBlk->ui32BlockSize);
if (eError != PVRSRV_OK)
{
goto e1;
}
+ *puiSyncPrimVAddr = psNewSyncBlk->uiFWAddr.ui32Addr;
+
eError = DevmemAcquireCpuVirtAddr(psNewSyncBlk->psMemDesc,
(IMG_PVOID *) &psNewSyncBlk->pui32LinAddr);
if (eError != PVRSRV_OK)
DEVMEM_MEMDESC *psFWComputeContextStateMemDesc;
PVRSRV_CLIENT_SYNC_PRIM *psSync;
DLLIST_NODE sListNode;
+ SYNC_ADDR_LIST sSyncAddrListFence;
+ SYNC_ADDR_LIST sSyncAddrListUpdate;
};
IMG_EXPORT
goto fail_contextalloc;
}
+ SyncAddrListInit(&psComputeContext->sSyncAddrListFence);
+ SyncAddrListInit(&psComputeContext->sSyncAddrListUpdate);
+
{
PVRSRV_RGXDEV_INFO *psDevInfo = psDeviceNode->pvDevice;
DevmemFwFree(psComputeContext->psFWFrameworkMemDesc);
DevmemFwFree(psComputeContext->psFWComputeContextStateMemDesc);
SyncPrimFree(psComputeContext->psSync);
+
+ SyncAddrListDeinit(&psComputeContext->sSyncAddrListFence);
+ SyncAddrListDeinit(&psComputeContext->sSyncAddrListUpdate);
+
OSFreeMem(psComputeContext);
return PVRSRV_OK;
IMG_EXPORT
PVRSRV_ERROR PVRSRVRGXKickCDMKM(RGX_SERVER_COMPUTE_CONTEXT *psComputeContext,
IMG_UINT32 ui32ClientFenceCount,
- PRGXFWIF_UFO_ADDR *pauiClientFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **pauiClientFenceUFOSyncPrimBlock,
+ IMG_UINT32 *paui32ClientFenceSyncOffset,
IMG_UINT32 *paui32ClientFenceValue,
IMG_UINT32 ui32ClientUpdateCount,
- PRGXFWIF_UFO_ADDR *pauiClientUpdateUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **pauiClientUpdateUFOSyncPrimBlock,
+ IMG_UINT32 *paui32ClientUpdateSyncOffset,
IMG_UINT32 *paui32ClientUpdateValue,
IMG_UINT32 ui32ServerSyncPrims,
IMG_UINT32 *paui32ServerSyncFlags,
PRGXFWIF_TIMESTAMP_ADDR pPostAddr;
PRGXFWIF_UFO_ADDR pRMWUFOAddr;
-
+ eError = SyncAddrListPopulate(&psComputeContext->sSyncAddrListFence,
+ ui32ClientFenceCount,
+ pauiClientFenceUFOSyncPrimBlock,
+ paui32ClientFenceSyncOffset);
+ if(eError != PVRSRV_OK)
+ {
+ goto err_populate_sync_addr_list;
+ }
+
+ eError = SyncAddrListPopulate(&psComputeContext->sSyncAddrListUpdate,
+ ui32ClientUpdateCount,
+ pauiClientUpdateUFOSyncPrimBlock,
+ paui32ClientUpdateSyncOffset);
+ if(eError != PVRSRV_OK)
+ {
+ goto err_populate_sync_addr_list;
+ }
+
+
/* Sanity check the server fences */
for (i=0;i<ui32ServerSyncPrims;i++)
{
eError = RGXCmdHelperInitCmdCCB(FWCommonContextGetClientCCB(psComputeContext->psServerCommonContext),
ui32ClientFenceCount,
- pauiClientFenceUFOAddress,
+ psComputeContext->sSyncAddrListFence.pasFWAddrs,
paui32ClientFenceValue,
ui32ClientUpdateCount,
- pauiClientUpdateUFOAddress,
+ psComputeContext->sSyncAddrListUpdate.pasFWAddrs,
paui32ClientUpdateValue,
ui32ServerSyncPrims,
paui32ServerSyncFlags,
fail_cmdaquire:
fail_cmdinit:
+err_populate_sync_addr_list:
return eError;
}
IMG_EXPORT PVRSRV_ERROR
PVRSRVRGXKickSyncCDMKM(RGX_SERVER_COMPUTE_CONTEXT *psComputeContext,
IMG_UINT32 ui32ClientFenceCount,
- PRGXFWIF_UFO_ADDR *pauiClientFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **pauiClientFenceUFOSyncPrimBlock,
+ IMG_UINT32 *paui32ClientFenceSyncOffset,
IMG_UINT32 *paui32ClientFenceValue,
IMG_UINT32 ui32ClientUpdateCount,
- PRGXFWIF_UFO_ADDR *pauiClientUpdateUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **pauiClientUpdateUFOSyncPrimBlock,
+ IMG_UINT32 *paui32ClientUpdateSyncOffset,
IMG_UINT32 *paui32ClientUpdateValue,
IMG_UINT32 ui32ServerSyncPrims,
IMG_UINT32 *paui32ServerSyncFlags,
IMG_INT32 *paui32FenceFDs,
IMG_BOOL bPDumpContinuous)
{
+ PVRSRV_ERROR eError;
+
+ eError = SyncAddrListPopulate(&psComputeContext->sSyncAddrListFence,
+ ui32ClientFenceCount,
+ pauiClientFenceUFOSyncPrimBlock,
+ paui32ClientFenceSyncOffset);
+ if(eError != PVRSRV_OK)
+ {
+ goto err_populate_sync_addr_list;
+ }
+
+ eError = SyncAddrListPopulate(&psComputeContext->sSyncAddrListUpdate,
+ ui32ClientUpdateCount,
+ pauiClientUpdateUFOSyncPrimBlock,
+ paui32ClientUpdateSyncOffset);
+ if(eError != PVRSRV_OK)
+ {
+ goto err_populate_sync_addr_list;
+ }
+
if (ui32NumFenceFDs > 0)
{
return PVRSRV_ERROR_NOT_IMPLEMENTED;
}
- return RGXKickSyncKM(psComputeContext->psDeviceNode,
+ eError = RGXKickSyncKM(psComputeContext->psDeviceNode,
psComputeContext->psServerCommonContext,
RGXFWIF_DM_CDM,
"SyncCDM",
ui32ClientFenceCount,
- pauiClientFenceUFOAddress,
+ psComputeContext->sSyncAddrListFence.pasFWAddrs,
paui32ClientFenceValue,
ui32ClientUpdateCount,
- pauiClientUpdateUFOAddress,
+ psComputeContext->sSyncAddrListUpdate.pasFWAddrs,
paui32ClientUpdateValue,
ui32ServerSyncPrims,
paui32ServerSyncFlags,
pasServerSyncs,
bPDumpContinuous);
+
+err_populate_sync_addr_list:
+ return eError;
}
/******************************************************************************
End of file (rgxcompute.c)
IMG_EXPORT
PVRSRV_ERROR PVRSRVRGXKickCDMKM(RGX_SERVER_COMPUTE_CONTEXT *psComputeContext,
IMG_UINT32 ui32ClientFenceCount,
- PRGXFWIF_UFO_ADDR *pauiClientFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **pauiClientFenceUFOSyncPrimBlock,
+ IMG_UINT32 *paui32ClientFenceSyncOffset,
IMG_UINT32 *paui32ClientFenceValue,
IMG_UINT32 ui32ClientUpdateCount,
- PRGXFWIF_UFO_ADDR *pauiClientUpdateUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **pauiClientUpdateUFOSyncPrimBlock,
+ IMG_UINT32 *paui32ClientUpdateSyncOffset,
IMG_UINT32 *paui32ClientUpdateValue,
IMG_UINT32 ui32ServerSyncPrims,
IMG_UINT32 *paui32ServerSyncFlags,
IMG_EXPORT PVRSRV_ERROR
PVRSRVRGXKickSyncCDMKM(RGX_SERVER_COMPUTE_CONTEXT *psComputeContext,
IMG_UINT32 ui32ClientFenceCount,
- PRGXFWIF_UFO_ADDR *pauiClientFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **pauiClientFenceUFOSyncPrimBlock,
+ IMG_UINT32 *paui32ClientFenceSyncOffset,
IMG_UINT32 *paui32ClientFenceValue,
IMG_UINT32 ui32ClientUpdateCount,
- PRGXFWIF_UFO_ADDR *pauiClientUpdateUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **pauiClientUpdateUFOSyncPrimBlock,
+ IMG_UINT32 *paui32ClientUpdateSyncOffset,
IMG_UINT32 *paui32ClientUpdateValue,
IMG_UINT32 ui32ServerSyncPrims,
IMG_UINT32 *paui32ServerSyncFlags,
#include "tlstream.h"
#include "rgxfwutils.h"
#include "pvrsrv.h"
+#include "services.h"
#include "devicemem_pdump.h"
#if defined(RGX_FEATURE_RAY_TRACING)
#include "rgxray.h"
#endif
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+#include "devicemem_history_server.h"
+#endif
#define RGX_DEBUG_STR_SIZE (150)
#if !defined(RGX_FEATURE_S7_TOP_INFRASTRUCTURE)
+
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+
+typedef enum _DEVICEMEM_HISTORY_QUERY_INDEX_
+{
+ DEVICEMEM_HISTORY_QUERY_INDEX_PRECEDING,
+ DEVICEMEM_HISTORY_QUERY_INDEX_FAULTED,
+ DEVICEMEM_HISTORY_QUERY_INDEX_NEXT,
+ DEVICEMEM_HISTORY_QUERY_INDEX_COUNT,
+} DEVICEMEM_HISTORY_QUERY_INDEX;
+
+/*!
+*******************************************************************************
+
+ @Function _PrintDevicememHistoryQueryResult
+
+ @Description
+
+ Print details of a single result from a DevicememHistory query
+
+ @Input pfnDumpDebugPrintf - Debug printf function
+ @Input psResult - The DevicememHistory result to be printed
+ @Input psFaultProcessInfo - The process info derived from the page fault
+ @Input ui32Index - The index of the result
+
+ @Return IMG_VOID
+
+******************************************************************************/
+static IMG_VOID _PrintDevicememHistoryQueryResult(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
+ RGXMEM_PROCESS_INFO *psFaultProcessInfo,
+ DEVICEMEM_HISTORY_QUERY_OUT_RESULT *psResult,
+ IMG_UINT32 ui32Index)
+{
+ IMG_UINT32 ui32Remainder;
+
+ if(psFaultProcessInfo->uiPID != RGXMEM_SERVER_PID_FIRMWARE)
+ {
+ PVR_DUMPDEBUG_LOG((" [%u] Name: %s Base address: " IMG_DEV_VIRTADDR_FMTSPEC
+ " Size: " IMG_DEVMEM_SIZE_FMTSPEC
+ " Allocated: %c Modified %llu us ago (abs time %llu us)",
+ ui32Index,
+ psResult->szString,
+ (unsigned long long) psResult->sBaseDevVAddr.uiAddr,
+ (unsigned long long) psResult->uiSize,
+ psResult->bAllocated ? 'Y' : 'N',
+ (unsigned long long) OSDivide64r64(psResult->ui64Age, 1000, &ui32Remainder),
+ (unsigned long long) OSDivide64r64(psResult->ui64When, 1000, &ui32Remainder)));
+ }
+ else
+ {
+ PVR_DUMPDEBUG_LOG((" [%u] Name: %s Base address: " IMG_DEV_VIRTADDR_FMTSPEC
+ " Size: " IMG_DEVMEM_SIZE_FMTSPEC
+ " Allocated: %c Modified %llu us ago (abs time %llu us) PID: %u (%s)",
+ ui32Index,
+ psResult->szString,
+ (unsigned long long) psResult->sBaseDevVAddr.uiAddr,
+ (unsigned long long) psResult->uiSize,
+ psResult->bAllocated ? 'Y' : 'N',
+ (unsigned long long) OSDivide64r64(psResult->ui64Age, 1000, &ui32Remainder),
+ (unsigned long long) OSDivide64r64(psResult->ui64When, 1000, &ui32Remainder),
+ (unsigned int) psResult->sProcessInfo.uiPID,
+ psResult->sProcessInfo.szProcessName));
+ }
+}
+
+/*!
+*******************************************************************************
+
+ @Function _PrintDevicememHistoryQueryOut
+
+ @Description
+
+ Print details of all the results from a DevicememHistory query
+
+ @Input pfnDumpDebugPrintf - Debug printf function
+ @Input psResult - The DevicememHistory result to be printed
+
+ @Return IMG_VOID
+
+******************************************************************************/
+static IMG_VOID _PrintDevicememHistoryQueryOut(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
+ RGXMEM_PROCESS_INFO *psFaultProcessInfo,
+ DEVICEMEM_HISTORY_QUERY_OUT *psQueryOut)
+{
+ IMG_UINT32 i;
+
+ if(psQueryOut->ui32NumResults == 0)
+ {
+ PVR_DUMPDEBUG_LOG((" No results"));
+ }
+ else
+ {
+ for(i = 0; i < psQueryOut->ui32NumResults; i++)
+ {
+ _PrintDevicememHistoryQueryResult(pfnDumpDebugPrintf,
+ psFaultProcessInfo,
+ &psQueryOut->sResults[i],
+ i);
+ }
+ }
+}
+
+/* table of HW page size values and the equivalent */
+static const unsigned int aui32HWPageSizeTable[][2] =
+{
+ { 0, PVRSRV_4K_PAGE_SIZE },
+ { 1, PVRSRV_16K_PAGE_SIZE },
+ { 2, PVRSRV_64K_PAGE_SIZE },
+ { 3, PVRSRV_256K_PAGE_SIZE },
+ { 4, PVRSRV_1M_PAGE_SIZE },
+ { 5, PVRSRV_2M_PAGE_SIZE }
+};
+
+/*!
+*******************************************************************************
+
+ @Function _PageSizeHWToBytes
+
+ @Description
+
+ Convert a HW page size value to its size in bytes
+
+ @Input ui32PageSizeHW - The HW page size value
+
+ @Return IMG_UINT32 The page size in bytes
+
+******************************************************************************/
+static IMG_UINT32 _PageSizeHWToBytes(IMG_UINT32 ui32PageSizeHW)
+{
+ PVR_ASSERT(ui32PageSizeHW <= 5);
+
+ return aui32HWPageSizeTable[ui32PageSizeHW][1];
+}
+
+/*!
+*******************************************************************************
+
+ @Function _GetDevicememHistoryData
+
+ @Description
+
+ Get the DevicememHistory results for the given PID and faulting device virtual address.
+ The function will query DevicememHistory for information about the faulting page, as well
+ as the page before and after.
+
+ @Input uiPID - The process ID to search for allocations belonging to
+ @Input sFaultDevVAddr - The device address to search for allocations at/before/after
+ @Input asQueryOut - Storage for the query results
+ @Input ui32PageSizeBytes - Faulted page size in bytes
+
+ @Return IMG_VOID
+
+******************************************************************************/
+static IMG_BOOL _GetDevicememHistoryData(IMG_PID uiPID, IMG_DEV_VIRTADDR sFaultDevVAddr,
+ DEVICEMEM_HISTORY_QUERY_OUT asQueryOut[DEVICEMEM_HISTORY_QUERY_INDEX_COUNT],
+ IMG_UINT32 ui32PageSizeBytes)
+{
+ IMG_UINT32 i;
+ DEVICEMEM_HISTORY_QUERY_IN sQueryIn;
+ IMG_BOOL bAnyHits = IMG_FALSE;
+
+ /* if the page fault originated in the firmware then the allocation may
+ * appear to belong to any PID, because FW allocations are attributed
+ * to the client process creating the allocation, so instruct the
+ * devicemem_history query to search all available PIDs
+ */
+ if(uiPID == RGXMEM_SERVER_PID_FIRMWARE)
+ {
+ sQueryIn.uiPID = DEVICEMEM_HISTORY_PID_ANY;
+ }
+ else
+ {
+ sQueryIn.uiPID = uiPID;
+ }
+
+ /* query the DevicememHistory about the preceding / faulting / next page */
+
+ for(i = DEVICEMEM_HISTORY_QUERY_INDEX_PRECEDING; i < DEVICEMEM_HISTORY_QUERY_INDEX_COUNT; i++)
+ {
+ IMG_BOOL bHits;
+
+ switch(i)
+ {
+ case DEVICEMEM_HISTORY_QUERY_INDEX_PRECEDING:
+ sQueryIn.sDevVAddr.uiAddr = (sFaultDevVAddr.uiAddr & ~(IMG_UINT64)(ui32PageSizeBytes - 1)) - 1;
+ break;
+ case DEVICEMEM_HISTORY_QUERY_INDEX_FAULTED:
+ sQueryIn.sDevVAddr = sFaultDevVAddr;
+ break;
+ case DEVICEMEM_HISTORY_QUERY_INDEX_NEXT:
+ sQueryIn.sDevVAddr.uiAddr = (sFaultDevVAddr.uiAddr & ~(IMG_UINT64)(ui32PageSizeBytes - 1)) + ui32PageSizeBytes;
+ break;
+ }
+
+ /* return value ignored because we check each of the QUERY_OUT elements
+ * later to see if they contain any hits
+ */
+ bHits = DevicememHistoryQuery(&sQueryIn, &asQueryOut[i]);
+
+ if(bHits == IMG_TRUE)
+ {
+ bAnyHits = IMG_TRUE;
+ }
+ }
+
+ return bAnyHits;
+}
+
+/* stored data about one page fault */
+typedef struct _FAULT_INFO_
+{
+ /* the process info of the memory context that page faulted */
+ RGXMEM_PROCESS_INFO sProcessInfo;
+ IMG_DEV_VIRTADDR sFaultDevVAddr;
+ DEVICEMEM_HISTORY_QUERY_OUT asQueryOut[DEVICEMEM_HISTORY_QUERY_INDEX_COUNT];
+ /* the CR timer value at the time of the fault, recorded by the FW.
+ * used to differentiate different page faults
+ */
+ IMG_UINT64 ui64CRTimer;
+ /* time when this FAULT_INFO entry was added. used for timing
+ * reference against the map/unmap information
+ */
+ IMG_UINT64 ui64When;
+} FAULT_INFO;
+
+/* history list of page faults.
+ * Keeps the first `n` page faults and the last `n` page faults, like the FW
+ * HWR log
+ */
+typedef struct _FAULT_INFO_LOG_
+{
+ IMG_UINT32 ui32Head;
+ IMG_UINT32 ui32NumWrites;
+ /* the number of faults in this log need not correspond exactly to
+ * the HWINFO number of the FW, as the FW HWINFO log may contain
+ * non-page fault HWRs
+ */
+ FAULT_INFO asFaults[RGXFWIF_HWINFO_MAX];
+} FAULT_INFO_LOG;
+
+static FAULT_INFO_LOG gsFaultInfoLog = { 0 };
+
+/*!
+*******************************************************************************
+
+ @Function _QueryFaultInfo
+
+ @Description
+
+ Searches the local list of previously analysed page faults to see if the given
+ fault has already been analysed and if so, returns a pointer to the analysis
+ object (FAULT_INFO *), otherwise returns NULL.
+
+ @Input pfnDumpDebugPrintf - The debug printf function
+ @Input sFaultDevVAddr - The faulting device virtual address
+ @Input ui64CRTimer - The CR timer value recorded by the FW at the time of the fault
+
+ @Return FAULT_INFO* Pointer to an existing fault analysis structure if found, otherwise IMG_NULL
+
+******************************************************************************/
+static FAULT_INFO *_QueryFaultInfo(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
+ IMG_DEV_VIRTADDR sFaultDevVAddr,
+ IMG_UINT64 ui64CRTimer)
+{
+ IMG_UINT32 i;
+
+ for(i = 0; i < MIN(gsFaultInfoLog.ui32NumWrites, RGXFWIF_HWINFO_MAX); i++)
+ {
+ if((gsFaultInfoLog.asFaults[i].ui64CRTimer == ui64CRTimer) &&
+ (gsFaultInfoLog.asFaults[i].sFaultDevVAddr.uiAddr == sFaultDevVAddr.uiAddr))
+ {
+ return &gsFaultInfoLog.asFaults[i];
+ }
+ }
+
+ return IMG_NULL;
+}
+
+/*!
+*******************************************************************************
+
+ @Function __AcquireNextFaultInfoElement
+
+ @Description
+
+ Gets a pointer to the next element in the fault info log
+ (requires the fault info lock be held)
+
+
+ @Return FAULT_INFO* Pointer to the next record for writing
+
+******************************************************************************/
+
+static FAULT_INFO *_AcquireNextFaultInfoElement(IMG_VOID)
+{
+ IMG_UINT32 ui32Head = gsFaultInfoLog.ui32Head;
+ FAULT_INFO *psInfo = &gsFaultInfoLog.asFaults[ui32Head];
+
+ return psInfo;
+}
+
+static IMG_VOID _CommitFaultInfo(PVRSRV_RGXDEV_INFO *psDevInfo,
+ FAULT_INFO *psInfo,
+ RGXMEM_PROCESS_INFO *psProcessInfo,
+ IMG_DEV_VIRTADDR sFaultDevVAddr,
+ IMG_UINT64 ui64CRTimer)
+{
+ IMG_UINT32 i, j;
+
+ /* commit the page fault details */
+
+ psInfo->sProcessInfo = *psProcessInfo;
+ psInfo->sFaultDevVAddr = sFaultDevVAddr;
+ psInfo->ui64CRTimer = ui64CRTimer;
+ psInfo->ui64When = OSClockus64();
+
+ /* if the page fault was caused by the firmware then get information about
+ * which client application created the related allocations.
+ *
+ * Fill in the process info data for each query result.
+ */
+
+ if(psInfo->sProcessInfo.uiPID == RGXMEM_SERVER_PID_FIRMWARE)
+ {
+ for(i = 0; i < DEVICEMEM_HISTORY_QUERY_INDEX_COUNT; i++)
+ {
+ for(j = 0; j < DEVICEMEM_HISTORY_QUERY_OUT_MAX_RESULTS; j++)
+ {
+ IMG_BOOL bFound;
+
+ RGXMEM_PROCESS_INFO *psProcInfo = &psInfo->asQueryOut[i].sResults[j].sProcessInfo;
+ bFound = RGXPCPIDToProcessInfo(psDevInfo,
+ psProcInfo->uiPID,
+ psProcInfo);
+ if(!bFound)
+ {
+ OSStringNCopy(psProcInfo->szProcessName,
+ "(unknown)",
+ sizeof(psProcInfo->szProcessName) - 1);
+ psProcInfo->szProcessName[sizeof(psProcInfo->szProcessName) - 1] = '\0';
+ }
+ }
+ }
+ }
+
+ /* assert the faults circular buffer hasn't been moving and
+ * move the head along
+ */
+
+ PVR_ASSERT(psInfo == &gsFaultInfoLog.asFaults[gsFaultInfoLog.ui32Head]);
+
+ if(gsFaultInfoLog.ui32Head < RGXFWIF_HWINFO_MAX - 1)
+ {
+ gsFaultInfoLog.ui32Head++;
+ }
+ else
+ {
+ /* wrap back to the first of the 'LAST' entries */
+ gsFaultInfoLog.ui32Head = RGXFWIF_HWINFO_MAX_FIRST;
+ }
+
+ gsFaultInfoLog.ui32NumWrites++;
+
+
+}
+
+/*!
+*******************************************************************************
+
+ @Function _PrintFaultInfo
+
+ @Description
+
+ Print all the details of a page fault from a FAULT_INFO structure
+
+ @Input pfnDumpDebugPrintf - The debug printf function
+ @Input psInfo - The page fault occurrence to print
+ @Input pui32Index - (optional) index value to include in the print output
+
+ @Return IMG_VOID
+
+******************************************************************************/
+static IMG_VOID _PrintFaultInfo(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
+ FAULT_INFO *psInfo,
+ const IMG_UINT32 *pui32Index)
+{
+ IMG_UINT32 i;
+
+ IMG_PID uiPID;
+
+ uiPID = (psInfo->sProcessInfo.uiPID == RGXMEM_SERVER_PID_FIRMWARE) ? 0 : psInfo->sProcessInfo.uiPID;
+
+ if(pui32Index)
+ {
+ PVR_DUMPDEBUG_LOG(("(%u) Device memory history for page fault address 0x%010llX, CRTimer: 0x%016llX, "
+ "PID: %u (%s, unregistered: %u) Abs Time: %llu us",
+ *pui32Index,
+ (unsigned long long) psInfo->sFaultDevVAddr.uiAddr,
+ psInfo->ui64CRTimer,
+ (unsigned int) uiPID,
+ psInfo->sProcessInfo.szProcessName,
+ psInfo->sProcessInfo.bUnregistered,
+ (unsigned long long) psInfo->ui64When));
+ }
+ else
+ {
+ PVR_DUMPDEBUG_LOG(("Device memory history for page fault address 0x%010llX, PID: %u (%s, unregistered: %u) Abs Time: %llu us",
+ (unsigned long long) psInfo->sFaultDevVAddr.uiAddr,
+ (unsigned int) uiPID,
+ psInfo->sProcessInfo.szProcessName,
+ psInfo->sProcessInfo.bUnregistered,
+ (unsigned long long) psInfo->ui64When));
+ }
+
+ for(i = DEVICEMEM_HISTORY_QUERY_INDEX_PRECEDING; i < DEVICEMEM_HISTORY_QUERY_INDEX_COUNT; i++)
+ {
+ const IMG_CHAR *pszWhich;
+
+ switch(i)
+ {
+ case DEVICEMEM_HISTORY_QUERY_INDEX_PRECEDING:
+ pszWhich = "Preceding page";
+ break;
+ case DEVICEMEM_HISTORY_QUERY_INDEX_FAULTED:
+ pszWhich = "Faulted page";
+ break;
+ case DEVICEMEM_HISTORY_QUERY_INDEX_NEXT:
+ pszWhich = "Next page";
+ break;
+ }
+
+ PVR_DUMPDEBUG_LOG(("%s:", pszWhich));
+ _PrintDevicememHistoryQueryOut(pfnDumpDebugPrintf,
+ &psInfo->sProcessInfo,
+ &psInfo->asQueryOut[i]);
+ }
+}
+
+#endif
+
/*!
*******************************************************************************
@Input eBankID - BIF identifier
@Input ui64MMUStatus - MMU Status register value
@Input ui64ReqStatus - BIF request Status register value
+ @Input ui64PCAddress - Page catalogue base address of faulting access
+ @Input ui64CRTimer - RGX CR timer value at time of page fault
@Input bBIFSummary - Flag to check whether the function is called
as a part of the debug dump summary or
as a part of a HWR log
RGXDBG_BIF_ID eBankID,
IMG_UINT64 ui64MMUStatus,
IMG_UINT64 ui64ReqStatus,
+ IMG_UINT64 ui64PCAddress,
+ IMG_UINT64 ui64CRTimer,
IMG_BOOL bBIFSummary)
{
}
else
{
+ IMG_DEV_VIRTADDR sFaultDevVAddr;
+ IMG_DEV_PHYADDR sPCDevPAddr = { 0 };
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ IMG_BOOL bFound = IMG_FALSE;
+ RGXMEM_PROCESS_INFO sProcessInfo;
+ IMG_UINT32 ui32PageSizeBytes;
+ FAULT_INFO *psInfo;
+#endif
/* Bank 0 & 1 share the same fields */
PVR_DUMPDEBUG_LOG(("%s%s - FAULT:",
(bBIFSummary)?"":" ",
IMG_BOOL bROFault = (ui64MMUStatus & RGX_CR_BIF_FAULT_BANK0_MMU_STATUS_FAULT_RO_EN) != 0;
IMG_BOOL bProtFault = (ui64MMUStatus & RGX_CR_BIF_FAULT_BANK0_MMU_STATUS_FAULT_PM_META_RO_EN) != 0;
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ ui32PageSizeBytes = _PageSizeHWToBytes(ui32PageSize);
+#endif
+
PVR_DUMPDEBUG_LOG(("%s * MMU status (0x%016llX): PC = %d%s, Page Size = %d, MMU data type = %d%s%s.",
(bBIFSummary)?"":" ",
ui64MMUStatus,
IMG_UINT32 ui32TagID =
(ui64ReqStatus & ~RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_TAG_ID_CLRMSK) >>
RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_TAG_ID_SHIFT;
- IMG_UINT64 ui64Addr = (ui64ReqStatus & ~RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_ADDRESS_CLRMSK);
+ IMG_UINT64 ui64Addr = ((ui64ReqStatus & ~RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_ADDRESS_CLRMSK) >>
+ RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_ADDRESS_SHIFT) <<
+ RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_ADDRESS_ALIGNSHIFT;
_RGXDecodeBIFReqTags(eBankID, ui32TagID, ui32TagSB, &pszTagID, &pszTagSB, &aszScratch[0], RGX_DEBUG_STR_SIZE);
}
/* Check if the host thinks this fault is valid */
+
+ sFaultDevVAddr.uiAddr = (ui64ReqStatus & ~RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_ADDRESS_CLRMSK);
+
if(bBIFSummary)
{
IMG_UINT32 ui32PC =
(ui64MMUStatus & ~RGX_CR_BIF_FAULT_BANK0_MMU_STATUS_CAT_BASE_CLRMSK) >>
RGX_CR_BIF_FAULT_BANK0_MMU_STATUS_CAT_BASE_SHIFT;
- IMG_DEV_VIRTADDR sFaultDevVAddr;
- IMG_DEV_PHYADDR sPCDevPAddr;
+
+ /* Only the first 8 cat bases are application memory contexts which we can validate... */
+ if (ui32PC < 8)
+ {
+ sPCDevPAddr.uiAddr = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_BIF_CAT_BASEN(ui32PC));
+ PVR_DUMPDEBUG_LOG(("Acquired live PC address: 0x%016llX", sPCDevPAddr.uiAddr));
+ }
+ else
+ {
+ sPCDevPAddr.uiAddr = 0;
+ }
+ }
+ else
+ {
+ PVR_DUMPDEBUG_LOG(("FW logged fault using PC Address: 0x%016llX", ui64PCAddress));
+ sPCDevPAddr.uiAddr = ui64PCAddress;
+ }
- sPCDevPAddr.uiAddr = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_BIF_CAT_BASEN(ui32PC));
- sFaultDevVAddr.uiAddr = (ui64ReqStatus & ~RGX_CR_BIF_FAULT_BANK0_REQ_STATUS_ADDRESS_CLRMSK);
+ if(bBIFSummary)
+ {
+ PVR_DUMPDEBUG_LOG(("Checking faulting address 0x%010llX", sFaultDevVAddr.uiAddr));
RGXCheckFaultAddress(psDevInfo, &sFaultDevVAddr, &sPCDevPAddr);
}
-
+
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+
+ /* look to see if we have already processed this fault.
+ * if so then use the previously acquired information.
+ */
+ OSLockAcquire(psDevInfo->hDebugFaultInfoLock);
+ psInfo = _QueryFaultInfo(pfnDumpDebugPrintf, sFaultDevVAddr, ui64CRTimer);
+
+ if(psInfo == IMG_NULL)
+ {
+ if(sPCDevPAddr.uiAddr != RGXFWIF_INVALID_PC_PHYADDR)
+ {
+ /* look up the process details for the faulting page catalogue */
+ bFound = RGXPCAddrToProcessInfo(psDevInfo, sPCDevPAddr, &sProcessInfo);
+
+ if(bFound)
+ {
+ IMG_BOOL bHits;
+
+ psInfo = _AcquireNextFaultInfoElement();
+
+ /* get any DevicememHistory data for the faulting address */
+ bHits = _GetDevicememHistoryData(sProcessInfo.uiPID,
+ sFaultDevVAddr,
+ psInfo->asQueryOut,
+ ui32PageSizeBytes);
+
+ if(bHits)
+ {
+ _CommitFaultInfo(psDevInfo,
+ psInfo,
+ &sProcessInfo,
+ sFaultDevVAddr,
+ ui64CRTimer);
+ }
+ }
+ else
+ {
+ PVR_DUMPDEBUG_LOG(("Could not find PID for PC 0x%016llX", sPCDevPAddr.uiAddr));
+ }
+ }
+ else
+ {
+ PVR_DUMPDEBUG_LOG(("Page fault not applicable to Devmem History"));
+ }
+ }
+
+ /* psInfo should always be non-NULL if the process was found */
+ PVR_ASSERT((psInfo != IMG_NULL) || !bFound);
+
+ if(psInfo != IMG_NULL)
+ {
+ _PrintFaultInfo(pfnDumpDebugPrintf, psInfo, NULL);
+ }
+
+ OSLockRelease(psDevInfo->hDebugFaultInfoLock);
+#endif
+
}
}
_RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXFWIF_HWRTYPE_BIF_BANK_GET(psHWRInfo->eHWRType),
psHWRInfo->uHWRData.sBIFInfo.ui64BIFMMUStatus,
psHWRInfo->uHWRData.sBIFInfo.ui64BIFReqStatus,
+ psHWRInfo->uHWRData.sBIFInfo.ui64PCAddress,
+ psHWRInfo->ui64CRTimer,
IMG_FALSE);
}
break;
_RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXDBG_TEXAS_BIF,
psHWRInfo->uHWRData.sBIFInfo.ui64BIFMMUStatus,
psHWRInfo->uHWRData.sBIFInfo.ui64BIFReqStatus,
+ psHWRInfo->uHWRData.sBIFInfo.ui64PCAddress,
+ psHWRInfo->ui64CRTimer,
IMG_FALSE);
}
break;
ui64RegValMMUStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_BIF_FAULT_BANK0_MMU_STATUS);
ui64RegValREQStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_BIF_FAULT_BANK0_REQ_STATUS);
- _RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXDBG_BIF0, ui64RegValMMUStatus, ui64RegValREQStatus, IMG_TRUE);
+ _RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXDBG_BIF0, ui64RegValMMUStatus, ui64RegValREQStatus, 0, 0, IMG_TRUE);
ui64RegValMMUStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_BIF_FAULT_BANK1_MMU_STATUS);
ui64RegValREQStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_BIF_FAULT_BANK1_REQ_STATUS);
- _RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXDBG_BIF1, ui64RegValMMUStatus, ui64RegValREQStatus, IMG_TRUE);
+ _RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXDBG_BIF1, ui64RegValMMUStatus, ui64RegValREQStatus, 0, 0, IMG_TRUE);
#if defined(RGX_FEATURE_CLUSTER_GROUPING)
#if defined(RGX_NUM_PHANTOMS)
ui64RegValMMUStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_TEXAS_BIF_FAULT_BANK0_MMU_STATUS);
ui64RegValREQStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_TEXAS_BIF_FAULT_BANK0_REQ_STATUS);
- _RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXDBG_TEXAS, ui64RegValMMUStatus, ui64RegValREQStatus, IMG_TRUE);
+ _RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXDBG_TEXAS, ui64RegValMMUStatus, ui64RegValREQStatus, 0, 0, IMG_TRUE);
}
}
#else
ui64RegValMMUStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_TEXAS_BIF_FAULT_BANK0_MMU_STATUS);
ui64RegValREQStatus = OSReadHWReg64(psDevInfo->pvRegsBaseKM, RGX_CR_TEXAS_BIF_FAULT_BANK0_REQ_STATUS);
- _RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXDBG_TEXAS_BIF, ui64RegValMMUStatus, ui64RegValREQStatus, IMG_TRUE);
+ _RGXDumpRGXBIFBank(pfnDumpDebugPrintf, psDevInfo, RGXDBG_TEXAS_BIF, ui64RegValMMUStatus, ui64RegValREQStatus, 0, 0, IMG_TRUE);
#endif
#endif
#endif
DLLIST_NODE sCommonCtxtListHead;
IMG_UINT32 ui32CommonCtxtCurrentID; /*!< ID assigned to the next common context */
+
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ POS_LOCK hDebugFaultInfoLock; /*!< Lock to protect the debug fault info list */
+ POS_LOCK hMMUCtxUnregLock; /*!< Lock to protect list of unregistered MMU contexts */
+#endif
} PVRSRV_RGXDEV_INFO;
dllist_init(&psDevInfo->sFreeListHead);
psDevInfo->ui32FreelistCurrID = 1;
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ eError = OSLockCreate(&psDevInfo->hDebugFaultInfoLock, LOCK_TYPE_PASSIVE);
+
+ if(eError != PVRSRV_OK)
+ {
+ return eError;
+ }
+
+ eError = OSLockCreate(&psDevInfo->hMMUCtxUnregLock, LOCK_TYPE_PASSIVE);
+
+ if(eError != PVRSRV_OK)
+ {
+ return eError;
+ }
+#endif
+
/* Allocate DVFS History */
psDevInfo->psGpuDVFSHistory = OSAllocZMem(sizeof(*(psDevInfo->psGpuDVFSHistory)));
if (psDevInfo->psGpuDVFSHistory == IMG_NULL)
OSWRLockDestroy(psDevInfo->hRaytraceCtxListLock);
OSWRLockDestroy(psDevInfo->hMemoryCtxListLock);
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ OSLockDestroy(psDevInfo->hDebugFaultInfoLock);
+ OSLockDestroy(psDevInfo->hMMUCtxUnregLock);
+#endif
+
/* Free the init scripts. */
OSFreeMem(psDevInfo->psScripts);
static IMG_UINT32 ui32CacheOpps = 0;
static IMG_UINT32 ui32CacheOpSequence = 0;
-
-#define SERVER_MMU_CONTEXT_MAX_NAME 40
typedef struct _SERVER_MMU_CONTEXT_ {
DEVMEM_MEMDESC *psFWMemContextMemDesc;
MMU_CONTEXT *psMMUContext;
IMG_PID uiPID;
- IMG_CHAR szProcessName[SERVER_MMU_CONTEXT_MAX_NAME];
+ IMG_CHAR szProcessName[RGXMEM_SERVER_MMU_CONTEXT_MAX_NAME];
DLLIST_NODE sNode;
PVRSRV_RGXDEV_INFO *psDevInfo;
} SERVER_MMU_CONTEXT;
return eError;
}
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+/* page fault debug is the only current use case for needing to find process info
+ * after that process device memory context has been destroyed
+ */
+
+typedef struct _UNREGISTERED_MEMORY_CONTEXT_
+{
+ IMG_PID uiPID;
+ IMG_CHAR szProcessName[RGXMEM_SERVER_MMU_CONTEXT_MAX_NAME];
+ IMG_DEV_PHYADDR sPCDevPAddr;
+} UNREGISTERED_MEMORY_CONTEXT;
+
+/* must be a power of two */
+#define UNREGISTERED_MEMORY_CONTEXTS_HISTORY_SIZE (1 << 3)
+
+static UNREGISTERED_MEMORY_CONTEXT gasUnregisteredMemCtxs[UNREGISTERED_MEMORY_CONTEXTS_HISTORY_SIZE];
+static IMG_UINT32 gui32UnregisteredMemCtxsHead = 0;
+
+/* record a device memory context being unregistered.
+ * the list of unregistered contexts can be used to find the PID and process name
+ * belonging to a memory context which has been destroyed
+ */
+static IMG_VOID _RecordUnregisteredMemoryContext(PVRSRV_RGXDEV_INFO *psDevInfo, SERVER_MMU_CONTEXT *psServerMMUContext)
+{
+ UNREGISTERED_MEMORY_CONTEXT *psRecord;
+
+ OSLockAcquire(psDevInfo->hMMUCtxUnregLock);
+
+ psRecord = &gasUnregisteredMemCtxs[gui32UnregisteredMemCtxsHead];
+
+ gui32UnregisteredMemCtxsHead = (gui32UnregisteredMemCtxsHead + 1)
+ & (UNREGISTERED_MEMORY_CONTEXTS_HISTORY_SIZE - 1);
+
+ OSLockRelease(psDevInfo->hMMUCtxUnregLock);
+
+ psRecord->uiPID = psServerMMUContext->uiPID;
+ MMU_AcquireBaseAddr(psServerMMUContext->psMMUContext, &psRecord->sPCDevPAddr);
+ OSStringNCopy(psRecord->szProcessName, psServerMMUContext->szProcessName, sizeof(psRecord->szProcessName));
+ psRecord->szProcessName[sizeof(psRecord->szProcessName) - 1] = '\0';
+}
+
+#endif
+
IMG_VOID RGXUnregisterMemoryContext(IMG_HANDLE hPrivData)
{
SERVER_MMU_CONTEXT *psServerMMUContext = hPrivData;
dllist_remove_node(&psServerMMUContext->sNode);
OSWRLockReleaseWrite(psDevInfo->hMemoryCtxListLock);
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ _RecordUnregisteredMemoryContext(psDevInfo, psServerMMUContext);
+#endif
+
/*
* Release the page catalogue address acquired in RGXRegisterMemoryContext().
*/
psServerMMUContext->psMMUContext = psMMUContext;
psServerMMUContext->psFWMemContextMemDesc = psFWMemContextMemDesc;
if (OSSNPrintf(psServerMMUContext->szProcessName,
- SERVER_MMU_CONTEXT_MAX_NAME,
+ RGXMEM_SERVER_MMU_CONTEXT_MAX_NAME,
"%s",
- OSGetCurrentProcessNameKM()) == SERVER_MMU_CONTEXT_MAX_NAME)
+ OSGetCurrentProcessNameKM()) == RGXMEM_SERVER_MMU_CONTEXT_MAX_NAME)
{
- psServerMMUContext->szProcessName[SERVER_MMU_CONTEXT_MAX_NAME-1] = '\0';
+ psServerMMUContext->szProcessName[RGXMEM_SERVER_MMU_CONTEXT_MAX_NAME-1] = '\0';
}
OSWRLockAcquireWrite(psDevInfo->hMemoryCtxListLock, DEVINFO_MEMORYLIST);
OSWRLockReleaseRead(psDevInfo->hMemoryCtxListLock);
}
+/* input for query to find the MMU context corresponding to a
+ * page catalogue address
+ */
+typedef struct _RGX_FIND_MMU_CONTEXT_
+{
+ IMG_DEV_PHYADDR sPCAddress;
+ SERVER_MMU_CONTEXT *psServerMMUContext;
+ MMU_CONTEXT *psMMUContext;
+} RGX_FIND_MMU_CONTEXT;
+
+static IMG_BOOL _RGXFindMMUContext(PDLLIST_NODE psNode, IMG_PVOID pvCallbackData)
+{
+ SERVER_MMU_CONTEXT *psServerMMUContext = IMG_CONTAINER_OF(psNode, SERVER_MMU_CONTEXT, sNode);
+ RGX_FIND_MMU_CONTEXT *psData = pvCallbackData;
+ IMG_DEV_PHYADDR sPCDevPAddr;
+
+ if (MMU_AcquireBaseAddr(psServerMMUContext->psMMUContext, &sPCDevPAddr) != PVRSRV_OK)
+ {
+ PVR_LOG(("Failed to get PC address for memory context"));
+ return IMG_TRUE;
+ }
+
+ if (psData->sPCAddress.uiAddr == sPCDevPAddr.uiAddr)
+ {
+ psData->psServerMMUContext = psServerMMUContext;
+
+ return IMG_FALSE;
+ }
+ return IMG_TRUE;
+}
+
+/* given the physical address of a page catalogue, searches for a corresponding
+ * MMU context and if found, provides the caller details of the process.
+ * Returns IMG_TRUE if a process is found.
+ */
+IMG_BOOL RGXPCAddrToProcessInfo(PVRSRV_RGXDEV_INFO *psDevInfo, IMG_DEV_PHYADDR sPCAddress,
+ RGXMEM_PROCESS_INFO *psInfo)
+{
+ RGX_FIND_MMU_CONTEXT sData;
+ IMG_BOOL bRet = IMG_FALSE;
+
+ sData.sPCAddress = sPCAddress;
+ sData.psServerMMUContext = IMG_NULL;
+
+ /* check if the input PC addr corresponds to an active memory context */
+ dllist_foreach_node(&psDevInfo->sMemoryContextList, _RGXFindMMUContext, &sData);
+
+ if(sData.psServerMMUContext != IMG_NULL)
+ {
+ psInfo->uiPID = sData.psServerMMUContext->uiPID;
+ OSStringNCopy(psInfo->szProcessName, sData.psServerMMUContext->szProcessName, sizeof(psInfo->szProcessName));
+ psInfo->szProcessName[sizeof(psInfo->szProcessName) - 1] = '\0';
+ psInfo->bUnregistered = IMG_FALSE;
+ bRet = IMG_TRUE;
+ }
+ /* else check if the input PC addr corresponds to the firmware */
+ else
+ {
+ IMG_DEV_PHYADDR sKernelPCDevPAddr;
+ PVRSRV_ERROR eError;
+
+ eError = MMU_AcquireBaseAddr(psDevInfo->psKernelMMUCtx, &sKernelPCDevPAddr);
+
+ if(eError != PVRSRV_OK)
+ {
+ PVR_LOG(("Failed to get PC address for kernel memory context"));
+ }
+ else
+ {
+ if(sPCAddress.uiAddr == sKernelPCDevPAddr.uiAddr)
+ {
+ psInfo->uiPID = RGXMEM_SERVER_PID_FIRMWARE;
+ OSStringNCopy(psInfo->szProcessName, "Firmware", sizeof(psInfo->szProcessName));
+ psInfo->szProcessName[sizeof(psInfo->szProcessName) - 1] = '\0';
+ psInfo->bUnregistered = IMG_FALSE;
+ bRet = IMG_TRUE;
+ }
+ }
+ }
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ if(bRet == IMG_FALSE)
+ {
+ /* no active memory context found with the given PC address.
+ * Check the list of most recently freed memory contexts.
+ */
+ IMG_UINT32 i;
+
+ OSLockAcquire(psDevInfo->hMMUCtxUnregLock);
+
+ for(i = (gui32UnregisteredMemCtxsHead > 0) ? (gui32UnregisteredMemCtxsHead - 1) :
+ UNREGISTERED_MEMORY_CONTEXTS_HISTORY_SIZE;
+ i != gui32UnregisteredMemCtxsHead; i--)
+ {
+ UNREGISTERED_MEMORY_CONTEXT *psRecord = &gasUnregisteredMemCtxs[i];
+
+ if(psRecord->sPCDevPAddr.uiAddr == sPCAddress.uiAddr)
+ {
+ psInfo->uiPID = psRecord->uiPID;
+ OSStringNCopy(psInfo->szProcessName, psRecord->szProcessName, sizeof(psInfo->szProcessName)-1);
+ psInfo->szProcessName[sizeof(psInfo->szProcessName) - 1] = '\0';
+ psInfo->bUnregistered = IMG_TRUE;
+ bRet = IMG_TRUE;
+ break;
+ }
+ }
+
+ OSLockRelease(psDevInfo->hMMUCtxUnregLock);
+
+ }
+#endif
+ return bRet;
+}
+
+/* input for query to find the MMU context corresponding to a PID */
+typedef struct _RGX_FIND_MMU_CONTEXT_BY_PID_
+{
+ IMG_PID uiPID;
+ SERVER_MMU_CONTEXT *psServerMMUContext;
+ MMU_CONTEXT *psMMUContext;
+} RGX_FIND_MMU_CONTEXT_BY_PID;
+
+static IMG_BOOL _RGXFindMMUContextByPID(PDLLIST_NODE psNode, IMG_PVOID pvCallbackData)
+{
+ SERVER_MMU_CONTEXT *psServerMMUContext = IMG_CONTAINER_OF(psNode, SERVER_MMU_CONTEXT, sNode);
+ RGX_FIND_MMU_CONTEXT_BY_PID *psData = pvCallbackData;
+
+ if (psData->uiPID == psServerMMUContext->uiPID)
+ {
+ psData->psServerMMUContext = psServerMMUContext;
+
+ return IMG_FALSE;
+ }
+ return IMG_TRUE;
+}
+
+IMG_BOOL RGXPCPIDToProcessInfo(PVRSRV_RGXDEV_INFO *psDevInfo, IMG_PID uiPID,
+ RGXMEM_PROCESS_INFO *psInfo)
+{
+ RGX_FIND_MMU_CONTEXT_BY_PID sData;
+ IMG_BOOL bRet = IMG_FALSE;
+
+ sData.uiPID = uiPID;
+ sData.psServerMMUContext = IMG_NULL;
+
+ /* check if the input PID corresponds to an active memory context */
+ dllist_foreach_node(&psDevInfo->sMemoryContextList, _RGXFindMMUContextByPID, &sData);
+
+ if(sData.psServerMMUContext != IMG_NULL)
+ {
+ psInfo->uiPID = sData.psServerMMUContext->uiPID;
+ OSStringNCopy(psInfo->szProcessName, sData.psServerMMUContext->szProcessName, sizeof(psInfo->szProcessName));
+ psInfo->szProcessName[sizeof(psInfo->szProcessName) - 1] = '\0';
+ psInfo->bUnregistered = IMG_FALSE;
+ bRet = IMG_TRUE;
+ }
+ /* else check if the input PID corresponds to the firmware */
+ else if(uiPID == RGXMEM_SERVER_PID_FIRMWARE)
+ {
+ psInfo->uiPID = RGXMEM_SERVER_PID_FIRMWARE;
+ OSStringNCopy(psInfo->szProcessName, "Firmware", sizeof(psInfo->szProcessName));
+ psInfo->szProcessName[sizeof(psInfo->szProcessName) - 1] = '\0';
+ psInfo->bUnregistered = IMG_FALSE;
+ bRet = IMG_TRUE;
+ }
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ /* if the PID didn't correspond to an active context or the
+ * FW address then see if it matches a recently unregistered context
+ */
+ if(bRet == IMG_FALSE)
+ {
+ IMG_UINT32 i;
+
+ OSLockAcquire(psDevInfo->hMMUCtxUnregLock);
+
+ for(i = (gui32UnregisteredMemCtxsHead > 0) ? (gui32UnregisteredMemCtxsHead - 1) :
+ UNREGISTERED_MEMORY_CONTEXTS_HISTORY_SIZE;
+ i != gui32UnregisteredMemCtxsHead; i--)
+ {
+ UNREGISTERED_MEMORY_CONTEXT *psRecord = &gasUnregisteredMemCtxs[i];
+
+ if(psRecord->uiPID == uiPID)
+ {
+ psInfo->uiPID = psRecord->uiPID;
+ OSStringNCopy(psInfo->szProcessName, psRecord->szProcessName, sizeof(psInfo->szProcessName)-1);
+ psInfo->szProcessName[sizeof(psInfo->szProcessName) - 1] = '\0';
+ psInfo->bUnregistered = IMG_TRUE;
+ bRet = IMG_TRUE;
+ break;
+ }
+ }
+
+ OSLockRelease(psDevInfo->hMMUCtxUnregLock);
+
+ }
+#endif
+ return bRet;
+}
+
/******************************************************************************
End of file (rgxmem.c)
******************************************************************************/
#include "mmu_common.h"
#include "rgxdevice.h"
+#define RGXMEM_SERVER_MMU_CONTEXT_MAX_NAME 40
+
+/* this PID denotes the firmware */
+#define RGXMEM_SERVER_PID_FIRMWARE 0xFFFFFFFF
+
+typedef struct _RGXMEM_PROCESS_INFO_
+{
+ IMG_PID uiPID;
+ IMG_CHAR szProcessName[RGXMEM_SERVER_MMU_CONTEXT_MAX_NAME];
+ IMG_BOOL bUnregistered;
+} RGXMEM_PROCESS_INFO;
IMG_VOID RGXMMUSyncPrimAlloc(PVRSRV_DEVICE_NODE *psDeviceNode);
IMG_VOID RGXMMUSyncPrimFree(IMG_VOID);
IMG_VOID RGXCheckFaultAddress(PVRSRV_RGXDEV_INFO *psDevInfo,
IMG_DEV_VIRTADDR *psDevVAddr,
IMG_DEV_PHYADDR *psDevPAddr);
+
+IMG_BOOL RGXPCAddrToProcessInfo(PVRSRV_RGXDEV_INFO *psDevInfo, IMG_DEV_PHYADDR sPCAddress,
+ RGXMEM_PROCESS_INFO *psInfo);
+
+IMG_BOOL RGXPCPIDToProcessInfo(PVRSRV_RGXDEV_INFO *psDevInfo, IMG_PID uiPID,
+ RGXMEM_PROCESS_INFO *psInfo);
+
#endif /* __RGXMEM_H__ */
#define RC_CLEANUP_3D_COMPLETE (1 << 1)
PVRSRV_CLIENT_SYNC_PRIM *psCleanupSync;
DLLIST_NODE sListNode;
+ SYNC_ADDR_LIST sSyncAddrListTAFence;
+ SYNC_ADDR_LIST sSyncAddrListTAUpdate;
+ SYNC_ADDR_LIST sSyncAddrList3DFence;
+ SYNC_ADDR_LIST sSyncAddrList3DUpdate;
};
goto fail_3dcontext;
}
+ SyncAddrListInit(&psRenderContext->sSyncAddrListTAFence);
+ SyncAddrListInit(&psRenderContext->sSyncAddrListTAUpdate);
+ SyncAddrListInit(&psRenderContext->sSyncAddrList3DFence);
+ SyncAddrListInit(&psRenderContext->sSyncAddrList3DUpdate);
+
{
PVRSRV_RGXDEV_INFO *psDevInfo = psDeviceNode->pvDevice;
/* Free the cleanup sync */
SyncPrimFree(psRenderContext->psCleanupSync);
+ SyncAddrListDeinit(&psRenderContext->sSyncAddrListTAFence);
+ SyncAddrListDeinit(&psRenderContext->sSyncAddrListTAUpdate);
+ SyncAddrListDeinit(&psRenderContext->sSyncAddrList3DFence);
+ SyncAddrListDeinit(&psRenderContext->sSyncAddrList3DUpdate);
+
OSFreeMem(psRenderContext);
}
IMG_EXPORT
PVRSRV_ERROR PVRSRVRGXKickTA3DKM(RGX_SERVER_RENDER_CONTEXT *psRenderContext,
IMG_UINT32 ui32ClientTAFenceCount,
- PRGXFWIF_UFO_ADDR *pauiClientTAFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **apsClientTAFenceSyncPrimBlock,
+ IMG_UINT32 *paui32ClientTAFenceSyncOffset,
IMG_UINT32 *paui32ClientTAFenceValue,
IMG_UINT32 ui32ClientTAUpdateCount,
- PRGXFWIF_UFO_ADDR *pauiClientTAUpdateUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **apsClientTAUpdateSyncPrimBlock,
+ IMG_UINT32 *paui32ClientTAUpdateSyncOffset,
IMG_UINT32 *paui32ClientTAUpdateValue,
IMG_UINT32 ui32ServerTASyncPrims,
IMG_UINT32 *paui32ServerTASyncFlags,
SERVER_SYNC_PRIMITIVE **pasServerTASyncs,
IMG_UINT32 ui32Client3DFenceCount,
- PRGXFWIF_UFO_ADDR *pauiClient3DFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **apsClient3DFenceSyncPrimBlock,
+ IMG_UINT32 *paui32Client3DFenceSyncOffset,
IMG_UINT32 *paui32Client3DFenceValue,
IMG_UINT32 ui32Client3DUpdateCount,
- PRGXFWIF_UFO_ADDR *pauiClient3DUpdateUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **apsClient3DUpdateSyncPrimBlock,
+ IMG_UINT32 *paui32Client3DUpdateSyncOffset,
IMG_UINT32 *paui32Client3DUpdateValue,
IMG_UINT32 ui32Server3DSyncPrims,
IMG_UINT32 *paui32Server3DSyncFlags,
SERVER_SYNC_PRIMITIVE **pasServer3DSyncs,
- PRGXFWIF_UFO_ADDR uiPRFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK *psPRFenceSyncPrimBlock,
+ IMG_UINT32 ui32PRFenceSyncOffset,
IMG_UINT32 ui32PRFenceValue,
IMG_UINT32 ui32NumFenceFDs,
IMG_INT32 *ai32FenceFDs,
PRGXFWIF_UFO_ADDR *puiUpdateFWAddrs = IMG_NULL;
IMG_UINT32 *pui32UpdateValues = IMG_NULL;
+ PRGXFWIF_UFO_ADDR uiPRFenceUFOAddress;
+
#if defined(PVR_ANDROID_NATIVE_WINDOW_HAS_SYNC)
/* Android fd sync update info */
struct pvr_sync_append_data *psFDData = NULL;
PRGXFWIF_TIMESTAMP_ADDR pPostAddr;
PRGXFWIF_UFO_ADDR pRMWUFOAddr;
+ PRGXFWIF_UFO_ADDR *pauiClientTAFenceUFOAddress;
+ PRGXFWIF_UFO_ADDR *pauiClientTAUpdateUFOAddress;
+ PRGXFWIF_UFO_ADDR *pauiClient3DFenceUFOAddress;
+ PRGXFWIF_UFO_ADDR *pauiClient3DUpdateUFOAddress;
+
*pbCommittedRefCountsTA = IMG_FALSE;
*pbCommittedRefCounts3D = IMG_FALSE;
+ eError = SyncAddrListPopulate(&psRenderContext->sSyncAddrListTAFence,
+ ui32ClientTAFenceCount,
+ apsClientTAFenceSyncPrimBlock,
+ paui32ClientTAFenceSyncOffset);
+ if(eError != PVRSRV_OK)
+ {
+ goto err_populate_sync_addr_list;
+ }
+
+ pauiClientTAFenceUFOAddress = psRenderContext->sSyncAddrListTAFence.pasFWAddrs;
+
+ eError = SyncAddrListPopulate(&psRenderContext->sSyncAddrListTAUpdate,
+ ui32ClientTAUpdateCount,
+ apsClientTAUpdateSyncPrimBlock,
+ paui32ClientTAUpdateSyncOffset);
+ if(eError != PVRSRV_OK)
+ {
+ goto err_populate_sync_addr_list;
+ }
+
+ pauiClientTAUpdateUFOAddress = psRenderContext->sSyncAddrListTAUpdate.pasFWAddrs;
+
+ eError = SyncAddrListPopulate(&psRenderContext->sSyncAddrList3DFence,
+ ui32Client3DFenceCount,
+ apsClient3DFenceSyncPrimBlock,
+ paui32Client3DFenceSyncOffset);
+ if(eError != PVRSRV_OK)
+ {
+ goto err_populate_sync_addr_list;
+ }
+
+ pauiClient3DFenceUFOAddress = psRenderContext->sSyncAddrList3DFence.pasFWAddrs;
+
+ eError = SyncAddrListPopulate(&psRenderContext->sSyncAddrList3DUpdate,
+ ui32Client3DUpdateCount,
+ apsClient3DUpdateSyncPrimBlock,
+ paui32Client3DUpdateSyncOffset);
+ if(eError != PVRSRV_OK)
+ {
+ goto err_populate_sync_addr_list;
+ }
+
+ pauiClient3DUpdateUFOAddress = psRenderContext->sSyncAddrList3DUpdate.pasFWAddrs;
+
+ eError = SyncPrimitiveBlockToFWAddr(psPRFenceSyncPrimBlock,
+ ui32PRFenceSyncOffset,
+ &uiPRFenceUFOAddress);
+
+ if(eError != PVRSRV_OK)
+ {
+ goto err_pr_fence_address;
+ }
+
/* Sanity check the server fences */
for (i=0;i<ui32ServerTASyncPrims;i++)
{
pvr_sync_free_append_fences_data(psFDData);
fail_fdsync:
#endif
+err_pr_fence_address:
+err_populate_sync_addr_list:
PVR_ASSERT(eError != PVRSRV_OK);
return eError;
}
IMG_EXPORT PVRSRV_ERROR
PVRSRVRGXKickSyncTAKM(RGX_SERVER_RENDER_CONTEXT *psRenderContext,
IMG_UINT32 ui32TAClientFenceCount,
- PRGXFWIF_UFO_ADDR *pauiTAClientFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **apsTAClientFenceSyncPrimBlock,
+ IMG_UINT32 *paui32TAClientFenceSyncOffset,
IMG_UINT32 *paui32TAClientFenceValue,
IMG_UINT32 ui32TAClientUpdateCount,
- PRGXFWIF_UFO_ADDR *pauiTAClientUpdateUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **apsTAClientUpdateSyncPrimBlock,
+ IMG_UINT32 *paui32TAClientUpdateSyncOffset,
IMG_UINT32 *paui32TAClientUpdateValue,
IMG_UINT32 ui32TAServerSyncPrimsCount,
IMG_UINT32 *paui32TAServerSyncFlags,
SERVER_SYNC_PRIMITIVE **pasTAServerSyncs,
IMG_UINT32 ui323DClientFenceCount,
- PRGXFWIF_UFO_ADDR *paui3DClientFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **aps3DClientFenceSyncPrimBlock,
+ IMG_UINT32 *paui323DClientFenceSyncOffset,
IMG_UINT32 *paui323DClientFenceValue,
IMG_UINT32 ui323DClientUpdateCount,
- PRGXFWIF_UFO_ADDR *paui3DClientUpdateUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **aps3DClientUpdateSyncPrimBlock,
+ IMG_UINT32 *paui323DClientUpdateSyncOffset,
IMG_UINT32 *paui323DClientUpdateValue,
IMG_UINT32 ui323DServerSyncPrimsCount,
IMG_UINT32 *paui323DServerSyncFlags,
IMG_BOOL bPDumpContinuous)
{
PVRSRV_ERROR eError = PVRSRV_OK;
+ PRGXFWIF_UFO_ADDR *pauiTAClientFenceUFOAddress;
+ PRGXFWIF_UFO_ADDR *pauiTAClientUpdateUFOAddress;
+ PRGXFWIF_UFO_ADDR *paui3DClientFenceUFOAddress;
+ PRGXFWIF_UFO_ADDR *paui3DClientUpdateUFOAddress;
#if defined(PVR_ANDROID_NATIVE_WINDOW_HAS_SYNC)
/* Android fd sync update info */
struct pvr_sync_append_data *psFDData = NULL;
+#endif
+
+ eError = SyncAddrListPopulate(&psRenderContext->sSyncAddrListTAFence,
+ ui32TAClientFenceCount,
+ apsTAClientFenceSyncPrimBlock,
+ paui32TAClientFenceSyncOffset);
+ if(eError != PVRSRV_OK)
+ {
+ goto err_populate_sync_addr_list;
+ }
+
+ pauiTAClientFenceUFOAddress = psRenderContext->sSyncAddrListTAFence.pasFWAddrs;
+
+ eError = SyncAddrListPopulate(&psRenderContext->sSyncAddrListTAUpdate,
+ ui32TAClientUpdateCount,
+ apsTAClientUpdateSyncPrimBlock,
+ paui32TAClientUpdateSyncOffset);
+ if(eError != PVRSRV_OK)
+ {
+ goto err_populate_sync_addr_list;
+ }
+ pauiTAClientUpdateUFOAddress = psRenderContext->sSyncAddrListTAUpdate.pasFWAddrs;
+
+ eError = SyncAddrListPopulate(&psRenderContext->sSyncAddrList3DFence,
+ ui323DClientFenceCount,
+ aps3DClientFenceSyncPrimBlock,
+ paui323DClientFenceSyncOffset);
+ if(eError != PVRSRV_OK)
+ {
+ goto err_populate_sync_addr_list;
+ }
+
+ paui3DClientFenceUFOAddress = psRenderContext->sSyncAddrList3DFence.pasFWAddrs;
+
+ eError = SyncAddrListPopulate(&psRenderContext->sSyncAddrList3DUpdate,
+ ui323DClientUpdateCount,
+ aps3DClientUpdateSyncPrimBlock,
+ paui323DClientUpdateSyncOffset);
+ if(eError != PVRSRV_OK)
+ {
+ goto err_populate_sync_addr_list;
+ }
+
+ paui3DClientUpdateUFOAddress = psRenderContext->sSyncAddrList3DUpdate.pasFWAddrs;
+
+#if defined(PVR_ANDROID_NATIVE_WINDOW_HAS_SYNC)
/* Android FD fences are hardcoded to updates (IMG_TRUE below), Fences go to the TA and updates to the 3D */
if (ui32NumFenceFDs)
{
pvr_sync_free_append_fences_data(psFDData);
fail_fdsync:
#endif
-
+err_populate_sync_addr_list:
return eError;
}
/******************************************************************************
IMG_EXPORT
PVRSRV_ERROR PVRSRVRGXKickTA3DKM(RGX_SERVER_RENDER_CONTEXT *psRenderContext,
IMG_UINT32 ui32ClientTAFenceCount,
- PRGXFWIF_UFO_ADDR *pauiClientTAFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **apsClientTAFenceSyncPrimBlock,
+ IMG_UINT32 *paui32ClientTAFenceSyncOffset,
IMG_UINT32 *paui32ClientTAFenceValue,
IMG_UINT32 ui32ClientTAUpdateCount,
- PRGXFWIF_UFO_ADDR *pauiClientUpdateTAUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **apsClientUpdateSyncPrimBlock,
+ IMG_UINT32 *paui32ClientUpdateSyncOffset,
IMG_UINT32 *paui32ClientTAUpdateValue,
IMG_UINT32 ui32ServerTASyncPrims,
IMG_UINT32 *paui32ServerTASyncFlags,
SERVER_SYNC_PRIMITIVE **pasServerTASyncs,
IMG_UINT32 ui32Client3DFenceCount,
- PRGXFWIF_UFO_ADDR *pauiClient3DFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **apsClient3DFenceSyncPrimBlock,
+ IMG_UINT32 *pauiClient3DFenceSyncOffset,
IMG_UINT32 *paui32Client3DFenceValue,
IMG_UINT32 ui32Client3DUpdateCount,
- PRGXFWIF_UFO_ADDR *pauiClientUpdate3DUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **apsClient3DUpdateSyncPrimBlock,
+ IMG_UINT32 *paui32Client3DUpdateSyncOffset,
IMG_UINT32 *paui32Client3DUpdateValue,
IMG_UINT32 ui32Server3DSyncPrims,
IMG_UINT32 *paui32Server3DSyncFlags,
SERVER_SYNC_PRIMITIVE **pasServer3DSyncs,
- PRGXFWIF_UFO_ADDR uiPRFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK *psPRSyncPrimBlock,
+ IMG_UINT32 ui32PRSyncOffset,
IMG_UINT32 ui32PRFenceValue,
IMG_UINT32 ui32NumFenceFds,
IMG_INT32 *pai32FenceFds,
IMG_EXPORT PVRSRV_ERROR
PVRSRVRGXKickSyncTAKM(RGX_SERVER_RENDER_CONTEXT *psRenderContext,
IMG_UINT32 ui32TAClientFenceCount,
- PRGXFWIF_UFO_ADDR *pauiTAClientFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **apsClientTAFenceSyncPrimBlock,
+ IMG_UINT32 *paui32ClientTAFenceSyncOffset,
IMG_UINT32 *paui32TAClientFenceValue,
IMG_UINT32 ui32TAClientUpdateCount,
- PRGXFWIF_UFO_ADDR *pauiTAClientUpdateUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **apsClientTAUpdateSyncPrimBlock,
+ IMG_UINT32 *paui32ClientTAUpdateSyncOffset,
IMG_UINT32 *paui32TAClientUpdateValue,
IMG_UINT32 ui32TAServerSyncPrims,
IMG_UINT32 *paui32TAServerSyncFlags,
SERVER_SYNC_PRIMITIVE **pasTAServerSyncs,
IMG_UINT32 ui323DClientFenceCount,
- PRGXFWIF_UFO_ADDR *paui3DClientFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **apsClient3DFenceSyncPrimBlock,
+ IMG_UINT32 *paui32Client3DFenceSyncOffset,
IMG_UINT32 *paui323DClientFenceValue,
IMG_UINT32 ui323DClientUpdateCount,
- PRGXFWIF_UFO_ADDR *paui3DClientUpdateUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **apsClient3DUpdateSyncPrimBlock,
+ IMG_UINT32 *paui32Client3DUpdateSyncOffset,
IMG_UINT32 *paui323DClientUpdateValue,
IMG_UINT32 ui323DServerSyncPrims,
IMG_UINT32 *paui323DServerSyncFlags,
RGX_SERVER_TQ_2D_DATA s2DData;
PVRSRV_CLIENT_SYNC_PRIM *psCleanupSync;
DLLIST_NODE sListNode;
+ SYNC_ADDR_LIST sSyncAddrListFence;
+ SYNC_ADDR_LIST sSyncAddrListUpdate;
};
/*
}
psTransferContext->ui32Flags |= RGX_SERVER_TQ_CONTEXT_FLAGS_2D;
+ SyncAddrListInit(&psTransferContext->sSyncAddrListFence);
+ SyncAddrListInit(&psTransferContext->sSyncAddrListUpdate);
+
{
PVRSRV_RGXDEV_INFO *psDevInfo = psDeviceNode->pvDevice;
DevmemFwFree(psTransferContext->psFWFrameworkMemDesc);
SyncPrimFree(psTransferContext->psCleanupSync);
+ SyncAddrListDeinit(&psTransferContext->sSyncAddrListFence);
+ SyncAddrListDeinit(&psTransferContext->sSyncAddrListUpdate);
+
OSFreeMem(psTransferContext);
return PVRSRV_OK;
PVRSRV_ERROR PVRSRVRGXSubmitTransferKM(RGX_SERVER_TQ_CONTEXT *psTransferContext,
IMG_UINT32 ui32PrepareCount,
IMG_UINT32 *paui32ClientFenceCount,
- PRGXFWIF_UFO_ADDR **papauiClientFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK ***papauiClientFenceUFOSyncPrimBlock,
+ IMG_UINT32 **papaui32ClientFenceSyncOffset,
IMG_UINT32 **papaui32ClientFenceValue,
IMG_UINT32 *paui32ClientUpdateCount,
- PRGXFWIF_UFO_ADDR **papauiClientUpdateUFOAddress,
+ SYNC_PRIMITIVE_BLOCK ***papauiClientUpdateUFOSyncPrimBlock,
+ IMG_UINT32 **papaui32ClientUpdateSyncOffset,
IMG_UINT32 **papaui32ClientUpdateValue,
IMG_UINT32 *paui32ServerSyncCount,
IMG_UINT32 **papaui32ServerSyncFlags,
}
ui32IntClientFenceCount = paui32ClientFenceCount[i];
- pauiIntFenceUFOAddress = papauiClientFenceUFOAddress[i];
+ eError = SyncAddrListPopulate(&psTransferContext->sSyncAddrListFence,
+ ui32IntClientFenceCount,
+ papauiClientFenceUFOSyncPrimBlock[i],
+ papaui32ClientFenceSyncOffset[i]);
+ if(eError != PVRSRV_OK)
+ {
+ goto fail_populate_sync_addr_list;
+ }
+ pauiIntFenceUFOAddress = psTransferContext->sSyncAddrListFence.pasFWAddrs;
+
paui32IntFenceValue = papaui32ClientFenceValue[i];
ui32IntClientUpdateCount = paui32ClientUpdateCount[i];
- pauiIntUpdateUFOAddress = papauiClientUpdateUFOAddress[i];
+ eError = SyncAddrListPopulate(&psTransferContext->sSyncAddrListUpdate,
+ ui32IntClientUpdateCount,
+ papauiClientUpdateUFOSyncPrimBlock[i],
+ papaui32ClientUpdateSyncOffset[i]);
+ if(eError != PVRSRV_OK)
+ {
+ goto fail_populate_sync_addr_list;
+ }
+ pauiIntUpdateUFOAddress = psTransferContext->sSyncAddrListUpdate.pasFWAddrs;
paui32IntUpdateValue = papaui32ClientUpdateValue[i];
#if defined(PVR_ANDROID_NATIVE_WINDOW_HAS_SYNC)
psFDFenceData = NULL;
}
#endif
-
+fail_populate_sync_addr_list:
fail_pdumpcheck:
fail_cmdtype:
PVR_ASSERT(eError != PVRSRV_OK);
PVRSRV_ERROR PVRSRVRGXKickSyncTransferKM(RGX_SERVER_TQ_CONTEXT *psTransferContext,
IMG_UINT32 ui32ClientFenceCount,
- PRGXFWIF_UFO_ADDR *pauiClientFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **pauiClientFenceUFOSyncPrimBlock,
+ IMG_UINT32 *paui32ClientFenceSyncOffset,
IMG_UINT32 *paui32ClientFenceValue,
IMG_UINT32 ui32ClientUpdateCount,
- PRGXFWIF_UFO_ADDR *pauiClientUpdateUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **pauiClientUpdateUFOSyncPrimBlock,
+ IMG_UINT32 *paui32ClientUpdateSyncOffset,
IMG_UINT32 *paui32ClientUpdateValue,
IMG_UINT32 ui32ServerSyncCount,
IMG_UINT32 *pui32ServerSyncFlags,
IMG_CHAR *pszCommandName;
RGXFWIF_DM eDM;
IMG_BOOL bPDumpContinuous;
+
+ PRGXFWIF_UFO_ADDR *pauiClientFenceUFOAddress;
+ PRGXFWIF_UFO_ADDR *pauiClientUpdateUFOAddress;
+
#if defined(PVR_ANDROID_NATIVE_WINDOW_HAS_SYNC)
/* Android fd sync update info */
struct pvr_sync_append_data *psFDFenceData = NULL;
#endif /* defined(PVR_ANDROID_NATIVE_WINDOW_HAS_SYNC) */
+ eError = SyncAddrListPopulate(&psTransferContext->sSyncAddrListFence,
+ ui32ClientFenceCount,
+ pauiClientFenceUFOSyncPrimBlock,
+ paui32ClientFenceSyncOffset);
+ if(eError != PVRSRV_OK)
+ {
+ goto err_populate_sync_addr_list;
+ }
+
+ pauiClientFenceUFOAddress = psTransferContext->sSyncAddrListFence.pasFWAddrs;
+
+ eError = SyncAddrListPopulate(&psTransferContext->sSyncAddrListUpdate,
+ ui32ClientUpdateCount,
+ pauiClientUpdateUFOSyncPrimBlock,
+ paui32ClientUpdateSyncOffset);
+ if(eError != PVRSRV_OK)
+ {
+ goto err_populate_sync_addr_list;
+ }
+
+ pauiClientUpdateUFOAddress = psTransferContext->sSyncAddrListUpdate.pasFWAddrs;
+
bPDumpContinuous = ((ui32TQPrepareFlags & TQ_PREP_FLAGS_PDUMPCONTINUOUS) == TQ_PREP_FLAGS_PDUMPCONTINUOUS);
pvr_sync_free_append_fences_data(psFDFenceData);
fail_fdsync:
#endif
-
+err_populate_sync_addr_list:
return eError;
}
PVRSRV_ERROR PVRSRVRGXSubmitTransferKM(RGX_SERVER_TQ_CONTEXT *psTransferContext,
IMG_UINT32 ui32PrepareCount,
IMG_UINT32 *paui32ClientFenceCount,
- PRGXFWIF_UFO_ADDR **papauiClientFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK ***papauiClientFenceUFOSyncPrimBlock,
+ IMG_UINT32 **papaui32ClientFenceSyncOffset,
IMG_UINT32 **papaui32ClientFenceValue,
IMG_UINT32 *paui32ClientUpdateCount,
- PRGXFWIF_UFO_ADDR **papauiClientUpdateUFOAddress,
+ SYNC_PRIMITIVE_BLOCK ***papauiClientUpdateUFOSyncPrimBlock,
+ IMG_UINT32 **papaui32ClientUpdateSyncOffset,
IMG_UINT32 **papaui32ClientUpdateValue,
IMG_UINT32 *paui32ServerSyncCount,
IMG_UINT32 **papaui32ServerSyncFlags,
PVRSRV_ERROR PVRSRVRGXKickSyncTransferKM(RGX_SERVER_TQ_CONTEXT *psTransferContext,
IMG_UINT32 ui32ClientFenceCount,
- PRGXFWIF_UFO_ADDR *pauiClientFenceUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **pauiClientFenceUFOSyncPrimBlock,
+ IMG_UINT32 *paui32ClientFenceSyncOffset,
IMG_UINT32 *paui32ClientFenceValue,
IMG_UINT32 ui32ClientUpdateCount,
- PRGXFWIF_UFO_ADDR *pauiClientUpdateUFOAddress,
+ SYNC_PRIMITIVE_BLOCK **pauiClientUpdateUFOSyncPrimBlock,
+ IMG_UINT32 *paui32ClientUpdateSyncOffset,
IMG_UINT32 *paui32ClientUpdateValue,
IMG_UINT32 ui32ServerSyncCount,
IMG_UINT32 *pui32ServerSyncFlags,
pvrsrvkm-y += services/server/common/ri_server.o
endif
+ifeq ($(SUPPORT_PAGE_FAULT_DEBUG),1)
+pvrsrvkm-y += services/server/common/devicemem_history_server.o
+endif
+
ifeq ($(PVR_HANDLE_BACKEND),generic)
pvrsrvkm-y += services/server/common/handle_generic.o
else
ifeq ($(PVR_RI_DEBUG),1)
CFLAGS_ri_server.o := -Werror
endif
+ifeq ($(SUPPORT_PAGE_FAULT_DEBUG),1)
+CFLAGS_devicememhistory_server.o := -Werror
+endif
ifeq ($(SUPPORT_GPUTRACE_EVENTS),1)
CFLAGS_pvr_gputrace.o := -Werror
endif
-I$(bridge_base)/dri_bridge
endif
+ifeq ($(SUPPORT_PAGE_FAULT_DEBUG),1)
+ccflags-y += \
+ -I$(bridge_base)/devicememhistory_bridge \
+ -I$(bridge_base)/ddevicememhistory_bridge
+endif
ifeq ($(SUPPORT_RAY_TRACING),1)
ccflags-y += -I$(bridge_base)/rgxray_bridge
generated/ri_bridge/server_ri_bridge.o \
generated/dri_bridge/client_ri_bridge.o
endif
+ifeq ($(SUPPORT_PAGE_FAULT_DEBUG),1)
+pvrsrvkm-y += \
+ generated/devicememhistory_bridge/server_devicememhistory_bridge.o \
+ generated/ddevicememhistory_bridge/client_devicememhistory_bridge.o
+endif
ifeq ($(SUPPORT_DISPLAY_CLASS),1)
pvrsrvkm-y += \
CFLAGS_server_ri_bridge.o := -Werror
CFLAGS_client_ri_bridge.o := -Werror
endif
+ifeq ($(SUPPORT_PAGE_FAULT_DEBUG),1)
+CFLAGS_server_devicememhistory_bridge.o := -Werror
+CFLAGS_client_devicememhistory_bridge.o := -Werror
+endif
ifeq ($(SUPPORT_ION),1)
CFLAGS_physmem_dmabuf.o := -Werror
CFLAGS_server_dmabuf_bridge.o = -Werror
#define ON_EACH_CPU(func, info, wait) on_each_cpu(func, info, 0, wait)
#endif
-#define ROUND_UP(x,a) (((x) + (a) - 1) & ~((a) - 1))
-
static void per_cpu_cache_flush(void *arg)
{
PVR_UNREFERENCED_PARAMETER(arg);
IMG_BYTE *pbEnd = (IMG_BYTE *)pvEnd;
IMG_BYTE *pbBase;
- pbEnd = (IMG_BYTE *)ROUND_UP((IMG_UINTPTR_T)pbEnd,
- boot_cpu_data.x86_clflush_size);
+ pbEnd = (IMG_BYTE *)PVR_ALIGN((IMG_UINTPTR_T)pbEnd,
+ (IMG_UINTPTR_T)boot_cpu_data.x86_clflush_size);
mb();
for(pbBase = pbStart; pbBase < pbEnd; pbBase += boot_cpu_data.x86_clflush_size)
#include <linux/dma-buf.h>
#include <linux/scatterlist.h>
+#if defined(LDM_PCI)
+#include <linux/pci.h>
+#elif defined(LDM_PLATFORM)
+#include <linux/platform_device.h>
+#else
+#error Either LDM_PCI or LDM_PLATFORM must be defined
+#endif
+
typedef struct _PMR_DMA_BUF_DATA_
{
struct dma_buf_attachment *psAttachment;
/* Start size of the g_psDmaBufHash hash table */
#define DMA_BUF_HASH_SIZE 20
+extern
+#if defined(LDM_PCI)
+ struct pci_dev
+#elif defined(LDM_PLATFORM)
+ struct platform_device
+#endif
+ *gpsPVRLDMDev;
+
static HASH_TABLE *g_psDmaBufHash = IMG_NULL;
static IMG_UINT32 g_ui32HashRefCount = 0;
}
/* Attach a fake device to to the dmabuf */
- psPrivData->psAttachment = dma_buf_attach(psPrivData->psDmaBuf, (void *)0x1);
+ psPrivData->psAttachment = dma_buf_attach(psPrivData->psDmaBuf, &gpsPVRLDMDev->dev);
if (IS_ERR_OR_NULL(psPrivData->psAttachment))
{
#if defined(PVR_RI_DEBUG)
PVRSRV_ERROR RegisterRIFunctions(void);
#endif
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+PVRSRV_ERROR RegisterDEVICEMEMHISTORYFunctions(void);
+#endif
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+PVRSRV_ERROR InitDEVICEMEMHISTORYBridge(IMG_VOID);
+PVRSRV_ERROR DeinitDEVICEMEMHISTORYBridge(IMG_VOID);
+#endif
#if defined(SUPPORT_ION)
PVRSRV_ERROR RegisterDMABUFFunctions(void);
#endif
return eError;
}
#endif
+ #if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ eError = RegisterDEVICEMEMHISTORYFunctions();
+ if (eError != PVRSRV_OK)
+ {
+ return eError;
+ }
+ #endif
#if defined (SUPPORT_RGX)
eError = RegisterRGXTQFunctions();
#include "rgxdebug.h"
#include "lists.h"
#include "osfunc.h"
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+#include "devicemem_history_server.h"
+#endif
#if defined(PVRSRV_NEED_PVR_DPF)
}
#endif /* defined(DEBUG) */
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+
+static void *_DevicememHistorySeqStart(struct seq_file *psSeqFile,
+ loff_t *puiPosition)
+{
+ if (*puiPosition == 0)
+ {
+ return SEQ_START_TOKEN;
+ }
+
+ return NULL;
+}
+
+static void _DevicememHistorySeqStop(struct seq_file *psSeqFile, void *pvData)
+{
+ PVR_UNREFERENCED_PARAMETER(psSeqFile);
+ PVR_UNREFERENCED_PARAMETER(pvData);
+}
+
+static void *_DevicememHistorySeqNext(struct seq_file *psSeqFile,
+ void *pvData,
+ loff_t *puiPosition)
+{
+ PVR_UNREFERENCED_PARAMETER(pvData);
+
+ (*puiPosition)++;
+
+ return NULL;
+}
+
+static struct seq_file *gpsDevicememHistoryPrintfSeqFile = IMG_NULL;
+
+static void _DevicememHistorySeqPrintf(const IMG_CHAR *pszFormat, ...)
+{
+ if (gpsDevicememHistoryPrintfSeqFile)
+ {
+ IMG_CHAR szBuffer[PVR_MAX_DEBUG_MESSAGE_LEN];
+ va_list ArgList;
+
+ va_start(ArgList, pszFormat);
+ vsnprintf(szBuffer, PVR_MAX_DEBUG_MESSAGE_LEN, pszFormat, ArgList);
+ seq_printf(gpsDevicememHistoryPrintfSeqFile, "%s", szBuffer);
+ va_end(ArgList);
+ }
+}
+static int _DevicememHistorySeqShow(struct seq_file *psSeqFile, void *pvData)
+{
+ if (pvData == SEQ_START_TOKEN)
+ {
+ gpsDevicememHistoryPrintfSeqFile = psSeqFile;
+
+ DevicememHistoryPrintAllWrapper(_DevicememHistorySeqPrintf);
+
+ gpsDevicememHistoryPrintfSeqFile = NULL;
+ }
+ return 0;
+}
+
+static struct seq_operations gsDevicememHistoryReadOps =
+{
+ .start = _DevicememHistorySeqStart,
+ .stop = _DevicememHistorySeqStop,
+ .next = _DevicememHistorySeqNext,
+ .show = _DevicememHistorySeqShow,
+};
+
+static PVR_DEBUGFS_ENTRY_DATA *gpsDevicememHistoryDebugFSEntry;
+
+#endif
static PVR_DEBUGFS_ENTRY_DATA *gpsVersionDebugFSEntry;
static PVR_DEBUGFS_ENTRY_DATA *gpsNodesDebugFSEntry;
}
#endif
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ iResult = PVRDebugFSCreateEntry("devicemem_history",
+ NULL,
+ &gsDevicememHistoryReadOps,
+ NULL,
+ NULL,
+ &gpsDevicememHistoryDebugFSEntry);
+ if(iResult != 0)
+ {
+ goto ErrorRemoveDebugLevelEntry;
+ }
+#endif
+
return 0;
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ErrorRemoveDebugLevelEntry:
+#if defined(DEBUG)
+ PVRDebugFSRemoveEntry(gpsDebugLevelDebugFSEntry);
+ gpsDebugLevelDebugFSEntry = NULL;
+#endif
+#endif
+
#if (defined(DEBUG) && defined(PVRSRV_ENABLE_FW_TRACE_DEBUGFS))
ErrorRemoveFWTraceLogEntry:
PVRDebugFSRemoveEntry(gpsFWTraceDebugFSEntry);
gpsVersionDebugFSEntry = NULL;
}
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ if(gpsDevicememHistoryDebugFSEntry != NULL)
+ {
+ PVRDebugFSRemoveEntry(gpsDevicememHistoryDebugFSEntry);
+ gpsDevicememHistoryDebugFSEntry = NULL;
+ }
+#endif
+
}
PVR_DEBUGFS_DRIVER_STAT *psStatData = (PVR_DEBUGFS_DRIVER_STAT *)psSeqFile->private;
IMG_BOOL bResult = IMG_FALSE;
- if (puiPosition)
+ if (puiPosition && psStatData && psStatData->pvData)
{
- (*puiPosition)++;
+ bResult = psStatData->pfnGetNextStat(psStatData->pvData,
+ (IMG_UINT32)(*puiPosition) + 1,
+ &psStatData->i32StatValue,
+ &psStatData->pszStatFormat);
- if (psStatData)
+ if (psStatData->pszStatFormat)
{
- if (psStatData->pvData)
- {
- bResult = psStatData->pfnGetNextStat(psStatData->pvData,
- (IMG_UINT32)(*puiPosition),
- &psStatData->i32StatValue,
- &psStatData->pszStatFormat);
- }
+ IMG_CHAR tmp_buff[1];
+ IMG_INT32 i32Size = snprintf(tmp_buff, 0, psStatData->pszStatFormat,
+ psStatData->i32StatValue);
+ if ((i32Size < 0) || (psSeqFile->size - psSeqFile->count < i32Size))
+ return NULL;
}
+
+ if (bResult)
+ (*puiPosition)++;
+
}
return bResult ? psStatData : NULL;
}
if (psStatData != NULL)
{
+ int ret;
+
if (psStatData->pszStatFormat == NULL)
{
return -EINVAL;
}
- seq_printf(psSeqFile, psStatData->pszStatFormat, psStatData->i32StatValue);
+ if ((ret = seq_printf(psSeqFile, psStatData->pszStatFormat, psStatData->i32StatValue)))
+ {
+ PVR_DPF((PVR_DBG_WARNING, "%s: Overflow when writing to seq_file (%d).", __FUNCTION__, ret));
+ return ret;
+ }
}
return 0;
*/ /**************************************************************************/
PVR_DEBUGFS_DRIVER_STAT *PVRDebugFSCreateStatisticEntry(const char *pszName,
PVR_DEBUGFS_DIR_DATA *psDir,
- PVRSRV_GET_NEXT_STAT_FUNC *pfnGetNextStat,
+ PVRSRV_GET_NEXT_STAT_FUNC *pfnGetNextStat,
PVRSRV_INC_STAT_MEM_REFCOUNT_FUNC *pfnIncStatMemRefCount,
PVRSRV_INC_STAT_MEM_REFCOUNT_FUNC *pfnDecStatMemRefCount,
void *pvData)
--- /dev/null
+/*************************************************************************/ /*!
+@File devicemem_history_server.h
+@Title Resource Information abstraction
+@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
+@Description Devicemem History functions
+@License Dual MIT/GPLv2
+
+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.
+
+Alternatively, the contents of this file may be used under the terms of
+the GNU General Public License Version 2 ("GPL") in which case the provisions
+of GPL are applicable instead of those above.
+
+If you wish to allow use of your version of this file only under the terms of
+GPL, and not to allow others to use your version of this file under the terms
+of the MIT license, indicate your decision by deleting the provisions above
+and replace them with the notice and other provisions required by GPL as set
+out in the file called "GPL-COPYING" included in this distribution. If you do
+not delete the provisions above, a recipient may use your version of this file
+under the terms of either the MIT license or GPL.
+
+This License is also included in this distribution in the file called
+"MIT-COPYING".
+
+EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) 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; AND (B) 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 _DEVICEMEM_HISTORY_SERVER_H_
+#define _DEVICEMEM_HISTORY_SERVER_H_
+
+#include "img_defs.h"
+#include "mm_common.h"
+#include "pvrsrv_error.h"
+#include "rgxmem.h"
+#include "pvrsrv.h"
+
+extern PVRSRV_ERROR
+DevicememHistoryInitKM(IMG_VOID);
+
+extern IMG_VOID
+DevicememHistoryDeInitKM(IMG_VOID);
+
+extern PVRSRV_ERROR
+DevicememHistoryMapKM(IMG_DEV_VIRTADDR sDevVAddr, IMG_SIZE_T uiSize, const char szText[DEVICEMEM_HISTORY_TEXT_BUFSZ]);
+
+extern PVRSRV_ERROR
+DevicememHistoryUnmapKM(IMG_DEV_VIRTADDR sDevVAddr, IMG_SIZE_T uiSize, const char szText[DEVICEMEM_HISTORY_TEXT_BUFSZ]);
+
+/* used when the PID does not matter */
+#define DEVICEMEM_HISTORY_PID_ANY 0xFFFFFFFE
+
+typedef struct _DEVICEMEM_HISTORY_QUERY_IN_
+{
+ IMG_PID uiPID;
+ IMG_DEV_VIRTADDR sDevVAddr;
+} DEVICEMEM_HISTORY_QUERY_IN;
+
+/* store up to 2 results for a lookup. in the case of the faulting page being
+ * re-mapped between the page fault occurring on HW and the page fault analysis
+ * being done, the second result entry will show the allocation being unmapped
+ */
+#define DEVICEMEM_HISTORY_QUERY_OUT_MAX_RESULTS 2
+
+typedef struct _DEVICEMEM_HISTORY_QUERY_OUT_RESULT_
+{
+ IMG_CHAR szString[DEVICEMEM_HISTORY_TEXT_BUFSZ];
+ IMG_DEV_VIRTADDR sBaseDevVAddr;
+ IMG_SIZE_T uiSize;
+ IMG_BOOL bAllocated;
+ IMG_UINT64 ui64When;
+ IMG_UINT64 ui64Age;
+ RGXMEM_PROCESS_INFO sProcessInfo;
+} DEVICEMEM_HISTORY_QUERY_OUT_RESULT;
+
+typedef struct _DEVICEMEM_HISTORY_QUERY_OUT_
+{
+ IMG_UINT32 ui32NumResults;
+ /* result 0 is the newest */
+ DEVICEMEM_HISTORY_QUERY_OUT_RESULT sResults[DEVICEMEM_HISTORY_QUERY_OUT_MAX_RESULTS];
+} DEVICEMEM_HISTORY_QUERY_OUT;
+
+extern IMG_BOOL
+DevicememHistoryQuery(DEVICEMEM_HISTORY_QUERY_IN *psQueryIn, DEVICEMEM_HISTORY_QUERY_OUT *psQueryOut);
+
+extern void
+DevicememHistoryPrintAllWrapper(DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf);
+
+#endif
typedef struct _SYNC_CONNECTION_DATA_ SYNC_CONNECTION_DATA;
typedef struct SYNC_RECORD* SYNC_RECORD_HANDLE;
+typedef struct _SYNC_ADDR_LIST_
+{
+ IMG_UINT32 ui32NumSyncs;
+ PRGXFWIF_UFO_ADDR *pasFWAddrs;
+} SYNC_ADDR_LIST;
+
+PVRSRV_ERROR
+SyncPrimitiveBlockToFWAddr(SYNC_PRIMITIVE_BLOCK *psSyncPrimBlock,
+ IMG_UINT32 ui32Offset,
+ PRGXFWIF_UFO_ADDR *psAddrOut);
+
+IMG_VOID
+SyncAddrListInit(SYNC_ADDR_LIST *psList);
+
+IMG_VOID
+SyncAddrListDeinit(SYNC_ADDR_LIST *psList);
+
+PVRSRV_ERROR
+SyncAddrListPopulate(SYNC_ADDR_LIST *psList,
+ IMG_UINT32 ui32NumSyncs,
+ SYNC_PRIMITIVE_BLOCK **apsSyncPrimBlock,
+ IMG_UINT32 *paui32SyncOffset);
+
PVRSRV_ERROR
PVRSRVAllocSyncPrimitiveBlockKM(CONNECTION_DATA *psConnection,
PVRSRV_DEVICE_NODE *psDevNode,
#if defined(PVR_RI_DEBUG)
#include "client_ri_bridge.h"
#endif
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+#include "client_devicememhistory_bridge.h"
+#endif
#if defined(__KERNEL__)
#include "pvrsrv.h"
#endif
}
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ /* copy the allocation descriptive name and size so it can be passed to DevicememHistory when
+ * the allocation gets mapped/unmapped
+ */
+ OSStringNCopy(psMemDesc->sTraceData.szText, pszText, sizeof(psMemDesc->sTraceData.szText) - 1);
+ psMemDesc->sTraceData.uiSize = uiSize;
+#endif
#if defined(PVR_RI_DEBUG)
{
*ppsMemDescPtr = psMemDesc;
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ /* copy the allocation descriptive name and size so it can be passed to DevicememHistory when
+ * the allocation gets mapped/unmapped
+ */
+ OSStringNCopy(psMemDesc->sTraceData.szText, pszText, sizeof(psMemDesc->sTraceData.szText) - 1);
+ psMemDesc->sTraceData.uiSize = uiSize;
+#endif
+
#if defined(PVR_RI_DEBUG)
{
eError = BridgeRIWritePMREntry (psImport->hBridge,
0,
psImport);
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ /* copy the allocation descriptive name and size so it can be passed to DevicememHistory when
+ * the allocation gets mapped/unmapped
+ */
+ OSStringNCopy(psMemDesc->sTraceData.szText, pszText, sizeof(psMemDesc->sTraceData.szText) - 1);
+ psMemDesc->sTraceData.uiSize = uiSize;
+#endif
+
#if defined(PVR_RI_DEBUG)
{
eError = BridgeRIWritePMREntry (psImport->hBridge,
OSLockRelease(psMemDesc->sDeviceMemDesc.hLock);
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ BridgeDevicememHistoryMap(psMemDesc->psImport->hBridge,
+ psMemDesc->sDeviceMemDesc.sDevVAddr,
+ psMemDesc->sTraceData.uiSize,
+ psMemDesc->sTraceData.szText);
+#endif
+
#if defined(PVR_RI_DEBUG)
if (psMemDesc->hRIHandle)
{
if (--psMemDesc->sDeviceMemDesc.ui32RefCount == 0)
{
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ BridgeDevicememHistoryUnmap(psMemDesc->psImport->hBridge,
+ psMemDesc->sDeviceMemDesc.sDevVAddr,
+ psMemDesc->sTraceData.uiSize,
+ psMemDesc->sTraceData.szText);
+#endif
_DevmemImportStructDevUnmap(psMemDesc->psImport);
OSLockRelease(psMemDesc->sDeviceMemDesc.hLock);
}
+IMG_INTERNAL PVRSRV_ERROR SyncPrimLocalGetHandleAndOffset(PVRSRV_CLIENT_SYNC_PRIM *psSync,
+ IMG_HANDLE *phBlock,
+ IMG_UINT32 *pui32Offset)
+{
+ SYNC_PRIM *psSyncInt;
+
+ if(!psSync || !phBlock || !pui32Offset)
+ {
+ PVR_DPF((PVR_DBG_ERROR, "SyncPrimGetHandleAndOffset: invalid input pointer"));
+ return PVRSRV_ERROR_INVALID_PARAMS;
+ }
+
+ psSyncInt = IMG_CONTAINER_OF(psSync, SYNC_PRIM, sCommon);
+
+ PVR_ASSERT(psSyncInt->eType == SYNC_PRIM_TYPE_LOCAL);
+
+ *phBlock = psSyncInt->u.sLocal.psSyncBlock->hServerSyncPrimBlock;
+ *pui32Offset = psSyncInt->u.sLocal.uiSpanAddr - psSyncInt->u.sLocal.psSyncBlock->uiSpanBase;
+
+ return PVRSRV_OK;
+}
+
IMG_INTERNAL IMG_UINT32 SyncPrimGetFirmwareAddr(PVRSRV_CLIENT_SYNC_PRIM *psSync)
{
SYNC_PRIM *psSyncInt;
--- /dev/null
+/*************************************************************************/ /*!
+@File
+@Title Device Memory History shared definitions
+@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
+@Description Shared (client/server) definitions related to the Devicemem History
+ functionality.
+@License Dual MIT/GPLv2
+
+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.
+
+Alternatively, the contents of this file may be used under the terms of
+the GNU General Public License Version 2 ("GPL") in which case the provisions
+of GPL are applicable instead of those above.
+
+If you wish to allow use of your version of this file only under the terms of
+GPL, and not to allow others to use your version of this file under the terms
+of the MIT license, indicate your decision by deleting the provisions above
+and replace them with the notice and other provisions required by GPL as set
+out in the file called "GPL-COPYING" included in this distribution. If you do
+not delete the provisions above, a recipient may use your version of this file
+under the terms of either the MIT license or GPL.
+
+This License is also included in this distribution in the file called
+"MIT-COPYING".
+
+EXCEPT AS OTHERWISE STATED IN A NEGOTIATED AGREEMENT: (A) 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; AND (B) 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 DEVICEMEM_HISTORY_SHARED_H
+#define DEVICEMEM_HISTORY_SHARED_H
+
+/* structure used inside MEMDESC to hold the allocation name until
+ * the allocation is unmapped
+ */
+typedef struct _DEVICEMEM_HISTORY_MEMDESC_DATA_
+{
+ IMG_CHAR szText[DEVICEMEM_HISTORY_TEXT_BUFSZ];
+ IMG_DEVMEM_SIZE_T uiSize;
+} DEVICEMEM_HISTORY_MEMDESC_DATA;
+
+#endif
#include "lock.h"
#include "devicemem_mmap.h"
#include "devicemem_utils.h"
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+#include "mm_common.h"
+#include "devicemem_history_shared.h"
+#endif
#define DEVMEM_HEAPNAME_MAXLENGTH 160
DEVMEM_DEVICE_MEMDESC sDeviceMemDesc; /*!< Device specifics of the memdesc */
DEVMEM_CPU_MEMDESC sCPUMemDesc; /*!< CPU specifics of the memdesc */
+#if defined(SUPPORT_PAGE_FAULT_DEBUG)
+ DEVICEMEM_HISTORY_MEMDESC_DATA sTraceData;
+#endif
#if defined(PVR_RI_DEBUG)
IMG_HANDLE hRIHandle; /*!< Handle to RI information */
IMG_INTERNAL IMG_UINT32 SyncPrimGetFirmwareAddr(PVRSRV_CLIENT_SYNC_PRIM *psSync);
+IMG_INTERNAL PVRSRV_ERROR SyncPrimLocalGetHandleAndOffset(PVRSRV_CLIENT_SYNC_PRIM *psSync,
+ IMG_HANDLE *phBlock,
+ IMG_UINT32 *pui32Offset);
+
+
#endif /* _SYNC_INTERNAL_ */
projects / firefly-linux-kernel-4.4.55.git / commitdiff