2 * Read flash partition table from command line
4 * Copyright © 2002 SYSGO Real-Time Solutions GmbH
5 * Copyright © 2002-2010 David Woodhouse <dwmw2@infradead.org>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 * The format for the command line is as follows:
23 * mtdparts=<mtddef>[;<mtddef]
24 * <mtddef> := <mtd-id>:<partdef>[,<partdef>]
25 * where <mtd-id> is the name from the "cat /proc/mtd" command
26 * <partdef> := <size>[@offset][<name>][ro][lk]
27 * <mtd-id> := unique name used in mapping driver/device (mtd->name)
28 * <size> := standard linux memsize OR "-" to denote all remaining space
29 * <name> := '(' NAME ')'
33 * 1 NOR Flash, with 1 single writable partition:
36 * 1 NOR Flash with 2 partitions, 1 NAND with one
37 * edb7312-nor:256k(ARMboot)ro,-(root);edb7312-nand:-(home)
40 #include <linux/kernel.h>
41 #include <linux/slab.h>
42 #include <linux/mtd/mtd.h>
43 #include <linux/mtd/partitions.h>
44 #include <linux/module.h>
45 #include <linux/err.h>
47 /* error message prefix */
52 #define dbg(x) do { printk("DEBUG-CMDLINE-PART: "); printk x; } while(0)
58 /* special size referring to all the remaining space in a partition */
59 #define SIZE_REMAINING UINT_MAX
60 #define OFFSET_CONTINUOUS UINT_MAX
62 struct cmdline_mtd_partition
{
63 struct cmdline_mtd_partition
*next
;
66 struct mtd_partition
*parts
;
69 /* mtdpart_setup() parses into here */
70 static struct cmdline_mtd_partition
*partitions
;
72 /* the command line passed to mtdpart_setup() */
74 static int cmdline_parsed
;
77 * Parse one partition definition for an MTD. Since there can be many
78 * comma separated partition definitions, this function calls itself
79 * recursively until no more partition definitions are found. Nice side
80 * effect: the memory to keep the mtd_partition structs and the names
81 * is allocated upon the last definition being found. At that point the
82 * syntax has been verified ok.
84 static struct mtd_partition
* newpart(char *s
,
88 unsigned char **extra_mem_ptr
,
91 struct mtd_partition
*parts
;
92 unsigned long size
, offset
= OFFSET_CONTINUOUS
;
95 unsigned char *extra_mem
;
97 unsigned int mask_flags
;
99 /* fetch the partition size */
101 /* assign all remaining space to this partition */
102 size
= SIZE_REMAINING
;
105 size
= memparse(s
, &s
);
106 if (size
< PAGE_SIZE
) {
107 printk(KERN_ERR ERRP
"partition size too small (%lx)\n", size
);
108 return ERR_PTR(-EINVAL
);
112 /* fetch partition name and flags */
113 mask_flags
= 0; /* this is going to be a regular partition */
116 /* check for offset */
119 offset
= memparse(s
, &s
);
122 /* now look for name */
130 p
= strchr(name
, delim
);
132 printk(KERN_ERR ERRP
"no closing %c found in partition name\n", delim
);
133 return ERR_PTR(-EINVAL
);
139 name_len
= 13; /* Partition_000 */
142 /* record name length for memory allocation later */
143 extra_mem_size
+= name_len
+ 1;
145 /* test for options */
146 if (strncmp(s
, "ro", 2) == 0) {
147 mask_flags
|= MTD_WRITEABLE
;
151 /* if lk is found do NOT unlock the MTD partition*/
152 if (strncmp(s
, "lk", 2) == 0) {
153 mask_flags
|= MTD_POWERUP_LOCK
;
157 /* test if more partitions are following */
159 if (size
== SIZE_REMAINING
) {
160 printk(KERN_ERR ERRP
"no partitions allowed after a fill-up partition\n");
161 return ERR_PTR(-EINVAL
);
163 /* more partitions follow, parse them */
164 parts
= newpart(s
+ 1, &s
, num_parts
, this_part
+ 1,
165 &extra_mem
, extra_mem_size
);
169 /* this is the last partition: allocate space for all */
172 *num_parts
= this_part
+ 1;
173 alloc_size
= *num_parts
* sizeof(struct mtd_partition
) +
176 parts
= kzalloc(alloc_size
, GFP_KERNEL
);
178 return ERR_PTR(-ENOMEM
);
179 extra_mem
= (unsigned char *)(parts
+ *num_parts
);
182 /* enter this partition (offset will be calculated later if it is zero at this point) */
183 parts
[this_part
].size
= size
;
184 parts
[this_part
].offset
= offset
;
185 parts
[this_part
].mask_flags
= mask_flags
;
187 strlcpy(extra_mem
, name
, name_len
+ 1);
189 sprintf(extra_mem
, "Partition_%03d", this_part
);
190 parts
[this_part
].name
= extra_mem
;
191 extra_mem
+= name_len
+ 1;
193 dbg(("partition %d: name <%s>, offset %llx, size %llx, mask flags %x\n",
194 this_part
, parts
[this_part
].name
, parts
[this_part
].offset
,
195 parts
[this_part
].size
, parts
[this_part
].mask_flags
));
197 /* return (updated) pointer to extra_mem memory */
199 *extra_mem_ptr
= extra_mem
;
201 /* return (updated) pointer command line string */
204 /* return partition table */
209 * Parse the command line.
211 static int mtdpart_setup_real(char *s
)
217 struct cmdline_mtd_partition
*this_mtd
;
218 struct mtd_partition
*parts
;
219 int mtd_id_len
, num_parts
;
227 printk(KERN_ERR ERRP
"no mtd-id\n");
230 mtd_id_len
= p
- mtd_id
;
232 dbg(("parsing <%s>\n", p
+1));
235 * parse one mtd. have it reserve memory for the
236 * struct cmdline_mtd_partition and the mtd-id string.
238 parts
= newpart(p
+ 1, /* cmdline */
239 &s
, /* out: updated cmdline ptr */
240 &num_parts
, /* out: number of parts */
241 0, /* first partition */
242 (unsigned char**)&this_mtd
, /* out: extra mem */
243 mtd_id_len
+ 1 + sizeof(*this_mtd
) +
244 sizeof(void*)-1 /*alignment*/);
247 * An error occurred. We're either:
248 * a) out of memory, or
249 * b) in the middle of the partition spec
250 * Either way, this mtd is hosed and we're
251 * unlikely to succeed in parsing any more
253 return PTR_ERR(parts
);
257 this_mtd
= (struct cmdline_mtd_partition
*)
258 ALIGN((unsigned long)this_mtd
, sizeof(void *));
260 this_mtd
->parts
= parts
;
261 this_mtd
->num_parts
= num_parts
;
262 this_mtd
->mtd_id
= (char*)(this_mtd
+ 1);
263 strlcpy(this_mtd
->mtd_id
, mtd_id
, mtd_id_len
+ 1);
265 /* link into chain */
266 this_mtd
->next
= partitions
;
267 partitions
= this_mtd
;
269 dbg(("mtdid=<%s> num_parts=<%d>\n",
270 this_mtd
->mtd_id
, this_mtd
->num_parts
));
273 /* EOS - we're done */
277 /* does another spec follow? */
279 printk(KERN_ERR ERRP
"bad character after partition (%c)\n", *s
);
289 * Main function to be called from the MTD mapping driver/device to
290 * obtain the partitioning information. At this point the command line
291 * arguments will actually be parsed and turned to struct mtd_partition
292 * information. It returns partitions for the requested mtd device, or
293 * the first one in the chain if a NULL mtd_id is passed in.
295 static int parse_cmdline_partitions(struct mtd_info
*master
,
296 struct mtd_partition
**pparts
,
297 struct mtd_part_parser_data
*data
)
299 unsigned long offset
;
301 struct cmdline_mtd_partition
*part
;
302 const char *mtd_id
= master
->name
;
304 /* parse command line */
305 if (!cmdline_parsed
) {
306 err
= mtdpart_setup_real(cmdline
);
311 for (part
= partitions
; part
; part
= part
->next
) {
312 if ((!mtd_id
) || (!strcmp(part
->mtd_id
, mtd_id
))) {
313 for (i
= 0, offset
= 0; i
< part
->num_parts
; i
++) {
314 if (part
->parts
[i
].offset
== OFFSET_CONTINUOUS
)
315 part
->parts
[i
].offset
= offset
;
317 offset
= part
->parts
[i
].offset
;
319 if (part
->parts
[i
].size
== SIZE_REMAINING
)
320 part
->parts
[i
].size
= master
->size
- offset
;
322 if (part
->parts
[i
].size
== 0) {
323 printk(KERN_WARNING ERRP
324 "%s: skipping zero sized partition\n",
327 memmove(&part
->parts
[i
],
329 sizeof(*part
->parts
) * (part
->num_parts
- i
));
333 if (offset
+ part
->parts
[i
].size
> master
->size
) {
334 printk(KERN_WARNING ERRP
335 "%s: partitioning exceeds flash size, truncating\n",
337 part
->parts
[i
].size
= master
->size
- offset
;
339 offset
+= part
->parts
[i
].size
;
342 *pparts
= kmemdup(part
->parts
,
343 sizeof(*part
->parts
) * part
->num_parts
,
348 return part
->num_parts
;
357 * This is the handler for our kernel parameter, called from
358 * main.c::checksetup(). Note that we can not yet kmalloc() anything,
359 * so we only save the commandline for later processing.
361 * This function needs to be visible for bootloaders.
363 static int mtdpart_setup(char *s
)
369 __setup("mtdparts=", mtdpart_setup
);
371 static struct mtd_part_parser cmdline_parser
= {
372 .owner
= THIS_MODULE
,
373 .parse_fn
= parse_cmdline_partitions
,
374 .name
= "cmdlinepart",
377 static int __init
cmdline_parser_init(void)
379 return register_mtd_parser(&cmdline_parser
);
382 module_init(cmdline_parser_init
);
384 MODULE_LICENSE("GPL");
385 MODULE_AUTHOR("Marius Groeger <mag@sysgo.de>");
386 MODULE_DESCRIPTION("Command line configuration of MTD partitions");