[PATCH] spi: mtd dataflash driver
[linux-2.6] / drivers / mtd / mtdcore.c
1 /*
2  * $Id: mtdcore.c,v 1.47 2005/11/07 11:14:20 gleixner Exp $
3  *
4  * Core registration and callback routines for MTD
5  * drivers and users.
6  *
7  */
8
9 #include <linux/config.h>
10 #include <linux/module.h>
11 #include <linux/kernel.h>
12 #include <linux/sched.h>
13 #include <linux/ptrace.h>
14 #include <linux/slab.h>
15 #include <linux/string.h>
16 #include <linux/timer.h>
17 #include <linux/major.h>
18 #include <linux/fs.h>
19 #include <linux/ioctl.h>
20 #include <linux/init.h>
21 #include <linux/mtd/compatmac.h>
22 #ifdef CONFIG_PROC_FS
23 #include <linux/proc_fs.h>
24 #endif
25
26 #include <linux/mtd/mtd.h>
27
28 /* These are exported solely for the purpose of mtd_blkdevs.c. You
29    should not use them for _anything_ else */
30 DECLARE_MUTEX(mtd_table_mutex);
31 struct mtd_info *mtd_table[MAX_MTD_DEVICES];
32
33 EXPORT_SYMBOL_GPL(mtd_table_mutex);
34 EXPORT_SYMBOL_GPL(mtd_table);
35
36 static LIST_HEAD(mtd_notifiers);
37
38 /**
39  *      add_mtd_device - register an MTD device
40  *      @mtd: pointer to new MTD device info structure
41  *
42  *      Add a device to the list of MTD devices present in the system, and
43  *      notify each currently active MTD 'user' of its arrival. Returns
44  *      zero on success or 1 on failure, which currently will only happen
45  *      if the number of present devices exceeds MAX_MTD_DEVICES (i.e. 16)
46  */
47
48 int add_mtd_device(struct mtd_info *mtd)
49 {
50         int i;
51
52         down(&mtd_table_mutex);
53
54         for (i=0; i < MAX_MTD_DEVICES; i++)
55                 if (!mtd_table[i]) {
56                         struct list_head *this;
57
58                         mtd_table[i] = mtd;
59                         mtd->index = i;
60                         mtd->usecount = 0;
61
62                         DEBUG(0, "mtd: Giving out device %d to %s\n",i, mtd->name);
63                         /* No need to get a refcount on the module containing
64                            the notifier, since we hold the mtd_table_mutex */
65                         list_for_each(this, &mtd_notifiers) {
66                                 struct mtd_notifier *not = list_entry(this, struct mtd_notifier, list);
67                                 not->add(mtd);
68                         }
69
70                         up(&mtd_table_mutex);
71                         /* We _know_ we aren't being removed, because
72                            our caller is still holding us here. So none
73                            of this try_ nonsense, and no bitching about it
74                            either. :) */
75                         __module_get(THIS_MODULE);
76                         return 0;
77                 }
78
79         up(&mtd_table_mutex);
80         return 1;
81 }
82
83 /**
84  *      del_mtd_device - unregister an MTD device
85  *      @mtd: pointer to MTD device info structure
86  *
87  *      Remove a device from the list of MTD devices present in the system,
88  *      and notify each currently active MTD 'user' of its departure.
89  *      Returns zero on success or 1 on failure, which currently will happen
90  *      if the requested device does not appear to be present in the list.
91  */
92
93 int del_mtd_device (struct mtd_info *mtd)
94 {
95         int ret;
96
97         down(&mtd_table_mutex);
98
99         if (mtd_table[mtd->index] != mtd) {
100                 ret = -ENODEV;
101         } else if (mtd->usecount) {
102                 printk(KERN_NOTICE "Removing MTD device #%d (%s) with use count %d\n",
103                        mtd->index, mtd->name, mtd->usecount);
104                 ret = -EBUSY;
105         } else {
106                 struct list_head *this;
107
108                 /* No need to get a refcount on the module containing
109                    the notifier, since we hold the mtd_table_mutex */
110                 list_for_each(this, &mtd_notifiers) {
111                         struct mtd_notifier *not = list_entry(this, struct mtd_notifier, list);
112                         not->remove(mtd);
113                 }
114
115                 mtd_table[mtd->index] = NULL;
116
117                 module_put(THIS_MODULE);
118                 ret = 0;
119         }
120
121         up(&mtd_table_mutex);
122         return ret;
123 }
124
125 /**
126  *      register_mtd_user - register a 'user' of MTD devices.
127  *      @new: pointer to notifier info structure
128  *
129  *      Registers a pair of callbacks function to be called upon addition
130  *      or removal of MTD devices. Causes the 'add' callback to be immediately
131  *      invoked for each MTD device currently present in the system.
132  */
133
134 void register_mtd_user (struct mtd_notifier *new)
135 {
136         int i;
137
138         down(&mtd_table_mutex);
139
140         list_add(&new->list, &mtd_notifiers);
141
142         __module_get(THIS_MODULE);
143
144         for (i=0; i< MAX_MTD_DEVICES; i++)
145                 if (mtd_table[i])
146                         new->add(mtd_table[i]);
147
148         up(&mtd_table_mutex);
149 }
150
151 /**
152  *      unregister_mtd_user - unregister a 'user' of MTD devices.
153  *      @old: pointer to notifier info structure
154  *
155  *      Removes a callback function pair from the list of 'users' to be
156  *      notified upon addition or removal of MTD devices. Causes the
157  *      'remove' callback to be immediately invoked for each MTD device
158  *      currently present in the system.
159  */
160
161 int unregister_mtd_user (struct mtd_notifier *old)
162 {
163         int i;
164
165         down(&mtd_table_mutex);
166
167         module_put(THIS_MODULE);
168
169         for (i=0; i< MAX_MTD_DEVICES; i++)
170                 if (mtd_table[i])
171                         old->remove(mtd_table[i]);
172
173         list_del(&old->list);
174         up(&mtd_table_mutex);
175         return 0;
176 }
177
178
179 /**
180  *      get_mtd_device - obtain a validated handle for an MTD device
181  *      @mtd: last known address of the required MTD device
182  *      @num: internal device number of the required MTD device
183  *
184  *      Given a number and NULL address, return the num'th entry in the device
185  *      table, if any.  Given an address and num == -1, search the device table
186  *      for a device with that address and return if it's still present. Given
187  *      both, return the num'th driver only if its address matches. Return NULL
188  *      if not.
189  */
190
191 struct mtd_info *get_mtd_device(struct mtd_info *mtd, int num)
192 {
193         struct mtd_info *ret = NULL;
194         int i;
195
196         down(&mtd_table_mutex);
197
198         if (num == -1) {
199                 for (i=0; i< MAX_MTD_DEVICES; i++)
200                         if (mtd_table[i] == mtd)
201                                 ret = mtd_table[i];
202         } else if (num < MAX_MTD_DEVICES) {
203                 ret = mtd_table[num];
204                 if (mtd && mtd != ret)
205                         ret = NULL;
206         }
207
208         if (ret && !try_module_get(ret->owner))
209                 ret = NULL;
210
211         if (ret)
212                 ret->usecount++;
213
214         up(&mtd_table_mutex);
215         return ret;
216 }
217
218 void put_mtd_device(struct mtd_info *mtd)
219 {
220         int c;
221
222         down(&mtd_table_mutex);
223         c = --mtd->usecount;
224         up(&mtd_table_mutex);
225         BUG_ON(c < 0);
226
227         module_put(mtd->owner);
228 }
229
230 /* default_mtd_writev - default mtd writev method for MTD devices that
231  *                      dont implement their own
232  */
233
234 int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
235                        unsigned long count, loff_t to, size_t *retlen)
236 {
237         unsigned long i;
238         size_t totlen = 0, thislen;
239         int ret = 0;
240
241         if(!mtd->write) {
242                 ret = -EROFS;
243         } else {
244                 for (i=0; i<count; i++) {
245                         if (!vecs[i].iov_len)
246                                 continue;
247                         ret = mtd->write(mtd, to, vecs[i].iov_len, &thislen, vecs[i].iov_base);
248                         totlen += thislen;
249                         if (ret || thislen != vecs[i].iov_len)
250                                 break;
251                         to += vecs[i].iov_len;
252                 }
253         }
254         if (retlen)
255                 *retlen = totlen;
256         return ret;
257 }
258
259
260 /* default_mtd_readv - default mtd readv method for MTD devices that dont
261  *                     implement their own
262  */
263
264 int default_mtd_readv(struct mtd_info *mtd, struct kvec *vecs,
265                       unsigned long count, loff_t from, size_t *retlen)
266 {
267         unsigned long i;
268         size_t totlen = 0, thislen;
269         int ret = 0;
270
271         if(!mtd->read) {
272                 ret = -EIO;
273         } else {
274                 for (i=0; i<count; i++) {
275                         if (!vecs[i].iov_len)
276                                 continue;
277                         ret = mtd->read(mtd, from, vecs[i].iov_len, &thislen, vecs[i].iov_base);
278                         totlen += thislen;
279                         if (ret || thislen != vecs[i].iov_len)
280                                 break;
281                         from += vecs[i].iov_len;
282                 }
283         }
284         if (retlen)
285                 *retlen = totlen;
286         return ret;
287 }
288
289
290 EXPORT_SYMBOL(add_mtd_device);
291 EXPORT_SYMBOL(del_mtd_device);
292 EXPORT_SYMBOL(get_mtd_device);
293 EXPORT_SYMBOL(put_mtd_device);
294 EXPORT_SYMBOL(register_mtd_user);
295 EXPORT_SYMBOL(unregister_mtd_user);
296 EXPORT_SYMBOL(default_mtd_writev);
297 EXPORT_SYMBOL(default_mtd_readv);
298
299 /*====================================================================*/
300 /* Support for /proc/mtd */
301
302 #ifdef CONFIG_PROC_FS
303 static struct proc_dir_entry *proc_mtd;
304
305 static inline int mtd_proc_info (char *buf, int i)
306 {
307         struct mtd_info *this = mtd_table[i];
308
309         if (!this)
310                 return 0;
311
312         return sprintf(buf, "mtd%d: %8.8x %8.8x \"%s\"\n", i, this->size,
313                        this->erasesize, this->name);
314 }
315
316 static int mtd_read_proc (char *page, char **start, off_t off, int count,
317                           int *eof, void *data_unused)
318 {
319         int len, l, i;
320         off_t   begin = 0;
321
322         down(&mtd_table_mutex);
323
324         len = sprintf(page, "dev:    size   erasesize  name\n");
325         for (i=0; i< MAX_MTD_DEVICES; i++) {
326
327                 l = mtd_proc_info(page + len, i);
328                 len += l;
329                 if (len+begin > off+count)
330                         goto done;
331                 if (len+begin < off) {
332                         begin += len;
333                         len = 0;
334                 }
335         }
336
337         *eof = 1;
338
339 done:
340         up(&mtd_table_mutex);
341         if (off >= len+begin)
342                 return 0;
343         *start = page + (off-begin);
344         return ((count < begin+len-off) ? count : begin+len-off);
345 }
346
347 #endif /* CONFIG_PROC_FS */
348
349 /*====================================================================*/
350 /* Init code */
351
352 static int __init init_mtd(void)
353 {
354 #ifdef CONFIG_PROC_FS
355         if ((proc_mtd = create_proc_entry( "mtd", 0, NULL )))
356                 proc_mtd->read_proc = mtd_read_proc;
357 #endif
358         return 0;
359 }
360
361 static void __exit cleanup_mtd(void)
362 {
363 #ifdef CONFIG_PROC_FS
364         if (proc_mtd)
365                 remove_proc_entry( "mtd", NULL);
366 #endif
367 }
368
369 module_init(init_mtd);
370 module_exit(cleanup_mtd);
371
372
373 MODULE_LICENSE("GPL");
374 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
375 MODULE_DESCRIPTION("Core MTD registration and access routines");