]>
Commit | Line | Data |
---|---|---|
68d7d651 SR |
1 | /* |
2 | * (C) Copyright 2002 | |
3 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. | |
4 | * | |
5 | * (C) Copyright 2002 | |
6 | * Robert Schwebel, Pengutronix, <r.schwebel@pengutronix.de> | |
7 | * | |
8 | * (C) Copyright 2003 | |
9 | * Kai-Uwe Bloem, Auerswald GmbH & Co KG, <linux-development@auerswald.de> | |
10 | * | |
11 | * (C) Copyright 2005 | |
12 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. | |
13 | * | |
14 | * Added support for reading flash partition table from environment. | |
15 | * Parsing routines are based on driver/mtd/cmdline.c from the linux 2.4 | |
16 | * kernel tree. | |
17 | * | |
ca75b20e BG |
18 | * (C) Copyright 2008 |
19 | * Harald Welte, OpenMoko, Inc., Harald Welte <laforge@openmoko.org> | |
20 | * | |
68d7d651 SR |
21 | * $Id: cmdlinepart.c,v 1.17 2004/11/26 11:18:47 lavinen Exp $ |
22 | * Copyright 2002 SYSGO Real-Time Solutions GmbH | |
23 | * | |
1a459660 | 24 | * SPDX-License-Identifier: GPL-2.0+ |
68d7d651 SR |
25 | */ |
26 | ||
27 | /* | |
28 | * Three environment variables are used by the parsing routines: | |
29 | * | |
30 | * 'partition' - keeps current partition identifier | |
31 | * | |
32 | * partition := <part-id> | |
33 | * <part-id> := <dev-id>,part_num | |
34 | * | |
35 | * | |
36 | * 'mtdids' - linux kernel mtd device id <-> u-boot device id mapping | |
37 | * | |
38 | * mtdids=<idmap>[,<idmap>,...] | |
39 | * | |
40 | * <idmap> := <dev-id>=<mtd-id> | |
41 | * <dev-id> := 'nand'|'nor'|'onenand'<dev-num> | |
42 | * <dev-num> := mtd device number, 0... | |
43 | * <mtd-id> := unique device tag used by linux kernel to find mtd device (mtd->name) | |
44 | * | |
45 | * | |
46 | * 'mtdparts' - partition list | |
47 | * | |
48 | * mtdparts=mtdparts=<mtd-def>[;<mtd-def>...] | |
49 | * | |
50 | * <mtd-def> := <mtd-id>:<part-def>[,<part-def>...] | |
51 | * <mtd-id> := unique device tag used by linux kernel to find mtd device (mtd->name) | |
52 | * <part-def> := <size>[@<offset>][<name>][<ro-flag>] | |
53 | * <size> := standard linux memsize OR '-' to denote all remaining space | |
54 | * <offset> := partition start offset within the device | |
55 | * <name> := '(' NAME ')' | |
56 | * <ro-flag> := when set to 'ro' makes partition read-only (not used, passed to kernel) | |
57 | * | |
58 | * Notes: | |
59 | * - each <mtd-id> used in mtdparts must albo exist in 'mtddis' mapping | |
60 | * - if the above variables are not set defaults for a given target are used | |
61 | * | |
62 | * Examples: | |
63 | * | |
64 | * 1 NOR Flash, with 1 single writable partition: | |
65 | * mtdids=nor0=edb7312-nor | |
66 | * mtdparts=mtdparts=edb7312-nor:- | |
67 | * | |
68 | * 1 NOR Flash with 2 partitions, 1 NAND with one | |
69 | * mtdids=nor0=edb7312-nor,nand0=edb7312-nand | |
70 | * mtdparts=mtdparts=edb7312-nor:256k(ARMboot)ro,-(root);edb7312-nand:-(home) | |
71 | * | |
72 | */ | |
73 | ||
68d7d651 SR |
74 | #include <common.h> |
75 | #include <command.h> | |
76 | #include <malloc.h> | |
b93b24bf | 77 | #include <jffs2/load_kernel.h> |
68d7d651 SR |
78 | #include <linux/list.h> |
79 | #include <linux/ctype.h> | |
864aa034 SR |
80 | #include <linux/err.h> |
81 | #include <linux/mtd/mtd.h> | |
68d7d651 SR |
82 | |
83 | #if defined(CONFIG_CMD_NAND) | |
68d7d651 SR |
84 | #include <linux/mtd/nand.h> |
85 | #include <nand.h> | |
68d7d651 SR |
86 | #endif |
87 | ||
88 | #if defined(CONFIG_CMD_ONENAND) | |
68d7d651 SR |
89 | #include <linux/mtd/onenand.h> |
90 | #include <onenand_uboot.h> | |
91 | #endif | |
92 | ||
a7eb1d66 JH |
93 | DECLARE_GLOBAL_DATA_PTR; |
94 | ||
68d7d651 SR |
95 | /* special size referring to all the remaining space in a partition */ |
96 | #define SIZE_REMAINING 0xFFFFFFFF | |
97 | ||
98 | /* special offset value, it is used when not provided by user | |
99 | * | |
100 | * this value is used temporarily during parsing, later such offests | |
101 | * are recalculated */ | |
102 | #define OFFSET_NOT_SPECIFIED 0xFFFFFFFF | |
103 | ||
104 | /* minimum partition size */ | |
105 | #define MIN_PART_SIZE 4096 | |
106 | ||
107 | /* this flag needs to be set in part_info struct mask_flags | |
108 | * field for read-only partitions */ | |
109 | #define MTD_WRITEABLE_CMD 1 | |
110 | ||
111 | /* default values for mtdids and mtdparts variables */ | |
112 | #if defined(MTDIDS_DEFAULT) | |
113 | static const char *const mtdids_default = MTDIDS_DEFAULT; | |
114 | #else | |
68d7d651 SR |
115 | static const char *const mtdids_default = NULL; |
116 | #endif | |
117 | ||
118 | #if defined(MTDPARTS_DEFAULT) | |
119 | static const char *const mtdparts_default = MTDPARTS_DEFAULT; | |
120 | #else | |
68d7d651 SR |
121 | static const char *const mtdparts_default = NULL; |
122 | #endif | |
123 | ||
124 | /* copies of last seen 'mtdids', 'mtdparts' and 'partition' env variables */ | |
125 | #define MTDIDS_MAXLEN 128 | |
126 | #define MTDPARTS_MAXLEN 512 | |
127 | #define PARTITION_MAXLEN 16 | |
128 | static char last_ids[MTDIDS_MAXLEN]; | |
129 | static char last_parts[MTDPARTS_MAXLEN]; | |
130 | static char last_partition[PARTITION_MAXLEN]; | |
131 | ||
132 | /* low level jffs2 cache cleaning routine */ | |
133 | extern void jffs2_free_cache(struct part_info *part); | |
134 | ||
135 | /* mtdids mapping list, filled by parse_ids() */ | |
088f1b19 | 136 | static struct list_head mtdids; |
68d7d651 SR |
137 | |
138 | /* device/partition list, parse_cmdline() parses into here */ | |
088f1b19 | 139 | static struct list_head devices; |
68d7d651 SR |
140 | |
141 | /* current active device and partition number */ | |
76b5883d SR |
142 | struct mtd_device *current_mtd_dev = NULL; |
143 | u8 current_mtd_partnum = 0; | |
68d7d651 SR |
144 | |
145 | static struct part_info* mtd_part_info(struct mtd_device *dev, unsigned int part_num); | |
146 | ||
147 | /* command line only routines */ | |
148 | static struct mtdids* id_find_by_mtd_id(const char *mtd_id, unsigned int mtd_id_len); | |
149 | static int device_del(struct mtd_device *dev); | |
150 | ||
151 | /** | |
152 | * Parses a string into a number. The number stored at ptr is | |
153 | * potentially suffixed with K (for kilobytes, or 1024 bytes), | |
154 | * M (for megabytes, or 1048576 bytes), or G (for gigabytes, or | |
155 | * 1073741824). If the number is suffixed with K, M, or G, then | |
156 | * the return value is the number multiplied by one kilobyte, one | |
157 | * megabyte, or one gigabyte, respectively. | |
158 | * | |
159 | * @param ptr where parse begins | |
160 | * @param retptr output pointer to next char after parse completes (output) | |
161 | * @return resulting unsigned int | |
162 | */ | |
163 | static unsigned long memsize_parse (const char *const ptr, const char **retptr) | |
164 | { | |
165 | unsigned long ret = simple_strtoul(ptr, (char **)retptr, 0); | |
166 | ||
167 | switch (**retptr) { | |
168 | case 'G': | |
169 | case 'g': | |
170 | ret <<= 10; | |
171 | case 'M': | |
172 | case 'm': | |
173 | ret <<= 10; | |
174 | case 'K': | |
175 | case 'k': | |
176 | ret <<= 10; | |
177 | (*retptr)++; | |
178 | default: | |
179 | break; | |
180 | } | |
181 | ||
182 | return ret; | |
183 | } | |
184 | ||
185 | /** | |
186 | * Format string describing supplied size. This routine does the opposite job | |
187 | * to memsize_parse(). Size in bytes is converted to string and if possible | |
188 | * shortened by using k (kilobytes), m (megabytes) or g (gigabytes) suffix. | |
189 | * | |
190 | * Note, that this routine does not check for buffer overflow, it's the caller | |
191 | * who must assure enough space. | |
192 | * | |
193 | * @param buf output buffer | |
194 | * @param size size to be converted to string | |
195 | */ | |
196 | static void memsize_format(char *buf, u32 size) | |
197 | { | |
198 | #define SIZE_GB ((u32)1024*1024*1024) | |
199 | #define SIZE_MB ((u32)1024*1024) | |
200 | #define SIZE_KB ((u32)1024) | |
201 | ||
202 | if ((size % SIZE_GB) == 0) | |
203 | sprintf(buf, "%ug", size/SIZE_GB); | |
204 | else if ((size % SIZE_MB) == 0) | |
205 | sprintf(buf, "%um", size/SIZE_MB); | |
206 | else if (size % SIZE_KB == 0) | |
207 | sprintf(buf, "%uk", size/SIZE_KB); | |
208 | else | |
209 | sprintf(buf, "%u", size); | |
210 | } | |
211 | ||
212 | /** | |
213 | * This routine does global indexing of all partitions. Resulting index for | |
214 | * current partition is saved in 'mtddevnum'. Current partition name in | |
215 | * 'mtddevname'. | |
216 | */ | |
217 | static void index_partitions(void) | |
218 | { | |
68d7d651 SR |
219 | u16 mtddevnum; |
220 | struct part_info *part; | |
221 | struct list_head *dentry; | |
222 | struct mtd_device *dev; | |
223 | ||
e1d2950d | 224 | debug("--- index partitions ---\n"); |
68d7d651 | 225 | |
76b5883d | 226 | if (current_mtd_dev) { |
68d7d651 SR |
227 | mtddevnum = 0; |
228 | list_for_each(dentry, &devices) { | |
229 | dev = list_entry(dentry, struct mtd_device, link); | |
76b5883d SR |
230 | if (dev == current_mtd_dev) { |
231 | mtddevnum += current_mtd_partnum; | |
41ef372c | 232 | setenv_ulong("mtddevnum", mtddevnum); |
68d7d651 SR |
233 | break; |
234 | } | |
235 | mtddevnum += dev->num_parts; | |
236 | } | |
237 | ||
76b5883d | 238 | part = mtd_part_info(current_mtd_dev, current_mtd_partnum); |
68d7d651 SR |
239 | setenv("mtddevname", part->name); |
240 | ||
e1d2950d | 241 | debug("=> mtddevnum %d,\n=> mtddevname %s\n", mtddevnum, part->name); |
68d7d651 SR |
242 | } else { |
243 | setenv("mtddevnum", NULL); | |
244 | setenv("mtddevname", NULL); | |
245 | ||
e1d2950d | 246 | debug("=> mtddevnum NULL\n=> mtddevname NULL\n"); |
68d7d651 SR |
247 | } |
248 | } | |
249 | ||
250 | /** | |
251 | * Save current device and partition in environment variable 'partition'. | |
252 | */ | |
253 | static void current_save(void) | |
254 | { | |
255 | char buf[16]; | |
256 | ||
e1d2950d | 257 | debug("--- current_save ---\n"); |
68d7d651 | 258 | |
76b5883d SR |
259 | if (current_mtd_dev) { |
260 | sprintf(buf, "%s%d,%d", MTD_DEV_TYPE(current_mtd_dev->id->type), | |
261 | current_mtd_dev->id->num, current_mtd_partnum); | |
68d7d651 SR |
262 | |
263 | setenv("partition", buf); | |
264 | strncpy(last_partition, buf, 16); | |
265 | ||
e1d2950d | 266 | debug("=> partition %s\n", buf); |
68d7d651 SR |
267 | } else { |
268 | setenv("partition", NULL); | |
269 | last_partition[0] = '\0'; | |
270 | ||
e1d2950d | 271 | debug("=> partition NULL\n"); |
68d7d651 SR |
272 | } |
273 | index_partitions(); | |
274 | } | |
275 | ||
0a026d3e BG |
276 | |
277 | /** | |
278 | * Produce a mtd_info given a type and num. | |
279 | * | |
280 | * @param type mtd type | |
281 | * @param num mtd number | |
282 | * @param mtd a pointer to an mtd_info instance (output) | |
283 | * @return 0 if device is valid, 1 otherwise | |
284 | */ | |
285 | static int get_mtd_info(u8 type, u8 num, struct mtd_info **mtd) | |
286 | { | |
287 | char mtd_dev[16]; | |
288 | ||
289 | sprintf(mtd_dev, "%s%d", MTD_DEV_TYPE(type), num); | |
290 | *mtd = get_mtd_device_nm(mtd_dev); | |
291 | if (IS_ERR(*mtd)) { | |
292 | printf("Device %s not found!\n", mtd_dev); | |
293 | return 1; | |
294 | } | |
295 | ||
296 | return 0; | |
297 | } | |
298 | ||
68d7d651 | 299 | /** |
864aa034 SR |
300 | * Performs sanity check for supplied flash partition. |
301 | * Table of existing MTD flash devices is searched and partition device | |
302 | * is located. Alignment with the granularity of nand erasesize is verified. | |
68d7d651 SR |
303 | * |
304 | * @param id of the parent device | |
305 | * @param part partition to validate | |
306 | * @return 0 if partition is valid, 1 otherwise | |
307 | */ | |
864aa034 | 308 | static int part_validate_eraseblock(struct mtdids *id, struct part_info *part) |
68d7d651 | 309 | { |
0a026d3e | 310 | struct mtd_info *mtd = NULL; |
864aa034 SR |
311 | int i, j; |
312 | ulong start; | |
313 | ||
0a026d3e | 314 | if (get_mtd_info(id->type, id->num, &mtd)) |
68d7d651 | 315 | return 1; |
68d7d651 | 316 | |
864aa034 | 317 | part->sector_size = mtd->erasesize; |
68d7d651 | 318 | |
864aa034 SR |
319 | if (!mtd->numeraseregions) { |
320 | /* | |
321 | * Only one eraseregion (NAND, OneNAND or uniform NOR), | |
322 | * checking for alignment is easy here | |
323 | */ | |
324 | if ((unsigned long)part->offset % mtd->erasesize) { | |
325 | printf("%s%d: partition (%s) start offset" | |
326 | "alignment incorrect\n", | |
327 | MTD_DEV_TYPE(id->type), id->num, part->name); | |
328 | return 1; | |
329 | } | |
68d7d651 | 330 | |
864aa034 SR |
331 | if (part->size % mtd->erasesize) { |
332 | printf("%s%d: partition (%s) size alignment incorrect\n", | |
333 | MTD_DEV_TYPE(id->type), id->num, part->name); | |
334 | return 1; | |
335 | } | |
336 | } else { | |
337 | /* | |
338 | * Multiple eraseregions (non-uniform NOR), | |
339 | * checking for alignment is more complex here | |
340 | */ | |
341 | ||
342 | /* Check start alignment */ | |
343 | for (i = 0; i < mtd->numeraseregions; i++) { | |
344 | start = mtd->eraseregions[i].offset; | |
345 | for (j = 0; j < mtd->eraseregions[i].numblocks; j++) { | |
346 | if (part->offset == start) | |
347 | goto start_ok; | |
348 | start += mtd->eraseregions[i].erasesize; | |
349 | } | |
350 | } | |
68d7d651 | 351 | |
68d7d651 | 352 | printf("%s%d: partition (%s) start offset alignment incorrect\n", |
864aa034 | 353 | MTD_DEV_TYPE(id->type), id->num, part->name); |
68d7d651 | 354 | return 1; |
68d7d651 | 355 | |
864aa034 | 356 | start_ok: |
68d7d651 | 357 | |
864aa034 SR |
358 | /* Check end/size alignment */ |
359 | for (i = 0; i < mtd->numeraseregions; i++) { | |
360 | start = mtd->eraseregions[i].offset; | |
361 | for (j = 0; j < mtd->eraseregions[i].numblocks; j++) { | |
362 | if ((part->offset + part->size) == start) | |
363 | goto end_ok; | |
364 | start += mtd->eraseregions[i].erasesize; | |
365 | } | |
366 | } | |
367 | /* Check last sector alignment */ | |
368 | if ((part->offset + part->size) == start) | |
369 | goto end_ok; | |
68d7d651 | 370 | |
68d7d651 | 371 | printf("%s%d: partition (%s) size alignment incorrect\n", |
864aa034 | 372 | MTD_DEV_TYPE(id->type), id->num, part->name); |
68d7d651 | 373 | return 1; |
864aa034 SR |
374 | |
375 | end_ok: | |
376 | return 0; | |
68d7d651 SR |
377 | } |
378 | ||
379 | return 0; | |
68d7d651 SR |
380 | } |
381 | ||
382 | ||
383 | /** | |
384 | * Performs sanity check for supplied partition. Offset and size are verified | |
385 | * to be within valid range. Partition type is checked and either | |
386 | * parts_validate_nor() or parts_validate_nand() is called with the argument | |
387 | * of part. | |
388 | * | |
389 | * @param id of the parent device | |
390 | * @param part partition to validate | |
391 | * @return 0 if partition is valid, 1 otherwise | |
392 | */ | |
393 | static int part_validate(struct mtdids *id, struct part_info *part) | |
394 | { | |
395 | if (part->size == SIZE_REMAINING) | |
396 | part->size = id->size - part->offset; | |
397 | ||
398 | if (part->offset > id->size) { | |
399 | printf("%s: offset %08x beyond flash size %08x\n", | |
400 | id->mtd_id, part->offset, id->size); | |
401 | return 1; | |
402 | } | |
403 | ||
404 | if ((part->offset + part->size) <= part->offset) { | |
405 | printf("%s%d: partition (%s) size too big\n", | |
406 | MTD_DEV_TYPE(id->type), id->num, part->name); | |
407 | return 1; | |
408 | } | |
409 | ||
410 | if (part->offset + part->size > id->size) { | |
411 | printf("%s: partitioning exceeds flash size\n", id->mtd_id); | |
412 | return 1; | |
413 | } | |
414 | ||
864aa034 SR |
415 | /* |
416 | * Now we need to check if the partition starts and ends on | |
417 | * sector (eraseblock) regions | |
418 | */ | |
419 | return part_validate_eraseblock(id, part); | |
68d7d651 SR |
420 | } |
421 | ||
422 | /** | |
423 | * Delete selected partition from the partion list of the specified device. | |
424 | * | |
425 | * @param dev device to delete partition from | |
426 | * @param part partition to delete | |
427 | * @return 0 on success, 1 otherwise | |
428 | */ | |
429 | static int part_del(struct mtd_device *dev, struct part_info *part) | |
430 | { | |
431 | u8 current_save_needed = 0; | |
432 | ||
433 | /* if there is only one partition, remove whole device */ | |
434 | if (dev->num_parts == 1) | |
435 | return device_del(dev); | |
436 | ||
437 | /* otherwise just delete this partition */ | |
438 | ||
76b5883d | 439 | if (dev == current_mtd_dev) { |
68d7d651 SR |
440 | /* we are modyfing partitions for the current device, |
441 | * update current */ | |
442 | struct part_info *curr_pi; | |
76b5883d | 443 | curr_pi = mtd_part_info(current_mtd_dev, current_mtd_partnum); |
68d7d651 SR |
444 | |
445 | if (curr_pi) { | |
446 | if (curr_pi == part) { | |
447 | printf("current partition deleted, resetting current to 0\n"); | |
76b5883d | 448 | current_mtd_partnum = 0; |
68d7d651 | 449 | } else if (part->offset <= curr_pi->offset) { |
76b5883d | 450 | current_mtd_partnum--; |
68d7d651 SR |
451 | } |
452 | current_save_needed = 1; | |
453 | } | |
454 | } | |
455 | ||
68d7d651 SR |
456 | list_del(&part->link); |
457 | free(part); | |
458 | dev->num_parts--; | |
459 | ||
460 | if (current_save_needed > 0) | |
461 | current_save(); | |
462 | else | |
463 | index_partitions(); | |
464 | ||
465 | return 0; | |
466 | } | |
467 | ||
468 | /** | |
469 | * Delete all partitions from parts head list, free memory. | |
470 | * | |
471 | * @param head list of partitions to delete | |
472 | */ | |
473 | static void part_delall(struct list_head *head) | |
474 | { | |
475 | struct list_head *entry, *n; | |
476 | struct part_info *part_tmp; | |
477 | ||
478 | /* clean tmp_list and free allocated memory */ | |
479 | list_for_each_safe(entry, n, head) { | |
480 | part_tmp = list_entry(entry, struct part_info, link); | |
481 | ||
68d7d651 SR |
482 | list_del(entry); |
483 | free(part_tmp); | |
484 | } | |
485 | } | |
486 | ||
487 | /** | |
488 | * Add new partition to the supplied partition list. Make sure partitions are | |
489 | * sorted by offset in ascending order. | |
490 | * | |
491 | * @param head list this partition is to be added to | |
492 | * @param new partition to be added | |
493 | */ | |
494 | static int part_sort_add(struct mtd_device *dev, struct part_info *part) | |
495 | { | |
496 | struct list_head *entry; | |
497 | struct part_info *new_pi, *curr_pi; | |
498 | ||
499 | /* link partition to parrent dev */ | |
500 | part->dev = dev; | |
501 | ||
502 | if (list_empty(&dev->parts)) { | |
e1d2950d | 503 | debug("part_sort_add: list empty\n"); |
68d7d651 SR |
504 | list_add(&part->link, &dev->parts); |
505 | dev->num_parts++; | |
506 | index_partitions(); | |
507 | return 0; | |
508 | } | |
509 | ||
510 | new_pi = list_entry(&part->link, struct part_info, link); | |
511 | ||
512 | /* get current partition info if we are updating current device */ | |
513 | curr_pi = NULL; | |
76b5883d SR |
514 | if (dev == current_mtd_dev) |
515 | curr_pi = mtd_part_info(current_mtd_dev, current_mtd_partnum); | |
68d7d651 SR |
516 | |
517 | list_for_each(entry, &dev->parts) { | |
518 | struct part_info *pi; | |
519 | ||
520 | pi = list_entry(entry, struct part_info, link); | |
521 | ||
522 | /* be compliant with kernel cmdline, allow only one partition at offset zero */ | |
523 | if ((new_pi->offset == pi->offset) && (pi->offset == 0)) { | |
524 | printf("cannot add second partition at offset 0\n"); | |
525 | return 1; | |
526 | } | |
527 | ||
528 | if (new_pi->offset <= pi->offset) { | |
529 | list_add_tail(&part->link, entry); | |
530 | dev->num_parts++; | |
531 | ||
532 | if (curr_pi && (pi->offset <= curr_pi->offset)) { | |
533 | /* we are modyfing partitions for the current | |
534 | * device, update current */ | |
76b5883d | 535 | current_mtd_partnum++; |
68d7d651 SR |
536 | current_save(); |
537 | } else { | |
538 | index_partitions(); | |
539 | } | |
540 | return 0; | |
541 | } | |
542 | } | |
543 | ||
544 | list_add_tail(&part->link, &dev->parts); | |
545 | dev->num_parts++; | |
546 | index_partitions(); | |
547 | return 0; | |
548 | } | |
549 | ||
550 | /** | |
551 | * Add provided partition to the partition list of a given device. | |
552 | * | |
553 | * @param dev device to which partition is added | |
554 | * @param part partition to be added | |
555 | * @return 0 on success, 1 otherwise | |
556 | */ | |
557 | static int part_add(struct mtd_device *dev, struct part_info *part) | |
558 | { | |
559 | /* verify alignment and size */ | |
560 | if (part_validate(dev->id, part) != 0) | |
561 | return 1; | |
562 | ||
563 | /* partition is ok, add it to the list */ | |
564 | if (part_sort_add(dev, part) != 0) | |
565 | return 1; | |
566 | ||
567 | return 0; | |
568 | } | |
569 | ||
570 | /** | |
571 | * Parse one partition definition, allocate memory and return pointer to this | |
572 | * location in retpart. | |
573 | * | |
574 | * @param partdef pointer to the partition definition string i.e. <part-def> | |
575 | * @param ret output pointer to next char after parse completes (output) | |
576 | * @param retpart pointer to the allocated partition (output) | |
577 | * @return 0 on success, 1 otherwise | |
578 | */ | |
579 | static int part_parse(const char *const partdef, const char **ret, struct part_info **retpart) | |
580 | { | |
581 | struct part_info *part; | |
582 | unsigned long size; | |
583 | unsigned long offset; | |
584 | const char *name; | |
585 | int name_len; | |
586 | unsigned int mask_flags; | |
587 | const char *p; | |
588 | ||
589 | p = partdef; | |
590 | *retpart = NULL; | |
591 | *ret = NULL; | |
592 | ||
593 | /* fetch the partition size */ | |
594 | if (*p == '-') { | |
595 | /* assign all remaining space to this partition */ | |
e1d2950d | 596 | debug("'-': remaining size assigned\n"); |
68d7d651 SR |
597 | size = SIZE_REMAINING; |
598 | p++; | |
599 | } else { | |
600 | size = memsize_parse(p, &p); | |
601 | if (size < MIN_PART_SIZE) { | |
602 | printf("partition size too small (%lx)\n", size); | |
603 | return 1; | |
604 | } | |
605 | } | |
606 | ||
607 | /* check for offset */ | |
608 | offset = OFFSET_NOT_SPECIFIED; | |
609 | if (*p == '@') { | |
610 | p++; | |
611 | offset = memsize_parse(p, &p); | |
612 | } | |
613 | ||
614 | /* now look for the name */ | |
615 | if (*p == '(') { | |
616 | name = ++p; | |
617 | if ((p = strchr(name, ')')) == NULL) { | |
618 | printf("no closing ) found in partition name\n"); | |
619 | return 1; | |
620 | } | |
621 | name_len = p - name + 1; | |
622 | if ((name_len - 1) == 0) { | |
623 | printf("empty partition name\n"); | |
624 | return 1; | |
625 | } | |
626 | p++; | |
627 | } else { | |
628 | /* 0x00000000@0x00000000 */ | |
629 | name_len = 22; | |
630 | name = NULL; | |
631 | } | |
632 | ||
633 | /* test for options */ | |
634 | mask_flags = 0; | |
635 | if (strncmp(p, "ro", 2) == 0) { | |
636 | mask_flags |= MTD_WRITEABLE_CMD; | |
637 | p += 2; | |
638 | } | |
639 | ||
640 | /* check for next partition definition */ | |
641 | if (*p == ',') { | |
642 | if (size == SIZE_REMAINING) { | |
643 | *ret = NULL; | |
644 | printf("no partitions allowed after a fill-up partition\n"); | |
645 | return 1; | |
646 | } | |
647 | *ret = ++p; | |
648 | } else if ((*p == ';') || (*p == '\0')) { | |
649 | *ret = p; | |
650 | } else { | |
651 | printf("unexpected character '%c' at the end of partition\n", *p); | |
652 | *ret = NULL; | |
653 | return 1; | |
654 | } | |
655 | ||
656 | /* allocate memory */ | |
657 | part = (struct part_info *)malloc(sizeof(struct part_info) + name_len); | |
658 | if (!part) { | |
659 | printf("out of memory\n"); | |
660 | return 1; | |
661 | } | |
662 | memset(part, 0, sizeof(struct part_info) + name_len); | |
663 | part->size = size; | |
664 | part->offset = offset; | |
665 | part->mask_flags = mask_flags; | |
666 | part->name = (char *)(part + 1); | |
667 | ||
668 | if (name) { | |
669 | /* copy user provided name */ | |
670 | strncpy(part->name, name, name_len - 1); | |
671 | part->auto_name = 0; | |
672 | } else { | |
673 | /* auto generated name in form of size@offset */ | |
674 | sprintf(part->name, "0x%08lx@0x%08lx", size, offset); | |
675 | part->auto_name = 1; | |
676 | } | |
677 | ||
678 | part->name[name_len - 1] = '\0'; | |
679 | INIT_LIST_HEAD(&part->link); | |
680 | ||
e1d2950d | 681 | debug("+ partition: name %-22s size 0x%08x offset 0x%08x mask flags %d\n", |
68d7d651 SR |
682 | part->name, part->size, |
683 | part->offset, part->mask_flags); | |
684 | ||
685 | *retpart = part; | |
686 | return 0; | |
687 | } | |
688 | ||
689 | /** | |
690 | * Check device number to be within valid range for given device type. | |
691 | * | |
0a026d3e BG |
692 | * @param type mtd type |
693 | * @param num mtd number | |
694 | * @param size a pointer to the size of the mtd device (output) | |
68d7d651 SR |
695 | * @return 0 if device is valid, 1 otherwise |
696 | */ | |
088f1b19 | 697 | static int mtd_device_validate(u8 type, u8 num, u32 *size) |
68d7d651 | 698 | { |
0a026d3e | 699 | struct mtd_info *mtd = NULL; |
68d7d651 | 700 | |
0a026d3e | 701 | if (get_mtd_info(type, num, &mtd)) |
864aa034 | 702 | return 1; |
68d7d651 | 703 | |
864aa034 | 704 | *size = mtd->size; |
68d7d651 | 705 | |
864aa034 | 706 | return 0; |
68d7d651 SR |
707 | } |
708 | ||
709 | /** | |
710 | * Delete all mtd devices from a supplied devices list, free memory allocated for | |
711 | * each device and delete all device partitions. | |
712 | * | |
713 | * @return 0 on success, 1 otherwise | |
714 | */ | |
715 | static int device_delall(struct list_head *head) | |
716 | { | |
717 | struct list_head *entry, *n; | |
718 | struct mtd_device *dev_tmp; | |
719 | ||
720 | /* clean devices list */ | |
721 | list_for_each_safe(entry, n, head) { | |
722 | dev_tmp = list_entry(entry, struct mtd_device, link); | |
723 | list_del(entry); | |
724 | part_delall(&dev_tmp->parts); | |
725 | free(dev_tmp); | |
726 | } | |
727 | INIT_LIST_HEAD(&devices); | |
728 | ||
729 | return 0; | |
730 | } | |
731 | ||
732 | /** | |
733 | * If provided device exists it's partitions are deleted, device is removed | |
734 | * from device list and device memory is freed. | |
735 | * | |
736 | * @param dev device to be deleted | |
737 | * @return 0 on success, 1 otherwise | |
738 | */ | |
739 | static int device_del(struct mtd_device *dev) | |
740 | { | |
741 | part_delall(&dev->parts); | |
742 | list_del(&dev->link); | |
743 | free(dev); | |
744 | ||
76b5883d | 745 | if (dev == current_mtd_dev) { |
68d7d651 SR |
746 | /* we just deleted current device */ |
747 | if (list_empty(&devices)) { | |
76b5883d | 748 | current_mtd_dev = NULL; |
68d7d651 SR |
749 | } else { |
750 | /* reset first partition from first dev from the | |
751 | * devices list as current */ | |
76b5883d SR |
752 | current_mtd_dev = list_entry(devices.next, struct mtd_device, link); |
753 | current_mtd_partnum = 0; | |
68d7d651 SR |
754 | } |
755 | current_save(); | |
756 | return 0; | |
757 | } | |
758 | ||
759 | index_partitions(); | |
760 | return 0; | |
761 | } | |
762 | ||
763 | /** | |
764 | * Search global device list and return pointer to the device of type and num | |
765 | * specified. | |
766 | * | |
767 | * @param type device type | |
768 | * @param num device number | |
769 | * @return NULL if requested device does not exist | |
770 | */ | |
3c950e2e | 771 | struct mtd_device *device_find(u8 type, u8 num) |
68d7d651 SR |
772 | { |
773 | struct list_head *entry; | |
774 | struct mtd_device *dev_tmp; | |
775 | ||
776 | list_for_each(entry, &devices) { | |
777 | dev_tmp = list_entry(entry, struct mtd_device, link); | |
778 | ||
779 | if ((dev_tmp->id->type == type) && (dev_tmp->id->num == num)) | |
780 | return dev_tmp; | |
781 | } | |
782 | ||
783 | return NULL; | |
784 | } | |
785 | ||
786 | /** | |
787 | * Add specified device to the global device list. | |
788 | * | |
789 | * @param dev device to be added | |
790 | */ | |
791 | static void device_add(struct mtd_device *dev) | |
792 | { | |
793 | u8 current_save_needed = 0; | |
794 | ||
795 | if (list_empty(&devices)) { | |
76b5883d SR |
796 | current_mtd_dev = dev; |
797 | current_mtd_partnum = 0; | |
68d7d651 SR |
798 | current_save_needed = 1; |
799 | } | |
800 | ||
801 | list_add_tail(&dev->link, &devices); | |
802 | ||
803 | if (current_save_needed > 0) | |
804 | current_save(); | |
805 | else | |
806 | index_partitions(); | |
807 | } | |
808 | ||
809 | /** | |
810 | * Parse device type, name and mtd-id. If syntax is ok allocate memory and | |
811 | * return pointer to the device structure. | |
812 | * | |
813 | * @param mtd_dev pointer to the device definition string i.e. <mtd-dev> | |
814 | * @param ret output pointer to next char after parse completes (output) | |
815 | * @param retdev pointer to the allocated device (output) | |
816 | * @return 0 on success, 1 otherwise | |
817 | */ | |
818 | static int device_parse(const char *const mtd_dev, const char **ret, struct mtd_device **retdev) | |
819 | { | |
820 | struct mtd_device *dev; | |
821 | struct part_info *part; | |
822 | struct mtdids *id; | |
823 | const char *mtd_id; | |
824 | unsigned int mtd_id_len; | |
419a1fe9 | 825 | const char *p; |
419a1fe9 | 826 | const char *pend; |
68d7d651 SR |
827 | LIST_HEAD(tmp_list); |
828 | struct list_head *entry, *n; | |
829 | u16 num_parts; | |
830 | u32 offset; | |
831 | int err = 1; | |
832 | ||
e1d2950d | 833 | debug("===device_parse===\n"); |
2697eff1 WD |
834 | |
835 | assert(retdev); | |
68d7d651 | 836 | *retdev = NULL; |
68d7d651 | 837 | |
2697eff1 WD |
838 | if (ret) |
839 | *ret = NULL; | |
68d7d651 SR |
840 | |
841 | /* fetch <mtd-id> */ | |
2697eff1 | 842 | mtd_id = p = mtd_dev; |
68d7d651 SR |
843 | if (!(p = strchr(mtd_id, ':'))) { |
844 | printf("no <mtd-id> identifier\n"); | |
845 | return 1; | |
846 | } | |
847 | mtd_id_len = p - mtd_id + 1; | |
848 | p++; | |
849 | ||
850 | /* verify if we have a valid device specified */ | |
851 | if ((id = id_find_by_mtd_id(mtd_id, mtd_id_len - 1)) == NULL) { | |
852 | printf("invalid mtd device '%.*s'\n", mtd_id_len - 1, mtd_id); | |
853 | return 1; | |
854 | } | |
855 | ||
419a1fe9 WD |
856 | #ifdef DEBUG |
857 | pend = strchr(p, ';'); | |
858 | #endif | |
e1d2950d | 859 | debug("dev type = %d (%s), dev num = %d, mtd-id = %s\n", |
68d7d651 SR |
860 | id->type, MTD_DEV_TYPE(id->type), |
861 | id->num, id->mtd_id); | |
e1d2950d | 862 | debug("parsing partitions %.*s\n", (pend ? pend - p : strlen(p)), p); |
68d7d651 SR |
863 | |
864 | ||
865 | /* parse partitions */ | |
866 | num_parts = 0; | |
867 | ||
868 | offset = 0; | |
869 | if ((dev = device_find(id->type, id->num)) != NULL) { | |
870 | /* if device already exists start at the end of the last partition */ | |
871 | part = list_entry(dev->parts.prev, struct part_info, link); | |
872 | offset = part->offset + part->size; | |
873 | } | |
874 | ||
875 | while (p && (*p != '\0') && (*p != ';')) { | |
876 | err = 1; | |
877 | if ((part_parse(p, &p, &part) != 0) || (!part)) | |
878 | break; | |
879 | ||
880 | /* calculate offset when not specified */ | |
881 | if (part->offset == OFFSET_NOT_SPECIFIED) | |
882 | part->offset = offset; | |
883 | else | |
884 | offset = part->offset; | |
885 | ||
886 | /* verify alignment and size */ | |
887 | if (part_validate(id, part) != 0) | |
888 | break; | |
889 | ||
890 | offset += part->size; | |
891 | ||
892 | /* partition is ok, add it to the list */ | |
893 | list_add_tail(&part->link, &tmp_list); | |
894 | num_parts++; | |
895 | err = 0; | |
896 | } | |
897 | if (err == 1) { | |
898 | part_delall(&tmp_list); | |
899 | return 1; | |
900 | } | |
901 | ||
902 | if (num_parts == 0) { | |
903 | printf("no partitions for device %s%d (%s)\n", | |
904 | MTD_DEV_TYPE(id->type), id->num, id->mtd_id); | |
905 | return 1; | |
906 | } | |
907 | ||
e1d2950d | 908 | debug("\ntotal partitions: %d\n", num_parts); |
68d7d651 SR |
909 | |
910 | /* check for next device presence */ | |
911 | if (p) { | |
912 | if (*p == ';') { | |
2697eff1 WD |
913 | if (ret) |
914 | *ret = ++p; | |
68d7d651 | 915 | } else if (*p == '\0') { |
2697eff1 WD |
916 | if (ret) |
917 | *ret = p; | |
68d7d651 SR |
918 | } else { |
919 | printf("unexpected character '%c' at the end of device\n", *p); | |
2697eff1 WD |
920 | if (ret) |
921 | *ret = NULL; | |
68d7d651 SR |
922 | return 1; |
923 | } | |
924 | } | |
925 | ||
926 | /* allocate memory for mtd_device structure */ | |
927 | if ((dev = (struct mtd_device *)malloc(sizeof(struct mtd_device))) == NULL) { | |
928 | printf("out of memory\n"); | |
929 | return 1; | |
930 | } | |
931 | memset(dev, 0, sizeof(struct mtd_device)); | |
932 | dev->id = id; | |
933 | dev->num_parts = 0; /* part_sort_add increments num_parts */ | |
934 | INIT_LIST_HEAD(&dev->parts); | |
935 | INIT_LIST_HEAD(&dev->link); | |
936 | ||
937 | /* move partitions from tmp_list to dev->parts */ | |
938 | list_for_each_safe(entry, n, &tmp_list) { | |
939 | part = list_entry(entry, struct part_info, link); | |
940 | list_del(entry); | |
941 | if (part_sort_add(dev, part) != 0) { | |
942 | device_del(dev); | |
943 | return 1; | |
944 | } | |
945 | } | |
946 | ||
947 | *retdev = dev; | |
948 | ||
e1d2950d | 949 | debug("===\n\n"); |
68d7d651 SR |
950 | return 0; |
951 | } | |
952 | ||
953 | /** | |
954 | * Initialize global device list. | |
955 | * | |
956 | * @return 0 on success, 1 otherwise | |
957 | */ | |
958 | static int mtd_devices_init(void) | |
959 | { | |
960 | last_parts[0] = '\0'; | |
76b5883d | 961 | current_mtd_dev = NULL; |
68d7d651 SR |
962 | current_save(); |
963 | ||
964 | return device_delall(&devices); | |
965 | } | |
966 | ||
967 | /* | |
968 | * Search global mtdids list and find id of requested type and number. | |
969 | * | |
970 | * @return pointer to the id if it exists, NULL otherwise | |
971 | */ | |
972 | static struct mtdids* id_find(u8 type, u8 num) | |
973 | { | |
974 | struct list_head *entry; | |
975 | struct mtdids *id; | |
976 | ||
977 | list_for_each(entry, &mtdids) { | |
978 | id = list_entry(entry, struct mtdids, link); | |
979 | ||
980 | if ((id->type == type) && (id->num == num)) | |
981 | return id; | |
982 | } | |
983 | ||
984 | return NULL; | |
985 | } | |
986 | ||
987 | /** | |
988 | * Search global mtdids list and find id of a requested mtd_id. | |
989 | * | |
990 | * Note: first argument is not null terminated. | |
991 | * | |
992 | * @param mtd_id string containing requested mtd_id | |
993 | * @param mtd_id_len length of supplied mtd_id | |
994 | * @return pointer to the id if it exists, NULL otherwise | |
995 | */ | |
996 | static struct mtdids* id_find_by_mtd_id(const char *mtd_id, unsigned int mtd_id_len) | |
997 | { | |
998 | struct list_head *entry; | |
999 | struct mtdids *id; | |
1000 | ||
e1d2950d | 1001 | debug("--- id_find_by_mtd_id: '%.*s' (len = %d)\n", |
68d7d651 SR |
1002 | mtd_id_len, mtd_id, mtd_id_len); |
1003 | ||
1004 | list_for_each(entry, &mtdids) { | |
1005 | id = list_entry(entry, struct mtdids, link); | |
1006 | ||
e1d2950d | 1007 | debug("entry: '%s' (len = %d)\n", |
68d7d651 SR |
1008 | id->mtd_id, strlen(id->mtd_id)); |
1009 | ||
1010 | if (mtd_id_len != strlen(id->mtd_id)) | |
1011 | continue; | |
1012 | if (strncmp(id->mtd_id, mtd_id, mtd_id_len) == 0) | |
1013 | return id; | |
1014 | } | |
1015 | ||
1016 | return NULL; | |
1017 | } | |
1018 | ||
1019 | /** | |
1020 | * Parse device id string <dev-id> := 'nand'|'nor'|'onenand'<dev-num>, | |
1021 | * return device type and number. | |
1022 | * | |
1023 | * @param id string describing device id | |
1024 | * @param ret_id output pointer to next char after parse completes (output) | |
1025 | * @param dev_type parsed device type (output) | |
1026 | * @param dev_num parsed device number (output) | |
1027 | * @return 0 on success, 1 otherwise | |
1028 | */ | |
088f1b19 KP |
1029 | int mtd_id_parse(const char *id, const char **ret_id, u8 *dev_type, |
1030 | u8 *dev_num) | |
68d7d651 SR |
1031 | { |
1032 | const char *p = id; | |
1033 | ||
1034 | *dev_type = 0; | |
1035 | if (strncmp(p, "nand", 4) == 0) { | |
1036 | *dev_type = MTD_DEV_TYPE_NAND; | |
1037 | p += 4; | |
1038 | } else if (strncmp(p, "nor", 3) == 0) { | |
1039 | *dev_type = MTD_DEV_TYPE_NOR; | |
1040 | p += 3; | |
1041 | } else if (strncmp(p, "onenand", 7) == 0) { | |
1042 | *dev_type = MTD_DEV_TYPE_ONENAND; | |
1043 | p += 7; | |
1044 | } else { | |
1045 | printf("incorrect device type in %s\n", id); | |
1046 | return 1; | |
1047 | } | |
1048 | ||
1049 | if (!isdigit(*p)) { | |
1050 | printf("incorrect device number in %s\n", id); | |
1051 | return 1; | |
1052 | } | |
1053 | ||
1054 | *dev_num = simple_strtoul(p, (char **)&p, 0); | |
1055 | if (ret_id) | |
1056 | *ret_id = p; | |
1057 | return 0; | |
1058 | } | |
1059 | ||
1060 | /** | |
1061 | * Process all devices and generate corresponding mtdparts string describing | |
1062 | * all partitions on all devices. | |
1063 | * | |
1064 | * @param buf output buffer holding generated mtdparts string (output) | |
1065 | * @param buflen buffer size | |
1066 | * @return 0 on success, 1 otherwise | |
1067 | */ | |
1068 | static int generate_mtdparts(char *buf, u32 buflen) | |
1069 | { | |
1070 | struct list_head *pentry, *dentry; | |
1071 | struct mtd_device *dev; | |
1072 | struct part_info *part, *prev_part; | |
1073 | char *p = buf; | |
1074 | char tmpbuf[32]; | |
1075 | u32 size, offset, len, part_cnt; | |
1076 | u32 maxlen = buflen - 1; | |
1077 | ||
e1d2950d | 1078 | debug("--- generate_mtdparts ---\n"); |
68d7d651 SR |
1079 | |
1080 | if (list_empty(&devices)) { | |
1081 | buf[0] = '\0'; | |
1082 | return 0; | |
1083 | } | |
1084 | ||
1085 | sprintf(p, "mtdparts="); | |
1086 | p += 9; | |
1087 | ||
1088 | list_for_each(dentry, &devices) { | |
1089 | dev = list_entry(dentry, struct mtd_device, link); | |
1090 | ||
1091 | /* copy mtd_id */ | |
1092 | len = strlen(dev->id->mtd_id) + 1; | |
1093 | if (len > maxlen) | |
1094 | goto cleanup; | |
1095 | memcpy(p, dev->id->mtd_id, len - 1); | |
1096 | p += len - 1; | |
1097 | *(p++) = ':'; | |
1098 | maxlen -= len; | |
1099 | ||
1100 | /* format partitions */ | |
1101 | prev_part = NULL; | |
1102 | part_cnt = 0; | |
1103 | list_for_each(pentry, &dev->parts) { | |
1104 | part = list_entry(pentry, struct part_info, link); | |
1105 | size = part->size; | |
1106 | offset = part->offset; | |
1107 | part_cnt++; | |
1108 | ||
1109 | /* partition size */ | |
1110 | memsize_format(tmpbuf, size); | |
1111 | len = strlen(tmpbuf); | |
1112 | if (len > maxlen) | |
1113 | goto cleanup; | |
1114 | memcpy(p, tmpbuf, len); | |
1115 | p += len; | |
1116 | maxlen -= len; | |
1117 | ||
1118 | ||
1119 | /* add offset only when there is a gap between | |
1120 | * partitions */ | |
1121 | if ((!prev_part && (offset != 0)) || | |
1122 | (prev_part && ((prev_part->offset + prev_part->size) != part->offset))) { | |
1123 | ||
1124 | memsize_format(tmpbuf, offset); | |
1125 | len = strlen(tmpbuf) + 1; | |
1126 | if (len > maxlen) | |
1127 | goto cleanup; | |
1128 | *(p++) = '@'; | |
1129 | memcpy(p, tmpbuf, len - 1); | |
1130 | p += len - 1; | |
1131 | maxlen -= len; | |
1132 | } | |
1133 | ||
1134 | /* copy name only if user supplied */ | |
1135 | if(!part->auto_name) { | |
1136 | len = strlen(part->name) + 2; | |
1137 | if (len > maxlen) | |
1138 | goto cleanup; | |
1139 | ||
1140 | *(p++) = '('; | |
1141 | memcpy(p, part->name, len - 2); | |
1142 | p += len - 2; | |
1143 | *(p++) = ')'; | |
1144 | maxlen -= len; | |
1145 | } | |
1146 | ||
1147 | /* ro mask flag */ | |
1148 | if (part->mask_flags && MTD_WRITEABLE_CMD) { | |
1149 | len = 2; | |
1150 | if (len > maxlen) | |
1151 | goto cleanup; | |
1152 | *(p++) = 'r'; | |
1153 | *(p++) = 'o'; | |
1154 | maxlen -= 2; | |
1155 | } | |
1156 | ||
1157 | /* print ',' separator if there are other partitions | |
1158 | * following */ | |
1159 | if (dev->num_parts > part_cnt) { | |
1160 | if (1 > maxlen) | |
1161 | goto cleanup; | |
1162 | *(p++) = ','; | |
1163 | maxlen--; | |
1164 | } | |
1165 | prev_part = part; | |
1166 | } | |
1167 | /* print ';' separator if there are other devices following */ | |
1168 | if (dentry->next != &devices) { | |
1169 | if (1 > maxlen) | |
1170 | goto cleanup; | |
1171 | *(p++) = ';'; | |
1172 | maxlen--; | |
1173 | } | |
1174 | } | |
1175 | ||
1176 | /* we still have at least one char left, as we decremented maxlen at | |
1177 | * the begining */ | |
1178 | *p = '\0'; | |
1179 | ||
1180 | return 0; | |
1181 | ||
1182 | cleanup: | |
1183 | last_parts[0] = '\0'; | |
1184 | return 1; | |
1185 | } | |
1186 | ||
1187 | /** | |
1188 | * Call generate_mtdparts to process all devices and generate corresponding | |
1189 | * mtdparts string, save it in mtdparts environment variable. | |
1190 | * | |
1191 | * @param buf output buffer holding generated mtdparts string (output) | |
1192 | * @param buflen buffer size | |
1193 | * @return 0 on success, 1 otherwise | |
1194 | */ | |
1195 | static int generate_mtdparts_save(char *buf, u32 buflen) | |
1196 | { | |
1197 | int ret; | |
1198 | ||
1199 | ret = generate_mtdparts(buf, buflen); | |
1200 | ||
1201 | if ((buf[0] != '\0') && (ret == 0)) | |
1202 | setenv("mtdparts", buf); | |
1203 | else | |
1204 | setenv("mtdparts", NULL); | |
1205 | ||
1206 | return ret; | |
1207 | } | |
1208 | ||
04ac3802 | 1209 | #if defined(CONFIG_CMD_MTDPARTS_SHOW_NET_SIZES) |
68d7d651 | 1210 | /** |
04ac3802 BG |
1211 | * Get the net size (w/o bad blocks) of the given partition. |
1212 | * | |
1213 | * @param mtd the mtd info | |
1214 | * @param part the partition | |
1215 | * @return the calculated net size of this partition | |
68d7d651 | 1216 | */ |
04ac3802 BG |
1217 | static uint64_t net_part_size(struct mtd_info *mtd, struct part_info *part) |
1218 | { | |
36650ca9 SW |
1219 | uint64_t i, net_size = 0; |
1220 | ||
04ac3802 BG |
1221 | if (!mtd->block_isbad) |
1222 | return part->size; | |
1223 | ||
04ac3802 BG |
1224 | for (i = 0; i < part->size; i += mtd->erasesize) { |
1225 | if (!mtd->block_isbad(mtd, part->offset + i)) | |
1226 | net_size += mtd->erasesize; | |
1227 | } | |
36650ca9 | 1228 | |
04ac3802 BG |
1229 | return net_size; |
1230 | } | |
1231 | #endif | |
1232 | ||
1233 | static void print_partition_table(void) | |
68d7d651 SR |
1234 | { |
1235 | struct list_head *dentry, *pentry; | |
1236 | struct part_info *part; | |
1237 | struct mtd_device *dev; | |
1238 | int part_num; | |
1239 | ||
68d7d651 SR |
1240 | list_for_each(dentry, &devices) { |
1241 | dev = list_entry(dentry, struct mtd_device, link); | |
04ac3802 BG |
1242 | /* list partitions for given device */ |
1243 | part_num = 0; | |
1244 | #if defined(CONFIG_CMD_MTDPARTS_SHOW_NET_SIZES) | |
1245 | struct mtd_info *mtd; | |
1246 | ||
1247 | if (get_mtd_info(dev->id->type, dev->id->num, &mtd)) | |
1248 | return; | |
1249 | ||
1250 | printf("\ndevice %s%d <%s>, # parts = %d\n", | |
1251 | MTD_DEV_TYPE(dev->id->type), dev->id->num, | |
1252 | dev->id->mtd_id, dev->num_parts); | |
1253 | printf(" #: name\t\tsize\t\tnet size\toffset\t\tmask_flags\n"); | |
1254 | ||
1255 | list_for_each(pentry, &dev->parts) { | |
1256 | u32 net_size; | |
1257 | char *size_note; | |
1258 | ||
1259 | part = list_entry(pentry, struct part_info, link); | |
1260 | net_size = net_part_size(mtd, part); | |
1261 | size_note = part->size == net_size ? " " : " (!)"; | |
1262 | printf("%2d: %-20s0x%08x\t0x%08x%s\t0x%08x\t%d\n", | |
1263 | part_num, part->name, part->size, | |
1264 | net_size, size_note, part->offset, | |
1265 | part->mask_flags); | |
1266 | #else /* !defined(CONFIG_CMD_MTDPARTS_SHOW_NET_SIZES) */ | |
68d7d651 SR |
1267 | printf("\ndevice %s%d <%s>, # parts = %d\n", |
1268 | MTD_DEV_TYPE(dev->id->type), dev->id->num, | |
1269 | dev->id->mtd_id, dev->num_parts); | |
08f077da | 1270 | printf(" #: name\t\tsize\t\toffset\t\tmask_flags\n"); |
68d7d651 | 1271 | |
68d7d651 SR |
1272 | list_for_each(pentry, &dev->parts) { |
1273 | part = list_entry(pentry, struct part_info, link); | |
1274 | printf("%2d: %-20s0x%08x\t0x%08x\t%d\n", | |
1275 | part_num, part->name, part->size, | |
1276 | part->offset, part->mask_flags); | |
04ac3802 | 1277 | #endif /* defined(CONFIG_CMD_MTDPARTS_SHOW_NET_SIZES) */ |
68d7d651 SR |
1278 | part_num++; |
1279 | } | |
1280 | } | |
04ac3802 | 1281 | |
68d7d651 SR |
1282 | if (list_empty(&devices)) |
1283 | printf("no partitions defined\n"); | |
04ac3802 BG |
1284 | } |
1285 | ||
1286 | /** | |
1287 | * Format and print out a partition list for each device from global device | |
1288 | * list. | |
1289 | */ | |
1290 | static void list_partitions(void) | |
1291 | { | |
1292 | struct part_info *part; | |
1293 | ||
1294 | debug("\n---list_partitions---\n"); | |
1295 | print_partition_table(); | |
68d7d651 | 1296 | |
76b5883d SR |
1297 | /* current_mtd_dev is not NULL only when we have non empty device list */ |
1298 | if (current_mtd_dev) { | |
1299 | part = mtd_part_info(current_mtd_dev, current_mtd_partnum); | |
68d7d651 SR |
1300 | if (part) { |
1301 | printf("\nactive partition: %s%d,%d - (%s) 0x%08x @ 0x%08x\n", | |
76b5883d SR |
1302 | MTD_DEV_TYPE(current_mtd_dev->id->type), |
1303 | current_mtd_dev->id->num, current_mtd_partnum, | |
68d7d651 SR |
1304 | part->name, part->size, part->offset); |
1305 | } else { | |
1306 | printf("could not get current partition info\n\n"); | |
1307 | } | |
1308 | } | |
1309 | ||
1310 | printf("\ndefaults:\n"); | |
36c9169a WD |
1311 | printf("mtdids : %s\n", |
1312 | mtdids_default ? mtdids_default : "none"); | |
a693447c AG |
1313 | /* |
1314 | * Using printf() here results in printbuffer overflow | |
1315 | * if default mtdparts string is greater than console | |
1316 | * printbuffer. Use puts() to prevent system crashes. | |
1317 | */ | |
1318 | puts("mtdparts: "); | |
1319 | puts(mtdparts_default ? mtdparts_default : "none"); | |
1320 | puts("\n"); | |
68d7d651 SR |
1321 | } |
1322 | ||
1323 | /** | |
1324 | * Given partition identifier in form of <dev_type><dev_num>,<part_num> find | |
1325 | * corresponding device and verify partition number. | |
1326 | * | |
1327 | * @param id string describing device and partition or partition name | |
1328 | * @param dev pointer to the requested device (output) | |
1329 | * @param part_num verified partition number (output) | |
1330 | * @param part pointer to requested partition (output) | |
1331 | * @return 0 on success, 1 otherwise | |
1332 | */ | |
1333 | int find_dev_and_part(const char *id, struct mtd_device **dev, | |
1334 | u8 *part_num, struct part_info **part) | |
1335 | { | |
1336 | struct list_head *dentry, *pentry; | |
1337 | u8 type, dnum, pnum; | |
1338 | const char *p; | |
1339 | ||
e1d2950d | 1340 | debug("--- find_dev_and_part ---\nid = %s\n", id); |
68d7d651 SR |
1341 | |
1342 | list_for_each(dentry, &devices) { | |
1343 | *part_num = 0; | |
1344 | *dev = list_entry(dentry, struct mtd_device, link); | |
1345 | list_for_each(pentry, &(*dev)->parts) { | |
1346 | *part = list_entry(pentry, struct part_info, link); | |
1347 | if (strcmp((*part)->name, id) == 0) | |
1348 | return 0; | |
1349 | (*part_num)++; | |
1350 | } | |
1351 | } | |
1352 | ||
1353 | p = id; | |
1354 | *dev = NULL; | |
1355 | *part = NULL; | |
1356 | *part_num = 0; | |
1357 | ||
1358 | if (mtd_id_parse(p, &p, &type, &dnum) != 0) | |
1359 | return 1; | |
1360 | ||
1361 | if ((*p++ != ',') || (*p == '\0')) { | |
1362 | printf("no partition number specified\n"); | |
1363 | return 1; | |
1364 | } | |
1365 | pnum = simple_strtoul(p, (char **)&p, 0); | |
1366 | if (*p != '\0') { | |
1367 | printf("unexpected trailing character '%c'\n", *p); | |
1368 | return 1; | |
1369 | } | |
1370 | ||
1371 | if ((*dev = device_find(type, dnum)) == NULL) { | |
1372 | printf("no such device %s%d\n", MTD_DEV_TYPE(type), dnum); | |
1373 | return 1; | |
1374 | } | |
1375 | ||
1376 | if ((*part = mtd_part_info(*dev, pnum)) == NULL) { | |
1377 | printf("no such partition\n"); | |
1378 | *dev = NULL; | |
1379 | return 1; | |
1380 | } | |
1381 | ||
1382 | *part_num = pnum; | |
1383 | ||
1384 | return 0; | |
1385 | } | |
1386 | ||
1387 | /** | |
1388 | * Find and delete partition. For partition id format see find_dev_and_part(). | |
1389 | * | |
1390 | * @param id string describing device and partition | |
1391 | * @return 0 on success, 1 otherwise | |
1392 | */ | |
1393 | static int delete_partition(const char *id) | |
1394 | { | |
1395 | u8 pnum; | |
1396 | struct mtd_device *dev; | |
1397 | struct part_info *part; | |
1398 | ||
1399 | if (find_dev_and_part(id, &dev, &pnum, &part) == 0) { | |
1400 | ||
e1d2950d | 1401 | debug("delete_partition: device = %s%d, partition %d = (%s) 0x%08x@0x%08x\n", |
68d7d651 SR |
1402 | MTD_DEV_TYPE(dev->id->type), dev->id->num, pnum, |
1403 | part->name, part->size, part->offset); | |
1404 | ||
1405 | if (part_del(dev, part) != 0) | |
1406 | return 1; | |
1407 | ||
1408 | if (generate_mtdparts_save(last_parts, MTDPARTS_MAXLEN) != 0) { | |
a22bf16b | 1409 | printf("generated mtdparts too long, resetting to null\n"); |
68d7d651 SR |
1410 | return 1; |
1411 | } | |
1412 | return 0; | |
1413 | } | |
1414 | ||
1415 | printf("partition %s not found\n", id); | |
1416 | return 1; | |
1417 | } | |
1418 | ||
ca75b20e BG |
1419 | #if defined(CONFIG_CMD_MTDPARTS_SPREAD) |
1420 | /** | |
1421 | * Increase the size of the given partition so that it's net size is at least | |
1422 | * as large as the size member and such that the next partition would start on a | |
1423 | * good block if it were adjacent to this partition. | |
1424 | * | |
1425 | * @param mtd the mtd device | |
1426 | * @param part the partition | |
1427 | * @param next_offset pointer to the offset of the next partition after this | |
1428 | * partition's size has been modified (output) | |
1429 | */ | |
1430 | static void spread_partition(struct mtd_info *mtd, struct part_info *part, | |
1431 | uint64_t *next_offset) | |
1432 | { | |
1433 | uint64_t net_size, padding_size = 0; | |
1434 | int truncated; | |
1435 | ||
1436 | mtd_get_len_incl_bad(mtd, part->offset, part->size, &net_size, | |
1437 | &truncated); | |
1438 | ||
1439 | /* | |
1440 | * Absorb bad blocks immediately following this | |
1441 | * partition also into the partition, such that | |
1442 | * the next partition starts with a good block. | |
1443 | */ | |
1444 | if (!truncated) { | |
1445 | mtd_get_len_incl_bad(mtd, part->offset + net_size, | |
1446 | mtd->erasesize, &padding_size, &truncated); | |
1447 | if (truncated) | |
1448 | padding_size = 0; | |
1449 | else | |
1450 | padding_size -= mtd->erasesize; | |
1451 | } | |
1452 | ||
1453 | if (truncated) { | |
1454 | printf("truncated partition %s to %lld bytes\n", part->name, | |
1455 | (uint64_t) net_size + padding_size); | |
1456 | } | |
1457 | ||
1458 | part->size = net_size + padding_size; | |
1459 | *next_offset = part->offset + part->size; | |
1460 | } | |
1461 | ||
1462 | /** | |
1463 | * Adjust all of the partition sizes, such that all partitions are at least | |
1464 | * as big as their mtdparts environment variable sizes and they each start | |
1465 | * on a good block. | |
1466 | * | |
1467 | * @return 0 on success, 1 otherwise | |
1468 | */ | |
1469 | static int spread_partitions(void) | |
1470 | { | |
1471 | struct list_head *dentry, *pentry; | |
1472 | struct mtd_device *dev; | |
1473 | struct part_info *part; | |
1474 | struct mtd_info *mtd; | |
1475 | int part_num; | |
1476 | uint64_t cur_offs; | |
1477 | ||
1478 | list_for_each(dentry, &devices) { | |
1479 | dev = list_entry(dentry, struct mtd_device, link); | |
1480 | ||
1481 | if (get_mtd_info(dev->id->type, dev->id->num, &mtd)) | |
1482 | return 1; | |
1483 | ||
1484 | part_num = 0; | |
1485 | cur_offs = 0; | |
1486 | list_for_each(pentry, &dev->parts) { | |
1487 | part = list_entry(pentry, struct part_info, link); | |
1488 | ||
1489 | debug("spread_partitions: device = %s%d, partition %d =" | |
1490 | " (%s) 0x%08x@0x%08x\n", | |
1491 | MTD_DEV_TYPE(dev->id->type), dev->id->num, | |
1492 | part_num, part->name, part->size, | |
1493 | part->offset); | |
1494 | ||
1495 | if (cur_offs > part->offset) | |
1496 | part->offset = cur_offs; | |
1497 | ||
1498 | spread_partition(mtd, part, &cur_offs); | |
1499 | ||
1500 | part_num++; | |
1501 | } | |
1502 | } | |
1503 | ||
1504 | index_partitions(); | |
1505 | ||
1506 | if (generate_mtdparts_save(last_parts, MTDPARTS_MAXLEN) != 0) { | |
a22bf16b | 1507 | printf("generated mtdparts too long, resetting to null\n"); |
ca75b20e BG |
1508 | return 1; |
1509 | } | |
1510 | return 0; | |
1511 | } | |
1512 | #endif /* CONFIG_CMD_MTDPARTS_SPREAD */ | |
1513 | ||
68d7d651 SR |
1514 | /** |
1515 | * Accept character string describing mtd partitions and call device_parse() | |
1516 | * for each entry. Add created devices to the global devices list. | |
1517 | * | |
1518 | * @param mtdparts string specifing mtd partitions | |
1519 | * @return 0 on success, 1 otherwise | |
1520 | */ | |
1521 | static int parse_mtdparts(const char *const mtdparts) | |
1522 | { | |
1523 | const char *p = mtdparts; | |
1524 | struct mtd_device *dev; | |
1525 | int err = 1; | |
a7eb1d66 | 1526 | char tmp_parts[MTDPARTS_MAXLEN]; |
68d7d651 | 1527 | |
e1d2950d | 1528 | debug("\n---parse_mtdparts---\nmtdparts = %s\n\n", p); |
68d7d651 SR |
1529 | |
1530 | /* delete all devices and partitions */ | |
1531 | if (mtd_devices_init() != 0) { | |
1532 | printf("could not initialise device list\n"); | |
1533 | return err; | |
1534 | } | |
1535 | ||
1536 | /* re-read 'mtdparts' variable, mtd_devices_init may be updating env */ | |
a7eb1d66 JH |
1537 | if (gd->flags & GD_FLG_ENV_READY) { |
1538 | p = getenv("mtdparts"); | |
1539 | } else { | |
1540 | p = tmp_parts; | |
1541 | getenv_f("mtdparts", tmp_parts, MTDPARTS_MAXLEN); | |
1542 | } | |
68d7d651 SR |
1543 | |
1544 | if (strncmp(p, "mtdparts=", 9) != 0) { | |
1545 | printf("mtdparts variable doesn't start with 'mtdparts='\n"); | |
1546 | return err; | |
1547 | } | |
1548 | p += 9; | |
1549 | ||
1550 | while (p && (*p != '\0')) { | |
1551 | err = 1; | |
1552 | if ((device_parse(p, &p, &dev) != 0) || (!dev)) | |
1553 | break; | |
1554 | ||
e1d2950d | 1555 | debug("+ device: %s\t%d\t%s\n", MTD_DEV_TYPE(dev->id->type), |
68d7d651 SR |
1556 | dev->id->num, dev->id->mtd_id); |
1557 | ||
1558 | /* check if parsed device is already on the list */ | |
1559 | if (device_find(dev->id->type, dev->id->num) != NULL) { | |
1560 | printf("device %s%d redefined, please correct mtdparts variable\n", | |
1561 | MTD_DEV_TYPE(dev->id->type), dev->id->num); | |
1562 | break; | |
1563 | } | |
1564 | ||
1565 | list_add_tail(&dev->link, &devices); | |
1566 | err = 0; | |
1567 | } | |
1568 | if (err == 1) { | |
1569 | device_delall(&devices); | |
1570 | return 1; | |
1571 | } | |
1572 | ||
1573 | return 0; | |
1574 | } | |
1575 | ||
1576 | /** | |
1577 | * Parse provided string describing mtdids mapping (see file header for mtdids | |
1578 | * variable format). Allocate memory for each entry and add all found entries | |
1579 | * to the global mtdids list. | |
1580 | * | |
1581 | * @param ids mapping string | |
1582 | * @return 0 on success, 1 otherwise | |
1583 | */ | |
1584 | static int parse_mtdids(const char *const ids) | |
1585 | { | |
1586 | const char *p = ids; | |
1587 | const char *mtd_id; | |
1588 | int mtd_id_len; | |
1589 | struct mtdids *id; | |
1590 | struct list_head *entry, *n; | |
1591 | struct mtdids *id_tmp; | |
1592 | u8 type, num; | |
1593 | u32 size; | |
1594 | int ret = 1; | |
1595 | ||
e1d2950d | 1596 | debug("\n---parse_mtdids---\nmtdids = %s\n\n", ids); |
68d7d651 SR |
1597 | |
1598 | /* clean global mtdids list */ | |
1599 | list_for_each_safe(entry, n, &mtdids) { | |
1600 | id_tmp = list_entry(entry, struct mtdids, link); | |
e1d2950d | 1601 | debug("mtdids del: %d %d\n", id_tmp->type, id_tmp->num); |
68d7d651 SR |
1602 | list_del(entry); |
1603 | free(id_tmp); | |
1604 | } | |
1605 | last_ids[0] = '\0'; | |
1606 | INIT_LIST_HEAD(&mtdids); | |
1607 | ||
1608 | while(p && (*p != '\0')) { | |
1609 | ||
1610 | ret = 1; | |
1611 | /* parse 'nor'|'nand'|'onenand'<dev-num> */ | |
1612 | if (mtd_id_parse(p, &p, &type, &num) != 0) | |
1613 | break; | |
1614 | ||
1615 | if (*p != '=') { | |
1616 | printf("mtdids: incorrect <dev-num>\n"); | |
1617 | break; | |
1618 | } | |
1619 | p++; | |
1620 | ||
1621 | /* check if requested device exists */ | |
1622 | if (mtd_device_validate(type, num, &size) != 0) | |
1623 | return 1; | |
1624 | ||
1625 | /* locate <mtd-id> */ | |
1626 | mtd_id = p; | |
1627 | if ((p = strchr(mtd_id, ',')) != NULL) { | |
1628 | mtd_id_len = p - mtd_id + 1; | |
1629 | p++; | |
1630 | } else { | |
1631 | mtd_id_len = strlen(mtd_id) + 1; | |
1632 | } | |
1633 | if (mtd_id_len == 0) { | |
1634 | printf("mtdids: no <mtd-id> identifier\n"); | |
1635 | break; | |
1636 | } | |
1637 | ||
1638 | /* check if this id is already on the list */ | |
1639 | int double_entry = 0; | |
1640 | list_for_each(entry, &mtdids) { | |
1641 | id_tmp = list_entry(entry, struct mtdids, link); | |
1642 | if ((id_tmp->type == type) && (id_tmp->num == num)) { | |
1643 | double_entry = 1; | |
1644 | break; | |
1645 | } | |
1646 | } | |
1647 | if (double_entry) { | |
1648 | printf("device id %s%d redefined, please correct mtdids variable\n", | |
1649 | MTD_DEV_TYPE(type), num); | |
1650 | break; | |
1651 | } | |
1652 | ||
1653 | /* allocate mtdids structure */ | |
1654 | if (!(id = (struct mtdids *)malloc(sizeof(struct mtdids) + mtd_id_len))) { | |
1655 | printf("out of memory\n"); | |
1656 | break; | |
1657 | } | |
1658 | memset(id, 0, sizeof(struct mtdids) + mtd_id_len); | |
1659 | id->num = num; | |
1660 | id->type = type; | |
1661 | id->size = size; | |
1662 | id->mtd_id = (char *)(id + 1); | |
1663 | strncpy(id->mtd_id, mtd_id, mtd_id_len - 1); | |
1664 | id->mtd_id[mtd_id_len - 1] = '\0'; | |
1665 | INIT_LIST_HEAD(&id->link); | |
1666 | ||
e1d2950d | 1667 | debug("+ id %s%d\t%16d bytes\t%s\n", |
68d7d651 SR |
1668 | MTD_DEV_TYPE(id->type), id->num, |
1669 | id->size, id->mtd_id); | |
1670 | ||
1671 | list_add_tail(&id->link, &mtdids); | |
1672 | ret = 0; | |
1673 | } | |
1674 | if (ret == 1) { | |
1675 | /* clean mtdids list and free allocated memory */ | |
1676 | list_for_each_safe(entry, n, &mtdids) { | |
1677 | id_tmp = list_entry(entry, struct mtdids, link); | |
1678 | list_del(entry); | |
1679 | free(id_tmp); | |
1680 | } | |
1681 | return 1; | |
1682 | } | |
1683 | ||
1684 | return 0; | |
1685 | } | |
1686 | ||
1687 | /** | |
1688 | * Parse and initialize global mtdids mapping and create global | |
1689 | * device/partition list. | |
1690 | * | |
1691 | * @return 0 on success, 1 otherwise | |
1692 | */ | |
1693 | int mtdparts_init(void) | |
1694 | { | |
1695 | static int initialized = 0; | |
1696 | const char *ids, *parts; | |
1697 | const char *current_partition; | |
1698 | int ids_changed; | |
1699 | char tmp_ep[PARTITION_MAXLEN]; | |
a7eb1d66 | 1700 | char tmp_parts[MTDPARTS_MAXLEN]; |
68d7d651 | 1701 | |
e1d2950d | 1702 | debug("\n---mtdparts_init---\n"); |
68d7d651 SR |
1703 | if (!initialized) { |
1704 | INIT_LIST_HEAD(&mtdids); | |
1705 | INIT_LIST_HEAD(&devices); | |
1706 | memset(last_ids, 0, MTDIDS_MAXLEN); | |
1707 | memset(last_parts, 0, MTDPARTS_MAXLEN); | |
1708 | memset(last_partition, 0, PARTITION_MAXLEN); | |
1709 | initialized = 1; | |
1710 | } | |
1711 | ||
1712 | /* get variables */ | |
1713 | ids = getenv("mtdids"); | |
a7eb1d66 JH |
1714 | /* |
1715 | * The mtdparts variable tends to be long. If we need to access it | |
1716 | * before the env is relocated, then we need to use our own stack | |
1717 | * buffer. gd->env_buf will be too small. | |
1718 | */ | |
1719 | if (gd->flags & GD_FLG_ENV_READY) { | |
1720 | parts = getenv("mtdparts"); | |
1721 | } else { | |
1722 | parts = tmp_parts; | |
1723 | getenv_f("mtdparts", tmp_parts, MTDPARTS_MAXLEN); | |
1724 | } | |
68d7d651 SR |
1725 | current_partition = getenv("partition"); |
1726 | ||
1727 | /* save it for later parsing, cannot rely on current partition pointer | |
1728 | * as 'partition' variable may be updated during init */ | |
1729 | tmp_ep[0] = '\0'; | |
1730 | if (current_partition) | |
1731 | strncpy(tmp_ep, current_partition, PARTITION_MAXLEN); | |
1732 | ||
e1d2950d WD |
1733 | debug("last_ids : %s\n", last_ids); |
1734 | debug("env_ids : %s\n", ids); | |
1735 | debug("last_parts: %s\n", last_parts); | |
1736 | debug("env_parts : %s\n\n", parts); | |
68d7d651 | 1737 | |
e1d2950d WD |
1738 | debug("last_partition : %s\n", last_partition); |
1739 | debug("env_partition : %s\n", current_partition); | |
68d7d651 SR |
1740 | |
1741 | /* if mtdids varible is empty try to use defaults */ | |
1742 | if (!ids) { | |
1743 | if (mtdids_default) { | |
e1d2950d | 1744 | debug("mtdids variable not defined, using default\n"); |
68d7d651 SR |
1745 | ids = mtdids_default; |
1746 | setenv("mtdids", (char *)ids); | |
1747 | } else { | |
1748 | printf("mtdids not defined, no default present\n"); | |
1749 | return 1; | |
1750 | } | |
1751 | } | |
1752 | if (strlen(ids) > MTDIDS_MAXLEN - 1) { | |
1753 | printf("mtdids too long (> %d)\n", MTDIDS_MAXLEN); | |
1754 | return 1; | |
1755 | } | |
1756 | ||
1757 | /* do no try to use defaults when mtdparts variable is not defined, | |
1758 | * just check the length */ | |
1759 | if (!parts) | |
1760 | printf("mtdparts variable not set, see 'help mtdparts'\n"); | |
1761 | ||
1762 | if (parts && (strlen(parts) > MTDPARTS_MAXLEN - 1)) { | |
1763 | printf("mtdparts too long (> %d)\n", MTDPARTS_MAXLEN); | |
1764 | return 1; | |
1765 | } | |
1766 | ||
1767 | /* check if we have already parsed those mtdids */ | |
1768 | if ((last_ids[0] != '\0') && (strcmp(last_ids, ids) == 0)) { | |
1769 | ids_changed = 0; | |
1770 | } else { | |
1771 | ids_changed = 1; | |
1772 | ||
1773 | if (parse_mtdids(ids) != 0) { | |
1774 | mtd_devices_init(); | |
1775 | return 1; | |
1776 | } | |
1777 | ||
1778 | /* ok it's good, save new ids */ | |
1779 | strncpy(last_ids, ids, MTDIDS_MAXLEN); | |
1780 | } | |
1781 | ||
1782 | /* parse partitions if either mtdparts or mtdids were updated */ | |
1783 | if (parts && ((last_parts[0] == '\0') || ((strcmp(last_parts, parts) != 0)) || ids_changed)) { | |
1784 | if (parse_mtdparts(parts) != 0) | |
1785 | return 1; | |
1786 | ||
1787 | if (list_empty(&devices)) { | |
1788 | printf("mtdparts_init: no valid partitions\n"); | |
1789 | return 1; | |
1790 | } | |
1791 | ||
1792 | /* ok it's good, save new parts */ | |
1793 | strncpy(last_parts, parts, MTDPARTS_MAXLEN); | |
1794 | ||
1795 | /* reset first partition from first dev from the list as current */ | |
76b5883d SR |
1796 | current_mtd_dev = list_entry(devices.next, struct mtd_device, link); |
1797 | current_mtd_partnum = 0; | |
68d7d651 SR |
1798 | current_save(); |
1799 | ||
e1d2950d | 1800 | debug("mtdparts_init: current_mtd_dev = %s%d, current_mtd_partnum = %d\n", |
76b5883d SR |
1801 | MTD_DEV_TYPE(current_mtd_dev->id->type), |
1802 | current_mtd_dev->id->num, current_mtd_partnum); | |
68d7d651 SR |
1803 | } |
1804 | ||
1805 | /* mtdparts variable was reset to NULL, delete all devices/partitions */ | |
1806 | if (!parts && (last_parts[0] != '\0')) | |
1807 | return mtd_devices_init(); | |
1808 | ||
1809 | /* do not process current partition if mtdparts variable is null */ | |
1810 | if (!parts) | |
1811 | return 0; | |
1812 | ||
1813 | /* is current partition set in environment? if so, use it */ | |
1814 | if ((tmp_ep[0] != '\0') && (strcmp(tmp_ep, last_partition) != 0)) { | |
1815 | struct part_info *p; | |
1816 | struct mtd_device *cdev; | |
1817 | u8 pnum; | |
1818 | ||
e1d2950d | 1819 | debug("--- getting current partition: %s\n", tmp_ep); |
68d7d651 SR |
1820 | |
1821 | if (find_dev_and_part(tmp_ep, &cdev, &pnum, &p) == 0) { | |
76b5883d SR |
1822 | current_mtd_dev = cdev; |
1823 | current_mtd_partnum = pnum; | |
68d7d651 SR |
1824 | current_save(); |
1825 | } | |
1826 | } else if (getenv("partition") == NULL) { | |
e1d2950d | 1827 | debug("no partition variable set, setting...\n"); |
68d7d651 SR |
1828 | current_save(); |
1829 | } | |
1830 | ||
1831 | return 0; | |
1832 | } | |
1833 | ||
1834 | /** | |
1835 | * Return pointer to the partition of a requested number from a requested | |
1836 | * device. | |
1837 | * | |
1838 | * @param dev device that is to be searched for a partition | |
1839 | * @param part_num requested partition number | |
1840 | * @return pointer to the part_info, NULL otherwise | |
1841 | */ | |
1842 | static struct part_info* mtd_part_info(struct mtd_device *dev, unsigned int part_num) | |
1843 | { | |
1844 | struct list_head *entry; | |
1845 | struct part_info *part; | |
1846 | int num; | |
1847 | ||
1848 | if (!dev) | |
1849 | return NULL; | |
1850 | ||
e1d2950d | 1851 | debug("\n--- mtd_part_info: partition number %d for device %s%d (%s)\n", |
68d7d651 SR |
1852 | part_num, MTD_DEV_TYPE(dev->id->type), |
1853 | dev->id->num, dev->id->mtd_id); | |
1854 | ||
1855 | if (part_num >= dev->num_parts) { | |
1856 | printf("invalid partition number %d for device %s%d (%s)\n", | |
1857 | part_num, MTD_DEV_TYPE(dev->id->type), | |
1858 | dev->id->num, dev->id->mtd_id); | |
1859 | return NULL; | |
1860 | } | |
1861 | ||
1862 | /* locate partition number, return it */ | |
1863 | num = 0; | |
1864 | list_for_each(entry, &dev->parts) { | |
1865 | part = list_entry(entry, struct part_info, link); | |
1866 | ||
1867 | if (part_num == num++) { | |
1868 | return part; | |
1869 | } | |
1870 | } | |
1871 | ||
1872 | return NULL; | |
1873 | } | |
1874 | ||
1875 | /***************************************************/ | |
1876 | /* U-boot commands */ | |
1877 | /***************************************************/ | |
1878 | /* command line only */ | |
1879 | /** | |
1880 | * Routine implementing u-boot chpart command. Sets new current partition based | |
1881 | * on the user supplied partition id. For partition id format see find_dev_and_part(). | |
1882 | * | |
1883 | * @param cmdtp command internal data | |
1884 | * @param flag command flag | |
1885 | * @param argc number of arguments supplied to the command | |
1886 | * @param argv arguments list | |
1887 | * @return 0 on success, 1 otherwise | |
1888 | */ | |
088f1b19 | 1889 | static int do_chpart(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
68d7d651 SR |
1890 | { |
1891 | /* command line only */ | |
1892 | struct mtd_device *dev; | |
1893 | struct part_info *part; | |
1894 | u8 pnum; | |
1895 | ||
1896 | if (mtdparts_init() !=0) | |
1897 | return 1; | |
1898 | ||
1899 | if (argc < 2) { | |
1900 | printf("no partition id specified\n"); | |
1901 | return 1; | |
1902 | } | |
1903 | ||
1904 | if (find_dev_and_part(argv[1], &dev, &pnum, &part) != 0) | |
1905 | return 1; | |
1906 | ||
76b5883d SR |
1907 | current_mtd_dev = dev; |
1908 | current_mtd_partnum = pnum; | |
68d7d651 SR |
1909 | current_save(); |
1910 | ||
1911 | printf("partition changed to %s%d,%d\n", | |
1912 | MTD_DEV_TYPE(dev->id->type), dev->id->num, pnum); | |
1913 | ||
1914 | return 0; | |
1915 | } | |
1916 | ||
1917 | /** | |
1918 | * Routine implementing u-boot mtdparts command. Initialize/update default global | |
1919 | * partition list and process user partition request (list, add, del). | |
1920 | * | |
1921 | * @param cmdtp command internal data | |
1922 | * @param flag command flag | |
1923 | * @param argc number of arguments supplied to the command | |
1924 | * @param argv arguments list | |
1925 | * @return 0 on success, 1 otherwise | |
1926 | */ | |
088f1b19 KP |
1927 | static int do_mtdparts(cmd_tbl_t *cmdtp, int flag, int argc, |
1928 | char * const argv[]) | |
68d7d651 SR |
1929 | { |
1930 | if (argc == 2) { | |
1931 | if (strcmp(argv[1], "default") == 0) { | |
1932 | setenv("mtdids", (char *)mtdids_default); | |
1933 | setenv("mtdparts", (char *)mtdparts_default); | |
1934 | setenv("partition", NULL); | |
1935 | ||
1936 | mtdparts_init(); | |
1937 | return 0; | |
1938 | } else if (strcmp(argv[1], "delall") == 0) { | |
1939 | /* this may be the first run, initialize lists if needed */ | |
1940 | mtdparts_init(); | |
1941 | ||
1942 | setenv("mtdparts", NULL); | |
1943 | ||
1944 | /* mtd_devices_init() calls current_save() */ | |
1945 | return mtd_devices_init(); | |
1946 | } | |
1947 | } | |
1948 | ||
1949 | /* make sure we are in sync with env variables */ | |
1950 | if (mtdparts_init() != 0) | |
1951 | return 1; | |
1952 | ||
1953 | if (argc == 1) { | |
1954 | list_partitions(); | |
1955 | return 0; | |
1956 | } | |
1957 | ||
1958 | /* mtdparts add <mtd-dev> <size>[@<offset>] <name> [ro] */ | |
59a50d2d | 1959 | if (((argc == 5) || (argc == 6)) && (strncmp(argv[1], "add", 3) == 0)) { |
68d7d651 SR |
1960 | #define PART_ADD_DESC_MAXLEN 64 |
1961 | char tmpbuf[PART_ADD_DESC_MAXLEN]; | |
59a50d2d BG |
1962 | #if defined(CONFIG_CMD_MTDPARTS_SPREAD) |
1963 | struct mtd_info *mtd; | |
1964 | uint64_t next_offset; | |
1965 | #endif | |
68d7d651 SR |
1966 | u8 type, num, len; |
1967 | struct mtd_device *dev; | |
1968 | struct mtd_device *dev_tmp; | |
1969 | struct mtdids *id; | |
1970 | struct part_info *p; | |
1971 | ||
1972 | if (mtd_id_parse(argv[2], NULL, &type, &num) != 0) | |
1973 | return 1; | |
1974 | ||
1975 | if ((id = id_find(type, num)) == NULL) { | |
1976 | printf("no such device %s defined in mtdids variable\n", argv[2]); | |
1977 | return 1; | |
1978 | } | |
1979 | ||
1980 | len = strlen(id->mtd_id) + 1; /* 'mtd_id:' */ | |
1981 | len += strlen(argv[3]); /* size@offset */ | |
1982 | len += strlen(argv[4]) + 2; /* '(' name ')' */ | |
1983 | if (argv[5] && (strlen(argv[5]) == 2)) | |
1984 | len += 2; /* 'ro' */ | |
1985 | ||
1986 | if (len >= PART_ADD_DESC_MAXLEN) { | |
1987 | printf("too long partition description\n"); | |
1988 | return 1; | |
1989 | } | |
1990 | sprintf(tmpbuf, "%s:%s(%s)%s", | |
1991 | id->mtd_id, argv[3], argv[4], argv[5] ? argv[5] : ""); | |
e1d2950d | 1992 | debug("add tmpbuf: %s\n", tmpbuf); |
68d7d651 SR |
1993 | |
1994 | if ((device_parse(tmpbuf, NULL, &dev) != 0) || (!dev)) | |
1995 | return 1; | |
1996 | ||
e1d2950d | 1997 | debug("+ %s\t%d\t%s\n", MTD_DEV_TYPE(dev->id->type), |
68d7d651 SR |
1998 | dev->id->num, dev->id->mtd_id); |
1999 | ||
59a50d2d BG |
2000 | p = list_entry(dev->parts.next, struct part_info, link); |
2001 | ||
2002 | #if defined(CONFIG_CMD_MTDPARTS_SPREAD) | |
2003 | if (get_mtd_info(dev->id->type, dev->id->num, &mtd)) | |
2004 | return 1; | |
2005 | ||
2006 | if (!strcmp(&argv[1][3], ".spread")) { | |
2007 | spread_partition(mtd, p, &next_offset); | |
2008 | debug("increased %s to %d bytes\n", p->name, p->size); | |
2009 | } | |
2010 | #endif | |
2011 | ||
2012 | dev_tmp = device_find(dev->id->type, dev->id->num); | |
2013 | if (dev_tmp == NULL) { | |
68d7d651 | 2014 | device_add(dev); |
59a50d2d | 2015 | } else if (part_add(dev_tmp, p) != 0) { |
68d7d651 | 2016 | /* merge new partition with existing ones*/ |
59a50d2d BG |
2017 | device_del(dev); |
2018 | return 1; | |
68d7d651 SR |
2019 | } |
2020 | ||
2021 | if (generate_mtdparts_save(last_parts, MTDPARTS_MAXLEN) != 0) { | |
a22bf16b | 2022 | printf("generated mtdparts too long, resetting to null\n"); |
68d7d651 SR |
2023 | return 1; |
2024 | } | |
2025 | ||
2026 | return 0; | |
2027 | } | |
2028 | ||
2029 | /* mtdparts del part-id */ | |
2030 | if ((argc == 3) && (strcmp(argv[1], "del") == 0)) { | |
e1d2950d | 2031 | debug("del: part-id = %s\n", argv[2]); |
68d7d651 SR |
2032 | |
2033 | return delete_partition(argv[2]); | |
2034 | } | |
2035 | ||
ca75b20e BG |
2036 | #if defined(CONFIG_CMD_MTDPARTS_SPREAD) |
2037 | if ((argc == 2) && (strcmp(argv[1], "spread") == 0)) | |
2038 | return spread_partitions(); | |
2039 | #endif /* CONFIG_CMD_MTDPARTS_SPREAD */ | |
2040 | ||
4c12eeb8 | 2041 | return CMD_RET_USAGE; |
68d7d651 SR |
2042 | } |
2043 | ||
2044 | /***************************************************/ | |
2045 | U_BOOT_CMD( | |
2046 | chpart, 2, 0, do_chpart, | |
2047 | "change active partition", | |
2048 | "part-id\n" | |
a89c33db | 2049 | " - change active partition (e.g. part-id = nand0,1)" |
68d7d651 SR |
2050 | ); |
2051 | ||
088f1b19 KP |
2052 | #ifdef CONFIG_SYS_LONGHELP |
2053 | static char mtdparts_help_text[] = | |
68d7d651 SR |
2054 | "\n" |
2055 | " - list partition table\n" | |
2056 | "mtdparts delall\n" | |
2057 | " - delete all partitions\n" | |
2058 | "mtdparts del part-id\n" | |
2059 | " - delete partition (e.g. part-id = nand0,1)\n" | |
2060 | "mtdparts add <mtd-dev> <size>[@<offset>] [<name>] [ro]\n" | |
2061 | " - add partition\n" | |
59a50d2d BG |
2062 | #if defined(CONFIG_CMD_MTDPARTS_SPREAD) |
2063 | "mtdparts add.spread <mtd-dev> <size>[@<offset>] [<name>] [ro]\n" | |
2064 | " - add partition, padding size by skipping bad blocks\n" | |
2065 | #endif | |
68d7d651 | 2066 | "mtdparts default\n" |
ca75b20e BG |
2067 | " - reset partition table to defaults\n" |
2068 | #if defined(CONFIG_CMD_MTDPARTS_SPREAD) | |
2069 | "mtdparts spread\n" | |
2070 | " - adjust the sizes of the partitions so they are\n" | |
2071 | " at least as big as the mtdparts variable specifies\n" | |
2072 | " and they each start on a good block\n\n" | |
2073 | #else | |
2074 | "\n" | |
2075 | #endif /* CONFIG_CMD_MTDPARTS_SPREAD */ | |
68d7d651 SR |
2076 | "-----\n\n" |
2077 | "this command uses three environment variables:\n\n" | |
2078 | "'partition' - keeps current partition identifier\n\n" | |
2079 | "partition := <part-id>\n" | |
2080 | "<part-id> := <dev-id>,part_num\n\n" | |
2081 | "'mtdids' - linux kernel mtd device id <-> u-boot device id mapping\n\n" | |
2082 | "mtdids=<idmap>[,<idmap>,...]\n\n" | |
2083 | "<idmap> := <dev-id>=<mtd-id>\n" | |
2084 | "<dev-id> := 'nand'|'nor'|'onenand'<dev-num>\n" | |
2085 | "<dev-num> := mtd device number, 0...\n" | |
2086 | "<mtd-id> := unique device tag used by linux kernel to find mtd device (mtd->name)\n\n" | |
2087 | "'mtdparts' - partition list\n\n" | |
2088 | "mtdparts=mtdparts=<mtd-def>[;<mtd-def>...]\n\n" | |
2089 | "<mtd-def> := <mtd-id>:<part-def>[,<part-def>...]\n" | |
2090 | "<mtd-id> := unique device tag used by linux kernel to find mtd device (mtd->name)\n" | |
2091 | "<part-def> := <size>[@<offset>][<name>][<ro-flag>]\n" | |
2092 | "<size> := standard linux memsize OR '-' to denote all remaining space\n" | |
2093 | "<offset> := partition start offset within the device\n" | |
2094 | "<name> := '(' NAME ')'\n" | |
088f1b19 KP |
2095 | "<ro-flag> := when set to 'ro' makes partition read-only (not used, passed to kernel)"; |
2096 | #endif | |
2097 | ||
2098 | U_BOOT_CMD( | |
2099 | mtdparts, 6, 0, do_mtdparts, | |
2100 | "define flash/nand partitions", mtdparts_help_text | |
68d7d651 SR |
2101 | ); |
2102 | /***************************************************/ |