static INT32 command_transfer (INT32 index, void (*callback)(INT32 type, INT32 process, UINT8 *str))
{
UINT32 id,transLen=0;
UINT32 chunk_pos;
BYTE *p = NULL;
char strTmp[30];
struct sto_device* sto_dev = NULL;
id = pblock_list[index].id;
chunk_pos = sto_chunk_goto(&id, 0xFFFFFFFF, 1);
transLen = sto_fetch_long(chunk_pos + CHUNK_OFFSET);
if(transLen == 0)
transLen = sto_fetch_long(chunk_pos + CHUNK_LENGTH) + 16;
if (chunk_pos == (UINT32)ERR_PARA || chunk_pos == (UINT32)ERR_FAILUE)
{
ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_ERROR_601),strTmp);
callback(2,0,strTmp);
return !SUCCESS;
}
p = ((unsigned char *)FLASH_BASE) + chunk_pos;
return (INT32)cmd_transfer(p, transLen, UpgradeProgress, get_exit_key);
}
static RET_CODE find_key(UINT32 type, unsigned long *paddr, CIPLUS_KEY_HDR *phdr)
{
unsigned long addr, chunk_end;
UINT32 chunk_len;
UINT32 ch_id = CIPLUSKEY_CHUNK_ID;
addr = sto_chunk_goto(&ch_id, 0xFFFFFFFF, 1);
if(addr & 0x80000000)
return RET_FAILURE;
chunk_len = sto_fetch_long(addr + CHUNK_LENGTH);
chunk_end = addr +16 + chunk_len;
addr += CHUNK_HEADER_SIZE;
while(addr < chunk_end)
{
phdr->type = sto_fetch_long(addr);
phdr->len = sto_fetch_long(addr+4);
if(phdr->type == type)
{
*paddr = addr+sizeof(CIPLUS_KEY_HDR);
phdr->size = sto_fetch_long(addr+8);
//phdr->reserved = sto_fetch_long(addr+12);
return RET_SUCCESS;
}
addr += phdr->len;
}
return RET_FAILURE;
}
static UINT8 find_ota_loader(UINT32 *ota_loader_addr)
{
#define C_SECTOR_SIZE 0x10000
UINT8 *buffer;
UINT32 data_id;
UINT32 data_len;
UINT32 data_off;
UINT32 data_crc;
UINT32 crc;
UINT32 pointer = 0;
struct sto_device *flash_dev = (struct sto_device *)dev_get_by_type(NULL, HLD_DEV_TYPE_STO);
while(pointer < (UINT32)flash_dev->totol_size)
{
data_id = sto_fetch_long((UINT32)pointer + CHUNK_ID);
data_len = sto_fetch_long((UINT32)pointer + CHUNK_LENGTH);
data_off = sto_fetch_long((UINT32)pointer + CHUNK_OFFSET);
data_crc = sto_fetch_long((UINT32)pointer + CHUNK_CRC);
if(data_len && (data_len < data_off) && (data_crc != NO_CRC) && ((data_id & CHUNKID_SECLOADER_MASK) == CHUNKID_SECLOADER))
{
buffer = (UINT8 *)MALLOC(data_len);
if(buffer != NULL)
{
sto_get_data(flash_dev, buffer, pointer + 16, data_len);
crc = MG_Table_Driven_CRC(0xFFFFFFFF, buffer, data_len);
FREE(buffer);
if(data_crc == crc)
{
*ota_loader_addr = pointer;
return 1;
}
}
}
pointer += C_SECTOR_SIZE;
}
return 0;
}
static INT32 SlaveReorg(void (*callback)(INT32 type, INT32 process, UINT8 *str))
{
UINT32 len,offset;
// UINT8* p;
UINT32 chunk_pos;
INT32 i,j;
BOOL all_upg_flag = TRUE;
char strTmp[30];
char strTmp1[30];
#ifdef FORCE_UPGRADE_OLD_PROTOCOL_BOOTLOADER
BOOL force_upgrade = FALSE;
#endif
slave_reorg_size = 0;
slave_burn_size = 0;
#ifdef FORCE_UPGRADE_OLD_PROTOCOL_BOOTLOADER
// if upgrade protocol version is old protocol version
// and upgrade chunk include maincode or second loader
// force upgrade bootloader
if(g_protocol_version < NEW_PROTOCOL_VERSION)
{
for(i=1; i<block_number; i++)
{
if(pblock_list[i].upg_flag &&
(((pblock_list[i].id & 0xFFFF0000) == 0x01FE0000)
|| ((pblock_list[i].id & 0xFFFF0000) == 0x00FF0000)))
{
force_upgrade = TRUE;
break;
}
}
if(force_upgrade)
pblock_list[0].upg_flag = 1;
}
#endif
for(i=1; i<block_number; i++)
{
if(pblock_list[i].upg_flag != 1)
{
all_upg_flag = FALSE;
break;
}
}
if((block_number != slave_blocks_number) && (!all_upg_flag))
{
return !SUCCESS;
}
if(all_upg_flag)
{
slave_reorg_number = block_number;
pslave_reorg_list = (CHUNK_LIST2 *)MALLOC(sizeof(CHUNK_LIST2)*slave_reorg_number);
if(pslave_reorg_list == NULL) return !SUCCESS;
chunk_pos = sto_chunk_goto(&pblock_list[0].id, 0xFFFFFFFF, 1);
offset = sto_fetch_long(chunk_pos + CHUNK_OFFSET);
pslave_reorg_list[0].type = 1; //move
pslave_reorg_list[0].index= 0;
pslave_reorg_list[0].offset = offset;
for(i=1; i<block_number; i++)
{
chunk_pos = sto_chunk_goto(&pblock_list[i].id, 0xFFFFFFFF, 1);
offset = sto_fetch_long(chunk_pos + CHUNK_OFFSET);
pslave_reorg_list[i].type = 2; //transfer
pslave_reorg_list[i].index= i;
pslave_reorg_list[i].offset = offset;
}
}
else
{
slave_reorg_number = slave_blocks_number;
for(i=1; i<block_number; i++)
{
if(pblock_list[i].upg_flag)
{
if(IsInSlave(pblock_list[i].id) != SUCCESS)
{
return !SUCCESS;//slave_reorg_number++; //add chunk
}
}
else
{
if(slave_status != 0)
{
ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_SLAVEDATA_DESTROY_UPDATE_ALLCODE),strTmp);
callback(2,0,strTmp);
return !SUCCESS;
}
}
}
pslave_reorg_list = (CHUNK_LIST2 *)MALLOC(sizeof(CHUNK_LIST2)*slave_reorg_number);
if(pslave_reorg_list == NULL) return !SUCCESS;
/*init pslave_reorg_list*/
for(i=0; i<slave_reorg_number; i++)
{
pslave_reorg_list[i].type = 1; //move chunk
pslave_reorg_list[i].index= i;
pslave_reorg_list[i].offset = pslave_list[i].offset;
}
for(i=1; i<block_number; i++)
{
if(pblock_list[i].upg_flag)
{
chunk_pos = sto_chunk_goto(&pblock_list[i].id, 0xFFFFFFFF, 1);
offset = sto_fetch_long(chunk_pos + CHUNK_OFFSET);
/*replace chunk*/
for(j=0; j<slave_blocks_number; j++)
{
if(pslave_reorg_list[j].type == 1 && pslave_list[pslave_reorg_list[j].index].id == pblock_list[i].id)
{
/*
//frank disnable
#if (SYS_CHIP_MODULE == ALI_M3327C && SYS_SDRAM_SIZE == 2)
if(ID_TYPE(pblock_list[i].id)!=TEMPDB_ID || slave_status!=0)
#endif
*/
{
pslave_reorg_list[j].type = 2; //transfer
pslave_reorg_list[j].index= i;
pslave_reorg_list[j].offset = offset;
}
break;
}
}
}
}
}
/*upgrade bootloader*/
if(((IsUpgBootloader(pslave_list[0].version)==SUCCESS) || m_allcode_include_bootloader) && (pblock_list[0].upg_flag==1))
{
chunk_pos = sto_chunk_goto(&pblock_list[0].id, 0xFFFFFFFF, 1);
offset = sto_fetch_long(chunk_pos + CHUNK_OFFSET);
pslave_reorg_list[0].type = 2; //transfer
pslave_reorg_list[0].index= 0;
pslave_reorg_list[0].offset = offset;
slave_reorg_size += offset;
slave_burn_size += offset;
}
for(i=1; i<slave_reorg_number; i++)
{
if(pslave_reorg_list[i].type == 1) //move
{
// Jie Wu, disable below line to let the progress bar move smoothly.
//slave_reorg_size += pslave_list[pslave_reorg_list[i].index].len+16;
if(pslave_reorg_list[i].offset == 0)
slave_burn_size += pslave_list[pslave_reorg_list[i].index].len+16;
else
slave_burn_size += pslave_reorg_list[i].offset;
}
else //transfer
{
chunk_pos = sto_chunk_goto(&pblock_list[pslave_reorg_list[i].index].id, 0xFFFFFFFF, 1);
len = sto_fetch_long(chunk_pos + CHUNK_OFFSET);
if(len == 0)
len = sto_fetch_long(chunk_pos + CHUNK_LENGTH) + 16;
slave_reorg_size += len;
if(pslave_reorg_list[i].offset == 0)
slave_burn_size += len ;
else
slave_burn_size += pslave_reorg_list[i].offset;
}
}
if(pslave_reorg_list[0].type == 2) //transfer bootloader
{
if(slave_burn_size > slave_Flash_type)
{
ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_UPDATE_DATE_LARGE_FAILED),strTmp1);
callback(2,0,strTmp1);
return !SUCCESS;
}
}
else
{
if(pslave_list[0].offset+slave_burn_size > slave_Flash_type)
{
ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_UPDATE_DATE_LARGE_FAILED),strTmp1);
callback(2,0,strTmp1);
return !SUCCESS;
}
}
return SUCCESS;
}
static BOOL init_slave()
{
UINT8 *ptr_data_buf, *ptr_temp_buf;
UINT32 ptr_zip_pos;
UINT8 zero_buf[16];
UINT32 slave_addr;
UINT32 total_len, len, chid;
int ret;
UINT32 i;
char strTmp[30];
char strTmp1[30];
ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_INIT_SLAVER),strTmp);
callback_fun(2, 0, strTmp);
P2PUPG_DBG("init_slave\n");
// init slave sdram
for(i=0; i<sizeof(m_SlaveConfig)/sizeof(m_SlaveConfig[0]); i++)
{
osal_task_sleep(50);
// if(0xb8000029 == m_SlaveConfig[i].Address)
// {
// if(sys_ic_is_M3101())
// m_SlaveConfig[i].Data = *((volatile UINT8 *)m_SlaveConfig[i].Address) & 0x07;
// else
// m_SlaveConfig[i].Data = *((volatile UINT8 *)m_SlaveConfig[i].Address) & 0x1c;
// }
erom_wm(m_SlaveConfig[i].Address, &m_SlaveConfig[i].Data, 1, 0);
}
// set upgrade param
init_upgrade_param();
for(i=0; i<sizeof(EROM_UPGRADE_PARAM); i+=sizeof(UINT32))
{
if(!send_upgrade_param(i))
{
ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_SEND_UPGRADE_PARAM_FAILED),strTmp1);
callback_fun(2, 0,strTmp1);
return FALSE;
}
}
P2PUPG_DBG("send_upgrade_param OK\n");
unsigned long chunk_id = g_upge_feature_config.chip_flashwr;
ptr_zip_pos = (UINT8 *)sto_chunk_goto(&chunk_id, 0xFFFFFFFF, 1);
unsigned long zip_size = sto_fetch_long(ptr_zip_pos + CHUNK_LENGTH);
ptr_zip_pos += CHUNK_HEADER_SIZE;
ptr_data_buf = (UINT8 *)bk_buff; // 48KB for unzip buffer
ptr_temp_buf = (UINT8 *)(bk_buff + 0xC000); // 16KB for temp buffer
P2PUPG_DBG("ptr_zip_pos = 0x%x\n ptr_data_buf = 0x%x\n ptr_temp_buf = 0x%x\n",ptr_zip_pos,ptr_data_buf,ptr_temp_buf);
if(g_upge_feature_config.enable_lzma_out_read == TRUE)
ret = un7zip(ptr_zip_pos+SYS_FLASH_BASE_ADDR, zip_size, ptr_temp_buf, 0x4000, ptr_data_buf, 0xC000, NULL);
else
ret = un7zip(ptr_zip_pos+SYS_FLASH_BASE_ADDR, ptr_data_buf, ptr_temp_buf);
P2PUPG_DBG("un7zip ret=%d\n",ret);
if(ret)
return FALSE;
P2PUPG_DBG("un7zip OK");
MEMCPY(&total_len, ptr_temp_buf, sizeof(unsigned int));
P2PUPG_DBG("total_len =%d\n",total_len);
uart_high_speed_config(UART_SPEED_NORMAL);
// download flashwr
erom_download(FLASHWR_RUN_ADDR, ptr_data_buf, total_len);
// init slave config buffer
P2PUPG_DBG("erom_download1 OK\n");
MEMSET(zero_buf, 0, sizeof(zero_buf));
erom_download(FWCFG_START_ADDR, zero_buf, sizeof(zero_buf));
P2PUPG_DBG("erom_download2 OK\n");
// download config chunk
chid = g_upge_feature_config.chip_config;
if((chid!=0)&&(chid!=0xFFFFFFFF))
{
ptr_data_buf = sto_chunk_goto(&chid, 0xFFFFFFFF, 1);
P2PUPG_DBG("ptr_data_buf=0x%x\n",ptr_data_buf);
if(ptr_data_buf != NULL)
{
total_len = sto_fetch_long((unsigned long)(ptr_data_buf+CHUNK_OFFSET));
erom_download(FWCFG_START_ADDR, ptr_data_buf, total_len);
}
}
if(UPGRADE_SINGLE == upgrade_mode)
{
erom_setpc(FLASHWR_RUN_ADDR);
osal_task_sleep(50);
sci_mode_set(p2p_uart_id, 115200, SCI_PARITY_EVEN);
osal_task_sleep(100);
config_uart_speed(UART_DOWNLOAD_SPEED);
}
return TRUE;
}
//LIB_ASH_OC(argc & 0xFF);
//LIB_ASH_OC(argv[1][0]);
//LIB_ASH_OC(argv[1][1]);
if( argc >= 2 && argv[1][0] == 0x2d && argv[1][1] == 0x72)//"-r"
{
#ifdef TRANSFER_FORMAT2_SUPPORT
LIB_ASH_OC((nVersion >> 8) & 0xFF);
LIB_ASH_OC( nVersion & 0xFF);
#endif
}
/* collect information */
n = sto_chunk_count(0, 0);
of = sto_chunk_goto(&chid, 0, n);
len = sto_fetch_long(of + CHUNK_LENGTH);
/* send Length */
data_len = n * CHUNK_HEADER_SIZE + 2;
LIB_ASH_OC((data_len >> 8) & 0xFF);
LIB_ASH_OC(data_len & 0xFF);
crc = 0xFFFFFFFF;
/* send Flash ID */
LIB_ASH_OC(flash_id_val);
crc = MG_Table_Driven_CRC(crc, &flash_id_val, 1);
/* send Chunk Status */
LIB_ASH_OC(g_crc_bad);
crc = MG_Table_Driven_CRC(crc, &g_crc_bad, 1);
/* send Chunks */
for (i = 1; i <= n; i++)
