2 * Core registration and callback routines for MTD
7 #include <linux/module.h>
8 #include <linux/kernel.h>
9 #include <linux/ptrace.h>
10 #include <linux/slab.h>
11 #include <linux/string.h>
12 #include <linux/timer.h>
13 #include <linux/major.h>
15 #include <linux/err.h>
16 #include <linux/ioctl.h>
17 #include <linux/init.h>
18 #include <linux/mtd/compatmac.h>
19 #include <linux/proc_fs.h>
20 #include <linux/idr.h>
22 #include <linux/mtd/mtd.h>
27 static int mtd_cls_suspend(struct device *dev, pm_message_t state);
28 static int mtd_cls_resume(struct device *dev);
30 static struct class mtd_class = {
33 .suspend = mtd_cls_suspend,
34 .resume = mtd_cls_resume,
37 static DEFINE_IDR(mtd_idr);
39 /* These are exported solely for the purpose of mtd_blkdevs.c. You
40 should not use them for _anything_ else */
41 DEFINE_MUTEX(mtd_table_mutex);
42 EXPORT_SYMBOL_GPL(mtd_table_mutex);
44 struct mtd_info *__mtd_next_device(int i)
46 return idr_get_next(&mtd_idr, &i);
48 EXPORT_SYMBOL_GPL(__mtd_next_device);
50 static LIST_HEAD(mtd_notifiers);
53 #if defined(CONFIG_MTD_CHAR) || defined(CONFIG_MTD_CHAR_MODULE)
54 #define MTD_DEVT(index) MKDEV(MTD_CHAR_MAJOR, (index)*2)
56 #define MTD_DEVT(index) 0
59 /* REVISIT once MTD uses the driver model better, whoever allocates
60 * the mtd_info will probably want to use the release() hook...
62 static void mtd_release(struct device *dev)
64 dev_t index = MTD_DEVT(dev_to_mtd(dev)->index);
66 /* remove /dev/mtdXro node if needed */
68 device_destroy(&mtd_class, index + 1);
71 static int mtd_cls_suspend(struct device *dev, pm_message_t state)
73 struct mtd_info *mtd = dev_to_mtd(dev);
75 if (mtd && mtd->suspend)
76 return mtd->suspend(mtd);
81 static int mtd_cls_resume(struct device *dev)
83 struct mtd_info *mtd = dev_to_mtd(dev);
85 if (mtd && mtd->resume)
90 static ssize_t mtd_type_show(struct device *dev,
91 struct device_attribute *attr, char *buf)
93 struct mtd_info *mtd = dev_to_mtd(dev);
122 return snprintf(buf, PAGE_SIZE, "%s\n", type);
124 static DEVICE_ATTR(type, S_IRUGO, mtd_type_show, NULL);
126 static ssize_t mtd_flags_show(struct device *dev,
127 struct device_attribute *attr, char *buf)
129 struct mtd_info *mtd = dev_to_mtd(dev);
131 return snprintf(buf, PAGE_SIZE, "0x%lx\n", (unsigned long)mtd->flags);
134 static DEVICE_ATTR(flags, S_IRUGO, mtd_flags_show, NULL);
136 static ssize_t mtd_size_show(struct device *dev,
137 struct device_attribute *attr, char *buf)
139 struct mtd_info *mtd = dev_to_mtd(dev);
141 return snprintf(buf, PAGE_SIZE, "%llu\n",
142 (unsigned long long)mtd->size);
145 static DEVICE_ATTR(size, S_IRUGO, mtd_size_show, NULL);
147 static ssize_t mtd_erasesize_show(struct device *dev,
148 struct device_attribute *attr, char *buf)
150 struct mtd_info *mtd = dev_to_mtd(dev);
152 return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->erasesize);
155 static DEVICE_ATTR(erasesize, S_IRUGO, mtd_erasesize_show, NULL);
157 static ssize_t mtd_writesize_show(struct device *dev,
158 struct device_attribute *attr, char *buf)
160 struct mtd_info *mtd = dev_to_mtd(dev);
162 return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->writesize);
165 static DEVICE_ATTR(writesize, S_IRUGO, mtd_writesize_show, NULL);
167 static ssize_t mtd_subpagesize_show(struct device *dev,
168 struct device_attribute *attr, char *buf)
170 struct mtd_info *mtd = dev_to_mtd(dev);
171 unsigned int subpagesize = mtd->writesize >> mtd->subpage_sft;
173 return snprintf(buf, PAGE_SIZE, "%u\n", subpagesize);
176 static DEVICE_ATTR(subpagesize, S_IRUGO, mtd_subpagesize_show, NULL);
178 static ssize_t mtd_oobsize_show(struct device *dev,
179 struct device_attribute *attr, char *buf)
181 struct mtd_info *mtd = dev_to_mtd(dev);
183 return snprintf(buf, PAGE_SIZE, "%lu\n", (unsigned long)mtd->oobsize);
186 static DEVICE_ATTR(oobsize, S_IRUGO, mtd_oobsize_show, NULL);
188 static ssize_t mtd_numeraseregions_show(struct device *dev,
189 struct device_attribute *attr, char *buf)
191 struct mtd_info *mtd = dev_to_mtd(dev);
193 return snprintf(buf, PAGE_SIZE, "%u\n", mtd->numeraseregions);
196 static DEVICE_ATTR(numeraseregions, S_IRUGO, mtd_numeraseregions_show,
199 static ssize_t mtd_name_show(struct device *dev,
200 struct device_attribute *attr, char *buf)
202 struct mtd_info *mtd = dev_to_mtd(dev);
204 return snprintf(buf, PAGE_SIZE, "%s\n", mtd->name);
207 static DEVICE_ATTR(name, S_IRUGO, mtd_name_show, NULL);
209 static struct attribute *mtd_attrs[] = {
211 &dev_attr_flags.attr,
213 &dev_attr_erasesize.attr,
214 &dev_attr_writesize.attr,
215 &dev_attr_subpagesize.attr,
216 &dev_attr_oobsize.attr,
217 &dev_attr_numeraseregions.attr,
222 static struct attribute_group mtd_group = {
226 static const struct attribute_group *mtd_groups[] = {
231 static struct device_type mtd_devtype = {
233 .groups = mtd_groups,
234 .release = mtd_release,
238 * add_mtd_device - register an MTD device
239 * @mtd: pointer to new MTD device info structure
241 * Add a device to the list of MTD devices present in the system, and
242 * notify each currently active MTD 'user' of its arrival. Returns
243 * zero on success or 1 on failure, which currently will only happen
244 * if there is insufficient memory or a sysfs error.
247 int add_mtd_device(struct mtd_info *mtd)
249 struct mtd_notifier *not;
252 if (!mtd->backing_dev_info) {
255 mtd->backing_dev_info = &mtd_bdi_rw_mappable;
258 mtd->backing_dev_info = &mtd_bdi_ro_mappable;
261 mtd->backing_dev_info = &mtd_bdi_unmappable;
266 BUG_ON(mtd->writesize == 0);
267 mutex_lock(&mtd_table_mutex);
270 if (!idr_pre_get(&mtd_idr, GFP_KERNEL))
272 error = idr_get_new(&mtd_idr, mtd, &i);
273 } while (error == -EAGAIN);
281 if (is_power_of_2(mtd->erasesize))
282 mtd->erasesize_shift = ffs(mtd->erasesize) - 1;
284 mtd->erasesize_shift = 0;
286 if (is_power_of_2(mtd->writesize))
287 mtd->writesize_shift = ffs(mtd->writesize) - 1;
289 mtd->writesize_shift = 0;
291 mtd->erasesize_mask = (1 << mtd->erasesize_shift) - 1;
292 mtd->writesize_mask = (1 << mtd->writesize_shift) - 1;
294 /* Some chips always power up locked. Unlock them now */
295 if ((mtd->flags & MTD_WRITEABLE)
296 && (mtd->flags & MTD_POWERUP_LOCK) && mtd->unlock) {
297 if (mtd->unlock(mtd, 0, mtd->size))
299 "%s: unlock failed, writes may not work\n",
303 /* Caller should have set dev.parent to match the
306 mtd->dev.type = &mtd_devtype;
307 mtd->dev.class = &mtd_class;
308 mtd->dev.devt = MTD_DEVT(i);
309 dev_set_name(&mtd->dev, "mtd%d", i);
310 dev_set_drvdata(&mtd->dev, mtd);
311 if (device_register(&mtd->dev) != 0)
315 device_create(&mtd_class, mtd->dev.parent,
319 DEBUG(0, "mtd: Giving out device %d to %s\n", i, mtd->name);
320 /* No need to get a refcount on the module containing
321 the notifier, since we hold the mtd_table_mutex */
322 list_for_each_entry(not, &mtd_notifiers, list)
325 mutex_unlock(&mtd_table_mutex);
326 /* We _know_ we aren't being removed, because
327 our caller is still holding us here. So none
328 of this try_ nonsense, and no bitching about it
330 __module_get(THIS_MODULE);
334 idr_remove(&mtd_idr, i);
336 mutex_unlock(&mtd_table_mutex);
341 * del_mtd_device - unregister an MTD device
342 * @mtd: pointer to MTD device info structure
344 * Remove a device from the list of MTD devices present in the system,
345 * and notify each currently active MTD 'user' of its departure.
346 * Returns zero on success or 1 on failure, which currently will happen
347 * if the requested device does not appear to be present in the list.
350 int del_mtd_device (struct mtd_info *mtd)
353 struct mtd_notifier *not;
355 mutex_lock(&mtd_table_mutex);
357 if (idr_find(&mtd_idr, mtd->index) != mtd) {
362 /* No need to get a refcount on the module containing
363 the notifier, since we hold the mtd_table_mutex */
364 list_for_each_entry(not, &mtd_notifiers, list)
368 printk(KERN_NOTICE "Removing MTD device #%d (%s) with use count %d\n",
369 mtd->index, mtd->name, mtd->usecount);
372 device_unregister(&mtd->dev);
374 idr_remove(&mtd_idr, mtd->index);
376 module_put(THIS_MODULE);
381 mutex_unlock(&mtd_table_mutex);
386 * register_mtd_user - register a 'user' of MTD devices.
387 * @new: pointer to notifier info structure
389 * Registers a pair of callbacks function to be called upon addition
390 * or removal of MTD devices. Causes the 'add' callback to be immediately
391 * invoked for each MTD device currently present in the system.
394 void register_mtd_user (struct mtd_notifier *new)
396 struct mtd_info *mtd;
398 mutex_lock(&mtd_table_mutex);
400 list_add(&new->list, &mtd_notifiers);
402 __module_get(THIS_MODULE);
404 mtd_for_each_device(mtd)
407 mutex_unlock(&mtd_table_mutex);
411 * unregister_mtd_user - unregister a 'user' of MTD devices.
412 * @old: pointer to notifier info structure
414 * Removes a callback function pair from the list of 'users' to be
415 * notified upon addition or removal of MTD devices. Causes the
416 * 'remove' callback to be immediately invoked for each MTD device
417 * currently present in the system.
420 int unregister_mtd_user (struct mtd_notifier *old)
422 struct mtd_info *mtd;
424 mutex_lock(&mtd_table_mutex);
426 module_put(THIS_MODULE);
428 mtd_for_each_device(mtd)
431 list_del(&old->list);
432 mutex_unlock(&mtd_table_mutex);
438 * get_mtd_device - obtain a validated handle for an MTD device
439 * @mtd: last known address of the required MTD device
440 * @num: internal device number of the required MTD device
442 * Given a number and NULL address, return the num'th entry in the device
443 * table, if any. Given an address and num == -1, search the device table
444 * for a device with that address and return if it's still present. Given
445 * both, return the num'th driver only if its address matches. Return
449 struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num)
451 struct mtd_info *ret = NULL, *other;
454 mutex_lock(&mtd_table_mutex);
457 mtd_for_each_device(other) {
463 } else if (num >= 0) {
464 ret = idr_find(&mtd_idr, num);
465 if (mtd && mtd != ret)
474 err = __get_mtd_device(ret);
478 mutex_unlock(&mtd_table_mutex);
483 int __get_mtd_device(struct mtd_info *mtd)
487 if (!try_module_get(mtd->owner))
490 if (mtd->get_device) {
492 err = mtd->get_device(mtd);
495 module_put(mtd->owner);
504 * get_mtd_device_nm - obtain a validated handle for an MTD device by
506 * @name: MTD device name to open
508 * This function returns MTD device description structure in case of
509 * success and an error code in case of failure.
512 struct mtd_info *get_mtd_device_nm(const char *name)
515 struct mtd_info *mtd = NULL, *other;
517 mutex_lock(&mtd_table_mutex);
519 mtd_for_each_device(other) {
520 if (!strcmp(name, other->name)) {
529 if (!try_module_get(mtd->owner))
532 if (mtd->get_device) {
533 err = mtd->get_device(mtd);
539 mutex_unlock(&mtd_table_mutex);
543 module_put(mtd->owner);
545 mutex_unlock(&mtd_table_mutex);
549 void put_mtd_device(struct mtd_info *mtd)
551 mutex_lock(&mtd_table_mutex);
552 __put_mtd_device(mtd);
553 mutex_unlock(&mtd_table_mutex);
557 void __put_mtd_device(struct mtd_info *mtd)
560 BUG_ON(mtd->usecount < 0);
563 mtd->put_device(mtd);
565 module_put(mtd->owner);
568 /* default_mtd_writev - default mtd writev method for MTD devices that
569 * don't implement their own
572 int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
573 unsigned long count, loff_t to, size_t *retlen)
576 size_t totlen = 0, thislen;
582 for (i=0; i<count; i++) {
583 if (!vecs[i].iov_len)
585 ret = mtd->write(mtd, to, vecs[i].iov_len, &thislen, vecs[i].iov_base);
587 if (ret || thislen != vecs[i].iov_len)
589 to += vecs[i].iov_len;
597 EXPORT_SYMBOL_GPL(add_mtd_device);
598 EXPORT_SYMBOL_GPL(del_mtd_device);
599 EXPORT_SYMBOL_GPL(get_mtd_device);
600 EXPORT_SYMBOL_GPL(get_mtd_device_nm);
601 EXPORT_SYMBOL_GPL(__get_mtd_device);
602 EXPORT_SYMBOL_GPL(put_mtd_device);
603 EXPORT_SYMBOL_GPL(__put_mtd_device);
604 EXPORT_SYMBOL_GPL(register_mtd_user);
605 EXPORT_SYMBOL_GPL(unregister_mtd_user);
606 EXPORT_SYMBOL_GPL(default_mtd_writev);
608 #ifdef CONFIG_PROC_FS
610 /*====================================================================*/
611 /* Support for /proc/mtd */
613 static struct proc_dir_entry *proc_mtd;
615 static inline int mtd_proc_info(char *buf, struct mtd_info *this)
617 return sprintf(buf, "mtd%d: %8.8llx %8.8x \"%s\"\n", this->index,
618 (unsigned long long)this->size,
619 this->erasesize, this->name);
622 static int mtd_read_proc (char *page, char **start, off_t off, int count,
623 int *eof, void *data_unused)
625 struct mtd_info *mtd;
629 mutex_lock(&mtd_table_mutex);
631 len = sprintf(page, "dev: size erasesize name\n");
632 mtd_for_each_device(mtd) {
633 l = mtd_proc_info(page + len, mtd);
635 if (len+begin > off+count)
637 if (len+begin < off) {
646 mutex_unlock(&mtd_table_mutex);
647 if (off >= len+begin)
649 *start = page + (off-begin);
650 return ((count < begin+len-off) ? count : begin+len-off);
653 #endif /* CONFIG_PROC_FS */
655 /*====================================================================*/
658 static int __init init_mtd(void)
661 ret = class_register(&mtd_class);
664 pr_err("Error registering mtd class: %d\n", ret);
667 #ifdef CONFIG_PROC_FS
668 if ((proc_mtd = create_proc_entry( "mtd", 0, NULL )))
669 proc_mtd->read_proc = mtd_read_proc;
670 #endif /* CONFIG_PROC_FS */
674 static void __exit cleanup_mtd(void)
676 #ifdef CONFIG_PROC_FS
678 remove_proc_entry( "mtd", NULL);
679 #endif /* CONFIG_PROC_FS */
680 class_unregister(&mtd_class);
683 module_init(init_mtd);
684 module_exit(cleanup_mtd);
686 MODULE_LICENSE("GPL");
687 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
688 MODULE_DESCRIPTION("Core MTD registration and access routines");