/*************************************************************************/ /*!
|
@File rgxtdmtransfer.c
|
@Title Device specific TDM transfer queue routines
|
@Copyright Copyright (c) Imagination Technologies Ltd. All Rights Reserved
|
@Description Device specific 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 "pdump_km.h"
|
#include "rgxdevice.h"
|
#include "rgxccb.h"
|
#include "rgxutils.h"
|
#include "rgxfwutils.h"
|
#include "rgxtdmtransfer.h"
|
#include "rgx_tq_shared.h"
|
#include "rgxmem.h"
|
#include "allocmem.h"
|
#include "devicemem.h"
|
#include "devicemem_pdump.h"
|
#include "osfunc.h"
|
#include "pvr_debug.h"
|
#include "pvrsrv.h"
|
#include "rgx_fwif_resetframework.h"
|
#include "rgx_memallocflags.h"
|
#include "rgxtimerquery.h"
|
#include "rgxhwperf.h"
|
#include "htbuffer.h"
|
|
#include "pdump_km.h"
|
|
#include "sync_server.h"
|
#include "sync_internal.h"
|
#include "sync.h"
|
|
#if defined(SUPPORT_BUFFER_SYNC)
|
#include "pvr_buffer_sync.h"
|
#endif
|
|
#if defined(SUPPORT_NATIVE_FENCE_SYNC)
|
#include "pvr_sync.h"
|
#endif
|
|
|
typedef struct {
|
RGX_SERVER_COMMON_CONTEXT * psServerCommonContext;
|
IMG_UINT32 ui32Priority;
|
} RGX_SERVER_TQ_TDM_DATA;
|
|
|
struct _RGX_SERVER_TQ_TDM_CONTEXT_ {
|
PVRSRV_DEVICE_NODE *psDeviceNode;
|
DEVMEM_MEMDESC *psFWFrameworkMemDesc;
|
IMG_UINT32 ui32Flags;
|
RGX_SERVER_TQ_TDM_DATA sTDMData;
|
PVRSRV_CLIENT_SYNC_PRIM *psCleanupSync;
|
DLLIST_NODE sListNode;
|
SYNC_ADDR_LIST sSyncAddrListFence;
|
SYNC_ADDR_LIST sSyncAddrListUpdate;
|
ATOMIC_T hJobId;
|
};
|
|
static PVRSRV_ERROR _CreateTDMTransferContext(
|
CONNECTION_DATA * psConnection,
|
PVRSRV_DEVICE_NODE * psDeviceNode,
|
DEVMEM_MEMDESC * psFWMemContextMemDesc,
|
IMG_UINT32 ui32Priority,
|
RGX_COMMON_CONTEXT_INFO * psInfo,
|
RGX_SERVER_TQ_TDM_DATA * psTDMData)
|
{
|
PVRSRV_ERROR eError;
|
|
eError = FWCommonContextAllocate(
|
psConnection,
|
psDeviceNode,
|
REQ_TYPE_TQ_TDM,
|
RGXFWIF_DM_TDM,
|
NULL,
|
0,
|
psFWMemContextMemDesc,
|
NULL,
|
RGX_TQ2D_CCB_SIZE_LOG2,
|
ui32Priority,
|
psInfo,
|
&psTDMData->psServerCommonContext);
|
if (eError != PVRSRV_OK)
|
{
|
goto fail_contextalloc;
|
}
|
|
psTDMData->ui32Priority = ui32Priority;
|
return PVRSRV_OK;
|
|
fail_contextalloc:
|
PVR_ASSERT(eError != PVRSRV_OK);
|
return eError;
|
}
|
|
|
static PVRSRV_ERROR _DestroyTDMTransferContext(
|
RGX_SERVER_TQ_TDM_DATA * psTDMData,
|
PVRSRV_DEVICE_NODE * psDeviceNode,
|
PVRSRV_CLIENT_SYNC_PRIM * psCleanupSync)
|
{
|
PVRSRV_ERROR eError;
|
|
/* Check if the FW has finished with this resource ... */
|
eError = RGXFWRequestCommonContextCleanUp(
|
psDeviceNode,
|
psTDMData->psServerCommonContext,
|
psCleanupSync,
|
RGXFWIF_DM_TDM,
|
PDUMP_FLAGS_NONE);
|
if (eError == PVRSRV_ERROR_RETRY)
|
{
|
return eError;
|
}
|
else if (eError != PVRSRV_OK)
|
{
|
PVR_LOG(("%s: Unexpected error from RGXFWRequestCommonContextCleanUp (%s)",
|
__FUNCTION__,
|
PVRSRVGetErrorStringKM(eError)));
|
return eError;
|
}
|
|
/* ... it has so we can free it's resources */
|
FWCommonContextFree(psTDMData->psServerCommonContext);
|
return PVRSRV_OK;
|
}
|
|
/*
|
* PVRSRVCreateTransferContextKM
|
*/
|
IMG_EXPORT
|
PVRSRV_ERROR PVRSRVRGXTDMCreateTransferContextKM(
|
CONNECTION_DATA * psConnection,
|
PVRSRV_DEVICE_NODE * psDeviceNode,
|
IMG_UINT32 ui32Priority,
|
IMG_DEV_VIRTADDR sMCUFenceAddr,
|
IMG_UINT32 ui32FrameworkCommandSize,
|
IMG_PBYTE pabyFrameworkCommand,
|
IMG_HANDLE hMemCtxPrivData,
|
RGX_SERVER_TQ_TDM_CONTEXT ** ppsTransferContext)
|
{
|
RGX_SERVER_TQ_TDM_CONTEXT * psTransferContext;
|
|
DEVMEM_MEMDESC * psFWMemContextMemDesc = RGXGetFWMemDescFromMemoryContextHandle(hMemCtxPrivData);
|
RGX_COMMON_CONTEXT_INFO sInfo;
|
PVRSRV_ERROR eError = PVRSRV_OK;
|
PVRSRV_RGXDEV_INFO *psDevInfo = psDeviceNode->pvDevice;
|
|
/* Allocate the server side structure */
|
*ppsTransferContext = NULL;
|
psTransferContext = OSAllocZMem(sizeof(*psTransferContext));
|
if (psTransferContext == NULL)
|
{
|
return PVRSRV_ERROR_OUT_OF_MEMORY;
|
}
|
|
psTransferContext->psDeviceNode = psDeviceNode;
|
|
/* Allocate cleanup sync */
|
eError = SyncPrimAlloc(psDeviceNode->hSyncPrimContext,
|
&psTransferContext->psCleanupSync,
|
"transfer context cleanup");
|
if (eError != PVRSRV_OK)
|
{
|
PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateTransferContextKM: Failed to allocate cleanup sync (0x%x)",
|
eError));
|
goto fail_syncalloc;
|
}
|
|
/*
|
* Create the FW framework buffer
|
*/
|
eError = PVRSRVRGXFrameworkCreateKM(psDeviceNode,
|
&psTransferContext->psFWFrameworkMemDesc,
|
ui32FrameworkCommandSize);
|
if (eError != PVRSRV_OK)
|
{
|
PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateTransferContextKM: Failed to allocate firmware GPU framework state (%u)",
|
eError));
|
goto fail_frameworkcreate;
|
}
|
|
/* Copy the Framework client data into the framework buffer */
|
eError = PVRSRVRGXFrameworkCopyCommand(psTransferContext->psFWFrameworkMemDesc,
|
pabyFrameworkCommand,
|
ui32FrameworkCommandSize);
|
if (eError != PVRSRV_OK)
|
{
|
PVR_DPF((PVR_DBG_ERROR,"PVRSRVCreateTransferContextKM: Failed to populate the framework buffer (%u)",
|
eError));
|
goto fail_frameworkcopy;
|
}
|
|
sInfo.psFWFrameworkMemDesc = psTransferContext->psFWFrameworkMemDesc;
|
sInfo.psMCUFenceAddr = &sMCUFenceAddr;
|
|
eError = _CreateTDMTransferContext(psConnection,
|
psDeviceNode,
|
psFWMemContextMemDesc,
|
ui32Priority,
|
&sInfo,
|
&psTransferContext->sTDMData);
|
if (eError != PVRSRV_OK)
|
{
|
goto fail_tdmtransfercontext;
|
}
|
|
SyncAddrListInit(&psTransferContext->sSyncAddrListFence);
|
SyncAddrListInit(&psTransferContext->sSyncAddrListUpdate);
|
|
{
|
OSWRLockAcquireWrite(psDevInfo->hTDMCtxListLock);
|
dllist_add_to_tail(&(psDevInfo->sTDMCtxtListHead), &(psTransferContext->sListNode));
|
OSWRLockReleaseWrite(psDevInfo->hTDMCtxListLock);
|
*ppsTransferContext = psTransferContext;
|
}
|
|
*ppsTransferContext = psTransferContext;
|
|
return PVRSRV_OK;
|
|
fail_tdmtransfercontext:
|
fail_frameworkcopy:
|
DevmemFwFree(psDevInfo, psTransferContext->psFWFrameworkMemDesc);
|
fail_frameworkcreate:
|
SyncPrimFree(psTransferContext->psCleanupSync);
|
fail_syncalloc:
|
OSFreeMem(psTransferContext);
|
PVR_ASSERT(eError != PVRSRV_OK);
|
*ppsTransferContext = NULL;
|
return eError;
|
}
|
|
IMG_EXPORT
|
PVRSRV_ERROR PVRSRVRGXTDMDestroyTransferContextKM(RGX_SERVER_TQ_TDM_CONTEXT *psTransferContext)
|
{
|
PVRSRV_ERROR eError;
|
PVRSRV_RGXDEV_INFO *psDevInfo = psTransferContext->psDeviceNode->pvDevice;
|
|
/* remove node from list before calling destroy - as destroy, if successful
|
* will invalidate the node
|
* must be re-added if destroy fails
|
*/
|
OSWRLockAcquireWrite(psDevInfo->hTDMCtxListLock);
|
dllist_remove_node(&(psTransferContext->sListNode));
|
OSWRLockReleaseWrite(psDevInfo->hTDMCtxListLock);
|
|
|
eError = _DestroyTDMTransferContext(&psTransferContext->sTDMData,
|
psTransferContext->psDeviceNode,
|
psTransferContext->psCleanupSync);
|
if (eError != PVRSRV_OK)
|
{
|
goto fail_destroyTDM;
|
}
|
|
DevmemFwFree(psDevInfo, psTransferContext->psFWFrameworkMemDesc);
|
SyncPrimFree(psTransferContext->psCleanupSync);
|
|
SyncAddrListDeinit(&psTransferContext->sSyncAddrListFence);
|
SyncAddrListDeinit(&psTransferContext->sSyncAddrListUpdate);
|
|
OSFreeMem(psTransferContext);
|
|
return PVRSRV_OK;
|
|
fail_destroyTDM:
|
|
OSWRLockAcquireWrite(psDevInfo->hTDMCtxListLock);
|
dllist_add_to_tail(&(psDevInfo->sTDMCtxtListHead), &(psTransferContext->sListNode));
|
OSWRLockReleaseWrite(psDevInfo->hTDMCtxListLock);
|
PVR_ASSERT(eError != PVRSRV_OK);
|
return eError;
|
}
|
|
|
/*
|
* PVRSRVSubmitTQ3DKickKM
|
*/
|
IMG_EXPORT
|
PVRSRV_ERROR PVRSRVRGXTDMSubmitTransferKM(
|
RGX_SERVER_TQ_TDM_CONTEXT * psTransferContext,
|
IMG_UINT32 ui32PDumpFlags,
|
IMG_UINT32 ui32ClientCacheOpSeqNum,
|
IMG_UINT32 ui32ClientFenceCount,
|
SYNC_PRIMITIVE_BLOCK ** pauiClientFenceUFOSyncPrimBlock,
|
IMG_UINT32 * paui32ClientFenceSyncOffset,
|
IMG_UINT32 * paui32ClientFenceValue,
|
IMG_UINT32 ui32ClientUpdateCount,
|
SYNC_PRIMITIVE_BLOCK ** pauiClientUpdateUFOSyncPrimBlock,
|
IMG_UINT32 * paui32ClientUpdateSyncOffset,
|
IMG_UINT32 * paui32ClientUpdateValue,
|
IMG_UINT32 ui32ServerSyncCount,
|
IMG_UINT32 * paui32ServerSyncFlags,
|
SERVER_SYNC_PRIMITIVE ** papsServerSyncs,
|
IMG_INT32 i32CheckFenceFD,
|
IMG_INT32 i32UpdateTimelineFD,
|
IMG_INT32 * pi32UpdateFenceFD,
|
IMG_CHAR szFenceName[32],
|
IMG_UINT32 ui32FWCommandSize,
|
IMG_UINT8 * pui8FWCommand,
|
IMG_UINT32 ui32ExtJobRef,
|
IMG_UINT32 ui32SyncPMRCount,
|
IMG_UINT32 * paui32SyncPMRFlags,
|
PMR ** ppsSyncPMRs)
|
{
|
PVRSRV_DEVICE_NODE *psDeviceNode = psTransferContext->psDeviceNode;
|
RGX_CCB_CMD_HELPER_DATA *psCmdHelper;
|
PRGXFWIF_UFO_ADDR * pauiIntFenceUFOAddress = NULL;
|
PRGXFWIF_UFO_ADDR * pauiIntUpdateUFOAddress = NULL;
|
IMG_UINT32 * paui32IntFenceValue = paui32ClientFenceValue;
|
IMG_UINT32 ui32IntClientFenceCount = ui32ClientFenceCount;
|
IMG_UINT32 * paui32IntUpdateValue = paui32ClientUpdateValue;
|
IMG_UINT32 ui32IntClientUpdateCount = ui32ClientUpdateCount;
|
PVRSRV_ERROR eError;
|
PVRSRV_ERROR eError2;
|
IMG_INT32 i32UpdateFenceFD = -1;
|
IMG_UINT32 ui32JobId;
|
|
IMG_UINT32 ui32CmdOffset = 0;
|
|
PRGXFWIF_TIMESTAMP_ADDR pPreAddr;
|
PRGXFWIF_TIMESTAMP_ADDR pPostAddr;
|
PRGXFWIF_UFO_ADDR pRMWUFOAddr;
|
|
#if defined(SUPPORT_BUFFER_SYNC)
|
struct pvr_buffer_sync_append_data *psAppendData = NULL;
|
#endif
|
|
#if defined(SUPPORT_NATIVE_FENCE_SYNC)
|
struct pvr_sync_append_data *psFDFenceData = NULL;
|
|
if (i32UpdateTimelineFD >= 0 && !pi32UpdateFenceFD)
|
{
|
return PVRSRV_ERROR_INVALID_PARAMS;
|
}
|
#else
|
if (i32UpdateTimelineFD >= 0)
|
{
|
PVR_DPF((PVR_DBG_ERROR, "%s: Providing native sync timeline (%d) in non native sync enabled driver",
|
__func__, i32UpdateTimelineFD));
|
return PVRSRV_ERROR_INVALID_PARAMS;
|
}
|
if (i32CheckFenceFD >= 0)
|
{
|
PVR_DPF((PVR_DBG_ERROR, "%s: Providing native check sync (%d) in non native sync enabled driver",
|
__func__, i32CheckFenceFD));
|
return PVRSRV_ERROR_INVALID_PARAMS;
|
}
|
#endif
|
|
ui32JobId = OSAtomicIncrement(&psTransferContext->hJobId);
|
|
/* Ensure the string is null-terminated (Required for safety) */
|
szFenceName[31] = '\0';
|
|
if (ui32SyncPMRCount != 0)
|
{
|
if (!ppsSyncPMRs)
|
{
|
return PVRSRV_ERROR_INVALID_PARAMS;
|
}
|
}
|
|
/* We can't allocate the required amount of stack space on all consumer architectures */
|
psCmdHelper = OSAllocMem(sizeof(RGX_CCB_CMD_HELPER_DATA));
|
if (psCmdHelper == NULL)
|
{
|
eError = PVRSRV_ERROR_OUT_OF_MEMORY;
|
goto fail_allochelper;
|
}
|
|
|
/*
|
Init the command helper commands for all the prepares
|
*/
|
{
|
RGX_CLIENT_CCB *psClientCCB;
|
RGX_SERVER_COMMON_CONTEXT *psServerCommonCtx;
|
IMG_CHAR *pszCommandName;
|
RGXFWIF_CCB_CMD_TYPE eType;
|
|
psServerCommonCtx = psTransferContext->sTDMData.psServerCommonContext;
|
psClientCCB = FWCommonContextGetClientCCB(psServerCommonCtx);
|
pszCommandName = "TQ-TDM";
|
eType = (ui32FWCommandSize == 0) ? RGXFWIF_CCB_CMD_TYPE_NULL : RGXFWIF_CCB_CMD_TYPE_TQ_TDM;
|
|
eError = SyncAddrListPopulate(&psTransferContext->sSyncAddrListFence,
|
ui32ClientFenceCount,
|
pauiClientFenceUFOSyncPrimBlock,
|
paui32ClientFenceSyncOffset);
|
if(eError != PVRSRV_OK)
|
{
|
goto fail_populate_sync_addr_list;
|
}
|
pauiIntFenceUFOAddress = psTransferContext->sSyncAddrListFence.pasFWAddrs;
|
|
eError = SyncAddrListPopulate(&psTransferContext->sSyncAddrListUpdate,
|
ui32ClientUpdateCount,
|
pauiClientUpdateUFOSyncPrimBlock,
|
paui32ClientUpdateSyncOffset);
|
if(eError != PVRSRV_OK)
|
{
|
goto fail_populate_sync_addr_list;
|
}
|
pauiIntUpdateUFOAddress = psTransferContext->sSyncAddrListUpdate.pasFWAddrs;
|
|
|
#if defined(SUPPORT_BUFFER_SYNC)
|
if (ui32SyncPMRCount)
|
{
|
int err;
|
|
err = pvr_buffer_sync_append_start(psDeviceNode->psBufferSyncContext,
|
ui32SyncPMRCount,
|
ppsSyncPMRs,
|
paui32SyncPMRFlags,
|
ui32IntClientFenceCount,
|
pauiIntFenceUFOAddress,
|
paui32IntFenceValue,
|
ui32IntClientUpdateCount,
|
pauiIntUpdateUFOAddress,
|
paui32IntUpdateValue,
|
&psAppendData);
|
if (err)
|
{
|
PVR_DPF((PVR_DBG_ERROR, "%s: Failed to append buffer syncs (errno=%d)", __FUNCTION__, err));
|
eError = (err == -ENOMEM) ? PVRSRV_ERROR_OUT_OF_MEMORY : PVRSRV_ERROR_INVALID_PARAMS;
|
goto fail_sync_append;
|
}
|
|
pvr_buffer_sync_append_checks_get(psAppendData,
|
&ui32IntClientFenceCount,
|
&pauiIntFenceUFOAddress,
|
&paui32IntFenceValue);
|
|
pvr_buffer_sync_append_updates_get(psAppendData,
|
&ui32IntClientUpdateCount,
|
&pauiIntUpdateUFOAddress,
|
&paui32IntUpdateValue);
|
}
|
#endif /* defined(SUPPORT_BUFFER_SYNC) */
|
|
#if defined(SUPPORT_NATIVE_FENCE_SYNC)
|
if (i32CheckFenceFD >= 0 || i32UpdateTimelineFD >= 0)
|
{
|
eError =
|
pvr_sync_append_fences(szFenceName,
|
i32CheckFenceFD,
|
i32UpdateTimelineFD,
|
ui32IntClientUpdateCount,
|
pauiIntUpdateUFOAddress,
|
paui32IntUpdateValue,
|
ui32IntClientFenceCount,
|
pauiIntFenceUFOAddress,
|
paui32IntFenceValue,
|
&psFDFenceData);
|
if (eError != PVRSRV_OK)
|
{
|
goto fail_syncinit;
|
}
|
pvr_sync_get_updates(psFDFenceData, &ui32IntClientUpdateCount,
|
&pauiIntUpdateUFOAddress, &paui32IntUpdateValue);
|
pvr_sync_get_checks(psFDFenceData, &ui32IntClientFenceCount,
|
&pauiIntFenceUFOAddress, &paui32IntFenceValue);
|
}
|
#endif
|
|
RGX_GetTimestampCmdHelper((PVRSRV_RGXDEV_INFO*) psTransferContext->psDeviceNode->pvDevice,
|
& pPreAddr,
|
& pPostAddr,
|
& pRMWUFOAddr);
|
|
/*
|
Create the command helper data for this command
|
*/
|
eError = RGXCmdHelperInitCmdCCB(psClientCCB,
|
ui32IntClientFenceCount,
|
pauiIntFenceUFOAddress,
|
paui32IntFenceValue,
|
ui32IntClientUpdateCount,
|
pauiIntUpdateUFOAddress,
|
paui32IntUpdateValue,
|
ui32ServerSyncCount,
|
paui32ServerSyncFlags,
|
SYNC_FLAG_MASK_ALL,
|
papsServerSyncs,
|
ui32FWCommandSize,
|
pui8FWCommand,
|
& pPreAddr,
|
& pPostAddr,
|
& pRMWUFOAddr,
|
eType,
|
ui32ExtJobRef,
|
ui32JobId,
|
ui32PDumpFlags,
|
NULL,
|
pszCommandName,
|
psCmdHelper);
|
if (eError != PVRSRV_OK)
|
{
|
goto fail_initcmd;
|
}
|
}
|
|
/*
|
Acquire space for all the commands in one go
|
*/
|
|
eError = RGXCmdHelperAcquireCmdCCB(1, psCmdHelper);
|
if (eError != PVRSRV_OK)
|
{
|
goto fail_3dcmdacquire;
|
}
|
|
|
/*
|
We should acquire the kernel CCB(s) space here as the schedule could fail
|
and we would have to roll back all the syncs
|
*/
|
|
/*
|
Only do the command helper release (which takes the server sync
|
operations if the acquire succeeded
|
*/
|
ui32CmdOffset = RGXGetHostWriteOffsetCCB(FWCommonContextGetClientCCB(psTransferContext->sTDMData.psServerCommonContext));
|
RGXCmdHelperReleaseCmdCCB(1,
|
psCmdHelper,
|
"TQ_TDM",
|
FWCommonContextGetFWAddress(psTransferContext->sTDMData.psServerCommonContext).ui32Addr);
|
|
|
/*
|
Even if we failed to acquire the client CCB space we might still need
|
to kick the HW to process a padding packet to release space for us next
|
time round
|
*/
|
{
|
RGXFWIF_KCCB_CMD sTDMKCCBCmd;
|
|
/* Construct the kernel 3D CCB command. */
|
sTDMKCCBCmd.eCmdType = RGXFWIF_KCCB_CMD_KICK;
|
sTDMKCCBCmd.uCmdData.sCmdKickData.psContext = FWCommonContextGetFWAddress(psTransferContext->sTDMData.psServerCommonContext);
|
sTDMKCCBCmd.uCmdData.sCmdKickData.ui32CWoffUpdate = RGXGetHostWriteOffsetCCB(FWCommonContextGetClientCCB(psTransferContext->sTDMData.psServerCommonContext));
|
sTDMKCCBCmd.uCmdData.sCmdKickData.ui32NumCleanupCtl = 0;
|
|
/* HTBLOGK(HTB_SF_MAIN_KICK_TDM, */
|
/* s3DKCCBCmd.uCmdData.sCmdKickData.psContext, */
|
/* ui323DCmdOffset); */
|
RGX_HWPERF_HOST_ENQ(psTransferContext, OSGetCurrentClientProcessIDKM(),
|
FWCommonContextGetFWAddress(psTransferContext->
|
sTDMData.psServerCommonContext).ui32Addr,
|
ui32ExtJobRef, ui32JobId, RGX_HWPERF_KICK_TYPE_TQTDM);
|
|
LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
|
{
|
eError2 = RGXScheduleCommand(psDeviceNode->pvDevice,
|
RGXFWIF_DM_TDM,
|
& sTDMKCCBCmd,
|
sizeof(sTDMKCCBCmd),
|
ui32ClientCacheOpSeqNum,
|
ui32PDumpFlags);
|
if (eError2 != PVRSRV_ERROR_RETRY)
|
{
|
break;
|
}
|
OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
|
} END_LOOP_UNTIL_TIMEOUT();
|
|
#if defined(SUPPORT_GPUTRACE_EVENTS)
|
RGXHWPerfFTraceGPUEnqueueEvent(psDeviceNode->pvDevice,
|
FWCommonContextGetFWAddress(psTransferContext->
|
sTDMData.psServerCommonContext).ui32Addr,
|
ui32JobId, RGX_HWPERF_KICK_TYPE_TQTDM);
|
#endif
|
}
|
|
/*
|
* Now check eError (which may have returned an error from our earlier calls
|
* to RGXCmdHelperAcquireCmdCCB) - we needed to process any flush command first
|
* so we check it now...
|
*/
|
if (eError != PVRSRV_OK )
|
{
|
goto fail_2dcmdacquire;
|
}
|
|
#if defined(SUPPORT_NATIVE_FENCE_SYNC)
|
if (i32UpdateTimelineFD >= 0)
|
{
|
/* If we get here, this should never fail. Hitting that likely implies
|
* a code error above */
|
i32UpdateFenceFD = pvr_sync_get_update_fd(psFDFenceData);
|
if (i32UpdateFenceFD < 0)
|
{
|
PVR_DPF((PVR_DBG_ERROR, "%s: Failed to get install update sync fd",
|
__FUNCTION__));
|
/* If we fail here, we cannot rollback the syncs as the hw already
|
* has references to resources they may be protecting in the kick
|
* so fallthrough */
|
|
eError = PVRSRV_ERROR_INVALID_PARAMS;
|
goto fail_free_append_data;
|
}
|
}
|
#if defined(NO_HARDWARE)
|
pvr_sync_nohw_complete_fences(psFDFenceData);
|
#endif
|
/*
|
Free the merged sync memory if required
|
*/
|
pvr_sync_free_append_fences_data(psFDFenceData);
|
#endif
|
|
#if defined(SUPPORT_BUFFER_SYNC)
|
if (psAppendData)
|
{
|
pvr_buffer_sync_append_finish(psAppendData);
|
}
|
#endif
|
|
* pi32UpdateFenceFD = i32UpdateFenceFD;
|
|
OSFreeMem(psCmdHelper);
|
|
return PVRSRV_OK;
|
|
/*
|
No resources are created in this function so there is nothing to free
|
unless we had to merge syncs.
|
If we fail after the client CCB acquire there is still nothing to do
|
as only the client CCB release will modify the client CCB
|
*/
|
fail_2dcmdacquire:
|
fail_3dcmdacquire:
|
|
fail_initcmd:
|
|
/* fail_pdumpcheck: */
|
/* fail_cmdtype: */
|
|
#if defined(SUPPORT_NATIVE_FENCE_SYNC)
|
fail_syncinit:
|
/* Relocated cleanup here as the loop could fail after the first iteration
|
* at the above goto tags at which point the psFDCheckData memory would
|
* have been allocated.
|
*/
|
pvr_sync_rollback_append_fences(psFDFenceData);
|
fail_free_append_data:
|
pvr_sync_free_append_fences_data(psFDFenceData);
|
#endif
|
#if defined(SUPPORT_BUFFER_SYNC)
|
pvr_buffer_sync_append_abort(psAppendData);
|
fail_sync_append:
|
#endif
|
fail_populate_sync_addr_list:
|
PVR_ASSERT(eError != PVRSRV_OK);
|
OSFreeMem(psCmdHelper);
|
fail_allochelper:
|
return eError;
|
|
|
}
|
|
|
IMG_EXPORT
|
PVRSRV_ERROR PVRSRVRGXTDMNotifyWriteOffsetUpdateKM(
|
RGX_SERVER_TQ_TDM_CONTEXT *psTransferContext,
|
IMG_UINT32 ui32PDumpFlags)
|
{
|
RGXFWIF_KCCB_CMD sKCCBCmd;
|
PVRSRV_ERROR eError;
|
|
/* Schedule the firmware command */
|
sKCCBCmd.eCmdType = RGXFWIF_KCCB_CMD_NOTIFY_WRITE_OFFSET_UPDATE;
|
sKCCBCmd.uCmdData.sWriteOffsetUpdateData.psContext = FWCommonContextGetFWAddress(psTransferContext->sTDMData.psServerCommonContext);
|
|
LOOP_UNTIL_TIMEOUT(MAX_HW_TIME_US)
|
{
|
eError = RGXScheduleCommand(psTransferContext->psDeviceNode->pvDevice,
|
RGXFWIF_DM_TDM,
|
&sKCCBCmd,
|
sizeof(sKCCBCmd),
|
0,
|
ui32PDumpFlags);
|
if (eError != PVRSRV_ERROR_RETRY)
|
{
|
break;
|
}
|
OSWaitus(MAX_HW_TIME_US/WAIT_TRY_COUNT);
|
} END_LOOP_UNTIL_TIMEOUT();
|
|
if (eError != PVRSRV_OK)
|
{
|
PVR_DPF((PVR_DBG_ERROR,"PVRSRVRGXTDMNotifyWriteOffsetUpdateKM: Failed to schedule the FW command %d (%s)",
|
eError, PVRSRVGETERRORSTRING(eError)));
|
}
|
|
return eError;
|
}
|
|
|
PVRSRV_ERROR PVRSRVRGXTDMSetTransferContextPriorityKM(CONNECTION_DATA *psConnection,
|
PVRSRV_DEVICE_NODE * psDeviceNode,
|
RGX_SERVER_TQ_TDM_CONTEXT *psTransferContext,
|
IMG_UINT32 ui32Priority)
|
{
|
PVRSRV_ERROR eError;
|
|
PVR_UNREFERENCED_PARAMETER(psDeviceNode);
|
|
if (psTransferContext->sTDMData.ui32Priority != ui32Priority)
|
{
|
eError = ContextSetPriority(psTransferContext->sTDMData.psServerCommonContext,
|
psConnection,
|
psTransferContext->psDeviceNode->pvDevice,
|
ui32Priority,
|
RGXFWIF_DM_TDM);
|
if (eError != PVRSRV_OK)
|
{
|
PVR_DPF((PVR_DBG_ERROR, "%s: Failed to set the priority (%s)", __FUNCTION__, PVRSRVGetErrorStringKM(eError)));
|
return eError;
|
}
|
}
|
|
return PVRSRV_OK;
|
}
|
|
void CheckForStalledTDMTransferCtxt(PVRSRV_RGXDEV_INFO *psDevInfo,
|
DUMPDEBUG_PRINTF_FUNC *pfnDumpDebugPrintf,
|
void *pvDumpDebugFile)
|
{
|
DLLIST_NODE *psNode, *psNext;
|
|
OSWRLockAcquireRead(psDevInfo->hTDMCtxListLock);
|
|
dllist_foreach_node(&psDevInfo->sTDMCtxtListHead, psNode, psNext)
|
{
|
RGX_SERVER_TQ_TDM_CONTEXT *psCurrentServerTransferCtx =
|
IMG_CONTAINER_OF(psNode, RGX_SERVER_TQ_TDM_CONTEXT, sListNode);
|
|
DumpStalledFWCommonContext(psCurrentServerTransferCtx->sTDMData.psServerCommonContext,
|
pfnDumpDebugPrintf, pvDumpDebugFile);
|
}
|
|
OSWRLockReleaseRead(psDevInfo->hTDMCtxListLock);
|
}
|
|
|
IMG_UINT32 CheckForStalledClientTDMTransferCtxt(PVRSRV_RGXDEV_INFO *psDevInfo)
|
{
|
DLLIST_NODE *psNode, *psNext;
|
IMG_UINT32 ui32ContextBitMask = 0;
|
|
OSWRLockAcquireRead(psDevInfo->hTDMCtxListLock);
|
|
dllist_foreach_node(&psDevInfo->sTDMCtxtListHead, psNode, psNext)
|
{
|
RGX_SERVER_TQ_TDM_CONTEXT *psCurrentServerTransferCtx =
|
IMG_CONTAINER_OF(psNode, RGX_SERVER_TQ_TDM_CONTEXT, sListNode);
|
|
if (CheckStalledClientCommonContext(
|
psCurrentServerTransferCtx->sTDMData.psServerCommonContext, RGX_KICK_TYPE_DM_TDM_2D)
|
== PVRSRV_ERROR_CCCB_STALLED) {
|
ui32ContextBitMask = RGX_KICK_TYPE_DM_TDM_2D;
|
}
|
}
|
|
OSWRLockReleaseRead(psDevInfo->hTDMCtxListLock);
|
return ui32ContextBitMask;
|
}
|
|
|
|
/**************************************************************************//**
|
End of file (rgxtdmtransfer.c)
|
******************************************************************************/
|
