[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);
}


/* FIXME: ensure that mtd->size % erase_size == 0 */
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 devinit_err;
	}
	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 devinit_err;
	}

	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 devinit_err;

	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 devinit_err;
	}
	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;

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 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);
		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
	212	/* FIXME: ensure that mtd->size % erase_size == 0 */
	213	static struct block2mtd_dev add_device(char devname, int erase_size)
	214	{
e525fd89	215	const fmode_t mode = FMODE_READ \| FMODE_WRITE \| FMODE_EXCL;
1da177e4 LT	216	struct block_device *bdev;
1da177e4 LT	217	struct block2mtd_dev *dev;
eadcf0d7	218	char *name;
1da177e4 LT	219
	220	if (!devname)
	221	return NULL;
	222
95b93a0c	223	dev = kzalloc(sizeof(struct block2mtd_dev), GFP_KERNEL);
1da177e4 LT	224	if (!dev)
1da177e4 LT	225	return NULL;
1da177e4 LT	226
1da177e4 LT	227	/* Get a handle on the device */
d4d77629	228	bdev = blkdev_get_by_path(devname, mode, dev);
c4e7fb31 VH	229	#ifndef MODULE
	230	if (IS_ERR(bdev)) {
	231
	232	/* We might not have rootfs mounted at this point. Try
	233	to resolve the device name by other means. */
	234
8870530a	235	dev_t devt = name_to_dev_t(devname);
e525fd89	236	if (devt)
d4d77629	237	bdev = blkdev_get_by_dev(devt, mode, dev);
c4e7fb31 VH	238	}
	239	#endif
	240
1da177e4	241	if (IS_ERR(bdev)) {
a1c06609	242	pr_err("error: cannot open device %s\n", devname);
1da177e4 LT	243	goto devinit_err;
	244	}
	245	dev->blkdev = bdev;
	246
	247	if (MAJOR(bdev->bd_dev) == MTD_BLOCK_MAJOR) {
a1c06609	248	pr_err("attempting to use an MTD device as a block device\n");
1da177e4 LT	249	goto devinit_err;
	250	}
	251
48b19268	252	mutex_init(&dev->write_mutex);
1da177e4 LT	253
	254	/* Setup the MTD structure */
	255	/* make the name contain the block device in */
4d682420	256	name = kasprintf(GFP_KERNEL, "block2mtd: %s", devname);
eadcf0d7	257	if (!name)
1da177e4 LT	258	goto devinit_err;
1da177e4 LT	259
eadcf0d7	260	dev->mtd.name = name;
1da177e4 LT	261
	262	dev->mtd.size = dev->blkdev->bd_inode->i_size & PAGE_MASK;
	263	dev->mtd.erasesize = erase_size;
17ffc7ba	264	dev->mtd.writesize = 1;
b6043874	265	dev->mtd.writebufsize = PAGE_SIZE;
21c8db9e	266	dev->mtd.type = MTD_RAM;
1da177e4	267	dev->mtd.flags = MTD_CAP_RAM;
3c3c10bb AB	268	dev->mtd._erase = block2mtd_erase;
3c3c10bb AB	269	dev->mtd._write = block2mtd_write;
3c3c10bb AB	270	dev->mtd._sync = block2mtd_sync;
3c3c10bb AB	271	dev->mtd._read = block2mtd_read;
1da177e4 LT	272	dev->mtd.priv = dev;
	273	dev->mtd.owner = THIS_MODULE;
	274
ee0e87b1	275	if (mtd_device_register(&dev->mtd, NULL, 0)) {
25985edc	276	/* Device didn't get added, so free the entry */
1da177e4 LT	277	goto devinit_err;
	278	}
	279	list_add(&dev->list, &blkmtd_device_list);
a1c06609 JP	280	pr_info("mtd%d: [%s] erase_size = %dKiB [%d]\n",
	281	dev->mtd.index,
	282	dev->mtd.name + strlen("block2mtd: "),
	283	dev->mtd.erasesize >> 10, dev->mtd.erasesize);
1da177e4 LT	284	return dev;
	285
	286	devinit_err:
	287	block2mtd_free_device(dev);
	288	return NULL;
	289	}
	290
	291
954c2422 JE	292	/* This function works similar to reguler strtoul. In addition, it
	293	* allows some suffixes for a more human-readable number format:
	294	* ki, Ki, kiB, KiB - multiply result with 1024
	295	* Mi, MiB - multiply result with 1024^2
	296	* Gi, GiB - multiply result with 1024^3
	297	*/
1da177e4 LT	298	static int ustrtoul(const char cp, char *endp, unsigned int base)
	299	{
	300	unsigned long result = simple_strtoul(cp, endp, base);
	301	switch (**endp) {
	302	case 'G' :
	303	result *= 1024;
	304	case 'M':
	305	result *= 1024;
954c2422	306	case 'K':
1da177e4 LT	307	case 'k':
	308	result *= 1024;
	309	/* By dwmw2 editorial decree, "ki", "Mi" or "Gi" are to be used. */
954c2422 JE	310	if ((*endp)[1] == 'i') {
	311	if ((*endp)[2] == 'B')
	312	(*endp) += 3;
	313	else
	314	(*endp) += 2;
	315	}
1da177e4 LT	316	}
	317	return result;
	318	}
	319
	320
cc71229f	321	static int parse_num(size_t num, const char token)
1da177e4 LT	322	{
1da177e4 LT	323	char *endp;
cc71229f	324	size_t n;
1da177e4	325
cc71229f	326	n = (size_t) ustrtoul(token, &endp, 0);
1da177e4 LT	327	if (*endp)
	328	return -EINVAL;
	329
cc71229f	330	*num = n;
1da177e4 LT	331	return 0;
	332	}
	333
	334
1da177e4 LT	335	static inline void kill_final_newline(char *str)
	336	{
	337	char *newline = strrchr(str, '\n');
	338	if (newline && !newline[1])
	339	*newline = 0;
	340	}
	341
	342
c4e7fb31 VH	343	#ifndef MODULE
c4e7fb31 VH	344	static int block2mtd_init_called = 0;
4839f048	345	static char block2mtd_paramline[80 + 12]; /* 80 for device, 12 for erase size */
c4e7fb31 VH	346	#endif
c4e7fb31 VH	347
c4e7fb31	348	static int block2mtd_setup2(const char *val)
1da177e4	349	{
c4e7fb31	350	char buf[80 + 12]; /* 80 for device, 12 for erase size */
a6550e57	351	char *str = buf;
1da177e4 LT	352	char *token[2];
1da177e4 LT	353	char *name;
cc71229f	354	size_t erase_size = PAGE_SIZE;
1da177e4 LT	355	int i, ret;
1da177e4 LT	356
a1c06609 JP	357	if (strnlen(val, sizeof(buf)) >= sizeof(buf)) {
	358	pr_err("parameter too long\n");
	359	return 0;
	360	}
1da177e4 LT	361
	362	strcpy(str, val);
	363	kill_final_newline(str);
	364
a6550e57	365	for (i = 0; i < 2; i++)
1da177e4 LT	366	token[i] = strsep(&str, ",");
1da177e4 LT	367
a1c06609 JP	368	if (str) {
	369	pr_err("too many arguments\n");
	370	return 0;
	371	}
1da177e4	372
a1c06609 JP	373	if (!token[0]) {
	374	pr_err("no argument\n");
	375	return 0;
	376	}
1da177e4	377
c4e7fb31	378	name = token[0];
a1c06609 JP	379	if (strlen(name) + 1 > 80) {
	380	pr_err("device name too long\n");
	381	return 0;
	382	}
1da177e4 LT	383
1da177e4 LT	384	if (token[1]) {
cc71229f	385	ret = parse_num(&erase_size, token[1]);
a6550e57	386	if (ret) {
a1c06609 JP	387	pr_err("illegal erase size\n");
a1c06609 JP	388	return 0;
a6550e57	389	}
1da177e4 LT	390	}
	391
	392	add_device(name, erase_size);
	393
	394	return 0;
	395	}
	396
	397
c4e7fb31 VH	398	static int block2mtd_setup(const char val, struct kernel_param kp)
	399	{
	400	#ifdef MODULE
	401	return block2mtd_setup2(val);
	402	#else
	403	/* If more parameters are later passed in via
	404	/sys/module/block2mtd/parameters/block2mtd
	405	and block2mtd_init() has already been called,
	406	we can parse the argument now. */
	407
	408	if (block2mtd_init_called)
	409	return block2mtd_setup2(val);
	410
	411	/* During early boot stage, we only save the parameters
	412	here. We must parse them later: if the param passed
	413	from kernel boot command line, block2mtd_setup() is
	414	called so early that it is not possible to resolve
	415	the device (even kmalloc() fails). Deter that work to
	416	block2mtd_setup2(). */
	417
	418	strlcpy(block2mtd_paramline, val, sizeof(block2mtd_paramline));
	419
	420	return 0;
	421	#endif
	422	}
	423
	424
1da177e4 LT	425	module_param_call(block2mtd, block2mtd_setup, NULL, NULL, 0200);
	426	MODULE_PARM_DESC(block2mtd, "Device to use. \"block2mtd=<dev>[,<erasesize>]\"");
	427
	428	static int __init block2mtd_init(void)
	429	{
c4e7fb31	430	int ret = 0;
c4e7fb31 VH	431
	432	#ifndef MODULE
	433	if (strlen(block2mtd_paramline))
	434	ret = block2mtd_setup2(block2mtd_paramline);
	435	block2mtd_init_called = 1;
	436	#endif
	437
	438	return ret;
1da177e4 LT	439	}
	440
	441
810b7e06	442	static void block2mtd_exit(void)
1da177e4 LT	443	{
	444	struct list_head pos, next;
	445
	446	/* Remove the MTD devices */
	447	list_for_each_safe(pos, next, &blkmtd_device_list) {
	448	struct block2mtd_dev dev = list_entry(pos, typeof(dev), list);
	449	block2mtd_sync(&dev->mtd);
ee0e87b1	450	mtd_device_unregister(&dev->mtd);
a1c06609 JP	451	pr_info("mtd%d: [%s] removed\n",
	452	dev->mtd.index,
	453	dev->mtd.name + strlen("block2mtd: "));
1da177e4 LT	454	list_del(&dev->list);
	455	block2mtd_free_device(dev);
	456	}
	457	}
	458
	459
	460	module_init(block2mtd_init);
	461	module_exit(block2mtd_exit);
	462
	463	MODULE_LICENSE("GPL");
2b54aaef	464	MODULE_AUTHOR("Joern Engel <joern@lazybastard.org>");
1da177e4	465	MODULE_DESCRIPTION("Emulate an MTD using a block device");