dm: blk: Add a way to obtain a block device from its parent

[oweals/u-boot.git] / drivers / block / blk-uclass.c

diff --git a/drivers/block/blk-uclass.c b/drivers/block/blk-uclass.c
index f67f9b9d5524cc7c01d5063ff06cb472a75868c0..23f131b7ad74b0a363038ef5bcd0b667e871c082 100644 (file)
--- a/drivers/block/blk-uclass.c
+++ b/drivers/block/blk-uclass.c
@@ -26,7 +26,7 @@ static const char *if_typename_str[IF_TYPE_COUNT] = {
 
 static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
        [IF_TYPE_IDE]           = UCLASS_INVALID,
-       [IF_TYPE_SCSI]          = UCLASS_INVALID,
+       [IF_TYPE_SCSI]          = UCLASS_SCSI,
        [IF_TYPE_ATAPI]         = UCLASS_INVALID,
        [IF_TYPE_USB]           = UCLASS_MASS_STORAGE,
        [IF_TYPE_DOC]           = UCLASS_INVALID,
@@ -156,6 +156,8 @@ static int get_desc(enum if_type if_type, int devnum, struct blk_desc **descp)
                                if (ret)
                                        return ret;
 
+                               *descp = desc;
+                               return 0;
                        } else if (desc->devnum > devnum) {
                                found_more = true;
                        }
@@ -165,6 +167,18 @@ static int get_desc(enum if_type if_type, int devnum, struct blk_desc **descp)
        return found_more ? -ENOENT : -ENODEV;
 }
 
+int blk_select_hwpart_devnum(enum if_type if_type, int devnum, int hwpart)
+{
+       struct udevice *dev;
+       int ret;
+
+       ret = blk_get_device(if_type, devnum, &dev);
+       if (ret)
+               return ret;
+
+       return blk_select_hwpart(dev, hwpart);
+}
+
 int blk_list_part(enum if_type if_type)
 {
        struct blk_desc *desc;
@@ -291,6 +305,23 @@ ulong blk_write_devnum(enum if_type if_type, int devnum, lbaint_t start,
        return blk_dwrite(desc, start, blkcnt, buffer);
 }
 
+int blk_select_hwpart(struct udevice *dev, int hwpart)
+{
+       const struct blk_ops *ops = blk_get_ops(dev);
+
+       if (!ops)
+               return -ENOSYS;
+       if (!ops->select_hwpart)
+               return 0;
+
+       return ops->select_hwpart(dev, hwpart);
+}
+
+int blk_dselect_hwpart(struct blk_desc *desc, int hwpart)
+{
+       return blk_select_hwpart(desc->bdev, hwpart);
+}
+
 int blk_first_device(int if_type, struct udevice **devp)
 {
        struct blk_desc *desc;
@@ -332,7 +363,7 @@ int blk_next_device(struct udevice **devp)
        } while (1);
 }
 
-int blk_get_device(int if_type, int devnum, struct udevice **devp)
+int blk_find_device(int if_type, int devnum, struct udevice **devp)
 {
        struct uclass *uc;
        struct udevice *dev;
@@ -348,13 +379,24 @@ int blk_get_device(int if_type, int devnum, struct udevice **devp)
                      if_type, devnum, dev->name, desc->if_type, desc->devnum);
                if (desc->if_type == if_type && desc->devnum == devnum) {
                        *devp = dev;
-                       return device_probe(dev);
+                       return 0;
                }
        }
 
        return -ENODEV;
 }
 
+int blk_get_device(int if_type, int devnum, struct udevice **devp)
+{
+       int ret;
+
+       ret = blk_find_device(if_type, devnum, devp);
+       if (ret)
+               return ret;
+
+       return device_probe(*devp);
+}
+
 unsigned long blk_dread(struct blk_desc *block_dev, lbaint_t start,
                        lbaint_t blkcnt, void *buffer)
 {
@@ -411,6 +453,32 @@ int blk_prepare_device(struct udevice *dev)
        return 0;
 }
 
+int blk_get_from_parent(struct udevice *parent, struct udevice **devp)
+{
+       struct udevice *dev;
+       enum uclass_id id;
+       int ret;
+
+       device_find_first_child(parent, &dev);
+       if (!dev) {
+               debug("%s: No block device found for parent '%s'\n", __func__,
+                     parent->name);
+               return -ENODEV;
+       }
+       id = device_get_uclass_id(dev);
+       if (id != UCLASS_BLK) {
+               debug("%s: Incorrect uclass %s for block device '%s'\n",
+                     __func__, uclass_get_name(id), dev->name);
+               return -ENOTBLK;
+       }
+       ret = device_probe(dev);
+       if (ret)
+               return ret;
+       *devp = dev;
+
+       return 0;
+}
+
 int blk_find_max_devnum(enum if_type if_type)
 {
        struct udevice *dev;
@@ -431,6 +499,44 @@ int blk_find_max_devnum(enum if_type if_type)
        return max_devnum;
 }
 
+static int blk_next_free_devnum(enum if_type if_type)
+{
+       int ret;
+
+       ret = blk_find_max_devnum(if_type);
+       if (ret == -ENODEV)
+               return 0;
+       if (ret < 0)
+               return ret;
+
+       return ret + 1;
+}
+
+static int blk_claim_devnum(enum if_type if_type, int devnum)
+{
+       struct udevice *dev;
+       struct uclass *uc;
+       int ret;
+
+       ret = uclass_get(UCLASS_BLK, &uc);
+       if (ret)
+               return ret;
+       uclass_foreach_dev(dev, uc) {
+               struct blk_desc *desc = dev_get_uclass_platdata(dev);
+
+               if (desc->if_type == if_type && desc->devnum == devnum) {
+                       int next = blk_next_free_devnum(if_type);
+
+                       if (next < 0)
+                               return next;
+                       desc->devnum = next;
+                       return 0;
+               }
+       }
+
+       return -ENOENT;
+}
+
 int blk_create_device(struct udevice *parent, const char *drv_name,
                      const char *name, int if_type, int devnum, int blksz,
                      lbaint_t size, struct udevice **devp)
@@ -440,14 +546,14 @@ int blk_create_device(struct udevice *parent, const char *drv_name,
        int ret;
 
        if (devnum == -1) {
-               ret = blk_find_max_devnum(if_type);
-               if (ret == -ENODEV)
-                       devnum = 0;
-               else if (ret < 0)
+               devnum = blk_next_free_devnum(if_type);
+       } else {
+               ret = blk_claim_devnum(if_type, devnum);
+               if (ret < 0 && ret != -ENOENT)
                        return ret;
-               else
-                       devnum = ret + 1;
        }
+       if (devnum < 0)
+               return devnum;
        ret = device_bind_driver(parent, drv_name, name, &dev);
        if (ret)
                return ret;
@@ -468,14 +574,22 @@ int blk_create_devicef(struct udevice *parent, const char *drv_name,
                       lbaint_t size, struct udevice **devp)
 {
        char dev_name[30], *str;
+       int ret;
 
        snprintf(dev_name, sizeof(dev_name), "%s.%s", parent->name, name);
        str = strdup(dev_name);
        if (!str)
                return -ENOMEM;
 
-       return blk_create_device(parent, drv_name, str, if_type, devnum,
-                                blksz, size, devp);
+       ret = blk_create_device(parent, drv_name, str, if_type, devnum,
+                               blksz, size, devp);
+       if (ret) {
+               free(str);
+               return ret;
+       }
+       device_set_name_alloced(*devp);
+
+       return ret;
 }
 
 int blk_unbind_all(int if_type)
@@ -491,7 +605,7 @@ int blk_unbind_all(int if_type)
                struct blk_desc *desc = dev_get_uclass_platdata(dev);
 
                if (desc->if_type == if_type) {
-                       ret = device_remove(dev);
+                       ret = device_remove(dev, DM_REMOVE_NORMAL);
                        if (ret)
                                return ret;
                        ret = device_unbind(dev);