int ali_ce_generate_single_level_key(pCE_DEVICE pCeDev, pCE_DATA_INFO pCe_data_info)
{
#if !defined(CONFIG_ALI_RPCNG)
__u32 desc[] =
{ //desc of pointer para
1, DESC_STATIC_STRU(0, sizeof(CE_DATA_INFO)),
1, DESC_P_PARA(0, 1, 0),
//desc of pointer ret
0,
0,
};
jump_to_func(NULL, ali_rpc_call, pCeDev, CE_NPARA(2)|FUNC_CE_GENERATE_SINGLE_LEVEL_KEY, desc);
#else
Param dev;
Param ce_info;
CE_DATA_INFO ce_data;
ali_ce_umemcpy(&ce_data, pCe_data_info, sizeof(ce_data));
RPC_PARAM_UPDATE(dev, PARAM_IN, PARAM_UINT32, sizeof(__u32), &pCeDev);
RPC_PARAM_UPDATE(ce_info, PARAM_IN, PARAM_Ce_data_info_rpc, sizeof(Ce_data_info_rpc), &ce_data);
return RpcCallCompletion(RPC_ce_generate_single_level_key,&dev,&ce_info,NULL);
#endif
}
int ali_ce_generate_cw_key(__u8 *in_cw_data,__u8 mode,
__u8 first_pos,__u8 second_pos)
{
#if !defined(CONFIG_ALI_RPCNG)
__u32 desc[] =
{ //desc of pointer para
1, DESC_STATIC_STRU(0, 16),
1, DESC_P_PARA(0, 0, 0),
//desc of pointer ret
0,
0,
};
jump_to_func(NULL, ali_rpc_call, in_cw_data, CE_NPARA(4)|FUNC_CE_GENERATE_CW_KEY, desc);
#else
Data_param_rpc data_param;
Param p1;
Param p2;
Param p3;
Param p4;
ali_ce_umemcpy(&data_param.crypt_data[0], in_cw_data, sizeof(data_param.crypt_data));
RPC_PARAM_UPDATE(p1, PARAM_IN, PARAM_Data_param_rpc, sizeof(Data_param_rpc), &data_param);
RPC_PARAM_UPDATE(p2, PARAM_IN, PARAM_UCHAR, sizeof(__u8), &mode);
RPC_PARAM_UPDATE(p3, PARAM_IN, PARAM_UCHAR, sizeof(__u8), &first_pos);
RPC_PARAM_UPDATE(p4, PARAM_IN, PARAM_UCHAR, sizeof(__u8), &second_pos);
return RpcCallCompletion(RPC_ce_generate_cw_key,&p1,&p2,&p3,&p4,NULL);
#endif
}
int ali_ce_key_load(pCE_DEVICE pCeDev, pOTP_PARAM pCe_opt_info)
{
#if !defined(CONFIG_ALI_RPCNG)
__u32 desc[] =
{ //desc of pointer para
1, DESC_STATIC_STRU(0, sizeof(OTP_PARAM)),
1, DESC_P_PARA(0, 1, 0),
//desc of pointer ret
0,
0,
};
jump_to_func(NULL, ali_rpc_call, pCeDev, CE_NPARA(2)|FUNC_CE_LOAD, desc);
#else
Param dev;
Param otp_info;
OTP_PARAM otp_data;
ali_ce_umemcpy(&otp_data, pCe_opt_info, sizeof(otp_data));
RPC_PARAM_UPDATE(dev, PARAM_IN, PARAM_UINT32, sizeof(__u32), &pCeDev);
RPC_PARAM_UPDATE(otp_info, PARAM_IN, PARAM_Otp_param_rpc, sizeof(Otp_param_rpc), &otp_data);
return RpcCallCompletion(RPC_ce_key_load,&dev,&otp_info,NULL);
#endif
}
RET_CODE ce_key_load(pCE_DEVICE pCeDev,pOTP_PARAM pCe_opt_info)
{
UINT32 desc[] =
{ //desc of pointer para
1, DESC_STATIC_STRU(0, sizeof(OTP_PARAM)),
1, DESC_P_PARA(0, 1, 0),
//desc of pointer ret
0,
0,
};
jump_to_func(NULL, OS_hld_caller, pCeDev, CE_NPARA(2)|FUNC_CE_LOAD, desc);
}
RET_CODE ce_key_generate(pCE_DEVICE pCeDev,pCE_DATA_INFO pCe_data_info)
{
UINT32 desc[] =
{ //desc of pointer para
1, DESC_STATIC_STRU(0, sizeof(CE_DATA_INFO)),
1, DESC_P_PARA(0, 1, 0),
//desc of pointer ret
0,
0,
};
jump_to_func(NULL, OS_hld_caller, pCeDev, CE_NPARA(2)|FUNC_CE_GENERATE, desc);
}
RET_CODE ce_generate_cw_key(const UINT8 *in_cw_data,UINT8 mode,UINT8 first_pos,UINT8 second_pos)
{
UINT32 desc[] =
{ //desc of pointer para
1, DESC_STATIC_STRU(0, 16),
1, DESC_P_PARA(0, 0, 0),
//desc of pointer ret
0,
0,
};
jump_to_func(NULL, OS_hld_caller, in_cw_data, CE_NPARA(4)|FUNC_CE_GENERATE_CW_KEY, desc);
}
RET_CODE ce_aes_key_generate_two_level(pCE_DEVICE pCeDev,pCE_DATA_INFO pCe_data_info_one,
pCE_DATA_INFO pCe_data_info_two)
{
UINT32 desc[] =
{ //desc of pointer para
2, DESC_STATIC_STRU(0, sizeof(CE_DATA_INFO)),DESC_STATIC_STRU(0, sizeof(CE_DATA_INFO)),
2, DESC_P_PARA(0, 1, 0),DESC_P_PARA(0, 2, 1),
//desc of pointer ret
0,
0,
};
jump_to_func(NULL, OS_hld_caller, pCeDev, CE_NPARA(3)|FUNC_CE_KEY_GENERATE_TWO_AES, desc);
}
void ali_m36_ce_see_uninit(void)
{
pCE_DEVICE pCeDev = ( pCE_DEVICE ) hld_dev_get_by_type ( NULL, HLD_DEV_TYPE_CE );
if(NULL != pCeDev)
{
ALI_CE_RPC_DEBUG("\nali_m36_ce_see_uninit jump to see ce_api_detach\n\n");
#if !defined(CONFIG_ALI_RPCNG)
jump_to_func(NULL, ali_rpc_call, NULL, CE_NPARA(0) | FUNC_CE_DETACH, NULL);
#else
RpcCallCompletion(RPC_ce_api_detach,NULL);
#endif
}
}
RET_CODE ce_close(pCE_DEVICE pCeDev)
{
jump_to_func(NULL, OS_hld_caller, pCeDev, CE_NPARA(1)|FUNC_CE_CLOSE, NULL);
}
RET_CODE ce_open(pCE_DEVICE pCeDev)
{
jump_to_func(NULL, OS_hld_caller, pCeDev, CE_NPARA(1)|FUNC_CE_OPEN, NULL);
}
RET_CODE ce_ioctl(pCE_DEVICE pCeDev,UINT32 cmd,UINT32 param)
{
UINT32 i;
UINT32 common_desc[sizeof(ce_io_control)];
UINT32 *desc = (UINT32 *)common_desc;
UINT32 *b = (UINT32 *)ce_io_control;
for(i = 0; i < sizeof(ce_io_control)/sizeof(UINT32); i++)
{
desc[i] = b[i];
}
switch (cmd)
{
case IO_OTP_ROOT_KEY_GET:
DESC_STATIC_STRU_SET_SIZE(common_desc, 0, sizeof(OTP_PARAM));
break;
case IO_CRYPT_DATA_INPUT:
DESC_STATIC_STRU_SET_SIZE(common_desc, 0, sizeof(DATA_PARAM));
break;
case IO_CRYPT_PARAM_SET:
DESC_STATIC_STRU_SET_SIZE(common_desc, 0, sizeof(DES_PARAM));
break;
case IO_CRYPT_SECOND_KEY_CONFIG:
DESC_STATIC_STRU_SET_SIZE(common_desc, 0, sizeof(CE_KEY_PARAM));
break;
case IO_SECOND_KEY_GENERATE:
desc = NULL ;
break;
case IO_CRYPT_DEBUG_GET_KEY:
DESC_OUTPUT_STRU_SET_SIZE(common_desc, 0, sizeof(CE_DEBUG_KEY_INFO));
break;
case IO_CRYPT_POS_IS_OCCUPY:
{
DESC_OUTPUT_STRU_SET_SIZE(common_desc, 0, sizeof(CE_POS_STS_PARAM));
}
break;
case IO_CRYPT_POS_SET_USED:
{
desc=NULL;
}
break;
case IO_CRYPT_POS_SET_IDLE:
{
desc=NULL;
}
break;
case IO_CRYPT_FOUND_FREE_POS:
{
DESC_OUTPUT_STRU_SET_SIZE(common_desc, 0, sizeof(CE_FOUND_FREE_POS_PARAM));
}
break;
case IO_DECRYPT_PVR_USER_KEY:
{
DESC_STATIC_STRU_SET_SIZE(common_desc, 0, sizeof(CE_PVR_KEY_PARAM));
}
break;
default:
SDBBP();
break;
}
jump_to_func(NULL, OS_hld_caller, pCeDev, CE_NPARA(3)|FUNC_CE_IOCTL, desc);
}
int ali_ce_ioctl(CE_DEVICE *pCeDev,__u32 cmd,__u32 param)
{
#if !defined(CONFIG_ALI_RPCNG)
__u32 i;
__u32 common_desc[sizeof(ce_io_control)];
__u32 *desc = (__u32 *)common_desc;
__u32 *b = (__u32 *)ce_io_control;
for(i = 0; i < sizeof(ce_io_control)/sizeof(__u32); i++)
{
desc[i] = b[i];
}
switch (CE_IO_CMD(cmd))
{
case CE_IO_CMD(IO_OTP_ROOT_KEY_GET):
DESC_STATIC_STRU_SET_SIZE(common_desc, 0, sizeof(OTP_PARAM));
break;
case CE_IO_CMD(IO_CRYPT_DEBUG_GET_KEY):
DESC_OUTPUT_STRU_SET_SIZE(common_desc, 0, sizeof(CE_DEBUG_KEY_INFO));
break;
case CE_IO_CMD(IO_CRYPT_POS_IS_OCCUPY):
DESC_OUTPUT_STRU_SET_SIZE(common_desc, 0, sizeof(CE_POS_STS_PARAM));
break;
case CE_IO_CMD(IO_CRYPT_POS_SET_USED):
desc=NULL;
break;
case CE_IO_CMD(IO_CRYPT_POS_SET_IDLE):
desc=NULL;
break;
case CE_IO_CMD(IO_CRYPT_FOUND_FREE_POS):
DESC_OUTPUT_STRU_SET_SIZE(common_desc, 0, \
sizeof(CE_FOUND_FREE_POS_PARAM));
break;
case CE_IO_CMD(IO_DECRYPT_PVR_USER_KEY):
DESC_STATIC_STRU_SET_SIZE(common_desc, 0, sizeof(CE_PVR_KEY_PARAM));
break;
default:
{
ALI_CE_RPC_DEBUG("CE rpc Error:invalid cmd\n");
break;
}
}
jump_to_func(NULL, ali_rpc_call, pCeDev, CE_NPARA(3)|FUNC_CE_IOCTL, desc);
#else
RET_CODE ret = RET_FAILURE;
union
{
OTP_PARAM otp;
CE_PVR_KEY_PARAM ce_pvr_key;
CE_FOUND_FREE_POS_PARAM kpos_param;
CE_DEBUG_KEY_INFO kdebug_param;
CE_POS_STS_PARAM ksts_param;
}tmp;
Param p1;
Param p2;
Param p3;
RPC_PARAM_UPDATE(p1, PARAM_IN, PARAM_UINT32, sizeof(long), (void *)&pCeDev);
RPC_PARAM_UPDATE(p2, PARAM_IN, PARAM_UINT32, sizeof(long), (void *)&cmd);
RPC_PARAM_UPDATE(p3, PARAM_IN, PARAM_UINT32, sizeof(long), (void *)¶m);
switch (CE_IO_CMD(cmd))
{
case CE_IO_CMD(IO_OTP_ROOT_KEY_GET):
ali_ce_umemcpy(&tmp, (void *)param, sizeof(tmp.otp));
RPC_PARAM_UPDATE(p3, PARAM_IN, PARAM_Otp_param_rpc, \
sizeof(Otp_param_rpc), (void *)&tmp);
break;
case CE_IO_CMD(IO_CRYPT_DEBUG_GET_KEY):
ali_ce_umemcpy(&tmp, (void *)param, sizeof(tmp.kdebug_param));
RPC_PARAM_UPDATE(p3, PARAM_INOUT, PARAM_Ce_debug_key_info_rpc, \
sizeof(Ce_debug_key_info_rpc), (void *)&tmp);
break;
case CE_IO_CMD(IO_CRYPT_POS_IS_OCCUPY):
ali_ce_umemcpy(&tmp, (void *)param, sizeof(tmp.ksts_param));
RPC_PARAM_UPDATE(p3, PARAM_INOUT, PARAM_Ce_pos_status_param_rpc, \
sizeof(Ce_pos_status_param_rpc), (void *)&tmp);
break;
case CE_IO_CMD(IO_CRYPT_POS_SET_USED):
break;
case CE_IO_CMD(IO_CRYPT_POS_SET_IDLE):
break;
case CE_IO_CMD(IO_CRYPT_FOUND_FREE_POS):
RPC_PARAM_UPDATE(p3, PARAM_INOUT, PARAM_Ce_found_free_pos_param_rpc, \
sizeof(Ce_found_free_pos_param_rpc), (void *)param);
break;
case CE_IO_CMD(IO_DECRYPT_PVR_USER_KEY):
ali_ce_umemcpy(&tmp, (void *)param, sizeof(tmp.ce_pvr_key));
RPC_PARAM_UPDATE(p3, PARAM_IN, PARAM_Ce_pvr_key_param_rpc,
sizeof(Ce_pvr_key_param_rpc), (void *)&tmp);
break;
default:
{
ALI_CE_RPC_DEBUG("CE rpc Error: invalid cmd=0x%x\n",cmd);
break;
}
}
ret = RpcCallCompletion(RPC_ce_ioctl,&p1,&p2,&p3,NULL);
if(CE_IO_CMD(IO_CRYPT_DEBUG_GET_KEY) == CE_IO_CMD(cmd))
{
ali_ce_umemcpy((void *)param, &tmp, sizeof(tmp.kdebug_param));
}
if(CE_IO_CMD(IO_CRYPT_POS_IS_OCCUPY) == CE_IO_CMD(cmd))
{
ali_ce_umemcpy((void *)param, &tmp, sizeof(tmp.ksts_param));
}
return ret;
#endif
}
