/*---------------------------------------------------------- *
* func name: get_system_version_info()
* function : 得到当前系统的软件相关版本信息. 存放于systemversion
* calllist : sto_chunk_count()
* sto_chunk_goto()
* sto_get_chunk_header()
*
* calledlist:
* input :
* output :
* parameter: 无
*
* return : 0 获取内存失败
* block_number 版本信息数目
*
*
*
* notice : systemversion内存要注意释放
*--------------------------------------------------------*/
unsigned int get_system_version_info(void)
{
int i = 0;
UINT32 id;
UINT32 mask;
block_number = sto_chunk_count(0,0);
if(0 == block_number)
return 0;
systemversion = (CHUNK_HEADER*)MALLOC(sizeof(CHUNK_HEADER)*block_number);
if(NULL == systemversion)
{
libc_printf("Get Memorey fialed!!\n");
return -1;
}
//bootloader, maincode,seecode,Radioback,Radiobg,cccam_prio,softcamkey
//cccam_newcamd,defaultdb,userdb
for(i = 0; i<block_number; i++)
{
id = mask = 0;
sto_chunk_goto(&id,mask,i+1);
sto_get_chunk_header(id, systemversion+i);
}
return block_number;
}
UINT8 gyca_mail_init(void)
{
UINT32 chunk_id = CAS_MAIL_CHUNK_ID;
CHUNK_HEADER chuck_hdr;
/* get table info base addr by using chunk */
if(sto_get_chunk_header(chunk_id, &chuck_hdr) == 0)
{
GYCAS_PRINTF("Err: %s get chunk header fail!\n", __FUNCTION__);
return 1;
}
gyca_email_mutex = osal_mutex_create();
if(gyca_email_mutex == OSAL_INVALID_ID)
{
GYCAS_PRINTF("Err: %s create mutex failed!\n", __FUNCTION__);
}
gyca_email_start_addr = sto_chunk_goto(&chunk_id, 0xFFFFFFFF, 1) + CHUNK_HEADER_SIZE + SECTOR_SIZE;
if(!gyca_check_flash_mail_head(gyca_email_start_addr))
gyca_readmail_all_from_flash(gyca_email_start_addr, GYCA_MAIL_HEAD_SIZE);
else
{
MEMSET(flashbuf, 0, sizeof(flashbuf));
//gyca_mail_test();
//gyca_delmail_all_flash(gyca_email_start_addr);
//gyca_writemaill_all_to_flash(gyca_email_start_addr, GYCA_MAIL_HEAD_SIZE);
}
}
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 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);
}
HRESULT DVTSTBCA_GetDataBufferAddr(long * lSize, char ** ppStartAddr)
{
UINT32 chunk_id = CAS_CHUNK_ID;
CHUNK_HEADER chuck_hdr;
struct sto_device *sto_flash_dev = NULL;
/* get table info base addr by using chunk */
if(sto_get_chunk_header(chunk_id, &chuck_hdr) == 0)
{
CAS_NVMERR_PRINTF("Err: %s get chunk header fail!\n", __FUNCTION__);
return CAS_FAIL;
}
CAS_flash_start_addr = sto_chunk_goto(&chunk_id, 0xFFFFFFFF, 1);
CAS_flash_start_addr += CHUNK_HEADER_SIZE;
*ppStartAddr = (UINT8 *)CAS_flash_start_addr;
*lSize = CAS_FLASH_MAXSIZE;//CAS_CHUNK_SIZE/2;
if (NULL == cas_flash_buff)
cas_flash_buff = MALLOC(*lSize);
if (NULL == cas_flash_buff)
return CAS_FAIL;
//copy the CA flash data to mem
sto_flash_dev = (struct sto_device *)dev_get_by_type(NULL, HLD_DEV_TYPE_STO);
if(NULL == sto_flash_dev)
{
CAS_NVMERR_PRINTF("TFSTBCA_WriteBuffer: dev_get_by_name failed!\n");
return CAS_FAIL;
}
if (sto_open(sto_flash_dev) != SUCCESS)
{
CAS_NVMERR_PRINTF("%s: sto_open failed!\n", __FUNCTION__);
return CAS_FAIL;
}
if( (INT32) CAS_flash_start_addr != sto_lseek(sto_flash_dev, (INT32) CAS_flash_start_addr, STO_LSEEK_SET))
{
CAS_NVMERR_PRINTF("%s: lseek failed!\n", __FUNCTION__);
return CAS_FAIL;
}
if (CAS_FLASH_MAXSIZE != sto_read(sto_flash_dev, cas_flash_buff, CAS_FLASH_MAXSIZE))
{
CAS_NVMERR_PRINTF("%s: sto_read failed!\n", __FUNCTION__);
return CAS_FAIL;
}
CAS_NVM_PRINTF("%s: flash StartAddr=%08x, Len:%08x\n", __FUNCTION__, *ppStartAddr, *lSize);
return CAS_SUCCESS;
}
void clear_ca_data()
{
INT32 ret;
struct sto_device *sto_flash_dev;
UINT32 param;
UINT32 flash_cmd;
CHUNK_HEADER chuck_hdr;
UINT32 chunk_id = 0x08F70100;
ret = sto_get_chunk_header(chunk_id, &chuck_hdr);
if (ret == 0)
{
libc_printf("%s(): CHUNK ID not found\n",__FUNCTION__,chunk_id);
return;
}
sto_flash_dev = (struct sto_device *)dev_get_by_type(NULL, HLD_DEV_TYPE_STO);
if(sto_flash_dev == NULL)
{
libc_printf("STBCA_WriteBuffer: dev_get_by_name failed!\n");
return;
}
if (sto_open(sto_flash_dev) != SUCCESS)
{
libc_printf("STBCA_WriteBuffer: sto_open failed!\n");
return;
}
UINT32 tmp_param[2];
tmp_param[0] = (UINT32)sto_chunk_goto(&chunk_id, 0xFFFFFFFF, 1) + CHUNK_HEADER_SIZE;;
tmp_param[1] = 0x20000 >> 10;
param = (UINT32)tmp_param;
flash_cmd = STO_DRIVER_SECTOR_ERASE_EXT;
ret = sto_io_control(sto_flash_dev, flash_cmd, param);
if(ret != SUCCESS)
{
libc_printf("STBCA_WriteBuffer: Erase failed!\n");
return;
}
}
UINT32 GetChunk(BYTE *buffer, UINT32 nLen)
{
UINT8 *p, *pblock;
UINT32 chunk_pos;
struct sto_device *sto_dev = NULL;
UINT8 sVer[16], hVer[16];
INT32 i = 0;
char strTmp[30];
#if (defined HDCP_IN_FLASH ||defined DIVX_CERT_ENABLE)
INT32 temp_slave_blocks_number=0;
CHUNK_HEADER *temp_pslave_list = NULL;
#endif
switch((unsigned int)buffer[0])
{
case 1:
case 2:
case 7:
case 10:
slave_Flash_type = 0x80000; //flash size
break;
case 3:
case 4:
case 8:
case 9:
case 11:
case 13:
slave_Flash_type = 0x100000;
break;
case 5:
case 6:
case 12:
case 14:
case 15:
case 16:
case 25:
case 28:
case 30:
slave_Flash_type = 0x200000;
break;
case 17:
case 18:
case 19:
case 33:
slave_Flash_type = 0x400000;
break;
default:
slave_Flash_type = 0x200000;/*For unkown flash type,default is 2M*/
//return !SUCCESS;
}
slave_status = (unsigned int)buffer[1];
if(slave_status==0)
slave_blocks_number = (nLen -2)/CHUNK_HEADER_SIZE;
else
slave_blocks_number = 1;
pslave_list= (CHUNK_HEADER *)MALLOC(sizeof(CHUNK_HEADER)*slave_blocks_number);
if (pslave_list == NULL)
return !SUCCESS;
MEMSET((void *)pslave_list,0,sizeof(CHUNK_HEADER)*slave_blocks_number);
#if (defined HDCP_IN_FLASH ||defined DIVX_CERT_ENABLE)
#ifdef HDCP_IN_FLASH
if(m_allcode_include_bootloader==0)
#endif
{
temp_pslave_list= (CHUNK_HEADER *)MALLOC(sizeof(CHUNK_HEADER)*slave_blocks_number);
if (temp_pslave_list == NULL)
return !SUCCESS;
MEMSET((void *)temp_pslave_list,0,sizeof(CHUNK_HEADER)*slave_blocks_number);
}
#endif
pblock = &buffer[2];
for(i=0; i<slave_blocks_number; i++)
{
p = pblock + CHUNK_ID;
pslave_list[i].id = (*p<<24)+(*(p+1)<<16)+(*(p+2)<<8)+(*(p+3)<<0);
p = pblock + CHUNK_LENGTH;
pslave_list[i].len = (*p<<24)+(*(p+1)<<16)+(*(p+2)<<8)+(*(p+3)<<0);
p = pblock + CHUNK_OFFSET;
pslave_list[i].offset = (*p<<24)+(*(p+1)<<16)+(*(p+2)<<8)+(*(p+3)<<0);
p = pblock + CHUNK_CRC;
pslave_list[i].crc = (*p<<24)+(*(p+1)<<16)+(*(p+2)<<8)+(*(p+3)<<0);
p = pblock + CHUNK_NAME;
STRCPY((char *)pslave_list[i].name, (char *)p);
p = pblock + CHUNK_VERSION;
STRCPY((char *)pslave_list[i].version, (char *)p);
p = pblock + CHUNK_TIME;
STRCPY((char *)pslave_list[i].time, (char *)p);
#if (defined HDCP_IN_FLASH ||defined DIVX_CERT_ENABLE)
#ifdef HDCP_IN_FLASH
if(m_allcode_include_bootloader==0)
#endif
{
UINT32 special_type = 0;
#ifdef HDCP_IN_FLASH
if(pslave_list[i].id == HDCPKEY_CHUNK_ID)
{
special_type =1;
}
#endif
#ifdef DIVX_CERT_ENABLE
if(pslave_list[i].id == DIVX_CHUCK_ID)
{
special_type =1;
}
#endif
if(special_type!=1)
{
MEMCPY((temp_pslave_list+temp_slave_blocks_number),(pslave_list+i),sizeof(CHUNK_HEADER));
temp_slave_blocks_number++;
}
else
{
if(i > 0)
{
temp_pslave_list[i-1].offset=(temp_pslave_list[i-1].offset+pslave_list[i].offset);
}
}
}
#endif
pblock += CHUNK_HEADER_SIZE;
}
#if (defined HDCP_IN_FLASH ||defined DIVX_CERT_ENABLE)
#ifdef HDCP_IN_FLASH
if(m_allcode_include_bootloader==0)
#endif
{
FREE(pslave_list);
slave_blocks_number=temp_slave_blocks_number;
pslave_list = (CHUNK_HEADER *)MALLOC(sizeof(CHUNK_HEADER)*slave_blocks_number);
MEMCPY(pslave_list,temp_pslave_list,sizeof(CHUNK_HEADER)*slave_blocks_number);
FREE(temp_pslave_list);
}
#endif
STRCPY(sVer, pslave_list[0].version);
chunk_pos = sto_chunk_goto(&pblock_list[0].id, 0xFFFFFFFF, 1);
sto_dev = (struct sto_device*)dev_get_by_id(HLD_DEV_TYPE_STO, 0);
sto_open(sto_dev);
sto_lseek(sto_dev, chunk_pos+CHUNK_VERSION, STO_LSEEK_SET);
sto_read(sto_dev, hVer, 16);
//sto_close(sto_dev);
#ifdef FORCE_UPGRADE_OLD_PROTOCOL_BOOTLOADER
if(g_protocol_version < NEW_PROTOCOL_VERSION)
return SUCCESS;
#endif
if(CheckVersion(sVer, hVer) != SUCCESS)
{
ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_STB_VERSION_NOT_COMPATIBLE),strTmp);
callback_fun(2,0,strTmp);
return !SUCCESS;
}
}
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;
}
static void display_sys_infomation(UINT8 flag)
{
CHUNK_HEADER blk_header;
UINT8 i;
UINT32 id,mask;
char str[30];
BYTE info_block_number;
info_block_number = sto_chunk_count(0,0);
for(i=0;i<info_block_number;i++)
{
id = mask = 0;
sto_chunk_goto(&id,mask,i + 1);
sto_get_chunk_header(id, &blk_header);
set_info_con_rect(CON_L, CON_T + (CON_H + CON_GAP)*i,CON_W,CON_H);
/* Name */
OSD_SetTextFieldContent(&info_txt_name,STRING_ANSI, (UINT32)blk_header.name);
if(flag == 0)
{//show version & time
/* Version */
if(i==0)
OSD_SetTextFieldContent(&info_txt1,STRING_ANSI, (UINT32)&blk_header.version[8]);
#ifdef UPGRADE_BY_CUSTOMER_ID
else if(i == 1)/*main code version*/
{
if(blk_header.version[1] != '.')
{
OSD_SetTextFieldContent(&info_txt1,STRING_ANSI, (UINT32)&blk_header.version[CUSTOMER_ID_LENGTH]);
}
else
{
OSD_SetTextFieldContent(&info_txt1,STRING_ANSI, (UINT32)blk_header.version);
}
}
#endif
else
OSD_SetTextFieldContent(&info_txt1,STRING_ANSI, (UINT32)blk_header.version);
/* Time */
OSD_SetTextFieldContent(&info_txt2,STRING_ANSI, (UINT32)blk_header.time);
}
else
{//show length & offset
/*length*/
sprintf(str,"0x%x",blk_header.len);
OSD_SetTextFieldContent(&info_txt1,STRING_ANSI, (UINT32)str);
/* Offset */
sprintf(str,"0x%x",blk_header.offset);
OSD_SetTextFieldContent(&info_txt2,STRING_ANSI, (UINT32)str);
}
OSD_DrawObject((POBJECT_HEAD )&info_item_con,C_UPDATE_ALL);
}
}
static void win_rs232upg_load_chunk_info()
{
CHUNK_HEADER blk_header;
UINT32 id,mask;
UINT8 chunk_number;
UINT8 i;
char strTmp[30];
char strTmp1[30];
char strTmp2[30];
char strTmp3[30];
char strTmp4[30];
char strTmp5[30];
char strTmp6[30];
char strTmp7[30];
char strTmp8[30];
#if (defined HDCP_IN_FLASH ||defined DIVX_CERT_ENABLE)
UINT32 Block_id = 0, HDCP_key_ID = 0,divx_key_ID = 0,ciplus_key_ID = 0;
UINT8 hdcp_chunk_index = 0;
UINT8 cipluskey_chunk_index = 0;
BOOL has_hdcp_chunk = FALSE;
BOOL has_cipluskey_chunk = FALSE;
UINT8 divx_chunk_index = 0;
BOOL has_divx_chunk = FALSE;
UINT32 special_type =0;
#endif
//-a by wangyang del seecode upgrade {{
UINT32 seecode_key_ID = 0;
UINT8 seecode_chunk_index = 0;
BOOL has_seecodekey_chunk = FALSE;
//-a by wangyang del seecode upgrade }}
chunk_number = sto_chunk_count(0,0);
if(chunk_number == 0)
return;
if(InitBlockList() != SUCCESS)
return;
if(rs232upg_upgtype_chars != NULL)
FREE(rs232upg_upgtype_chars);
rs232upg_upgtype_chars = (UINT16**)MALLOC(sizeof(UINT16*)*chunk_number);
if(rs232upg_upgtype_chars == NULL)
ASSERT(0);
for(i=0; i<chunk_number; i++)
{
rs232upg_upgtype_chars[i] = (UINT16*)MALLOC(16*sizeof(UINT16));
if(rs232upg_upgtype_chars[i] == NULL)
ASSERT(0);
}
// STRCPY(rs232upg_upgtype_chars[0],"allcode");
{
UINT16 *unistr=NULL;
unistr=OSD_GetUnicodeString(RS_TOTAL_FLASH);
ComUniStrCopyChar(rs232upg_upgtype_chars[0],(UINT16 *)unistr);
//ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_TOTAL_FLASH),strTmp);
//STRCPY(rs232upg_upgtype_chars[0],strTmp);
}
for(i=1; i<chunk_number; i++)
{
id = mask = 0;
sto_chunk_goto(&id,mask,i + 1);
sto_get_chunk_header(id, &blk_header);
#if (defined HDCP_IN_FLASH ||defined DIVX_CERT_ENABLE || defined CI_PLUS_SUPPORT )
special_type = 0;
#ifdef HDCP_IN_FLASH
HDCP_key_ID = HDCPKEY_CHUNK_ID;
if(((UINT32)blk_header.id) == HDCP_key_ID)
{
hdcp_chunk_index = i;
has_hdcp_chunk = TRUE;
special_type = 1;
}
#endif
#ifdef DIVX_CERT_ENABLE
divx_key_ID = DIVX_CHUCK_ID;
if(((UINT32)blk_header.id) == divx_key_ID)
{
divx_chunk_index = i;
has_divx_chunk = TRUE;
special_type = 1;
}
#endif
#ifdef CI_PLUS_SUPPORT
ciplus_key_ID = CIPLUSKEY_CHUNK_ID;
if(((UINT32)blk_header.id) == ciplus_key_ID)
{
cipluskey_chunk_index = i;
has_cipluskey_chunk = TRUE;
special_type = 1;
}
#endif
//-a by wangyang del seecode upgrade {{
seecode_key_ID =SEECODE_CHUNK_ID
if(((UINT32)blk_header.id) == ciplus_key_ID)
{
seecode_chunk_index = i;
has_seecodekey_chunk = TRUE;
special_type = 1;
}
//-a by wangyang del seecode upgrade }}
if(special_type != 1)
{
STRCPY(rs232upg_upgtype_chars[i], blk_header.name);
//-a by wangyang del seecode upgrade {{
if(i==1)
{
ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_FIRMWARE),strTmp1);
STRCPY(rs232upg_upgtype_chars[i], strTmp1);
}
else if (i == 2)
{
ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_SEECODE),strTmp2);
STRCPY(rs232upg_upgtype_chars[i],strTmp2);
}
else if (i == 3)
{
ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_LOGO),strTmp3);
STRCPY(rs232upg_upgtype_chars[i], strTmp3);
}
else if (i == 4)
{
ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_CCCAM_PRIO),strTmp4);
STRCPY(rs232upg_upgtype_chars[i], strTmp4);
}
else if (i == 5)
{
ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_CCCAM_NEWCAM),strTmp5);
STRCPY(rs232upg_upgtype_chars[i], strTmp5);
}
else if (i == 6)
{
ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_DEFAULT_DATA),strTmp6);
STRCPY(rs232upg_upgtype_chars[i], strTmp6);
}
else if (i == 7)
{
ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_USER_DATA),strTmp7);
STRCPY(rs232upg_upgtype_chars[i], strTmp7);
}
//-a by wangyang del seecode upgrade }}
}
#else
STRCPY(rs232upg_upgtype_chars[i],blk_header.name);
//-a by wangyang del seecode upgrade {{
seecode_key_ID =SEECODE_CHUNK_ID;
if(((UINT32)blk_header.id) == seecode_key_ID)
{
seecode_chunk_index = i;
has_seecodekey_chunk = TRUE;
//special_type = 1;
}
if(i==1)
{
UINT16 *unistr=NULL;
unistr=OSD_GetUnicodeString(RS_FIRMWARE);
ComUniStrCopyChar(rs232upg_upgtype_chars[1],(UINT16 *)unistr);
//ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_FIRMWARE),strTmp1);
//STRCPY(rs232upg_upgtype_chars[1], strTmp1);
}
else if (i == 2)
{
// ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_SEECODE),strTmp2);
// STRCPY(rs232upg_upgtype_chars[i], strTmp2);
}
else if (i == 3)
{
// ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_LOGO),strTmp3);
// STRCPY(rs232upg_upgtype_chars[i],strTmp3);
}
else if (i == 4)
{
// ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_CCCAM_PRIO),strTmp4);
// STRCPY(rs232upg_upgtype_chars[i], strTmp4);
}
else if (i == 5)
{
// ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_CCCAM_NEWCAM),strTmp5);
// STRCPY(rs232upg_upgtype_chars[i], strTmp5);
}
else if (i == 6)
{
// ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_DEFAULT_DATA),strTmp6);
// STRCPY(rs232upg_upgtype_chars[i], strTmp6);
}
else if (i == 9)
{
// ComUniStrToAsc((UINT8 *)OSD_GetUnicodeString(RS_USER_DATA),strTmp7);
// STRCPY(rs232upg_upgtype_chars[2],strTmp7);
}
//-a by wangyang del seecode upgrade }}
#endif
}
//-a by wangyang del seecode upgrade {{
if(has_seecodekey_chunk == TRUE)
{
FREE(rs232upg_upgtype_chars[seecode_chunk_index]);
for(i=seecode_chunk_index; i<chunk_number;i++)
rs232upg_upgtype_chars[i] = rs232upg_upgtype_chars[i+1];
chunk_number--;
#ifdef HDCP_IN_FLASH
if( (has_seecodekey_chunk == TRUE) && seecode_chunk_index < hdcp_chunk_index)
hdcp_chunk_index --;
if( (has_divx_chunk == TRUE) && seecode_chunk_index < cipluskey_chunk_index)
cipluskey_chunk_index --;
if( (has_divx_chunk == TRUE) && seecode_chunk_index < divx_chunk_index)
divx_chunk_index --;
#endif
}
//-a by wangyang del seecode upgrade }}
#ifdef HDCP_IN_FLASH
if(has_hdcp_chunk == TRUE)
{
FREE(rs232upg_upgtype_chars[hdcp_chunk_index]);
for(i=hdcp_chunk_index; i<chunk_number;i++)
rs232upg_upgtype_chars[i] = rs232upg_upgtype_chars[i+1];
chunk_number--;
if( (has_cipluskey_chunk == TRUE) && hdcp_chunk_index < cipluskey_chunk_index)
cipluskey_chunk_index --;
if( (has_divx_chunk == TRUE) && hdcp_chunk_index < divx_chunk_index)
divx_chunk_index --;
}
#endif
#ifdef DIVX_CERT_ENABLE
if(has_divx_chunk == TRUE)
{
FREE(rs232upg_upgtype_chars[divx_chunk_index]);
for(i=divx_chunk_index; i<chunk_number;i++)
rs232upg_upgtype_chars[i] = rs232upg_upgtype_chars[i+1];
chunk_number--;
if( (has_cipluskey_chunk == TRUE) && divx_chunk_index < cipluskey_chunk_index)
cipluskey_chunk_index --;
}
#endif
#ifdef CI_PLUS_SUPPORT
if(has_cipluskey_chunk == TRUE)
{
FREE(rs232upg_upgtype_chars[cipluskey_chunk_index]);
for(i=cipluskey_chunk_index; i<chunk_number;i++)
rs232upg_upgtype_chars[i] = rs232upg_upgtype_chars[i+1];
chunk_number--;
}
#endif
#if (defined HDCP_IN_FLASH ||defined DIVX_CERT_ENABLE || defined CI_PLUS_SUPPORT )
OSD_SetMultiselSelTable(&rs232upg_sel_upgrade_type,rs232upg_upgtype_chars);
OSD_SetMultiselCount(&rs232upg_sel_upgrade_type, chunk_number);
#else
OSD_SetMultiselSelTable(&rs232upg_sel_upgrade_type,rs232upg_upgtype_chars);
OSD_SetMultiselCount(&rs232upg_sel_upgrade_type, 2);
#endif
}
//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 */
