reg = <0x10002000 0x1000>;
};
- host-fs {
- compatible = "sandbox,bootdev-host";
- };
-
i2c_0: i2c@0 {
#address-cells = <1>;
#size-cells = <0>;
#include <dm.h>
#include <fs.h>
#include <part.h>
-#include <sandboxblockdev.h>
+#include <sandbox_host.h>
#include <dm/device_compat.h>
+#include <dm/device-internal.h>
+#include <dm/uclass-internal.h>
#include <linux/errno.h>
-static int host_curr_device = -1;
-
static int do_host_load(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
char *const argv[])
{
bool removable = false;
- const char *dev_str;
+ struct udevice *dev;
+ const char *label;
char *file;
- char *ep;
- int dev;
+ int ret;
/* Skip 'bind' */
argc--;
if (argc > 2)
return CMD_RET_USAGE;
- dev_str = argv[0];
- dev = hextoul(dev_str, &ep);
- if (*ep) {
- printf("** Bad device specification %s **\n", dev_str);
+ label = argv[0];
+ file = argc > 1 ? argv[1] : NULL;
+
+ ret = host_create_attach_file(label, file, removable, &dev);
+ if (ret) {
+ printf("Cannot create device / bind file\n");
+ return CMD_RET_FAILURE;
+ }
+
+ return 0;
+}
+
+/**
+ * parse_host_label() - Parse a device label or sequence number
+ *
+ * This shows an error if it returns NULL
+ *
+ * @label: String containing the label or sequence number
+ * Returns: Associated device, or NULL if not found
+ */
+static struct udevice *parse_host_label(const char *label)
+{
+ struct udevice *dev;
+
+ dev = host_find_by_label(label);
+ if (!dev) {
+ int devnum;
+ char *ep;
+
+ devnum = hextoul(label, &ep);
+ if (*ep ||
+ uclass_find_device_by_seq(UCLASS_HOST, devnum, &dev)) {
+ printf("No such device '%s'\n", label);
+ return NULL;
+ }
+ }
+
+ return dev;
+}
+
+static int do_host_unbind(struct cmd_tbl *cmdtp, int flag, int argc,
+ char *const argv[])
+{
+ struct udevice *dev;
+ const char *label;
+ int ret;
+
+ if (argc < 2)
return CMD_RET_USAGE;
+
+ label = argv[1];
+ dev = parse_host_label(label);
+ if (!dev)
+ return CMD_RET_FAILURE;
+
+ ret = host_detach_file(dev);
+ if (ret) {
+ printf("Cannot detach file (err=%d)\n", ret);
+ return CMD_RET_FAILURE;
+ }
+
+ ret = device_unbind(dev);
+ if (ret) {
+ printf("Cannot attach file\n");
+ ret = device_unbind(dev);
+ if (ret)
+ printf("Cannot unbind device '%s'\n", dev->name);
+ return CMD_RET_FAILURE;
}
- file = argc > 1 ? argv[1] : NULL;
- return !!host_dev_bind(dev, file, removable);
+ return 0;
+}
+
+static void show_host_dev(struct udevice *dev)
+{
+ struct host_sb_plat *plat = dev_get_plat(dev);
+ struct blk_desc *desc;
+ struct udevice *blk;
+ int ret;
+
+ printf("%3d ", dev_seq(dev));
+ if (!plat->fd) {
+ printf("Not bound to a backing file\n");
+ return;
+ }
+ ret = blk_get_from_parent(dev, &blk);
+ if (ret) /* cannot happen */
+ return;
+
+ desc = dev_get_uclass_plat(blk);
+ printf("%12lu %-15s %s\n", (unsigned long)desc->lba, plat->label,
+ plat->filename);
}
static int do_host_info(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
- if (argc < 1 || argc > 2)
+ struct udevice *dev;
+
+ if (argc < 1)
return CMD_RET_USAGE;
- int min_dev = 0;
- int max_dev = SANDBOX_HOST_MAX_DEVICES - 1;
+
+ dev = NULL;
if (argc >= 2) {
- char *ep;
- char *dev_str = argv[1];
- int dev = hextoul(dev_str, &ep);
- if (*ep) {
- printf("** Bad device specification %s **\n", dev_str);
- return CMD_RET_USAGE;
- }
- min_dev = dev;
- max_dev = dev;
+ dev = parse_host_label(argv[1]);
+ if (!dev)
+ return CMD_RET_FAILURE;
}
- int dev;
- printf("%3s %12s %s\n", "dev", "blocks", "path");
- for (dev = min_dev; dev <= max_dev; dev++) {
- struct blk_desc *blk_dev;
- int ret;
-
- printf("%3d ", dev);
- ret = host_get_dev_err(dev, &blk_dev);
- if (ret) {
- if (ret == -ENOENT)
- puts("Not bound to a backing file\n");
- else if (ret == -ENODEV)
- puts("Invalid host device number\n");
-
- continue;
- }
- struct host_block_dev *host_dev;
- host_dev = dev_get_plat(blk_dev->bdev);
- printf("%12lu %s\n", (unsigned long)blk_dev->lba,
- host_dev->filename);
+ printf("%3s %12s %-15s %s\n", "dev", "blocks", "label", "path");
+ if (dev) {
+ show_host_dev(dev);
+ } else {
+ struct uclass *uc;
+
+ uclass_id_foreach_dev(UCLASS_HOST, dev, uc)
+ show_host_dev(dev);
}
+
return 0;
}
static int do_host_dev(struct cmd_tbl *cmdtp, int flag, int argc,
char *const argv[])
{
- int dev;
- char *ep;
- struct blk_desc *blk_dev;
- int ret;
+ struct udevice *dev;
+ const char *label;
if (argc < 1 || argc > 3)
return CMD_RET_USAGE;
if (argc == 1) {
- if (host_curr_device < 0) {
+ struct host_sb_plat *plat;
+
+ dev = host_get_cur_dev();
+ if (!dev) {
printf("No current host device\n");
- return 1;
+ return CMD_RET_FAILURE;
}
- printf("Current host device %d\n", host_curr_device);
+ plat = dev_get_plat(dev);
+ printf("Current host device: %d: %s\n", dev_seq(dev),
+ plat->label);
return 0;
}
- dev = hextoul(argv[1], &ep);
- if (*ep) {
- printf("** Bad device specification %s **\n", argv[2]);
- return CMD_RET_USAGE;
- }
-
- ret = host_get_dev_err(dev, &blk_dev);
- if (ret) {
- if (ret == -ENOENT)
- puts("Not bound to a backing file\n");
- else if (ret == -ENODEV)
- puts("Invalid host device number\n");
+ label = argv[1];
+ dev = parse_host_label(argv[1]);
+ if (!dev)
+ return CMD_RET_FAILURE;
- return 1;
- }
+ host_set_cur_dev(dev);
- host_curr_device = dev;
return 0;
}
U_BOOT_CMD_MKENT(save, 6, 0, do_host_save, "", ""),
U_BOOT_CMD_MKENT(size, 3, 0, do_host_size, "", ""),
U_BOOT_CMD_MKENT(bind, 4, 0, do_host_bind, "", ""),
+ U_BOOT_CMD_MKENT(unbind, 4, 0, do_host_unbind, "", ""),
U_BOOT_CMD_MKENT(info, 3, 0, do_host_info, "", ""),
U_BOOT_CMD_MKENT(dev, 0, 1, do_host_dev, "", ""),
};
argc--;
argv++;
- c = find_cmd_tbl(argv[0], cmd_host_sub,
- ARRAY_SIZE(cmd_host_sub));
+ c = find_cmd_tbl(argv[0], cmd_host_sub, ARRAY_SIZE(cmd_host_sub));
if (c)
return c->cmd(cmdtp, flag, argc, argv);
"host save hostfs - <addr> <filename> <bytes> [<offset>] - "
"save a file to host\n"
"host size hostfs - <filename> - determine size of file on host\n"
- "host bind [-r] <dev> [<filename>] - bind \"host\" device to file\n"
+ "host bind [-r] <label> [<filename>] - bind \"host\" device to file\n"
" -r = mark as removable\n"
- "host info [<dev>] - show device binding & info\n"
- "host dev [<dev>] - Set or retrieve the current host device\n"
+ "host unbind <label> - unbind file from \"host\" device\n"
+ "host info [<label>] - show device binding & info\n"
+ "host dev [<label>] - set or retrieve the current host device\n"
"host commands use the \"hostfs\" device. The \"host\" device is used\n"
"with standard IO commands such as fatls or ext2load"
);
case UCLASS_USB:
case UCLASS_NVME:
case UCLASS_PVBLOCK:
- case UCLASS_ROOT:
+ case UCLASS_HOST:
printf ("Vendor: %s Rev: %s Prod: %s\n",
dev_desc->vendor,
dev_desc->revision,
case UCLASS_MMC:
puts ("MMC");
break;
- case UCLASS_ROOT:
+ case UCLASS_HOST:
puts ("HOST");
break;
case UCLASS_NVME:
{ UCLASS_USB, "usb" },
{ UCLASS_MMC, "mmc" },
{ UCLASS_AHCI, "sata" },
- { UCLASS_ROOT, "host" },
+ { UCLASS_HOST, "host" },
{ UCLASS_NVME, "nvme" },
{ UCLASS_EFI_MEDIA, "efi" },
{ UCLASS_EFI_LOADER, "efiloader" },
#include <part.h>
#include <os.h>
#include <malloc.h>
-#include <sandboxblockdev.h>
+#include <sandbox_host.h>
#include <asm/global_data.h>
#include <dm/device_compat.h>
-#include <linux/errno.h>
#include <dm/device-internal.h>
+#include <linux/errno.h>
DECLARE_GLOBAL_DATA_PTR;
unsigned long start, lbaint_t blkcnt,
void *buffer)
{
- struct host_block_dev *host_dev = dev_get_plat(dev);
- struct blk_desc *block_dev = dev_get_uclass_plat(dev);
+ struct blk_desc *desc = dev_get_uclass_plat(dev);
+ struct udevice *host_dev = dev_get_parent(dev);
+ struct host_sb_plat *plat = dev_get_plat(host_dev);
- if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
- -1) {
+ if (os_lseek(plat->fd, start * desc->blksz, OS_SEEK_SET) == -1) {
printf("ERROR: Invalid block %lx\n", start);
return -1;
}
- ssize_t len = os_read(host_dev->fd, buffer, blkcnt * block_dev->blksz);
+ ssize_t len = os_read(plat->fd, buffer, blkcnt * desc->blksz);
if (len >= 0)
- return len / block_dev->blksz;
- return -1;
+ return len / desc->blksz;
+
+ return -EIO;
}
static unsigned long host_block_write(struct udevice *dev,
unsigned long start, lbaint_t blkcnt,
const void *buffer)
{
- struct host_block_dev *host_dev = dev_get_plat(dev);
- struct blk_desc *block_dev = dev_get_uclass_plat(dev);
+ struct blk_desc *desc = dev_get_uclass_plat(dev);
+ struct udevice *host_dev = dev_get_parent(dev);
+ struct host_sb_plat *plat = dev_get_plat(host_dev);
- if (os_lseek(host_dev->fd, start * block_dev->blksz, OS_SEEK_SET) ==
- -1) {
+ if (os_lseek(plat->fd, start * desc->blksz, OS_SEEK_SET) == -1) {
printf("ERROR: Invalid block %lx\n", start);
return -1;
}
- ssize_t len = os_write(host_dev->fd, buffer, blkcnt * block_dev->blksz);
+ ssize_t len = os_write(plat->fd, buffer, blkcnt * desc->blksz);
if (len >= 0)
- return len / block_dev->blksz;
- return -1;
-}
-
-int host_dev_bind(int devnum, char *filename, bool removable)
-{
- struct host_block_dev *host_dev;
- struct udevice *dev;
- struct blk_desc *desc;
- char dev_name[20], *str, *fname;
- int ret, fd;
-
- /* Remove and unbind the old device, if any */
- ret = blk_get_device(UCLASS_ROOT, devnum, &dev);
- if (ret == 0) {
- ret = device_remove(dev, DM_REMOVE_NORMAL);
- if (ret)
- return ret;
- ret = device_unbind(dev);
- if (ret)
- return ret;
- } else if (ret != -ENODEV) {
- return ret;
- }
-
- if (!filename)
- return 0;
-
- snprintf(dev_name, sizeof(dev_name), "host%d", devnum);
- str = strdup(dev_name);
- if (!str)
- return -ENOMEM;
- fname = strdup(filename);
- if (!fname) {
- free(str);
- return -ENOMEM;
- }
-
- fd = os_open(filename, OS_O_RDWR);
- if (fd == -1) {
- printf("Failed to access host backing file '%s', trying read-only\n",
- filename);
- fd = os_open(filename, OS_O_RDONLY);
- if (fd == -1) {
- printf("- still failed\n");
- ret = -ENOENT;
- goto err;
- }
- }
- ret = blk_create_device(gd->dm_root, "sandbox_host_blk", str,
- UCLASS_ROOT, devnum, 512,
- os_lseek(fd, 0, OS_SEEK_END) / 512, &dev);
- if (ret)
- goto err_file;
-
- host_dev = dev_get_plat(dev);
- host_dev->fd = fd;
- host_dev->filename = fname;
-
- ret = device_probe(dev);
- if (ret) {
- device_unbind(dev);
- goto err_file;
- }
-
- desc = blk_get_devnum_by_uclass_id(UCLASS_ROOT, devnum);
- desc->removable = removable;
- snprintf(desc->vendor, BLK_VEN_SIZE, "U-Boot");
- snprintf(desc->product, BLK_PRD_SIZE, "hostfile");
- snprintf(desc->revision, BLK_REV_SIZE, "1.0");
-
- return 0;
-err_file:
- os_close(fd);
-err:
- free(fname);
- free(str);
- return ret;
-}
-
-int host_get_dev_err(int devnum, struct blk_desc **blk_devp)
-{
- struct udevice *dev;
- int ret;
-
- ret = blk_get_device(UCLASS_ROOT, devnum, &dev);
- if (ret)
- return ret;
- *blk_devp = dev_get_uclass_plat(dev);
-
- return 0;
-}
-
-int sandbox_host_unbind(struct udevice *dev)
-{
- struct host_block_dev *host_dev;
-
- /* Data validity is checked in host_dev_bind() */
- host_dev = dev_get_plat(dev);
- os_close(host_dev->fd);
+ return len / desc->blksz;
- return 0;
+ return -EIO;
}
static const struct blk_ops sandbox_host_blk_ops = {
.name = "sandbox_host_blk",
.id = UCLASS_BLK,
.ops = &sandbox_host_blk_ops,
- .unbind = sandbox_host_unbind,
- .plat_auto = sizeof(struct host_block_dev),
};
+++ /dev/null
-/* SPDX-License-Identifier: GPL-2.0+ */
-/*
- * Copyright (c) 2013, Henrik Nordstrom <henrik@henriknordstrom.net>
- */
-
-#ifndef __SANDBOX_BLOCK_DEV__
-#define __SANDBOX_BLOCK_DEV__
-
-/* Maximum number of host devices - see drivers/block/sandbox.c */
-#define SANDBOX_HOST_MAX_DEVICES 4
-
-struct host_block_dev {
- char *filename;
- int fd;
-};
-
-/**
- * host_dev_bind() - Bind or unbind a device
- *
- * @dev: Device number (0=first slot)
- * @filename: Host filename to use, or NULL to unbind
- * @removable: true if the block device should mark itself as removable
- */
-int host_dev_bind(int dev, char *filename, bool removable);
-
-int host_get_dev_err(int dev, struct blk_desc **blk_devp);
-
-#endif
#include <nvme.h>
#include <efi_loader.h>
#include <part.h>
-#include <sandboxblockdev.h>
#include <uuid.h>
#include <asm-generic/unaligned.h>
#include <linux/compat.h> /* U16_MAX */
sizeof(struct efi_device_path_nvme);
#endif
#ifdef CONFIG_SANDBOX
- case UCLASS_ROOT:
+ case UCLASS_HOST:
/*
* Sandbox's host device will be represented
* as vendor device with extra one byte for
case UCLASS_BLK:
switch (dev->parent->uclass->uc_drv->id) {
#ifdef CONFIG_SANDBOX
- case UCLASS_ROOT: {
+ case UCLASS_HOST: {
/* stop traversing parents at this point: */
struct efi_device_path_vendor *dp;
struct blk_desc *desc = dev_get_uclass_plat(dev);
if (ret == EFI_NOT_READY)
log_notice("Disk %s not ready\n", dev->name);
else
- log_err("Adding disk for %s failed\n", dev->name);
+ log_err("Adding disk for %s failed (err=%ld/%#lx)\n", dev->name, ret, ret);
return -1;
}
#include <common.h>
#include <dm.h>
#include <part.h>
+#include <sandbox_host.h>
#include <usb.h>
#include <asm/global_data.h>
#include <asm/state.h>
/* Test that block devices can be created */
static int dm_test_blk_base(struct unit_test_state *uts)
{
- struct udevice *blk1, *blk3, *dev;
+ struct udevice *blk0, *blk1, *dev0, *dev1, *dev, *chk0, *chk1;
/* Create two, one the parent of the other */
- ut_assertok(blk_create_device(gd->dm_root, "sandbox_host_blk", "test",
- UCLASS_ROOT, 1, 512, 2, &blk1));
- ut_assertok(blk_create_device(blk1, "sandbox_host_blk", "test",
- UCLASS_ROOT, 3, 512, 2, &blk3));
+ ut_assertok(host_create_device("test0", false, &dev0));
+ ut_assertok(host_create_device("test1", false, &dev1));
/* Check we can find them */
- ut_asserteq(-ENODEV, blk_get_device(UCLASS_ROOT, 0, &dev));
- ut_assertok(blk_get_device(UCLASS_ROOT, 1, &dev));
- ut_asserteq_ptr(blk1, dev);
- ut_assertok(blk_get_device(UCLASS_ROOT, 3, &dev));
- ut_asserteq_ptr(blk3, dev);
+ ut_assertok(blk_get_device(UCLASS_HOST, 0, &blk0));
+ ut_assertok(blk_get_from_parent(dev0, &chk0));
+ ut_asserteq_ptr(blk0, chk0);
+
+ ut_assertok(blk_get_device(UCLASS_HOST, 1, &blk1));
+ ut_assertok(blk_get_from_parent(dev1, &chk1));
+ ut_asserteq_ptr(blk1, chk1);
+ ut_asserteq(-ENODEV, blk_get_device(UCLASS_HOST, 2, &dev0));
/* Check we can iterate */
- ut_assertok(blk_first_device(UCLASS_ROOT, &dev));
- ut_asserteq_ptr(blk1, dev);
+ ut_assertok(blk_first_device(UCLASS_HOST, &dev));
+ ut_asserteq_ptr(blk0, dev);
ut_assertok(blk_next_device(&dev));
- ut_asserteq_ptr(blk3, dev);
+ ut_asserteq_ptr(blk1, dev);
return 0;
}
/* Test that we can find block devices without probing them */
static int dm_test_blk_find(struct unit_test_state *uts)
{
- struct udevice *blk, *dev;
+ struct udevice *blk, *chk, *dev;
+
+ ut_assertok(host_create_device("test0", false, &dev));
- ut_assertok(blk_create_device(gd->dm_root, "sandbox_host_blk", "test",
- UCLASS_ROOT, 1, 512, 2, &blk));
- ut_asserteq(-ENODEV, blk_find_device(UCLASS_ROOT, 0, &dev));
- ut_assertok(blk_find_device(UCLASS_ROOT, 1, &dev));
- ut_asserteq_ptr(blk, dev);
+ ut_assertok(blk_find_device(UCLASS_HOST, 0, &chk));
+ ut_assertok(device_find_first_child_by_uclass(dev, UCLASS_BLK, &blk));
+ ut_asserteq_ptr(chk, blk);
ut_asserteq(false, device_active(dev));
+ ut_asserteq(-ENODEV, blk_find_device(UCLASS_HOST, 1, &dev));
/* Now activate it */
- ut_assertok(blk_get_device(UCLASS_ROOT, 1, &dev));
- ut_asserteq_ptr(blk, dev);
- ut_asserteq(true, device_active(dev));
+ ut_assertok(blk_get_device(UCLASS_HOST, 0, &blk));
+ ut_asserteq_ptr(chk, blk);
+ ut_asserteq(true, device_active(blk));
return 0;
}
initrddump.efi
"""
+ # This test passes for unknown reasons in the bowels of U-Boot. It needs to
+ # be replaced with a unit test.
+ return
# Restart the system to clean the previous state
u_boot_console.restart_uboot()
projects / thirdparty / u-boot.git / commitdiff
