mirror of
https://source.denx.de/u-boot/u-boot.git
synced 2026-03-01 03:51:26 +01:00
b5da53046c
This commit introduces a new API,
request_firmware_into_buf_via_script(), to the fs_loader framework.
This function allows firmware to be loaded into memory using
a user-defined U-Boot script, providing greater flexibility for
firmware loading scenarios that cannot be handled by static file
paths or device/partition selection alone.
Key features:
- The API runs a specified U-Boot script (by name), which is responsible
for loading the firmware into memory by any means (e.g., load from MMC, USB, network, etc.).
- The script must set two environment variables: 'fw_addr'
(the memory address where the firmware is loaded) and
'fw_size' (the size of the firmware in bytes).
- The function validates these variables, copies the firmware into a newly
allocated buffer (using memdup), and returns the pointer
via the provided double pointer argument.
- The maximum allowed firmware size is checked to prevent buffer overflows.
- The environment variables are cleared after use to avoid stale data.
- Detailed error messages are provided for all failure conditions to aid debugging.
Usage example:
1. Define a U-Boot script in the environment that loads the firmware
and sets the required variables:
=> env set my_fw_script 'load mmc 0:1 ${loadaddr} firmware.bin &&
env set fw_addr ${loadaddr} && env set fw_size ${filesize}'
2. In your code, call the new API:
void *fw_buf = NULL;
int ret = request_firmware_into_buf_via_script(&fw_buf, 0x46000000, "my_fw_script");
if (ret < 0)
return ret;
This approach allows board integrators and users to customize the firmware
loading process without modifying the source code,
simply by changing the script in the U-Boot environment.
Signed-off-by: Lucien.Jheng <lucienzx159@gmail.com>
Reviewed-by: Marek Vasut <marek.vasut+renesas@mailbox.org>
[trini: Fix printf of size_t needing to use %zx]
Signed-off-by: Tom Rini <trini@konsulko.com>
92 lines
2.9 KiB
C
92 lines
2.9 KiB
C
/*
|
|
* Copyright (C) 2018 Intel Corporation <www.intel.com>
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0
|
|
*/
|
|
#ifndef _FS_LOADER_H_
|
|
#define _FS_LOADER_H_
|
|
|
|
struct udevice;
|
|
|
|
/**
|
|
* struct phandle_part - A place for storing phandle of node and its partition
|
|
*
|
|
* This holds information about a phandle of the block device, and its
|
|
* partition where the firmware would be loaded from.
|
|
*
|
|
* @phandle: Phandle of storage device node
|
|
* @partition: Partition of block device
|
|
*/
|
|
struct phandle_part {
|
|
u32 phandle;
|
|
u32 partition;
|
|
};
|
|
|
|
/**
|
|
* struct phandle_part - A place for storing all supported storage devices
|
|
*
|
|
* This holds information about all supported storage devices for driver use.
|
|
*
|
|
* @phandlepart: Attribute data for block device.
|
|
* @mtdpart: MTD partition for ubi partition.
|
|
* @ubivol: UBI volume-name for ubifsmount.
|
|
*/
|
|
struct device_plat {
|
|
struct phandle_part phandlepart;
|
|
char *mtdpart;
|
|
char *ubivol;
|
|
};
|
|
|
|
/**
|
|
* request_firmware_into_buf - Load firmware into a previously allocated buffer.
|
|
* @dev: An instance of a driver.
|
|
* @name: Name of firmware file.
|
|
* @buf: Address of buffer to load firmware into.
|
|
* @size: Size of buffer.
|
|
* @offset: Offset of a file for start reading into buffer.
|
|
*
|
|
* The firmware is loaded directly into the buffer pointed to by @buf.
|
|
*
|
|
* Return: Size of total read, negative value when error.
|
|
*/
|
|
int request_firmware_into_buf(struct udevice *dev,
|
|
const char *name,
|
|
void *buf, size_t size, u32 offset);
|
|
|
|
/**
|
|
* get_fs_loader() - Get the chosen filesystem loader
|
|
* @dev: Where to store the device
|
|
*
|
|
* This gets a filesystem loader device based on the value of
|
|
* /chosen/firmware-loader. If no such property exists, it returns a
|
|
* firmware loader which is configured by environmental variables.
|
|
*
|
|
* Return: 0 on success, negative value on error
|
|
*/
|
|
int get_fs_loader(struct udevice **dev);
|
|
|
|
/**
|
|
* request_firmware_into_buf_via_script() -
|
|
* Load firmware using a U-Boot script and copy to buffer
|
|
* @buf: Pointer to a pointer where the firmware buffer will be stored.
|
|
* @max_size: Maximum allowed size for the firmware to be loaded.
|
|
* @script_name: Name of the U-Boot script to execute for firmware loading.
|
|
*
|
|
* Executes a U-Boot script (@script_name) that loads firmware into
|
|
* memory and sets the environment variables 'fw_addr' (address) and
|
|
* 'fw_size' (size in bytes). On success, copies the firmware
|
|
* from the given address to user buffer @buf.
|
|
*
|
|
* The script must set these environment variables:
|
|
* fw_addr - Address where firmware is loaded in memory
|
|
* fw_size - Size of the firmware in bytes
|
|
*
|
|
* The script should be defined in the U-Boot environment, for example:
|
|
* env set script_name 'load mmc 0:1 ${loadaddr} firmware.bin &&
|
|
* env set fw_addr ${loadaddr} && env set fw_size ${filesize}
|
|
* Return: 0 on success, negative value on error.
|
|
*/
|
|
int request_firmware_into_buf_via_script(void **buf, size_t max_size,
|
|
const char *script_name);
|
|
#endif
|