[net-next-2.6.git] / drivers / mtd / devices / block2mtd.c

/*
 * $Id: block2mtd.c,v 1.30 2005/11/29 14:48:32 gleixner Exp $
 *
 * block2mtd.c - create an mtd from a block device
 *
 * Copyright (C) 2001,2002	Simon Evans <spse@secret.org.uk>
 * Copyright (C) 2004-2006	Jörn Engel <joern@wh.fh-wedel.de>
 *
 * Licence: GPL
 */
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/blkdev.h>
#include <linux/bio.h>
#include <linux/pagemap.h>
#include <linux/list.h>
#include <linux/init.h>
#include <linux/mtd/mtd.h>
#include <linux/buffer_head.h>
#include <linux/mutex.h>

#define VERSION "$Revision: 1.30 $"


#define ERROR(fmt, args...) printk(KERN_ERR "block2mtd: " fmt "\n" , ## args)
#define INFO(fmt, args...) printk(KERN_INFO "block2mtd: " fmt "\n" , ## args)


/* Info for the block device */
struct block2mtd_dev {
	struct list_head list;
	struct block_device *blkdev;
	struct mtd_info mtd;
	struct mutex write_mutex;
};


/* Static info about the MTD, used in cleanup_module */
static LIST_HEAD(blkmtd_device_list);


#define PAGE_READAHEAD 64
static void cache_readahead(struct address_space *mapping, int index)
{
	filler_t *filler = (filler_t*)mapping->a_ops->readpage;
	int i, pagei;
	unsigned ret = 0;
	unsigned long end_index;
	struct page *page;
	LIST_HEAD(page_pool);
	struct inode *inode = mapping->host;
	loff_t isize = i_size_read(inode);

	if (!isize) {
		INFO("iSize=0 in cache_readahead\n");
		return;
	}

	end_index = ((isize - 1) >> PAGE_CACHE_SHIFT);

	read_lock_irq(&mapping->tree_lock);
	for (i = 0; i < PAGE_READAHEAD; i++) {
		pagei = index + i;
		if (pagei > end_index) {
			INFO("Overrun end of disk in cache readahead\n");
			break;
		}
		page = radix_tree_lookup(&mapping->page_tree, pagei);
		if (page && (!i))
			break;
		if (page)
			continue;
		read_unlock_irq(&mapping->tree_lock);
		page = page_cache_alloc_cold(mapping);
		read_lock_irq(&mapping->tree_lock);
		if (!page)
			break;
		page->index = pagei;
		list_add(&page->lru, &page_pool);
		ret++;
	}
	read_unlock_irq(&mapping->tree_lock);
	if (ret)
		read_cache_pages(mapping, &page_pool, filler, NULL);
}


static struct page* page_readahead(struct address_space *mapping, int index)
{
	filler_t *filler = (filler_t*)mapping->a_ops->readpage;
	cache_readahead(mapping, index);
	return read_cache_page(mapping, index, filler, NULL);
}


/* erase a specified part of the device */
static int _block2mtd_erase(struct block2mtd_dev *dev, loff_t to, size_t len)
{
	struct address_space *mapping = dev->blkdev->bd_inode->i_mapping;
	struct page *page;
	int index = to >> PAGE_SHIFT;	// page index
	int pages = len >> PAGE_SHIFT;
	u_long *p;
	u_long *max;

	while (pages) {
		page = page_readahead(mapping, index);
		if (!page)
			return -ENOMEM;
		if (IS_ERR(page))
			return PTR_ERR(page);

		max = (u_long*)page_address(page) + PAGE_SIZE;
		for (p=(u_long*)page_address(page); p<max; p++)
			if (*p != -1UL) {
				lock_page(page);
				memset(page_address(page), 0xff, PAGE_SIZE);
				set_page_dirty(page);
				unlock_page(page);
				break;
			}

		page_cache_release(page);
		pages--;
		index++;
	}
	return 0;
}
static int block2mtd_erase(struct mtd_info *mtd, struct erase_info *instr)
{
	struct block2mtd_dev *dev = mtd->priv;
	size_t from = instr->addr;
	size_t len = instr->len;
	int err;

	instr->state = MTD_ERASING;
	mutex_lock(&dev->write_mutex);
	err = _block2mtd_erase(dev, from, len);
	mutex_unlock(&dev->write_mutex);
	if (err) {
		ERROR("erase failed err = %d", err);
		instr->state = MTD_ERASE_FAILED;
	} else
		instr->state = MTD_ERASE_DONE;

	instr->state = MTD_ERASE_DONE;
	mtd_erase_callback(instr);
	return err;
}


static int block2mtd_read(struct mtd_info *mtd, loff_t from, size_t len,
		size_t *retlen, u_char *buf)
{
	struct block2mtd_dev *dev = mtd->priv;
	struct page *page;
	int index = from >> PAGE_SHIFT;
	int offset = from & (PAGE_SIZE-1);
	int cpylen;

	if (from > mtd->size)
		return -EINVAL;
	if (from + len > mtd->size)
		len = mtd->size - from;

	if (retlen)
		*retlen = 0;

	while (len) {
		if ((offset + len) > PAGE_SIZE)
			cpylen = PAGE_SIZE - offset;	// multiple pages
		else
			cpylen = len;	// this page
		len = len - cpylen;

		//      Get page
		page = page_readahead(dev->blkdev->bd_inode->i_mapping, index);
		if (!page)
			return -ENOMEM;
		if (IS_ERR(page))
			return PTR_ERR(page);

		memcpy(buf, page_address(page) + offset, cpylen);
		page_cache_release(page);

		if (retlen)
			*retlen += cpylen;
		buf += cpylen;
		offset = 0;
		index++;
	}
	return 0;
}


/* write data to the underlying device */
static int _block2mtd_write(struct block2mtd_dev *dev, const u_char *buf,
		loff_t to, size_t len, size_t *retlen)
{
	struct page *page;
	struct address_space *mapping = dev->blkdev->bd_inode->i_mapping;
	int index = to >> PAGE_SHIFT;	// page index
	int offset = to & ~PAGE_MASK;	// page offset
	int cpylen;

	if (retlen)
		*retlen = 0;
	while (len) {
		if ((offset+len) > PAGE_SIZE)
			cpylen = PAGE_SIZE - offset;	// multiple pages
		else
			cpylen = len;			// this page
		len = len - cpylen;

		//	Get page
		page = page_readahead(mapping, index);
		if (!page)
			return -ENOMEM;
		if (IS_ERR(page))
			return PTR_ERR(page);

		if (memcmp(page_address(page)+offset, buf, cpylen)) {
			lock_page(page);
			memcpy(page_address(page) + offset, buf, cpylen);
			set_page_dirty(page);
			unlock_page(page);
		}
		page_cache_release(page);

		if (retlen)
			*retlen += cpylen;

		buf += cpylen;
		offset = 0;
		index++;
	}
	return 0;
}
static int block2mtd_write(struct mtd_info *mtd, loff_t to, size_t len,
		size_t *retlen, const u_char *buf)
{
	struct block2mtd_dev *dev = mtd->priv;
	int err;

	if (!len)
		return 0;
	if (to >= mtd->size)
		return -ENOSPC;
	if (to + len > mtd->size)
		len = mtd->size - to;

	mutex_lock(&dev->write_mutex);
	err = _block2mtd_write(dev, buf, to, len, retlen);
	mutex_unlock(&dev->write_mutex);
	if (err > 0)
		err = 0;
	return err;
}


/* sync the device - wait until the write queue is empty */
static void block2mtd_sync(struct mtd_info *mtd)
{
	struct block2mtd_dev *dev = mtd->priv;
	sync_blockdev(dev->blkdev);
	return;
}


static void block2mtd_free_device(struct block2mtd_dev *dev)
{
	if (!dev)
		return;

	kfree(dev->mtd.name);

	if (dev->blkdev) {
		invalidate_inode_pages(dev->blkdev->bd_inode->i_mapping);
		close_bdev_excl(dev->blkdev);
	}

	kfree(dev);
}


/* FIXME: ensure that mtd->size % erase_size == 0 */
static struct block2mtd_dev *add_device(char *devname, int erase_size)
{
	struct block_device *bdev;
	struct block2mtd_dev *dev;

	if (!devname)
		return NULL;

	dev = kmalloc(sizeof(struct block2mtd_dev), GFP_KERNEL);
	if (!dev)
		return NULL;
	memset(dev, 0, sizeof(*dev));

	/* Get a handle on the device */
	bdev = open_bdev_excl(devname, O_RDWR, NULL);
	if (IS_ERR(bdev)) {
		ERROR("error: cannot open device %s", devname);
		goto devinit_err;
	}
	dev->blkdev = bdev;

	if (MAJOR(bdev->bd_dev) == MTD_BLOCK_MAJOR) {
		ERROR("attempting to use an MTD device as a block device");
		goto devinit_err;
	}

	mutex_init(&dev->write_mutex);

	/* Setup the MTD structure */
	/* make the name contain the block device in */
	dev->mtd.name = kmalloc(sizeof("block2mtd: ") + strlen(devname),
			GFP_KERNEL);
	if (!dev->mtd.name)
		goto devinit_err;

	sprintf(dev->mtd.name, "block2mtd: %s", devname);

	dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK;
	dev->mtd.erasesize = erase_size;
	dev->mtd.writesize = 1;
	dev->mtd.type = MTD_RAM;
	dev->mtd.flags = MTD_CAP_RAM;
	dev->mtd.erase = block2mtd_erase;
	dev->mtd.write = block2mtd_write;
	dev->mtd.writev = default_mtd_writev;
	dev->mtd.sync = block2mtd_sync;
	dev->mtd.read = block2mtd_read;
	dev->mtd.priv = dev;
	dev->mtd.owner = THIS_MODULE;

	if (add_mtd_device(&dev->mtd)) {
		/* Device didnt get added, so free the entry */
		goto devinit_err;
	}
	list_add(&dev->list, &blkmtd_device_list);
	INFO("mtd%d: [%s] erase_size = %dKiB [%d]", dev->mtd.index,
			dev->mtd.name + strlen("blkmtd: "),
			dev->mtd.erasesize >> 10, dev->mtd.erasesize);
	return dev;

devinit_err:
	block2mtd_free_device(dev);
	return NULL;
}


/* This function works similar to reguler strtoul.  In addition, it
 * allows some suffixes for a more human-readable number format:
 * ki, Ki, kiB, KiB	- multiply result with 1024
 * Mi, MiB		- multiply result with 1024^2
 * Gi, GiB		- multiply result with 1024^3
 */
static int ustrtoul(const char *cp, char **endp, unsigned int base)
{
	unsigned long result = simple_strtoul(cp, endp, base);
	switch (**endp) {
	case 'G' :
		result *= 1024;
	case 'M':
		result *= 1024;
	case 'K':
	case 'k':
		result *= 1024;
	/* By dwmw2 editorial decree, "ki", "Mi" or "Gi" are to be used. */
		if ((*endp)[1] == 'i') {
			if ((*endp)[2] == 'B')
				(*endp) += 3;
			else
				(*endp) += 2;
		}
	}
	return result;
}


static int parse_num(size_t *num, const char *token)
{
	char *endp;
	size_t n;

	n = (size_t) ustrtoul(token, &endp, 0);
	if (*endp)
		return -EINVAL;

	*num = n;
	return 0;
}


static int parse_name(char **pname, const char *token, size_t limit)
{
	size_t len;
	char *name;

	len = strlen(token) + 1;
	if (len > limit)
		return -ENOSPC;

	name = kmalloc(len, GFP_KERNEL);
	if (!name)
		return -ENOMEM;

	strcpy(name, token);

	*pname = name;
	return 0;
}


static inline void kill_final_newline(char *str)
{
	char *newline = strrchr(str, '\n');
	if (newline && !newline[1])
		*newline = 0;
}


#define parse_err(fmt, args...) do {		\
	ERROR("block2mtd: " fmt "\n", ## args);	\
	return 0;				\
} while (0)

static int block2mtd_setup(const char *val, struct kernel_param *kp)
{
	char buf[80+12]; /* 80 for device, 12 for erase size */
	char *str = buf;
	char *token[2];
	char *name;
	size_t erase_size = PAGE_SIZE;
	int i, ret;

	if (strnlen(val, sizeof(buf)) >= sizeof(buf))
		parse_err("parameter too long");

	strcpy(str, val);
	kill_final_newline(str);

	for (i = 0; i < 2; i++)
		token[i] = strsep(&str, ",");

	if (str)
		parse_err("too many arguments");

	if (!token[0])
		parse_err("no argument");

	ret = parse_name(&name, token[0], 80);
	if (ret == -ENOMEM)
		parse_err("out of memory");
	if (ret == -ENOSPC)
		parse_err("name too long");
	if (ret)
		return 0;

	if (token[1]) {
		ret = parse_num(&erase_size, token[1]);
		if (ret) {
			kfree(name);
			parse_err("illegal erase size");
		}
	}

	add_device(name, erase_size);

	return 0;
}


module_param_call(block2mtd, block2mtd_setup, NULL, NULL, 0200);
MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,<erasesize>]\"");

static int __init block2mtd_init(void)
{
	INFO("version " VERSION);
	return 0;
}


static void __devexit block2mtd_exit(void)
{
	struct list_head *pos, *next;

	/* Remove the MTD devices */
	list_for_each_safe(pos, next, &blkmtd_device_list) {
		struct block2mtd_dev *dev = list_entry(pos, typeof(*dev), list);
		block2mtd_sync(&dev->mtd);
		del_mtd_device(&dev->mtd);
		INFO("mtd%d: [%s] removed", dev->mtd.index,
				dev->mtd.name + strlen("blkmtd: "));
		list_del(&dev->list);
		block2mtd_free_device(dev);
	}
}


module_init(block2mtd_init);
module_exit(block2mtd_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Simon Evans <spse@secret.org.uk> and others");
MODULE_DESCRIPTION("Emulate an MTD using a block device");
Commit	Line	Data
1da177e4	1	/*
2b9175c1	2	* $Id: block2mtd.c,v 1.30 2005/11/29 14:48:32 gleixner Exp $
1da177e4 LT	3	*
	4	* block2mtd.c - create an mtd from a block device
	5	*
	6	* Copyright (C) 2001,2002 Simon Evans <spse@secret.org.uk>
151e7659	7	* Copyright (C) 2004-2006 Jörn Engel <joern@wh.fh-wedel.de>
1da177e4 LT	8	*
	9	* Licence: GPL
	10	*/
1da177e4 LT	11	#include <linux/module.h>
	12	#include <linux/fs.h>
	13	#include <linux/blkdev.h>
	14	#include <linux/bio.h>
	15	#include <linux/pagemap.h>
	16	#include <linux/list.h>
	17	#include <linux/init.h>
	18	#include <linux/mtd/mtd.h>
	19	#include <linux/buffer_head.h>
48b19268	20	#include <linux/mutex.h>
1da177e4	21
2b9175c1	22	#define VERSION "$Revision: 1.30 $"
1da177e4 LT	23
	24
	25	#define ERROR(fmt, args...) printk(KERN_ERR "block2mtd: " fmt "\n" , ## args)
	26	#define INFO(fmt, args...) printk(KERN_INFO "block2mtd: " fmt "\n" , ## args)
	27
	28
	29	/* Info for the block device */
	30	struct block2mtd_dev {
	31	struct list_head list;
	32	struct block_device *blkdev;
	33	struct mtd_info mtd;
48b19268	34	struct mutex write_mutex;
1da177e4 LT	35	};
	36
	37
	38	/* Static info about the MTD, used in cleanup_module */
	39	static LIST_HEAD(blkmtd_device_list);
	40
	41
	42	#define PAGE_READAHEAD 64
2b9175c1	43	static void cache_readahead(struct address_space *mapping, int index)
1da177e4 LT	44	{
	45	filler_t filler = (filler_t)mapping->a_ops->readpage;
	46	int i, pagei;
	47	unsigned ret = 0;
	48	unsigned long end_index;
	49	struct page *page;
	50	LIST_HEAD(page_pool);
	51	struct inode *inode = mapping->host;
	52	loff_t isize = i_size_read(inode);
	53
	54	if (!isize) {
	55	INFO("iSize=0 in cache_readahead\n");
	56	return;
	57	}
	58
	59	end_index = ((isize - 1) >> PAGE_CACHE_SHIFT);
	60
	61	read_lock_irq(&mapping->tree_lock);
	62	for (i = 0; i < PAGE_READAHEAD; i++) {
	63	pagei = index + i;
	64	if (pagei > end_index) {
	65	INFO("Overrun end of disk in cache readahead\n");
	66	break;
	67	}
	68	page = radix_tree_lookup(&mapping->page_tree, pagei);
	69	if (page && (!i))
	70	break;
	71	if (page)
	72	continue;
	73	read_unlock_irq(&mapping->tree_lock);
	74	page = page_cache_alloc_cold(mapping);
	75	read_lock_irq(&mapping->tree_lock);
	76	if (!page)
	77	break;
	78	page->index = pagei;
	79	list_add(&page->lru, &page_pool);
	80	ret++;
	81	}
	82	read_unlock_irq(&mapping->tree_lock);
	83	if (ret)
	84	read_cache_pages(mapping, &page_pool, filler, NULL);
	85	}
	86
	87
	88	static struct page* page_readahead(struct address_space *mapping, int index)
	89	{
	90	filler_t filler = (filler_t)mapping->a_ops->readpage;
1da177e4 LT	91	cache_readahead(mapping, index);
	92	return read_cache_page(mapping, index, filler, NULL);
	93	}
	94
	95
	96	/* erase a specified part of the device */
	97	static int _block2mtd_erase(struct block2mtd_dev *dev, loff_t to, size_t len)
	98	{
	99	struct address_space *mapping = dev->blkdev->bd_inode->i_mapping;
	100	struct page *page;
	101	int index = to >> PAGE_SHIFT; // page index
	102	int pages = len >> PAGE_SHIFT;
	103	u_long *p;
	104	u_long *max;
	105
	106	while (pages) {
	107	page = page_readahead(mapping, index);
	108	if (!page)
	109	return -ENOMEM;
	110	if (IS_ERR(page))
	111	return PTR_ERR(page);
	112
	113	max = (u_long*)page_address(page) + PAGE_SIZE;
e5580fbe	114	for (p=(u_long*)page_address(page); p<max; p++)
1da177e4 LT	115	if (*p != -1UL) {
	116	lock_page(page);
	117	memset(page_address(page), 0xff, PAGE_SIZE);
	118	set_page_dirty(page);
	119	unlock_page(page);
	120	break;
	121	}
	122
	123	page_cache_release(page);
	124	pages--;
	125	index++;
	126	}
	127	return 0;
	128	}
	129	static int block2mtd_erase(struct mtd_info mtd, struct erase_info instr)
	130	{
	131	struct block2mtd_dev *dev = mtd->priv;
	132	size_t from = instr->addr;
	133	size_t len = instr->len;
	134	int err;
	135
	136	instr->state = MTD_ERASING;
48b19268	137	mutex_lock(&dev->write_mutex);
1da177e4	138	err = _block2mtd_erase(dev, from, len);
48b19268	139	mutex_unlock(&dev->write_mutex);
1da177e4 LT	140	if (err) {
	141	ERROR("erase failed err = %d", err);
	142	instr->state = MTD_ERASE_FAILED;
	143	} else
	144	instr->state = MTD_ERASE_DONE;
	145
	146	instr->state = MTD_ERASE_DONE;
	147	mtd_erase_callback(instr);
	148	return err;
	149	}
	150
	151
	152	static int block2mtd_read(struct mtd_info *mtd, loff_t from, size_t len,
	153	size_t retlen, u_char buf)
	154	{
	155	struct block2mtd_dev *dev = mtd->priv;
	156	struct page *page;
	157	int index = from >> PAGE_SHIFT;
711c11b7	158	int offset = from & (PAGE_SIZE-1);
1da177e4 LT	159	int cpylen;
	160
	161	if (from > mtd->size)
	162	return -EINVAL;
	163	if (from + len > mtd->size)
	164	len = mtd->size - from;
	165
	166	if (retlen)
	167	*retlen = 0;
	168
	169	while (len) {
	170	if ((offset + len) > PAGE_SIZE)
	171	cpylen = PAGE_SIZE - offset; // multiple pages
	172	else
	173	cpylen = len; // this page
	174	len = len - cpylen;
	175
	176	// Get page
	177	page = page_readahead(dev->blkdev->bd_inode->i_mapping, index);
	178	if (!page)
	179	return -ENOMEM;
	180	if (IS_ERR(page))
	181	return PTR_ERR(page);
	182
	183	memcpy(buf, page_address(page) + offset, cpylen);
	184	page_cache_release(page);
	185
	186	if (retlen)
	187	*retlen += cpylen;
	188	buf += cpylen;
	189	offset = 0;
	190	index++;
	191	}
	192	return 0;
	193	}
	194
	195
	196	/* write data to the underlying device */
	197	static int _block2mtd_write(struct block2mtd_dev dev, const u_char buf,
	198	loff_t to, size_t len, size_t *retlen)
	199	{
	200	struct page *page;
	201	struct address_space *mapping = dev->blkdev->bd_inode->i_mapping;
	202	int index = to >> PAGE_SHIFT; // page index
	203	int offset = to & ~PAGE_MASK; // page offset
	204	int cpylen;
	205
	206	if (retlen)
	207	*retlen = 0;
	208	while (len) {
e5580fbe	209	if ((offset+len) > PAGE_SIZE)
1da177e4 LT	210	cpylen = PAGE_SIZE - offset; // multiple pages
	211	else
	212	cpylen = len; // this page
	213	len = len - cpylen;
	214
	215	// Get page
	216	page = page_readahead(mapping, index);
	217	if (!page)
	218	return -ENOMEM;
	219	if (IS_ERR(page))
	220	return PTR_ERR(page);
	221
	222	if (memcmp(page_address(page)+offset, buf, cpylen)) {
	223	lock_page(page);
	224	memcpy(page_address(page) + offset, buf, cpylen);
	225	set_page_dirty(page);
	226	unlock_page(page);
	227	}
	228	page_cache_release(page);
	229
	230	if (retlen)
	231	*retlen += cpylen;
	232
	233	buf += cpylen;
	234	offset = 0;
	235	index++;
	236	}
	237	return 0;
	238	}
	239	static int block2mtd_write(struct mtd_info *mtd, loff_t to, size_t len,
	240	size_t retlen, const u_char buf)
	241	{
	242	struct block2mtd_dev *dev = mtd->priv;
	243	int err;
	244
	245	if (!len)
	246	return 0;
	247	if (to >= mtd->size)
	248	return -ENOSPC;
	249	if (to + len > mtd->size)
	250	len = mtd->size - to;
	251
48b19268	252	mutex_lock(&dev->write_mutex);
1da177e4	253	err = _block2mtd_write(dev, buf, to, len, retlen);
48b19268	254	mutex_unlock(&dev->write_mutex);
1da177e4 LT	255	if (err > 0)
	256	err = 0;
	257	return err;
	258	}
	259
	260
	261	/* sync the device - wait until the write queue is empty */
	262	static void block2mtd_sync(struct mtd_info *mtd)
	263	{
	264	struct block2mtd_dev *dev = mtd->priv;
	265	sync_blockdev(dev->blkdev);
	266	return;
	267	}
	268
	269
	270	static void block2mtd_free_device(struct block2mtd_dev *dev)
	271	{
	272	if (!dev)
	273	return;
	274
	275	kfree(dev->mtd.name);
	276
	277	if (dev->blkdev) {
	278	invalidate_inode_pages(dev->blkdev->bd_inode->i_mapping);
	279	close_bdev_excl(dev->blkdev);
	280	}
	281
	282	kfree(dev);
	283	}
	284
	285
	286	/* FIXME: ensure that mtd->size % erase_size == 0 */
	287	static struct block2mtd_dev add_device(char devname, int erase_size)
	288	{
	289	struct block_device *bdev;
	290	struct block2mtd_dev *dev;
	291
	292	if (!devname)
	293	return NULL;
	294
	295	dev = kmalloc(sizeof(struct block2mtd_dev), GFP_KERNEL);
	296	if (!dev)
	297	return NULL;
	298	memset(dev, 0, sizeof(*dev));
	299
	300	/* Get a handle on the device */
	301	bdev = open_bdev_excl(devname, O_RDWR, NULL);
	302	if (IS_ERR(bdev)) {
	303	ERROR("error: cannot open device %s", devname);
	304	goto devinit_err;
	305	}
	306	dev->blkdev = bdev;
	307
	308	if (MAJOR(bdev->bd_dev) == MTD_BLOCK_MAJOR) {
	309	ERROR("attempting to use an MTD device as a block device");
	310	goto devinit_err;
	311	}
	312
48b19268	313	mutex_init(&dev->write_mutex);
1da177e4 LT	314
	315	/* Setup the MTD structure */
	316	/* make the name contain the block device in */
	317	dev->mtd.name = kmalloc(sizeof("block2mtd: ") + strlen(devname),
	318	GFP_KERNEL);
	319	if (!dev->mtd.name)
	320	goto devinit_err;
	321
	322	sprintf(dev->mtd.name, "block2mtd: %s", devname);
	323
	324	dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK;
	325	dev->mtd.erasesize = erase_size;
17ffc7ba	326	dev->mtd.writesize = 1;
21c8db9e	327	dev->mtd.type = MTD_RAM;
1da177e4 LT	328	dev->mtd.flags = MTD_CAP_RAM;
	329	dev->mtd.erase = block2mtd_erase;
	330	dev->mtd.write = block2mtd_write;
	331	dev->mtd.writev = default_mtd_writev;
	332	dev->mtd.sync = block2mtd_sync;
	333	dev->mtd.read = block2mtd_read;
1da177e4 LT	334	dev->mtd.priv = dev;
	335	dev->mtd.owner = THIS_MODULE;
	336
	337	if (add_mtd_device(&dev->mtd)) {
	338	/* Device didnt get added, so free the entry */
	339	goto devinit_err;
	340	}
	341	list_add(&dev->list, &blkmtd_device_list);
	342	INFO("mtd%d: [%s] erase_size = %dKiB [%d]", dev->mtd.index,
	343	dev->mtd.name + strlen("blkmtd: "),
	344	dev->mtd.erasesize >> 10, dev->mtd.erasesize);
	345	return dev;
	346
	347	devinit_err:
	348	block2mtd_free_device(dev);
	349	return NULL;
	350	}
	351
	352
954c2422 JE	353	/* This function works similar to reguler strtoul. In addition, it
	354	* allows some suffixes for a more human-readable number format:
	355	* ki, Ki, kiB, KiB - multiply result with 1024
	356	* Mi, MiB - multiply result with 1024^2
	357	* Gi, GiB - multiply result with 1024^3
	358	*/
1da177e4 LT	359	static int ustrtoul(const char cp, char *endp, unsigned int base)
	360	{
	361	unsigned long result = simple_strtoul(cp, endp, base);
	362	switch (**endp) {
	363	case 'G' :
	364	result *= 1024;
	365	case 'M':
	366	result *= 1024;
954c2422	367	case 'K':
1da177e4 LT	368	case 'k':
	369	result *= 1024;
	370	/* By dwmw2 editorial decree, "ki", "Mi" or "Gi" are to be used. */
954c2422 JE	371	if ((*endp)[1] == 'i') {
	372	if ((*endp)[2] == 'B')
	373	(*endp) += 3;
	374	else
	375	(*endp) += 2;
	376	}
1da177e4 LT	377	}
	378	return result;
	379	}
	380
	381
cc71229f	382	static int parse_num(size_t num, const char token)
1da177e4 LT	383	{
1da177e4 LT	384	char *endp;
cc71229f	385	size_t n;
1da177e4	386
cc71229f	387	n = (size_t) ustrtoul(token, &endp, 0);
1da177e4 LT	388	if (*endp)
	389	return -EINVAL;
	390
cc71229f	391	*num = n;
1da177e4 LT	392	return 0;
	393	}
	394
	395
	396	static int parse_name(char *pname, const char token, size_t limit)
	397	{
	398	size_t len;
	399	char *name;
	400
	401	len = strlen(token) + 1;
	402	if (len > limit)
	403	return -ENOSPC;
	404
	405	name = kmalloc(len, GFP_KERNEL);
	406	if (!name)
	407	return -ENOMEM;
	408
	409	strcpy(name, token);
	410
	411	*pname = name;
	412	return 0;
	413	}
	414
	415
	416	static inline void kill_final_newline(char *str)
	417	{
	418	char *newline = strrchr(str, '\n');
	419	if (newline && !newline[1])
	420	*newline = 0;
	421	}
	422
	423
	424	#define parse_err(fmt, args...) do { \
	425	ERROR("block2mtd: " fmt "\n", ## args); \
	426	return 0; \
	427	} while (0)
	428
	429	static int block2mtd_setup(const char val, struct kernel_param kp)
	430	{
a6550e57 JJ	431	char buf[80+12]; /* 80 for device, 12 for erase size */
a6550e57 JJ	432	char *str = buf;
1da177e4 LT	433	char *token[2];
1da177e4 LT	434	char *name;
cc71229f	435	size_t erase_size = PAGE_SIZE;
1da177e4 LT	436	int i, ret;
	437
	438	if (strnlen(val, sizeof(buf)) >= sizeof(buf))
	439	parse_err("parameter too long");
	440
	441	strcpy(str, val);
	442	kill_final_newline(str);
	443
a6550e57	444	for (i = 0; i < 2; i++)
1da177e4 LT	445	token[i] = strsep(&str, ",");
	446
	447	if (str)
	448	parse_err("too many arguments");
	449
	450	if (!token[0])
	451	parse_err("no argument");
	452
	453	ret = parse_name(&name, token[0], 80);
	454	if (ret == -ENOMEM)
	455	parse_err("out of memory");
	456	if (ret == -ENOSPC)
	457	parse_err("name too long");
	458	if (ret)
	459	return 0;
	460
	461	if (token[1]) {
cc71229f	462	ret = parse_num(&erase_size, token[1]);
a6550e57 JJ	463	if (ret) {
a6550e57 JJ	464	kfree(name);
1da177e4	465	parse_err("illegal erase size");
a6550e57	466	}
1da177e4 LT	467	}
	468
	469	add_device(name, erase_size);
	470
	471	return 0;
	472	}
	473
	474
	475	module_param_call(block2mtd, block2mtd_setup, NULL, NULL, 0200);
	476	MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,<erasesize>]\"");
	477
	478	static int __init block2mtd_init(void)
	479	{
	480	INFO("version " VERSION);
	481	return 0;
	482	}
	483
	484
	485	static void __devexit block2mtd_exit(void)
	486	{
	487	struct list_head pos, next;
	488
	489	/* Remove the MTD devices */
	490	list_for_each_safe(pos, next, &blkmtd_device_list) {
	491	struct block2mtd_dev dev = list_entry(pos, typeof(dev), list);
	492	block2mtd_sync(&dev->mtd);
	493	del_mtd_device(&dev->mtd);
	494	INFO("mtd%d: [%s] removed", dev->mtd.index,
	495	dev->mtd.name + strlen("blkmtd: "));
	496	list_del(&dev->list);
	497	block2mtd_free_device(dev);
	498	}
	499	}
	500
	501
	502	module_init(block2mtd_init);
	503	module_exit(block2mtd_exit);
	504
	505	MODULE_LICENSE("GPL");
	506	MODULE_AUTHOR("Simon Evans <spse@secret.org.uk> and others");
	507	MODULE_DESCRIPTION("Emulate an MTD using a block device");