2 * Core registration and callback routines for MTD
5 * Copyright © 1999-2010 David Woodhouse <dwmw2@infradead.org>
6 * Copyright © 2006 Red Hat UK Limited
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24 #include <linux/module.h>
25 #include <linux/kernel.h>
26 #include <linux/ptrace.h>
27 #include <linux/seq_file.h>
28 #include <linux/string.h>
29 #include <linux/timer.h>
30 #include <linux/major.h>
32 #include <linux/err.h>
33 #include <linux/ioctl.h>
34 #include <linux/init.h>
35 #include <linux/proc_fs.h>
36 #include <linux/idr.h>
37 #include <linux/backing-dev.h>
38 #include <linux/gfp.h>
40 #include <linux/mtd/mtd.h>
41 #include <linux/mtd/partitions.h>
45 * backing device capabilities for non-mappable devices (such as NAND flash)
46 * - permits private mappings, copies are taken of the data
48 static struct backing_dev_info mtd_bdi_unmappable = {
49 .capabilities = BDI_CAP_MAP_COPY,
53 * backing device capabilities for R/O mappable devices (such as ROM)
54 * - permits private mappings, copies are taken of the data
55 * - permits non-writable shared mappings
57 static struct backing_dev_info mtd_bdi_ro_mappable = {
58 .capabilities = (BDI_CAP_MAP_COPY | BDI_CAP_MAP_DIRECT |
59 BDI_CAP_EXEC_MAP | BDI_CAP_READ_MAP),
63 * backing device capabilities for writable mappable devices (such as RAM)
64 * - permits private mappings, copies are taken of the data
65 * - permits non-writable shared mappings
67 static struct backing_dev_info mtd_bdi_rw_mappable = {
68 .capabilities = (BDI_CAP_MAP_COPY | BDI_CAP_MAP_DIRECT |
69 BDI_CAP_EXEC_MAP | BDI_CAP_READ_MAP |
73 static int mtd_cls_suspend(struct device *dev, pm_message_t state);
74 static int mtd_cls_resume(struct device *dev);
76 static struct class mtd_class = {
79 .suspend = mtd_cls_suspend,
80 .resume = mtd_cls_resume,
83 static DEFINE_IDR(mtd_idr);
85 /* These are exported solely for the purpose of mtd_blkdevs.c. You
86 should not use them for _anything_ else */
87 DEFINE_MUTEX(mtd_table_mutex);
88 EXPORT_SYMBOL_GPL(mtd_table_mutex);
90 struct mtd_info *__mtd_next_device(int i)
92 return idr_get_next(&mtd_idr, &i);
94 EXPORT_SYMBOL_GPL(__mtd_next_device);
96 static LIST_HEAD(mtd_notifiers);
99 #if defined(CONFIG_MTD_CHAR) || defined(CONFIG_MTD_CHAR_MODULE)
100 #define MTD_DEVT(index) MKDEV(MTD_CHAR_MAJOR, (index)*2)
102 #define MTD_DEVT(index) 0
105 /* REVISIT once MTD uses the driver model better, whoever allocates
106 * the mtd_info will probably want to use the release() hook...
108 static void mtd_release(struct device *dev)
110 struct mtd_info *mtd = dev_get_drvdata(dev);
111 dev_t index = MTD_DEVT(mtd->index);
113 /* remove /dev/mtdXro node if needed */
115 device_destroy(&mtd_class, index + 1);
118 static int mtd_cls_suspend(struct device *dev, pm_message_t state)
120 struct mtd_info *mtd = dev_get_drvdata(dev);
122 if (mtd && mtd->suspend)
123 return mtd_suspend(mtd);
128 static int mtd_cls_resume(struct device *dev)
130 struct mtd_info *mtd = dev_get_drvdata(dev);
132 if (mtd && mtd->resume)
137 static ssize_t mtd_type_show(struct device *dev,
138 struct device_attribute *attr, char *buf)
140 struct mtd_info *mtd = dev_get_drvdata(dev);
169 return snprintf(buf, PAGE_SIZE, "%s\n", type);
171 static DEVICE_ATTR(type, S_IRUGO, mtd_type_show, NULL);
173 static ssize_t mtd_flags_show(struct device *dev,
174 struct device_attribute *attr, char *buf)
176 struct mtd_info *mtd = dev_get_drvdata(dev);
178 return snprintf(buf, PAGE_SIZE, "0x%lx\n", (unsigned long)mtd->flags);
181 static DEVICE_ATTR(flags, S_IRUGO, mtd_flags_show, NULL);
183 static ssize_t mtd_size_show(struct device *dev,
184 struct device_attribute *attr, char *buf)
186 struct mtd_info *mtd = dev_get_drvdata(dev);
188 return snprintf(buf, PAGE_SIZE, "%llu\n",
189 (unsigned long long)mtd->size);
192 static DEVICE_ATTR(size, S_IRUGO, mtd_size_show, NULL);
194 static ssize_t mtd_erasesize_show(struct device *dev,
195 struct device_attribute *attr, char *buf)
197 struct mtd_info *mtd = dev_get_drvdata(dev);
199 return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->erasesize);
202 static DEVICE_ATTR(erasesize, S_IRUGO, mtd_erasesize_show, NULL);
204 static ssize_t mtd_writesize_show(struct device *dev,
205 struct device_attribute *attr, char *buf)
207 struct mtd_info *mtd = dev_get_drvdata(dev);
209 return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->writesize);
212 static DEVICE_ATTR(writesize, S_IRUGO, mtd_writesize_show, NULL);
214 static ssize_t mtd_subpagesize_show(struct device *dev,
215 struct device_attribute *attr, char *buf)
217 struct mtd_info *mtd = dev_get_drvdata(dev);
218 unsigned int subpagesize = mtd->writesize >> mtd->subpage_sft;
220 return snprintf(buf, PAGE_SIZE, "%u\n", subpagesize);
223 static DEVICE_ATTR(subpagesize, S_IRUGO, mtd_subpagesize_show, NULL);
225 static ssize_t mtd_oobsize_show(struct device *dev,
226 struct device_attribute *attr, char *buf)
228 struct mtd_info *mtd = dev_get_drvdata(dev);
230 return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->oobsize);
233 static DEVICE_ATTR(oobsize, S_IRUGO, mtd_oobsize_show, NULL);
235 static ssize_t mtd_numeraseregions_show(struct device *dev,
236 struct device_attribute *attr, char *buf)
238 struct mtd_info *mtd = dev_get_drvdata(dev);
240 return snprintf(buf, PAGE_SIZE, "%u\n", mtd->numeraseregions);
243 static DEVICE_ATTR(numeraseregions, S_IRUGO, mtd_numeraseregions_show,
246 static ssize_t mtd_name_show(struct device *dev,
247 struct device_attribute *attr, char *buf)
249 struct mtd_info *mtd = dev_get_drvdata(dev);
251 return snprintf(buf, PAGE_SIZE, "%s\n", mtd->name);
254 static DEVICE_ATTR(name, S_IRUGO, mtd_name_show, NULL);
256 static struct attribute *mtd_attrs[] = {
258 &dev_attr_flags.attr,
260 &dev_attr_erasesize.attr,
261 &dev_attr_writesize.attr,
262 &dev_attr_subpagesize.attr,
263 &dev_attr_oobsize.attr,
264 &dev_attr_numeraseregions.attr,
269 static struct attribute_group mtd_group = {
273 static const struct attribute_group *mtd_groups[] = {
278 static struct device_type mtd_devtype = {
280 .groups = mtd_groups,
281 .release = mtd_release,
285 * add_mtd_device - register an MTD device
286 * @mtd: pointer to new MTD device info structure
288 * Add a device to the list of MTD devices present in the system, and
289 * notify each currently active MTD 'user' of its arrival. Returns
290 * zero on success or 1 on failure, which currently will only happen
291 * if there is insufficient memory or a sysfs error.
294 int add_mtd_device(struct mtd_info *mtd)
296 struct mtd_notifier *not;
299 if (!mtd->backing_dev_info) {
302 mtd->backing_dev_info = &mtd_bdi_rw_mappable;
305 mtd->backing_dev_info = &mtd_bdi_ro_mappable;
308 mtd->backing_dev_info = &mtd_bdi_unmappable;
313 BUG_ON(mtd->writesize == 0);
314 mutex_lock(&mtd_table_mutex);
317 if (!idr_pre_get(&mtd_idr, GFP_KERNEL))
319 error = idr_get_new(&mtd_idr, mtd, &i);
320 } while (error == -EAGAIN);
328 if (is_power_of_2(mtd->erasesize))
329 mtd->erasesize_shift = ffs(mtd->erasesize) - 1;
331 mtd->erasesize_shift = 0;
333 if (is_power_of_2(mtd->writesize))
334 mtd->writesize_shift = ffs(mtd->writesize) - 1;
336 mtd->writesize_shift = 0;
338 mtd->erasesize_mask = (1 << mtd->erasesize_shift) - 1;
339 mtd->writesize_mask = (1 << mtd->writesize_shift) - 1;
341 /* Some chips always power up locked. Unlock them now */
342 if ((mtd->flags & MTD_WRITEABLE)
343 && (mtd->flags & MTD_POWERUP_LOCK) && mtd->unlock) {
344 if (mtd_unlock(mtd, 0, mtd->size))
346 "%s: unlock failed, writes may not work\n",
350 /* Caller should have set dev.parent to match the
353 mtd->dev.type = &mtd_devtype;
354 mtd->dev.class = &mtd_class;
355 mtd->dev.devt = MTD_DEVT(i);
356 dev_set_name(&mtd->dev, "mtd%d", i);
357 dev_set_drvdata(&mtd->dev, mtd);
358 if (device_register(&mtd->dev) != 0)
362 device_create(&mtd_class, mtd->dev.parent,
366 pr_debug("mtd: Giving out device %d to %s\n", i, mtd->name);
367 /* No need to get a refcount on the module containing
368 the notifier, since we hold the mtd_table_mutex */
369 list_for_each_entry(not, &mtd_notifiers, list)
372 mutex_unlock(&mtd_table_mutex);
373 /* We _know_ we aren't being removed, because
374 our caller is still holding us here. So none
375 of this try_ nonsense, and no bitching about it
377 __module_get(THIS_MODULE);
381 idr_remove(&mtd_idr, i);
383 mutex_unlock(&mtd_table_mutex);
388 * del_mtd_device - unregister an MTD device
389 * @mtd: pointer to MTD device info structure
391 * Remove a device from the list of MTD devices present in the system,
392 * and notify each currently active MTD 'user' of its departure.
393 * Returns zero on success or 1 on failure, which currently will happen
394 * if the requested device does not appear to be present in the list.
397 int del_mtd_device(struct mtd_info *mtd)
400 struct mtd_notifier *not;
402 mutex_lock(&mtd_table_mutex);
404 if (idr_find(&mtd_idr, mtd->index) != mtd) {
409 /* No need to get a refcount on the module containing
410 the notifier, since we hold the mtd_table_mutex */
411 list_for_each_entry(not, &mtd_notifiers, list)
415 printk(KERN_NOTICE "Removing MTD device #%d (%s) with use count %d\n",
416 mtd->index, mtd->name, mtd->usecount);
419 device_unregister(&mtd->dev);
421 idr_remove(&mtd_idr, mtd->index);
423 module_put(THIS_MODULE);
428 mutex_unlock(&mtd_table_mutex);
433 * mtd_device_parse_register - parse partitions and register an MTD device.
435 * @mtd: the MTD device to register
436 * @types: the list of MTD partition probes to try, see
437 * 'parse_mtd_partitions()' for more information
438 * @parser_data: MTD partition parser-specific data
439 * @parts: fallback partition information to register, if parsing fails;
440 * only valid if %nr_parts > %0
441 * @nr_parts: the number of partitions in parts, if zero then the full
442 * MTD device is registered if no partition info is found
444 * This function aggregates MTD partitions parsing (done by
445 * 'parse_mtd_partitions()') and MTD device and partitions registering. It
446 * basically follows the most common pattern found in many MTD drivers:
448 * * It first tries to probe partitions on MTD device @mtd using parsers
449 * specified in @types (if @types is %NULL, then the default list of parsers
450 * is used, see 'parse_mtd_partitions()' for more information). If none are
451 * found this functions tries to fallback to information specified in
453 * * If any partitioning info was found, this function registers the found
455 * * If no partitions were found this function just registers the MTD device
458 * Returns zero in case of success and a negative error code in case of failure.
460 int mtd_device_parse_register(struct mtd_info *mtd, const char **types,
461 struct mtd_part_parser_data *parser_data,
462 const struct mtd_partition *parts,
466 struct mtd_partition *real_parts;
468 err = parse_mtd_partitions(mtd, types, &real_parts, parser_data);
469 if (err <= 0 && nr_parts && parts) {
470 real_parts = kmemdup(parts, sizeof(*parts) * nr_parts,
479 err = add_mtd_partitions(mtd, real_parts, err);
481 } else if (err == 0) {
482 err = add_mtd_device(mtd);
489 EXPORT_SYMBOL_GPL(mtd_device_parse_register);
492 * mtd_device_unregister - unregister an existing MTD device.
494 * @master: the MTD device to unregister. This will unregister both the master
495 * and any partitions if registered.
497 int mtd_device_unregister(struct mtd_info *master)
501 err = del_mtd_partitions(master);
505 if (!device_is_registered(&master->dev))
508 return del_mtd_device(master);
510 EXPORT_SYMBOL_GPL(mtd_device_unregister);
513 * register_mtd_user - register a 'user' of MTD devices.
514 * @new: pointer to notifier info structure
516 * Registers a pair of callbacks function to be called upon addition
517 * or removal of MTD devices. Causes the 'add' callback to be immediately
518 * invoked for each MTD device currently present in the system.
521 void register_mtd_user (struct mtd_notifier *new)
523 struct mtd_info *mtd;
525 mutex_lock(&mtd_table_mutex);
527 list_add(&new->list, &mtd_notifiers);
529 __module_get(THIS_MODULE);
531 mtd_for_each_device(mtd)
534 mutex_unlock(&mtd_table_mutex);
538 * unregister_mtd_user - unregister a 'user' of MTD devices.
539 * @old: pointer to notifier info structure
541 * Removes a callback function pair from the list of 'users' to be
542 * notified upon addition or removal of MTD devices. Causes the
543 * 'remove' callback to be immediately invoked for each MTD device
544 * currently present in the system.
547 int unregister_mtd_user (struct mtd_notifier *old)
549 struct mtd_info *mtd;
551 mutex_lock(&mtd_table_mutex);
553 module_put(THIS_MODULE);
555 mtd_for_each_device(mtd)
558 list_del(&old->list);
559 mutex_unlock(&mtd_table_mutex);
565 * get_mtd_device - obtain a validated handle for an MTD device
566 * @mtd: last known address of the required MTD device
567 * @num: internal device number of the required MTD device
569 * Given a number and NULL address, return the num'th entry in the device
570 * table, if any. Given an address and num == -1, search the device table
571 * for a device with that address and return if it's still present. Given
572 * both, return the num'th driver only if its address matches. Return
576 struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num)
578 struct mtd_info *ret = NULL, *other;
581 mutex_lock(&mtd_table_mutex);
584 mtd_for_each_device(other) {
590 } else if (num >= 0) {
591 ret = idr_find(&mtd_idr, num);
592 if (mtd && mtd != ret)
601 err = __get_mtd_device(ret);
605 mutex_unlock(&mtd_table_mutex);
610 int __get_mtd_device(struct mtd_info *mtd)
614 if (!try_module_get(mtd->owner))
617 if (mtd->get_device) {
618 err = mtd->get_device(mtd);
621 module_put(mtd->owner);
630 * get_mtd_device_nm - obtain a validated handle for an MTD device by
632 * @name: MTD device name to open
634 * This function returns MTD device description structure in case of
635 * success and an error code in case of failure.
638 struct mtd_info *get_mtd_device_nm(const char *name)
641 struct mtd_info *mtd = NULL, *other;
643 mutex_lock(&mtd_table_mutex);
645 mtd_for_each_device(other) {
646 if (!strcmp(name, other->name)) {
655 err = __get_mtd_device(mtd);
659 mutex_unlock(&mtd_table_mutex);
663 mutex_unlock(&mtd_table_mutex);
667 void put_mtd_device(struct mtd_info *mtd)
669 mutex_lock(&mtd_table_mutex);
670 __put_mtd_device(mtd);
671 mutex_unlock(&mtd_table_mutex);
675 void __put_mtd_device(struct mtd_info *mtd)
678 BUG_ON(mtd->usecount < 0);
681 mtd->put_device(mtd);
683 module_put(mtd->owner);
687 * default_mtd_writev - the default writev method
688 * @mtd: mtd device description object pointer
689 * @vecs: the vectors to write
690 * @count: count of vectors in @vecs
691 * @to: the MTD device offset to write to
692 * @retlen: on exit contains the count of bytes written to the MTD device.
694 * This function returns zero in case of success and a negative error code in
697 int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
698 unsigned long count, loff_t to, size_t *retlen)
701 size_t totlen = 0, thislen;
704 for (i = 0; i < count; i++) {
705 if (!vecs[i].iov_len)
707 ret = mtd_write(mtd, to, vecs[i].iov_len, &thislen,
710 if (ret || thislen != vecs[i].iov_len)
712 to += vecs[i].iov_len;
719 * mtd_kmalloc_up_to - allocate a contiguous buffer up to the specified size
720 * @mtd: mtd device description object pointer
721 * @size: a pointer to the ideal or maximum size of the allocation, points
722 * to the actual allocation size on success.
724 * This routine attempts to allocate a contiguous kernel buffer up to
725 * the specified size, backing off the size of the request exponentially
726 * until the request succeeds or until the allocation size falls below
727 * the system page size. This attempts to make sure it does not adversely
728 * impact system performance, so when allocating more than one page, we
729 * ask the memory allocator to avoid re-trying, swapping, writing back
732 * Note, this function also makes sure that the allocated buffer is aligned to
733 * the MTD device's min. I/O unit, i.e. the "mtd->writesize" value.
735 * This is called, for example by mtd_{read,write} and jffs2_scan_medium,
736 * to handle smaller (i.e. degraded) buffer allocations under low- or
737 * fragmented-memory situations where such reduced allocations, from a
738 * requested ideal, are allowed.
740 * Returns a pointer to the allocated buffer on success; otherwise, NULL.
742 void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size)
744 gfp_t flags = __GFP_NOWARN | __GFP_WAIT |
745 __GFP_NORETRY | __GFP_NO_KSWAPD;
746 size_t min_alloc = max_t(size_t, mtd->writesize, PAGE_SIZE);
749 *size = min_t(size_t, *size, KMALLOC_MAX_SIZE);
751 while (*size > min_alloc) {
752 kbuf = kmalloc(*size, flags);
757 *size = ALIGN(*size, mtd->writesize);
761 * For the last resort allocation allow 'kmalloc()' to do all sorts of
762 * things (write-back, dropping caches, etc) by using GFP_KERNEL.
764 return kmalloc(*size, GFP_KERNEL);
767 EXPORT_SYMBOL_GPL(get_mtd_device);
768 EXPORT_SYMBOL_GPL(get_mtd_device_nm);
769 EXPORT_SYMBOL_GPL(__get_mtd_device);
770 EXPORT_SYMBOL_GPL(put_mtd_device);
771 EXPORT_SYMBOL_GPL(__put_mtd_device);
772 EXPORT_SYMBOL_GPL(register_mtd_user);
773 EXPORT_SYMBOL_GPL(unregister_mtd_user);
774 EXPORT_SYMBOL_GPL(default_mtd_writev);
775 EXPORT_SYMBOL_GPL(mtd_kmalloc_up_to);
777 #ifdef CONFIG_PROC_FS
779 /*====================================================================*/
780 /* Support for /proc/mtd */
782 static struct proc_dir_entry *proc_mtd;
784 static int mtd_proc_show(struct seq_file *m, void *v)
786 struct mtd_info *mtd;
788 seq_puts(m, "dev: size erasesize name\n");
789 mutex_lock(&mtd_table_mutex);
790 mtd_for_each_device(mtd) {
791 seq_printf(m, "mtd%d: %8.8llx %8.8x \"%s\"\n",
792 mtd->index, (unsigned long long)mtd->size,
793 mtd->erasesize, mtd->name);
795 mutex_unlock(&mtd_table_mutex);
799 static int mtd_proc_open(struct inode *inode, struct file *file)
801 return single_open(file, mtd_proc_show, NULL);
804 static const struct file_operations mtd_proc_ops = {
805 .open = mtd_proc_open,
808 .release = single_release,
810 #endif /* CONFIG_PROC_FS */
812 /*====================================================================*/
815 static int __init mtd_bdi_init(struct backing_dev_info *bdi, const char *name)
821 ret = bdi_register(bdi, NULL, name);
829 static int __init init_mtd(void)
833 ret = class_register(&mtd_class);
837 ret = mtd_bdi_init(&mtd_bdi_unmappable, "mtd-unmap");
841 ret = mtd_bdi_init(&mtd_bdi_ro_mappable, "mtd-romap");
845 ret = mtd_bdi_init(&mtd_bdi_rw_mappable, "mtd-rwmap");
849 #ifdef CONFIG_PROC_FS
850 proc_mtd = proc_create("mtd", 0, NULL, &mtd_proc_ops);
851 #endif /* CONFIG_PROC_FS */
855 bdi_destroy(&mtd_bdi_ro_mappable);
857 bdi_destroy(&mtd_bdi_unmappable);
859 class_unregister(&mtd_class);
861 pr_err("Error registering mtd class or bdi: %d\n", ret);
865 static void __exit cleanup_mtd(void)
867 #ifdef CONFIG_PROC_FS
869 remove_proc_entry( "mtd", NULL);
870 #endif /* CONFIG_PROC_FS */
871 class_unregister(&mtd_class);
872 bdi_destroy(&mtd_bdi_unmappable);
873 bdi_destroy(&mtd_bdi_ro_mappable);
874 bdi_destroy(&mtd_bdi_rw_mappable);
877 module_init(init_mtd);
878 module_exit(cleanup_mtd);
880 MODULE_LICENSE("GPL");
881 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
882 MODULE_DESCRIPTION("Core MTD registration and access routines");