int32_t cmdqRecProfileMarker(cmdqRecHandle handle, const char *tag)
{
#ifdef CMDQ_PROFILE_MARKER_SUPPORT
int32_t status;
int32_t index;
cmdqBackupSlotHandle hSlot;
dma_addr_t allocatedStartPA;
do {
allocatedStartPA = 0;
status = 0;
/* allocate temp slot for GCE to store timestamp info */
/* those timestamp info will copy to record strute after task execute done */
if ((0 == handle->profileMarker.count) && (0 == handle->profileMarker.hSlot)) {
status = cmdqCoreAllocWriteAddress(CMDQ_MAX_PROFILE_MARKER_IN_TASK, &allocatedStartPA);
if(0 > status) {
CMDQ_ERR("[REC][PROF_MARKER]allocate failed, status:%d\n", status);
break;
}
handle->profileMarker.hSlot = 0LL | (allocatedStartPA);
CMDQ_VERBOSE("[REC][PROF_MARKER]update handle(%p) slot start PA:%pa(0x%llx)\n",
handle, &allocatedStartPA, handle->profileMarker.hSlot);
}
/* insert instruciton */
index = handle->profileMarker.count;
hSlot = (cmdqBackupSlotHandle)(handle->profileMarker.hSlot);
if (index >= CMDQ_MAX_PROFILE_MARKER_IN_TASK) {
CMDQ_ERR("[REC][PROF_MARKER]insert profile maker failed since already reach max count\n");
status = -EFAULT;
break;
}
CMDQ_VERBOSE("[REC][PROF_MARKER]inserting profile instr, handle:%p, slot:%pa(0x%llx), index:%d, tag:%s\n",
handle, &hSlot, handle->profileMarker.hSlot, index, tag);
cmdqRecBackupRegisterToSlot(handle, hSlot, index, CMDQ_APXGPT2_COUNT);
handle->profileMarker.tag[index] = tag;
handle->profileMarker.count += 1;
} while(0);
return status;
#else
CMDQ_ERR("func:%s failed since CMDQ dosen't enable profile marker\n", __func__);
return -EFAULT;
#endif
}
/**
* Allocate 32-bit register backup slot
*
*/
int32_t cmdqBackupAllocateSlot(cmdqBackupSlotHandle *phBackupSlot, uint32_t slotCount)
{
#ifdef CMDQ_GPR_SUPPORT
dma_addr_t paStart = 0;
int status = 0;
if (NULL == phBackupSlot) {
return -EINVAL;
}
status = cmdqCoreAllocWriteAddress(slotCount, &paStart);
*phBackupSlot = paStart;
return status;
#else
CMDQ_ERR("func:%s failed since CMDQ dosen't support GPR\n", __func__);
return -EFAULT;
#endif /* CMDQ_GPR_SUPPORT */
}
static long cmdq_ioctl(struct file *pFile, unsigned int code, unsigned long param)
{
struct cmdqCommandStruct command;
struct cmdqJobStruct job;
int count[CMDQ_MAX_ENGINE_COUNT];
struct TaskStruct *pTask;
int32_t status;
struct cmdqJobResultStruct jobResult;
uint32_t *userRegValue = NULL;
uint32_t userRegCount = 0;
/* backup value after task release */
uint32_t regCount = 0, regCountUserSpace = 0, regUserToken = 0;
switch (code) {
case CMDQ_IOCTL_EXEC_COMMAND:
if (copy_from_user(&command, (void *)param, sizeof(cmdqCommandStruct)))
return -EFAULT;
/* insert private_data for resource reclaim */
command.privateData = (cmdqU32Ptr_t) (unsigned long)(pFile->private_data);
if (cmdq_driver_process_command_request(&command))
return -EFAULT;
break;
case CMDQ_IOCTL_QUERY_USAGE:
if (cmdqCoreQueryUsage(count))
return -EFAULT;
if (copy_to_user((void *)param, count, sizeof(int32_t) * CMDQ_MAX_ENGINE_COUNT)) {
CMDQ_ERR("CMDQ_IOCTL_QUERY_USAGE copy_to_user failed\n");
return -EFAULT;
}
break;
case CMDQ_IOCTL_ASYNC_JOB_EXEC:
if (copy_from_user(&job, (void *)param, sizeof(cmdqJobStruct)))
return -EFAULT;
/* not support secure path for async ioctl yet */
if (true == job.command.secData.isSecure) {
CMDQ_ERR("not support secure path for CMDQ_IOCTL_ASYNC_JOB_EXEC\n");
return -EFAULT;
}
/* backup */
userRegCount = job.command.regRequest.count;
/* insert private_data for resource reclaim */
job.command.privateData = (cmdqU32Ptr_t) (unsigned long)(pFile->private_data);
/* create kernel-space address buffer */
status = cmdq_driver_create_reg_address_buffer(&job.command);
if (0 != status)
return status;
/* scenario id fixup */
cmdq_core_fix_command_scenario_for_user_space(&job.command);
status = cmdqCoreSubmitTaskAsync(&job.command, NULL, 0, &pTask);
/* store user space request count in TaskStruct */
/* for later retrieval */
if (pTask) {
pTask->regCountUserSpace = userRegCount;
pTask->regUserToken = job.command.debugRegDump;
}
/* we don't need regAddress anymore, free it now */
kfree(CMDQ_U32_PTR(job.command.regRequest.regAddresses));
job.command.regRequest.regAddresses = (cmdqU32Ptr_t) (unsigned long)(NULL);
if (status >= 0) {
job.hJob = (unsigned long)pTask;
if (copy_to_user((void *)param, (void *)&job, sizeof(cmdqJobStruct))) {
CMDQ_ERR("CMDQ_IOCTL_ASYNC_JOB_EXEC copy_to_user failed\n");
return -EFAULT;
}
} else {
job.hJob = (unsigned long)NULL;
return -EFAULT;
}
break;
case CMDQ_IOCTL_ASYNC_JOB_WAIT_AND_CLOSE:
if (copy_from_user(&jobResult, (void *)param, sizeof(jobResult))) {
CMDQ_ERR("copy_from_user jobResult fail\n");
return -EFAULT;
}
/* verify job handle */
if (!cmdqIsValidTaskPtr((TaskStruct *) (unsigned long)jobResult.hJob)) {
CMDQ_ERR("invalid task ptr = 0x%llx\n", jobResult.hJob);
return -EFAULT;
}
pTask = (TaskStruct *) (unsigned long)jobResult.hJob;
/* utility service, fill the engine flag. */
/* this is required by MDP. */
jobResult.engineFlag = pTask->engineFlag;
/* check if reg buffer suffices */
if (jobResult.regValue.count < pTask->regCountUserSpace) {
jobResult.regValue.count = pTask->regCountUserSpace;
if (copy_to_user((void *)param, (void *)&jobResult, sizeof(jobResult))) {
CMDQ_ERR("copy_to_user fail, line=%d\n", __LINE__);
return -EINVAL;
}
CMDQ_ERR("insufficient register buffer\n");
return -ENOMEM;
}
/* inform client the actual read register count */
jobResult.regValue.count = pTask->regCountUserSpace;
/* update user space before we replace the regValues pointer. */
if (copy_to_user((void *)param, (void *)&jobResult, sizeof(jobResult))) {
CMDQ_ERR("copy_to_user fail line=%d\n", __LINE__);
return -EINVAL;
}
/* allocate kernel space result buffer */
/* which contains kernel + user space requests */
userRegValue = CMDQ_U32_PTR(jobResult.regValue.regValues);
jobResult.regValue.regValues = (cmdqU32Ptr_t) (unsigned long)
(kzalloc(pTask->regCount * sizeof(uint32_t), GFP_KERNEL));
jobResult.regValue.count = pTask->regCount;
if (NULL == CMDQ_U32_PTR(jobResult.regValue.regValues)) {
CMDQ_ERR("no reg value buffer\n");
return -ENOMEM;
}
/* backup value after task release */
regCount = pTask->regCount;
regCountUserSpace = pTask->regCountUserSpace;
regUserToken = pTask->regUserToken;
/* make sure the task is running and wait for it */
status = cmdqCoreWaitResultAndReleaseTask(pTask,
&jobResult.regValue,
msecs_to_jiffies
(CMDQ_DEFAULT_TIMEOUT_MS));
if (status < 0) {
CMDQ_ERR("waitResultAndReleaseTask fail=%d\n", status);
/* free kernel space result buffer */
kfree(CMDQ_U32_PTR(jobResult.regValue.regValues));
return status;
}
/* pTask is released, do not access it any more */
pTask = NULL;
/* notify kernel space dump callback */
if (regCount > regCountUserSpace) {
CMDQ_VERBOSE("kernel space reg dump = %d, %d, %d\n", regCount,
regCountUserSpace, regUserToken);
status = cmdqCoreDebugRegDumpEnd(regUserToken,
regCount - regCountUserSpace,
CMDQ_U32_PTR(jobResult.regValue.regValues +
regCountUserSpace));
if (0 != status) {
/* Error status print */
CMDQ_ERR("cmdqCoreDebugRegDumpEnd returns %d\n", status);
}
}
/* copy result to user space */
if (copy_to_user
((void *)userRegValue, (void *)(unsigned long)jobResult.regValue.regValues,
regCountUserSpace * sizeof(uint32_t))) {
CMDQ_ERR("Copy REGVALUE to user space failed\n");
return -EFAULT;
}
if (jobResult.readAddress.count > 0)
cmdq_driver_process_read_address_request(&jobResult.readAddress);
/* free kernel space result buffer */
kfree(CMDQ_U32_PTR(jobResult.regValue.regValues));
break;
case CMDQ_IOCTL_ALLOC_WRITE_ADDRESS:
do {
cmdqWriteAddressStruct addrReq;
dma_addr_t paStart = 0;
CMDQ_LOG("CMDQ_IOCTL_ALLOC_WRITE_ADDRESS\n");
if (copy_from_user(&addrReq, (void *)param, sizeof(addrReq))) {
CMDQ_ERR("CMDQ_IOCTL_ALLOC_WRITE_ADDRESS copy_from_user failed\n");
return -EFAULT;
}
status = cmdqCoreAllocWriteAddress(addrReq.count, &paStart);
if (0 != status) {
CMDQ_ERR
("CMDQ_IOCTL_ALLOC_WRITE_ADDRESS cmdqCoreAllocWriteAddress() failed\n");
return status;
}
addrReq.startPA = (uint32_t) paStart;
CMDQ_LOG("CMDQ_IOCTL_ALLOC_WRITE_ADDRESS get 0x%08x\n", addrReq.startPA);
if (copy_to_user((void *)param, &addrReq, sizeof(addrReq))) {
CMDQ_ERR("CMDQ_IOCTL_ALLOC_WRITE_ADDRESS copy_to_user failed\n");
return -EFAULT;
}
status = 0;
} while (0);
break;
case CMDQ_IOCTL_FREE_WRITE_ADDRESS:
do {
cmdqWriteAddressStruct freeReq;
CMDQ_LOG("CMDQ_IOCTL_FREE_WRITE_ADDRESS\n");
if (copy_from_user(&freeReq, (void *)param, sizeof(freeReq))) {
CMDQ_ERR("CMDQ_IOCTL_FREE_WRITE_ADDRESS copy_from_user failed\n");
return -EFAULT;
}
status = cmdqCoreFreeWriteAddress(freeReq.startPA);
if (0 != status)
return status;
status = 0;
} while (0);
break;
case CMDQ_IOCTL_READ_ADDRESS_VALUE:
do {
cmdqReadAddressStruct readReq;
CMDQ_LOG("CMDQ_IOCTL_READ_ADDRESS_VALUE\n");
if (copy_from_user(&readReq, (void *)param, sizeof(readReq))) {
CMDQ_ERR("CMDQ_IOCTL_READ_ADDRESS_VALUE copy_from_user failed\n");
return -EFAULT;
}
/* this will copy result to readReq->values buffer */
cmdq_driver_process_read_address_request(&readReq);
status = 0;
} while (0);
break;
case CMDQ_IOCTL_QUERY_CAP_BITS:
do {
int capBits = 0;
if (cmdq_driver_support_wait_and_receive_event_in_same_tick())
capBits |= (1L << CMDQ_CAP_WFE);
else
capBits &= ~(1L << CMDQ_CAP_WFE);
if (copy_to_user((void *)param, &capBits, sizeof(int))) {
CMDQ_ERR("Copy capacity bits to user space failed\n");
return -EFAULT;
}
} while (0);
break;
case CMDQ_IOCTL_QUERY_DTS:
do {
cmdqDTSDataStruct *pDtsData;
pDtsData = cmdq_core_get_whole_DTS_Data();
if (copy_to_user((void *)param, pDtsData, sizeof(cmdqDTSDataStruct))) {
CMDQ_ERR("Copy device tree information to user space failed\n");
return -EFAULT;
}
} while (0);
break;
case CMDQ_IOCTL_NOTIFY_ENGINE:
do {
uint64_t engineFlag;
if (copy_from_user(&engineFlag, (void *)param, sizeof(uint64_t))) {
CMDQ_ERR("CMDQ_IOCTL_NOTIFY_ENGINE copy_from_user failed\n");
return -EFAULT;
}
cmdqCoreLockResource(engineFlag, true);
} while (0);
break;
default:
CMDQ_ERR("unrecognized ioctl 0x%08x\n", code);
return -ENOIOCTLCMD;
}
return 0;
}
static long cmdq_ioctl(struct file *pFile, unsigned int code, unsigned long param)
{
int mutex;
struct cmdqCommandStruct command;
struct cmdqJobStruct job;
struct cmdqFileNodeStruct *pNode;
unsigned long flags;
int count[CMDQ_MAX_ENGINE_COUNT];
struct TaskStruct *pTask;
int32_t status;
struct cmdqJobResultStruct jobResult;
uint32_t *userRegValue = NULL;
uint32_t userRegCount = 0;
/* backup value after task release */
uint32_t regCount = 0, regCountUserSpace = 0, regUserToken = 0;
switch (code) {
case CMDQ_IOCTL_LOCK_MUTEX:
mutex = cmdqMutexAcquire();
if (-1 == mutex)
return -IOCTL_RET_LOCK_MUTEX_FAIL;
if (copy_to_user((void *)param, &mutex, sizeof(int))) {
CMDQ_ERR("Copy mutex number to user failed\n");
cmdqMutexRelease(mutex);
return -IOCTL_RET_COPY_MUTEX_NUM_TO_USER_FAIL;
}
/* register mutex into file node data */
pNode = (struct cmdqFileNodeStruct *)pFile->private_data;
if (pNode) {
spin_lock_irqsave(&pNode->nodeLock, flags);
pNode->mutexFlag |= (1 << mutex);
spin_unlock_irqrestore(&pNode->nodeLock, flags);
}
break;
case CMDQ_IOCTL_UNLOCK_MUTEX:
if (copy_from_user(&mutex, (void *)param, sizeof(int))) {
CMDQ_ERR("Copy mutex number from user failed\n");
return -IOCLT_RET_COPY_MUTEX_NUM_FROM_USER_FAIL;
}
status = cmdqMutexRelease(mutex);
if (status < 0)
return -IOCTL_RET_RELEASE_MUTEX_FAIL;
if (-1 != mutex) {
pNode = (struct cmdqFileNodeStruct *)pFile->private_data;
spin_lock_irqsave(&pNode->nodeLock, flags);
pNode->mutexFlag &= ~(1 << mutex);
spin_unlock_irqrestore(&pNode->nodeLock, flags);
}
break;
case CMDQ_IOCTL_EXEC_COMMAND:
if (copy_from_user(&command, (void *)param, sizeof(struct cmdqCommandStruct)))
return -IOCTL_RET_COPY_EXEC_CMD_FROM_USER_FAIL;
if (cmdqCoreIsEarlySuspended() && (CMDQ_SCENARIO_USER_MDP == command.scenario))
return -IOCTL_RET_IS_SUSPEND_WHEN_EXEC_CMD;
/* insert private_data for resource reclaim */
command.privateData = (cmdqU32Ptr_t) pFile->private_data;
if (cmdq_driver_process_command_request(&command))
return -IOCTL_RET_PROCESS_CMD_REQUEST_FAIL;
break;
case CMDQ_IOCTL_QUERY_USAGE:
if (cmdqCoreQueryUsage(count))
return -IOCLT_RET_QUERY_USAGE_FAIL;
if (copy_to_user((void *)param, count, sizeof(int32_t) * CMDQ_MAX_ENGINE_COUNT)) {
CMDQ_ERR("CMDQ_IOCTL_QUERY_USAGE copy_to_user failed\n");
return -IOCTL_RET_COPY_USAGE_TO_USER_FAIL;
}
break;
case CMDQ_IOCTL_ASYNC_JOB_EXEC:
if (copy_from_user(&job, (void *)param, sizeof(struct cmdqJobStruct)))
return -IOCTL_RET_COPY_ASYNC_JOB_EXEC_FROM_USER_FAIL;
if (cmdqCoreIsEarlySuspended() && (CMDQ_SCENARIO_USER_MDP == job.command.scenario)) {
CMDQ_ERR("CMDQ_IOCTL_ASYNC_JOB_EXEC suspended, return\n");
return -IOCTL_RET_IS_SUSPEND_WHEN_ASYNC_JOB_EXEC;
}
/* not support secure path for async ioctl yet */
if (true == job.command.secData.isSecure) {
CMDQ_ERR("not support secure path for CMDQ_IOCTL_ASYNC_JOB_EXEC\n");
return -IOCTL_RET_NOT_SUPPORT_SEC_PATH_FOR_ASYNC_JOB_EXEC;
}
/* backup */
userRegCount = job.command.regRequest.count;
/* insert private_data for resource reclaim */
job.command.privateData = (cmdqU32Ptr_t) (unsigned long)(pFile->private_data);
/* create kernel-space address buffer */
status = cmdq_driver_create_reg_address_buffer(&job.command);
if (0 != status)
return -IOCTL_RET_CREATE_REG_ADDR_BUF_FAIL;
/* scenario id fixup */
if ((CMDQ_SCENARIO_USER_DISP_COLOR == job.command.scenario)
|| (CMDQ_SCENARIO_USER_MDP == job.command.scenario)) {
CMDQ_VERBOSE("user space request, scenario:%d\n", job.command.scenario);
} else {
CMDQ_LOG("[WARNING]fix user space request to CMDQ_SCENARIO_USER_SPACE\n");
job.command.scenario = CMDQ_SCENARIO_USER_SPACE;
}
status = cmdqCoreSubmitTaskAsync(&job.command, NULL, 0, &pTask);
/* store user space request count in struct TaskStruct */
/* for later retrieval */
if (pTask) {
pTask->regCountUserSpace = userRegCount;
pTask->regUserToken = job.command.debugRegDump;
}
/* we don't need regAddress anymore, free it now */
kfree(CMDQ_U32_PTR(job.command.regRequest.regAddresses));
job.command.regRequest.regAddresses = (cmdqU32Ptr_t) (unsigned long)(NULL);
if (status >= 0) {
job.hJob = (unsigned long)pTask;
if (copy_to_user((void *)param, (void *)&job, sizeof(struct cmdqJobStruct))) {
CMDQ_ERR("CMDQ_IOCTL_ASYNC_JOB_EXEC copy_to_user failed\n");
return -IOCLT_RET_COPY_ASYNC_JOB_EXEC_TO_USER_FAIL;
}
} else {
job.hJob = (unsigned long)NULL;
return -IOCTL_RET_SUBMIT_TASK_ASYNC_FAILED;
}
break;
case CMDQ_IOCTL_ASYNC_JOB_WAIT_AND_CLOSE:
if (copy_from_user(&jobResult, (void *)param, sizeof(jobResult))) {
CMDQ_ERR("copy_from_user jobResult fail\n");
return -IOCTL_RET_COPY_ASYNC_JOB_WAIT_AND_CLOSE_FROM_USER_FAIL;
}
if (cmdqCoreIsEarlySuspended() && (CMDQ_SCENARIO_USER_MDP == job.command.scenario)) {
CMDQ_ERR("CMDQ_IOCTL_ASYNC_JOB_WAIT_AND_CLOSE suspended, return\n");
return -IOCTL_RET_IS_SUSPEND_WHEN_ASYNC_JOB_WAIT_AND_CLOSE;
}
/* verify job handle */
if (!cmdqIsValidTaskPtr((struct TaskStruct *)(unsigned long)jobResult.hJob)) {
CMDQ_ERR("invalid task ptr = 0x%llx\n", jobResult.hJob);
return -IOCTL_RET_INVALID_TASK_PTR;
}
pTask = (struct TaskStruct *)(unsigned long)jobResult.hJob;
/* utility service, fill the engine flag. */
/* this is required by MDP. */
jobResult.engineFlag = pTask->engineFlag;
/* check if reg buffer suffices */
if (jobResult.regValue.count < pTask->regCountUserSpace) {
jobResult.regValue.count = pTask->regCountUserSpace;
if (copy_to_user((void *)param, (void *)&jobResult, sizeof(jobResult))) {
CMDQ_ERR("copy_to_user fail, line=%d\n", __LINE__);
return -IOCTL_RET_COPY_JOB_RESULT_TO_USER1_FAIL;
}
CMDQ_ERR("insufficient register buffer\n");
return -IOCTL_RET_NOT_ENOUGH_REGISTER_BUFFER;
}
/* inform client the actual read register count */
jobResult.regValue.count = pTask->regCountUserSpace;
/* update user space before we replace the regValues pointer. */
if (copy_to_user((void *)param, (void *)&jobResult, sizeof(jobResult))) {
CMDQ_ERR("copy_to_user fail line=%d\n", __LINE__);
return -IOCTL_RET_COPY_JOB_RESULT_TO_USER2_FAIL;
}
/* allocate kernel space result buffer */
/* which contains kernel + user space requests */
userRegValue = CMDQ_U32_PTR(jobResult.regValue.regValues);
jobResult.regValue.regValues =
(cmdqU32Ptr_t) (unsigned
long)(kzalloc(pTask->regCount * sizeof(uint32_t), GFP_KERNEL));
jobResult.regValue.count = pTask->regCount;
if (NULL == CMDQ_U32_PTR(jobResult.regValue.regValues)) {
CMDQ_ERR("no reg value buffer\n");
return -IOCTL_RET_NO_REG_VAL_BUFFER;
}
/* backup value after task release */
regCount = pTask->regCount;
regCountUserSpace = pTask->regCountUserSpace;
regUserToken = pTask->regUserToken;
/* make sure the task is running and wait for it */
status = cmdqCoreWaitResultAndReleaseTask(pTask,
&jobResult.regValue,
msecs_to_jiffies
(CMDQ_DEFAULT_TIMEOUT_MS));
if (status < 0) {
CMDQ_ERR("waitResultAndReleaseTask fail=%d\n", status);
/* free kernel space result buffer */
kfree(CMDQ_U32_PTR(jobResult.regValue.regValues));
return -IOCTL_RET_WAIT_RESULT_AND_RELEASE_TASK_FAIL;
}
/* pTask is released, do not access it any more */
pTask = NULL;
/* notify kernel space dump callback */
if (regCount > regCountUserSpace) {
CMDQ_VERBOSE("kernel space reg dump = %d, %d, %d\n", regCount,
regCountUserSpace, regUserToken);
status = cmdqCoreDebugRegDumpEnd(regUserToken,
regCount - regCountUserSpace,
CMDQ_U32_PTR(jobResult.regValue.regValues +
regCountUserSpace));
if (0 != status)
CMDQ_ERR("cmdqCoreDebugRegDumpEnd returns %d\n", status);
}
/* copy result to user space */
if (copy_to_user
((void *)userRegValue, (void *)(unsigned long)jobResult.regValue.regValues,
regCountUserSpace * sizeof(uint32_t))) {
CMDQ_ERR("Copy REGVALUE to user space failed\n");
return -IOCLT_RET_COPY_REG_VALUE_TO_USER_FAIL;
}
if (jobResult.readAddress.count > 0)
cmdq_driver_process_read_address_request(&jobResult.readAddress);
/* free kernel space result buffer */
kfree(CMDQ_U32_PTR(jobResult.regValue.regValues));
break;
case CMDQ_IOCTL_ALLOC_WRITE_ADDRESS:
do {
struct cmdqWriteAddressStruct addrReq;
dma_addr_t paStart = 0;
CMDQ_LOG("CMDQ_IOCTL_ALLOC_WRITE_ADDRESS\n");
if (copy_from_user(&addrReq, (void *)param, sizeof(addrReq))) {
CMDQ_ERR("CMDQ_IOCTL_ALLOC_WRITE_ADDRESS copy_from_user failed\n");
return -IOCTL_RET_COPY_ALLOC_WRITE_ADDR_FROM_USER_FAIL;
}
status = cmdqCoreAllocWriteAddress(addrReq.count, &paStart);
if (0 != status) {
CMDQ_ERR
("CMDQ_IOCTL_ALLOC_WRITE_ADDRESS cmdqCoreAllocWriteAddress() failed\n");
return -IOCTL_RET_ALLOC_WRITE_ADDR_FAIL;
}
addrReq.startPA = (uint32_t) paStart;
CMDQ_LOG("CMDQ_IOCTL_ALLOC_WRITE_ADDRESS get 0x%08x\n", addrReq.startPA);
if (copy_to_user((void *)param, &addrReq, sizeof(addrReq))) {
CMDQ_ERR("CMDQ_IOCTL_ALLOC_WRITE_ADDRESS copy_to_user failed\n");
return -IOCTL_RET_COPY_ALLOC_WRITE_ADDR_TO_USER_FAIL;
}
status = 0;
} while (0);
break;
case CMDQ_IOCTL_FREE_WRITE_ADDRESS:
do {
struct cmdqWriteAddressStruct freeReq;
CMDQ_LOG("CMDQ_IOCTL_FREE_WRITE_ADDRESS\n");
if (copy_from_user(&freeReq, (void *)param, sizeof(freeReq))) {
CMDQ_ERR("CMDQ_IOCTL_FREE_WRITE_ADDRESS copy_from_user failed\n");
return -IOCTL_RET_COPY_FREE_WRITE_ADDR_FROM_USER_FAIL;
}
status = cmdqCoreFreeWriteAddress(freeReq.startPA);
if (0 != status)
return -IOCTL_RET_FREE_WRITE_ADDR_FAIL;
status = 0;
} while (0);
break;
case CMDQ_IOCTL_READ_ADDRESS_VALUE:
do {
struct cmdqReadAddressStruct readReq;
CMDQ_LOG("CMDQ_IOCTL_READ_ADDRESS_VALUE\n");
if (copy_from_user(&readReq, (void *)param, sizeof(readReq))) {
CMDQ_ERR("CMDQ_IOCTL_READ_ADDRESS_VALUE copy_from_user failed\n");
return -IOCTL_RET_COPY_READ_ADDR_VAL_FROM_USER_FAIL;
}
/* this will copy result to readReq->values buffer */
cmdq_driver_process_read_address_request(&readReq);
status = 0;
} while (0);
break;
case CMDQ_IOCTL_QUERY_CAP_BITS:
do {
int capBits = 0;
if (cmdq_core_support_wait_and_receive_event_in_same_tick())
capBits |= (1L << CMDQ_CAP_WFE);
else
capBits &= ~(1L << CMDQ_CAP_WFE);
if (copy_to_user((void *)param, &capBits, sizeof(int))) {
CMDQ_ERR("Copy capacity bits to user space failed\n");
return -IOCTL_RET_COPY_CAP_BITS_TO_USER_FAIL;
}
} while (0);
break;
case CMDQ_IOCTL_SYNC_BUF_HDCP_VERSION:
#ifdef CMDQ_SECURE_PATH_SUPPORT
do {
struct cmdqSyncHandleHdcpStruct syncHandle;
if (copy_from_user(&syncHandle, (void *)param, sizeof(syncHandle))) {
CMDQ_ERR
("CMDQ_IOCTL_SYNC_BUF_HDCP_VERSION copy_from_user failed\n");
return -IOCTL_RET_COPY_HDCP_VERSION_FROM_USER_FAIL;
}
status = cmdq_sec_sync_handle_hdcp_unlock(syncHandle);
if (0 != status)
CMDQ_ERR("cmdq_sec_sync_handle_hdcp_unlock returns %d\n", status);
} while (0);
#else
CMDQ_ERR("SVP not supported\n");
return -IOCTL_RET_SVP_NOT_SUPPORT;
#endif
break;
default:
CMDQ_ERR("unrecognized ioctl 0x%08x\n", code);
CMDQ_ERR("CMDQ_IOCTL_LOCK_MUTEX:0x%08lx sizeof(int) = %ld\n",
CMDQ_IOCTL_LOCK_MUTEX, sizeof(int));
CMDQ_ERR("CMDQ_IOCTL_UNLOCK_MUTEX:0x%08lx sizeof(int) = %ld\n",
CMDQ_IOCTL_UNLOCK_MUTEX, sizeof(int));
CMDQ_ERR("CMDQ_IOCTL_EXEC_COMMAND:0x%08lx sizeof(struct cmdqCommandStruct) = %ld\n",
CMDQ_IOCTL_EXEC_COMMAND, sizeof(struct cmdqCommandStruct));
CMDQ_ERR("CMDQ_IOCTL_QUERY_USAGE:0x%08lx sizeof(struct cmdqUsageInfoStruct) = %ld\n",
CMDQ_IOCTL_QUERY_USAGE, sizeof(struct cmdqUsageInfoStruct));
CMDQ_ERR("CMDQ_IOCTL_ASYNC_JOB_EXEC:0x%08lx sizeof(struct cmdqJobStruct) = %ld\n",
CMDQ_IOCTL_ASYNC_JOB_EXEC, sizeof(struct cmdqJobStruct));
CMDQ_ERR("CMDQ_IOCTL_ASYNC_JOB_WAIT_AND_CLOSE:0x%08lx sizeof(struct cmdqJobResultStruct) = %ld\n",
CMDQ_IOCTL_ASYNC_JOB_WAIT_AND_CLOSE, sizeof(struct cmdqJobResultStruct));
CMDQ_ERR("CMDQ_IOCTL_ALLOC_WRITE_ADDRESS:0x%08lx sizeof(struct cmdqWriteAddressStruct) = %ld\n",
CMDQ_IOCTL_ALLOC_WRITE_ADDRESS, sizeof(struct cmdqWriteAddressStruct));
CMDQ_ERR("CMDQ_IOCTL_FREE_WRITE_ADDRESS:0x%08lx sizeof(struct cmdqWriteAddressStruct) = %ld\n",
CMDQ_IOCTL_FREE_WRITE_ADDRESS, sizeof(struct cmdqWriteAddressStruct));
CMDQ_ERR("CMDQ_IOCTL_READ_ADDRESS_VALUE:0x%08lx sizeof(struct cmdqReadAddressStruct) = %ld\n",
CMDQ_IOCTL_READ_ADDRESS_VALUE, sizeof(struct cmdqReadAddressStruct));
CMDQ_ERR("CMDQ_IOCTL_QUERY_CAP_BITS:0x%08lx sizeof(int) = %ld\n",
CMDQ_IOCTL_QUERY_CAP_BITS, sizeof(int));
CMDQ_ERR("CMDQ_IOCTL_SYNC_BUF_HDCP_VERSION:0x%08lx sizeof(struct cmdqSyncHandleHdcpStruct) = %ld\n",
CMDQ_IOCTL_SYNC_BUF_HDCP_VERSION, sizeof(struct cmdqSyncHandleHdcpStruct));
return -IOCTL_RET_UNRECOGNIZED_IOCTL;
}
return IOCTL_RET_SUCCESS;
}