2 * Copyright (C) 2016 Google, Inc
3 * Written by Simon Glass <sjg@chromium.org>
5 * SPDX-License-Identifier: GPL-2.0+
11 #include <dm/device-internal.h>
14 static const char *if_typename_str[IF_TYPE_COUNT] = {
15 [IF_TYPE_IDE] = "ide",
16 [IF_TYPE_SCSI] = "scsi",
17 [IF_TYPE_ATAPI] = "atapi",
18 [IF_TYPE_USB] = "usb",
19 [IF_TYPE_DOC] = "doc",
20 [IF_TYPE_MMC] = "mmc",
22 [IF_TYPE_SATA] = "sata",
23 [IF_TYPE_HOST] = "host",
24 [IF_TYPE_SYSTEMACE] = "ace",
27 static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
28 [IF_TYPE_IDE] = UCLASS_INVALID,
29 [IF_TYPE_SCSI] = UCLASS_INVALID,
30 [IF_TYPE_ATAPI] = UCLASS_INVALID,
31 [IF_TYPE_USB] = UCLASS_MASS_STORAGE,
32 [IF_TYPE_DOC] = UCLASS_INVALID,
33 [IF_TYPE_MMC] = UCLASS_MMC,
34 [IF_TYPE_SD] = UCLASS_INVALID,
35 [IF_TYPE_SATA] = UCLASS_AHCI,
36 [IF_TYPE_HOST] = UCLASS_ROOT,
37 [IF_TYPE_SYSTEMACE] = UCLASS_INVALID,
40 static enum if_type if_typename_to_iftype(const char *if_typename)
44 for (i = 0; i < IF_TYPE_COUNT; i++) {
45 if (if_typename_str[i] &&
46 !strcmp(if_typename, if_typename_str[i]))
50 return IF_TYPE_UNKNOWN;
53 static enum uclass_id if_type_to_uclass_id(enum if_type if_type)
55 return if_type_uclass_id[if_type];
58 struct blk_desc *blk_get_devnum_by_type(enum if_type if_type, int devnum)
60 struct blk_desc *desc;
64 ret = blk_get_device(if_type, devnum, &dev);
67 desc = dev_get_uclass_platdata(dev);
73 * This function is complicated with driver model. We look up the interface
74 * name in a local table. This gives us an interface type which we can match
75 * against the uclass of the block device's parent.
77 struct blk_desc *blk_get_devnum_by_typename(const char *if_typename, int devnum)
79 enum uclass_id uclass_id;
85 if_type = if_typename_to_iftype(if_typename);
86 if (if_type == IF_TYPE_UNKNOWN) {
87 debug("%s: Unknown interface type '%s'\n", __func__,
91 uclass_id = if_type_to_uclass_id(if_type);
92 if (uclass_id == UCLASS_INVALID) {
93 debug("%s: Unknown uclass for interface type'\n",
94 if_typename_str[if_type]);
98 ret = uclass_get(UCLASS_BLK, &uc);
101 uclass_foreach_dev(dev, uc) {
102 struct blk_desc *desc = dev_get_uclass_platdata(dev);
104 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
105 if_type, devnum, dev->name, desc->if_type, desc->devnum);
106 if (desc->devnum != devnum)
109 /* Find out the parent device uclass */
110 if (device_get_uclass_id(dev->parent) != uclass_id) {
111 debug("%s: parent uclass %d, this dev %d\n", __func__,
112 device_get_uclass_id(dev->parent), uclass_id);
116 if (device_probe(dev))
119 debug("%s: Device desc %p\n", __func__, desc);
122 debug("%s: No device found\n", __func__);
128 * get_desc() - Get the block device descriptor for the given device number
130 * @if_type: Interface type
131 * @devnum: Device number (0 = first)
132 * @descp: Returns block device descriptor on success
133 * @return 0 on success, -ENODEV if there is no such device and no device
134 * with a higher device number, -ENOENT if there is no such device but there
135 * is one with a higher number, or other -ve on other error.
137 static int get_desc(enum if_type if_type, int devnum, struct blk_desc **descp)
139 bool found_more = false;
145 ret = uclass_get(UCLASS_BLK, &uc);
148 uclass_foreach_dev(dev, uc) {
149 struct blk_desc *desc = dev_get_uclass_platdata(dev);
151 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
152 if_type, devnum, dev->name, desc->if_type, desc->devnum);
153 if (desc->if_type == if_type) {
154 if (desc->devnum == devnum) {
155 ret = device_probe(dev);
159 } else if (desc->devnum > devnum) {
165 return found_more ? -ENOENT : -ENODEV;
168 int blk_list_part(enum if_type if_type)
170 struct blk_desc *desc;
174 for (ok = 0, devnum = 0;; ++devnum) {
175 ret = get_desc(if_type, devnum, &desc);
180 if (desc->part_type != PART_TYPE_UNKNOWN) {
193 int blk_print_part_devnum(enum if_type if_type, int devnum)
195 struct blk_desc *desc;
198 ret = get_desc(if_type, devnum, &desc);
201 if (desc->type == DEV_TYPE_UNKNOWN)
208 void blk_list_devices(enum if_type if_type)
210 struct blk_desc *desc;
215 ret = get_desc(if_type, i, &desc);
220 if (desc->type == DEV_TYPE_UNKNOWN)
221 continue; /* list only known devices */
222 printf("Device %d: ", i);
227 int blk_print_device_num(enum if_type if_type, int devnum)
229 struct blk_desc *desc;
232 ret = get_desc(if_type, devnum, &desc);
235 printf("\nIDE device %d: ", devnum);
241 int blk_show_device(enum if_type if_type, int devnum)
243 struct blk_desc *desc;
246 printf("\nDevice %d: ", devnum);
247 ret = get_desc(if_type, devnum, &desc);
248 if (ret == -ENODEV || ret == -ENOENT) {
249 printf("unknown device\n");
256 if (desc->type == DEV_TYPE_UNKNOWN)
262 ulong blk_read_devnum(enum if_type if_type, int devnum, lbaint_t start,
263 lbaint_t blkcnt, void *buffer)
265 struct blk_desc *desc;
269 ret = get_desc(if_type, devnum, &desc);
272 n = blk_dread(desc, start, blkcnt, buffer);
276 /* flush cache after read */
277 flush_cache((ulong)buffer, blkcnt * desc->blksz);
282 ulong blk_write_devnum(enum if_type if_type, int devnum, lbaint_t start,
283 lbaint_t blkcnt, const void *buffer)
285 struct blk_desc *desc;
288 ret = get_desc(if_type, devnum, &desc);
291 return blk_dwrite(desc, start, blkcnt, buffer);
294 int blk_first_device(int if_type, struct udevice **devp)
296 struct blk_desc *desc;
299 ret = uclass_first_device(UCLASS_BLK, devp);
305 desc = dev_get_uclass_platdata(*devp);
306 if (desc->if_type == if_type)
308 ret = uclass_next_device(devp);
316 int blk_next_device(struct udevice **devp)
318 struct blk_desc *desc;
321 desc = dev_get_uclass_platdata(*devp);
322 if_type = desc->if_type;
324 ret = uclass_next_device(devp);
329 desc = dev_get_uclass_platdata(*devp);
330 if (desc->if_type == if_type)
335 int blk_get_device(int if_type, int devnum, struct udevice **devp)
341 ret = uclass_get(UCLASS_BLK, &uc);
344 uclass_foreach_dev(dev, uc) {
345 struct blk_desc *desc = dev_get_uclass_platdata(dev);
347 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
348 if_type, devnum, dev->name, desc->if_type, desc->devnum);
349 if (desc->if_type == if_type && desc->devnum == devnum) {
351 return device_probe(dev);
358 unsigned long blk_dread(struct blk_desc *block_dev, lbaint_t start,
359 lbaint_t blkcnt, void *buffer)
361 struct udevice *dev = block_dev->bdev;
362 const struct blk_ops *ops = blk_get_ops(dev);
368 if (blkcache_read(block_dev->if_type, block_dev->devnum,
369 start, blkcnt, block_dev->blksz, buffer))
371 blks_read = ops->read(dev, start, blkcnt, buffer);
372 if (blks_read == blkcnt)
373 blkcache_fill(block_dev->if_type, block_dev->devnum,
374 start, blkcnt, block_dev->blksz, buffer);
379 unsigned long blk_dwrite(struct blk_desc *block_dev, lbaint_t start,
380 lbaint_t blkcnt, const void *buffer)
382 struct udevice *dev = block_dev->bdev;
383 const struct blk_ops *ops = blk_get_ops(dev);
388 blkcache_invalidate(block_dev->if_type, block_dev->devnum);
389 return ops->write(dev, start, blkcnt, buffer);
392 unsigned long blk_derase(struct blk_desc *block_dev, lbaint_t start,
395 struct udevice *dev = block_dev->bdev;
396 const struct blk_ops *ops = blk_get_ops(dev);
401 blkcache_invalidate(block_dev->if_type, block_dev->devnum);
402 return ops->erase(dev, start, blkcnt);
405 int blk_prepare_device(struct udevice *dev)
407 struct blk_desc *desc = dev_get_uclass_platdata(dev);
414 int blk_find_max_devnum(enum if_type if_type)
417 int max_devnum = -ENODEV;
421 ret = uclass_get(UCLASS_BLK, &uc);
424 uclass_foreach_dev(dev, uc) {
425 struct blk_desc *desc = dev_get_uclass_platdata(dev);
427 if (desc->if_type == if_type && desc->devnum > max_devnum)
428 max_devnum = desc->devnum;
434 int blk_create_device(struct udevice *parent, const char *drv_name,
435 const char *name, int if_type, int devnum, int blksz,
436 lbaint_t size, struct udevice **devp)
438 struct blk_desc *desc;
443 ret = blk_find_max_devnum(if_type);
451 ret = device_bind_driver(parent, drv_name, name, &dev);
454 desc = dev_get_uclass_platdata(dev);
455 desc->if_type = if_type;
457 desc->lba = size / blksz;
458 desc->part_type = PART_TYPE_UNKNOWN;
460 desc->devnum = devnum;
466 int blk_create_devicef(struct udevice *parent, const char *drv_name,
467 const char *name, int if_type, int devnum, int blksz,
468 lbaint_t size, struct udevice **devp)
470 char dev_name[30], *str;
472 snprintf(dev_name, sizeof(dev_name), "%s.%s", parent->name, name);
473 str = strdup(dev_name);
477 return blk_create_device(parent, drv_name, str, if_type, devnum,
481 int blk_unbind_all(int if_type)
484 struct udevice *dev, *next;
487 ret = uclass_get(UCLASS_BLK, &uc);
490 uclass_foreach_dev_safe(dev, next, uc) {
491 struct blk_desc *desc = dev_get_uclass_platdata(dev);
493 if (desc->if_type == if_type) {
494 ret = device_remove(dev);
497 ret = device_unbind(dev);
506 UCLASS_DRIVER(blk) = {
509 .per_device_platdata_auto_alloc_size = sizeof(struct blk_desc),