/* *get file info in back ,default,nvdload */ u32 nv_sec_file_info_init(const s8* name,struct nv_file_info_stru* sec_info) { u32 ret = NV_ERROR; u32 file_len = 0; struct nv_file_info_stru info; struct nv_ctrl_file_info_stru ctrl_info; u8* file_info; /*first: read nv ctrl file*/ ret = (u32)bsp_nand_read((char*)name,0,&ctrl_info,sizeof(ctrl_info),NULL); if(NAND_OK != ret) { printf("[%s]:patrition name %s,get file magic fail ret 0x%x,\n",__func__,name,ret); return ret; } /*second :check magic num in file head*/ if(ctrl_info.magicnum != NV_CTRL_FILE_MAGIC_NUM) { printf("[%s]:enter this way 1111! %s\n",__func__,name); return NV_OK; } /*third: read all nv ctrl file*/ file_info = (u8*)nv_malloc(ctrl_info.file_size+1); if(NULL == file_info) { printf("[%s]:enter this way 2222! %s\n",__func__,name); return BSP_ERR_NV_MALLOC_FAIL; } ret = (u32)bsp_nand_read((char*)name,sizeof(struct nv_ctrl_file_info_stru),file_info,ctrl_info.file_size,NULL); if(NAND_OK != ret) { printf("[%s]:enter this way 3333! %s\n",__func__,name); goto init_end; } /*fourth: count nv file len base the ctrl file info*/ ret = nv_get_bin_crc_file_len(&ctrl_info,(struct nv_file_list_info_stru*)file_info,&file_len); if(ret) { printf("[%s]:enter this way 4444! %s\n",__func__,name); goto init_end; } info.len = file_len; info.magic_num = NV_FILE_EXIST; info.off = 0; memcpy(sec_info,&info,sizeof(info)); init_end: nv_free(file_info); return NV_OK; }
bool get_sc_file_back_state(void) { struct sc_file_packet_info_struct sc_file; int ret; int i; /*标志文件存在返回false*/ if(!BSP_access((char*)SC_FILE_BACKUP_FLAG,0)){ printk("%s is exist!\n",SC_FILE_BACKUP_FLAG); return false; } ret = bsp_nand_read((char*)SC_BACKUP_SEC_NAME,SC_BACKUP_SEC_OFFSET,&sc_file,sizeof(sc_file),NULL); if(ret){ printk("%s bsp_nand_read err ret :0x%x!\n",__func__,ret); return false; } if(sc_file.magic_num != SC_FILE_PACKET_MAGIC){ printk(" %s magic num is invalid!\n",__func__); return false; } for(i= 0;i<SC_FILE_NUM;i++) { if(sc_file.file_info[i].magic_num != SC_FILE_EXIST_MAGIC){ printk("%d file is not exist !\n",i); return false; } } return true; }
s32 nv_modify_upgrade_flag(bool flag) { struct nv_dload_packet_head_stru nv_dload; s32 ret; u32 old_magic; u32 new_magic; ret = bsp_nand_read((char*)NV_DLOAD_SEC_NAME,0,&nv_dload,sizeof(nv_dload),NULL); if(ret) { return ret; } /*lint -save -e731*/ if(true == flag) { old_magic = NV_DLOAD_INVALID_FLAG; new_magic = NV_FILE_EXIST; } else { new_magic = NV_DLOAD_INVALID_FLAG; old_magic = NV_FILE_EXIST; } /*lint -restore*/ nv_dload.nv_bin.magic_num = (nv_dload.nv_bin.magic_num == old_magic) ? new_magic : nv_dload.nv_bin.magic_num; ret = bsp_nand_write((char*)NV_DLOAD_SEC_NAME,0,&nv_dload,sizeof(nv_dload)); if(ret) { return ret; } return 0; }
/*lint -save -e813*/ int sc_file_restore(void) { int i; int ret; struct sc_file_packet_info_struct sc_file; if(false == get_sc_file_back_state()){ return -1; } ret = bsp_nand_read((char*)SC_BACKUP_SEC_NAME,SC_BACKUP_SEC_OFFSET,&sc_file,sizeof(sc_file),NULL); if(ret){ printk("%s bsp_nand_read err ret :0x%x!\n",__func__,ret); return ret; } for(i=0;i<SC_FILE_NUM;i++) { ret = sc_file_restore_from_factory(&sc_file.file_info[i]); if(ret){ return ret; } } return 0; }
int his_modem_load_vxworks(char *part_name) { int ret = 0; int offset = 0; int skip_len = 0; u32 image_total_length = 0; void *image_load_addr = 0; struct image_head head; hi_trace(HI_INFO, ">>loading:%s.....\r\n", part_name); ret = bsp_nand_read(part_name, (FSZ)0, &head, sizeof(struct image_head) , &skip_len); if (NAND_OK != ret) { hi_trace(HI_ERR, "fail to read vxworks image head, error code 0x%x\r\n", ret); return NAND_ERROR; } if (memcmp(head.image_name, CCORE_IMAGE_NAME, sizeof(CCORE_IMAGE_NAME))) { hi_trace(HI_ERR, "vxworks image error!!.\r\n"); return NAND_ERROR; } offset += sizeof(struct image_head) + skip_len; image_total_length = (u32)head.image_length; image_load_addr = (void*)g_ccore_entry; ret = bsp_nand_read(part_name, offset, image_load_addr, image_total_length, &skip_len); if(NAND_OK != ret) { hi_trace(HI_ERR, "fail to read vxworks image, error code 0x%x\r\n", ret); goto exit; } hi_trace(HI_INFO, ">>load vxworks ok, entey %#x, length %#x\r\n", head.load_addr, head.image_length); exit: return ret; }
/************************************************************************************************ * * Function: load_modem_dsp_to_secos * Description: read modem_dsp of specified image from emmc to sec os * Calls: * load_data_to_secos * bsp_nand_read * * Data Accessed: session * Data Updated: * * Parameters: * * Return: * @u32 * SEC_OK: success * SEC_ERROR: failure * *************************************************************************************************/ static s32 load_modem_dsp_to_secos(TEEC_Session *session) { u32 skip_len = 0; u32 offset = 0; /* coverity[var_decl] */ struct image_head head; s32 ret = SEC_ERROR; /* clean ok flag */ writel(0, (void*)SHM_MEM_DSP_FLAG_ADDR); ret = bsp_nand_read(PTN_MODEM_DSP_NAME, (FSZ)0, &head, sizeof(struct image_head), &skip_len); if (NAND_OK != ret) { sec_print_err("fail to read modem dsp image head, error code 0x%x\r\n", ret); return SEC_ERROR; } /* coverity[uninit_use_in_call] */ if (memcmp(head.image_name, DSP_IMAGE_NAME, sizeof(DSP_IMAGE_NAME))) { sec_print_err("DSP image error!!.\r\n"); return SEC_ERROR; } trans_data.image_length = DDR_TLPHY_IMAGE_SIZE; trans_data.image_addr = DDR_TLPHY_IMAGE_ADDR; offset += LPHY_BBE16_MUTI_IMAGE_OFFSET + sizeof(struct image_head) + skip_len; ret = load_data_to_secos(session, PTN_MODEM_DSP_NAME, offset, trans_data.image_length, &skip_len); if(SEC_ERROR == ret) { sec_print_err("load dsp fail!\n"); return ret; } trans_data.image_length = MODEM_TDS_SIZE; trans_data.image_addr = DDR_LPHY_SDR_ADDR + MODEM_DSP_SIZE + MODEM_TDS_SIZE; offset += LPHY_BBE16_MUTI_IMAGE_SIZE + skip_len; ret = load_data_to_secos(session, PTN_MODEM_DSP_NAME, offset, trans_data.image_length, &skip_len); if(SEC_ERROR == ret) { sec_print_err("load TDS fail!\n"); return ret; } /* set the ok flag of dsp image */ writel(DSP_IMAGE_STATE_OK, (void*)SHM_MEM_DSP_FLAG_ADDR); return SEC_OK; }
/************************************************************************************************ * * Function: load_VRL_to_secos * Description: read vrl of specified image from emmc * Calls: * bsp_trans_to_os * bsp_nand_read * * Data Accessed: No * Data Updated: * * Parameters: * * Return: * @u32 * SEC_OK: success * SEC_ERROR: failure * *************************************************************************************************/ static s32 load_VRL_to_secos(TEEC_Session *session) { unsigned read_bytes; s32 ret; read_bytes = SECBOOT_VRL_SIZE; ret = bsp_nand_read(PTN_VRL_P_NAME, SECBOOT_MODEM_VRL_OFFSET * SECBOOT_VRL_SIZE, (void *)g_vrl_P, read_bytes, NULL); if (NAND_OK != ret) { sec_print_err("%s: can't make ptn for vrl!\n", __func__); return SEC_ERROR; } ret = bsp_nand_read(PTN_VRL_M_NAME, SECBOOT_MODEM_VRL_OFFSET * SECBOOT_VRL_SIZE, (void *)g_vrl_M, read_bytes, NULL); if (NAND_OK != ret) { sec_print_err("%s: can't make ptn for vrl_backup!\n", __func__); return SEC_ERROR; } /* compare the data read from vrl and vrl_back, if not equ, we restore primary vrl to backup vrl */ if (memcmp((void *)g_vrl_P, (void *)g_vrl_M, SECBOOT_VRL_SIZE)) { sec_print_err("%s: memcmp data error!\n", __func__); return SEC_ERROR; } /* trans the vrl to secure os. */ ret = bsp_trans_to_os(session,SECBOOT_CMD_ID_COPY_VRL,(void *)g_vrl_P,0,SECBOOT_VRL_SIZE); if (SEC_ERROR == ret) { sec_print_err("modem image trans to os is failed, error code 0x%x\r\n", ret); return SEC_ERROR; } return SEC_OK; }
static s32 load_modem_head(void) { u32 skip_len = 0; u32 g_ccore_entry = 0; u32 image_load_addr = 0; /* coverity[var_decl] */ struct image_head head; s32 ret = SEC_ERROR; ret = bsp_nand_read(PTN_MODEM_NAME, (FSZ)0, &head, sizeof(struct image_head) , &skip_len); if (NAND_OK != ret) { sec_print_err("fail to read modem image head, error code 0x%x\r\n", ret); return SEC_ERROR; } /* coverity[uninit_use_in_call] */ if (memcmp(head.image_name, CCORE_IMAGE_NAME, sizeof(CCORE_IMAGE_NAME))) { sec_print_err("vxworks image error!!.\r\n"); return SEC_ERROR; } /* coverity[uninit_use] */ g_ccore_entry = head.load_addr; /* coverity[uninit_use] */ trans_data.image_length = (u32)head.image_length + 2*IDIO_LEN + OEM_CA_LEN + sizeof(struct image_head); /* coverity[uninit_use] */ if (head.is_compressed) { image_load_addr = g_ccore_entry - (MCORE_TEXT_START_ADDR - DDR_MCORE_ADDR) + DDR_MCORE_SIZE - trans_data.image_length; } else { image_load_addr = g_ccore_entry; } if(trans_data.image_length % 64) { trans_data.image_length = trans_data.image_length + (64 - trans_data.image_length % 64); } trans_data.image_addr = image_load_addr - sizeof(struct image_head); return SEC_OK; }
/* * 读nand接口 * mtd : mtd device * off : loggic offset in this file,need * len : data len write to flash ,len <= mtd->erasesize * ptr : the data need to write */ u32 nv_mtd_read(struct nv_emmc_file_header_stru* fd,FSZ off,u32 len,u8* ptr) { u32 ret; u32 offset = 0; /*传进来的偏移相对于文件头的逻辑偏移*/ struct mtd_info* mtd = fd->mtd; ret = nv_sec_off_count(fd,off,&offset); if(ret != NAND_OK) { return ret; } ret = (u32)bsp_nand_read((char*)mtd->name,offset,ptr,len,NULL); return ret; }
u32 nv_dload_file_info_init(void) { u32 ret = NV_ERROR; struct nv_dload_packet_head_stru nv_dload; /*first read file packet head*/ ret = (u32)bsp_nand_read((char*)NV_DLOAD_SEC_NAME,0,&nv_dload,sizeof(nv_dload),NULL); if(ret) { printf("[%s]:ret 0x%x,\n",__func__,ret); return ret; } memcpy(&g_emmc_info.nv_dload,&nv_dload,sizeof(nv_dload)); return NV_OK; }
/*获取升级包数据有效性 *true :有效 false: 无效 */ bool nv_get_upgrade_flag(void) { struct nv_dload_packet_head_stru nv_dload; s32 ret; ret = bsp_nand_read((char*)NV_DLOAD_SEC_NAME,0,&nv_dload,sizeof(nv_dload),NULL); if(ret) { return false; } if(nv_dload.nv_bin.magic_num == NV_FILE_EXIST) { return true; } return false; }
int sc_file_restore_from_factory(struct sc_file_info* file_info) { int ret; void* fp = NULL; void* buf = NULL; unsigned int off = SC_BACKUP_SEC_OFFSET +(unsigned int)file_info->off; buf = (void*)kmalloc((unsigned int)(file_info->len),GFP_KERNEL); if(!buf) return 1; ret = bsp_nand_read((char*)SC_BACKUP_SEC_NAME,off,buf,(unsigned int)(file_info->len),NULL); if(ret){ printk("%s : off = 0x%x,len = 0x%x\n",__func__,off,file_info->len); kfree(buf); return 2; } fp = BSP_fopen(file_info->path,"wb+"); if(!fp){ printk("open %s fail !\n",file_info->path); kfree(buf); return 3; } ret = BSP_fwrite(buf,1,(unsigned int)(file_info->len),fp); kfree(buf); BSP_fclose(fp); if(ret != file_info->len){ printk("write %s fail,ret :0x%x,len :0x%x\n",__func__,ret,file_info->len); BSP_remove(file_info->path); return 4; } return 0; }
u32 nv_dload_file_info_init(void) { u32 ret = NV_ERROR; struct nv_dload_packet_head_stru nv_dload; u32 total_len; u32 i = 0; g_sec_info.nv_dload[0] = 0; /*first read file packet head*/ ret = (u32)bsp_nand_read((char*)NV_DLOAD_SEC_NAME,0,&nv_dload,sizeof(nv_dload),NULL); if(ret) { printf("[%s]:ret 0x%x,\n",__func__,ret); return ret; } /*second count file total len*/ total_len = sizeof(nv_dload); total_len += ((nv_dload.nv_bin.magic_num == NV_FILE_EXIST)?nv_dload.nv_bin.len:0); for(i=0;i<2;i++)/*双卡双待有双份xml数据*/ { /* coverity[uninit_use] */ total_len += ((nv_dload.xnv_xml[i].magic_num == NV_FILE_EXIST)?nv_dload.xnv_xml[i].len:0); /* coverity[uninit_use] */ total_len += ((nv_dload.cust_xml[i].magic_num == NV_FILE_EXIST)?nv_dload.cust_xml[i].len:0); /* coverity[uninit_use] */ total_len += ((nv_dload.xnv_map[i].magic_num == NV_FILE_EXIST)?nv_dload.xnv_map[i].len:0); } ret = nv_count_file_sec_info((const s8*)NV_DLOAD_SEC_NAME,total_len,g_sec_info.nv_dload); if(ret) { printf("[%s] ret : 0x%x\n",__func__,ret); return NV_ERROR; } memcpy(&g_flash_info.nv_dload,&nv_dload,sizeof(nv_dload)); return NV_OK; }
int his_modem_load_vxworks(char *part_name) { int ret = 0; int offset = 0; int skip_len = 0; u32 image_total_length = 0; void *image_load_addr = 0; decompress_fn inflate_fn = NULL; struct image_head head; hi_trace(HI_INFO, ">>loading:%s.....\r\n", part_name); ret = bsp_nand_read(part_name, (FSZ)0, &head, sizeof(struct image_head) , &skip_len); if (NAND_OK != ret) { hi_trace(HI_ERR, "fail to read vxworks image head, error code 0x%x\r\n", ret); return NAND_ERROR; } /*coverity[uninit_use_in_call] */ if (memcmp(head.image_name, CCORE_IMAGE_NAME, sizeof(CCORE_IMAGE_NAME))) { hi_trace(HI_ERR, "vxworks image error!!.\r\n"); return NAND_ERROR; } /*coverity[uninit_use] */ if (head.image_length + 2*IDIO_LEN + OEM_CA_LEN > PRODUCT_CFG_FLASH_CCORE_LEN) { hi_trace(HI_ERR, "loadsize is incorrect, 0x%x!\r\n", head.image_length + 2*IDIO_LEN + OEM_CA_LEN); return NAND_ERROR; } /*coverity[uninit_use_in_call] */ g_ccore_entry = (u32)ioremap_cached(head.load_addr, DDR_MCORE_SIZE - (MCORE_TEXT_START_ADDR - DDR_MCORE_ADDR)); if(!g_ccore_entry) { hi_trace(HI_ERR, "ioremap failed.\r\n"); return NAND_ERROR; } offset += sizeof(struct image_head) + skip_len; image_total_length = (u32)head.image_length + 2*IDIO_LEN + OEM_CA_LEN; /*coverity[uninit_use] */ if (head.is_compressed) { image_load_addr = (void*)g_ccore_entry - (MCORE_TEXT_START_ADDR - DDR_MCORE_ADDR) + DDR_MCORE_SIZE - image_total_length; } else { image_load_addr = (void*)g_ccore_entry; } ret = bsp_nand_read(part_name, offset, image_load_addr, image_total_length, &skip_len); if(NAND_OK != ret) { hi_trace(HI_ERR, "fail to read vxworks image, error code 0x%x\r\n", ret); goto exit; } ret = bsp_sec_check((u32)image_load_addr, head.image_length); if (ret) { hi_trace(HI_ERR, "fail to check vxworks image, error code 0x%x\r\n", ret); goto exit; } if (head.is_compressed) { hi_trace(HI_INFO, ">>start to decompress vxworks image ...\r\n"); inflate_fn = decompress_method((const unsigned char *)image_load_addr, 2, NULL); if (inflate_fn) { ret = inflate_fn((unsigned char*)image_load_addr, head.image_length, NULL, NULL, (unsigned char*)g_ccore_entry, NULL, (void(*)(char*))printk); if (ret) { hi_trace(HI_ERR, "fail to decompress vxworks image, error code 0x%x\r\n", ret); goto exit; } } else { hi_trace(HI_ERR, "fail to get decompress method\r\n"); goto exit; } } /* flush cache */ __dma_single_cpu_to_dev_noverify((const void *)g_ccore_entry, DDR_MCORE_SIZE - (MCORE_TEXT_START_ADDR - DDR_MCORE_ADDR), CACHE_DMA_TO_DEVICE); hi_trace(HI_INFO, ">>load vxworks ok, entey %#x, length %#x\r\n", head.load_addr, head.image_length); exit: iounmap((void volatile *)g_ccore_entry); return ret; }
/* * Function : sc_restore * Discription: c core nv init,this phase build upon the a core kernel init, * this phase after icc init,this phase ensure to use all nv api normal * start at this phase ,ops global ddr need spinlock * Parameter : none * Output : result * History : */ s32 sc_restore(s8 *pdata, u32 len) { s32 sc_fp = 0; s32 rlen = 0; s32 wlen = 0; u32 sc_mtd_len = 0; struct mtd_info* mtd; mtd = get_mtd_device_nm((char*)SC_BACKUP_SEC_NAME); if (IS_ERR(mtd)) { sc_error_printf("get mtd device err! %s\n",mtd); return BSP_ERR_READ_MTD_FAIL; } sc_mtd_len = mtd->size; put_mtd_device(mtd); if((sc_mtd_len < SC_MTD_PTABLE_OFFSET) || (len >= SC_MTD_PTABLE_OFFSET)) { sc_error_printf("mtd length err! size 0x%x\n",mtd->size); return BSP_ERR_READ_LGTH_FAIL; } rlen = bsp_nand_read((char*)SC_BACKUP_SEC_NAME, (sc_mtd_len - SC_MTD_PTABLE_OFFSET), pdata, len, NULL); if(rlen != BSP_OK) { sc_error_printf("mtd length err! read_ret 0x%x, len is 0x%x\n",rlen,len); return BSP_ERR_SC_READ_FILE_FAIL; } else { sc_debug_printf("mtd length read ok len is 0x%x\n",rlen); } /* write to file */ sc_fp = bsp_open((char*)SC_PACKET_TRANS_FILE,(RFILE_CREAT|RFILE_RDWR),0660); if(!sc_fp) { sc_error_printf("bsp_open error, chanid :0x%x sc_fp :0x%x\n",SC_ICC_CHAN_ID,sc_fp); return BSP_ERR_SC_NO_FILE; } else { sc_debug_printf("bsp_open ok, file is 0x%x!\n",sc_fp); } /* write to file */ wlen = bsp_write(sc_fp, pdata, len); if(wlen != len) { sc_error_printf("bsp_write error, chanid :0x%x wlen :0x%x, len : 0x%x\n",SC_ICC_CHAN_ID,wlen,len); bsp_close(sc_fp); return BSP_ERR_SC_WRITE_FILE_FAIL; } else { sc_debug_printf("bsp_write ok,wlen is 0x%x",wlen); } bsp_close(sc_fp); return SC_OK; }
void show_flash_info(void) { struct nv_dload_packet_head_stru nv_dload; struct nv_ctrl_file_info_stru ctrl_info; u8* file_info; s32 ret = -1 ; u32 i = 0; printf("\n******************sys info*********************\n"); printf("\n************sys nv info in mem**************\n"); ret = bsp_nand_read((char*)NV_DLOAD_SEC_NAME,0,&ctrl_info,sizeof(ctrl_info),NULL); if(ret) return; /* coverity[uninit_use] */ if(ctrl_info.magicnum != NV_CTRL_FILE_MAGIC_NUM) { ctrl_info.file_size = 144; } /* coverity[uninit_use] */ file_info = (u8*)nv_malloc(ctrl_info.file_size+1); if(NULL == file_info) { return; } ret = bsp_nand_read((char*)NV_DLOAD_SEC_NAME,sizeof(ctrl_info),file_info,ctrl_info.file_size,NULL); if(ret){ nv_free(file_info); return; } printf("\n********sys mem info*******\n"); printf("nv :flag 0x%x,off 0x%x,len 0x%x\n",g_flash_info.sys_nv.magic_num,\ g_flash_info.sys_nv.off,g_flash_info.sys_nv.len); printf("\n************sys info in nand**************\n"); /* coverity[uninit_use_in_call] */ printf("magic :0x%x,file num: %d,nv num :0x%x,modem num :%d\n",\ ctrl_info.magicnum,ctrl_info.file_num,ctrl_info.ref_count,ctrl_info.modem_num); for(i= 0;i<NV_BIN_FILE_BLOCK_NUM;i++) printf("nv img file %d block off :0x%x\n",i,g_sec_info.sys_nv[i]); printf("\n******************dload info*******************\n"); ret = bsp_nand_read((char*)NV_DLOAD_SEC_NAME,0,&nv_dload,sizeof(nv_dload),NULL); if(ret){ nv_free(file_info); return; } printf("\n********dload mem info*******\n"); printf("nv : flag 0x%x,len 0x%x,off 0x%x\n",g_flash_info.nv_dload.nv_bin.magic_num,\ g_flash_info.nv_dload.nv_bin.len,g_flash_info.nv_dload.nv_bin.off); printf("xnv1 : flag 0x%x,len 0x%x,off 0x%x\n",g_flash_info.nv_dload.xnv_xml[0].magic_num,\ g_flash_info.nv_dload.xnv_xml[0].len,g_flash_info.nv_dload.xnv_xml[0].off); printf("cust1: flag 0x%x,len 0x%x,off 0x%x\n",g_flash_info.nv_dload.cust_xml[0].magic_num,\ g_flash_info.nv_dload.cust_xml[0].len,g_flash_info.nv_dload.cust_xml[0].off); printf("xnv2 : flag 0x%x,len 0x%x,off 0x%x\n",g_flash_info.nv_dload.xnv_xml[1].magic_num,\ g_flash_info.nv_dload.xnv_xml[1].len,g_flash_info.nv_dload.xnv_xml[1].off); printf("cust2: flag 0x%x,len 0x%x,off 0x%x\n",g_flash_info.nv_dload.cust_xml[1].magic_num,\ g_flash_info.nv_dload.cust_xml[1].len,g_flash_info.nv_dload.cust_xml[1].off); printf("xnv map1: flag 0x%x,len 0x%x,off 0x%x\n",g_flash_info.nv_dload.xnv_map[0].magic_num,\ g_flash_info.nv_dload.xnv_map[0].len,g_flash_info.nv_dload.xnv_map[0].off); printf("xnv map2: flag 0x%x,len 0x%x,off 0x%x\n",g_flash_info.nv_dload.xnv_map[1].magic_num,\ g_flash_info.nv_dload.xnv_map[1].len,g_flash_info.nv_dload.xnv_map[1].off); printf("\n********dload mtd info*******\n"); printf("nv : flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.nv_bin.magic_num,\ nv_dload.nv_bin.len,nv_dload.nv_bin.off); /* coverity[uninit_use] */ printf("xnv1 : flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.xnv_xml[0].magic_num,\ nv_dload.xnv_xml[0].len,nv_dload.xnv_xml[0].off); /* coverity[uninit_use] */ printf("cust1: flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.cust_xml[0].magic_num,\ nv_dload.cust_xml[0].len,nv_dload.cust_xml[0].off); printf("xnv2 : flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.xnv_xml[1].magic_num,\ nv_dload.xnv_xml[1].len,nv_dload.xnv_xml[1].off); printf("cust2: flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.cust_xml[1].magic_num,\ nv_dload.cust_xml[1].len,nv_dload.cust_xml[1].off); /* coverity[uninit_use] */ printf("xnv map1: flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.xnv_map[0].magic_num,\ nv_dload.xnv_map[0].len,nv_dload.xnv_map[0].off); printf("xnv map2: flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.xnv_map[1].magic_num,\ nv_dload.xnv_map[1].len,nv_dload.xnv_map[1].off); for(i= 0;i<NV_DLOAD_FILE_BLOCK_NUM;i++) printf("nv dload file %d block off :0x%x\n",i,g_sec_info.nv_dload[i]); printf("\n******************backup info******************\n"); printf("\n********backup mem info******\n"); printf("backup flag: 0x%x, len : 0x%x, off:0x%x\n",g_flash_info.bak_sec.magic_num,\ g_flash_info.bak_sec.len,g_flash_info.bak_sec.off); printf("\n********backup mtd info******\n"); ret = bsp_nand_read((char*)NV_BACK_SEC_NAME,0,&ctrl_info,sizeof(ctrl_info),NULL); if(ret){ nv_free(file_info); return; } if(ctrl_info.magicnum != NV_CTRL_FILE_MAGIC_NUM) { ctrl_info.file_size = 144; } ret = bsp_nand_read((char*)NV_BACK_SEC_NAME,sizeof(ctrl_info),file_info,ctrl_info.file_size,NULL); if(ret){ nv_free(file_info); return; } printf("magic :0x%x,file num: %d,nv num :0x%x,modem num :%d\n",\ ctrl_info.magicnum,ctrl_info.file_num,ctrl_info.ref_count,ctrl_info.modem_num); for(i= 0;i<NV_BIN_FILE_BLOCK_NUM;i++) printf("nv back file %d block off :0x%x\n",i,g_sec_info.nv_bak[i]); printf("\n******************default info*****************\n"); printf("\n********default mem info*****\n"); printf("default flag: 0x%x, len : 0x%x, off:0x%x\n",g_flash_info.def_sec.magic_num,\ g_flash_info.def_sec.len,g_flash_info.def_sec.off); printf("\n********default mtd info*****\n"); ret = bsp_nand_read((char*)NV_DEF_SEC_NAME,0,&ctrl_info,sizeof(ctrl_info),NULL); if(ret){ nv_free(file_info); return; } if(ctrl_info.magicnum != NV_CTRL_FILE_MAGIC_NUM) { ctrl_info.file_size = 144; } ret = bsp_nand_read((char*)NV_DEF_SEC_NAME,sizeof(ctrl_info),file_info,ctrl_info.file_size,NULL); if(ret){ nv_free(file_info); return; } printf("magic :0x%x,file num: %d,nv num :0x%x,modem num :%d\n",\ ctrl_info.magicnum,ctrl_info.file_num,ctrl_info.ref_count,ctrl_info.modem_num); for(i= 0;i<NV_BIN_FILE_BLOCK_NUM;i++) printf("nv default file %d block off :0x%x\n",i,g_sec_info.nv_default[i]); nv_free(file_info); }
void show_emmc_info(void) { struct nv_dload_packet_head_stru nv_dload; struct nv_ctrl_file_info_stru ctrl_info; u8* file_info; s32 ret = -1 ; printf("\n******************img info*********************\n"); ret = bsp_nand_read((char*)NV_SYS_SEC_NAME,0,&ctrl_info,sizeof(ctrl_info),NULL); if(ret) return; if(ctrl_info.magicnum != NV_CTRL_FILE_MAGIC_NUM) { ctrl_info.file_size = 144; } file_info = (u8*)nv_malloc(ctrl_info.file_size+1); if(NULL == file_info) { return; } ret = bsp_nand_read((char*)NV_SYS_SEC_NAME,sizeof(ctrl_info),file_info,ctrl_info.file_size,NULL); if(ret) return; printf("\n********sys mem info*******\n"); printf("nv :flag 0x%x,off 0x%x,len 0x%x\n",g_emmc_info.sys_nv.magic_num,\ g_emmc_info.sys_nv.off,g_emmc_info.sys_nv.len); printf("\n************sys info in nand**************\n"); printf("magic :0x%x,file num: %d,nv num :0x%x,modem num :%d\n",\ ctrl_info.magicnum,ctrl_info.file_num,ctrl_info.ref_count,ctrl_info.modem_num); printf("\n******************dload info*******************\n"); ret = bsp_nand_read((char*)NV_DLOAD_SEC_NAME,0,&nv_dload,sizeof(nv_dload),NULL); if(ret) return; printf("\n********dload mem info*******\n"); printf("nv : flag 0x%x,len 0x%x,off 0x%x\n",g_emmc_info.nv_dload.nv_bin.magic_num,\ g_emmc_info.nv_dload.nv_bin.len,g_emmc_info.nv_dload.nv_bin.off); printf("xnv1 : flag 0x%x,len 0x%x,off 0x%x\n",g_emmc_info.nv_dload.xnv_xml[0].magic_num,\ g_emmc_info.nv_dload.xnv_xml[0].len,g_emmc_info.nv_dload.xnv_xml[0].off); printf("cust1: flag 0x%x,len 0x%x,off 0x%x\n",g_emmc_info.nv_dload.cust_xml[0].magic_num,\ g_emmc_info.nv_dload.cust_xml[0].len,g_emmc_info.nv_dload.cust_xml[0].off); printf("xnv2 : flag 0x%x,len 0x%x,off 0x%x\n",g_emmc_info.nv_dload.xnv_xml[1].magic_num,\ g_emmc_info.nv_dload.xnv_xml[1].len,g_emmc_info.nv_dload.xnv_xml[1].off); printf("cust2: flag 0x%x,len 0x%x,off 0x%x\n",g_emmc_info.nv_dload.cust_xml[1].magic_num,\ g_emmc_info.nv_dload.cust_xml[1].len,g_emmc_info.nv_dload.cust_xml[1].off); printf("xnv map1: flag 0x%x,len 0x%x,off 0x%x\n",g_emmc_info.nv_dload.xnv_map[0].magic_num,\ g_emmc_info.nv_dload.xnv_map[0].len,g_emmc_info.nv_dload.xnv_map[0].off); printf("xnv map2: flag 0x%x,len 0x%x,off 0x%x\n",g_emmc_info.nv_dload.xnv_map[1].magic_num,\ g_emmc_info.nv_dload.xnv_map[1].len,g_emmc_info.nv_dload.xnv_map[1].off); printf("\n********dload mtd info*******\n"); printf("nv : flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.nv_bin.magic_num,\ nv_dload.nv_bin.len,nv_dload.nv_bin.off); printf("xnv1 : flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.xnv_xml[0].magic_num,\ nv_dload.xnv_xml[0].len,nv_dload.xnv_xml[0].off); printf("cust1: flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.cust_xml[0].magic_num,\ nv_dload.cust_xml[0].len,nv_dload.cust_xml[0].off); printf("xnv2 : flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.xnv_xml[1].magic_num,\ nv_dload.xnv_xml[1].len,nv_dload.xnv_xml[1].off); printf("cust2: flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.cust_xml[1].magic_num,\ nv_dload.cust_xml[1].len,nv_dload.cust_xml[1].off); printf("xnv map1: flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.xnv_map[0].magic_num,\ nv_dload.xnv_map[0].len,nv_dload.xnv_map[0].off); printf("xnv map2: flag 0x%x,len 0x%x,off 0x%x\n",nv_dload.xnv_map[1].magic_num,\ nv_dload.xnv_map[1].len,nv_dload.xnv_map[1].off); printf("\n******************backup info******************\n"); printf("\n********backup mem info******\n"); printf("backup flag: 0x%x, len : 0x%x, off:0x%x\n",g_emmc_info.bak_sec.magic_num,\ g_emmc_info.bak_sec.len,g_emmc_info.bak_sec.off); printf("\n********backup mtd info******\n"); ret = bsp_nand_read((char*)NV_BACK_SEC_NAME,0,&ctrl_info,sizeof(ctrl_info),NULL); if(ret) return; if(ctrl_info.magicnum != NV_CTRL_FILE_MAGIC_NUM) { ctrl_info.file_size = 144; } ret = bsp_nand_read((char*)NV_BACK_SEC_NAME,sizeof(ctrl_info),file_info,ctrl_info.file_size,NULL); if(ret) return; printf("magic :0x%x,file num: %d,nv num :0x%x,modem num :%d\n",\ ctrl_info.magicnum,ctrl_info.file_num,ctrl_info.ref_count,ctrl_info.modem_num); printf("\n******************default info*****************\n"); printf("\n********default mem info*****\n"); printf("default flag: 0x%x, len : 0x%x, off:0x%x\n",g_emmc_info.def_sec.magic_num,\ g_emmc_info.def_sec.len,g_emmc_info.def_sec.off); printf("\n********default mtd info*****\n"); ret = bsp_nand_read((char*)NV_DEF_SEC_NAME,0,&ctrl_info,sizeof(ctrl_info),NULL); if(ret) return; if(ctrl_info.magicnum != NV_CTRL_FILE_MAGIC_NUM) { ctrl_info.file_size = 144; } ret = bsp_nand_read((char*)NV_DEF_SEC_NAME,sizeof(ctrl_info),file_info,ctrl_info.file_size,NULL); if(ret) return; printf("magic :0x%x,file num: %d,nv num :0x%x,modem num :%d\n",\ ctrl_info.magicnum,ctrl_info.file_num,ctrl_info.ref_count,ctrl_info.modem_num); nv_free(file_info); }
/****************************************************************************** Function: load_data_to_secos Description: 从指定偏移开始传送指定大小的镜像 Input: part_name - 要发送镜像的名称 offset - 偏移地址 sizeToRead - 输入参数,要写入的镜像的bytes大小 Output: none Return: SEC_OK: OK SEC_ERROR: ERROR码 ******************************************************************************/ static s32 load_data_to_secos(TEEC_Session *session, char* part_name, u32 offset, u32 sizeToRead, u32 * skip_len) { u32 read_bytes; u32 end_bytes; u32 copy_bytes; u32 timers; u32 i; s32 ret = SEC_ERROR; /*split the size to be read to each 64K bytes.*/ timers = sizeToRead / SECBOOT_BUFLEN; if (sizeToRead % SECBOOT_BUFLEN) timers = timers + 1; end_bytes = sizeToRead; /*call flash_read each time to read to memDst.*/ for (i = 0; i < timers; i++) { if (end_bytes >= SECBOOT_BUFLEN) read_bytes = SECBOOT_BUFLEN; else read_bytes = end_bytes; if (bsp_nand_read(part_name, offset + i * SECBOOT_BUFLEN, (void *)SECBOOT_BUFFER, read_bytes, skip_len)) { sec_print_err("%s: err: flash_read\n", __func__); return SEC_ERROR; } if (end_bytes >= SECBOOT_BUFLEN) { if (SECBOOT_BUFLEN != read_bytes) { sec_print_err("%s: err: SECBOOT_BUFLEN:%d != read_bytes:%d\r\n", __func__, SECBOOT_BUFLEN, read_bytes); return SEC_ERROR; } copy_bytes = SECBOOT_BUFLEN; } else { if (end_bytes > read_bytes) { sec_print_err("%s: err: end_bytes:%d!= read_bytes:%d\r\n", __func__, end_bytes, read_bytes); return SEC_ERROR; } copy_bytes = end_bytes; } ret = bsp_trans_to_os(session, SECBOOT_CMD_ID_COPY_DATA, (void *)(SECBOOT_BUFFER), (i * SECBOOT_BUFLEN), copy_bytes); if (SEC_ERROR == ret) { sec_print_err("modem image trans to os is failed, error code 0x%x\r\n", ret); return SEC_ERROR; } end_bytes -= copy_bytes; } if (0 != end_bytes) { sec_print_err("%s: end_bytes = 0x%x\n", __func__, end_bytes); return SEC_ERROR; } return SEC_OK; /*lint --e{818}*/ }