void handle_flash(const char *name, unsigned addr, unsigned sz)
{
struct ptentry *ptn;
struct ptable *ptable;
void *data = (void *)addr;
unsigned extra = 0;
ptable = flash_get_ptable();
if (ptable == NULL) {
jtag_fail("partition table doesn't exist");
return;
}
ptn = ptable_find(ptable, name);
if (ptn == NULL) {
jtag_fail("unknown partition name");
return;
}
if (!strcmp(ptn->name, "boot") || !strcmp(ptn->name, "recovery")) {
if (memcmp((void *)data, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
jtag_fail("image is not a boot image");
return;
}
}
if (!strcmp(ptn->name, "system") || !strcmp(ptn->name, "userdata")
|| !strcmp(ptn->name, "persist"))
extra = ((page_size >> 9) * 16);
else
int get_recovery_message(struct recovery_message *out)
{
struct ptentry *ptn;
struct ptable *ptable;
unsigned offset = 0;
unsigned pagesize = flash_page_size();
ptable = flash_get_ptable();
if (ptable == NULL) {
dprintf(CRITICAL, "ERROR: Partition table not found\n");
return -1;
}
ptn = ptable_find(ptable, "misc");
if (ptn == NULL) {
dprintf(CRITICAL, "ERROR: No misc partition found\n");
return -1;
}
offset += (pagesize * MISC_COMMAND_PAGE);
if (flash_read(ptn, offset, (void *) buf, pagesize)) {
dprintf(CRITICAL, "ERROR: Cannot read recovery_header\n");
return -1;
}
memcpy(out, buf, sizeof(*out));
return 0;
}
static int set_ssd_radio_update (char *name)
{
struct ptentry *ptn;
struct ptable *ptable;
unsigned int ssd_cookie[2] = {0x53534443, 0x4F4F4B49};
unsigned pagesize = flash_page_size();
unsigned pagemask = pagesize -1;
unsigned n = 0;
ptable = flash_get_ptable();
if (ptable == NULL) {
dprintf(CRITICAL, "ERROR: Partition table not found\n");
return -1;
}
n = (sizeof(ssd_cookie) + pagemask) & (~pagemask);
ptn = ptable_find(ptable, name);
if (ptn == NULL) {
dprintf(CRITICAL, "ERROR: No %s partition found\n", name);
return -1;
}
if (flash_write(ptn, 0, ssd_cookie, n)) {
dprintf(CRITICAL, "ERROR: flash write fail!\n");
return -1;
}
dprintf(INFO, "FOTA partition written successfully!");
return 0;
}
int read_update_header_for_bootloader(struct update_header *header)
{
struct ptentry *ptn;
struct ptable *ptable;
unsigned offset = 0;
unsigned pagesize = flash_page_size();
ptable = flash_get_ptable();
if (ptable == NULL) {
dprintf(CRITICAL, "ERROR: Partition table not found\n");
return -1;
}
ptn = ptable_find(ptable, "cache");
if (ptn == NULL) {
dprintf(CRITICAL, "ERROR: No cache partition found\n");
return -1;
}
if (flash_read(ptn, offset, buf, pagesize)) {
dprintf(CRITICAL, "ERROR: Cannot read recovery_header\n");
return -1;
}
memcpy(header, buf, sizeof(*header));
if (strncmp((char *) header->MAGIC, UPDATE_MAGIC, UPDATE_MAGIC_SIZE))
{
return -1;
}
return 0;
}
void target_reinit(int option)
{
#if defined(NAND_BOOT_INCLUDE)
#if defined(TNFTL_V8_INCLUDE)
target_init();
#else
unsigned offset;
struct flash_info *flash_info;
int ret, i;
dprintf(INFO, "target_reinit()\n");
if (flash_get_ptable() == NULL) {
target_init();
return;
}
flash_init_ptable();
ptable_init(&flash_ptable);
flash_init();
flash_info = flash_get_info();
ASSERT(flash_info);
if (flash_info->num_blocks)
{
offset = flash_info->offset; // TODO
//dprintf(INFO, "offset: %d\n", offset);
for (i = 0; i < num_parts; i++)
{
struct ptentry *ptn = &board_part_list[i];
dprintf(INFO, "offset: %d ptn->start: %d\n", offset, ptn->start );
ptable_add(&flash_ptable, ptn->name, offset + ptn->start,
ptn->length, ptn->flags);
}
ptable_dump(&flash_ptable);
flash_set_ptable(&flash_ptable);
ret = flash_set_badblktable();
ASSERT( ret == SUCCESS );
}
#endif
#endif
}
int update_firmware_image (struct update_header *header, char *name)
{
struct ptentry *ptn;
struct ptable *ptable;
unsigned offset = 0;
unsigned pagesize = flash_page_size();
unsigned pagemask = pagesize -1;
unsigned n = 0;
void *scratch_addr = target_get_scratch_address();
ptable = flash_get_ptable();
if (ptable == NULL) {
dprintf(CRITICAL, "ERROR: Partition table not found\n");
return -1;
}
ptn = ptable_find(ptable, "cache");
if (ptn == NULL) {
dprintf(CRITICAL, "ERROR: No cache partition found\n");
return -1;
}
offset += header->image_offset;
n = (header->image_length + pagemask) & (~pagemask);
if (flash_read(ptn, offset, scratch_addr, n)) {
dprintf(CRITICAL, "ERROR: Cannot read radio image\n");
return -1;
}
ptn = ptable_find(ptable, name);
if (ptn == NULL) {
dprintf(CRITICAL, "ERROR: No %s partition found\n", name);
return -1;
}
if (flash_write(ptn, 0, scratch_addr, n)) {
dprintf(CRITICAL, "ERROR: flash write fail!\n");
return -1;
}
dprintf(INFO, "Partition writen successfully!");
return 0;
}
int get_target_boot_params(const char *cmdline, const char *part, char **buf)
{
struct ptable *ptable;
int system_ptn_index = -1;
uint32_t buflen = strlen(UBI_CMDLINE) + strlen(" root=ubi0:rootfs ubi.mtd=") + sizeof(int) + 1; /* 1 byte for null character*/
*buf = (char *)malloc(buflen);
if(!(*buf)) {
dprintf(CRITICAL,"Unable to allocate memory for boot params\n");
return -1;
}
ptable = flash_get_ptable();
if (!ptable) {
dprintf(CRITICAL,"WARN: Cannot get flash partition table\n");
free(*buf);
return -1;
}
system_ptn_index = ptable_get_index(ptable, part);
if (system_ptn_index < 0) {
dprintf(CRITICAL,"WARN: Cannot get partition index for %s\n", part);
free(*buf);
return -1;
}
/* Adding command line parameters according to target boot type */
snprintf(*buf, buflen, UBI_CMDLINE);
/*check if cmdline contains "root=" at the beginning of buffer or
* " root=" in the middle of buffer.
*/
if (((!strncmp(cmdline, "root=", strlen("root="))) ||
(strstr(cmdline, " root="))))
dprintf(DEBUG, "DEBUG: cmdline has root=\n");
else
snprintf(*buf+strlen(*buf), buflen, " root=ubi0:rootfs ubi.mtd=%d", system_ptn_index);
/*in success case buf will be freed in the calling function of this*/
return 0;
}
int set_recovery_message(const struct recovery_message *in)
{
struct ptentry *ptn;
struct ptable *ptable;
unsigned offset = 0;
unsigned pagesize = flash_page_size();
unsigned n = 0;
void *scratch_addr = target_get_scratch_address();
ptable = flash_get_ptable();
if (ptable == NULL) {
dprintf(CRITICAL, "ERROR: Partition table not found\n");
return -1;
}
ptn = ptable_find(ptable, "misc");
if (ptn == NULL) {
dprintf(CRITICAL, "ERROR: No misc partition found\n");
return -1;
}
n = pagesize * (MISC_COMMAND_PAGE + 1);
if (flash_read(ptn, offset, scratch_addr, n)) {
dprintf(CRITICAL, "ERROR: Cannot read recovery_header\n");
return -1;
}
offset += (pagesize * MISC_COMMAND_PAGE);
offset += (unsigned) scratch_addr;
memcpy((void *) offset, in, sizeof(*in));
if (flash_write(ptn, 0, scratch_addr, n)) {
dprintf(CRITICAL, "ERROR: flash write fail!\n");
return -1;
}
return 0;
}
static unsigned int get_fota_cookie(void)
{
struct ptentry *ptn;
struct ptable *ptable;
unsigned int cookie = 0;
ptable = flash_get_ptable();
if (ptable == NULL) {
dprintf(CRITICAL, "ERROR: Partition table not found\n");
return 0;
}
ptn = ptable_find(ptable, "fota");
if (ptn == NULL) {
dprintf(CRITICAL, "ERROR: No fota partition found\n");
return 0;
}
if(read_from_flash(ptn, 0, sizeof(unsigned int), &cookie) == -1){
dprintf(CRITICAL,"ERROR: failed to read fota cookie from flash");
return 0;
}
return cookie;
}
void cmd_erase(const char *arg, void *data, unsigned sz)
{
struct ptentry *ptn;
struct ptable *ptable;
ptable = flash_get_ptable();
if (ptable == NULL) {
fastboot_fail("partition table doesn't exist");
return;
}
ptn = ptable_find(ptable, arg);
if (ptn == NULL) {
fastboot_fail("unknown partition name");
return;
}
if (flash_erase(ptn)) {
fastboot_fail("failed to erase partition");
return;
}
fastboot_okay("");
}
void target_init(void)
{
#if defined(NAND_BOOT_INCLUDE)
ASSERT(NAND_MTD_PARTITION_NUM == num_parts);
unsigned offset;
unsigned total_num_of_blocks;
unsigned blocks_per_megabytes;
unsigned next_ptr_start_adr = 0;
int ret, i;
struct flash_info *flash_info;
bool start_addr_changed = false;
unsigned long long nMTDReserved_Num=0; // total number of MTD Reserved Area
TNFTL_MTDBadBlkInfo MTDBadBlkInfo[num_parts];
/////////////////////////////////////////////////////////////////////////////////////////////
unsigned long long nROAreaSize, nPartitionSize = 0;
unsigned long int nBlockSize, nBlockSize_MB;
unsigned int nDevPBpV, nDevBBpZ, nDevBBpV, nRervRate;
unsigned int j, nUserDataArea = 0;
struct ptable sPartition_List;
memset( MTDBadBlkInfo, 0, sizeof(TNFTL_MTDBadBlkInfo) * num_parts );
edi_init();
#endif
dprintf(ALWAYS, "target_init()\n");
keys_init();
keypad_init();
#if defined(BOOTSD_INCLUDE)
if (target_is_emmc_boot())
{
emmc_boot_main();
return ;
}
#endif
#if defined(NAND_BOOT_INCLUDE)
#if defined(TNFTL_V8_INCLUDE)
if (check_fwdn_mode()) {
fwdn_start();
return;
}
flash_boot_main();
#else
if ( ( flash_get_ptable() == NULL ) ) {
ptable_init(&flash_ptable);
flash_set_partnum( num_parts );
flash_init();
flash_info = flash_get_info();
ASSERT(flash_info);
if ( (flash_info->num_blocks) && (!flash_check_table()) )
{
memcpy( sPartition_List.parts, board_part_list, sizeof( struct ptentry ) * num_parts );
flash_get_DevPBpV( &nDevPBpV, &nDevBBpZ, &nMTDReserved_Num );
nROAreaSize = (unsigned long long)( nMTDReserved_Num << 20 );
nBlockSize = flash_info->page_size << flash_info->ShiftPpB; // Set Block Size ( Byte Size )
//nROAreaSize = flash_info->num_blocks * nBlockSize; // Set Total ROArea Size ( Byte Size )
nBlockSize_MB = nBlockSize / ( 1 << 20 );
if( nBlockSize_MB > 1 ) // If Block is over the 1MB. Block must aligned.
{ // ex) Block Size 2MB, If Partition Size is 3MB. Partition Block Number must be 2. not 1.
if( nBlockSize_MB == 2 ) // If Block Size 2MB.
{
for( i = 0; i < num_parts; i++ )
{
if( sPartition_List.parts[i].length & 0x01 )
sPartition_List.parts[i].length++;
}
}
else if ( nBlockSize_MB == 4 ) // If Block Size 4MB
{
unsigned int nDiff_Val;
for( i = 0; i < num_parts; i++ )
{
nDiff_Val = sPartition_List.parts[i].length & 0x03;
if( nDiff_Val )
sPartition_List.parts[i].length += ( 4 - nDiff_Val );
}
}
}
nMTDReserved_Num = ( nMTDReserved_Num << 20 ) / nBlockSize;
nDevBBpV = ( nDevPBpV / 1024 ) * nDevBBpZ;
nRervRate = ( nMTDReserved_Num * 100 ) / nDevPBpV;
nDevBBpV = ( nDevBBpV * nRervRate ) / 100;
if( nRervRate != 0 )
nRervRate = ( 100 / nRervRate );
nMTDReserved_Num = nRervRate + nDevBBpV; // Setup ROArea Reserved Block
if(nMTDReserved_Num == 0)
nMTDReserved_Num = 2;
else if ( nMTDReserved_Num & 0x01 )
nMTDReserved_Num++;
if( flash_info->ExtInterrupt == TRUE )
nMTDReserved_Num = nMTDReserved_Num << 1;
for( i = 0; i < num_parts; i++ )
{
if( sPartition_List.parts[i].length != VARIABLE_LENGTH )
{
sPartition_List.parts[i].length = (unsigned long long)(sPartition_List.parts[i].length << 20); // Convert Length Unit. MByte -> Byte
nPartitionSize += sPartition_List.parts[i].length;
//ND_TRACE("sPartition_List.parts[%d].length:%lld [nPartitionSize:%d]\n", i, sPartition_List.parts[i].length, nPartitionSize);
}
else
{
nUserDataArea = i;
}
}
if( nUserDataArea != 0 )
{
sPartition_List.parts[nUserDataArea].length = nROAreaSize - nPartitionSize; // Calculate UserDataArea Size ( include Rerv Block )
//ND_TRACE("sPartition_List.parts[5].length:%lld [nPartitionSize:%d]\n", i, sPartition_List.parts[5].length, nPartitionSize);
//sPartition_List.parts[nUserDataArea].length -= (nMTDReserved_Num * nBlockSize ); // UserDataArea Size. Reverved Block Removed
}
i = 1;
sPartition_List.parts[0].length /= nBlockSize; // Partition 0 Length ( Block Unit )
MTDBadBlkInfo[0].PartBlkNum = sPartition_List.parts[0].length; // Set Block Number Each Partition
do
{
sPartition_List.parts[i].length /= nBlockSize; // Partition i Length ( Block Unit )
sPartition_List.parts[i].start = sPartition_List.parts[i-1].start + sPartition_List.parts[i-1].length;
MTDBadBlkInfo[i].PartBlkNum = sPartition_List.parts[i].length; // Set Block Number Each Partition
++i;
} while( i < num_parts );
flash_set_rervnum( nMTDReserved_Num ); // Set Reserved Block Number
flash_set_badblkinfo( MTDBadBlkInfo ); // Set Bad Block Table Info. About Block Number Each Partition
for( i = 0; i < num_parts; i++ )
{
ptable_add(&flash_ptable, sPartition_List.parts[i].name, flash_info->offset + sPartition_List.parts[i].start,
sPartition_List.parts[i].length, sPartition_List.parts[i].flags);
}
ND_TRACE("\n-------------- [ Partition Table ] --------------\n");
for( i = 0; i < num_parts; i++ )
{
ND_TRACE(" [Part %2d.%9s] [Start:%4d] [Length:%4d]\n", i, sPartition_List.parts[i].name ,sPartition_List.parts[i].start + flash_info->offset, sPartition_List.parts[i].length );
}
ND_TRACE("-------------------------------------------------\n");
dprintf(INFO, "[NAND ] [Maker:0x%02x ][Device:0x%02x][Page_size:%d]\n",
flash_info->vendor, flash_info->device, flash_info->page_size);
dprintf(INFO, " [Spare_Size:%d][Block_Size:%d][MTD_TotalBlock:%d]\n",
flash_info->spare_size, flash_info->block_size, flash_info->num_blocks);
//dprintf(INFO, " [Spare_Size:%d][Block_Size:%d][MTD_Block:%d][Rerv_Block:%d]\n",
// flash_info->spare_size, flash_info->block_size, flash_info->num_blocks - (U32)nMTDReserved_Num, (U32)nMTDReserved_Num);
//ptable_dump(&flash_ptable);
flash_set_ptable(&flash_ptable);
ret = flash_set_badblktable();
if( ret != SUCCESS )
{
dprintf(INFO, " !!! Fail Create Bad Block Table. [func:%s] [line:%d] !!! \n", __func__, __LINE__ );
ASSERT(-1);
}
flash_set_tablestatus(TRUE);
}
}
#endif
#endif
}
int write_misc(unsigned page_offset, void *buf, unsigned size)
{
const char *ptn_name = "misc";
void *scratch_addr = target_get_scratch_address();
unsigned offset;
unsigned aligned_size;
if (size == 0 || buf == NULL || scratch_addr == NULL)
return -1;
if (target_is_emmc_boot())
{
int index;
unsigned long long ptn;
unsigned long long ptn_size;
index = partition_get_index(ptn_name);
if (index == INVALID_PTN)
{
dprintf(CRITICAL, "No '%s' partition found\n", ptn_name);
return -1;
}
ptn = partition_get_offset(index);
ptn_size = partition_get_size(index);
offset = page_offset * BLOCK_SIZE;
aligned_size = ROUND_TO_PAGE(size, (unsigned)BLOCK_SIZE - 1);
if (ptn_size < offset + aligned_size)
{
dprintf(CRITICAL, "Write request out of '%s' boundaries\n",
ptn_name);
return -1;
}
if (scratch_addr != buf)
memcpy(scratch_addr, buf, size);
if (mmc_write(ptn + offset, aligned_size, (unsigned int *)scratch_addr))
{
dprintf(CRITICAL, "Writing MMC failed\n");
return -1;
}
}
else
{
struct ptentry *ptn;
struct ptable *ptable;
unsigned pagesize = flash_page_size();
ptable = flash_get_ptable();
if (ptable == NULL)
{
dprintf(CRITICAL, "Partition table not found\n");
return -1;
}
ptn = ptable_find(ptable, ptn_name);
if (ptn == NULL)
{
dprintf(CRITICAL, "No '%s' partition found\n", ptn_name);
return -1;
}
offset = page_offset * pagesize;
aligned_size = ROUND_TO_PAGE(size, pagesize - 1);
if (ptn->length < offset + aligned_size)
{
dprintf(CRITICAL, "Write request out of '%s' boundaries\n",
ptn_name);
return -1;
}
if (scratch_addr != buf)
memcpy(scratch_addr, buf, size);
if (flash_write(ptn, offset, scratch_addr, aligned_size)) {
dprintf(CRITICAL, "Writing flash failed\n");
return -1;
}
}
return 0;
}
void target_init(void)
{
ASSERT(NAND_MTD_PARTITION_NUM == num_parts);
unsigned offset;
unsigned total_num_of_blocks;
unsigned blocks_per_megabytes;
unsigned next_ptr_start_adr = 0;
int ret, i;
struct flash_info *flash_info;
bool start_addr_changed = false;
unsigned int nMTDReserved_Num=0; // total number of MTD Reserved Area
TNFTL_MTDBadBlkInfo MTDBadBlkInfo[num_parts];
/////////////////////////////////////////////////////////////////////////////////////////////
unsigned int nROAreaSize, nPartitionSize = 0;
unsigned int nBlockSize, nBlockSize_MB;
unsigned int nDevPBpV, nDevBBpZ, nDevBBpV, nRervRate;
unsigned int j, nUserDataArea = 0;
struct ptable sPartition_List;
memset( MTDBadBlkInfo, 0, sizeof(TNFTL_MTDBadBlkInfo) * num_parts );
dprintf(ALWAYS, "target_init()\n");
#if _EMMC_BOOT_TCC
PARTITION PartitionArr[50];
unsigned int nPartitionCnt = 0;
#endif
#ifdef TRIFLASH_INCLUDE
ioctl_diskinfo_t disk_info;
#endif
#if (!ENABLE_NANDWRITE)
#ifdef BOARD_TCC930X_STB_DEMO
#else
keys_init();
keypad_init();
#endif
#endif
if (target_is_emmc_boot())
{
#if _EMMC_BOOT_TCC
dprintf(INFO, "target_init() emmc_boot\n");
ptable_init(&flash_ptable);
//SDMMC init //MCC
DISK_Ioctl(DISK_DEVICE_TRIFLASH, DEV_INITIALIZE, NULL );
//get flash info? //MCC
DISK_Ioctl(DISK_DEVICE_TRIFLASH, DEV_GET_DISKINFO, (void *)&disk_info);
dprintf(INFO, "disk info: head: %d cylinder: %d sector : %d sector size: %d Total_sectors: %d \n",disk_info.head,disk_info.cylinder,disk_info.sector,disk_info.sector_size,disk_info.Total_sectors);
//ptabel init //MCC
// offset = flash_info->offset;
offset = 0; //fixme
// total_num_of_blocks = flash_info->num_blocks;
total_num_of_blocks=10000000; // fixme
memset(&PartitionArr, 0, sizeof(PARTITION) * 50);
nPartitionCnt = GetLocalPartition(0, PartitionArr);
for(i=0; i<nPartitionCnt; i++)
PrintPartitionInfo(&PartitionArr[i], i);
/* convert partition size to block unit */ //512byte ?
blocks_per_megabytes = 1024*1024 / (disk_info.sector_size);
ASSERT(blocks_per_megabytes);
for (i = 0; i < num_parts; i++) {
struct ptentry *ptn = &board_part_list[i];
if (ptn->length != VARIABLE_LENGTH)
ptn->length *= blocks_per_megabytes;
}
for (i = 0; i < num_parts; i++) {
struct ptentry *ptn = &board_part_list[i];
unsigned len = ptn->length;
if (ptn->start != DIFF_START_ADDR)
{
if(i==2)
{
ptn->start = PartitionArr[1].start;
}
else
{
ptn->start *= blocks_per_megabytes;
}
}
if (len == VARIABLE_LENGTH) {
start_addr_changed = true;
unsigned length_for_prt = ptn->start;
unsigned j;
for (j = i+1; j < num_parts; j++)
{
struct ptentry *temp_ptn = &board_part_list[j];
ASSERT(temp_ptn->length != VARIABLE_LENGTH);
length_for_prt += temp_ptn->length;
}
len = total_num_of_blocks - length_for_prt;
ASSERT(len >= 0);
next_ptr_start_adr = ptn->start + len;
}
if((ptn->start == DIFF_START_ADDR) && (start_addr_changed)) {
ASSERT(next_ptr_start_adr);
ptn->start = next_ptr_start_adr;
next_ptr_start_adr = ptn->start + ptn->length;
}
ptable_add(&flash_ptable, ptn->name, offset + ptn->start,
len, ptn->flags);
}
ptable_dump(&flash_ptable);
flash_set_ptable(&flash_ptable);
#endif
return;
}
if (flash_get_ptable() == NULL) {
ptable_init(&flash_ptable);
flash_set_partnum( num_parts );
flash_init();
flash_info = flash_get_info();
ASSERT(flash_info);
if ( (flash_info->num_blocks) && (!flash_check_table()) )
{
memcpy( sPartition_List.parts, board_part_list, sizeof( struct ptentry ) * num_parts );
nBlockSize = flash_info->page_size << flash_info->ShiftPpB; // Set Block Size ( Byte Size )
nROAreaSize = flash_info->num_blocks * nBlockSize; // Set Total ROArea Size ( Byte Size )
nBlockSize_MB = nBlockSize / ( 1 << 20 );
if( nBlockSize_MB > 1 ) // If Block is over the 1MB. Block must aligned.
{ // ex) Block Size 2MB, If Partition Size is 3MB. Partition Block Number must be 2. not 1.
if( nBlockSize_MB == 2 ) // If Block Size 2MB.
{
for( i = 0; i < num_parts; i++ )
{
if( sPartition_List.parts[i].length & 0x01 )
sPartition_List.parts[i].length++;
}
}
else if ( nBlockSize_MB == 4 ) // If Block Size 4MB
{
unsigned int nDiff_Val;
for( i = 0; i < num_parts; i++ )
{
nDiff_Val = sPartition_List.parts[i].length & 0x03;
if( nDiff_Val )
sPartition_List.parts[i].length += ( 4 - nDiff_Val );
}
}
}
flash_get_DevPBpV( &nDevPBpV, &nDevBBpZ, &nMTDReserved_Num );
nMTDReserved_Num = ( nMTDReserved_Num << 20 ) / nBlockSize;
nDevBBpV = ( nDevPBpV / 1024 ) * nDevBBpZ;
nRervRate = ( nMTDReserved_Num * 100 ) / nDevPBpV;
nDevBBpV = ( nDevBBpV * nRervRate ) / 100;
nRervRate = ( 100 / nRervRate );
nMTDReserved_Num = nRervRate + nDevBBpV; // Setup ROArea Reserved Block
if( nMTDReserved_Num & 0x01 )
nMTDReserved_Num++;
if( flash_info->ExtInterrupt == TRUE )
nMTDReserved_Num = nMTDReserved_Num << 1;
for( i = 0; i < num_parts; i++ )
{
if( sPartition_List.parts[i].length != VARIABLE_LENGTH )
{
sPartition_List.parts[i].length = sPartition_List.parts[i].length << 20; // Convert Length Unit. MByte -> Byte
nPartitionSize += sPartition_List.parts[i].length;
}
else
{
nUserDataArea = i;
}
}
sPartition_List.parts[nUserDataArea].length = nROAreaSize - nPartitionSize; // Calculate UserDataArea Size ( include Rerv Block )
sPartition_List.parts[nUserDataArea].length -= (nMTDReserved_Num * nBlockSize ); // UserDataArea Size. Reverved Block Removed
i = 1;
sPartition_List.parts[0].length /= nBlockSize; // Partition 0 Length ( Block Unit )
MTDBadBlkInfo[0].PartBlkNum = sPartition_List.parts[0].length; // Set Block Number Each Partition
do
{
sPartition_List.parts[i].length /= nBlockSize; // Partition i Length ( Block Unit )
sPartition_List.parts[i].start = sPartition_List.parts[i-1].start + sPartition_List.parts[i-1].length;
MTDBadBlkInfo[i].PartBlkNum = sPartition_List.parts[i].length; // Set Block Number Each Partition
++i;
} while( i < num_parts );
flash_set_rervnum( nMTDReserved_Num ); // Set Reserved Block Number
flash_set_badblkinfo( MTDBadBlkInfo ); // Set Bad Block Table Info. About Block Number Each Partition
for( i = 0; i < num_parts; i++ )
{
ptable_add(&flash_ptable, sPartition_List.parts[i].name, flash_info->offset + sPartition_List.parts[i].start,
sPartition_List.parts[i].length, sPartition_List.parts[i].flags);
}
ND_TRACE("\n-------------- [ Partition Table ] --------------\n");
for( i = 0; i < num_parts; i++ )
{
ND_TRACE(" [Part %2d.%9s] [Start:%4d] [Length:%4d]\n", i, sPartition_List.parts[i].name ,sPartition_List.parts[i].start + flash_info->offset, sPartition_List.parts[i].length );
}
ND_TRACE("-------------------------------------------------\n");
dprintf(INFO, "[NAND ] [Maker:0x%02x ][Device:0x%02x][Page_size:%d]\n",
flash_info->vendor, flash_info->device, flash_info->page_size);
dprintf(INFO, " [Spare_Size:%d][Block_Size:%d][MTD_Block:%d][Rerv_Block:%d]\n",
flash_info->spare_size, flash_info->block_size, flash_info->num_blocks - (U32)nMTDReserved_Num, (U32)nMTDReserved_Num);
//ptable_dump(&flash_ptable);
flash_set_ptable(&flash_ptable);
ret = flash_set_badblktable();
if( ret != SUCCESS )
{
dprintf(INFO, " !!! Fail Create Bad Block Table. [func:%s] [line:%d] !!! \n", __func__, __LINE__ );
ASSERT(-1);
}
flash_set_tablestatus(TRUE);
}
}
}
int boot_linux_from_flash(void)
{
struct boot_img_hdr *hdr = (void*) buf;
unsigned n;
struct ptentry *ptn;
struct ptable *ptable;
unsigned offset = 0;
const char *cmdline;
if (target_is_emmc_boot()) {
hdr = (struct boot_img_hdr *)EMMC_BOOT_IMG_HEADER_ADDR;
if (memcmp(hdr->magic, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
dprintf(CRITICAL, "ERROR: Invalid boot image header\n");
return -1;
}
goto continue_boot;
}
ptable = flash_get_ptable();
if (ptable == NULL) {
dprintf(CRITICAL, "ERROR: Partition table not found\n");
return -1;
}
if(!boot_into_recovery)
{
ptn = ptable_find(ptable, "boot");
if (ptn == NULL) {
dprintf(CRITICAL, "ERROR: No boot partition found\n");
return -1;
}
}
else
{
ptn = ptable_find(ptable, "recovery");
if (ptn == NULL) {
dprintf(CRITICAL, "ERROR: No recovery partition found\n");
return -1;
}
}
if (flash_read(ptn, offset, buf, page_size)) {
dprintf(CRITICAL, "ERROR: Cannot read boot image header\n");
return -1;
}
offset += page_size;
if (memcmp(hdr->magic, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
dprintf(CRITICAL, "ERROR: Invaled boot image heador\n");
return -1;
}
if (hdr->page_size != page_size) {
dprintf(CRITICAL, "ERROR: Invaled boot image pagesize. Device pagesize: %d, Image pagesize: %d\n",page_size,hdr->page_size);
return -1;
}
n = ROUND_TO_PAGE(hdr->kernel_size, page_mask);
if (flash_read(ptn, offset, (void *)hdr->kernel_addr, n)) {
dprintf(CRITICAL, "ERROR: Cannot read kernel image\n");
return -1;
}
offset += n;
n = ROUND_TO_PAGE(hdr->ramdisk_size, page_mask);
if (flash_read(ptn, offset, (void *)hdr->ramdisk_addr, n)) {
dprintf(CRITICAL, "ERROR: Cannot read ramdisk image\n");
return -1;
}
offset += n;
continue_boot:
dprintf(INFO, "\nkernel @ %x (%d bytes)\n", hdr->kernel_addr,
hdr->kernel_size);
dprintf(INFO, "ramdisk @ %x (%d bytes)\n", hdr->ramdisk_addr,
hdr->ramdisk_size);
if(hdr->cmdline[0]) {
cmdline = (char*) hdr->cmdline;
} else {
cmdline = DEFAULT_CMDLINE;
}
dprintf(INFO, "cmdline = '%s'\n", cmdline);
/* TODO: create/pass atags to kernel */
dprintf(INFO, "\nBooting Linux\n");
boot_linux((void *)hdr->kernel_addr, (void *)TAGS_ADDR,
(const char *)cmdline, board_machtype(),
(void *)hdr->ramdisk_addr, hdr->ramdisk_size);
return 0;
}
void boot_linux(void *kernel, unsigned *tags,
const char *cmdline, unsigned machtype,
void *ramdisk, unsigned ramdisk_size)
{
unsigned *ptr = tags;
unsigned pcount = 0;
void (*entry)(unsigned,unsigned,unsigned*) = kernel;
struct ptable *ptable;
int cmdline_len = 0;
int have_cmdline = 0;
int pause_at_bootup = 0;
/* CORE */
*ptr++ = 2;
*ptr++ = 0x54410001;
if (ramdisk_size) {
*ptr++ = 4;
*ptr++ = 0x54420005;
*ptr++ = (unsigned)ramdisk;
*ptr++ = ramdisk_size;
}
ptr = target_atag_mem(ptr);
if (!target_is_emmc_boot()) {
/* Skip NAND partition ATAGS for eMMC boot */
if ((ptable = flash_get_ptable()) && (ptable->count != 0)) {
int i;
for(i=0; i < ptable->count; i++) {
struct ptentry *ptn;
ptn = ptable_get(ptable, i);
if (ptn->type == TYPE_APPS_PARTITION)
pcount++;
}
*ptr++ = 2 + (pcount * (sizeof(struct atag_ptbl_entry) /
sizeof(unsigned)));
*ptr++ = 0x4d534d70;
for (i = 0; i < ptable->count; ++i)
ptentry_to_tag(&ptr, ptable_get(ptable, i));
}
}
if (cmdline && cmdline[0]) {
cmdline_len = strlen(cmdline);
have_cmdline = 1;
}
if (target_is_emmc_boot()) {
cmdline_len += strlen(emmc_cmdline);
}
if (target_pause_for_battery_charge()) {
pause_at_bootup = 1;
cmdline_len += strlen(battchg_pause);
}
if (cmdline_len > 0) {
const char *src;
char *dst;
unsigned n;
/* include terminating 0 and round up to a word multiple */
n = (cmdline_len + 4) & (~3);
*ptr++ = (n / 4) + 2;
*ptr++ = 0x54410009;
dst = (char *)ptr;
if (have_cmdline) {
src = cmdline;
while ((*dst++ = *src++));
}
if (target_is_emmc_boot()) {
src = emmc_cmdline;
if (have_cmdline) --dst;
have_cmdline = 1;
while ((*dst++ = *src++));
}
if (pause_at_bootup) {
src = battchg_pause;
if (have_cmdline) --dst;
while ((*dst++ = *src++));
}
ptr += (n / 4);
}
/* END */
*ptr++ = 0;
*ptr++ = 0;
dprintf(INFO, "booting linux @ %p, ramdisk @ %p (%d)\n",
kernel, ramdisk, ramdisk_size);
if (cmdline)
dprintf(INFO, "cmdline: %s\n", cmdline);
enter_critical_section();
platform_uninit_timer();
arch_disable_cache(UCACHE);
arch_disable_mmu();
#if DISPLAY_SPLASH_SCREEN
display_shutdown();
#endif
entry(0, machtype, tags);
}
int update_firmware_image (struct update_header *header, char *name)
{
struct ptentry *ptn;
struct ptable *ptable;
unsigned offset = 0;
unsigned pagesize = flash_page_size();
unsigned pagemask = pagesize -1;
unsigned n = 0;
ptable = flash_get_ptable();
if (ptable == NULL) {
dprintf(CRITICAL, "ERROR: Partition table not found\n");
return -1;
}
ptn = ptable_find(ptable, "cache");
if (ptn == NULL) {
dprintf(CRITICAL, "ERROR: No cache partition found\n");
return -1;
}
offset += header->image_offset;
n = (header->image_length + pagemask) & (~pagemask);
if (flash_read(ptn, offset, SCRATCH_ADDR, n)) {
dprintf(CRITICAL, "ERROR: Cannot read radio image\n");
return -1;
}
if (!strcmp(name, "radio")) {
ptn = ptable_find(ptable, name);
if (ptn == NULL) {
dprintf(CRITICAL, "ERROR: No %s partition found\n", name);
return -1;
}
if (flash_write(ptn, 0, SCRATCH_ADDR, n)) {
dprintf(CRITICAL, "ERROR: flash write fail!\n");
return -1;
}
} else if (!strcmp(name, "bootloader")) {
#ifdef PLATFORM_TCC
struct ptentry ptn = {
.name = "bootloader",
};
flash_write(&ptn, 0, SCRATCH_ADDR, n);
#endif
}
dprintf(INFO, "Partition writen successfully!");
return 0;
}
/* Bootloader / Recovery Flow
*
* On every boot, the bootloader will read the recovery_message
* from flash and check the command field. The bootloader should
* deal with the command field not having a 0 terminator correctly
* (so as to not crash if the block is invalid or corrupt).
*
* The bootloader will have to publish the partition that contains
* the recovery_message to the linux kernel so it can update it.
*
* if command == "boot-recovery" -> boot recovery.img
* else if command == "update-radio" -> update radio image (below)
* else -> boot boot.img (normal boot)
*
* Radio Update Flow
* 1. the bootloader will attempt to load and validate the header
* 2. if the header is invalid, status="invalid-update", goto #8
* 3. display the busy image on-screen
* 4. if the update image is invalid, status="invalid-radio-image", goto #8
* 5. attempt to update the firmware (depending on the command)
* 6. if successful, status="okay", goto #8
* 7. if failed, and the old image can still boot, status="failed-update"
* 8. write the recovery_message, leaving the recovery field
* unchanged, updating status, and setting command to
* "boot-recovery"
* 9. reboot
*
* The bootloader will not modify or erase the cache partition.
* It is recovery's responsibility to clean up the mess afterwards.
*/
int recovery_init (void)
{
struct recovery_message msg;
struct update_header header;
char partition_name[32];
unsigned valid_command = 0;
// get recovery message
if(get_recovery_message(&msg))
return -1;
if (msg.command[0] != 0 && msg.command[0] != 255) {
dprintf(INFO, "Recovery command: %s\n", msg.command);
}
msg.command[sizeof(msg.command)-1] = '\0'; //Ensure termination
if (!strcmp("boot-recovery",msg.command)) {
valid_command = 1;
strcpy(msg.command, ""); // to safe against multiple reboot into recovery
strcpy(msg.status, "OKAY");
set_recovery_message(&msg); // send recovery message
boot_into_recovery = 1; // Boot in recovery mode
return 0;
}
if (!strcmp("update-radio",msg.command)) {
valid_command = 1;
strcpy(partition_name, "AMSS");
} else if (!strcmp("update-bootloader", msg.command)) {
valid_command = 1;
strcpy(partition_name, "bootloader");
}
if(!valid_command) {
//We need not to do anything
return 0; // Boot in normal mode
}
if (read_update_header_for_bootloader(&header)) {
strcpy(msg.status, "invalid-update");
goto SEND_RECOVERY_MSG;
}
if (update_firmware_image (&header, partition_name)) {
strcpy(msg.status, "failed-update");
goto SEND_RECOVERY_MSG;
}
strcpy(msg.status, "OKAY");
SEND_RECOVERY_MSG:
strcpy(msg.command, "boot-recovery");
set_recovery_message(&msg); // send recovery message
boot_into_recovery = 1; // Boot in recovery mode
reboot_device(0);
return 0;
}
#elif defined(TNFTL_V8_INCLUDE)
static int set_recovery_msg_v8(struct recovery_message *out)
{
char *ptn_name = "misc";
unsigned long long ptn = 0;
unsigned int size = ROUND_TO_PAGE(sizeof(*out),511);
unsigned char data[size];
ptn = flash_ptn_offset(ptn_name);
if(ptn == 0) {
dprintf(CRITICAL,"partition %s doesn't exist\n",ptn_name);
return -1;
}
memcpy(data, out, sizeof(*out));
if (flash_write_tnftl_v8(ptn_name, ptn , size, (unsigned int*)data))
{
dprintf(CRITICAL,"write failure %s %d\n",ptn_name, sizeof(*out));
return -1;
}
return 0;
}
