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