mtd: Fix check in mtd_unpoint()
[platform/kernel/linux-rpi.git] / drivers / mtd / mtdcore.c
1 /*
2  * Core registration and callback routines for MTD
3  * drivers and users.
4  *
5  * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
6  * Copyright © 2006      Red Hat UK Limited 
7  *
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
21  *
22  */
23
24 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/ptrace.h>
27 #include <linux/seq_file.h>
28 #include <linux/string.h>
29 #include <linux/timer.h>
30 #include <linux/major.h>
31 #include <linux/fs.h>
32 #include <linux/err.h>
33 #include <linux/ioctl.h>
34 #include <linux/init.h>
35 #include <linux/of.h>
36 #include <linux/proc_fs.h>
37 #include <linux/idr.h>
38 #include <linux/backing-dev.h>
39 #include <linux/gfp.h>
40 #include <linux/slab.h>
41 #include <linux/reboot.h>
42 #include <linux/leds.h>
43
44 #include <linux/mtd/mtd.h>
45 #include <linux/mtd/partitions.h>
46
47 #include "mtdcore.h"
48
49 struct backing_dev_info *mtd_bdi;
50
51 #ifdef CONFIG_PM_SLEEP
52
53 static int mtd_cls_suspend(struct device *dev)
54 {
55         struct mtd_info *mtd = dev_get_drvdata(dev);
56
57         return mtd ? mtd_suspend(mtd) : 0;
58 }
59
60 static int mtd_cls_resume(struct device *dev)
61 {
62         struct mtd_info *mtd = dev_get_drvdata(dev);
63
64         if (mtd)
65                 mtd_resume(mtd);
66         return 0;
67 }
68
69 static SIMPLE_DEV_PM_OPS(mtd_cls_pm_ops, mtd_cls_suspend, mtd_cls_resume);
70 #define MTD_CLS_PM_OPS (&mtd_cls_pm_ops)
71 #else
72 #define MTD_CLS_PM_OPS NULL
73 #endif
74
75 static struct class mtd_class = {
76         .name = "mtd",
77         .owner = THIS_MODULE,
78         .pm = MTD_CLS_PM_OPS,
79 };
80
81 static DEFINE_IDR(mtd_idr);
82
83 /* These are exported solely for the purpose of mtd_blkdevs.c. You
84    should not use them for _anything_ else */
85 DEFINE_MUTEX(mtd_table_mutex);
86 EXPORT_SYMBOL_GPL(mtd_table_mutex);
87
88 struct mtd_info *__mtd_next_device(int i)
89 {
90         return idr_get_next(&mtd_idr, &i);
91 }
92 EXPORT_SYMBOL_GPL(__mtd_next_device);
93
94 static LIST_HEAD(mtd_notifiers);
95
96
97 #define MTD_DEVT(index) MKDEV(MTD_CHAR_MAJOR, (index)*2)
98
99 /* REVISIT once MTD uses the driver model better, whoever allocates
100  * the mtd_info will probably want to use the release() hook...
101  */
102 static void mtd_release(struct device *dev)
103 {
104         struct mtd_info *mtd = dev_get_drvdata(dev);
105         dev_t index = MTD_DEVT(mtd->index);
106
107         /* remove /dev/mtdXro node */
108         device_destroy(&mtd_class, index + 1);
109 }
110
111 static ssize_t mtd_type_show(struct device *dev,
112                 struct device_attribute *attr, char *buf)
113 {
114         struct mtd_info *mtd = dev_get_drvdata(dev);
115         char *type;
116
117         switch (mtd->type) {
118         case MTD_ABSENT:
119                 type = "absent";
120                 break;
121         case MTD_RAM:
122                 type = "ram";
123                 break;
124         case MTD_ROM:
125                 type = "rom";
126                 break;
127         case MTD_NORFLASH:
128                 type = "nor";
129                 break;
130         case MTD_NANDFLASH:
131                 type = "nand";
132                 break;
133         case MTD_DATAFLASH:
134                 type = "dataflash";
135                 break;
136         case MTD_UBIVOLUME:
137                 type = "ubi";
138                 break;
139         case MTD_MLCNANDFLASH:
140                 type = "mlc-nand";
141                 break;
142         default:
143                 type = "unknown";
144         }
145
146         return snprintf(buf, PAGE_SIZE, "%s\n", type);
147 }
148 static DEVICE_ATTR(type, S_IRUGO, mtd_type_show, NULL);
149
150 static ssize_t mtd_flags_show(struct device *dev,
151                 struct device_attribute *attr, char *buf)
152 {
153         struct mtd_info *mtd = dev_get_drvdata(dev);
154
155         return snprintf(buf, PAGE_SIZE, "0x%lx\n", (unsigned long)mtd->flags);
156
157 }
158 static DEVICE_ATTR(flags, S_IRUGO, mtd_flags_show, NULL);
159
160 static ssize_t mtd_size_show(struct device *dev,
161                 struct device_attribute *attr, char *buf)
162 {
163         struct mtd_info *mtd = dev_get_drvdata(dev);
164
165         return snprintf(buf, PAGE_SIZE, "%llu\n",
166                 (unsigned long long)mtd->size);
167
168 }
169 static DEVICE_ATTR(size, S_IRUGO, mtd_size_show, NULL);
170
171 static ssize_t mtd_erasesize_show(struct device *dev,
172                 struct device_attribute *attr, char *buf)
173 {
174         struct mtd_info *mtd = dev_get_drvdata(dev);
175
176         return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->erasesize);
177
178 }
179 static DEVICE_ATTR(erasesize, S_IRUGO, mtd_erasesize_show, NULL);
180
181 static ssize_t mtd_writesize_show(struct device *dev,
182                 struct device_attribute *attr, char *buf)
183 {
184         struct mtd_info *mtd = dev_get_drvdata(dev);
185
186         return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->writesize);
187
188 }
189 static DEVICE_ATTR(writesize, S_IRUGO, mtd_writesize_show, NULL);
190
191 static ssize_t mtd_subpagesize_show(struct device *dev,
192                 struct device_attribute *attr, char *buf)
193 {
194         struct mtd_info *mtd = dev_get_drvdata(dev);
195         unsigned int subpagesize = mtd->writesize >> mtd->subpage_sft;
196
197         return snprintf(buf, PAGE_SIZE, "%u\n", subpagesize);
198
199 }
200 static DEVICE_ATTR(subpagesize, S_IRUGO, mtd_subpagesize_show, NULL);
201
202 static ssize_t mtd_oobsize_show(struct device *dev,
203                 struct device_attribute *attr, char *buf)
204 {
205         struct mtd_info *mtd = dev_get_drvdata(dev);
206
207         return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->oobsize);
208
209 }
210 static DEVICE_ATTR(oobsize, S_IRUGO, mtd_oobsize_show, NULL);
211
212 static ssize_t mtd_numeraseregions_show(struct device *dev,
213                 struct device_attribute *attr, char *buf)
214 {
215         struct mtd_info *mtd = dev_get_drvdata(dev);
216
217         return snprintf(buf, PAGE_SIZE, "%u\n", mtd->numeraseregions);
218
219 }
220 static DEVICE_ATTR(numeraseregions, S_IRUGO, mtd_numeraseregions_show,
221         NULL);
222
223 static ssize_t mtd_name_show(struct device *dev,
224                 struct device_attribute *attr, char *buf)
225 {
226         struct mtd_info *mtd = dev_get_drvdata(dev);
227
228         return snprintf(buf, PAGE_SIZE, "%s\n", mtd->name);
229
230 }
231 static DEVICE_ATTR(name, S_IRUGO, mtd_name_show, NULL);
232
233 static ssize_t mtd_ecc_strength_show(struct device *dev,
234                                      struct device_attribute *attr, char *buf)
235 {
236         struct mtd_info *mtd = dev_get_drvdata(dev);
237
238         return snprintf(buf, PAGE_SIZE, "%u\n", mtd->ecc_strength);
239 }
240 static DEVICE_ATTR(ecc_strength, S_IRUGO, mtd_ecc_strength_show, NULL);
241
242 static ssize_t mtd_bitflip_threshold_show(struct device *dev,
243                                           struct device_attribute *attr,
244                                           char *buf)
245 {
246         struct mtd_info *mtd = dev_get_drvdata(dev);
247
248         return snprintf(buf, PAGE_SIZE, "%u\n", mtd->bitflip_threshold);
249 }
250
251 static ssize_t mtd_bitflip_threshold_store(struct device *dev,
252                                            struct device_attribute *attr,
253                                            const char *buf, size_t count)
254 {
255         struct mtd_info *mtd = dev_get_drvdata(dev);
256         unsigned int bitflip_threshold;
257         int retval;
258
259         retval = kstrtouint(buf, 0, &bitflip_threshold);
260         if (retval)
261                 return retval;
262
263         mtd->bitflip_threshold = bitflip_threshold;
264         return count;
265 }
266 static DEVICE_ATTR(bitflip_threshold, S_IRUGO | S_IWUSR,
267                    mtd_bitflip_threshold_show,
268                    mtd_bitflip_threshold_store);
269
270 static ssize_t mtd_ecc_step_size_show(struct device *dev,
271                 struct device_attribute *attr, char *buf)
272 {
273         struct mtd_info *mtd = dev_get_drvdata(dev);
274
275         return snprintf(buf, PAGE_SIZE, "%u\n", mtd->ecc_step_size);
276
277 }
278 static DEVICE_ATTR(ecc_step_size, S_IRUGO, mtd_ecc_step_size_show, NULL);
279
280 static ssize_t mtd_ecc_stats_corrected_show(struct device *dev,
281                 struct device_attribute *attr, char *buf)
282 {
283         struct mtd_info *mtd = dev_get_drvdata(dev);
284         struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
285
286         return snprintf(buf, PAGE_SIZE, "%u\n", ecc_stats->corrected);
287 }
288 static DEVICE_ATTR(corrected_bits, S_IRUGO,
289                    mtd_ecc_stats_corrected_show, NULL);
290
291 static ssize_t mtd_ecc_stats_errors_show(struct device *dev,
292                 struct device_attribute *attr, char *buf)
293 {
294         struct mtd_info *mtd = dev_get_drvdata(dev);
295         struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
296
297         return snprintf(buf, PAGE_SIZE, "%u\n", ecc_stats->failed);
298 }
299 static DEVICE_ATTR(ecc_failures, S_IRUGO, mtd_ecc_stats_errors_show, NULL);
300
301 static ssize_t mtd_badblocks_show(struct device *dev,
302                 struct device_attribute *attr, char *buf)
303 {
304         struct mtd_info *mtd = dev_get_drvdata(dev);
305         struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
306
307         return snprintf(buf, PAGE_SIZE, "%u\n", ecc_stats->badblocks);
308 }
309 static DEVICE_ATTR(bad_blocks, S_IRUGO, mtd_badblocks_show, NULL);
310
311 static ssize_t mtd_bbtblocks_show(struct device *dev,
312                 struct device_attribute *attr, char *buf)
313 {
314         struct mtd_info *mtd = dev_get_drvdata(dev);
315         struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
316
317         return snprintf(buf, PAGE_SIZE, "%u\n", ecc_stats->bbtblocks);
318 }
319 static DEVICE_ATTR(bbt_blocks, S_IRUGO, mtd_bbtblocks_show, NULL);
320
321 static struct attribute *mtd_attrs[] = {
322         &dev_attr_type.attr,
323         &dev_attr_flags.attr,
324         &dev_attr_size.attr,
325         &dev_attr_erasesize.attr,
326         &dev_attr_writesize.attr,
327         &dev_attr_subpagesize.attr,
328         &dev_attr_oobsize.attr,
329         &dev_attr_numeraseregions.attr,
330         &dev_attr_name.attr,
331         &dev_attr_ecc_strength.attr,
332         &dev_attr_ecc_step_size.attr,
333         &dev_attr_corrected_bits.attr,
334         &dev_attr_ecc_failures.attr,
335         &dev_attr_bad_blocks.attr,
336         &dev_attr_bbt_blocks.attr,
337         &dev_attr_bitflip_threshold.attr,
338         NULL,
339 };
340 ATTRIBUTE_GROUPS(mtd);
341
342 static struct device_type mtd_devtype = {
343         .name           = "mtd",
344         .groups         = mtd_groups,
345         .release        = mtd_release,
346 };
347
348 #ifndef CONFIG_MMU
349 unsigned mtd_mmap_capabilities(struct mtd_info *mtd)
350 {
351         switch (mtd->type) {
352         case MTD_RAM:
353                 return NOMMU_MAP_COPY | NOMMU_MAP_DIRECT | NOMMU_MAP_EXEC |
354                         NOMMU_MAP_READ | NOMMU_MAP_WRITE;
355         case MTD_ROM:
356                 return NOMMU_MAP_COPY | NOMMU_MAP_DIRECT | NOMMU_MAP_EXEC |
357                         NOMMU_MAP_READ;
358         default:
359                 return NOMMU_MAP_COPY;
360         }
361 }
362 EXPORT_SYMBOL_GPL(mtd_mmap_capabilities);
363 #endif
364
365 static int mtd_reboot_notifier(struct notifier_block *n, unsigned long state,
366                                void *cmd)
367 {
368         struct mtd_info *mtd;
369
370         mtd = container_of(n, struct mtd_info, reboot_notifier);
371         mtd->_reboot(mtd);
372
373         return NOTIFY_DONE;
374 }
375
376 /**
377  * mtd_wunit_to_pairing_info - get pairing information of a wunit
378  * @mtd: pointer to new MTD device info structure
379  * @wunit: write unit we are interested in
380  * @info: returned pairing information
381  *
382  * Retrieve pairing information associated to the wunit.
383  * This is mainly useful when dealing with MLC/TLC NANDs where pages can be
384  * paired together, and where programming a page may influence the page it is
385  * paired with.
386  * The notion of page is replaced by the term wunit (write-unit) to stay
387  * consistent with the ->writesize field.
388  *
389  * The @wunit argument can be extracted from an absolute offset using
390  * mtd_offset_to_wunit(). @info is filled with the pairing information attached
391  * to @wunit.
392  *
393  * From the pairing info the MTD user can find all the wunits paired with
394  * @wunit using the following loop:
395  *
396  * for (i = 0; i < mtd_pairing_groups(mtd); i++) {
397  *      info.pair = i;
398  *      mtd_pairing_info_to_wunit(mtd, &info);
399  *      ...
400  * }
401  */
402 int mtd_wunit_to_pairing_info(struct mtd_info *mtd, int wunit,
403                               struct mtd_pairing_info *info)
404 {
405         int npairs = mtd_wunit_per_eb(mtd) / mtd_pairing_groups(mtd);
406
407         if (wunit < 0 || wunit >= npairs)
408                 return -EINVAL;
409
410         if (mtd->pairing && mtd->pairing->get_info)
411                 return mtd->pairing->get_info(mtd, wunit, info);
412
413         info->group = 0;
414         info->pair = wunit;
415
416         return 0;
417 }
418 EXPORT_SYMBOL_GPL(mtd_wunit_to_pairing_info);
419
420 /**
421  * mtd_wunit_to_pairing_info - get wunit from pairing information
422  * @mtd: pointer to new MTD device info structure
423  * @info: pairing information struct
424  *
425  * Returns a positive number representing the wunit associated to the info
426  * struct, or a negative error code.
427  *
428  * This is the reverse of mtd_wunit_to_pairing_info(), and can help one to
429  * iterate over all wunits of a given pair (see mtd_wunit_to_pairing_info()
430  * doc).
431  *
432  * It can also be used to only program the first page of each pair (i.e.
433  * page attached to group 0), which allows one to use an MLC NAND in
434  * software-emulated SLC mode:
435  *
436  * info.group = 0;
437  * npairs = mtd_wunit_per_eb(mtd) / mtd_pairing_groups(mtd);
438  * for (info.pair = 0; info.pair < npairs; info.pair++) {
439  *      wunit = mtd_pairing_info_to_wunit(mtd, &info);
440  *      mtd_write(mtd, mtd_wunit_to_offset(mtd, blkoffs, wunit),
441  *                mtd->writesize, &retlen, buf + (i * mtd->writesize));
442  * }
443  */
444 int mtd_pairing_info_to_wunit(struct mtd_info *mtd,
445                               const struct mtd_pairing_info *info)
446 {
447         int ngroups = mtd_pairing_groups(mtd);
448         int npairs = mtd_wunit_per_eb(mtd) / ngroups;
449
450         if (!info || info->pair < 0 || info->pair >= npairs ||
451             info->group < 0 || info->group >= ngroups)
452                 return -EINVAL;
453
454         if (mtd->pairing && mtd->pairing->get_wunit)
455                 return mtd->pairing->get_wunit(mtd, info);
456
457         return info->pair;
458 }
459 EXPORT_SYMBOL_GPL(mtd_pairing_info_to_wunit);
460
461 /**
462  * mtd_pairing_groups - get the number of pairing groups
463  * @mtd: pointer to new MTD device info structure
464  *
465  * Returns the number of pairing groups.
466  *
467  * This number is usually equal to the number of bits exposed by a single
468  * cell, and can be used in conjunction with mtd_pairing_info_to_wunit()
469  * to iterate over all pages of a given pair.
470  */
471 int mtd_pairing_groups(struct mtd_info *mtd)
472 {
473         if (!mtd->pairing || !mtd->pairing->ngroups)
474                 return 1;
475
476         return mtd->pairing->ngroups;
477 }
478 EXPORT_SYMBOL_GPL(mtd_pairing_groups);
479
480 /**
481  *      add_mtd_device - register an MTD device
482  *      @mtd: pointer to new MTD device info structure
483  *
484  *      Add a device to the list of MTD devices present in the system, and
485  *      notify each currently active MTD 'user' of its arrival. Returns
486  *      zero on success or non-zero on failure.
487  */
488
489 int add_mtd_device(struct mtd_info *mtd)
490 {
491         struct mtd_notifier *not;
492         int i, error;
493
494         /*
495          * May occur, for instance, on buggy drivers which call
496          * mtd_device_parse_register() multiple times on the same master MTD,
497          * especially with CONFIG_MTD_PARTITIONED_MASTER=y.
498          */
499         if (WARN_ONCE(mtd->dev.type, "MTD already registered\n"))
500                 return -EEXIST;
501
502         BUG_ON(mtd->writesize == 0);
503         mutex_lock(&mtd_table_mutex);
504
505         i = idr_alloc(&mtd_idr, mtd, 0, 0, GFP_KERNEL);
506         if (i < 0) {
507                 error = i;
508                 goto fail_locked;
509         }
510
511         mtd->index = i;
512         mtd->usecount = 0;
513
514         /* default value if not set by driver */
515         if (mtd->bitflip_threshold == 0)
516                 mtd->bitflip_threshold = mtd->ecc_strength;
517
518         if (is_power_of_2(mtd->erasesize))
519                 mtd->erasesize_shift = ffs(mtd->erasesize) - 1;
520         else
521                 mtd->erasesize_shift = 0;
522
523         if (is_power_of_2(mtd->writesize))
524                 mtd->writesize_shift = ffs(mtd->writesize) - 1;
525         else
526                 mtd->writesize_shift = 0;
527
528         mtd->erasesize_mask = (1 << mtd->erasesize_shift) - 1;
529         mtd->writesize_mask = (1 << mtd->writesize_shift) - 1;
530
531         /* Some chips always power up locked. Unlock them now */
532         if ((mtd->flags & MTD_WRITEABLE) && (mtd->flags & MTD_POWERUP_LOCK)) {
533                 error = mtd_unlock(mtd, 0, mtd->size);
534                 if (error && error != -EOPNOTSUPP)
535                         printk(KERN_WARNING
536                                "%s: unlock failed, writes may not work\n",
537                                mtd->name);
538                 /* Ignore unlock failures? */
539                 error = 0;
540         }
541
542         /* Caller should have set dev.parent to match the
543          * physical device, if appropriate.
544          */
545         mtd->dev.type = &mtd_devtype;
546         mtd->dev.class = &mtd_class;
547         mtd->dev.devt = MTD_DEVT(i);
548         dev_set_name(&mtd->dev, "mtd%d", i);
549         dev_set_drvdata(&mtd->dev, mtd);
550         of_node_get(mtd_get_of_node(mtd));
551         error = device_register(&mtd->dev);
552         if (error)
553                 goto fail_added;
554
555         device_create(&mtd_class, mtd->dev.parent, MTD_DEVT(i) + 1, NULL,
556                       "mtd%dro", i);
557
558         pr_debug("mtd: Giving out device %d to %s\n", i, mtd->name);
559         /* No need to get a refcount on the module containing
560            the notifier, since we hold the mtd_table_mutex */
561         list_for_each_entry(not, &mtd_notifiers, list)
562                 not->add(mtd);
563
564         mutex_unlock(&mtd_table_mutex);
565         /* We _know_ we aren't being removed, because
566            our caller is still holding us here. So none
567            of this try_ nonsense, and no bitching about it
568            either. :) */
569         __module_get(THIS_MODULE);
570         return 0;
571
572 fail_added:
573         of_node_put(mtd_get_of_node(mtd));
574         idr_remove(&mtd_idr, i);
575 fail_locked:
576         mutex_unlock(&mtd_table_mutex);
577         return error;
578 }
579
580 /**
581  *      del_mtd_device - unregister an MTD device
582  *      @mtd: pointer to MTD device info structure
583  *
584  *      Remove a device from the list of MTD devices present in the system,
585  *      and notify each currently active MTD 'user' of its departure.
586  *      Returns zero on success or 1 on failure, which currently will happen
587  *      if the requested device does not appear to be present in the list.
588  */
589
590 int del_mtd_device(struct mtd_info *mtd)
591 {
592         int ret;
593         struct mtd_notifier *not;
594
595         mutex_lock(&mtd_table_mutex);
596
597         if (idr_find(&mtd_idr, mtd->index) != mtd) {
598                 ret = -ENODEV;
599                 goto out_error;
600         }
601
602         /* No need to get a refcount on the module containing
603                 the notifier, since we hold the mtd_table_mutex */
604         list_for_each_entry(not, &mtd_notifiers, list)
605                 not->remove(mtd);
606
607         if (mtd->usecount) {
608                 printk(KERN_NOTICE "Removing MTD device #%d (%s) with use count %d\n",
609                        mtd->index, mtd->name, mtd->usecount);
610                 ret = -EBUSY;
611         } else {
612                 device_unregister(&mtd->dev);
613
614                 idr_remove(&mtd_idr, mtd->index);
615                 of_node_put(mtd_get_of_node(mtd));
616
617                 module_put(THIS_MODULE);
618                 ret = 0;
619         }
620
621 out_error:
622         mutex_unlock(&mtd_table_mutex);
623         return ret;
624 }
625
626 static int mtd_add_device_partitions(struct mtd_info *mtd,
627                                      struct mtd_partitions *parts)
628 {
629         const struct mtd_partition *real_parts = parts->parts;
630         int nbparts = parts->nr_parts;
631         int ret;
632
633         if (nbparts == 0 || IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER)) {
634                 ret = add_mtd_device(mtd);
635                 if (ret)
636                         return ret;
637         }
638
639         if (nbparts > 0) {
640                 ret = add_mtd_partitions(mtd, real_parts, nbparts);
641                 if (ret && IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER))
642                         del_mtd_device(mtd);
643                 return ret;
644         }
645
646         return 0;
647 }
648
649 /*
650  * Set a few defaults based on the parent devices, if not provided by the
651  * driver
652  */
653 static void mtd_set_dev_defaults(struct mtd_info *mtd)
654 {
655         if (mtd->dev.parent) {
656                 if (!mtd->owner && mtd->dev.parent->driver)
657                         mtd->owner = mtd->dev.parent->driver->owner;
658                 if (!mtd->name)
659                         mtd->name = dev_name(mtd->dev.parent);
660         } else {
661                 pr_debug("mtd device won't show a device symlink in sysfs\n");
662         }
663 }
664
665 /**
666  * mtd_device_parse_register - parse partitions and register an MTD device.
667  *
668  * @mtd: the MTD device to register
669  * @types: the list of MTD partition probes to try, see
670  *         'parse_mtd_partitions()' for more information
671  * @parser_data: MTD partition parser-specific data
672  * @parts: fallback partition information to register, if parsing fails;
673  *         only valid if %nr_parts > %0
674  * @nr_parts: the number of partitions in parts, if zero then the full
675  *            MTD device is registered if no partition info is found
676  *
677  * This function aggregates MTD partitions parsing (done by
678  * 'parse_mtd_partitions()') and MTD device and partitions registering. It
679  * basically follows the most common pattern found in many MTD drivers:
680  *
681  * * It first tries to probe partitions on MTD device @mtd using parsers
682  *   specified in @types (if @types is %NULL, then the default list of parsers
683  *   is used, see 'parse_mtd_partitions()' for more information). If none are
684  *   found this functions tries to fallback to information specified in
685  *   @parts/@nr_parts.
686  * * If any partitioning info was found, this function registers the found
687  *   partitions. If the MTD_PARTITIONED_MASTER option is set, then the device
688  *   as a whole is registered first.
689  * * If no partitions were found this function just registers the MTD device
690  *   @mtd and exits.
691  *
692  * Returns zero in case of success and a negative error code in case of failure.
693  */
694 int mtd_device_parse_register(struct mtd_info *mtd, const char * const *types,
695                               struct mtd_part_parser_data *parser_data,
696                               const struct mtd_partition *parts,
697                               int nr_parts)
698 {
699         struct mtd_partitions parsed;
700         int ret;
701
702         mtd_set_dev_defaults(mtd);
703
704         memset(&parsed, 0, sizeof(parsed));
705
706         ret = parse_mtd_partitions(mtd, types, &parsed, parser_data);
707         if ((ret < 0 || parsed.nr_parts == 0) && parts && nr_parts) {
708                 /* Fall back to driver-provided partitions */
709                 parsed = (struct mtd_partitions){
710                         .parts          = parts,
711                         .nr_parts       = nr_parts,
712                 };
713         } else if (ret < 0) {
714                 /* Didn't come up with parsed OR fallback partitions */
715                 pr_info("mtd: failed to find partitions; one or more parsers reports errors (%d)\n",
716                         ret);
717                 /* Don't abort on errors; we can still use unpartitioned MTD */
718                 memset(&parsed, 0, sizeof(parsed));
719         }
720
721         ret = mtd_add_device_partitions(mtd, &parsed);
722         if (ret)
723                 goto out;
724
725         /*
726          * FIXME: some drivers unfortunately call this function more than once.
727          * So we have to check if we've already assigned the reboot notifier.
728          *
729          * Generally, we can make multiple calls work for most cases, but it
730          * does cause problems with parse_mtd_partitions() above (e.g.,
731          * cmdlineparts will register partitions more than once).
732          */
733         WARN_ONCE(mtd->_reboot && mtd->reboot_notifier.notifier_call,
734                   "MTD already registered\n");
735         if (mtd->_reboot && !mtd->reboot_notifier.notifier_call) {
736                 mtd->reboot_notifier.notifier_call = mtd_reboot_notifier;
737                 register_reboot_notifier(&mtd->reboot_notifier);
738         }
739
740 out:
741         /* Cleanup any parsed partitions */
742         mtd_part_parser_cleanup(&parsed);
743         return ret;
744 }
745 EXPORT_SYMBOL_GPL(mtd_device_parse_register);
746
747 /**
748  * mtd_device_unregister - unregister an existing MTD device.
749  *
750  * @master: the MTD device to unregister.  This will unregister both the master
751  *          and any partitions if registered.
752  */
753 int mtd_device_unregister(struct mtd_info *master)
754 {
755         int err;
756
757         if (master->_reboot)
758                 unregister_reboot_notifier(&master->reboot_notifier);
759
760         err = del_mtd_partitions(master);
761         if (err)
762                 return err;
763
764         if (!device_is_registered(&master->dev))
765                 return 0;
766
767         return del_mtd_device(master);
768 }
769 EXPORT_SYMBOL_GPL(mtd_device_unregister);
770
771 /**
772  *      register_mtd_user - register a 'user' of MTD devices.
773  *      @new: pointer to notifier info structure
774  *
775  *      Registers a pair of callbacks function to be called upon addition
776  *      or removal of MTD devices. Causes the 'add' callback to be immediately
777  *      invoked for each MTD device currently present in the system.
778  */
779 void register_mtd_user (struct mtd_notifier *new)
780 {
781         struct mtd_info *mtd;
782
783         mutex_lock(&mtd_table_mutex);
784
785         list_add(&new->list, &mtd_notifiers);
786
787         __module_get(THIS_MODULE);
788
789         mtd_for_each_device(mtd)
790                 new->add(mtd);
791
792         mutex_unlock(&mtd_table_mutex);
793 }
794 EXPORT_SYMBOL_GPL(register_mtd_user);
795
796 /**
797  *      unregister_mtd_user - unregister a 'user' of MTD devices.
798  *      @old: pointer to notifier info structure
799  *
800  *      Removes a callback function pair from the list of 'users' to be
801  *      notified upon addition or removal of MTD devices. Causes the
802  *      'remove' callback to be immediately invoked for each MTD device
803  *      currently present in the system.
804  */
805 int unregister_mtd_user (struct mtd_notifier *old)
806 {
807         struct mtd_info *mtd;
808
809         mutex_lock(&mtd_table_mutex);
810
811         module_put(THIS_MODULE);
812
813         mtd_for_each_device(mtd)
814                 old->remove(mtd);
815
816         list_del(&old->list);
817         mutex_unlock(&mtd_table_mutex);
818         return 0;
819 }
820 EXPORT_SYMBOL_GPL(unregister_mtd_user);
821
822 /**
823  *      get_mtd_device - obtain a validated handle for an MTD device
824  *      @mtd: last known address of the required MTD device
825  *      @num: internal device number of the required MTD device
826  *
827  *      Given a number and NULL address, return the num'th entry in the device
828  *      table, if any.  Given an address and num == -1, search the device table
829  *      for a device with that address and return if it's still present. Given
830  *      both, return the num'th driver only if its address matches. Return
831  *      error code if not.
832  */
833 struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num)
834 {
835         struct mtd_info *ret = NULL, *other;
836         int err = -ENODEV;
837
838         mutex_lock(&mtd_table_mutex);
839
840         if (num == -1) {
841                 mtd_for_each_device(other) {
842                         if (other == mtd) {
843                                 ret = mtd;
844                                 break;
845                         }
846                 }
847         } else if (num >= 0) {
848                 ret = idr_find(&mtd_idr, num);
849                 if (mtd && mtd != ret)
850                         ret = NULL;
851         }
852
853         if (!ret) {
854                 ret = ERR_PTR(err);
855                 goto out;
856         }
857
858         err = __get_mtd_device(ret);
859         if (err)
860                 ret = ERR_PTR(err);
861 out:
862         mutex_unlock(&mtd_table_mutex);
863         return ret;
864 }
865 EXPORT_SYMBOL_GPL(get_mtd_device);
866
867
868 int __get_mtd_device(struct mtd_info *mtd)
869 {
870         int err;
871
872         if (!try_module_get(mtd->owner))
873                 return -ENODEV;
874
875         if (mtd->_get_device) {
876                 err = mtd->_get_device(mtd);
877
878                 if (err) {
879                         module_put(mtd->owner);
880                         return err;
881                 }
882         }
883         mtd->usecount++;
884         return 0;
885 }
886 EXPORT_SYMBOL_GPL(__get_mtd_device);
887
888 /**
889  *      get_mtd_device_nm - obtain a validated handle for an MTD device by
890  *      device name
891  *      @name: MTD device name to open
892  *
893  *      This function returns MTD device description structure in case of
894  *      success and an error code in case of failure.
895  */
896 struct mtd_info *get_mtd_device_nm(const char *name)
897 {
898         int err = -ENODEV;
899         struct mtd_info *mtd = NULL, *other;
900
901         mutex_lock(&mtd_table_mutex);
902
903         mtd_for_each_device(other) {
904                 if (!strcmp(name, other->name)) {
905                         mtd = other;
906                         break;
907                 }
908         }
909
910         if (!mtd)
911                 goto out_unlock;
912
913         err = __get_mtd_device(mtd);
914         if (err)
915                 goto out_unlock;
916
917         mutex_unlock(&mtd_table_mutex);
918         return mtd;
919
920 out_unlock:
921         mutex_unlock(&mtd_table_mutex);
922         return ERR_PTR(err);
923 }
924 EXPORT_SYMBOL_GPL(get_mtd_device_nm);
925
926 void put_mtd_device(struct mtd_info *mtd)
927 {
928         mutex_lock(&mtd_table_mutex);
929         __put_mtd_device(mtd);
930         mutex_unlock(&mtd_table_mutex);
931
932 }
933 EXPORT_SYMBOL_GPL(put_mtd_device);
934
935 void __put_mtd_device(struct mtd_info *mtd)
936 {
937         --mtd->usecount;
938         BUG_ON(mtd->usecount < 0);
939
940         if (mtd->_put_device)
941                 mtd->_put_device(mtd);
942
943         module_put(mtd->owner);
944 }
945 EXPORT_SYMBOL_GPL(__put_mtd_device);
946
947 /*
948  * Erase is an asynchronous operation.  Device drivers are supposed
949  * to call instr->callback() whenever the operation completes, even
950  * if it completes with a failure.
951  * Callers are supposed to pass a callback function and wait for it
952  * to be called before writing to the block.
953  */
954 int mtd_erase(struct mtd_info *mtd, struct erase_info *instr)
955 {
956         if (instr->addr >= mtd->size || instr->len > mtd->size - instr->addr)
957                 return -EINVAL;
958         if (!(mtd->flags & MTD_WRITEABLE))
959                 return -EROFS;
960         instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
961         if (!instr->len) {
962                 instr->state = MTD_ERASE_DONE;
963                 mtd_erase_callback(instr);
964                 return 0;
965         }
966         ledtrig_mtd_activity();
967         return mtd->_erase(mtd, instr);
968 }
969 EXPORT_SYMBOL_GPL(mtd_erase);
970
971 /*
972  * This stuff for eXecute-In-Place. phys is optional and may be set to NULL.
973  */
974 int mtd_point(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,
975               void **virt, resource_size_t *phys)
976 {
977         *retlen = 0;
978         *virt = NULL;
979         if (phys)
980                 *phys = 0;
981         if (!mtd->_point)
982                 return -EOPNOTSUPP;
983         if (from < 0 || from >= mtd->size || len > mtd->size - from)
984                 return -EINVAL;
985         if (!len)
986                 return 0;
987         return mtd->_point(mtd, from, len, retlen, virt, phys);
988 }
989 EXPORT_SYMBOL_GPL(mtd_point);
990
991 /* We probably shouldn't allow XIP if the unpoint isn't a NULL */
992 int mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
993 {
994         if (!mtd->_unpoint)
995                 return -EOPNOTSUPP;
996         if (from < 0 || from >= mtd->size || len > mtd->size - from)
997                 return -EINVAL;
998         if (!len)
999                 return 0;
1000         return mtd->_unpoint(mtd, from, len);
1001 }
1002 EXPORT_SYMBOL_GPL(mtd_unpoint);
1003
1004 /*
1005  * Allow NOMMU mmap() to directly map the device (if not NULL)
1006  * - return the address to which the offset maps
1007  * - return -ENOSYS to indicate refusal to do the mapping
1008  */
1009 unsigned long mtd_get_unmapped_area(struct mtd_info *mtd, unsigned long len,
1010                                     unsigned long offset, unsigned long flags)
1011 {
1012         if (!mtd->_get_unmapped_area)
1013                 return -EOPNOTSUPP;
1014         if (offset >= mtd->size || len > mtd->size - offset)
1015                 return -EINVAL;
1016         return mtd->_get_unmapped_area(mtd, len, offset, flags);
1017 }
1018 EXPORT_SYMBOL_GPL(mtd_get_unmapped_area);
1019
1020 int mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,
1021              u_char *buf)
1022 {
1023         int ret_code;
1024         *retlen = 0;
1025         if (from < 0 || from >= mtd->size || len > mtd->size - from)
1026                 return -EINVAL;
1027         if (!len)
1028                 return 0;
1029
1030         ledtrig_mtd_activity();
1031         /*
1032          * In the absence of an error, drivers return a non-negative integer
1033          * representing the maximum number of bitflips that were corrected on
1034          * any one ecc region (if applicable; zero otherwise).
1035          */
1036         ret_code = mtd->_read(mtd, from, len, retlen, buf);
1037         if (unlikely(ret_code < 0))
1038                 return ret_code;
1039         if (mtd->ecc_strength == 0)
1040                 return 0;       /* device lacks ecc */
1041         return ret_code >= mtd->bitflip_threshold ? -EUCLEAN : 0;
1042 }
1043 EXPORT_SYMBOL_GPL(mtd_read);
1044
1045 int mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
1046               const u_char *buf)
1047 {
1048         *retlen = 0;
1049         if (to < 0 || to >= mtd->size || len > mtd->size - to)
1050                 return -EINVAL;
1051         if (!mtd->_write || !(mtd->flags & MTD_WRITEABLE))
1052                 return -EROFS;
1053         if (!len)
1054                 return 0;
1055         ledtrig_mtd_activity();
1056         return mtd->_write(mtd, to, len, retlen, buf);
1057 }
1058 EXPORT_SYMBOL_GPL(mtd_write);
1059
1060 /*
1061  * In blackbox flight recorder like scenarios we want to make successful writes
1062  * in interrupt context. panic_write() is only intended to be called when its
1063  * known the kernel is about to panic and we need the write to succeed. Since
1064  * the kernel is not going to be running for much longer, this function can
1065  * break locks and delay to ensure the write succeeds (but not sleep).
1066  */
1067 int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
1068                     const u_char *buf)
1069 {
1070         *retlen = 0;
1071         if (!mtd->_panic_write)
1072                 return -EOPNOTSUPP;
1073         if (to < 0 || to >= mtd->size || len > mtd->size - to)
1074                 return -EINVAL;
1075         if (!(mtd->flags & MTD_WRITEABLE))
1076                 return -EROFS;
1077         if (!len)
1078                 return 0;
1079         return mtd->_panic_write(mtd, to, len, retlen, buf);
1080 }
1081 EXPORT_SYMBOL_GPL(mtd_panic_write);
1082
1083 int mtd_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops)
1084 {
1085         int ret_code;
1086         ops->retlen = ops->oobretlen = 0;
1087         if (!mtd->_read_oob)
1088                 return -EOPNOTSUPP;
1089
1090         ledtrig_mtd_activity();
1091         /*
1092          * In cases where ops->datbuf != NULL, mtd->_read_oob() has semantics
1093          * similar to mtd->_read(), returning a non-negative integer
1094          * representing max bitflips. In other cases, mtd->_read_oob() may
1095          * return -EUCLEAN. In all cases, perform similar logic to mtd_read().
1096          */
1097         ret_code = mtd->_read_oob(mtd, from, ops);
1098         if (unlikely(ret_code < 0))
1099                 return ret_code;
1100         if (mtd->ecc_strength == 0)
1101                 return 0;       /* device lacks ecc */
1102         return ret_code >= mtd->bitflip_threshold ? -EUCLEAN : 0;
1103 }
1104 EXPORT_SYMBOL_GPL(mtd_read_oob);
1105
1106 int mtd_write_oob(struct mtd_info *mtd, loff_t to,
1107                                 struct mtd_oob_ops *ops)
1108 {
1109         ops->retlen = ops->oobretlen = 0;
1110         if (!mtd->_write_oob)
1111                 return -EOPNOTSUPP;
1112         if (!(mtd->flags & MTD_WRITEABLE))
1113                 return -EROFS;
1114         ledtrig_mtd_activity();
1115         return mtd->_write_oob(mtd, to, ops);
1116 }
1117 EXPORT_SYMBOL_GPL(mtd_write_oob);
1118
1119 /**
1120  * mtd_ooblayout_ecc - Get the OOB region definition of a specific ECC section
1121  * @mtd: MTD device structure
1122  * @section: ECC section. Depending on the layout you may have all the ECC
1123  *           bytes stored in a single contiguous section, or one section
1124  *           per ECC chunk (and sometime several sections for a single ECC
1125  *           ECC chunk)
1126  * @oobecc: OOB region struct filled with the appropriate ECC position
1127  *          information
1128  *
1129  * This function returns ECC section information in the OOB area. If you want
1130  * to get all the ECC bytes information, then you should call
1131  * mtd_ooblayout_ecc(mtd, section++, oobecc) until it returns -ERANGE.
1132  *
1133  * Returns zero on success, a negative error code otherwise.
1134  */
1135 int mtd_ooblayout_ecc(struct mtd_info *mtd, int section,
1136                       struct mtd_oob_region *oobecc)
1137 {
1138         memset(oobecc, 0, sizeof(*oobecc));
1139
1140         if (!mtd || section < 0)
1141                 return -EINVAL;
1142
1143         if (!mtd->ooblayout || !mtd->ooblayout->ecc)
1144                 return -ENOTSUPP;
1145
1146         return mtd->ooblayout->ecc(mtd, section, oobecc);
1147 }
1148 EXPORT_SYMBOL_GPL(mtd_ooblayout_ecc);
1149
1150 /**
1151  * mtd_ooblayout_free - Get the OOB region definition of a specific free
1152  *                      section
1153  * @mtd: MTD device structure
1154  * @section: Free section you are interested in. Depending on the layout
1155  *           you may have all the free bytes stored in a single contiguous
1156  *           section, or one section per ECC chunk plus an extra section
1157  *           for the remaining bytes (or other funky layout).
1158  * @oobfree: OOB region struct filled with the appropriate free position
1159  *           information
1160  *
1161  * This function returns free bytes position in the OOB area. If you want
1162  * to get all the free bytes information, then you should call
1163  * mtd_ooblayout_free(mtd, section++, oobfree) until it returns -ERANGE.
1164  *
1165  * Returns zero on success, a negative error code otherwise.
1166  */
1167 int mtd_ooblayout_free(struct mtd_info *mtd, int section,
1168                        struct mtd_oob_region *oobfree)
1169 {
1170         memset(oobfree, 0, sizeof(*oobfree));
1171
1172         if (!mtd || section < 0)
1173                 return -EINVAL;
1174
1175         if (!mtd->ooblayout || !mtd->ooblayout->free)
1176                 return -ENOTSUPP;
1177
1178         return mtd->ooblayout->free(mtd, section, oobfree);
1179 }
1180 EXPORT_SYMBOL_GPL(mtd_ooblayout_free);
1181
1182 /**
1183  * mtd_ooblayout_find_region - Find the region attached to a specific byte
1184  * @mtd: mtd info structure
1185  * @byte: the byte we are searching for
1186  * @sectionp: pointer where the section id will be stored
1187  * @oobregion: used to retrieve the ECC position
1188  * @iter: iterator function. Should be either mtd_ooblayout_free or
1189  *        mtd_ooblayout_ecc depending on the region type you're searching for
1190  *
1191  * This function returns the section id and oobregion information of a
1192  * specific byte. For example, say you want to know where the 4th ECC byte is
1193  * stored, you'll use:
1194  *
1195  * mtd_ooblayout_find_region(mtd, 3, &section, &oobregion, mtd_ooblayout_ecc);
1196  *
1197  * Returns zero on success, a negative error code otherwise.
1198  */
1199 static int mtd_ooblayout_find_region(struct mtd_info *mtd, int byte,
1200                                 int *sectionp, struct mtd_oob_region *oobregion,
1201                                 int (*iter)(struct mtd_info *,
1202                                             int section,
1203                                             struct mtd_oob_region *oobregion))
1204 {
1205         int pos = 0, ret, section = 0;
1206
1207         memset(oobregion, 0, sizeof(*oobregion));
1208
1209         while (1) {
1210                 ret = iter(mtd, section, oobregion);
1211                 if (ret)
1212                         return ret;
1213
1214                 if (pos + oobregion->length > byte)
1215                         break;
1216
1217                 pos += oobregion->length;
1218                 section++;
1219         }
1220
1221         /*
1222          * Adjust region info to make it start at the beginning at the
1223          * 'start' ECC byte.
1224          */
1225         oobregion->offset += byte - pos;
1226         oobregion->length -= byte - pos;
1227         *sectionp = section;
1228
1229         return 0;
1230 }
1231
1232 /**
1233  * mtd_ooblayout_find_eccregion - Find the ECC region attached to a specific
1234  *                                ECC byte
1235  * @mtd: mtd info structure
1236  * @eccbyte: the byte we are searching for
1237  * @sectionp: pointer where the section id will be stored
1238  * @oobregion: OOB region information
1239  *
1240  * Works like mtd_ooblayout_find_region() except it searches for a specific ECC
1241  * byte.
1242  *
1243  * Returns zero on success, a negative error code otherwise.
1244  */
1245 int mtd_ooblayout_find_eccregion(struct mtd_info *mtd, int eccbyte,
1246                                  int *section,
1247                                  struct mtd_oob_region *oobregion)
1248 {
1249         return mtd_ooblayout_find_region(mtd, eccbyte, section, oobregion,
1250                                          mtd_ooblayout_ecc);
1251 }
1252 EXPORT_SYMBOL_GPL(mtd_ooblayout_find_eccregion);
1253
1254 /**
1255  * mtd_ooblayout_get_bytes - Extract OOB bytes from the oob buffer
1256  * @mtd: mtd info structure
1257  * @buf: destination buffer to store OOB bytes
1258  * @oobbuf: OOB buffer
1259  * @start: first byte to retrieve
1260  * @nbytes: number of bytes to retrieve
1261  * @iter: section iterator
1262  *
1263  * Extract bytes attached to a specific category (ECC or free)
1264  * from the OOB buffer and copy them into buf.
1265  *
1266  * Returns zero on success, a negative error code otherwise.
1267  */
1268 static int mtd_ooblayout_get_bytes(struct mtd_info *mtd, u8 *buf,
1269                                 const u8 *oobbuf, int start, int nbytes,
1270                                 int (*iter)(struct mtd_info *,
1271                                             int section,
1272                                             struct mtd_oob_region *oobregion))
1273 {
1274         struct mtd_oob_region oobregion;
1275         int section, ret;
1276
1277         ret = mtd_ooblayout_find_region(mtd, start, &section,
1278                                         &oobregion, iter);
1279
1280         while (!ret) {
1281                 int cnt;
1282
1283                 cnt = min_t(int, nbytes, oobregion.length);
1284                 memcpy(buf, oobbuf + oobregion.offset, cnt);
1285                 buf += cnt;
1286                 nbytes -= cnt;
1287
1288                 if (!nbytes)
1289                         break;
1290
1291                 ret = iter(mtd, ++section, &oobregion);
1292         }
1293
1294         return ret;
1295 }
1296
1297 /**
1298  * mtd_ooblayout_set_bytes - put OOB bytes into the oob buffer
1299  * @mtd: mtd info structure
1300  * @buf: source buffer to get OOB bytes from
1301  * @oobbuf: OOB buffer
1302  * @start: first OOB byte to set
1303  * @nbytes: number of OOB bytes to set
1304  * @iter: section iterator
1305  *
1306  * Fill the OOB buffer with data provided in buf. The category (ECC or free)
1307  * is selected by passing the appropriate iterator.
1308  *
1309  * Returns zero on success, a negative error code otherwise.
1310  */
1311 static int mtd_ooblayout_set_bytes(struct mtd_info *mtd, const u8 *buf,
1312                                 u8 *oobbuf, int start, int nbytes,
1313                                 int (*iter)(struct mtd_info *,
1314                                             int section,
1315                                             struct mtd_oob_region *oobregion))
1316 {
1317         struct mtd_oob_region oobregion;
1318         int section, ret;
1319
1320         ret = mtd_ooblayout_find_region(mtd, start, &section,
1321                                         &oobregion, iter);
1322
1323         while (!ret) {
1324                 int cnt;
1325
1326                 cnt = min_t(int, nbytes, oobregion.length);
1327                 memcpy(oobbuf + oobregion.offset, buf, cnt);
1328                 buf += cnt;
1329                 nbytes -= cnt;
1330
1331                 if (!nbytes)
1332                         break;
1333
1334                 ret = iter(mtd, ++section, &oobregion);
1335         }
1336
1337         return ret;
1338 }
1339
1340 /**
1341  * mtd_ooblayout_count_bytes - count the number of bytes in a OOB category
1342  * @mtd: mtd info structure
1343  * @iter: category iterator
1344  *
1345  * Count the number of bytes in a given category.
1346  *
1347  * Returns a positive value on success, a negative error code otherwise.
1348  */
1349 static int mtd_ooblayout_count_bytes(struct mtd_info *mtd,
1350                                 int (*iter)(struct mtd_info *,
1351                                             int section,
1352                                             struct mtd_oob_region *oobregion))
1353 {
1354         struct mtd_oob_region oobregion;
1355         int section = 0, ret, nbytes = 0;
1356
1357         while (1) {
1358                 ret = iter(mtd, section++, &oobregion);
1359                 if (ret) {
1360                         if (ret == -ERANGE)
1361                                 ret = nbytes;
1362                         break;
1363                 }
1364
1365                 nbytes += oobregion.length;
1366         }
1367
1368         return ret;
1369 }
1370
1371 /**
1372  * mtd_ooblayout_get_eccbytes - extract ECC bytes from the oob buffer
1373  * @mtd: mtd info structure
1374  * @eccbuf: destination buffer to store ECC bytes
1375  * @oobbuf: OOB buffer
1376  * @start: first ECC byte to retrieve
1377  * @nbytes: number of ECC bytes to retrieve
1378  *
1379  * Works like mtd_ooblayout_get_bytes(), except it acts on ECC bytes.
1380  *
1381  * Returns zero on success, a negative error code otherwise.
1382  */
1383 int mtd_ooblayout_get_eccbytes(struct mtd_info *mtd, u8 *eccbuf,
1384                                const u8 *oobbuf, int start, int nbytes)
1385 {
1386         return mtd_ooblayout_get_bytes(mtd, eccbuf, oobbuf, start, nbytes,
1387                                        mtd_ooblayout_ecc);
1388 }
1389 EXPORT_SYMBOL_GPL(mtd_ooblayout_get_eccbytes);
1390
1391 /**
1392  * mtd_ooblayout_set_eccbytes - set ECC bytes into the oob buffer
1393  * @mtd: mtd info structure
1394  * @eccbuf: source buffer to get ECC bytes from
1395  * @oobbuf: OOB buffer
1396  * @start: first ECC byte to set
1397  * @nbytes: number of ECC bytes to set
1398  *
1399  * Works like mtd_ooblayout_set_bytes(), except it acts on ECC bytes.
1400  *
1401  * Returns zero on success, a negative error code otherwise.
1402  */
1403 int mtd_ooblayout_set_eccbytes(struct mtd_info *mtd, const u8 *eccbuf,
1404                                u8 *oobbuf, int start, int nbytes)
1405 {
1406         return mtd_ooblayout_set_bytes(mtd, eccbuf, oobbuf, start, nbytes,
1407                                        mtd_ooblayout_ecc);
1408 }
1409 EXPORT_SYMBOL_GPL(mtd_ooblayout_set_eccbytes);
1410
1411 /**
1412  * mtd_ooblayout_get_databytes - extract data bytes from the oob buffer
1413  * @mtd: mtd info structure
1414  * @databuf: destination buffer to store ECC bytes
1415  * @oobbuf: OOB buffer
1416  * @start: first ECC byte to retrieve
1417  * @nbytes: number of ECC bytes to retrieve
1418  *
1419  * Works like mtd_ooblayout_get_bytes(), except it acts on free bytes.
1420  *
1421  * Returns zero on success, a negative error code otherwise.
1422  */
1423 int mtd_ooblayout_get_databytes(struct mtd_info *mtd, u8 *databuf,
1424                                 const u8 *oobbuf, int start, int nbytes)
1425 {
1426         return mtd_ooblayout_get_bytes(mtd, databuf, oobbuf, start, nbytes,
1427                                        mtd_ooblayout_free);
1428 }
1429 EXPORT_SYMBOL_GPL(mtd_ooblayout_get_databytes);
1430
1431 /**
1432  * mtd_ooblayout_get_eccbytes - set data bytes into the oob buffer
1433  * @mtd: mtd info structure
1434  * @eccbuf: source buffer to get data bytes from
1435  * @oobbuf: OOB buffer
1436  * @start: first ECC byte to set
1437  * @nbytes: number of ECC bytes to set
1438  *
1439  * Works like mtd_ooblayout_get_bytes(), except it acts on free bytes.
1440  *
1441  * Returns zero on success, a negative error code otherwise.
1442  */
1443 int mtd_ooblayout_set_databytes(struct mtd_info *mtd, const u8 *databuf,
1444                                 u8 *oobbuf, int start, int nbytes)
1445 {
1446         return mtd_ooblayout_set_bytes(mtd, databuf, oobbuf, start, nbytes,
1447                                        mtd_ooblayout_free);
1448 }
1449 EXPORT_SYMBOL_GPL(mtd_ooblayout_set_databytes);
1450
1451 /**
1452  * mtd_ooblayout_count_freebytes - count the number of free bytes in OOB
1453  * @mtd: mtd info structure
1454  *
1455  * Works like mtd_ooblayout_count_bytes(), except it count free bytes.
1456  *
1457  * Returns zero on success, a negative error code otherwise.
1458  */
1459 int mtd_ooblayout_count_freebytes(struct mtd_info *mtd)
1460 {
1461         return mtd_ooblayout_count_bytes(mtd, mtd_ooblayout_free);
1462 }
1463 EXPORT_SYMBOL_GPL(mtd_ooblayout_count_freebytes);
1464
1465 /**
1466  * mtd_ooblayout_count_freebytes - count the number of ECC bytes in OOB
1467  * @mtd: mtd info structure
1468  *
1469  * Works like mtd_ooblayout_count_bytes(), except it count ECC bytes.
1470  *
1471  * Returns zero on success, a negative error code otherwise.
1472  */
1473 int mtd_ooblayout_count_eccbytes(struct mtd_info *mtd)
1474 {
1475         return mtd_ooblayout_count_bytes(mtd, mtd_ooblayout_ecc);
1476 }
1477 EXPORT_SYMBOL_GPL(mtd_ooblayout_count_eccbytes);
1478
1479 /*
1480  * Method to access the protection register area, present in some flash
1481  * devices. The user data is one time programmable but the factory data is read
1482  * only.
1483  */
1484 int mtd_get_fact_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen,
1485                            struct otp_info *buf)
1486 {
1487         if (!mtd->_get_fact_prot_info)
1488                 return -EOPNOTSUPP;
1489         if (!len)
1490                 return 0;
1491         return mtd->_get_fact_prot_info(mtd, len, retlen, buf);
1492 }
1493 EXPORT_SYMBOL_GPL(mtd_get_fact_prot_info);
1494
1495 int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
1496                            size_t *retlen, u_char *buf)
1497 {
1498         *retlen = 0;
1499         if (!mtd->_read_fact_prot_reg)
1500                 return -EOPNOTSUPP;
1501         if (!len)
1502                 return 0;
1503         return mtd->_read_fact_prot_reg(mtd, from, len, retlen, buf);
1504 }
1505 EXPORT_SYMBOL_GPL(mtd_read_fact_prot_reg);
1506
1507 int mtd_get_user_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen,
1508                            struct otp_info *buf)
1509 {
1510         if (!mtd->_get_user_prot_info)
1511                 return -EOPNOTSUPP;
1512         if (!len)
1513                 return 0;
1514         return mtd->_get_user_prot_info(mtd, len, retlen, buf);
1515 }
1516 EXPORT_SYMBOL_GPL(mtd_get_user_prot_info);
1517
1518 int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
1519                            size_t *retlen, u_char *buf)
1520 {
1521         *retlen = 0;
1522         if (!mtd->_read_user_prot_reg)
1523                 return -EOPNOTSUPP;
1524         if (!len)
1525                 return 0;
1526         return mtd->_read_user_prot_reg(mtd, from, len, retlen, buf);
1527 }
1528 EXPORT_SYMBOL_GPL(mtd_read_user_prot_reg);
1529
1530 int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, size_t len,
1531                             size_t *retlen, u_char *buf)
1532 {
1533         int ret;
1534
1535         *retlen = 0;
1536         if (!mtd->_write_user_prot_reg)
1537                 return -EOPNOTSUPP;
1538         if (!len)
1539                 return 0;
1540         ret = mtd->_write_user_prot_reg(mtd, to, len, retlen, buf);
1541         if (ret)
1542                 return ret;
1543
1544         /*
1545          * If no data could be written at all, we are out of memory and
1546          * must return -ENOSPC.
1547          */
1548         return (*retlen) ? 0 : -ENOSPC;
1549 }
1550 EXPORT_SYMBOL_GPL(mtd_write_user_prot_reg);
1551
1552 int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len)
1553 {
1554         if (!mtd->_lock_user_prot_reg)
1555                 return -EOPNOTSUPP;
1556         if (!len)
1557                 return 0;
1558         return mtd->_lock_user_prot_reg(mtd, from, len);
1559 }
1560 EXPORT_SYMBOL_GPL(mtd_lock_user_prot_reg);
1561
1562 /* Chip-supported device locking */
1563 int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1564 {
1565         if (!mtd->_lock)
1566                 return -EOPNOTSUPP;
1567         if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)
1568                 return -EINVAL;
1569         if (!len)
1570                 return 0;
1571         return mtd->_lock(mtd, ofs, len);
1572 }
1573 EXPORT_SYMBOL_GPL(mtd_lock);
1574
1575 int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1576 {
1577         if (!mtd->_unlock)
1578                 return -EOPNOTSUPP;
1579         if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)
1580                 return -EINVAL;
1581         if (!len)
1582                 return 0;
1583         return mtd->_unlock(mtd, ofs, len);
1584 }
1585 EXPORT_SYMBOL_GPL(mtd_unlock);
1586
1587 int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1588 {
1589         if (!mtd->_is_locked)
1590                 return -EOPNOTSUPP;
1591         if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)
1592                 return -EINVAL;
1593         if (!len)
1594                 return 0;
1595         return mtd->_is_locked(mtd, ofs, len);
1596 }
1597 EXPORT_SYMBOL_GPL(mtd_is_locked);
1598
1599 int mtd_block_isreserved(struct mtd_info *mtd, loff_t ofs)
1600 {
1601         if (ofs < 0 || ofs >= mtd->size)
1602                 return -EINVAL;
1603         if (!mtd->_block_isreserved)
1604                 return 0;
1605         return mtd->_block_isreserved(mtd, ofs);
1606 }
1607 EXPORT_SYMBOL_GPL(mtd_block_isreserved);
1608
1609 int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs)
1610 {
1611         if (ofs < 0 || ofs >= mtd->size)
1612                 return -EINVAL;
1613         if (!mtd->_block_isbad)
1614                 return 0;
1615         return mtd->_block_isbad(mtd, ofs);
1616 }
1617 EXPORT_SYMBOL_GPL(mtd_block_isbad);
1618
1619 int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs)
1620 {
1621         if (!mtd->_block_markbad)
1622                 return -EOPNOTSUPP;
1623         if (ofs < 0 || ofs >= mtd->size)
1624                 return -EINVAL;
1625         if (!(mtd->flags & MTD_WRITEABLE))
1626                 return -EROFS;
1627         return mtd->_block_markbad(mtd, ofs);
1628 }
1629 EXPORT_SYMBOL_GPL(mtd_block_markbad);
1630
1631 /*
1632  * default_mtd_writev - the default writev method
1633  * @mtd: mtd device description object pointer
1634  * @vecs: the vectors to write
1635  * @count: count of vectors in @vecs
1636  * @to: the MTD device offset to write to
1637  * @retlen: on exit contains the count of bytes written to the MTD device.
1638  *
1639  * This function returns zero in case of success and a negative error code in
1640  * case of failure.
1641  */
1642 static int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
1643                               unsigned long count, loff_t to, size_t *retlen)
1644 {
1645         unsigned long i;
1646         size_t totlen = 0, thislen;
1647         int ret = 0;
1648
1649         for (i = 0; i < count; i++) {
1650                 if (!vecs[i].iov_len)
1651                         continue;
1652                 ret = mtd_write(mtd, to, vecs[i].iov_len, &thislen,
1653                                 vecs[i].iov_base);
1654                 totlen += thislen;
1655                 if (ret || thislen != vecs[i].iov_len)
1656                         break;
1657                 to += vecs[i].iov_len;
1658         }
1659         *retlen = totlen;
1660         return ret;
1661 }
1662
1663 /*
1664  * mtd_writev - the vector-based MTD write method
1665  * @mtd: mtd device description object pointer
1666  * @vecs: the vectors to write
1667  * @count: count of vectors in @vecs
1668  * @to: the MTD device offset to write to
1669  * @retlen: on exit contains the count of bytes written to the MTD device.
1670  *
1671  * This function returns zero in case of success and a negative error code in
1672  * case of failure.
1673  */
1674 int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
1675                unsigned long count, loff_t to, size_t *retlen)
1676 {
1677         *retlen = 0;
1678         if (!(mtd->flags & MTD_WRITEABLE))
1679                 return -EROFS;
1680         if (!mtd->_writev)
1681                 return default_mtd_writev(mtd, vecs, count, to, retlen);
1682         return mtd->_writev(mtd, vecs, count, to, retlen);
1683 }
1684 EXPORT_SYMBOL_GPL(mtd_writev);
1685
1686 /**
1687  * mtd_kmalloc_up_to - allocate a contiguous buffer up to the specified size
1688  * @mtd: mtd device description object pointer
1689  * @size: a pointer to the ideal or maximum size of the allocation, points
1690  *        to the actual allocation size on success.
1691  *
1692  * This routine attempts to allocate a contiguous kernel buffer up to
1693  * the specified size, backing off the size of the request exponentially
1694  * until the request succeeds or until the allocation size falls below
1695  * the system page size. This attempts to make sure it does not adversely
1696  * impact system performance, so when allocating more than one page, we
1697  * ask the memory allocator to avoid re-trying, swapping, writing back
1698  * or performing I/O.
1699  *
1700  * Note, this function also makes sure that the allocated buffer is aligned to
1701  * the MTD device's min. I/O unit, i.e. the "mtd->writesize" value.
1702  *
1703  * This is called, for example by mtd_{read,write} and jffs2_scan_medium,
1704  * to handle smaller (i.e. degraded) buffer allocations under low- or
1705  * fragmented-memory situations where such reduced allocations, from a
1706  * requested ideal, are allowed.
1707  *
1708  * Returns a pointer to the allocated buffer on success; otherwise, NULL.
1709  */
1710 void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size)
1711 {
1712         gfp_t flags = __GFP_NOWARN | __GFP_DIRECT_RECLAIM | __GFP_NORETRY;
1713         size_t min_alloc = max_t(size_t, mtd->writesize, PAGE_SIZE);
1714         void *kbuf;
1715
1716         *size = min_t(size_t, *size, KMALLOC_MAX_SIZE);
1717
1718         while (*size > min_alloc) {
1719                 kbuf = kmalloc(*size, flags);
1720                 if (kbuf)
1721                         return kbuf;
1722
1723                 *size >>= 1;
1724                 *size = ALIGN(*size, mtd->writesize);
1725         }
1726
1727         /*
1728          * For the last resort allocation allow 'kmalloc()' to do all sorts of
1729          * things (write-back, dropping caches, etc) by using GFP_KERNEL.
1730          */
1731         return kmalloc(*size, GFP_KERNEL);
1732 }
1733 EXPORT_SYMBOL_GPL(mtd_kmalloc_up_to);
1734
1735 #ifdef CONFIG_PROC_FS
1736
1737 /*====================================================================*/
1738 /* Support for /proc/mtd */
1739
1740 static int mtd_proc_show(struct seq_file *m, void *v)
1741 {
1742         struct mtd_info *mtd;
1743
1744         seq_puts(m, "dev:    size   erasesize  name\n");
1745         mutex_lock(&mtd_table_mutex);
1746         mtd_for_each_device(mtd) {
1747                 seq_printf(m, "mtd%d: %8.8llx %8.8x \"%s\"\n",
1748                            mtd->index, (unsigned long long)mtd->size,
1749                            mtd->erasesize, mtd->name);
1750         }
1751         mutex_unlock(&mtd_table_mutex);
1752         return 0;
1753 }
1754
1755 static int mtd_proc_open(struct inode *inode, struct file *file)
1756 {
1757         return single_open(file, mtd_proc_show, NULL);
1758 }
1759
1760 static const struct file_operations mtd_proc_ops = {
1761         .open           = mtd_proc_open,
1762         .read           = seq_read,
1763         .llseek         = seq_lseek,
1764         .release        = single_release,
1765 };
1766 #endif /* CONFIG_PROC_FS */
1767
1768 /*====================================================================*/
1769 /* Init code */
1770
1771 static struct backing_dev_info * __init mtd_bdi_init(char *name)
1772 {
1773         struct backing_dev_info *bdi;
1774         int ret;
1775
1776         bdi = bdi_alloc(GFP_KERNEL);
1777         if (!bdi)
1778                 return ERR_PTR(-ENOMEM);
1779
1780         bdi->name = name;
1781         /*
1782          * We put '-0' suffix to the name to get the same name format as we
1783          * used to get. Since this is called only once, we get a unique name. 
1784          */
1785         ret = bdi_register(bdi, "%.28s-0", name);
1786         if (ret)
1787                 bdi_put(bdi);
1788
1789         return ret ? ERR_PTR(ret) : bdi;
1790 }
1791
1792 static struct proc_dir_entry *proc_mtd;
1793
1794 static int __init init_mtd(void)
1795 {
1796         int ret;
1797
1798         ret = class_register(&mtd_class);
1799         if (ret)
1800                 goto err_reg;
1801
1802         mtd_bdi = mtd_bdi_init("mtd");
1803         if (IS_ERR(mtd_bdi)) {
1804                 ret = PTR_ERR(mtd_bdi);
1805                 goto err_bdi;
1806         }
1807
1808         proc_mtd = proc_create("mtd", 0, NULL, &mtd_proc_ops);
1809
1810         ret = init_mtdchar();
1811         if (ret)
1812                 goto out_procfs;
1813
1814         return 0;
1815
1816 out_procfs:
1817         if (proc_mtd)
1818                 remove_proc_entry("mtd", NULL);
1819         bdi_put(mtd_bdi);
1820 err_bdi:
1821         class_unregister(&mtd_class);
1822 err_reg:
1823         pr_err("Error registering mtd class or bdi: %d\n", ret);
1824         return ret;
1825 }
1826
1827 static void __exit cleanup_mtd(void)
1828 {
1829         cleanup_mtdchar();
1830         if (proc_mtd)
1831                 remove_proc_entry("mtd", NULL);
1832         class_unregister(&mtd_class);
1833         bdi_put(mtd_bdi);
1834         idr_destroy(&mtd_idr);
1835 }
1836
1837 module_init(init_mtd);
1838 module_exit(cleanup_mtd);
1839
1840 MODULE_LICENSE("GPL");
1841 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
1842 MODULE_DESCRIPTION("Core MTD registration and access routines");