TZ_RESULT UREE_GetSecurememinfo (UREE_SESSION_HANDLE session, UREE_SECUREMEM_INFO *info)
{
MTEEC_PARAM p[4];
TZ_RESULT ret;
if ((info == NULL))
{
return TZ_RESULT_ERROR_BAD_PARAMETERS;
}
ret = UREE_TeeServiceCall(session, TZCMD_DBG_SECUREMEM_INFO,
TZ_ParamTypes2(TZPT_VALUE_OUTPUT, TZPT_VALUE_OUTPUT), p);
if (ret != TZ_RESULT_SUCCESS)
{
printf("[uree] UREE_GetSecurememinfo Error: %d\n", ret);
return ret;
}
info->used_byte = p[0].value.a;
info->max_free_cont_mem_sz = p[0].value.b;
info->total_byte = p[1].value.a;
info->max_foot_print = p[1].value.b;
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;
}
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;
}
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);
}
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));
}
}
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;
}
uint32_t TEECK_Icnt_Counter(KREE_SESSION_HANDLE session, uint32_t* a, uint32_t* b)
{
MTEEC_PARAM param[4];
uint32_t paramTypes;
TZ_RESULT ret;
paramTypes = TZ_ParamTypes2(TZPT_VALUE_OUTPUT, TZPT_VALUE_OUTPUT);
ret = KREE_TeeServiceCall(session, TZCMD_ICNT_COUNT,
paramTypes, param);
if (ret != TZ_RESULT_SUCCESS)
{
printk("ServiceCall error %d\n", ret);
}
*a = param[0].value.a;
*b = param[1].value.a;
return ret;
}
TZ_RESULT UREE_ReleaseSecurechunkmem (UREE_SESSION_HANDLE session, uint32_t size, uint32_t *released_size)
{
MTEEC_PARAM p[4];
TZ_RESULT ret;
if (session == 0)
{
return TZ_RESULT_ERROR_BAD_PARAMETERS;
}
p[0].value.a = size;
ret = UREE_TeeServiceCall(session, TZCMD_MEM_SECURECM_RELEASE, TZ_ParamTypes2(TZPT_VALUE_INPUT, TZPT_VALUE_OUTPUT), p);
if (ret != TZ_RESULT_SUCCESS)
{
#ifdef DBG_UREE_MEM
printf("[uree] UREE_ReleaseSecurechunkmem Error: %d\n", ret);
#endif
return ret;
}
*released_size = p[1].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;
}
