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 ULLONG_MAX
60 #define OFFSET_CONTINUOUS ULLONG_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 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 (%llx)\n",
109 return ERR_PTR(-EINVAL
);
113 /* fetch partition name and flags */
114 mask_flags
= 0; /* this is going to be a regular partition */
117 /* check for offset */
120 offset
= memparse(s
, &s
);
123 /* now look for name */
131 p
= strchr(name
, delim
);
133 printk(KERN_ERR ERRP
"no closing %c found in partition name\n", delim
);
134 return ERR_PTR(-EINVAL
);
140 name_len
= 13; /* Partition_000 */
143 /* record name length for memory allocation later */
144 extra_mem_size
+= name_len
+ 1;
146 /* test for options */
147 if (strncmp(s
, "ro", 2) == 0) {
148 mask_flags
|= MTD_WRITEABLE
;
152 /* if lk is found do NOT unlock the MTD partition*/
153 if (strncmp(s
, "lk", 2) == 0) {
154 mask_flags
|= MTD_POWERUP_LOCK
;
158 /* test if more partitions are following */
160 if (size
== SIZE_REMAINING
) {
161 printk(KERN_ERR ERRP
"no partitions allowed after a fill-up partition\n");
162 return ERR_PTR(-EINVAL
);
164 /* more partitions follow, parse them */
165 parts
= newpart(s
+ 1, &s
, num_parts
, this_part
+ 1,
166 &extra_mem
, extra_mem_size
);
170 /* this is the last partition: allocate space for all */
173 *num_parts
= this_part
+ 1;
174 alloc_size
= *num_parts
* sizeof(struct mtd_partition
) +
177 parts
= kzalloc(alloc_size
, GFP_KERNEL
);
179 return ERR_PTR(-ENOMEM
);
180 extra_mem
= (unsigned char *)(parts
+ *num_parts
);
183 /* enter this partition (offset will be calculated later if it is zero at this point) */
184 parts
[this_part
].size
= size
;
185 parts
[this_part
].offset
= offset
;
186 parts
[this_part
].mask_flags
= mask_flags
;
188 strlcpy(extra_mem
, name
, name_len
+ 1);
190 sprintf(extra_mem
, "Partition_%03d", this_part
);
191 parts
[this_part
].name
= extra_mem
;
192 extra_mem
+= name_len
+ 1;
194 dbg(("partition %d: name <%s>, offset %llx, size %llx, mask flags %x\n",
195 this_part
, parts
[this_part
].name
, parts
[this_part
].offset
,
196 parts
[this_part
].size
, parts
[this_part
].mask_flags
));
198 /* return (updated) pointer to extra_mem memory */
200 *extra_mem_ptr
= extra_mem
;
202 /* return (updated) pointer command line string */
205 /* return partition table */
210 * Parse the command line.
212 static int mtdpart_setup_real(char *s
)
218 struct cmdline_mtd_partition
*this_mtd
;
219 struct mtd_partition
*parts
;
220 int mtd_id_len
, num_parts
;
228 printk(KERN_ERR ERRP
"no mtd-id\n");
231 mtd_id_len
= p
- mtd_id
;
233 dbg(("parsing <%s>\n", p
+1));
236 * parse one mtd. have it reserve memory for the
237 * struct cmdline_mtd_partition and the mtd-id string.
239 parts
= newpart(p
+ 1, /* cmdline */
240 &s
, /* out: updated cmdline ptr */
241 &num_parts
, /* out: number of parts */
242 0, /* first partition */
243 (unsigned char**)&this_mtd
, /* out: extra mem */
244 mtd_id_len
+ 1 + sizeof(*this_mtd
) +
245 sizeof(void*)-1 /*alignment*/);
248 * An error occurred. We're either:
249 * a) out of memory, or
250 * b) in the middle of the partition spec
251 * Either way, this mtd is hosed and we're
252 * unlikely to succeed in parsing any more
254 return PTR_ERR(parts
);
258 this_mtd
= (struct cmdline_mtd_partition
*)
259 ALIGN((unsigned long)this_mtd
, sizeof(void *));
261 this_mtd
->parts
= parts
;
262 this_mtd
->num_parts
= num_parts
;
263 this_mtd
->mtd_id
= (char*)(this_mtd
+ 1);
264 strlcpy(this_mtd
->mtd_id
, mtd_id
, mtd_id_len
+ 1);
266 /* link into chain */
267 this_mtd
->next
= partitions
;
268 partitions
= this_mtd
;
270 dbg(("mtdid=<%s> num_parts=<%d>\n",
271 this_mtd
->mtd_id
, this_mtd
->num_parts
));
274 /* EOS - we're done */
278 /* does another spec follow? */
280 printk(KERN_ERR ERRP
"bad character after partition (%c)\n", *s
);
290 * Main function to be called from the MTD mapping driver/device to
291 * obtain the partitioning information. At this point the command line
292 * arguments will actually be parsed and turned to struct mtd_partition
293 * information. It returns partitions for the requested mtd device, or
294 * the first one in the chain if a NULL mtd_id is passed in.
296 static int parse_cmdline_partitions(struct mtd_info
*master
,
297 struct mtd_partition
**pparts
,
298 struct mtd_part_parser_data
*data
)
300 unsigned long long offset
;
302 struct cmdline_mtd_partition
*part
;
303 const char *mtd_id
= master
->name
;
305 /* parse command line */
306 if (!cmdline_parsed
) {
307 err
= mtdpart_setup_real(cmdline
);
313 * Search for the partition definition matching master->name.
314 * If master->name is not set, stop at first partition definition.
316 for (part
= partitions
; part
; part
= part
->next
) {
317 if ((!mtd_id
) || (!strcmp(part
->mtd_id
, mtd_id
)))
324 for (i
= 0, offset
= 0; i
< part
->num_parts
; i
++) {
325 if (part
->parts
[i
].offset
== OFFSET_CONTINUOUS
)
326 part
->parts
[i
].offset
= offset
;
328 offset
= part
->parts
[i
].offset
;
330 if (part
->parts
[i
].size
== SIZE_REMAINING
)
331 part
->parts
[i
].size
= master
->size
- offset
;
333 if (part
->parts
[i
].size
== 0) {
334 printk(KERN_WARNING ERRP
335 "%s: skipping zero sized partition\n",
338 memmove(&part
->parts
[i
], &part
->parts
[i
+ 1],
339 sizeof(*part
->parts
) * (part
->num_parts
- i
));
343 if (offset
+ part
->parts
[i
].size
> master
->size
) {
344 printk(KERN_WARNING ERRP
345 "%s: partitioning exceeds flash size, truncating\n",
347 part
->parts
[i
].size
= master
->size
- offset
;
349 offset
+= part
->parts
[i
].size
;
352 *pparts
= kmemdup(part
->parts
, sizeof(*part
->parts
) * part
->num_parts
,
357 return part
->num_parts
;
362 * This is the handler for our kernel parameter, called from
363 * main.c::checksetup(). Note that we can not yet kmalloc() anything,
364 * so we only save the commandline for later processing.
366 * This function needs to be visible for bootloaders.
368 static int mtdpart_setup(char *s
)
374 __setup("mtdparts=", mtdpart_setup
);
376 static struct mtd_part_parser cmdline_parser
= {
377 .owner
= THIS_MODULE
,
378 .parse_fn
= parse_cmdline_partitions
,
379 .name
= "cmdlinepart",
382 static int __init
cmdline_parser_init(void)
384 return register_mtd_parser(&cmdline_parser
);
387 module_init(cmdline_parser_init
);
389 MODULE_LICENSE("GPL");
390 MODULE_AUTHOR("Marius Groeger <mag@sysgo.de>");
391 MODULE_DESCRIPTION("Command line configuration of MTD partitions");