[mirror_ubuntu-artful-kernel.git] / drivers / mtd / devices / block2mtd.c

/*
 * block2mtd.c - create an mtd from a block device
 *
 * Copyright (C) 2001,2002	Simon Evans <spse@secret.org.uk>
 * Copyright (C) 2004-2006	Joern Engel <joern@wh.fh-wedel.de>
 *
 * Licence: GPL
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#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/mutex.h>
#include <linux/mount.h>
#include <linux/slab.h>
#include <linux/major.h>

/* 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);


static struct page *page_read(struct address_space *mapping, int index)
{
	return read_mapping_page(mapping, index, 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_read(mapping, index);
		if (IS_ERR(page))
			return PTR_ERR(page);

		max = page_address(page) + PAGE_SIZE;
		for (p=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);
				balance_dirty_pages_ratelimited(mapping);
				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) {
		pr_err("erase failed err = %d\n", err);
		instr->state = MTD_ERASE_FAILED;
	} else
		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;

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

		page = page_read(dev->blkdev->bd_inode->i_mapping, index);
		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;

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

		page = page_read(mapping, index);
		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);
			balance_dirty_pages_ratelimited(mapping);
		}
		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;

	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_mapping_pages(dev->blkdev->bd_inode->i_mapping,
					0, -1);
		blkdev_put(dev->blkdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
	}

	kfree(dev);
}


static struct block2mtd_dev *add_device(char *devname, int erase_size)
{
	const fmode_t mode = FMODE_READ | FMODE_WRITE | FMODE_EXCL;
	struct block_device *bdev;
	struct block2mtd_dev *dev;
	char *name;

	if (!devname)
		return NULL;

	dev = kzalloc(sizeof(struct block2mtd_dev), GFP_KERNEL);
	if (!dev)
		return NULL;

	/* Get a handle on the device */
	bdev = blkdev_get_by_path(devname, mode, dev);
#ifndef MODULE
	if (IS_ERR(bdev)) {

		/* We might not have rootfs mounted at this point. Try
		   to resolve the device name by other means. */

		dev_t devt = name_to_dev_t(devname);
		if (devt)
			bdev = blkdev_get_by_dev(devt, mode, dev);
	}
#endif

	if (IS_ERR(bdev)) {
		pr_err("error: cannot open device %s\n", devname);
		goto err_free_block2mtd;
	}
	dev->blkdev = bdev;

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

	if ((long)dev->blkdev->bd_inode->i_size % erase_size) {
		pr_err("erasesize must be a divisor of device size\n");
		goto err_free_block2mtd;
	}

	mutex_init(&dev->write_mutex);

	/* Setup the MTD structure */
	/* make the name contain the block device in */
	name = kasprintf(GFP_KERNEL, "block2mtd: %s", devname);
	if (!name)
		goto err_destroy_mutex;

	dev->mtd.name = name;

	dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK;
	dev->mtd.erasesize = erase_size;
	dev->mtd.writesize = 1;
	dev->mtd.writebufsize = PAGE_SIZE;
	dev->mtd.type = MTD_RAM;
	dev->mtd.flags = MTD_CAP_RAM;
	dev->mtd._erase = block2mtd_erase;
	dev->mtd._write = block2mtd_write;
	dev->mtd._sync = block2mtd_sync;
	dev->mtd._read = block2mtd_read;
	dev->mtd.priv = dev;
	dev->mtd.owner = THIS_MODULE;

	if (mtd_device_register(&dev->mtd, NULL, 0)) {
		/* Device didn't get added, so free the entry */
		goto err_destroy_mutex;
	}
	list_add(&dev->list, &blkmtd_device_list);
	pr_info("mtd%d: [%s] erase_size = %dKiB [%d]\n",
		dev->mtd.index,
		dev->mtd.name + strlen("block2mtd: "),
		dev->mtd.erasesize >> 10, dev->mtd.erasesize);
	return dev;

err_destroy_mutex:
	mutex_destroy(&dev->write_mutex);
err_free_block2mtd:
	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 inline void kill_final_newline(char *str)
{
	char *newline = strrchr(str, '\n');
	if (newline && !newline[1])
		*newline = 0;
}


#ifndef MODULE
static int block2mtd_init_called = 0;
static char block2mtd_paramline[80 + 12]; /* 80 for device, 12 for erase size */
#endif

static int block2mtd_setup2(const char *val)
{
	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)) {
		pr_err("parameter too long\n");
		return 0;
	}

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

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

	if (str) {
		pr_err("too many arguments\n");
		return 0;
	}

	if (!token[0]) {
		pr_err("no argument\n");
		return 0;
	}

	name = token[0];
	if (strlen(name) + 1 > 80) {
		pr_err("device name too long\n");
		return 0;
	}

	if (token[1]) {
		ret = parse_num(&erase_size, token[1]);
		if (ret) {
			pr_err("illegal erase size\n");
			return 0;
		}
	}

	add_device(name, erase_size);

	return 0;
}


static int block2mtd_setup(const char *val, struct kernel_param *kp)
{
#ifdef MODULE
	return block2mtd_setup2(val);
#else
	/* If more parameters are later passed in via
	   /sys/module/block2mtd/parameters/block2mtd
	   and block2mtd_init() has already been called,
	   we can parse the argument now. */

	if (block2mtd_init_called)
		return block2mtd_setup2(val);

	/* During early boot stage, we only save the parameters
	   here. We must parse them later: if the param passed
	   from kernel boot command line, block2mtd_setup() is
	   called so early that it is not possible to resolve
	   the device (even kmalloc() fails). Deter that work to
	   block2mtd_setup2(). */

	strlcpy(block2mtd_paramline, val, sizeof(block2mtd_paramline));

	return 0;
#endif
}


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)
{
	int ret = 0;

#ifndef MODULE
	if (strlen(block2mtd_paramline))
		ret = block2mtd_setup2(block2mtd_paramline);
	block2mtd_init_called = 1;
#endif

	return ret;
}


static void 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);
		mtd_device_unregister(&dev->mtd);
		mutex_destroy(&dev->write_mutex);
		pr_info("mtd%d: [%s] removed\n",
			dev->mtd.index,
			dev->mtd.name + strlen("block2mtd: "));
		list_del(&dev->list);
		block2mtd_free_device(dev);
	}
}


module_init(block2mtd_init);
module_exit(block2mtd_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Joern Engel <joern@lazybastard.org>");
MODULE_DESCRIPTION("Emulate an MTD using a block device");
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* block2mtd.c - create an mtd from a block device
	3	*
	4	* Copyright (C) 2001,2002 Simon Evans <spse@secret.org.uk>
2b54aaef	5	* Copyright (C) 2004-2006 Joern Engel <joern@wh.fh-wedel.de>
1da177e4 LT	6	*
	7	* Licence: GPL
	8	*/
a1c06609 JP	9
	10	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	11
1da177e4 LT	12	#include <linux/module.h>
	13	#include <linux/fs.h>
	14	#include <linux/blkdev.h>
	15	#include <linux/bio.h>
	16	#include <linux/pagemap.h>
	17	#include <linux/list.h>
	18	#include <linux/init.h>
	19	#include <linux/mtd/mtd.h>
48b19268	20	#include <linux/mutex.h>
c4e7fb31	21	#include <linux/mount.h>
5a0e3ad6	22	#include <linux/slab.h>
f83c3838	23	#include <linux/major.h>
1da177e4	24
1da177e4 LT	25	/* Info for the block device */
	26	struct block2mtd_dev {
	27	struct list_head list;
	28	struct block_device *blkdev;
	29	struct mtd_info mtd;
48b19268	30	struct mutex write_mutex;
1da177e4 LT	31	};
	32
	33
	34	/* Static info about the MTD, used in cleanup_module */
	35	static LIST_HEAD(blkmtd_device_list);
	36
	37
6fe6900e	38	static struct page page_read(struct address_space mapping, int index)
1da177e4	39	{
6fe6900e	40	return read_mapping_page(mapping, index, NULL);
1da177e4 LT	41	}
1da177e4 LT	42
1da177e4 LT	43	/* erase a specified part of the device */
	44	static int _block2mtd_erase(struct block2mtd_dev *dev, loff_t to, size_t len)
	45	{
	46	struct address_space *mapping = dev->blkdev->bd_inode->i_mapping;
	47	struct page *page;
	48	int index = to >> PAGE_SHIFT; // page index
	49	int pages = len >> PAGE_SHIFT;
	50	u_long *p;
	51	u_long *max;
	52
	53	while (pages) {
21d31f1f	54	page = page_read(mapping, index);
1da177e4 LT	55	if (IS_ERR(page))
	56	return PTR_ERR(page);
	57
0ffb74cc JE	58	max = page_address(page) + PAGE_SIZE;
0ffb74cc JE	59	for (p=page_address(page); p<max; p++)
1da177e4 LT	60	if (*p != -1UL) {
	61	lock_page(page);
	62	memset(page_address(page), 0xff, PAGE_SIZE);
	63	set_page_dirty(page);
	64	unlock_page(page);
031da73f	65	balance_dirty_pages_ratelimited(mapping);
1da177e4 LT	66	break;
	67	}
	68
	69	page_cache_release(page);
	70	pages--;
	71	index++;
	72	}
	73	return 0;
	74	}
	75	static int block2mtd_erase(struct mtd_info mtd, struct erase_info instr)
	76	{
	77	struct block2mtd_dev *dev = mtd->priv;
	78	size_t from = instr->addr;
	79	size_t len = instr->len;
	80	int err;
	81
	82	instr->state = MTD_ERASING;
48b19268	83	mutex_lock(&dev->write_mutex);
1da177e4	84	err = _block2mtd_erase(dev, from, len);
48b19268	85	mutex_unlock(&dev->write_mutex);
1da177e4	86	if (err) {
a1c06609	87	pr_err("erase failed err = %d\n", err);
1da177e4 LT	88	instr->state = MTD_ERASE_FAILED;
	89	} else
	90	instr->state = MTD_ERASE_DONE;
	91
1da177e4 LT	92	mtd_erase_callback(instr);
	93	return err;
	94	}
	95
	96
	97	static int block2mtd_read(struct mtd_info *mtd, loff_t from, size_t len,
	98	size_t retlen, u_char buf)
	99	{
	100	struct block2mtd_dev *dev = mtd->priv;
	101	struct page *page;
	102	int index = from >> PAGE_SHIFT;
711c11b7	103	int offset = from & (PAGE_SIZE-1);
1da177e4 LT	104	int cpylen;
1da177e4 LT	105
1da177e4 LT	106	while (len) {
	107	if ((offset + len) > PAGE_SIZE)
	108	cpylen = PAGE_SIZE - offset; // multiple pages
	109	else
	110	cpylen = len; // this page
	111	len = len - cpylen;
	112
21d31f1f	113	page = page_read(dev->blkdev->bd_inode->i_mapping, index);
1da177e4 LT	114	if (IS_ERR(page))
	115	return PTR_ERR(page);
	116
	117	memcpy(buf, page_address(page) + offset, cpylen);
	118	page_cache_release(page);
	119
	120	if (retlen)
	121	*retlen += cpylen;
	122	buf += cpylen;
	123	offset = 0;
	124	index++;
	125	}
	126	return 0;
	127	}
	128
	129
	130	/* write data to the underlying device */
	131	static int _block2mtd_write(struct block2mtd_dev dev, const u_char buf,
	132	loff_t to, size_t len, size_t *retlen)
	133	{
	134	struct page *page;
	135	struct address_space *mapping = dev->blkdev->bd_inode->i_mapping;
	136	int index = to >> PAGE_SHIFT; // page index
	137	int offset = to & ~PAGE_MASK; // page offset
	138	int cpylen;
	139
1da177e4	140	while (len) {
e5580fbe	141	if ((offset+len) > PAGE_SIZE)
1da177e4 LT	142	cpylen = PAGE_SIZE - offset; // multiple pages
	143	else
	144	cpylen = len; // this page
	145	len = len - cpylen;
	146
21d31f1f	147	page = page_read(mapping, index);
1da177e4 LT	148	if (IS_ERR(page))
	149	return PTR_ERR(page);
	150
	151	if (memcmp(page_address(page)+offset, buf, cpylen)) {
	152	lock_page(page);
	153	memcpy(page_address(page) + offset, buf, cpylen);
	154	set_page_dirty(page);
	155	unlock_page(page);
031da73f	156	balance_dirty_pages_ratelimited(mapping);
1da177e4 LT	157	}
	158	page_cache_release(page);
	159
	160	if (retlen)
	161	*retlen += cpylen;
	162
	163	buf += cpylen;
	164	offset = 0;
	165	index++;
	166	}
	167	return 0;
	168	}
c4e7fb31 VH	169
c4e7fb31 VH	170
1da177e4 LT	171	static int block2mtd_write(struct mtd_info *mtd, loff_t to, size_t len,
	172	size_t retlen, const u_char buf)
	173	{
	174	struct block2mtd_dev *dev = mtd->priv;
	175	int err;
	176
48b19268	177	mutex_lock(&dev->write_mutex);
1da177e4	178	err = _block2mtd_write(dev, buf, to, len, retlen);
48b19268	179	mutex_unlock(&dev->write_mutex);
1da177e4 LT	180	if (err > 0)
	181	err = 0;
	182	return err;
	183	}
	184
	185
	186	/* sync the device - wait until the write queue is empty */
	187	static void block2mtd_sync(struct mtd_info *mtd)
	188	{
	189	struct block2mtd_dev *dev = mtd->priv;
	190	sync_blockdev(dev->blkdev);
	191	return;
	192	}
	193
	194
	195	static void block2mtd_free_device(struct block2mtd_dev *dev)
	196	{
	197	if (!dev)
	198	return;
	199
	200	kfree(dev->mtd.name);
	201
	202	if (dev->blkdev) {
fc0ecff6 AM	203	invalidate_mapping_pages(dev->blkdev->bd_inode->i_mapping,
fc0ecff6 AM	204	0, -1);
e525fd89	205	blkdev_put(dev->blkdev, FMODE_READ\|FMODE_WRITE\|FMODE_EXCL);
1da177e4 LT	206	}
	207
	208	kfree(dev);
	209	}
	210
	211
1da177e4 LT	212	static struct block2mtd_dev add_device(char devname, int erase_size)
1da177e4 LT	213	{
e525fd89	214	const fmode_t mode = FMODE_READ \| FMODE_WRITE \| FMODE_EXCL;
1da177e4 LT	215	struct block_device *bdev;
1da177e4 LT	216	struct block2mtd_dev *dev;
eadcf0d7	217	char *name;
1da177e4 LT	218
	219	if (!devname)
	220	return NULL;
	221
95b93a0c	222	dev = kzalloc(sizeof(struct block2mtd_dev), GFP_KERNEL);
1da177e4 LT	223	if (!dev)
1da177e4 LT	224	return NULL;
1da177e4 LT	225
1da177e4 LT	226	/* Get a handle on the device */
d4d77629	227	bdev = blkdev_get_by_path(devname, mode, dev);
c4e7fb31 VH	228	#ifndef MODULE
	229	if (IS_ERR(bdev)) {
	230
	231	/* We might not have rootfs mounted at this point. Try
	232	to resolve the device name by other means. */
	233
8870530a	234	dev_t devt = name_to_dev_t(devname);
e525fd89	235	if (devt)
d4d77629	236	bdev = blkdev_get_by_dev(devt, mode, dev);
c4e7fb31 VH	237	}
	238	#endif
	239
1da177e4	240	if (IS_ERR(bdev)) {
a1c06609	241	pr_err("error: cannot open device %s\n", devname);
4bed207c	242	goto err_free_block2mtd;
1da177e4 LT	243	}
	244	dev->blkdev = bdev;
	245
	246	if (MAJOR(bdev->bd_dev) == MTD_BLOCK_MAJOR) {
a1c06609	247	pr_err("attempting to use an MTD device as a block device\n");
4bed207c	248	goto err_free_block2mtd;
1da177e4 LT	249	}
1da177e4 LT	250
ea6d833a FF	251	if ((long)dev->blkdev->bd_inode->i_size % erase_size) {
	252	pr_err("erasesize must be a divisor of device size\n");
	253	goto err_free_block2mtd;
	254	}
	255
48b19268	256	mutex_init(&dev->write_mutex);
1da177e4 LT	257
	258	/* Setup the MTD structure */
	259	/* make the name contain the block device in */
4d682420	260	name = kasprintf(GFP_KERNEL, "block2mtd: %s", devname);
eadcf0d7	261	if (!name)
4bed207c	262	goto err_destroy_mutex;
1da177e4	263
eadcf0d7	264	dev->mtd.name = name;
1da177e4 LT	265
	266	dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK;
	267	dev->mtd.erasesize = erase_size;
17ffc7ba	268	dev->mtd.writesize = 1;
b6043874	269	dev->mtd.writebufsize = PAGE_SIZE;
21c8db9e	270	dev->mtd.type = MTD_RAM;
1da177e4	271	dev->mtd.flags = MTD_CAP_RAM;
3c3c10bb AB	272	dev->mtd._erase = block2mtd_erase;
3c3c10bb AB	273	dev->mtd._write = block2mtd_write;
3c3c10bb AB	274	dev->mtd._sync = block2mtd_sync;
3c3c10bb AB	275	dev->mtd._read = block2mtd_read;
1da177e4 LT	276	dev->mtd.priv = dev;
	277	dev->mtd.owner = THIS_MODULE;
	278
ee0e87b1	279	if (mtd_device_register(&dev->mtd, NULL, 0)) {
25985edc	280	/* Device didn't get added, so free the entry */
4bed207c	281	goto err_destroy_mutex;
1da177e4 LT	282	}
1da177e4 LT	283	list_add(&dev->list, &blkmtd_device_list);
a1c06609 JP	284	pr_info("mtd%d: [%s] erase_size = %dKiB [%d]\n",
	285	dev->mtd.index,
	286	dev->mtd.name + strlen("block2mtd: "),
	287	dev->mtd.erasesize >> 10, dev->mtd.erasesize);
1da177e4 LT	288	return dev;
1da177e4 LT	289
4bed207c FF	290	err_destroy_mutex:
	291	mutex_destroy(&dev->write_mutex);
	292	err_free_block2mtd:
1da177e4 LT	293	block2mtd_free_device(dev);
	294	return NULL;
	295	}
	296
	297
954c2422 JE	298	/* This function works similar to reguler strtoul. In addition, it
	299	* allows some suffixes for a more human-readable number format:
	300	* ki, Ki, kiB, KiB - multiply result with 1024
	301	* Mi, MiB - multiply result with 1024^2
	302	* Gi, GiB - multiply result with 1024^3
	303	*/
1da177e4 LT	304	static int ustrtoul(const char cp, char *endp, unsigned int base)
	305	{
	306	unsigned long result = simple_strtoul(cp, endp, base);
	307	switch (**endp) {
	308	case 'G' :
	309	result *= 1024;
	310	case 'M':
	311	result *= 1024;
954c2422	312	case 'K':
1da177e4 LT	313	case 'k':
	314	result *= 1024;
	315	/* By dwmw2 editorial decree, "ki", "Mi" or "Gi" are to be used. */
954c2422 JE	316	if ((*endp)[1] == 'i') {
	317	if ((*endp)[2] == 'B')
	318	(*endp) += 3;
	319	else
	320	(*endp) += 2;
	321	}
1da177e4 LT	322	}
	323	return result;
	324	}
	325
	326
cc71229f	327	static int parse_num(size_t num, const char token)
1da177e4 LT	328	{
1da177e4 LT	329	char *endp;
cc71229f	330	size_t n;
1da177e4	331
cc71229f	332	n = (size_t) ustrtoul(token, &endp, 0);
1da177e4 LT	333	if (*endp)
	334	return -EINVAL;
	335
cc71229f	336	*num = n;
1da177e4 LT	337	return 0;
	338	}
	339
	340
1da177e4 LT	341	static inline void kill_final_newline(char *str)
	342	{
	343	char *newline = strrchr(str, '\n');
	344	if (newline && !newline[1])
	345	*newline = 0;
	346	}
	347
	348
c4e7fb31 VH	349	#ifndef MODULE
c4e7fb31 VH	350	static int block2mtd_init_called = 0;
4839f048	351	static char block2mtd_paramline[80 + 12]; /* 80 for device, 12 for erase size */
c4e7fb31 VH	352	#endif
c4e7fb31 VH	353
c4e7fb31	354	static int block2mtd_setup2(const char *val)
1da177e4	355	{
c4e7fb31	356	char buf[80 + 12]; /* 80 for device, 12 for erase size */
a6550e57	357	char *str = buf;
1da177e4 LT	358	char *token[2];
1da177e4 LT	359	char *name;
cc71229f	360	size_t erase_size = PAGE_SIZE;
1da177e4 LT	361	int i, ret;
1da177e4 LT	362
a1c06609 JP	363	if (strnlen(val, sizeof(buf)) >= sizeof(buf)) {
	364	pr_err("parameter too long\n");
	365	return 0;
	366	}
1da177e4 LT	367
	368	strcpy(str, val);
	369	kill_final_newline(str);
	370
a6550e57	371	for (i = 0; i < 2; i++)
1da177e4 LT	372	token[i] = strsep(&str, ",");
1da177e4 LT	373
a1c06609 JP	374	if (str) {
	375	pr_err("too many arguments\n");
	376	return 0;
	377	}
1da177e4	378
a1c06609 JP	379	if (!token[0]) {
	380	pr_err("no argument\n");
	381	return 0;
	382	}
1da177e4	383
c4e7fb31	384	name = token[0];
a1c06609 JP	385	if (strlen(name) + 1 > 80) {
	386	pr_err("device name too long\n");
	387	return 0;
	388	}
1da177e4 LT	389
1da177e4 LT	390	if (token[1]) {
cc71229f	391	ret = parse_num(&erase_size, token[1]);
a6550e57	392	if (ret) {
a1c06609 JP	393	pr_err("illegal erase size\n");
a1c06609 JP	394	return 0;
a6550e57	395	}
1da177e4 LT	396	}
	397
	398	add_device(name, erase_size);
	399
	400	return 0;
	401	}
	402
	403
c4e7fb31 VH	404	static int block2mtd_setup(const char val, struct kernel_param kp)
	405	{
	406	#ifdef MODULE
	407	return block2mtd_setup2(val);
	408	#else
	409	/* If more parameters are later passed in via
	410	/sys/module/block2mtd/parameters/block2mtd
	411	and block2mtd_init() has already been called,
	412	we can parse the argument now. */
	413
	414	if (block2mtd_init_called)
	415	return block2mtd_setup2(val);
	416
	417	/* During early boot stage, we only save the parameters
	418	here. We must parse them later: if the param passed
	419	from kernel boot command line, block2mtd_setup() is
	420	called so early that it is not possible to resolve
	421	the device (even kmalloc() fails). Deter that work to
	422	block2mtd_setup2(). */
	423
	424	strlcpy(block2mtd_paramline, val, sizeof(block2mtd_paramline));
	425
	426	return 0;
	427	#endif
	428	}
	429
	430
1da177e4 LT	431	module_param_call(block2mtd, block2mtd_setup, NULL, NULL, 0200);
	432	MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,<erasesize>]\"");
	433
	434	static int __init block2mtd_init(void)
	435	{
c4e7fb31	436	int ret = 0;
c4e7fb31 VH	437
	438	#ifndef MODULE
	439	if (strlen(block2mtd_paramline))
	440	ret = block2mtd_setup2(block2mtd_paramline);
	441	block2mtd_init_called = 1;
	442	#endif
	443
	444	return ret;
1da177e4 LT	445	}
	446
	447
810b7e06	448	static void block2mtd_exit(void)
1da177e4 LT	449	{
	450	struct list_head pos, next;
	451
	452	/* Remove the MTD devices */
	453	list_for_each_safe(pos, next, &blkmtd_device_list) {
	454	struct block2mtd_dev dev = list_entry(pos, typeof(dev), list);
	455	block2mtd_sync(&dev->mtd);
ee0e87b1	456	mtd_device_unregister(&dev->mtd);
4bed207c	457	mutex_destroy(&dev->write_mutex);
a1c06609 JP	458	pr_info("mtd%d: [%s] removed\n",
	459	dev->mtd.index,
	460	dev->mtd.name + strlen("block2mtd: "));
1da177e4 LT	461	list_del(&dev->list);
	462	block2mtd_free_device(dev);
	463	}
	464	}
	465
	466
	467	module_init(block2mtd_init);
	468	module_exit(block2mtd_exit);
	469
	470	MODULE_LICENSE("GPL");
2b54aaef	471	MODULE_AUTHOR("Joern Engel <joern@lazybastard.org>");
1da177e4	472	MODULE_DESCRIPTION("Emulate an MTD using a block device");