[linux-2.6-block.git] / drivers / mtd / mtd_blkdevs.c

/*
 * (C) 2003 David Woodhouse <dwmw2@infradead.org>
 *
 * Interface to Linux 2.5 block layer for MTD 'translation layers'.
 *
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/list.h>
#include <linux/fs.h>
#include <linux/mtd/blktrans.h>
#include <linux/mtd/mtd.h>
#include <linux/blkdev.h>
#include <linux/blkpg.h>
#include <linux/freezer.h>
#include <linux/spinlock.h>
#include <linux/hdreg.h>
#include <linux/init.h>
#include <linux/mutex.h>
#include <linux/kthread.h>
#include <asm/uaccess.h>

#include "mtdcore.h"

static LIST_HEAD(blktrans_majors);

struct mtd_blkcore_priv {
	struct task_struct *thread;
	struct request_queue *rq;
	spinlock_t queue_lock;
};

static int do_blktrans_request(struct mtd_blktrans_ops *tr,
			       struct mtd_blktrans_dev *dev,
			       struct request *req)
{
	unsigned long block, nsect;
	char *buf;

	block = req->sector << 9 >> tr->blkshift;
	nsect = req->current_nr_sectors << 9 >> tr->blkshift;

	buf = req->buffer;

	if (!blk_fs_request(req))
		return 0;

	if (req->sector + req->current_nr_sectors > get_capacity(req->rq_disk))
		return 0;

	switch(rq_data_dir(req)) {
	case READ:
		for (; nsect > 0; nsect--, block++, buf += tr->blksize)
			if (tr->readsect(dev, block, buf))
				return 0;
		return 1;

	case WRITE:
		if (!tr->writesect)
			return 0;

		for (; nsect > 0; nsect--, block++, buf += tr->blksize)
			if (tr->writesect(dev, block, buf))
				return 0;
		return 1;

	default:
		printk(KERN_NOTICE "Unknown request %u\n", rq_data_dir(req));
		return 0;
	}
}

static int mtd_blktrans_thread(void *arg)
{
	struct mtd_blktrans_ops *tr = arg;
	struct request_queue *rq = tr->blkcore_priv->rq;

	/* we might get involved when memory gets low, so use PF_MEMALLOC */
	current->flags |= PF_MEMALLOC;

	spin_lock_irq(rq->queue_lock);
	while (!kthread_should_stop()) {
		struct request *req;
		struct mtd_blktrans_dev *dev;
		int res = 0;

		req = elv_next_request(rq);

		if (!req) {
			set_current_state(TASK_INTERRUPTIBLE);
			spin_unlock_irq(rq->queue_lock);
			schedule();
			spin_lock_irq(rq->queue_lock);
			continue;
		}

		dev = req->rq_disk->private_data;
		tr = dev->tr;

		spin_unlock_irq(rq->queue_lock);

		mutex_lock(&dev->lock);
		res = do_blktrans_request(tr, dev, req);
		mutex_unlock(&dev->lock);

		spin_lock_irq(rq->queue_lock);

		end_request(req, res);
	}
	spin_unlock_irq(rq->queue_lock);

	return 0;
}

static void mtd_blktrans_request(struct request_queue *rq)
{
	struct mtd_blktrans_ops *tr = rq->queuedata;
	wake_up_process(tr->blkcore_priv->thread);
}


static int blktrans_open(struct inode *i, struct file *f)
{
	struct mtd_blktrans_dev *dev;
	struct mtd_blktrans_ops *tr;
	int ret = -ENODEV;

	dev = i->i_bdev->bd_disk->private_data;
	tr = dev->tr;

	if (!try_module_get(dev->mtd->owner))
		goto out;

	if (!try_module_get(tr->owner))
		goto out_tr;

	/* FIXME: Locking. A hot pluggable device can go away
	   (del_mtd_device can be called for it) without its module
	   being unloaded. */
	dev->mtd->usecount++;

	ret = 0;
	if (tr->open && (ret = tr->open(dev))) {
		dev->mtd->usecount--;
		module_put(dev->mtd->owner);
	out_tr:
		module_put(tr->owner);
	}
 out:
	return ret;
}

static int blktrans_release(struct inode *i, struct file *f)
{
	struct mtd_blktrans_dev *dev;
	struct mtd_blktrans_ops *tr;
	int ret = 0;

	dev = i->i_bdev->bd_disk->private_data;
	tr = dev->tr;

	if (tr->release)
		ret = tr->release(dev);

	if (!ret) {
		dev->mtd->usecount--;
		module_put(dev->mtd->owner);
		module_put(tr->owner);
	}

	return ret;
}

static int blktrans_getgeo(struct block_device *bdev, struct hd_geometry *geo)
{
	struct mtd_blktrans_dev *dev = bdev->bd_disk->private_data;

	if (dev->tr->getgeo)
		return dev->tr->getgeo(dev, geo);
	return -ENOTTY;
}

static int blktrans_ioctl(struct inode *inode, struct file *file,
			      unsigned int cmd, unsigned long arg)
{
	struct mtd_blktrans_dev *dev = inode->i_bdev->bd_disk->private_data;
	struct mtd_blktrans_ops *tr = dev->tr;

	switch (cmd) {
	case BLKFLSBUF:
		if (tr->flush)
			return tr->flush(dev);
		/* The core code did the work, we had nothing to do. */
		return 0;
	default:
		return -ENOTTY;
	}
}

static struct block_device_operations mtd_blktrans_ops = {
	.owner		= THIS_MODULE,
	.open		= blktrans_open,
	.release	= blktrans_release,
	.ioctl		= blktrans_ioctl,
	.getgeo		= blktrans_getgeo,
};

int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
{
	struct mtd_blktrans_ops *tr = new->tr;
	struct list_head *this;
	int last_devnum = -1;
	struct gendisk *gd;

	if (mutex_trylock(&mtd_table_mutex)) {
		mutex_unlock(&mtd_table_mutex);
		BUG();
	}

	list_for_each(this, &tr->devs) {
		struct mtd_blktrans_dev *d = list_entry(this, struct mtd_blktrans_dev, list);
		if (new->devnum == -1) {
			/* Use first free number */
			if (d->devnum != last_devnum+1) {
				/* Found a free devnum. Plug it in here */
				new->devnum = last_devnum+1;
				list_add_tail(&new->list, &d->list);
				goto added;
			}
		} else if (d->devnum == new->devnum) {
			/* Required number taken */
			return -EBUSY;
		} else if (d->devnum > new->devnum) {
			/* Required number was free */
			list_add_tail(&new->list, &d->list);
			goto added;
		}
		last_devnum = d->devnum;
	}
	if (new->devnum == -1)
		new->devnum = last_devnum+1;

	if ((new->devnum << tr->part_bits) > 256) {
		return -EBUSY;
	}

	list_add_tail(&new->list, &tr->devs);
 added:
	mutex_init(&new->lock);
	if (!tr->writesect)
		new->readonly = 1;

	gd = alloc_disk(1 << tr->part_bits);
	if (!gd) {
		list_del(&new->list);
		return -ENOMEM;
	}
	gd->major = tr->major;
	gd->first_minor = (new->devnum) << tr->part_bits;
	gd->fops = &mtd_blktrans_ops;

	if (tr->part_bits)
		if (new->devnum < 26)
			snprintf(gd->disk_name, sizeof(gd->disk_name),
				 "%s%c", tr->name, 'a' + new->devnum);
		else
			snprintf(gd->disk_name, sizeof(gd->disk_name),
				 "%s%c%c", tr->name,
				 'a' - 1 + new->devnum / 26,
				 'a' + new->devnum % 26);
	else
		snprintf(gd->disk_name, sizeof(gd->disk_name),
			 "%s%d", tr->name, new->devnum);

	/* 2.5 has capacity in units of 512 bytes while still
	   having BLOCK_SIZE_BITS set to 10. Just to keep us amused. */
	set_capacity(gd, (new->size * tr->blksize) >> 9);

	gd->private_data = new;
	new->blkcore_priv = gd;
	gd->queue = tr->blkcore_priv->rq;

	if (new->readonly)
		set_disk_ro(gd, 1);

	add_disk(gd);

	return 0;
}

int del_mtd_blktrans_dev(struct mtd_blktrans_dev *old)
{
	if (mutex_trylock(&mtd_table_mutex)) {
		mutex_unlock(&mtd_table_mutex);
		BUG();
	}

	list_del(&old->list);

	del_gendisk(old->blkcore_priv);
	put_disk(old->blkcore_priv);

	return 0;
}

static void blktrans_notify_remove(struct mtd_info *mtd)
{
	struct list_head *this, *this2, *next;

	list_for_each(this, &blktrans_majors) {
		struct mtd_blktrans_ops *tr = list_entry(this, struct mtd_blktrans_ops, list);

		list_for_each_safe(this2, next, &tr->devs) {
			struct mtd_blktrans_dev *dev = list_entry(this2, struct mtd_blktrans_dev, list);

			if (dev->mtd == mtd)
				tr->remove_dev(dev);
		}
	}
}

static void blktrans_notify_add(struct mtd_info *mtd)
{
	struct list_head *this;

	if (mtd->type == MTD_ABSENT)
		return;

	list_for_each(this, &blktrans_majors) {
		struct mtd_blktrans_ops *tr = list_entry(this, struct mtd_blktrans_ops, list);

		tr->add_mtd(tr, mtd);
	}

}

static struct mtd_notifier blktrans_notifier = {
	.add = blktrans_notify_add,
	.remove = blktrans_notify_remove,
};

int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
{
	int ret, i;

	/* Register the notifier if/when the first device type is
	   registered, to prevent the link/init ordering from fucking
	   us over. */
	if (!blktrans_notifier.list.next)
		register_mtd_user(&blktrans_notifier);

	tr->blkcore_priv = kzalloc(sizeof(*tr->blkcore_priv), GFP_KERNEL);
	if (!tr->blkcore_priv)
		return -ENOMEM;

	mutex_lock(&mtd_table_mutex);

	ret = register_blkdev(tr->major, tr->name);
	if (ret) {
		printk(KERN_WARNING "Unable to register %s block device on major %d: %d\n",
		       tr->name, tr->major, ret);
		kfree(tr->blkcore_priv);
		mutex_unlock(&mtd_table_mutex);
		return ret;
	}
	spin_lock_init(&tr->blkcore_priv->queue_lock);

	tr->blkcore_priv->rq = blk_init_queue(mtd_blktrans_request, &tr->blkcore_priv->queue_lock);
	if (!tr->blkcore_priv->rq) {
		unregister_blkdev(tr->major, tr->name);
		kfree(tr->blkcore_priv);
		mutex_unlock(&mtd_table_mutex);
		return -ENOMEM;
	}

	tr->blkcore_priv->rq->queuedata = tr;
	blk_queue_hardsect_size(tr->blkcore_priv->rq, tr->blksize);
	tr->blkshift = ffs(tr->blksize) - 1;

	tr->blkcore_priv->thread = kthread_run(mtd_blktrans_thread, tr,
			"%sd", tr->name);
	if (IS_ERR(tr->blkcore_priv->thread)) {
		blk_cleanup_queue(tr->blkcore_priv->rq);
		unregister_blkdev(tr->major, tr->name);
		kfree(tr->blkcore_priv);
		mutex_unlock(&mtd_table_mutex);
		return PTR_ERR(tr->blkcore_priv->thread);
	}

	INIT_LIST_HEAD(&tr->devs);
	list_add(&tr->list, &blktrans_majors);

	for (i=0; i<MAX_MTD_DEVICES; i++) {
		if (mtd_table[i] && mtd_table[i]->type != MTD_ABSENT)
			tr->add_mtd(tr, mtd_table[i]);
	}

	mutex_unlock(&mtd_table_mutex);

	return 0;
}

int deregister_mtd_blktrans(struct mtd_blktrans_ops *tr)
{
	struct list_head *this, *next;

	mutex_lock(&mtd_table_mutex);

	/* Clean up the kernel thread */
	kthread_stop(tr->blkcore_priv->thread);

	/* Remove it from the list of active majors */
	list_del(&tr->list);

	list_for_each_safe(this, next, &tr->devs) {
		struct mtd_blktrans_dev *dev = list_entry(this, struct mtd_blktrans_dev, list);
		tr->remove_dev(dev);
	}

	blk_cleanup_queue(tr->blkcore_priv->rq);
	unregister_blkdev(tr->major, tr->name);

	mutex_unlock(&mtd_table_mutex);

	kfree(tr->blkcore_priv);

	BUG_ON(!list_empty(&tr->devs));
	return 0;
}

static void __exit mtd_blktrans_exit(void)
{
	/* No race here -- if someone's currently in register_mtd_blktrans
	   we're screwed anyway. */
	if (blktrans_notifier.list.next)
		unregister_mtd_user(&blktrans_notifier);
}

module_exit(mtd_blktrans_exit);

EXPORT_SYMBOL_GPL(register_mtd_blktrans);
EXPORT_SYMBOL_GPL(deregister_mtd_blktrans);
EXPORT_SYMBOL_GPL(add_mtd_blktrans_dev);
EXPORT_SYMBOL_GPL(del_mtd_blktrans_dev);

MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Common interface to block layer for MTD 'translation layers'");
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* (C) 2003 David Woodhouse <dwmw2@infradead.org>
	3	*
	4	* Interface to Linux 2.5 block layer for MTD 'translation layers'.
	5	*
	6	*/
	7
	8	#include <linux/kernel.h>
	9	#include <linux/slab.h>
	10	#include <linux/module.h>
	11	#include <linux/list.h>
	12	#include <linux/fs.h>
	13	#include <linux/mtd/blktrans.h>
	14	#include <linux/mtd/mtd.h>
	15	#include <linux/blkdev.h>
	16	#include <linux/blkpg.h>
83144186	17	#include <linux/freezer.h>
1da177e4 LT	18	#include <linux/spinlock.h>
	19	#include <linux/hdreg.h>
	20	#include <linux/init.h>
48b19268	21	#include <linux/mutex.h>
99f9b243	22	#include <linux/kthread.h>
1da177e4	23	#include <asm/uaccess.h>
1da177e4	24
356d70f1	25	#include "mtdcore.h"
1da177e4	26
356d70f1	27	static LIST_HEAD(blktrans_majors);
1da177e4 LT	28
1da177e4 LT	29	struct mtd_blkcore_priv {
3e67fe45	30	struct task_struct *thread;
1da177e4 LT	31	struct request_queue *rq;
	32	spinlock_t queue_lock;
	33	};
	34
	35	static int do_blktrans_request(struct mtd_blktrans_ops *tr,
	36	struct mtd_blktrans_dev *dev,
	37	struct request *req)
	38	{
	39	unsigned long block, nsect;
	40	char *buf;
	41
19187672 RP	42	block = req->sector << 9 >> tr->blkshift;
	43	nsect = req->current_nr_sectors << 9 >> tr->blkshift;
	44
1da177e4 LT	45	buf = req->buffer;
1da177e4 LT	46
4aff5e23	47	if (!blk_fs_request(req))
1da177e4 LT	48	return 0;
1da177e4 LT	49
19187672	50	if (req->sector + req->current_nr_sectors > get_capacity(req->rq_disk))
1da177e4 LT	51	return 0;
	52
	53	switch(rq_data_dir(req)) {
	54	case READ:
19187672	55	for (; nsect > 0; nsect--, block++, buf += tr->blksize)
1da177e4 LT	56	if (tr->readsect(dev, block, buf))
	57	return 0;
	58	return 1;
	59
	60	case WRITE:
	61	if (!tr->writesect)
	62	return 0;
	63
19187672	64	for (; nsect > 0; nsect--, block++, buf += tr->blksize)
1da177e4 LT	65	if (tr->writesect(dev, block, buf))
	66	return 0;
	67	return 1;
	68
	69	default:
9a292308	70	printk(KERN_NOTICE "Unknown request %u\n", rq_data_dir(req));
1da177e4 LT	71	return 0;
	72	}
	73	}
	74
	75	static int mtd_blktrans_thread(void *arg)
	76	{
	77	struct mtd_blktrans_ops *tr = arg;
	78	struct request_queue *rq = tr->blkcore_priv->rq;
	79
	80	/* we might get involved when memory gets low, so use PF_MEMALLOC */
83144186	81	current->flags \|= PF_MEMALLOC;
1da177e4	82
1da177e4	83	spin_lock_irq(rq->queue_lock);
3e67fe45	84	while (!kthread_should_stop()) {
1da177e4 LT	85	struct request *req;
	86	struct mtd_blktrans_dev *dev;
	87	int res = 0;
1da177e4 LT	88
	89	req = elv_next_request(rq);
	90
	91	if (!req) {
1da177e4	92	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	93	spin_unlock_irq(rq->queue_lock);
1da177e4	94	schedule();
1da177e4	95	spin_lock_irq(rq->queue_lock);
1da177e4 LT	96	continue;
	97	}
	98
	99	dev = req->rq_disk->private_data;
	100	tr = dev->tr;
	101
	102	spin_unlock_irq(rq->queue_lock);
	103
48b19268	104	mutex_lock(&dev->lock);
1da177e4	105	res = do_blktrans_request(tr, dev, req);
48b19268	106	mutex_unlock(&dev->lock);
1da177e4 LT	107
	108	spin_lock_irq(rq->queue_lock);
	109
	110	end_request(req, res);
	111	}
	112	spin_unlock_irq(rq->queue_lock);
	113
3e67fe45	114	return 0;
1da177e4 LT	115	}
	116
	117	static void mtd_blktrans_request(struct request_queue *rq)
	118	{
	119	struct mtd_blktrans_ops *tr = rq->queuedata;
3e67fe45	120	wake_up_process(tr->blkcore_priv->thread);
1da177e4 LT	121	}
	122
	123
	124	static int blktrans_open(struct inode i, struct file f)
	125	{
	126	struct mtd_blktrans_dev *dev;
	127	struct mtd_blktrans_ops *tr;
	128	int ret = -ENODEV;
	129
	130	dev = i->i_bdev->bd_disk->private_data;
	131	tr = dev->tr;
	132
	133	if (!try_module_get(dev->mtd->owner))
	134	goto out;
	135
	136	if (!try_module_get(tr->owner))
	137	goto out_tr;
	138
97894cda	139	/* FIXME: Locking. A hot pluggable device can go away
1da177e4 LT	140	(del_mtd_device can be called for it) without its module
	141	being unloaded. */
	142	dev->mtd->usecount++;
	143
	144	ret = 0;
	145	if (tr->open && (ret = tr->open(dev))) {
	146	dev->mtd->usecount--;
	147	module_put(dev->mtd->owner);
	148	out_tr:
	149	module_put(tr->owner);
	150	}
	151	out:
	152	return ret;
	153	}
	154
	155	static int blktrans_release(struct inode i, struct file f)
	156	{
	157	struct mtd_blktrans_dev *dev;
	158	struct mtd_blktrans_ops *tr;
	159	int ret = 0;
	160
	161	dev = i->i_bdev->bd_disk->private_data;
	162	tr = dev->tr;
	163
	164	if (tr->release)
	165	ret = tr->release(dev);
	166
	167	if (!ret) {
	168	dev->mtd->usecount--;
	169	module_put(dev->mtd->owner);
	170	module_put(tr->owner);
	171	}
	172
	173	return ret;
	174	}
	175
a885c8c4 CH	176	static int blktrans_getgeo(struct block_device bdev, struct hd_geometry geo)
	177	{
	178	struct mtd_blktrans_dev *dev = bdev->bd_disk->private_data;
	179
	180	if (dev->tr->getgeo)
	181	return dev->tr->getgeo(dev, geo);
	182	return -ENOTTY;
	183	}
1da177e4	184
97894cda	185	static int blktrans_ioctl(struct inode inode, struct file file,
1da177e4 LT	186	unsigned int cmd, unsigned long arg)
	187	{
	188	struct mtd_blktrans_dev *dev = inode->i_bdev->bd_disk->private_data;
	189	struct mtd_blktrans_ops *tr = dev->tr;
	190
	191	switch (cmd) {
	192	case BLKFLSBUF:
	193	if (tr->flush)
	194	return tr->flush(dev);
	195	/* The core code did the work, we had nothing to do. */
	196	return 0;
1da177e4 LT	197	default:
	198	return -ENOTTY;
	199	}
	200	}
	201
8f026f75	202	static struct block_device_operations mtd_blktrans_ops = {
1da177e4 LT	203	.owner = THIS_MODULE,
	204	.open = blktrans_open,
	205	.release = blktrans_release,
	206	.ioctl = blktrans_ioctl,
a885c8c4	207	.getgeo = blktrans_getgeo,
1da177e4 LT	208	};
	209
	210	int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
	211	{
	212	struct mtd_blktrans_ops *tr = new->tr;
	213	struct list_head *this;
	214	int last_devnum = -1;
	215	struct gendisk *gd;
	216
b3561ea9	217	if (mutex_trylock(&mtd_table_mutex)) {
48b19268	218	mutex_unlock(&mtd_table_mutex);
1da177e4 LT	219	BUG();
	220	}
	221
	222	list_for_each(this, &tr->devs) {
	223	struct mtd_blktrans_dev *d = list_entry(this, struct mtd_blktrans_dev, list);
	224	if (new->devnum == -1) {
	225	/* Use first free number */
	226	if (d->devnum != last_devnum+1) {
	227	/* Found a free devnum. Plug it in here */
	228	new->devnum = last_devnum+1;
	229	list_add_tail(&new->list, &d->list);
	230	goto added;
	231	}
	232	} else if (d->devnum == new->devnum) {
	233	/* Required number taken */
	234	return -EBUSY;
	235	} else if (d->devnum > new->devnum) {
	236	/* Required number was free */
	237	list_add_tail(&new->list, &d->list);
	238	goto added;
97894cda	239	}
1da177e4 LT	240	last_devnum = d->devnum;
	241	}
	242	if (new->devnum == -1)
	243	new->devnum = last_devnum+1;
	244
	245	if ((new->devnum << tr->part_bits) > 256) {
	246	return -EBUSY;
	247	}
	248
1da177e4 LT	249	list_add_tail(&new->list, &tr->devs);
1da177e4 LT	250	added:
ce37ab42	251	mutex_init(&new->lock);
1da177e4 LT	252	if (!tr->writesect)
	253	new->readonly = 1;
	254
	255	gd = alloc_disk(1 << tr->part_bits);
	256	if (!gd) {
	257	list_del(&new->list);
	258	return -ENOMEM;
	259	}
	260	gd->major = tr->major;
	261	gd->first_minor = (new->devnum) << tr->part_bits;
	262	gd->fops = &mtd_blktrans_ops;
97894cda	263
65a8de36 TP	264	if (tr->part_bits)
	265	if (new->devnum < 26)
	266	snprintf(gd->disk_name, sizeof(gd->disk_name),
	267	"%s%c", tr->name, 'a' + new->devnum);
	268	else
	269	snprintf(gd->disk_name, sizeof(gd->disk_name),
	270	"%s%c%c", tr->name,
	271	'a' - 1 + new->devnum / 26,
	272	'a' + new->devnum % 26);
	273	else
	274	snprintf(gd->disk_name, sizeof(gd->disk_name),
	275	"%s%d", tr->name, new->devnum);
1da177e4 LT	276
	277	/* 2.5 has capacity in units of 512 bytes while still
	278	having BLOCK_SIZE_BITS set to 10. Just to keep us amused. */
19187672	279	set_capacity(gd, (new->size * tr->blksize) >> 9);
1da177e4 LT	280
	281	gd->private_data = new;
	282	new->blkcore_priv = gd;
	283	gd->queue = tr->blkcore_priv->rq;
	284
	285	if (new->readonly)
	286	set_disk_ro(gd, 1);
	287
	288	add_disk(gd);
97894cda	289
1da177e4 LT	290	return 0;
	291	}
	292
	293	int del_mtd_blktrans_dev(struct mtd_blktrans_dev *old)
	294	{
b3561ea9	295	if (mutex_trylock(&mtd_table_mutex)) {
48b19268	296	mutex_unlock(&mtd_table_mutex);
1da177e4 LT	297	BUG();
	298	}
	299
	300	list_del(&old->list);
	301
	302	del_gendisk(old->blkcore_priv);
	303	put_disk(old->blkcore_priv);
97894cda	304
1da177e4 LT	305	return 0;
	306	}
	307
	308	static void blktrans_notify_remove(struct mtd_info *mtd)
	309	{
	310	struct list_head this, this2, *next;
	311
	312	list_for_each(this, &blktrans_majors) {
	313	struct mtd_blktrans_ops *tr = list_entry(this, struct mtd_blktrans_ops, list);
	314
	315	list_for_each_safe(this2, next, &tr->devs) {
	316	struct mtd_blktrans_dev *dev = list_entry(this2, struct mtd_blktrans_dev, list);
	317
	318	if (dev->mtd == mtd)
	319	tr->remove_dev(dev);
	320	}
	321	}
	322	}
	323
	324	static void blktrans_notify_add(struct mtd_info *mtd)
	325	{
	326	struct list_head *this;
	327
	328	if (mtd->type == MTD_ABSENT)
	329	return;
	330
	331	list_for_each(this, &blktrans_majors) {
	332	struct mtd_blktrans_ops *tr = list_entry(this, struct mtd_blktrans_ops, list);
	333
	334	tr->add_mtd(tr, mtd);
	335	}
	336
	337	}
	338
	339	static struct mtd_notifier blktrans_notifier = {
	340	.add = blktrans_notify_add,
	341	.remove = blktrans_notify_remove,
	342	};
97894cda	343
1da177e4 LT	344	int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
	345	{
	346	int ret, i;
	347
97894cda	348	/* Register the notifier if/when the first device type is
1da177e4 LT	349	registered, to prevent the link/init ordering from fucking
	350	us over. */
	351	if (!blktrans_notifier.list.next)
	352	register_mtd_user(&blktrans_notifier);
	353
95b93a0c	354	tr->blkcore_priv = kzalloc(sizeof(*tr->blkcore_priv), GFP_KERNEL);
1da177e4 LT	355	if (!tr->blkcore_priv)
	356	return -ENOMEM;
	357
48b19268	358	mutex_lock(&mtd_table_mutex);
1da177e4 LT	359
	360	ret = register_blkdev(tr->major, tr->name);
	361	if (ret) {
	362	printk(KERN_WARNING "Unable to register %s block device on major %d: %d\n",
	363	tr->name, tr->major, ret);
	364	kfree(tr->blkcore_priv);
48b19268	365	mutex_unlock(&mtd_table_mutex);
1da177e4 LT	366	return ret;
	367	}
	368	spin_lock_init(&tr->blkcore_priv->queue_lock);
1da177e4 LT	369
	370	tr->blkcore_priv->rq = blk_init_queue(mtd_blktrans_request, &tr->blkcore_priv->queue_lock);
	371	if (!tr->blkcore_priv->rq) {
	372	unregister_blkdev(tr->major, tr->name);
	373	kfree(tr->blkcore_priv);
48b19268	374	mutex_unlock(&mtd_table_mutex);
1da177e4 LT	375	return -ENOMEM;
	376	}
	377
	378	tr->blkcore_priv->rq->queuedata = tr;
19187672 RP	379	blk_queue_hardsect_size(tr->blkcore_priv->rq, tr->blksize);
19187672 RP	380	tr->blkshift = ffs(tr->blksize) - 1;
1da177e4	381
3e67fe45 CH	382	tr->blkcore_priv->thread = kthread_run(mtd_blktrans_thread, tr,
	383	"%sd", tr->name);
	384	if (IS_ERR(tr->blkcore_priv->thread)) {
1da177e4 LT	385	blk_cleanup_queue(tr->blkcore_priv->rq);
	386	unregister_blkdev(tr->major, tr->name);
	387	kfree(tr->blkcore_priv);
48b19268	388	mutex_unlock(&mtd_table_mutex);
3e67fe45	389	return PTR_ERR(tr->blkcore_priv->thread);
97894cda	390	}
1da177e4	391
1da177e4 LT	392	INIT_LIST_HEAD(&tr->devs);
	393	list_add(&tr->list, &blktrans_majors);
	394
	395	for (i=0; i<MAX_MTD_DEVICES; i++) {
	396	if (mtd_table[i] && mtd_table[i]->type != MTD_ABSENT)
	397	tr->add_mtd(tr, mtd_table[i]);
	398	}
	399
48b19268	400	mutex_unlock(&mtd_table_mutex);
1da177e4 LT	401
	402	return 0;
	403	}
	404
	405	int deregister_mtd_blktrans(struct mtd_blktrans_ops *tr)
	406	{
	407	struct list_head this, next;
	408
48b19268	409	mutex_lock(&mtd_table_mutex);
1da177e4 LT	410
1da177e4 LT	411	/* Clean up the kernel thread */
3e67fe45	412	kthread_stop(tr->blkcore_priv->thread);
1da177e4 LT	413
	414	/* Remove it from the list of active majors */
	415	list_del(&tr->list);
	416
	417	list_for_each_safe(this, next, &tr->devs) {
	418	struct mtd_blktrans_dev *dev = list_entry(this, struct mtd_blktrans_dev, list);
	419	tr->remove_dev(dev);
	420	}
	421
1da177e4 LT	422	blk_cleanup_queue(tr->blkcore_priv->rq);
	423	unregister_blkdev(tr->major, tr->name);
	424
48b19268	425	mutex_unlock(&mtd_table_mutex);
1da177e4 LT	426
	427	kfree(tr->blkcore_priv);
	428
373ebfbf	429	BUG_ON(!list_empty(&tr->devs));
1da177e4 LT	430	return 0;
	431	}
	432
	433	static void __exit mtd_blktrans_exit(void)
	434	{
	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);
	439	}
	440
	441	module_exit(mtd_blktrans_exit);
	442
	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);
	447
	448	MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org>");
	449	MODULE_LICENSE("GPL");
	450	MODULE_DESCRIPTION("Common interface to block layer for MTD 'translation layers'");