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
mount_ubifs(char * mtdpart,char * ubivol)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
umount_ubifs(void)50 static int umount_ubifs(void)
51 {
52 return cmd_ubifs_umount();
53 }
54 #else
mount_ubifs(char * mtdpart,char * ubivol)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
select_fs_dev(struct device_platdata * plat)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 */
_request_firmware_prepare(struct udevice * dev,const char * name,void * dbuf,size_t size,u32 offset)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 */
fw_get_filesystem_firmware(struct udevice * dev)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 */
request_firmware_into_buf(struct udevice * dev,const char * name,void * buf,size_t size,u32 offset)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
fs_loader_ofdata_to_platdata(struct udevice * dev)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
fs_loader_probe(struct udevice * dev)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