int ccci_init_security(void)
{
int ret = 0;
#ifdef ENABLE_MD_IMG_SECURITY_FEATURE
static int security_init; /* for multi-modem support */
if (security_init)
return ret;
security_init = 1;
ret = masp_boot_init();
if (ret != 0) {
CCCI_UTIL_ERR_MSG("masp_boot_init fail: %d\n", ret);
ret = -EIO;
}
if (sec_lib_version_check() != 0) {
CCCI_UTIL_ERR_MSG("sec lib version check error\n");
ret = -EIO;
}
CCCI_UTIL_INF_MSG("security is on!\n");
#else
CCCI_UTIL_INF_MSG("security is off!\n");
#endif
return ret;
}
int ccci_get_fo_setting(char item[], unsigned int *val)
{
char *ccci_name;
int ccci_value;
int i;
for (i=0; i<ARRAY_SIZE(ccci_fos_default_setting); i++) {
ccci_name = ccci_fos_default_setting[i].name;
ccci_value = ccci_fos_default_setting[i].value;
if(!strcmp(ccci_name, item)) {
CCCI_UTIL_ERR_MSG("FO:%s -> %08x\n", item, ccci_value);
*val = (unsigned int)ccci_value;
return 0;
}
}
CCCI_UTIL_ERR_MSG("FO:%s not found\n", item);
return -CCCI_ERR_INVALID_PARAM;
}
static int sec_lib_version_check(void)
{
int ret = 0;
int sec_lib_ver = masp_ccci_version_info();
if(sec_lib_ver != CURR_SEC_CCCI_SYNC_VER){
CCCI_UTIL_ERR_MSG("[Error]sec lib for ccci mismatch: sec_ver:%d, ccci_ver:%d\n", sec_lib_ver, CURR_SEC_CCCI_SYNC_VER);
ret = -1;
}
return ret;
}
//--- META arguments parse -------
static int ccci_parse_meta_md_setting(unsigned char args[])
{
unsigned char md_active_setting = args[1];
unsigned char md_setting_flag = args[0];
int active_id = -1;
if(md_active_setting & MD1_EN)
active_id = MD_SYS1;
else if(md_active_setting & MD2_EN)
active_id = MD_SYS2;
else if(md_active_setting & MD3_EN)
active_id = MD_SYS3;
else if(md_active_setting & MD5_EN)
active_id = MD_SYS5;
else
CCCI_UTIL_ERR_MSG("META MD setting not found [%d][%d]\n", args[0], args[1]);
switch(active_id)
{
case MD_SYS1:
case MD_SYS2:
case MD_SYS3:
case MD_SYS5:
if(md_setting_flag == MD_2G_FLAG) {
meta_md_support[active_id] = modem_2g;
} else if(md_setting_flag == MD_WG_FLAG) {
meta_md_support[active_id] = modem_wg;
} else if(md_setting_flag == MD_TG_FLAG) {
meta_md_support[active_id] = modem_tg;
} else if(md_setting_flag == MD_LWG_FLAG){
meta_md_support[active_id] = modem_lwg;
} else if(md_setting_flag == MD_LTG_FLAG){
meta_md_support[active_id] = modem_ltg;
} else if(md_setting_flag & MD_SGLTE_FLAG){
meta_md_support[active_id] = modem_sglte;
}
CCCI_UTIL_INF_MSG("META MD%d to type:%d\n", active_id+1, meta_md_support[active_id]);
break;
}
return 0;
}
static void get_md_postfix(int md_id, char k[], char buf[], char buf_ex[])
{
// name format: modem_X_YY_K_Ex.img
int X, Ex;
char YY_K[IMG_POSTFIX_LEN];
unsigned int feature_val = 0;
if ((md_id<0) || (md_id>MAX_MD_NUM)) {
CCCI_UTIL_ERR_MSG("wrong MD ID to get postfix %d\n", md_id);
return;
}
// X
X = md_id + 1;
// YY_
YY_K[0] = '\0';
//#ifndef Flyme_EDIT
//#[email protected] for load modem firmware by hardware info
feature_val = mz_get_operator_type();
CCCI_UTIL_INF_MSG("mz_get_operator_type = 0x%x\n",feature_val);
if (IS_LWG(feature_val)){
CCCI_UTIL_INF_MSG("modem type is china unicom\n");
feature_val = modem_lwg;
}else if (IS_LTG(feature_val)){
CCCI_UTIL_INF_MSG("modem type is china mobile\n");
feature_val = modem_ltg;
}else {
CCCI_UTIL_INF_MSG("modem type is public\n");
switch(md_id) {
case MD_SYS1:
feature_val = get_modem_support_cap(MD_SYS1);
break;
case MD_SYS2:
feature_val = get_modem_support_cap(MD_SYS2);
break;
case MD_SYS5:
feature_val = get_modem_support_cap(MD_SYS5);
break;
default:
CCCI_UTIL_ERR_MSG("request MD ID %d not supported\n", md_id);
break;
}
}
//#endif /*Flyme_EDIT*/
if((feature_val==0) || (feature_val>=MAX_IMG_NUM)) {
CCCI_UTIL_ERR_MSG("request MD type %d not supported\n", feature_val);
feature_val = md_type_invalid;
}
// K
if(k == NULL)
snprintf(YY_K, IMG_POSTFIX_LEN, "_%s_n", type_str[feature_val]);
else
snprintf(YY_K, IMG_POSTFIX_LEN, "_%s_%s", type_str[feature_val], k);
// [_Ex] Get chip version
#if 0
if(get_chip_version() == CHIP_SW_VER_01)
Ex = 1;
else if(get_chip_version() == CHIP_SW_VER_02)
Ex = 2;
#else
Ex = 1;
#endif
// Gen post fix
if(buf) {
snprintf(buf, IMG_POSTFIX_LEN, "%d%s", X, YY_K);
CCCI_UTIL_INF_MSG("MD%d image postfix=%s\n", md_id+1, buf);
}
if(buf_ex) {
snprintf(buf_ex, IMG_POSTFIX_LEN, "%d%s_E%d", X, YY_K, Ex);
CCCI_UTIL_INF_MSG("MD%d image postfix=%s\n", md_id+1, buf_ex);
}
}
static void v1_cal_md_mem_setting(void)
{
phys_addr_t *addr;
unsigned int md1_en, md2_en;
addr = md_resv_mem_list; // MD ROM start address should be 32M align as remap hardware limitation
if( (md_usage_case&(MD1_EN|MD2_EN))==(MD1_EN|MD2_EN)) { // Both two MD enabled
md1_en = 1;
md2_en = 1;
md_resv_mem_addr[MD_SYS1] = addr[0];
md_resv_mem_addr[MD_SYS2] = addr[1];
md_resv_smem_addr[MD_SYS1] = addr[0] + md_resv_mem_size[MD_SYS1];
md_resv_smem_addr[MD_SYS2] = addr[1] + md_resv_mem_size[MD_SYS2];
md_resv_smem_base = addr[0]; // attention, share memory's base is not where share memory actually starts, but the same as MD ROM, check ccci_set_mem_remap()
} else if( (md_usage_case&(MD1_EN|MD2_EN))==(MD1_EN)) { //Only MD1 enabled
md1_en = 1;
md2_en = 0;
md_resv_mem_addr[MD_SYS1] = addr[0];
md_resv_mem_addr[MD_SYS2] = 0;
md_resv_smem_addr[MD_SYS1] = addr[0] + md_resv_mem_size[MD_SYS1];
md_resv_smem_addr[MD_SYS2] = 0;
md_resv_smem_base = addr[0];
} else if( (md_usage_case&(MD1_EN|MD2_EN))==(MD2_EN)) { //Only MD2 enabled
md1_en = 0;
md2_en = 1;
md_resv_mem_addr[MD_SYS1] = 0;
md_resv_mem_addr[MD_SYS2] = addr[0];
md_resv_smem_addr[MD_SYS1] = 0;
md_resv_smem_addr[MD_SYS2] = addr[0] + md_resv_mem_size[MD_SYS2];
md_resv_smem_base = addr[0];
} else { // No MD is enabled
md1_en = 0;
md2_en = 0;
md_resv_mem_addr[MD_SYS1] = 0;
md_resv_mem_addr[MD_SYS2] = 0;
md_resv_smem_addr[MD_SYS1] = 0;
md_resv_smem_addr[MD_SYS2] = 0;
md_resv_smem_base = 0;
}
if (md1_en && ((md_resv_mem_addr[MD_SYS1]&(CCCI_MEM_ALIGN - 1)) != 0))
CCCI_UTIL_ERR_MSG("md1 memory addr is not 32M align!!!\n");
if (md2_en && ((md_resv_mem_addr[MD_SYS2]&(CCCI_MEM_ALIGN - 1)) != 0))
CCCI_UTIL_ERR_MSG("md2 memory addr is not 32M align!!!\n");
if (md1_en && ((md_resv_smem_addr[MD_SYS1]&(CCCI_SMEM_ALIGN_MD1 - 1)) != 0))
CCCI_UTIL_ERR_MSG("md1 share memory addr %pa is not %x align!!\n", &md_resv_smem_addr[MD_SYS1], CCCI_SMEM_ALIGN_MD1);
if (md2_en && ((md_resv_smem_addr[MD_SYS2]&(CCCI_SMEM_ALIGN_MD2 - 1)) != 0))
CCCI_UTIL_ERR_MSG("md2 share memory addr %pa is not %x align!!\n", &md_resv_smem_addr[MD_SYS2], CCCI_SMEM_ALIGN_MD2);
CCCI_UTIL_INF_MSG("MD1_EN(%d):MD2_EN(%d):MemBase(0x%pa)\n", md1_en, md2_en, &md_resv_smem_base);
CCCI_UTIL_INF_MSG("MemStart(0x%pa:0x%pa):MemSize(0x%08X:0x%08X)\n", \
&md_resv_mem_addr[MD_SYS1], &md_resv_mem_addr[MD_SYS2], \
md_resv_mem_size[MD_SYS1], md_resv_mem_size[MD_SYS2]);
CCCI_UTIL_INF_MSG("SmemStart(0x%pa:0x%pa):SmemSize(0x%08X:0x%08X)\n", \
&md_resv_smem_addr[MD_SYS1], &md_resv_smem_addr[MD_SYS2], \
md_resv_smem_size[MD_SYS1], md_resv_smem_size[MD_SYS2]);
}
static void collect_md_settings(void)
{
unsigned int tmp;
unsigned int md1_en = 0;
unsigned int md2_en = 0;
unsigned int md3_en = 0;
unsigned int md5_en = 0;
md_usage_case = 0;
printk("[ccci] collect_md_settings\n");
// MTK_ENABLE_MD*
if(ccci_get_fo_setting("MTK_ENABLE_MD1", &tmp) == 0) {
if(tmp > 0)
md1_en = 1;
}
if(ccci_get_fo_setting("MTK_ENABLE_MD2", &tmp) == 0) {
if(tmp > 0)
md2_en = 1;
}
if(ccci_get_fo_setting("MTK_ENABLE_MD3", &tmp) == 0) {
if(tmp > 0)
md3_en = 1;
}
if(ccci_get_fo_setting("MTK_ENABLE_MD5", &tmp) == 0) {
if(tmp > 0)
md5_en = 1;
}
// MTK_MD*_SUPPORT
if(ccci_get_fo_setting("MTK_MD1_SUPPORT", &tmp) == 0) {
md_support[MD_SYS1] = tmp;
}
if(ccci_get_fo_setting("MTK_MD2_SUPPORT", &tmp) == 0) {
md_support[MD_SYS2] = tmp;
}
if(ccci_get_fo_setting("MTK_MD3_SUPPORT", &tmp) == 0) {
md_support[MD_SYS3] = tmp;
}
if(ccci_get_fo_setting("MTK_MD5_SUPPORT", &tmp) == 0) {
md_support[MD_SYS5] = tmp;
}
// MD*_SIZE
/*
* for legacy CCCI: make share memory start address to be 2MB align, as share
* memory size is 2MB - requested by MD MPU.
* for ECCCI: ROM+RAM size will be align to 1M, and share memory is 2K,
* 1M alignment is also 2K alignment.
*/
if(ccci_get_fo_setting("MD1_SIZE", &tmp) == 0) {
tmp = round_up(tmp, get_md_smem_align(MD_SYS1));
md_resv_mem_size[MD_SYS1] = tmp;
}
if(ccci_get_fo_setting("MD2_SIZE", &tmp) == 0) {
tmp = round_up(tmp, get_md_smem_align(MD_SYS2));
md_resv_mem_size[MD_SYS2] = tmp;
}
if(ccci_get_fo_setting("MD3_SIZE", &tmp) == 0) {
tmp = round_up(tmp, get_md_smem_align(MD_SYS3));
md_resv_mem_size[MD_SYS3] = tmp;
}
// MD*_SMEM_SIZE
#if 0
if(ccci_get_fo_setting("MD1_SMEM_SIZE", &tmp) == 0) {
md_resv_smem_size[MD_SYS1] = tmp;
}
#else
md_resv_smem_size[MD_SYS1] = 2*1024*1024;
#endif
#if 0
if(ccci_get_fo_setting("MD2_SMEM_SIZE", &tmp) == 0) {
md_resv_smem_size[MD_SYS2] = tmp;
}
#else
md_resv_smem_size[MD_SYS2] = 4*1024*1024;
#endif
if(ccci_get_fo_setting("MD3_SMEM_SIZE", &tmp) == 0) {
md_resv_smem_size[MD_SYS3] = tmp;
}
// Setting conflict checking
if(md1_en && (md_resv_smem_size[MD_SYS1]>0) && (md_resv_mem_size[MD_SYS1]>0)) {
// Setting is OK
} else if (md1_en && ((md_resv_smem_size[MD_SYS1]<=0) || (md_resv_mem_size[MD_SYS1]<=0))) {
CCCI_UTIL_ERR_MSG("FO Setting for md1 wrong: <%d:0x%08X:0x%08X>\n",
md1_en, md_resv_mem_size[MD_SYS1], md_resv_smem_size[MD_SYS1]);
md1_en = 0;
md_resv_smem_size[MD_SYS1] = 0;
md_resv_mem_size[MD_SYS1] = 0;
}
if(md2_en && (md_resv_smem_size[MD_SYS2]>0) && (md_resv_mem_size[MD_SYS2]>0)) {
// Setting is OK
} else if (md2_en && ((md_resv_smem_size[MD_SYS2]<=0) || (md_resv_mem_size[MD_SYS2]<=0))) {
CCCI_UTIL_ERR_MSG("FO Setting for md2 wrong: <%d:0x%08X:0x%08X>\n",
md2_en, md_resv_mem_size[MD_SYS2], md_resv_smem_size[MD_SYS2]);
md2_en = 0;
md_resv_smem_size[MD_SYS2] = 0;
md_resv_mem_size[MD_SYS2] = 0;
}
if(md3_en && (md_resv_smem_size[MD_SYS3]>0) && (md_resv_mem_size[MD_SYS3]>0)) {
// Setting is OK
} else if (md3_en && ((md_resv_smem_size[MD_SYS3]<=0) || (md_resv_mem_size[MD_SYS3]<=0))) {
CCCI_UTIL_ERR_MSG("FO Setting for md3 wrong: <%d:0x%08X:0x%08X>\n",
md3_en, md_resv_mem_size[MD_SYS3], md_resv_smem_size[MD_SYS3]);
md3_en = 0;
md_resv_smem_size[MD_SYS2] = 0;
md_resv_mem_size[MD_SYS2] = 0;
}
if(md1_en) {
md_usage_case |= MD1_EN;
modem_num++;
}
if(md2_en) {
md_usage_case |= MD2_EN;
modem_num++;
}
if(md3_en) {
md_usage_case |= MD3_EN;
modem_num++;
}
if(md5_en) {
md_usage_case |= MD5_EN;
modem_num++;
}
memory_layout_cal(MEM_LAY_OUT_VER);
}
