BOOL keyupg_burnflash(UINT32 chunk_id, char *buffer_adr,UINT32 buffer_size)
{
UINT32 chunk_len,chunk_addr;
UINT32 param;
struct sto_device *f_dev;
UINT32 sector_count=0;
api_get_chuck_addlen(chunk_id, &chunk_addr, &chunk_len);//chunk_addr is the real data addr not include header
if ((f_dev = (struct sto_device *)dev_get_by_id(HLD_DEV_TYPE_STO, 0)) == NULL)
{
libc_printf("ERROR: Not found Flash device!\n");
return FALSE;
}
if(chunk_id==HDCPKEY_CHUNK_ID)
{
//hdcp key,need rewrite bootloader
UINT8 *bootloader_sector = NULL;
CHUNK_HEADER bloader_chuck_hdr;
sto_get_chunk_header(BLOADER_CHUNK_ID,&bloader_chuck_hdr);
bootloader_sector = (UINT8 *)MALLOC(sizeof(UINT8)*(bloader_chuck_hdr.offset));
sto_lseek(f_dev, 0x00, STO_LSEEK_SET);
sto_read(f_dev, bootloader_sector, bloader_chuck_hdr.offset);
/*
param = 0x00;
param = param << 10;
param +=( (SECTOR_SIZE*(bloader_chuck_hdr.offset/SECTOR_SIZE+1)) >> 10);
sto_io_control(f_dev, STO_DRIVER_SECTOR_ERASE, param);
*/
for(sector_count=0;sector_count< ((bloader_chuck_hdr.offset-1)/SECTOR_SIZE+1);sector_count++)
{
param = 0x00+sector_count*SECTOR_SIZE;
param = param << 10; /* Lower 10 bits of LSB is length in K bytes*/
param += SECTOR_SIZE >> 10;
sto_io_control(f_dev, STO_DRIVER_SECTOR_ERASE_EXT, param);
}
sto_lseek(f_dev, 0x00, STO_LSEEK_SET);
sto_write(f_dev, bootloader_sector, bloader_chuck_hdr.offset);
CHUNK_HEADER hdcp_chuck_hdr;
//sto_get_chunk_header(chunk_id,&hdcp_chuck_hdr);
hdcp_chuck_hdr.id = data_change_for_sto(chunk_id);
hdcp_chuck_hdr.len = data_change_for_sto(buffer_size);
hdcp_chuck_hdr.offset = data_change_for_sto(0x200);
hdcp_chuck_hdr.crc = data_change_for_sto(0x4e435243);
strcpy(hdcp_chuck_hdr.name,"HDCPKey");
strcpy(hdcp_chuck_hdr.version,"Encrypted");
strcpy(hdcp_chuck_hdr.time,"2010.09.01");
sto_write(f_dev,&hdcp_chuck_hdr,sizeof(CHUNK_HEADER));
sto_write(f_dev,buffer_adr, buffer_size);
FREE(bootloader_sector);
}
static INT32 BurnBlock(UINT8 *pBuffer, UINT32 Pos, UINT8 NumSectors)
{
struct sto_device *sto_dev = m_StoDevice;
UINT32 param;
INT32 offset, er = SUCCESS;
UINT8 i;
OTA_PRINTF("user_db_start_sector == %d \n", m_ota_info.user_db_start_sector);
OTA_PRINTF("user_db_sectors == %d \n", m_ota_info.user_db_sectors);
OTA_PRINTF("ota_bin_sectors == %d \n", m_ota_info.ota_bin_sectors);
OTA_PRINTF("ota_upg_sectors == %d \n", m_ota_info.ota_upg_sectors);
for(i=0; i<NumSectors; i++)
{
offset = (Pos + i) * C_SECTOR_SIZE;
param = ((UINT32)offset) << 10; // upper 22 bits is offset based on SYS_FLASH_BASE_ADDR
param += C_SECTOR_SIZE >> 10; // lower 10 bits is length in K bytes
OTA_PRINTF("%s: erase sector %d\n", __FUNCTION__, Pos+i);
er = sto_io_control(sto_dev, STO_DRIVER_SECTOR_ERASE, param);
if(er != SUCCESS)
{
OTA_PRINTF("%s: erase sector %d failed\n", __FUNCTION__, i);
break;
}
if(pBuffer)
{
OTA_PRINTF("%s: seek sector %d, offset = %xh\n", __FUNCTION__, Pos+i,offset);
if(sto_lseek(sto_dev, offset, STO_LSEEK_SET) != offset)
{
OTA_PRINTF("%s: seek sector %d failed\n", __FUNCTION__, i);
er = ERR_FAILED;
break;
}
OTA_PRINTF("%s: write sector %d, src = %xh\n", __FUNCTION__, Pos+i,&pBuffer[C_SECTOR_SIZE * i]);
if(sto_write(sto_dev, &pBuffer[C_SECTOR_SIZE * i], C_SECTOR_SIZE) != C_SECTOR_SIZE)
{
OTA_PRINTF("%s: write sector %d failed\n", __FUNCTION__, i);
er = ERR_FAILED;
break;
}
}
StepBurningProgress();
}
OTA_PRINTF("er == %d\n",er);
return er;
}
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 cmd_stbid(unsigned int argc, unsigned char *argv[])
{
UINT8 i = 0, j = 0, ch = 0xff;
UINT8 *_stbid_flag = "SRI";
INT32 _stbid_flag_len = 3;
UINT8 _serial_data[1024]; // max receive 1KB data
UINT32 timeout = 1000, stbid_offset = STB_HWINFO_SERIAL_OFF, _stbid_crc = 0, _stbid_len = 0, _serial_len = 0, _crc = 0, _crc_pos = 0;
UINT8 *buffer = NULL;
UINT32 nReturn = SUCCESS;
UINT32 nPacketNum = 0;
PACKET packet;
UINT32 tick = osal_get_tick();
UINT8 retry_num = 5, _tr_num = 5;
ID _task_id = g_com_ash_id;
osal_task_dispatch_off();
SendStatusPacket(COMMAND_STATUS_OK, 0);
pan_display(g_pan_dev, "Stb-", 4);
RETRY:
_tr_num = 5;
//transfer data
MEMSET(&packet, 0, sizeof(PACKET));
nReturn = packet_receive(&packet, 5 * 1000);
if(SUCCESS != nReturn)
{
SERIAL_DEBUG("receive packet fail!\n");
retry_num--;
goto RETURN;
}
if(packet.packet_type == PACKET_DATA)
{
_serial_len = packet.packet_length-4;
MEMCPY(_serial_data, packet.data_buffer+4, packet.packet_length-4);
}
else
{
SERIAL_DEBUG("receive %d packet, ignore!\n", packet.packet_type);
retry_num--;
goto RETURN;
}
SERIAL_DEBUG("stbid get data total len %d finish, data: \n", _serial_len);
for(i=0; i<_serial_len; i++)
{
SERIAL_DEBUG("%c", _serial_data[i]);
}
SERIAL_DEBUG("\n");
pan_display(g_pan_dev, "GET", 4);
if((_serial_data[0] != _stbid_flag[0]) || (_serial_data[1] != _stbid_flag[1]) || (_serial_data[2] != _stbid_flag[2])) // received flag tag
{
SERIAL_DEBUG("Error: SRI flag missing!\n");
retry_num--;
goto RETURN;
}
pan_display(g_pan_dev, "FLAG", 4);
_stbid_len = _serial_len-4-8;
if(_stbid_len > STB_HWINFO_MAC_OFF)
{
SERIAL_DEBUG("Error: stbid len %d != [%d], please resend cmd!\n", _stbid_len, STB_HWINFO_MAC_OFF);
retry_num--;
goto RETURN;
}
pan_display(g_pan_dev, "LENG", 4);
// do crc check
_crc_pos = _stbid_flag_len+1+_stbid_len;
_stbid_crc = 0;
for(i=0; i<8; i++)
{
_stbid_crc |= (((_serial_data[_crc_pos+i]>'9') ? (_serial_data[_crc_pos+i]-'A'+10) : (_serial_data[_crc_pos+i]-'0'))<<((7-i)*4));
}
_crc = MG_Table_Driven_CRC(0xFFFFFFFF, _serial_data, _crc_pos);
if(_stbid_crc != _crc)
{
// fail, need re-trans
SERIAL_DEBUG("stbid crc fail, calcu = 0x%x!\n", _crc);
retry_num--;
goto RETURN;
}
pan_display(g_pan_dev, "CRC", 4);
// burn code, enable drive auto-erase
for(i=0; i<(STB_HWINFO_OUI_OFF-STB_HWINFO_MAC_OFF); i++) // init mac
{
ch = _serial_data[STB_HWINFO_MAC_OFF+4-12+i*2];
_serial_data[i+STB_HWINFO_MAC_OFF+4] = (((ch>'9') ? ((ch>='a') ? (ch-'a'+10) : (ch-'A'+10)) : (ch-'0'))<<4);
ch = _serial_data[STB_HWINFO_MAC_OFF+4-12+i*2+1];
_serial_data[i+STB_HWINFO_MAC_OFF+4] |= ((ch>'9') ? ((ch>='a') ? (ch-'a'+10) : (ch-'A'+10)) : (ch-'0'));
}
buffer = MALLOC(64*1024);
if(buffer == NULL)
{
SDBBP();
}
sto_io_control(g_sto_dev, STO_DRIVER_SECTOR_BUFFER, (UINT32)buffer);
sto_io_control(g_sto_dev, STO_DRIVER_SET_FLAG, STO_FLAG_AUTO_ERASE|STO_FLAG_SAVE_REST);
SERIAL_DEBUG("Now burn stbid: ");
for(i=0; i<STB_HWINFO_OUI_OFF; i++)
{
SERIAL_DEBUG("%c", _serial_data[i+_stbid_flag_len+1]);
}
SERIAL_DEBUG("\n");
sto_put_data(g_sto_dev, STB_HWINFO_BASE_ADDR, &_serial_data[_stbid_flag_len+1], STB_HWINFO_OUI_OFF);
if(buffer)
{
FREE(buffer);
buffer = NULL;
sto_io_control(g_sto_dev, STO_DRIVER_SECTOR_BUFFER, 0);
sto_io_control(g_sto_dev, STO_DRIVER_SET_FLAG, 0);
}
if(g_stb_hwinfo != NULL)
{
FREE(g_stb_hwinfo);
g_stb_hwinfo = NULL;
}
pan_display(g_pan_dev, "-tr-", 4);
SERIAL_DEBUG("stbid finish, task %d deleted!\n", g_com_ash_id);
SERIAL_DEBUG("cmd_stbid takes %dms\n", osal_get_tick()-tick);
retry_num = 0;
RESEND:
SendStatusPacket(COMMAND_STATUS_DONE, 0);
MEMSET(&packet, 0, sizeof(PACKET));
osal_task_sleep(100);
nReturn = packet_receive(&packet, 5 * 1000);
if((SUCCESS != nReturn) || (packet.packet_type != PACKET_STATUS))
{
if(_tr_num-- > 0)
{
SERIAL_DEBUG("stbid finish, but signal send fail, now re-send!\n");
goto RESEND;
}
else
{
pan_display(g_pan_dev, "dStb", 4); // done, but notice fail!
}
}
else
{
pan_display(g_pan_dev, "-Stb", 4); // done, all ok!
}
RETURN:
if(retry_num >0)
{
SendStatusPacket(COMMAND_STATUS_ERROR, 0);
goto RETRY;
}
else
{
SERIAL_DEBUG("error, please redo!\n");
api_set_com_check_flag(COM_MONITOR_CHECK_STBID);
}
g_com_ash_id = INVALID_ID;
osal_task_dispatch_on();
osal_task_delete(_task_id);
}
