mtd: Be more strict on the "mtdparts=" prefix check
[platform/kernel/u-boot.git] / drivers / mtd / mtd_uboot.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * (C) Copyright 2014
4  * Heiko Schocher, DENX Software Engineering, hs@denx.de.
5  */
6 #include <common.h>
7 #include <dm/device.h>
8 #include <dm/uclass-internal.h>
9 #include <jffs2/jffs2.h> /* LEGACY */
10 #include <linux/mtd/mtd.h>
11 #include <linux/mtd/partitions.h>
12 #include <mtd.h>
13
14 #define MTD_NAME_MAX_LEN 20
15
16 void board_mtdparts_default(const char **mtdids, const char **mtdparts);
17
18 static const char *get_mtdids(void)
19 {
20         __maybe_unused const char *mtdparts = NULL;
21         const char *mtdids = env_get("mtdids");
22
23         if (mtdids)
24                 return mtdids;
25
26 #if defined(CONFIG_SYS_MTDPARTS_RUNTIME)
27         board_mtdparts_default(&mtdids, &mtdparts);
28 #elif defined(MTDIDS_DEFAULT)
29         mtdids = MTDIDS_DEFAULT;
30 #elif defined(CONFIG_MTDIDS_DEFAULT)
31         mtdids = CONFIG_MTDIDS_DEFAULT;
32 #endif
33
34         if (mtdids)
35                 env_set("mtdids", mtdids);
36
37         return mtdids;
38 }
39
40 /**
41  * mtd_search_alternate_name - Search an alternate name for @mtdname thanks to
42  *                             the mtdids legacy environment variable.
43  *
44  * The mtdids string is a list of comma-separated 'dev_id=mtd_id' tupples.
45  * Check if one of the mtd_id matches mtdname, in this case save dev_id in
46  * altname.
47  *
48  * @mtdname: Current MTD device name
49  * @altname: Alternate name to return
50  * @max_len: Length of the alternate name buffer
51  *
52  * @return 0 on success, an error otherwise.
53  */
54 int mtd_search_alternate_name(const char *mtdname, char *altname,
55                               unsigned int max_len)
56 {
57         const char *mtdids, *equal, *comma, *dev_id, *mtd_id;
58         int dev_id_len, mtd_id_len;
59
60         mtdids = get_mtdids();
61         if (!mtdids)
62                 return -EINVAL;
63
64         do {
65                 /* Find the '=' sign */
66                 dev_id = mtdids;
67                 equal = strchr(dev_id, '=');
68                 if (!equal)
69                         break;
70                 dev_id_len = equal - mtdids;
71                 mtd_id = equal + 1;
72
73                 /* Find the end of the tupple */
74                 comma = strchr(mtdids, ',');
75                 if (comma)
76                         mtd_id_len = comma - mtd_id;
77                 else
78                         mtd_id_len = &mtdids[strlen(mtdids)] - mtd_id + 1;
79
80                 if (!dev_id_len || !mtd_id_len)
81                         return -EINVAL;
82
83                 if (dev_id_len + 1 > max_len)
84                         continue;
85
86                 /* Compare the name we search with the current mtd_id */
87                 if (!strncmp(mtdname, mtd_id, mtd_id_len)) {
88                         strncpy(altname, dev_id, dev_id_len);
89                         altname[dev_id_len] = 0;
90
91                         return 0;
92                 }
93
94                 /* Go to the next tupple */
95                 mtdids = comma + 1;
96         } while (comma);
97
98         return -EINVAL;
99 }
100
101 #if IS_ENABLED(CONFIG_MTD)
102 static void mtd_probe_uclass_mtd_devs(void)
103 {
104         struct udevice *dev;
105         int idx = 0;
106
107         /* Probe devices with DM compliant drivers */
108         while (!uclass_find_device(UCLASS_MTD, idx, &dev) && dev) {
109                 mtd_probe(dev);
110                 idx++;
111         }
112 }
113 #else
114 static void mtd_probe_uclass_mtd_devs(void) { }
115 #endif
116
117 #if defined(CONFIG_MTD_PARTITIONS)
118
119 #define MTDPARTS_MAXLEN         512
120
121 static const char *get_mtdparts(void)
122 {
123         __maybe_unused const char *mtdids = NULL;
124         static char tmp_parts[MTDPARTS_MAXLEN];
125         static bool use_defaults = true;
126         const char *mtdparts = NULL;
127
128         if (gd->flags & GD_FLG_ENV_READY)
129                 mtdparts = env_get("mtdparts");
130         else if (env_get_f("mtdparts", tmp_parts, sizeof(tmp_parts)) != -1)
131                 mtdparts = tmp_parts;
132
133         if (mtdparts || !use_defaults)
134                 return mtdparts;
135
136 #if defined(CONFIG_SYS_MTDPARTS_RUNTIME)
137         board_mtdparts_default(&mtdids, &mtdparts);
138 #elif defined(MTDPARTS_DEFAULT)
139         mtdparts = MTDPARTS_DEFAULT;
140 #elif defined(CONFIG_MTDPARTS_DEFAULT)
141         mtdparts = CONFIG_MTDPARTS_DEFAULT;
142 #endif
143
144         if (mtdparts)
145                 env_set("mtdparts", mtdparts);
146
147         use_defaults = false;
148
149         return mtdparts;
150 }
151
152 int mtd_probe_devices(void)
153 {
154         static char *old_mtdparts;
155         static char *old_mtdids;
156         const char *mtdparts = get_mtdparts();
157         const char *mtdids = get_mtdids();
158         bool remaining_partitions = true;
159         struct mtd_info *mtd;
160
161         mtd_probe_uclass_mtd_devs();
162
163         /*
164          * Check if mtdparts/mtdids changed or if the MTD dev list was updated
165          * since last call, otherwise: exit
166          */
167         if ((!mtdparts && !old_mtdparts && !mtdids && !old_mtdids) ||
168             (mtdparts && old_mtdparts && mtdids && old_mtdids &&
169              !mtd_dev_list_updated() &&
170              !strcmp(mtdparts, old_mtdparts) &&
171              !strcmp(mtdids, old_mtdids)))
172                 return 0;
173
174         /* Update the local copy of mtdparts */
175         free(old_mtdparts);
176         free(old_mtdids);
177         old_mtdparts = strdup(mtdparts);
178         old_mtdids = strdup(mtdids);
179
180         /* If at least one partition is still in use, do not delete anything */
181         mtd_for_each_device(mtd) {
182                 if (mtd->usecount) {
183                         printf("Partition \"%s\" already in use, aborting\n",
184                                mtd->name);
185                         return -EACCES;
186                 }
187         }
188
189         /*
190          * Everything looks clear, remove all partitions. It is not safe to
191          * remove entries from the mtd_for_each_device loop as it uses idr
192          * indexes and the partitions removal is done in bulk (all partitions of
193          * one device at the same time), so break and iterate from start each
194          * time a new partition is found and deleted.
195          */
196         while (remaining_partitions) {
197                 remaining_partitions = false;
198                 mtd_for_each_device(mtd) {
199                         if (!mtd_is_partition(mtd) && mtd_has_partitions(mtd)) {
200                                 del_mtd_partitions(mtd);
201                                 remaining_partitions = true;
202                                 break;
203                         }
204                 }
205         }
206
207         /*
208          * Call mtd_dev_list_updated() to clear updates generated by our own
209          * parts removal loop.
210          */
211         mtd_dev_list_updated();
212
213         /* If either mtdparts or mtdids is empty, then exit */
214         if (!mtdparts || !mtdids)
215                 return 0;
216
217         /* Start the parsing by ignoring the extra 'mtdparts=' prefix, if any */
218         if (!strncmp(mtdparts, "mtdparts=", sizeof("mtdparts=") - 1))
219                 mtdparts += 9;
220
221         /* For each MTD device in mtdparts */
222         while (mtdparts[0] != '\0') {
223                 char mtd_name[MTD_NAME_MAX_LEN], *colon;
224                 struct mtd_partition *parts;
225                 int mtd_name_len, nparts;
226                 int ret;
227
228                 colon = strchr(mtdparts, ':');
229                 if (!colon) {
230                         printf("Wrong mtdparts: %s\n", mtdparts);
231                         return -EINVAL;
232                 }
233
234                 mtd_name_len = colon - mtdparts;
235                 strncpy(mtd_name, mtdparts, mtd_name_len);
236                 mtd_name[mtd_name_len] = '\0';
237                 /* Move the pointer forward (including the ':') */
238                 mtdparts += mtd_name_len + 1;
239                 mtd = get_mtd_device_nm(mtd_name);
240                 if (IS_ERR_OR_NULL(mtd)) {
241                         char linux_name[MTD_NAME_MAX_LEN];
242
243                         /*
244                          * The MTD device named "mtd_name" does not exist. Try
245                          * to find a correspondance with an MTD device having
246                          * the same type and number as defined in the mtdids.
247                          */
248                         debug("No device named %s\n", mtd_name);
249                         ret = mtd_search_alternate_name(mtd_name, linux_name,
250                                                         MTD_NAME_MAX_LEN);
251                         if (!ret)
252                                 mtd = get_mtd_device_nm(linux_name);
253
254                         /*
255                          * If no device could be found, move the mtdparts
256                          * pointer forward until the next set of partitions.
257                          */
258                         if (ret || IS_ERR_OR_NULL(mtd)) {
259                                 printf("Could not find a valid device for %s\n",
260                                        mtd_name);
261                                 mtdparts = strchr(mtdparts, ';');
262                                 if (mtdparts)
263                                         mtdparts++;
264
265                                 continue;
266                         }
267                 }
268
269                 /*
270                  * Parse the MTD device partitions. It will update the mtdparts
271                  * pointer, create an array of parts (that must be freed), and
272                  * return the number of partition structures in the array.
273                  */
274                 ret = mtd_parse_partitions(mtd, &mtdparts, &parts, &nparts);
275                 if (ret) {
276                         printf("Could not parse device %s\n", mtd->name);
277                         put_mtd_device(mtd);
278                         return -EINVAL;
279                 }
280
281                 if (!nparts)
282                         continue;
283
284                 /* Create the new MTD partitions */
285                 add_mtd_partitions(mtd, parts, nparts);
286
287                 /* Free the structures allocated during the parsing */
288                 mtd_free_parsed_partitions(parts, nparts);
289
290                 put_mtd_device(mtd);
291         }
292
293         /*
294          * Call mtd_dev_list_updated() to clear updates generated by our own
295          * parts registration loop.
296          */
297         mtd_dev_list_updated();
298
299         return 0;
300 }
301 #else
302 int mtd_probe_devices(void)
303 {
304         mtd_probe_uclass_mtd_devs();
305
306         return 0;
307 }
308 #endif /* defined(CONFIG_MTD_PARTITIONS) */
309
310 /* Legacy */
311
312 static int get_part(const char *partname, int *idx, loff_t *off, loff_t *size,
313                 loff_t *maxsize, int devtype)
314 {
315 #ifdef CONFIG_CMD_MTDPARTS
316         struct mtd_device *dev;
317         struct part_info *part;
318         u8 pnum;
319         int ret;
320
321         ret = mtdparts_init();
322         if (ret)
323                 return ret;
324
325         ret = find_dev_and_part(partname, &dev, &pnum, &part);
326         if (ret)
327                 return ret;
328
329         if (dev->id->type != devtype) {
330                 printf("not same typ %d != %d\n", dev->id->type, devtype);
331                 return -1;
332         }
333
334         *off = part->offset;
335         *size = part->size;
336         *maxsize = part->size;
337         *idx = dev->id->num;
338
339         return 0;
340 #else
341         puts("mtdparts support missing.\n");
342         return -1;
343 #endif
344 }
345
346 int mtd_arg_off(const char *arg, int *idx, loff_t *off, loff_t *size,
347                 loff_t *maxsize, int devtype, uint64_t chipsize)
348 {
349         if (!str2off(arg, off))
350                 return get_part(arg, idx, off, size, maxsize, devtype);
351
352         if (*off >= chipsize) {
353                 puts("Offset exceeds device limit\n");
354                 return -1;
355         }
356
357         *maxsize = chipsize - *off;
358         *size = *maxsize;
359         return 0;
360 }
361
362 int mtd_arg_off_size(int argc, char *const argv[], int *idx, loff_t *off,
363                      loff_t *size, loff_t *maxsize, int devtype,
364                      uint64_t chipsize)
365 {
366         int ret;
367
368         if (argc == 0) {
369                 *off = 0;
370                 *size = chipsize;
371                 *maxsize = *size;
372                 goto print;
373         }
374
375         ret = mtd_arg_off(argv[0], idx, off, size, maxsize, devtype,
376                           chipsize);
377         if (ret)
378                 return ret;
379
380         if (argc == 1)
381                 goto print;
382
383         if (!str2off(argv[1], size)) {
384                 printf("'%s' is not a number\n", argv[1]);
385                 return -1;
386         }
387
388         if (*size > *maxsize) {
389                 puts("Size exceeds partition or device limit\n");
390                 return -1;
391         }
392
393 print:
394         printf("device %d ", *idx);
395         if (*size == chipsize)
396                 puts("whole chip\n");
397         else
398                 printf("offset 0x%llx, size 0x%llx\n",
399                        (unsigned long long)*off, (unsigned long long)*size);
400         return 0;
401 }