mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-30 05:48:51 +09:00
![Tien Fong Chee](/assets/img/avatar_default.png)
Switching private data manual allocation to driver model auto allocation so users no longer need to deallocate themself because this would be deallocated by driver model when the device is no longer required. Signed-off-by: Tien Fong Chee <tien.fong.chee@intel.com> Reviewed-by: Simon Glass <sjg@chromium.org>
277 lines
6.0 KiB
C
277 lines
6.0 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2018 Intel Corporation <www.intel.com>
|
|
*
|
|
*/
|
|
#include <common.h>
|
|
#include <dm.h>
|
|
#include <errno.h>
|
|
#include <blk.h>
|
|
#include <fs.h>
|
|
#include <fs_loader.h>
|
|
#include <linux/string.h>
|
|
#include <mapmem.h>
|
|
#include <malloc.h>
|
|
#include <spl.h>
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
/**
|
|
* struct firmware - A place for storing firmware and its attribute data.
|
|
*
|
|
* This holds information about a firmware and its content.
|
|
*
|
|
* @size: Size of a file
|
|
* @data: Buffer for file
|
|
* @priv: Firmware loader private fields
|
|
* @name: Filename
|
|
* @offset: Offset of reading a file
|
|
*/
|
|
struct firmware {
|
|
size_t size;
|
|
const u8 *data;
|
|
const char *name;
|
|
u32 offset;
|
|
};
|
|
|
|
#ifdef CONFIG_CMD_UBIFS
|
|
static int mount_ubifs(char *mtdpart, char *ubivol)
|
|
{
|
|
int ret = ubi_part(mtdpart, NULL);
|
|
|
|
if (ret) {
|
|
debug("Cannot find mtd partition %s\n", mtdpart);
|
|
return ret;
|
|
}
|
|
|
|
return cmd_ubifs_mount(ubivol);
|
|
}
|
|
|
|
static int umount_ubifs(void)
|
|
{
|
|
return cmd_ubifs_umount();
|
|
}
|
|
#else
|
|
static int mount_ubifs(char *mtdpart, char *ubivol)
|
|
{
|
|
debug("Error: Cannot load image: no UBIFS support\n");
|
|
return -ENOSYS;
|
|
}
|
|
#endif
|
|
|
|
static int select_fs_dev(struct device_platdata *plat)
|
|
{
|
|
int ret;
|
|
|
|
if (plat->phandlepart.phandle) {
|
|
ofnode node;
|
|
|
|
node = ofnode_get_by_phandle(plat->phandlepart.phandle);
|
|
|
|
struct udevice *dev;
|
|
|
|
ret = device_get_global_by_ofnode(node, &dev);
|
|
if (!ret) {
|
|
struct blk_desc *desc = blk_get_by_device(dev);
|
|
if (desc) {
|
|
ret = fs_set_blk_dev_with_part(desc,
|
|
plat->phandlepart.partition);
|
|
} else {
|
|
debug("%s: No device found\n", __func__);
|
|
return -ENODEV;
|
|
}
|
|
}
|
|
} else if (plat->mtdpart && plat->ubivol) {
|
|
ret = mount_ubifs(plat->mtdpart, plat->ubivol);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = fs_set_blk_dev("ubi", NULL, FS_TYPE_UBIFS);
|
|
} else {
|
|
debug("Error: unsupported storage device.\n");
|
|
return -ENODEV;
|
|
}
|
|
|
|
if (ret)
|
|
debug("Error: could not access storage.\n");
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* _request_firmware_prepare - Prepare firmware struct.
|
|
*
|
|
* @dev: An instance of a driver.
|
|
* @name: Name of firmware file.
|
|
* @dbuf: Address of buffer to load firmware into.
|
|
* @size: Size of buffer.
|
|
* @offset: Offset of a file for start reading into buffer.
|
|
*
|
|
* Return: Negative value if fail, 0 for successful.
|
|
*/
|
|
static int _request_firmware_prepare(struct udevice *dev,
|
|
const char *name, void *dbuf,
|
|
size_t size, u32 offset)
|
|
{
|
|
if (!name || name[0] == '\0')
|
|
return -EINVAL;
|
|
|
|
struct firmware *firmwarep = dev_get_priv(dev);
|
|
|
|
if (!firmwarep)
|
|
return -ENOMEM;
|
|
|
|
firmwarep->name = name;
|
|
firmwarep->offset = offset;
|
|
firmwarep->data = dbuf;
|
|
firmwarep->size = size;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* fw_get_filesystem_firmware - load firmware into an allocated buffer.
|
|
* @dev: An instance of a driver.
|
|
*
|
|
* Return: Size of total read, negative value when error.
|
|
*/
|
|
static int fw_get_filesystem_firmware(struct udevice *dev)
|
|
{
|
|
loff_t actread;
|
|
char *storage_interface, *dev_part, *ubi_mtdpart, *ubi_volume;
|
|
int ret;
|
|
|
|
storage_interface = env_get("storage_interface");
|
|
dev_part = env_get("fw_dev_part");
|
|
ubi_mtdpart = env_get("fw_ubi_mtdpart");
|
|
ubi_volume = env_get("fw_ubi_volume");
|
|
|
|
if (storage_interface && dev_part) {
|
|
ret = fs_set_blk_dev(storage_interface, dev_part, FS_TYPE_ANY);
|
|
} else if (storage_interface && ubi_mtdpart && ubi_volume) {
|
|
ret = mount_ubifs(ubi_mtdpart, ubi_volume);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (!strcmp("ubi", storage_interface))
|
|
ret = fs_set_blk_dev(storage_interface, NULL,
|
|
FS_TYPE_UBIFS);
|
|
else
|
|
ret = -ENODEV;
|
|
} else {
|
|
ret = select_fs_dev(dev->platdata);
|
|
}
|
|
|
|
if (ret)
|
|
goto out;
|
|
|
|
struct firmware *firmwarep = dev_get_priv(dev);
|
|
|
|
if (!firmwarep)
|
|
return -ENOMEM;
|
|
|
|
ret = fs_read(firmwarep->name, (ulong)map_to_sysmem(firmwarep->data),
|
|
firmwarep->offset, firmwarep->size, &actread);
|
|
|
|
if (ret) {
|
|
debug("Error: %d Failed to read %s from flash %lld != %zu.\n",
|
|
ret, firmwarep->name, actread, firmwarep->size);
|
|
} else {
|
|
ret = actread;
|
|
}
|
|
|
|
out:
|
|
#ifdef CONFIG_CMD_UBIFS
|
|
umount_ubifs();
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
int ret;
|
|
|
|
if (!dev)
|
|
return -EINVAL;
|
|
|
|
ret = _request_firmware_prepare(dev, name, buf, size, offset);
|
|
if (ret < 0) /* error */
|
|
return ret;
|
|
|
|
ret = fw_get_filesystem_firmware(dev);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int fs_loader_ofdata_to_platdata(struct udevice *dev)
|
|
{
|
|
const char *fs_loader_path;
|
|
u32 phandlepart[2];
|
|
|
|
fs_loader_path = ofnode_get_chosen_prop("firmware-loader");
|
|
|
|
if (fs_loader_path) {
|
|
ofnode fs_loader_node;
|
|
|
|
fs_loader_node = ofnode_path(fs_loader_path);
|
|
if (ofnode_valid(fs_loader_node)) {
|
|
struct device_platdata *plat;
|
|
plat = dev->platdata;
|
|
|
|
if (!ofnode_read_u32_array(fs_loader_node,
|
|
"phandlepart",
|
|
phandlepart, 2)) {
|
|
plat->phandlepart.phandle = phandlepart[0];
|
|
plat->phandlepart.partition = phandlepart[1];
|
|
}
|
|
|
|
plat->mtdpart = (char *)ofnode_read_string(
|
|
fs_loader_node, "mtdpart");
|
|
|
|
plat->ubivol = (char *)ofnode_read_string(
|
|
fs_loader_node, "ubivol");
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int fs_loader_probe(struct udevice *dev)
|
|
{
|
|
return 0;
|
|
};
|
|
|
|
static const struct udevice_id fs_loader_ids[] = {
|
|
{ .compatible = "u-boot,fs-loader"},
|
|
{ }
|
|
};
|
|
|
|
U_BOOT_DRIVER(fs_loader) = {
|
|
.name = "fs-loader",
|
|
.id = UCLASS_FS_FIRMWARE_LOADER,
|
|
.of_match = fs_loader_ids,
|
|
.probe = fs_loader_probe,
|
|
.ofdata_to_platdata = fs_loader_ofdata_to_platdata,
|
|
.platdata_auto_alloc_size = sizeof(struct device_platdata),
|
|
.priv_auto_alloc_size = sizeof(struct firmware),
|
|
};
|
|
|
|
UCLASS_DRIVER(fs_loader) = {
|
|
.id = UCLASS_FS_FIRMWARE_LOADER,
|
|
.name = "fs-loader",
|
|
};
|