コード例 #1
0
void display_init(void)
{
    struct fbcon_config *fb_cfg;
#if DISPLAY_TYPE_LCDC
    struct lcdc_timing_parameters *lcd_timing;
    mdp_clock_init();
    if (board_machtype() == LINUX_MACHTYPE_8660_FLUID) {
        mmss_pixel_clock_configure(PIXEL_CLK_INDEX_25M);
    } else {
        mmss_pixel_clock_configure(PIXEL_CLK_INDEX_54M);
    }
    lcd_timing = get_lcd_timing();
    fb_cfg = lcdc_init_set( lcd_timing );
    fbcon_setup(fb_cfg);
    fbcon_clear();
    panel_poweron();
#endif
#if DISPLAY_TYPE_MIPI
    mdp_clock_init();
    configure_dsicore_dsiclk();
    configure_dsicore_byteclk();
    configure_dsicore_pclk();

    fb_cfg = mipi_init();
    fbcon_setup(fb_cfg);
#endif

}
コード例 #2
0
void target_uart_init(void)
{
	unsigned target_id = board_machtype();

	switch (target_id) {
	case LINUX_MACHTYPE_8960_SIM:
	case LINUX_MACHTYPE_8960_RUMI3:
	case LINUX_MACHTYPE_8960_CDP:
	case LINUX_MACHTYPE_8960_MTP:
	case LINUX_MACHTYPE_8960_FLUID:
	case LINUX_MACHTYPE_8960_APQ:
	case LINUX_MACHTYPE_8960_LIQUID:

		if(board_baseband() == BASEBAND_SGLTE)
		{
			uart_dm_init(8, 0x1A000000, 0x1A040000);;
		}
		else
		{
			uart_dm_init(5, 0x16400000, 0x16440000);
		}
		break;

	case LINUX_MACHTYPE_8930_CDP:
	case LINUX_MACHTYPE_8930_MTP:
	case LINUX_MACHTYPE_8930_FLUID:

		uart_dm_init(5, 0x16400000, 0x16440000);
		break;

	case LINUX_MACHTYPE_8064_SIM:
	case LINUX_MACHTYPE_8064_RUMI3:
		uart_dm_init(3, 0x16200000, 0x16240000);
		break;

	case LINUX_MACHTYPE_8064_CDP:
	case LINUX_MACHTYPE_8064_MTP:
	case LINUX_MACHTYPE_8064_LIQUID:
		uart_dm_init(7, 0x16600000, 0x16640000);
		break;

	case LINUX_MACHTYPE_8064_MPQ_CDP:
	case LINUX_MACHTYPE_8064_MPQ_HRD:
	case LINUX_MACHTYPE_8064_MPQ_DTV:
		uart_dm_init(5, 0x1A200000, 0x1A240000);
		break;

	case LINUX_MACHTYPE_8627_CDP:
	case LINUX_MACHTYPE_8627_MTP:

		uart_dm_init(5, 0x16400000, 0x16440000);
		break;

	default:
		dprintf(CRITICAL, "uart gsbi not defined for target: %d\n",
			target_id);

		ASSERT(0);
	}
}
コード例 #3
0
struct lcdc_timing_parameters *get_lcd_timing(void)
{
   if (board_machtype() == LINUX_MACHTYPE_8660_FLUID)
		return auo_timing_param();
	else
		return DEFAULT_LCD_TIMING;
}
コード例 #4
0
void ssbi_keypad_init(struct qwerty_keypad_info  *qwerty_kp)
{
    unsigned int mach_id;
    int len;

    len = sizeof(struct gpio_qwerty_kp);
    qwerty_keypad = malloc(len);
    ASSERT(qwerty_keypad);

    memset(qwerty_keypad, 0, len);
    qwerty_keypad->keypad_info = qwerty_kp;

    event_init(&qwerty_keypad->full_scan, false, EVENT_FLAG_AUTOUNSIGNAL);
    timer_initialize(&qwerty_keypad->timer);

    mach_id = board_machtype();
    ssbi_gpio_init(mach_id);

    if(mach_id == LINUX_MACHTYPE_8660_QT)
    {
        mdelay((qwerty_keypad->keypad_info)->settle_time);
#ifdef QT_8660_KEYPAD_HW_BUG
        timer_set_oneshot(&qwerty_keypad->timer, 0, scan_qt_keypad, NULL);
#endif
    }
    else
        timer_set_oneshot(&qwerty_keypad->timer, 0, scan_qwerty_keypad, NULL);

    /* wait for the keypad to complete one full scan */
    event_wait(&qwerty_keypad->full_scan);
}
コード例 #5
0
ファイル: grub.c プロジェクト: sndnvaps/lk-1
int grub_boot(void)
{
	void (*entry)(unsigned, unsigned, unsigned*) = (void*)GRUB_LOADING_ADDRESS_VIRT;

	// load grub into RAM
#ifdef GRUB_BOOT_PARTITION
	if(grub_load_from_mmc()) {
		dprintf(CRITICAL, "%s: failed to load grub from mmc.\n", __func__);
	}
	else goto boot;
#endif

#if !BOOT_2NDSTAGE
	if(grub_load_from_tar()) {
		dprintf(CRITICAL, "%s: failed to load grub from tar.\n", __func__);
	}
	else goto boot;
#endif

	dprintf(CRITICAL, "%s: Couldn't find grub at any known location!\n", __func__);
	return -1;

boot:
	// BOOT !
	dprintf(INFO, "booting GRUB @ %p\n", entry);

#if WITH_APP_DISPLAY_SERVER
	display_server_stop();
#endif

	entry(0, board_machtype(), NULL);
	
	return 0;
}
コード例 #6
0
ファイル: init.c プロジェクト: jsr-d9/android_kernel_lk
int machine_is_qrd7()
{
	if (board_machtype() == MSM8X25_QRD7)
		return 1;
	else
		return 0;
}
コード例 #7
0
ファイル: init.c プロジェクト: jsr-d9/android_kernel_lk
int machine_is_qrd5a()
{
	if (board_machtype() == MSM7X27A_QRD5A)
		return 1;
	else
		return 0;
}
コード例 #8
0
struct lcdc_timing_parameters *get_lcd_timing(void)
{
	if (board_machtype() == LINUX_MACHTYPE_7x30_FLUID) {
		return sharp_timing_param();
	} else {
		return DEFAULT_LCD_TIMING;
	}
}
コード例 #9
0
static int msm7627a_mdp_clock_init(int enable)
{
	int ret = 0;
	unsigned rate = 0;

	rate = panel.panel_info.clk_rate;

	if (enable) {
                /* enable MDP clock in MP to boost display up */
                if (board_machtype() != MSM8X25_QRD5
                        && board_machtype() != MSM8X25Q_SKUD)
                        mdp_clock_init(rate);
	} else {
		mdp_clock_disable();
        }
	return ret;
}
コード例 #10
0
ファイル: keypad.c プロジェクト: ilarrain/lk-thunderg
void keypad_init(void)
{
    unsigned int mach_id;

    mach_id = board_machtype();

    if(mach_id == LINUX_MACHTYPE_8660_QT)
        ssbi_keypad_init(&qt_keypad);
    else
        ssbi_keypad_init(&qwerty_keypad);
}
コード例 #11
0
void panel_poweron(void)
{
#if DISPLAY_TYPE_LCDC
	if (board_machtype() == LINUX_MACHTYPE_7x30_FLUID) {
		sharp_lcdc_on();
	} else {
		panel_backlight(1);
		lcdc_on();
	}
#endif
}
コード例 #12
0
void panel_poweron(void)
{
	if (board_machtype() == LINUX_MACHTYPE_8660_FLUID)
	{
		auo_board_lcd_enable();
	}
	else
	{
		panel_backlight(1);
		lcdc_on();
	}
}
コード例 #13
0
ファイル: init.c プロジェクト: jsr-d9/android_kernel_lk
int machine_is_skua()
{
	int ret = 0;
	unsigned mach_type = board_machtype();

	switch(mach_type) {
		case MSM8X25_SKUA:
			ret = 1;
			break;
		default:
			ret = 0;
	}
	return ret;
}
コード例 #14
0
static void boot_linux(void)
{
    unsigned *tags = (unsigned*) 0x10000100;
    void (*entry)(unsigned,unsigned,unsigned) = (void*) kernel_addr;

    if(linux_type == 0) {
        linux_type = board_machtype();
    }
    
    fixup_tags((unsigned*) linux_tags, tags, cmdline);    

    entry(0, linux_type, tags);
    
    for(;;);
}
コード例 #15
0
ファイル: init.c プロジェクト: HunterNight/lk-ef65l
int target_is_sku3()
{
       int ret = 0;
       unsigned mach_type = 0;

       mach_type = board_machtype();

       switch(mach_type) {
               case MSM7X27A_QRD3:
                        ret = 1;
                        break;
                default:
			ret = 0;
	};
	return ret;
}
コード例 #16
0
ファイル: init.c プロジェクト: HunterNight/lk-ef65l
int machine_is_skud()
{
	int ret = 0;
	unsigned mach_type = board_machtype();

	switch(mach_type) {
		case MSM8X25Q_SKUD_PRIME:
		case MSM8X25Q_SKUD:
		case MSM8X25Q_EVBD:
			ret = 1;
			break;
		default:
			ret = 0;
	}
	return ret;
}
コード例 #17
0
int machine_is_evb()
{
	int ret = 0;
	unsigned mach_type = board_machtype();

	switch(mach_type) {
		case MSM7X27A_EVB:
		case MSM8X25_EVB:
		case MSM8X25_EVT:
			ret = 1;
			break;
		default:
			ret = 0;
	}
	return ret;
}
コード例 #18
0
int machine_is_qrd()
{
	int ret = 0;
	unsigned mach_type = board_machtype();

	switch(mach_type) {
		case MSM7X27A_QRD1:
		case MSM7X27A_QRD3:
		case MSM8X25_QRD7:
			ret = 1;
			break;
		default:
			ret = 0;
	}
	return ret;
}
コード例 #19
0
ファイル: grub.c プロジェクト: sndnvaps/lk-1
static int grub_sideload_handler(void *data)
{
	struct boot_img_hdr *hdr =  (struct boot_img_hdr *)data;
	unsigned kernel_size = ALIGN(hdr->kernel_size, hdr->page_size);
	void* local_kernel_addr = data + hdr->page_size;
	void* local_ramdisk_addr = local_kernel_addr + kernel_size;

	// Load ramdisk & kernel
	memmove((void*) hdr->kernel_addr, local_kernel_addr, hdr->kernel_size);
	memmove((void*) hdr->ramdisk_addr, local_ramdisk_addr, hdr->ramdisk_size);

	// use ramdisk
	if(hdr->ramdisk_size>0) {
		// prepare block api
		priv.index = 0;
		priv.ptn = (unsigned) hdr->ramdisk_addr;
		priv.is_ramdisk = 1;
		tio.blksz = BLOCK_SIZE;
		tio.lba = hdr->ramdisk_size;
		// set bootdev
		grub_bootdev = strdup("hd1");
		grub_bootpath = strdup("/boot/grub");
		grub_found_tar = 1;
	}
	else {
		// set bootdev
		unsigned int index = (unsigned int) partition_get_index(GRUB_BOOT_PARTITION);
		char buf[20];
		sprintf(buf, "hd0,%u", index+1);
		grub_bootdev = strdup(buf);
		grub_bootpath = strdup(GRUB_BOOT_PATH_PREFIX "boot/grub");
	}
	dprintf(INFO, "bootdev: %s\n", grub_bootdev);
	dprintf(INFO, "bootpath: %s\n", grub_bootpath);

	// BOOT !
	void (*entry)(unsigned, unsigned, unsigned*) = (void*)hdr->kernel_addr;
	dprintf(INFO, "booting GRUB from sideload @ %p ramdisk @ %p\n", entry, (void*)hdr->ramdisk_addr);

#if WITH_APP_DISPLAY_SERVER
	display_server_stop();
#endif

	entry(0, board_machtype(), NULL);

	return 0;
}
コード例 #20
0
int target_cont_splash_screen()
{
	int ret = 0;
	unsigned mach_type = 0;

	mach_type = board_machtype();

	switch(mach_type) {
		case MSM8X25_EVB:
		case MSM8X25_EVT:
			ret = 1;
			break;
		default:
			ret = 0;
	};
	return ret;
}
コード例 #21
0
ファイル: init.c プロジェクト: jsr-d9/android_kernel_lk
int machine_is_7x27a_surf_ffa()
{
	int ret = 0;
	unsigned mach_type = board_machtype();

	switch(mach_type) {
		case MSM7X27A_FFA:
		case MSM7X27A_SURF:
		case MSM7X25A_SURF:
		case MSM7X25A_FFA:
			ret = 1;
			break;
		default:
			ret = 0;
	}
	return ret;
}
コード例 #22
0
int machine_is_8x25()
{
	int ret = 0;
	unsigned mach_type = board_machtype();

	switch(mach_type) {
		case MSM8X25_SURF:
		case MSM8X25_FFA:
		case MSM8X25_EVB:
		case MSM8X25_EVT:
		case MSM8X25_QRD7:
			ret = 1;
			break;
		default:
			ret = 0;
	}
	return ret;
}
コード例 #23
0
void cmd_boot(const char *arg, void *data, unsigned sz)
{
	unsigned kernel_actual;
	unsigned ramdisk_actual;
	static struct boot_img_hdr hdr;
	char *ptr = ((char*) data);

	if (sz < sizeof(hdr)) {
		fastboot_fail("invalid bootimage header");
		return;
	}

	memcpy(&hdr, data, sizeof(hdr));

	/* ensure commandline is terminated */
	hdr.cmdline[BOOT_ARGS_SIZE-1] = 0;

	if(target_is_emmc_boot() && hdr.page_size) {
		page_size = hdr.page_size;
		page_mask = page_size - 1;
	}

	kernel_actual = ROUND_TO_PAGE(hdr.kernel_size, page_mask);
	ramdisk_actual = ROUND_TO_PAGE(hdr.ramdisk_size, page_mask);

	if (page_size + kernel_actual + ramdisk_actual < sz) {
		fastboot_fail("incomplete bootimage");
		return;
	}

	memmove((void*) KERNEL_ADDR, ptr + page_size, hdr.kernel_size);
	memmove((void*) RAMDISK_ADDR, ptr + page_size + kernel_actual, hdr.ramdisk_size);

	fastboot_okay("");
	target_battery_charging_enable(0, 1);
	udc_stop();

	boot_linux((void*) KERNEL_ADDR, (void*) TAGS_ADDR,
		   (const char*) hdr.cmdline, board_machtype(),
		   (void*) RAMDISK_ADDR, hdr.ramdisk_size);
}
コード例 #24
0
ファイル: miniloader.c プロジェクト: DeeJay-NuKe/FreeXperia
static void boot_linux(void)
{
    unsigned *tags = (unsigned*) TAGS_ADDR;
    int ret;
    int (*entry)(unsigned,unsigned,unsigned) = (void*) kernel_addr;

    if(linux_type == 0) {
        linux_type = board_machtype();
    }
    if(!cmdline[0]){
        strcpy(cmdline, board_cmdline());
    }
    
    fixup_tags((unsigned*) linux_tags, tags, cmdline);    
    DISPLAY_MSG("entry=%x, entry(%d, %d, %x)\n", entry, 0, linux_type, tags);
    ret = entry(0, linux_type, tags);
    mmu_off();
    DISPLAY_MSG("ok ret=%x\n", ret);
//goroh for re-entry boot-img loading
//    for(;;);
}
コード例 #25
0
ファイル: main.c プロジェクト: npuazm/crespo-bootloader
static void boot_linux(unsigned kaddr)
{
    void (*entry)(unsigned,unsigned,unsigned) = (void*) kaddr;

    entry(0, board_machtype(), ADDR_TAGS);
}
コード例 #26
0
static int lcd_power_on()
{
    uint8_t buffer = 0x0, mask = 0x0, prev_val = 0x0;
    int ret = 0;

    /* Configure LDO L2 TEST Bank 2, to Range Select 0 */
    /* Not updating reference voltage */
    buffer = (0x80);            /* Write mode */
    buffer |= (PM8901_LDO_TEST_BANK(2));    /* Test Bank 2 */
    mask = buffer | LDO_TEST_RANGE_SELECT_MASK;

    if ((ret = pm8901_test_bank_read(&prev_val,
                                     PM8901_LDO_TEST_BANK(2),
                                     PM8901_LDO_L2_TEST_BANK))) {
        return ret;
    }
    if ((ret = pm8901_vreg_write(&buffer, mask, PM8901_LDO_L2_TEST_BANK,
                                 prev_val))) {
        return ret;
    }

    /* Enable LDO L2 at Max Voltage (should be around 3.3v) */
    buffer = (0x0 << PM8901_LDO_CTL_ENABLE__S);
    /* Disable Pull Down */
    buffer |= (0x1 << PM8901_LDO_CTL_PULL_DOWN__S);
    /* Put LDO into normal mode instead of low power mode */
    buffer |= (0x0 << PM8901_LDO_CTL_MODE__S);

	/* Set voltage programming to 3.3V or 2.85V(8660 fluid) */
	if (board_machtype() == LINUX_MACHTYPE_8660_FLUID)
		buffer |= (0xB);
	else
		buffer |= (0xF);

    mask = buffer | LDO_CTL_ENABLE_MASK |
        LDO_CTL_PULL_DOWN_MASK |
        LDO_CTL_NORMAL_POWER_MODE_MASK | LDO_CTL_VOLTAGE_SET_MASK;

    /* Do a normal read here, as to not destroy the value in LDO control */
    if ((ret = pm8901_read(&prev_val, 1, PM8901_LDO_L2))) {
        return ret;
    }
    /* Configure the LDO2 for 3.3V or 2.85V(8660 fluid) */
    ret = pm8901_vreg_write(&buffer, mask, PM8901_LDO_L2, prev_val);

    /* Configure LDO L2 TEST Bank 4, for High Range Mode */
    buffer = (0x80);            /* Write mode */
    buffer |= (PM8901_LDO_TEST_BANK(4));    /* Test Bank 4 */
    buffer |= (0x01);           /* Put into High Range Mode */
    mask = buffer | LDO_TEST_OUTPUT_RANGE_MASK;

    if ((ret = pm8901_test_bank_read(&prev_val,
                                     PM8901_LDO_TEST_BANK(4),
                                     PM8901_LDO_L2_TEST_BANK))) {
        return ret;
    }
    if ((ret = pm8901_vreg_write(&buffer, mask, PM8901_LDO_L2_TEST_BANK,
                                 prev_val))) {
        return ret;
    }

    /* Configure LDO L2 TEST Bank 2, to Range Select 0 */
    buffer = (0x80);            /* Write mode */
    buffer |= (PM8901_LDO_TEST_BANK(2));    /* Test Bank 2 */
    buffer |= (1<<1);           /* For fine step 50 mV */
    buffer |= (1<<3);           /* to update reference voltage */
    mask = buffer | LDO_TEST_RANGE_SELECT_MASK;
    mask |= (1<<2);             /* Setting mask to make ref voltage as 1.25 V */

    if ((ret = pm8901_test_bank_read(&prev_val,
                                     PM8901_LDO_TEST_BANK(2),
                                     PM8901_LDO_L2_TEST_BANK))) {
        return ret;
    }
    if ((ret = pm8901_vreg_write(&buffer, mask, PM8901_LDO_L2_TEST_BANK,
                                 prev_val))) {
        return ret;
    }

    /* Enable PMR for LDO L2 */
    buffer = 0x7F;
    mask = 0x7F;
    if ((ret = pm8901_read(&prev_val, 1, PM8901_PMR_7))) {
        return ret;
    }
    ret = pm8901_vreg_write(&buffer, mask, PM8901_PMR_7, prev_val);
    return ret;
}
コード例 #27
0
ファイル: main.c プロジェクト: npuazm/crespo-bootloader
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;
}
コード例 #28
0
/*
 * USB boot routine
 *
 * Desc: usb boot.
 * Retn: 0 for success, -1 for error.
 */
int usb_boot(unsigned zero, unsigned type, unsigned tags)
{
#ifdef DEBUG
	serial_puts_info("Usb_boot:  In function of usb_boot ...\n");
#endif
	/* see all of files in android-1.5r2/bootable/bootloader/legacy/usbloader */
	unsigned long ram_size;
	unsigned long addr;

	 USB_STATUS status = {NULL, {0, 0}, 0, 0, 0};
         int usb_last_stat;

	/* must do this before board_init() so that we
        ** use the partition table in the tags if it 
        ** already exists 
        */
	linux_type = board_machtype();
	linux_tags = 0;
#ifdef DEBUG	
	serial_puts_info("Usb_boot:  Board init ...\n");
#endif
	board_init();
	ram_size = initdram(0);
/*test*/
    if (ram_size > EMC_LOW_SDRAM_SPACE_SIZE)
                ram_size = EMC_LOW_SDRAM_SPACE_SIZE;
/*test*/
	addr = CFG_SDRAM_BASE + ram_size;

	/* We can reserve some RAM "on top" here. */
	/* round down to next 4 kB limit. */
	addr &= ~(4096 - 1);
#ifdef DEBUG
	serial_puts_info("Usb_boot:  Lcd_setmem ...\n");
#endif
	addr = lcd_setmem(addr);
	fb_base = addr;
#ifdef DEBUG
	serial_puts_info("Usb_boot:  Drv_lcd_init ...\n");
#endif
	drv_lcd_init();
	lcd_console_init();
	
#if 0
	memset(print_buf, 0, PRINT_BUF_MAX);
	strcpy(print_buf, "123456:USB FastBoot:bbb");
	lcd_puts(print_buf);
	memset(print_buf, 0, PRINT_BUF_MAX);
	cprintf(print_buf, ":ABC%dEFG:a\rabc",3);
	lcd_puts(print_buf);
#endif

#if 1
	memset(print_buf, '\0', PRINT_BUF_MAX);
	cprintf(print_buf, "USB FastBoot:  V %s\n", FAST_BOOT_VERSION);
	lcd_puts(print_buf);

	memset(print_buf, '\0', PRINT_BUF_MAX);
	cprintf(print_buf, "Machine ID:    %d v %d\n", linux_type, revision);
	lcd_puts(print_buf);
	
	memset(print_buf, '\0', PRINT_BUF_MAX);
	cprintf(print_buf, "Build Date:    "__DATE__", "__TIME__"\n");
	lcd_puts(print_buf);

	/* memset(print_buf, '\0', PRINT_BUF_MAX); */
	/* cprintf(print_buf, "Serial Number: %s\n", "UNKNOWN"); */
	/* lcd_puts(print_buf); */
#endif

#if 1
	serial_puts_msg("\nUSB FastBoot: V ");
	serial_puts_msg(FAST_BOOT_VERSION);
	serial_puts_msg(" \n");

	serial_puts_msg("Machine ID: ");
	dump_uint(linux_type);
	serial_puts_msg("  v ");
	dump_uint(revision);
	serial_puts_msg(" \n");

	serial_puts_msg("Build Date: ");
	serial_puts_msg(__DATE__);
	serial_puts_msg("  ");
	serial_puts_msg(__TIME__);
	serial_puts_msg("\n");
	
	serial_puts_msg("Serial Number: ");
	if (serialno[0])
		serial_puts_msg(serialno);
	else
		serial_puts_msg("UNKNOWN\n");
#endif
	flash_dump_ptn();
	jz4780_usbloader_init();
        usb_last_stat = 1;

	for(;;) {
            /* if(__usb_detected()) { */
            /*     if(usb_last_stat == 0) { */
            /*         serial_puts("USB status:   ONLINE\n"); */
            /*         memset(print_buf, 0, PRINT_BUF_MAX); */
            /*         cprintf(print_buf, "\rUSB status:   ONLINE"); */
            /*         lcd_puts(print_buf); */
            /*     } */
            /*     usb_last_stat = 1; */
            /* } else { */
            /*     if(usb_last_stat == 1) { */
            /*         serial_puts("USB status:   OFFLINE\n"); */
            /*         memset(print_buf, 0, PRINT_BUF_MAX); */
            /*         cprintf(print_buf, "\rUSB status:  OFFLINE"); */
            /*         lcd_puts(print_buf); */
            /*     } */
            /*     usb_last_stat = 0; */
            /* } */
            jz4780_usb_poll(&status);
	}
	
	return 0;
}
コード例 #29
0
ファイル: sys_commands.c プロジェクト: SonyAimbo/iq456_kernel
void cmd_boot(const char *arg, void *data, unsigned sz)
{
	unsigned kernel_actual;
	unsigned ramdisk_actual;
	static struct boot_img_hdr hdr;
	char *ptr = ((char*) data);
   unsigned page_size = 0;
   unsigned page_mask = 0;
   int strlen = 0;

	if (sz < sizeof(hdr)) {
		fastboot_fail("invalid bootimage header");
		return;
	}

	memcpy(&hdr, data, sizeof(hdr));

  printf("\n============================================================\n");
	hdr.magic[7] = '\0';
  printf("[%s] Android Boot IMG Hdr - Magic 	        : %s\n",MODULE_NAME,hdr.magic);
  printf("[%s] Android Boot IMG Hdr - Kernel Size 	: 0x%x\n",MODULE_NAME,hdr.kernel_size);
  printf("[%s] Android Boot IMG Hdr - Rootfs Size 	: 0x%x\n",MODULE_NAME,hdr.ramdisk_size);
  printf("[%s] Android Boot IMG Hdr - Page Size    	: 0x%x\n",MODULE_NAME,hdr.page_size);
  printf("============================================================\n");

	/* ensure commandline is terminated */
	hdr.cmdline[BOOT_ARGS_SIZE-1] = 0;

	if(hdr.page_size) {
		page_size = hdr.page_size;
		page_mask = page_size - 1;
		//page_mask = 2*1024 ; /*FIXME*/
	}
   else
   {
     printf("[FASTBOOT] Please specify the storage page-size in the boot header!\n");
     fastboot_fail("Please specify the storage page-size in the boot header!\n");
     return;
   }

	kernel_actual = ROUND_TO_PAGE(hdr.kernel_size, page_mask);
	ramdisk_actual = ROUND_TO_PAGE(hdr.ramdisk_size, page_mask);

	/* sz should have atleast raw boot image */
	if (page_size + kernel_actual + ramdisk_actual > sz) {
		fastboot_fail("incomplete bootimage");
		return;
	}

	memmove((void*) hdr.kernel_addr, (ptr + MKIMG_HEADER_SZ + BIMG_HEADER_SZ), hdr.kernel_size);
	memmove((void*) hdr.ramdisk_addr, (ptr + MKIMG_HEADER_SZ + BIMG_HEADER_SZ + kernel_actual), hdr.ramdisk_size);

  strlen += sprintf((const char*) hdr.cmdline, "%s lcm=%1d-%s", hdr.cmdline, DISP_IsLcmFound(), mt_disp_get_lcm_id());
  strlen += sprintf((const char*) hdr.cmdline, "%s fps=%1d", hdr.cmdline, mt_disp_get_lcd_time());

	fastboot_okay("");
	udc_stop();
   mtk_wdt_init(); //re-open wdt

  g_boot_mode = NORMAL_BOOT;

	boot_linux((void*) hdr.kernel_addr, (void*) hdr.tags_addr,
		   (const char*) hdr.cmdline, board_machtype(),
		   (void*) hdr.ramdisk_addr, hdr.ramdisk_size);
#if 0
  unsigned kernel_actual;
  unsigned ramdisk_actual;
  struct boot_img_hdr boot_hdr;
  unsigned int k_pg_cnt = 0;
  unsigned int r_pg_cnt = 0;
  unsigned int b_pg_cnt = 0;
  unsigned int size_b = 0;
  unsigned int pg_sz = 2*1024 ;
  int strlen = 0;

  /*copy hdr data from download_base*/
  memcpy(&boot_hdr, data, sizeof(boot_hdr));

  /* ensure commandline is terminated */
  boot_hdr.cmdline[BOOT_ARGS_SIZE-1] = 0;

  printf("\n============================================================\n");
	boot_hdr.magic[7] = '\0';
  printf("[%s] Android Boot IMG Hdr - Magic 	        : %s\n",MODULE_NAME,boot_hdr.magic);
  printf("[%s] Android Boot IMG Hdr - Kernel Size 	: 0x%x\n",MODULE_NAME,boot_hdr.kernel_size);
  printf("[%s] Android Boot IMG Hdr - Rootfs Size 	: 0x%x\n",MODULE_NAME,boot_hdr.ramdisk_size);
  printf("[%s] Android Boot IMG Hdr - Page Size    	: 0x%x\n",MODULE_NAME,boot_hdr.page_size);
  printf("============================================================\n");

  //***************
  //* check partition magic
  //*
  if (strncmp(boot_hdr.magic,BOOT_MAGIC, sizeof(BOOT_MAGIC))!=0) {
    printf("[%s] boot image header magic error\n", MODULE_NAME);
    return -1;
  }

  g_kmem_off =  (unsigned int)target_get_scratch_address();
  g_kmem_off = g_kmem_off + MKIMG_HEADER_SZ + BIMG_HEADER_SZ;


  if(boot_hdr.kernel_size % pg_sz == 0)
  {
    k_pg_cnt = boot_hdr.kernel_size / pg_sz;
  }
  else
  {
    k_pg_cnt = (boot_hdr.kernel_size / pg_sz) + 1;
  }

  if(boot_hdr.ramdisk_size % pg_sz == 0)
  {
    r_pg_cnt = boot_hdr.ramdisk_size / pg_sz;
  }
  else
  {
    r_pg_cnt = (boot_hdr.ramdisk_size / pg_sz) + 1;
  }

  printf(" > page count of kernel image = %d\n",k_pg_cnt);
  g_rmem_off = g_kmem_off + k_pg_cnt * pg_sz;

  printf(" > kernel mem offset = 0x%x\n",g_kmem_off);
  printf(" > rootfs mem offset = 0x%x\n",g_rmem_off);

  //***************
  //* specify boot image size
  //*
  g_bimg_sz = (k_pg_cnt + r_pg_cnt + 2)* pg_sz;
  printf(" > boot image size = 0x%x\n",g_bimg_sz);

  memmove((void*)CFG_BOOTIMG_LOAD_ADDR , g_kmem_off, boot_hdr.kernel_size);
  memmove((void*)CFG_RAMDISK_LOAD_ADDR , g_rmem_off, boot_hdr.ramdisk_size);

  //custom_port_in_kernel(g_boot_mode, commanline);
  //strlen += sprintf(commanline, "%s lcm=%1d-%s", commanline, DISP_IsLcmFound(), mt_disp_get_lcm_id());
  //strlen += sprintf(commanline, "%s fps=%1d", commanline, mt_disp_get_lcd_time());

  fastboot_okay("");

  udc_stop();

  mtk_wdt_init();
  boot_linux((void *)CFG_BOOTIMG_LOAD_ADDR, (unsigned *)CFG_BOOTARGS_ADDR,
		   (const char*) boot_hdr.cmdline, board_machtype(),
		   (void *)CFG_RAMDISK_LOAD_ADDR, boot_hdr.ramdisk_size);
#endif
}
コード例 #30
0
ファイル: target_display.c プロジェクト: MiCode/mi2_lk
void display_init(void)
{
	unsigned mach_type;
	mach_type = board_machtype();

	dprintf(SPEW, "display_init\n");

	switch (mach_type) {
	case MSM7X27A_SURF:
	case MSM8X25_SURF:
	case MSM7X27A_FFA:
#if MIPI_VIDEO_MODE
		mipi_renesas_video_fwvga_init(&(panel.panel_info));
#else
		mipi_renesas_cmd_fwvga_init(&(panel.panel_info));
#endif
		panel.clk_func = msm7627a_mdp_clock_init;
		panel.power_func = mipi_renesas_panel_dsi_config;
		panel.fb.base = MIPI_FB_ADDR;
		panel.fb.width =  panel.panel_info.xres;
		panel.fb.height =  panel.panel_info.yres;
		panel.fb.stride =  panel.panel_info.xres;
		panel.fb.bpp =  panel.panel_info.bpp;
		panel.fb.format = FB_FORMAT_RGB888;
		panel.mdp_rev = MDP_REV_303;
		break;
	case MSM7X25A_SURF:
	case MSM7X25A_FFA:
#if MIPI_VIDEO_MODE
		mipi_renesas_video_hvga_init(&(panel.panel_info));
#else
		mipi_renesas_cmd_hvga_init(&(panel.panel_info));
#endif
		panel.clk_func = msm7627a_mdp_clock_init;
		panel.power_func = mipi_renesas_panel_dsi_config;
		panel.fb.base = MIPI_FB_ADDR;
		panel.fb.width =  panel.panel_info.xres;
		panel.fb.height =  panel.panel_info.yres;
		panel.fb.stride =  panel.panel_info.xres;
		panel.fb.bpp =  panel.panel_info.bpp;
		panel.fb.format = FB_FORMAT_RGB888;
		panel.mdp_rev = MDP_REV_303;
		break;
	case MSM7X27A_EVB:
	case MSM8X25_EVB:
	case MSM8X25_EVT:
#if MIPI_VIDEO_MODE
		mipi_nt35510_video_wvga_init(&(panel.panel_info));
#else
		mipi_nt35510_cmd_wvga_init(&(panel.panel_info));
#endif
		panel.clk_func = msm7627a_mdp_clock_init;
		panel.power_func = mipi_nt35510_panel_dsi_config;
		panel.fb.base = MIPI_FB_ADDR;
		panel.fb.width =  panel.panel_info.xres;
		panel.fb.height =  panel.panel_info.yres;
		panel.fb.stride =  panel.panel_info.xres;
		panel.fb.bpp =  panel.panel_info.bpp;
		panel.fb.format = FB_FORMAT_RGB888;
		panel.mdp_rev = MDP_REV_303;
		if (mach_type == MSM8X25_EVT)
			panel.rotate = 1;
		break;
	default:
		return;
	};

	if (msm_display_init(&panel)) {
		dprintf(CRITICAL, "Display init failed!\n");
		return;
	}
	display_enabled = 1;
}