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; }