2 * Simple MTD partitioning layer
4 * (C) 2000 Nicolas Pitre <nico@cam.org>
8 * $Id: mtdpart.c,v 1.55 2005/11/07 11:14:20 gleixner Exp $
10 * 02-21-2002 Thomas Gleixner <gleixner@autronix.de>
11 * added support for read_oob, write_oob
14 #include <linux/module.h>
15 #include <linux/types.h>
16 #include <linux/kernel.h>
17 #include <linux/slab.h>
18 #include <linux/list.h>
19 #include <linux/config.h>
20 #include <linux/kmod.h>
21 #include <linux/mtd/mtd.h>
22 #include <linux/mtd/partitions.h>
23 #include <linux/mtd/compatmac.h>
25 /* Our partition linked list */
26 static LIST_HEAD(mtd_partitions);
28 /* Our partition node structure */
31 struct mtd_info *master;
34 struct list_head list;
39 * Given a pointer to the MTD object in the mtd_part structure, we can retrieve
40 * the pointer to that structure with this macro.
42 #define PART(x) ((struct mtd_part *)(x))
46 * MTD methods which simply translate the effective address and pass through
47 * to the _real_ device.
50 static int part_read (struct mtd_info *mtd, loff_t from, size_t len,
51 size_t *retlen, u_char *buf)
53 struct mtd_part *part = PART(mtd);
54 if (from >= mtd->size)
56 else if (from + len > mtd->size)
57 len = mtd->size - from;
58 return part->master->read (part->master, from + part->offset,
62 static int part_point (struct mtd_info *mtd, loff_t from, size_t len,
63 size_t *retlen, u_char **buf)
65 struct mtd_part *part = PART(mtd);
66 if (from >= mtd->size)
68 else if (from + len > mtd->size)
69 len = mtd->size - from;
70 return part->master->point (part->master, from + part->offset,
74 static void part_unpoint (struct mtd_info *mtd, u_char *addr, loff_t from, size_t len)
76 struct mtd_part *part = PART(mtd);
78 part->master->unpoint (part->master, addr, from + part->offset, len);
81 static int part_read_oob (struct mtd_info *mtd, loff_t from, size_t len,
82 size_t *retlen, u_char *buf)
84 struct mtd_part *part = PART(mtd);
85 if (from >= mtd->size)
87 else if (from + len > mtd->size)
88 len = mtd->size - from;
89 return part->master->read_oob (part->master, from + part->offset,
93 static int part_read_user_prot_reg (struct mtd_info *mtd, loff_t from, size_t len,
94 size_t *retlen, u_char *buf)
96 struct mtd_part *part = PART(mtd);
97 return part->master->read_user_prot_reg (part->master, from,
101 static int part_get_user_prot_info (struct mtd_info *mtd,
102 struct otp_info *buf, size_t len)
104 struct mtd_part *part = PART(mtd);
105 return part->master->get_user_prot_info (part->master, buf, len);
108 static int part_read_fact_prot_reg (struct mtd_info *mtd, loff_t from, size_t len,
109 size_t *retlen, u_char *buf)
111 struct mtd_part *part = PART(mtd);
112 return part->master->read_fact_prot_reg (part->master, from,
116 static int part_get_fact_prot_info (struct mtd_info *mtd,
117 struct otp_info *buf, size_t len)
119 struct mtd_part *part = PART(mtd);
120 return part->master->get_fact_prot_info (part->master, buf, len);
123 static int part_write (struct mtd_info *mtd, loff_t to, size_t len,
124 size_t *retlen, const u_char *buf)
126 struct mtd_part *part = PART(mtd);
127 if (!(mtd->flags & MTD_WRITEABLE))
131 else if (to + len > mtd->size)
132 len = mtd->size - to;
133 return part->master->write (part->master, to + part->offset,
137 static int part_write_oob (struct mtd_info *mtd, loff_t to, size_t len,
138 size_t *retlen, const u_char *buf)
140 struct mtd_part *part = PART(mtd);
141 if (!(mtd->flags & MTD_WRITEABLE))
145 else if (to + len > mtd->size)
146 len = mtd->size - to;
147 return part->master->write_oob (part->master, to + part->offset,
151 static int part_write_user_prot_reg (struct mtd_info *mtd, loff_t from, size_t len,
152 size_t *retlen, u_char *buf)
154 struct mtd_part *part = PART(mtd);
155 return part->master->write_user_prot_reg (part->master, from,
159 static int part_lock_user_prot_reg (struct mtd_info *mtd, loff_t from, size_t len)
161 struct mtd_part *part = PART(mtd);
162 return part->master->lock_user_prot_reg (part->master, from, len);
165 static int part_writev (struct mtd_info *mtd, const struct kvec *vecs,
166 unsigned long count, loff_t to, size_t *retlen)
168 struct mtd_part *part = PART(mtd);
169 if (!(mtd->flags & MTD_WRITEABLE))
171 return part->master->writev (part->master, vecs, count,
172 to + part->offset, retlen);
175 static int part_erase (struct mtd_info *mtd, struct erase_info *instr)
177 struct mtd_part *part = PART(mtd);
179 if (!(mtd->flags & MTD_WRITEABLE))
181 if (instr->addr >= mtd->size)
183 instr->addr += part->offset;
184 ret = part->master->erase(part->master, instr);
188 void mtd_erase_callback(struct erase_info *instr)
190 if (instr->mtd->erase == part_erase) {
191 struct mtd_part *part = PART(instr->mtd);
193 if (instr->fail_addr != 0xffffffff)
194 instr->fail_addr -= part->offset;
195 instr->addr -= part->offset;
198 instr->callback(instr);
200 EXPORT_SYMBOL_GPL(mtd_erase_callback);
202 static int part_lock (struct mtd_info *mtd, loff_t ofs, size_t len)
204 struct mtd_part *part = PART(mtd);
205 if ((len + ofs) > mtd->size)
207 return part->master->lock(part->master, ofs + part->offset, len);
210 static int part_unlock (struct mtd_info *mtd, loff_t ofs, size_t len)
212 struct mtd_part *part = PART(mtd);
213 if ((len + ofs) > mtd->size)
215 return part->master->unlock(part->master, ofs + part->offset, len);
218 static void part_sync(struct mtd_info *mtd)
220 struct mtd_part *part = PART(mtd);
221 part->master->sync(part->master);
224 static int part_suspend(struct mtd_info *mtd)
226 struct mtd_part *part = PART(mtd);
227 return part->master->suspend(part->master);
230 static void part_resume(struct mtd_info *mtd)
232 struct mtd_part *part = PART(mtd);
233 part->master->resume(part->master);
236 static int part_block_isbad (struct mtd_info *mtd, loff_t ofs)
238 struct mtd_part *part = PART(mtd);
239 if (ofs >= mtd->size)
242 return part->master->block_isbad(part->master, ofs);
245 static int part_block_markbad (struct mtd_info *mtd, loff_t ofs)
247 struct mtd_part *part = PART(mtd);
248 if (!(mtd->flags & MTD_WRITEABLE))
250 if (ofs >= mtd->size)
253 return part->master->block_markbad(part->master, ofs);
257 * This function unregisters and destroy all slave MTD objects which are
258 * attached to the given master MTD object.
261 int del_mtd_partitions(struct mtd_info *master)
263 struct list_head *node;
264 struct mtd_part *slave;
266 for (node = mtd_partitions.next;
267 node != &mtd_partitions;
269 slave = list_entry(node, struct mtd_part, list);
270 if (slave->master == master) {
271 struct list_head *prev = node->prev;
272 __list_del(prev, node->next);
273 if(slave->registered)
274 del_mtd_device(&slave->mtd);
284 * This function, given a master MTD object and a partition table, creates
285 * and registers slave MTD objects which are bound to the master according to
286 * the partition definitions.
287 * (Q: should we register the master MTD object as well?)
290 int add_mtd_partitions(struct mtd_info *master,
291 const struct mtd_partition *parts,
294 struct mtd_part *slave;
295 u_int32_t cur_offset = 0;
298 printk (KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name);
300 for (i = 0; i < nbparts; i++) {
302 /* allocate the partition structure */
303 slave = kmalloc (sizeof(*slave), GFP_KERNEL);
305 printk ("memory allocation error while creating partitions for \"%s\"\n",
307 del_mtd_partitions(master);
310 memset(slave, 0, sizeof(*slave));
311 list_add(&slave->list, &mtd_partitions);
313 /* set up the MTD object for this partition */
314 slave->mtd.type = master->type;
315 slave->mtd.flags = master->flags & ~parts[i].mask_flags;
316 slave->mtd.size = parts[i].size;
317 slave->mtd.writesize = master->writesize;
318 slave->mtd.oobsize = master->oobsize;
319 slave->mtd.ecctype = master->ecctype;
320 slave->mtd.eccsize = master->eccsize;
322 slave->mtd.name = parts[i].name;
323 slave->mtd.bank_size = master->bank_size;
324 slave->mtd.owner = master->owner;
326 slave->mtd.read = part_read;
327 slave->mtd.write = part_write;
329 if(master->point && master->unpoint){
330 slave->mtd.point = part_point;
331 slave->mtd.unpoint = part_unpoint;
334 if (master->read_oob)
335 slave->mtd.read_oob = part_read_oob;
336 if (master->write_oob)
337 slave->mtd.write_oob = part_write_oob;
338 if(master->read_user_prot_reg)
339 slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
340 if(master->read_fact_prot_reg)
341 slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
342 if(master->write_user_prot_reg)
343 slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
344 if(master->lock_user_prot_reg)
345 slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
346 if(master->get_user_prot_info)
347 slave->mtd.get_user_prot_info = part_get_user_prot_info;
348 if(master->get_fact_prot_info)
349 slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
351 slave->mtd.sync = part_sync;
352 if (!i && master->suspend && master->resume) {
353 slave->mtd.suspend = part_suspend;
354 slave->mtd.resume = part_resume;
357 slave->mtd.writev = part_writev;
359 slave->mtd.lock = part_lock;
361 slave->mtd.unlock = part_unlock;
362 if (master->block_isbad)
363 slave->mtd.block_isbad = part_block_isbad;
364 if (master->block_markbad)
365 slave->mtd.block_markbad = part_block_markbad;
366 slave->mtd.erase = part_erase;
367 slave->master = master;
368 slave->offset = parts[i].offset;
371 if (slave->offset == MTDPART_OFS_APPEND)
372 slave->offset = cur_offset;
373 if (slave->offset == MTDPART_OFS_NXTBLK) {
374 slave->offset = cur_offset;
375 if ((cur_offset % master->erasesize) != 0) {
376 /* Round up to next erasesize */
377 slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize;
378 printk(KERN_NOTICE "Moving partition %d: "
379 "0x%08x -> 0x%08x\n", i,
380 cur_offset, slave->offset);
383 if (slave->mtd.size == MTDPART_SIZ_FULL)
384 slave->mtd.size = master->size - slave->offset;
385 cur_offset = slave->offset + slave->mtd.size;
387 printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset,
388 slave->offset + slave->mtd.size, slave->mtd.name);
390 /* let's do some sanity checks */
391 if (slave->offset >= master->size) {
392 /* let's register it anyway to preserve ordering */
395 printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
398 if (slave->offset + slave->mtd.size > master->size) {
399 slave->mtd.size = master->size - slave->offset;
400 printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
401 parts[i].name, master->name, slave->mtd.size);
403 if (master->numeraseregions>1) {
404 /* Deal with variable erase size stuff */
406 struct mtd_erase_region_info *regions = master->eraseregions;
408 /* Find the first erase regions which is part of this partition. */
409 for (i=0; i < master->numeraseregions && slave->offset >= regions[i].offset; i++)
412 for (i--; i < master->numeraseregions && slave->offset + slave->mtd.size > regions[i].offset; i++) {
413 if (slave->mtd.erasesize < regions[i].erasesize) {
414 slave->mtd.erasesize = regions[i].erasesize;
418 /* Single erase size */
419 slave->mtd.erasesize = master->erasesize;
422 if ((slave->mtd.flags & MTD_WRITEABLE) &&
423 (slave->offset % slave->mtd.erasesize)) {
424 /* Doesn't start on a boundary of major erase size */
425 /* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
426 slave->mtd.flags &= ~MTD_WRITEABLE;
427 printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
430 if ((slave->mtd.flags & MTD_WRITEABLE) &&
431 (slave->mtd.size % slave->mtd.erasesize)) {
432 slave->mtd.flags &= ~MTD_WRITEABLE;
433 printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
437 slave->mtd.oobinfo = master->oobinfo;
440 { /* store the object pointer (caller may or may not register it */
441 *parts[i].mtdp = &slave->mtd;
442 slave->registered = 0;
446 /* register our partition */
447 add_mtd_device(&slave->mtd);
448 slave->registered = 1;
455 EXPORT_SYMBOL(add_mtd_partitions);
456 EXPORT_SYMBOL(del_mtd_partitions);
458 static DEFINE_SPINLOCK(part_parser_lock);
459 static LIST_HEAD(part_parsers);
461 static struct mtd_part_parser *get_partition_parser(const char *name)
463 struct list_head *this;
465 spin_lock(&part_parser_lock);
467 list_for_each(this, &part_parsers) {
468 struct mtd_part_parser *p = list_entry(this, struct mtd_part_parser, list);
470 if (!strcmp(p->name, name) && try_module_get(p->owner)) {
475 spin_unlock(&part_parser_lock);
480 int register_mtd_parser(struct mtd_part_parser *p)
482 spin_lock(&part_parser_lock);
483 list_add(&p->list, &part_parsers);
484 spin_unlock(&part_parser_lock);
489 int deregister_mtd_parser(struct mtd_part_parser *p)
491 spin_lock(&part_parser_lock);
493 spin_unlock(&part_parser_lock);
497 int parse_mtd_partitions(struct mtd_info *master, const char **types,
498 struct mtd_partition **pparts, unsigned long origin)
500 struct mtd_part_parser *parser;
503 for ( ; ret <= 0 && *types; types++) {
504 parser = get_partition_parser(*types);
506 if (!parser && !request_module("%s", *types))
507 parser = get_partition_parser(*types);
510 printk(KERN_NOTICE "%s partition parsing not available\n",
514 ret = (*parser->parse_fn)(master, pparts, origin);
516 printk(KERN_NOTICE "%d %s partitions found on MTD device %s\n",
517 ret, parser->name, master->name);
519 put_partition_parser(parser);
524 EXPORT_SYMBOL_GPL(parse_mtd_partitions);
525 EXPORT_SYMBOL_GPL(register_mtd_parser);
526 EXPORT_SYMBOL_GPL(deregister_mtd_parser);
528 MODULE_LICENSE("GPL");
529 MODULE_AUTHOR("Nicolas Pitre <nico@cam.org>");
530 MODULE_DESCRIPTION("Generic support for partitioning of MTD devices");