drivers/misc/fs_loader.c

   1 // SPDX-License-Identifier: GPL-2.0
   2  /*
   3  * Copyright (C) 2018-2019 Intel Corporation <www.intel.com>
   4  *
   5  */
   6
   7 #define LOG_CATEGORY UCLASS_FS_FIRMWARE_LOADER
   8
   9 #include <common.h>
  10 #include <dm.h>
  11 #include <env.h>
  12 #include <errno.h>
  13 #include <blk.h>
  14 #include <fs.h>
  15 #include <fs_loader.h>
  16 #include <log.h>
  17 #include <asm/global_data.h>
  18 #include <linux/string.h>
  19 #include <mapmem.h>
  20 #include <malloc.h>
  21 #include <spl.h>
  22
  23 DECLARE_GLOBAL_DATA_PTR;
  24
  25 /**
  26  * struct firmware - A place for storing firmware and its attribute data.
  27  *
  28  * This holds information about a firmware and its content.
  29  *
  30  * @size: Size of a file
  31  * @data: Buffer for file
  32  * @priv: Firmware loader private fields
  33  * @name: Filename
  34  * @offset: Offset of reading a file
  35  */
  36 struct firmware {
  37         size_t size;
  38         const u8 *data;
  39         const char *name;
  40         u32 offset;
  41 };
  42
  43 #ifdef CONFIG_CMD_UBIFS
  44 static int mount_ubifs(char *mtdpart, char *ubivol)
  45 {
  46         int ret = ubi_part(mtdpart, NULL);
  47
  48         if (ret) {
  49                 debug("Cannot find mtd partition %s\n", mtdpart);
  50                 return ret;
  51         }
  52
  53         return cmd_ubifs_mount(ubivol);
  54 }
  55
  56 static int umount_ubifs(void)
  57 {
  58         return cmd_ubifs_umount();
  59 }
  60 #else
  61 static int mount_ubifs(char *mtdpart, char *ubivol)
  62 {
  63         debug("Error: Cannot load image: no UBIFS support\n");
  64         return -ENOSYS;
  65 }
  66 #endif
  67
  68 static int select_fs_dev(struct device_plat *plat)
  69 {
  70         int ret;
  71
  72         if (plat->phandlepart.phandle) {
  73                 ofnode node;
  74
  75                 node = ofnode_get_by_phandle(plat->phandlepart.phandle);
  76
  77                 struct udevice *dev;
  78
  79                 ret = device_get_global_by_ofnode(node, &dev);
  80                 if (!ret) {
  81                         struct blk_desc *desc = blk_get_by_device(dev);
  82                         if (desc) {
  83                                 ret = fs_set_blk_dev_with_part(desc,
  84                                         plat->phandlepart.partition);
  85                         } else {
  86                                 debug("%s: No device found\n", __func__);
  87                                 return -ENODEV;
  88                         }
  89                 }
  90         } else if (plat->mtdpart && plat->ubivol) {
  91                 ret = mount_ubifs(plat->mtdpart, plat->ubivol);
  92                 if (ret)
  93                         return ret;
  94
  95                 ret = fs_set_blk_dev("ubi", NULL, FS_TYPE_UBIFS);
  96         } else {
  97                 debug("Error: unsupported storage device.\n");
  98                 return -ENODEV;
  99         }
 100
 101         if (ret)
 102                 debug("Error: could not access storage.\n");
 103
 104         return ret;
 105 }
 106
 107 /**
 108  * _request_firmware_prepare - Prepare firmware struct.
 109  *
 110  * @dev: An instance of a driver.
 111  * @name: Name of firmware file.
 112  * @dbuf: Address of buffer to load firmware into.
 113  * @size: Size of buffer.
 114  * @offset: Offset of a file for start reading into buffer.
 115  *
 116  * Return: Negative value if fail, 0 for successful.
 117  */
 118 static int _request_firmware_prepare(struct udevice *dev,
 119                                     const char *name, void *dbuf,
 120                                     size_t size, u32 offset)
 121 {
 122         if (!name || name[0] == '\0')
 123                 return -EINVAL;
 124
 125         struct firmware *firmwarep = dev_get_priv(dev);
 126
 127         if (!firmwarep)
 128                 return -ENOMEM;
 129
 130         firmwarep->name = name;
 131         firmwarep->offset = offset;
 132         firmwarep->data = dbuf;
 133         firmwarep->size = size;
 134
 135         return 0;
 136 }
 137
 138 /**
 139  * fw_get_filesystem_firmware - load firmware into an allocated buffer.
 140  * @dev: An instance of a driver.
 141  *
 142  * Return: Size of total read, negative value when error.
 143  */
 144 static int fw_get_filesystem_firmware(struct udevice *dev)
 145 {
 146         loff_t actread;
 147         char *storage_interface, *dev_part, *ubi_mtdpart, *ubi_volume;
 148         int ret;
 149
 150         storage_interface = env_get("storage_interface");
 151         dev_part = env_get("fw_dev_part");
 152         ubi_mtdpart = env_get("fw_ubi_mtdpart");
 153         ubi_volume = env_get("fw_ubi_volume");
 154
 155         if (storage_interface && dev_part) {
 156                 ret = fs_set_blk_dev(storage_interface, dev_part, FS_TYPE_ANY);
 157         } else if (storage_interface && ubi_mtdpart && ubi_volume) {
 158                 ret = mount_ubifs(ubi_mtdpart, ubi_volume);
 159                 if (ret)
 160                         return ret;
 161
 162                 if (!strcmp("ubi", storage_interface))
 163                         ret = fs_set_blk_dev(storage_interface, NULL,
 164                                 FS_TYPE_UBIFS);
 165                 else
 166                         ret = -ENODEV;
 167         } else {
 168                 ret = select_fs_dev(dev_get_plat(dev));
 169         }
 170
 171         if (ret)
 172                 goto out;
 173
 174         struct firmware *firmwarep = dev_get_priv(dev);
 175
 176         if (!firmwarep)
 177                 return -ENOMEM;
 178
 179         ret = fs_read(firmwarep->name, (ulong)map_to_sysmem(firmwarep->data),
 180                         firmwarep->offset, firmwarep->size, &actread);
 181
 182         if (ret) {
 183                 debug("Error: %d Failed to read %s from flash %lld != %zu.\n",
 184                       ret, firmwarep->name, actread, firmwarep->size);
 185         } else {
 186                 ret = actread;
 187         }
 188
 189 out:
 190 #ifdef CONFIG_CMD_UBIFS
 191         umount_ubifs();
 192 #endif
 193         return ret;
 194 }
 195
 196 /**
 197  * request_firmware_into_buf - Load firmware into a previously allocated buffer.
 198  * @dev: An instance of a driver.
 199  * @name: Name of firmware file.
 200  * @buf: Address of buffer to load firmware into.
 201  * @size: Size of buffer.
 202  * @offset: Offset of a file for start reading into buffer.
 203  *
 204  * The firmware is loaded directly into the buffer pointed to by @buf.
 205  *
 206  * Return: Size of total read, negative value when error.
 207  */
 208 int request_firmware_into_buf(struct udevice *dev,
 209                               const char *name,
 210                               void *buf, size_t size, u32 offset)
 211 {
 212         int ret;
 213
 214         if (!dev)
 215                 return -EINVAL;
 216
 217         ret = _request_firmware_prepare(dev, name, buf, size, offset);
 218         if (ret < 0) /* error */
 219                 return ret;
 220
 221         ret = fw_get_filesystem_firmware(dev);
 222
 223         return ret;
 224 }
 225
 226 static int fs_loader_of_to_plat(struct udevice *dev)
 227 {
 228         u32 phandlepart[2];
 229
 230         ofnode fs_loader_node = dev_ofnode(dev);
 231
 232         if (ofnode_valid(fs_loader_node)) {
 233                 struct device_plat *plat;
 234
 235                 plat = dev_get_plat(dev);
 236                 if (!ofnode_read_u32_array(fs_loader_node,
 237                                           "phandlepart",
 238                                           phandlepart, 2)) {
 239                         plat->phandlepart.phandle = phandlepart[0];
 240                         plat->phandlepart.partition = phandlepart[1];
 241                 }
 242
 243                 plat->mtdpart = (char *)ofnode_read_string(
 244                                  fs_loader_node, "mtdpart");
 245
 246                 plat->ubivol = (char *)ofnode_read_string(
 247                                  fs_loader_node, "ubivol");
 248         }
 249
 250         return 0;
 251 }
 252
 253 static int fs_loader_probe(struct udevice *dev)
 254 {
 255 #if CONFIG_IS_ENABLED(DM) && CONFIG_IS_ENABLED(BLK)
 256         int ret;
 257         struct device_plat *plat = dev_get_plat(dev);
 258
 259         if (plat->phandlepart.phandle) {
 260                 ofnode node = ofnode_get_by_phandle(plat->phandlepart.phandle);
 261                 struct udevice *parent_dev = NULL;
 262
 263                 ret = device_get_global_by_ofnode(node, &parent_dev);
 264                 if (!ret) {
 265                         struct udevice *dev;
 266
 267                         ret = blk_get_from_parent(parent_dev, &dev);
 268                         if (ret) {
 269                                 debug("fs_loader: No block device: %d\n",
 270                                         ret);
 271
 272                                 return ret;
 273                         }
 274                 }
 275         }
 276 #endif
 277
 278         return 0;
 279 };
 280
 281 static const struct udevice_id fs_loader_ids[] = {
 282         { .compatible = "u-boot,fs-loader"},
 283         { }
 284 };
 285
 286 U_BOOT_DRIVER(fs_loader) = {
 287         .name                   = "fs-loader",
 288         .id                     = UCLASS_FS_FIRMWARE_LOADER,
 289         .of_match               = fs_loader_ids,
 290         .probe                  = fs_loader_probe,
 291         .of_to_plat     = fs_loader_of_to_plat,
 292         .plat_auto      = sizeof(struct device_plat),
 293         .priv_auto      = sizeof(struct firmware),
 294 };
 295
 296 UCLASS_DRIVER(fs_loader) = {
 297         .id             = UCLASS_FS_FIRMWARE_LOADER,
 298         .name           = "fs-loader",
 299 };