]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/mtd/mtdpart.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mtd: Update copyright notices
[net-next-2.6.git] / drivers / mtd / mtdpart.c
CommitLineData
1da177e4
LT		 1/*
2 * Simple MTD partitioning layer
3 *
a1452a37
DW		 4 * Copyright © 2000 Nicolas Pitre <nico@fluxnic.net>
5 * Copyright © 2002 Thomas Gleixner <gleixner@linutronix.de>
6 * Copyright © 2000-2010 David Woodhouse <dwmw2@infradead.org>
1da177e4 7 *
a1452a37
DW		 8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
1da177e4 21 *
97894cda 22 */
1da177e4
LT		 23
24#include <linux/module.h>
25#include <linux/types.h>
26#include <linux/kernel.h>
27#include <linux/slab.h>
28#include <linux/list.h>
1da177e4
LT		 29#include <linux/kmod.h>
30#include <linux/mtd/mtd.h>
31#include <linux/mtd/partitions.h>
32#include <linux/mtd/compatmac.h>
33
34/* Our partition linked list */
35static LIST_HEAD(mtd_partitions);
36
37/* Our partition node structure */
38struct mtd_part {
39 struct mtd_info mtd;
40 struct mtd_info *master;
69423d99 41 uint64_t offset;
1da177e4 42 struct list_head list;
1da177e4
LT		 43};
44
45/*
46 * Given a pointer to the MTD object in the mtd_part structure, we can retrieve
47 * the pointer to that structure with this macro.
48 */
49#define PART(x) ((struct mtd_part *)(x))
50
97894cda
TG		 51
52/*
1da177e4
LT		 53 * MTD methods which simply translate the effective address and pass through
54 * to the _real_ device.
55 */
56
b33a2887
AN		 57static int part_read(struct mtd_info *mtd, loff_t from, size_t len,
58 size_t *retlen, u_char *buf)
1da177e4
LT		 59{
60 struct mtd_part *part = PART(mtd);
d8877f19 61 struct mtd_ecc_stats stats;
f1a28c02
TG		 62 int res;
63
d8877f19
YK		 64 stats = part->master->ecc_stats;
65
1da177e4
LT		 66 if (from >= mtd->size)
67 len = 0;
68 else if (from + len > mtd->size)
69 len = mtd->size - from;
b33a2887 70 res = part->master->read(part->master, from + part->offset,
9223a456 71 len, retlen, buf);
f1a28c02
TG		 72 if (unlikely(res)) {
73 if (res == -EUCLEAN)
d8877f19 74 mtd->ecc_stats.corrected += part->master->ecc_stats.corrected - stats.corrected;
f1a28c02 75 if (res == -EBADMSG)
d8877f19 76 mtd->ecc_stats.failed += part->master->ecc_stats.failed - stats.failed;
f1a28c02
TG		 77 }
78 return res;
1da177e4
LT		 79}
80
b33a2887
AN		 81static int part_point(struct mtd_info *mtd, loff_t from, size_t len,
82 size_t *retlen, void **virt, resource_size_t *phys)
1da177e4
LT		 83{
84 struct mtd_part *part = PART(mtd);
85 if (from >= mtd->size)
86 len = 0;
87 else if (from + len > mtd->size)
88 len = mtd->size - from;
97894cda 89 return part->master->point (part->master, from + part->offset,
a98889f3 90 len, retlen, virt, phys);
1da177e4 91}
9223a456 92
a98889f3 93static void part_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
1da177e4
LT		 94{
95 struct mtd_part *part = PART(mtd);
96
a98889f3 97 part->master->unpoint(part->master, from + part->offset, len);
1da177e4
LT		 98}
99
402d3265
DH		 100static unsigned long part_get_unmapped_area(struct mtd_info *mtd,
101 unsigned long len,
102 unsigned long offset,
103 unsigned long flags)
104{
105 struct mtd_part *part = PART(mtd);
106
107 offset += part->offset;
108 return part->master->get_unmapped_area(part->master, len, offset,
109 flags);
110}
111
8593fbc6 112static int part_read_oob(struct mtd_info *mtd, loff_t from,
b33a2887 113 struct mtd_oob_ops *ops)
1da177e4
LT		 114{
115 struct mtd_part *part = PART(mtd);
f1a28c02 116 int res;
8593fbc6 117
1da177e4 118 if (from >= mtd->size)
8593fbc6 119 return -EINVAL;
7014568b 120 if (ops->datbuf && from + ops->len > mtd->size)
8593fbc6 121 return -EINVAL;
f1a28c02
TG		 122 res = part->master->read_oob(part->master, from + part->offset, ops);
123
124 if (unlikely(res)) {
125 if (res == -EUCLEAN)
126 mtd->ecc_stats.corrected++;
127 if (res == -EBADMSG)
128 mtd->ecc_stats.failed++;
129 }
130 return res;
1da177e4
LT		 131}
132
b33a2887
AN		 133static int part_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
134 size_t len, size_t *retlen, u_char *buf)
1da177e4
LT		 135{
136 struct mtd_part *part = PART(mtd);
b33a2887 137 return part->master->read_user_prot_reg(part->master, from,
1da177e4
LT		 138 len, retlen, buf);
139}
140
b33a2887
AN		 141static int part_get_user_prot_info(struct mtd_info *mtd,
142 struct otp_info *buf, size_t len)
f77814dd
NP		 143{
144 struct mtd_part *part = PART(mtd);
b33a2887 145 return part->master->get_user_prot_info(part->master, buf, len);
f77814dd
NP		 146}
147
b33a2887
AN		 148static int part_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
149 size_t len, size_t *retlen, u_char *buf)
1da177e4
LT		 150{
151 struct mtd_part *part = PART(mtd);
b33a2887 152 return part->master->read_fact_prot_reg(part->master, from,
1da177e4
LT		 153 len, retlen, buf);
154}
155
b33a2887
AN		 156static int part_get_fact_prot_info(struct mtd_info *mtd, struct otp_info *buf,
157 size_t len)
f77814dd
NP		 158{
159 struct mtd_part *part = PART(mtd);
b33a2887 160 return part->master->get_fact_prot_info(part->master, buf, len);
f77814dd
NP		 161}
162
b33a2887
AN		 163static int part_write(struct mtd_info *mtd, loff_t to, size_t len,
164 size_t *retlen, const u_char *buf)
1da177e4
LT		 165{
166 struct mtd_part *part = PART(mtd);
167 if (!(mtd->flags & MTD_WRITEABLE))
168 return -EROFS;
169 if (to >= mtd->size)
170 len = 0;
171 else if (to + len > mtd->size)
172 len = mtd->size - to;
b33a2887 173 return part->master->write(part->master, to + part->offset,
9223a456 174 len, retlen, buf);
1da177e4
LT		 175}
176
b33a2887
AN		 177static int part_panic_write(struct mtd_info *mtd, loff_t to, size_t len,
178 size_t *retlen, const u_char *buf)
388bbb09
RP		 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;
b33a2887 187 return part->master->panic_write(part->master, to + part->offset,
388bbb09
RP		 188 len, retlen, buf);
189}
190
8593fbc6 191static int part_write_oob(struct mtd_info *mtd, loff_t to,
b33a2887 192 struct mtd_oob_ops *ops)
1da177e4
LT		 193{
194 struct mtd_part *part = PART(mtd);
8593fbc6 195
1da177e4
LT		 196 if (!(mtd->flags & MTD_WRITEABLE))
197 return -EROFS;
8593fbc6 198
1da177e4 199 if (to >= mtd->size)
8593fbc6 200 return -EINVAL;
7014568b 201 if (ops->datbuf && to + ops->len > mtd->size)
8593fbc6
TG		 202 return -EINVAL;
203 return part->master->write_oob(part->master, to + part->offset, ops);
1da177e4
LT		 204}
205
b33a2887
AN		 206static int part_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
207 size_t len, size_t *retlen, u_char *buf)
1da177e4
LT		 208{
209 struct mtd_part *part = PART(mtd);
b33a2887 210 return part->master->write_user_prot_reg(part->master, from,
1da177e4
LT		 211 len, retlen, buf);
212}
213
b33a2887
AN		 214static int part_lock_user_prot_reg(struct mtd_info *mtd, loff_t from,
215 size_t len)
f77814dd
NP		 216{
217 struct mtd_part *part = PART(mtd);
b33a2887 218 return part->master->lock_user_prot_reg(part->master, from, len);
f77814dd
NP		 219}
220
b33a2887
AN		 221static int part_writev(struct mtd_info *mtd, const struct kvec *vecs,
222 unsigned long count, loff_t to, size_t *retlen)
1da177e4
LT		 223{
224 struct mtd_part *part = PART(mtd);
225 if (!(mtd->flags & MTD_WRITEABLE))
226 return -EROFS;
b33a2887 227 return part->master->writev(part->master, vecs, count,
1da177e4 228 to + part->offset, retlen);
1da177e4
LT		 229}
230
b33a2887 231static int part_erase(struct mtd_info *mtd, struct erase_info *instr)
1da177e4
LT		 232{
233 struct mtd_part *part = PART(mtd);
234 int ret;
235 if (!(mtd->flags & MTD_WRITEABLE))
236 return -EROFS;
237 if (instr->addr >= mtd->size)
238 return -EINVAL;
239 instr->addr += part->offset;
240 ret = part->master->erase(part->master, instr);
74641d75 241 if (ret) {
bb0eb217 242 if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
74641d75
AH		 243 instr->fail_addr -= part->offset;
244 instr->addr -= part->offset;
245 }
1da177e4
LT		 246 return ret;
247}
248
249void mtd_erase_callback(struct erase_info *instr)
250{
251 if (instr->mtd->erase == part_erase) {
252 struct mtd_part *part = PART(instr->mtd);
253
bb0eb217 254 if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
1da177e4
LT		 255 instr->fail_addr -= part->offset;
256 instr->addr -= part->offset;
257 }
258 if (instr->callback)
259 instr->callback(instr);
260}
261EXPORT_SYMBOL_GPL(mtd_erase_callback);
262
69423d99 263static int part_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1da177e4
LT		 264{
265 struct mtd_part *part = PART(mtd);
97894cda 266 if ((len + ofs) > mtd->size)
1da177e4
LT		 267 return -EINVAL;
268 return part->master->lock(part->master, ofs + part->offset, len);
269}
270
69423d99 271static int part_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1da177e4
LT		 272{
273 struct mtd_part *part = PART(mtd);
97894cda 274 if ((len + ofs) > mtd->size)
1da177e4
LT		 275 return -EINVAL;
276 return part->master->unlock(part->master, ofs + part->offset, len);
277}
278
9938424f
RC		 279static int part_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
280{
281 struct mtd_part *part = PART(mtd);
282 if ((len + ofs) > mtd->size)
283 return -EINVAL;
284 return part->master->is_locked(part->master, ofs + part->offset, len);
285}
286
1da177e4
LT		 287static void part_sync(struct mtd_info *mtd)
288{
289 struct mtd_part *part = PART(mtd);
290 part->master->sync(part->master);
291}
292
293static int part_suspend(struct mtd_info *mtd)
294{
295 struct mtd_part *part = PART(mtd);
296 return part->master->suspend(part->master);
297}
298
299static void part_resume(struct mtd_info *mtd)
300{
301 struct mtd_part *part = PART(mtd);
302 part->master->resume(part->master);
303}
304
b33a2887 305static int part_block_isbad(struct mtd_info *mtd, loff_t ofs)
1da177e4
LT		 306{
307 struct mtd_part *part = PART(mtd);
308 if (ofs >= mtd->size)
309 return -EINVAL;
310 ofs += part->offset;
311 return part->master->block_isbad(part->master, ofs);
312}
313
b33a2887 314static int part_block_markbad(struct mtd_info *mtd, loff_t ofs)
1da177e4
LT		 315{
316 struct mtd_part *part = PART(mtd);
f1a28c02
TG		 317 int res;
318
1da177e4
LT		 319 if (!(mtd->flags & MTD_WRITEABLE))
320 return -EROFS;
321 if (ofs >= mtd->size)
322 return -EINVAL;
323 ofs += part->offset;
f1a28c02
TG		 324 res = part->master->block_markbad(part->master, ofs);
325 if (!res)
326 mtd->ecc_stats.badblocks++;
327 return res;
1da177e4
LT		 328}
329
97894cda
TG		 330/*
331 * This function unregisters and destroy all slave MTD objects which are
1da177e4
LT		 332 * attached to the given master MTD object.
333 */
334
335int del_mtd_partitions(struct mtd_info *master)
336{
71a928c0 337 struct mtd_part *slave, *next;
1da177e4 338
71a928c0 339 list_for_each_entry_safe(slave, next, &mtd_partitions, list)
1da177e4 340 if (slave->master == master) {
71a928c0 341 list_del(&slave->list);
b90cf668 342 del_mtd_device(&slave->mtd);
1da177e4 343 kfree(slave);
1da177e4 344 }
1da177e4
LT		 345
346 return 0;
347}
b33a2887 348EXPORT_SYMBOL(del_mtd_partitions);
1da177e4 349
7788ba71
AN		 350static struct mtd_part *add_one_partition(struct mtd_info *master,
351 const struct mtd_partition *part, int partno,
69423d99 352 uint64_t cur_offset)
7788ba71
AN		 353{
354 struct mtd_part *slave;
355
356 /* allocate the partition structure */
b33a2887 357 slave = kzalloc(sizeof(*slave), GFP_KERNEL);
7788ba71 358 if (!slave) {
b33a2887 359 printk(KERN_ERR"memory allocation error while creating partitions for \"%s\"\n",
7788ba71
AN		 360 master->name);
361 del_mtd_partitions(master);
362 return NULL;
363 }
364 list_add(&slave->list, &mtd_partitions);
365
366 /* set up the MTD object for this partition */
367 slave->mtd.type = master->type;
368 slave->mtd.flags = master->flags & ~part->mask_flags;
369 slave->mtd.size = part->size;
370 slave->mtd.writesize = master->writesize;
371 slave->mtd.oobsize = master->oobsize;
372 slave->mtd.oobavail = master->oobavail;
373 slave->mtd.subpage_sft = master->subpage_sft;
374
375 slave->mtd.name = part->name;
376 slave->mtd.owner = master->owner;
402d3265 377 slave->mtd.backing_dev_info = master->backing_dev_info;
7788ba71 378
1f24b5a8
DB		 379 /* NOTE: we don't arrange MTDs as a tree; it'd be error-prone
380 * to have the same data be in two different partitions.
381 */
382 slave->mtd.dev.parent = master->dev.parent;
383
7788ba71
AN		 384 slave->mtd.read = part_read;
385 slave->mtd.write = part_write;
386
387 if (master->panic_write)
388 slave->mtd.panic_write = part_panic_write;
389
b33a2887 390 if (master->point && master->unpoint) {
7788ba71
AN		 391 slave->mtd.point = part_point;
392 slave->mtd.unpoint = part_unpoint;
393 }
394
402d3265
DH		 395 if (master->get_unmapped_area)
396 slave->mtd.get_unmapped_area = part_get_unmapped_area;
7788ba71
AN		 397 if (master->read_oob)
398 slave->mtd.read_oob = part_read_oob;
399 if (master->write_oob)
400 slave->mtd.write_oob = part_write_oob;
b33a2887 401 if (master->read_user_prot_reg)
7788ba71 402 slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
b33a2887 403 if (master->read_fact_prot_reg)
7788ba71 404 slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
b33a2887 405 if (master->write_user_prot_reg)
7788ba71 406 slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
b33a2887 407 if (master->lock_user_prot_reg)
7788ba71 408 slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
b33a2887 409 if (master->get_user_prot_info)
7788ba71 410 slave->mtd.get_user_prot_info = part_get_user_prot_info;
b33a2887 411 if (master->get_fact_prot_info)
7788ba71
AN		 412 slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
413 if (master->sync)
414 slave->mtd.sync = part_sync;
4704a784 415 if (!partno && !master->dev.class && master->suspend && master->resume) {
7788ba71
AN		 416 slave->mtd.suspend = part_suspend;
417 slave->mtd.resume = part_resume;
418 }
419 if (master->writev)
420 slave->mtd.writev = part_writev;
421 if (master->lock)
422 slave->mtd.lock = part_lock;
423 if (master->unlock)
424 slave->mtd.unlock = part_unlock;
9938424f
RC		 425 if (master->is_locked)
426 slave->mtd.is_locked = part_is_locked;
7788ba71
AN		 427 if (master->block_isbad)
428 slave->mtd.block_isbad = part_block_isbad;
429 if (master->block_markbad)
430 slave->mtd.block_markbad = part_block_markbad;
431 slave->mtd.erase = part_erase;
432 slave->master = master;
433 slave->offset = part->offset;
7788ba71
AN		 434
435 if (slave->offset == MTDPART_OFS_APPEND)
436 slave->offset = cur_offset;
437 if (slave->offset == MTDPART_OFS_NXTBLK) {
438 slave->offset = cur_offset;
69423d99 439 if (mtd_mod_by_eb(cur_offset, master) != 0) {
7788ba71 440 /* Round up to next erasesize */
69423d99 441 slave->offset = (mtd_div_by_eb(cur_offset, master) + 1) * master->erasesize;
7788ba71 442 printk(KERN_NOTICE "Moving partition %d: "
69423d99
AH		 443 "0x%012llx -> 0x%012llx\n", partno,
444 (unsigned long long)cur_offset, (unsigned long long)slave->offset);
7788ba71
AN		 445 }
446 }
447 if (slave->mtd.size == MTDPART_SIZ_FULL)
448 slave->mtd.size = master->size - slave->offset;
449
69423d99
AH		 450 printk(KERN_NOTICE "0x%012llx-0x%012llx : \"%s\"\n", (unsigned long long)slave->offset,
451 (unsigned long long)(slave->offset + slave->mtd.size), slave->mtd.name);
7788ba71
AN		 452
453 /* let's do some sanity checks */
454 if (slave->offset >= master->size) {
f636ffb4 455 /* let's register it anyway to preserve ordering */
7788ba71
AN		 456 slave->offset = 0;
457 slave->mtd.size = 0;
b33a2887 458 printk(KERN_ERR"mtd: partition \"%s\" is out of reach -- disabled\n",
7788ba71 459 part->name);
f636ffb4 460 goto out_register;
7788ba71
AN		 461 }
462 if (slave->offset + slave->mtd.size > master->size) {
463 slave->mtd.size = master->size - slave->offset;
69423d99
AH		 464 printk(KERN_WARNING"mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#llx\n",
465 part->name, master->name, (unsigned long long)slave->mtd.size);
7788ba71 466 }
b33a2887 467 if (master->numeraseregions > 1) {
7788ba71 468 /* Deal with variable erase size stuff */
6910c136 469 int i, max = master->numeraseregions;
69423d99 470 u64 end = slave->offset + slave->mtd.size;
7788ba71
AN		 471 struct mtd_erase_region_info *regions = master->eraseregions;
472
6910c136
AN		 473 /* Find the first erase regions which is part of this
474 * partition. */
475 for (i = 0; i < max && regions[i].offset <= slave->offset; i++)
7788ba71 476 ;
6910c136 477 /* The loop searched for the region _behind_ the first one */
a57ca046
RK		 478 if (i > 0)
479 i--;
7788ba71 480
6910c136
AN		 481 /* Pick biggest erasesize */
482 for (; i < max && regions[i].offset < end; i++) {
7788ba71
AN		 483 if (slave->mtd.erasesize < regions[i].erasesize) {
484 slave->mtd.erasesize = regions[i].erasesize;
485 }
486 }
6910c136 487 BUG_ON(slave->mtd.erasesize == 0);
7788ba71
AN		 488 } else {
489 /* Single erase size */
490 slave->mtd.erasesize = master->erasesize;
491 }
492
493 if ((slave->mtd.flags & MTD_WRITEABLE) &&
69423d99 494 mtd_mod_by_eb(slave->offset, &slave->mtd)) {
7788ba71 495 /* Doesn't start on a boundary of major erase size */
b33a2887
AN		 496 /* FIXME: Let it be writable if it is on a boundary of
497 * _minor_ erase size though */
7788ba71 498 slave->mtd.flags &= ~MTD_WRITEABLE;
b33a2887 499 printk(KERN_WARNING"mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
7788ba71
AN		 500 part->name);
501 }
502 if ((slave->mtd.flags & MTD_WRITEABLE) &&
69423d99 503 mtd_mod_by_eb(slave->mtd.size, &slave->mtd)) {
7788ba71 504 slave->mtd.flags &= ~MTD_WRITEABLE;
b33a2887 505 printk(KERN_WARNING"mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
7788ba71
AN		 506 part->name);
507 }
508
509 slave->mtd.ecclayout = master->ecclayout;
510 if (master->block_isbad) {
69423d99 511 uint64_t offs = 0;
7788ba71 512
b33a2887 513 while (offs < slave->mtd.size) {
7788ba71
AN		 514 if (master->block_isbad(master,
515 offs + slave->offset))
516 slave->mtd.ecc_stats.badblocks++;
517 offs += slave->mtd.erasesize;
518 }
519 }
520
f636ffb4 521out_register:
b90cf668
DW		 522 /* register our partition */
523 add_mtd_device(&slave->mtd);
524
7788ba71
AN		 525 return slave;
526}
527
1da177e4
LT		 528/*
529 * This function, given a master MTD object and a partition table, creates
530 * and registers slave MTD objects which are bound to the master according to
531 * the partition definitions.
1f24b5a8
DB		 532 *
533 * We don't register the master, or expect the caller to have done so,
534 * for reasons of data integrity.
1da177e4
LT		 535 */
536
97894cda 537int add_mtd_partitions(struct mtd_info *master,
1da177e4
LT		 538 const struct mtd_partition *parts,
539 int nbparts)
540{
541 struct mtd_part *slave;
69423d99 542 uint64_t cur_offset = 0;
1da177e4
LT		 543 int i;
544
b33a2887 545 printk(KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name);
1da177e4
LT		 546
547 for (i = 0; i < nbparts; i++) {
7788ba71
AN		 548 slave = add_one_partition(master, parts + i, i, cur_offset);
549 if (!slave)
1da177e4 550 return -ENOMEM;
1da177e4 551 cur_offset = slave->offset + slave->mtd.size;
1da177e4
LT		 552 }
553
554 return 0;
555}
1da177e4 556EXPORT_SYMBOL(add_mtd_partitions);
1da177e4
LT		 557
558static DEFINE_SPINLOCK(part_parser_lock);
559static LIST_HEAD(part_parsers);
560
561static struct mtd_part_parser *get_partition_parser(const char *name)
562{
71a928c0 563 struct mtd_part_parser *p, *ret = NULL;
1da177e4 564
71a928c0 565 spin_lock(&part_parser_lock);
1da177e4 566
71a928c0 567 list_for_each_entry(p, &part_parsers, list)
1da177e4
LT		 568 if (!strcmp(p->name, name) && try_module_get(p->owner)) {
569 ret = p;
570 break;
571 }
71a928c0 572
1da177e4
LT		 573 spin_unlock(&part_parser_lock);
574
575 return ret;
576}
577
578int register_mtd_parser(struct mtd_part_parser *p)
579{
580 spin_lock(&part_parser_lock);
581 list_add(&p->list, &part_parsers);
582 spin_unlock(&part_parser_lock);
583
584 return 0;
585}
b33a2887 586EXPORT_SYMBOL_GPL(register_mtd_parser);
1da177e4
LT		 587
588int deregister_mtd_parser(struct mtd_part_parser *p)
589{
590 spin_lock(&part_parser_lock);
591 list_del(&p->list);
592 spin_unlock(&part_parser_lock);
593 return 0;
594}
b33a2887 595EXPORT_SYMBOL_GPL(deregister_mtd_parser);
1da177e4 596
97894cda 597int parse_mtd_partitions(struct mtd_info *master, const char **types,
1da177e4
LT		 598 struct mtd_partition **pparts, unsigned long origin)
599{
600 struct mtd_part_parser *parser;
601 int ret = 0;
97894cda 602
1da177e4
LT		 603 for ( ; ret <= 0 && *types; types++) {
604 parser = get_partition_parser(*types);
1da177e4
LT		 605 if (!parser && !request_module("%s", *types))
606 parser = get_partition_parser(*types);
1da177e4
LT		 607 if (!parser) {
608 printk(KERN_NOTICE "%s partition parsing not available\n",
609 *types);
610 continue;
611 }
612 ret = (*parser->parse_fn)(master, pparts, origin);
613 if (ret > 0) {
97894cda 614 printk(KERN_NOTICE "%d %s partitions found on MTD device %s\n",
1da177e4
LT		 615 ret, parser->name, master->name);
616 }
617 put_partition_parser(parser);
618 }
619 return ret;
620}
1da177e4 621EXPORT_SYMBOL_GPL(parse_mtd_partitions);
Clone of davem's net-next-2.6 tree