aubrey/kernel_samsung_a34x-permissive
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity
kernel_samsung_a34x-permissive/drivers/misc/mediatek/cmdq/v2/cmdq_sec.c

1452 lines
37 KiB
C
Raw Normal View History

Import A346BXXU1AWB9 kernel source Android 13
2024-04-28 06:49:01 -07:00
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2020 MediaTek Inc.
*/
#include <linux/slab.h>
#include <linux/delay.h>
#include "cmdq_sec.h"
#include "cmdq_def.h"
#include "cmdq_virtual.h"
#include "cmdq_device.h"
#ifdef CMDQ_MET_READY
#include <linux/met_drv.h>
#endif
/* lock to protect atomic secure task execution */
static DEFINE_MUTEX(gCmdqSecExecLock);
/* ensure atomic enable/disable secure path profile */
static DEFINE_MUTEX(gCmdqSecProfileLock);
/* secure context list. note each porcess has its own sec context */
static struct list_head gCmdqSecContextList;
#if defined(CMDQ_SECURE_PATH_SUPPORT)
/* mobicore driver interface */
#include "mobicore_driver_api.h"
/* sectrace interface */
#ifdef CMDQ_SECTRACE_SUPPORT
#include <linux/sectrace.h>
#endif
/* secure path header */
#include "cmdqsectl_api.h"
#define CMDQ_DR_UUID { { 2, 0xb, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
#define CMDQ_TL_UUID { { 9, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
/* secure context to cmdqSecTL */
static struct cmdqSecContextStruct *gCmdqSecContextHandle;
/* sectrace */
/* sectrace log buffer, which mapped between NWd and SWd */
struct mc_bulk_map gCmdqSectraceMappedInfo;
/* internal control */
/* Set 1 to open once for each process context, because of below reasons:
* 1. mc_open_session is too slow (major)
* 2. we entry secure world for config and trigger GCE, and wait in normal world
*/
#define CMDQ_OPEN_SESSION_ONCE (1)
/************************************************
* operator API
*************************************************/
int32_t cmdq_sec_open_mobicore_impl(uint32_t deviceId)
{
int32_t status;
enum mc_result mcRet = MC_DRV_ERR_UNKNOWN;
int retry_cnt = 0, max_retry = 30;
do {
status = 0;
mcRet = mc_open_device(deviceId);
/* Currently, a process context limits to */
/* open mobicore device once, */
/* and mc_open_device dose not support reference cout */
/* so skip the false alarm error.... */
if (mcRet == MC_DRV_ERR_INVALID_OPERATION) {
CMDQ_MSG("[SEC]already opened,continue to execution\n");
status = -EEXIST;
} else if (mcRet != MC_DRV_OK) {
CMDQ_ERR("[SEC]_MOBICORE_OPEN: err[0x%x], retry[%d]\n",
mcRet, retry_cnt);
status = -1;
msleep_interruptible(2000);
retry_cnt++;
continue;
}
break;
} while (retry_cnt < max_retry);
if (retry_cnt >= max_retry) {
/* print error message */
CMDQ_ERR("[SEC]fail: status[%d], mcRet[0x%x], retry[%d]\n",
status, mcRet, retry_cnt);
} else {
CMDQ_MSG("[SEC] status[%d], mcRet[0x%x], retry[%d]\n",
status, mcRet, retry_cnt);
}
return status;
}
int32_t cmdq_sec_close_mobicore_impl(const uint32_t deviceId,
const uint32_t openMobicoreByOther)
{
int32_t status = 0;
enum mc_result mcRet = 0;
if (openMobicoreByOther == 1) {
/* do nothing */
/* let last user to close mobicore.... */
CMDQ_MSG("[SEC]: opened by other, bypass device close\n");
} else {
mcRet = mc_close_device(deviceId);
CMDQ_MSG("[SEC]status[%d], ret[%0x],openMobicoreByOther[%d]\n",
status, mcRet, openMobicoreByOther);
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("[SEC]_MOBICORE_CLOSE: err[0x%x]\n", mcRet);
status = -1;
}
}
return status;
}
int32_t cmdq_sec_allocate_wsm_impl(uint32_t deviceId,
uint8_t **ppWsm, uint32_t wsmSize)
{
int32_t status = 0;
enum mc_result mcRet = MC_DRV_OK;
do {
if ((*ppWsm) != NULL) {
status = -1;
CMDQ_ERR("[SEC]_WSM_ALLOC: err[pWsm is not NULL]");
break;
}
/* because world shared mem(WSM) will ba managed */
/* by mobicore device, not linux kernel */
/* instead of vmalloc/kmalloc, call mc_malloc_wasm */
/* to alloc WSM to prvent error such as */
/* "can not resolve tci physicall address" etc */
mcRet = mc_malloc_wsm(deviceId, 0, wsmSize, ppWsm, 0);
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("[SEC]_WSM_ALLOC: err[0x%x]\n", mcRet);
status = -1;
break;
}
CMDQ_MSG("[SEC]_WSM_ALLOC: status[%d], *ppWsm: 0x%p\n",
status, (*ppWsm));
} while (0);
return status;
}
int32_t cmdq_sec_free_wsm_impl(uint32_t deviceId, uint8_t **ppWsm)
{
int32_t status = 0;
enum mc_result mcRet = mc_free_wsm(deviceId, (*ppWsm));
(*ppWsm) = (mcRet == MC_DRV_OK) ? (NULL) : (*ppWsm);
CMDQ_VERBOSE("_WSM_FREE: ret[0x%x], *ppWsm[0x%p]\n", mcRet, (*ppWsm));
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("_WSM_FREE: err[0x%x]", mcRet);
status = -1;
}
return status;
}
int32_t cmdq_sec_open_session_impl(uint32_t deviceId,
const struct mc_uuid_t *uuid,
uint8_t *pWsm,
uint32_t wsmSize,
struct mc_session_handle *pSessionHandle)
{
int32_t status = 0;
int retry_cnt = 0, max_retry = 30;
enum mc_result mcRet = MC_DRV_OK;
if (pWsm == NULL || pSessionHandle == NULL) {
status = -1;
CMDQ_ERR
("[SEC]: invalid param, pWsm[0x%p], handle[0x%p]\n",
pWsm, pSessionHandle);
return status;
}
memset(pSessionHandle, 0, sizeof(*pSessionHandle));
pSessionHandle->device_id = deviceId;
do {
mcRet = mc_open_session(pSessionHandle, uuid, pWsm, wsmSize);
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("[SEC]_SESSION_OPEN: err[0x%x], retry[%d]\n",
mcRet, retry_cnt);
retry_cnt++;
msleep_interruptible(2000);
status = -1;
continue;
}
/* Open Session success */
status = 0;
break;
} while (retry_cnt < max_retry);
if (retry_cnt >= max_retry) {
/* print error message */
CMDQ_ERR("[SEC]: status[%d], mcRet[0x%x], retry[%d]\n",
status, mcRet, retry_cnt);
} else {
CMDQ_MSG("[SEC]: status[%d], mcRet[0x%x], retry[%d]\n",
status, mcRet, retry_cnt);
}
return status;
}
int32_t cmdq_sec_close_session_impl(
struct mc_session_handle *pSessionHandle)
{
int32_t status = 0;
enum mc_result mcRet = mc_close_session(pSessionHandle);
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("_SESSION_CLOSE: err[0x%x]", mcRet);
status = -1;
}
return status;
}
int32_t cmdq_sec_init_session_unlocked(const struct mc_uuid_t *uuid,
uint8_t **ppWsm,
uint32_t wsmSize,
struct mc_session_handle *pSessionHandle,
enum CMDQ_IWC_STATE_ENUM *pIwcState,
uint32_t *openMobicoreByOther)
{
int32_t openRet = 0;
int32_t status = 0;
uint32_t deviceId = MC_DEVICE_ID_DEFAULT;
CMDQ_MSG("[SEC]-->SESSION_INIT: iwcState[%d]\n", (*pIwcState));
do {
#if CMDQ_OPEN_SESSION_ONCE
if (IWC_SES_OPENED <= (*pIwcState)) {
CMDQ_MSG("SESSION_INIT: already opened\n");
break;
}
CMDQ_MSG("[SEC]SESSION_INIT: open new session[%d]\n",
(*pIwcState));
#endif
CMDQ_VERBOSE
("[SEC]SESSION_INIT: wsmSize[%d], pSessionHandle: 0x%p\n",
wsmSize, pSessionHandle);
CMDQ_PROF_START(current->pid, "CMDQ_SEC_INIT");
if (IWC_MOBICORE_OPENED > (*pIwcState)) {
/* open mobicore device */
openRet = cmdq_sec_open_mobicore_impl(deviceId);
if (-EEXIST == openRet) {
/* mobicore has been opened */
/* in this process context */
/* it is a ok case, so continue to execute */
status = 0;
(*openMobicoreByOther) = 1;
} else if (openRet < 0) {
status = -1;
break;
}
(*pIwcState) = IWC_MOBICORE_OPENED;
}
if (IWC_WSM_ALLOCATED > (*pIwcState)) {
/* allocate world shared memory */
if (cmdq_sec_allocate_wsm_impl(deviceId,
ppWsm, wsmSize) < 0) {
status = -1;
break;
}
(*pIwcState) = IWC_WSM_ALLOCATED;
}
/* open a secure session */
if (cmdq_sec_open_session_impl(deviceId, uuid,
(*ppWsm), wsmSize, pSessionHandle)
< 0) {
status = -1;
break;
}
(*pIwcState) = IWC_SES_OPENED;
CMDQ_PROF_END(current->pid, "CMDQ_SEC_INIT");
} while (0);
CMDQ_MSG("[SEC]<--SESSION_INIT[%d]\n", status);
return status;
}
int32_t cmdq_sec_fill_iwc_command_basic_unlocked(
int32_t iwcCommand, void *_pTask, int32_t thread,
void *_pIwc)
{
struct iwcCmdqMessage_t *pIwc;
pIwc = (struct iwcCmdqMessage_t *) _pIwc;
/* specify command id only, don't care other other */
memset(pIwc, 0x0, sizeof(struct iwcCmdqMessage_t));
pIwc->cmd = iwcCommand;
/* medatada: debug config */
pIwc->debug.logLevel = (cmdq_core_should_print_msg()) ? (1) : (0);
pIwc->debug.enableProfile = cmdq_core_profile_enabled();
return 0;
}
int32_t cmdq_sec_fill_iwc_command_msg_unlocked(
int32_t iwcCommand, void *_pTask, int32_t thread,
void *_pIwc)
{
int32_t status;
const struct TaskStruct *pTask = (struct TaskStruct *) _pTask;
struct iwcCmdqMessage_t *pIwc;
/* cmdqSecDr will insert some instr */
const uint32_t reservedCommandSize = 4 * CMDQ_INST_SIZE;
struct CmdBufferStruct *cmd_buffer = NULL;
/* check task first */
if (!pTask) {
CMDQ_ERR("[SEC]: Unable to fill message by empty task.\n");
return -EFAULT;
}
status = 0;
pIwc = (struct iwcCmdqMessage_t *) _pIwc;
/* check command size first */
if ((pTask->commandSize + reservedCommandSize) >
CMDQ_TZ_CMD_BLOCK_SIZE) {
CMDQ_ERR("[SEC]SESSION_MSG: pTask %p commandSize %d > %d\n",
pTask, pTask->commandSize, CMDQ_TZ_CMD_BLOCK_SIZE);
return -EFAULT;
}
CMDQ_MSG("[SEC]-->SESSION_MSG: cmdId[%d]\n", iwcCommand);
/* fill message buffer for inter world communication */
memset(pIwc, 0x0, sizeof(struct iwcCmdqMessage_t));
pIwc->cmd = iwcCommand;
/* metadata */
pIwc->command.metadata.enginesNeedDAPC =
pTask->secData.enginesNeedDAPC;
pIwc->command.metadata.enginesNeedPortSecurity =
pTask->secData.enginesNeedPortSecurity;
if (thread != CMDQ_INVALID_THREAD) {
uint8_t *current_va = (uint8_t *)pIwc->command.pVABase;
/* basic data */
pIwc->command.scenario = pTask->scenario;
pIwc->command.thread = thread;
pIwc->command.priority = pTask->priority;
pIwc->command.engineFlag = pTask->engineFlag;
pIwc->command.hNormalTask = 0LL | ((unsigned long)pTask);
list_for_each_entry(cmd_buffer, &pTask->cmd_buffer_list,
listEntry) {
bool is_last = list_is_last(&cmd_buffer->listEntry,
&pTask->cmd_buffer_list);
uint32_t copy_size = is_last ?
CMDQ_CMD_BUFFER_SIZE -
pTask->buf_available_size :
CMDQ_CMD_BUFFER_SIZE - CMDQ_INST_SIZE;
uint32_t *end_va = (u32 *)(current_va + copy_size);
memcpy(current_va, (cmd_buffer->pVABase), (copy_size));
/* we must reset the jump inst */
/* since now buffer is continues */
if (is_last && ((end_va[-1] >> 24) & 0xff) ==
CMDQ_CODE_JUMP &&
(end_va[-1] & 0x1) == 1) {
end_va[-1] = CMDQ_CODE_JUMP << 24;
end_va[-2] = 0x8;
}
current_va += copy_size;
}
pIwc->command.commandSize = (uint32_t)
(current_va - (uint8_t *)pIwc->command.pVABase);
/* cookie */
pIwc->command.waitCookie = pTask->secData.waitCookie;
pIwc->command.resetExecCnt = pTask->secData.resetExecCnt;
CMDQ_MSG("[SEC]SESSION_MSG: task: 0x%p, thread: %d, size: %d\n",
pTask, thread, pTask->commandSize);
CMDQ_MSG("scenario: %d, flag: 0x%016llx\n",
pTask->scenario, pTask->engineFlag);
CMDQ_VERBOSE("[SEC]SESSION_MSG: addrList[%d][0x%p]\n",
pTask->secData.addrMetadataCount,
CMDQ_U32_PTR(pTask->secData.addrMetadatas));
if (pTask->secData.addrMetadataCount > 0) {
pIwc->command.metadata.addrListLength =
pTask->secData.addrMetadataCount;
memcpy((pIwc->command.metadata.addrList),
CMDQ_U32_PTR(pTask->secData.addrMetadatas),
(pTask->secData.addrMetadataCount) *
sizeof(struct iwcCmdqAddrMetadata_t));
}
/* medatada: debug config */
pIwc->debug.logLevel = (cmdq_core_should_print_msg()) ?
(1) : (0);
pIwc->debug.enableProfile = cmdq_core_profile_enabled();
} else {
/* relase resource, or debug function will go here */
CMDQ_VERBOSE("[SEC]-->SESSION_MSG: no task, cmdId[%d]\n",
iwcCommand);
pIwc->command.commandSize = 0;
pIwc->command.metadata.addrListLength = 0;
}
CMDQ_MSG("[SEC]<--SESSION_MSG[%d]\n", status);
return status;
}
/* TODO: when do release secure command buffer */
int32_t cmdq_sec_fill_iwc_resource_msg_unlocked(int32_t iwcCommand,
void *_pTask, int32_t thread,
void *_pIwc)
{
struct iwcCmdqMessage_t *pIwc;
struct cmdqSecSharedMemoryStruct *pSharedMem;
pSharedMem = cmdq_core_get_secure_shared_memory();
if (pSharedMem == NULL) {
CMDQ_ERR("FILL:RES, NULL shared memory\n");
return -EFAULT;
}
if (pSharedMem && pSharedMem->pVABase == NULL) {
CMDQ_ERR("FILL:RES, %p shared memory has not init\n",
pSharedMem);
return -EFAULT;
}
pIwc = (struct iwcCmdqMessage_t *) _pIwc;
memset(pIwc, 0x0, sizeof(struct iwcCmdqMessage_t));
pIwc->cmd = iwcCommand;
pIwc->pathResource.shareMemoyPA = 0LL | (pSharedMem->MVABase);
pIwc->pathResource.size = pSharedMem->size;
#if defined(CMDQ_SECURE_PATH_NORMAL_IRQ) || defined(CMDQ_SECURE_PATH_HW_LOCK)
pIwc->pathResource.useNormalIRQ = 1;
#else
pIwc->pathResource.useNormalIRQ = 0;
#endif
CMDQ_MSG("FILL:RES, shared memory:%pa(0x%llx), size:%d\n",
&(pSharedMem->MVABase),
pIwc->pathResource.shareMemoyPA,
pSharedMem->size);
/* medatada: debug config */
pIwc->debug.logLevel = (cmdq_core_should_print_msg()) ? (1) : (0);
pIwc->debug.enableProfile = cmdq_core_profile_enabled();
return 0;
}
int32_t cmdq_sec_fill_iwc_cancel_msg_unlocked(int32_t iwcCommand,
void *_pTask, int32_t thread,
void *_pIwc)
{
const struct TaskStruct *pTask = (struct TaskStruct *) _pTask;
struct iwcCmdqMessage_t *pIwc;
pIwc = (struct iwcCmdqMessage_t *) _pIwc;
memset(pIwc, 0x0, sizeof(struct iwcCmdqMessage_t));
pIwc->cmd = iwcCommand;
pIwc->cancelTask.waitCookie = pTask->secData.waitCookie;
pIwc->cancelTask.thread = thread;
/* medatada: debug config */
pIwc->debug.logLevel = (cmdq_core_should_print_msg()) ? (1) : (0);
pIwc->debug.enableProfile = cmdq_core_profile_enabled();
CMDQ_LOG("FILL:CANCEL_TASK: task: %p, thread:%d, cookie:%d\n",
pTask, thread, pTask->secData.waitCookie);
return 0;
}
int32_t cmdq_sec_execute_session_unlocked(
struct mc_session_handle *pSessionHandle,
enum CMDQ_IWC_STATE_ENUM *pIwcState, int32_t timeout_ms)
{
enum mc_result mcRet;
int32_t status = 0;
const int32_t secureWoldTimeout_ms = (timeout_ms > 0) ?
(timeout_ms) : (MC_INFINITE_TIMEOUT);
CMDQ_PROF_START(current->pid, "CMDQ_SEC_EXE");
do {
/* notify to secure world */
mcRet = mc_notify(pSessionHandle);
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("[SEC]EXEC: mc_notify err[0x%x]\n", mcRet);
status = -1;
break;
}
CMDQ_MSG("[SEC]EXEC: mc_notify ret[0x%x]\n", mcRet);
(*pIwcState) = IWC_SES_TRANSACTED;
/* wait respond */
mcRet = mc_wait_notification(pSessionHandle,
secureWoldTimeout_ms);
if (mcRet == MC_DRV_ERR_TIMEOUT) {
CMDQ_ERR
("[SEC]EXEC:timeout,err[0x%x], Timeout_ms[%d]\n",
mcRet, secureWoldTimeout_ms);
status = -ETIMEDOUT;
break;
}
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("[SEC]EXEC: mc_wait_notification err[0x%x]\n",
mcRet);
status = -1;
break;
}
CMDQ_MSG("[SEC]EXEC: mc_wait_notification err[%d]\n", mcRet);
(*pIwcState) = IWC_SES_ON_TRANSACTED;
} while (0);
CMDQ_PROF_END(current->pid, "CMDQ_SEC_EXE");
return status;
}
void cmdq_sec_deinit_session_unlocked(uint8_t **ppWsm,
struct mc_session_handle *pSessionHandle,
const enum CMDQ_IWC_STATE_ENUM iwcState,
const uint32_t openMobicoreByOther)
{
uint32_t deviceId = MC_DEVICE_ID_DEFAULT;
CMDQ_MSG("[SEC]-->SESSION_DEINIT\n");
do {
switch (iwcState) {
case IWC_SES_ON_TRANSACTED:
case IWC_SES_TRANSACTED:
case IWC_SES_MSG_PACKAGED:
/* continue next clean-up */
case IWC_SES_OPENED:
cmdq_sec_close_session_impl(pSessionHandle);
/* continue next clean-up */
case IWC_WSM_ALLOCATED:
cmdq_sec_free_wsm_impl(deviceId, ppWsm);
/* continue next clean-up */
case IWC_MOBICORE_OPENED:
cmdq_sec_close_mobicore_impl(deviceId,
openMobicoreByOther);
/* continue next clean-up */
break;
case IWC_INIT:
/* CMDQ_ERR("open secure driver failed\n"); */
break;
default:
break;
}
} while (0);
CMDQ_MSG("[SEC]<--SESSION_DEINIT\n");
}
/*******************************************************
* context handle
************************************************/
int32_t cmdq_sec_setup_context_session(
struct cmdqSecContextStruct *handle)
{
int32_t status = 0;
const struct mc_uuid_t uuid = CMDQ_TL_UUID;
/* init iwc parameter */
if (handle->state == IWC_INIT)
handle->uuid = uuid;
/* init secure session */
status = cmdq_sec_init_session_unlocked(&(handle->uuid),
(uint8_t **) (&(handle->iwcMessage)),
sizeof(struct iwcCmdqMessage_t),
&(handle->sessionHandle),
&(handle->state), &(handle->openMobicoreByOther));
CMDQ_MSG("SEC_SETUP: status[%d], tgid[%d], mobicoreOpenByOther[%d]\n",
status, handle->tgid, handle->openMobicoreByOther);
return status;
}
void cmdq_sec_handle_attach_status(struct TaskStruct *pTask,
uint32_t iwcCommand,
const struct iwcCmdqMessage_t *pIwc,
int32_t sec_status_code,
char **dispatch_mod_ptr)
{
int index = 0;
const struct iwcCmdqSecStatus_t *secStatus = NULL;
if (!pIwc || !dispatch_mod_ptr)
return;
/* assign status ptr to print without task */
secStatus = &pIwc->secStatus;
if (pTask) {
if (pTask->secStatus) {
if (iwcCommand == CMD_CMDQ_TL_CANCEL_TASK) {
const struct iwcCmdqSecStatus_t *
last_sec_status = pTask->secStatus;
/* cancel task uses same errored */
/* task thus secStatus may exist */
CMDQ_ERR(
"Last secure status: %d step: 0x%08x\n",
last_sec_status->status,
last_sec_status->step);
CMDQ_ERR(
"args: 0x%08x 0x%08x 0x%08x 0x%08x\n",
last_sec_status->args[0],
last_sec_status->args[1],
last_sec_status->args[2],
last_sec_status->args[3]);
CMDQ_ERR(
"dispatch: %s task: 0x%p\n",
last_sec_status->dispatch,
pTask);
} else {
/* task should not send to */
/* secure twice, aee it */
CMDQ_AEE("CMDQ",
"Last exists, task: 0x%p command:%u\n",
pTask,
iwcCommand);
}
kfree(pTask->secStatus);
pTask->secStatus = NULL;
}
pTask->secStatus = kzalloc(sizeof(struct iwcCmdqSecStatus_t),
GFP_KERNEL);
if (pTask->secStatus) {
memcpy(pTask->secStatus, &pIwc->secStatus,
sizeof(struct iwcCmdqSecStatus_t));
secStatus = pTask->secStatus;
}
}
if (secStatus->status != 0 || sec_status_code != 0) {
/* secure status may contains debug information */
CMDQ_ERR(
"Secure status: %d (%d) step: 0x%08x\n",
secStatus->status,
sec_status_code,
secStatus->step);
CMDQ_ERR(
"args: 0x%08x 0x%08x 0x%08x 0x%08x\n",
secStatus->args[0], secStatus->args[1],
secStatus->args[2], secStatus->args[3]);
CMDQ_ERR(
"dispatch: %s task: 0x%p\n",
secStatus->dispatch, pTask);
for (index = 0; index < secStatus->inst_index; index += 2) {
CMDQ_ERR("Secure instruction %d: 0x%08x:%08x\n",
(index / 2),
secStatus->sec_inst[index],
secStatus->sec_inst[index+1]);
}
switch (secStatus->status) {
case -CMDQ_ERR_ADDR_CONVERT_HANDLE_2_PA:
*dispatch_mod_ptr = "TEE";
break;
case -CMDQ_ERR_ADDR_CONVERT_ALLOC_MVA:
case -CMDQ_ERR_ADDR_CONVERT_ALLOC_MVA_N2S:
switch (pIwc->command.thread) {
case CMDQ_THREAD_SEC_PRIMARY_DISP:
case CMDQ_THREAD_SEC_SUB_DISP:
*dispatch_mod_ptr = "DISP";
break;
case CMDQ_THREAD_SEC_MDP:
*dispatch_mod_ptr = "MDP";
break;
}
break;
}
}
}
int32_t cmdq_sec_handle_session_reply_unlocked(
const struct iwcCmdqMessage_t *pIwc,
const int32_t iwcCommand, struct TaskStruct *pTask,
void *data)
{
int32_t status;
int32_t iwcRsp;
struct cmdqSecCancelTaskResultStruct *pCancelResult = NULL;
/* get secure task execution result */
iwcRsp = (pIwc)->rsp;
status = iwcRsp;
if (iwcCommand == CMD_CMDQ_TL_CANCEL_TASK) {
pCancelResult = (struct cmdqSecCancelTaskResultStruct *) data;
if (pCancelResult) {
pCancelResult->throwAEE = pIwc->cancelTask.throwAEE;
pCancelResult->hasReset = pIwc->cancelTask.hasReset;
pCancelResult->irqFlag = pIwc->cancelTask.irqFlag;
pCancelResult->errInstr[0] =
pIwc->cancelTask.errInstr[0]; /* arg_b */
pCancelResult->errInstr[1] =
pIwc->cancelTask.errInstr[1]; /* arg_a */
pCancelResult->regValue = pIwc->cancelTask.regValue;
pCancelResult->pc = pIwc->cancelTask.pc;
}
/* for WFE, we specifically dump the event value */
if (((pIwc->cancelTask.errInstr[1] &
0xFF000000) >> 24) == CMDQ_CODE_WFE) {
const uint32_t eventID =
0x3FF & pIwc->cancelTask.errInstr[1];
CMDQ_ERR
("==== [CMDQ] Error WFE Instruction Status ===\n");
CMDQ_ERR("CMDQ_SYNC_TOKEN_VAL of %s is %d\n",
cmdq_core_get_event_name(eventID),
pIwc->cancelTask.regValue);
}
CMDQ_ERR
("CANCEL_TASK: pTask %p, INST:(0x%08x, 0x%08x)\n",
pTask, pIwc->cancelTask.errInstr[1],
pIwc->cancelTask.errInstr[0]);
CMDQ_ERR
("throwAEE:%d, hasReset:%d, pc:0x%08x\n",
pIwc->cancelTask.throwAEE,
pIwc->cancelTask.hasReset, pIwc->cancelTask.pc);
} else if (iwcCommand == CMD_CMDQ_TL_PATH_RES_ALLOCATE
|| iwcCommand == CMD_CMDQ_TL_PATH_RES_RELEASE) {
/* do nothing */
} else {
/* note we etnry SWd to config GCE, */
/* and wait execution result in NWd */
/* update taskState only if config failed */
if (pTask && iwcRsp < 0)
pTask->taskState = TASK_STATE_ERROR;
}
/* log print */
if (status > 0) {
CMDQ_ERR("SEC_SEND: status[%d], cmdId[%d], iwcRsp[%d]\n",
status, iwcCommand, iwcRsp);
} else {
CMDQ_MSG("SEC_SEND: status[%d], cmdId[%d], iwcRsp[%d]\n",
status, iwcCommand, iwcRsp);
}
return status;
}
CmdqSecFillIwcCB cmdq_sec_get_iwc_msg_fill_cb_by_iwc_command(
uint32_t iwcCommand)
{
CmdqSecFillIwcCB cb = NULL;
switch (iwcCommand) {
case CMD_CMDQ_TL_CANCEL_TASK:
cb = cmdq_sec_fill_iwc_cancel_msg_unlocked;
break;
case CMD_CMDQ_TL_PATH_RES_ALLOCATE:
case CMD_CMDQ_TL_PATH_RES_RELEASE:
cb = cmdq_sec_fill_iwc_resource_msg_unlocked;
break;
case CMD_CMDQ_TL_SUBMIT_TASK:
cb = cmdq_sec_fill_iwc_command_msg_unlocked;
break;
case CMD_CMDQ_TL_TEST_HELLO_TL:
case CMD_CMDQ_TL_TEST_DUMMY:
default:
cb = cmdq_sec_fill_iwc_command_basic_unlocked;
break;
};
return cb;
}
int32_t cmdq_sec_send_context_session_message(
struct cmdqSecContextStruct *handle,
uint32_t iwcCommand,
struct TaskStruct *pTask,
int32_t thread, CmdqSecFillIwcCB cb, void *data)
{
int32_t status;
const int32_t timeout_ms = (3 * 1000);
const CmdqSecFillIwcCB iwcFillCB = (cb == NULL) ?
cmdq_sec_get_iwc_msg_fill_cb_by_iwc_command(iwcCommand) : (cb);
do {
/* fill message bufer */
status = iwcFillCB(iwcCommand, pTask, thread,
(void *)(handle->iwcMessage));
if (status < 0) {
CMDQ_ERR("fill msg fail[%d],pid[%d:%d],cmdId[%d]\n",
status, current->tgid,
current->pid, iwcCommand);
break;
}
/* send message */
status = cmdq_sec_execute_session_unlocked(
&(handle->sessionHandle),
&(handle->state), timeout_ms);
if (status < 0) {
CMDQ_ERR("[SEC]session_unlock fail[%d], pid[%d:%d]\n",
status, current->tgid, current->pid);
break;
}
status = cmdq_sec_handle_session_reply_unlocked(
handle->iwcMessage,
iwcCommand, pTask,
data);
} while (0);
return status;
}
int32_t cmdq_sec_teardown_context_session(
struct cmdqSecContextStruct *handle)
{
int32_t status = 0;
if (handle) {
CMDQ_MSG("[SEC]SEC_TEARDOWN: state: %d, iwcMessage:0x%p\n",
handle->state, handle->iwcMessage);
cmdq_sec_deinit_session_unlocked(
(uint8_t **) (&(handle->iwcMessage)),
&(handle->sessionHandle),
handle->state, handle->openMobicoreByOther);
/* clrean up handle's attritubes */
handle->state = IWC_INIT;
} else {
CMDQ_ERR("[SEC]SEC_TEARDOWN: null secCtxHandle\n");
status = -1;
}
return status;
}
void cmdq_sec_track_task_record(const uint32_t iwcCommand,
struct TaskStruct *pTask, CMDQ_TIME *pEntrySec, CMDQ_TIME *pExitSec)
{
if (pTask == NULL)
return;
if (iwcCommand != CMD_CMDQ_TL_SUBMIT_TASK)
return;
/* record profile data */
/* tbase timer/time support is not enough currently, */
/* so we treats entry/exit timing to */
/* secure world as the trigger timing */
pTask->entrySec = *pEntrySec;
pTask->exitSec = *pExitSec;
pTask->trigger = *pEntrySec;
}
int32_t cmdq_sec_submit_to_secure_world_async_unlocked(
uint32_t iwcCommand,
struct TaskStruct *pTask, int32_t thread,
CmdqSecFillIwcCB iwcFillCB, void *data,
bool throwAEE)
{
const int32_t tgid = current->tgid;
const int32_t pid = current->pid;
struct cmdqSecContextStruct *handle = NULL;
int32_t status = 0;
int32_t duration = 0;
char longMsg[CMDQ_LONGSTRING_MAX];
uint32_t msgOffset;
int32_t msgMAXSize;
char *dispatch_mod = "CMDQ";
CMDQ_TIME tEntrySec;
CMDQ_TIME tExitSec;
CMDQ_MSG("[SEC]-->SEC_SUBMIT: tgid[%d:%d]\n", tgid, pid);
do {
/* find handle first */
/* Unlike tBase user space API,
* tBase kernel API maintains a GLOBAL table
* to control mobicore device reference count.
* For kernel spece user, mc_open_device and
* session_handle don't depend on the process context.
* Therefore we use global secssion
* handle to inter-world commumication.
*/
if (gCmdqSecContextHandle == NULL)
gCmdqSecContextHandle =
cmdq_sec_context_handle_create(current->tgid);
handle = gCmdqSecContextHandle;
if (handle == NULL) {
CMDQ_ERR("SEC_SUBMIT: tgid %d err[NULL secCtxHandle]\n",
tgid);
status = -(CMDQ_ERR_NULL_SEC_CTX_HANDLE);
break;
}
if (cmdq_sec_setup_context_session(handle) < 0) {
status = -(CMDQ_ERR_SEC_CTX_SETUP);
break;
}
tEntrySec = sched_clock();
status = cmdq_sec_send_context_session_message(handle,
iwcCommand, pTask, thread,
iwcFillCB, data);
tExitSec = sched_clock();
CMDQ_GET_TIME_IN_US_PART(tEntrySec, tExitSec, duration);
cmdq_sec_track_task_record(iwcCommand, pTask,
&tEntrySec, &tExitSec);
/* check status and attach secure */
/* error before session teardown */
cmdq_sec_handle_attach_status(pTask, iwcCommand,
handle->iwcMessage, status, &dispatch_mod);
/* release resource */
#if !(CMDQ_OPEN_SESSION_ONCE)
cmdq_sec_teardown_context_session(handle)
#endif
/* Note we entry secure for config only */
/* and wait result in normal world. */
/* No need reset module HW for config failed case */
} while (0);
if (status == -ETIMEDOUT) {
/* t-base strange issue, mc_wait_notification */
/* false timeout when secure world has done */
/* because retry may failed, give up retry method */
cmdq_core_longstring_init(longMsg, &msgOffset, &msgMAXSize);
cmdqCoreLongString(false, longMsg, &msgOffset, &msgMAXSize,
"[SEC]<--SEC_SUBMIT: err[%d][mc_wait_notification timeout], pTask[0x%p], THR[%d],",
status, pTask, thread);
cmdqCoreLongString(false, longMsg, &msgOffset, &msgMAXSize,
" tgid[%d:%d], config_duration_ms[%d], cmdId[%d]\n",
tgid, pid, duration, iwcCommand);
if (msgOffset > 0) {
/* print message */
if (throwAEE) {
/* In timeout case, error come */
/* from TEE API, dispatch to AEE directly. */
CMDQ_AEE("TEE", "%s", longMsg);
}
cmdq_core_turnon_first_dump(pTask);
cmdq_core_dump_secure_task_status();
CMDQ_ERR("%s", longMsg);
}
} else if (status < 0) {
cmdq_core_longstring_init(longMsg, &msgOffset, &msgMAXSize);
cmdqCoreLongString(false, longMsg, &msgOffset, &msgMAXSize,
"[SEC]<--SEC_SUBMIT: err[%d], pTask[0x%p], THR[%d], tgid[%d:%d],",
status, pTask, thread, tgid, pid);
cmdqCoreLongString(false, longMsg, &msgOffset, &msgMAXSize,
" config_duration_ms[%d], cmdId[%d]\n",
duration, iwcCommand);
if (msgOffset > 0) {
/* print message */
if (throwAEE) {
/* print message */
CMDQ_AEE(dispatch_mod, "%s", longMsg);
}
cmdq_core_turnon_first_dump(pTask);
CMDQ_ERR("%s", longMsg);
}
/* dump metadata first */
if (pTask)
cmdq_core_dump_secure_metadata(&(pTask->secData));
} else {
cmdq_core_longstring_init(longMsg, &msgOffset, &msgMAXSize);
cmdqCoreLongString(false, longMsg, &msgOffset, &msgMAXSize,
"[SEC]<--SEC_SUBMIT: err[%d], pTask[0x%p], THR[%d], tgid[%d:%d],",
status, pTask, thread, tgid, pid);
cmdqCoreLongString(false, longMsg, &msgOffset, &msgMAXSize,
" config_duration_ms[%d], cmdId[%d]\n",
duration, iwcCommand);
if (msgOffset > 0) {
/* print message */
CMDQ_MSG("%s", longMsg);
}
}
return status;
}
int32_t cmdq_sec_init_allocate_resource_thread(void *data)
{
int32_t status = 0;
cmdq_sec_lock_secure_path();
gCmdqSecContextHandle = NULL;
status = cmdq_sec_allocate_path_resource_unlocked(false);
cmdq_sec_unlock_secure_path();
return status;
}
/*********************************************************
* sectrace
*******************************************************/
int32_t cmdq_sec_fill_iwc_command_sectrace_unlocked(
int32_t iwcCommand, void *_pTask,
int32_t thread, void *_pIwc)
{
struct iwcCmdqMessage_t *pIwc;
pIwc = (struct iwcCmdqMessage_t *) _pIwc;
/* specify command id only, don't care other other */
memset(pIwc, 0x0, sizeof(struct iwcCmdqMessage_t));
pIwc->cmd = iwcCommand;
switch (iwcCommand) {
case CMD_CMDQ_TL_SECTRACE_MAP:
pIwc->sectracBuffer.addr =
(uint32_t) (gCmdqSectraceMappedInfo.secure_virt_addr);
pIwc->sectracBuffer.size =
(gCmdqSectraceMappedInfo.secure_virt_len);
break;
case CMD_CMDQ_TL_SECTRACE_UNMAP:
case CMD_CMDQ_TL_SECTRACE_TRANSACT:
default:
pIwc->sectracBuffer.addr = 0;
pIwc->sectracBuffer.size = 0;
break;
}
/* medatada: debug config */
pIwc->debug.logLevel = (cmdq_core_should_print_msg()) ? (1) : (0);
pIwc->debug.enableProfile = cmdq_core_profile_enabled();
CMDQ_LOG("SESSION_MSG: iwcCmd:%d, msg(addr:0x%x, size:%d)\n",
iwcCommand, pIwc->sectracBuffer.addr,
pIwc->sectracBuffer.size);
return 0;
}
#ifdef CMDQ_SECTRACE_SUPPORT
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,
true);
/* map log buffer in NWd */
mcRet = mc_map(&(gCmdqSecContextHandle->sessionHandle),
va, (uint32_t) size,
&gCmdqSectraceMappedInfo);
if (mcRet != MC_DRV_OK) {
CMDQ_ERR("[sectrace]map: failed in NWd err: 0x%x\n",
mcRet);
status = -EFAULT;
break;
}
CMDQ_LOG
("[sectrace]map: mc_map done, Info(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, true);
if (status < 0) {
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;
}
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 (gCmdqSecContextHandle == NULL) {
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, true);
if (status < 0) {
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_transact(void)
{
int status;
CMDQ_LOG("[sectrace]-->transact\n");
status = cmdq_sec_submit_to_secure_world_async_unlocked(
CMD_CMDQ_TL_SECTRACE_TRANSACT,
NULL, CMDQ_INVALID_THREAD,
cmdq_sec_fill_iwc_command_sectrace_unlocked,
NULL, true);
CMDQ_LOG("[sectrace]<--transact: status: %d\n", status);
return status;
}
#endif
int32_t cmdq_sec_sectrace_init(void)
{
#ifdef CMDQ_SECTRACE_SUPPORT
int32_t status;
const uint32_t CMDQ_SECTRACE_BUFFER_SIZE_KB = 64;
union callback_func sectraceCB;
/* use callback_tl_function because */
/* CMDQ use "TCI" for inter-world communication */
sectraceCB.tl.map = cmdq_sec_sectrace_map;
sectraceCB.tl.unmap = cmdq_sec_sectrace_unmap;
sectraceCB.tl.transact = cmdq_sec_sectrace_transact;
/* create sectrace entry in debug FS */
/* use TCI for inter world communication */
status = init_sectrace("CMDQ_SEC", if_tci,
/* print sectrace log for tl and driver */
usage_tl_dr,
CMDQ_SECTRACE_BUFFER_SIZE_KB, &sectraceCB);
CMDQ_LOG("cmdq_sec_trace_init, status:%d\n", status);
return 0;
#else
return 0;
#endif
}
int32_t cmdq_sec_sectrace_deinit(void)
{
#ifdef CMDQ_SECTRACE_SUPPORT
/* destroy sectrace entry in debug FS */
deinit_sectrace("CMDQ_SEC");
return 0;
#else
return 0;
#endif
}
#endif /* CMDQ_SECURE_PATH_SUPPORT */
/*************************************************
* common part: for general projects
**************************************************/
int32_t cmdq_sec_create_shared_memory(
struct cmdqSecSharedMemoryStruct **pHandle, const uint32_t size)
{
struct cmdqSecSharedMemoryStruct *handle = NULL;
void *pVA = NULL;
dma_addr_t PA = 0;
handle = kzalloc(sizeof(uint8_t *) *
sizeof(struct cmdqSecSharedMemoryStruct),
GFP_KERNEL);
if (handle == NULL)
return -ENOMEM;
CMDQ_LOG("%s\n", __func__);
/* allocate non-cachable memory */
pVA = cmdq_core_alloc_hw_buffer(cmdq_dev_get(), size, &PA, GFP_KERNEL);
CMDQ_MSG("%s, MVA:%pa, pVA:%p, size:%d\n", __func__, &PA, pVA, size);
if (pVA == NULL) {
kfree(handle);
return -ENOMEM;
}
/* update memory information */
handle->size = size;
handle->pVABase = pVA;
handle->MVABase = PA;
*pHandle = handle;
return 0;
}
int32_t cmdq_sec_destroy_shared_memory(
struct cmdqSecSharedMemoryStruct *handle)
{
if (handle && handle->pVABase) {
cmdq_core_free_hw_buffer(cmdq_dev_get(), handle->size,
handle->pVABase, handle->MVABase);
}
kfree(handle);
handle = NULL;
return 0;
}
int32_t cmdq_sec_exec_task_async_unlocked(struct TaskStruct *pTask,
int32_t thread)
{
#ifdef CMDQ_SECURE_PATH_SUPPORT
int32_t status = 0;
status =
cmdq_sec_submit_to_secure_world_async_unlocked(
CMD_CMDQ_TL_SUBMIT_TASK, pTask, thread,
NULL, NULL, true);
if (status < 0) {
/* Error status print */
CMDQ_ERR("%s[%d]\n", __func__, status);
}
return status;
#else
CMDQ_ERR("secure path not support\n");
return -EFAULT;
#endif
}
int32_t cmdq_sec_cancel_error_task_unlocked(
struct TaskStruct *pTask, int32_t thread,
struct cmdqSecCancelTaskResultStruct *pResult)
{
#ifdef CMDQ_SECURE_PATH_SUPPORT
int32_t status = 0;
if ((pTask == NULL) ||
(cmdq_get_func()->isSecureThread(thread) == false) ||
(pResult == NULL)) {
CMDQ_ERR("%s invalid param, pTask:%p, thread:%d, pResult:%p\n",
__func__, pTask, thread, pResult);
return -EFAULT;
}
status = cmdq_sec_submit_to_secure_world_async_unlocked(
CMD_CMDQ_TL_CANCEL_TASK,
pTask, thread, NULL,
(void *)pResult, true);
return status;
#else
CMDQ_ERR("secure path not support\n");
return -EFAULT;
#endif
}
#ifdef CMDQ_SECURE_PATH_SUPPORT
static atomic_t gCmdqSecPathResource = ATOMIC_INIT(0);
#endif
int32_t cmdq_sec_allocate_path_resource_unlocked(bool throwAEE)
{
#ifdef CMDQ_SECURE_PATH_SUPPORT
int32_t status = 0;
CMDQ_MSG("%s throwAEE: %s", __func__, throwAEE ? "true" : "false");
if (atomic_cmpxchg(&gCmdqSecPathResource, 0, 1) != 0) {
/* has allocated successfully */
return status;
}
status =
cmdq_sec_submit_to_secure_world_async_unlocked(
CMD_CMDQ_TL_PATH_RES_ALLOCATE, NULL,
CMDQ_INVALID_THREAD, NULL, NULL,
throwAEE);
if (status < 0) {
/* Error status print */
CMDQ_ERR("%s[%d] reset context\n", __func__, status);
/* in fail case, we want function alloc again */
atomic_set(&gCmdqSecPathResource, 0);
}
return status;
#else
CMDQ_ERR("secure path not support\n");
return -EFAULT;
#endif
}
/****************************************************
* common part: SecContextHandle handle
******************************************************/
struct cmdqSecContextStruct *cmdq_sec_context_handle_create(
uint32_t tgid)
{
struct cmdqSecContextStruct *handle = NULL;
handle = kmalloc(sizeof(uint8_t *) *
sizeof(struct cmdqSecContextStruct),
GFP_ATOMIC);
if (handle) {
handle->state = IWC_INIT;
handle->iwcMessage = NULL;
handle->tgid = tgid;
handle->referCount = 0;
#ifndef CONFIG_MTK_CMDQ_TAB
handle->openMobicoreByOther = 0;
#endif
} else {
CMDQ_ERR("SecCtxHandle_CREATE: err[LOW_MEM], tgid[%d]\n",
tgid);
}
CMDQ_MSG("SecCtxHandle_CREATE: create new, H[0x%p], tgid[%d]\n",
handle, tgid);
return handle;
}
/******************************************************
* common part: init, deinit, path
*********************************************************/
void cmdq_sec_lock_secure_path(void)
{
mutex_lock(&gCmdqSecExecLock);
/* set memory barrier for lock */
smp_mb();
}
void cmdq_sec_unlock_secure_path(void)
{
mutex_unlock(&gCmdqSecExecLock);
}
void cmdqSecDeInitialize(void)
{
}
void cmdqSecInitialize(void)
{
INIT_LIST_HEAD(&gCmdqSecContextList);
}
void cmdqSecEnableProfile(const bool enable)
{
#ifdef CMDQ_SECURE_PATH_SUPPORT
CMDQ_LOG("[sectrace]enable profile %d\n", enable);
mutex_lock(&gCmdqSecProfileLock);
if (enable)
cmdq_sec_sectrace_init();
else
cmdq_sec_sectrace_deinit();
mutex_unlock(&gCmdqSecProfileLock);
#endif
}
Reference in a new issue Copy permalink