void kree_fiq_eoi(unsigned int iar) { MTEEC_PARAM param[4]; param[0].value.a = iar; KREE_TeeServiceCall(irq_session, TZCMD_IRQ_EOI, TZ_ParamTypes1(TZPT_VALUE_INPUT), param); }
unsigned int kree_fiq_get_intack(void) { MTEEC_PARAM param[4]; TZ_RESULT ret; ret = KREE_TeeServiceCall(irq_session, TZCMD_IRQ_GET_INTACK, TZ_ParamTypes1(TZPT_VALUE_OUTPUT), param); if (ret == TZ_RESULT_SUCCESS) return param[0].value.a; return 0xffff; }
/************************************************************* * REE Service *************************************************************/ static irqreturn_t KREE_IrqHandler(int irq, void *dev) { uint32_t paramTypes; MTEEC_PARAM param[4]; TZ_RESULT ret; param[0].value.a = (uint32_t)irq; paramTypes = TZ_ParamTypes1(TZPT_VALUE_INPUT); ret = KREE_TeeServiceCall((KREE_SESSION_HANDLE)MTEE_SESSION_HANDLE_SYSTEM, TZCMD_SYS_IRQ, paramTypes, param); return (ret == TZ_RESULT_SUCCESS) ? IRQ_HANDLED : IRQ_NONE; }
int kree_pm_device_ops(int state) { MTEEC_PARAM param[4]; TZ_RESULT ret; param[0].value.a = (uint32_t)state; ret = KREE_TeeServiceCall(pm_session, TZCMD_PM_DEVICE_OPS, TZ_ParamTypes1(TZPT_VALUE_INPUT), param); if (ret != TZ_RESULT_SUCCESS) { printk("%s error: %s\n", __FUNCTION__, TZ_GetErrorString(ret)); } return ret; }
int kree_pm_cpu_dormant(int mode) { MTEEC_PARAM param[4]; TZ_RESULT ret; param[0].value.a = mode; ret = KREE_TeeServiceCall(pm_session, TZCMD_PM_CPU_DORMANT, TZ_ParamTypes1(TZPT_VALUE_INPUT), param); if (ret != TZ_RESULT_SUCCESS) { printk("%s error: %s\n", __FUNCTION__, TZ_GetErrorString(ret)); } return 0; }
TZ_RESULT kree_unregister_sharedmem (KREE_SESSION_HANDLE session, KREE_SHAREDMEM_HANDLE mem_handle) { MTEEC_PARAM p[4]; TZ_RESULT ret; p[0].value.a = (uint32_t) mem_handle; ret = KREE_TeeServiceCall(session, TZCMD_MEM_SHAREDMEM_UNREG, TZ_ParamTypes1(TZPT_VALUE_INPUT), p); if (ret != TZ_RESULT_SUCCESS) { return ret; } return TZ_RESULT_SUCCESS; }
void kree_irq_mask_restore(unsigned int *pmask, unsigned int size) { MTEEC_PARAM param[4]; TZ_RESULT ret; param[0].mem.buffer = pmask; param[0].mem.size = size; ret = KREE_TeeServiceCall(irq_session, TZCMD_IRQ_MASK_RESTORE, TZ_ParamTypes1(TZPT_MEM_INPUT), param); if (ret != TZ_RESULT_SUCCESS) { printk("%s error: %s\n", __FUNCTION__, TZ_GetErrorString(ret)); } }
TZ_RESULT KREE_GetTEETotalSize (KREE_SESSION_HANDLE session, uint32_t *size) { MTEEC_PARAM p[4]; TZ_RESULT ret; ret = KREE_TeeServiceCall(session, TZCMD_MEM_TOTAL_SIZE, TZ_ParamTypes1(TZPT_VALUE_OUTPUT), p); if (ret != TZ_RESULT_SUCCESS) { #ifdef DBG_KREE_MEM printk("[kree] KREE_GetTEETotalSize Error: %d\n", ret); #endif return ret; } *size = p[0].value.a; return TZ_RESULT_SUCCESS; }
uint32_t TEECK_Icnt_Rate(KREE_SESSION_HANDLE session, uint32_t* a) { MTEEC_PARAM param[4]; uint32_t paramTypes; TZ_RESULT ret; paramTypes = TZ_ParamTypes1(TZPT_VALUE_OUTPUT); ret = KREE_TeeServiceCall(session, TZCMD_ICNT_RATE, paramTypes, param); if (ret != TZ_RESULT_SUCCESS) { printk("ServiceCall error %d\n", ret); } *a = param[0].value.a; return ret; }
static inline TZ_RESULT _handleOpFunc (uint32_t cmd, KREE_SESSION_HANDLE session, uint32_t mem_handle, char *dbg) { MTEEC_PARAM p[4]; TZ_RESULT ret; if ((session == 0) || (mem_handle == 0)) { return TZ_RESULT_ERROR_BAD_PARAMETERS; } p[0].value.a = (uint32_t) mem_handle; ret = KREE_TeeServiceCall(session, cmd, TZ_ParamTypes1( TZPT_VALUE_INPUT), p); if (ret < 0) { #ifdef DBG_KREE_MEM printk("[kree] %s Error: %d\n", dbg, ret); #endif return ret; } return TZ_RESULT_SUCCESS; }
static int MTEE_TestSerivce(MTEE_SESSION_HANDLE handle, uint32_t cmd, uint32_t paramTypes, MTEE_PARAM param[4]) { switch (cmd) { case TZCMD_TEST_ADD: if (TZ_GetParamTypes(paramTypes, 0) == TZPT_VALUE_INPUT && TZ_GetParamTypes(paramTypes, 1) == TZPT_VALUE_INPUT && TZ_GetParamTypes(paramTypes, 2) == TZPT_VALUE_OUTPUT) { param[2].value.a = param[0].value.a + param[1].value.a; return 0; } else return TZ_RESULT_ERROR_BAD_FORMAT; break; case TZCMD_TEST_MUL: if (paramTypes == TZ_ParamTypes3(TZPT_VALUE_INPUT, TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT)) { param[2].value.a = param[0].value.a * param[1].value.a; return 0; } else return TZ_RESULT_ERROR_BAD_FORMAT; break; case TZCMD_TEST_SECUREFUNC: { uint32_t testFunc = 0xdead; MTEE_SecureFunction ((MTEE_SecureFunctionPrototype) &test_secureFunc, &testFunc); return TZ_RESULT_SUCCESS; } break; case TZCMD_TEST_THREAD: if (paramTypes == TZ_ParamTypes2(TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT)) { MTEE_THREAD_HANDLE handle; void *result = NULL; uint32_t user_data; TZ_RESULT ret; user_data = param[0].value.a; ret = MTEE_CreateThread (&handle, (MTEE_ThreadFunc) &test_threadFunc, &user_data, "0123456789abcdef0123456789abcdef0123456789abcdef"); if (ret != TZ_RESULT_SUCCESS) { printf ("TZCMD_TEST_THREAD error create = 0x%x\n", ret); return ret; } ret = MTEE_JoinThread (handle, &result); if (ret != TZ_RESULT_SUCCESS) { printf ("TZCMD_TEST_THREAD error joint = 0x%x\n", ret); return ret; } param[1].value.a = *((uint32_t *) result); return TZ_RESULT_SUCCESS; } else return TZ_RESULT_ERROR_BAD_FORMAT; break; case TZCMD_TEST_ADD_MEM: if (paramTypes == TZ_ParamTypes3(TZPT_MEMREF_INPUT, TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT)) { int *buffer; uint32_t size; int result; buffer = param[0].mem.buffer; size = param[1].value.a; result = 0; for (; size != 0; size --) { result += *buffer ++; } param[2].value.a = result; return TZ_RESULT_SUCCESS; } else return TZ_RESULT_ERROR_BAD_FORMAT; break; case TZCMD_TEST_DO_A: if (paramTypes == TZ_ParamTypes3(TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT, TZPT_VALUE_OUTPUT)) { MTEE_SECUREMEM_HANDLE memHandle; MTEE_MEM_PARAM p; int i; uint32_t *buf; memHandle = param[0].value.a; // query memory by handle TA_Mem_QueryMem (memHandle, &p); buf = (uint32_t *) p.buffer; printf ("Do A: memory rank = 0x%x (0x%x)\n", MTEE_QueryMemoryrank (buf), (uint32_t) buf); // do something with the secure memory for (i = 0; i < 8; i ++) { *buf ++ = _testPatternA[i]; } param[1].value.a = (uint32_t) p.buffer; param[2].value.a = p.size; return TZ_RESULT_SUCCESS; } else return TZ_RESULT_ERROR_BAD_FORMAT; break; case TZCMD_TEST_DO_B: if (paramTypes == TZ_ParamTypes3(TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT, TZPT_VALUE_OUTPUT)) { MTEE_SECUREMEM_HANDLE memHandle; MTEE_MEM_PARAM p; int i; uint32_t *buf; memHandle = param[0].value.a; // query memory by handle TA_Mem_QueryMem (memHandle, &p); buf = (uint32_t *) p.buffer; // do something with the secure memory for (i = 0; i < 8; i ++) { if (*buf != _testPatternA[i]) { param[1].value.a = _testPatternA[i]; param[2].value.a = 0; return TZ_RESULT_SUCCESS; } buf ++; } param[1].value.a = (uint32_t) p.buffer; param[2].value.a = p.size; return TZ_RESULT_SUCCESS; } else return TZ_RESULT_ERROR_BAD_FORMAT; break; case TZCMD_TEST_DO_C: if (paramTypes == TZ_ParamTypes1(TZPT_VALUE_OUTPUT)) { int i; uint32_t *buf; buf = MTEE_AllocOnchipMem (TEST_SRAM_LOOP * sizeof (uint32_t)); // do something with the secure memory for (i = 0; i < TEST_SRAM_LOOP; i ++) { buf[i] = i; } param[0].value.a = (uint32_t) buf; return TZ_RESULT_SUCCESS; } else return TZ_RESULT_ERROR_BAD_FORMAT; break; case TZCMD_TEST_DO_D: if (paramTypes == TZ_ParamTypes1(TZPT_VALUE_INPUT)) { int i; uint32_t *buf; buf = (uint32_t *) param[0].value.a; // do something with the secure memory for (i = 0; i < TEST_SRAM_LOOP; i ++) { if (buf[i] != i) { return TZ_RESULT_ERROR_GENERIC; } //printf ("--> 0x%x\n", buf[i]); } MTEE_FreeOnchipMem (buf); return TZ_RESULT_SUCCESS; } else return TZ_RESULT_ERROR_BAD_FORMAT; break; case TZCMD_TEST_CP_SBUF2NBUF: if (paramTypes == TZ_ParamTypes3(TZPT_VALUE_INPUT, TZPT_MEMREF_INOUT, TZPT_VALUE_INPUT)) { MTEE_SECUREMEM_HANDLE memHandle; MTEE_MEM_PARAM p; uint8_t* p_nbuf; uint8_t* p_sbuf; uint32_t size; size = (param[1].mem.size > param[2].value.a) ? param[2].value.a : param[1].mem.size; p_nbuf = param[1].mem.buffer; memHandle = param[0].value.a; /* query memory by handle */ TA_Mem_QueryMem(memHandle, &p); p_sbuf = (uint8_t*) p.buffer; memcpy(p_nbuf, p_sbuf, size ); return TZ_RESULT_SUCCESS; } return TZ_RESULT_ERROR_BAD_FORMAT; break; case TZCMD_TEST_CP_NBUF2SBUF: if (paramTypes == TZ_ParamTypes3(TZPT_VALUE_INPUT, TZPT_MEMREF_INOUT, TZPT_VALUE_INPUT)) { MTEE_SECUREMEM_HANDLE memHandle; MTEE_MEM_PARAM p; uint8_t* p_nbuf; uint8_t* p_sbuf; uint32_t size; size = (param[1].mem.size > param[2].value.a) ? param[2].value.a : param[1].mem.size; p_nbuf = param[1].mem.buffer; memHandle = param[0].value.a; /* query memory by handle */ TA_Mem_QueryMem(memHandle, &p); p_sbuf = (uint8_t*) p.buffer; memcpy(p_sbuf, p_nbuf, size ); return TZ_RESULT_SUCCESS; } return TZ_RESULT_ERROR_BAD_FORMAT; break; #if 0 case TZCMD_TEST_COUNT: //printf("(yjdbg) TZCMD_TEST_COUNT\n"); if (paramTypes == TZ_ParamTypes2(TZPT_VALUE_OUTPUT, TZPT_VALUE_OUTPUT)) { u64 tmp = get_incr_only_count(); //printf("(yjdbg) TZCMD_TEST_COUNT - 0x%x\n", READ_REGISTER_UINT32(0xf0008020 + 0x08)); //printf("(yjdbg) TZCMD_TEST_COUNT - 0x%llx\n", tmp); param[0].value.a = tmp & 0xffffffff; param[1].value.a = tmp >> 32; } return TZ_RESULT_SUCCESS; break; #endif default: return TZ_RESULT_ERROR_GENERIC; }