TZ_RESULT KREE_WriteSecurechunkmem (KREE_SESSION_HANDLE session, uint32_t offset, uint32_t size, void *buffer) { MTEEC_PARAM p[4]; TZ_RESULT ret; if ((session == 0) || (size == 0)) { return TZ_RESULT_ERROR_BAD_PARAMETERS; } p[0].value.a = offset; p[1].value.a = size; p[2].mem.buffer = buffer; p[2].mem.size = size; // fix me!!!! ret = KREE_TeeServiceCall(session, TZCMD_MEM_SECURECM_WRITE, TZ_ParamTypes3(TZPT_VALUE_INPUT, TZPT_VALUE_INPUT, TZPT_MEM_INPUT), p); if (ret != TZ_RESULT_SUCCESS) { #ifdef DBG_KREE_MEM printk("[kree] KREE_WriteSecurechunkmem Error: %d\n", ret); #endif return ret; } return TZ_RESULT_SUCCESS; }
// notiec: handle type is the same static inline TZ_RESULT _allocFunc (uint32_t cmd, KREE_SESSION_HANDLE session, uint32_t *mem_handle, uint32_t alignment, uint32_t size, char *dbg) { MTEEC_PARAM p[4]; TZ_RESULT ret; if ((session == 0) || (mem_handle == NULL) || (size == 0)) { return TZ_RESULT_ERROR_BAD_PARAMETERS; } p[0].value.a = alignment; p[1].value.a = size; ret = KREE_TeeServiceCall(session, cmd, TZ_ParamTypes3( TZPT_VALUE_INPUT, TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT), p); if (ret != TZ_RESULT_SUCCESS) { #ifdef DBG_KREE_MEM printk("[kree] %s Error: %d\n", dbg, ret); #endif return ret; } *mem_handle = (KREE_SECUREMEM_HANDLE) p[2].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; }
int entropy_thread(void * arg) { TZ_RESULT ret; KREE_SESSION_HANDLE ndbg_session; KREE_SESSION_HANDLE mem_session; KREE_SHAREDMEM_HANDLE shm_handle; KREE_SHAREDMEM_PARAM shm_param; MTEEC_PARAM param[4]; uint8_t* ptr; ptr = (uint8_t*)kmalloc(NDBG_REE_ENTROPY_SZ, GFP_KERNEL); memset(ptr, 0, NDBG_REE_ENTROPY_SZ); while(!kthread_should_stop()) { ret = KREE_CreateSession(TZ_TA_NDBG_UUID, &ndbg_session); if (ret != TZ_RESULT_SUCCESS) { printk("CreateSession error %d\n", ret); return 1; } ret = KREE_CreateSession(TZ_TA_MEM_UUID, &mem_session); if (ret != TZ_RESULT_SUCCESS) { printk("Create memory session error %d\n", ret); return 1; } shm_param.buffer = ptr; shm_param.size = NDBG_REE_ENTROPY_SZ; ret = KREE_RegisterSharedmem(mem_session, &shm_handle, &shm_param); if (ret != TZ_RESULT_SUCCESS) { printk("KREE_RegisterSharedmem Error: %s\n", TZ_GetErrorString(ret)); return 1; } #ifdef CONFIG_MTK_SMART_BATTERY *((uint32_t*)(ptr+0)) = get_bat_sense_volt(1); *((uint32_t*)(ptr+4)) = get_i_sense_volt(1); *((uint32_t*)(ptr+8)) = get_charger_volt(1); *((uint32_t*)(ptr+12)) = get_charger_volt(1); get_urandom_value(ptr+NDBG_BAT_ST_SIZE, URAN_SIZE); #else /* without battery, any other good source for nondetermined #? */ get_urandom_value(ptr, NDBG_REE_ENTROPY_SZ); #endif param[0].memref.handle = (uint32_t) shm_handle; param[0].memref.offset = 0; param[0].memref.size = NDBG_REE_ENTROPY_SZ; param[1].value.a = NDBG_REE_ENTROPY_SZ; ret = KREE_TeeServiceCall((KREE_SESSION_HANDLE)ndbg_session, TZCMD_NDBG_INIT, TZ_ParamTypes3(TZPT_MEMREF_INPUT, TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT), param); printk ("Start to wait reseed.\n"); ret = KREE_TeeServiceCall((KREE_SESSION_HANDLE)ndbg_session, TZCMD_NDBG_WAIT_RESEED, TZ_ParamTypes3(TZPT_MEMREF_INPUT, TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT), param); printk ("OK to send reseed.\n"); ret = KREE_UnregisterSharedmem(mem_session, shm_handle); if (ret != TZ_RESULT_SUCCESS) { printk("KREE_UnregisterSharedmem Error: %s\n", TZ_GetErrorString(ret)); return 1; } ret = KREE_CloseSession(ndbg_session); if (ret != TZ_RESULT_SUCCESS) printk("CloseSession error %d\n", ret); ret = KREE_CloseSession(mem_session); if (ret != TZ_RESULT_SUCCESS) printk("Close memory session error %d\n", ret); } kfree(ptr); return 0; }
int test_random_thread(void * arg) { TZ_RESULT ret; KREE_SESSION_HANDLE ndbg_session; KREE_SESSION_HANDLE mem_session; KREE_SHAREDMEM_HANDLE shm_handle; KREE_SHAREDMEM_PARAM shm_param; MTEEC_PARAM param[4]; uint32_t *ptr; int size = 32; ptr = (uint32_t *)kmalloc(size, GFP_KERNEL); memset(ptr, 0, size); while(!kthread_should_stop()) { ret = KREE_CreateSession(TZ_TA_NDBG_UUID, &ndbg_session); if (ret != TZ_RESULT_SUCCESS) { printk("CreateSession error %d\n", ret); return 1; } ret = KREE_CreateSession(TZ_TA_MEM_UUID, &mem_session); if (ret != TZ_RESULT_SUCCESS) { printk("Create memory session error %d\n", ret); return 1; } shm_param.buffer = ptr; shm_param.size = size; ret = KREE_RegisterSharedmem(mem_session, &shm_handle, &shm_param); if (ret != TZ_RESULT_SUCCESS) { printk("KREE_RegisterSharedmem Error: %s\n", TZ_GetErrorString(ret)); return 1; } param[0].memref.handle = (uint32_t) shm_handle; param[0].memref.offset = 0; param[0].memref.size = size/4; param[1].value.a = size/4; ret = KREE_TeeServiceCall((KREE_SESSION_HANDLE)ndbg_session, TZCMD_NDBG_RANDOM, TZ_ParamTypes3(TZPT_MEMREF_INPUT, TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT), param); ret = KREE_UnregisterSharedmem(mem_session, shm_handle); if (ret != TZ_RESULT_SUCCESS) { printk("KREE_UnregisterSharedmem Error: %s\n", TZ_GetErrorString(ret)); return 1; } ret = KREE_CloseSession(ndbg_session); if (ret != TZ_RESULT_SUCCESS) printk("CloseSession error %d\n", ret); ret = KREE_CloseSession(mem_session); if (ret != TZ_RESULT_SUCCESS) printk("Close memory session error %d\n", ret); ssleep(5); } kfree(ptr); return 0; }