Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6] / drivers / mtd / mtdpart.c
1 /*
2  * Simple MTD partitioning layer
3  *
4  * (C) 2000 Nicolas Pitre <nico@cam.org>
5  *
6  * This code is GPL
7  *
8  * $Id: mtdpart.c,v 1.55 2005/11/07 11:14:20 gleixner Exp $
9  *
10  *      02-21-2002      Thomas Gleixner <gleixner@autronix.de>
11  *                      added support for read_oob, write_oob
12  */
13
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/kmod.h>
20 #include <linux/mtd/mtd.h>
21 #include <linux/mtd/partitions.h>
22 #include <linux/mtd/compatmac.h>
23
24 /* Our partition linked list */
25 static LIST_HEAD(mtd_partitions);
26
27 /* Our partition node structure */
28 struct mtd_part {
29         struct mtd_info mtd;
30         struct mtd_info *master;
31         u_int32_t offset;
32         int index;
33         struct list_head list;
34         int registered;
35 };
36
37 /*
38  * Given a pointer to the MTD object in the mtd_part structure, we can retrieve
39  * the pointer to that structure with this macro.
40  */
41 #define PART(x)  ((struct mtd_part *)(x))
42
43
44 /*
45  * MTD methods which simply translate the effective address and pass through
46  * to the _real_ device.
47  */
48
49 static int part_read (struct mtd_info *mtd, loff_t from, size_t len,
50                         size_t *retlen, u_char *buf)
51 {
52         struct mtd_part *part = PART(mtd);
53         int res;
54
55         if (from >= mtd->size)
56                 len = 0;
57         else if (from + len > mtd->size)
58                 len = mtd->size - from;
59         res = part->master->read (part->master, from + part->offset,
60                                    len, retlen, buf);
61         if (unlikely(res)) {
62                 if (res == -EUCLEAN)
63                         mtd->ecc_stats.corrected++;
64                 if (res == -EBADMSG)
65                         mtd->ecc_stats.failed++;
66         }
67         return res;
68 }
69
70 static int part_point (struct mtd_info *mtd, loff_t from, size_t len,
71                         size_t *retlen, u_char **buf)
72 {
73         struct mtd_part *part = PART(mtd);
74         if (from >= mtd->size)
75                 len = 0;
76         else if (from + len > mtd->size)
77                 len = mtd->size - from;
78         return part->master->point (part->master, from + part->offset,
79                                     len, retlen, buf);
80 }
81
82 static void part_unpoint (struct mtd_info *mtd, u_char *addr, loff_t from, size_t len)
83 {
84         struct mtd_part *part = PART(mtd);
85
86         part->master->unpoint (part->master, addr, from + part->offset, len);
87 }
88
89 static int part_read_oob(struct mtd_info *mtd, loff_t from,
90                          struct mtd_oob_ops *ops)
91 {
92         struct mtd_part *part = PART(mtd);
93         int res;
94
95         if (from >= mtd->size)
96                 return -EINVAL;
97         if (ops->datbuf && from + ops->len > mtd->size)
98                 return -EINVAL;
99         res = part->master->read_oob(part->master, from + part->offset, ops);
100
101         if (unlikely(res)) {
102                 if (res == -EUCLEAN)
103                         mtd->ecc_stats.corrected++;
104                 if (res == -EBADMSG)
105                         mtd->ecc_stats.failed++;
106         }
107         return res;
108 }
109
110 static int part_read_user_prot_reg (struct mtd_info *mtd, loff_t from, size_t len,
111                         size_t *retlen, u_char *buf)
112 {
113         struct mtd_part *part = PART(mtd);
114         return part->master->read_user_prot_reg (part->master, from,
115                                         len, retlen, buf);
116 }
117
118 static int part_get_user_prot_info (struct mtd_info *mtd,
119                                     struct otp_info *buf, size_t len)
120 {
121         struct mtd_part *part = PART(mtd);
122         return part->master->get_user_prot_info (part->master, buf, len);
123 }
124
125 static int part_read_fact_prot_reg (struct mtd_info *mtd, loff_t from, size_t len,
126                         size_t *retlen, u_char *buf)
127 {
128         struct mtd_part *part = PART(mtd);
129         return part->master->read_fact_prot_reg (part->master, from,
130                                         len, retlen, buf);
131 }
132
133 static int part_get_fact_prot_info (struct mtd_info *mtd,
134                                     struct otp_info *buf, size_t len)
135 {
136         struct mtd_part *part = PART(mtd);
137         return part->master->get_fact_prot_info (part->master, buf, len);
138 }
139
140 static int part_write (struct mtd_info *mtd, loff_t to, size_t len,
141                         size_t *retlen, const u_char *buf)
142 {
143         struct mtd_part *part = PART(mtd);
144         if (!(mtd->flags & MTD_WRITEABLE))
145                 return -EROFS;
146         if (to >= mtd->size)
147                 len = 0;
148         else if (to + len > mtd->size)
149                 len = mtd->size - to;
150         return part->master->write (part->master, to + part->offset,
151                                     len, retlen, buf);
152 }
153
154 static int part_panic_write (struct mtd_info *mtd, loff_t to, size_t len,
155                         size_t *retlen, const u_char *buf)
156 {
157         struct mtd_part *part = PART(mtd);
158         if (!(mtd->flags & MTD_WRITEABLE))
159                 return -EROFS;
160         if (to >= mtd->size)
161                 len = 0;
162         else if (to + len > mtd->size)
163                 len = mtd->size - to;
164         return part->master->panic_write (part->master, to + part->offset,
165                                     len, retlen, buf);
166 }
167
168 static int part_write_oob(struct mtd_info *mtd, loff_t to,
169                          struct mtd_oob_ops *ops)
170 {
171         struct mtd_part *part = PART(mtd);
172
173         if (!(mtd->flags & MTD_WRITEABLE))
174                 return -EROFS;
175
176         if (to >= mtd->size)
177                 return -EINVAL;
178         if (ops->datbuf && to + ops->len > mtd->size)
179                 return -EINVAL;
180         return part->master->write_oob(part->master, to + part->offset, ops);
181 }
182
183 static int part_write_user_prot_reg (struct mtd_info *mtd, loff_t from, size_t len,
184                         size_t *retlen, u_char *buf)
185 {
186         struct mtd_part *part = PART(mtd);
187         return part->master->write_user_prot_reg (part->master, from,
188                                         len, retlen, buf);
189 }
190
191 static int part_lock_user_prot_reg (struct mtd_info *mtd, loff_t from, size_t len)
192 {
193         struct mtd_part *part = PART(mtd);
194         return part->master->lock_user_prot_reg (part->master, from, len);
195 }
196
197 static int part_writev (struct mtd_info *mtd,  const struct kvec *vecs,
198                          unsigned long count, loff_t to, size_t *retlen)
199 {
200         struct mtd_part *part = PART(mtd);
201         if (!(mtd->flags & MTD_WRITEABLE))
202                 return -EROFS;
203         return part->master->writev (part->master, vecs, count,
204                                         to + part->offset, retlen);
205 }
206
207 static int part_erase (struct mtd_info *mtd, struct erase_info *instr)
208 {
209         struct mtd_part *part = PART(mtd);
210         int ret;
211         if (!(mtd->flags & MTD_WRITEABLE))
212                 return -EROFS;
213         if (instr->addr >= mtd->size)
214                 return -EINVAL;
215         instr->addr += part->offset;
216         ret = part->master->erase(part->master, instr);
217         if (ret) {
218                 if (instr->fail_addr != 0xffffffff)
219                         instr->fail_addr -= part->offset;
220                 instr->addr -= part->offset;
221         }
222         return ret;
223 }
224
225 void mtd_erase_callback(struct erase_info *instr)
226 {
227         if (instr->mtd->erase == part_erase) {
228                 struct mtd_part *part = PART(instr->mtd);
229
230                 if (instr->fail_addr != 0xffffffff)
231                         instr->fail_addr -= part->offset;
232                 instr->addr -= part->offset;
233         }
234         if (instr->callback)
235                 instr->callback(instr);
236 }
237 EXPORT_SYMBOL_GPL(mtd_erase_callback);
238
239 static int part_lock (struct mtd_info *mtd, loff_t ofs, size_t len)
240 {
241         struct mtd_part *part = PART(mtd);
242         if ((len + ofs) > mtd->size)
243                 return -EINVAL;
244         return part->master->lock(part->master, ofs + part->offset, len);
245 }
246
247 static int part_unlock (struct mtd_info *mtd, loff_t ofs, size_t len)
248 {
249         struct mtd_part *part = PART(mtd);
250         if ((len + ofs) > mtd->size)
251                 return -EINVAL;
252         return part->master->unlock(part->master, ofs + part->offset, len);
253 }
254
255 static void part_sync(struct mtd_info *mtd)
256 {
257         struct mtd_part *part = PART(mtd);
258         part->master->sync(part->master);
259 }
260
261 static int part_suspend(struct mtd_info *mtd)
262 {
263         struct mtd_part *part = PART(mtd);
264         return part->master->suspend(part->master);
265 }
266
267 static void part_resume(struct mtd_info *mtd)
268 {
269         struct mtd_part *part = PART(mtd);
270         part->master->resume(part->master);
271 }
272
273 static int part_block_isbad (struct mtd_info *mtd, loff_t ofs)
274 {
275         struct mtd_part *part = PART(mtd);
276         if (ofs >= mtd->size)
277                 return -EINVAL;
278         ofs += part->offset;
279         return part->master->block_isbad(part->master, ofs);
280 }
281
282 static int part_block_markbad (struct mtd_info *mtd, loff_t ofs)
283 {
284         struct mtd_part *part = PART(mtd);
285         int res;
286
287         if (!(mtd->flags & MTD_WRITEABLE))
288                 return -EROFS;
289         if (ofs >= mtd->size)
290                 return -EINVAL;
291         ofs += part->offset;
292         res = part->master->block_markbad(part->master, ofs);
293         if (!res)
294                 mtd->ecc_stats.badblocks++;
295         return res;
296 }
297
298 /*
299  * This function unregisters and destroy all slave MTD objects which are
300  * attached to the given master MTD object.
301  */
302
303 int del_mtd_partitions(struct mtd_info *master)
304 {
305         struct list_head *node;
306         struct mtd_part *slave;
307
308         for (node = mtd_partitions.next;
309              node != &mtd_partitions;
310              node = node->next) {
311                 slave = list_entry(node, struct mtd_part, list);
312                 if (slave->master == master) {
313                         struct list_head *prev = node->prev;
314                         __list_del(prev, node->next);
315                         if(slave->registered)
316                                 del_mtd_device(&slave->mtd);
317                         kfree(slave);
318                         node = prev;
319                 }
320         }
321
322         return 0;
323 }
324
325 /*
326  * This function, given a master MTD object and a partition table, creates
327  * and registers slave MTD objects which are bound to the master according to
328  * the partition definitions.
329  * (Q: should we register the master MTD object as well?)
330  */
331
332 int add_mtd_partitions(struct mtd_info *master,
333                        const struct mtd_partition *parts,
334                        int nbparts)
335 {
336         struct mtd_part *slave;
337         u_int32_t cur_offset = 0;
338         int i;
339
340         printk (KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name);
341
342         for (i = 0; i < nbparts; i++) {
343
344                 /* allocate the partition structure */
345                 slave = kzalloc (sizeof(*slave), GFP_KERNEL);
346                 if (!slave) {
347                         printk ("memory allocation error while creating partitions for \"%s\"\n",
348                                 master->name);
349                         del_mtd_partitions(master);
350                         return -ENOMEM;
351                 }
352                 list_add(&slave->list, &mtd_partitions);
353
354                 /* set up the MTD object for this partition */
355                 slave->mtd.type = master->type;
356                 slave->mtd.flags = master->flags & ~parts[i].mask_flags;
357                 slave->mtd.size = parts[i].size;
358                 slave->mtd.writesize = master->writesize;
359                 slave->mtd.oobsize = master->oobsize;
360                 slave->mtd.oobavail = master->oobavail;
361                 slave->mtd.subpage_sft = master->subpage_sft;
362
363                 slave->mtd.name = parts[i].name;
364                 slave->mtd.owner = master->owner;
365
366                 slave->mtd.read = part_read;
367                 slave->mtd.write = part_write;
368
369                 if (master->panic_write)
370                         slave->mtd.panic_write = part_panic_write;
371
372                 if(master->point && master->unpoint){
373                         slave->mtd.point = part_point;
374                         slave->mtd.unpoint = part_unpoint;
375                 }
376
377                 if (master->read_oob)
378                         slave->mtd.read_oob = part_read_oob;
379                 if (master->write_oob)
380                         slave->mtd.write_oob = part_write_oob;
381                 if(master->read_user_prot_reg)
382                         slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
383                 if(master->read_fact_prot_reg)
384                         slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
385                 if(master->write_user_prot_reg)
386                         slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
387                 if(master->lock_user_prot_reg)
388                         slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
389                 if(master->get_user_prot_info)
390                         slave->mtd.get_user_prot_info = part_get_user_prot_info;
391                 if(master->get_fact_prot_info)
392                         slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
393                 if (master->sync)
394                         slave->mtd.sync = part_sync;
395                 if (!i && master->suspend && master->resume) {
396                                 slave->mtd.suspend = part_suspend;
397                                 slave->mtd.resume = part_resume;
398                 }
399                 if (master->writev)
400                         slave->mtd.writev = part_writev;
401                 if (master->lock)
402                         slave->mtd.lock = part_lock;
403                 if (master->unlock)
404                         slave->mtd.unlock = part_unlock;
405                 if (master->block_isbad)
406                         slave->mtd.block_isbad = part_block_isbad;
407                 if (master->block_markbad)
408                         slave->mtd.block_markbad = part_block_markbad;
409                 slave->mtd.erase = part_erase;
410                 slave->master = master;
411                 slave->offset = parts[i].offset;
412                 slave->index = i;
413
414                 if (slave->offset == MTDPART_OFS_APPEND)
415                         slave->offset = cur_offset;
416                 if (slave->offset == MTDPART_OFS_NXTBLK) {
417                         slave->offset = cur_offset;
418                         if ((cur_offset % master->erasesize) != 0) {
419                                 /* Round up to next erasesize */
420                                 slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize;
421                                 printk(KERN_NOTICE "Moving partition %d: "
422                                        "0x%08x -> 0x%08x\n", i,
423                                        cur_offset, slave->offset);
424                         }
425                 }
426                 if (slave->mtd.size == MTDPART_SIZ_FULL)
427                         slave->mtd.size = master->size - slave->offset;
428                 cur_offset = slave->offset + slave->mtd.size;
429
430                 printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset,
431                         slave->offset + slave->mtd.size, slave->mtd.name);
432
433                 /* let's do some sanity checks */
434                 if (slave->offset >= master->size) {
435                                 /* let's register it anyway to preserve ordering */
436                         slave->offset = 0;
437                         slave->mtd.size = 0;
438                         printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
439                                 parts[i].name);
440                 }
441                 if (slave->offset + slave->mtd.size > master->size) {
442                         slave->mtd.size = master->size - slave->offset;
443                         printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
444                                 parts[i].name, master->name, slave->mtd.size);
445                 }
446                 if (master->numeraseregions>1) {
447                         /* Deal with variable erase size stuff */
448                         int i;
449                         struct mtd_erase_region_info *regions = master->eraseregions;
450
451                         /* Find the first erase regions which is part of this partition. */
452                         for (i=0; i < master->numeraseregions && slave->offset >= regions[i].offset; i++)
453                                 ;
454
455                         for (i--; i < master->numeraseregions && slave->offset + slave->mtd.size > regions[i].offset; i++) {
456                                 if (slave->mtd.erasesize < regions[i].erasesize) {
457                                         slave->mtd.erasesize = regions[i].erasesize;
458                                 }
459                         }
460                 } else {
461                         /* Single erase size */
462                         slave->mtd.erasesize = master->erasesize;
463                 }
464
465                 if ((slave->mtd.flags & MTD_WRITEABLE) &&
466                     (slave->offset % slave->mtd.erasesize)) {
467                         /* Doesn't start on a boundary of major erase size */
468                         /* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
469                         slave->mtd.flags &= ~MTD_WRITEABLE;
470                         printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
471                                 parts[i].name);
472                 }
473                 if ((slave->mtd.flags & MTD_WRITEABLE) &&
474                     (slave->mtd.size % slave->mtd.erasesize)) {
475                         slave->mtd.flags &= ~MTD_WRITEABLE;
476                         printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
477                                 parts[i].name);
478                 }
479
480                 slave->mtd.ecclayout = master->ecclayout;
481                 if (master->block_isbad) {
482                         uint32_t offs = 0;
483
484                         while(offs < slave->mtd.size) {
485                                 if (master->block_isbad(master,
486                                                         offs + slave->offset))
487                                         slave->mtd.ecc_stats.badblocks++;
488                                 offs += slave->mtd.erasesize;
489                         }
490                 }
491
492                 if(parts[i].mtdp)
493                 {       /* store the object pointer (caller may or may not register it */
494                         *parts[i].mtdp = &slave->mtd;
495                         slave->registered = 0;
496                 }
497                 else
498                 {
499                         /* register our partition */
500                         add_mtd_device(&slave->mtd);
501                         slave->registered = 1;
502                 }
503         }
504
505         return 0;
506 }
507
508 EXPORT_SYMBOL(add_mtd_partitions);
509 EXPORT_SYMBOL(del_mtd_partitions);
510
511 static DEFINE_SPINLOCK(part_parser_lock);
512 static LIST_HEAD(part_parsers);
513
514 static struct mtd_part_parser *get_partition_parser(const char *name)
515 {
516         struct list_head *this;
517         void *ret = NULL;
518         spin_lock(&part_parser_lock);
519
520         list_for_each(this, &part_parsers) {
521                 struct mtd_part_parser *p = list_entry(this, struct mtd_part_parser, list);
522
523                 if (!strcmp(p->name, name) && try_module_get(p->owner)) {
524                         ret = p;
525                         break;
526                 }
527         }
528         spin_unlock(&part_parser_lock);
529
530         return ret;
531 }
532
533 int register_mtd_parser(struct mtd_part_parser *p)
534 {
535         spin_lock(&part_parser_lock);
536         list_add(&p->list, &part_parsers);
537         spin_unlock(&part_parser_lock);
538
539         return 0;
540 }
541
542 int deregister_mtd_parser(struct mtd_part_parser *p)
543 {
544         spin_lock(&part_parser_lock);
545         list_del(&p->list);
546         spin_unlock(&part_parser_lock);
547         return 0;
548 }
549
550 int parse_mtd_partitions(struct mtd_info *master, const char **types,
551                          struct mtd_partition **pparts, unsigned long origin)
552 {
553         struct mtd_part_parser *parser;
554         int ret = 0;
555
556         for ( ; ret <= 0 && *types; types++) {
557                 parser = get_partition_parser(*types);
558 #ifdef CONFIG_KMOD
559                 if (!parser && !request_module("%s", *types))
560                                 parser = get_partition_parser(*types);
561 #endif
562                 if (!parser) {
563                         printk(KERN_NOTICE "%s partition parsing not available\n",
564                                *types);
565                         continue;
566                 }
567                 ret = (*parser->parse_fn)(master, pparts, origin);
568                 if (ret > 0) {
569                         printk(KERN_NOTICE "%d %s partitions found on MTD device %s\n",
570                                ret, parser->name, master->name);
571                 }
572                 put_partition_parser(parser);
573         }
574         return ret;
575 }
576
577 EXPORT_SYMBOL_GPL(parse_mtd_partitions);
578 EXPORT_SYMBOL_GPL(register_mtd_parser);
579 EXPORT_SYMBOL_GPL(deregister_mtd_parser);