int do_reiserls (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { char *filename = "/"; int dev, part; block_dev_desc_t *dev_desc=NULL; disk_partition_t info; if (argc < 3) return CMD_RET_USAGE; part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); if (part < 0) return 1; if (argc == 4) { filename = argv[3]; } dev = dev_desc->dev; PRINTF("Using device %s %d:%d, directory: %s\n", argv[1], dev, part, filename); reiserfs_set_blk_dev(dev_desc, &info); if (!reiserfs_mount(info.size)) { printf ("** Bad Reiserfs partition or disk - %s %d:%d **\n", argv[1], dev, part); return 1; } if (reiserfs_ls (filename)) { printf ("** Error reiserfs_ls() **\n"); return 1; }; 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); }
static int do_zfs_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { const char *filename = "/"; int part; block_dev_desc_t *dev_desc; disk_partition_t info; struct device_s vdev; if (argc < 2) return cmd_usage(cmdtp); if (argc == 4) filename = argv[3]; part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); if (part < 0) return 1; zfs_set_blk_dev(dev_desc, &info); vdev.part_length = info.size; zfs_ls(&vdev, filename, zfs_print); return 0; }
int do_part_info(int argc, char * const argv[]) { int part; block_dev_desc_t *dev_desc; disk_partition_t info; char buf_convert[20]; if (argc < 2) return CMD_RET_USAGE; if (argc > 5) return CMD_RET_USAGE; part = get_device_and_partition(argv[0], argv[1], &dev_desc, &info, 0); if (part < 0) return 1; snprintf(buf_convert, sizeof(buf_convert), LBAF, info.start); if (argc > 2) setenv(argv[2], buf_convert); else printf("Partition start :0x%s\n", buf_convert); snprintf(buf_convert, sizeof(buf_convert), LBAF, info.size); if (argc > 3) setenv(argv[3], buf_convert); else printf("Partition size :0x%s\n", buf_convert); snprintf(buf_convert, sizeof(buf_convert), "%lx", info.blksz); if (argc > 4) setenv(argv[4], buf_convert); else printf("Block size :0x%s bytes\n", buf_convert); return 0; }
int saveenv(void) { env_t env_new; block_dev_desc_t *dev_desc = NULL; disk_partition_t info; int dev, part; int err; err = env_export(&env_new); if (err) return err; part = get_device_and_partition(FAT_ENV_INTERFACE, FAT_ENV_DEVICE_AND_PART, &dev_desc, &info, 1); if (part < 0) return 1; dev = dev_desc->dev; if (fat_set_blk_dev(dev_desc, &info) != 0) { printf("\n** Unable to use %s %d:%d for saveenv **\n", FAT_ENV_INTERFACE, dev, part); return 1; } err = file_fat_write(FAT_ENV_FILE, (void *)&env_new, sizeof(env_t)); if (err == -1) { printf("\n** Unable to write \"%s\" from %s%d:%d **\n", FAT_ENV_FILE, FAT_ENV_INTERFACE, dev, part); return 1; } puts("done\n"); return 0; }
int do_fat_ls (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { char *filename = "/"; int ret, dev, part; block_dev_desc_t *dev_desc=NULL; disk_partition_t info; if (argc < 2) { printf("usage: fatls <interface> [<dev[:part]>] [directory]\n"); return 0; } part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); if (part < 0) return 1; dev = dev_desc->dev; if (fat_register_device(dev_desc,part)!=0) { printf("\n** Unable to use %s %d:%d for fatls **\n", argv[1], dev, part); return 1; } if (argc == 4) ret = file_fat_ls(argv[3]); else ret = file_fat_ls(filename); if(ret!=0) printf("No Fat FS detected\n"); return ret; }
int do_ext4_write(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { #if 0 const char *filename = "/"; int dev, part; unsigned long ram_address; unsigned long file_size; disk_partition_t info; block_dev_desc_t *dev_desc; if (argc < 6) return cmd_usage(cmdtp); part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); if (part < 0) return 1; dev = dev_desc->dev; /* get the filename */ filename = argv[4]; /* get the address in hexadecimal format (string to int) */ ram_address = simple_strtoul(argv[3], NULL, 16); /* get the filesize in base 10 format */ file_size = simple_strtoul(argv[5], NULL, 10); /* set the device as block device */ ext4fs_set_blk_dev(dev_desc, &info); /* mount the filesystem */ if (!ext4fs_mount(info.size)) { printf("Bad ext4 partition %s %d:%d\n", argv[1], dev, part); goto fail; } /* start write */ if (ext4fs_write(filename, (unsigned char *)ram_address, file_size)) { printf("** Error ext4fs_write() **\n"); goto fail; } ext4fs_close(); return 0; fail: ext4fs_close(); return 1; #endif return 0; }
int do_fat_fsload (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { long size; unsigned long offset; unsigned long count = 0; unsigned long pos = 0; char buf [12]; block_dev_desc_t *dev_desc=NULL; disk_partition_t info; int part, dev; if (argc < 5) { printf("usage: fatload <interface> [<dev[:part]>] " "<addr> <filename> [bytes [pos]]\n"); return 1; } part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); if (part < 0) return 1; dev = dev_desc->dev; 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); if (argc >= 7) pos = simple_strtoul(argv[6], NULL, 16); size = file_fat_read_at(argv[4], pos, (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; } printf("\n%ld bytes read\n", size); sprintf(buf, "%lX", size); setenv("filesize", buf); return 0; }
static int do_fat_fswrite(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { long size; unsigned long addr; unsigned long count; block_dev_desc_t *dev_desc = NULL; disk_partition_t info; int dev = 0; int part = 1; void *buf; if (argc < 5) return cmd_usage(cmdtp); part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); if (part < 0) return 1; dev = dev_desc->dev; if (fat_set_blk_dev(dev_desc, &info) != 0) { printf("\n** Unable to use %s %d:%d for fatwrite **\n", argv[1], dev, part); return 1; } addr = simple_strtoul(argv[3], NULL, 16); count = simple_strtoul(argv[5], NULL, 16); buf = map_sysmem(addr, count); size = file_fat_write(argv[4], buf, count); unmap_sysmem(buf); if (size == -1) { printf("\n** Unable to write \"%s\" from %s %d:%d **\n", argv[4], argv[1], dev, part); return 1; } printf("%ld bytes written\n", size); return 0; }
static int do_part_uuid(int argc, char * const argv[]) { int part; block_dev_desc_t *dev_desc; disk_partition_t info; if (argc < 2) return CMD_RET_USAGE; if (argc > 3) return CMD_RET_USAGE; part = get_device_and_partition(argv[0], argv[1], &dev_desc, &info, 0); if (part < 0) return 1; if (argc > 2) setenv(argv[2], info.uuid); else printf("%s\n", info.uuid); return 0; }
int do_fat_fsinfo (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { int dev, part; block_dev_desc_t *dev_desc; disk_partition_t info; if (argc < 2) { printf("usage: fatinfo <interface> [<dev[:part]>]\n"); return 0; } part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); if (part < 0) return 1; dev = dev_desc->dev; if (fat_register_device(dev_desc,part)!=0) { printf("\n** Unable to use %s %d:%d for fatinfo **\n", argv[1], dev, part); return 1; } return file_fat_detectfs(); }
/****************************************************************************** * Reiserfs boot command intepreter. Derived from diskboot */ int do_reiserload (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { char *filename = NULL; int dev, part; ulong addr = 0, filelen; disk_partition_t info; block_dev_desc_t *dev_desc = NULL; unsigned long count; char *addr_str; switch (argc) { case 3: addr_str = getenv("loadaddr"); if (addr_str != NULL) { addr = simple_strtoul (addr_str, NULL, 16); } else { addr = CONFIG_SYS_LOAD_ADDR; } filename = getenv ("bootfile"); count = 0; break; case 4: addr = simple_strtoul (argv[3], NULL, 16); filename = getenv ("bootfile"); count = 0; break; case 5: addr = simple_strtoul (argv[3], NULL, 16); filename = argv[4]; count = 0; break; case 6: addr = simple_strtoul (argv[3], NULL, 16); filename = argv[4]; count = simple_strtoul (argv[5], NULL, 16); break; default: return CMD_RET_USAGE; } if (!filename) { puts ("\n** No boot file defined **\n"); return 1; } part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); if (part < 0) return 1; dev = dev_desc->dev; printf("Loading file \"%s\" from %s device %d%c%c\n", filename, argv[1], dev, part ? ':' : ' ', part ? part + '0' : ' '); reiserfs_set_blk_dev(dev_desc, &info); if (!reiserfs_mount(info.size)) { printf ("** Bad Reiserfs partition or disk - %s %d:%d **\n", argv[1], dev, part); return 1; } filelen = reiserfs_open(filename); if (filelen < 0) { printf("** File not found %s **\n", filename); return 1; } if ((count < filelen) && (count != 0)) { filelen = count; } if (reiserfs_read((char *)addr, filelen) != filelen) { printf("\n** Unable to read \"%s\" from %s %d:%d **\n", filename, argv[1], dev, part); return 1; } /* Loading ok, update default load address */ load_addr = addr; printf ("\n%ld bytes read\n", filelen); setenv_hex("filesize", filelen); return filelen; }
int common_diskboot(cmd_tbl_t *cmdtp, const char *intf, int argc, char *const argv[]) { int dev, part; ulong addr = CONFIG_SYS_LOAD_ADDR; ulong cnt; disk_partition_t info; #if defined(CONFIG_IMAGE_FORMAT_LEGACY) image_header_t *hdr; #endif block_dev_desc_t *dev_desc; #if defined(CONFIG_FIT) const void *fit_hdr = NULL; #endif bootstage_mark(BOOTSTAGE_ID_IDE_START); if (argc > 3) { bootstage_error(BOOTSTAGE_ID_IDE_ADDR); return CMD_RET_USAGE; } bootstage_mark(BOOTSTAGE_ID_IDE_ADDR); if (argc > 1) addr = simple_strtoul(argv[1], NULL, 16); bootstage_mark(BOOTSTAGE_ID_IDE_BOOT_DEVICE); part = get_device_and_partition(intf, (argc == 3) ? argv[2] : NULL, &dev_desc, &info, 1); if (part < 0) { bootstage_error(BOOTSTAGE_ID_IDE_TYPE); return 1; } dev = dev_desc->dev; bootstage_mark(BOOTSTAGE_ID_IDE_TYPE); printf("\nLoading from %s device %d, partition %d: " "Name: %.32s Type: %.32s\n", intf, dev, part, info.name, info.type); debug("First Block: " LBAFU ", # of blocks: " LBAFU ", Block Size: %ld\n", info.start, info.size, info.blksz); if (dev_desc->block_read(dev, info.start, 1, (ulong *) addr) != 1) { printf("** Read error on %d:%d\n", dev, part); bootstage_error(BOOTSTAGE_ID_IDE_PART_READ); return 1; } bootstage_mark(BOOTSTAGE_ID_IDE_PART_READ); switch (genimg_get_format((void *) addr)) { #if defined(CONFIG_IMAGE_FORMAT_LEGACY) case IMAGE_FORMAT_LEGACY: hdr = (image_header_t *) addr; bootstage_mark(BOOTSTAGE_ID_IDE_FORMAT); if (!image_check_hcrc(hdr)) { puts("\n** Bad Header Checksum **\n"); bootstage_error(BOOTSTAGE_ID_IDE_CHECKSUM); return 1; } bootstage_mark(BOOTSTAGE_ID_IDE_CHECKSUM); image_print_contents(hdr); cnt = image_get_image_size(hdr); break; #endif #if defined(CONFIG_FIT) case IMAGE_FORMAT_FIT: fit_hdr = (const void *) addr; puts("Fit image detected...\n"); cnt = fit_get_size(fit_hdr); break; #endif default: bootstage_error(BOOTSTAGE_ID_IDE_FORMAT); puts("** Unknown image type\n"); return 1; } cnt += info.blksz - 1; cnt /= info.blksz; cnt -= 1; if (dev_desc->block_read(dev, info.start + 1, cnt, (ulong *)(addr + info.blksz)) != cnt) { printf("** Read error on %d:%d\n", dev, part); bootstage_error(BOOTSTAGE_ID_IDE_READ); return 1; } bootstage_mark(BOOTSTAGE_ID_IDE_READ); #if defined(CONFIG_FIT) /* This cannot be done earlier, * we need complete FIT image in RAM first */ if (genimg_get_format((void *) addr) == IMAGE_FORMAT_FIT) { if (!fit_check_format(fit_hdr)) { bootstage_error(BOOTSTAGE_ID_IDE_FIT_READ); puts("** Bad FIT image format\n"); return 1; } bootstage_mark(BOOTSTAGE_ID_IDE_FIT_READ_OK); fit_print_contents(fit_hdr); } #endif flush_cache(addr, (cnt+1)*info.blksz); /* Loading ok, update default load address */ load_addr = addr; return bootm_maybe_autostart(cmdtp, argv[0]); }
static int do_zfs_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { char *filename = NULL; int dev; int part; ulong addr = 0; disk_partition_t info; block_dev_desc_t *dev_desc; char buf[12]; unsigned long count; const char *addr_str; struct zfs_file zfile; struct device_s vdev; if (argc < 3) return CMD_RET_USAGE; count = 0; addr = simple_strtoul(argv[3], NULL, 16); filename = getenv("bootfile"); switch (argc) { case 3: addr_str = getenv("loadaddr"); if (addr_str != NULL) addr = simple_strtoul(addr_str, NULL, 16); else addr = CONFIG_SYS_LOAD_ADDR; break; case 4: break; case 5: filename = argv[4]; break; case 6: filename = argv[4]; count = simple_strtoul(argv[5], NULL, 16); break; default: return cmd_usage(cmdtp); } if (!filename) { puts("** No boot file defined **\n"); return 1; } part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); if (part < 0) return 1; dev = dev_desc->dev; printf("Loading file \"%s\" from %s device %d%c%c\n", filename, argv[1], dev, part ? ':' : ' ', part ? part + '0' : ' '); zfs_set_blk_dev(dev_desc, &info); vdev.part_length = info.size; memset(&zfile, 0, sizeof(zfile)); zfile.device = &vdev; if (zfs_open(&zfile, filename)) { printf("** File not found %s\n", filename); return 1; } if ((count < zfile.size) && (count != 0)) zfile.size = (uint64_t)count; if (zfs_read(&zfile, (char *)addr, zfile.size) != zfile.size) { printf("** Unable to read \"%s\" from %s %d:%d **\n", filename, argv[1], dev, part); zfs_close(&zfile); return 1; } zfs_close(&zfile); /* Loading ok, update default load address */ load_addr = addr; printf("%llu bytes read\n", zfile.size); setenv_hex("filesize", zfile.size); return 0; }