static int splash_select_fs_dev(struct splash_location *location)
{
int res;
switch (location->storage) {
case SPLASH_STORAGE_MMC:
res = fs_set_blk_dev("mmc", location->devpart, FS_TYPE_ANY);
break;
case SPLASH_STORAGE_USB:
res = fs_set_blk_dev("usb", location->devpart, FS_TYPE_ANY);
break;
case SPLASH_STORAGE_SATA:
res = fs_set_blk_dev("sata", location->devpart, FS_TYPE_ANY);
break;
case SPLASH_STORAGE_NAND:
if (location->ubivol != NULL)
res = fs_set_blk_dev("ubi", NULL, FS_TYPE_UBIFS);
else
res = -ENODEV;
break;
default:
printf("Error: unsupported location storage.\n");
return -ENODEV;
}
if (res)
printf("Error: could not access storage.\n");
return res;
}
/**
* fw_get_filesystem_firmware - load firmware into an allocated buffer.
* @dev: An instance of a driver.
*
* Return: Size of total read, negative value when error.
*/
static int fw_get_filesystem_firmware(struct udevice *dev)
{
loff_t actread;
char *storage_interface, *dev_part, *ubi_mtdpart, *ubi_volume;
int ret;
storage_interface = env_get("storage_interface");
dev_part = env_get("fw_dev_part");
ubi_mtdpart = env_get("fw_ubi_mtdpart");
ubi_volume = env_get("fw_ubi_volume");
if (storage_interface && dev_part) {
ret = fs_set_blk_dev(storage_interface, dev_part, FS_TYPE_ANY);
} else if (storage_interface && ubi_mtdpart && ubi_volume) {
ret = mount_ubifs(ubi_mtdpart, ubi_volume);
if (ret)
return ret;
if (!strcmp("ubi", storage_interface))
ret = fs_set_blk_dev(storage_interface, NULL,
FS_TYPE_UBIFS);
else
ret = -ENODEV;
} else {
ret = select_fs_dev(dev->platdata);
}
if (ret)
goto out;
struct firmware *firmwarep = dev_get_priv(dev);
if (!firmwarep)
return -ENOMEM;
ret = fs_read(firmwarep->name, (ulong)map_to_sysmem(firmwarep->data),
firmwarep->offset, firmwarep->size, &actread);
if (ret) {
debug("Error: %d Failed to read %s from flash %lld != %zu.\n",
ret, firmwarep->name, actread, firmwarep->size);
} else {
ret = actread;
}
out:
#ifdef CONFIG_CMD_UBIFS
umount_ubifs();
#endif
return ret;
}
static size_t usb_read_file(const char *file_name)
{
loff_t act_read = 0;
struct udevice *dev;
int rc;
usb_stop();
if (usb_init() < 0) {
printf("Error: usb_init failed\n");
return 0;
}
/* Try to recognize storage devices immediately */
blk_first_device(IF_TYPE_USB, &dev);
if (!dev) {
printf("Error: USB storage device not found\n");
return 0;
}
/* Always load from usb 0 */
if (fs_set_blk_dev("usb", "0", FS_TYPE_ANY)) {
printf("Error: USB 0 not found\n");
return 0;
}
/* Perfrom file read */
rc = fs_read(file_name, get_load_addr(), 0, 0, &act_read);
if (rc)
return 0;
return act_read;
}
static size_t mmc_read_file(const char *file_name)
{
loff_t act_read = 0;
int rc;
struct mmc *mmc;
const u8 mmc_dev_num = CONFIG_SYS_MMC_ENV_DEV;
mmc = find_mmc_device(mmc_dev_num);
if (!mmc) {
printf("No SD/MMC/eMMC card found\n");
return 0;
}
if (mmc_init(mmc)) {
printf("%s(%d) init failed\n", IS_SD(mmc) ? "SD" : "MMC",
mmc_dev_num);
return 0;
}
/* Load from data partition (0) */
if (fs_set_blk_dev("mmc", "0", FS_TYPE_ANY)) {
printf("Error: MMC 0 not found\n");
return 0;
}
/* Perfrom file read */
rc = fs_read(file_name, get_load_addr(), 0, 0, &act_read);
if (rc)
return 0;
return act_read;
}
static int load_devicetree(void)
{
char *dtbname = getenv("dtb");
char *dtbdev = getenv("dtbdev");
char *dtppart = getenv("dtbpart");
u32 dtbaddr = getenv_ulong("dtbaddr", 16, ~0UL);
loff_t dtbsize;
if (!dtbdev || !dtbdev) {
puts("load_devicetree: <dtbdev>/<dtbpart> missing.\n");
return -1;
}
if (fs_set_blk_dev(dtbdev, dtppart, FS_TYPE_EXT)) {
puts("load_devicetree: set_blk_dev failed.\n");
return -1;
}
if (dtbname && dtbaddr != ~0UL) {
if (fs_read(dtbname, dtbaddr, 0, 0, &dtbsize) == 0) {
gd->fdt_blob = (void *)dtbaddr;
gd->fdt_size = dtbsize;
debug("loaded %d bytes of dtb onto 0x%08x\n",
(u32)dtbsize, dtbaddr);
return dtbsize;
}
puts("load_devicetree: load dtb failed,file does not exist!\n");
}
puts("load_devicetree: <dtb>/<dtbaddr> missing!\n");
return -1;
}
static int load_devicetree(void)
{
int rc;
loff_t dtbsize;
u32 dtbaddr = env_get_ulong("dtbaddr", 16, 0UL);
if (dtbaddr == 0) {
printf("%s: don't have a valid <dtbaddr> in env!\n", __func__);
return -1;
}
#ifdef CONFIG_NAND
dtbsize = 0x20000;
rc = nand_read_skip_bad(get_nand_dev_by_index(0), 0x40000,
(size_t *)&dtbsize,
NULL, 0x20000, (u_char *)dtbaddr);
#else
char *dtbname = env_get("dtb");
char *dtbdev = env_get("dtbdev");
char *dtbpart = env_get("dtbpart");
if (!dtbdev || !dtbpart || !dtbname) {
printf("%s: <dtbdev>/<dtbpart>/<dtb> missing.\n", __func__);
return -1;
}
if (fs_set_blk_dev(dtbdev, dtbpart, FS_TYPE_EXT)) {
puts("load_devicetree: set_blk_dev failed.\n");
return -1;
}
rc = fs_read(dtbname, (u32)dtbaddr, 0, 0, &dtbsize);
#endif
if (rc == 0) {
gd->fdt_blob = (void *)dtbaddr;
gd->fdt_size = dtbsize;
debug("loaded %d bytes of dtb onto 0x%08x\n",
(u32)dtbsize, (u32)gd->fdt_blob);
return dtbsize;
}
printf("%s: load dtb failed!\n", __func__);
return -1;
}
static int select_fs_dev(struct device_platdata *plat)
{
int ret;
if (plat->phandlepart.phandle) {
ofnode node;
node = ofnode_get_by_phandle(plat->phandlepart.phandle);
struct udevice *dev;
ret = device_get_global_by_ofnode(node, &dev);
if (!ret) {
struct blk_desc *desc = blk_get_by_device(dev);
if (desc) {
ret = fs_set_blk_dev_with_part(desc,
plat->phandlepart.partition);
} else {
debug("%s: No device found\n", __func__);
return -ENODEV;
}
}
} else if (plat->mtdpart && plat->ubivol) {
ret = mount_ubifs(plat->mtdpart, plat->ubivol);
if (ret)
return ret;
ret = fs_set_blk_dev("ubi", NULL, FS_TYPE_UBIFS);
} else {
debug("Error: unsupported storage device.\n");
return -ENODEV;
}
if (ret)
debug("Error: could not access storage.\n");
return ret;
}
static int do_update_sdcard(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
//struct update_sdcard_device *fd = f_devices;
//struct update_sdcard_part *fp;
//struct list_head *entry, *n;
char *p;
unsigned long addr;
unsigned long time;
int i = 0;
int res = 0;
int len_read = 0;
int err = 0;
if (argc != 5)
{
printf("## [%s():%d] ret_error \n", __func__,__LINE__);
goto ret_error;
}
memset(f_sdcard_part, 0x0, sizeof(f_sdcard_part)*UPDATE_SDCARD_DEV_PART_MAX);
len_read = update_sd_do_load(cmdtp, flag, argc, argv, FS_TYPE_FAT, 16);
if(len_read > 0)
{
fboot_lcd_start();
// partition map parse
addr = simple_strtoul(argv[3], NULL, 16);
p = (char*)addr;
p[len_read+1] = '\0';
update_sdcard_sort_string((char*)p, len_read);
setenv("fastboot", (char *)p);
saveenv();
err = update_sdcard_part_lists_make(p, strlen(p));
if (err >= 0)
{
struct update_sdcard_part *fp = f_sdcard_part;
update_sdcard_part_lists_print();
printf("\n");
for(i=0; i<UPDATE_SDCARD_DEV_PART_MAX; i++, fp++)
{
if(!strcmp(fp->device, "")) break;
if (!strcmp(fp->file_name, "dummy"))
continue;
if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, FS_TYPE_FAT))
{
printf("## [%s():%d] ret_error \n", __func__,__LINE__);
goto ret_error;
}
printf("=============================================================\n");
fboot_lcd_flash((char*)fp->file_name, "reading ");
time = get_timer(0);
len_read = fs_read(fp->file_name, addr, 0, 0);
time = get_timer(time);
printf("%d bytes read in %lu ms", len_read, time);
if (time > 0) {
puts(" (");
print_size(len_read / time * 1000, "/s");
puts(")");
}
puts("\n");
debug(" %s.%d : %s : %s : 0x%llx, 0x%llx : %s\n",
fp->device, fp->dev_no,
fp->partition_name, UPDATE_SDCARD_FS_MASK&fp->fs_type?"fs":"img",
fp->start, fp->length,
fp->file_name);
if( 0 >= len_read)
continue;
fboot_lcd_flash((char*)fp->file_name, "flashing ");
{
block_dev_desc_t *desc;
char cmd[128];
int i = 0, l = 0, p = 0;
char *device = fp->device;
char *partition_name = fp->partition_name;
char *file_name = fp->file_name;
uint64_t start = fp->start;
uint64_t length = fp->length;
int dev = fp->dev_no;
unsigned int fs_type = fp->fs_type;
int part_num = fp->part_num;
//lbaint_t blk, cnt;
//int blk_size = 512;
length=len_read;
memset(cmd, 0x0, sizeof(cmd));
if (!strcmp(device, "eeprom"))
{
p = sprintf(cmd, "update_eeprom ");
if (fs_type & UPDATE_SDCARD_FS_BOOT)
l = sprintf(&cmd[p], "%s", "uboot");
else if (fs_type & UPDATE_SDCARD_FS_2NDBOOT)
l = sprintf(&cmd[p], "%s", "2ndboot");
else
l = sprintf(&cmd[p], "%s", "raw");
p += l;
l = sprintf(&cmd[p], " 0x%x 0x%llx 0x%llx", (unsigned int)addr, start, length);
p += l;
cmd[p] = 0;
debug("%s\n", cmd);
if(0 > run_command(cmd, 0))
printf("Flash : %s - %s\n", file_name, "FAIL");
else
printf("Flash : %s - %s\n", file_name, "DONE");
}
else if (!strcmp(device, "mmc"))
{
sprintf(cmd, "mmc dev %d", dev);
//printf("** mmc.%d partition %s (%s)**\n",
// dev, partition_name, fs_type&UPDATE_SDCARD_FS_EXT4?"FS":"Image");
/* set mmc devicee */
if (0 > get_device("mmc", simple_itoa(dev), &desc)) {
if (0 > run_command(cmd, 0))
{
printf("## [%s():%d] ret_error \n", __func__,__LINE__);
goto ret_error;
}
if (0 > run_command("mmc rescan", 0))
{
printf("## [%s():%d] ret_error \n", __func__,__LINE__);
goto ret_error;
}
}
if (0 > run_command(cmd, 0)) /* mmc device */
{
printf("## [%s():%d] ret_error \n", __func__,__LINE__);
goto ret_error;
}
if (0 > get_device("mmc", simple_itoa(dev), &desc))
{
printf("## [%s():%d] ret_error \n", __func__,__LINE__);
goto ret_error;
}
memset(cmd, 0x0, sizeof(cmd));
if (fs_type == UPDATE_SDCARD_FS_2NDBOOT ||
fs_type == UPDATE_SDCARD_FS_BOOT) {
if (fs_type == UPDATE_SDCARD_FS_2NDBOOT)
p = sprintf(cmd, "update_mmc %d 2ndboot", dev);
else
p = sprintf(cmd, "update_mmc %d boot", dev);
l = sprintf(&cmd[p], " 0x%x 0x%llx 0x%llx", (unsigned int)addr, start, length);
p += l;
cmd[p] = 0;
}
else if (fs_type & UPDATE_SDCARD_FS_MASK)
{
if (update_sdcard_mmc_check_part_table(desc, fp) > 0) {
struct update_sdcard_part *fp_1 = fp;
int j, cnt=0;
uint64_t part_start[UPDATE_SDCARD_DEV_PART_MAX];
uint64_t part_length[UPDATE_SDCARD_DEV_PART_MAX];
char args[128];
printf("Warn : [%s] make new partitions ....\n", partition_name);
for (j=i; j<UPDATE_SDCARD_DEV_PART_MAX; j++, fp_1++) {
if(!strcmp(fp_1->device, "")) break;
part_start[cnt] = fp_1->start;
part_length[cnt] = fp_1->length;
cnt++;
}
l = sprintf(args, "fdisk %d %d:", dev, cnt);
p = l;
for (j= 0; j < cnt; j++) {
l = sprintf(&args[p], " 0x%llx:0x%llx", part_start[j], part_length[j]);
p += l;
}
args[p] = 0;
printf("%s\n", args);
if(0 > run_command(args, 0))
printf("fdisk : %s\n", "FAIL");
else
printf("fdisk : %s\n", "DONE");
}
//blk = fp->start/blk_size ;
//cnt = (length/blk_size) + ((length & (blk_size-1)) ? 1 : 0);
//p = sprintf(cmd, "mmc write %x %x %x", addr, blk, cnt);
p = sprintf(cmd, "update_mmc %d part %x %d %x", dev, (unsigned int)addr, part_num, (unsigned int)length);
}
printf("%s\n", cmd);
if(0 > run_command(cmd, 0))
printf("Flash : %s - %s\n", file_name, "FAIL");
else
printf("Flash : %s - %s\n", file_name, "DONE");
}
}
}
printf("=============================================================\n");
}
else
{
printf("## [%s():%d] ret_error \n", __func__,__LINE__);
goto ret_error;
}
}
else
{
printf("## [%s():%d] ret_error \n", __func__,__LINE__);
goto ret_error;
}
fboot_lcd_status("exit");
while (1) {
if (ctrlc())
{
printf("update_sdcard end\n\n");
break;
}
}
//fboot_lcd_stop();
//do_reset (NULL, 0, 0, NULL);
return res;
ret_error:
fboot_lcd_stop();
return -1;
}
int update_sd_do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],int fstype, int cmdline_base)
{
unsigned long addr;
const char *addr_str;
const char *filename;
unsigned long bytes;
unsigned long pos;
int len_read;
char buf[12];
unsigned long time;
if (argc < 2)
return CMD_RET_USAGE;
if (argc > 7)
return CMD_RET_USAGE;
if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
return -1;
if (argc >= 4) {
addr = simple_strtoul(argv[3], NULL, cmdline_base);
} else {
addr_str = getenv("loadaddr");
if (addr_str != NULL)
addr = simple_strtoul(addr_str, NULL, 16);
else
addr = CONFIG_SYS_LOAD_ADDR;
}
if (argc >= 5) {
filename = argv[4];
} else {
filename = getenv("bootfile");
if (!filename) {
puts("** No boot file defined **\n");
return -1;
}
}
if (argc >= 6)
bytes = simple_strtoul(argv[5], NULL, cmdline_base);
else
bytes = 0;
if (argc >= 7)
pos = simple_strtoul(argv[6], NULL, cmdline_base);
else
pos = 0;
time = get_timer(0);
len_read = fs_read(filename, addr, pos, bytes);
time = get_timer(time);
if (len_read <= 0)
return -1;
printf("%d bytes read in %lu ms", len_read, time);
if (time > 0) {
puts(" (");
print_size(len_read / time * 1000, "/s");
puts(")");
}
puts("\n");
sprintf(buf, "0x%x", len_read);
setenv("filesize", buf);
return len_read;
}
