1 /* 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> 13 #include <dm/uclass-internal.h> 14 15 static 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_NVME] = "nvme", 26 [IF_TYPE_EFI] = "efi", 27 }; 28 29 static enum uclass_id if_type_uclass_id[IF_TYPE_COUNT] = { 30 [IF_TYPE_IDE] = UCLASS_IDE, 31 [IF_TYPE_SCSI] = UCLASS_SCSI, 32 [IF_TYPE_ATAPI] = UCLASS_INVALID, 33 [IF_TYPE_USB] = UCLASS_MASS_STORAGE, 34 [IF_TYPE_DOC] = UCLASS_INVALID, 35 [IF_TYPE_MMC] = UCLASS_MMC, 36 [IF_TYPE_SD] = UCLASS_INVALID, 37 [IF_TYPE_SATA] = UCLASS_AHCI, 38 [IF_TYPE_HOST] = UCLASS_ROOT, 39 [IF_TYPE_NVME] = UCLASS_NVME, 40 [IF_TYPE_EFI] = UCLASS_EFI, 41 }; 42 43 static enum if_type if_typename_to_iftype(const char *if_typename) 44 { 45 int i; 46 47 for (i = 0; i < IF_TYPE_COUNT; i++) { 48 if (if_typename_str[i] && 49 !strcmp(if_typename, if_typename_str[i])) 50 return i; 51 } 52 53 return IF_TYPE_UNKNOWN; 54 } 55 56 static enum uclass_id if_type_to_uclass_id(enum if_type if_type) 57 { 58 return if_type_uclass_id[if_type]; 59 } 60 61 const char *blk_get_if_type_name(enum if_type if_type) 62 { 63 return if_typename_str[if_type]; 64 } 65 66 struct blk_desc *blk_get_devnum_by_type(enum if_type if_type, int devnum) 67 { 68 struct blk_desc *desc; 69 struct udevice *dev; 70 int ret; 71 72 ret = blk_get_device(if_type, devnum, &dev); 73 if (ret) 74 return NULL; 75 desc = dev_get_uclass_platdata(dev); 76 77 return desc; 78 } 79 80 /* 81 * This function is complicated with driver model. We look up the interface 82 * name in a local table. This gives us an interface type which we can match 83 * against the uclass of the block device's parent. 84 */ 85 struct blk_desc *blk_get_devnum_by_typename(const char *if_typename, int devnum) 86 { 87 enum uclass_id uclass_id; 88 enum if_type if_type; 89 struct udevice *dev; 90 struct uclass *uc; 91 int ret; 92 93 if_type = if_typename_to_iftype(if_typename); 94 if (if_type == IF_TYPE_UNKNOWN) { 95 debug("%s: Unknown interface type '%s'\n", __func__, 96 if_typename); 97 return NULL; 98 } 99 uclass_id = if_type_to_uclass_id(if_type); 100 if (uclass_id == UCLASS_INVALID) { 101 debug("%s: Unknown uclass for interface type'\n", 102 if_typename_str[if_type]); 103 return NULL; 104 } 105 106 ret = uclass_get(UCLASS_BLK, &uc); 107 if (ret) 108 return NULL; 109 uclass_foreach_dev(dev, uc) { 110 struct blk_desc *desc = dev_get_uclass_platdata(dev); 111 112 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__, 113 if_type, devnum, dev->name, desc->if_type, desc->devnum); 114 if (desc->devnum != devnum) 115 continue; 116 117 /* Find out the parent device uclass */ 118 if (device_get_uclass_id(dev->parent) != uclass_id) { 119 debug("%s: parent uclass %d, this dev %d\n", __func__, 120 device_get_uclass_id(dev->parent), uclass_id); 121 continue; 122 } 123 124 if (device_probe(dev)) 125 return NULL; 126 127 debug("%s: Device desc %p\n", __func__, desc); 128 return desc; 129 } 130 debug("%s: No device found\n", __func__); 131 132 return NULL; 133 } 134 135 /** 136 * get_desc() - Get the block device descriptor for the given device number 137 * 138 * @if_type: Interface type 139 * @devnum: Device number (0 = first) 140 * @descp: Returns block device descriptor on success 141 * @return 0 on success, -ENODEV if there is no such device and no device 142 * with a higher device number, -ENOENT if there is no such device but there 143 * is one with a higher number, or other -ve on other error. 144 */ 145 static int get_desc(enum if_type if_type, int devnum, struct blk_desc **descp) 146 { 147 bool found_more = false; 148 struct udevice *dev; 149 struct uclass *uc; 150 int ret; 151 152 *descp = NULL; 153 ret = uclass_get(UCLASS_BLK, &uc); 154 if (ret) 155 return ret; 156 uclass_foreach_dev(dev, uc) { 157 struct blk_desc *desc = dev_get_uclass_platdata(dev); 158 159 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__, 160 if_type, devnum, dev->name, desc->if_type, desc->devnum); 161 if (desc->if_type == if_type) { 162 if (desc->devnum == devnum) { 163 ret = device_probe(dev); 164 if (ret) 165 return ret; 166 167 *descp = desc; 168 return 0; 169 } else if (desc->devnum > devnum) { 170 found_more = true; 171 } 172 } 173 } 174 175 return found_more ? -ENOENT : -ENODEV; 176 } 177 178 int blk_select_hwpart_devnum(enum if_type if_type, int devnum, int hwpart) 179 { 180 struct udevice *dev; 181 int ret; 182 183 ret = blk_get_device(if_type, devnum, &dev); 184 if (ret) 185 return ret; 186 187 return blk_select_hwpart(dev, hwpart); 188 } 189 190 int blk_list_part(enum if_type if_type) 191 { 192 struct blk_desc *desc; 193 int devnum, ok; 194 int ret; 195 196 for (ok = 0, devnum = 0;; ++devnum) { 197 ret = get_desc(if_type, devnum, &desc); 198 if (ret == -ENODEV) 199 break; 200 else if (ret) 201 continue; 202 if (desc->part_type != PART_TYPE_UNKNOWN) { 203 ++ok; 204 if (devnum) 205 putc('\n'); 206 part_print(desc); 207 } 208 } 209 if (!ok) 210 return -ENODEV; 211 212 return 0; 213 } 214 215 int blk_print_part_devnum(enum if_type if_type, int devnum) 216 { 217 struct blk_desc *desc; 218 int ret; 219 220 ret = get_desc(if_type, devnum, &desc); 221 if (ret) 222 return ret; 223 if (desc->type == DEV_TYPE_UNKNOWN) 224 return -ENOENT; 225 part_print(desc); 226 227 return 0; 228 } 229 230 void blk_list_devices(enum if_type if_type) 231 { 232 struct blk_desc *desc; 233 int ret; 234 int i; 235 236 for (i = 0;; ++i) { 237 ret = get_desc(if_type, i, &desc); 238 if (ret == -ENODEV) 239 break; 240 else if (ret) 241 continue; 242 if (desc->type == DEV_TYPE_UNKNOWN) 243 continue; /* list only known devices */ 244 printf("Device %d: ", i); 245 dev_print(desc); 246 } 247 } 248 249 int blk_print_device_num(enum if_type if_type, int devnum) 250 { 251 struct blk_desc *desc; 252 int ret; 253 254 ret = get_desc(if_type, devnum, &desc); 255 if (ret) 256 return ret; 257 printf("\nIDE device %d: ", devnum); 258 dev_print(desc); 259 260 return 0; 261 } 262 263 int blk_show_device(enum if_type if_type, int devnum) 264 { 265 struct blk_desc *desc; 266 int ret; 267 268 printf("\nDevice %d: ", devnum); 269 ret = get_desc(if_type, devnum, &desc); 270 if (ret == -ENODEV || ret == -ENOENT) { 271 printf("unknown device\n"); 272 return -ENODEV; 273 } 274 if (ret) 275 return ret; 276 dev_print(desc); 277 278 if (desc->type == DEV_TYPE_UNKNOWN) 279 return -ENOENT; 280 281 return 0; 282 } 283 284 ulong blk_read_devnum(enum if_type if_type, int devnum, lbaint_t start, 285 lbaint_t blkcnt, void *buffer) 286 { 287 struct blk_desc *desc; 288 ulong n; 289 int ret; 290 291 ret = get_desc(if_type, devnum, &desc); 292 if (ret) 293 return ret; 294 n = blk_dread(desc, start, blkcnt, buffer); 295 if (IS_ERR_VALUE(n)) 296 return n; 297 298 return n; 299 } 300 301 ulong blk_write_devnum(enum if_type if_type, int devnum, lbaint_t start, 302 lbaint_t blkcnt, const void *buffer) 303 { 304 struct blk_desc *desc; 305 int ret; 306 307 ret = get_desc(if_type, devnum, &desc); 308 if (ret) 309 return ret; 310 return blk_dwrite(desc, start, blkcnt, buffer); 311 } 312 313 int blk_select_hwpart(struct udevice *dev, int hwpart) 314 { 315 const struct blk_ops *ops = blk_get_ops(dev); 316 317 if (!ops) 318 return -ENOSYS; 319 if (!ops->select_hwpart) 320 return 0; 321 322 return ops->select_hwpart(dev, hwpart); 323 } 324 325 int blk_dselect_hwpart(struct blk_desc *desc, int hwpart) 326 { 327 return blk_select_hwpart(desc->bdev, hwpart); 328 } 329 330 int blk_first_device(int if_type, struct udevice **devp) 331 { 332 struct blk_desc *desc; 333 int ret; 334 335 ret = uclass_find_first_device(UCLASS_BLK, devp); 336 if (ret) 337 return ret; 338 if (!*devp) 339 return -ENODEV; 340 do { 341 desc = dev_get_uclass_platdata(*devp); 342 if (desc->if_type == if_type) 343 return 0; 344 ret = uclass_find_next_device(devp); 345 if (ret) 346 return ret; 347 } while (*devp); 348 349 return -ENODEV; 350 } 351 352 int blk_next_device(struct udevice **devp) 353 { 354 struct blk_desc *desc; 355 int ret, if_type; 356 357 desc = dev_get_uclass_platdata(*devp); 358 if_type = desc->if_type; 359 do { 360 ret = uclass_find_next_device(devp); 361 if (ret) 362 return ret; 363 if (!*devp) 364 return -ENODEV; 365 desc = dev_get_uclass_platdata(*devp); 366 if (desc->if_type == if_type) 367 return 0; 368 } while (1); 369 } 370 371 int blk_find_device(int if_type, int devnum, struct udevice **devp) 372 { 373 struct uclass *uc; 374 struct udevice *dev; 375 int ret; 376 377 ret = uclass_get(UCLASS_BLK, &uc); 378 if (ret) 379 return ret; 380 uclass_foreach_dev(dev, uc) { 381 struct blk_desc *desc = dev_get_uclass_platdata(dev); 382 383 debug("%s: if_type=%d, devnum=%d: %s, %d, %d\n", __func__, 384 if_type, devnum, dev->name, desc->if_type, desc->devnum); 385 if (desc->if_type == if_type && desc->devnum == devnum) { 386 *devp = dev; 387 return 0; 388 } 389 } 390 391 return -ENODEV; 392 } 393 394 int blk_get_device(int if_type, int devnum, struct udevice **devp) 395 { 396 int ret; 397 398 ret = blk_find_device(if_type, devnum, devp); 399 if (ret) 400 return ret; 401 402 return device_probe(*devp); 403 } 404 405 unsigned long blk_dread(struct blk_desc *block_dev, lbaint_t start, 406 lbaint_t blkcnt, void *buffer) 407 { 408 struct udevice *dev = block_dev->bdev; 409 const struct blk_ops *ops = blk_get_ops(dev); 410 ulong blks_read; 411 412 if (!ops->read) 413 return -ENOSYS; 414 415 if (blkcache_read(block_dev->if_type, block_dev->devnum, 416 start, blkcnt, block_dev->blksz, buffer)) 417 return blkcnt; 418 blks_read = ops->read(dev, start, blkcnt, buffer); 419 if (blks_read == blkcnt) 420 blkcache_fill(block_dev->if_type, block_dev->devnum, 421 start, blkcnt, block_dev->blksz, buffer); 422 423 return blks_read; 424 } 425 426 unsigned long blk_dwrite(struct blk_desc *block_dev, lbaint_t start, 427 lbaint_t blkcnt, const void *buffer) 428 { 429 struct udevice *dev = block_dev->bdev; 430 const struct blk_ops *ops = blk_get_ops(dev); 431 432 if (!ops->write) 433 return -ENOSYS; 434 435 blkcache_invalidate(block_dev->if_type, block_dev->devnum); 436 return ops->write(dev, start, blkcnt, buffer); 437 } 438 439 unsigned long blk_derase(struct blk_desc *block_dev, lbaint_t start, 440 lbaint_t blkcnt) 441 { 442 struct udevice *dev = block_dev->bdev; 443 const struct blk_ops *ops = blk_get_ops(dev); 444 445 if (!ops->erase) 446 return -ENOSYS; 447 448 blkcache_invalidate(block_dev->if_type, block_dev->devnum); 449 return ops->erase(dev, start, blkcnt); 450 } 451 452 int blk_prepare_device(struct udevice *dev) 453 { 454 struct blk_desc *desc = dev_get_uclass_platdata(dev); 455 456 part_init(desc); 457 458 return 0; 459 } 460 461 int blk_get_from_parent(struct udevice *parent, struct udevice **devp) 462 { 463 struct udevice *dev; 464 enum uclass_id id; 465 int ret; 466 467 device_find_first_child(parent, &dev); 468 if (!dev) { 469 debug("%s: No block device found for parent '%s'\n", __func__, 470 parent->name); 471 return -ENODEV; 472 } 473 id = device_get_uclass_id(dev); 474 if (id != UCLASS_BLK) { 475 debug("%s: Incorrect uclass %s for block device '%s'\n", 476 __func__, uclass_get_name(id), dev->name); 477 return -ENOTBLK; 478 } 479 ret = device_probe(dev); 480 if (ret) 481 return ret; 482 *devp = dev; 483 484 return 0; 485 } 486 487 int blk_find_max_devnum(enum if_type if_type) 488 { 489 struct udevice *dev; 490 int max_devnum = -ENODEV; 491 struct uclass *uc; 492 int ret; 493 494 ret = uclass_get(UCLASS_BLK, &uc); 495 if (ret) 496 return ret; 497 uclass_foreach_dev(dev, uc) { 498 struct blk_desc *desc = dev_get_uclass_platdata(dev); 499 500 if (desc->if_type == if_type && desc->devnum > max_devnum) 501 max_devnum = desc->devnum; 502 } 503 504 return max_devnum; 505 } 506 507 static int blk_next_free_devnum(enum if_type if_type) 508 { 509 int ret; 510 511 ret = blk_find_max_devnum(if_type); 512 if (ret == -ENODEV) 513 return 0; 514 if (ret < 0) 515 return ret; 516 517 return ret + 1; 518 } 519 520 static int blk_claim_devnum(enum if_type if_type, int devnum) 521 { 522 struct udevice *dev; 523 struct uclass *uc; 524 int ret; 525 526 ret = uclass_get(UCLASS_BLK, &uc); 527 if (ret) 528 return ret; 529 uclass_foreach_dev(dev, uc) { 530 struct blk_desc *desc = dev_get_uclass_platdata(dev); 531 532 if (desc->if_type == if_type && desc->devnum == devnum) { 533 int next = blk_next_free_devnum(if_type); 534 535 if (next < 0) 536 return next; 537 desc->devnum = next; 538 return 0; 539 } 540 } 541 542 return -ENOENT; 543 } 544 545 int blk_create_device(struct udevice *parent, const char *drv_name, 546 const char *name, int if_type, int devnum, int blksz, 547 lbaint_t lba, struct udevice **devp) 548 { 549 struct blk_desc *desc; 550 struct udevice *dev; 551 int ret; 552 553 if (devnum == -1) { 554 devnum = blk_next_free_devnum(if_type); 555 } else { 556 ret = blk_claim_devnum(if_type, devnum); 557 if (ret < 0 && ret != -ENOENT) 558 return ret; 559 } 560 if (devnum < 0) 561 return devnum; 562 ret = device_bind_driver(parent, drv_name, name, &dev); 563 if (ret) 564 return ret; 565 desc = dev_get_uclass_platdata(dev); 566 desc->if_type = if_type; 567 desc->blksz = blksz; 568 desc->lba = lba; 569 desc->part_type = PART_TYPE_UNKNOWN; 570 desc->bdev = dev; 571 desc->devnum = devnum; 572 *devp = dev; 573 574 return 0; 575 } 576 577 int blk_create_devicef(struct udevice *parent, const char *drv_name, 578 const char *name, int if_type, int devnum, int blksz, 579 lbaint_t lba, struct udevice **devp) 580 { 581 char dev_name[30], *str; 582 int ret; 583 584 snprintf(dev_name, sizeof(dev_name), "%s.%s", parent->name, name); 585 str = strdup(dev_name); 586 if (!str) 587 return -ENOMEM; 588 589 ret = blk_create_device(parent, drv_name, str, if_type, devnum, 590 blksz, lba, devp); 591 if (ret) { 592 free(str); 593 return ret; 594 } 595 device_set_name_alloced(*devp); 596 597 return 0; 598 } 599 600 int blk_unbind_all(int if_type) 601 { 602 struct uclass *uc; 603 struct udevice *dev, *next; 604 int ret; 605 606 ret = uclass_get(UCLASS_BLK, &uc); 607 if (ret) 608 return ret; 609 uclass_foreach_dev_safe(dev, next, uc) { 610 struct blk_desc *desc = dev_get_uclass_platdata(dev); 611 612 if (desc->if_type == if_type) { 613 ret = device_remove(dev, DM_REMOVE_NORMAL); 614 if (ret) 615 return ret; 616 ret = device_unbind(dev); 617 if (ret) 618 return ret; 619 } 620 } 621 622 return 0; 623 } 624 625 UCLASS_DRIVER(blk) = { 626 .id = UCLASS_BLK, 627 .name = "blk", 628 .per_device_platdata_auto_alloc_size = sizeof(struct blk_desc), 629 }; 630