2 * $Id: mtd_blkdevs.c,v 1.27 2005/11/07 11:14:20 gleixner Exp $
4 * (C) 2003 David Woodhouse <dwmw2@infradead.org>
6 * Interface to Linux 2.5 block layer for MTD 'translation layers'.
10 #include <linux/kernel.h>
11 #include <linux/slab.h>
12 #include <linux/module.h>
13 #include <linux/list.h>
15 #include <linux/mtd/blktrans.h>
16 #include <linux/mtd/mtd.h>
17 #include <linux/blkdev.h>
18 #include <linux/blkpg.h>
19 #include <linux/spinlock.h>
20 #include <linux/hdreg.h>
21 #include <linux/init.h>
22 #include <asm/semaphore.h>
23 #include <asm/uaccess.h>
25 static LIST_HEAD(blktrans_majors
);
27 extern struct semaphore mtd_table_mutex
;
28 extern struct mtd_info
*mtd_table
[];
30 struct mtd_blkcore_priv
{
31 struct completion thread_dead
;
33 wait_queue_head_t thread_wq
;
34 struct request_queue
*rq
;
35 spinlock_t queue_lock
;
38 static int do_blktrans_request(struct mtd_blktrans_ops
*tr
,
39 struct mtd_blktrans_dev
*dev
,
42 unsigned long block
, nsect
;
46 nsect
= req
->current_nr_sectors
;
49 if (!(req
->flags
& REQ_CMD
))
52 if (block
+ nsect
> get_capacity(req
->rq_disk
))
55 switch(rq_data_dir(req
)) {
57 for (; nsect
> 0; nsect
--, block
++, buf
+= 512)
58 if (tr
->readsect(dev
, block
, buf
))
66 for (; nsect
> 0; nsect
--, block
++, buf
+= 512)
67 if (tr
->writesect(dev
, block
, buf
))
72 printk(KERN_NOTICE
"Unknown request %ld\n", rq_data_dir(req
));
77 static int mtd_blktrans_thread(void *arg
)
79 struct mtd_blktrans_ops
*tr
= arg
;
80 struct request_queue
*rq
= tr
->blkcore_priv
->rq
;
82 /* we might get involved when memory gets low, so use PF_MEMALLOC */
83 current
->flags
|= PF_MEMALLOC
| PF_NOFREEZE
;
85 daemonize("%sd", tr
->name
);
87 /* daemonize() doesn't do this for us since some kernel threads
88 actually want to deal with signals. We can't just call
89 exit_sighand() since that'll cause an oops when we finally
91 spin_lock_irq(¤t
->sighand
->siglock
);
92 sigfillset(¤t
->blocked
);
94 spin_unlock_irq(¤t
->sighand
->siglock
);
96 spin_lock_irq(rq
->queue_lock
);
98 while (!tr
->blkcore_priv
->exiting
) {
100 struct mtd_blktrans_dev
*dev
;
102 DECLARE_WAITQUEUE(wait
, current
);
104 req
= elv_next_request(rq
);
107 add_wait_queue(&tr
->blkcore_priv
->thread_wq
, &wait
);
108 set_current_state(TASK_INTERRUPTIBLE
);
110 spin_unlock_irq(rq
->queue_lock
);
113 remove_wait_queue(&tr
->blkcore_priv
->thread_wq
, &wait
);
115 spin_lock_irq(rq
->queue_lock
);
120 dev
= req
->rq_disk
->private_data
;
123 spin_unlock_irq(rq
->queue_lock
);
126 res
= do_blktrans_request(tr
, dev
, req
);
129 spin_lock_irq(rq
->queue_lock
);
131 end_request(req
, res
);
133 spin_unlock_irq(rq
->queue_lock
);
135 complete_and_exit(&tr
->blkcore_priv
->thread_dead
, 0);
138 static void mtd_blktrans_request(struct request_queue
*rq
)
140 struct mtd_blktrans_ops
*tr
= rq
->queuedata
;
141 wake_up(&tr
->blkcore_priv
->thread_wq
);
145 static int blktrans_open(struct inode
*i
, struct file
*f
)
147 struct mtd_blktrans_dev
*dev
;
148 struct mtd_blktrans_ops
*tr
;
151 dev
= i
->i_bdev
->bd_disk
->private_data
;
154 if (!try_module_get(dev
->mtd
->owner
))
157 if (!try_module_get(tr
->owner
))
160 /* FIXME: Locking. A hot pluggable device can go away
161 (del_mtd_device can be called for it) without its module
163 dev
->mtd
->usecount
++;
166 if (tr
->open
&& (ret
= tr
->open(dev
))) {
167 dev
->mtd
->usecount
--;
168 module_put(dev
->mtd
->owner
);
170 module_put(tr
->owner
);
176 static int blktrans_release(struct inode
*i
, struct file
*f
)
178 struct mtd_blktrans_dev
*dev
;
179 struct mtd_blktrans_ops
*tr
;
182 dev
= i
->i_bdev
->bd_disk
->private_data
;
186 ret
= tr
->release(dev
);
189 dev
->mtd
->usecount
--;
190 module_put(dev
->mtd
->owner
);
191 module_put(tr
->owner
);
198 static int blktrans_ioctl(struct inode
*inode
, struct file
*file
,
199 unsigned int cmd
, unsigned long arg
)
201 struct mtd_blktrans_dev
*dev
= inode
->i_bdev
->bd_disk
->private_data
;
202 struct mtd_blktrans_ops
*tr
= dev
->tr
;
207 return tr
->flush(dev
);
208 /* The core code did the work, we had nothing to do. */
213 struct hd_geometry g
;
216 memset(&g
, 0, sizeof(g
));
217 ret
= tr
->getgeo(dev
, &g
);
221 g
.start
= get_start_sect(inode
->i_bdev
);
222 if (copy_to_user((void __user
*)arg
, &g
, sizeof(g
)))
231 struct block_device_operations mtd_blktrans_ops
= {
232 .owner
= THIS_MODULE
,
233 .open
= blktrans_open
,
234 .release
= blktrans_release
,
235 .ioctl
= blktrans_ioctl
,
238 int add_mtd_blktrans_dev(struct mtd_blktrans_dev
*new)
240 struct mtd_blktrans_ops
*tr
= new->tr
;
241 struct list_head
*this;
242 int last_devnum
= -1;
245 if (!down_trylock(&mtd_table_mutex
)) {
246 up(&mtd_table_mutex
);
250 list_for_each(this, &tr
->devs
) {
251 struct mtd_blktrans_dev
*d
= list_entry(this, struct mtd_blktrans_dev
, list
);
252 if (new->devnum
== -1) {
253 /* Use first free number */
254 if (d
->devnum
!= last_devnum
+1) {
255 /* Found a free devnum. Plug it in here */
256 new->devnum
= last_devnum
+1;
257 list_add_tail(&new->list
, &d
->list
);
260 } else if (d
->devnum
== new->devnum
) {
261 /* Required number taken */
263 } else if (d
->devnum
> new->devnum
) {
264 /* Required number was free */
265 list_add_tail(&new->list
, &d
->list
);
268 last_devnum
= d
->devnum
;
270 if (new->devnum
== -1)
271 new->devnum
= last_devnum
+1;
273 if ((new->devnum
<< tr
->part_bits
) > 256) {
277 init_MUTEX(&new->sem
);
278 list_add_tail(&new->list
, &tr
->devs
);
283 gd
= alloc_disk(1 << tr
->part_bits
);
285 list_del(&new->list
);
288 gd
->major
= tr
->major
;
289 gd
->first_minor
= (new->devnum
) << tr
->part_bits
;
290 gd
->fops
= &mtd_blktrans_ops
;
293 if (new->devnum
< 26)
294 snprintf(gd
->disk_name
, sizeof(gd
->disk_name
),
295 "%s%c", tr
->name
, 'a' + new->devnum
);
297 snprintf(gd
->disk_name
, sizeof(gd
->disk_name
),
299 'a' - 1 + new->devnum
/ 26,
300 'a' + new->devnum
% 26);
302 snprintf(gd
->disk_name
, sizeof(gd
->disk_name
),
303 "%s%d", tr
->name
, new->devnum
);
305 /* 2.5 has capacity in units of 512 bytes while still
306 having BLOCK_SIZE_BITS set to 10. Just to keep us amused. */
307 set_capacity(gd
, (new->size
* new->blksize
) >> 9);
309 gd
->private_data
= new;
310 new->blkcore_priv
= gd
;
311 gd
->queue
= tr
->blkcore_priv
->rq
;
321 int del_mtd_blktrans_dev(struct mtd_blktrans_dev
*old
)
323 if (!down_trylock(&mtd_table_mutex
)) {
324 up(&mtd_table_mutex
);
328 list_del(&old
->list
);
330 del_gendisk(old
->blkcore_priv
);
331 put_disk(old
->blkcore_priv
);
336 static void blktrans_notify_remove(struct mtd_info
*mtd
)
338 struct list_head
*this, *this2
, *next
;
340 list_for_each(this, &blktrans_majors
) {
341 struct mtd_blktrans_ops
*tr
= list_entry(this, struct mtd_blktrans_ops
, list
);
343 list_for_each_safe(this2
, next
, &tr
->devs
) {
344 struct mtd_blktrans_dev
*dev
= list_entry(this2
, struct mtd_blktrans_dev
, list
);
352 static void blktrans_notify_add(struct mtd_info
*mtd
)
354 struct list_head
*this;
356 if (mtd
->type
== MTD_ABSENT
)
359 list_for_each(this, &blktrans_majors
) {
360 struct mtd_blktrans_ops
*tr
= list_entry(this, struct mtd_blktrans_ops
, list
);
362 tr
->add_mtd(tr
, mtd
);
367 static struct mtd_notifier blktrans_notifier
= {
368 .add
= blktrans_notify_add
,
369 .remove
= blktrans_notify_remove
,
372 int register_mtd_blktrans(struct mtd_blktrans_ops
*tr
)
376 /* Register the notifier if/when the first device type is
377 registered, to prevent the link/init ordering from fucking
379 if (!blktrans_notifier
.list
.next
)
380 register_mtd_user(&blktrans_notifier
);
382 tr
->blkcore_priv
= kmalloc(sizeof(*tr
->blkcore_priv
), GFP_KERNEL
);
383 if (!tr
->blkcore_priv
)
386 memset(tr
->blkcore_priv
, 0, sizeof(*tr
->blkcore_priv
));
388 down(&mtd_table_mutex
);
390 ret
= register_blkdev(tr
->major
, tr
->name
);
392 printk(KERN_WARNING
"Unable to register %s block device on major %d: %d\n",
393 tr
->name
, tr
->major
, ret
);
394 kfree(tr
->blkcore_priv
);
395 up(&mtd_table_mutex
);
398 spin_lock_init(&tr
->blkcore_priv
->queue_lock
);
399 init_completion(&tr
->blkcore_priv
->thread_dead
);
400 init_waitqueue_head(&tr
->blkcore_priv
->thread_wq
);
402 tr
->blkcore_priv
->rq
= blk_init_queue(mtd_blktrans_request
, &tr
->blkcore_priv
->queue_lock
);
403 if (!tr
->blkcore_priv
->rq
) {
404 unregister_blkdev(tr
->major
, tr
->name
);
405 kfree(tr
->blkcore_priv
);
406 up(&mtd_table_mutex
);
410 tr
->blkcore_priv
->rq
->queuedata
= tr
;
412 ret
= kernel_thread(mtd_blktrans_thread
, tr
, CLONE_KERNEL
);
414 blk_cleanup_queue(tr
->blkcore_priv
->rq
);
415 unregister_blkdev(tr
->major
, tr
->name
);
416 kfree(tr
->blkcore_priv
);
417 up(&mtd_table_mutex
);
421 INIT_LIST_HEAD(&tr
->devs
);
422 list_add(&tr
->list
, &blktrans_majors
);
424 for (i
=0; i
<MAX_MTD_DEVICES
; i
++) {
425 if (mtd_table
[i
] && mtd_table
[i
]->type
!= MTD_ABSENT
)
426 tr
->add_mtd(tr
, mtd_table
[i
]);
429 up(&mtd_table_mutex
);
434 int deregister_mtd_blktrans(struct mtd_blktrans_ops
*tr
)
436 struct list_head
*this, *next
;
438 down(&mtd_table_mutex
);
440 /* Clean up the kernel thread */
441 tr
->blkcore_priv
->exiting
= 1;
442 wake_up(&tr
->blkcore_priv
->thread_wq
);
443 wait_for_completion(&tr
->blkcore_priv
->thread_dead
);
445 /* Remove it from the list of active majors */
448 list_for_each_safe(this, next
, &tr
->devs
) {
449 struct mtd_blktrans_dev
*dev
= list_entry(this, struct mtd_blktrans_dev
, list
);
453 blk_cleanup_queue(tr
->blkcore_priv
->rq
);
454 unregister_blkdev(tr
->major
, tr
->name
);
456 up(&mtd_table_mutex
);
458 kfree(tr
->blkcore_priv
);
460 if (!list_empty(&tr
->devs
))
465 static void __exit
mtd_blktrans_exit(void)
467 /* No race here -- if someone's currently in register_mtd_blktrans
468 we're screwed anyway. */
469 if (blktrans_notifier
.list
.next
)
470 unregister_mtd_user(&blktrans_notifier
);
473 module_exit(mtd_blktrans_exit
);
475 EXPORT_SYMBOL_GPL(register_mtd_blktrans
);
476 EXPORT_SYMBOL_GPL(deregister_mtd_blktrans
);
477 EXPORT_SYMBOL_GPL(add_mtd_blktrans_dev
);
478 EXPORT_SYMBOL_GPL(del_mtd_blktrans_dev
);
480 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
481 MODULE_LICENSE("GPL");
482 MODULE_DESCRIPTION("Common interface to block layer for MTD 'translation layers'");