static void mmc_load_image_fat(struct mmc *mmc)
{
int err;
struct image_header *header;
header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
sizeof(struct image_header));
err = fat_register_device(&mmc->block_dev,
CONFIG_SYS_MMC_SD_FAT_BOOT_PARTITION);
if (err) {
printf("spl: fat register err - %d\n", err);
hang();
}
err = file_fat_read(CONFIG_SPL_FAT_LOAD_PAYLOAD_NAME,
header, sizeof(struct image_header));
if (err <= 0)
goto end;
spl_parse_image_header(header);
err = file_fat_read(CONFIG_SPL_FAT_LOAD_PAYLOAD_NAME,
(u8 *)spl_image.load_addr, 0);
end:
if (err <= 0) {
printf("spl: error reading image %s, err - %d\n",
CONFIG_SPL_FAT_LOAD_PAYLOAD_NAME, err);
hang();
}
}
static int mmc_load_image_fat_os(struct mmc *mmc)
{
int err;
struct image_header *header;
err = file_fat_read(spl_image.args,
(void *)spl_image.args_addr, 0);
if (err <= 0) {
printf("spl: error reading image %s, err - %d\n",
spl_image.args, err);
goto end;
}
header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
sizeof(struct image_header));
err = file_fat_read(spl_image.args, header, sizeof(struct image_header));
if (err <= 0)
goto end;
spl_parse_image_header(header);
return mmc_load_image_fat(mmc, spl_image.os_image);
end:
return err;
}
static int mmc_load_image_fat(struct mmc *mmc, const char *filename)
{
int err;
struct image_header *header;
header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
sizeof(struct image_header));
err = file_fat_read(filename, header, sizeof(struct image_header));
if (err <= 0)
goto end;
spl_parse_image_header(header);
err = file_fat_read(filename, (u8 *)spl_image.load_addr, 0);
end:
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
if (err <= 0)
printf("spl: error reading image %s, err - %d\n",
filename, err);
#endif
return (err <= 0);
}
int spl_load_image_fat_os(struct spl_image_info *spl_image,
struct blk_desc *block_dev, int partition)
{
int err;
__maybe_unused char *file;
err = spl_register_fat_device(block_dev, partition);
if (err)
return err;
#if defined(CONFIG_SPL_ENV_SUPPORT) && defined(CONFIG_SPL_OS_BOOT)
file = env_get("falcon_args_file");
if (file) {
err = file_fat_read(file, (void *)CONFIG_SYS_SPL_ARGS_ADDR, 0);
if (err <= 0) {
printf("spl: error reading image %s, err - %d, falling back to default\n",
file, err);
goto defaults;
}
file = env_get("falcon_image_file");
if (file) {
err = spl_load_image_fat(spl_image, block_dev,
partition, file);
if (err != 0) {
puts("spl: falling back to default\n");
goto defaults;
}
return 0;
} else
puts("spl: falcon_image_file not set in environment, falling back to default\n");
} else
puts("spl: falcon_args_file not set in environment, falling back to default\n");
defaults:
#endif
err = file_fat_read(CONFIG_SPL_FS_LOAD_ARGS_NAME,
(void *)CONFIG_SYS_SPL_ARGS_ADDR, 0);
if (err <= 0) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
printf("%s: error reading image %s, err - %d\n",
__func__, CONFIG_SPL_FS_LOAD_ARGS_NAME, err);
#endif
return -1;
}
return spl_load_image_fat(spl_image, block_dev, partition,
CONFIG_SPL_FS_LOAD_KERNEL_NAME);
}
int fat_fsload_file (char * file_name,unsigned int ddr_addr)
{
long size;
unsigned long count;
block_dev_desc_t *dev_desc=NULL;
int dev=0;
int part=1;
dev_desc = get_dev("sunxi_flash",dev);
if (dev_desc == NULL) {
puts("\n** Invalid boot device **\n");
return -1;
}
if (fat_register_device(dev_desc,part)!=0) {
printf("\n** Unable to use %s %d:%d for fatload **\n",
"sunxi_flash", dev, part);
return -1;
}
count = 0;
size = file_fat_read(file_name, (unsigned char *)ddr_addr, count);
if(size==-1) {
printf("\n** Unable to read \"%s\" from %s %d:%d **\n",
file_name, "sunxi_flash", dev, part);
return -1;
}
return size;
}
static int loadImageFromUsbToRam(const char *pcFileName, void *pvOutBuffer, int *pnOutLength)
{
long nReadFileSize = 0;
int nMaxLength = 0;
if (pcFileName==NULL || pvOutBuffer == NULL || pnOutLength==NULL) {
debug("[loadImageFromUsbToRam] pcFileName: %p pvOutBuffer: %p pnOutLength: %p\n", pcFileName, pvOutBuffer, pnOutLength);
return FALSE;
}
#ifdef CONFIG_ATMEL_LCD
lcd_printf("System is reading image from USB storage, please wait");
#endif
nMaxLength = *pnOutLength;
memset(pvOutBuffer, 0xFF, nMaxLength);
nReadFileSize = file_fat_read(pcFileName, pvOutBuffer, nMaxLength);
if (nReadFileSize < 0) {
debug("[loadImageFromUsbToRam] pcFileName: %p pvOutBuffer: %p pnOutLength: %p\n", pcFileName, pvOutBuffer, pnOutLength);
return FALSE;
}
debug("[loadImageToRam] pcFileName: %s pvOutBuffer: %d nReadFileSize: %d\n", pcFileName, pvOutBuffer, nReadFileSize);
*pnOutLength = nReadFileSize;
#ifdef CONFIG_ATMEL_LCD
lcd_putc('\n');
#endif
return TRUE;
}
int mmc_read_bootloader(int dev)
{
unsigned char ret = 0;
unsigned long offset = ( CFG_LOADADDR - 0x120 );
ret = mmc_init(dev);
if (ret != 0){
printf("\n MMC init failed \n");
return -1;
}
#ifdef CFG_CMD_FAT
long size;
block_dev_desc_t *dev_desc = NULL;
if (fat_boot()) {
dev_desc = mmc_get_dev(dev);
fat_register_device(dev_desc, 1);
size = file_fat_read("u-boot.bin", (unsigned char *)offset, 0);
if (size == -1)
return -1;
} else {
/* FIXME: OMAP4 specific */
mmc_read(dev, 0x200, (unsigned char *)( CFG_LOADADDR - 0x120 ),
0x00060000);
}
#endif
return 0;
}
void env_relocate_spec(void)
{
char buf[CONFIG_ENV_SIZE];
block_dev_desc_t *dev_desc = NULL;
disk_partition_t info;
int dev, part;
int err;
part = get_device_and_partition(FAT_ENV_INTERFACE,
FAT_ENV_DEVICE_AND_PART,
&dev_desc, &info, 1);
if (part < 0)
goto err_env_relocate;
dev = dev_desc->dev;
if (fat_set_blk_dev(dev_desc, &info) != 0) {
printf("\n** Unable to use %s %d:%d for loading the env **\n",
FAT_ENV_INTERFACE, dev, part);
goto err_env_relocate;
}
err = file_fat_read(FAT_ENV_FILE, (uchar *)&buf, CONFIG_ENV_SIZE);
if (err == -1) {
printf("\n** Unable to read \"%s\" from %s%d:%d **\n",
FAT_ENV_FILE, FAT_ENV_INTERFACE, dev, part);
goto err_env_relocate;
}
env_import(buf, 1);
return;
err_env_relocate:
set_default_env(NULL);
}
long fs_read(const char *filename, void *buffer, unsigned long maxsize)
{
#ifdef HTCLEO_SUPPORT_VFAT
return file_fat_read(filename, buffer, maxsize);
#endif
return 0;
}
int mmc_read_bootloader(int dev, int part)
{
long size;
unsigned long offset = CFG_LOADADDR;
block_dev_desc_t *dev_desc = NULL;
unsigned char ret = 0;
ret = mmc_init(dev);
if (ret != 0){
printf("\n MMC init failed \n");
return -1;
}
if (part) { /* FAT Read for extenal SD card */
dev_desc = mmc_get_dev(dev);
size = file_fat_read("u-boot.bin", (unsigned char *)offset, 0);
if (size == -1)
return -1;
} else { /* RAW read for EMMC */
ret = mmc_read(dev, 0x400, (unsigned char *)offset, 0x60000);
if (ret != 1)
return -1;
}
return 0;
}
static int mmc_load_fpga_image_fat(struct mmc *mmc)
{
int err;
int devnum = 0;
const fpga_desc *const desc = fpga_get_desc(devnum);
Xilinx_desc *desc_xilinx = desc->devdesc;
/* FIXME = standard file size + header desc_xilinx->size + 0x6c */
err = file_fat_read(CONFIG_SPL_FPGA_LOAD_ARGS_NAME,
(void *)CONFIG_SPL_FPGA_LOAD_ADDR,
0);
if (err <= 0) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
printf("spl: error reading image %s, err - %d\n",
CONFIG_SPL_FPGA_LOAD_ARGS_NAME, err);
#endif
return -1;
}
#ifdef CONFIG_SPL_FPGA_BIT
return fpga_loadbitstream(devnum, (char *)CONFIG_SPL_FPGA_LOAD_ADDR,
desc_xilinx->size, BIT_FULL);
#else
return fpga_load(devnum, (const void *)CONFIG_SPL_FPGA_LOAD_ADDR,
desc_xilinx->size, BIT_FULL);
#endif
}
int spl_load_image_fat(struct spl_image_info *spl_image,
struct blk_desc *block_dev, int partition,
const char *filename)
{
int err;
struct image_header *header;
err = spl_register_fat_device(block_dev, partition);
if (err)
goto end;
header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
sizeof(struct image_header));
err = file_fat_read(filename, header, sizeof(struct image_header));
if (err <= 0)
goto end;
if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) &&
image_get_magic(header) == FDT_MAGIC) {
struct spl_load_info load;
debug("Found FIT\n");
load.read = spl_fit_read;
load.bl_len = 1;
load.filename = (void *)filename;
load.priv = NULL;
return spl_load_simple_fit(spl_image, &load, 0, header);
} else {
err = spl_parse_image_header(spl_image, header);
if (err)
goto end;
err = file_fat_read(filename,
(u8 *)(uintptr_t)spl_image->load_addr, 0);
}
end:
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
if (err <= 0)
printf("%s: error reading image %s, err - %d\n",
__func__, filename, err);
#endif
return (err <= 0);
}
int do_fat_fsload (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
long size;
unsigned long offset;
unsigned long count;
char buf [12];
block_dev_desc_t *dev_desc=NULL;
int dev=0;
int part=1;
char *ep;
if (argc < 5) {
printf( "usage: fatload <interface> <dev[:part]> "
"<addr> <filename> [bytes]\n");
return 1;
}
dev = (int)simple_strtoul(argv[2], &ep, 16);
dev_desc = get_dev(argv[1],dev);
if (dev_desc == NULL) {
puts("\n** Invalid boot device **\n");
return 1;
}
if (*ep) {
if (*ep != ':') {
puts("\n** Invalid boot device, use `dev[:part]' **\n");
return 1;
}
part = (int)simple_strtoul(++ep, NULL, 16);
}
if (fat_register_device(dev_desc,part)!=0) {
printf("\n** Unable to use %s %d:%d for fatload **\n",
argv[1], dev, part);
return 1;
}
offset = simple_strtoul(argv[3], NULL, 16);
if (argc == 6)
count = simple_strtoul(argv[5], NULL, 16);
else
count = 0;
#ifdef DEBUG
printf("offset = %x\n", (int)offset);
#endif
size = file_fat_read(argv[4], (unsigned char *)offset, count);
if(size==-1) {
printf("\n** Unable to read \"%s\" from %s %d:%d **\n",
argv[4], argv[1], dev, part);
return 1;
}
debug("\n%ld bytes read\n", size);
sprintf(buf, "%lX", size);
setenv("filesize", buf);
return 0;
}
static void mmc_load_image_fat(struct mmc *mmc)
{
s32 err;
struct image_header *header;
char *payloadname;
header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
sizeof(struct image_header));
err = fat_register_device(&mmc->block_dev,
CONFIG_SYS_MMC_SD_FAT_BOOT_PARTITION);
if (err) {
printf("spl: fat register err - %d\n", err);
hang();
}
payloadname = CONFIG_SPL_FAT_LOAD_PAYLOAD_NAME;
err = file_fat_read(payloadname,
(u8 *)header, sizeof(struct image_header));
if (err <= 0) {
payloadname = "u-boot.bin";
err = file_fat_read(payloadname,
(u8 *)header, sizeof(struct image_header));
if (err <= 0) {
goto end;
}
}
spl_parse_image_header(header);
err = file_fat_read(payloadname,
(u8 *)spl_image.load_addr, 0);
end:
if (err <= 0) {
printf("spl: error reading image %s, err - %d\n",
payloadname, err);
hang();
}
}
int do_update_image_name(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
long size;
char linebuf[1024];
char kernel[256];
char rootfs[256];
int i;
block_dev_desc_t *dev_desc=NULL;
dev_desc = get_dev("mmc", 0);
if (dev_desc==NULL) {
puts ("\n** Invalid boot device **\n");
return 1;
}
if (fat_register_device(dev_desc, 1)!=0) {
printf ("\n** Unable to use mmc %d:%d for fatload **\n",0,0);
return 1;
}
if (dev_desc==NULL) {
puts ("\n** Invalid boot device **\n");
return 1;
}
size = file_fat_read ("/images/uEnv.txt", (unsigned char *) linebuf, 0);
if(size==-1) {
printf("\n** Unable to read /images/uEnv.txt\n");
return 1;
}
printf("file size = %ld bytes\n", size);
char *p = strchr(linebuf, '=') + 1;
for(i=0; i<size && *p != '\r' && *p != '\n'; i++) {
kernel[i] = *p++;
}
kernel[i]='\0';
p = strrchr(linebuf, '=') + 1;
int len = size - (p-linebuf);
for(i=0; i<len && *p != '\r' && *p != '\n'; i++) {
rootfs[i]=*p++;
}
rootfs[i]='\0';
printf("kernel:%s\n", kernel);
printf("rootfs:%s\n", rootfs);
//设置环境变量
setenv("kernel", kernel);
setenv("rootfs", rootfs);
return 0;
}
static int mmc_load_image_fat_os(struct mmc *mmc)
{
int err;
err = file_fat_read(CONFIG_SPL_FAT_LOAD_ARGS_NAME,
(void *)CONFIG_SYS_SPL_ARGS_ADDR, 0);
if (err <= 0) {
/*printf("spl: error reading image %s, err - %d\n",
CONFIG_SPL_FAT_LOAD_ARGS_NAME, err);*/
return -1;
}
return mmc_load_image_fat(mmc, CONFIG_SPL_FAT_LOAD_KERNEL_NAME);
}
/**********************************************************
* Routine: mboot_common_load_logo
*
* Description: function to load logo to display
*
**********************************************************/
int mboot_common_load_logo(unsigned long logo_addr, char* filename)
{
int ret;
long len;
#if (CONFIG_COMMANDS & CFG_CMD_FAT)
len = file_fat_read(filename, (unsigned char *)logo_addr, 0);
if (len > 0)
return (int)len;
#endif
ret = mboot_common_load_part(PART_LOGO, logo_addr);
return ret;
}
static int usb_load_image_fat_os(struct usb_device *usb_dev)
{
int err;
err = file_fat_read(CONFIG_SPL_FAT_LOAD_ARGS_NAME,
(void *)CONFIG_SYS_SPL_ARGS_ADDR, 0);
if (err <= 0) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
printf("spl: error reading image %s, err - %d\n",
CONFIG_SPL_FAT_LOAD_ARGS_NAME, err);
#endif
return -1;
}
return usb_load_image_fat(CONFIG_SPL_FAT_LOAD_KERNEL_NAME);
}
/**********************************************************
* Routine: mboot_android_load_factoryimg
*
* Description: main function to load Android Factory Image
*
**********************************************************/
int mboot_android_load_factoryimg(char *part_name, unsigned long addr)
{
int len = 0;
unsigned long start_addr;
//***************
//* not to include unused header
//*
addr = addr - MKIMG_HEADER_SZ - BIMG_HEADER_SZ;
#if (CONFIG_COMMANDS & CFG_CMD_FAT)
len = file_fat_read(part_name, (uchar*)addr, 0);
printf("len = %d, addr = 0x%x\n", len, addr);
printf("part name = %s \n", part_name);
#endif
//***************
//* check kernel header
//*
g_kimg_sz = mboot_android_check_img_info(PART_KERNEL,(part_hdr_t *)(g_kmem_off - MKIMG_HEADER_SZ));
if(g_kimg_sz == -1) {
len = -EIO;
goto exit;
}
//***************
//* check rootfs header
//*
g_rimg_sz = mboot_android_check_img_info(PART_ROOTFS,(part_hdr_t *)(g_rmem_off - MKIMG_HEADER_SZ));
if(g_rimg_sz == -1) {
len = -EIO;
goto exit;
}
if (len < 0) {
len = -EIO;
goto exit;
}
exit:
return len;
}
void env_relocate_spec(void)
{
char buf[CONFIG_ENV_SIZE];
block_dev_desc_t *dev_desc = NULL;
int dev = FAT_ENV_DEVICE;
int part = FAT_ENV_PART;
#ifdef CONFIG_MMC
if (strcmp (FAT_ENV_INTERFACE, "mmc") == 0) {
struct mmc *mmc = find_mmc_device(dev);
if (!mmc) {
printf("no mmc device at slot %x\n", dev);
set_default_env(NULL);
return;
}
mmc->has_init = 0;
mmc_init(mmc);
}
#endif /* CONFIG_MMC */
dev_desc = get_dev(FAT_ENV_INTERFACE, dev);
if (dev_desc == NULL) {
printf("Failed to find %s%d\n",
FAT_ENV_INTERFACE, dev);
set_default_env(NULL);
return;
}
if (fat_register_device(dev_desc, part) != 0) {
printf("Failed to register %s%d:%d\n",
FAT_ENV_INTERFACE, dev, part);
set_default_env(NULL);
return;
}
if (file_fat_read(FAT_ENV_FILE, (unsigned char *)&buf, CONFIG_ENV_SIZE) == -1) {
printf("\n** Unable to read \"%s\" from %s%d:%d **\n",
FAT_ENV_FILE, FAT_ENV_INTERFACE, dev, part);
set_default_env(NULL);
return;
}
env_import(buf, 1);
}
int detect_program_bin(void)
{
int ret, size, count;
u32 *buf;
buf = (u32 *)0xe00000;
fat_register_device(&mmc_blk_dev,1);
//buzzer_off();
size = file_fat_read ("program.bin", buf, 128 * 1024);
if (size > 1 && (buf[0] == 0xea000012 || buf[0] == 0x120000ea))
{
buzzer_on(0);
run_command("go e00000", 0);
buzzer_off();
}
//buzzer_off();
return 0;
}
static int env_fat_load(void)
{
ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
struct blk_desc *dev_desc = NULL;
disk_partition_t info;
int dev, part;
int err;
part = blk_get_device_part_str(CONFIG_ENV_FAT_INTERFACE,
CONFIG_ENV_FAT_DEVICE_AND_PART,
&dev_desc, &info, 1);
if (part < 0)
goto err_env_relocate;
dev = dev_desc->devnum;
if (fat_set_blk_dev(dev_desc, &info) != 0) {
/*
* This printf is embedded in the messages from env_save that
* will calling it. The missing \n is intentional.
*/
printf("Unable to use %s %d:%d... ",
CONFIG_ENV_FAT_INTERFACE, dev, part);
goto err_env_relocate;
}
err = file_fat_read(CONFIG_ENV_FAT_FILE, buf, CONFIG_ENV_SIZE);
if (err == -1) {
/*
* This printf is embedded in the messages from env_save that
* will calling it. The missing \n is intentional.
*/
printf("Unable to read \"%s\" from %s%d:%d... ",
CONFIG_ENV_FAT_FILE, CONFIG_ENV_FAT_INTERFACE, dev, part);
goto err_env_relocate;
}
return env_import(buf, 1);
err_env_relocate:
set_default_env(NULL);
return -EIO;
}
/*
* this is called from board_init() after the hardware has been set up
* and is usable. That seems like a good time to do this.
* Right now the return value is ignored.
*/
int do_auto_update(void)
{
block_dev_desc_t *stor_dev;
long sz;
int i, res = 0, cnt, old_ctrlc;
char *env;
long start, end;
#if 0 /* disable key-press detection to speed up boot-up time */
uchar keypad_status1[2] = {0,0}, keypad_status2[2] = {0,0};
/*
* Read keypad status
*/
i2c_read(I2C_PSOC_KEYPAD_ADDR, 0, 0, keypad_status1, 2);
mdelay(500);
i2c_read(I2C_PSOC_KEYPAD_ADDR, 0, 0, keypad_status2, 2);
/*
* Check keypad
*/
if ( !(keypad_status1[1] & KEYPAD_MASK_LO) ||
(keypad_status1[1] != keypad_status2[1])) {
return 0;
}
#endif
au_usb_stor_curr_dev = -1;
/* start USB */
if (usb_stop() < 0) {
debug ("usb_stop failed\n");
return -1;
}
if (usb_init() < 0) {
debug ("usb_init failed\n");
return -1;
}
/*
* check whether a storage device is attached (assume that it's
* a USB memory stick, since nothing else should be attached).
*/
au_usb_stor_curr_dev = usb_stor_scan(0);
if (au_usb_stor_curr_dev == -1) {
debug ("No device found. Not initialized?\n");
res = -1;
goto xit;
}
/* check whether it has a partition table */
stor_dev = get_dev("usb", 0);
if (stor_dev == NULL) {
debug ("uknown device type\n");
res = -1;
goto xit;
}
if (fat_register_device(stor_dev, 1) != 0) {
debug ("Unable to use USB %d:%d for fatls\n",
au_usb_stor_curr_dev, 1);
res = -1;
goto xit;
}
if (file_fat_detectfs() != 0) {
debug ("file_fat_detectfs failed\n");
}
/*
* now check whether start and end are defined using environment
* variables.
*/
start = -1;
end = 0;
env = getenv("firmware_st");
if (env != NULL)
start = simple_strtoul(env, NULL, 16);
env = getenv("firmware_nd");
if (env != NULL)
end = simple_strtoul(env, NULL, 16);
if (start >= 0 && end && end > start) {
ausize[IDX_FIRMWARE] = (end + 1) - start;
aufl_layout[IDX_FIRMWARE].start = start;
aufl_layout[IDX_FIRMWARE].end = end;
}
start = -1;
end = 0;
env = getenv("kernel_st");
if (env != NULL)
start = simple_strtoul(env, NULL, 16);
env = getenv("kernel_nd");
if (env != NULL)
end = simple_strtoul(env, NULL, 16);
if (start >= 0 && end && end > start) {
ausize[IDX_KERNEL] = (end + 1) - start;
aufl_layout[IDX_KERNEL].start = start;
aufl_layout[IDX_KERNEL].end = end;
}
start = -1;
end = 0;
env = getenv("rootfs_st");
if (env != NULL)
start = simple_strtoul(env, NULL, 16);
env = getenv("rootfs_nd");
if (env != NULL)
end = simple_strtoul(env, NULL, 16);
if (start >= 0 && end && end > start) {
ausize[IDX_ROOTFS] = (end + 1) - start;
aufl_layout[IDX_ROOTFS].start = start;
aufl_layout[IDX_ROOTFS].end = end;
}
/* make certain that HUSH is runnable */
u_boot_hush_start();
/* make sure that we see CTRL-C and save the old state */
old_ctrlc = disable_ctrlc(0);
/* validate the images first */
for (i = 0; i < AU_MAXFILES; i++) {
ulong imsize;
/* just read the header */
sz = file_fat_read(aufile[i], LOAD_ADDR, image_get_header_size ());
debug ("read %s sz %ld hdr %d\n",
aufile[i], sz, image_get_header_size ());
if (sz <= 0 || sz < image_get_header_size ()) {
debug ("%s not found\n", aufile[i]);
ausize[i] = 0;
continue;
}
/* au_check_header_valid() updates ausize[] */
if ((imsize = au_check_header_valid(i, sz)) < 0) {
debug ("%s header not valid\n", aufile[i]);
continue;
}
/* totsize accounts for image size and flash erase size */
totsize += (imsize + (aufl_layout[i].end - aufl_layout[i].start));
}
#ifdef CONFIG_PROGRESSBAR
if (totsize) {
lcd_puts(" Update in progress\n");
lcd_enable();
}
#endif
/* just loop thru all the possible files */
for (i = 0; i < AU_MAXFILES && totsize; i++) {
if (!ausize[i]) {
continue;
}
sz = file_fat_read(aufile[i], LOAD_ADDR, ausize[i]);
debug ("read %s sz %ld hdr %d\n",
aufile[i], sz, image_get_header_size ());
if (sz != ausize[i]) {
printf ("%s: size %ld read %ld?\n", aufile[i], ausize[i], sz);
continue;
}
if (sz <= 0 || sz <= image_get_header_size ()) {
debug ("%s not found\n", aufile[i]);
continue;
}
if (au_check_cksum_valid(i, sz) < 0) {
debug ("%s checksum not valid\n", aufile[i]);
continue;
}
/* this is really not a good idea, but it's what the */
/* customer wants. */
cnt = 0;
do {
res = au_do_update(i, sz);
/* let the user break out of the loop */
if (ctrlc() || had_ctrlc()) {
clear_ctrlc();
break;
}
cnt++;
#ifdef AU_TEST_ONLY
} while (res < 0 && cnt < (AU_MAXFILES + 1));
if (cnt < (AU_MAXFILES + 1))
#else
} while (res < 0);
#endif
}
int do_octbootstage3(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
uint32_t addr, rc;
int rcode = 0;
char *filename;
char *failsafe_filename;
const char *dev_name;
int failsafe;
int size = 0;
int max_size = 0;
int part_no;
int dev_no = 0;
block_dev_desc_t *dev_desc = NULL;
filename = getenv("octeon_stage3_bootloader");
addr = getenv_ulong("octeon_stage3_load_addr", 16,
CONFIG_OCTEON_STAGE3_LOAD_ADDR);
max_size = getenv_ulong("octeon_stage3_max_size", 0,
CONFIG_OCTEON_STAGE3_MAX_SIZE);
dev_no = getenv_ulong("octeon_stage3_devno", 0,
CONFIG_OCTEON_STAGE3_DEVNO);
dev_name = getenv("octeon_stage3_devname");
if (!dev_name)
dev_name = CONFIG_OCTEON_STAGE3_DEVNAME;
dev_desc = get_dev(dev_name, dev_no);
if (!dev_desc) {
printf("Could not find device %s %d\n", dev_name, dev_no);
return -1;
}
part_no = find_bootable_fat_partition(dev_desc);
if (part_no < 0) {
printf("No bootable FAT partition found\n");
return -1;
}
if (fat_register_device(dev_desc, part_no) != 0) {
printf("Unable to use %s %d:%d for FAT partition\n", dev_name,
dev_no, part_no);
}
#ifndef CONFIG_OCTEON_NO_STAGE3_FAILSAFE
failsafe = gpio_direction_input(CONFIG_OCTEON_FAILSAFE_GPIO);
if (!filename) {
failsafe = 1;
}
if (!failsafe) {
size = file_fat_read(filename, (unsigned char *)addr, max_size);
if (size <= 0) {
printf("Could not read %s, trying failsafe\n", filename);
goto failsafe;
}
do_go_exec((void *)addr, argc - 1, argv + 1);
}
failsafe:
failsafe_filename = getenv("octeon_stage3_failsafe_bootloader");
if (!failsafe_filename) {
failsafe_filename = CONFIG_OCTEON_STAGE3_FAILSAFE_FILENAME;
printf("Error: environment variable octeon_stage3_failsafe_bootloader is not set.\n");
return 0;
}
if (failsafe_filename) {
size = file_fat_read(filename, (unsigned char *)addr,
max_size);
if (size <= 0) {
printf("Could not read failsafe bootloader %s, "
"trying %s\n", failsafe_filename,
CONFIG_OCTEON_STAGE3_FAILSAFE_FILENAME);
failsafe_filename = CONFIG_OCTEON_STAGE3_FAILSAFE_FILENAME;
}
} else {
printf("No failsafe available!\n");
return -1;
}
#else
if (!filename)
filename = CONFIG_OCTEON_STAGE3_FILENAME;
size = file_fat_read(filename, (unsigned char *)addr, max_size);
if (size <= 0) {
printf("Could not open stage 3 bootloader %s\n", filename);
return -1;
}
do_go_exec((void *)addr, argc - 1, argv + 1);
#endif
return -1;
}
/**********************************************************
* Routine: mboot_android_check_factoryimg_hdr
*
* Description: this function is called to
* (1) 'read' the header of boot image from nand flash
* (2) 'parse' the header of boot image to obtain
* - (a) kernel image size
* - (b) rootfs image size
* - (c) rootfs offset
*
* Notice : this function must be read first when doing nand / msdc boot
*
**********************************************************/
static int mboot_android_check_factoryimg_hdr(char *part_name, boot_img_hdr *boot_hdr)
{
int len;
ulong addr;
//**********************************
// TODO : fix pg_sz assignment
//**********************************
unsigned int pg_sz = 2*KB ;
//***************
//* read partition header
//*
#if (CONFIG_COMMANDS & CFG_CMD_FAT)
len = file_fat_read(part_name, (uchar*) boot_hdr, sizeof(boot_img_hdr));
if (len < 0) {
printf("[%s] %s Factory image header read error. LINE: %d\n", MODULE_NAME, part_name, __LINE__);
return -1;
}
#endif
printf("\n============================================================\n");
boot_hdr->magic[7] = '\0';
printf("[%s] Android Factory IMG Hdr - Magic : %s\n",MODULE_NAME,boot_hdr->magic);
printf("[%s] Android Factory IMG Hdr - Kernel Size : 0x%x\n",MODULE_NAME,boot_hdr->kernel_size);
printf("[%s] Android Factory IMG Hdr - Rootfs Size : 0x%x\n",MODULE_NAME,boot_hdr->ramdisk_size);
printf("[%s] Android Factory 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] Factory image header magic error\n", MODULE_NAME);
return -1;
}
//***************
//* follow bootimg.h to calculate the location of rootfs
//*
if(len != -1)
{
unsigned int k_pg_cnt = 0;
g_kmem_off = CFG_KIMAGE_LOAD_ADDR;
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;
}
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_fcimg_sz = PART_BLKS_RECOVERY * BLK_SIZE;
printf(" > Factory image size = 0x%x\n", g_rcimg_sz);
}
return 0;
}
/*
* this is called from board_init() after the hardware has been set up
* and is usable. That seems like a good time to do this.
* Right now the return value is ignored.
*/
int
do_auto_update(void)
{
block_dev_desc_t *stor_dev;
long sz;
int i, res = 0, bitmap_first, cnt, old_ctrlc, got_ctrlc;
char *env;
long start, end;
#undef ERASE_EEPROM
#ifdef ERASE_EEPROM
int arr[18];
memset(arr, 0, sizeof(arr));
i2c_write_multiple(0x54, 64, 1, arr, sizeof(arr));
#endif
au_usb_stor_curr_dev = -1;
/* start USB */
if (usb_stop() < 0) {
debug ("usb_stop failed\n");
return -1;
}
if (usb_init() < 0) {
debug ("usb_init failed\n");
return -1;
}
/*
* check whether a storage device is attached (assume that it's
* a USB memory stick, since nothing else should be attached).
*/
au_usb_stor_curr_dev = usb_stor_scan(0);
if (au_usb_stor_curr_dev == -1) {
debug ("No device found. Not initialized?\n");
res = -1;
goto xit;
}
/* check whether it has a partition table */
stor_dev = get_dev("usb", 0);
if (stor_dev == NULL) {
debug ("uknown device type\n");
res = -1;
goto xit;
}
if (fat_register_device(stor_dev, 1) != 0) {
debug ("Unable to use USB %d:%d for fatls\n",
au_usb_stor_curr_dev, 1);
res = -1;
goto xit;
}
if (file_fat_detectfs() != 0) {
debug ("file_fat_detectfs failed\n");
}
/* initialize the array of file names */
memset(aufile, 0, sizeof(aufile));
aufile[IDX_PREPARE] = AU_PREPARE;
aufile[IDX_PREINST] = AU_PREINST;
aufile[IDX_FIRMWARE] = AU_FIRMWARE;
aufile[IDX_KERNEL] = AU_KERNEL;
aufile[IDX_APP] = AU_APP;
aufile[IDX_DISK] = AU_DISK;
aufile[IDX_POSTINST] = AU_POSTINST;
/* initialize the array of flash sizes */
memset(ausize, 0, sizeof(ausize));
ausize[IDX_FIRMWARE] = (AU_FL_FIRMWARE_ND + 1) - AU_FL_FIRMWARE_ST;
ausize[IDX_KERNEL] = (AU_FL_KERNEL_ND + 1) - AU_FL_KERNEL_ST;
ausize[IDX_APP] = (AU_FL_APP_ND + 1) - AU_FL_APP_ST;
ausize[IDX_DISK] = (AU_FL_DISK_ND + 1) - AU_FL_DISK_ST;
/*
* now check whether start and end are defined using environment
* variables.
*/
start = -1;
end = 0;
env = getenv("firmware_st");
if (env != NULL)
start = simple_strtoul(env, NULL, 16);
env = getenv("firmware_nd");
if (env != NULL)
end = simple_strtoul(env, NULL, 16);
if (start >= 0 && end && end > start) {
ausize[IDX_FIRMWARE] = (end + 1) - start;
aufl_layout[0].start = start;
aufl_layout[0].end = end;
}
start = -1;
end = 0;
env = getenv("kernel_st");
if (env != NULL)
start = simple_strtoul(env, NULL, 16);
env = getenv("kernel_nd");
if (env != NULL)
end = simple_strtoul(env, NULL, 16);
if (start >= 0 && end && end > start) {
ausize[IDX_KERNEL] = (end + 1) - start;
aufl_layout[1].start = start;
aufl_layout[1].end = end;
}
start = -1;
end = 0;
env = getenv("app_st");
if (env != NULL)
start = simple_strtoul(env, NULL, 16);
env = getenv("app_nd");
if (env != NULL)
end = simple_strtoul(env, NULL, 16);
if (start >= 0 && end && end > start) {
ausize[IDX_APP] = (end + 1) - start;
aufl_layout[2].start = start;
aufl_layout[2].end = end;
}
start = -1;
end = 0;
env = getenv("disk_st");
if (env != NULL)
start = simple_strtoul(env, NULL, 16);
env = getenv("disk_nd");
if (env != NULL)
end = simple_strtoul(env, NULL, 16);
if (start >= 0 && end && end > start) {
ausize[IDX_DISK] = (end + 1) - start;
aufl_layout[3].start = start;
aufl_layout[3].end = end;
}
/* make certain that HUSH is runnable */
u_boot_hush_start();
/* make sure that we see CTRL-C and save the old state */
old_ctrlc = disable_ctrlc(0);
bitmap_first = 0;
/* just loop thru all the possible files */
for (i = 0; i < AU_MAXFILES; i++) {
/* just read the header */
sz = file_fat_read(aufile[i], LOAD_ADDR, image_get_header_size ());
debug ("read %s sz %ld hdr %d\n",
aufile[i], sz, image_get_header_size ());
if (sz <= 0 || sz < image_get_header_size ()) {
debug ("%s not found\n", aufile[i]);
continue;
}
if (au_check_header_valid(i, sz) < 0) {
debug ("%s header not valid\n", aufile[i]);
continue;
}
sz = file_fat_read(aufile[i], LOAD_ADDR, MAX_LOADSZ);
debug ("read %s sz %ld hdr %d\n",
aufile[i], sz, image_get_header_size ());
if (sz <= 0 || sz <= image_get_header_size ()) {
debug ("%s not found\n", aufile[i]);
continue;
}
if (au_check_cksum_valid(i, sz) < 0) {
debug ("%s checksum not valid\n", aufile[i]);
continue;
}
#ifdef CONFIG_VFD
/* now that we have a valid file we can display the */
/* bitmap. */
if (bitmap_first == 0) {
env = getenv("bitmap2");
if (env == NULL) {
trab_vfd(0);
} else {
/* not so simple - bitmap2 is supposed to */
/* contain the address of the bitmap */
env = (char *)simple_strtoul(env, NULL, 16);
/* NOTE: these are taken from vfd_logo.h. If that file changes then */
/* these defines MUST also be updated! These may be wrong for bitmap2. */
#define VFD_LOGO_WIDTH 112
#define VFD_LOGO_HEIGHT 72
/* must call transfer_pic directly */
transfer_pic(3, (unsigned char *)env,
VFD_LOGO_HEIGHT, VFD_LOGO_WIDTH);
}
bitmap_first = 1;
}
#endif
/* this is really not a good idea, but it's what the */
/* customer wants. */
cnt = 0;
got_ctrlc = 0;
do {
res = au_do_update(i, sz);
/* let the user break out of the loop */
if (ctrlc() || had_ctrlc()) {
clear_ctrlc();
if (res < 0)
got_ctrlc = 1;
break;
}
cnt++;
#ifdef AU_TEST_ONLY
} while (res < 0 && cnt < 3);
if (cnt < 3)
#else
} while (res < 0);
#endif
/*
* it doesn't make sense to update the EEPROM if the
* update was interrupted by the user due to errors.
*/
if (got_ctrlc == 0)
au_update_eeprom(i);
else
/* enable the power switch */
*CPLD_VFD_BK &= ~POWER_OFF;
}
