| // SPDX-License-Identifier: GPL-2.0+ |
| /* |
| * Copyright 2021 Google LLC |
| * Written by Simon Glass <sjg@chromium.org> |
| */ |
| |
| #define LOG_CATEGORY UCLASS_BOOTSTD |
| |
| #include <common.h> |
| #include <bootdev.h> |
| #include <bootflow.h> |
| #include <bootmeth.h> |
| #include <bootstd.h> |
| #include <dm.h> |
| #include <malloc.h> |
| #include <dm/device-internal.h> |
| #include <dm/uclass-internal.h> |
| |
| /* error codes used to signal running out of things */ |
| enum { |
| BF_NO_MORE_PARTS = -ESHUTDOWN, |
| BF_NO_MORE_DEVICES = -ENODEV, |
| }; |
| |
| /** |
| * bootflow_state - name for each state |
| * |
| * See enum bootflow_state_t for what each of these means |
| */ |
| static const char *const bootflow_state[BOOTFLOWST_COUNT] = { |
| "base", |
| "media", |
| "part", |
| "fs", |
| "file", |
| "ready", |
| }; |
| |
| const char *bootflow_state_get_name(enum bootflow_state_t state) |
| { |
| /* This doesn't need to be a useful name, since it will never occur */ |
| if (state < 0 || state >= BOOTFLOWST_COUNT) |
| return "?"; |
| |
| return bootflow_state[state]; |
| } |
| |
| int bootflow_first_glob(struct bootflow **bflowp) |
| { |
| struct bootstd_priv *std; |
| int ret; |
| |
| ret = bootstd_get_priv(&std); |
| if (ret) |
| return ret; |
| |
| if (list_empty(&std->glob_head)) |
| return -ENOENT; |
| |
| *bflowp = list_first_entry(&std->glob_head, struct bootflow, |
| glob_node); |
| |
| return 0; |
| } |
| |
| int bootflow_next_glob(struct bootflow **bflowp) |
| { |
| struct bootstd_priv *std; |
| struct bootflow *bflow = *bflowp; |
| int ret; |
| |
| ret = bootstd_get_priv(&std); |
| if (ret) |
| return ret; |
| |
| *bflowp = NULL; |
| |
| if (list_is_last(&bflow->glob_node, &std->glob_head)) |
| return -ENOENT; |
| |
| *bflowp = list_entry(bflow->glob_node.next, struct bootflow, glob_node); |
| |
| return 0; |
| } |
| |
| void bootflow_iter_init(struct bootflow_iter *iter, int flags) |
| { |
| memset(iter, '\0', sizeof(*iter)); |
| iter->first_glob_method = -1; |
| iter->flags = flags; |
| } |
| |
| void bootflow_iter_uninit(struct bootflow_iter *iter) |
| { |
| free(iter->dev_order); |
| free(iter->method_order); |
| } |
| |
| int bootflow_iter_drop_bootmeth(struct bootflow_iter *iter, |
| const struct udevice *bmeth) |
| { |
| /* We only support disabling the current bootmeth */ |
| if (bmeth != iter->method || iter->cur_method >= iter->num_methods || |
| iter->method_order[iter->cur_method] != bmeth) |
| return -EINVAL; |
| |
| memmove(&iter->method_order[iter->cur_method], |
| &iter->method_order[iter->cur_method + 1], |
| (iter->num_methods - iter->cur_method - 1) * sizeof(void *)); |
| |
| iter->num_methods--; |
| |
| return 0; |
| } |
| |
| static void bootflow_iter_set_dev(struct bootflow_iter *iter, |
| struct udevice *dev) |
| { |
| struct bootmeth_uc_plat *ucp = dev_get_uclass_plat(iter->method); |
| |
| iter->dev = dev; |
| if ((iter->flags & (BOOTFLOWF_SHOW | BOOTFLOWF_SINGLE_DEV)) == |
| BOOTFLOWF_SHOW) { |
| if (dev) |
| printf("Scanning bootdev '%s':\n", dev->name); |
| else if (IS_ENABLED(CONFIG_BOOTMETH_GLOBAL) && |
| ucp->flags & BOOTMETHF_GLOBAL) |
| printf("Scanning global bootmeth '%s':\n", |
| iter->method->name); |
| else |
| printf("No more bootdevs\n"); |
| } |
| } |
| |
| /** |
| * iter_incr() - Move to the next item (method, part, bootdev) |
| * |
| * Return: 0 if OK, BF_NO_MORE_DEVICES if there are no more bootdevs |
| */ |
| static int iter_incr(struct bootflow_iter *iter) |
| { |
| struct udevice *dev; |
| bool inc_dev = true; |
| bool global; |
| int ret; |
| |
| global = iter->doing_global; |
| |
| if (iter->err == BF_NO_MORE_DEVICES) |
| return BF_NO_MORE_DEVICES; |
| |
| if (iter->err != BF_NO_MORE_PARTS) { |
| /* Get the next boothmethod */ |
| if (++iter->cur_method < iter->num_methods) { |
| iter->method = iter->method_order[iter->cur_method]; |
| return 0; |
| } |
| |
| /* |
| * If we have finished scanning the global bootmeths, start the |
| * normal bootdev scan |
| */ |
| if (IS_ENABLED(CONFIG_BOOTMETH_GLOBAL) && global) { |
| iter->num_methods = iter->first_glob_method; |
| iter->doing_global = false; |
| |
| /* |
| * Don't move to the next dev as we haven't tried this |
| * one yet! |
| */ |
| inc_dev = false; |
| } |
| } |
| |
| /* No more bootmeths; start at the first one, and... */ |
| iter->cur_method = 0; |
| iter->method = iter->method_order[iter->cur_method]; |
| |
| if (iter->err != BF_NO_MORE_PARTS) { |
| /* ...select next partition */ |
| if (++iter->part <= iter->max_part) |
| return 0; |
| } |
| |
| /* No more partitions; start at the first one and...*/ |
| iter->part = 0; |
| |
| /* |
| * Note: as far as we know, there is no partition table on the next |
| * bootdev, so set max_part to 0 until we discover otherwise. See |
| * bootdev_find_in_blk() for where this is set. |
| */ |
| iter->max_part = 0; |
| |
| /* ...select next bootdev */ |
| if (iter->flags & BOOTFLOWF_SINGLE_DEV) { |
| ret = -ENOENT; |
| } else { |
| if (inc_dev) |
| iter->cur_dev++; |
| if (iter->cur_dev == iter->num_devs) { |
| ret = -ENOENT; |
| bootflow_iter_set_dev(iter, NULL); |
| } else { |
| dev = iter->dev_order[iter->cur_dev]; |
| ret = device_probe(dev); |
| if (!log_msg_ret("probe", ret)) |
| bootflow_iter_set_dev(iter, dev); |
| } |
| } |
| |
| /* if there are no more bootdevs, give up */ |
| if (ret) |
| return log_msg_ret("incr", BF_NO_MORE_DEVICES); |
| |
| return 0; |
| } |
| |
| /** |
| * bootflow_check() - Check if a bootflow can be obtained |
| * |
| * @iter: Provides part, bootmeth to use |
| * @bflow: Bootflow to update on success |
| * Return: 0 if OK, -ENOSYS if there is no bootflow support on this device, |
| * BF_NO_MORE_PARTS if there are no more partitions on bootdev |
| */ |
| static int bootflow_check(struct bootflow_iter *iter, struct bootflow *bflow) |
| { |
| struct udevice *dev; |
| int ret; |
| |
| if (IS_ENABLED(CONFIG_BOOTMETH_GLOBAL) && iter->doing_global) { |
| bootflow_iter_set_dev(iter, NULL); |
| ret = bootmeth_get_bootflow(iter->method, bflow); |
| if (ret) |
| return log_msg_ret("glob", ret); |
| |
| return 0; |
| } |
| |
| dev = iter->dev; |
| ret = bootdev_get_bootflow(dev, iter, bflow); |
| |
| /* If we got a valid bootflow, return it */ |
| if (!ret) { |
| log_debug("Bootdevice '%s' part %d method '%s': Found bootflow\n", |
| dev->name, iter->part, iter->method->name); |
| return 0; |
| } |
| |
| /* Unless there is nothing more to try, move to the next device */ |
| else if (ret != BF_NO_MORE_PARTS && ret != -ENOSYS) { |
| log_debug("Bootdevice '%s' part %d method '%s': Error %d\n", |
| dev->name, iter->part, iter->method->name, ret); |
| /* |
| * For 'all' we return all bootflows, even |
| * those with errors |
| */ |
| if (iter->flags & BOOTFLOWF_ALL) |
| return log_msg_ret("all", ret); |
| } |
| if (ret) |
| return log_msg_ret("check", ret); |
| |
| return 0; |
| } |
| |
| int bootflow_scan_bootdev(struct udevice *dev, struct bootflow_iter *iter, |
| int flags, struct bootflow *bflow) |
| { |
| int ret; |
| |
| if (dev) |
| flags |= BOOTFLOWF_SKIP_GLOBAL; |
| bootflow_iter_init(iter, flags); |
| |
| ret = bootdev_setup_iter_order(iter, &dev); |
| if (ret) |
| return log_msg_ret("obdev", -ENODEV); |
| |
| ret = bootmeth_setup_iter_order(iter, !(flags & BOOTFLOWF_SKIP_GLOBAL)); |
| if (ret) |
| return log_msg_ret("obmeth", -ENODEV); |
| |
| /* Find the first bootmeth (there must be at least one!) */ |
| iter->method = iter->method_order[iter->cur_method]; |
| if (!IS_ENABLED(CONFIG_BOOTMETH_GLOBAL) || !iter->doing_global) |
| bootflow_iter_set_dev(iter, dev); |
| |
| ret = bootflow_check(iter, bflow); |
| if (ret) { |
| if (ret != BF_NO_MORE_PARTS && ret != -ENOSYS) { |
| if (iter->flags & BOOTFLOWF_ALL) |
| return log_msg_ret("all", ret); |
| } |
| iter->err = ret; |
| ret = bootflow_scan_next(iter, bflow); |
| if (ret) |
| return log_msg_ret("get", ret); |
| } |
| |
| return 0; |
| } |
| |
| int bootflow_scan_first(struct bootflow_iter *iter, int flags, |
| struct bootflow *bflow) |
| { |
| int ret; |
| |
| ret = bootflow_scan_bootdev(NULL, iter, flags, bflow); |
| if (ret) |
| return log_msg_ret("start", ret); |
| |
| return 0; |
| } |
| |
| int bootflow_scan_next(struct bootflow_iter *iter, struct bootflow *bflow) |
| { |
| int ret; |
| |
| do { |
| ret = iter_incr(iter); |
| if (ret == BF_NO_MORE_DEVICES) |
| return log_msg_ret("done", ret); |
| |
| if (!ret) { |
| ret = bootflow_check(iter, bflow); |
| if (!ret) |
| return 0; |
| iter->err = ret; |
| if (ret != BF_NO_MORE_PARTS && ret != -ENOSYS) { |
| if (iter->flags & BOOTFLOWF_ALL) |
| return log_msg_ret("all", ret); |
| } |
| } else { |
| iter->err = ret; |
| } |
| |
| } while (1); |
| } |
| |
| void bootflow_init(struct bootflow *bflow, struct udevice *bootdev, |
| struct udevice *meth) |
| { |
| memset(bflow, '\0', sizeof(*bflow)); |
| bflow->dev = bootdev; |
| bflow->method = meth; |
| bflow->state = BOOTFLOWST_BASE; |
| } |
| |
| void bootflow_free(struct bootflow *bflow) |
| { |
| free(bflow->name); |
| free(bflow->subdir); |
| free(bflow->fname); |
| free(bflow->buf); |
| free(bflow->os_name); |
| free(bflow->fdt_fname); |
| } |
| |
| void bootflow_remove(struct bootflow *bflow) |
| { |
| if (bflow->dev) |
| list_del(&bflow->bm_node); |
| list_del(&bflow->glob_node); |
| |
| bootflow_free(bflow); |
| free(bflow); |
| } |
| |
| int bootflow_boot(struct bootflow *bflow) |
| { |
| int ret; |
| |
| if (bflow->state != BOOTFLOWST_READY) |
| return log_msg_ret("load", -EPROTO); |
| |
| ret = bootmeth_boot(bflow->method, bflow); |
| if (ret) |
| return log_msg_ret("boot", ret); |
| |
| /* |
| * internal error, should not get here since we should have booted |
| * something or returned an error |
| */ |
| |
| return log_msg_ret("end", -EFAULT); |
| } |
| |
| int bootflow_run_boot(struct bootflow_iter *iter, struct bootflow *bflow) |
| { |
| int ret; |
| |
| printf("** Booting bootflow '%s' with %s\n", bflow->name, |
| bflow->method->name); |
| ret = bootflow_boot(bflow); |
| if (!IS_ENABLED(CONFIG_BOOTSTD_FULL)) { |
| printf("Boot failed (err=%d)\n", ret); |
| return ret; |
| } |
| |
| switch (ret) { |
| case -EPROTO: |
| printf("Bootflow not loaded (state '%s')\n", |
| bootflow_state_get_name(bflow->state)); |
| break; |
| case -ENOSYS: |
| printf("Boot method '%s' not supported\n", bflow->method->name); |
| break; |
| case -ENOTSUPP: |
| /* Disable this bootflow for this iteration */ |
| if (iter) { |
| int ret2; |
| |
| ret2 = bootflow_iter_drop_bootmeth(iter, bflow->method); |
| if (!ret2) { |
| printf("Boot method '%s' failed and will not be retried\n", |
| bflow->method->name); |
| } |
| } |
| |
| break; |
| default: |
| printf("Boot failed (err=%d)\n", ret); |
| break; |
| } |
| |
| return ret; |
| } |
| |
| int bootflow_iter_check_blk(const struct bootflow_iter *iter) |
| { |
| const struct udevice *media = dev_get_parent(iter->dev); |
| enum uclass_id id = device_get_uclass_id(media); |
| |
| log_debug("uclass %d: %s\n", id, uclass_get_name(id)); |
| if (id != UCLASS_ETH && id != UCLASS_BOOTSTD) |
| return 0; |
| |
| return -ENOTSUPP; |
| } |
| |
| int bootflow_iter_check_net(const struct bootflow_iter *iter) |
| { |
| const struct udevice *media = dev_get_parent(iter->dev); |
| enum uclass_id id = device_get_uclass_id(media); |
| |
| log_debug("uclass %d: %s\n", id, uclass_get_name(id)); |
| if (id == UCLASS_ETH) |
| return 0; |
| |
| return -ENOTSUPP; |
| } |
| |
| int bootflow_iter_check_system(const struct bootflow_iter *iter) |
| { |
| const struct udevice *media = dev_get_parent(iter->dev); |
| enum uclass_id id = device_get_uclass_id(media); |
| |
| log_debug("uclass %d: %s\n", id, uclass_get_name(id)); |
| if (id == UCLASS_BOOTSTD) |
| return 0; |
| |
| return -ENOTSUPP; |
| } |