2 * $Id: mtdcore.c,v 1.47 2005/11/07 11:14:20 gleixner Exp $
4 * Core registration and callback routines for MTD
9 #include <linux/module.h>
10 #include <linux/kernel.h>
11 #include <linux/ptrace.h>
12 #include <linux/slab.h>
13 #include <linux/string.h>
14 #include <linux/timer.h>
15 #include <linux/major.h>
17 #include <linux/err.h>
18 #include <linux/ioctl.h>
19 #include <linux/init.h>
20 #include <linux/mtd/compatmac.h>
21 #include <linux/proc_fs.h>
23 #include <linux/mtd/mtd.h>
25 /* These are exported solely for the purpose of mtd_blkdevs.c. You
26 should not use them for _anything_ else */
27 DEFINE_MUTEX(mtd_table_mutex
);
28 struct mtd_info
*mtd_table
[MAX_MTD_DEVICES
];
30 EXPORT_SYMBOL_GPL(mtd_table_mutex
);
31 EXPORT_SYMBOL_GPL(mtd_table
);
33 static LIST_HEAD(mtd_notifiers
);
36 * add_mtd_device - register an MTD device
37 * @mtd: pointer to new MTD device info structure
39 * Add a device to the list of MTD devices present in the system, and
40 * notify each currently active MTD 'user' of its arrival. Returns
41 * zero on success or 1 on failure, which currently will only happen
42 * if the number of present devices exceeds MAX_MTD_DEVICES (i.e. 16)
45 int add_mtd_device(struct mtd_info
*mtd
)
49 BUG_ON(mtd
->writesize
== 0);
50 mutex_lock(&mtd_table_mutex
);
52 for (i
=0; i
< MAX_MTD_DEVICES
; i
++)
54 struct mtd_notifier
*not;
60 /* Some chips always power up locked. Unlock them now */
61 if ((mtd
->flags
& MTD_WRITEABLE
)
62 && (mtd
->flags
& MTD_STUPID_LOCK
) && mtd
->unlock
) {
63 if (mtd
->unlock(mtd
, 0, mtd
->size
))
66 "writes may not work\n",
70 DEBUG(0, "mtd: Giving out device %d to %s\n",i
, mtd
->name
);
71 /* No need to get a refcount on the module containing
72 the notifier, since we hold the mtd_table_mutex */
73 list_for_each_entry(not, &mtd_notifiers
, list
)
76 mutex_unlock(&mtd_table_mutex
);
77 /* We _know_ we aren't being removed, because
78 our caller is still holding us here. So none
79 of this try_ nonsense, and no bitching about it
81 __module_get(THIS_MODULE
);
85 mutex_unlock(&mtd_table_mutex
);
90 * del_mtd_device - unregister an MTD device
91 * @mtd: pointer to MTD device info structure
93 * Remove a device from the list of MTD devices present in the system,
94 * and notify each currently active MTD 'user' of its departure.
95 * Returns zero on success or 1 on failure, which currently will happen
96 * if the requested device does not appear to be present in the list.
99 int del_mtd_device (struct mtd_info
*mtd
)
103 mutex_lock(&mtd_table_mutex
);
105 if (mtd_table
[mtd
->index
] != mtd
) {
107 } else if (mtd
->usecount
) {
108 printk(KERN_NOTICE
"Removing MTD device #%d (%s) with use count %d\n",
109 mtd
->index
, mtd
->name
, mtd
->usecount
);
112 struct mtd_notifier
*not;
114 /* No need to get a refcount on the module containing
115 the notifier, since we hold the mtd_table_mutex */
116 list_for_each_entry(not, &mtd_notifiers
, list
)
119 mtd_table
[mtd
->index
] = NULL
;
121 module_put(THIS_MODULE
);
125 mutex_unlock(&mtd_table_mutex
);
130 * register_mtd_user - register a 'user' of MTD devices.
131 * @new: pointer to notifier info structure
133 * Registers a pair of callbacks function to be called upon addition
134 * or removal of MTD devices. Causes the 'add' callback to be immediately
135 * invoked for each MTD device currently present in the system.
138 void register_mtd_user (struct mtd_notifier
*new)
142 mutex_lock(&mtd_table_mutex
);
144 list_add(&new->list
, &mtd_notifiers
);
146 __module_get(THIS_MODULE
);
148 for (i
=0; i
< MAX_MTD_DEVICES
; i
++)
150 new->add(mtd_table
[i
]);
152 mutex_unlock(&mtd_table_mutex
);
156 * unregister_mtd_user - unregister a 'user' of MTD devices.
157 * @old: pointer to notifier info structure
159 * Removes a callback function pair from the list of 'users' to be
160 * notified upon addition or removal of MTD devices. Causes the
161 * 'remove' callback to be immediately invoked for each MTD device
162 * currently present in the system.
165 int unregister_mtd_user (struct mtd_notifier
*old
)
169 mutex_lock(&mtd_table_mutex
);
171 module_put(THIS_MODULE
);
173 for (i
=0; i
< MAX_MTD_DEVICES
; i
++)
175 old
->remove(mtd_table
[i
]);
177 list_del(&old
->list
);
178 mutex_unlock(&mtd_table_mutex
);
184 * get_mtd_device - obtain a validated handle for an MTD device
185 * @mtd: last known address of the required MTD device
186 * @num: internal device number of the required MTD device
188 * Given a number and NULL address, return the num'th entry in the device
189 * table, if any. Given an address and num == -1, search the device table
190 * for a device with that address and return if it's still present. Given
191 * both, return the num'th driver only if its address matches. Return
195 struct mtd_info
*get_mtd_device(struct mtd_info
*mtd
, int num
)
197 struct mtd_info
*ret
= NULL
;
198 int i
, err
= -ENODEV
;
200 mutex_lock(&mtd_table_mutex
);
203 for (i
=0; i
< MAX_MTD_DEVICES
; i
++)
204 if (mtd_table
[i
] == mtd
)
206 } else if (num
< MAX_MTD_DEVICES
) {
207 ret
= mtd_table
[num
];
208 if (mtd
&& mtd
!= ret
)
215 if (!try_module_get(ret
->owner
))
218 if (ret
->get_device
) {
219 err
= ret
->get_device(ret
);
225 mutex_unlock(&mtd_table_mutex
);
229 module_put(ret
->owner
);
231 mutex_unlock(&mtd_table_mutex
);
236 * get_mtd_device_nm - obtain a validated handle for an MTD device by
238 * @name: MTD device name to open
240 * This function returns MTD device description structure in case of
241 * success and an error code in case of failure.
244 struct mtd_info
*get_mtd_device_nm(const char *name
)
246 int i
, err
= -ENODEV
;
247 struct mtd_info
*mtd
= NULL
;
249 mutex_lock(&mtd_table_mutex
);
251 for (i
= 0; i
< MAX_MTD_DEVICES
; i
++) {
252 if (mtd_table
[i
] && !strcmp(name
, mtd_table
[i
]->name
)) {
261 if (!try_module_get(mtd
->owner
))
264 if (mtd
->get_device
) {
265 err
= mtd
->get_device(mtd
);
271 mutex_unlock(&mtd_table_mutex
);
275 module_put(mtd
->owner
);
277 mutex_unlock(&mtd_table_mutex
);
281 void put_mtd_device(struct mtd_info
*mtd
)
285 mutex_lock(&mtd_table_mutex
);
288 mtd
->put_device(mtd
);
289 mutex_unlock(&mtd_table_mutex
);
292 module_put(mtd
->owner
);
295 /* default_mtd_writev - default mtd writev method for MTD devices that
296 * don't implement their own
299 int default_mtd_writev(struct mtd_info
*mtd
, const struct kvec
*vecs
,
300 unsigned long count
, loff_t to
, size_t *retlen
)
303 size_t totlen
= 0, thislen
;
309 for (i
=0; i
<count
; i
++) {
310 if (!vecs
[i
].iov_len
)
312 ret
= mtd
->write(mtd
, to
, vecs
[i
].iov_len
, &thislen
, vecs
[i
].iov_base
);
314 if (ret
|| thislen
!= vecs
[i
].iov_len
)
316 to
+= vecs
[i
].iov_len
;
325 * mtd_kmalloc_up_to - allocate a contiguous buffer up to the specified size
326 * @size: A pointer to the ideal or maximum size of the allocation. Points
327 * to the actual allocation size on success.
329 * This routine attempts to allocate a contiguous kernel buffer up to
330 * the specified size, backing off the size of the request exponentially
331 * until the request succeeds or until the allocation size falls below
332 * the system page size. This attempts to make sure it does not adversely
333 * impact system performance, so when allocating more than one page, we
334 * ask the memory allocator to avoid re-trying, swapping, writing back
337 * Note, this function also makes sure that the allocated buffer is aligned to
338 * the MTD device's min. I/O unit, i.e. the "mtd->writesize" value.
340 * This is called, for example by mtd_{read,write} and jffs2_scan_medium,
341 * to handle smaller (i.e. degraded) buffer allocations under low- or
342 * fragmented-memory situations where such reduced allocations, from a
343 * requested ideal, are allowed.
345 * Returns a pointer to the allocated buffer on success; otherwise, NULL.
347 void *mtd_kmalloc_up_to(const struct mtd_info
*mtd
, size_t *size
)
349 gfp_t flags
= __GFP_NOWARN
| __GFP_WAIT
|
351 size_t min_alloc
= max_t(size_t, mtd
->writesize
, PAGE_SIZE
);
354 *size
= min_t(size_t, *size
, KMALLOC_MAX_SIZE
);
356 while (*size
> min_alloc
) {
357 kbuf
= kmalloc(*size
, flags
);
362 *size
= ALIGN(*size
, mtd
->writesize
);
366 * For the last resort allocation allow 'kmalloc()' to do all sorts of
367 * things (write-back, dropping caches, etc) by using GFP_KERNEL.
369 return kmalloc(*size
, GFP_KERNEL
);
372 EXPORT_SYMBOL_GPL(add_mtd_device
);
373 EXPORT_SYMBOL_GPL(del_mtd_device
);
374 EXPORT_SYMBOL_GPL(get_mtd_device
);
375 EXPORT_SYMBOL_GPL(get_mtd_device_nm
);
376 EXPORT_SYMBOL_GPL(put_mtd_device
);
377 EXPORT_SYMBOL_GPL(register_mtd_user
);
378 EXPORT_SYMBOL_GPL(unregister_mtd_user
);
379 EXPORT_SYMBOL_GPL(default_mtd_writev
);
380 EXPORT_SYMBOL_GPL(mtd_kmalloc_up_to
);
382 #ifdef CONFIG_PROC_FS
384 /*====================================================================*/
385 /* Support for /proc/mtd */
387 static struct proc_dir_entry
*proc_mtd
;
389 static inline int mtd_proc_info (char *buf
, int i
)
391 struct mtd_info
*this = mtd_table
[i
];
396 return sprintf(buf
, "mtd%d: %8.8x %8.8x \"%s\"\n", i
, this->size
,
397 this->erasesize
, this->name
);
400 static int mtd_read_proc (char *page
, char **start
, off_t off
, int count
,
401 int *eof
, void *data_unused
)
406 mutex_lock(&mtd_table_mutex
);
408 len
= sprintf(page
, "dev: size erasesize name\n");
409 for (i
=0; i
< MAX_MTD_DEVICES
; i
++) {
411 l
= mtd_proc_info(page
+ len
, i
);
413 if (len
+begin
> off
+count
)
415 if (len
+begin
< off
) {
424 mutex_unlock(&mtd_table_mutex
);
425 if (off
>= len
+begin
)
427 *start
= page
+ (off
-begin
);
428 return ((count
< begin
+len
-off
) ? count
: begin
+len
-off
);
431 /*====================================================================*/
434 static int __init
init_mtd(void)
436 if ((proc_mtd
= create_proc_entry( "mtd", 0, NULL
)))
437 proc_mtd
->read_proc
= mtd_read_proc
;
441 static void __exit
cleanup_mtd(void)
444 remove_proc_entry( "mtd", NULL
);
447 module_init(init_mtd
);
448 module_exit(cleanup_mtd
);
450 #endif /* CONFIG_PROC_FS */
453 MODULE_LICENSE("GPL");
454 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
455 MODULE_DESCRIPTION("Core MTD registration and access routines");