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