/* * Read flash partition table from command line * * Copyright © 2002 SYSGO Real-Time Solutions GmbH * Copyright © 2002-2010 David Woodhouse * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * * The format for the command line is as follows: * * mtdparts=[; := :[,] * := [@][][ro][lk] * := unique name used in mapping driver/device (mtd->name) * := standard linux memsize OR "-" to denote all remaining space * size is automatically truncated at end of device * if specified or truncated size is 0 the part is skipped * := standard linux memsize * if omitted the part will immediately follow the previous part * or 0 if the first part * := '(' NAME ')' * NAME will appear in /proc/mtd * * and can be specified such that the parts are out of order * in physical memory and may even overlap. * * The parts are assigned MTD numbers in the order they are specified in the * command line regardless of their order in physical memory. * * Examples: * * 1 NOR Flash, with 1 single writable partition: * edb7312-nor:- * * 1 NOR Flash with 2 partitions, 1 NAND with one * edb7312-nor:256k(ARMboot)ro,-(root);edb7312-nand:-(home) * * ========================================================================== * AVM extensions * -------------- * * A new command line parameter 'mtdparts_ext' was introduced with * same format as 'mtdparts' above. * * The semantics of 'mtdparts' force a complete override of previously * given parameters in case another 'mtdparts' entry is found. * * All 'mtdparts_ext' entries however are appended. * When the parser kicks in the first time, the kernel's 'mtdparts' * is appended to the 'mtdparts_ext' collection, so that the system is fed * with the complete information. * ========================================================================== */ #define pr_fmt(fmt) "mtd: " fmt #include #include #include #include #include #include /* debug macro */ #if 0 #define dbg(x) do { printk("DEBUG-CMDLINE-PART: "); printk x; } while(0) #else #define dbg(x) #endif /* special size referring to all the remaining space in a partition */ #define SIZE_REMAINING ULLONG_MAX #define OFFSET_CONTINUOUS ULLONG_MAX struct cmdline_mtd_partition { struct cmdline_mtd_partition *next; char *mtd_id; int num_parts; struct mtd_partition *parts; }; /* mtdpart_setup() parses into here */ static struct cmdline_mtd_partition *partitions; /* the command line passed to mtdpart_setup() */ static char *mtdparts; static char *cmdline; static int cmdline_parsed; #define AVM_MAX_MTDPARTS_EXT 64 static const char *avm_cmdline_ext[AVM_MAX_MTDPARTS_EXT + 1] __maybe_unused; static unsigned int num_avm_cmdline_ext __maybe_unused; /* * Parse one partition definition for an MTD. Since there can be many * comma separated partition definitions, this function calls itself * recursively until no more partition definitions are found. Nice side * effect: the memory to keep the mtd_partition structs and the names * is allocated upon the last definition being found. At that point the * syntax has been verified ok. */ static struct mtd_partition * newpart(char *s, char **retptr, int *num_parts, int this_part, unsigned char **extra_mem_ptr, int extra_mem_size) { struct mtd_partition *parts; unsigned long long size, offset = OFFSET_CONTINUOUS; char *name; int name_len; unsigned char *extra_mem; char delim; unsigned int mask_flags; /* fetch the partition size */ if (*s == '-') { /* assign all remaining space to this partition */ size = SIZE_REMAINING; s++; } else { size = memparse(s, &s); if (!size) { pr_err("partition has size 0\n"); return ERR_PTR(-EINVAL); } } /* fetch partition name and flags */ mask_flags = 0; /* this is going to be a regular partition */ delim = 0; /* check for offset */ if (*s == '@') { s++; offset = memparse(s, &s); } /* now look for name */ if (*s == '(') delim = ')'; if (delim) { char *p; name = ++s; p = strchr(name, delim); if (!p) { pr_err("no closing %c found in partition name\n", delim); return ERR_PTR(-EINVAL); } name_len = p - name; s = p + 1; } else { name = NULL; name_len = 13; /* Partition_000 */ } /* record name length for memory allocation later */ extra_mem_size += name_len + 1; /* test for options */ if (strncmp(s, "ro", 2) == 0) { mask_flags |= MTD_WRITEABLE; s += 2; } /* if lk is found do NOT unlock the MTD partition*/ if (strncmp(s, "lk", 2) == 0) { mask_flags |= MTD_POWERUP_LOCK; s += 2; } /* test if more partitions are following */ if (*s == ',') { if (size == SIZE_REMAINING) { pr_err("no partitions allowed after a fill-up partition\n"); return ERR_PTR(-EINVAL); } /* more partitions follow, parse them */ parts = newpart(s + 1, &s, num_parts, this_part + 1, &extra_mem, extra_mem_size); if (IS_ERR(parts)) return parts; } else { /* this is the last partition: allocate space for all */ int alloc_size; *num_parts = this_part + 1; alloc_size = *num_parts * sizeof(struct mtd_partition) + extra_mem_size; parts = kzalloc(alloc_size, GFP_KERNEL); if (!parts) return ERR_PTR(-ENOMEM); extra_mem = (unsigned char *)(parts + *num_parts); } /* enter this partition (offset will be calculated later if it is zero at this point) */ parts[this_part].size = size; parts[this_part].offset = offset; parts[this_part].mask_flags = mask_flags; if (name) strlcpy(extra_mem, name, name_len + 1); else sprintf(extra_mem, "Partition_%03d", this_part); parts[this_part].name = extra_mem; extra_mem += name_len + 1; dbg(("partition %d: name <%s>, offset %llx, size %llx, mask flags %x\n", this_part, parts[this_part].name, parts[this_part].offset, parts[this_part].size, parts[this_part].mask_flags)); /* return (updated) pointer to extra_mem memory */ if (extra_mem_ptr) *extra_mem_ptr = extra_mem; /* return (updated) pointer command line string */ *retptr = s; /* return partition table */ return parts; } #ifdef CONFIG_MTD_CMDLINE_PARTS_EXT static char *mtdpart_ext_build_cmdline(void) { char *cmdline_joined; unsigned int arg_n; size_t len; if (cmdline) avm_cmdline_ext[num_avm_cmdline_ext++] = cmdline; if (num_avm_cmdline_ext == 0) return NULL; len = 0; for (arg_n = 0; arg_n < num_avm_cmdline_ext; ++arg_n) len += strlen(avm_cmdline_ext[arg_n]); /* Reserve room for added ';' */ len += num_avm_cmdline_ext - 1; cmdline_joined = kzalloc(len + 1, GFP_KERNEL); if (!cmdline_joined) return ERR_PTR(-ENOMEM); for (arg_n = 0; arg_n < num_avm_cmdline_ext; ++arg_n) { if (arg_n) strcat(cmdline_joined, ";"); strcat(cmdline_joined, avm_cmdline_ext[arg_n]); } return cmdline_joined; } static int __init mtdpart_setup_ext(char *s) { if (num_avm_cmdline_ext < AVM_MAX_MTDPARTS_EXT) avm_cmdline_ext[num_avm_cmdline_ext++] = s; else pr_err("Too many mtdparts_ext arguments, discarding arg \"%s\"\n", s); return 1; } __setup("mtdparts_ext=", mtdpart_setup_ext); #endif /* * Parse the command line. */ static int mtdpart_setup_real(char *s) { cmdline_parsed = 1; for( ; s != NULL; ) { struct cmdline_mtd_partition *this_mtd; struct mtd_partition *parts; int mtd_id_len, num_parts; char *p, *mtd_id, *semicol, *open_parenth; /* * Replace the first ';' by a NULL char so strrchr can work * properly. */ semicol = strchr(s, ';'); if (semicol) *semicol = '\0'; /* * make sure that part-names with ":" will not be handled as * part of the mtd-id with an ":" */ open_parenth = strchr(s, '('); if (open_parenth) *open_parenth = '\0'; mtd_id = s; /* * fetch . We use strrchr to ignore all ':' that could * be present in the MTD name, only the last one is interpreted * as an / separator. */ p = strrchr(s, ':'); /* Restore the '(' now. */ if (open_parenth) *open_parenth = '('; /* Restore the ';' now. */ if (semicol) *semicol = ';'; if (!p) { pr_err("no mtd-id\n"); return -EINVAL; } mtd_id_len = p - mtd_id; dbg(("parsing <%s>\n", p+1)); /* * parse one mtd. have it reserve memory for the * struct cmdline_mtd_partition and the mtd-id string. */ parts = newpart(p + 1, /* cmdline */ &s, /* out: updated cmdline ptr */ &num_parts, /* out: number of parts */ 0, /* first partition */ (unsigned char**)&this_mtd, /* out: extra mem */ mtd_id_len + 1 + sizeof(*this_mtd) + sizeof(void*)-1 /*alignment*/); if (IS_ERR(parts)) { /* * An error occurred. We're either: * a) out of memory, or * b) in the middle of the partition spec * Either way, this mtd is hosed and we're * unlikely to succeed in parsing any more */ return PTR_ERR(parts); } /* align this_mtd */ this_mtd = (struct cmdline_mtd_partition *) ALIGN((unsigned long)this_mtd, sizeof(void *)); /* enter results */ this_mtd->parts = parts; this_mtd->num_parts = num_parts; this_mtd->mtd_id = (char*)(this_mtd + 1); strlcpy(this_mtd->mtd_id, mtd_id, mtd_id_len + 1); /* link into chain */ this_mtd->next = partitions; partitions = this_mtd; dbg(("mtdid=<%s> num_parts=<%d>\n", this_mtd->mtd_id, this_mtd->num_parts)); /* EOS - we're done */ if (*s == 0) break; /* does another spec follow? */ if (*s != ';') { pr_err("bad character after partition (%c)\n", *s); return -EINVAL; } s++; } return 0; } /* * Main function to be called from the MTD mapping driver/device to * obtain the partitioning information. At this point the command line * arguments will actually be parsed and turned to struct mtd_partition * information. It returns partitions for the requested mtd device, or * the first one in the chain if a NULL mtd_id is passed in. */ static int parse_cmdline_partitions(struct mtd_info *master, struct mtd_partition **pparts, struct mtd_part_parser_data *data) { unsigned long long offset; int i, err; struct cmdline_mtd_partition *part; const char *mtd_id = master->name; /* parse command line */ if (!cmdline_parsed) { char *ext_cmdline = cmdline; #ifdef CONFIG_MTD_CMDLINE_PARTS_EXT ext_cmdline = mtdpart_ext_build_cmdline(); if (IS_ERR(ext_cmdline)) return PTR_ERR(ext_cmdline); #endif err = mtdpart_setup_real(ext_cmdline); if (ext_cmdline != cmdline) kfree(ext_cmdline); if (err) return err; } /* * Search for the partition definition matching master->name. * If master->name is not set, stop at first partition definition. */ for (part = partitions; part; part = part->next) { if ((!mtd_id) || (!strcmp(part->mtd_id, mtd_id))) break; } if (!part) return 0; for (i = 0, offset = 0; i < part->num_parts; i++) { if (part->parts[i].offset == OFFSET_CONTINUOUS) part->parts[i].offset = offset; else offset = part->parts[i].offset; if (part->parts[i].size == SIZE_REMAINING) part->parts[i].size = master->size - offset; if (offset + part->parts[i].size > master->size) { pr_warn("%s: partitioning exceeds flash size, truncating\n", part->mtd_id); part->parts[i].size = master->size - offset; } offset += part->parts[i].size; if (part->parts[i].size == 0) { pr_warn("%s: skipping zero sized partition\n", part->mtd_id); part->num_parts--; memmove(&part->parts[i], &part->parts[i + 1], sizeof(*part->parts) * (part->num_parts - i)); i--; } } *pparts = kmemdup(part->parts, sizeof(*part->parts) * part->num_parts, GFP_KERNEL); if (!*pparts) return -ENOMEM; return part->num_parts; } /* * This is the handler for our kernel parameter, called from * main.c::checksetup(). Note that we can not yet kmalloc() anything, * so we only save the commandline for later processing. * * This function needs to be visible for bootloaders. */ static int __init mtdpart_setup(char *s) { cmdline = s; return 1; } __setup("mtdparts=", mtdpart_setup); static struct mtd_part_parser cmdline_parser = { .owner = THIS_MODULE, .parse_fn = parse_cmdline_partitions, .name = "cmdlinepart", }; static int __init cmdline_parser_init(void) { if (mtdparts) mtdpart_setup(mtdparts); register_mtd_parser(&cmdline_parser); return 0; } static void __exit cmdline_parser_exit(void) { deregister_mtd_parser(&cmdline_parser); } module_init(cmdline_parser_init); module_exit(cmdline_parser_exit); MODULE_PARM_DESC(mtdparts, "Partitioning specification"); module_param(mtdparts, charp, 0); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Marius Groeger "); MODULE_DESCRIPTION("Command line configuration of MTD partitions");