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