1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2016 Google, Inc
4 * Written by Simon Glass <sjg@chromium.org>
13 #include <dm/device-internal.h>
15 #include <dm/uclass-internal.h>
16 #include <linux/err.h>
18 static const char *if_typename_str[IF_TYPE_COUNT] = {
19 [IF_TYPE_IDE] = "ide",
20 [IF_TYPE_SCSI] = "scsi",
21 [IF_TYPE_ATAPI] = "atapi",
22 [IF_TYPE_USB] = "usb",
23 [IF_TYPE_DOC] = "doc",
24 [IF_TYPE_MMC] = "mmc",
26 [IF_TYPE_SATA] = "sata",
27 [IF_TYPE_HOST] = "host",
28 [IF_TYPE_NVME] = "nvme",
29 [IF_TYPE_EFI] = "efi",
30 [IF_TYPE_VIRTIO] = "virtio",
31 [IF_TYPE_PVBLOCK] = "pvblock",
34 static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
35 [IF_TYPE_IDE] = UCLASS_IDE,
36 [IF_TYPE_SCSI] = UCLASS_SCSI,
37 [IF_TYPE_ATAPI] = UCLASS_INVALID,
38 [IF_TYPE_USB] = UCLASS_MASS_STORAGE,
39 [IF_TYPE_DOC] = UCLASS_INVALID,
40 [IF_TYPE_MMC] = UCLASS_MMC,
41 [IF_TYPE_SD] = UCLASS_INVALID,
42 [IF_TYPE_SATA] = UCLASS_AHCI,
43 [IF_TYPE_HOST] = UCLASS_ROOT,
44 [IF_TYPE_NVME] = UCLASS_NVME,
45 [IF_TYPE_EFI] = UCLASS_EFI,
46 [IF_TYPE_VIRTIO] = UCLASS_VIRTIO,
47 [IF_TYPE_PVBLOCK] = UCLASS_PVBLOCK,
50 static enum if_type if_typename_to_iftype(const char *if_typename)
54 for (i = 0; i < IF_TYPE_COUNT; i++) {
55 if (if_typename_str[i] &&
56 !strcmp(if_typename, if_typename_str[i]))
60 return IF_TYPE_UNKNOWN;
63 static enum uclass_id if_type_to_uclass_id(enum if_type if_type)
65 return if_type_uclass_id[if_type];
68 const char *blk_get_if_type_name(enum if_type if_type)
70 return if_typename_str[if_type];
73 struct blk_desc *blk_get_devnum_by_type(enum if_type if_type, int devnum)
75 struct blk_desc *desc;
79 ret = blk_get_device(if_type, devnum, &dev);
82 desc = dev_get_uclass_plat(dev);
88 * This function is complicated with driver model. We look up the interface
89 * name in a local table. This gives us an interface type which we can match
90 * against the uclass of the block device's parent.
92 struct blk_desc *blk_get_devnum_by_typename(const char *if_typename, int devnum)
94 enum uclass_id uclass_id;
100 if_type = if_typename_to_iftype(if_typename);
101 if (if_type == IF_TYPE_UNKNOWN) {
102 debug("%s: Unknown interface type '%s'\n", __func__,
106 uclass_id = if_type_to_uclass_id(if_type);
107 if (uclass_id == UCLASS_INVALID) {
108 debug("%s: Unknown uclass for interface type'\n",
109 if_typename_str[if_type]);
113 ret = uclass_get(UCLASS_BLK, &uc);
116 uclass_foreach_dev(dev, uc) {
117 struct blk_desc *desc = dev_get_uclass_plat(dev);
119 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
120 if_type, devnum, dev->name, desc->if_type, desc->devnum);
121 if (desc->devnum != devnum)
124 /* Find out the parent device uclass */
125 if (device_get_uclass_id(dev->parent) != uclass_id) {
126 debug("%s: parent uclass %d, this dev %d\n", __func__,
127 device_get_uclass_id(dev->parent), uclass_id);
131 if (device_probe(dev))
134 debug("%s: Device desc %p\n", __func__, desc);
137 debug("%s: No device found\n", __func__);
143 * blk_get_by_device() - Get the block device descriptor for the given device
144 * @dev: Instance of a storage device
146 * Return: With block device descriptor on success , NULL if there is no such
149 struct blk_desc *blk_get_by_device(struct udevice *dev)
151 struct udevice *child_dev;
153 device_foreach_child(child_dev, dev) {
154 if (device_get_uclass_id(child_dev) != UCLASS_BLK)
157 return dev_get_uclass_plat(child_dev);
160 debug("%s: No block device found\n", __func__);
166 * get_desc() - Get the block device descriptor for the given device number
168 * @if_type: Interface type
169 * @devnum: Device number (0 = first)
170 * @descp: Returns block device descriptor on success
171 * @return 0 on success, -ENODEV if there is no such device and no device
172 * with a higher device number, -ENOENT if there is no such device but there
173 * is one with a higher number, or other -ve on other error.
175 static int get_desc(enum if_type if_type, int devnum, struct blk_desc **descp)
177 bool found_more = false;
183 ret = uclass_get(UCLASS_BLK, &uc);
186 uclass_foreach_dev(dev, uc) {
187 struct blk_desc *desc = dev_get_uclass_plat(dev);
189 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
190 if_type, devnum, dev->name, desc->if_type, desc->devnum);
191 if (desc->if_type == if_type) {
192 if (desc->devnum == devnum) {
193 ret = device_probe(dev);
199 } else if (desc->devnum > devnum) {
205 return found_more ? -ENOENT : -ENODEV;
208 int blk_select_hwpart_devnum(enum if_type if_type, int devnum, int hwpart)
213 ret = blk_get_device(if_type, devnum, &dev);
217 return blk_select_hwpart(dev, hwpart);
220 int blk_list_part(enum if_type if_type)
222 struct blk_desc *desc;
226 for (ok = 0, devnum = 0;; ++devnum) {
227 ret = get_desc(if_type, devnum, &desc);
232 if (desc->part_type != PART_TYPE_UNKNOWN) {
245 int blk_print_part_devnum(enum if_type if_type, int devnum)
247 struct blk_desc *desc;
250 ret = get_desc(if_type, devnum, &desc);
253 if (desc->type == DEV_TYPE_UNKNOWN)
260 void blk_list_devices(enum if_type if_type)
262 struct blk_desc *desc;
267 ret = get_desc(if_type, i, &desc);
272 if (desc->type == DEV_TYPE_UNKNOWN)
273 continue; /* list only known devices */
274 printf("Device %d: ", i);
279 int blk_print_device_num(enum if_type if_type, int devnum)
281 struct blk_desc *desc;
284 ret = get_desc(if_type, devnum, &desc);
287 printf("\nIDE device %d: ", devnum);
293 int blk_show_device(enum if_type if_type, int devnum)
295 struct blk_desc *desc;
298 printf("\nDevice %d: ", devnum);
299 ret = get_desc(if_type, devnum, &desc);
300 if (ret == -ENODEV || ret == -ENOENT) {
301 printf("unknown device\n");
308 if (desc->type == DEV_TYPE_UNKNOWN)
314 ulong blk_read_devnum(enum if_type if_type, int devnum, lbaint_t start,
315 lbaint_t blkcnt, void *buffer)
317 struct blk_desc *desc;
321 ret = get_desc(if_type, devnum, &desc);
324 n = blk_dread(desc, start, blkcnt, buffer);
331 ulong blk_write_devnum(enum if_type if_type, int devnum, lbaint_t start,
332 lbaint_t blkcnt, const void *buffer)
334 struct blk_desc *desc;
337 ret = get_desc(if_type, devnum, &desc);
340 return blk_dwrite(desc, start, blkcnt, buffer);
343 int blk_select_hwpart(struct udevice *dev, int hwpart)
345 const struct blk_ops *ops = blk_get_ops(dev);
349 if (!ops->select_hwpart)
352 return ops->select_hwpart(dev, hwpart);
355 int blk_dselect_hwpart(struct blk_desc *desc, int hwpart)
357 return blk_select_hwpart(desc->bdev, hwpart);
360 int blk_first_device(int if_type, struct udevice **devp)
362 struct blk_desc *desc;
365 ret = uclass_find_first_device(UCLASS_BLK, devp);
371 desc = dev_get_uclass_plat(*devp);
372 if (desc->if_type == if_type)
374 ret = uclass_find_next_device(devp);
382 int blk_next_device(struct udevice **devp)
384 struct blk_desc *desc;
387 desc = dev_get_uclass_plat(*devp);
388 if_type = desc->if_type;
390 ret = uclass_find_next_device(devp);
395 desc = dev_get_uclass_plat(*devp);
396 if (desc->if_type == if_type)
401 int blk_find_device(int if_type, int devnum, struct udevice **devp)
407 ret = uclass_get(UCLASS_BLK, &uc);
410 uclass_foreach_dev(dev, uc) {
411 struct blk_desc *desc = dev_get_uclass_plat(dev);
413 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
414 if_type, devnum, dev->name, desc->if_type, desc->devnum);
415 if (desc->if_type == if_type && desc->devnum == devnum) {
424 int blk_get_device(int if_type, int devnum, struct udevice **devp)
428 ret = blk_find_device(if_type, devnum, devp);
432 return device_probe(*devp);
435 unsigned long blk_dread(struct blk_desc *block_dev, lbaint_t start,
436 lbaint_t blkcnt, void *buffer)
438 struct udevice *dev = block_dev->bdev;
439 const struct blk_ops *ops = blk_get_ops(dev);
445 if (blkcache_read(block_dev->if_type, block_dev->devnum,
446 start, blkcnt, block_dev->blksz, buffer))
448 blks_read = ops->read(dev, start, blkcnt, buffer);
449 if (blks_read == blkcnt)
450 blkcache_fill(block_dev->if_type, block_dev->devnum,
451 start, blkcnt, block_dev->blksz, buffer);
456 unsigned long blk_dwrite(struct blk_desc *block_dev, lbaint_t start,
457 lbaint_t blkcnt, const void *buffer)
459 struct udevice *dev = block_dev->bdev;
460 const struct blk_ops *ops = blk_get_ops(dev);
465 blkcache_invalidate(block_dev->if_type, block_dev->devnum);
466 return ops->write(dev, start, blkcnt, buffer);
469 unsigned long blk_derase(struct blk_desc *block_dev, lbaint_t start,
472 struct udevice *dev = block_dev->bdev;
473 const struct blk_ops *ops = blk_get_ops(dev);
478 blkcache_invalidate(block_dev->if_type, block_dev->devnum);
479 return ops->erase(dev, start, blkcnt);
482 int blk_get_from_parent(struct udevice *parent, struct udevice **devp)
488 device_find_first_child(parent, &dev);
490 debug("%s: No block device found for parent '%s'\n", __func__,
494 id = device_get_uclass_id(dev);
495 if (id != UCLASS_BLK) {
496 debug("%s: Incorrect uclass %s for block device '%s'\n",
497 __func__, uclass_get_name(id), dev->name);
500 ret = device_probe(dev);
508 int blk_find_max_devnum(enum if_type if_type)
511 int max_devnum = -ENODEV;
515 ret = uclass_get(UCLASS_BLK, &uc);
518 uclass_foreach_dev(dev, uc) {
519 struct blk_desc *desc = dev_get_uclass_plat(dev);
521 if (desc->if_type == if_type && desc->devnum > max_devnum)
522 max_devnum = desc->devnum;
528 int blk_next_free_devnum(enum if_type if_type)
532 ret = blk_find_max_devnum(if_type);
541 static int blk_claim_devnum(enum if_type if_type, int devnum)
547 ret = uclass_get(UCLASS_BLK, &uc);
550 uclass_foreach_dev(dev, uc) {
551 struct blk_desc *desc = dev_get_uclass_plat(dev);
553 if (desc->if_type == if_type && desc->devnum == devnum) {
554 int next = blk_next_free_devnum(if_type);
566 int blk_create_device(struct udevice *parent, const char *drv_name,
567 const char *name, int if_type, int devnum, int blksz,
568 lbaint_t lba, struct udevice **devp)
570 struct blk_desc *desc;
575 devnum = blk_next_free_devnum(if_type);
577 ret = blk_claim_devnum(if_type, devnum);
578 if (ret < 0 && ret != -ENOENT)
583 ret = device_bind_driver(parent, drv_name, name, &dev);
586 desc = dev_get_uclass_plat(dev);
587 desc->if_type = if_type;
589 desc->log2blksz = LOG2(desc->blksz);
591 desc->part_type = PART_TYPE_UNKNOWN;
593 desc->devnum = devnum;
599 int blk_create_devicef(struct udevice *parent, const char *drv_name,
600 const char *name, int if_type, int devnum, int blksz,
601 lbaint_t lba, struct udevice **devp)
603 char dev_name[30], *str;
606 snprintf(dev_name, sizeof(dev_name), "%s.%s", parent->name, name);
607 str = strdup(dev_name);
611 ret = blk_create_device(parent, drv_name, str, if_type, devnum,
617 device_set_name_alloced(*devp);
622 int blk_unbind_all(int if_type)
625 struct udevice *dev, *next;
628 ret = uclass_get(UCLASS_BLK, &uc);
631 uclass_foreach_dev_safe(dev, next, uc) {
632 struct blk_desc *desc = dev_get_uclass_plat(dev);
634 if (desc->if_type == if_type) {
635 ret = device_remove(dev, DM_REMOVE_NORMAL);
638 ret = device_unbind(dev);
647 static int blk_post_probe(struct udevice *dev)
649 if (IS_ENABLED(CONFIG_PARTITIONS) &&
650 IS_ENABLED(CONFIG_HAVE_BLOCK_DEVICE)) {
651 struct blk_desc *desc = dev_get_uclass_plat(dev);
659 UCLASS_DRIVER(blk) = {
662 .post_probe = blk_post_probe,
663 .per_device_plat_auto = sizeof(struct blk_desc),