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>
21 #include <linux/mtd/mtd.h>
27 static struct class *mtd_class
;
29 /* These are exported solely for the purpose of mtd_blkdevs.c. You
30 should not use them for _anything_ else */
31 DEFINE_MUTEX(mtd_table_mutex
);
32 struct mtd_info
*mtd_table
[MAX_MTD_DEVICES
];
34 EXPORT_SYMBOL_GPL(mtd_table_mutex
);
35 EXPORT_SYMBOL_GPL(mtd_table
);
37 static LIST_HEAD(mtd_notifiers
);
40 #if defined(CONFIG_MTD_CHAR) || defined(CONFIG_MTD_CHAR_MODULE)
41 #define MTD_DEVT(index) MKDEV(MTD_CHAR_MAJOR, (index)*2)
43 #define MTD_DEVT(index) 0
46 /* REVISIT once MTD uses the driver model better, whoever allocates
47 * the mtd_info will probably want to use the release() hook...
49 static void mtd_release(struct device
*dev
)
51 struct mtd_info
*mtd
= dev_to_mtd(dev
);
53 /* remove /dev/mtdXro node if needed */
54 if (MTD_DEVT(mtd
->index
))
55 device_destroy(mtd_class
, MTD_DEVT(mtd
->index
) + 1);
58 static ssize_t
mtd_type_show(struct device
*dev
,
59 struct device_attribute
*attr
, char *buf
)
61 struct mtd_info
*mtd
= dev_to_mtd(dev
);
90 return snprintf(buf
, PAGE_SIZE
, "%s\n", type
);
92 static DEVICE_ATTR(type
, S_IRUGO
, mtd_type_show
, NULL
);
94 static ssize_t
mtd_flags_show(struct device
*dev
,
95 struct device_attribute
*attr
, char *buf
)
97 struct mtd_info
*mtd
= dev_to_mtd(dev
);
99 return snprintf(buf
, PAGE_SIZE
, "0x%lx\n", (unsigned long)mtd
->flags
);
102 static DEVICE_ATTR(flags
, S_IRUGO
, mtd_flags_show
, NULL
);
104 static ssize_t
mtd_size_show(struct device
*dev
,
105 struct device_attribute
*attr
, char *buf
)
107 struct mtd_info
*mtd
= dev_to_mtd(dev
);
109 return snprintf(buf
, PAGE_SIZE
, "%llu\n",
110 (unsigned long long)mtd
->size
);
113 static DEVICE_ATTR(size
, S_IRUGO
, mtd_size_show
, NULL
);
115 static ssize_t
mtd_erasesize_show(struct device
*dev
,
116 struct device_attribute
*attr
, char *buf
)
118 struct mtd_info
*mtd
= dev_to_mtd(dev
);
120 return snprintf(buf
, PAGE_SIZE
, "%lu\n", (unsigned long)mtd
->erasesize
);
123 static DEVICE_ATTR(erasesize
, S_IRUGO
, mtd_erasesize_show
, NULL
);
125 static ssize_t
mtd_writesize_show(struct device
*dev
,
126 struct device_attribute
*attr
, char *buf
)
128 struct mtd_info
*mtd
= dev_to_mtd(dev
);
130 return snprintf(buf
, PAGE_SIZE
, "%lu\n", (unsigned long)mtd
->writesize
);
133 static DEVICE_ATTR(writesize
, S_IRUGO
, mtd_writesize_show
, NULL
);
135 static ssize_t
mtd_oobsize_show(struct device
*dev
,
136 struct device_attribute
*attr
, char *buf
)
138 struct mtd_info
*mtd
= dev_to_mtd(dev
);
140 return snprintf(buf
, PAGE_SIZE
, "%lu\n", (unsigned long)mtd
->oobsize
);
143 static DEVICE_ATTR(oobsize
, S_IRUGO
, mtd_oobsize_show
, NULL
);
145 static ssize_t
mtd_numeraseregions_show(struct device
*dev
,
146 struct device_attribute
*attr
, char *buf
)
148 struct mtd_info
*mtd
= dev_to_mtd(dev
);
150 return snprintf(buf
, PAGE_SIZE
, "%u\n", mtd
->numeraseregions
);
153 static DEVICE_ATTR(numeraseregions
, S_IRUGO
, mtd_numeraseregions_show
,
156 static ssize_t
mtd_name_show(struct device
*dev
,
157 struct device_attribute
*attr
, char *buf
)
159 struct mtd_info
*mtd
= dev_to_mtd(dev
);
161 return snprintf(buf
, PAGE_SIZE
, "%s\n", mtd
->name
);
164 static DEVICE_ATTR(name
, S_IRUGO
, mtd_name_show
, NULL
);
166 static struct attribute
*mtd_attrs
[] = {
168 &dev_attr_flags
.attr
,
170 &dev_attr_erasesize
.attr
,
171 &dev_attr_writesize
.attr
,
172 &dev_attr_oobsize
.attr
,
173 &dev_attr_numeraseregions
.attr
,
178 struct attribute_group mtd_group
= {
182 struct attribute_group
*mtd_groups
[] = {
187 static struct device_type mtd_devtype
= {
189 .groups
= mtd_groups
,
190 .release
= mtd_release
,
194 * add_mtd_device - register an MTD device
195 * @mtd: pointer to new MTD device info structure
197 * Add a device to the list of MTD devices present in the system, and
198 * notify each currently active MTD 'user' of its arrival. Returns
199 * zero on success or 1 on failure, which currently will only happen
200 * if the number of present devices exceeds MAX_MTD_DEVICES (i.e. 16)
201 * or there's a sysfs error.
204 int add_mtd_device(struct mtd_info
*mtd
)
208 if (!mtd
->backing_dev_info
) {
211 mtd
->backing_dev_info
= &mtd_bdi_rw_mappable
;
214 mtd
->backing_dev_info
= &mtd_bdi_ro_mappable
;
217 mtd
->backing_dev_info
= &mtd_bdi_unmappable
;
222 BUG_ON(mtd
->writesize
== 0);
223 mutex_lock(&mtd_table_mutex
);
225 for (i
=0; i
< MAX_MTD_DEVICES
; i
++)
227 struct mtd_notifier
*not;
233 if (is_power_of_2(mtd
->erasesize
))
234 mtd
->erasesize_shift
= ffs(mtd
->erasesize
) - 1;
236 mtd
->erasesize_shift
= 0;
238 if (is_power_of_2(mtd
->writesize
))
239 mtd
->writesize_shift
= ffs(mtd
->writesize
) - 1;
241 mtd
->writesize_shift
= 0;
243 mtd
->erasesize_mask
= (1 << mtd
->erasesize_shift
) - 1;
244 mtd
->writesize_mask
= (1 << mtd
->writesize_shift
) - 1;
246 /* Some chips always power up locked. Unlock them now */
247 if ((mtd
->flags
& MTD_WRITEABLE
)
248 && (mtd
->flags
& MTD_POWERUP_LOCK
) && mtd
->unlock
) {
249 if (mtd
->unlock(mtd
, 0, mtd
->size
))
251 "%s: unlock failed, "
252 "writes may not work\n",
256 /* Caller should have set dev.parent to match the
259 mtd
->dev
.type
= &mtd_devtype
;
260 mtd
->dev
.class = mtd_class
;
261 mtd
->dev
.devt
= MTD_DEVT(i
);
262 dev_set_name(&mtd
->dev
, "mtd%d", i
);
263 if (device_register(&mtd
->dev
) != 0) {
269 device_create(mtd_class
, mtd
->dev
.parent
,
273 DEBUG(0, "mtd: Giving out device %d to %s\n",i
, mtd
->name
);
274 /* No need to get a refcount on the module containing
275 the notifier, since we hold the mtd_table_mutex */
276 list_for_each_entry(not, &mtd_notifiers
, list
)
279 mutex_unlock(&mtd_table_mutex
);
280 /* We _know_ we aren't being removed, because
281 our caller is still holding us here. So none
282 of this try_ nonsense, and no bitching about it
284 __module_get(THIS_MODULE
);
288 mutex_unlock(&mtd_table_mutex
);
293 * del_mtd_device - unregister an MTD device
294 * @mtd: pointer to MTD device info structure
296 * Remove a device from the list of MTD devices present in the system,
297 * and notify each currently active MTD 'user' of its departure.
298 * Returns zero on success or 1 on failure, which currently will happen
299 * if the requested device does not appear to be present in the list.
302 int del_mtd_device (struct mtd_info
*mtd
)
306 mutex_lock(&mtd_table_mutex
);
308 if (mtd_table
[mtd
->index
] != mtd
) {
310 } else if (mtd
->usecount
) {
311 printk(KERN_NOTICE
"Removing MTD device #%d (%s) with use count %d\n",
312 mtd
->index
, mtd
->name
, mtd
->usecount
);
315 struct mtd_notifier
*not;
317 device_unregister(&mtd
->dev
);
319 /* No need to get a refcount on the module containing
320 the notifier, since we hold the mtd_table_mutex */
321 list_for_each_entry(not, &mtd_notifiers
, list
)
324 mtd_table
[mtd
->index
] = NULL
;
326 module_put(THIS_MODULE
);
330 mutex_unlock(&mtd_table_mutex
);
335 * register_mtd_user - register a 'user' of MTD devices.
336 * @new: pointer to notifier info structure
338 * Registers a pair of callbacks function to be called upon addition
339 * or removal of MTD devices. Causes the 'add' callback to be immediately
340 * invoked for each MTD device currently present in the system.
343 void register_mtd_user (struct mtd_notifier
*new)
347 mutex_lock(&mtd_table_mutex
);
349 list_add(&new->list
, &mtd_notifiers
);
351 __module_get(THIS_MODULE
);
353 for (i
=0; i
< MAX_MTD_DEVICES
; i
++)
355 new->add(mtd_table
[i
]);
357 mutex_unlock(&mtd_table_mutex
);
361 * unregister_mtd_user - unregister a 'user' of MTD devices.
362 * @old: pointer to notifier info structure
364 * Removes a callback function pair from the list of 'users' to be
365 * notified upon addition or removal of MTD devices. Causes the
366 * 'remove' callback to be immediately invoked for each MTD device
367 * currently present in the system.
370 int unregister_mtd_user (struct mtd_notifier
*old
)
374 mutex_lock(&mtd_table_mutex
);
376 module_put(THIS_MODULE
);
378 for (i
=0; i
< MAX_MTD_DEVICES
; i
++)
380 old
->remove(mtd_table
[i
]);
382 list_del(&old
->list
);
383 mutex_unlock(&mtd_table_mutex
);
389 * get_mtd_device - obtain a validated handle for an MTD device
390 * @mtd: last known address of the required MTD device
391 * @num: internal device number of the required MTD device
393 * Given a number and NULL address, return the num'th entry in the device
394 * table, if any. Given an address and num == -1, search the device table
395 * for a device with that address and return if it's still present. Given
396 * both, return the num'th driver only if its address matches. Return
400 struct mtd_info
*get_mtd_device(struct mtd_info
*mtd
, int num
)
402 struct mtd_info
*ret
= NULL
;
403 int i
, err
= -ENODEV
;
405 mutex_lock(&mtd_table_mutex
);
408 for (i
=0; i
< MAX_MTD_DEVICES
; i
++)
409 if (mtd_table
[i
] == mtd
)
411 } else if (num
< MAX_MTD_DEVICES
) {
412 ret
= mtd_table
[num
];
413 if (mtd
&& mtd
!= ret
)
420 if (!try_module_get(ret
->owner
))
423 if (ret
->get_device
) {
424 err
= ret
->get_device(ret
);
430 mutex_unlock(&mtd_table_mutex
);
434 module_put(ret
->owner
);
436 mutex_unlock(&mtd_table_mutex
);
441 * get_mtd_device_nm - obtain a validated handle for an MTD device by
443 * @name: MTD device name to open
445 * This function returns MTD device description structure in case of
446 * success and an error code in case of failure.
449 struct mtd_info
*get_mtd_device_nm(const char *name
)
451 int i
, err
= -ENODEV
;
452 struct mtd_info
*mtd
= NULL
;
454 mutex_lock(&mtd_table_mutex
);
456 for (i
= 0; i
< MAX_MTD_DEVICES
; i
++) {
457 if (mtd_table
[i
] && !strcmp(name
, mtd_table
[i
]->name
)) {
466 if (!try_module_get(mtd
->owner
))
469 if (mtd
->get_device
) {
470 err
= mtd
->get_device(mtd
);
476 mutex_unlock(&mtd_table_mutex
);
480 module_put(mtd
->owner
);
482 mutex_unlock(&mtd_table_mutex
);
486 void put_mtd_device(struct mtd_info
*mtd
)
490 mutex_lock(&mtd_table_mutex
);
493 mtd
->put_device(mtd
);
494 mutex_unlock(&mtd_table_mutex
);
497 module_put(mtd
->owner
);
500 /* default_mtd_writev - default mtd writev method for MTD devices that
501 * don't implement their own
504 int default_mtd_writev(struct mtd_info
*mtd
, const struct kvec
*vecs
,
505 unsigned long count
, loff_t to
, size_t *retlen
)
508 size_t totlen
= 0, thislen
;
514 for (i
=0; i
<count
; i
++) {
515 if (!vecs
[i
].iov_len
)
517 ret
= mtd
->write(mtd
, to
, vecs
[i
].iov_len
, &thislen
, vecs
[i
].iov_base
);
519 if (ret
|| thislen
!= vecs
[i
].iov_len
)
521 to
+= vecs
[i
].iov_len
;
529 EXPORT_SYMBOL_GPL(add_mtd_device
);
530 EXPORT_SYMBOL_GPL(del_mtd_device
);
531 EXPORT_SYMBOL_GPL(get_mtd_device
);
532 EXPORT_SYMBOL_GPL(get_mtd_device_nm
);
533 EXPORT_SYMBOL_GPL(put_mtd_device
);
534 EXPORT_SYMBOL_GPL(register_mtd_user
);
535 EXPORT_SYMBOL_GPL(unregister_mtd_user
);
536 EXPORT_SYMBOL_GPL(default_mtd_writev
);
538 #ifdef CONFIG_PROC_FS
540 /*====================================================================*/
541 /* Support for /proc/mtd */
543 static struct proc_dir_entry
*proc_mtd
;
545 static inline int mtd_proc_info (char *buf
, int i
)
547 struct mtd_info
*this = mtd_table
[i
];
552 return sprintf(buf
, "mtd%d: %8.8llx %8.8x \"%s\"\n", i
,
553 (unsigned long long)this->size
,
554 this->erasesize
, this->name
);
557 static int mtd_read_proc (char *page
, char **start
, off_t off
, int count
,
558 int *eof
, void *data_unused
)
563 mutex_lock(&mtd_table_mutex
);
565 len
= sprintf(page
, "dev: size erasesize name\n");
566 for (i
=0; i
< MAX_MTD_DEVICES
; i
++) {
568 l
= mtd_proc_info(page
+ len
, i
);
570 if (len
+begin
> off
+count
)
572 if (len
+begin
< off
) {
581 mutex_unlock(&mtd_table_mutex
);
582 if (off
>= len
+begin
)
584 *start
= page
+ (off
-begin
);
585 return ((count
< begin
+len
-off
) ? count
: begin
+len
-off
);
588 #endif /* CONFIG_PROC_FS */
590 /*====================================================================*/
593 static int __init
init_mtd(void)
595 mtd_class
= class_create(THIS_MODULE
, "mtd");
597 if (IS_ERR(mtd_class
)) {
598 pr_err("Error creating mtd class.\n");
599 return PTR_ERR(mtd_class
);
601 #ifdef CONFIG_PROC_FS
602 if ((proc_mtd
= create_proc_entry( "mtd", 0, NULL
)))
603 proc_mtd
->read_proc
= mtd_read_proc
;
604 #endif /* CONFIG_PROC_FS */
608 static void __exit
cleanup_mtd(void)
610 #ifdef CONFIG_PROC_FS
612 remove_proc_entry( "mtd", NULL
);
613 #endif /* CONFIG_PROC_FS */
614 class_destroy(mtd_class
);
617 module_init(init_mtd
);
618 module_exit(cleanup_mtd
);
620 MODULE_LICENSE("GPL");
621 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
622 MODULE_DESCRIPTION("Core MTD registration and access routines");