int main(int argc, char *argv[])
{
TZ_RESULT ret;
UREE_SESSION_HANDLE dbg_session;
UREE_SECUREMEM_INFO info;
printf ("Run memory CA\n");
ret = UREE_CreateSession(TZ_TA_DBG_UUID, &dbg_session);
if (ret != TZ_RESULT_SUCCESS)
{
// Should provide strerror style error string in UREE.
printf("CreateSession Error: %s\n", TZ_GetErrorString(ret));
return 1;
}
// get secure memory information
ret = UREE_GetSecurememinfo (dbg_session, &info);
if (ret != TZ_RESULT_SUCCESS)
{
printf("UREE_GetSecurememinfo Error: %s\n", TZ_GetErrorString(ret));
return 0;
}
printf ("secure memory: Used = 0x%x bytes, Total = 0x%x bytes,\n"
" Max free continuous mem sz = 0x%x bytes\n"
" Max foot print = 0x%x bytes\n"
, info.used_byte, info.total_byte, info.max_free_cont_mem_sz, info.max_foot_print);
// get secure chunk memory information
ret = UREE_GetSecurechunkmeminfo (dbg_session, &info);
if (ret != TZ_RESULT_SUCCESS)
{
printf("UREE_GetSecurechunkmeminfo Error: %s\n", TZ_GetErrorString(ret));
return 0;
}
printf ("secure chunk memory: Used = 0x%x bytes, Total = 0x%x bytes,\n"
" Max free continuous mem sz = 0x%x bytes\n"
" Max foot print = 0x%x bytes\n"
, info.used_byte, info.total_byte, info.max_free_cont_mem_sz, info.max_foot_print);
ret = UREE_CloseSession(dbg_session);
if (ret != TZ_RESULT_SUCCESS)
{
printf("CloseSeesion dbg_session_A Error: %d\n", ret);
}
printf ("Memory CA done\n");
return 0;
}
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;
}
TZ_RESULT UREE_ReleaseTzmem (int *fd_p)
{
int fd;
int ret = TZ_RESULT_SUCCESS;
UREE_SESSION_HANDLE session;
uint32_t size;
if (fd_p == NULL)
{
return TZ_RESULT_ERROR_BAD_PARAMETERS;
}
pthread_mutex_lock(&mtee_tzmemInfo.mutex);
if (mtee_tzmemInfo.control != 0)
{
ret = TZ_RESULT_ERROR_GENERIC;
goto out;
}
ret = UREE_CreateSession(TZ_TA_MEM_UUID, &session);
if (ret != TZ_RESULT_SUCCESS)
{
printf("UREE_ReleaseTzmem: CreateSession Error = %s\n", TZ_GetErrorString(ret));
goto out;
}
ret = UREE_ReleaseSecurechunkmem (session, 0x0, &size);
printf ("released size = 0x%x\n", size);
if (ret != TZ_RESULT_SUCCESS)
{
ret = TZ_RESULT_ERROR_GENERIC;
goto out_release_fail;
}
fd = open("/dev/tzmem", O_RDWR);
if (fd < 0)
{
ret = TZ_RESULT_ERROR_GENERIC;
goto out_release_fail;
}
else
{
*fd_p = fd;
}
mtee_tzmemInfo.session = session;
mtee_tzmemInfo.control = 1;
pthread_mutex_unlock(&mtee_tzmemInfo.mutex);
return ret;
out_release_fail:
UREE_CloseSession (session);
out:
pthread_mutex_unlock(&mtee_tzmemInfo.mutex);
return ret;
}
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;
}
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));
}
}
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));
}
}
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;
}
TZ_RESULT UREE_AppendTzmem (int fd)
{
int ret = TZ_RESULT_SUCCESS;
UREE_SESSION_HANDLE session;
if (fd == 0)
{
return TZ_RESULT_ERROR_BAD_PARAMETERS;
}
pthread_mutex_lock(&mtee_tzmemInfo.mutex);
if (mtee_tzmemInfo.control == 0)
{
ret = TZ_RESULT_ERROR_GENERIC;
goto out;
}
close (fd);
session = mtee_tzmemInfo.session;
ret = UREE_AppendSecurechunkmem (session);
if (ret != TZ_RESULT_SUCCESS)
{
ret = TZ_RESULT_ERROR_GENERIC;
}
ret = UREE_CloseSession(session);
if (ret != TZ_RESULT_SUCCESS)
{
printf("UREE_AppendTzmem: UREE_CloseSession Error = %s\n", TZ_GetErrorString(ret));
goto out;
}
mtee_tzmemInfo.control = 0;
out:
pthread_mutex_unlock(&mtee_tzmemInfo.mutex);
return ret;
}
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;
}
