blob: 0345755f58fccb41340375c2c1eb415919014f50 [file] [log] [blame]
// 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);
}
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;
}