blob: bfda2211f0e8b122b2d3f9909d2e54d5bb7bc005 [file] [log] [blame]
Simon Glass09d71aa2016-02-29 15:25:55 -07001/*
2 * Copyright (C) 2016 Google, Inc
3 * Written by Simon Glass <sjg@chromium.org>
4 *
5 * SPDX-License-Identifier: GPL-2.0+
6 */
7
8#include <common.h>
9#include <blk.h>
10#include <dm.h>
11#include <dm/device-internal.h>
12#include <dm/lists.h>
Stefan Roese8a5cbc02017-11-29 16:46:42 +010013#include <dm/uclass-internal.h>
Simon Glass09d71aa2016-02-29 15:25:55 -070014
Simon Glassd508c822016-05-01 11:36:08 -060015static const char *if_typename_str[IF_TYPE_COUNT] = {
16 [IF_TYPE_IDE] = "ide",
17 [IF_TYPE_SCSI] = "scsi",
18 [IF_TYPE_ATAPI] = "atapi",
19 [IF_TYPE_USB] = "usb",
20 [IF_TYPE_DOC] = "doc",
21 [IF_TYPE_MMC] = "mmc",
22 [IF_TYPE_SD] = "sd",
23 [IF_TYPE_SATA] = "sata",
24 [IF_TYPE_HOST] = "host",
25 [IF_TYPE_SYSTEMACE] = "ace",
Zhikang Zhangffab6942017-08-03 02:30:56 -070026 [IF_TYPE_NVME] = "nvme",
Heinrich Schuchardt05ef48a2018-01-21 19:29:30 +010027 [IF_TYPE_EFI] = "efi",
Simon Glassd508c822016-05-01 11:36:08 -060028};
29
30static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = {
Bin Meng68e6f222017-09-10 05:12:51 -070031 [IF_TYPE_IDE] = UCLASS_IDE,
Michal Simeke8a016b2016-09-08 15:06:45 +020032 [IF_TYPE_SCSI] = UCLASS_SCSI,
Simon Glassd508c822016-05-01 11:36:08 -060033 [IF_TYPE_ATAPI] = UCLASS_INVALID,
34 [IF_TYPE_USB] = UCLASS_MASS_STORAGE,
35 [IF_TYPE_DOC] = UCLASS_INVALID,
36 [IF_TYPE_MMC] = UCLASS_MMC,
37 [IF_TYPE_SD] = UCLASS_INVALID,
38 [IF_TYPE_SATA] = UCLASS_AHCI,
39 [IF_TYPE_HOST] = UCLASS_ROOT,
40 [IF_TYPE_SYSTEMACE] = UCLASS_INVALID,
Heinrich Schuchardt05ef48a2018-01-21 19:29:30 +010041 [IF_TYPE_NVME] = UCLASS_NVME,
42 [IF_TYPE_EFI] = UCLASS_EFI,
Simon Glassd508c822016-05-01 11:36:08 -060043};
44
45static enum if_type if_typename_to_iftype(const char *if_typename)
46{
47 int i;
48
49 for (i = 0; i < IF_TYPE_COUNT; i++) {
50 if (if_typename_str[i] &&
51 !strcmp(if_typename, if_typename_str[i]))
52 return i;
53 }
54
55 return IF_TYPE_UNKNOWN;
56}
57
58static enum uclass_id if_type_to_uclass_id(enum if_type if_type)
59{
60 return if_type_uclass_id[if_type];
61}
62
Simon Glass6faa4ed2017-07-29 11:34:53 -060063const char *blk_get_if_type_name(enum if_type if_type)
64{
65 return if_typename_str[if_type];
66}
67
Simon Glassd508c822016-05-01 11:36:08 -060068struct blk_desc *blk_get_devnum_by_type(enum if_type if_type, int devnum)
69{
70 struct blk_desc *desc;
71 struct udevice *dev;
72 int ret;
73
74 ret = blk_get_device(if_type, devnum, &dev);
75 if (ret)
76 return NULL;
77 desc = dev_get_uclass_platdata(dev);
78
79 return desc;
80}
81
82/*
83 * This function is complicated with driver model. We look up the interface
84 * name in a local table. This gives us an interface type which we can match
85 * against the uclass of the block device's parent.
86 */
87struct blk_desc *blk_get_devnum_by_typename(const char *if_typename, int devnum)
88{
89 enum uclass_id uclass_id;
90 enum if_type if_type;
91 struct udevice *dev;
92 struct uclass *uc;
93 int ret;
94
95 if_type = if_typename_to_iftype(if_typename);
96 if (if_type == IF_TYPE_UNKNOWN) {
97 debug("%s: Unknown interface type '%s'\n", __func__,
98 if_typename);
99 return NULL;
100 }
101 uclass_id = if_type_to_uclass_id(if_type);
102 if (uclass_id == UCLASS_INVALID) {
103 debug("%s: Unknown uclass for interface type'\n",
104 if_typename_str[if_type]);
105 return NULL;
106 }
107
108 ret = uclass_get(UCLASS_BLK, &uc);
109 if (ret)
110 return NULL;
111 uclass_foreach_dev(dev, uc) {
112 struct blk_desc *desc = dev_get_uclass_platdata(dev);
113
114 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
115 if_type, devnum, dev->name, desc->if_type, desc->devnum);
116 if (desc->devnum != devnum)
117 continue;
118
119 /* Find out the parent device uclass */
120 if (device_get_uclass_id(dev->parent) != uclass_id) {
121 debug("%s: parent uclass %d, this dev %d\n", __func__,
122 device_get_uclass_id(dev->parent), uclass_id);
123 continue;
124 }
125
126 if (device_probe(dev))
127 return NULL;
128
129 debug("%s: Device desc %p\n", __func__, desc);
130 return desc;
131 }
132 debug("%s: No device found\n", __func__);
133
134 return NULL;
135}
136
137/**
138 * get_desc() - Get the block device descriptor for the given device number
139 *
140 * @if_type: Interface type
141 * @devnum: Device number (0 = first)
142 * @descp: Returns block device descriptor on success
143 * @return 0 on success, -ENODEV if there is no such device and no device
144 * with a higher device number, -ENOENT if there is no such device but there
145 * is one with a higher number, or other -ve on other error.
146 */
147static int get_desc(enum if_type if_type, int devnum, struct blk_desc **descp)
148{
149 bool found_more = false;
150 struct udevice *dev;
151 struct uclass *uc;
152 int ret;
153
154 *descp = NULL;
155 ret = uclass_get(UCLASS_BLK, &uc);
156 if (ret)
157 return ret;
158 uclass_foreach_dev(dev, uc) {
159 struct blk_desc *desc = dev_get_uclass_platdata(dev);
160
161 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
162 if_type, devnum, dev->name, desc->if_type, desc->devnum);
163 if (desc->if_type == if_type) {
164 if (desc->devnum == devnum) {
165 ret = device_probe(dev);
166 if (ret)
167 return ret;
168
Michal Simek4408f6f2016-11-16 17:37:42 +0100169 *descp = desc;
170 return 0;
Simon Glassd508c822016-05-01 11:36:08 -0600171 } else if (desc->devnum > devnum) {
172 found_more = true;
173 }
174 }
175 }
176
177 return found_more ? -ENOENT : -ENODEV;
178}
179
Simon Glasscd0fb552016-05-01 13:52:30 -0600180int blk_select_hwpart_devnum(enum if_type if_type, int devnum, int hwpart)
181{
182 struct udevice *dev;
183 int ret;
184
185 ret = blk_get_device(if_type, devnum, &dev);
186 if (ret)
187 return ret;
188
189 return blk_select_hwpart(dev, hwpart);
190}
191
Simon Glassd508c822016-05-01 11:36:08 -0600192int blk_list_part(enum if_type if_type)
193{
194 struct blk_desc *desc;
195 int devnum, ok;
196 int ret;
197
198 for (ok = 0, devnum = 0;; ++devnum) {
199 ret = get_desc(if_type, devnum, &desc);
200 if (ret == -ENODEV)
201 break;
202 else if (ret)
203 continue;
204 if (desc->part_type != PART_TYPE_UNKNOWN) {
205 ++ok;
206 if (devnum)
207 putc('\n');
208 part_print(desc);
209 }
210 }
211 if (!ok)
212 return -ENODEV;
213
214 return 0;
215}
216
217int blk_print_part_devnum(enum if_type if_type, int devnum)
218{
219 struct blk_desc *desc;
220 int ret;
221
222 ret = get_desc(if_type, devnum, &desc);
223 if (ret)
224 return ret;
225 if (desc->type == DEV_TYPE_UNKNOWN)
226 return -ENOENT;
227 part_print(desc);
228
229 return 0;
230}
231
232void blk_list_devices(enum if_type if_type)
233{
234 struct blk_desc *desc;
235 int ret;
236 int i;
237
238 for (i = 0;; ++i) {
239 ret = get_desc(if_type, i, &desc);
240 if (ret == -ENODEV)
241 break;
242 else if (ret)
243 continue;
244 if (desc->type == DEV_TYPE_UNKNOWN)
245 continue; /* list only known devices */
246 printf("Device %d: ", i);
247 dev_print(desc);
248 }
249}
250
251int blk_print_device_num(enum if_type if_type, int devnum)
252{
253 struct blk_desc *desc;
254 int ret;
255
256 ret = get_desc(if_type, devnum, &desc);
257 if (ret)
258 return ret;
259 printf("\nIDE device %d: ", devnum);
260 dev_print(desc);
261
262 return 0;
263}
264
265int blk_show_device(enum if_type if_type, int devnum)
266{
267 struct blk_desc *desc;
268 int ret;
269
270 printf("\nDevice %d: ", devnum);
271 ret = get_desc(if_type, devnum, &desc);
272 if (ret == -ENODEV || ret == -ENOENT) {
273 printf("unknown device\n");
274 return -ENODEV;
275 }
276 if (ret)
277 return ret;
278 dev_print(desc);
279
280 if (desc->type == DEV_TYPE_UNKNOWN)
281 return -ENOENT;
282
283 return 0;
284}
285
286ulong blk_read_devnum(enum if_type if_type, int devnum, lbaint_t start,
287 lbaint_t blkcnt, void *buffer)
288{
289 struct blk_desc *desc;
290 ulong n;
291 int ret;
292
293 ret = get_desc(if_type, devnum, &desc);
294 if (ret)
295 return ret;
296 n = blk_dread(desc, start, blkcnt, buffer);
297 if (IS_ERR_VALUE(n))
298 return n;
299
Simon Glassd508c822016-05-01 11:36:08 -0600300 return n;
301}
302
303ulong blk_write_devnum(enum if_type if_type, int devnum, lbaint_t start,
304 lbaint_t blkcnt, const void *buffer)
305{
306 struct blk_desc *desc;
307 int ret;
308
309 ret = get_desc(if_type, devnum, &desc);
310 if (ret)
311 return ret;
312 return blk_dwrite(desc, start, blkcnt, buffer);
313}
314
Simon Glasscd0fb552016-05-01 13:52:30 -0600315int blk_select_hwpart(struct udevice *dev, int hwpart)
316{
317 const struct blk_ops *ops = blk_get_ops(dev);
318
319 if (!ops)
320 return -ENOSYS;
321 if (!ops->select_hwpart)
322 return 0;
323
324 return ops->select_hwpart(dev, hwpart);
325}
326
327int blk_dselect_hwpart(struct blk_desc *desc, int hwpart)
328{
329 return blk_select_hwpart(desc->bdev, hwpart);
330}
331
Simon Glass09d71aa2016-02-29 15:25:55 -0700332int blk_first_device(int if_type, struct udevice **devp)
333{
334 struct blk_desc *desc;
335 int ret;
336
Stefan Roese8a5cbc02017-11-29 16:46:42 +0100337 ret = uclass_find_first_device(UCLASS_BLK, devp);
Simon Glass09d71aa2016-02-29 15:25:55 -0700338 if (ret)
339 return ret;
340 if (!*devp)
341 return -ENODEV;
342 do {
343 desc = dev_get_uclass_platdata(*devp);
344 if (desc->if_type == if_type)
345 return 0;
Stefan Roese8a5cbc02017-11-29 16:46:42 +0100346 ret = uclass_find_next_device(devp);
Simon Glass09d71aa2016-02-29 15:25:55 -0700347 if (ret)
348 return ret;
349 } while (*devp);
350
351 return -ENODEV;
352}
353
354int blk_next_device(struct udevice **devp)
355{
356 struct blk_desc *desc;
357 int ret, if_type;
358
359 desc = dev_get_uclass_platdata(*devp);
360 if_type = desc->if_type;
361 do {
Stefan Roese8a5cbc02017-11-29 16:46:42 +0100362 ret = uclass_find_next_device(devp);
Simon Glass09d71aa2016-02-29 15:25:55 -0700363 if (ret)
364 return ret;
365 if (!*devp)
366 return -ENODEV;
367 desc = dev_get_uclass_platdata(*devp);
368 if (desc->if_type == if_type)
369 return 0;
370 } while (1);
371}
372
Simon Glass61392812017-04-23 20:02:05 -0600373int blk_find_device(int if_type, int devnum, struct udevice **devp)
Simon Glass09d71aa2016-02-29 15:25:55 -0700374{
375 struct uclass *uc;
376 struct udevice *dev;
377 int ret;
378
379 ret = uclass_get(UCLASS_BLK, &uc);
380 if (ret)
381 return ret;
382 uclass_foreach_dev(dev, uc) {
383 struct blk_desc *desc = dev_get_uclass_platdata(dev);
384
385 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__,
386 if_type, devnum, dev->name, desc->if_type, desc->devnum);
387 if (desc->if_type == if_type && desc->devnum == devnum) {
388 *devp = dev;
Simon Glass61392812017-04-23 20:02:05 -0600389 return 0;
Simon Glass09d71aa2016-02-29 15:25:55 -0700390 }
391 }
392
393 return -ENODEV;
394}
395
Simon Glass61392812017-04-23 20:02:05 -0600396int blk_get_device(int if_type, int devnum, struct udevice **devp)
397{
398 int ret;
399
400 ret = blk_find_device(if_type, devnum, devp);
401 if (ret)
402 return ret;
403
404 return device_probe(*devp);
405}
406
Simon Glass09d71aa2016-02-29 15:25:55 -0700407unsigned long blk_dread(struct blk_desc *block_dev, lbaint_t start,
408 lbaint_t blkcnt, void *buffer)
409{
410 struct udevice *dev = block_dev->bdev;
411 const struct blk_ops *ops = blk_get_ops(dev);
Eric Nelsone40cf342016-03-28 10:05:44 -0700412 ulong blks_read;
Simon Glass09d71aa2016-02-29 15:25:55 -0700413
414 if (!ops->read)
415 return -ENOSYS;
416
Eric Nelsone40cf342016-03-28 10:05:44 -0700417 if (blkcache_read(block_dev->if_type, block_dev->devnum,
418 start, blkcnt, block_dev->blksz, buffer))
419 return blkcnt;
420 blks_read = ops->read(dev, start, blkcnt, buffer);
421 if (blks_read == blkcnt)
422 blkcache_fill(block_dev->if_type, block_dev->devnum,
423 start, blkcnt, block_dev->blksz, buffer);
424
425 return blks_read;
Simon Glass09d71aa2016-02-29 15:25:55 -0700426}
427
428unsigned long blk_dwrite(struct blk_desc *block_dev, lbaint_t start,
429 lbaint_t blkcnt, const void *buffer)
430{
431 struct udevice *dev = block_dev->bdev;
432 const struct blk_ops *ops = blk_get_ops(dev);
433
434 if (!ops->write)
435 return -ENOSYS;
436
Eric Nelsone40cf342016-03-28 10:05:44 -0700437 blkcache_invalidate(block_dev->if_type, block_dev->devnum);
Simon Glass09d71aa2016-02-29 15:25:55 -0700438 return ops->write(dev, start, blkcnt, buffer);
439}
440
441unsigned long blk_derase(struct blk_desc *block_dev, lbaint_t start,
442 lbaint_t blkcnt)
443{
444 struct udevice *dev = block_dev->bdev;
445 const struct blk_ops *ops = blk_get_ops(dev);
446
447 if (!ops->erase)
448 return -ENOSYS;
449
Eric Nelsone40cf342016-03-28 10:05:44 -0700450 blkcache_invalidate(block_dev->if_type, block_dev->devnum);
Simon Glass09d71aa2016-02-29 15:25:55 -0700451 return ops->erase(dev, start, blkcnt);
452}
453
454int blk_prepare_device(struct udevice *dev)
455{
456 struct blk_desc *desc = dev_get_uclass_platdata(dev);
457
458 part_init(desc);
459
460 return 0;
461}
462
Simon Glass9f103b92017-05-27 11:37:17 -0600463int blk_get_from_parent(struct udevice *parent, struct udevice **devp)
464{
465 struct udevice *dev;
466 enum uclass_id id;
467 int ret;
468
469 device_find_first_child(parent, &dev);
470 if (!dev) {
471 debug("%s: No block device found for parent '%s'\n", __func__,
472 parent->name);
473 return -ENODEV;
474 }
475 id = device_get_uclass_id(dev);
476 if (id != UCLASS_BLK) {
477 debug("%s: Incorrect uclass %s for block device '%s'\n",
478 __func__, uclass_get_name(id), dev->name);
479 return -ENOTBLK;
480 }
481 ret = device_probe(dev);
482 if (ret)
483 return ret;
484 *devp = dev;
485
486 return 0;
487}
488
Simon Glass52138fd2016-05-01 11:36:28 -0600489int blk_find_max_devnum(enum if_type if_type)
490{
491 struct udevice *dev;
492 int max_devnum = -ENODEV;
493 struct uclass *uc;
494 int ret;
495
496 ret = uclass_get(UCLASS_BLK, &uc);
497 if (ret)
498 return ret;
499 uclass_foreach_dev(dev, uc) {
500 struct blk_desc *desc = dev_get_uclass_platdata(dev);
501
502 if (desc->if_type == if_type && desc->devnum > max_devnum)
503 max_devnum = desc->devnum;
504 }
505
506 return max_devnum;
507}
508
Simon Glasse8abbb52017-04-23 20:02:06 -0600509static int blk_next_free_devnum(enum if_type if_type)
510{
511 int ret;
512
513 ret = blk_find_max_devnum(if_type);
514 if (ret == -ENODEV)
515 return 0;
516 if (ret < 0)
517 return ret;
518
519 return ret + 1;
520}
521
Simon Glasse48eeb92017-04-23 20:02:07 -0600522static int blk_claim_devnum(enum if_type if_type, int devnum)
523{
524 struct udevice *dev;
525 struct uclass *uc;
526 int ret;
527
528 ret = uclass_get(UCLASS_BLK, &uc);
529 if (ret)
530 return ret;
531 uclass_foreach_dev(dev, uc) {
532 struct blk_desc *desc = dev_get_uclass_platdata(dev);
533
534 if (desc->if_type == if_type && desc->devnum == devnum) {
535 int next = blk_next_free_devnum(if_type);
536
537 if (next < 0)
538 return next;
539 desc->devnum = next;
540 return 0;
541 }
542 }
543
544 return -ENOENT;
545}
546
Simon Glass09d71aa2016-02-29 15:25:55 -0700547int blk_create_device(struct udevice *parent, const char *drv_name,
548 const char *name, int if_type, int devnum, int blksz,
Jean-Jacques Hiblot5fe77022017-06-09 16:45:18 +0200549 lbaint_t lba, struct udevice **devp)
Simon Glass09d71aa2016-02-29 15:25:55 -0700550{
551 struct blk_desc *desc;
552 struct udevice *dev;
553 int ret;
554
Simon Glass52138fd2016-05-01 11:36:28 -0600555 if (devnum == -1) {
Simon Glasse48eeb92017-04-23 20:02:07 -0600556 devnum = blk_next_free_devnum(if_type);
557 } else {
558 ret = blk_claim_devnum(if_type, devnum);
559 if (ret < 0 && ret != -ENOENT)
Simon Glass52138fd2016-05-01 11:36:28 -0600560 return ret;
Simon Glass52138fd2016-05-01 11:36:28 -0600561 }
Simon Glasse48eeb92017-04-23 20:02:07 -0600562 if (devnum < 0)
563 return devnum;
Simon Glass72a85c02016-05-01 13:52:22 -0600564 ret = device_bind_driver(parent, drv_name, name, &dev);
565 if (ret)
566 return ret;
567 desc = dev_get_uclass_platdata(dev);
568 desc->if_type = if_type;
569 desc->blksz = blksz;
Jean-Jacques Hiblot5fe77022017-06-09 16:45:18 +0200570 desc->lba = lba;
Simon Glass72a85c02016-05-01 13:52:22 -0600571 desc->part_type = PART_TYPE_UNKNOWN;
572 desc->bdev = dev;
Simon Glass09d71aa2016-02-29 15:25:55 -0700573 desc->devnum = devnum;
574 *devp = dev;
575
576 return 0;
577}
578
Simon Glass9107c972016-05-01 11:36:29 -0600579int blk_create_devicef(struct udevice *parent, const char *drv_name,
580 const char *name, int if_type, int devnum, int blksz,
Jean-Jacques Hiblot5fe77022017-06-09 16:45:18 +0200581 lbaint_t lba, struct udevice **devp)
Simon Glass9107c972016-05-01 11:36:29 -0600582{
583 char dev_name[30], *str;
Simon Glassd0773522016-05-01 13:52:24 -0600584 int ret;
Simon Glass9107c972016-05-01 11:36:29 -0600585
586 snprintf(dev_name, sizeof(dev_name), "%s.%s", parent->name, name);
587 str = strdup(dev_name);
588 if (!str)
589 return -ENOMEM;
590
Simon Glassd0773522016-05-01 13:52:24 -0600591 ret = blk_create_device(parent, drv_name, str, if_type, devnum,
Jean-Jacques Hiblot5fe77022017-06-09 16:45:18 +0200592 blksz, lba, devp);
Simon Glassd0773522016-05-01 13:52:24 -0600593 if (ret) {
594 free(str);
595 return ret;
596 }
597 device_set_name_alloced(*devp);
598
Simon Glass7074b2a2017-07-29 11:34:59 -0600599 return 0;
Simon Glass9107c972016-05-01 11:36:29 -0600600}
601
Simon Glass09d71aa2016-02-29 15:25:55 -0700602int blk_unbind_all(int if_type)
603{
604 struct uclass *uc;
605 struct udevice *dev, *next;
606 int ret;
607
608 ret = uclass_get(UCLASS_BLK, &uc);
609 if (ret)
610 return ret;
611 uclass_foreach_dev_safe(dev, next, uc) {
612 struct blk_desc *desc = dev_get_uclass_platdata(dev);
613
614 if (desc->if_type == if_type) {
Stefan Roese706865a2017-03-20 12:51:48 +0100615 ret = device_remove(dev, DM_REMOVE_NORMAL);
Simon Glass09d71aa2016-02-29 15:25:55 -0700616 if (ret)
617 return ret;
618 ret = device_unbind(dev);
619 if (ret)
620 return ret;
621 }
622 }
623
624 return 0;
625}
626
627UCLASS_DRIVER(blk) = {
628 .id = UCLASS_BLK,
629 .name = "blk",
630 .per_device_platdata_auto_alloc_size = sizeof(struct blk_desc),
631};