1
2
3
4
5
6
7
8
9
10#include <linux/module.h>
11#include <linux/kernel.h>
12#include <linux/ptrace.h>
13#include <linux/seq_file.h>
14#include <linux/string.h>
15#include <linux/timer.h>
16#include <linux/major.h>
17#include <linux/fs.h>
18#include <linux/err.h>
19#include <linux/ioctl.h>
20#include <linux/init.h>
21#include <linux/of.h>
22#include <linux/proc_fs.h>
23#include <linux/idr.h>
24#include <linux/backing-dev.h>
25#include <linux/gfp.h>
26#include <linux/slab.h>
27#include <linux/reboot.h>
28#include <linux/leds.h>
29#include <linux/debugfs.h>
30#include <linux/nvmem-provider.h>
31
32#include <linux/mtd/mtd.h>
33#include <linux/mtd/partitions.h>
34
35#include "mtdcore.h"
36
37struct backing_dev_info *mtd_bdi;
38
39#ifdef CONFIG_PM_SLEEP
40
41static int mtd_cls_suspend(struct device *dev)
42{
43 struct mtd_info *mtd = dev_get_drvdata(dev);
44
45 return mtd ? mtd_suspend(mtd) : 0;
46}
47
48static int mtd_cls_resume(struct device *dev)
49{
50 struct mtd_info *mtd = dev_get_drvdata(dev);
51
52 if (mtd)
53 mtd_resume(mtd);
54 return 0;
55}
56
57static SIMPLE_DEV_PM_OPS(mtd_cls_pm_ops, mtd_cls_suspend, mtd_cls_resume);
58#define MTD_CLS_PM_OPS (&mtd_cls_pm_ops)
59#else
60#define MTD_CLS_PM_OPS NULL
61#endif
62
63static struct class mtd_class = {
64 .name = "mtd",
65 .owner = THIS_MODULE,
66 .pm = MTD_CLS_PM_OPS,
67};
68
69static DEFINE_IDR(mtd_idr);
70
71
72
73DEFINE_MUTEX(mtd_table_mutex);
74EXPORT_SYMBOL_GPL(mtd_table_mutex);
75
76struct mtd_info *__mtd_next_device(int i)
77{
78 return idr_get_next(&mtd_idr, &i);
79}
80EXPORT_SYMBOL_GPL(__mtd_next_device);
81
82static LIST_HEAD(mtd_notifiers);
83
84
85#define MTD_DEVT(index) MKDEV(MTD_CHAR_MAJOR, (index)*2)
86
87
88
89
90static void mtd_release(struct device *dev)
91{
92 struct mtd_info *mtd = dev_get_drvdata(dev);
93 dev_t index = MTD_DEVT(mtd->index);
94
95
96 device_destroy(&mtd_class, index + 1);
97}
98
99static ssize_t mtd_type_show(struct device *dev,
100 struct device_attribute *attr, char *buf)
101{
102 struct mtd_info *mtd = dev_get_drvdata(dev);
103 char *type;
104
105 switch (mtd->type) {
106 case MTD_ABSENT:
107 type = "absent";
108 break;
109 case MTD_RAM:
110 type = "ram";
111 break;
112 case MTD_ROM:
113 type = "rom";
114 break;
115 case MTD_NORFLASH:
116 type = "nor";
117 break;
118 case MTD_NANDFLASH:
119 type = "nand";
120 break;
121 case MTD_DATAFLASH:
122 type = "dataflash";
123 break;
124 case MTD_UBIVOLUME:
125 type = "ubi";
126 break;
127 case MTD_MLCNANDFLASH:
128 type = "mlc-nand";
129 break;
130 default:
131 type = "unknown";
132 }
133
134 return snprintf(buf, PAGE_SIZE, "%s\n", type);
135}
136static DEVICE_ATTR(type, S_IRUGO, mtd_type_show, NULL);
137
138static ssize_t mtd_flags_show(struct device *dev,
139 struct device_attribute *attr, char *buf)
140{
141 struct mtd_info *mtd = dev_get_drvdata(dev);
142
143 return snprintf(buf, PAGE_SIZE, "0x%lx\n", (unsigned long)mtd->flags);
144}
145static DEVICE_ATTR(flags, S_IRUGO, mtd_flags_show, NULL);
146
147static ssize_t mtd_size_show(struct device *dev,
148 struct device_attribute *attr, char *buf)
149{
150 struct mtd_info *mtd = dev_get_drvdata(dev);
151
152 return snprintf(buf, PAGE_SIZE, "%llu\n",
153 (unsigned long long)mtd->size);
154}
155static DEVICE_ATTR(size, S_IRUGO, mtd_size_show, NULL);
156
157static ssize_t mtd_erasesize_show(struct device *dev,
158 struct device_attribute *attr, char *buf)
159{
160 struct mtd_info *mtd = dev_get_drvdata(dev);
161
162 return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->erasesize);
163}
164static DEVICE_ATTR(erasesize, S_IRUGO, mtd_erasesize_show, NULL);
165
166static ssize_t mtd_writesize_show(struct device *dev,
167 struct device_attribute *attr, char *buf)
168{
169 struct mtd_info *mtd = dev_get_drvdata(dev);
170
171 return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->writesize);
172}
173static DEVICE_ATTR(writesize, S_IRUGO, mtd_writesize_show, NULL);
174
175static ssize_t mtd_subpagesize_show(struct device *dev,
176 struct device_attribute *attr, char *buf)
177{
178 struct mtd_info *mtd = dev_get_drvdata(dev);
179 unsigned int subpagesize = mtd->writesize >> mtd->subpage_sft;
180
181 return snprintf(buf, PAGE_SIZE, "%u\n", subpagesize);
182}
183static DEVICE_ATTR(subpagesize, S_IRUGO, mtd_subpagesize_show, NULL);
184
185static ssize_t mtd_oobsize_show(struct device *dev,
186 struct device_attribute *attr, char *buf)
187{
188 struct mtd_info *mtd = dev_get_drvdata(dev);
189
190 return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->oobsize);
191}
192static DEVICE_ATTR(oobsize, S_IRUGO, mtd_oobsize_show, NULL);
193
194static ssize_t mtd_oobavail_show(struct device *dev,
195 struct device_attribute *attr, char *buf)
196{
197 struct mtd_info *mtd = dev_get_drvdata(dev);
198
199 return snprintf(buf, PAGE_SIZE, "%u\n", mtd->oobavail);
200}
201static DEVICE_ATTR(oobavail, S_IRUGO, mtd_oobavail_show, NULL);
202
203static ssize_t mtd_numeraseregions_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, "%u\n", mtd->numeraseregions);
209}
210static DEVICE_ATTR(numeraseregions, S_IRUGO, mtd_numeraseregions_show,
211 NULL);
212
213static ssize_t mtd_name_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, "%s\n", mtd->name);
219}
220static DEVICE_ATTR(name, S_IRUGO, mtd_name_show, NULL);
221
222static ssize_t mtd_ecc_strength_show(struct device *dev,
223 struct device_attribute *attr, char *buf)
224{
225 struct mtd_info *mtd = dev_get_drvdata(dev);
226
227 return snprintf(buf, PAGE_SIZE, "%u\n", mtd->ecc_strength);
228}
229static DEVICE_ATTR(ecc_strength, S_IRUGO, mtd_ecc_strength_show, NULL);
230
231static ssize_t mtd_bitflip_threshold_show(struct device *dev,
232 struct device_attribute *attr,
233 char *buf)
234{
235 struct mtd_info *mtd = dev_get_drvdata(dev);
236
237 return snprintf(buf, PAGE_SIZE, "%u\n", mtd->bitflip_threshold);
238}
239
240static ssize_t mtd_bitflip_threshold_store(struct device *dev,
241 struct device_attribute *attr,
242 const char *buf, size_t count)
243{
244 struct mtd_info *mtd = dev_get_drvdata(dev);
245 unsigned int bitflip_threshold;
246 int retval;
247
248 retval = kstrtouint(buf, 0, &bitflip_threshold);
249 if (retval)
250 return retval;
251
252 mtd->bitflip_threshold = bitflip_threshold;
253 return count;
254}
255static DEVICE_ATTR(bitflip_threshold, S_IRUGO | S_IWUSR,
256 mtd_bitflip_threshold_show,
257 mtd_bitflip_threshold_store);
258
259static ssize_t mtd_ecc_step_size_show(struct device *dev,
260 struct device_attribute *attr, char *buf)
261{
262 struct mtd_info *mtd = dev_get_drvdata(dev);
263
264 return snprintf(buf, PAGE_SIZE, "%u\n", mtd->ecc_step_size);
265
266}
267static DEVICE_ATTR(ecc_step_size, S_IRUGO, mtd_ecc_step_size_show, NULL);
268
269static ssize_t mtd_ecc_stats_corrected_show(struct device *dev,
270 struct device_attribute *attr, char *buf)
271{
272 struct mtd_info *mtd = dev_get_drvdata(dev);
273 struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
274
275 return snprintf(buf, PAGE_SIZE, "%u\n", ecc_stats->corrected);
276}
277static DEVICE_ATTR(corrected_bits, S_IRUGO,
278 mtd_ecc_stats_corrected_show, NULL);
279
280static ssize_t mtd_ecc_stats_errors_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->failed);
287}
288static DEVICE_ATTR(ecc_failures, S_IRUGO, mtd_ecc_stats_errors_show, NULL);
289
290static ssize_t mtd_badblocks_show(struct device *dev,
291 struct device_attribute *attr, char *buf)
292{
293 struct mtd_info *mtd = dev_get_drvdata(dev);
294 struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
295
296 return snprintf(buf, PAGE_SIZE, "%u\n", ecc_stats->badblocks);
297}
298static DEVICE_ATTR(bad_blocks, S_IRUGO, mtd_badblocks_show, NULL);
299
300static ssize_t mtd_bbtblocks_show(struct device *dev,
301 struct device_attribute *attr, char *buf)
302{
303 struct mtd_info *mtd = dev_get_drvdata(dev);
304 struct mtd_ecc_stats *ecc_stats = &mtd->ecc_stats;
305
306 return snprintf(buf, PAGE_SIZE, "%u\n", ecc_stats->bbtblocks);
307}
308static DEVICE_ATTR(bbt_blocks, S_IRUGO, mtd_bbtblocks_show, NULL);
309
310static struct attribute *mtd_attrs[] = {
311 &dev_attr_type.attr,
312 &dev_attr_flags.attr,
313 &dev_attr_size.attr,
314 &dev_attr_erasesize.attr,
315 &dev_attr_writesize.attr,
316 &dev_attr_subpagesize.attr,
317 &dev_attr_oobsize.attr,
318 &dev_attr_oobavail.attr,
319 &dev_attr_numeraseregions.attr,
320 &dev_attr_name.attr,
321 &dev_attr_ecc_strength.attr,
322 &dev_attr_ecc_step_size.attr,
323 &dev_attr_corrected_bits.attr,
324 &dev_attr_ecc_failures.attr,
325 &dev_attr_bad_blocks.attr,
326 &dev_attr_bbt_blocks.attr,
327 &dev_attr_bitflip_threshold.attr,
328 NULL,
329};
330ATTRIBUTE_GROUPS(mtd);
331
332static const struct device_type mtd_devtype = {
333 .name = "mtd",
334 .groups = mtd_groups,
335 .release = mtd_release,
336};
337
338static int mtd_partid_show(struct seq_file *s, void *p)
339{
340 struct mtd_info *mtd = s->private;
341
342 seq_printf(s, "%s\n", mtd->dbg.partid);
343
344 return 0;
345}
346
347static int mtd_partid_debugfs_open(struct inode *inode, struct file *file)
348{
349 return single_open(file, mtd_partid_show, inode->i_private);
350}
351
352static const struct file_operations mtd_partid_debug_fops = {
353 .open = mtd_partid_debugfs_open,
354 .read = seq_read,
355 .llseek = seq_lseek,
356 .release = single_release,
357};
358
359static int mtd_partname_show(struct seq_file *s, void *p)
360{
361 struct mtd_info *mtd = s->private;
362
363 seq_printf(s, "%s\n", mtd->dbg.partname);
364
365 return 0;
366}
367
368static int mtd_partname_debugfs_open(struct inode *inode, struct file *file)
369{
370 return single_open(file, mtd_partname_show, inode->i_private);
371}
372
373static const struct file_operations mtd_partname_debug_fops = {
374 .open = mtd_partname_debugfs_open,
375 .read = seq_read,
376 .llseek = seq_lseek,
377 .release = single_release,
378};
379
380static struct dentry *dfs_dir_mtd;
381
382static void mtd_debugfs_populate(struct mtd_info *mtd)
383{
384 struct device *dev = &mtd->dev;
385 struct dentry *root;
386
387 if (IS_ERR_OR_NULL(dfs_dir_mtd))
388 return;
389
390 root = debugfs_create_dir(dev_name(dev), dfs_dir_mtd);
391 mtd->dbg.dfs_dir = root;
392
393 if (mtd->dbg.partid)
394 debugfs_create_file("partid", 0400, root, mtd,
395 &mtd_partid_debug_fops);
396
397 if (mtd->dbg.partname)
398 debugfs_create_file("partname", 0400, root, mtd,
399 &mtd_partname_debug_fops);
400}
401
402#ifndef CONFIG_MMU
403unsigned mtd_mmap_capabilities(struct mtd_info *mtd)
404{
405 switch (mtd->type) {
406 case MTD_RAM:
407 return NOMMU_MAP_COPY | NOMMU_MAP_DIRECT | NOMMU_MAP_EXEC |
408 NOMMU_MAP_READ | NOMMU_MAP_WRITE;
409 case MTD_ROM:
410 return NOMMU_MAP_COPY | NOMMU_MAP_DIRECT | NOMMU_MAP_EXEC |
411 NOMMU_MAP_READ;
412 default:
413 return NOMMU_MAP_COPY;
414 }
415}
416EXPORT_SYMBOL_GPL(mtd_mmap_capabilities);
417#endif
418
419static int mtd_reboot_notifier(struct notifier_block *n, unsigned long state,
420 void *cmd)
421{
422 struct mtd_info *mtd;
423
424 mtd = container_of(n, struct mtd_info, reboot_notifier);
425 mtd->_reboot(mtd);
426
427 return NOTIFY_DONE;
428}
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456int mtd_wunit_to_pairing_info(struct mtd_info *mtd, int wunit,
457 struct mtd_pairing_info *info)
458{
459 struct mtd_info *master = mtd_get_master(mtd);
460 int npairs = mtd_wunit_per_eb(master) / mtd_pairing_groups(master);
461
462 if (wunit < 0 || wunit >= npairs)
463 return -EINVAL;
464
465 if (master->pairing && master->pairing->get_info)
466 return master->pairing->get_info(master, wunit, info);
467
468 info->group = 0;
469 info->pair = wunit;
470
471 return 0;
472}
473EXPORT_SYMBOL_GPL(mtd_wunit_to_pairing_info);
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499int mtd_pairing_info_to_wunit(struct mtd_info *mtd,
500 const struct mtd_pairing_info *info)
501{
502 struct mtd_info *master = mtd_get_master(mtd);
503 int ngroups = mtd_pairing_groups(master);
504 int npairs = mtd_wunit_per_eb(master) / ngroups;
505
506 if (!info || info->pair < 0 || info->pair >= npairs ||
507 info->group < 0 || info->group >= ngroups)
508 return -EINVAL;
509
510 if (master->pairing && master->pairing->get_wunit)
511 return mtd->pairing->get_wunit(master, info);
512
513 return info->pair;
514}
515EXPORT_SYMBOL_GPL(mtd_pairing_info_to_wunit);
516
517
518
519
520
521
522
523
524
525
526
527int mtd_pairing_groups(struct mtd_info *mtd)
528{
529 struct mtd_info *master = mtd_get_master(mtd);
530
531 if (!master->pairing || !master->pairing->ngroups)
532 return 1;
533
534 return master->pairing->ngroups;
535}
536EXPORT_SYMBOL_GPL(mtd_pairing_groups);
537
538static int mtd_nvmem_reg_read(void *priv, unsigned int offset,
539 void *val, size_t bytes)
540{
541 struct mtd_info *mtd = priv;
542 size_t retlen;
543 int err;
544
545 err = mtd_read(mtd, offset, bytes, &retlen, val);
546 if (err && err != -EUCLEAN)
547 return err;
548
549 return retlen == bytes ? 0 : -EIO;
550}
551
552static int mtd_nvmem_add(struct mtd_info *mtd)
553{
554 struct nvmem_config config = {};
555
556 config.id = -1;
557 config.dev = &mtd->dev;
558 config.name = dev_name(&mtd->dev);
559 config.owner = THIS_MODULE;
560 config.reg_read = mtd_nvmem_reg_read;
561 config.size = mtd->size;
562 config.word_size = 1;
563 config.stride = 1;
564 config.read_only = true;
565 config.root_only = true;
566 config.no_of_node = true;
567 config.priv = mtd;
568
569 mtd->nvmem = nvmem_register(&config);
570 if (IS_ERR(mtd->nvmem)) {
571
572 if (PTR_ERR(mtd->nvmem) == -EOPNOTSUPP) {
573 mtd->nvmem = NULL;
574 } else {
575 dev_err(&mtd->dev, "Failed to register NVMEM device\n");
576 return PTR_ERR(mtd->nvmem);
577 }
578 }
579
580 return 0;
581}
582
583
584
585
586
587
588
589
590
591
592int add_mtd_device(struct mtd_info *mtd)
593{
594 struct mtd_info *master = mtd_get_master(mtd);
595 struct mtd_notifier *not;
596 int i, error;
597
598
599
600
601
602
603 if (WARN_ONCE(mtd->dev.type, "MTD already registered\n"))
604 return -EEXIST;
605
606 BUG_ON(mtd->writesize == 0);
607
608
609
610
611
612 if (WARN_ON((mtd->_write && mtd->_write_oob) ||
613 (mtd->_read && mtd->_read_oob)))
614 return -EINVAL;
615
616 if (WARN_ON((!mtd->erasesize || !master->_erase) &&
617 !(mtd->flags & MTD_NO_ERASE)))
618 return -EINVAL;
619
620
621
622
623
624
625
626
627
628 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION &&
629 (!mtd_is_partition(mtd) || master->type != MTD_MLCNANDFLASH ||
630 !master->pairing || master->_writev))
631 return -EINVAL;
632
633 mutex_lock(&mtd_table_mutex);
634
635 i = idr_alloc(&mtd_idr, mtd, 0, 0, GFP_KERNEL);
636 if (i < 0) {
637 error = i;
638 goto fail_locked;
639 }
640
641 mtd->index = i;
642 mtd->usecount = 0;
643
644
645 if (mtd->bitflip_threshold == 0)
646 mtd->bitflip_threshold = mtd->ecc_strength;
647
648 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
649 int ngroups = mtd_pairing_groups(master);
650
651 mtd->erasesize /= ngroups;
652 mtd->size = (u64)mtd_div_by_eb(mtd->size, master) *
653 mtd->erasesize;
654 }
655
656 if (is_power_of_2(mtd->erasesize))
657 mtd->erasesize_shift = ffs(mtd->erasesize) - 1;
658 else
659 mtd->erasesize_shift = 0;
660
661 if (is_power_of_2(mtd->writesize))
662 mtd->writesize_shift = ffs(mtd->writesize) - 1;
663 else
664 mtd->writesize_shift = 0;
665
666 mtd->erasesize_mask = (1 << mtd->erasesize_shift) - 1;
667 mtd->writesize_mask = (1 << mtd->writesize_shift) - 1;
668
669
670 if ((mtd->flags & MTD_WRITEABLE) && (mtd->flags & MTD_POWERUP_LOCK)) {
671 error = mtd_unlock(mtd, 0, mtd->size);
672 if (error && error != -EOPNOTSUPP)
673 printk(KERN_WARNING
674 "%s: unlock failed, writes may not work\n",
675 mtd->name);
676
677 error = 0;
678 }
679
680
681
682
683 mtd->dev.type = &mtd_devtype;
684 mtd->dev.class = &mtd_class;
685 mtd->dev.devt = MTD_DEVT(i);
686 dev_set_name(&mtd->dev, "mtd%d", i);
687 dev_set_drvdata(&mtd->dev, mtd);
688 of_node_get(mtd_get_of_node(mtd));
689 error = device_register(&mtd->dev);
690 if (error)
691 goto fail_added;
692
693
694 error = mtd_nvmem_add(mtd);
695 if (error)
696 goto fail_nvmem_add;
697
698 mtd_debugfs_populate(mtd);
699
700 device_create(&mtd_class, mtd->dev.parent, MTD_DEVT(i) + 1, NULL,
701 "mtd%dro", i);
702
703 pr_debug("mtd: Giving out device %d to %s\n", i, mtd->name);
704
705
706 list_for_each_entry(not, &mtd_notifiers, list)
707 not->add(mtd);
708
709 mutex_unlock(&mtd_table_mutex);
710
711
712
713
714 __module_get(THIS_MODULE);
715 return 0;
716
717fail_nvmem_add:
718 device_unregister(&mtd->dev);
719fail_added:
720 of_node_put(mtd_get_of_node(mtd));
721 idr_remove(&mtd_idr, i);
722fail_locked:
723 mutex_unlock(&mtd_table_mutex);
724 return error;
725}
726
727
728
729
730
731
732
733
734
735
736
737int del_mtd_device(struct mtd_info *mtd)
738{
739 int ret;
740 struct mtd_notifier *not;
741
742 mutex_lock(&mtd_table_mutex);
743
744 debugfs_remove_recursive(mtd->dbg.dfs_dir);
745
746 if (idr_find(&mtd_idr, mtd->index) != mtd) {
747 ret = -ENODEV;
748 goto out_error;
749 }
750
751
752
753 list_for_each_entry(not, &mtd_notifiers, list)
754 not->remove(mtd);
755
756 if (mtd->usecount) {
757 printk(KERN_NOTICE "Removing MTD device #%d (%s) with use count %d\n",
758 mtd->index, mtd->name, mtd->usecount);
759 ret = -EBUSY;
760 } else {
761
762 if (mtd->nvmem)
763 nvmem_unregister(mtd->nvmem);
764
765 device_unregister(&mtd->dev);
766
767 idr_remove(&mtd_idr, mtd->index);
768 of_node_put(mtd_get_of_node(mtd));
769
770 module_put(THIS_MODULE);
771 ret = 0;
772 }
773
774out_error:
775 mutex_unlock(&mtd_table_mutex);
776 return ret;
777}
778
779
780
781
782
783static void mtd_set_dev_defaults(struct mtd_info *mtd)
784{
785 if (mtd->dev.parent) {
786 if (!mtd->owner && mtd->dev.parent->driver)
787 mtd->owner = mtd->dev.parent->driver->owner;
788 if (!mtd->name)
789 mtd->name = dev_name(mtd->dev.parent);
790 } else {
791 pr_debug("mtd device won't show a device symlink in sysfs\n");
792 }
793
794 INIT_LIST_HEAD(&mtd->partitions);
795 mutex_init(&mtd->master.partitions_lock);
796}
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826int mtd_device_parse_register(struct mtd_info *mtd, const char * const *types,
827 struct mtd_part_parser_data *parser_data,
828 const struct mtd_partition *parts,
829 int nr_parts)
830{
831 int ret;
832
833 mtd_set_dev_defaults(mtd);
834
835 if (IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER)) {
836 ret = add_mtd_device(mtd);
837 if (ret)
838 return ret;
839 }
840
841
842 ret = parse_mtd_partitions(mtd, types, parser_data);
843 if (ret > 0)
844 ret = 0;
845 else if (nr_parts)
846 ret = add_mtd_partitions(mtd, parts, nr_parts);
847 else if (!device_is_registered(&mtd->dev))
848 ret = add_mtd_device(mtd);
849 else
850 ret = 0;
851
852 if (ret)
853 goto out;
854
855
856
857
858
859
860
861
862
863 WARN_ONCE(mtd->_reboot && mtd->reboot_notifier.notifier_call,
864 "MTD already registered\n");
865 if (mtd->_reboot && !mtd->reboot_notifier.notifier_call) {
866 mtd->reboot_notifier.notifier_call = mtd_reboot_notifier;
867 register_reboot_notifier(&mtd->reboot_notifier);
868 }
869
870out:
871 if (ret && device_is_registered(&mtd->dev))
872 del_mtd_device(mtd);
873
874 return ret;
875}
876EXPORT_SYMBOL_GPL(mtd_device_parse_register);
877
878
879
880
881
882
883
884int mtd_device_unregister(struct mtd_info *master)
885{
886 int err;
887
888 if (master->_reboot)
889 unregister_reboot_notifier(&master->reboot_notifier);
890
891 err = del_mtd_partitions(master);
892 if (err)
893 return err;
894
895 if (!device_is_registered(&master->dev))
896 return 0;
897
898 return del_mtd_device(master);
899}
900EXPORT_SYMBOL_GPL(mtd_device_unregister);
901
902
903
904
905
906
907
908
909
910void register_mtd_user (struct mtd_notifier *new)
911{
912 struct mtd_info *mtd;
913
914 mutex_lock(&mtd_table_mutex);
915
916 list_add(&new->list, &mtd_notifiers);
917
918 __module_get(THIS_MODULE);
919
920 mtd_for_each_device(mtd)
921 new->add(mtd);
922
923 mutex_unlock(&mtd_table_mutex);
924}
925EXPORT_SYMBOL_GPL(register_mtd_user);
926
927
928
929
930
931
932
933
934
935
936int unregister_mtd_user (struct mtd_notifier *old)
937{
938 struct mtd_info *mtd;
939
940 mutex_lock(&mtd_table_mutex);
941
942 module_put(THIS_MODULE);
943
944 mtd_for_each_device(mtd)
945 old->remove(mtd);
946
947 list_del(&old->list);
948 mutex_unlock(&mtd_table_mutex);
949 return 0;
950}
951EXPORT_SYMBOL_GPL(unregister_mtd_user);
952
953
954
955
956
957
958
959
960
961
962
963
964struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num)
965{
966 struct mtd_info *ret = NULL, *other;
967 int err = -ENODEV;
968
969 mutex_lock(&mtd_table_mutex);
970
971 if (num == -1) {
972 mtd_for_each_device(other) {
973 if (other == mtd) {
974 ret = mtd;
975 break;
976 }
977 }
978 } else if (num >= 0) {
979 ret = idr_find(&mtd_idr, num);
980 if (mtd && mtd != ret)
981 ret = NULL;
982 }
983
984 if (!ret) {
985 ret = ERR_PTR(err);
986 goto out;
987 }
988
989 err = __get_mtd_device(ret);
990 if (err)
991 ret = ERR_PTR(err);
992out:
993 mutex_unlock(&mtd_table_mutex);
994 return ret;
995}
996EXPORT_SYMBOL_GPL(get_mtd_device);
997
998
999int __get_mtd_device(struct mtd_info *mtd)
1000{
1001 struct mtd_info *master = mtd_get_master(mtd);
1002 int err;
1003
1004 if (!try_module_get(master->owner))
1005 return -ENODEV;
1006
1007 if (master->_get_device) {
1008 err = master->_get_device(mtd);
1009
1010 if (err) {
1011 module_put(master->owner);
1012 return err;
1013 }
1014 }
1015
1016 while (mtd->parent) {
1017 mtd->usecount++;
1018 mtd = mtd->parent;
1019 }
1020
1021 return 0;
1022}
1023EXPORT_SYMBOL_GPL(__get_mtd_device);
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033struct mtd_info *get_mtd_device_nm(const char *name)
1034{
1035 int err = -ENODEV;
1036 struct mtd_info *mtd = NULL, *other;
1037
1038 mutex_lock(&mtd_table_mutex);
1039
1040 mtd_for_each_device(other) {
1041 if (!strcmp(name, other->name)) {
1042 mtd = other;
1043 break;
1044 }
1045 }
1046
1047 if (!mtd)
1048 goto out_unlock;
1049
1050 err = __get_mtd_device(mtd);
1051 if (err)
1052 goto out_unlock;
1053
1054 mutex_unlock(&mtd_table_mutex);
1055 return mtd;
1056
1057out_unlock:
1058 mutex_unlock(&mtd_table_mutex);
1059 return ERR_PTR(err);
1060}
1061EXPORT_SYMBOL_GPL(get_mtd_device_nm);
1062
1063void put_mtd_device(struct mtd_info *mtd)
1064{
1065 mutex_lock(&mtd_table_mutex);
1066 __put_mtd_device(mtd);
1067 mutex_unlock(&mtd_table_mutex);
1068
1069}
1070EXPORT_SYMBOL_GPL(put_mtd_device);
1071
1072void __put_mtd_device(struct mtd_info *mtd)
1073{
1074 struct mtd_info *master = mtd_get_master(mtd);
1075
1076 while (mtd->parent) {
1077 --mtd->usecount;
1078 BUG_ON(mtd->usecount < 0);
1079 mtd = mtd->parent;
1080 }
1081
1082 if (master->_put_device)
1083 master->_put_device(master);
1084
1085 module_put(master->owner);
1086}
1087EXPORT_SYMBOL_GPL(__put_mtd_device);
1088
1089
1090
1091
1092
1093
1094int mtd_erase(struct mtd_info *mtd, struct erase_info *instr)
1095{
1096 struct mtd_info *master = mtd_get_master(mtd);
1097 u64 mst_ofs = mtd_get_master_ofs(mtd, 0);
1098 struct erase_info adjinstr;
1099 int ret;
1100
1101 instr->fail_addr = MTD_FAIL_ADDR_UNKNOWN;
1102 adjinstr = *instr;
1103
1104 if (!mtd->erasesize || !master->_erase)
1105 return -ENOTSUPP;
1106
1107 if (instr->addr >= mtd->size || instr->len > mtd->size - instr->addr)
1108 return -EINVAL;
1109 if (!(mtd->flags & MTD_WRITEABLE))
1110 return -EROFS;
1111
1112 if (!instr->len)
1113 return 0;
1114
1115 ledtrig_mtd_activity();
1116
1117 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
1118 adjinstr.addr = (loff_t)mtd_div_by_eb(instr->addr, mtd) *
1119 master->erasesize;
1120 adjinstr.len = ((u64)mtd_div_by_eb(instr->addr + instr->len, mtd) *
1121 master->erasesize) -
1122 adjinstr.addr;
1123 }
1124
1125 adjinstr.addr += mst_ofs;
1126
1127 ret = master->_erase(master, &adjinstr);
1128
1129 if (adjinstr.fail_addr != MTD_FAIL_ADDR_UNKNOWN) {
1130 instr->fail_addr = adjinstr.fail_addr - mst_ofs;
1131 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
1132 instr->fail_addr = mtd_div_by_eb(instr->fail_addr,
1133 master);
1134 instr->fail_addr *= mtd->erasesize;
1135 }
1136 }
1137
1138 return ret;
1139}
1140EXPORT_SYMBOL_GPL(mtd_erase);
1141
1142
1143
1144
1145int mtd_point(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,
1146 void **virt, resource_size_t *phys)
1147{
1148 struct mtd_info *master = mtd_get_master(mtd);
1149
1150 *retlen = 0;
1151 *virt = NULL;
1152 if (phys)
1153 *phys = 0;
1154 if (!master->_point)
1155 return -EOPNOTSUPP;
1156 if (from < 0 || from >= mtd->size || len > mtd->size - from)
1157 return -EINVAL;
1158 if (!len)
1159 return 0;
1160
1161 from = mtd_get_master_ofs(mtd, from);
1162 return master->_point(master, from, len, retlen, virt, phys);
1163}
1164EXPORT_SYMBOL_GPL(mtd_point);
1165
1166
1167int mtd_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
1168{
1169 struct mtd_info *master = mtd_get_master(mtd);
1170
1171 if (!master->_unpoint)
1172 return -EOPNOTSUPP;
1173 if (from < 0 || from >= mtd->size || len > mtd->size - from)
1174 return -EINVAL;
1175 if (!len)
1176 return 0;
1177 return master->_unpoint(master, mtd_get_master_ofs(mtd, from), len);
1178}
1179EXPORT_SYMBOL_GPL(mtd_unpoint);
1180
1181
1182
1183
1184
1185
1186unsigned long mtd_get_unmapped_area(struct mtd_info *mtd, unsigned long len,
1187 unsigned long offset, unsigned long flags)
1188{
1189 size_t retlen;
1190 void *virt;
1191 int ret;
1192
1193 ret = mtd_point(mtd, offset, len, &retlen, &virt, NULL);
1194 if (ret)
1195 return ret;
1196 if (retlen != len) {
1197 mtd_unpoint(mtd, offset, retlen);
1198 return -ENOSYS;
1199 }
1200 return (unsigned long)virt;
1201}
1202EXPORT_SYMBOL_GPL(mtd_get_unmapped_area);
1203
1204static void mtd_update_ecc_stats(struct mtd_info *mtd, struct mtd_info *master,
1205 const struct mtd_ecc_stats *old_stats)
1206{
1207 struct mtd_ecc_stats diff;
1208
1209 if (master == mtd)
1210 return;
1211
1212 diff = master->ecc_stats;
1213 diff.failed -= old_stats->failed;
1214 diff.corrected -= old_stats->corrected;
1215
1216 while (mtd->parent) {
1217 mtd->ecc_stats.failed += diff.failed;
1218 mtd->ecc_stats.corrected += diff.corrected;
1219 mtd = mtd->parent;
1220 }
1221}
1222
1223int mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen,
1224 u_char *buf)
1225{
1226 struct mtd_oob_ops ops = {
1227 .len = len,
1228 .datbuf = buf,
1229 };
1230 int ret;
1231
1232 ret = mtd_read_oob(mtd, from, &ops);
1233 *retlen = ops.retlen;
1234
1235 return ret;
1236}
1237EXPORT_SYMBOL_GPL(mtd_read);
1238
1239int mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
1240 const u_char *buf)
1241{
1242 struct mtd_oob_ops ops = {
1243 .len = len,
1244 .datbuf = (u8 *)buf,
1245 };
1246 int ret;
1247
1248 ret = mtd_write_oob(mtd, to, &ops);
1249 *retlen = ops.retlen;
1250
1251 return ret;
1252}
1253EXPORT_SYMBOL_GPL(mtd_write);
1254
1255
1256
1257
1258
1259
1260
1261
1262int mtd_panic_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen,
1263 const u_char *buf)
1264{
1265 struct mtd_info *master = mtd_get_master(mtd);
1266
1267 *retlen = 0;
1268 if (!master->_panic_write)
1269 return -EOPNOTSUPP;
1270 if (to < 0 || to >= mtd->size || len > mtd->size - to)
1271 return -EINVAL;
1272 if (!(mtd->flags & MTD_WRITEABLE))
1273 return -EROFS;
1274 if (!len)
1275 return 0;
1276 if (!master->oops_panic_write)
1277 master->oops_panic_write = true;
1278
1279 return master->_panic_write(master, mtd_get_master_ofs(mtd, to), len,
1280 retlen, buf);
1281}
1282EXPORT_SYMBOL_GPL(mtd_panic_write);
1283
1284static int mtd_check_oob_ops(struct mtd_info *mtd, loff_t offs,
1285 struct mtd_oob_ops *ops)
1286{
1287
1288
1289
1290
1291
1292 if (!ops->datbuf)
1293 ops->len = 0;
1294
1295 if (!ops->oobbuf)
1296 ops->ooblen = 0;
1297
1298 if (offs < 0 || offs + ops->len > mtd->size)
1299 return -EINVAL;
1300
1301 if (ops->ooblen) {
1302 size_t maxooblen;
1303
1304 if (ops->ooboffs >= mtd_oobavail(mtd, ops))
1305 return -EINVAL;
1306
1307 maxooblen = ((size_t)(mtd_div_by_ws(mtd->size, mtd) -
1308 mtd_div_by_ws(offs, mtd)) *
1309 mtd_oobavail(mtd, ops)) - ops->ooboffs;
1310 if (ops->ooblen > maxooblen)
1311 return -EINVAL;
1312 }
1313
1314 return 0;
1315}
1316
1317static int mtd_read_oob_std(struct mtd_info *mtd, loff_t from,
1318 struct mtd_oob_ops *ops)
1319{
1320 struct mtd_info *master = mtd_get_master(mtd);
1321 int ret;
1322
1323 from = mtd_get_master_ofs(mtd, from);
1324 if (master->_read_oob)
1325 ret = master->_read_oob(master, from, ops);
1326 else
1327 ret = master->_read(master, from, ops->len, &ops->retlen,
1328 ops->datbuf);
1329
1330 return ret;
1331}
1332
1333static int mtd_write_oob_std(struct mtd_info *mtd, loff_t to,
1334 struct mtd_oob_ops *ops)
1335{
1336 struct mtd_info *master = mtd_get_master(mtd);
1337 int ret;
1338
1339 to = mtd_get_master_ofs(mtd, to);
1340 if (master->_write_oob)
1341 ret = master->_write_oob(master, to, ops);
1342 else
1343 ret = master->_write(master, to, ops->len, &ops->retlen,
1344 ops->datbuf);
1345
1346 return ret;
1347}
1348
1349static int mtd_io_emulated_slc(struct mtd_info *mtd, loff_t start, bool read,
1350 struct mtd_oob_ops *ops)
1351{
1352 struct mtd_info *master = mtd_get_master(mtd);
1353 int ngroups = mtd_pairing_groups(master);
1354 int npairs = mtd_wunit_per_eb(master) / ngroups;
1355 struct mtd_oob_ops adjops = *ops;
1356 unsigned int wunit, oobavail;
1357 struct mtd_pairing_info info;
1358 int max_bitflips = 0;
1359 u32 ebofs, pageofs;
1360 loff_t base, pos;
1361
1362 ebofs = mtd_mod_by_eb(start, mtd);
1363 base = (loff_t)mtd_div_by_eb(start, mtd) * master->erasesize;
1364 info.group = 0;
1365 info.pair = mtd_div_by_ws(ebofs, mtd);
1366 pageofs = mtd_mod_by_ws(ebofs, mtd);
1367 oobavail = mtd_oobavail(mtd, ops);
1368
1369 while (ops->retlen < ops->len || ops->oobretlen < ops->ooblen) {
1370 int ret;
1371
1372 if (info.pair >= npairs) {
1373 info.pair = 0;
1374 base += master->erasesize;
1375 }
1376
1377 wunit = mtd_pairing_info_to_wunit(master, &info);
1378 pos = mtd_wunit_to_offset(mtd, base, wunit);
1379
1380 adjops.len = ops->len - ops->retlen;
1381 if (adjops.len > mtd->writesize - pageofs)
1382 adjops.len = mtd->writesize - pageofs;
1383
1384 adjops.ooblen = ops->ooblen - ops->oobretlen;
1385 if (adjops.ooblen > oobavail - adjops.ooboffs)
1386 adjops.ooblen = oobavail - adjops.ooboffs;
1387
1388 if (read) {
1389 ret = mtd_read_oob_std(mtd, pos + pageofs, &adjops);
1390 if (ret > 0)
1391 max_bitflips = max(max_bitflips, ret);
1392 } else {
1393 ret = mtd_write_oob_std(mtd, pos + pageofs, &adjops);
1394 }
1395
1396 if (ret < 0)
1397 return ret;
1398
1399 max_bitflips = max(max_bitflips, ret);
1400 ops->retlen += adjops.retlen;
1401 ops->oobretlen += adjops.oobretlen;
1402 adjops.datbuf += adjops.retlen;
1403 adjops.oobbuf += adjops.oobretlen;
1404 adjops.ooboffs = 0;
1405 pageofs = 0;
1406 info.pair++;
1407 }
1408
1409 return max_bitflips;
1410}
1411
1412int mtd_read_oob(struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops)
1413{
1414 struct mtd_info *master = mtd_get_master(mtd);
1415 struct mtd_ecc_stats old_stats = master->ecc_stats;
1416 int ret_code;
1417
1418 ops->retlen = ops->oobretlen = 0;
1419
1420 ret_code = mtd_check_oob_ops(mtd, from, ops);
1421 if (ret_code)
1422 return ret_code;
1423
1424 ledtrig_mtd_activity();
1425
1426
1427 if (!master->_read_oob && (!master->_read || ops->oobbuf))
1428 return -EOPNOTSUPP;
1429
1430 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
1431 ret_code = mtd_io_emulated_slc(mtd, from, true, ops);
1432 else
1433 ret_code = mtd_read_oob_std(mtd, from, ops);
1434
1435 mtd_update_ecc_stats(mtd, master, &old_stats);
1436
1437
1438
1439
1440
1441
1442
1443 if (unlikely(ret_code < 0))
1444 return ret_code;
1445 if (mtd->ecc_strength == 0)
1446 return 0;
1447 return ret_code >= mtd->bitflip_threshold ? -EUCLEAN : 0;
1448}
1449EXPORT_SYMBOL_GPL(mtd_read_oob);
1450
1451int mtd_write_oob(struct mtd_info *mtd, loff_t to,
1452 struct mtd_oob_ops *ops)
1453{
1454 struct mtd_info *master = mtd_get_master(mtd);
1455 int ret;
1456
1457 ops->retlen = ops->oobretlen = 0;
1458
1459 if (!(mtd->flags & MTD_WRITEABLE))
1460 return -EROFS;
1461
1462 ret = mtd_check_oob_ops(mtd, to, ops);
1463 if (ret)
1464 return ret;
1465
1466 ledtrig_mtd_activity();
1467
1468
1469 if (!master->_write_oob && (!master->_write || ops->oobbuf))
1470 return -EOPNOTSUPP;
1471
1472 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
1473 return mtd_io_emulated_slc(mtd, to, false, ops);
1474
1475 return mtd_write_oob_std(mtd, to, ops);
1476}
1477EXPORT_SYMBOL_GPL(mtd_write_oob);
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495int mtd_ooblayout_ecc(struct mtd_info *mtd, int section,
1496 struct mtd_oob_region *oobecc)
1497{
1498 struct mtd_info *master = mtd_get_master(mtd);
1499
1500 memset(oobecc, 0, sizeof(*oobecc));
1501
1502 if (!master || section < 0)
1503 return -EINVAL;
1504
1505 if (!master->ooblayout || !master->ooblayout->ecc)
1506 return -ENOTSUPP;
1507
1508 return master->ooblayout->ecc(master, section, oobecc);
1509}
1510EXPORT_SYMBOL_GPL(mtd_ooblayout_ecc);
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529int mtd_ooblayout_free(struct mtd_info *mtd, int section,
1530 struct mtd_oob_region *oobfree)
1531{
1532 struct mtd_info *master = mtd_get_master(mtd);
1533
1534 memset(oobfree, 0, sizeof(*oobfree));
1535
1536 if (!master || section < 0)
1537 return -EINVAL;
1538
1539 if (!master->ooblayout || !master->ooblayout->free)
1540 return -ENOTSUPP;
1541
1542 return master->ooblayout->free(master, section, oobfree);
1543}
1544EXPORT_SYMBOL_GPL(mtd_ooblayout_free);
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563static int mtd_ooblayout_find_region(struct mtd_info *mtd, int byte,
1564 int *sectionp, struct mtd_oob_region *oobregion,
1565 int (*iter)(struct mtd_info *,
1566 int section,
1567 struct mtd_oob_region *oobregion))
1568{
1569 int pos = 0, ret, section = 0;
1570
1571 memset(oobregion, 0, sizeof(*oobregion));
1572
1573 while (1) {
1574 ret = iter(mtd, section, oobregion);
1575 if (ret)
1576 return ret;
1577
1578 if (pos + oobregion->length > byte)
1579 break;
1580
1581 pos += oobregion->length;
1582 section++;
1583 }
1584
1585
1586
1587
1588
1589 oobregion->offset += byte - pos;
1590 oobregion->length -= byte - pos;
1591 *sectionp = section;
1592
1593 return 0;
1594}
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609int mtd_ooblayout_find_eccregion(struct mtd_info *mtd, int eccbyte,
1610 int *section,
1611 struct mtd_oob_region *oobregion)
1612{
1613 return mtd_ooblayout_find_region(mtd, eccbyte, section, oobregion,
1614 mtd_ooblayout_ecc);
1615}
1616EXPORT_SYMBOL_GPL(mtd_ooblayout_find_eccregion);
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632static int mtd_ooblayout_get_bytes(struct mtd_info *mtd, u8 *buf,
1633 const u8 *oobbuf, int start, int nbytes,
1634 int (*iter)(struct mtd_info *,
1635 int section,
1636 struct mtd_oob_region *oobregion))
1637{
1638 struct mtd_oob_region oobregion;
1639 int section, ret;
1640
1641 ret = mtd_ooblayout_find_region(mtd, start, §ion,
1642 &oobregion, iter);
1643
1644 while (!ret) {
1645 int cnt;
1646
1647 cnt = min_t(int, nbytes, oobregion.length);
1648 memcpy(buf, oobbuf + oobregion.offset, cnt);
1649 buf += cnt;
1650 nbytes -= cnt;
1651
1652 if (!nbytes)
1653 break;
1654
1655 ret = iter(mtd, ++section, &oobregion);
1656 }
1657
1658 return ret;
1659}
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675static int mtd_ooblayout_set_bytes(struct mtd_info *mtd, const u8 *buf,
1676 u8 *oobbuf, int start, int nbytes,
1677 int (*iter)(struct mtd_info *,
1678 int section,
1679 struct mtd_oob_region *oobregion))
1680{
1681 struct mtd_oob_region oobregion;
1682 int section, ret;
1683
1684 ret = mtd_ooblayout_find_region(mtd, start, §ion,
1685 &oobregion, iter);
1686
1687 while (!ret) {
1688 int cnt;
1689
1690 cnt = min_t(int, nbytes, oobregion.length);
1691 memcpy(oobbuf + oobregion.offset, buf, cnt);
1692 buf += cnt;
1693 nbytes -= cnt;
1694
1695 if (!nbytes)
1696 break;
1697
1698 ret = iter(mtd, ++section, &oobregion);
1699 }
1700
1701 return ret;
1702}
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713static int mtd_ooblayout_count_bytes(struct mtd_info *mtd,
1714 int (*iter)(struct mtd_info *,
1715 int section,
1716 struct mtd_oob_region *oobregion))
1717{
1718 struct mtd_oob_region oobregion;
1719 int section = 0, ret, nbytes = 0;
1720
1721 while (1) {
1722 ret = iter(mtd, section++, &oobregion);
1723 if (ret) {
1724 if (ret == -ERANGE)
1725 ret = nbytes;
1726 break;
1727 }
1728
1729 nbytes += oobregion.length;
1730 }
1731
1732 return ret;
1733}
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747int mtd_ooblayout_get_eccbytes(struct mtd_info *mtd, u8 *eccbuf,
1748 const u8 *oobbuf, int start, int nbytes)
1749{
1750 return mtd_ooblayout_get_bytes(mtd, eccbuf, oobbuf, start, nbytes,
1751 mtd_ooblayout_ecc);
1752}
1753EXPORT_SYMBOL_GPL(mtd_ooblayout_get_eccbytes);
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767int mtd_ooblayout_set_eccbytes(struct mtd_info *mtd, const u8 *eccbuf,
1768 u8 *oobbuf, int start, int nbytes)
1769{
1770 return mtd_ooblayout_set_bytes(mtd, eccbuf, oobbuf, start, nbytes,
1771 mtd_ooblayout_ecc);
1772}
1773EXPORT_SYMBOL_GPL(mtd_ooblayout_set_eccbytes);
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787int mtd_ooblayout_get_databytes(struct mtd_info *mtd, u8 *databuf,
1788 const u8 *oobbuf, int start, int nbytes)
1789{
1790 return mtd_ooblayout_get_bytes(mtd, databuf, oobbuf, start, nbytes,
1791 mtd_ooblayout_free);
1792}
1793EXPORT_SYMBOL_GPL(mtd_ooblayout_get_databytes);
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807int mtd_ooblayout_set_databytes(struct mtd_info *mtd, const u8 *databuf,
1808 u8 *oobbuf, int start, int nbytes)
1809{
1810 return mtd_ooblayout_set_bytes(mtd, databuf, oobbuf, start, nbytes,
1811 mtd_ooblayout_free);
1812}
1813EXPORT_SYMBOL_GPL(mtd_ooblayout_set_databytes);
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823int mtd_ooblayout_count_freebytes(struct mtd_info *mtd)
1824{
1825 return mtd_ooblayout_count_bytes(mtd, mtd_ooblayout_free);
1826}
1827EXPORT_SYMBOL_GPL(mtd_ooblayout_count_freebytes);
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837int mtd_ooblayout_count_eccbytes(struct mtd_info *mtd)
1838{
1839 return mtd_ooblayout_count_bytes(mtd, mtd_ooblayout_ecc);
1840}
1841EXPORT_SYMBOL_GPL(mtd_ooblayout_count_eccbytes);
1842
1843
1844
1845
1846
1847
1848int mtd_get_fact_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen,
1849 struct otp_info *buf)
1850{
1851 struct mtd_info *master = mtd_get_master(mtd);
1852
1853 if (!master->_get_fact_prot_info)
1854 return -EOPNOTSUPP;
1855 if (!len)
1856 return 0;
1857 return master->_get_fact_prot_info(master, len, retlen, buf);
1858}
1859EXPORT_SYMBOL_GPL(mtd_get_fact_prot_info);
1860
1861int mtd_read_fact_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
1862 size_t *retlen, u_char *buf)
1863{
1864 struct mtd_info *master = mtd_get_master(mtd);
1865
1866 *retlen = 0;
1867 if (!master->_read_fact_prot_reg)
1868 return -EOPNOTSUPP;
1869 if (!len)
1870 return 0;
1871 return master->_read_fact_prot_reg(master, from, len, retlen, buf);
1872}
1873EXPORT_SYMBOL_GPL(mtd_read_fact_prot_reg);
1874
1875int mtd_get_user_prot_info(struct mtd_info *mtd, size_t len, size_t *retlen,
1876 struct otp_info *buf)
1877{
1878 struct mtd_info *master = mtd_get_master(mtd);
1879
1880 if (!master->_get_user_prot_info)
1881 return -EOPNOTSUPP;
1882 if (!len)
1883 return 0;
1884 return master->_get_user_prot_info(master, len, retlen, buf);
1885}
1886EXPORT_SYMBOL_GPL(mtd_get_user_prot_info);
1887
1888int mtd_read_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len,
1889 size_t *retlen, u_char *buf)
1890{
1891 struct mtd_info *master = mtd_get_master(mtd);
1892
1893 *retlen = 0;
1894 if (!master->_read_user_prot_reg)
1895 return -EOPNOTSUPP;
1896 if (!len)
1897 return 0;
1898 return master->_read_user_prot_reg(master, from, len, retlen, buf);
1899}
1900EXPORT_SYMBOL_GPL(mtd_read_user_prot_reg);
1901
1902int mtd_write_user_prot_reg(struct mtd_info *mtd, loff_t to, size_t len,
1903 size_t *retlen, u_char *buf)
1904{
1905 struct mtd_info *master = mtd_get_master(mtd);
1906 int ret;
1907
1908 *retlen = 0;
1909 if (!master->_write_user_prot_reg)
1910 return -EOPNOTSUPP;
1911 if (!len)
1912 return 0;
1913 ret = master->_write_user_prot_reg(master, to, len, retlen, buf);
1914 if (ret)
1915 return ret;
1916
1917
1918
1919
1920
1921 return (*retlen) ? 0 : -ENOSPC;
1922}
1923EXPORT_SYMBOL_GPL(mtd_write_user_prot_reg);
1924
1925int mtd_lock_user_prot_reg(struct mtd_info *mtd, loff_t from, size_t len)
1926{
1927 struct mtd_info *master = mtd_get_master(mtd);
1928
1929 if (!master->_lock_user_prot_reg)
1930 return -EOPNOTSUPP;
1931 if (!len)
1932 return 0;
1933 return master->_lock_user_prot_reg(master, from, len);
1934}
1935EXPORT_SYMBOL_GPL(mtd_lock_user_prot_reg);
1936
1937
1938int mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1939{
1940 struct mtd_info *master = mtd_get_master(mtd);
1941
1942 if (!master->_lock)
1943 return -EOPNOTSUPP;
1944 if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)
1945 return -EINVAL;
1946 if (!len)
1947 return 0;
1948
1949 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
1950 ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
1951 len = (u64)mtd_div_by_eb(len, mtd) * master->erasesize;
1952 }
1953
1954 return master->_lock(master, mtd_get_master_ofs(mtd, ofs), len);
1955}
1956EXPORT_SYMBOL_GPL(mtd_lock);
1957
1958int mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1959{
1960 struct mtd_info *master = mtd_get_master(mtd);
1961
1962 if (!master->_unlock)
1963 return -EOPNOTSUPP;
1964 if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)
1965 return -EINVAL;
1966 if (!len)
1967 return 0;
1968
1969 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
1970 ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
1971 len = (u64)mtd_div_by_eb(len, mtd) * master->erasesize;
1972 }
1973
1974 return master->_unlock(master, mtd_get_master_ofs(mtd, ofs), len);
1975}
1976EXPORT_SYMBOL_GPL(mtd_unlock);
1977
1978int mtd_is_locked(struct mtd_info *mtd, loff_t ofs, uint64_t len)
1979{
1980 struct mtd_info *master = mtd_get_master(mtd);
1981
1982 if (!master->_is_locked)
1983 return -EOPNOTSUPP;
1984 if (ofs < 0 || ofs >= mtd->size || len > mtd->size - ofs)
1985 return -EINVAL;
1986 if (!len)
1987 return 0;
1988
1989 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION) {
1990 ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
1991 len = (u64)mtd_div_by_eb(len, mtd) * master->erasesize;
1992 }
1993
1994 return master->_is_locked(master, mtd_get_master_ofs(mtd, ofs), len);
1995}
1996EXPORT_SYMBOL_GPL(mtd_is_locked);
1997
1998int mtd_block_isreserved(struct mtd_info *mtd, loff_t ofs)
1999{
2000 struct mtd_info *master = mtd_get_master(mtd);
2001
2002 if (ofs < 0 || ofs >= mtd->size)
2003 return -EINVAL;
2004 if (!master->_block_isreserved)
2005 return 0;
2006
2007 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
2008 ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
2009
2010 return master->_block_isreserved(master, mtd_get_master_ofs(mtd, ofs));
2011}
2012EXPORT_SYMBOL_GPL(mtd_block_isreserved);
2013
2014int mtd_block_isbad(struct mtd_info *mtd, loff_t ofs)
2015{
2016 struct mtd_info *master = mtd_get_master(mtd);
2017
2018 if (ofs < 0 || ofs >= mtd->size)
2019 return -EINVAL;
2020 if (!master->_block_isbad)
2021 return 0;
2022
2023 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
2024 ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
2025
2026 return master->_block_isbad(master, mtd_get_master_ofs(mtd, ofs));
2027}
2028EXPORT_SYMBOL_GPL(mtd_block_isbad);
2029
2030int mtd_block_markbad(struct mtd_info *mtd, loff_t ofs)
2031{
2032 struct mtd_info *master = mtd_get_master(mtd);
2033 int ret;
2034
2035 if (!master->_block_markbad)
2036 return -EOPNOTSUPP;
2037 if (ofs < 0 || ofs >= mtd->size)
2038 return -EINVAL;
2039 if (!(mtd->flags & MTD_WRITEABLE))
2040 return -EROFS;
2041
2042 if (mtd->flags & MTD_SLC_ON_MLC_EMULATION)
2043 ofs = (loff_t)mtd_div_by_eb(ofs, mtd) * master->erasesize;
2044
2045 ret = master->_block_markbad(master, mtd_get_master_ofs(mtd, ofs));
2046 if (ret)
2047 return ret;
2048
2049 while (mtd->parent) {
2050 mtd->ecc_stats.badblocks++;
2051 mtd = mtd->parent;
2052 }
2053
2054 return 0;
2055}
2056EXPORT_SYMBOL_GPL(mtd_block_markbad);
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069static int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
2070 unsigned long count, loff_t to, size_t *retlen)
2071{
2072 unsigned long i;
2073 size_t totlen = 0, thislen;
2074 int ret = 0;
2075
2076 for (i = 0; i < count; i++) {
2077 if (!vecs[i].iov_len)
2078 continue;
2079 ret = mtd_write(mtd, to, vecs[i].iov_len, &thislen,
2080 vecs[i].iov_base);
2081 totlen += thislen;
2082 if (ret || thislen != vecs[i].iov_len)
2083 break;
2084 to += vecs[i].iov_len;
2085 }
2086 *retlen = totlen;
2087 return ret;
2088}
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101int mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
2102 unsigned long count, loff_t to, size_t *retlen)
2103{
2104 struct mtd_info *master = mtd_get_master(mtd);
2105
2106 *retlen = 0;
2107 if (!(mtd->flags & MTD_WRITEABLE))
2108 return -EROFS;
2109
2110 if (!master->_writev)
2111 return default_mtd_writev(mtd, vecs, count, to, retlen);
2112
2113 return master->_writev(master, vecs, count,
2114 mtd_get_master_ofs(mtd, to), retlen);
2115}
2116EXPORT_SYMBOL_GPL(mtd_writev);
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size)
2143{
2144 gfp_t flags = __GFP_NOWARN | __GFP_DIRECT_RECLAIM | __GFP_NORETRY;
2145 size_t min_alloc = max_t(size_t, mtd->writesize, PAGE_SIZE);
2146 void *kbuf;
2147
2148 *size = min_t(size_t, *size, KMALLOC_MAX_SIZE);
2149
2150 while (*size > min_alloc) {
2151 kbuf = kmalloc(*size, flags);
2152 if (kbuf)
2153 return kbuf;
2154
2155 *size >>= 1;
2156 *size = ALIGN(*size, mtd->writesize);
2157 }
2158
2159
2160
2161
2162
2163 return kmalloc(*size, GFP_KERNEL);
2164}
2165EXPORT_SYMBOL_GPL(mtd_kmalloc_up_to);
2166
2167#ifdef CONFIG_PROC_FS
2168
2169
2170
2171
2172static int mtd_proc_show(struct seq_file *m, void *v)
2173{
2174 struct mtd_info *mtd;
2175
2176 seq_puts(m, "dev: size erasesize name\n");
2177 mutex_lock(&mtd_table_mutex);
2178 mtd_for_each_device(mtd) {
2179 seq_printf(m, "mtd%d: %8.8llx %8.8x \"%s\"\n",
2180 mtd->index, (unsigned long long)mtd->size,
2181 mtd->erasesize, mtd->name);
2182 }
2183 mutex_unlock(&mtd_table_mutex);
2184 return 0;
2185}
2186#endif
2187
2188
2189
2190
2191static struct backing_dev_info * __init mtd_bdi_init(char *name)
2192{
2193 struct backing_dev_info *bdi;
2194 int ret;
2195
2196 bdi = bdi_alloc(NUMA_NO_NODE);
2197 if (!bdi)
2198 return ERR_PTR(-ENOMEM);
2199
2200
2201
2202
2203
2204 ret = bdi_register(bdi, "%.28s-0", name);
2205 if (ret)
2206 bdi_put(bdi);
2207
2208 return ret ? ERR_PTR(ret) : bdi;
2209}
2210
2211static struct proc_dir_entry *proc_mtd;
2212
2213static int __init init_mtd(void)
2214{
2215 int ret;
2216
2217 ret = class_register(&mtd_class);
2218 if (ret)
2219 goto err_reg;
2220
2221 mtd_bdi = mtd_bdi_init("mtd");
2222 if (IS_ERR(mtd_bdi)) {
2223 ret = PTR_ERR(mtd_bdi);
2224 goto err_bdi;
2225 }
2226
2227 proc_mtd = proc_create_single("mtd", 0, NULL, mtd_proc_show);
2228
2229 ret = init_mtdchar();
2230 if (ret)
2231 goto out_procfs;
2232
2233 dfs_dir_mtd = debugfs_create_dir("mtd", NULL);
2234
2235 return 0;
2236
2237out_procfs:
2238 if (proc_mtd)
2239 remove_proc_entry("mtd", NULL);
2240 bdi_put(mtd_bdi);
2241err_bdi:
2242 class_unregister(&mtd_class);
2243err_reg:
2244 pr_err("Error registering mtd class or bdi: %d\n", ret);
2245 return ret;
2246}
2247
2248static void __exit cleanup_mtd(void)
2249{
2250 debugfs_remove_recursive(dfs_dir_mtd);
2251 cleanup_mtdchar();
2252 if (proc_mtd)
2253 remove_proc_entry("mtd", NULL);
2254 class_unregister(&mtd_class);
2255 bdi_put(mtd_bdi);
2256 idr_destroy(&mtd_idr);
2257}
2258
2259module_init(init_mtd);
2260module_exit(cleanup_mtd);
2261
2262MODULE_LICENSE("GPL");
2263MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
2264MODULE_DESCRIPTION("Core MTD registration and access routines");
2265