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");