TZ_RESULT UREE_GetSecurememinfo (UREE_SESSION_HANDLE session, UREE_SECUREMEM_INFO *info) { MTEEC_PARAM p[4]; TZ_RESULT ret; if ((info == NULL)) { return TZ_RESULT_ERROR_BAD_PARAMETERS; } ret = UREE_TeeServiceCall(session, TZCMD_DBG_SECUREMEM_INFO, TZ_ParamTypes2(TZPT_VALUE_OUTPUT, TZPT_VALUE_OUTPUT), p); if (ret != TZ_RESULT_SUCCESS) { printf("[uree] UREE_GetSecurememinfo Error: %d\n", ret); return ret; } info->used_byte = p[0].value.a; info->max_free_cont_mem_sz = p[0].value.b; info->total_byte = p[1].value.a; info->max_foot_print = p[1].value.b; return TZ_RESULT_SUCCESS; }
int kree_set_fiq(int irq, unsigned long irq_flags) { MTEEC_PARAM param[4]; TZ_RESULT ret; unsigned long tz_irq_flags = 0; if (irq_flags & (IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)) { tz_irq_flags |= TZ_IRQF_EDGE_SENSITIVE; tz_irq_flags |= (irq_flags & IRQF_TRIGGER_FALLING) ? TZ_IRQF_LOW : TZ_IRQF_HIGH; } else if (irq_flags & (IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW)) { tz_irq_flags |= TZ_IRQF_LEVEL_SENSITIVE; tz_irq_flags |= (irq_flags & IRQF_TRIGGER_LOW) ? TZ_IRQF_LOW : TZ_IRQF_HIGH; } param[0].value.a = irq; param[1].value.a = tz_irq_flags; ret = KREE_TeeServiceCall(irq_session, TZCMD_IRQ_SET_FIQ, TZ_ParamTypes2(TZPT_VALUE_INPUT, TZPT_VALUE_INPUT), param); if (ret != TZ_RESULT_SUCCESS) { printk("%s error: %s\n", __FUNCTION__, TZ_GetErrorString(ret)); } return ret; }
static inline TZ_RESULT _handleOpFunc_1 (uint32_t cmd, KREE_SESSION_HANDLE session, uint32_t mem_handle, uint32_t *count, char *dbg) { MTEEC_PARAM p[4]; TZ_RESULT ret; if ((session == 0) || (mem_handle == 0) || (count == NULL)) { return TZ_RESULT_ERROR_BAD_PARAMETERS; } p[0].value.a = (uint32_t) mem_handle; ret = KREE_TeeServiceCall(session, cmd, TZ_ParamTypes2( TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT), p); if (ret < 0) { #ifdef DBG_KREE_MEM printk("[kree] %s Error: %d\n", dbg, ret); #endif *count = 0; return ret; } *count = p[1].value.a; return TZ_RESULT_SUCCESS; }
int kree_raise_softfiq(unsigned int mask, unsigned int irq) { MTEEC_PARAM param[4]; TZ_RESULT ret; param[0].value.a = mask; param[1].value.a = irq; ret = KREE_TeeServiceCall(irq_session, TZCMD_IRQ_TRIGGER_SGI, TZ_ParamTypes2(TZPT_VALUE_INPUT, TZPT_VALUE_INPUT), param); return (ret == TZ_RESULT_SUCCESS); }
void kree_pm_cpu_lowpower(volatile int *ppen_release, int logical_cpuid) { MTEEC_PARAM param[4]; TZ_RESULT ret; param[0].value.a = (unsigned int)ppen_release; param[1].value.a = logical_cpuid; ret = KREE_TeeServiceCall(pm_session, TZCMD_PM_CPU_LOWPOWER, TZ_ParamTypes2(TZPT_VALUE_INPUT, TZPT_VALUE_INPUT), param); if (ret != TZ_RESULT_SUCCESS) { printk("%s error: %s\n", __FUNCTION__, TZ_GetErrorString(ret)); } }
static void __kree_enable_fiq(int irq, int enable) { MTEEC_PARAM param[4]; TZ_RESULT ret; param[0].value.a = irq; param[1].value.a = enable; ret = KREE_TeeServiceCall(irq_session, TZCMD_IRQ_ENABLE_FIQ, TZ_ParamTypes2(TZPT_VALUE_INPUT, TZPT_VALUE_INPUT), param); if (ret != TZ_RESULT_SUCCESS) { printk("%s error: %s\n", __FUNCTION__, TZ_GetErrorString(ret)); } }
void kree_query_fiq(int irq, int *enable, int *pending) { MTEEC_PARAM param[4]; TZ_RESULT ret; param[0].value.a = irq; ret = KREE_TeeServiceCall(irq_session, TZCMD_IRQ_QUERY_FIQ, TZ_ParamTypes2(TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT), param); if (ret != TZ_RESULT_SUCCESS) { printk("%s error: %s\n", __FUNCTION__, TZ_GetErrorString(ret)); param[1].value.a = 0; } *enable = param[1].value.a & 1; *pending = (param[1].value.a & 2) != 0; }
uint32_t TEECK_Icnt_Counter(KREE_SESSION_HANDLE session, uint32_t* a, uint32_t* b) { MTEEC_PARAM param[4]; uint32_t paramTypes; TZ_RESULT ret; paramTypes = TZ_ParamTypes2(TZPT_VALUE_OUTPUT, TZPT_VALUE_OUTPUT); ret = KREE_TeeServiceCall(session, TZCMD_ICNT_COUNT, paramTypes, param); if (ret != TZ_RESULT_SUCCESS) { printk("ServiceCall error %d\n", ret); } *a = param[0].value.a; *b = param[1].value.a; return ret; }
TZ_RESULT UREE_ReleaseSecurechunkmem (UREE_SESSION_HANDLE session, uint32_t size, uint32_t *released_size) { MTEEC_PARAM p[4]; TZ_RESULT ret; if (session == 0) { return TZ_RESULT_ERROR_BAD_PARAMETERS; } p[0].value.a = size; ret = UREE_TeeServiceCall(session, TZCMD_MEM_SECURECM_RELEASE, TZ_ParamTypes2(TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT), p); if (ret != TZ_RESULT_SUCCESS) { #ifdef DBG_UREE_MEM printf("[uree] UREE_ReleaseSecurechunkmem Error: %d\n", ret); #endif return ret; } *released_size = p[1].value.a; 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; }