1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Core registration and callback routines for MTD
6 * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
7 * Copyright © 2006 Red Hat UK Limited
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>
18 #include <linux/err.h>
19 #include <linux/ioctl.h>
20 #include <linux/init.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>
32 #include <linux/mtd/mtd.h>
33 #include <linux/mtd/partitions.h>
37 struct backing_dev_info
*mtd_bdi
;
39 #ifdef CONFIG_PM_SLEEP
41 static int mtd_cls_suspend(struct device
*dev
)
43 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
45 return mtd
? mtd_suspend(mtd
) : 0;
48 static int mtd_cls_resume(struct device
*dev
)
50 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
57 static SIMPLE_DEV_PM_OPS(mtd_cls_pm_ops
, mtd_cls_suspend
, mtd_cls_resume
);
58 #define MTD_CLS_PM_OPS (&mtd_cls_pm_ops)
60 #define MTD_CLS_PM_OPS NULL
63 static struct class mtd_class
= {
69 static DEFINE_IDR(mtd_idr
);
71 /* These are exported solely for the purpose of mtd_blkdevs.c. You
72 should not use them for _anything_ else */
73 DEFINE_MUTEX(mtd_table_mutex
);
74 EXPORT_SYMBOL_GPL(mtd_table_mutex
);
76 struct mtd_info
*__mtd_next_device(int i
)
78 return idr_get_next(&mtd_idr
, &i
);
80 EXPORT_SYMBOL_GPL(__mtd_next_device
);
82 static LIST_HEAD(mtd_notifiers
);
85 #define MTD_DEVT(index) MKDEV(MTD_CHAR_MAJOR, (index)*2)
87 /* REVISIT once MTD uses the driver model better, whoever allocates
88 * the mtd_info will probably want to use the release() hook...
90 static void mtd_release(struct device
*dev
)
92 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
93 dev_t index
= MTD_DEVT(mtd
->index
);
95 /* remove /dev/mtdXro node */
96 device_destroy(&mtd_class
, index
+ 1);
99 #define MTD_DEVICE_ATTR_RO(name) \
100 static DEVICE_ATTR(name, 0444, mtd_##name##_show, NULL)
102 #define MTD_DEVICE_ATTR_RW(name) \
103 static DEVICE_ATTR(name, 0644, mtd_##name##_show, mtd_##name##_store)
105 static ssize_t
mtd_type_show(struct device
*dev
,
106 struct device_attribute
*attr
, char *buf
)
108 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
133 case MTD_MLCNANDFLASH
:
140 return sysfs_emit(buf
, "%s\n", type
);
142 MTD_DEVICE_ATTR_RO(type
);
144 static ssize_t
mtd_flags_show(struct device
*dev
,
145 struct device_attribute
*attr
, char *buf
)
147 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
149 return sysfs_emit(buf
, "0x%lx\n", (unsigned long)mtd
->flags
);
151 MTD_DEVICE_ATTR_RO(flags
);
153 static ssize_t
mtd_size_show(struct device
*dev
,
154 struct device_attribute
*attr
, char *buf
)
156 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
158 return sysfs_emit(buf
, "%llu\n", (unsigned long long)mtd
->size
);
160 MTD_DEVICE_ATTR_RO(size
);
162 static ssize_t
mtd_erasesize_show(struct device
*dev
,
163 struct device_attribute
*attr
, char *buf
)
165 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
167 return sysfs_emit(buf
, "%lu\n", (unsigned long)mtd
->erasesize
);
169 MTD_DEVICE_ATTR_RO(erasesize
);
171 static ssize_t
mtd_writesize_show(struct device
*dev
,
172 struct device_attribute
*attr
, char *buf
)
174 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
176 return sysfs_emit(buf
, "%lu\n", (unsigned long)mtd
->writesize
);
178 MTD_DEVICE_ATTR_RO(writesize
);
180 static ssize_t
mtd_subpagesize_show(struct device
*dev
,
181 struct device_attribute
*attr
, char *buf
)
183 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
184 unsigned int subpagesize
= mtd
->writesize
>> mtd
->subpage_sft
;
186 return sysfs_emit(buf
, "%u\n", subpagesize
);
188 MTD_DEVICE_ATTR_RO(subpagesize
);
190 static ssize_t
mtd_oobsize_show(struct device
*dev
,
191 struct device_attribute
*attr
, char *buf
)
193 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
195 return sysfs_emit(buf
, "%lu\n", (unsigned long)mtd
->oobsize
);
197 MTD_DEVICE_ATTR_RO(oobsize
);
199 static ssize_t
mtd_oobavail_show(struct device
*dev
,
200 struct device_attribute
*attr
, char *buf
)
202 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
204 return sysfs_emit(buf
, "%u\n", mtd
->oobavail
);
206 MTD_DEVICE_ATTR_RO(oobavail
);
208 static ssize_t
mtd_numeraseregions_show(struct device
*dev
,
209 struct device_attribute
*attr
, char *buf
)
211 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
213 return sysfs_emit(buf
, "%u\n", mtd
->numeraseregions
);
215 MTD_DEVICE_ATTR_RO(numeraseregions
);
217 static ssize_t
mtd_name_show(struct device
*dev
,
218 struct device_attribute
*attr
, char *buf
)
220 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
222 return sysfs_emit(buf
, "%s\n", mtd
->name
);
224 MTD_DEVICE_ATTR_RO(name
);
226 static ssize_t
mtd_ecc_strength_show(struct device
*dev
,
227 struct device_attribute
*attr
, char *buf
)
229 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
231 return sysfs_emit(buf
, "%u\n", mtd
->ecc_strength
);
233 MTD_DEVICE_ATTR_RO(ecc_strength
);
235 static ssize_t
mtd_bitflip_threshold_show(struct device
*dev
,
236 struct device_attribute
*attr
,
239 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
241 return sysfs_emit(buf
, "%u\n", mtd
->bitflip_threshold
);
244 static ssize_t
mtd_bitflip_threshold_store(struct device
*dev
,
245 struct device_attribute
*attr
,
246 const char *buf
, size_t count
)
248 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
249 unsigned int bitflip_threshold
;
252 retval
= kstrtouint(buf
, 0, &bitflip_threshold
);
256 mtd
->bitflip_threshold
= bitflip_threshold
;
259 MTD_DEVICE_ATTR_RW(bitflip_threshold
);
261 static ssize_t
mtd_ecc_step_size_show(struct device
*dev
,
262 struct device_attribute
*attr
, char *buf
)
264 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
266 return sysfs_emit(buf
, "%u\n", mtd
->ecc_step_size
);
269 MTD_DEVICE_ATTR_RO(ecc_step_size
);
271 static ssize_t
mtd_corrected_bits_show(struct device
*dev
,
272 struct device_attribute
*attr
, char *buf
)
274 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
275 struct mtd_ecc_stats
*ecc_stats
= &mtd
->ecc_stats
;
277 return sysfs_emit(buf
, "%u\n", ecc_stats
->corrected
);
279 MTD_DEVICE_ATTR_RO(corrected_bits
); /* ecc stats corrected */
281 static ssize_t
mtd_ecc_failures_show(struct device
*dev
,
282 struct device_attribute
*attr
, char *buf
)
284 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
285 struct mtd_ecc_stats
*ecc_stats
= &mtd
->ecc_stats
;
287 return sysfs_emit(buf
, "%u\n", ecc_stats
->failed
);
289 MTD_DEVICE_ATTR_RO(ecc_failures
); /* ecc stats errors */
291 static ssize_t
mtd_bad_blocks_show(struct device
*dev
,
292 struct device_attribute
*attr
, char *buf
)
294 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
295 struct mtd_ecc_stats
*ecc_stats
= &mtd
->ecc_stats
;
297 return sysfs_emit(buf
, "%u\n", ecc_stats
->badblocks
);
299 MTD_DEVICE_ATTR_RO(bad_blocks
);
301 static ssize_t
mtd_bbt_blocks_show(struct device
*dev
,
302 struct device_attribute
*attr
, char *buf
)
304 struct mtd_info
*mtd
= dev_get_drvdata(dev
);
305 struct mtd_ecc_stats
*ecc_stats
= &mtd
->ecc_stats
;
307 return sysfs_emit(buf
, "%u\n", ecc_stats
->bbtblocks
);
309 MTD_DEVICE_ATTR_RO(bbt_blocks
);
311 static struct attribute
*mtd_attrs
[] = {
313 &dev_attr_flags
.attr
,
315 &dev_attr_erasesize
.attr
,
316 &dev_attr_writesize
.attr
,
317 &dev_attr_subpagesize
.attr
,
318 &dev_attr_oobsize
.attr
,
319 &dev_attr_oobavail
.attr
,
320 &dev_attr_numeraseregions
.attr
,
322 &dev_attr_ecc_strength
.attr
,
323 &dev_attr_ecc_step_size
.attr
,
324 &dev_attr_corrected_bits
.attr
,
325 &dev_attr_ecc_failures
.attr
,
326 &dev_attr_bad_blocks
.attr
,
327 &dev_attr_bbt_blocks
.attr
,
328 &dev_attr_bitflip_threshold
.attr
,
331 ATTRIBUTE_GROUPS(mtd
);
333 static const struct device_type mtd_devtype
= {
335 .groups
= mtd_groups
,
336 .release
= mtd_release
,
339 static int mtd_partid_debug_show(struct seq_file
*s
, void *p
)
341 struct mtd_info
*mtd
= s
->private;
343 seq_printf(s
, "%s\n", mtd
->dbg
.partid
);
348 DEFINE_SHOW_ATTRIBUTE(mtd_partid_debug
);
350 static int mtd_partname_debug_show(struct seq_file
*s
, void *p
)
352 struct mtd_info
*mtd
= s
->private;
354 seq_printf(s
, "%s\n", mtd
->dbg
.partname
);
359 DEFINE_SHOW_ATTRIBUTE(mtd_partname_debug
);
361 static struct dentry
*dfs_dir_mtd
;
363 static void mtd_debugfs_populate(struct mtd_info
*mtd
)
365 struct mtd_info
*master
= mtd_get_master(mtd
);
366 struct device
*dev
= &mtd
->dev
;
369 if (IS_ERR_OR_NULL(dfs_dir_mtd
))
372 root
= debugfs_create_dir(dev_name(dev
), dfs_dir_mtd
);
373 mtd
->dbg
.dfs_dir
= root
;
375 if (master
->dbg
.partid
)
376 debugfs_create_file("partid", 0400, root
, master
,
377 &mtd_partid_debug_fops
);
379 if (master
->dbg
.partname
)
380 debugfs_create_file("partname", 0400, root
, master
,
381 &mtd_partname_debug_fops
);
385 unsigned mtd_mmap_capabilities(struct mtd_info
*mtd
)
389 return NOMMU_MAP_COPY
| NOMMU_MAP_DIRECT
| NOMMU_MAP_EXEC
|
390 NOMMU_MAP_READ
| NOMMU_MAP_WRITE
;
392 return NOMMU_MAP_COPY
| NOMMU_MAP_DIRECT
| NOMMU_MAP_EXEC
|
395 return NOMMU_MAP_COPY
;
398 EXPORT_SYMBOL_GPL(mtd_mmap_capabilities
);
401 static int mtd_reboot_notifier(struct notifier_block
*n
, unsigned long state
,
404 struct mtd_info
*mtd
;
406 mtd
= container_of(n
, struct mtd_info
, reboot_notifier
);
413 * mtd_wunit_to_pairing_info - get pairing information of a wunit
414 * @mtd: pointer to new MTD device info structure
415 * @wunit: write unit we are interested in
416 * @info: returned pairing information
418 * Retrieve pairing information associated to the wunit.
419 * This is mainly useful when dealing with MLC/TLC NANDs where pages can be
420 * paired together, and where programming a page may influence the page it is
422 * The notion of page is replaced by the term wunit (write-unit) to stay
423 * consistent with the ->writesize field.
425 * The @wunit argument can be extracted from an absolute offset using
426 * mtd_offset_to_wunit(). @info is filled with the pairing information attached
429 * From the pairing info the MTD user can find all the wunits paired with
430 * @wunit using the following loop:
432 * for (i = 0; i < mtd_pairing_groups(mtd); i++) {
434 * mtd_pairing_info_to_wunit(mtd, &info);
438 int mtd_wunit_to_pairing_info(struct mtd_info
*mtd
, int wunit
,
439 struct mtd_pairing_info
*info
)
441 struct mtd_info
*master
= mtd_get_master(mtd
);
442 int npairs
= mtd_wunit_per_eb(master
) / mtd_pairing_groups(master
);
444 if (wunit
< 0 || wunit
>= npairs
)
447 if (master
->pairing
&& master
->pairing
->get_info
)
448 return master
->pairing
->get_info(master
, wunit
, info
);
455 EXPORT_SYMBOL_GPL(mtd_wunit_to_pairing_info
);
458 * mtd_pairing_info_to_wunit - get wunit from pairing information
459 * @mtd: pointer to new MTD device info structure
460 * @info: pairing information struct
462 * Returns a positive number representing the wunit associated to the info
463 * struct, or a negative error code.
465 * This is the reverse of mtd_wunit_to_pairing_info(), and can help one to
466 * iterate over all wunits of a given pair (see mtd_wunit_to_pairing_info()
469 * It can also be used to only program the first page of each pair (i.e.
470 * page attached to group 0), which allows one to use an MLC NAND in
471 * software-emulated SLC mode:
474 * npairs = mtd_wunit_per_eb(mtd) / mtd_pairing_groups(mtd);
475 * for (info.pair = 0; info.pair < npairs; info.pair++) {
476 * wunit = mtd_pairing_info_to_wunit(mtd, &info);
477 * mtd_write(mtd, mtd_wunit_to_offset(mtd, blkoffs, wunit),
478 * mtd->writesize, &retlen, buf + (i * mtd->writesize));
481 int mtd_pairing_info_to_wunit(struct mtd_info
*mtd
,
482 const struct mtd_pairing_info
*info
)
484 struct mtd_info
*master
= mtd_get_master(mtd
);
485 int ngroups
= mtd_pairing_groups(master
);
486 int npairs
= mtd_wunit_per_eb(master
) / ngroups
;
488 if (!info
|| info
->pair
< 0 || info
->pair
>= npairs
||
489 info
->group
< 0 || info
->group
>= ngroups
)
492 if (master
->pairing
&& master
->pairing
->get_wunit
)
493 return mtd
->pairing
->get_wunit(master
, info
);
497 EXPORT_SYMBOL_GPL(mtd_pairing_info_to_wunit
);
500 * mtd_pairing_groups - get the number of pairing groups
501 * @mtd: pointer to new MTD device info structure
503 * Returns the number of pairing groups.
505 * This number is usually equal to the number of bits exposed by a single
506 * cell, and can be used in conjunction with mtd_pairing_info_to_wunit()
507 * to iterate over all pages of a given pair.
509 int mtd_pairing_groups(struct mtd_info
*mtd
)
511 struct mtd_info
*master
= mtd_get_master(mtd
);
513 if (!master
->pairing
|| !master
->pairing
->ngroups
)
516 return master
->pairing
->ngroups
;
518 EXPORT_SYMBOL_GPL(mtd_pairing_groups
);
520 static int mtd_nvmem_reg_read(void *priv
, unsigned int offset
,
521 void *val
, size_t bytes
)
523 struct mtd_info
*mtd
= priv
;
527 err
= mtd_read(mtd
, offset
, bytes
, &retlen
, val
);
528 if (err
&& err
!= -EUCLEAN
)
531 return retlen
== bytes
? 0 : -EIO
;
534 static int mtd_nvmem_add(struct mtd_info
*mtd
)
536 struct device_node
*node
= mtd_get_of_node(mtd
);
537 struct nvmem_config config
= {};
540 config
.dev
= &mtd
->dev
;
541 config
.name
= dev_name(&mtd
->dev
);
542 config
.owner
= THIS_MODULE
;
543 config
.reg_read
= mtd_nvmem_reg_read
;
544 config
.size
= mtd
->size
;
545 config
.word_size
= 1;
547 config
.read_only
= true;
548 config
.root_only
= true;
549 config
.ignore_wp
= true;
550 config
.no_of_node
= !of_device_is_compatible(node
, "nvmem-cells");
553 mtd
->nvmem
= nvmem_register(&config
);
554 if (IS_ERR(mtd
->nvmem
)) {
555 /* Just ignore if there is no NVMEM support in the kernel */
556 if (PTR_ERR(mtd
->nvmem
) == -EOPNOTSUPP
) {
559 dev_err(&mtd
->dev
, "Failed to register NVMEM device\n");
560 return PTR_ERR(mtd
->nvmem
);
568 * add_mtd_device - register an MTD device
569 * @mtd: pointer to new MTD device info structure
571 * Add a device to the list of MTD devices present in the system, and
572 * notify each currently active MTD 'user' of its arrival. Returns
573 * zero on success or non-zero on failure.
576 int add_mtd_device(struct mtd_info
*mtd
)
578 struct mtd_info
*master
= mtd_get_master(mtd
);
579 struct mtd_notifier
*not;
583 * May occur, for instance, on buggy drivers which call
584 * mtd_device_parse_register() multiple times on the same master MTD,
585 * especially with CONFIG_MTD_PARTITIONED_MASTER=y.
587 if (WARN_ONCE(mtd
->dev
.type
, "MTD already registered\n"))
590 BUG_ON(mtd
->writesize
== 0);
593 * MTD drivers should implement ->_{write,read}() or
594 * ->_{write,read}_oob(), but not both.
596 if (WARN_ON((mtd
->_write
&& mtd
->_write_oob
) ||
597 (mtd
->_read
&& mtd
->_read_oob
)))
600 if (WARN_ON((!mtd
->erasesize
|| !master
->_erase
) &&
601 !(mtd
->flags
& MTD_NO_ERASE
)))
605 * MTD_SLC_ON_MLC_EMULATION can only be set on partitions, when the
606 * master is an MLC NAND and has a proper pairing scheme defined.
607 * We also reject masters that implement ->_writev() for now, because
608 * NAND controller drivers don't implement this hook, and adding the
609 * SLC -> MLC address/length conversion to this path is useless if we
612 if (mtd
->flags
& MTD_SLC_ON_MLC_EMULATION
&&
613 (!mtd_is_partition(mtd
) || master
->type
!= MTD_MLCNANDFLASH
||
614 !master
->pairing
|| master
->_writev
))
617 mutex_lock(&mtd_table_mutex
);
619 i
= idr_alloc(&mtd_idr
, mtd
, 0, 0, GFP_KERNEL
);
628 /* default value if not set by driver */
629 if (mtd
->bitflip_threshold
== 0)
630 mtd
->bitflip_threshold
= mtd
->ecc_strength
;
632 if (mtd
->flags
& MTD_SLC_ON_MLC_EMULATION
) {
633 int ngroups
= mtd_pairing_groups(master
);
635 mtd
->erasesize
/= ngroups
;
636 mtd
->size
= (u64
)mtd_div_by_eb(mtd
->size
, master
) *
640 if (is_power_of_2(mtd
->erasesize
))
641 mtd
->erasesize_shift
= ffs(mtd
->erasesize
) - 1;
643 mtd
->erasesize_shift
= 0;
645 if (is_power_of_2(mtd
->writesize
))
646 mtd
->writesize_shift
= ffs(mtd
->writesize
) - 1;
648 mtd
->writesize_shift
= 0;
650 mtd
->erasesize_mask
= (1 << mtd
->erasesize_shift
) - 1;
651 mtd
->writesize_mask
= (1 << mtd
->writesize_shift
) - 1;
653 /* Some chips always power up locked. Unlock them now */
654 if ((mtd
->flags
& MTD_WRITEABLE
) && (mtd
->flags
& MTD_POWERUP_LOCK
)) {
655 error
= mtd_unlock(mtd
, 0, mtd
->size
);
656 if (error
&& error
!= -EOPNOTSUPP
)
658 "%s: unlock failed, writes may not work\n",
660 /* Ignore unlock failures? */
664 /* Caller should have set dev.parent to match the
665 * physical device, if appropriate.
667 mtd
->dev
.type
= &mtd_devtype
;
668 mtd
->dev
.class = &mtd_class
;
669 mtd
->dev
.devt
= MTD_DEVT(i
);
670 dev_set_name(&mtd
->dev
, "mtd%d", i
);
671 dev_set_drvdata(&mtd
->dev
, mtd
);
672 of_node_get(mtd_get_of_node(mtd
));
673 error
= device_register(&mtd
->dev
);
677 /* Add the nvmem provider */
678 error
= mtd_nvmem_add(mtd
);
682 mtd_debugfs_populate(mtd
);
684 device_create(&mtd_class
, mtd
->dev
.parent
, MTD_DEVT(i
) + 1, NULL
,
687 pr_debug("mtd: Giving out device %d to %s\n", i
, mtd
->name
);
688 /* No need to get a refcount on the module containing
689 the notifier, since we hold the mtd_table_mutex */
690 list_for_each_entry(not, &mtd_notifiers
, list
)
693 mutex_unlock(&mtd_table_mutex
);
694 /* We _know_ we aren't being removed, because
695 our caller is still holding us here. So none
696 of this try_ nonsense, and no bitching about it
698 __module_get(THIS_MODULE
);
702 device_unregister(&mtd
->dev
);
704 of_node_put(mtd_get_of_node(mtd
));
705 idr_remove(&mtd_idr
, i
);
707 mutex_unlock(&mtd_table_mutex
);
712 * del_mtd_device - unregister an MTD device
713 * @mtd: pointer to MTD device info structure
715 * Remove a device from the list of MTD devices present in the system,
716 * and notify each currently active MTD 'user' of its departure.
717 * Returns zero on success or 1 on failure, which currently will happen
718 * if the requested device does not appear to be present in the list.
721 int del_mtd_device(struct mtd_info
*mtd
)
724 struct mtd_notifier
*not;
726 mutex_lock(&mtd_table_mutex
);
728 if (idr_find(&mtd_idr
, mtd
->index
) != mtd
) {
733 /* No need to get a refcount on the module containing
734 the notifier, since we hold the mtd_table_mutex */
735 list_for_each_entry(not, &mtd_notifiers
, list
)
739 printk(KERN_NOTICE
"Removing MTD device #%d (%s) with use count %d\n",
740 mtd
->index
, mtd
->name
, mtd
->usecount
);
743 debugfs_remove_recursive(mtd
->dbg
.dfs_dir
);
745 /* Try to remove the NVMEM provider */
747 nvmem_unregister(mtd
->nvmem
);
749 device_unregister(&mtd
->dev
);
751 idr_remove(&mtd_idr
, mtd
->index
);
752 of_node_put(mtd_get_of_node(mtd
));
754 module_put(THIS_MODULE
);
759 mutex_unlock(&mtd_table_mutex
);
764 * Set a few defaults based on the parent devices, if not provided by the
767 static void mtd_set_dev_defaults(struct mtd_info
*mtd
)
769 if (mtd
->dev
.parent
) {
770 if (!mtd
->owner
&& mtd
->dev
.parent
->driver
)
771 mtd
->owner
= mtd
->dev
.parent
->driver
->owner
;
773 mtd
->name
= dev_name(mtd
->dev
.parent
);
775 pr_debug("mtd device won't show a device symlink in sysfs\n");
778 INIT_LIST_HEAD(&mtd
->partitions
);
779 mutex_init(&mtd
->master
.partitions_lock
);
780 mutex_init(&mtd
->master
.chrdev_lock
);
783 static ssize_t
mtd_otp_size(struct mtd_info
*mtd
, bool is_user
)
785 struct otp_info
*info
;
791 info
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
796 ret
= mtd_get_user_prot_info(mtd
, PAGE_SIZE
, &retlen
, info
);
798 ret
= mtd_get_fact_prot_info(mtd
, PAGE_SIZE
, &retlen
, info
);
802 for (i
= 0; i
< retlen
/ sizeof(*info
); i
++)
803 size
+= info
[i
].length
;
811 /* ENODATA means there is no OTP region. */
812 return ret
== -ENODATA
? 0 : ret
;
815 static struct nvmem_device
*mtd_otp_nvmem_register(struct mtd_info
*mtd
,
816 const char *compatible
,
818 nvmem_reg_read_t reg_read
)
820 struct nvmem_device
*nvmem
= NULL
;
821 struct nvmem_config config
= {};
822 struct device_node
*np
;
824 /* DT binding is optional */
825 np
= of_get_compatible_child(mtd
->dev
.of_node
, compatible
);
827 /* OTP nvmem will be registered on the physical device */
828 config
.dev
= mtd
->dev
.parent
;
829 config
.name
= kasprintf(GFP_KERNEL
, "%s-%s", dev_name(&mtd
->dev
), compatible
);
830 config
.id
= NVMEM_DEVID_NONE
;
831 config
.owner
= THIS_MODULE
;
832 config
.type
= NVMEM_TYPE_OTP
;
833 config
.root_only
= true;
834 config
.ignore_wp
= true;
835 config
.reg_read
= reg_read
;
840 nvmem
= nvmem_register(&config
);
841 /* Just ignore if there is no NVMEM support in the kernel */
842 if (IS_ERR(nvmem
) && PTR_ERR(nvmem
) == -EOPNOTSUPP
)
851 static int mtd_nvmem_user_otp_reg_read(void *priv
, unsigned int offset
,
852 void *val
, size_t bytes
)
854 struct mtd_info
*mtd
= priv
;
858 ret
= mtd_read_user_prot_reg(mtd
, offset
, bytes
, &retlen
, val
);
862 return retlen
== bytes
? 0 : -EIO
;
865 static int mtd_nvmem_fact_otp_reg_read(void *priv
, unsigned int offset
,
866 void *val
, size_t bytes
)
868 struct mtd_info
*mtd
= priv
;
872 ret
= mtd_read_fact_prot_reg(mtd
, offset
, bytes
, &retlen
, val
);
876 return retlen
== bytes
? 0 : -EIO
;
879 static int mtd_otp_nvmem_add(struct mtd_info
*mtd
)
881 struct nvmem_device
*nvmem
;
885 if (mtd
->_get_user_prot_info
&& mtd
->_read_user_prot_reg
) {
886 size
= mtd_otp_size(mtd
, true);
891 nvmem
= mtd_otp_nvmem_register(mtd
, "user-otp", size
,
892 mtd_nvmem_user_otp_reg_read
);
894 dev_err(&mtd
->dev
, "Failed to register OTP NVMEM device\n");
895 return PTR_ERR(nvmem
);
897 mtd
->otp_user_nvmem
= nvmem
;
901 if (mtd
->_get_fact_prot_info
&& mtd
->_read_fact_prot_reg
) {
902 size
= mtd_otp_size(mtd
, false);
909 nvmem
= mtd_otp_nvmem_register(mtd
, "factory-otp", size
,
910 mtd_nvmem_fact_otp_reg_read
);
912 dev_err(&mtd
->dev
, "Failed to register OTP NVMEM device\n");
913 err
= PTR_ERR(nvmem
);
916 mtd
->otp_factory_nvmem
= nvmem
;
923 if (mtd
->otp_user_nvmem
)
924 nvmem_unregister(mtd
->otp_user_nvmem
);
929 * mtd_device_parse_register - parse partitions and register an MTD device.
931 * @mtd: the MTD device to register
932 * @types: the list of MTD partition probes to try, see
933 * 'parse_mtd_partitions()' for more information
934 * @parser_data: MTD partition parser-specific data
935 * @parts: fallback partition information to register, if parsing fails;
936 * only valid if %nr_parts > %0
937 * @nr_parts: the number of partitions in parts, if zero then the full
938 * MTD device is registered if no partition info is found
940 * This function aggregates MTD partitions parsing (done by
941 * 'parse_mtd_partitions()') and MTD device and partitions registering. It
942 * basically follows the most common pattern found in many MTD drivers:
944 * * If the MTD_PARTITIONED_MASTER option is set, then the device as a whole is
946 * * Then It tries to probe partitions on MTD device @mtd using parsers
947 * specified in @types (if @types is %NULL, then the default list of parsers
948 * is used, see 'parse_mtd_partitions()' for more information). If none are
949 * found this functions tries to fallback to information specified in
951 * * If no partitions were found this function just registers the MTD device
954 * Returns zero in case of success and a negative error code in case of failure.
956 int mtd_device_parse_register(struct mtd_info
*mtd
, const char * const *types
,
957 struct mtd_part_parser_data
*parser_data
,
958 const struct mtd_partition
*parts
,
963 mtd_set_dev_defaults(mtd
);
965 if (IS_ENABLED(CONFIG_MTD_PARTITIONED_MASTER
)) {
966 ret
= add_mtd_device(mtd
);
971 /* Prefer parsed partitions over driver-provided fallback */
972 ret
= parse_mtd_partitions(mtd
, types
, parser_data
);
973 if (ret
== -EPROBE_DEFER
)
979 ret
= add_mtd_partitions(mtd
, parts
, nr_parts
);
980 else if (!device_is_registered(&mtd
->dev
))
981 ret
= add_mtd_device(mtd
);
989 * FIXME: some drivers unfortunately call this function more than once.
990 * So we have to check if we've already assigned the reboot notifier.
992 * Generally, we can make multiple calls work for most cases, but it
993 * does cause problems with parse_mtd_partitions() above (e.g.,
994 * cmdlineparts will register partitions more than once).
996 WARN_ONCE(mtd
->_reboot
&& mtd
->reboot_notifier
.notifier_call
,
997 "MTD already registered\n");
998 if (mtd
->_reboot
&& !mtd
->reboot_notifier
.notifier_call
) {
999 mtd
->reboot_notifier
.notifier_call
= mtd_reboot_notifier
;
1000 register_reboot_notifier(&mtd
->reboot_notifier
);
1003 ret
= mtd_otp_nvmem_add(mtd
);
1006 if (ret
&& device_is_registered(&mtd
->dev
))
1007 del_mtd_device(mtd
);
1011 EXPORT_SYMBOL_GPL(mtd_device_parse_register
);
1014 * mtd_device_unregister - unregister an existing MTD device.
1016 * @master: the MTD device to unregister. This will unregister both the master
1017 * and any partitions if registered.
1019 int mtd_device_unregister(struct mtd_info
*master
)
1023 if (master
->_reboot
)
1024 unregister_reboot_notifier(&master
->reboot_notifier
);
1026 if (master
->otp_user_nvmem
)
1027 nvmem_unregister(master
->otp_user_nvmem
);
1029 if (master
->otp_factory_nvmem
)
1030 nvmem_unregister(master
->otp_factory_nvmem
);
1032 err
= del_mtd_partitions(master
);
1036 if (!device_is_registered(&master
->dev
))
1039 return del_mtd_device(master
);
1041 EXPORT_SYMBOL_GPL(mtd_device_unregister
);
1044 * register_mtd_user - register a 'user' of MTD devices.
1045 * @new: pointer to notifier info structure
1047 * Registers a pair of callbacks function to be called upon addition
1048 * or removal of MTD devices. Causes the 'add' callback to be immediately
1049 * invoked for each MTD device currently present in the system.
1051 void register_mtd_user (struct mtd_notifier
*new)
1053 struct mtd_info
*mtd
;
1055 mutex_lock(&mtd_table_mutex
);
1057 list_add(&new->list
, &mtd_notifiers
);
1059 __module_get(THIS_MODULE
);
1061 mtd_for_each_device(mtd
)
1064 mutex_unlock(&mtd_table_mutex
);
1066 EXPORT_SYMBOL_GPL(register_mtd_user
);
1069 * unregister_mtd_user - unregister a 'user' of MTD devices.
1070 * @old: pointer to notifier info structure
1072 * Removes a callback function pair from the list of 'users' to be
1073 * notified upon addition or removal of MTD devices. Causes the
1074 * 'remove' callback to be immediately invoked for each MTD device
1075 * currently present in the system.
1077 int unregister_mtd_user (struct mtd_notifier
*old
)
1079 struct mtd_info
*mtd
;
1081 mutex_lock(&mtd_table_mutex
);
1083 module_put(THIS_MODULE
);
1085 mtd_for_each_device(mtd
)
1088 list_del(&old
->list
);
1089 mutex_unlock(&mtd_table_mutex
);
1092 EXPORT_SYMBOL_GPL(unregister_mtd_user
);
1095 * get_mtd_device - obtain a validated handle for an MTD device
1096 * @mtd: last known address of the required MTD device
1097 * @num: internal device number of the required MTD device
1099 * Given a number and NULL address, return the num'th entry in the device
1100 * table, if any. Given an address and num == -1, search the device table
1101 * for a device with that address and return if it's still present. Given
1102 * both, return the num'th driver only if its address matches. Return
1103 * error code if not.
1105 struct mtd_info
*get_mtd_device(struct mtd_info
*mtd
, int num
)
1107 struct mtd_info
*ret
= NULL
, *other
;
1110 mutex_lock(&mtd_table_mutex
);
1113 mtd_for_each_device(other
) {
1119 } else if (num
>= 0) {
1120 ret
= idr_find(&mtd_idr
, num
);
1121 if (mtd
&& mtd
!= ret
)
1130 err
= __get_mtd_device(ret
);
1134 mutex_unlock(&mtd_table_mutex
);
1137 EXPORT_SYMBOL_GPL(get_mtd_device
);
1140 int __get_mtd_device(struct mtd_info
*mtd
)
1142 struct mtd_info
*master
= mtd_get_master(mtd
);
1145 if (!try_module_get(master
->owner
))
1148 if (master
->_get_device
) {
1149 err
= master
->_get_device(mtd
);
1152 module_put(master
->owner
);
1159 while (mtd
->parent
) {
1166 EXPORT_SYMBOL_GPL(__get_mtd_device
);
1169 * get_mtd_device_nm - obtain a validated handle for an MTD device by
1171 * @name: MTD device name to open
1173 * This function returns MTD device description structure in case of
1174 * success and an error code in case of failure.
1176 struct mtd_info
*get_mtd_device_nm(const char *name
)
1179 struct mtd_info
*mtd
= NULL
, *other
;
1181 mutex_lock(&mtd_table_mutex
);
1183 mtd_for_each_device(other
) {
1184 if (!strcmp(name
, other
->name
)) {
1193 err
= __get_mtd_device(mtd
);
1197 mutex_unlock(&mtd_table_mutex
);
1201 mutex_unlock(&mtd_table_mutex
);
1202 return ERR_PTR(err
);
1204 EXPORT_SYMBOL_GPL(get_mtd_device_nm
);
1206 void put_mtd_device(struct mtd_info
*mtd
)
1208 mutex_lock(&mtd_table_mutex
);
1209 __put_mtd_device(mtd
);
1210 mutex_unlock(&mtd_table_mutex
);
1213 EXPORT_SYMBOL_GPL(put_mtd_device
);
1215 void __put_mtd_device(struct mtd_info
*mtd
)
1217 struct mtd_info
*master
= mtd_get_master(mtd
);
1219 while (mtd
->parent
) {
1221 BUG_ON(mtd
->usecount
< 0);
1227 if (master
->_put_device
)
1228 master
->_put_device(master
);
1230 module_put(master
->owner
);
1232 EXPORT_SYMBOL_GPL(__put_mtd_device
);
1235 * Erase is an synchronous operation. Device drivers are epected to return a
1236 * negative error code if the operation failed and update instr->fail_addr
1237 * to point the portion that was not properly erased.
1239 int mtd_erase(struct mtd_info
*mtd
, struct erase_info
*instr
)
1241 struct mtd_info
*master
= mtd_get_master(mtd
);
1242 u64 mst_ofs
= mtd_get_master_ofs(mtd
, 0);
1243 struct erase_info adjinstr
;
1246 instr
->fail_addr
= MTD_FAIL_ADDR_UNKNOWN
;
1249 if (!mtd
->erasesize
|| !master
->_erase
)
1252 if (instr
->addr
>= mtd
->size
|| instr
->len
> mtd
->size
- instr
->addr
)
1254 if (!(mtd
->flags
& MTD_WRITEABLE
))
1260 ledtrig_mtd_activity();
1262 if (mtd
->flags
& MTD_SLC_ON_MLC_EMULATION
) {
1263 adjinstr
.addr
= (loff_t
)mtd_div_by_eb(instr
->addr
, mtd
) *
1265 adjinstr
.len
= ((u64
)mtd_div_by_eb(instr
->addr
+ instr
->len
, mtd
) *
1266 master
->erasesize
) -
1270 adjinstr
.addr
+= mst_ofs
;
1272 ret
= master
->_erase(master
, &adjinstr
);
1274 if (adjinstr
.fail_addr
!= MTD_FAIL_ADDR_UNKNOWN
) {
1275 instr
->fail_addr
= adjinstr
.fail_addr
- mst_ofs
;
1276 if (mtd
->flags
& MTD_SLC_ON_MLC_EMULATION
) {
1277 instr
->fail_addr
= mtd_div_by_eb(instr
->fail_addr
,
1279 instr
->fail_addr
*= mtd
->erasesize
;
1285 EXPORT_SYMBOL_GPL(mtd_erase
);
1288 * This stuff for eXecute-In-Place. phys is optional and may be set to NULL.
1290 int mtd_point(struct mtd_info
*mtd
, loff_t from
, size_t len
, size_t *retlen
,
1291 void **virt
, resource_size_t
*phys
)
1293 struct mtd_info
*master
= mtd_get_master(mtd
);
1299 if (!master
->_point
)
1301 if (from
< 0 || from
>= mtd
->size
|| len
> mtd
->size
- from
)
1306 from
= mtd_get_master_ofs(mtd
, from
);
1307 return master
->_point(master
, from
, len
, retlen
, virt
, phys
);
1309 EXPORT_SYMBOL_GPL(mtd_point
);
1311 /* We probably shouldn't allow XIP if the unpoint isn't a NULL */
1312 int mtd_unpoint(struct mtd_info
*mtd
, loff_t from
, size_t len
)
1314 struct mtd_info
*master
= mtd_get_master(mtd
);
1316 if (!master
->_unpoint
)
1318 if (from
< 0 || from
>= mtd
->size
|| len
> mtd
->size
- from
)
1322 return master
->_unpoint(master
, mtd_get_master_ofs(mtd
, from
), len
);
1324 EXPORT_SYMBOL_GPL(mtd_unpoint
);
1327 * Allow NOMMU mmap() to directly map the device (if not NULL)
1328 * - return the address to which the offset maps
1329 * - return -ENOSYS to indicate refusal to do the mapping
1331 unsigned long mtd_get_unmapped_area(struct mtd_info
*mtd
, unsigned long len
,
1332 unsigned long offset
, unsigned long flags
)
1338 ret
= mtd_point(mtd
, offset
, len
, &retlen
, &virt
, NULL
);
1341 if (retlen
!= len
) {
1342 mtd_unpoint(mtd
, offset
, retlen
);
1345 return (unsigned long)virt
;
1347 EXPORT_SYMBOL_GPL(mtd_get_unmapped_area
);
1349 static void mtd_update_ecc_stats(struct mtd_info
*mtd
, struct mtd_info
*master
,
1350 const struct mtd_ecc_stats
*old_stats
)
1352 struct mtd_ecc_stats diff
;
1357 diff
= master
->ecc_stats
;
1358 diff
.failed
-= old_stats
->failed
;
1359 diff
.corrected
-= old_stats
->corrected
;
1361 while (mtd
->parent
) {
1362 mtd
->ecc_stats
.failed
+= diff
.failed
;
1363 mtd
->ecc_stats
.corrected
+= diff
.corrected
;
1368 int mtd_read(struct mtd_info
*mtd
, loff_t from
, size_t len
, size_t *retlen
,
1371 struct mtd_oob_ops ops
= {
1377 ret
= mtd_read_oob(mtd
, from
, &ops
);
1378 *retlen
= ops
.retlen
;
1382 EXPORT_SYMBOL_GPL(mtd_read
);
1384 int mtd_write(struct mtd_info
*mtd
, loff_t to
, size_t len
, size_t *retlen
,
1387 struct mtd_oob_ops ops
= {
1389 .datbuf
= (u8
*)buf
,
1393 ret
= mtd_write_oob(mtd
, to
, &ops
);
1394 *retlen
= ops
.retlen
;
1398 EXPORT_SYMBOL_GPL(mtd_write
);
1401 * In blackbox flight recorder like scenarios we want to make successful writes
1402 * in interrupt context. panic_write() is only intended to be called when its
1403 * known the kernel is about to panic and we need the write to succeed. Since
1404 * the kernel is not going to be running for much longer, this function can
1405 * break locks and delay to ensure the write succeeds (but not sleep).
1407 int mtd_panic_write(struct mtd_info
*mtd
, loff_t to
, size_t len
, size_t *retlen
,
1410 struct mtd_info
*master
= mtd_get_master(mtd
);
1413 if (!master
->_panic_write
)
1415 if (to
< 0 || to
>= mtd
->size
|| len
> mtd
->size
- to
)
1417 if (!(mtd
->flags
& MTD_WRITEABLE
))
1421 if (!master
->oops_panic_write
)
1422 master
->oops_panic_write
= true;
1424 return master
->_panic_write(master
, mtd_get_master_ofs(mtd
, to
), len
,
1427 EXPORT_SYMBOL_GPL(mtd_panic_write
);
1429 static int mtd_check_oob_ops(struct mtd_info
*mtd
, loff_t offs
,
1430 struct mtd_oob_ops
*ops
)
1433 * Some users are setting ->datbuf or ->oobbuf to NULL, but are leaving
1434 * ->len or ->ooblen uninitialized. Force ->len and ->ooblen to 0 in
1443 if (offs
< 0 || offs
+ ops
->len
> mtd
->size
)
1449 if (ops
->ooboffs
>= mtd_oobavail(mtd
, ops
))
1452 maxooblen
= ((size_t)(mtd_div_by_ws(mtd
->size
, mtd
) -
1453 mtd_div_by_ws(offs
, mtd
)) *
1454 mtd_oobavail(mtd
, ops
)) - ops
->ooboffs
;
1455 if (ops
->ooblen
> maxooblen
)
1462 static int mtd_read_oob_std(struct mtd_info
*mtd
, loff_t from
,
1463 struct mtd_oob_ops
*ops
)
1465 struct mtd_info
*master
= mtd_get_master(mtd
);
1468 from
= mtd_get_master_ofs(mtd
, from
);
1469 if (master
->_read_oob
)
1470 ret
= master
->_read_oob(master
, from
, ops
);
1472 ret
= master
->_read(master
, from
, ops
->len
, &ops
->retlen
,
1478 static int mtd_write_oob_std(struct mtd_info
*mtd
, loff_t to
,
1479 struct mtd_oob_ops
*ops
)
1481 struct mtd_info
*master
= mtd_get_master(mtd
);
1484 to
= mtd_get_master_ofs(mtd
, to
);
1485 if (master
->_write_oob
)
1486 ret
= master
->_write_oob(master
, to
, ops
);
1488 ret
= master
->_write(master
, to
, ops
->len
, &ops
->retlen
,
1494 static int mtd_io_emulated_slc(struct mtd_info
*mtd
, loff_t start
, bool read
,
1495 struct mtd_oob_ops
*ops
)
1497 struct mtd_info
*master
= mtd_get_master(mtd
);
1498 int ngroups
= mtd_pairing_groups(master
);
1499 int npairs
= mtd_wunit_per_eb(master
) / ngroups
;
1500 struct mtd_oob_ops adjops
= *ops
;
1501 unsigned int wunit
, oobavail
;
1502 struct mtd_pairing_info info
;
1503 int max_bitflips
= 0;
1507 ebofs
= mtd_mod_by_eb(start
, mtd
);
1508 base
= (loff_t
)mtd_div_by_eb(start
, mtd
) * master
->erasesize
;
1510 info
.pair
= mtd_div_by_ws(ebofs
, mtd
);
1511 pageofs
= mtd_mod_by_ws(ebofs
, mtd
);
1512 oobavail
= mtd_oobavail(mtd
, ops
);
1514 while (ops
->retlen
< ops
->len
|| ops
->oobretlen
< ops
->ooblen
) {
1517 if (info
.pair
>= npairs
) {
1519 base
+= master
->erasesize
;
1522 wunit
= mtd_pairing_info_to_wunit(master
, &info
);
1523 pos
= mtd_wunit_to_offset(mtd
, base
, wunit
);
1525 adjops
.len
= ops
->len
- ops
->retlen
;
1526 if (adjops
.len
> mtd
->writesize
- pageofs
)
1527 adjops
.len
= mtd
->writesize
- pageofs
;
1529 adjops
.ooblen
= ops
->ooblen
- ops
->oobretlen
;
1530 if (adjops
.ooblen
> oobavail
- adjops
.ooboffs
)
1531 adjops
.ooblen
= oobavail
- adjops
.ooboffs
;
1534 ret
= mtd_read_oob_std(mtd
, pos
+ pageofs
, &adjops
);
1536 max_bitflips
= max(max_bitflips
, ret
);
1538 ret
= mtd_write_oob_std(mtd
, pos
+ pageofs
, &adjops
);
1544 max_bitflips
= max(max_bitflips
, ret
);
1545 ops
->retlen
+= adjops
.retlen
;
1546 ops
->oobretlen
+= adjops
.oobretlen
;
1547 adjops
.datbuf
+= adjops
.retlen
;
1548 adjops
.oobbuf
+= adjops
.oobretlen
;
1554 return max_bitflips
;
1557 int mtd_read_oob(struct mtd_info
*mtd
, loff_t from
, struct mtd_oob_ops
*ops
)
1559 struct mtd_info
*master
= mtd_get_master(mtd
);
1560 struct mtd_ecc_stats old_stats
= master
->ecc_stats
;
1563 ops
->retlen
= ops
->oobretlen
= 0;
1565 ret_code
= mtd_check_oob_ops(mtd
, from
, ops
);
1569 ledtrig_mtd_activity();
1571 /* Check the validity of a potential fallback on mtd->_read */
1572 if (!master
->_read_oob
&& (!master
->_read
|| ops
->oobbuf
))
1575 if (mtd
->flags
& MTD_SLC_ON_MLC_EMULATION
)
1576 ret_code
= mtd_io_emulated_slc(mtd
, from
, true, ops
);
1578 ret_code
= mtd_read_oob_std(mtd
, from
, ops
);
1580 mtd_update_ecc_stats(mtd
, master
, &old_stats
);
1583 * In cases where ops->datbuf != NULL, mtd->_read_oob() has semantics
1584 * similar to mtd->_read(), returning a non-negative integer
1585 * representing max bitflips. In other cases, mtd->_read_oob() may
1586 * return -EUCLEAN. In all cases, perform similar logic to mtd_read().
1588 if (unlikely(ret_code
< 0))
1590 if (mtd
->ecc_strength
== 0)
1591 return 0; /* device lacks ecc */
1592 return ret_code
>= mtd
->bitflip_threshold
? -EUCLEAN
: 0;
1594 EXPORT_SYMBOL_GPL(mtd_read_oob
);
1596 int mtd_write_oob(struct mtd_info
*mtd
, loff_t to
,
1597 struct mtd_oob_ops
*ops
)
1599 struct mtd_info
*master
= mtd_get_master(mtd
);
1602 ops
->retlen
= ops
->oobretlen
= 0;
1604 if (!(mtd
->flags
& MTD_WRITEABLE
))
1607 ret
= mtd_check_oob_ops(mtd
, to
, ops
);
1611 ledtrig_mtd_activity();
1613 /* Check the validity of a potential fallback on mtd->_write */
1614 if (!master
->_write_oob
&& (!master
->_write
|| ops
->oobbuf
))
1617 if (mtd
->flags
& MTD_SLC_ON_MLC_EMULATION
)
1618 return mtd_io_emulated_slc(mtd
, to
, false, ops
);
1620 return mtd_write_oob_std(mtd
, to
, ops
);
1622 EXPORT_SYMBOL_GPL(mtd_write_oob
);
1625 * mtd_ooblayout_ecc - Get the OOB region definition of a specific ECC section
1626 * @mtd: MTD device structure
1627 * @section: ECC section. Depending on the layout you may have all the ECC
1628 * bytes stored in a single contiguous section, or one section
1629 * per ECC chunk (and sometime several sections for a single ECC
1631 * @oobecc: OOB region struct filled with the appropriate ECC position
1634 * This function returns ECC section information in the OOB area. If you want
1635 * to get all the ECC bytes information, then you should call
1636 * mtd_ooblayout_ecc(mtd, section++, oobecc) until it returns -ERANGE.
1638 * Returns zero on success, a negative error code otherwise.
1640 int mtd_ooblayout_ecc(struct mtd_info
*mtd
, int section
,
1641 struct mtd_oob_region
*oobecc
)
1643 struct mtd_info
*master
= mtd_get_master(mtd
);
1645 memset(oobecc
, 0, sizeof(*oobecc
));
1647 if (!master
|| section
< 0)
1650 if (!master
->ooblayout
|| !master
->ooblayout
->ecc
)
1653 return master
->ooblayout
->ecc(master
, section
, oobecc
);
1655 EXPORT_SYMBOL_GPL(mtd_ooblayout_ecc
);
1658 * mtd_ooblayout_free - Get the OOB region definition of a specific free
1660 * @mtd: MTD device structure
1661 * @section: Free section you are interested in. Depending on the layout
1662 * you may have all the free bytes stored in a single contiguous
1663 * section, or one section per ECC chunk plus an extra section
1664 * for the remaining bytes (or other funky layout).
1665 * @oobfree: OOB region struct filled with the appropriate free position
1668 * This function returns free bytes position in the OOB area. If you want
1669 * to get all the free bytes information, then you should call
1670 * mtd_ooblayout_free(mtd, section++, oobfree) until it returns -ERANGE.
1672 * Returns zero on success, a negative error code otherwise.
1674 int mtd_ooblayout_free(struct mtd_info
*mtd
, int section
,
1675 struct mtd_oob_region
*oobfree
)
1677 struct mtd_info
*master
= mtd_get_master(mtd
);
1679 memset(oobfree
, 0, sizeof(*oobfree
));
1681 if (!master
|| section
< 0)
1684 if (!master
->ooblayout
|| !master
->ooblayout
->free
)
1687 return master
->ooblayout
->free(master
, section
, oobfree
);
1689 EXPORT_SYMBOL_GPL(mtd_ooblayout_free
);
1692 * mtd_ooblayout_find_region - Find the region attached to a specific byte
1693 * @mtd: mtd info structure
1694 * @byte: the byte we are searching for
1695 * @sectionp: pointer where the section id will be stored
1696 * @oobregion: used to retrieve the ECC position
1697 * @iter: iterator function. Should be either mtd_ooblayout_free or
1698 * mtd_ooblayout_ecc depending on the region type you're searching for
1700 * This function returns the section id and oobregion information of a
1701 * specific byte. For example, say you want to know where the 4th ECC byte is
1702 * stored, you'll use:
1704 * mtd_ooblayout_find_region(mtd, 3, §ion, &oobregion, mtd_ooblayout_ecc);
1706 * Returns zero on success, a negative error code otherwise.
1708 static int mtd_ooblayout_find_region(struct mtd_info
*mtd
, int byte
,
1709 int *sectionp
, struct mtd_oob_region
*oobregion
,
1710 int (*iter
)(struct mtd_info
*,
1712 struct mtd_oob_region
*oobregion
))
1714 int pos
= 0, ret
, section
= 0;
1716 memset(oobregion
, 0, sizeof(*oobregion
));
1719 ret
= iter(mtd
, section
, oobregion
);
1723 if (pos
+ oobregion
->length
> byte
)
1726 pos
+= oobregion
->length
;
1731 * Adjust region info to make it start at the beginning at the
1734 oobregion
->offset
+= byte
- pos
;
1735 oobregion
->length
-= byte
- pos
;
1736 *sectionp
= section
;
1742 * mtd_ooblayout_find_eccregion - Find the ECC region attached to a specific
1744 * @mtd: mtd info structure
1745 * @eccbyte: the byte we are searching for
1746 * @section: pointer where the section id will be stored
1747 * @oobregion: OOB region information
1749 * Works like mtd_ooblayout_find_region() except it searches for a specific ECC
1752 * Returns zero on success, a negative error code otherwise.
1754 int mtd_ooblayout_find_eccregion(struct mtd_info
*mtd
, int eccbyte
,
1756 struct mtd_oob_region
*oobregion
)
1758 return mtd_ooblayout_find_region(mtd
, eccbyte
, section
, oobregion
,
1761 EXPORT_SYMBOL_GPL(mtd_ooblayout_find_eccregion
);
1764 * mtd_ooblayout_get_bytes - Extract OOB bytes from the oob buffer
1765 * @mtd: mtd info structure
1766 * @buf: destination buffer to store OOB bytes
1767 * @oobbuf: OOB buffer
1768 * @start: first byte to retrieve
1769 * @nbytes: number of bytes to retrieve
1770 * @iter: section iterator
1772 * Extract bytes attached to a specific category (ECC or free)
1773 * from the OOB buffer and copy them into buf.
1775 * Returns zero on success, a negative error code otherwise.
1777 static int mtd_ooblayout_get_bytes(struct mtd_info
*mtd
, u8
*buf
,
1778 const u8
*oobbuf
, int start
, int nbytes
,
1779 int (*iter
)(struct mtd_info
*,
1781 struct mtd_oob_region
*oobregion
))
1783 struct mtd_oob_region oobregion
;
1786 ret
= mtd_ooblayout_find_region(mtd
, start
, §ion
,
1792 cnt
= min_t(int, nbytes
, oobregion
.length
);
1793 memcpy(buf
, oobbuf
+ oobregion
.offset
, cnt
);
1800 ret
= iter(mtd
, ++section
, &oobregion
);
1807 * mtd_ooblayout_set_bytes - put OOB bytes into the oob buffer
1808 * @mtd: mtd info structure
1809 * @buf: source buffer to get OOB bytes from
1810 * @oobbuf: OOB buffer
1811 * @start: first OOB byte to set
1812 * @nbytes: number of OOB bytes to set
1813 * @iter: section iterator
1815 * Fill the OOB buffer with data provided in buf. The category (ECC or free)
1816 * is selected by passing the appropriate iterator.
1818 * Returns zero on success, a negative error code otherwise.
1820 static int mtd_ooblayout_set_bytes(struct mtd_info
*mtd
, const u8
*buf
,
1821 u8
*oobbuf
, int start
, int nbytes
,
1822 int (*iter
)(struct mtd_info
*,
1824 struct mtd_oob_region
*oobregion
))
1826 struct mtd_oob_region oobregion
;
1829 ret
= mtd_ooblayout_find_region(mtd
, start
, §ion
,
1835 cnt
= min_t(int, nbytes
, oobregion
.length
);
1836 memcpy(oobbuf
+ oobregion
.offset
, buf
, cnt
);
1843 ret
= iter(mtd
, ++section
, &oobregion
);
1850 * mtd_ooblayout_count_bytes - count the number of bytes in a OOB category
1851 * @mtd: mtd info structure
1852 * @iter: category iterator
1854 * Count the number of bytes in a given category.
1856 * Returns a positive value on success, a negative error code otherwise.
1858 static int mtd_ooblayout_count_bytes(struct mtd_info
*mtd
,
1859 int (*iter
)(struct mtd_info
*,
1861 struct mtd_oob_region
*oobregion
))
1863 struct mtd_oob_region oobregion
;
1864 int section
= 0, ret
, nbytes
= 0;
1867 ret
= iter(mtd
, section
++, &oobregion
);
1874 nbytes
+= oobregion
.length
;
1881 * mtd_ooblayout_get_eccbytes - extract ECC bytes from the oob buffer
1882 * @mtd: mtd info structure
1883 * @eccbuf: destination buffer to store ECC bytes
1884 * @oobbuf: OOB buffer
1885 * @start: first ECC byte to retrieve
1886 * @nbytes: number of ECC bytes to retrieve
1888 * Works like mtd_ooblayout_get_bytes(), except it acts on ECC bytes.
1890 * Returns zero on success, a negative error code otherwise.
1892 int mtd_ooblayout_get_eccbytes(struct mtd_info
*mtd
, u8
*eccbuf
,
1893 const u8
*oobbuf
, int start
, int nbytes
)
1895 return mtd_ooblayout_get_bytes(mtd
, eccbuf
, oobbuf
, start
, nbytes
,
1898 EXPORT_SYMBOL_GPL(mtd_ooblayout_get_eccbytes
);
1901 * mtd_ooblayout_set_eccbytes - set ECC bytes into the oob buffer
1902 * @mtd: mtd info structure
1903 * @eccbuf: source buffer to get ECC bytes from
1904 * @oobbuf: OOB buffer
1905 * @start: first ECC byte to set
1906 * @nbytes: number of ECC bytes to set
1908 * Works like mtd_ooblayout_set_bytes(), except it acts on ECC bytes.
1910 * Returns zero on success, a negative error code otherwise.
1912 int mtd_ooblayout_set_eccbytes(struct mtd_info
*mtd
, const u8
*eccbuf
,
1913 u8
*oobbuf
, int start
, int nbytes
)
1915 return mtd_ooblayout_set_bytes(mtd
, eccbuf
, oobbuf
, start
, nbytes
,
1918 EXPORT_SYMBOL_GPL(mtd_ooblayout_set_eccbytes
);
1921 * mtd_ooblayout_get_databytes - extract data bytes from the oob buffer
1922 * @mtd: mtd info structure
1923 * @databuf: destination buffer to store ECC bytes
1924 * @oobbuf: OOB buffer
1925 * @start: first ECC byte to retrieve
1926 * @nbytes: number of ECC bytes to retrieve
1928 * Works like mtd_ooblayout_get_bytes(), except it acts on free bytes.
1930 * Returns zero on success, a negative error code otherwise.
1932 int mtd_ooblayout_get_databytes(struct mtd_info
*mtd
, u8
*databuf
,
1933 const u8
*oobbuf
, int start
, int nbytes
)
1935 return mtd_ooblayout_get_bytes(mtd
, databuf
, oobbuf
, start
, nbytes
,
1936 mtd_ooblayout_free
);
1938 EXPORT_SYMBOL_GPL(mtd_ooblayout_get_databytes
);
1941 * mtd_ooblayout_set_databytes - set data bytes into the oob buffer
1942 * @mtd: mtd info structure
1943 * @databuf: source buffer to get data bytes from
1944 * @oobbuf: OOB buffer
1945 * @start: first ECC byte to set
1946 * @nbytes: number of ECC bytes to set
1948 * Works like mtd_ooblayout_set_bytes(), except it acts on free bytes.
1950 * Returns zero on success, a negative error code otherwise.
1952 int mtd_ooblayout_set_databytes(struct mtd_info
*mtd
, const u8
*databuf
,
1953 u8
*oobbuf
, int start
, int nbytes
)
1955 return mtd_ooblayout_set_bytes(mtd
, databuf
, oobbuf
, start
, nbytes
,
1956 mtd_ooblayout_free
);
1958 EXPORT_SYMBOL_GPL(mtd_ooblayout_set_databytes
);
1961 * mtd_ooblayout_count_freebytes - count the number of free bytes in OOB
1962 * @mtd: mtd info structure
1964 * Works like mtd_ooblayout_count_bytes(), except it count free bytes.
1966 * Returns zero on success, a negative error code otherwise.
1968 int mtd_ooblayout_count_freebytes(struct mtd_info
*mtd
)
1970 return mtd_ooblayout_count_bytes(mtd
, mtd_ooblayout_free
);
1972 EXPORT_SYMBOL_GPL(mtd_ooblayout_count_freebytes
);
1975 * mtd_ooblayout_count_eccbytes - count the number of ECC bytes in OOB
1976 * @mtd: mtd info structure
1978 * Works like mtd_ooblayout_count_bytes(), except it count ECC bytes.
1980 * Returns zero on success, a negative error code otherwise.
1982 int mtd_ooblayout_count_eccbytes(struct mtd_info
*mtd
)
1984 return mtd_ooblayout_count_bytes(mtd
, mtd_ooblayout_ecc
);
1986 EXPORT_SYMBOL_GPL(mtd_ooblayout_count_eccbytes
);
1989 * Method to access the protection register area, present in some flash
1990 * devices. The user data is one time programmable but the factory data is read
1993 int mtd_get_fact_prot_info(struct mtd_info
*mtd
, size_t len
, size_t *retlen
,
1994 struct otp_info
*buf
)
1996 struct mtd_info
*master
= mtd_get_master(mtd
);
1998 if (!master
->_get_fact_prot_info
)
2002 return master
->_get_fact_prot_info(master
, len
, retlen
, buf
);
2004 EXPORT_SYMBOL_GPL(mtd_get_fact_prot_info
);
2006 int mtd_read_fact_prot_reg(struct mtd_info
*mtd
, loff_t from
, size_t len
,
2007 size_t *retlen
, u_char
*buf
)
2009 struct mtd_info
*master
= mtd_get_master(mtd
);
2012 if (!master
->_read_fact_prot_reg
)
2016 return master
->_read_fact_prot_reg(master
, from
, len
, retlen
, buf
);
2018 EXPORT_SYMBOL_GPL(mtd_read_fact_prot_reg
);
2020 int mtd_get_user_prot_info(struct mtd_info
*mtd
, size_t len
, size_t *retlen
,
2021 struct otp_info
*buf
)
2023 struct mtd_info
*master
= mtd_get_master(mtd
);
2025 if (!master
->_get_user_prot_info
)
2029 return master
->_get_user_prot_info(master
, len
, retlen
, buf
);
2031 EXPORT_SYMBOL_GPL(mtd_get_user_prot_info
);
2033 int mtd_read_user_prot_reg(struct mtd_info
*mtd
, loff_t from
, size_t len
,
2034 size_t *retlen
, u_char
*buf
)
2036 struct mtd_info
*master
= mtd_get_master(mtd
);
2039 if (!master
->_read_user_prot_reg
)
2043 return master
->_read_user_prot_reg(master
, from
, len
, retlen
, buf
);
2045 EXPORT_SYMBOL_GPL(mtd_read_user_prot_reg
);
2047 int mtd_write_user_prot_reg(struct mtd_info
*mtd
, loff_t to
, size_t len
,
2048 size_t *retlen
, const u_char
*buf
)
2050 struct mtd_info
*master
= mtd_get_master(mtd
);
2054 if (!master
->_write_user_prot_reg
)
2058 ret
= master
->_write_user_prot_reg(master
, to
, len
, retlen
, buf
);
2063 * If no data could be written at all, we are out of memory and
2064 * must return -ENOSPC.
2066 return (*retlen
) ? 0 : -ENOSPC
;
2068 EXPORT_SYMBOL_GPL(mtd_write_user_prot_reg
);
2070 int mtd_lock_user_prot_reg(struct mtd_info
*mtd
, loff_t from
, size_t len
)
2072 struct mtd_info
*master
= mtd_get_master(mtd
);
2074 if (!master
->_lock_user_prot_reg
)
2078 return master
->_lock_user_prot_reg(master
, from
, len
);
2080 EXPORT_SYMBOL_GPL(mtd_lock_user_prot_reg
);
2082 int mtd_erase_user_prot_reg(struct mtd_info
*mtd
, loff_t from
, size_t len
)
2084 struct mtd_info
*master
= mtd_get_master(mtd
);
2086 if (!master
->_erase_user_prot_reg
)
2090 return master
->_erase_user_prot_reg(master
, from
, len
);
2092 EXPORT_SYMBOL_GPL(mtd_erase_user_prot_reg
);
2094 /* Chip-supported device locking */
2095 int mtd_lock(struct mtd_info
*mtd
, loff_t ofs
, uint64_t len
)
2097 struct mtd_info
*master
= mtd_get_master(mtd
);
2101 if (ofs
< 0 || ofs
>= mtd
->size
|| len
> mtd
->size
- ofs
)
2106 if (mtd
->flags
& MTD_SLC_ON_MLC_EMULATION
) {
2107 ofs
= (loff_t
)mtd_div_by_eb(ofs
, mtd
) * master
->erasesize
;
2108 len
= (u64
)mtd_div_by_eb(len
, mtd
) * master
->erasesize
;
2111 return master
->_lock(master
, mtd_get_master_ofs(mtd
, ofs
), len
);
2113 EXPORT_SYMBOL_GPL(mtd_lock
);
2115 int mtd_unlock(struct mtd_info
*mtd
, loff_t ofs
, uint64_t len
)
2117 struct mtd_info
*master
= mtd_get_master(mtd
);
2119 if (!master
->_unlock
)
2121 if (ofs
< 0 || ofs
>= mtd
->size
|| len
> mtd
->size
- ofs
)
2126 if (mtd
->flags
& MTD_SLC_ON_MLC_EMULATION
) {
2127 ofs
= (loff_t
)mtd_div_by_eb(ofs
, mtd
) * master
->erasesize
;
2128 len
= (u64
)mtd_div_by_eb(len
, mtd
) * master
->erasesize
;
2131 return master
->_unlock(master
, mtd_get_master_ofs(mtd
, ofs
), len
);
2133 EXPORT_SYMBOL_GPL(mtd_unlock
);
2135 int mtd_is_locked(struct mtd_info
*mtd
, loff_t ofs
, uint64_t len
)
2137 struct mtd_info
*master
= mtd_get_master(mtd
);
2139 if (!master
->_is_locked
)
2141 if (ofs
< 0 || ofs
>= mtd
->size
|| len
> mtd
->size
- ofs
)
2146 if (mtd
->flags
& MTD_SLC_ON_MLC_EMULATION
) {
2147 ofs
= (loff_t
)mtd_div_by_eb(ofs
, mtd
) * master
->erasesize
;
2148 len
= (u64
)mtd_div_by_eb(len
, mtd
) * master
->erasesize
;
2151 return master
->_is_locked(master
, mtd_get_master_ofs(mtd
, ofs
), len
);
2153 EXPORT_SYMBOL_GPL(mtd_is_locked
);
2155 int mtd_block_isreserved(struct mtd_info
*mtd
, loff_t ofs
)
2157 struct mtd_info
*master
= mtd_get_master(mtd
);
2159 if (ofs
< 0 || ofs
>= mtd
->size
)
2161 if (!master
->_block_isreserved
)
2164 if (mtd
->flags
& MTD_SLC_ON_MLC_EMULATION
)
2165 ofs
= (loff_t
)mtd_div_by_eb(ofs
, mtd
) * master
->erasesize
;
2167 return master
->_block_isreserved(master
, mtd_get_master_ofs(mtd
, ofs
));
2169 EXPORT_SYMBOL_GPL(mtd_block_isreserved
);
2171 int mtd_block_isbad(struct mtd_info
*mtd
, loff_t ofs
)
2173 struct mtd_info
*master
= mtd_get_master(mtd
);
2175 if (ofs
< 0 || ofs
>= mtd
->size
)
2177 if (!master
->_block_isbad
)
2180 if (mtd
->flags
& MTD_SLC_ON_MLC_EMULATION
)
2181 ofs
= (loff_t
)mtd_div_by_eb(ofs
, mtd
) * master
->erasesize
;
2183 return master
->_block_isbad(master
, mtd_get_master_ofs(mtd
, ofs
));
2185 EXPORT_SYMBOL_GPL(mtd_block_isbad
);
2187 int mtd_block_markbad(struct mtd_info
*mtd
, loff_t ofs
)
2189 struct mtd_info
*master
= mtd_get_master(mtd
);
2192 if (!master
->_block_markbad
)
2194 if (ofs
< 0 || ofs
>= mtd
->size
)
2196 if (!(mtd
->flags
& MTD_WRITEABLE
))
2199 if (mtd
->flags
& MTD_SLC_ON_MLC_EMULATION
)
2200 ofs
= (loff_t
)mtd_div_by_eb(ofs
, mtd
) * master
->erasesize
;
2202 ret
= master
->_block_markbad(master
, mtd_get_master_ofs(mtd
, ofs
));
2206 while (mtd
->parent
) {
2207 mtd
->ecc_stats
.badblocks
++;
2213 EXPORT_SYMBOL_GPL(mtd_block_markbad
);
2216 * default_mtd_writev - the default writev method
2217 * @mtd: mtd device description object pointer
2218 * @vecs: the vectors to write
2219 * @count: count of vectors in @vecs
2220 * @to: the MTD device offset to write to
2221 * @retlen: on exit contains the count of bytes written to the MTD device.
2223 * This function returns zero in case of success and a negative error code in
2226 static int default_mtd_writev(struct mtd_info
*mtd
, const struct kvec
*vecs
,
2227 unsigned long count
, loff_t to
, size_t *retlen
)
2230 size_t totlen
= 0, thislen
;
2233 for (i
= 0; i
< count
; i
++) {
2234 if (!vecs
[i
].iov_len
)
2236 ret
= mtd_write(mtd
, to
, vecs
[i
].iov_len
, &thislen
,
2239 if (ret
|| thislen
!= vecs
[i
].iov_len
)
2241 to
+= vecs
[i
].iov_len
;
2248 * mtd_writev - the vector-based MTD write method
2249 * @mtd: mtd device description object pointer
2250 * @vecs: the vectors to write
2251 * @count: count of vectors in @vecs
2252 * @to: the MTD device offset to write to
2253 * @retlen: on exit contains the count of bytes written to the MTD device.
2255 * This function returns zero in case of success and a negative error code in
2258 int mtd_writev(struct mtd_info
*mtd
, const struct kvec
*vecs
,
2259 unsigned long count
, loff_t to
, size_t *retlen
)
2261 struct mtd_info
*master
= mtd_get_master(mtd
);
2264 if (!(mtd
->flags
& MTD_WRITEABLE
))
2267 if (!master
->_writev
)
2268 return default_mtd_writev(mtd
, vecs
, count
, to
, retlen
);
2270 return master
->_writev(master
, vecs
, count
,
2271 mtd_get_master_ofs(mtd
, to
), retlen
);
2273 EXPORT_SYMBOL_GPL(mtd_writev
);
2276 * mtd_kmalloc_up_to - allocate a contiguous buffer up to the specified size
2277 * @mtd: mtd device description object pointer
2278 * @size: a pointer to the ideal or maximum size of the allocation, points
2279 * to the actual allocation size on success.
2281 * This routine attempts to allocate a contiguous kernel buffer up to
2282 * the specified size, backing off the size of the request exponentially
2283 * until the request succeeds or until the allocation size falls below
2284 * the system page size. This attempts to make sure it does not adversely
2285 * impact system performance, so when allocating more than one page, we
2286 * ask the memory allocator to avoid re-trying, swapping, writing back
2287 * or performing I/O.
2289 * Note, this function also makes sure that the allocated buffer is aligned to
2290 * the MTD device's min. I/O unit, i.e. the "mtd->writesize" value.
2292 * This is called, for example by mtd_{read,write} and jffs2_scan_medium,
2293 * to handle smaller (i.e. degraded) buffer allocations under low- or
2294 * fragmented-memory situations where such reduced allocations, from a
2295 * requested ideal, are allowed.
2297 * Returns a pointer to the allocated buffer on success; otherwise, NULL.
2299 void *mtd_kmalloc_up_to(const struct mtd_info
*mtd
, size_t *size
)
2301 gfp_t flags
= __GFP_NOWARN
| __GFP_DIRECT_RECLAIM
| __GFP_NORETRY
;
2302 size_t min_alloc
= max_t(size_t, mtd
->writesize
, PAGE_SIZE
);
2305 *size
= min_t(size_t, *size
, KMALLOC_MAX_SIZE
);
2307 while (*size
> min_alloc
) {
2308 kbuf
= kmalloc(*size
, flags
);
2313 *size
= ALIGN(*size
, mtd
->writesize
);
2317 * For the last resort allocation allow 'kmalloc()' to do all sorts of
2318 * things (write-back, dropping caches, etc) by using GFP_KERNEL.
2320 return kmalloc(*size
, GFP_KERNEL
);
2322 EXPORT_SYMBOL_GPL(mtd_kmalloc_up_to
);
2324 #ifdef CONFIG_PROC_FS
2326 /*====================================================================*/
2327 /* Support for /proc/mtd */
2329 static int mtd_proc_show(struct seq_file
*m
, void *v
)
2331 struct mtd_info
*mtd
;
2333 seq_puts(m
, "dev: size erasesize name\n");
2334 mutex_lock(&mtd_table_mutex
);
2335 mtd_for_each_device(mtd
) {
2336 seq_printf(m
, "mtd%d: %8.8llx %8.8x \"%s\"\n",
2337 mtd
->index
, (unsigned long long)mtd
->size
,
2338 mtd
->erasesize
, mtd
->name
);
2340 mutex_unlock(&mtd_table_mutex
);
2343 #endif /* CONFIG_PROC_FS */
2345 /*====================================================================*/
2348 static struct backing_dev_info
* __init
mtd_bdi_init(const char *name
)
2350 struct backing_dev_info
*bdi
;
2353 bdi
= bdi_alloc(NUMA_NO_NODE
);
2355 return ERR_PTR(-ENOMEM
);
2360 * We put '-0' suffix to the name to get the same name format as we
2361 * used to get. Since this is called only once, we get a unique name.
2363 ret
= bdi_register(bdi
, "%.28s-0", name
);
2367 return ret
? ERR_PTR(ret
) : bdi
;
2370 static struct proc_dir_entry
*proc_mtd
;
2372 static int __init
init_mtd(void)
2376 ret
= class_register(&mtd_class
);
2380 mtd_bdi
= mtd_bdi_init("mtd");
2381 if (IS_ERR(mtd_bdi
)) {
2382 ret
= PTR_ERR(mtd_bdi
);
2386 proc_mtd
= proc_create_single("mtd", 0, NULL
, mtd_proc_show
);
2388 ret
= init_mtdchar();
2392 dfs_dir_mtd
= debugfs_create_dir("mtd", NULL
);
2398 remove_proc_entry("mtd", NULL
);
2401 class_unregister(&mtd_class
);
2403 pr_err("Error registering mtd class or bdi: %d\n", ret
);
2407 static void __exit
cleanup_mtd(void)
2409 debugfs_remove_recursive(dfs_dir_mtd
);
2412 remove_proc_entry("mtd", NULL
);
2413 class_unregister(&mtd_class
);
2415 idr_destroy(&mtd_idr
);
2418 module_init(init_mtd
);
2419 module_exit(cleanup_mtd
);
2421 MODULE_LICENSE("GPL");
2422 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
2423 MODULE_DESCRIPTION("Core MTD registration and access routines");