static int do_part_list(int argc, char * const argv[])
{
int ret;
block_dev_desc_t *desc;
if (argc < 2 || argc > 3)
return CMD_RET_USAGE;
ret = get_device(argv[0], argv[1], &desc);
if (ret < 0)
return 1;
if (argc == 3) {
int p;
char str[512] = { 0, };
disk_partition_t info;
for (p = 1; p < 128; p++) {
int r = get_partition_info(desc, p, &info);
if (r == 0) {
char t[5];
sprintf(t, "%s%d", str[0] ? " " : "", p);
strcat(str, t);
}
}
setenv(argv[2], str);
return 0;
}
print_part(desc);
return 0;
}
void print_partion_info(void)
{
block_dev_desc_t *dev_desc;
disk_partition_t info;
int pnum = 0;
int i;
unsigned long long start;
unsigned long long size;
dev_desc = get_dev("mmc", CONFIG_FASTBOOT_FLASH_MMC_DEV);
if (!dev_desc || dev_desc->type == DEV_TYPE_UNKNOWN) {
error("invalid mmc device\n");
fastboot_fail("invalid mmc device");
return;
}
pnum = get_partition_num(dev_desc);
for (i = 1; i <= pnum; i++) {
if (get_partition_info(dev_desc, i, &info))
break;
start = (unsigned long long)info.start * info.blksz;
size = (unsigned long long)info.size * info.blksz;
printf("part %3d::%12s\t start 0x%08llx, size 0x%08llx\n",
i, info.name, start, size);
}
}
static int warp_sd_init(int dev, disk_partition_t * info,
block_dev_desc_t ** dev_desc)
{
int ret;
u32 lun, part;
block_dev_desc_t *mmc_get_dev(int dev);
#ifdef CONFIG_GENERIC_MMC
struct mmc *mmc;
#endif
lun = WARP_DEV_TO_LUN(dev);
part = WARP_DEV_TO_PART(dev);
#ifdef CONFIG_GENERIC_MMC
if (!(mmc = find_mmc_device(lun))) {
printf("device %d not found\n", lun);
return -1;
}
ret = mmc_init(mmc);
#else
#if U_BOOT_VERSION_CODE < U_BOOT_VER(2009,3,0)
ret = mmc_init(0);
#else
ret = mmc_legacy_init(0);
#endif
#endif
if (ret != 0) {
printf("No MMC card found\n");
return ret;
}
if ((*dev_desc = mmc_get_dev(lun)) == NULL) {
printf("device %d not found\n", lun);
return -1;
}
if (part == 0) {
info->start = 0;
return 0;
}
if ((ret = get_partition_info(*dev_desc, part, info)) != 0) {
printf("partition %d:%d not found\n", lun, part);
return ret;
}
return 0;
}
static int warp_ata_init(int dev, disk_partition_t * info,
block_dev_desc_t ** dev_desc)
{
int ret;
u32 lun, part;
block_dev_desc_t *sata_get_dev(int dev);
lun = WARP_DEV_TO_LUN(dev);
part = WARP_DEV_TO_PART(dev);
if (sata_dev_desc[lun].if_type != IF_TYPE_SATA) {
memset(&sata_dev_desc[lun], 0, sizeof(struct block_dev_desc));
sata_dev_desc[lun].if_type = IF_TYPE_SATA;
sata_dev_desc[lun].dev = lun;
sata_dev_desc[lun].part_type = PART_TYPE_UNKNOWN;
sata_dev_desc[lun].type = DEV_TYPE_HARDDISK;
sata_dev_desc[lun].lba = 0;
sata_dev_desc[lun].blksz = 512;
sata_dev_desc[lun].block_read = sata_read;
sata_dev_desc[lun].block_write = sata_write;
if ((ret = init_sata(lun)))
return ret;
if ((ret = scan_sata(lun)))
return ret;
if ((sata_dev_desc[lun].lba > 0) && (sata_dev_desc[lun].blksz > 0))
init_part(&sata_dev_desc[lun]);
}
if ((*dev_desc = sata_get_dev(lun)) == NULL) {
printf("device %d not found\n", lun);
return -1;
}
if (part == 0) {
info->start = 0;
return 0;
}
if ((ret = get_partition_info(*dev_desc, part, info)) != 0) {
printf("partition %d:%d not found\n", lun, part);
return ret;
}
return 0;
}
int del_partition(block_dev_desc_t * dev_desc, int part)
{
disk_partition_t info;
switch (dev_desc->part_type) {
#ifdef CONFIG_DOS_PARTITION
case PART_TYPE_DOS:
if (get_partition_info(dev_desc, part, &info) == 0) {
return del_partition_dos(dev_desc, part);
} else
printf(" This partition is not found in the device\n");
break;
#endif
default:
break;
}
return (-1);
}
static ulong get_block_size(char *ifname, int dev, int part)
{
block_dev_desc_t *dev_desc = NULL;
disk_partition_t part_info;
dev_desc = get_dev(ifname, dev);
if (dev_desc == NULL) {
printf("Block device %s %d not supported\n", ifname, dev);
return 0;
}
if (get_partition_info(dev_desc, part, &part_info)) {
printf("Cannot find partition %d\n", part);
return 0;
}
return part_info.blksz;
}
int get_recovery_message(struct recovery_message *out)
{
block_dev_desc_t *p_block_dev = NULL;
disk_partition_t info;
int size=8192;
p_block_dev = get_dev("mmc", 1);
if(NULL == p_block_dev){
return -1;
}
if (!get_partition_info(p_block_dev, PARTITION_MISC, &info)) {
if(TRUE != Emmc_Read(PARTITION_USER, info.start, size/EMMC_SECTOR_SIZE, (void *)buf)){
printf("function: %s emcc read error\n", __FUNCTION__);
return -1;
}
}
memcpy(out, buf, sizeof(*out));
return 0;
}
int ext4_register_device(block_dev_desc_t *dev_desc, int part_no)
{
unsigned char buffer[SECTOR_SIZE];
disk_partition_t info;
if (!dev_desc->block_read)
return -1;
/* check if we have a MBR (on floppies we have only a PBR) */
if (dev_desc->block_read(dev_desc->dev, 0, 1, (ulong *) buffer) != 1) {
printf("** Can't read from device %d **\n", dev_desc->dev);
return -1;
}
if (buffer[DOS_PART_MAGIC_OFFSET] != 0x55 ||
buffer[DOS_PART_MAGIC_OFFSET + 1] != 0xaa) {
/* no signature found */
return -1;
}
/* First we assume there is a MBR */
if (!get_partition_info(dev_desc, part_no, &info)) {
part_offset = info.start;
cur_part = part_no;
part_size = info.size;
} else if ((strncmp((char *)&buffer[DOS_FS_TYPE_OFFSET],
"FAT", 3) == 0) || (strncmp((char *)&buffer
[DOS_FS32_TYPE_OFFSET],
"FAT32", 5) == 0)) {
/* ok, we assume we are on a PBR only */
cur_part = 1;
part_offset = 0;
} else {
printf("** Partition %d not valid on device %d **\n",
part_no, dev_desc->dev);
return -1;
}
return 0;
}
_make_hd_dn(uint8_t *buf, ssize_t size, int fd, uint32_t partition,
uint32_t options)
{
uint64_t part_start=0, part_size = 0;
uint8_t signature[16]="", format=0, signature_type=0;
int rc;
char *report=getenv("LIBEFIBOOT_REPORT_GPT_ERRORS");
if (report)
report_errors = 1;
errno = 0;
rc = get_partition_info(fd, options,
partition>0?partition:1, &part_start,
&part_size, signature, &format,
&signature_type);
if (rc < 0)
return rc;
return efidp_make_hd(buf, size, partition>0?partition:1, part_start,
part_size, signature, format, signature_type);
}
int
mmc_register_device(block_dev_desc_t *dev_desc, int part_no)
{
unsigned char buffer[0x200];
disk_partition_t info;
if (!dev_desc->block_read)
return -1;
mmc_cur_dev=dev_desc;
/* check if we have a MBR (on floppies we have only a PBR) */
if (dev_desc->block_read (dev_desc->dev, 0, 1, (ulong *) buffer) != 1) {
printf ("** Can't read from device %d **\n", dev_desc->dev);
return -1;
}
if(!get_partition_info(dev_desc, part_no, &info)) {
mmc_part_offset = info.start;
mmc_cur_part = part_no;
printf("part_offset : %x, cur_part : %x\n", mmc_part_offset, mmc_cur_part);
} else {
#if 1
printf ("** Partition %d not valid on device %d **\n",part_no,dev_desc->dev);
return -1;
#else
/* FIXME we need to determine the start block of the
* partition where the boot.img partition resides. This can be done
* by using the get_partition_info routine. For this
* purpose the libpart must be included.
*/
part_offset=32;
cur_part = 1;
#endif
}
return 0;
}
static int find_partition(struct tdev_t *pdev)
{
unsigned char buffer[SECTOR_SIZE];
disk_partition_t info;
block_dev_desc_t *dev_desc = pdev->dev_desc;
int part_no = pdev->part_offset;
if (!dev_desc->block_read)
return -1;
/* check if we have a MBR (on floppies we have only a PBR) */
if (dev_desc->block_read (dev_desc->dev, 0, 1, (ulong *) buffer) != 1) {
printf ("** Can't read from device %d **\n", dev_desc->dev);
return -1;
}
if (buffer[DOS_PART_MAGIC_OFFSET] != 0x55 ||
buffer[DOS_PART_MAGIC_OFFSET + 1] != 0xaa) {
/* no signature found */
return -1;
}
/* First we assume, there is a MBR */
/* Marvell fixed: PBR has the same magic as MBR:
add check for MBR "bootable" field (0 or 0x80 only);
add check for PBR bytes_per_sector field */
if (!get_partition_info(dev_desc, part_no, &info) && (buffer[MBR_BOOTABLE_OFFSET]&0x7f) == 0) {
pdev->part_offset = info.start;
} else if ((buffer[DOS_FS_SS_OFFSET] == 0) && (buffer[DOS_FS_SS_OFFSET + 1] == 2)) {
/* Sector size 0x200 at offset 0xb: assume PBR */
pdev->part_offset = 0;
} else {
printf ("** Partition %d not valid on device %d **\n",
part_no, dev_desc->dev);
return -1;
}
printf("PART offset = %lx\n", pdev->part_offset);
return 0;
}
/******************************************************************************
* Ext2fs boot command intepreter. Derived from diskboot
*/
int do_ext2load (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
char *filename = NULL;
char *ep;
int dev, part = 1;
ulong addr = 0, part_length, filelen;
disk_partition_t info;
block_dev_desc_t *dev_desc = NULL;
char buf [12];
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:
cmd_usage(cmdtp);
return(1);
}
if (!filename) {
puts ("\n** No boot file defined **\n");
return(1);
}
dev = (int)simple_strtoul (argv[2], &ep, 16);
dev_desc = get_dev(argv[1],dev);
if (dev_desc==NULL) {
printf ("\n** Block device %s %d not supported\n", argv[1], dev);
return(1);
}
if (*ep) {
if (*ep != ':') {
puts ("\n** Invalid boot device, use `dev[:part]' **\n");
return(1);
}
part = (int)simple_strtoul(++ep, NULL, 16);
}
PRINTF("Using device %s%d, partition %d\n", argv[1], dev, part);
if (part != 0) {
if (get_partition_info (dev_desc, part, &info)) {
printf ("** Bad partition %d **\n", part);
return(1);
}
if (strncmp((char *)info.type, BOOT_PART_TYPE, sizeof(info.type)) != 0) {
printf ("\n** Invalid partition type \"%.32s\""
" (expect \"" BOOT_PART_TYPE "\")\n",
info.type);
return(1);
}
PRINTF ("\nLoading from block device %s device %d, partition %d: "
"Name: %.32s Type: %.32s File:%s\n",
argv[1], dev, part, info.name, info.type, filename);
} else {
PRINTF ("\nLoading from block device %s device %d, File:%s\n",
argv[1], dev, filename);
}
if ((part_length = ext2fs_set_blk_dev(dev_desc, part)) == 0) {
printf ("** Bad partition - %s %d:%d **\n", argv[1], dev, part);
ext2fs_close();
return(1);
}
if (!ext2fs_mount(part_length)) {
printf ("** Bad ext2 partition or disk - %s %d:%d **\n", argv[1], dev, part);
ext2fs_close();
return(1);
}
filelen = ext2fs_open(filename);
if (filelen < 0) {
printf("** File not found %s\n", filename);
ext2fs_close();
return(1);
}
if ((count < filelen) && (count != 0)) {
filelen = count;
}
if (ext2fs_read((char *)addr, filelen) != filelen) {
printf("\n** Unable to read \"%s\" from %s %d:%d **\n", filename, argv[1], dev, part);
ext2fs_close();
return(1);
}
ext2fs_close();
/* Loading ok, update default load address */
load_addr = addr;
printf ("\n%ld bytes read\n", filelen);
sprintf(buf, "%lX", filelen);
setenv("filesize", buf);
return(filelen);
}
int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *s)
{
int dev, part;
struct mmc *mmc;
block_dev_desc_t *blk_dev;
disk_partition_t partinfo;
char *st;
dfu->dev_type = DFU_DEV_MMC;
st = strsep(&s, " ");
if (!strcmp(st, "mmc")) {
dfu->layout = DFU_RAW_ADDR;
dfu->data.mmc.lba_start = simple_strtoul(s, &s, 16);
dfu->data.mmc.lba_size = simple_strtoul(++s, &s, 16);
dfu->data.mmc.lba_blk_size = get_mmc_blk_size(dfu->dev_num);
} else if (!strcmp(st, "fat")) {
dfu->layout = DFU_FS_FAT;
} else if (!strcmp(st, "ext4")) {
dfu->layout = DFU_FS_EXT4;
} else if (!strcmp(st, "part")) {
dfu->layout = DFU_RAW_ADDR;
dev = simple_strtoul(s, &s, 10);
s++;
part = simple_strtoul(s, &s, 10);
mmc = find_mmc_device(dev);
if (mmc == NULL || mmc_init(mmc)) {
printf("%s: could not find mmc device #%d!\n",
__func__, dev);
return -ENODEV;
}
blk_dev = &mmc->block_dev;
if (get_partition_info(blk_dev, part, &partinfo) != 0) {
printf("%s: could not find partition #%d on mmc device #%d!\n",
__func__, part, dev);
return -ENODEV;
}
dfu->data.mmc.lba_start = partinfo.start;
dfu->data.mmc.lba_size = partinfo.size;
dfu->data.mmc.lba_blk_size = partinfo.blksz;
} else {
printf("%s: Memory layout (%s) not supported!\n", __func__, st);
return -ENODEV;
}
if (dfu->layout == DFU_FS_EXT4 || dfu->layout == DFU_FS_FAT) {
dfu->data.mmc.dev = simple_strtoul(s, &s, 10);
dfu->data.mmc.part = simple_strtoul(++s, &s, 10);
}
dfu->read_medium = dfu_read_medium_mmc;
dfu->write_medium = dfu_write_medium_mmc;
dfu->flush_medium = dfu_flush_medium_mmc;
/* initial state */
dfu->inited = 0;
return 0;
}
int
get_all_partitions(struct partition *parts[], const int max_parts, bool ignore_fs_type, PedPartitionFlag require_flag)
{
struct partition *p;
int part_count = 0;
PedDevice *dev = NULL;
PedDisk *disk;
PedPartition *part;
ped_device_probe_all();
while ((dev = ped_device_get_next(dev)) != NULL) {
if (dev->read_only)
continue;
if (strstr(dev->path, "/dev/mtd") == dev->path)
continue;
if (!ped_disk_probe(dev))
continue;
disk = ped_disk_new(dev);
part = NULL;
while ((part = ped_disk_next_partition(disk, part)) != NULL) {
if (part->type & (PED_PARTITION_METADATA | PED_PARTITION_FREESPACE | PED_PARTITION_EXTENDED))
continue;
if (part_count >= max_parts)
break;
#ifndef FIND_PARTS_MAIN
/* allow other udebs to block partitions */
if(block_partition(ped_partition_get_path(part)) != 0)
continue;
#endif
if (require_flag && !ped_partition_get_flag(part, require_flag))
continue;
p = malloc(sizeof(*p));
p->path = ped_partition_get_path(part);
if (strstr(p->path, "/dev/hd") == p->path) {
static char *targets[] = { "master", "slave" };
char drive;
int part;
if (sscanf(p->path, "/dev/hd%c%d", &drive, &part) == 2
&& drive >= 'a' && drive <= 'z')
asprintf(&p->description, "IDE%d %s\\, part. %d",
(drive - 'a') / 2 + 1, targets[(drive - 'a') % 2],
part);
else
p->description = strdup(p->path);
} else if (strstr(p->path, "/dev/sd") == p->path) {
char drive;
int host, bus, target, lun, part;
int done = 0;
if (sscanf(p->path, "/dev/sd%c%d", &drive, &part) == 2
&& drive >= 'a' && drive <= 'z') {
struct stat st;
char *disk, *disk_pos, *sys_device;
disk = strdup(p->path + 5);
for (disk_pos = disk + strlen(disk) - 1; disk_pos > disk;
--disk_pos) {
if (*disk_pos >= '0' && *disk_pos <= '9')
*disk_pos = 0;
else
break;
}
sys_device = malloc(strlen(disk) + 19);
sprintf(sys_device, "/sys/block/%s/device", disk);
/* TODO: device symlinks are allegedly slated to go
* away, but it's not entirely clear what their
* replacement will be yet ...
*/
if (lstat(sys_device, &st) == 0 && S_ISLNK(st.st_mode)) {
char buf[512];
memset(buf, 0, 512);
if (readlink(sys_device, buf, 511) > 0) {
const char *bus_id = basename(buf);
if (sscanf(bus_id, "%d:%d:%d:%d",
&host, &bus, &target, &lun) == 4) {
asprintf(&p->description, "SCSI%d (%d\\,%d\\,%d) part. %d",
host + 1, bus, target, lun, part);
done = 1;
}
}
}
}
if (!done)
p->description = strdup(p->path);
} else
p->description = strdup(p->path);
p->fstype = NULL;
p->fsid = NULL;
p->size = 0L;
p->op.filesystem = NULL;
p->op.mountpoint = NULL;
p->op.done = 0;
test_lvm(p);
test_evms(p);
test_raid(p);
/* FIXME: Other tests? */
get_partition_info(p, part, dev, ignore_fs_type);
parts[part_count++] = p;
}
if (part_count >= max_parts)
break;
}
return part_count;
}
/******************************************************************************
* scsi boot command intepreter. Derived from diskboot
*/
int do_scsiboot (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
char *boot_device = NULL;
char *ep;
int dev, part = 0;
ulong addr, cnt;
disk_partition_t info;
image_header_t *hdr;
#if defined(CONFIG_FIT)
const void *fit_hdr = NULL;
#endif
switch (argc) {
case 1:
addr = CONFIG_SYS_LOAD_ADDR;
boot_device = getenv ("bootdevice");
break;
case 2:
addr = simple_strtoul(argv[1], NULL, 16);
boot_device = getenv ("bootdevice");
break;
case 3:
addr = simple_strtoul(argv[1], NULL, 16);
boot_device = argv[2];
break;
default:
return CMD_RET_USAGE;
}
if (!boot_device) {
puts ("\n** No boot device **\n");
return 1;
}
dev = simple_strtoul(boot_device, &ep, 16);
printf("booting from dev %d\n",dev);
if (scsi_dev_desc[dev].type == DEV_TYPE_UNKNOWN) {
printf ("\n** Device %d not available\n", dev);
return 1;
}
if (*ep) {
if (*ep != ':') {
puts ("\n** Invalid boot device, use `dev[:part]' **\n");
return 1;
}
part = simple_strtoul(++ep, NULL, 16);
}
if (get_partition_info (&scsi_dev_desc[dev], part, &info)) {
printf("error reading partinfo\n");
return 1;
}
if ((strncmp((char *)(info.type), BOOT_PART_TYPE, sizeof(info.type)) != 0) &&
(strncmp((char *)(info.type), BOOT_PART_COMP, sizeof(info.type)) != 0)) {
printf ("\n** Invalid partition type \"%.32s\""
" (expect \"" BOOT_PART_TYPE "\")\n",
info.type);
return 1;
}
printf ("\nLoading from SCSI device %d, partition %d: "
"Name: %.32s Type: %.32s\n",
dev, part, info.name, info.type);
debug ("First Block: %ld, # of blocks: %ld, Block Size: %ld\n",
info.start, info.size, info.blksz);
if (scsi_read (dev, info.start, 1, (ulong *)addr) != 1) {
printf ("** Read error on %d:%d\n", dev, part);
return 1;
}
switch (genimg_get_format ((void *)addr)) {
case IMAGE_FORMAT_LEGACY:
hdr = (image_header_t *)addr;
if (!image_check_hcrc (hdr)) {
puts ("\n** Bad Header Checksum **\n");
return 1;
}
image_print_contents (hdr);
cnt = image_get_image_size (hdr);
break;
#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:
puts ("** Unknown image type\n");
return 1;
}
cnt += info.blksz - 1;
cnt /= info.blksz;
cnt -= 1;
if (scsi_read (dev, info.start+1, cnt,
(ulong *)(addr+info.blksz)) != cnt) {
printf ("** Read error on %d:%d\n", dev, part);
return 1;
}
#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)) {
puts ("** Bad FIT image format\n");
return 1;
}
fit_print_contents (fit_hdr);
}
#endif
/* Loading ok, update default load address */
load_addr = addr;
flush_cache (addr, (cnt+1)*info.blksz);
return bootm_maybe_autostart(cmdtp, argv[0]);
}
int do_bootext2 (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
int dev,part,active_part= -1 ;
ulong addr;
volatile disk_partition_t info[2];
volatile char *env,*env2;
block_dev_desc_t *dev_desc;
ulong boot_part[MAX_BOOT_PART];
char *ep;
if (argc != 5)
{
printf ("Usage:\n%s\n", cmdtp->usage);
return 1;
}
dev = simple_strtoul(argv[1], &ep, 16);
if (*ep) {
if (*ep != ':')
{
printf ("Usage:\n%s\n", cmdtp->usage);
return(1);
}
for (part=0 ; part < MAX_BOOT_PART-1 ; part++)
{
ep++;
boot_part[part] = (ulong)simple_strtoul(ep, &ep, 16);
if (*ep != ',') {
printf ("Usage:\n%s\n", cmdtp->usage);
return(1);
}
}
boot_part[part] = (ulong)simple_strtoul(++ep, NULL, 16);
}
else
{
puts ("\n** Invalid boot device, use `dev:boot_part1,boot_part2' **\n");
return(1);
}
addr = simple_strtoul(argv[2], NULL, 16);
dev_desc = (dev >= CFG_IDE_MAXDEVICE) ? NULL : ide_get_dev(dev);
if (dev_desc == NULL)
{
printf("Non valid dev number %x\n",dev);
return 1;
}
/* Initialize IDE */
sprintf(tmp_string,"ide reset");
run_command(tmp_string,0);
/* Search for Active partition in partition #1 and partition #2*/
for (part = 0; part < MAX_BOOT_PART ;part++ )
{
if (get_partition_info (dev_desc,
boot_part[part],
(disk_partition_t*)&info[part]))
{
continue;
}
if (info[part].boot_ind )
{
active_part = part;
break;
}
}
/* If no active partition then return */
if (active_part == -1)
{
printf("No active partition on %d and %d\n",
boot_part[0],boot_part[1]);
return 1;
}
/* Load /boot/uImage from active_part to addr */
sprintf(tmp_string,"ext2load ide %x:%x %x %s", dev, boot_part[active_part], addr,argv[3]);
printf("%s\n",tmp_string);
run_command(tmp_string,0);
sprintf(tmp_string,"root=%s%d ro",argv[4],boot_part[active_part]);
setenv("bootargs_root",tmp_string);
env = getenv("bootargs");
env2 = getenv("bootargs_root");
/* Save bootargs for secondary boot option if boot from active partition will fail */
sprintf(tmp_string1,"%s",env);
sprintf(tmp_string,"%s %s",env,env2);
setenv("bootargs",tmp_string);
sprintf(tmp_string,"bootm %x", addr);
printf("%s\n",tmp_string);
run_command(tmp_string,0);
/* If we get here then first boot fail */
active_part = (active_part + 1)%MAX_BOOT_PART;
sprintf(tmp_string,"ext2load ide %x:%x %x %s", dev, boot_part[active_part], addr,argv[3]);
printf("%s\n",tmp_string);
run_command(tmp_string,0);
sprintf(tmp_string,"root=%s%d ro",argv[4],boot_part[active_part]);
setenv("bootargs_root",tmp_string);
env2 = getenv("bootargs_root");
sprintf(tmp_string,"%s %s %s",tmp_string1,env2, "boot_failure");
setenv("bootargs",tmp_string);
sprintf(tmp_string,"bootm %x", addr);
printf("Starting secondary boot...\n");
printf("%s\n",tmp_string);
run_command(tmp_string,0);
printf("Secondary boot fail...\n");
return 1;
}
static int load_rescue_image(ulong addr)
{
disk_partition_t info;
int devno;
int partno;
int i;
char fwdir[64];
char nxri[128];
char *tmp;
char dev[7];
char addr_str[16];
char *argv[6] = { "fatload", "usb", dev, addr_str, nxri, NULL };
block_dev_desc_t *stor_dev = NULL;
cmd_tbl_t *bcmd;
/* Get name of firmware directory */
tmp = getenv("fw-dir");
/* Copy it into fwdir */
strncpy(fwdir, tmp ? tmp : FW_DIR, sizeof(fwdir));
fwdir[sizeof(fwdir) - 1] = 0; /* Terminate string */
printf(LOG_PREFIX "Checking for firmware image directory '%s' on USB"
" storage...\n", fwdir);
usb_stop();
if (usb_init() != 0)
return 1;
/* Check for storage device */
if (usb_stor_scan(1) != 0) {
usb_stop();
return 1;
}
/* Detect storage device */
for (devno = 0; devno < USB_MAX_STOR_DEV; devno++) {
stor_dev = usb_stor_get_dev(devno);
if (stor_dev->type != DEV_TYPE_UNKNOWN)
break;
}
if (!stor_dev || stor_dev->type == DEV_TYPE_UNKNOWN) {
printf(LOG_PREFIX "No valid storage device found...\n");
usb_stop();
return 1;
}
/* Detect partition */
for (partno = -1, i = 0; i < 6; i++) {
if (get_partition_info(stor_dev, i, &info) == 0) {
if (fat_register_device(stor_dev, i) == 0) {
/* Check if rescue image is present */
FW_DEBUG("Looking for firmware directory '%s'"
" on partition %d\n", fwdir, i);
if (do_fat_read(fwdir, NULL, 0, LS_NO) == -1) {
FW_DEBUG("No NX rescue image on "
"partition %d.\n", i);
partno = -2;
} else {
partno = i;
FW_DEBUG("Partition %d contains "
"firmware directory\n", partno);
break;
}
}
}
}
if (partno < 0) {
switch (partno) {
case -1:
printf(LOG_PREFIX "Error: No valid (FAT) partition "
"detected\n");
break;
case -2:
printf(LOG_PREFIX "Error: No NX rescue image on FAT "
"partition\n");
break;
default:
printf(LOG_PREFIX "Error: Failed with code %d\n",
partno);
}
usb_stop();
return 1;
}
/* Load the rescue image */
bcmd = find_cmd("fatload");
if (!bcmd) {
printf(LOG_PREFIX "Error - 'fatload' command not present.\n");
usb_stop();
return 1;
}
tmp = getenv("nx-rescue-image");
sprintf(nxri, "%s/%s", fwdir, tmp ? tmp : RESCUE_IMAGE);
sprintf(dev, "%d:%d", devno, partno);
sprintf(addr_str, "%lx", addr);
FW_DEBUG("fat_fsload device='%s', addr='%s', file: %s\n",
dev, addr_str, nxri);
if (do_fat_fsload(bcmd, 0, 5, argv) != 0) {
usb_stop();
return 1;
}
/* Stop USB */
usb_stop();
return 0;
}
/*
* @param s Parameter string containing space-separated arguments:
* 1st:
* raw (raw read/write)
* fat (files)
* ext4 (^)
* part (partition image)
* 2nd and 3rd:
* lba_start and lba_size, for raw write
* mmc_dev and mmc_part, for filesystems and part
* 4th (optional):
* mmcpart <num> (access to HW eMMC partitions)
*/
int dfu_fill_entity_mmc(struct dfu_entity *dfu, char *s)
{
const char *entity_type;
size_t second_arg;
size_t third_arg;
struct mmc *mmc;
const char *argv[3];
const char **parg = argv;
for (; parg < argv + sizeof(argv) / sizeof(*argv); ++parg) {
*parg = strsep(&s, " ");
if (*parg == NULL) {
error("Invalid number of arguments.\n");
return -ENODEV;
}
}
entity_type = argv[0];
/*
* Base 0 means we'll accept (prefixed with 0x or 0) base 16, 8,
* with default 10.
*/
second_arg = simple_strtoul(argv[1], NULL, 0);
third_arg = simple_strtoul(argv[2], NULL, 0);
mmc = find_mmc_device(dfu->dev_num);
if (mmc == NULL) {
error("Couldn't find MMC device no. %d.\n", dfu->dev_num);
return -ENODEV;
}
if (mmc_init(mmc)) {
error("Couldn't init MMC device.\n");
return -ENODEV;
}
dfu->data.mmc.hw_partition = -EINVAL;
if (!strcmp(entity_type, "raw")) {
dfu->layout = DFU_RAW_ADDR;
dfu->data.mmc.lba_start = second_arg;
dfu->data.mmc.lba_size = third_arg;
dfu->data.mmc.lba_blk_size = mmc->read_bl_len;
/*
* Check for an extra entry at dfu_alt_info env variable
* specifying the mmc HW defined partition number
*/
if (s)
if (!strcmp(strsep(&s, " "), "mmcpart"))
dfu->data.mmc.hw_partition =
simple_strtoul(s, NULL, 0);
} else if (!strcmp(entity_type, "part")) {
disk_partition_t partinfo;
block_dev_desc_t *blk_dev = &mmc->block_dev;
int mmcdev = second_arg;
int mmcpart = third_arg;
if (get_partition_info(blk_dev, mmcpart, &partinfo) != 0) {
error("Couldn't find part #%d on mmc device #%d\n",
mmcpart, mmcdev);
return -ENODEV;
}
dfu->layout = DFU_RAW_ADDR;
dfu->data.mmc.lba_start = partinfo.start;
dfu->data.mmc.lba_size = partinfo.size;
dfu->data.mmc.lba_blk_size = partinfo.blksz;
} else if (!strcmp(entity_type, "fat")) {
dfu->layout = DFU_FS_FAT;
} else if (!strcmp(entity_type, "ext4")) {
dfu->layout = DFU_FS_EXT4;
} else {
error("Memory layout (%s) not supported!\n", entity_type);
return -ENODEV;
}
/* if it's NOT a raw write */
if (strcmp(entity_type, "raw")) {
dfu->data.mmc.dev = second_arg;
dfu->data.mmc.part = third_arg;
}
dfu->dev_type = DFU_DEV_MMC;
dfu->read_medium = dfu_read_medium_mmc;
dfu->write_medium = dfu_write_medium_mmc;
dfu->flush_medium = dfu_flush_medium_mmc;
dfu->inited = 0;
return 0;
}
static int do_zfs_load(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
char *filename = NULL;
char *ep;
int dev;
unsigned long part = 1;
ulong addr = 0;
ulong part_length;
disk_partition_t info;
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;
}
dev = (int)simple_strtoul(argv[2], &ep, 16);
zfs_dev_desc = get_dev(argv[1], dev);
if (zfs_dev_desc == NULL) {
printf("** Block device %s %d not supported\n", argv[1], dev);
return 1;
}
if (*ep) {
if (*ep != ':') {
puts("** Invalid boot device, use `dev[:part]' **\n");
return 1;
}
part = simple_strtoul(++ep, NULL, 16);
}
if (part != 0) {
if (get_partition_info(zfs_dev_desc, part, &info)) {
printf("** Bad partition %lu **\n", part);
return 1;
}
if (strncmp((char *)info.type, BOOT_PART_TYPE,
strlen(BOOT_PART_TYPE)) != 0) {
printf("** Invalid partition type \"%s\" (expect \"" BOOT_PART_TYPE "\")\n",
info.type);
return 1;
}
printf("Loading file \"%s\" "
"from %s device %d:%lu %s\n",
filename, argv[1], dev, part, info.name);
} else {
printf("Loading file \"%s\" from %s device %d\n",
filename, argv[1], dev);
}
part_length = zfs_set_blk_dev(zfs_dev_desc, part);
if (part_length == 0) {
printf("**Bad partition - %s %d:%lu **\n", argv[1], dev, part);
return 1;
}
vdev.part_length = part_length;
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:%lu **\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);
sprintf(buf, "%llX", zfile.size);
setenv("filesize", buf);
return 0;
}
/* booti <addr> [ mmc0 | mmc1 [ <partition> ] ] */
int do_booti(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
unsigned addr = 0;
char *ptn = "boot";
int mmcc = -1;
boot_img_hdr *hdr = (void *)boothdr;
#ifdef CONFIG_SECURE_BOOT
u_int32_t load_addr;
uint32_t image_size;
#endif
if (argc < 2)
return -1;
if (!strncmp(argv[1], "mmc", 3))
mmcc = simple_strtoul(argv[1]+3, NULL, 10);
else
addr = simple_strtoul(argv[1], NULL, 16);
if (argc > 2)
ptn = argv[2];
if (mmcc != -1) {
#ifdef CONFIG_MMC
struct fastboot_ptentry *pte;
struct mmc *mmc;
disk_partition_t info;
block_dev_desc_t *dev_desc = NULL;
unsigned sector, partno = -1;
memset((void *)&info, 0 , sizeof(disk_partition_t));
/* i.MX use MBR as partition table, so this will have
to find the start block and length for the
partition name and register the fastboot pte we
define the partition number of each partition in
config file
*/
mmc = find_mmc_device(mmcc);
if (!mmc) {
printf("booti: cannot find '%d' mmc device\n", mmcc);
goto fail;
}
dev_desc = get_dev("mmc", mmcc);
if (NULL == dev_desc) {
printf("** Block device MMC %d not supported\n", mmcc);
goto fail;
}
/* below was i.MX mmc operation code */
if (mmc_init(mmc)) {
printf("mmc%d init failed\n", mmcc);
goto fail;
}
#ifdef CONFIG_ANDROID_BOOT_PARTITION_MMC
#ifdef CONFIG_ANDROID_RECOVERY_PARTITION_MMC
if (!strcmp(ptn, "boot"))
partno = CONFIG_ANDROID_BOOT_PARTITION_MMC;
if (!strcmp(ptn, "recovery"))
partno = CONFIG_ANDROID_RECOVERY_PARTITION_MMC;
if (get_partition_info(dev_desc, partno, &info)) {
printf("booti: device don't have such partition:%s\n", ptn);
goto fail;
}
#endif
#endif
#ifdef CONFIG_FASTBOOT
fastboot_ptentry the_partition = {
.start = info.start,
.length = info.start * info.blksz,
.flags = 0,
.partition_id = 0,
};
strncpy(the_partition.name, ptn, 10);
fastboot_flash_add_ptn(&the_partition);
/* fastboot_flash_dump_ptn(); */
pte = fastboot_flash_find_ptn(ptn);
if (!pte) {
printf("booti: cannot find '%s' partition\n", ptn);
goto fail;
}
if (mmc->block_dev.block_read(mmcc, pte->start,
1, (void *)hdr) < 0) {
printf("booti: mmc failed to read bootimg header\n");
goto fail;
}
/* flush cache after read */
flush_cache((ulong)hdr, 512); /* FIXME */
if (memcmp(hdr->magic, BOOT_MAGIC, 8)) {
printf("booti: bad boot image magic\n");
goto fail;
}
sector = pte->start + (hdr->page_size / 512);
#else
if (mmc->block_dev.block_read(mmcc, info.start,
1, (void *)hdr) < 0) {
printf("booti: mmc failed to read bootimg header\n");
goto fail;
}
/* flush cache after read */
flush_cache((ulong)hdr, 512); /* FIXME */
if (memcmp(hdr->magic, BOOT_MAGIC, 8)) {
printf("booti: bad boot image magic\n");
goto fail;
}
sector = info.start + (hdr->page_size / 512);
#endif
if (mmc->block_dev.block_read(mmcc, sector,
(hdr->kernel_size / 512) + 1,
(void *)hdr->kernel_addr) < 0) {
printf("booti: mmc failed to read kernel\n");
goto fail;
}
/* flush cache after read */
flush_cache((ulong)hdr->kernel_addr, hdr->kernel_size); /* FIXME */
sector += ALIGN_SECTOR(hdr->kernel_size, hdr->page_size) / 512;
if (mmc->block_dev.block_read(mmcc, sector,
(hdr->ramdisk_size / 512) + 1,
(void *)hdr->ramdisk_addr) < 0) {
printf("booti: mmc failed to read kernel\n");
goto fail;
}
/* flush cache after read */
flush_cache((ulong)hdr->ramdisk_addr, hdr->ramdisk_size); /* FIXME */
#else
return -1;
#endif
} else {
unsigned kaddr, raddr;
/* set this aside somewhere safe */
memcpy(hdr, (void *) addr, sizeof(*hdr));
if (memcmp(hdr->magic, BOOT_MAGIC, 8)) {
printf("booti: bad boot image magic\n");
return 1;
}
bootimg_print_image_hdr(hdr);
kaddr = addr + hdr->page_size;
raddr = kaddr + ALIGN_SECTOR(hdr->kernel_size, hdr->page_size);
memmove((void *) hdr->kernel_addr, (void *)kaddr, hdr->kernel_size);
memmove((void *) hdr->ramdisk_addr, (void *)raddr, hdr->ramdisk_size);
}
printf("kernel @ %08x (%d)\n", hdr->kernel_addr, hdr->kernel_size);
printf("ramdisk @ %08x (%d)\n", hdr->ramdisk_addr, hdr->ramdisk_size);
#ifdef CONFIG_SECURE_BOOT
#define IVT_SIZE 0x20
#define CSF_PAD_SIZE 0x2000
extern uint32_t authenticate_image(uint32_t ddr_start,
uint32_t image_size);
image_size = hdr->ramdisk_addr + hdr->ramdisk_size - hdr->kernel_addr -
IVT_SIZE - CSF_PAD_SIZE;
if (authenticate_image(hdr->kernel_addr, image_size))
printf("Authentication Successful\n");
else
printf("Authentication Failed\n");
#endif
do_booti_linux(hdr);
puts ("booti: Control returned to monitor - resetting...\n");
do_reset (cmdtp, flag, argc, argv);
return 1;
fail:
#ifdef CONFIG_FASTBOOT
return do_fastboot(NULL, 0, 0, NULL);
#else
return -1;
#endif
}
static int check_recovery_cmd_file(void)
{
static disk_partition_t info;
char buf[CONFIG_RECOVERYFILE_SIZE];
int err;
block_dev_desc_t *dev_desc = NULL;
int dev = 0;
int part = EXT4_CACHE_PART;
loff_t filelen;
const char *ifname;
debug("check_recovery_cmd_file\n");
ifname = getenv("devif");
if ( ifname == NULL) {
ifname = "nand";
printf("get devif fail\n");
}
dev = get_boot_dev_num();
dev_desc = get_dev(ifname, dev);
if (dev_desc == NULL) {
printf("Failed to find %s%d\n", ifname, dev);
return 1;
}
debug("part = %d\n", part);
if (get_partition_info(dev_desc, part, &info)) {
printf("** get_partition_info %s%d:%d\n",
ifname, dev, part);
if (part != 0) {
printf("** Partition %d not valid on device %d **\n",
part, dev_desc->dev);
return -1;
}
info.start = 0;
info.size = dev_desc->lba;
info.blksz = dev_desc->blksz;
info.name[0] = 0;
info.type[0] = 0;
info.bootable = 0;
#ifdef CONFIG_PARTITION_UUIDS
info.uuid[0] = 0;
#endif
}
ext4fs_set_blk_dev(dev_desc, &info);
debug("info.size = %d\n", (int) info.size);
if (!ext4fs_mount(info.size)) {
printf("Failed to mount %s%d:%d\n",
ifname, dev, part);
ext4fs_close();
return 1;
}
err = ext4fs_open(CONFIG_ANDROID_RECOVERY_CMD_FILE, &filelen);
if (err < 0) {
printf("** File not found %s\n",
CONFIG_ANDROID_RECOVERY_CMD_FILE);
ext4fs_close();
return 1;
}
debug("filelen = %lld\n", filelen);
err = ext4fs_read(buf, CONFIG_RECOVERYFILE_SIZE, &filelen);
if (err < 0) {
printf("** File read error: %s\n",
CONFIG_ANDROID_RECOVERY_CMD_FILE);
ext4fs_close();
return 1;
}
ext4fs_close();
return 0;
}
int do_ext4_write(cmd_tbl_t *cmdtp, int flag, int argc,
char *const argv[])
{
const char *filename = "/";
int part_length;
unsigned long part = 1;
int dev;
char *ep;
unsigned long ram_address;
unsigned long file_size;
disk_partition_t info;
struct ext_filesystem *fs;
if (argc < 6)
return cmd_usage(cmdtp);
dev = (int)simple_strtoul(argv[2], &ep, 16);
ext4_dev_desc = get_dev(argv[1], dev);
if (ext4_dev_desc == NULL) {
printf("Block device %s %d not supported\n", argv[1], dev);
return 1;
}
if (init_fs(ext4_dev_desc))
return 1;
fs = get_fs();
if (*ep) {
if (*ep != ':') {
puts("Invalid boot device, use `dev[:part]'\n");
goto fail;
}
part = simple_strtoul(++ep, NULL, 16);
}
/* get the filename */
filename = argv[3];
/* get the address in hexadecimal format (string to int) */
ram_address = simple_strtoul(argv[4], NULL, 16);
/* get the filesize in base 10 format */
file_size = simple_strtoul(argv[5], NULL, 10);
/* set the device as block device */
part_length = ext4fs_set_blk_dev(fs->dev_desc, part);
if (part_length == 0) {
printf("Bad partition - %s %d:%lu\n", argv[1], dev, part);
goto fail;
}
/* register the device and partition */
if (ext4_register_device(fs->dev_desc, part) != 0) {
printf("Unable to use %s %d:%lu for fattable\n",
argv[1], dev, part);
goto fail;
}
/* get the partition information */
if (!get_partition_info(fs->dev_desc, part, &info)) {
total_sector = (info.size * info.blksz) / SECTOR_SIZE;
fs->total_sect = total_sector;
} else {
printf("error : get partition info\n");
goto fail;
}
/* mount the filesystem */
if (!ext4fs_mount(part_length)) {
printf("Bad ext4 partition %s %d:%lu\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();
deinit_fs(fs->dev_desc);
return 0;
fail:
ext4fs_close();
deinit_fs(fs->dev_desc);
return 1;
}
/******************************************************************************
* scsi boot command intepreter. Derived from diskboot
*/
int do_scsiboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
char *boot_device = NULL;
char *ep;
int dev, part = 0;
ulong addr, cnt, checksum;
disk_partition_t info;
image_header_t *hdr;
int rcode = 0;
switch (argc) {
case 1:
addr = CFG_LOAD_ADDR;
boot_device = getenv ("bootdevice");
break;
case 2:
addr = simple_strtoul(argv[1], NULL, 16);
boot_device = getenv ("bootdevice");
break;
case 3:
addr = simple_strtoul(argv[1], NULL, 16);
boot_device = argv[2];
break;
default:
printf ("Usage:\n%s\n", cmdtp->usage);
return 1;
}
if (!boot_device) {
puts ("\n** No boot device **\n");
return 1;
}
dev = simple_strtoul(boot_device, &ep, 16);
printf("booting from dev %d\n",dev);
if (scsi_dev_desc[dev].type == DEV_TYPE_UNKNOWN) {
printf ("\n** Device %d not available\n", dev);
return 1;
}
if (*ep) {
if (*ep != ':') {
puts ("\n** Invalid boot device, use `dev[:part]' **\n");
return 1;
}
part = simple_strtoul(++ep, NULL, 16);
}
if (get_partition_info (&scsi_dev_desc[dev], part, &info)) {
printf("error reading partinfo\n");
return 1;
}
if ((strncmp((char *)(info.type), BOOT_PART_TYPE, sizeof(info.type)) != 0) &&
(strncmp((char *)(info.type), BOOT_PART_COMP, sizeof(info.type)) != 0)) {
printf ("\n** Invalid partition type \"%.32s\""
" (expect \"" BOOT_PART_TYPE "\")\n",
info.type);
return 1;
}
printf ("\nLoading from SCSI device %d, partition %d: "
"Name: %.32s Type: %.32s\n",
dev, part, info.name, info.type);
debug ("First Block: %ld, # of blocks: %ld, Block Size: %ld\n",
info.start, info.size, info.blksz);
if (scsi_read (dev, info.start, 1, (ulong *)addr) != 1) {
printf ("** Read error on %d:%d\n", dev, part);
return 1;
}
hdr = (image_header_t *)addr;
if (ntohl(hdr->ih_magic) == IH_MAGIC) {
printf("\n** Bad Magic Number **\n");
return 1;
}
checksum = ntohl(hdr->ih_hcrc);
hdr->ih_hcrc = 0;
if (crc32 (0, (uchar *)hdr, sizeof(image_header_t)) != checksum) {
puts ("\n** Bad Header Checksum **\n");
return 1;
}
hdr->ih_hcrc = htonl(checksum); /* restore checksum for later use */
print_image_hdr (hdr);
cnt = (ntohl(hdr->ih_size) + sizeof(image_header_t));
cnt += info.blksz - 1;
cnt /= info.blksz;
cnt -= 1;
if (scsi_read (dev, info.start+1, cnt,
(ulong *)(addr+info.blksz)) != cnt) {
printf ("** Read error on %d:%d\n", dev, part);
return 1;
}
/* Loading ok, update default load address */
load_addr = addr;
flush_cache (addr, (cnt+1)*info.blksz);
/* Check if we should attempt an auto-start */
if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
char *local_args[2];
extern int do_bootm (cmd_tbl_t *, int, int, char *[]);
local_args[0] = argv[0];
local_args[1] = NULL;
printf ("Automatic boot of image at addr 0x%08lX ...\n", addr);
rcode = do_bootm (cmdtp, 0, 1, local_args);
}
return rcode;
}
static int do_ext4_load(cmd_tbl_t *cmdtp, int flag, int argc,
char *const argv[])
{
char *filename = NULL;
char *ep;
int dev;
unsigned long part = 1;
ulong addr = 0;
ulong part_length;
int filelen;
disk_partition_t info;
struct ext_filesystem *fs;
char buf[12];
unsigned long count;
const char *addr_str;
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;
}
dev = (int)simple_strtoul(argv[2], &ep, 16);
ext4_dev_desc = get_dev(argv[1], dev);
if (ext4_dev_desc == NULL) {
printf("** Block device %s %d not supported\n", argv[1], dev);
return 1;
}
if (init_fs(ext4_dev_desc))
return 1;
fs = get_fs();
if (*ep) {
if (*ep != ':') {
puts("** Invalid boot device, use `dev[:part]' **\n");
return 1;
}
part = simple_strtoul(++ep, NULL, 16);
}
if (part != 0) {
if (get_partition_info(fs->dev_desc, part, &info)) {
printf("** Bad partition %lu **\n", part);
return 1;
}
if (strncmp((char *)info.type, BOOT_PART_TYPE,
strlen(BOOT_PART_TYPE)) != 0) {
printf("** Invalid partition type \"%s\""
" (expect \"" BOOT_PART_TYPE "\")\n", info.type);
return 1;
}
printf("Loading file \"%s\" "
"from %s device %d:%lu %s\n",
filename, argv[1], dev, part, info.name);
} else {
printf("Loading file \"%s\" from %s device %d\n",
filename, argv[1], dev);
}
part_length = ext4fs_set_blk_dev(fs->dev_desc, part);
if (part_length == 0) {
printf("**Bad partition - %s %d:%lu **\n", argv[1], dev, part);
ext4fs_close();
return 1;
}
if (!ext4fs_mount(part_length)) {
printf("** Bad ext2 partition or disk - %s %d:%lu **\n",
argv[1], dev, part);
ext4fs_close();
return 1;
}
filelen = ext4fs_open(filename);
if (filelen < 0) {
printf("** File not found %s\n", filename);
ext4fs_close();
return 1;
}
if ((count < filelen) && (count != 0))
filelen = count;
if (ext4fs_read((char *)addr, filelen) != filelen) {
printf("** Unable to read \"%s\" from %s %d:%lu **\n",
filename, argv[1], dev, part);
ext4fs_close();
return 1;
}
ext4fs_close();
deinit_fs(fs->dev_desc);
/* Loading ok, update default load address */
load_addr = addr;
printf("%d bytes read\n", filelen);
sprintf(buf, "%X", filelen);
setenv("filesize", buf);
return 0;
}
static int do_write(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
char *ep;
block_dev_desc_t *dev_desc = NULL;
int dev;
int part = 0;
disk_partition_t part_info;
ulong offset = 0u;
ulong limit = 0u;
void *addr;
uint blk;
uint cnt;
if (argc != 6) {
cmd_usage(cmdtp);
return 1;
}
dev = (int)simple_strtoul(argv[2], &ep, 16);
if (*ep) {
if (*ep != ':') {
printf("Invalid block device %s\n", argv[2]);
return 1;
}
part = (int)simple_strtoul(++ep, NULL, 16);
}
dev_desc = get_dev(argv[1], dev);
if (dev_desc == NULL) {
printf("Block device %s %d not supported\n", argv[1], dev);
return 1;
}
addr = (void *)simple_strtoul(argv[3], NULL, 16);
blk = simple_strtoul(argv[4], NULL, 16);
cnt = simple_strtoul(argv[5], NULL, 16);
if (part != 0) {
if (get_partition_info(dev_desc, part, &part_info)) {
printf("Cannot find partition %d\n", part);
return 1;
}
offset = part_info.start;
limit = part_info.size;
} else {
/* Largest address not available in block_dev_desc_t. */
limit = ~0;
}
if (cnt + blk > limit) {
printf("Write out of range\n");
return 1;
}
if (dev_desc->block_write(dev, offset + blk, cnt, addr) < 0) {
printf("Error writing blocks\n");
return 1;
}
return 0;
}
void spl_mmc_load_image(void)
{
struct mmc *mmc;
int err;
u32 boot_mode;
mmc_initialize(gd->bd);
/* We register only one device. So, the dev id is always 0 */
mmc = find_mmc_device(0);
if (!mmc) {
puts("spl: mmc device not found!!\n");
hang();
}
err = mmc_init(mmc);
if (err) {
printf("spl: mmc init failed: err - %d\n", err);
hang();
}
#ifdef CONFIG_SPL_FAT_SUPPORT
/* FAT filesystem */
err = fat_register_device(&mmc->block_dev,
CONFIG_SYS_MMC_SD_FAT_BOOT_PARTITION);
/*if (err) {
printf("spl: fat register err - %d\n", err);
}*/
#ifdef CONFIG_SPL_OS_BOOT
if (spl_start_uboot() || mmc_load_image_fat_os(mmc))
#endif
err = mmc_load_image_fat(mmc, CONFIG_SPL_FAT_LOAD_PAYLOAD_NAME);
#endif
#ifdef CONFIG_SPL_EXT_SUPPORT
/* EXT filesystem */
if (err) {
printf("Load image from EXT...\n");
disk_partition_t info;
if (get_partition_info(&mmc->block_dev, CONFIG_SYS_MMC_SD_FAT_BOOT_PARTITION, &info)) {
printf("Cannot find partition %d\n", CONFIG_SYS_MMC_SD_FAT_BOOT_PARTITION);
}
if (ext4fs_probe(&mmc->block_dev, &info)) {
printf("ext4fs probe failed \n");
}
#ifdef CONFIG_SPL_OS_BOOT
if (spl_start_uboot() || mmc_load_image_ext_os(mmc))
#endif
err = mmc_load_image_ext(mmc, CONFIG_SPL_FAT_LOAD_PAYLOAD_NAME);
}
#endif
if (err) {
printf("Load image from RAW...\n");
#ifdef CONFIG_SPL_OS_BOOT
if (spl_start_uboot() || mmc_load_image_raw_os(mmc))
#endif
err = mmc_load_image_raw(mmc, CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
if (err) {
printf("spl: wrong MMC boot mode\n");
hang();
}
}
}
static int do_disk(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
struct block_dev_desc *dev = NULL;
int id, part = -1;
unsigned long addr, start, size, blksz;
char *ep;
if (argc != 5 && argc != 6)
goto usage;
addr = simple_strtoul(argv[2], NULL, 16);
id = (int)simple_strtoul(argv[4], &ep, 0);
dev = get_dev(argv[3], id);
if (dev == NULL) {
puts("Invalid block device\n");
return 1;
}
if (*ep) {
if (*ep != ':')
goto usage;
part = (int)simple_strtoul(++ep, NULL, 0);
}
if (part >= 0) {
struct disk_partition partinfo;
if (get_partition_info(dev, part, &partinfo)) {
printf("Invalid partition");
return 1;
}
start = partinfo.start;
size = partinfo.size;
blksz = partinfo.blksz;
} else {
start = 0;
size = dev->lba;
blksz = dev->blksz;
}
if (argc >= 6) {
unsigned long s = simple_strtoul(argv[5], NULL, 16);
s = (s + blksz - 1) / blksz;
if (s > size) {
printf("Access beyond partition size!\n");
return 1;
}
size = s;
}
if (strcmp(argv[1], "read") == 0) {
return dev->block_read(dev->dev, start, size, (void *)addr) != size;
} else if (strcmp(argv[1], "write") == 0) {
if (!dev->block_write) {
printf("Read only device!");
return 1;
}
return dev->block_write(dev->dev, start, size, (void *)addr) != size;
}
usage:
printf("Usage: disk read|write <addr> <interface> <dev[:part]> [size]\n");
return 1;
}
int do_part_find(int argc, char * const argv[])
{
int part, dev, i, ret=1;
block_dev_desc_t *dev_desc;
disk_partition_t info;
size_t mnb_of;
const char *value_str;
char *dup_str = NULL;
const char *criteria_str;
char buf_str[4];
if (argc < 3)
return CMD_RET_USAGE;
if (argc > 4)
return CMD_RET_USAGE;
dev = get_device(argv[0], argv[1], &dev_desc);
if (dev < 0)
return 1;
/* check and split criteria:value */
value_str = strchr(argv[2],':');
if (!value_str)
return CMD_RET_USAGE;
dup_str = strdup(argv[2]);
if(!dup_str)
return 1;
if ( (value_str - argv[2]) > strlen(dup_str) )
return 1;
dup_str[value_str - argv[2]] = 0;
criteria_str = dup_str;
value_str++;
if(!strcmp(criteria_str, "uuid"))
mnb_of = offsetof(disk_partition_t, uuid);
else if(!strcmp(criteria_str, "label"))
mnb_of = offsetof(disk_partition_t, name);
else {
printf("Bad criteria: %s\n", criteria_str);
ret = CMD_RET_USAGE;
goto end_of_part_find;
}
part=-1;
for (i = 1; i <= MAX_SEARCH_PARTITIONS; i++) {
ret = get_partition_info(dev_desc, i, &info);
if (ret)
continue;
if(!strcmp(((char*)&info + mnb_of), value_str)) {
part = i;
ret = 0;
break;
}
}
if ( part == -1) {
printf("No partition found\n");
ret = 1;
goto end_of_part_find;
}
snprintf(buf_str, sizeof(buf_str), "%d", part);
if ( argc > 3)
setenv(argv[3],buf_str);
else
printf("Partition %s correspond to %s == %s\n",
buf_str, criteria_str, value_str);
end_of_part_find:
if( dup_str )
free (dup_str);
return ret;
}
int do_blkdevparts(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
disk_partition_t part_info;
block_dev_desc_t *dev_desc;
char *ep;
int part = 1; /* Start with partition 1 */
char *blkdevparts;
char blkdev_buf[MAX_BLKDEVPARTS_MAXLEN];
char part_buf[MAX_PARTITION_MAXLEN];
int dev;
int m, n;
const char *env_p;
debug("do_blkdevparts\n");
memset(blkdev_buf, 0, sizeof(blkdev_buf));
if (argc < 3) {
cmd_usage(cmdtp);
return 1;
}
dev = (int) simple_strtoul(argv[2], &ep, 16);
dev_desc = get_dev(argv[1], dev);
if (dev_desc == NULL) {
printf("Invalid device\n");
return 1;
}
if (dev_desc->part_type != PART_TYPE_TOC) {
printf("Device is not TOC partitioned!\n");
return 1;
}
/* Only support sd/mmc interface */
switch (dev_desc->if_type) {
case IF_TYPE_MMC:
case IF_TYPE_SD:
n = sprintf(blkdev_buf, "%s", MMC_BLKDEV_ID);
break;
default:
printf("Interface is not supported: %s\n", argv[1]);
return 1;
}
/* Add the device */
n += sprintf(&blkdev_buf[n], "%d:", dev);
while (get_partition_info(dev_desc, part, &part_info) == 0) {
memset(part_buf, 0, sizeof(part_buf));
m = 0;
/*
* Build up the bootargs environment
* variable with blkdev info
*/
debug("Partition found - part: %d!\n", part);
/* Partition found */
if (part > 1)
/* Don't add a comma before the first partition */
m = sprintf(part_buf, "%s", ",");
sprintf(&part_buf[m], "%lu@%lu",
part_info.size, part_info.start);
/* Append the partition to the blkdev string */
if ((n + sizeof(part_buf)) <= sizeof(blkdev_buf))
n += sprintf(&blkdev_buf[n], "%s", part_buf);
else {
printf("No space to add partition to blkdevparts\n");
return 1;
}
part++;
};
debug("No more partitions\n");
/* Check if blkdevparts env var already existing */
env_p = getenv("blkdevparts");
if (env_p) {
debug("Appending to existing blkdevparts env var\n");
/* Allocate a buffer incl the added ;*/
blkdevparts = malloc(strlen(env_p) + strlen(blkdev_buf) + 1);
sprintf(blkdevparts, "%s;%s", env_p, blkdev_buf);
setenv("blkdevparts", blkdevparts);
/* free up the buffer */
free(blkdevparts);
} else
setenv("blkdevparts", blkdev_buf);
return 0;
}
