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