int _main(unsigned zero, unsigned type, unsigned tags)
{
const char *cmdline = 0;
int n;
arm11_clock_init();
/* must do this before board_init() so that we
** use the partition table in the tags if it
** already exists
*/
if((zero == 0) && (type != 0) && tags_okay(tags)) {
linux_type = type;
linux_tags = tags;
cmdline = tags_get_cmdline((void*) linux_tags);
tags_import_partitions((void*) linux_tags);
revision = tags_get_revision((void*) linux_tags);
if(revision == 1) {
console_set_colors(0x03E0, 0xFFFF);
}
if(revision == 2) {
console_set_colors(0x49B2, 0xFFFF);
}
/* we're running as a second-stage, so wait for interrupt */
boot_from_flash = 0;
} else {
linux_type = board_machtype();
linux_tags = 0;
}
board_init();
keypad_init();
console_init();
dprintf_set_putc(uart_putc);
if(linux_tags == 0) {
/* generate atags containing partitions
* from the bootloader, etc
*/
linux_tags = ADDR_TAGS;
create_atags(linux_tags, 0, 0, 0);
}
if (cmdline) {
char *sn = strstr(cmdline, SERIALNO_STR);
if (sn) {
char *s = serialno;
sn += SERIALNO_LEN;
while (*sn && (*sn != ' ') && ((s - serialno) < 31)) {
*s++ = *sn++;
}
*s++ = 0;
}
}
cprintf("\n\nUSB FastBoot: V%s\n", get_fastboot_version());
cprintf("Machine ID: %d v%d\n", linux_type, revision);
cprintf("Build Date: "__DATE__", "__TIME__"\n\n");
cprintf("Serial Number: %s\n\n", serialno[0] ? serialno : "UNKNOWN");
flash_dump_ptn();
flash_init();
/* scan the keyboard a bit */
for(n = 0; n < 50; n++) {
boot_poll();
}
if (boot_from_flash) {
cprintf("\n ** BOOTING LINUX FROM FLASH **\n");
boot_linux_from_flash();
}
usbloader_init();
for(;;) {
usb_poll();
}
return 0;
}
void target_init(void)
{
unsigned offset;
struct flash_info *flash_info;
unsigned total_num_of_blocks;
unsigned next_ptr_start_adr = 0;
unsigned blocks_per_1MB = 8; /* Default value of 2k page size on 256MB flash drive*/
unsigned char slot;
unsigned int base_addr;
int i;
dprintf(INFO, "target_init()\n");
/* Display splash screen if enabled */
#if DISPLAY_SPLASH_SCREEN
display_init();
dprintf(SPEW, "Diplay initialized\n");
display_image_on_screen();
#endif
#if (!ENABLE_NANDWRITE)
keys_init();
keypad_init();
#endif
if (target_is_emmc_boot())
{
/* Must wait for modem-up before we can intialize MMC.
*/
while (readl(MSM_SHARED_BASE + 0x14) != 1);
/* Trying SDC3 first */
slot = 3;
base_addr = mmc_sdc_base[slot - 1];
if(mmc_boot_main(slot, base_addr))
{
/* Trying SDC1 next */
slot = 1;
base_addr = mmc_sdc_base[slot - 1];
if(mmc_boot_main(slot, base_addr))
{
dprintf(CRITICAL, "mmc init failed!");
ASSERT(0);
}
}
return;
}
ptable_init(&flash_ptable);
smem_ptable_init();
flash_init();
flash_info = flash_get_info();
ASSERT(flash_info);
offset = smem_get_apps_flash_start();
if (offset == 0xffffffff)
while(1);
total_num_of_blocks = flash_info->num_blocks;
blocks_per_1MB = (1 << 20) / (flash_info->block_size);
for (i = 0; i < num_parts; i++) {
struct ptentry *ptn = &board_part_list[i];
unsigned len = ((ptn->length) * blocks_per_1MB);
if(ptn->start != 0)
ASSERT(ptn->start == DIFF_START_ADDR);
ptn->start = next_ptr_start_adr;
if(ptn->length == VARIABLE_LENGTH)
{
unsigned length_for_prt = 0;
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) * blocks_per_1MB);
}
len = total_num_of_blocks - (offset + ptn->start + length_for_prt);
ASSERT(len >= 0);
}
next_ptr_start_adr = ptn->start + len;
ptable_add(&flash_ptable, ptn->name, offset + ptn->start,
len, ptn->flags, TYPE_APPS_PARTITION, PERM_WRITEABLE);
}
smem_add_modem_partitions(&flash_ptable);
ptable_dump(&flash_ptable);
flash_set_ptable(&flash_ptable);
}
void target_init(void)
{
struct flash_info *flash_info;
unsigned start_block;
unsigned blocks_per_plen = 1; //blocks per partition length
unsigned nand_num_blocks;
keys_init();
keypad_init();
uint16_t keys[] = {KEY_VOLUMEUP, KEY_VOLUMEDOWN, KEY_SOFT1, KEY_SEND, KEY_CLEAR, KEY_BACK, KEY_HOME};
for(unsigned i=0; i< sizeof(keys)/sizeof(uint16_t); i++)
if (keys_get_state(keys[i]) != 0)
{
display_init();
display_lk_version();
//dprintf(ALWAYS,"key %d pressed\n", i);
break;
}
dprintf(INFO, "htcleo_init\n");
if(get_boot_reason()==2) // booting for offmode charging, start recovery so kernel will charge phone
{
boot_into_recovery = 1;
//dprintf(INFO, "reboot needed... \n");
//reboot(0);
}
dprintf(ALWAYS, "load address %x\n", load_address);
dprintf(INFO, "flash init\n");
flash_init();
flash_info = flash_get_info();
ASSERT(flash_info);
ASSERT(flash_info->num_blocks);
nand_num_blocks = flash_info->num_blocks;
ptable_init(&flash_ptable);
if( strcmp(board_part_list[0].name,"PTABLE-BLK")==0 ) blocks_per_plen =1 ;
else if( strcmp(board_part_list[0].name,"PTABLE-MB")==0 ) blocks_per_plen = (1024*1024)/flash_info->block_size;
else panic("Invalid partition table\n");
start_block = HTCLEO_FLASH_OFFSET;
for (unsigned i = 1; i < num_parts; i++)
{
struct ptentry *ptn = &board_part_list[i];
if( IS_PART_EMPTY(ptn) ) break;
int len = ((ptn->length) * blocks_per_plen);
if( ptn->start == 0 ) ptn->start = start_block;
else if( ptn->start < start_block) panic("Partition %s start %x < %x\n", ptn->name, ptn->start, start_block);
if(ptn->length == 0)
{
unsigned length_for_prt = 0;
if( i<num_parts && !IS_PART_EMPTY((&board_part_list[i+1])) && board_part_list[i+1].start!=0)
{
length_for_prt = board_part_list[i+1].start - ptn->start;
}
else
{
for (unsigned j = i+1; j < num_parts; j++)
{
struct ptentry *temp_ptn = &board_part_list[j];
if( IS_PART_EMPTY(temp_ptn) ) break;
if( temp_ptn->length==0 ) panic("partition %s and %s have variable length\n", ptn->name, temp_ptn->name);
length_for_prt += ((temp_ptn->length) * blocks_per_plen);
}
}
len = (nand_num_blocks - 1 - 186 - 4) - (ptn->start + length_for_prt);
ASSERT(len >= 0);
}
start_block = ptn->start + len;
ptable_add(&flash_ptable, ptn->name, ptn->start, len, ptn->flags, TYPE_APPS_PARTITION, PERM_WRITEABLE);
}
htcleo_ptable_dump(&flash_ptable);
flash_set_ptable(&flash_ptable);
}
void target_init(void)
{
unsigned offset;
struct flash_info *flash_info;
unsigned total_num_of_blocks;
unsigned next_ptr_start_adr = 0;
unsigned blocks_per_1MB = 8; /* Default value of 2k page size on 256MB flash drive*/
int i;
dprintf(INFO, "target_init()\n");
#if (!ENABLE_NANDWRITE)
keys_init();
keypad_init();
#endif
if (target_is_emmc_boot())
return;
ptable_init(&flash_ptable);
smem_ptable_init();
flash_init();
flash_info = flash_get_info();
ASSERT(flash_info);
offset = smem_get_apps_flash_start();
if (offset == 0xffffffff)
while(1);
total_num_of_blocks = flash_info->num_blocks;
blocks_per_1MB = (1 << 20) / (flash_info->block_size);
for (i = 0; i < num_parts; i++) {
struct ptentry *ptn = &board_part_list[i];
unsigned len = ((ptn->length) * blocks_per_1MB);
if(ptn->start != 0)
ASSERT(ptn->start == DIFF_START_ADDR);
ptn->start = next_ptr_start_adr;
if(ptn->length == VARIABLE_LENGTH)
{
unsigned length_for_prt = 0;
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) * blocks_per_1MB);
}
len = (total_num_of_blocks - 1) - (offset + ptn->start + length_for_prt);
ASSERT(len >= 0);
}
next_ptr_start_adr = ptn->start + len;
ptable_add(&flash_ptable, ptn->name, offset + ptn->start,
len, ptn->flags, TYPE_APPS_PARTITION, PERM_WRITEABLE);
}
smem_add_modem_partitions(&flash_ptable);
ptable_dump(&flash_ptable);
flash_set_ptable(&flash_ptable);
}
void board_init(int with_irq)
{
/* Configure the memory interface */
calypso_mem_cfg(CALYPSO_nCS0, 3, CALYPSO_MEM_16bit, 1);
calypso_mem_cfg(CALYPSO_nCS1, 3, CALYPSO_MEM_16bit, 1);
calypso_mem_cfg(CALYPSO_nCS2, 5, CALYPSO_MEM_16bit, 1);
calypso_mem_cfg(CALYPSO_nCS3, 5, CALYPSO_MEM_16bit, 1);
calypso_mem_cfg(CALYPSO_CS4, 0, CALYPSO_MEM_8bit, 1);
calypso_mem_cfg(CALYPSO_nCS6, 0, CALYPSO_MEM_32bit, 1);
calypso_mem_cfg(CALYPSO_nCS7, 0, CALYPSO_MEM_32bit, 0);
/* Set VTCXO_DIV2 = 1, configure PLL for 104 MHz and give ARM half of that */
calypso_clock_set(2, CALYPSO_PLL13_104_MHZ, ARM_MCLK_DIV_2);
/* Configure the RHEA bridge with some sane default values */
calypso_rhea_cfg(0, 0, 0xff, 0, 1, 0, 0);
/* Initialize board-specific GPIO */
board_io_init();
/* Enable bootrom mapping to route exception vectors to RAM */
calypso_bootrom(with_irq);
calypso_exceptions_install();
/* Initialize interrupt controller */
if (with_irq)
irq_init();
sercomm_bind_uart(UART_MODEM);
cons_bind_uart(UART_IRDA);
/* initialize MODEM UART to be used for sercomm */
uart_init(UART_MODEM, with_irq);
uart_baudrate(UART_MODEM, UART_115200);
/* Initialize IRDA UART to be used for old-school console code.
* note: IRDA uart only accessible on C115 and C117 PCB */
uart_init(UART_IRDA, with_irq);
uart_baudrate(UART_IRDA, UART_115200);
/* Initialize hardware timers */
hwtimer_init();
/* Initialize DMA controller */
dma_init();
/* Initialize real time clock */
rtc_init();
/* Initialize system timers (uses hwtimer 2) */
timer_init();
/* Initialize LCD driver (uses I2C) and backlight */
fb_init();
bl_mode_pwl(1);
bl_level(50);
/* Initialize keypad driver */
keypad_init(keymap, with_irq);
/* Initialize ABB driver (uses SPI) */
twl3025_init();
/* Initialize the charging controller */
battery_compal_e88_init();
/* Initialize TIFFS reader (6 sectors of 8 KiB each) */
tiffs_init(0x001f0000, 0x2000, 6);
}
void target_init(void)
{
unsigned offset;
struct flash_info *flash_info;
struct ptentry *board_part_list;
unsigned total_num_of_blocks;
unsigned next_ptr_start_adr = 0;
unsigned blocks_per_1MB = 8; /* Default value of 2k page size on 256MB flash drive */
int i;
dprintf(INFO, "target_init()\n");
#if (!ENABLE_NANDWRITE)
keys_init();
keypad_init();
#endif
if (target_is_emmc_boot()) {
/* Must wait for modem-up before we can intialize MMC.
*/
while (readl(MSM_SHARED_BASE + 0x14) != 1) ;
if (!(dev = mmc_boot_main(MMC_SLOT, MSM_SDC3_BASE))) {
dprintf(CRITICAL, "mmc init failed!");
ASSERT(0);
}
return;
}
ptable_init(&flash_ptable);
smem_ptable_init();
flash_init();
flash_info = flash_get_info();
ASSERT(flash_info);
offset = smem_get_apps_flash_start();
if (offset == 0xffffffff)
while (1) ;
total_num_of_blocks = flash_info->num_blocks;
blocks_per_1MB = (1 << 20) / (flash_info->block_size);
if (target_is_sku3())
board_part_list = board_part_list_sku3;
else
board_part_list = board_part_list_default;
for (i = 0; i < num_parts; i++) {
struct ptentry *ptn = &board_part_list[i];
unsigned len = ((ptn->length) * blocks_per_1MB);
if (ptn->start != 0)
ASSERT(ptn->start == DIFF_START_ADDR);
ptn->start = next_ptr_start_adr;
if (ptn->length == VARIABLE_LENGTH) {
unsigned length_for_prt = 0;
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) * blocks_per_1MB);
}
len =
(total_num_of_blocks - 1) - (offset + ptn->start +
length_for_prt);
ASSERT(len >= 0);
}
next_ptr_start_adr = ptn->start + len;
ptable_add(&flash_ptable, ptn->name, offset + ptn->start,
len, ptn->flags, TYPE_APPS_PARTITION,
PERM_WRITEABLE);
}
smem_add_modem_partitions(&flash_ptable);
ptable_dump(&flash_ptable);
flash_set_ptable(&flash_ptable);
}
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);
}
}
}
void board_init(void)
{
/* Configure the memory interface */
calypso_mem_cfg(CALYPSO_nCS0, 3, CALYPSO_MEM_16bit, 1);
calypso_mem_cfg(CALYPSO_nCS1, 3, CALYPSO_MEM_16bit, 1);
calypso_mem_cfg(CALYPSO_nCS2, 5, CALYPSO_MEM_16bit, 1);
calypso_mem_cfg(CALYPSO_nCS3, 5, CALYPSO_MEM_16bit, 1);
calypso_mem_cfg(CALYPSO_CS4, 0, CALYPSO_MEM_8bit, 1);
calypso_mem_cfg(CALYPSO_nCS6, 0, CALYPSO_MEM_32bit, 1);
calypso_mem_cfg(CALYPSO_nCS7, 0, CALYPSO_MEM_32bit, 0);
/* Set VTCXO_DIV2 = 1, configure PLL for 104 MHz and give ARM half of that */
calypso_clock_set(2, CALYPSO_PLL13_104_MHZ, ARM_MCLK_DIV_2);
/* Configure the RHEA bridge with some sane default values */
calypso_rhea_cfg(0, 0, 0xff, 0, 1, 0, 0);
/* Initialize board-specific GPIO */
board_io_init();
/* Enable bootrom mapping to route exception vectors to RAM */
calypso_bootrom(1);
calypso_exceptions_install();
/* Initialize interrupt controller */
irq_init();
/* initialize MODEM UART to be used for sercomm*/
uart_init(SERCOMM_UART_NR, 1);
uart_baudrate(SERCOMM_UART_NR, UART_115200);
/* Initialize IRDA UART to be used for old-school console code.
* note: IRDA uart only accessible on C115 and C117 PCB */
uart_init(CONS_UART_NR, 1);
uart_baudrate(CONS_UART_NR, UART_115200);
/* Initialize hardware timers */
hwtimer_init();
/* Initialize DMA controller */
dma_init();
/* Initialize real time clock */
rtc_init();
/* Initialize system timers (uses hwtimer 2) */
timer_init();
/* Initialize LCD driver (uses I2C) and backlight */
display = &st7558_display;
display_init();
bl_mode_pwl(1);
bl_level(0);
/* Initialize keypad driver */
keypad_init(1);
/* Initialize ABB driver (uses SPI) */
twl3025_init();
/* enable LEDB driver of Iota for keypad backlight */
twl3025_reg_write(AUXLED, 0x02);
}
void target_init(void)
{
unsigned offset;
struct flash_info *flash_info;
unsigned total_num_of_blocks;
bool start_addr_changed = false;
unsigned next_ptr_start_adr = 0;
int i;
dprintf(INFO, "target_init()\n");
#if (!ENABLE_NANDWRITE)
keys_init();
keypad_init();
#endif
ptable_init(&flash_ptable);
smem_ptable_init();
flash_init();
flash_info = flash_get_info();
ASSERT(flash_info);
offset = smem_get_apps_flash_start();
if (offset == 0xffffffff)
while(1);
total_num_of_blocks = flash_info->num_blocks;
for (i = 0; i < num_parts; i++) {
struct ptentry *ptn = &board_part_list[i];
unsigned len = ptn->length;
if(len == VARIABLE_LENGTH)
{
start_addr_changed = true;
unsigned length_for_prt = 0;
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 - 1) - (offset + ptn->start + 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, TYPE_APPS_PARTITION, PERM_WRITEABLE);
}
smem_add_modem_partitions(&flash_ptable);
ptable_dump(&flash_ptable);
flash_set_ptable(&flash_ptable);
}
