MAINTAINERS: Add an entry for SPI NOR
[oweals/u-boot.git] / drivers / misc / fs_loader.c
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 };