boot/bootdev-uclass.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2021 Google LLC
   4  * Written by Simon Glass <[email protected]>
   5  */
   6
   7 #define LOG_CATEGORY UCLASS_BOOTSTD
   8
   9 #include <common.h>
  10 #include <dm.h>
  11 #include <bootdev.h>
  12 #include <bootflow.h>
  13 #include <bootmeth.h>
  14 #include <bootstd.h>
  15 #include <fs.h>
  16 #include <log.h>
  17 #include <malloc.h>
  18 #include <part.h>
  19 #include <sort.h>
  20 #include <dm/device-internal.h>
  21 #include <dm/lists.h>
  22 #include <dm/uclass-internal.h>
  23
  24 enum {
  25         /*
  26          * Set some sort of limit on the number of partitions a bootdev can
  27          * have. Note that for disks this limits the partitions numbers that
  28          * are scanned to 1..MAX_BOOTFLOWS_PER_BOOTDEV
  29          */
  30         MAX_PART_PER_BOOTDEV    = 30,
  31
  32         /* Maximum supported length of the "boot_targets" env string */
  33         BOOT_TARGETS_MAX_LEN    = 100,
  34 };
  35
  36 int bootdev_add_bootflow(struct bootflow *bflow)
  37 {
  38         struct bootstd_priv *std;
  39         struct bootflow *new;
  40         int ret;
  41
  42         ret = bootstd_get_priv(&std);
  43         if (ret)
  44                 return ret;
  45
  46         new = malloc(sizeof(*bflow));
  47         if (!new)
  48                 return log_msg_ret("bflow", -ENOMEM);
  49         memcpy(new, bflow, sizeof(*bflow));
  50
  51         list_add_tail(&new->glob_node, &std->glob_head);
  52         if (bflow->dev) {
  53                 struct bootdev_uc_plat *ucp = dev_get_uclass_plat(bflow->dev);
  54
  55                 list_add_tail(&new->bm_node, &ucp->bootflow_head);
  56         }
  57
  58         return 0;
  59 }
  60
  61 int bootdev_first_bootflow(struct udevice *dev, struct bootflow **bflowp)
  62 {
  63         struct bootdev_uc_plat *ucp = dev_get_uclass_plat(dev);
  64
  65         if (list_empty(&ucp->bootflow_head))
  66                 return -ENOENT;
  67
  68         *bflowp = list_first_entry(&ucp->bootflow_head, struct bootflow,
  69                                    bm_node);
  70
  71         return 0;
  72 }
  73
  74 int bootdev_next_bootflow(struct bootflow **bflowp)
  75 {
  76         struct bootflow *bflow = *bflowp;
  77         struct bootdev_uc_plat *ucp = dev_get_uclass_plat(bflow->dev);
  78
  79         *bflowp = NULL;
  80
  81         if (list_is_last(&bflow->bm_node, &ucp->bootflow_head))
  82                 return -ENOENT;
  83
  84         *bflowp = list_entry(bflow->bm_node.next, struct bootflow, bm_node);
  85
  86         return 0;
  87 }
  88
  89 int bootdev_bind(struct udevice *parent, const char *drv_name, const char *name,
  90                  struct udevice **devp)
  91 {
  92         struct udevice *dev;
  93         char dev_name[30];
  94         char *str;
  95         int ret;
  96
  97         snprintf(dev_name, sizeof(dev_name), "%s.%s", parent->name, name);
  98         str = strdup(dev_name);
  99         if (!str)
 100                 return -ENOMEM;
 101         ret = device_bind_driver(parent, drv_name, str, &dev);
 102         if (ret)
 103                 return ret;
 104         device_set_name_alloced(dev);
 105         *devp = dev;
 106
 107         return 0;
 108 }
 109
 110 int bootdev_find_in_blk(struct udevice *dev, struct udevice *blk,
 111                         struct bootflow_iter *iter, struct bootflow *bflow)
 112 {
 113         struct bootmeth_uc_plat *plat = dev_get_uclass_plat(bflow->method);
 114         bool allow_any_part = plat->flags & BOOTMETHF_ANY_PART;
 115         struct blk_desc *desc = dev_get_uclass_plat(blk);
 116         struct disk_partition info;
 117         char partstr[20];
 118         char name[60];
 119         int ret;
 120
 121         /* Sanity check */
 122         if (iter->part >= MAX_PART_PER_BOOTDEV)
 123                 return log_msg_ret("max", -ESHUTDOWN);
 124
 125         bflow->blk = blk;
 126         if (iter->part)
 127                 snprintf(partstr, sizeof(partstr), "part_%x", iter->part);
 128         else
 129                 strcpy(partstr, "whole");
 130         snprintf(name, sizeof(name), "%s.%s", dev->name, partstr);
 131         bflow->name = strdup(name);
 132         if (!bflow->name)
 133                 return log_msg_ret("name", -ENOMEM);
 134
 135         bflow->part = iter->part;
 136
 137         ret = bootmeth_check(bflow->method, iter);
 138         if (ret)
 139                 return log_msg_ret("check", ret);
 140
 141         /*
 142          * partition numbers start at 0 so this cannot succeed, but it can tell
 143          * us whether there is valid media there
 144          */
 145         ret = part_get_info(desc, iter->part, &info);
 146         log_debug("part_get_info() returned %d\n", ret);
 147         if (!iter->part && ret == -ENOENT)
 148                 ret = 0;
 149
 150         /*
 151          * This error indicates the media is not present. Otherwise we just
 152          * blindly scan the next partition. We could be more intelligent here
 153          * and check which partition numbers actually exist.
 154          */
 155         if (ret == -EOPNOTSUPP)
 156                 ret = -ESHUTDOWN;
 157         else
 158                 bflow->state = BOOTFLOWST_MEDIA;
 159         if (ret && !allow_any_part) {
 160                 /* allow partition 1 to be missing */
 161                 if (iter->part == 1) {
 162                         iter->max_part = 3;
 163                         ret = -ENOENT;
 164                 }
 165
 166                 return log_msg_ret("part", ret);
 167         }
 168
 169         /*
 170          * Currently we don't get the number of partitions, so just
 171          * assume a large number
 172          */
 173         iter->max_part = MAX_PART_PER_BOOTDEV;
 174
 175         if (iter->flags & BOOTFLOWIF_SINGLE_PARTITION) {
 176                 /* a particular partition was specified, scan it without checking */
 177         } else if (!iter->part) {
 178                 /* This is the whole disk, check if we have bootable partitions */
 179                 iter->first_bootable = part_get_bootable(desc);
 180                 log_debug("checking bootable=%d\n", iter->first_bootable);
 181         } else if (allow_any_part) {
 182                 /*
 183                  * allow any partition to be scanned, by skipping any checks
 184                  * for filesystems or partition contents on this disk
 185                  */
 186
 187         /* if there are bootable partitions, scan only those */
 188         } else if (iter->first_bootable >= 0 &&
 189                    (iter->first_bootable ? !info.bootable : iter->part != 1)) {
 190                 return log_msg_ret("boot", -EINVAL);
 191         } else {
 192                 ret = fs_set_blk_dev_with_part(desc, bflow->part);
 193                 bflow->state = BOOTFLOWST_PART;
 194                 if (ret)
 195                         return log_msg_ret("fs", ret);
 196
 197                 log_debug("%s: Found partition %x type %x fstype %d\n",
 198                           blk->name, bflow->part,
 199                           IS_ENABLED(CONFIG_DOS_PARTITION) ?
 200                           disk_partition_sys_ind(&info) : 0,
 201                           ret ? -1 : fs_get_type());
 202                 bflow->blk = blk;
 203                 bflow->state = BOOTFLOWST_FS;
 204         }
 205
 206         log_debug("method %s\n", bflow->method->name);
 207         ret = bootmeth_read_bootflow(bflow->method, bflow);
 208         if (ret)
 209                 return log_msg_ret("method", ret);
 210
 211         return 0;
 212 }
 213
 214 void bootdev_list(bool probe)
 215 {
 216         struct udevice *dev;
 217         int ret;
 218         int i;
 219
 220         printf("Seq  Probed  Status  Uclass    Name\n");
 221         printf("---  ------  ------  --------  ------------------\n");
 222         if (probe)
 223                 ret = uclass_first_device_check(UCLASS_BOOTDEV, &dev);
 224         else
 225                 ret = uclass_find_first_device(UCLASS_BOOTDEV, &dev);
 226         for (i = 0; dev; i++) {
 227                 printf("%3x   [ %c ]  %6s  %-9.9s %s\n", dev_seq(dev),
 228                        device_active(dev) ? '+' : ' ',
 229                        ret ? simple_itoa(-ret) : "OK",
 230                        dev_get_uclass_name(dev_get_parent(dev)), dev->name);
 231                 if (probe)
 232                         ret = uclass_next_device_check(&dev);
 233                 else
 234                         ret = uclass_find_next_device(&dev);
 235         }
 236         printf("---  ------  ------  --------  ------------------\n");
 237         printf("(%d bootdev%s)\n", i, i != 1 ? "s" : "");
 238 }
 239
 240 int bootdev_setup_for_dev(struct udevice *parent, const char *drv_name)
 241 {
 242         struct udevice *bdev;
 243         int ret;
 244
 245         ret = device_find_first_child_by_uclass(parent, UCLASS_BOOTDEV,
 246                                                 &bdev);
 247         if (ret) {
 248                 if (ret != -ENODEV) {
 249                         log_debug("Cannot access bootdev device\n");
 250                         return ret;
 251                 }
 252
 253                 ret = bootdev_bind(parent, drv_name, "bootdev", &bdev);
 254                 if (ret) {
 255                         log_debug("Cannot create bootdev device\n");
 256                         return ret;
 257                 }
 258         }
 259
 260         return 0;
 261 }
 262
 263 static int bootdev_get_suffix_start(struct udevice *dev, const char *suffix)
 264 {
 265         int len, slen;
 266
 267         len = strlen(dev->name);
 268         slen = strlen(suffix);
 269         if (len > slen && !strcmp(suffix, dev->name + len - slen))
 270                 return len - slen;
 271
 272         return len;
 273 }
 274
 275 int bootdev_setup_for_sibling_blk(struct udevice *blk, const char *drv_name)
 276 {
 277         struct udevice *parent, *dev;
 278         char dev_name[50];
 279         int ret, len;
 280
 281         len = bootdev_get_suffix_start(blk, ".blk");
 282         snprintf(dev_name, sizeof(dev_name), "%.*s.%s", len, blk->name,
 283                  "bootdev");
 284
 285         parent = dev_get_parent(blk);
 286         ret = device_find_child_by_name(parent, dev_name, &dev);
 287         if (ret) {
 288                 char *str;
 289
 290                 if (ret != -ENODEV) {
 291                         log_debug("Cannot access bootdev device\n");
 292                         return ret;
 293                 }
 294                 str = strdup(dev_name);
 295                 if (!str)
 296                         return -ENOMEM;
 297
 298                 ret = device_bind_driver(parent, drv_name, str, &dev);
 299                 if (ret) {
 300                         log_debug("Cannot create bootdev device\n");
 301                         return ret;
 302                 }
 303                 device_set_name_alloced(dev);
 304         }
 305
 306         return 0;
 307 }
 308
 309 int bootdev_get_sibling_blk(struct udevice *dev, struct udevice **blkp)
 310 {
 311         struct udevice *parent = dev_get_parent(dev);
 312         struct udevice *blk;
 313         int ret, len;
 314
 315         if (device_get_uclass_id(dev) != UCLASS_BOOTDEV)
 316                 return -EINVAL;
 317
 318         /*
 319          * This should always work if bootdev_setup_for_sibling_blk() was used
 320          */
 321         len = bootdev_get_suffix_start(dev, ".bootdev");
 322         ret = device_find_child_by_namelen(parent, dev->name, len, &blk);
 323         if (ret) {
 324                 char dev_name[50];
 325
 326                 snprintf(dev_name, sizeof(dev_name), "%.*s.blk", len,
 327                          dev->name);
 328                 ret = device_find_child_by_name(parent, dev_name, &blk);
 329                 if (ret)
 330                         return log_msg_ret("find", ret);
 331         }
 332         ret = device_probe(blk);
 333         if (ret)
 334                 return log_msg_ret("act", ret);
 335         *blkp = blk;
 336
 337         return 0;
 338 }
 339
 340 static int bootdev_get_from_blk(struct udevice *blk, struct udevice **bootdevp)
 341 {
 342         struct udevice *parent = dev_get_parent(blk);
 343         struct udevice *bootdev;
 344         char dev_name[50];
 345         int ret, len;
 346
 347         if (device_get_uclass_id(blk) != UCLASS_BLK)
 348                 return -EINVAL;
 349
 350         /* This should always work if bootdev_setup_for_sibling_blk() was used */
 351         len = bootdev_get_suffix_start(blk, ".blk");
 352         snprintf(dev_name, sizeof(dev_name), "%.*s.%s", len, blk->name,
 353                  "bootdev");
 354         ret = device_find_child_by_name(parent, dev_name, &bootdev);
 355         if (ret)
 356                 return log_msg_ret("find", ret);
 357         *bootdevp = bootdev;
 358
 359         return 0;
 360 }
 361
 362 int bootdev_unbind_dev(struct udevice *parent)
 363 {
 364         struct udevice *dev;
 365         int ret;
 366
 367         ret = device_find_first_child_by_uclass(parent, UCLASS_BOOTDEV, &dev);
 368         if (!ret) {
 369                 ret = device_remove(dev, DM_REMOVE_NORMAL);
 370                 if (ret)
 371                         return log_msg_ret("rem", ret);
 372                 ret = device_unbind(dev);
 373                 if (ret)
 374                         return log_msg_ret("unb", ret);
 375         }
 376
 377         return 0;
 378 }
 379
 380 /**
 381  * label_to_uclass() - Convert a label to a uclass and sequence number
 382  *
 383  * @label: Label to look up (e.g. "mmc1" or "mmc0")
 384  * @seqp: Returns the sequence number, or -1 if none
 385  * @method_flagsp: If non-NULL, returns any flags implied by the label
 386  * (enum bootflow_meth_flags_t), 0 if none
 387  * Returns: sequence number on success, -EPFNOSUPPORT is the uclass is not
 388  * known, other -ve error code on other error
 389  */
 390 static int label_to_uclass(const char *label, int *seqp, int *method_flagsp)
 391 {
 392         int seq, len, method_flags;
 393         enum uclass_id id;
 394         const char *end;
 395
 396         method_flags = 0;
 397         seq = trailing_strtoln_end(label, NULL, &end);
 398         len = end - label;
 399         if (!len)
 400                 return -EINVAL;
 401         id = uclass_get_by_namelen(label, len);
 402         log_debug("find %s: seq=%d, id=%d/%s\n", label, seq, id,
 403                   uclass_get_name(id));
 404         if (id == UCLASS_INVALID) {
 405                 /* try some special cases */
 406                 if (IS_ENABLED(CONFIG_BOOTDEV_SPI_FLASH) &&
 407                     !strncmp("spi", label, len)) {
 408                         id = UCLASS_SPI_FLASH;
 409                 } else if (IS_ENABLED(CONFIG_BOOTDEV_ETH) &&
 410                     !strncmp("pxe", label, len)) {
 411                         id = UCLASS_ETH;
 412                         method_flags |= BOOTFLOW_METHF_PXE_ONLY;
 413                 } else if (IS_ENABLED(CONFIG_BOOTDEV_ETH) &&
 414                     !strncmp("dhcp", label, len)) {
 415                         id = UCLASS_ETH;
 416                         method_flags |= BOOTFLOW_METHF_DHCP_ONLY;
 417                 } else {
 418                         return -EPFNOSUPPORT;
 419                 }
 420         }
 421         if (id == UCLASS_USB)
 422                 id = UCLASS_MASS_STORAGE;
 423         *seqp = seq;
 424         if (method_flagsp)
 425                 *method_flagsp = method_flags;
 426
 427         return id;
 428 }
 429
 430 int bootdev_find_by_label(const char *label, struct udevice **devp,
 431                           int *method_flagsp)
 432 {
 433         int seq, ret, method_flags = 0;
 434         struct udevice *media;
 435         struct uclass *uc;
 436         enum uclass_id id;
 437
 438         ret = label_to_uclass(label, &seq, &method_flags);
 439         if (ret < 0)
 440                 return log_msg_ret("uc", ret);
 441         id = ret;
 442
 443         /* Iterate through devices in the media uclass (e.g. UCLASS_MMC) */
 444         uclass_id_foreach_dev(id, media, uc) {
 445                 struct udevice *bdev, *blk;
 446                 int ret;
 447
 448                 /* if there is no seq, match anything */
 449                 if (seq != -1 && dev_seq(media) != seq) {
 450                         log_debug("- skip, media seq=%d\n", dev_seq(media));
 451                         continue;
 452                 }
 453
 454                 ret = device_find_first_child_by_uclass(media, UCLASS_BOOTDEV,
 455                                                         &bdev);
 456                 if (ret) {
 457                         log_debug("- looking via blk, seq=%d, id=%d\n", seq,
 458                                   id);
 459                         ret = blk_find_device(id, seq, &blk);
 460                         if (!ret) {
 461                                 log_debug("- get from blk %s\n", blk->name);
 462                                 ret = bootdev_get_from_blk(blk, &bdev);
 463                         }
 464                 }
 465                 if (!ret) {
 466                         log_debug("- found %s\n", bdev->name);
 467                         *devp = bdev;
 468
 469                         /*
 470                          * if no sequence number was provided, we must scan all
 471                          * bootdevs for this media uclass
 472                          */
 473                         if (seq == -1)
 474                                 method_flags |= BOOTFLOW_METHF_SINGLE_UCLASS;
 475                         if (method_flagsp)
 476                                 *method_flagsp = method_flags;
 477                         log_debug("method flags %x\n", method_flags);
 478                         return 0;
 479                 }
 480                 log_debug("- no device in %s\n", media->name);
 481         }
 482
 483         return -ENOENT;
 484 }
 485
 486 int bootdev_find_by_any(const char *name, struct udevice **devp,
 487                         int *method_flagsp)
 488 {
 489         struct udevice *dev;
 490         int method_flags = 0;
 491         int ret = -ENODEV, seq;
 492         char *endp;
 493
 494         seq = simple_strtol(name, &endp, 16);
 495
 496         /* Select by name, label or number */
 497         if (*endp) {
 498                 ret = uclass_get_device_by_name(UCLASS_BOOTDEV, name, &dev);
 499                 if (ret == -ENODEV) {
 500                         ret = bootdev_find_by_label(name, &dev, &method_flags);
 501                         if (ret) {
 502                                 printf("Cannot find bootdev '%s' (err=%d)\n",
 503                                        name, ret);
 504                                 return log_msg_ret("lab", ret);
 505                         }
 506                         ret = device_probe(dev);
 507                 }
 508                 if (ret) {
 509                         printf("Cannot probe bootdev '%s' (err=%d)\n", name,
 510                                ret);
 511                         return log_msg_ret("pro", ret);
 512                 }
 513         } else if (IS_ENABLED(CONFIG_BOOTSTD_FULL)) {
 514                 ret = uclass_get_device_by_seq(UCLASS_BOOTDEV, seq, &dev);
 515                 method_flags |= BOOTFLOW_METHF_SINGLE_DEV;
 516         }
 517         if (ret) {
 518                 printf("Cannot find '%s' (err=%d)\n", name, ret);
 519                 return ret;
 520         }
 521
 522         *devp = dev;
 523         if (method_flagsp)
 524                 *method_flagsp = method_flags;
 525
 526         return 0;
 527 }
 528
 529 int bootdev_hunt_and_find_by_label(const char *label, struct udevice **devp,
 530                                    int *method_flagsp)
 531 {
 532         int ret;
 533
 534         ret = bootdev_hunt(label, false);
 535         if (ret)
 536                 return log_msg_ret("scn", ret);
 537         ret = bootdev_find_by_label(label, devp, method_flagsp);
 538         if (ret)
 539                 return log_msg_ret("fnd", ret);
 540
 541         return 0;
 542 }
 543
 544 static int default_get_bootflow(struct udevice *dev, struct bootflow_iter *iter,
 545                                 struct bootflow *bflow)
 546 {
 547         struct udevice *blk;
 548         int ret;
 549
 550         ret = bootdev_get_sibling_blk(dev, &blk);
 551         log_debug("sibling_blk ret=%d, blk=%s\n", ret,
 552                   ret ? "(none)" : blk->name);
 553         /*
 554          * If there is no media, indicate that no more partitions should be
 555          * checked
 556          */
 557         if (ret == -EOPNOTSUPP)
 558                 ret = -ESHUTDOWN;
 559         if (ret)
 560                 return log_msg_ret("blk", ret);
 561         assert(blk);
 562         ret = bootdev_find_in_blk(dev, blk, iter, bflow);
 563         if (ret)
 564                 return log_msg_ret("find", ret);
 565
 566         return 0;
 567 }
 568
 569 int bootdev_get_bootflow(struct udevice *dev, struct bootflow_iter *iter,
 570                          struct bootflow *bflow)
 571 {
 572         const struct bootdev_ops *ops = bootdev_get_ops(dev);
 573
 574         log_debug("->get_bootflow %s,%x=%p\n", dev->name, iter->part,
 575                   ops->get_bootflow);
 576         bootflow_init(bflow, dev, iter->method);
 577         if (!ops->get_bootflow)
 578                 return default_get_bootflow(dev, iter, bflow);
 579
 580         return ops->get_bootflow(dev, iter, bflow);
 581 }
 582
 583 void bootdev_clear_bootflows(struct udevice *dev)
 584 {
 585         struct bootdev_uc_plat *ucp = dev_get_uclass_plat(dev);
 586
 587         while (!list_empty(&ucp->bootflow_head)) {
 588                 struct bootflow *bflow;
 589
 590                 bflow = list_first_entry(&ucp->bootflow_head, struct bootflow,
 591                                          bm_node);
 592                 bootflow_remove(bflow);
 593         }
 594 }
 595
 596 int bootdev_next_label(struct bootflow_iter *iter, struct udevice **devp,
 597                        int *method_flagsp)
 598 {
 599         struct udevice *dev;
 600
 601         log_debug("next\n");
 602         for (dev = NULL; !dev && iter->labels[++iter->cur_label];) {
 603                 const char *label = iter->labels[iter->cur_label];
 604                 int ret;
 605
 606                 log_debug("Scanning: %s\n", label);
 607                 ret = bootdev_hunt_and_find_by_label(label, &dev,
 608                                                      method_flagsp);
 609                 if (iter->flags & BOOTFLOWIF_SHOW) {
 610                         if (ret == -EPFNOSUPPORT) {
 611                                 log_warning("Unknown uclass '%s' in label\n",
 612                                             label);
 613                         } else if (ret == -ENOENT) {
 614                                 /*
 615                                  * looking for, e.g. 'scsi0' should find
 616                                  * something if SCSI is present
 617                                  */
 618                                 if (!trailing_strtol(label)) {
 619                                         log_warning("No bootdevs for '%s'\n",
 620                                                     label);
 621                                 }
 622                         }
 623                 }
 624
 625         }
 626
 627         if (!dev)
 628                 return log_msg_ret("fin", -ENODEV);
 629         *devp = dev;
 630
 631         return 0;
 632 }
 633
 634 int bootdev_next_prio(struct bootflow_iter *iter, struct udevice **devp)
 635 {
 636         struct udevice *dev = *devp, *last_dev = NULL;
 637         bool found;
 638         int ret;
 639
 640         /* find the next device with this priority */
 641         *devp = NULL;
 642         log_debug("next prio %d: dev=%p/%s\n", iter->cur_prio, dev,
 643                   dev ? dev->name : "none");
 644         do {
 645                 /*
 646                  * Don't probe devices here since they may not be of the
 647                  * required priority
 648                  */
 649                 if (!dev)
 650                         uclass_find_first_device(UCLASS_BOOTDEV, &dev);
 651                 else
 652                         uclass_find_next_device(&dev);
 653                 found = false;
 654
 655                 /* scan for the next device with the correct priority */
 656                 while (dev) {
 657                         struct bootdev_uc_plat *plat;
 658
 659                         plat = dev_get_uclass_plat(dev);
 660                         log_debug("- %s: %d, want %d\n", dev->name, plat->prio,
 661                                   iter->cur_prio);
 662                         if (plat->prio == iter->cur_prio)
 663                                 break;
 664                         uclass_find_next_device(&dev);
 665                 }
 666
 667                 /* none found for this priority, so move to the next */
 668                 if (!dev) {
 669                         log_debug("None found at prio %d, moving to %d\n",
 670                                   iter->cur_prio, iter->cur_prio + 1);
 671                         if (++iter->cur_prio == BOOTDEVP_COUNT)
 672                                 return log_msg_ret("fin", -ENODEV);
 673
 674                         if (iter->flags & BOOTFLOWIF_HUNT) {
 675                                 /* hunt to find new bootdevs */
 676                                 ret = bootdev_hunt_prio(iter->cur_prio,
 677                                                         iter->flags &
 678                                                         BOOTFLOWIF_SHOW);
 679                                 log_debug("- bootdev_hunt_prio() ret %d\n",
 680                                           ret);
 681                                 if (ret)
 682                                         return log_msg_ret("hun", ret);
 683                         }
 684                 } else {
 685                         ret = device_probe(dev);
 686                         if (!ret)
 687                                 last_dev = dev;
 688                         if (ret) {
 689                                 log_warning("Device '%s' failed to probe\n",
 690                                           dev->name);
 691                                 if (last_dev == dev) {
 692                                         /*
 693                                          * We have already tried this device
 694                                          * and it failed to probe. Give up.
 695                                          */
 696                                         return log_msg_ret("probe", ret);
 697                                 }
 698                                 last_dev = dev;
 699                                 dev = NULL;
 700                         }
 701                 }
 702         } while (!dev);
 703
 704         *devp = dev;
 705
 706         return 0;
 707 }
 708
 709 int bootdev_setup_iter(struct bootflow_iter *iter, const char *label,
 710                        struct udevice **devp, int *method_flagsp)
 711 {
 712         struct udevice *bootstd, *dev = NULL;
 713         bool show = iter->flags & BOOTFLOWIF_SHOW;
 714         int method_flags;
 715         char buf[32];
 716         int ret;
 717
 718         if (label) {
 719                 const char *end = strchr(label, ':');
 720
 721                 if (end) {
 722                         size_t len = (size_t)(end - label);
 723                         const char *part = end + 1;
 724
 725                         if (len + 1 > sizeof(buf)) {
 726                                 log_err("label \"%s\" is way too long\n", label);
 727                                 return -EINVAL;
 728                         }
 729
 730                         memcpy(buf, label, len);
 731                         buf[len] = '\0';
 732                         label = buf;
 733
 734                         unsigned long tmp;
 735
 736                         if (strict_strtoul(part, 0, &tmp)) {
 737                                 log_err("Invalid partition number: %s\n", part);
 738                                 return -EINVAL;
 739                         }
 740
 741                         iter->flags |= BOOTFLOWIF_SINGLE_PARTITION;
 742                         iter->part = tmp;
 743                 }
 744         }
 745
 746         ret = uclass_first_device_err(UCLASS_BOOTSTD, &bootstd);
 747         if (ret) {
 748                 log_err("Missing bootstd device\n");
 749                 return log_msg_ret("std", ret);
 750         }
 751
 752         /* hunt for any pre-scan devices */
 753         if (iter->flags & BOOTFLOWIF_HUNT) {
 754                 ret = bootdev_hunt_prio(BOOTDEVP_1_PRE_SCAN, show);
 755                 log_debug("- bootdev_hunt_prio() ret %d\n", ret);
 756                 if (ret)
 757                         return log_msg_ret("pre", ret);
 758         }
 759
 760         /* Handle scanning a single device */
 761         if (IS_ENABLED(CONFIG_BOOTSTD_FULL) && label) {
 762                 if (iter->flags & BOOTFLOWIF_HUNT) {
 763                         ret = bootdev_hunt(label, show);
 764                         if (ret)
 765                                 return log_msg_ret("hun", ret);
 766                 }
 767                 ret = bootdev_find_by_any(label, &dev, &method_flags);
 768                 if (ret)
 769                         return log_msg_ret("lab", ret);
 770
 771                 log_debug("method_flags: %x\n", method_flags);
 772                 if (method_flags & BOOTFLOW_METHF_SINGLE_UCLASS)
 773                         iter->flags |= BOOTFLOWIF_SINGLE_UCLASS;
 774                 else if (method_flags & BOOTFLOW_METHF_SINGLE_DEV)
 775                         iter->flags |= BOOTFLOWIF_SINGLE_DEV;
 776                 else
 777                         iter->flags |= BOOTFLOWIF_SINGLE_MEDIA;
 778                 log_debug("Selected label: %s, flags %x\n", label, iter->flags);
 779         } else {
 780                 bool ok;
 781
 782                 /* This either returns a non-empty list or NULL */
 783                 iter->labels = bootstd_get_bootdev_order(bootstd, &ok);
 784                 if (!ok)
 785                         return log_msg_ret("ord", -ENOMEM);
 786                 log_debug("setup labels %p\n", iter->labels);
 787                 if (iter->labels) {
 788                         iter->cur_label = -1;
 789                         ret = bootdev_next_label(iter, &dev, &method_flags);
 790                 } else {
 791                         ret = bootdev_next_prio(iter, &dev);
 792                         method_flags = 0;
 793                 }
 794                 if (!dev)
 795                         return log_msg_ret("fin", -ENOENT);
 796                 log_debug("Selected bootdev: %s\n", dev->name);
 797         }
 798
 799         ret = device_probe(dev);
 800         if (ret)
 801                 return log_msg_ret("probe", ret);
 802         if (method_flagsp)
 803                 *method_flagsp = method_flags;
 804         *devp = dev;
 805
 806         return 0;
 807 }
 808
 809 static int bootdev_hunt_drv(struct bootdev_hunter *info, uint seq, bool show)
 810 {
 811         const char *name = uclass_get_name(info->uclass);
 812         struct bootstd_priv *std;
 813         int ret;
 814
 815         ret = bootstd_get_priv(&std);
 816         if (ret)
 817                 return log_msg_ret("std", ret);
 818
 819         if (!(std->hunters_used & BIT(seq))) {
 820                 if (show)
 821                         printf("Hunting with: %s\n",
 822                                uclass_get_name(info->uclass));
 823                 log_debug("Hunting with: %s\n", name);
 824                 if (info->hunt) {
 825                         ret = info->hunt(info, show);
 826                         log_debug("  - hunt result %d\n", ret);
 827                         if (ret && ret != -ENOENT)
 828                                 return ret;
 829                 }
 830                 std->hunters_used |= BIT(seq);
 831         }
 832
 833         return 0;
 834 }
 835
 836 int bootdev_hunt(const char *spec, bool show)
 837 {
 838         struct bootdev_hunter *start;
 839         const char *end;
 840         int n_ent, i;
 841         int result;
 842         size_t len;
 843
 844         start = ll_entry_start(struct bootdev_hunter, bootdev_hunter);
 845         n_ent = ll_entry_count(struct bootdev_hunter, bootdev_hunter);
 846         result = 0;
 847
 848         len = SIZE_MAX;
 849         if (spec) {
 850                 trailing_strtoln_end(spec, NULL, &end);
 851                 len = end - spec;
 852         }
 853
 854         for (i = 0; i < n_ent; i++) {
 855                 struct bootdev_hunter *info = start + i;
 856                 const char *name = uclass_get_name(info->uclass);
 857                 int ret;
 858
 859                 log_debug("looking at %.*s for %s\n",
 860                           (int)max(strlen(name), len), spec, name);
 861                 if (spec && strncmp(spec, name, max(strlen(name), len))) {
 862                         if (info->uclass != UCLASS_ETH ||
 863                             (strcmp("dhcp", spec) && strcmp("pxe", spec)))
 864                                 continue;
 865                 }
 866                 ret = bootdev_hunt_drv(info, i, show);
 867                 if (ret)
 868                         result = ret;
 869         }
 870
 871         return result;
 872 }
 873
 874 int bootdev_unhunt(enum uclass_id id)
 875 {
 876         struct bootdev_hunter *start;
 877         int n_ent, i;
 878
 879         start = ll_entry_start(struct bootdev_hunter, bootdev_hunter);
 880         n_ent = ll_entry_count(struct bootdev_hunter, bootdev_hunter);
 881         for (i = 0; i < n_ent; i++) {
 882                 struct bootdev_hunter *info = start + i;
 883
 884                 if (info->uclass == id) {
 885                         struct bootstd_priv *std;
 886                         int ret;
 887
 888                         ret = bootstd_get_priv(&std);
 889                         if (ret)
 890                                 return log_msg_ret("std", ret);
 891                         if (!(std->hunters_used & BIT(i)))
 892                                 return -EALREADY;
 893                         std->hunters_used &= ~BIT(i);
 894                         return 0;
 895                 }
 896         }
 897
 898         return -ENOENT;
 899 }
 900
 901 int bootdev_hunt_prio(enum bootdev_prio_t prio, bool show)
 902 {
 903         struct bootdev_hunter *start;
 904         int n_ent, i;
 905         int result;
 906
 907         start = ll_entry_start(struct bootdev_hunter, bootdev_hunter);
 908         n_ent = ll_entry_count(struct bootdev_hunter, bootdev_hunter);
 909         result = 0;
 910
 911         log_debug("Hunting for priority %d\n", prio);
 912         for (i = 0; i < n_ent; i++) {
 913                 struct bootdev_hunter *info = start + i;
 914                 int ret;
 915
 916                 if (prio != info->prio)
 917                         continue;
 918                 ret = bootdev_hunt_drv(info, i, show);
 919                 log_debug("bootdev_hunt_drv() return %d\n", ret);
 920                 if (ret && ret != -ENOENT)
 921                         result = ret;
 922         }
 923         log_debug("exit %d\n", result);
 924
 925         return result;
 926 }
 927
 928 void bootdev_list_hunters(struct bootstd_priv *std)
 929 {
 930         struct bootdev_hunter *orig, *start;
 931         int n_ent, i;
 932
 933         orig = ll_entry_start(struct bootdev_hunter, bootdev_hunter);
 934         n_ent = ll_entry_count(struct bootdev_hunter, bootdev_hunter);
 935
 936         /*
 937          * workaround for strange bug in clang-12 which sees all the below data
 938          * as zeroes. Any access of start seems to fix it, such as
 939          *
 940          *    printf("%p", start);
 941          *
 942          * Use memcpy() to force the correct behaviour.
 943          */
 944         memcpy(&start, &orig, sizeof(orig));
 945         printf("%4s  %4s  %-15s  %s\n", "Prio", "Used", "Uclass", "Hunter");
 946         printf("%4s  %4s  %-15s  %s\n", "----", "----", "---------------", "---------------");
 947         for (i = 0; i < n_ent; i++) {
 948                 struct bootdev_hunter *info = start + i;
 949
 950                 printf("%4d  %4s  %-15s  %s\n", info->prio,
 951                        std->hunters_used & BIT(i) ? "*" : "",
 952                        uclass_get_name(info->uclass),
 953                        info->drv ? info->drv->name : "(none)");
 954         }
 955
 956         printf("(total hunters: %d)\n", n_ent);
 957 }
 958
 959 static int bootdev_post_bind(struct udevice *dev)
 960 {
 961         struct bootdev_uc_plat *ucp = dev_get_uclass_plat(dev);
 962
 963         INIT_LIST_HEAD(&ucp->bootflow_head);
 964
 965         return 0;
 966 }
 967
 968 static int bootdev_pre_unbind(struct udevice *dev)
 969 {
 970         bootdev_clear_bootflows(dev);
 971
 972         return 0;
 973 }
 974
 975 UCLASS_DRIVER(bootdev) = {
 976         .id             = UCLASS_BOOTDEV,
 977         .name           = "bootdev",
 978         .flags          = DM_UC_FLAG_SEQ_ALIAS,
 979         .per_device_plat_auto   = sizeof(struct bootdev_uc_plat),
 980         .post_bind      = bootdev_post_bind,
 981         .pre_unbind     = bootdev_pre_unbind,
 982 };