Mirrors/u-boot
2
0
Fork 0
mirror of https://github.com/AsahiLinux/u-boot synced 2024-12-03 18:10:13 +00:00
Code Issues Projects Releases Packages Wiki Activity
u-boot/boot/bootmeth-uclass.c

454 lines
9.7 KiB
C
Raw Normal View History

bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
// 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 <blk.h>
#include <bootflow.h>
#include <bootmeth.h>
#include <bootstd.h>
#include <dm.h>
#include <env_internal.h>
#include <fs.h>
#include <malloc.h>
#include <mapmem.h>
#include <dm/uclass-internal.h>
DECLARE_GLOBAL_DATA_PTR;
bootstd: Provide a bootmeth method to obtain state info Some bootmeths can provide information about what is available to boot. For example, VBE simple provides access to the firmware state. Add a new method for this, along with a sandbox test. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-07-30 21:52:19 +00:00
int bootmeth_get_state_desc(struct udevice *dev, char *buf, int maxsize)
{
const struct bootmeth_ops *ops = bootmeth_get_ops(dev);
if (!ops->get_state_desc)
return -ENOSYS;
return ops->get_state_desc(dev, buf, maxsize);
}
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
int bootmeth_check(struct udevice *dev, struct bootflow_iter *iter)
{
const struct bootmeth_ops *ops = bootmeth_get_ops(dev);
if (!ops->check)
return 0;
return ops->check(dev, iter);
}
int bootmeth_read_bootflow(struct udevice *dev, struct bootflow *bflow)
{
const struct bootmeth_ops *ops = bootmeth_get_ops(dev);
if (!ops->read_bootflow)
return -ENOSYS;
return ops->read_bootflow(dev, bflow);
}
bootstd: Add a new bootmeth method to set the bootflow Normally the bootmeth driver reads the bootflow from the bootdev, since it knows the correct way to do it. However it is easier for some bootdevs to handle this themselves. For example, reading from SPI flash is quite different from other devices. Add a way for the bootdev to pass a bootflow to the bootmeth, so that this can be supported. Signed-off-by: Simon Glass <sjg@chromium.org>
2023-01-17 17:48:01 +00:00
int bootmeth_set_bootflow(struct udevice *dev, struct bootflow *bflow,
char *buf, int size)
{
const struct bootmeth_ops *ops = bootmeth_get_ops(dev);
if (!ops->set_bootflow)
return -ENOSYS;
return ops->set_bootflow(dev, bflow, buf, size);
}
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
int bootmeth_boot(struct udevice *dev, struct bootflow *bflow)
{
const struct bootmeth_ops *ops = bootmeth_get_ops(dev);
if (!ops->boot)
return -ENOSYS;
return ops->boot(dev, bflow);
}
int bootmeth_read_file(struct udevice *dev, struct bootflow *bflow,
const char *file_path, ulong addr, ulong *sizep)
{
const struct bootmeth_ops *ops = bootmeth_get_ops(dev);
if (!ops->read_file)
return -ENOSYS;
return ops->read_file(dev, bflow, file_path, addr, sizep);
}
bootstd: Allow bootmeths to be marked as global The current way of handling things like EFI bootmgr is a bit odd, since that bootmeth handles selection of the bootdev itself. VBE needs to work the same way, so we should support it properly. Add a flag that indicates that the bootmeth is global, rather than being invoked on each bootdev. Provide a helper to read a bootflow from the bootmeth. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-07-30 21:52:21 +00:00
int bootmeth_get_bootflow(struct udevice *dev, struct bootflow *bflow)
{
const struct bootmeth_ops *ops = bootmeth_get_ops(dev);
if (!ops->read_bootflow)
return -ENOSYS;
bootstd: Add a way to set up a bootflow Add a function to init a bootflow, to reduce code duplication. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-10-21 00:22:51 +00:00
bootflow_init(bflow, NULL, dev);
bootstd: Allow bootmeths to be marked as global The current way of handling things like EFI bootmgr is a bit odd, since that bootmeth handles selection of the bootdev itself. VBE needs to work the same way, so we should support it properly. Add a flag that indicates that the bootmeth is global, rather than being invoked on each bootdev. Provide a helper to read a bootflow from the bootmeth. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-07-30 21:52:21 +00:00
return ops->read_bootflow(dev, bflow);
}
bootstd: Allow scanning for global bootmeths separately Typically we want to find and use global bootmeths first, since they have the best idea of how the system should boot. We then use normal bootmeths as a fallback. Add the logic for this, putting global bootmeths at the end of the ordering. We can then easily scan the global bootmeths first, then drop them from the list for subsequent bootdev-centric scans. This changes the ordering of global bootmeths, so update the bootflow_system() accordingly. Drop the comment from bootmeth_setup_iter_order() since this is an exported function and it should be in the header file. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-07-30 21:52:27 +00:00
int bootmeth_setup_iter_order(struct bootflow_iter *iter, bool include_global)
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
{
struct bootstd_priv *std;
struct udevice **order;
int count;
int ret;
ret = bootstd_get_priv(&std);
if (ret)
return ret;
/* Create an array large enough */
count = std->bootmeth_count ? std->bootmeth_count :
uclass_id_count(UCLASS_BOOTMETH);
if (!count)
return log_msg_ret("count", -ENOENT);
order = calloc(count, sizeof(struct udevice *));
if (!order)
return log_msg_ret("order", -ENOMEM);
/* If we have an ordering, copy it */
if (IS_ENABLED(CONFIG_BOOTSTD_FULL) && std->bootmeth_count) {
bootstd: Allow scanning for global bootmeths separately Typically we want to find and use global bootmeths first, since they have the best idea of how the system should boot. We then use normal bootmeths as a fallback. Add the logic for this, putting global bootmeths at the end of the ordering. We can then easily scan the global bootmeths first, then drop them from the list for subsequent bootdev-centric scans. This changes the ordering of global bootmeths, so update the bootflow_system() accordingly. Drop the comment from bootmeth_setup_iter_order() since this is an exported function and it should be in the header file. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-07-30 21:52:27 +00:00
int i;
/*
* We don't support skipping global bootmeths. Instead, the user
* should omit them from the ordering
*/
if (!include_global)
return log_msg_ret("glob", -EPERM);
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
memcpy(order, std->bootmeth_order,
count * sizeof(struct bootmeth *));
bootstd: Allow scanning for global bootmeths separately Typically we want to find and use global bootmeths first, since they have the best idea of how the system should boot. We then use normal bootmeths as a fallback. Add the logic for this, putting global bootmeths at the end of the ordering. We can then easily scan the global bootmeths first, then drop them from the list for subsequent bootdev-centric scans. This changes the ordering of global bootmeths, so update the bootflow_system() accordingly. Drop the comment from bootmeth_setup_iter_order() since this is an exported function and it should be in the header file. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-07-30 21:52:27 +00:00
if (IS_ENABLED(CONFIG_BOOTMETH_GLOBAL)) {
for (i = 0; i < count; i++) {
struct udevice *dev = order[i];
struct bootmeth_uc_plat *ucp;
bool is_global;
ucp = dev_get_uclass_plat(dev);
is_global = ucp->flags &
BOOTMETHF_GLOBAL;
if (is_global) {
iter->first_glob_method = i;
break;
}
}
}
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
} else {
struct udevice *dev;
bootstd: Allow scanning for global bootmeths separately Typically we want to find and use global bootmeths first, since they have the best idea of how the system should boot. We then use normal bootmeths as a fallback. Add the logic for this, putting global bootmeths at the end of the ordering. We can then easily scan the global bootmeths first, then drop them from the list for subsequent bootdev-centric scans. This changes the ordering of global bootmeths, so update the bootflow_system() accordingly. Drop the comment from bootmeth_setup_iter_order() since this is an exported function and it should be in the header file. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-07-30 21:52:27 +00:00
int i, upto, pass;
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
/*
bootstd: Allow scanning for global bootmeths separately Typically we want to find and use global bootmeths first, since they have the best idea of how the system should boot. We then use normal bootmeths as a fallback. Add the logic for this, putting global bootmeths at the end of the ordering. We can then easily scan the global bootmeths first, then drop them from the list for subsequent bootdev-centric scans. This changes the ordering of global bootmeths, so update the bootflow_system() accordingly. Drop the comment from bootmeth_setup_iter_order() since this is an exported function and it should be in the header file. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-07-30 21:52:27 +00:00
* Do two passes, one to find the normal bootmeths and another
* to find the global ones, if required, The global ones go at
* the end.
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
*/
bootstd: Allow scanning for global bootmeths separately Typically we want to find and use global bootmeths first, since they have the best idea of how the system should boot. We then use normal bootmeths as a fallback. Add the logic for this, putting global bootmeths at the end of the ordering. We can then easily scan the global bootmeths first, then drop them from the list for subsequent bootdev-centric scans. This changes the ordering of global bootmeths, so update the bootflow_system() accordingly. Drop the comment from bootmeth_setup_iter_order() since this is an exported function and it should be in the header file. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-07-30 21:52:27 +00:00
for (pass = 0, upto = 0; pass < 1 + include_global; pass++) {
if (pass)
iter->first_glob_method = upto;
/*
* Get a list of bootmethods, in seq order (i.e. using
* aliases). There may be gaps so try to count up high
* enough to find them all.
*/
for (i = 0; upto < count && i < 20 + count * 2; i++) {
struct bootmeth_uc_plat *ucp;
bool is_global;
ret = uclass_get_device_by_seq(UCLASS_BOOTMETH,
i, &dev);
if (ret)
continue;
ucp = dev_get_uclass_plat(dev);
is_global =
IS_ENABLED(CONFIG_BOOTMETH_GLOBAL) &&
(ucp->flags & BOOTMETHF_GLOBAL);
if (pass ? is_global : !is_global)
order[upto++] = dev;
}
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
}
count = upto;
}
bootstd: Detect empty bootmeth ordering If the ordering produces no entries, this is an error. Report it, so that the caller doesn't try to continue with a NULL bootmeth. This fixes a crash in the bootflow_iter test when running with the sandbox 'default' device tree, instead of the required 'test' one. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-07-30 21:52:18 +00:00
if (!count)
return log_msg_ret("count2", -ENOENT);
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
bootstd: Allow scanning for global bootmeths separately Typically we want to find and use global bootmeths first, since they have the best idea of how the system should boot. We then use normal bootmeths as a fallback. Add the logic for this, putting global bootmeths at the end of the ordering. We can then easily scan the global bootmeths first, then drop them from the list for subsequent bootdev-centric scans. This changes the ordering of global bootmeths, so update the bootflow_system() accordingly. Drop the comment from bootmeth_setup_iter_order() since this is an exported function and it should be in the header file. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-07-30 21:52:27 +00:00
if (IS_ENABLED(CONFIG_BOOTMETH_GLOBAL) && include_global &&
iter->first_glob_method != -1 && iter->first_glob_method != count) {
iter->cur_method = iter->first_glob_method;
iter->doing_global = true;
}
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
iter->method_order = order;
iter->num_methods = count;
return 0;
}
int bootmeth_set_order(const char *order_str)
{
struct bootstd_priv *std;
struct udevice **order;
int count, ret, i, len;
const char *s, *p;
ret = bootstd_get_priv(&std);
if (ret)
return ret;
if (!order_str) {
free(std->bootmeth_order);
std->bootmeth_order = NULL;
std->bootmeth_count = 0;
return 0;
}
/* Create an array large enough */
count = uclass_id_count(UCLASS_BOOTMETH);
if (!count)
return log_msg_ret("count", -ENOENT);
order = calloc(count + 1, sizeof(struct udevice *));
if (!order)
return log_msg_ret("order", -ENOMEM);
for (i = 0, s = order_str; *s && i < count; s = p + (*p == ' '), i++) {
struct udevice *dev;
p = strchrnul(s, ' ');
len = p - s;
ret = uclass_find_device_by_namelen(UCLASS_BOOTMETH, s, len,
&dev);
if (ret) {
printf("Unknown bootmeth '%.*s'\n", len, s);
free(order);
return ret;
}
order[i] = dev;
}
order[i] = NULL;
free(std->bootmeth_order);
std->bootmeth_order = order;
std->bootmeth_count = i;
return 0;
}
/**
* setup_fs() - Set up read to read a file
*
* We must redo the setup before each filesystem operation. This function
* handles that, including setting the filesystem type if a block device is not
* being used
*
* @bflow: Information about file to try
* @desc: Block descriptor to read from (NULL if not a block device)
* Return: 0 if OK, -ve on error
*/
static int setup_fs(struct bootflow *bflow, struct blk_desc *desc)
{
int ret;
if (desc) {
ret = fs_set_blk_dev_with_part(desc, bflow->part);
if (ret)
return log_msg_ret("set", ret);
} else if (IS_ENABLED(CONFIG_BOOTSTD_FULL) && bflow->fs_type) {
fs_set_type(bflow->fs_type);
}
return 0;
}
int bootmeth_try_file(struct bootflow *bflow, struct blk_desc *desc,
const char *prefix, const char *fname)
{
char path[200];
loff_t size;
int ret, ret2;
snprintf(path, sizeof(path), "%s%s", prefix ? prefix : "", fname);
log_debug("trying: %s\n", path);
free(bflow->fname);
bflow->fname = strdup(path);
if (!bflow->fname)
return log_msg_ret("name", -ENOMEM);
if (IS_ENABLED(CONFIG_BOOTSTD_FULL) && bflow->fs_type)
fs_set_type(bflow->fs_type);
ret = fs_size(path, &size);
log_debug(" %s - err=%d\n", path, ret);
/* Sadly FS closes the file after fs_size() so we must redo this */
ret2 = setup_fs(bflow, desc);
if (ret2)
return log_msg_ret("fs", ret2);
if (ret)
return log_msg_ret("size", ret);
bflow->size = size;
bflow->state = BOOTFLOWST_FILE;
return 0;
}
bootstd: Allow reading a logo for the OS Some operating systems provide a logo in bmp format. Read this in if present so it can be displayed in the menu. Signed-off-by: Simon Glass <sjg@chromium.org>
2023-01-06 14:52:34 +00:00
static int alloc_file(const char *fname, uint size, void **bufp)
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
{
loff_t bytes_read;
ulong addr;
char *buf;
int ret;
bootstd: Allow reading a logo for the OS Some operating systems provide a logo in bmp format. Read this in if present so it can be displayed in the menu. Signed-off-by: Simon Glass <sjg@chromium.org>
2023-01-06 14:52:34 +00:00
buf = malloc(size + 1);
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
if (!buf)
return log_msg_ret("buf", -ENOMEM);
addr = map_to_sysmem(buf);
bootstd: Allow reading a logo for the OS Some operating systems provide a logo in bmp format. Read this in if present so it can be displayed in the menu. Signed-off-by: Simon Glass <sjg@chromium.org>
2023-01-06 14:52:34 +00:00
ret = fs_read(fname, addr, 0, size, &bytes_read);
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
if (ret) {
free(buf);
return log_msg_ret("read", ret);
}
if (size != bytes_read)
bootstd: Tidy up reporting of errors In a few cases the error handling is not quite right. Make sure we return the actual error in distro_efi_read_bootflow_file() rather than -EINVAL. Return -IO when a file cannot be read. Also show the error name if available. This does not change operation, but does make it easier to diagnose problems. Signed-off-by: Simon Glass <sjg@chromium.org>
2023-05-10 22:34:26 +00:00
return log_msg_ret("bread", -EIO);
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
buf[size] = '\0';
bootstd: Allow reading a logo for the OS Some operating systems provide a logo in bmp format. Read this in if present so it can be displayed in the menu. Signed-off-by: Simon Glass <sjg@chromium.org>
2023-01-06 14:52:34 +00:00
*bufp = buf;
return 0;
}
int bootmeth_alloc_file(struct bootflow *bflow, uint size_limit, uint align)
{
void *buf;
uint size;
int ret;
size = bflow->size;
log_debug(" - script file size %x\n", size);
if (size > size_limit)
return log_msg_ret("chk", -E2BIG);
ret = alloc_file(bflow->fname, bflow->size, &buf);
if (ret)
return log_msg_ret("all", ret);
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
bflow->state = BOOTFLOWST_READY;
bflow->buf = buf;
return 0;
}
bootstd: Allow reading a logo for the OS Some operating systems provide a logo in bmp format. Read this in if present so it can be displayed in the menu. Signed-off-by: Simon Glass <sjg@chromium.org>
2023-01-06 14:52:34 +00:00
int bootmeth_alloc_other(struct bootflow *bflow, const char *fname,
void **bufp, uint *sizep)
{
struct blk_desc *desc = NULL;
char path[200];
loff_t size;
void *buf;
int ret;
snprintf(path, sizeof(path), "%s%s", bflow->subdir, fname);
log_debug("trying: %s\n", path);
if (bflow->blk)
desc = dev_get_uclass_plat(bflow->blk);
ret = setup_fs(bflow, desc);
if (ret)
return log_msg_ret("fs", ret);
ret = fs_size(path, &size);
log_debug(" %s - err=%d\n", path, ret);
ret = setup_fs(bflow, desc);
if (ret)
return log_msg_ret("fs", ret);
ret = alloc_file(path, size, &buf);
if (ret)
return log_msg_ret("all", ret);
*bufp = buf;
*sizep = size;
return 0;
}
bootstd: Add the bootmeth uclass and helpers A bootmeth is a method of locating an operating system. For now, just add the uclass itself. Drivers for particular bootmeths are added later. If no bootmeths devices are included in the devicetree, create them automatically. This avoids the need for boilerplate in the devicetree files. Signed-off-by: Simon Glass <sjg@chromium.org>
2022-04-25 05:31:08 +00:00
int bootmeth_common_read_file(struct udevice *dev, struct bootflow *bflow,
const char *file_path, ulong addr, ulong *sizep)
{
struct blk_desc *desc = NULL;
loff_t len_read;
loff_t size;
int ret;
if (bflow->blk)
desc = dev_get_uclass_plat(bflow->blk);
ret = setup_fs(bflow, desc);
if (ret)
return log_msg_ret("fs", ret);
ret = fs_size(file_path, &size);
if (ret)
return log_msg_ret("size", ret);
if (size > *sizep)
return log_msg_ret("spc", -ENOSPC);
ret = setup_fs(bflow, desc);
if (ret)
return log_msg_ret("fs", ret);
ret = fs_read(file_path, addr, 0, 0, &len_read);
if (ret)
return ret;
*sizep = len_read;
return 0;
}
#ifdef CONFIG_BOOTSTD_FULL
/**
* on_bootmeths() - Update the bootmeth order
*
* This will check for a valid baudrate and only apply it if valid.
*/
static int on_bootmeths(const char *name, const char *value, enum env_op op,
int flags)
{
int ret;
switch (op) {
case env_op_create:
case env_op_overwrite:
ret = bootmeth_set_order(value);
if (ret)
return 1;
return 0;
case env_op_delete:
bootmeth_set_order(NULL);
fallthrough;
default:
return 0;
}
}
U_BOOT_ENV_CALLBACK(bootmeths, on_bootmeths);
#endif /* CONFIG_BOOTSTD_FULL */
UCLASS_DRIVER(bootmeth) = {
.id = UCLASS_BOOTMETH,
.name = "bootmeth",
.flags = DM_UC_FLAG_SEQ_ALIAS,
.per_device_plat_auto = sizeof(struct bootmeth_uc_plat),
};
Reference in a new issue Copy permalink