2 * Simple MTD partitioning layer
4 * (C) 2000 Nicolas Pitre <nico@cam.org>
8 * $Id: mtdpart.c,v 1.41 2003/06/18 14:53:02 dwmw2 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 if (part
->master
->read_ecc
== NULL
)
59 return part
->master
->read (part
->master
, from
+ part
->offset
,
62 return part
->master
->read_ecc (part
->master
, from
+ part
->offset
,
63 len
, retlen
, buf
, NULL
, &mtd
->oobinfo
);
66 static int part_point (struct mtd_info
*mtd
, loff_t from
, size_t len
,
67 size_t *retlen
, u_char
**buf
)
69 struct mtd_part
*part
= PART(mtd
);
70 if (from
>= mtd
->size
)
72 else if (from
+ len
> mtd
->size
)
73 len
= mtd
->size
- from
;
74 return part
->master
->point (part
->master
, from
+ part
->offset
,
77 static void part_unpoint (struct mtd_info
*mtd
, u_char
*addr
, loff_t from
, size_t len
)
79 struct mtd_part
*part
= PART(mtd
);
81 part
->master
->unpoint (part
->master
, addr
, from
+ part
->offset
, len
);
85 static int part_read_ecc (struct mtd_info
*mtd
, loff_t from
, size_t len
,
86 size_t *retlen
, u_char
*buf
, u_char
*eccbuf
, struct nand_oobinfo
*oobsel
)
88 struct mtd_part
*part
= PART(mtd
);
90 oobsel
= &mtd
->oobinfo
;
91 if (from
>= mtd
->size
)
93 else if (from
+ len
> mtd
->size
)
94 len
= mtd
->size
- from
;
95 return part
->master
->read_ecc (part
->master
, from
+ part
->offset
,
96 len
, retlen
, buf
, eccbuf
, oobsel
);
99 static int part_read_oob (struct mtd_info
*mtd
, loff_t from
, size_t len
,
100 size_t *retlen
, u_char
*buf
)
102 struct mtd_part
*part
= PART(mtd
);
103 if (from
>= mtd
->size
)
105 else if (from
+ len
> mtd
->size
)
106 len
= mtd
->size
- from
;
107 return part
->master
->read_oob (part
->master
, from
+ part
->offset
,
111 static int part_read_user_prot_reg (struct mtd_info
*mtd
, loff_t from
, size_t len
,
112 size_t *retlen
, u_char
*buf
)
114 struct mtd_part
*part
= PART(mtd
);
115 return part
->master
->read_user_prot_reg (part
->master
, from
,
119 static int part_read_fact_prot_reg (struct mtd_info
*mtd
, loff_t from
, size_t len
,
120 size_t *retlen
, u_char
*buf
)
122 struct mtd_part
*part
= PART(mtd
);
123 return part
->master
->read_fact_prot_reg (part
->master
, from
,
127 static int part_write (struct mtd_info
*mtd
, loff_t to
, size_t len
,
128 size_t *retlen
, const u_char
*buf
)
130 struct mtd_part
*part
= PART(mtd
);
131 if (!(mtd
->flags
& MTD_WRITEABLE
))
135 else if (to
+ len
> mtd
->size
)
136 len
= mtd
->size
- to
;
137 if (part
->master
->write_ecc
== NULL
)
138 return part
->master
->write (part
->master
, to
+ part
->offset
,
141 return part
->master
->write_ecc (part
->master
, to
+ part
->offset
,
142 len
, retlen
, buf
, NULL
, &mtd
->oobinfo
);
146 static int part_write_ecc (struct mtd_info
*mtd
, loff_t to
, size_t len
,
147 size_t *retlen
, const u_char
*buf
,
148 u_char
*eccbuf
, struct nand_oobinfo
*oobsel
)
150 struct mtd_part
*part
= PART(mtd
);
151 if (!(mtd
->flags
& MTD_WRITEABLE
))
154 oobsel
= &mtd
->oobinfo
;
157 else if (to
+ len
> mtd
->size
)
158 len
= mtd
->size
- to
;
159 return part
->master
->write_ecc (part
->master
, to
+ part
->offset
,
160 len
, retlen
, buf
, eccbuf
, oobsel
);
163 static int part_write_oob (struct mtd_info
*mtd
, loff_t to
, size_t len
,
164 size_t *retlen
, const u_char
*buf
)
166 struct mtd_part
*part
= PART(mtd
);
167 if (!(mtd
->flags
& MTD_WRITEABLE
))
171 else if (to
+ len
> mtd
->size
)
172 len
= mtd
->size
- to
;
173 return part
->master
->write_oob (part
->master
, to
+ part
->offset
,
177 static int part_write_user_prot_reg (struct mtd_info
*mtd
, loff_t from
, size_t len
,
178 size_t *retlen
, u_char
*buf
)
180 struct mtd_part
*part
= PART(mtd
);
181 return part
->master
->write_user_prot_reg (part
->master
, from
,
185 static int part_writev (struct mtd_info
*mtd
, const struct iovec
*vecs
,
186 unsigned long count
, loff_t to
, size_t *retlen
)
188 struct mtd_part
*part
= PART(mtd
);
189 if (!(mtd
->flags
& MTD_WRITEABLE
))
191 if (part
->master
->writev_ecc
== NULL
)
192 return part
->master
->writev (part
->master
, vecs
, count
,
193 to
+ part
->offset
, retlen
);
195 return part
->master
->writev_ecc (part
->master
, vecs
, count
,
196 to
+ part
->offset
, retlen
,
197 NULL
, &mtd
->oobinfo
);
200 static int part_readv (struct mtd_info
*mtd
, struct iovec
*vecs
,
201 unsigned long count
, loff_t from
, size_t *retlen
)
203 struct mtd_part
*part
= PART(mtd
);
204 if (part
->master
->readv_ecc
== NULL
)
205 return part
->master
->readv (part
->master
, vecs
, count
,
206 from
+ part
->offset
, retlen
);
208 return part
->master
->readv_ecc (part
->master
, vecs
, count
,
209 from
+ part
->offset
, retlen
,
210 NULL
, &mtd
->oobinfo
);
213 static int part_writev_ecc (struct mtd_info
*mtd
, const struct iovec
*vecs
,
214 unsigned long count
, loff_t to
, size_t *retlen
,
215 u_char
*eccbuf
, struct nand_oobinfo
*oobsel
)
217 struct mtd_part
*part
= PART(mtd
);
218 if (!(mtd
->flags
& MTD_WRITEABLE
))
221 oobsel
= &mtd
->oobinfo
;
222 return part
->master
->writev_ecc (part
->master
, vecs
, count
,
223 to
+ part
->offset
, retlen
,
227 static int part_readv_ecc (struct mtd_info
*mtd
, struct iovec
*vecs
,
228 unsigned long count
, loff_t from
, size_t *retlen
,
229 u_char
*eccbuf
, struct nand_oobinfo
*oobsel
)
231 struct mtd_part
*part
= PART(mtd
);
233 oobsel
= &mtd
->oobinfo
;
234 return part
->master
->readv_ecc (part
->master
, vecs
, count
,
235 from
+ part
->offset
, retlen
,
239 static int part_erase (struct mtd_info
*mtd
, struct erase_info
*instr
)
241 struct mtd_part
*part
= PART(mtd
);
242 if (!(mtd
->flags
& MTD_WRITEABLE
))
244 if (instr
->addr
>= mtd
->size
)
246 instr
->addr
+= part
->offset
;
247 return part
->master
->erase(part
->master
, instr
);
250 static int part_lock (struct mtd_info
*mtd
, loff_t ofs
, size_t len
)
252 struct mtd_part
*part
= PART(mtd
);
253 if ((len
+ ofs
) > mtd
->size
)
255 return part
->master
->lock(part
->master
, ofs
+ part
->offset
, len
);
258 static int part_unlock (struct mtd_info
*mtd
, loff_t ofs
, size_t len
)
260 struct mtd_part
*part
= PART(mtd
);
261 if ((len
+ ofs
) > mtd
->size
)
263 return part
->master
->unlock(part
->master
, ofs
+ part
->offset
, len
);
266 static void part_sync(struct mtd_info
*mtd
)
268 struct mtd_part
*part
= PART(mtd
);
269 part
->master
->sync(part
->master
);
272 static int part_suspend(struct mtd_info
*mtd
)
274 struct mtd_part
*part
= PART(mtd
);
275 return part
->master
->suspend(part
->master
);
278 static void part_resume(struct mtd_info
*mtd
)
280 struct mtd_part
*part
= PART(mtd
);
281 part
->master
->resume(part
->master
);
285 * This function unregisters and destroy all slave MTD objects which are
286 * attached to the given master MTD object.
289 int del_mtd_partitions(struct mtd_info
*master
)
291 struct list_head
*node
;
292 struct mtd_part
*slave
;
294 for (node
= mtd_partitions
.next
;
295 node
!= &mtd_partitions
;
297 slave
= list_entry(node
, struct mtd_part
, list
);
298 if (slave
->master
== master
) {
299 struct list_head
*prev
= node
->prev
;
300 __list_del(prev
, node
->next
);
301 if(slave
->registered
)
302 del_mtd_device(&slave
->mtd
);
312 * This function, given a master MTD object and a partition table, creates
313 * and registers slave MTD objects which are bound to the master according to
314 * the partition definitions.
315 * (Q: should we register the master MTD object as well?)
318 int add_mtd_partitions(struct mtd_info
*master
,
319 struct mtd_partition
*parts
,
322 struct mtd_part
*slave
;
323 u_int32_t cur_offset
= 0;
326 printk (KERN_NOTICE
"Creating %d MTD partitions on \"%s\":\n", nbparts
, master
->name
);
328 for (i
= 0; i
< nbparts
; i
++) {
330 /* allocate the partition structure */
331 slave
= kmalloc (sizeof(*slave
), GFP_KERNEL
);
333 printk ("memory allocation error while creating partitions for \"%s\"\n",
335 del_mtd_partitions(master
);
338 memset(slave
, 0, sizeof(*slave
));
339 list_add(&slave
->list
, &mtd_partitions
);
341 /* set up the MTD object for this partition */
342 slave
->mtd
.type
= master
->type
;
343 slave
->mtd
.flags
= master
->flags
& ~parts
[i
].mask_flags
;
344 slave
->mtd
.size
= parts
[i
].size
;
345 slave
->mtd
.oobblock
= master
->oobblock
;
346 slave
->mtd
.oobsize
= master
->oobsize
;
347 slave
->mtd
.ecctype
= master
->ecctype
;
348 slave
->mtd
.eccsize
= master
->eccsize
;
350 slave
->mtd
.name
= parts
[i
].name
;
351 slave
->mtd
.bank_size
= master
->bank_size
;
352 slave
->mtd
.owner
= master
->owner
;
354 slave
->mtd
.read
= part_read
;
355 slave
->mtd
.write
= part_write
;
357 if(master
->point
&& master
->unpoint
){
358 slave
->mtd
.point
= part_point
;
359 slave
->mtd
.unpoint
= part_unpoint
;
362 if (master
->read_ecc
)
363 slave
->mtd
.read_ecc
= part_read_ecc
;
364 if (master
->write_ecc
)
365 slave
->mtd
.write_ecc
= part_write_ecc
;
366 if (master
->read_oob
)
367 slave
->mtd
.read_oob
= part_read_oob
;
368 if (master
->write_oob
)
369 slave
->mtd
.write_oob
= part_write_oob
;
370 if(master
->read_user_prot_reg
)
371 slave
->mtd
.read_user_prot_reg
= part_read_user_prot_reg
;
372 if(master
->read_fact_prot_reg
)
373 slave
->mtd
.read_fact_prot_reg
= part_read_fact_prot_reg
;
374 if(master
->write_user_prot_reg
)
375 slave
->mtd
.write_user_prot_reg
= part_write_user_prot_reg
;
377 slave
->mtd
.sync
= part_sync
;
378 if (!i
&& master
->suspend
&& master
->resume
) {
379 slave
->mtd
.suspend
= part_suspend
;
380 slave
->mtd
.resume
= part_resume
;
383 slave
->mtd
.writev
= part_writev
;
385 slave
->mtd
.readv
= part_readv
;
386 if (master
->writev_ecc
)
387 slave
->mtd
.writev_ecc
= part_writev_ecc
;
388 if (master
->readv_ecc
)
389 slave
->mtd
.readv_ecc
= part_readv_ecc
;
391 slave
->mtd
.lock
= part_lock
;
393 slave
->mtd
.unlock
= part_unlock
;
394 slave
->mtd
.erase
= part_erase
;
395 slave
->master
= master
;
396 slave
->offset
= parts
[i
].offset
;
399 if (slave
->offset
== MTDPART_OFS_APPEND
)
400 slave
->offset
= cur_offset
;
401 if (slave
->offset
== MTDPART_OFS_NXTBLK
) {
402 u_int32_t emask
= master
->erasesize
-1;
403 slave
->offset
= (cur_offset
+ emask
) & ~emask
;
404 if (slave
->offset
!= cur_offset
) {
405 printk(KERN_NOTICE
"Moving partition %d: "
406 "0x%08x -> 0x%08x\n", i
,
407 cur_offset
, slave
->offset
);
410 if (slave
->mtd
.size
== MTDPART_SIZ_FULL
)
411 slave
->mtd
.size
= master
->size
- slave
->offset
;
412 cur_offset
= slave
->offset
+ slave
->mtd
.size
;
414 printk (KERN_NOTICE
"0x%08x-0x%08x : \"%s\"\n", slave
->offset
,
415 slave
->offset
+ slave
->mtd
.size
, slave
->mtd
.name
);
417 /* let's do some sanity checks */
418 if (slave
->offset
>= master
->size
) {
419 /* let's register it anyway to preserve ordering */
422 printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
425 if (slave
->offset
+ slave
->mtd
.size
> master
->size
) {
426 slave
->mtd
.size
= master
->size
- slave
->offset
;
427 printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
428 parts
[i
].name
, master
->name
, slave
->mtd
.size
);
430 if (master
->numeraseregions
>1) {
431 /* Deal with variable erase size stuff */
433 struct mtd_erase_region_info
*regions
= master
->eraseregions
;
435 /* Find the first erase regions which is part of this partition. */
436 for (i
=0; i
< master
->numeraseregions
&& slave
->offset
>= regions
[i
].offset
; i
++)
439 for (i
--; i
< master
->numeraseregions
&& slave
->offset
+ slave
->mtd
.size
> regions
[i
].offset
; i
++) {
440 if (slave
->mtd
.erasesize
< regions
[i
].erasesize
) {
441 slave
->mtd
.erasesize
= regions
[i
].erasesize
;
445 /* Single erase size */
446 slave
->mtd
.erasesize
= master
->erasesize
;
449 if ((slave
->mtd
.flags
& MTD_WRITEABLE
) &&
450 (slave
->offset
% slave
->mtd
.erasesize
)) {
451 /* Doesn't start on a boundary of major erase size */
452 /* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
453 slave
->mtd
.flags
&= ~MTD_WRITEABLE
;
454 printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
457 if ((slave
->mtd
.flags
& MTD_WRITEABLE
) &&
458 (slave
->mtd
.size
% slave
->mtd
.erasesize
)) {
459 slave
->mtd
.flags
&= ~MTD_WRITEABLE
;
460 printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
465 { /* store the object pointer (caller may or may not register it */
466 *parts
[i
].mtdp
= &slave
->mtd
;
467 slave
->registered
= 0;
471 /* register our partition */
472 add_mtd_device(&slave
->mtd
);
473 slave
->registered
= 1;
480 EXPORT_SYMBOL(add_mtd_partitions
);
481 EXPORT_SYMBOL(del_mtd_partitions
);
483 static spinlock_t part_parser_lock
= SPIN_LOCK_UNLOCKED
;
484 static LIST_HEAD(part_parsers
);
486 struct mtd_part_parser
*get_partition_parser(const char *name
)
488 struct list_head
*this;
490 spin_lock(&part_parser_lock
);
492 list_for_each(this, &part_parsers
) {
493 struct mtd_part_parser
*p
= list_entry(this, struct mtd_part_parser
, list
);
495 if (!strcmp(p
->name
, name
) && try_module_get(p
->owner
)) {
500 spin_unlock(&part_parser_lock
);
505 int register_mtd_parser(struct mtd_part_parser
*p
)
507 spin_lock(&part_parser_lock
);
508 list_add(&p
->list
, &part_parsers
);
509 spin_unlock(&part_parser_lock
);
514 int deregister_mtd_parser(struct mtd_part_parser
*p
)
516 spin_lock(&part_parser_lock
);
518 spin_unlock(&part_parser_lock
);
522 int parse_mtd_partitions(struct mtd_info
*master
, const char **types
,
523 struct mtd_partition
**pparts
, unsigned long origin
)
525 struct mtd_part_parser
*parser
;
528 for ( ; ret
<= 0 && *types
; types
++) {
529 parser
= get_partition_parser(*types
);
531 if (!parser
&& !request_module("%s", *types
))
532 parser
= get_partition_parser(*types
);
535 printk(KERN_NOTICE
"%s partition parsing not available\n",
539 ret
= (*parser
->parse_fn
)(master
, pparts
, origin
);
541 printk(KERN_NOTICE
"%d %s partitions found on MTD device %s\n",
542 ret
, parser
->name
, master
->name
);
544 put_partition_parser(parser
);
549 EXPORT_SYMBOL_GPL(parse_mtd_partitions
);
550 EXPORT_SYMBOL_GPL(register_mtd_parser
);
551 EXPORT_SYMBOL_GPL(deregister_mtd_parser
);
553 MODULE_LICENSE("GPL");
554 MODULE_AUTHOR("Nicolas Pitre <nico@cam.org>");
555 MODULE_DESCRIPTION("Generic support for partitioning of MTD devices");