Merge branch 'master' of git://git.denx.de/u-boot-spi
[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
17 /**
18  * mtd_search_alternate_name - Search an alternate name for @mtdname thanks to
19  *                             the mtdids legacy environment variable.
20  *
21  * The mtdids string is a list of comma-separated 'dev_id=mtd_id' tupples.
22  * Check if one of the mtd_id matches mtdname, in this case save dev_id in
23  * altname.
24  *
25  * @mtdname: Current MTD device name
26  * @altname: Alternate name to return
27  * @max_len: Length of the alternate name buffer
28  *
29  * @return 0 on success, an error otherwise.
30  */
31 int mtd_search_alternate_name(const char *mtdname, char *altname,
32                               unsigned int max_len)
33 {
34         const char *mtdids, *equal, *comma, *dev_id, *mtd_id;
35         int dev_id_len, mtd_id_len;
36
37         mtdids = env_get("mtdids");
38         if (!mtdids)
39                 return -EINVAL;
40
41         do {
42                 /* Find the '=' sign */
43                 dev_id = mtdids;
44                 equal = strchr(dev_id, '=');
45                 if (!equal)
46                         break;
47                 dev_id_len = equal - mtdids;
48                 mtd_id = equal + 1;
49
50                 /* Find the end of the tupple */
51                 comma = strchr(mtdids, ',');
52                 if (comma)
53                         mtd_id_len = comma - mtd_id;
54                 else
55                         mtd_id_len = &mtdids[strlen(mtdids)] - mtd_id + 1;
56
57                 if (!dev_id_len || !mtd_id_len)
58                         return -EINVAL;
59
60                 if (dev_id_len + 1 > max_len)
61                         continue;
62
63                 /* Compare the name we search with the current mtd_id */
64                 if (!strncmp(mtdname, mtd_id, mtd_id_len)) {
65                         strncpy(altname, dev_id, dev_id_len);
66                         altname[dev_id_len] = 0;
67
68                         return 0;
69                 }
70
71                 /* Go to the next tupple */
72                 mtdids = comma + 1;
73         } while (comma);
74
75         return -EINVAL;
76 }
77
78 #if IS_ENABLED(CONFIG_MTD)
79 static void mtd_probe_uclass_mtd_devs(void)
80 {
81         struct udevice *dev;
82         int idx = 0;
83
84         /* Probe devices with DM compliant drivers */
85         while (!uclass_find_device(UCLASS_MTD, idx, &dev) && dev) {
86                 mtd_probe(dev);
87                 idx++;
88         }
89 }
90 #else
91 static void mtd_probe_uclass_mtd_devs(void) { }
92 #endif
93
94 #if defined(CONFIG_MTD_PARTITIONS)
95 int mtd_probe_devices(void)
96 {
97         static char *old_mtdparts;
98         static char *old_mtdids;
99         const char *mtdparts = env_get("mtdparts");
100         const char *mtdids = env_get("mtdids");
101         bool remaining_partitions = true;
102         struct mtd_info *mtd;
103
104         mtd_probe_uclass_mtd_devs();
105
106         /* Check if mtdparts/mtdids changed since last call, otherwise: exit */
107         if ((!mtdparts && !old_mtdparts && !mtdids && !old_mtdids) ||
108             (mtdparts && old_mtdparts && mtdids && old_mtdids &&
109              !strcmp(mtdparts, old_mtdparts) &&
110              !strcmp(mtdids, old_mtdids)))
111                 return 0;
112
113         /* Update the local copy of mtdparts */
114         free(old_mtdparts);
115         free(old_mtdids);
116         old_mtdparts = strdup(mtdparts);
117         old_mtdids = strdup(mtdids);
118
119         /* If at least one partition is still in use, do not delete anything */
120         mtd_for_each_device(mtd) {
121                 if (mtd->usecount) {
122                         printf("Partition \"%s\" already in use, aborting\n",
123                                mtd->name);
124                         return -EACCES;
125                 }
126         }
127
128         /*
129          * Everything looks clear, remove all partitions. It is not safe to
130          * remove entries from the mtd_for_each_device loop as it uses idr
131          * indexes and the partitions removal is done in bulk (all partitions of
132          * one device at the same time), so break and iterate from start each
133          * time a new partition is found and deleted.
134          */
135         while (remaining_partitions) {
136                 remaining_partitions = false;
137                 mtd_for_each_device(mtd) {
138                         if (!mtd_is_partition(mtd) && mtd_has_partitions(mtd)) {
139                                 del_mtd_partitions(mtd);
140                                 remaining_partitions = true;
141                                 break;
142                         }
143                 }
144         }
145
146         /* If either mtdparts or mtdids is empty, then exit */
147         if (!mtdparts || !mtdids)
148                 return 0;
149
150         /* Start the parsing by ignoring the extra 'mtdparts=' prefix, if any */
151         if (strstr(mtdparts, "mtdparts="))
152                 mtdparts += 9;
153
154         /* For each MTD device in mtdparts */
155         while (mtdparts[0] != '\0') {
156                 char mtd_name[MTD_NAME_MAX_LEN], *colon;
157                 struct mtd_partition *parts;
158                 int mtd_name_len, nparts;
159                 int ret;
160
161                 colon = strchr(mtdparts, ':');
162                 if (!colon) {
163                         printf("Wrong mtdparts: %s\n", mtdparts);
164                         return -EINVAL;
165                 }
166
167                 mtd_name_len = colon - mtdparts;
168                 strncpy(mtd_name, mtdparts, mtd_name_len);
169                 mtd_name[mtd_name_len] = '\0';
170                 /* Move the pointer forward (including the ':') */
171                 mtdparts += mtd_name_len + 1;
172                 mtd = get_mtd_device_nm(mtd_name);
173                 if (IS_ERR_OR_NULL(mtd)) {
174                         char linux_name[MTD_NAME_MAX_LEN];
175
176                         /*
177                          * The MTD device named "mtd_name" does not exist. Try
178                          * to find a correspondance with an MTD device having
179                          * the same type and number as defined in the mtdids.
180                          */
181                         debug("No device named %s\n", mtd_name);
182                         ret = mtd_search_alternate_name(mtd_name, linux_name,
183                                                         MTD_NAME_MAX_LEN);
184                         if (!ret)
185                                 mtd = get_mtd_device_nm(linux_name);
186
187                         /*
188                          * If no device could be found, move the mtdparts
189                          * pointer forward until the next set of partitions.
190                          */
191                         if (ret || IS_ERR_OR_NULL(mtd)) {
192                                 printf("Could not find a valid device for %s\n",
193                                        mtd_name);
194                                 mtdparts = strchr(mtdparts, ';');
195                                 if (mtdparts)
196                                         mtdparts++;
197
198                                 continue;
199                         }
200                 }
201
202                 /*
203                  * Parse the MTD device partitions. It will update the mtdparts
204                  * pointer, create an array of parts (that must be freed), and
205                  * return the number of partition structures in the array.
206                  */
207                 ret = mtd_parse_partitions(mtd, &mtdparts, &parts, &nparts);
208                 if (ret) {
209                         printf("Could not parse device %s\n", mtd->name);
210                         put_mtd_device(mtd);
211                         return -EINVAL;
212                 }
213
214                 if (!nparts)
215                         continue;
216
217                 /* Create the new MTD partitions */
218                 add_mtd_partitions(mtd, parts, nparts);
219
220                 /* Free the structures allocated during the parsing */
221                 mtd_free_parsed_partitions(parts, nparts);
222
223                 put_mtd_device(mtd);
224         }
225
226         return 0;
227 }
228 #else
229 int mtd_probe_devices(void)
230 {
231         mtd_probe_uclass_mtd_devs();
232
233         return 0;
234 }
235 #endif /* defined(CONFIG_MTD_PARTITIONS) */
236
237 /* Legacy */
238
239 static int get_part(const char *partname, int *idx, loff_t *off, loff_t *size,
240                 loff_t *maxsize, int devtype)
241 {
242 #ifdef CONFIG_CMD_MTDPARTS
243         struct mtd_device *dev;
244         struct part_info *part;
245         u8 pnum;
246         int ret;
247
248         ret = mtdparts_init();
249         if (ret)
250                 return ret;
251
252         ret = find_dev_and_part(partname, &dev, &pnum, &part);
253         if (ret)
254                 return ret;
255
256         if (dev->id->type != devtype) {
257                 printf("not same typ %d != %d\n", dev->id->type, devtype);
258                 return -1;
259         }
260
261         *off = part->offset;
262         *size = part->size;
263         *maxsize = part->size;
264         *idx = dev->id->num;
265
266         return 0;
267 #else
268         puts("mtdparts support missing.\n");
269         return -1;
270 #endif
271 }
272
273 int mtd_arg_off(const char *arg, int *idx, loff_t *off, loff_t *size,
274                 loff_t *maxsize, int devtype, uint64_t chipsize)
275 {
276         if (!str2off(arg, off))
277                 return get_part(arg, idx, off, size, maxsize, devtype);
278
279         if (*off >= chipsize) {
280                 puts("Offset exceeds device limit\n");
281                 return -1;
282         }
283
284         *maxsize = chipsize - *off;
285         *size = *maxsize;
286         return 0;
287 }
288
289 int mtd_arg_off_size(int argc, char *const argv[], int *idx, loff_t *off,
290                      loff_t *size, loff_t *maxsize, int devtype,
291                      uint64_t chipsize)
292 {
293         int ret;
294
295         if (argc == 0) {
296                 *off = 0;
297                 *size = chipsize;
298                 *maxsize = *size;
299                 goto print;
300         }
301
302         ret = mtd_arg_off(argv[0], idx, off, size, maxsize, devtype,
303                           chipsize);
304         if (ret)
305                 return ret;
306
307         if (argc == 1)
308                 goto print;
309
310         if (!str2off(argv[1], size)) {
311                 printf("'%s' is not a number\n", argv[1]);
312                 return -1;
313         }
314
315         if (*size > *maxsize) {
316                 puts("Size exceeds partition or device limit\n");
317                 return -1;
318         }
319
320 print:
321         printf("device %d ", *idx);
322         if (*size == chipsize)
323                 puts("whole chip\n");
324         else
325                 printf("offset 0x%llx, size 0x%llx\n",
326                        (unsigned long long)*off, (unsigned long long)*size);
327         return 0;
328 }