// 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;
}
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 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;
}
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;
}
TZ_RESULT kree_register_sharedmem (KREE_SESSION_HANDLE session, KREE_SHAREDMEM_HANDLE *mem_handle,
void *start, uint32_t size, void *map_p)
{
MTEEC_PARAM p[4];
TZ_RESULT ret;
p[0].value.a = (unsigned long)start;
p[0].value.b = (unsigned long long)(unsigned long)start >> 32;
p[1].value.a = size;
p[2].mem.buffer = map_p;
if(map_p != NULL)
p[2].mem.size = ((*(uint32_t *)map_p)+1)*sizeof(uint32_t);
else
p[2].mem.size = 0;
ret = KREE_TeeServiceCall(session, TZCMD_MEM_SHAREDMEM_REG,
TZ_ParamTypes4(TZPT_VALUE_INPUT, TZPT_VALUE_INPUT, TZPT_MEM_INPUT, TZPT_VALUE_OUTPUT), p);
if (ret != TZ_RESULT_SUCCESS)
{
*mem_handle = 0;
return ret;
}
*mem_handle = p[3].value.a;
return TZ_RESULT_SUCCESS;
}
void kree_fiq_eoi(unsigned int iar)
{
MTEEC_PARAM param[4];
param[0].value.a = iar;
KREE_TeeServiceCall(irq_session, TZCMD_IRQ_EOI,
TZ_ParamTypes1(TZPT_VALUE_INPUT), param);
}
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);
}
unsigned int kree_fiq_get_intack(void)
{
MTEEC_PARAM param[4];
TZ_RESULT ret;
ret = KREE_TeeServiceCall(irq_session, TZCMD_IRQ_GET_INTACK,
TZ_ParamTypes1(TZPT_VALUE_OUTPUT), param);
if (ret == TZ_RESULT_SUCCESS)
return param[0].value.a;
return 0xffff;
}
/*************************************************************
* REE Service
*************************************************************/
static irqreturn_t KREE_IrqHandler(int irq, void *dev)
{
uint32_t paramTypes;
MTEEC_PARAM param[4];
TZ_RESULT ret;
param[0].value.a = (uint32_t)irq;
paramTypes = TZ_ParamTypes1(TZPT_VALUE_INPUT);
ret = KREE_TeeServiceCall((KREE_SESSION_HANDLE)MTEE_SESSION_HANDLE_SYSTEM,
TZCMD_SYS_IRQ,
paramTypes, param);
return (ret == TZ_RESULT_SUCCESS) ? IRQ_HANDLED : IRQ_NONE;
}
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;
}
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));
}
}
TZ_RESULT kree_unregister_sharedmem (KREE_SESSION_HANDLE session, KREE_SHAREDMEM_HANDLE mem_handle)
{
MTEEC_PARAM p[4];
TZ_RESULT ret;
p[0].value.a = (uint32_t) mem_handle;
ret = KREE_TeeServiceCall(session, TZCMD_MEM_SHAREDMEM_UNREG,
TZ_ParamTypes1(TZPT_VALUE_INPUT), p);
if (ret != TZ_RESULT_SUCCESS)
{
return ret;
}
return TZ_RESULT_SUCCESS;
}
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));
}
}
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));
}
}
uint32_t TEECK_Icnt_Rate(KREE_SESSION_HANDLE session, uint32_t* a)
{
MTEEC_PARAM param[4];
uint32_t paramTypes;
TZ_RESULT ret;
paramTypes = TZ_ParamTypes1(TZPT_VALUE_OUTPUT);
ret = KREE_TeeServiceCall(session, TZCMD_ICNT_RATE,
paramTypes, param);
if (ret != TZ_RESULT_SUCCESS)
{
printk("ServiceCall error %d\n", ret);
}
*a = param[0].value.a;
return 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 KREE_GetTEETotalSize (KREE_SESSION_HANDLE session, uint32_t *size)
{
MTEEC_PARAM p[4];
TZ_RESULT ret;
ret = KREE_TeeServiceCall(session, TZCMD_MEM_TOTAL_SIZE, TZ_ParamTypes1(TZPT_VALUE_OUTPUT), p);
if (ret != TZ_RESULT_SUCCESS)
{
#ifdef DBG_KREE_MEM
printk("[kree] KREE_GetTEETotalSize Error: %d\n", ret);
#endif
return ret;
}
*size = p[0].value.a;
return TZ_RESULT_SUCCESS;
}
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;
}
