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