2 * (C) 2003 David Woodhouse <dwmw2@infradead.org>
4 * Interface to Linux 2.5 block layer for MTD 'translation layers'.
8 #include <linux/kernel.h>
9 #include <linux/slab.h>
10 #include <linux/module.h>
11 #include <linux/list.h>
13 #include <linux/mtd/blktrans.h>
14 #include <linux/mtd/mtd.h>
15 #include <linux/blkdev.h>
16 #include <linux/blkpg.h>
17 #include <linux/freezer.h>
18 #include <linux/spinlock.h>
19 #include <linux/hdreg.h>
20 #include <linux/init.h>
21 #include <linux/mutex.h>
22 #include <linux/kthread.h>
23 #include <asm/uaccess.h>
27 static LIST_HEAD(blktrans_majors
);
29 struct mtd_blkcore_priv
{
30 struct task_struct
*thread
;
31 struct request_queue
*rq
;
32 spinlock_t queue_lock
;
35 static int blktrans_discard_request(struct request_queue
*q
,
38 req
->cmd_type
= REQ_TYPE_LINUX_BLOCK
;
39 req
->cmd
[0] = REQ_LB_OP_DISCARD
;
43 static int do_blktrans_request(struct mtd_blktrans_ops
*tr
,
44 struct mtd_blktrans_dev
*dev
,
47 unsigned long block
, nsect
;
50 block
= req
->sector
<< 9 >> tr
->blkshift
;
51 nsect
= req
->current_nr_sectors
<< 9 >> tr
->blkshift
;
55 if (req
->cmd_type
== REQ_TYPE_LINUX_BLOCK
&&
56 req
->cmd
[0] == REQ_LB_OP_DISCARD
)
57 return !tr
->discard(dev
, block
, nsect
);
59 if (!blk_fs_request(req
))
62 if (req
->sector
+ req
->current_nr_sectors
> get_capacity(req
->rq_disk
))
65 switch(rq_data_dir(req
)) {
67 for (; nsect
> 0; nsect
--, block
++, buf
+= tr
->blksize
)
68 if (tr
->readsect(dev
, block
, buf
))
76 for (; nsect
> 0; nsect
--, block
++, buf
+= tr
->blksize
)
77 if (tr
->writesect(dev
, block
, buf
))
82 printk(KERN_NOTICE
"Unknown request %u\n", rq_data_dir(req
));
87 static int mtd_blktrans_thread(void *arg
)
89 struct mtd_blktrans_ops
*tr
= arg
;
90 struct request_queue
*rq
= tr
->blkcore_priv
->rq
;
92 /* we might get involved when memory gets low, so use PF_MEMALLOC */
93 current
->flags
|= PF_MEMALLOC
;
95 spin_lock_irq(rq
->queue_lock
);
96 while (!kthread_should_stop()) {
98 struct mtd_blktrans_dev
*dev
;
101 req
= elv_next_request(rq
);
104 set_current_state(TASK_INTERRUPTIBLE
);
105 spin_unlock_irq(rq
->queue_lock
);
107 spin_lock_irq(rq
->queue_lock
);
111 dev
= req
->rq_disk
->private_data
;
114 spin_unlock_irq(rq
->queue_lock
);
116 mutex_lock(&dev
->lock
);
117 res
= do_blktrans_request(tr
, dev
, req
);
118 mutex_unlock(&dev
->lock
);
120 spin_lock_irq(rq
->queue_lock
);
122 end_request(req
, res
);
124 spin_unlock_irq(rq
->queue_lock
);
129 static void mtd_blktrans_request(struct request_queue
*rq
)
131 struct mtd_blktrans_ops
*tr
= rq
->queuedata
;
132 wake_up_process(tr
->blkcore_priv
->thread
);
136 static int blktrans_open(struct block_device
*bdev
, fmode_t mode
)
138 struct mtd_blktrans_dev
*dev
= bdev
->bd_disk
->private_data
;
139 struct mtd_blktrans_ops
*tr
= dev
->tr
;
142 if (!try_module_get(dev
->mtd
->owner
))
145 if (!try_module_get(tr
->owner
))
148 /* FIXME: Locking. A hot pluggable device can go away
149 (del_mtd_device can be called for it) without its module
151 dev
->mtd
->usecount
++;
154 if (tr
->open
&& (ret
= tr
->open(dev
))) {
155 dev
->mtd
->usecount
--;
156 module_put(dev
->mtd
->owner
);
158 module_put(tr
->owner
);
164 static int blktrans_release(struct gendisk
*disk
, fmode_t mode
)
166 struct mtd_blktrans_dev
*dev
= disk
->private_data
;
167 struct mtd_blktrans_ops
*tr
= dev
->tr
;
171 ret
= tr
->release(dev
);
174 dev
->mtd
->usecount
--;
175 module_put(dev
->mtd
->owner
);
176 module_put(tr
->owner
);
182 static int blktrans_getgeo(struct block_device
*bdev
, struct hd_geometry
*geo
)
184 struct mtd_blktrans_dev
*dev
= bdev
->bd_disk
->private_data
;
187 return dev
->tr
->getgeo(dev
, geo
);
191 static int blktrans_ioctl(struct block_device
*bdev
, fmode_t mode
,
192 unsigned int cmd
, unsigned long arg
)
194 struct mtd_blktrans_dev
*dev
= bdev
->bd_disk
->private_data
;
195 struct mtd_blktrans_ops
*tr
= dev
->tr
;
200 return tr
->flush(dev
);
201 /* The core code did the work, we had nothing to do. */
208 static struct block_device_operations mtd_blktrans_ops
= {
209 .owner
= THIS_MODULE
,
210 .open
= blktrans_open
,
211 .release
= blktrans_release
,
212 .locked_ioctl
= blktrans_ioctl
,
213 .getgeo
= blktrans_getgeo
,
216 int add_mtd_blktrans_dev(struct mtd_blktrans_dev
*new)
218 struct mtd_blktrans_ops
*tr
= new->tr
;
219 struct mtd_blktrans_dev
*d
;
220 int last_devnum
= -1;
223 if (mutex_trylock(&mtd_table_mutex
)) {
224 mutex_unlock(&mtd_table_mutex
);
228 list_for_each_entry(d
, &tr
->devs
, list
) {
229 if (new->devnum
== -1) {
230 /* Use first free number */
231 if (d
->devnum
!= last_devnum
+1) {
232 /* Found a free devnum. Plug it in here */
233 new->devnum
= last_devnum
+1;
234 list_add_tail(&new->list
, &d
->list
);
237 } else if (d
->devnum
== new->devnum
) {
238 /* Required number taken */
240 } else if (d
->devnum
> new->devnum
) {
241 /* Required number was free */
242 list_add_tail(&new->list
, &d
->list
);
245 last_devnum
= d
->devnum
;
247 if (new->devnum
== -1)
248 new->devnum
= last_devnum
+1;
250 if ((new->devnum
<< tr
->part_bits
) > 256) {
254 list_add_tail(&new->list
, &tr
->devs
);
256 mutex_init(&new->lock
);
260 gd
= alloc_disk(1 << tr
->part_bits
);
262 list_del(&new->list
);
265 gd
->major
= tr
->major
;
266 gd
->first_minor
= (new->devnum
) << tr
->part_bits
;
267 gd
->fops
= &mtd_blktrans_ops
;
270 if (new->devnum
< 26)
271 snprintf(gd
->disk_name
, sizeof(gd
->disk_name
),
272 "%s%c", tr
->name
, 'a' + new->devnum
);
274 snprintf(gd
->disk_name
, sizeof(gd
->disk_name
),
276 'a' - 1 + new->devnum
/ 26,
277 'a' + new->devnum
% 26);
279 snprintf(gd
->disk_name
, sizeof(gd
->disk_name
),
280 "%s%d", tr
->name
, new->devnum
);
282 /* 2.5 has capacity in units of 512 bytes while still
283 having BLOCK_SIZE_BITS set to 10. Just to keep us amused. */
284 set_capacity(gd
, (new->size
* tr
->blksize
) >> 9);
286 gd
->private_data
= new;
287 new->blkcore_priv
= gd
;
288 gd
->queue
= tr
->blkcore_priv
->rq
;
289 gd
->driverfs_dev
= new->mtd
->dev
.parent
;
299 int del_mtd_blktrans_dev(struct mtd_blktrans_dev
*old
)
301 if (mutex_trylock(&mtd_table_mutex
)) {
302 mutex_unlock(&mtd_table_mutex
);
306 list_del(&old
->list
);
308 del_gendisk(old
->blkcore_priv
);
309 put_disk(old
->blkcore_priv
);
314 static void blktrans_notify_remove(struct mtd_info
*mtd
)
316 struct mtd_blktrans_ops
*tr
;
317 struct mtd_blktrans_dev
*dev
, *next
;
319 list_for_each_entry(tr
, &blktrans_majors
, list
)
320 list_for_each_entry_safe(dev
, next
, &tr
->devs
, list
)
325 static void blktrans_notify_add(struct mtd_info
*mtd
)
327 struct mtd_blktrans_ops
*tr
;
329 if (mtd
->type
== MTD_ABSENT
)
332 list_for_each_entry(tr
, &blktrans_majors
, list
)
333 tr
->add_mtd(tr
, mtd
);
336 static struct mtd_notifier blktrans_notifier
= {
337 .add
= blktrans_notify_add
,
338 .remove
= blktrans_notify_remove
,
341 int register_mtd_blktrans(struct mtd_blktrans_ops
*tr
)
345 /* Register the notifier if/when the first device type is
346 registered, to prevent the link/init ordering from fucking
348 if (!blktrans_notifier
.list
.next
)
349 register_mtd_user(&blktrans_notifier
);
351 tr
->blkcore_priv
= kzalloc(sizeof(*tr
->blkcore_priv
), GFP_KERNEL
);
352 if (!tr
->blkcore_priv
)
355 mutex_lock(&mtd_table_mutex
);
357 ret
= register_blkdev(tr
->major
, tr
->name
);
359 printk(KERN_WARNING
"Unable to register %s block device on major %d: %d\n",
360 tr
->name
, tr
->major
, ret
);
361 kfree(tr
->blkcore_priv
);
362 mutex_unlock(&mtd_table_mutex
);
365 spin_lock_init(&tr
->blkcore_priv
->queue_lock
);
367 tr
->blkcore_priv
->rq
= blk_init_queue(mtd_blktrans_request
, &tr
->blkcore_priv
->queue_lock
);
368 if (!tr
->blkcore_priv
->rq
) {
369 unregister_blkdev(tr
->major
, tr
->name
);
370 kfree(tr
->blkcore_priv
);
371 mutex_unlock(&mtd_table_mutex
);
375 tr
->blkcore_priv
->rq
->queuedata
= tr
;
376 blk_queue_hardsect_size(tr
->blkcore_priv
->rq
, tr
->blksize
);
378 blk_queue_set_discard(tr
->blkcore_priv
->rq
,
379 blktrans_discard_request
);
381 tr
->blkshift
= ffs(tr
->blksize
) - 1;
383 tr
->blkcore_priv
->thread
= kthread_run(mtd_blktrans_thread
, tr
,
385 if (IS_ERR(tr
->blkcore_priv
->thread
)) {
386 int ret
= PTR_ERR(tr
->blkcore_priv
->thread
);
387 blk_cleanup_queue(tr
->blkcore_priv
->rq
);
388 unregister_blkdev(tr
->major
, tr
->name
);
389 kfree(tr
->blkcore_priv
);
390 mutex_unlock(&mtd_table_mutex
);
394 INIT_LIST_HEAD(&tr
->devs
);
395 list_add(&tr
->list
, &blktrans_majors
);
397 for (i
=0; i
<MAX_MTD_DEVICES
; i
++) {
398 if (mtd_table
[i
] && mtd_table
[i
]->type
!= MTD_ABSENT
)
399 tr
->add_mtd(tr
, mtd_table
[i
]);
402 mutex_unlock(&mtd_table_mutex
);
407 int deregister_mtd_blktrans(struct mtd_blktrans_ops
*tr
)
409 struct mtd_blktrans_dev
*dev
, *next
;
411 mutex_lock(&mtd_table_mutex
);
413 /* Clean up the kernel thread */
414 kthread_stop(tr
->blkcore_priv
->thread
);
416 /* Remove it from the list of active majors */
419 list_for_each_entry_safe(dev
, next
, &tr
->devs
, list
)
422 blk_cleanup_queue(tr
->blkcore_priv
->rq
);
423 unregister_blkdev(tr
->major
, tr
->name
);
425 mutex_unlock(&mtd_table_mutex
);
427 kfree(tr
->blkcore_priv
);
429 BUG_ON(!list_empty(&tr
->devs
));
433 static void __exit
mtd_blktrans_exit(void)
435 /* No race here -- if someone's currently in register_mtd_blktrans
436 we're screwed anyway. */
437 if (blktrans_notifier
.list
.next
)
438 unregister_mtd_user(&blktrans_notifier
);
441 module_exit(mtd_blktrans_exit
);
443 EXPORT_SYMBOL_GPL(register_mtd_blktrans
);
444 EXPORT_SYMBOL_GPL(deregister_mtd_blktrans
);
445 EXPORT_SYMBOL_GPL(add_mtd_blktrans_dev
);
446 EXPORT_SYMBOL_GPL(del_mtd_blktrans_dev
);
448 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
449 MODULE_LICENSE("GPL");
450 MODULE_DESCRIPTION("Common interface to block layer for MTD 'translation layers'");