static TZ_RESULT _tzmem_get_poolsize(uint32_t *size)
{
KREE_SESSION_HANDLE session;
int ret = TZ_RESULT_SUCCESS;
ret = KREE_CreateSession(TZ_TA_MEM_UUID, &session);
if (ret != TZ_RESULT_SUCCESS) {
pr_debug(MTEE_TZMEM_TAG
"[%s] _tzmem_get_poolsize: KREE_CreateSession Error = 0x%x\n",
MODULE_NAME, ret);
return ret;
}
/* get ta preset tzmem size */
ret = KREE_GetSecurechunkReleaseSize(session, size);
if (ret != TZ_RESULT_SUCCESS) {
pr_debug(MTEE_TZMEM_TAG
"[%s] _tzmem_get_poolsize: KREE_GetSecurechunkReleaseSize Error = 0x%x\n",
MODULE_NAME, ret);
KREE_CloseSession(session);
return ret;
}
ret = KREE_CloseSession(session);
if (ret != TZ_RESULT_SUCCESS) {
pr_debug(MTEE_TZMEM_TAG "[%s] _tzmem_get_poolsize: KREE_CloseSession Error = 0x%x\n", MODULE_NAME, ret);
return ret;
}
return ret;
}
void kree_pm_init(void)
{
TZ_RESULT ret;
ret = KREE_CreateSession(TZ_TA_PM_UUID, &pm_session);
if (ret != TZ_RESULT_SUCCESS)
{
printk("CreateSession error %d\n", ret);
return;
}
}
void kree_irq_init(void)
{
TZ_RESULT ret;
ret = KREE_CreateSession(TZ_TA_IRQ_UUID, &irq_session);
if (ret != TZ_RESULT_SUCCESS)
{
printk("%s: CreateSession error %d\n", __FUNCTION__, ret);
return;
}
}
int update_counter_thread(void *data)
{
TZ_RESULT ret;
KREE_SESSION_HANDLE icnt_session;
uint32_t result;
uint32_t a, b, rate;
uint32_t nsec = THREAD_COUNT_FREQ;
ret = KREE_CreateSession(TZ_TA_ICNT_UUID, &icnt_session);
if (ret != TZ_RESULT_SUCCESS)
{
printk("CreateSession error %d\n", ret);
return 1;
}
result = TEECK_Icnt_Rate(icnt_session, &rate);
if (result == TZ_RESULT_SUCCESS)
{
//printk("(yjdbg) rate: %d\n", rate);
nsec = (0xffffffff / rate);
nsec -= 600;
//printk("(yjdbg) rate: %d\n", nsec);
}
set_freezable();
for (;;) {
if (kthread_should_stop())
break;
if (try_to_freeze())
continue;
result = TEECK_Icnt_Counter(icnt_session, &a, &b);
if (result == TZ_RESULT_SUCCESS)
{
//printk("(yjdbg) tz_test TZCMD_ICNT_COUNT: 0x%x, 0x%x\n", a, b);
}
schedule_timeout_interruptible(HZ * nsec);
}
ret = KREE_CloseSession(icnt_session);
if (ret != TZ_RESULT_SUCCESS)
{
printk("CloseSession error %d\n", ret);
return 1;
}
return 0;
}
/* Create disk on demand. So we won't create lots of disk for un-used devices. */
static struct kobject *tzmem_blk_probe(dev_t dev, int *part, void *data)
{
uint32_t len;
struct gendisk *disk;
struct kobject *kobj;
struct request_queue *queue;
struct tzmem_diskinfo_s *diskInfo;
int ret;
KREE_SESSION_HANDLE session;
#ifdef MTEE_TZMEM_DBG
pr_warn("====> tzmem_blk_probe\n");
#endif
mutex_lock(&tzmem_probe_mutex);
diskInfo = (struct tzmem_diskinfo_s *) &_tzmem_diskInfo[tzmem_poolIndex];
if (diskInfo->disk == NULL) {
disk = alloc_disk(1);
if (!disk)
goto out_info;
queue = blk_init_queue(do_tzmem_blk_request, &tzmem_blk_lock);
if (!queue)
goto out_queue;
blk_queue_max_hw_sectors(queue, 1024);
blk_queue_bounce_limit(queue, BLK_BOUNCE_ANY);
if (_tzmem_get_poolsize(&len))
goto out_init;
disk->major = IO_NODE_MAJOR_TZMEM;
disk->first_minor = MINOR(dev);
disk->fops = &tzmem_blk_fops;
disk->private_data = &_tzmem_diskInfo;
snprintf(disk->disk_name, sizeof(disk->disk_name), "tzmem%d", MINOR(dev));
disk->queue = queue;
set_capacity(disk, len / 512);
add_disk(disk);
ret = KREE_CreateSession(TZ_TA_MEM_UUID, &session);
if (ret != TZ_RESULT_SUCCESS) {
pr_debug(MTEE_TZMEM_TAG
"[%s] _tzmem_get_poolsize: KREE_CreateSession Error = 0x%x\n",
MODULE_NAME, ret);
goto out_init;
}
diskInfo->session = session;
diskInfo->pool_size = len;
diskInfo->disk = disk;
diskInfo->size = len;
}
*part = 0;
kobj = diskInfo ? get_disk(diskInfo->disk) : ERR_PTR(-ENOMEM);
mutex_unlock(&tzmem_probe_mutex);
return kobj;
out_init:
blk_cleanup_queue(queue);
out_queue:
put_disk(disk);
out_info:
mutex_unlock(&tzmem_probe_mutex);
return ERR_PTR(-ENOMEM);
}
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;
}
