static int cmdq_sec_sectrace_unmap(void *va, size_t size)
{
int status;
enum mc_result mcRet;
status = 0;
cmdq_sec_lock_secure_path();
do {
if(NULL == gCmdqSecContextHandle) {
status = -EFAULT;
break;
}
/* ask secure CMDQ to unmap sectrace log buffer */
status = cmdq_sec_submit_to_secure_world_async_unlocked(
CMD_CMDQ_TL_SECTRACE_UNMAP,
NULL, CMDQ_INVALID_THREAD,
cmdq_sec_fill_iwc_command_sectrace_unlocked,
NULL);
if(0 > status) {
CMDQ_ERR("[sectrace]unmap: failed in SWd: %d\n", status);
mc_unmap(&(gCmdqSecContextHandle->sessionHandle), va, &gCmdqSectraceMappedInfo);
status = -EFAULT;
break;
}
mcRet = mc_unmap(&(gCmdqSecContextHandle->sessionHandle), va, &gCmdqSectraceMappedInfo);
} while(0);
cmdq_sec_unlock_secure_path();
CMDQ_LOG("[sectrace]unmap: status: %d\n", status);
return status;
}
static int cmdq_sec_sectrace_map(void *va, size_t size)
{
int status;
enum mc_result mcRet;
CMDQ_LOG("[sectrace]-->map: start, va:%p, size:%d\n", va, (int)size);
status = 0;
cmdq_sec_lock_secure_path();
do {
/* HACK: submit a dummy message to ensure secure path init done */
status = cmdq_sec_submit_to_secure_world_async_unlocked(
CMD_CMDQ_TL_TEST_HELLO_TL, NULL, CMDQ_INVALID_THREAD, NULL, NULL);
/* map log buffer in NWd */
mcRet = mc_map(&(gCmdqSecContextHandle->sessionHandle),
va,
(uint32_t)size,
&gCmdqSectraceMappedInfo);
if (MC_DRV_OK != mcRet) {
CMDQ_ERR("[sectrace]map: failed in NWd, mc_map err: 0x%x\n", mcRet);
status = -EFAULT;
break;
}
CMDQ_LOG("[sectrace]map: mc_map sectrace buffer done, gCmdqSectraceMappedInfo(va:0x%08x, size:%d)\n",
gCmdqSectraceMappedInfo.secure_virt_addr, gCmdqSectraceMappedInfo.secure_virt_len);
/* ask secure CMDQ to map sectrace log buffer */
status = cmdq_sec_submit_to_secure_world_async_unlocked(
CMD_CMDQ_TL_SECTRACE_MAP,
NULL, CMDQ_INVALID_THREAD,
cmdq_sec_fill_iwc_command_sectrace_unlocked,
NULL);
if(0 > status) {
CMDQ_ERR("[sectrace]map: failed in SWd: %d\n", status);
mc_unmap(&(gCmdqSecContextHandle->sessionHandle), va, &gCmdqSectraceMappedInfo);
status = -EFAULT;
break;
}
} while(0);
cmdq_sec_unlock_secure_path();
CMDQ_LOG("[sectrace]<--map: status: %d\n", status);
return status;
}
/* DO NOT invoke this function unless you get HACC lock */
int tee_secure_request(unsigned int user, unsigned char *data, unsigned int data_size,
unsigned int direction, unsigned char *seed, unsigned int seed_size)
{
int ret = SEC_OK;
struct mc_bulk_map dataMapInfo;
struct mc_bulk_map seedMapInfo;
char *databuf = NULL;
char *seedbuf = NULL;
enum mc_result mcRet = 0;
/* allocate data buffer to be sent to TEE */
databuf = vmalloc(data_size);
if (databuf == NULL) {
pr_debug("NWD HACC: vmalloc fail for data buffer");
ret = ERR_HACC_ALLOCATE_BUFFER_FAIL;
goto _allocate_data_buf_err;
}
memcpy(databuf, data, data_size);
if (seed_size != 0) {
/* allocate seed buffer to be sent to TEE */
seedbuf = vmalloc(seed_size);
if (seedbuf == NULL) {
pr_debug("NWD HACC: vmalloc fail for seed buffer");
ret = ERR_HACC_ALLOCATE_BUFFER_FAIL;
goto _allocate_seed_buf_err;
}
memcpy(seedbuf, seed, seed_size);
}
/* map TCI virtual address for data buffer */
ret = mc_map(&drSessionHandle, databuf, data_size, &dataMapInfo);
if (MC_DRV_OK != ret) {
pr_debug("NWD HACC: mcMap failed of data buffer: %d", ret);
ret = ERR_HACC_MCMAP_BUFFER_FAIL;
goto _mcmap_data_fail;
}
pTci->data_addr = (uint32_t) dataMapInfo.secure_virt_addr;
pTci->data_len = data_size;
if (seed_size != 0) {
/* map TCI virtual address for seed buffer */
ret = mc_map(&drSessionHandle, seedbuf, seed_size, &seedMapInfo);
if (MC_DRV_OK != ret) {
pr_debug("NWD HACC: mcMap failed of seed buffer: %d", ret);
ret = ERR_HACC_MCMAP_BUFFER_FAIL;
goto _mcmap_seed_fail;
}
pTci->seed_addr = (uint32_t) seedMapInfo.secure_virt_addr;
pTci->seed_len = seed_size;
} else {
pTci->seed_addr = 0;
pTci->seed_len = 0;
}
/* set other TCI parameter */
pTci->hacc_user = user;
pTci->direction = direction;
/* set TCI command */
pTci->cmd.header.commandId = CMD_HACC_REQUEST;
/* notify the trustlet */
pr_debug("NWD HACC: prepare notify\n");
mcRet = mc_notify(&drSessionHandle);
if (MC_DRV_OK != mcRet) {
pr_debug("NWD HACC IRQ fail: mc_notify returned: %d\n", mcRet);
ret = ERR_HACC_NOTIFY_TO_TRUSTLET_FAIL;
goto _notify_to_trustlet_fail;
}
/* wait for response from the trustlet */
mcRet = mc_wait_notification(&drSessionHandle, /*MC_INFINITE_TIMEOUT */ 20000);
if (MC_DRV_OK != mcRet) {
pr_debug("NWD HACC IRQ fail: mc_wait_notification 20s timeout: %d\n", mcRet);
ret = ERR_HACC_NOTIFY_FROM_TRUSTLET_FAIL;
goto _notify_from_trustlet_fail;
}
if (pTci->result != 0) {
pr_debug("NWD HACC Request Fail!!!!!!!!(ret:%d, err:%d)\n", pTci->result,
pTci->rsp.header.returnCode);
} else {
pr_debug("NWD HACC Request Success!!!!!!!!\n");
/* update result from secure buffer */
memcpy(data, databuf, data_size);
}
_notify_from_trustlet_fail:
_notify_to_trustlet_fail:
if (seed_size != 0)
mc_unmap(&drSessionHandle, seedbuf, &seedMapInfo);
_mcmap_seed_fail:
mc_unmap(&drSessionHandle, databuf, &dataMapInfo);
_mcmap_data_fail:
if (seed_size != 0)
vfree(seedbuf);
_allocate_seed_buf_err:
vfree(databuf);
_allocate_data_buf_err:
return ret;
}
