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