blob: 46815ea2fdbfc4964a39932a7b9032916af8d333 [file] [log] [blame]
Simon Glass201417d2022-04-24 23:31:07 -06001// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright 2021 Google LLC
4 * Written by Simon Glass <sjg@chromium.org>
5 */
6
7#define LOG_CATEGORY UCLASS_BOOTSTD
8
Tom Rinid678a592024-05-18 20:20:43 -06009#include <common.h>
Simon Glass201417d2022-04-24 23:31:07 -060010#include <dm.h>
11#include <bootdev.h>
12#include <bootflow.h>
Simon Glassa8f5be12022-04-24 23:31:09 -060013#include <bootmeth.h>
Simon Glass201417d2022-04-24 23:31:07 -060014#include <bootstd.h>
Simon Glass201417d2022-04-24 23:31:07 -060015#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
24enum {
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
36int bootdev_add_bootflow(struct bootflow *bflow)
37{
Simon Glass201417d2022-04-24 23:31:07 -060038 struct bootstd_priv *std;
39 struct bootflow *new;
40 int ret;
41
Simon Glass201417d2022-04-24 23:31:07 -060042 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);
Simon Glasseccb25c2022-07-30 15:52:23 -060052 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 }
Simon Glass201417d2022-04-24 23:31:07 -060057
58 return 0;
59}
60
61int 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
74int 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
89int 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
110int bootdev_find_in_blk(struct udevice *dev, struct udevice *blk,
111 struct bootflow_iter *iter, struct bootflow *bflow)
112{
Simon Glass831405f2023-08-24 13:55:43 -0600113 struct bootmeth_uc_plat *plat = dev_get_uclass_plat(bflow->method);
114 bool allow_any_part = plat->flags & BOOTMETHF_ANY_PART;
Simon Glass201417d2022-04-24 23:31:07 -0600115 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
Simon Glassa8f5be12022-04-24 23:31:09 -0600137 ret = bootmeth_check(bflow->method, iter);
138 if (ret)
139 return log_msg_ret("check", ret);
140
Simon Glass201417d2022-04-24 23:31:07 -0600141 /*
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);
Simon Glass831405f2023-08-24 13:55:43 -0600146 log_debug("part_get_info() returned %d\n", ret);
Simon Glass201417d2022-04-24 23:31:07 -0600147 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;
Simon Glass831405f2023-08-24 13:55:43 -0600159 if (ret && !allow_any_part) {
Simon Glass76afc842023-04-28 13:18:09 -0600160 /* allow partition 1 to be missing */
161 if (iter->part == 1) {
162 iter->max_part = 3;
163 ret = -ENOENT;
164 }
165
Simon Glass201417d2022-04-24 23:31:07 -0600166 return log_msg_ret("part", ret);
Simon Glass76afc842023-04-28 13:18:09 -0600167 }
Simon Glass201417d2022-04-24 23:31:07 -0600168
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
Nam Cao11324712024-02-21 13:41:44 +0100175 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 */
Simon Glassf0e358f2023-01-17 10:47:42 -0700179 iter->first_bootable = part_get_bootable(desc);
180 log_debug("checking bootable=%d\n", iter->first_bootable);
Simon Glass831405f2023-08-24 13:55:43 -0600181 } 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 */
Simon Glassf0e358f2023-01-17 10:47:42 -0700186
187 /* if there are bootable partitions, scan only those */
Simon Glass831405f2023-08-24 13:55:43 -0600188 } else if (iter->first_bootable >= 0 &&
189 (iter->first_bootable ? !info.bootable : iter->part != 1)) {
Simon Glassf0e358f2023-01-17 10:47:42 -0700190 return log_msg_ret("boot", -EINVAL);
191 } else {
Simon Glass201417d2022-04-24 23:31:07 -0600192 ret = fs_set_blk_dev_with_part(desc, bflow->part);
193 bflow->state = BOOTFLOWST_PART;
Simon Glass1aabe4e2023-04-24 13:49:49 +1200194 if (ret)
195 return log_msg_ret("fs", ret);
Simon Glass201417d2022-04-24 23:31:07 -0600196
Simon Glass201417d2022-04-24 23:31:07 -0600197 log_debug("%s: Found partition %x type %x fstype %d\n",
Simon Glassb2b7e6c2023-08-24 13:55:33 -0600198 blk->name, bflow->part,
199 IS_ENABLED(CONFIG_DOS_PARTITION) ?
200 disk_partition_sys_ind(&info) : 0,
Simon Glass201417d2022-04-24 23:31:07 -0600201 ret ? -1 : fs_get_type());
Simon Glass1aabe4e2023-04-24 13:49:49 +1200202 bflow->blk = blk;
Simon Glass201417d2022-04-24 23:31:07 -0600203 bflow->state = BOOTFLOWST_FS;
204 }
205
Simon Glass831405f2023-08-24 13:55:43 -0600206 log_debug("method %s\n", bflow->method->name);
Simon Glassa8f5be12022-04-24 23:31:09 -0600207 ret = bootmeth_read_bootflow(bflow->method, bflow);
208 if (ret)
209 return log_msg_ret("method", ret);
210
Simon Glass201417d2022-04-24 23:31:07 -0600211 return 0;
212}
213
214void 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)
Michal Suchanek28a22cd2022-10-12 21:57:53 +0200223 ret = uclass_first_device_check(UCLASS_BOOTDEV, &dev);
Simon Glass201417d2022-04-24 23:31:07 -0600224 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) ? '+' : ' ',
Heinrich Schuchardtca9d9262023-07-30 16:29:25 +0200229 ret ? simple_itoa(-ret) : "OK",
Simon Glass201417d2022-04-24 23:31:07 -0600230 dev_get_uclass_name(dev_get_parent(dev)), dev->name);
231 if (probe)
Michal Suchanek28a22cd2022-10-12 21:57:53 +0200232 ret = uclass_next_device_check(&dev);
Simon Glass201417d2022-04-24 23:31:07 -0600233 else
234 ret = uclass_find_next_device(&dev);
235 }
236 printf("--- ------ ------ -------- ------------------\n");
237 printf("(%d bootdev%s)\n", i, i != 1 ? "s" : "");
238}
239
240int 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
Simon Glass3a2cb96e52023-01-17 10:47:25 -0700263static 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
Simon Glassd7d78572023-07-30 11:15:14 -0600275int bootdev_setup_for_sibling_blk(struct udevice *blk, const char *drv_name)
Simon Glass201417d2022-04-24 23:31:07 -0600276{
277 struct udevice *parent, *dev;
278 char dev_name[50];
Simon Glass3a2cb96e52023-01-17 10:47:25 -0700279 int ret, len;
Simon Glass201417d2022-04-24 23:31:07 -0600280
Simon Glass3a2cb96e52023-01-17 10:47:25 -0700281 len = bootdev_get_suffix_start(blk, ".blk");
282 snprintf(dev_name, sizeof(dev_name), "%.*s.%s", len, blk->name,
283 "bootdev");
Simon Glass201417d2022-04-24 23:31:07 -0600284
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
309int 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;
Simon Glass201417d2022-04-24 23:31:07 -0600314
315 if (device_get_uclass_id(dev) != UCLASS_BOOTDEV)
316 return -EINVAL;
317
Simon Glassd7d78572023-07-30 11:15:14 -0600318 /*
319 * This should always work if bootdev_setup_for_sibling_blk() was used
320 */
Simon Glass3a2cb96e52023-01-17 10:47:25 -0700321 len = bootdev_get_suffix_start(dev, ".bootdev");
Simon Glass201417d2022-04-24 23:31:07 -0600322 ret = device_find_child_by_namelen(parent, dev->name, len, &blk);
Simon Glass3a2cb96e52023-01-17 10:47:25 -0700323 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 }
Simon Glass965020c2023-01-28 15:00:19 -0700332 ret = device_probe(blk);
333 if (ret)
334 return log_msg_ret("act", ret);
Simon Glass201417d2022-04-24 23:31:07 -0600335 *blkp = blk;
336
337 return 0;
338}
339
340static 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];
Simon Glass3a2cb96e52023-01-17 10:47:25 -0700345 int ret, len;
Simon Glass201417d2022-04-24 23:31:07 -0600346
347 if (device_get_uclass_id(blk) != UCLASS_BLK)
348 return -EINVAL;
349
Simon Glassd7d78572023-07-30 11:15:14 -0600350 /* This should always work if bootdev_setup_for_sibling_blk() was used */
Simon Glass3a2cb96e52023-01-17 10:47:25 -0700351 len = bootdev_get_suffix_start(blk, ".blk");
352 snprintf(dev_name, sizeof(dev_name), "%.*s.%s", len, blk->name,
353 "bootdev");
Simon Glass201417d2022-04-24 23:31:07 -0600354 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
362int 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/**
Simon Glass74ebfb62023-01-17 10:48:00 -0700381 * 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
Simon Glassd9f48572023-01-17 10:48:05 -0700385 * @method_flagsp: If non-NULL, returns any flags implied by the label
386 * (enum bootflow_meth_flags_t), 0 if none
Simon Glass1736b4a2023-04-24 13:49:47 +1200387 * Returns: sequence number on success, -EPFNOSUPPORT is the uclass is not
388 * known, other -ve error code on other error
Simon Glass74ebfb62023-01-17 10:48:00 -0700389 */
Simon Glassd9f48572023-01-17 10:48:05 -0700390static int label_to_uclass(const char *label, int *seqp, int *method_flagsp)
Simon Glass74ebfb62023-01-17 10:48:00 -0700391{
Simon Glassd9f48572023-01-17 10:48:05 -0700392 int seq, len, method_flags;
Simon Glass74ebfb62023-01-17 10:48:00 -0700393 enum uclass_id id;
394 const char *end;
Simon Glass74ebfb62023-01-17 10:48:00 -0700395
Simon Glassd9f48572023-01-17 10:48:05 -0700396 method_flags = 0;
Simon Glass74ebfb62023-01-17 10:48:00 -0700397 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) {
Simon Glass0c1f4a92023-01-17 10:48:03 -0700405 /* try some special cases */
406 if (IS_ENABLED(CONFIG_BOOTDEV_SPI_FLASH) &&
407 !strncmp("spi", label, len)) {
408 id = UCLASS_SPI_FLASH;
Simon Glassd9f48572023-01-17 10:48:05 -0700409 } 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;
Simon Glass0c1f4a92023-01-17 10:48:03 -0700417 } else {
Simon Glass1736b4a2023-04-24 13:49:47 +1200418 return -EPFNOSUPPORT;
Simon Glass0c1f4a92023-01-17 10:48:03 -0700419 }
Simon Glass74ebfb62023-01-17 10:48:00 -0700420 }
421 if (id == UCLASS_USB)
422 id = UCLASS_MASS_STORAGE;
423 *seqp = seq;
Simon Glassd9f48572023-01-17 10:48:05 -0700424 if (method_flagsp)
425 *method_flagsp = method_flags;
Simon Glass74ebfb62023-01-17 10:48:00 -0700426
427 return id;
428}
429
Simon Glassd9f48572023-01-17 10:48:05 -0700430int bootdev_find_by_label(const char *label, struct udevice **devp,
431 int *method_flagsp)
Simon Glass201417d2022-04-24 23:31:07 -0600432{
Simon Glassd9f48572023-01-17 10:48:05 -0700433 int seq, ret, method_flags = 0;
Simon Glass201417d2022-04-24 23:31:07 -0600434 struct udevice *media;
435 struct uclass *uc;
436 enum uclass_id id;
Simon Glass201417d2022-04-24 23:31:07 -0600437
Simon Glassd9f48572023-01-17 10:48:05 -0700438 ret = label_to_uclass(label, &seq, &method_flags);
Simon Glass74ebfb62023-01-17 10:48:00 -0700439 if (ret < 0)
440 return log_msg_ret("uc", ret);
441 id = ret;
Simon Glass201417d2022-04-24 23:31:07 -0600442
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;
Simon Glass66e3dce2023-01-17 10:48:09 -0700468
469 /*
470 * if no sequence number was provided, we must scan all
471 * bootdevs for this media uclass
472 */
Simon Glasse824d0d2023-09-23 14:50:15 -0600473 if (seq == -1)
Simon Glass66e3dce2023-01-17 10:48:09 -0700474 method_flags |= BOOTFLOW_METHF_SINGLE_UCLASS;
Simon Glassd9f48572023-01-17 10:48:05 -0700475 if (method_flagsp)
476 *method_flagsp = method_flags;
Simon Glasse824d0d2023-09-23 14:50:15 -0600477 log_debug("method flags %x\n", method_flags);
Simon Glass201417d2022-04-24 23:31:07 -0600478 return 0;
479 }
480 log_debug("- no device in %s\n", media->name);
481 }
Simon Glass201417d2022-04-24 23:31:07 -0600482
483 return -ENOENT;
484}
485
Simon Glassd9f48572023-01-17 10:48:05 -0700486int bootdev_find_by_any(const char *name, struct udevice **devp,
487 int *method_flagsp)
Simon Glass201417d2022-04-24 23:31:07 -0600488{
489 struct udevice *dev;
Simon Glassd9f48572023-01-17 10:48:05 -0700490 int method_flags = 0;
Simon Glass66e3dce2023-01-17 10:48:09 -0700491 int ret = -ENODEV, seq;
Simon Glass201417d2022-04-24 23:31:07 -0600492 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) {
Simon Glassd9f48572023-01-17 10:48:05 -0700500 ret = bootdev_find_by_label(name, &dev, &method_flags);
Simon Glass201417d2022-04-24 23:31:07 -0600501 if (ret) {
502 printf("Cannot find bootdev '%s' (err=%d)\n",
503 name, ret);
Simon Glassd9f48572023-01-17 10:48:05 -0700504 return log_msg_ret("lab", ret);
Simon Glass201417d2022-04-24 23:31:07 -0600505 }
506 ret = device_probe(dev);
507 }
508 if (ret) {
509 printf("Cannot probe bootdev '%s' (err=%d)\n", name,
510 ret);
Simon Glassd9f48572023-01-17 10:48:05 -0700511 return log_msg_ret("pro", ret);
Simon Glass201417d2022-04-24 23:31:07 -0600512 }
Simon Glass66e3dce2023-01-17 10:48:09 -0700513 } else if (IS_ENABLED(CONFIG_BOOTSTD_FULL)) {
Simon Glass201417d2022-04-24 23:31:07 -0600514 ret = uclass_get_device_by_seq(UCLASS_BOOTDEV, seq, &dev);
Simon Glass66e3dce2023-01-17 10:48:09 -0700515 method_flags |= BOOTFLOW_METHF_SINGLE_DEV;
Simon Glass201417d2022-04-24 23:31:07 -0600516 }
517 if (ret) {
518 printf("Cannot find '%s' (err=%d)\n", name, ret);
519 return ret;
520 }
521
522 *devp = dev;
Simon Glassd9f48572023-01-17 10:48:05 -0700523 if (method_flagsp)
524 *method_flagsp = method_flags;
Simon Glass201417d2022-04-24 23:31:07 -0600525
526 return 0;
527}
528
Simon Glass66e3dce2023-01-17 10:48:09 -0700529int 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
Simon Glassb85fc8d2023-01-17 10:47:26 -0700544static 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);
Simon Glass3500ae12023-07-30 11:15:16 -0600551 log_debug("sibling_blk ret=%d, blk=%s\n", ret,
552 ret ? "(none)" : blk->name);
Simon Glassb85fc8d2023-01-17 10:47:26 -0700553 /*
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
Simon Glass201417d2022-04-24 23:31:07 -0600569int 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
Simon Glass831405f2023-08-24 13:55:43 -0600574 log_debug("->get_bootflow %s,%x=%p\n", dev->name, iter->part,
575 ops->get_bootflow);
Simon Glassb190deb2022-10-20 18:22:51 -0600576 bootflow_init(bflow, dev, iter->method);
Simon Glassb85fc8d2023-01-17 10:47:26 -0700577 if (!ops->get_bootflow)
578 return default_get_bootflow(dev, iter, bflow);
Simon Glass201417d2022-04-24 23:31:07 -0600579
580 return ops->get_bootflow(dev, iter, bflow);
581}
582
583void 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);
Simon Glassa8f5be12022-04-24 23:31:09 -0600592 bootflow_remove(bflow);
Simon Glass201417d2022-04-24 23:31:07 -0600593 }
594}
595
Simon Glasse4b69482023-01-17 10:48:10 -0700596int 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];) {
Simon Glass1736b4a2023-04-24 13:49:47 +1200603 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
Simon Glasse4b69482023-01-17 10:48:10 -0700625 }
626
627 if (!dev)
628 return log_msg_ret("fin", -ENODEV);
629 *devp = dev;
630
631 return 0;
632}
633
Simon Glass43e89a32023-01-17 10:48:11 -0700634int bootdev_next_prio(struct bootflow_iter *iter, struct udevice **devp)
635{
Caleb Connolly9d92c412024-01-04 16:03:35 +0000636 struct udevice *dev = *devp, *last_dev = NULL;
Simon Glass43e89a32023-01-17 10:48:11 -0700637 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
Simon Glass4f806f32023-02-22 12:17:03 -0700674 if (iter->flags & BOOTFLOWIF_HUNT) {
Simon Glass43e89a32023-01-17 10:48:11 -0700675 /* hunt to find new bootdevs */
676 ret = bootdev_hunt_prio(iter->cur_prio,
677 iter->flags &
Simon Glass4f806f32023-02-22 12:17:03 -0700678 BOOTFLOWIF_SHOW);
Simon Glass3500ae12023-07-30 11:15:16 -0600679 log_debug("- bootdev_hunt_prio() ret %d\n",
680 ret);
Simon Glass43e89a32023-01-17 10:48:11 -0700681 if (ret)
682 return log_msg_ret("hun", ret);
683 }
684 } else {
685 ret = device_probe(dev);
Caleb Connolly9d92c412024-01-04 16:03:35 +0000686 if (!ret)
687 last_dev = dev;
Simon Glass43e89a32023-01-17 10:48:11 -0700688 if (ret) {
Caleb Connolly9d92c412024-01-04 16:03:35 +0000689 log_warning("Device '%s' failed to probe\n",
Simon Glass43e89a32023-01-17 10:48:11 -0700690 dev->name);
Caleb Connolly9d92c412024-01-04 16:03:35 +0000691 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;
Simon Glass43e89a32023-01-17 10:48:11 -0700699 dev = NULL;
700 }
701 }
702 } while (!dev);
703
704 *devp = dev;
705
706 return 0;
707}
708
Simon Glass91943ff2023-01-17 10:48:15 -0700709int bootdev_setup_iter(struct bootflow_iter *iter, const char *label,
710 struct udevice **devp, int *method_flagsp)
Simon Glass201417d2022-04-24 23:31:07 -0600711{
Simon Glass91943ff2023-01-17 10:48:15 -0700712 struct udevice *bootstd, *dev = NULL;
Simon Glass4f806f32023-02-22 12:17:03 -0700713 bool show = iter->flags & BOOTFLOWIF_SHOW;
Simon Glass47aedc22023-01-17 10:48:14 -0700714 int method_flags;
Nam Cao11324712024-02-21 13:41:44 +0100715 char buf[32];
Simon Glass201417d2022-04-24 23:31:07 -0600716 int ret;
717
Nam Cao11324712024-02-21 13:41:44 +0100718 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
Simon Glass201417d2022-04-24 23:31:07 -0600746 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
Simon Glasseacc2612023-01-17 10:48:08 -0700752 /* hunt for any pre-scan devices */
Simon Glass4f806f32023-02-22 12:17:03 -0700753 if (iter->flags & BOOTFLOWIF_HUNT) {
Simon Glasseacc2612023-01-17 10:48:08 -0700754 ret = bootdev_hunt_prio(BOOTDEVP_1_PRE_SCAN, show);
Simon Glass3500ae12023-07-30 11:15:16 -0600755 log_debug("- bootdev_hunt_prio() ret %d\n", ret);
Simon Glasseacc2612023-01-17 10:48:08 -0700756 if (ret)
757 return log_msg_ret("pre", ret);
758 }
759
Simon Glass201417d2022-04-24 23:31:07 -0600760 /* Handle scanning a single device */
Simon Glass91943ff2023-01-17 10:48:15 -0700761 if (IS_ENABLED(CONFIG_BOOTSTD_FULL) && label) {
Simon Glass4f806f32023-02-22 12:17:03 -0700762 if (iter->flags & BOOTFLOWIF_HUNT) {
Simon Glass91943ff2023-01-17 10:48:15 -0700763 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)
Simon Glass4f806f32023-02-22 12:17:03 -0700773 iter->flags |= BOOTFLOWIF_SINGLE_UCLASS;
Simon Glass91943ff2023-01-17 10:48:15 -0700774 else if (method_flags & BOOTFLOW_METHF_SINGLE_DEV)
Simon Glass4f806f32023-02-22 12:17:03 -0700775 iter->flags |= BOOTFLOWIF_SINGLE_DEV;
Simon Glass91943ff2023-01-17 10:48:15 -0700776 else
Simon Glass4f806f32023-02-22 12:17:03 -0700777 iter->flags |= BOOTFLOWIF_SINGLE_MEDIA;
Simon Glass91943ff2023-01-17 10:48:15 -0700778 log_debug("Selected label: %s, flags %x\n", label, iter->flags);
Simon Glass47aedc22023-01-17 10:48:14 -0700779 } 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);
Simon Glass201417d2022-04-24 23:31:07 -0600797 }
798
Simon Glass201417d2022-04-24 23:31:07 -0600799 ret = device_probe(dev);
800 if (ret)
801 return log_msg_ret("probe", ret);
Simon Glass47aedc22023-01-17 10:48:14 -0700802 if (method_flagsp)
803 *method_flagsp = method_flags;
Simon Glass201417d2022-04-24 23:31:07 -0600804 *devp = dev;
805
806 return 0;
807}
808
Simon Glassc7b63d52023-01-17 10:47:34 -0700809static 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);
Simon Glass3500ae12023-07-30 11:15:16 -0600826 log_debug(" - hunt result %d\n", ret);
Tony Dinhee2ce292023-11-02 11:51:15 -0700827 if (ret && ret != -ENOENT)
Simon Glassc7b63d52023-01-17 10:47:34 -0700828 return ret;
829 }
830 std->hunters_used |= BIT(seq);
831 }
832
833 return 0;
834}
835
836int 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);
Simon Glasse4b69482023-01-17 10:48:10 -0700861 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 }
Simon Glassc7b63d52023-01-17 10:47:34 -0700866 ret = bootdev_hunt_drv(info, i, show);
867 if (ret)
868 result = ret;
869 }
870
871 return result;
872}
873
Simon Glass1b1d36e2023-09-20 07:29:49 -0600874int 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
Simon Glass79a7d4a2023-01-17 10:48:07 -0700901int 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);
Simon Glass3500ae12023-07-30 11:15:16 -0600919 log_debug("bootdev_hunt_drv() return %d\n", ret);
Simon Glass79a7d4a2023-01-17 10:48:07 -0700920 if (ret && ret != -ENOENT)
921 result = ret;
922 }
Simon Glass3500ae12023-07-30 11:15:16 -0600923 log_debug("exit %d\n", result);
Simon Glass79a7d4a2023-01-17 10:48:07 -0700924
925 return result;
926}
927
Simon Glassbd90b092023-01-17 10:47:33 -0700928void 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
Simon Glass201417d2022-04-24 23:31:07 -0600959static 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
968static int bootdev_pre_unbind(struct udevice *dev)
969{
970 bootdev_clear_bootflows(dev);
971
972 return 0;
973}
974
975UCLASS_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};