[mirror_ubuntu-hirsute-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

/*
 * When the first attempt at device initialization fails, we may need to
 * wait a little bit and retry. This timeout, by default 3 seconds, gives
 * device time to start up. Required on BCM2708 and a few other chipsets.
 */
#define MTD_DEFAULT_TIMEOUT	3

#include <linux/module.h>
#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/blkdev.h>
#include <linux/backing-dev.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, pgoff_t 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;
	pgoff_t 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;
			}

		put_page(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;

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

	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;
	pgoff_t 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);
		put_page(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;
	pgoff_t 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);
		}
		put_page(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,
		int timeout)
{
#ifndef MODULE
	int i;
#endif
	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
	/*
	 * We might not have the root device mounted at this point.
	 * Try to resolve the device name by other means.
	 */
	for (i = 0; IS_ERR(bdev) && i <= timeout; i++) {
		dev_t devt;

		if (i)
			/*
			 * Calling wait_for_device_probe in the first loop
			 * was not enough, sleep for a bit in subsequent
			 * go-arounds.
			 */
			msleep(1000);
		wait_for_device_probe();

		devt = name_to_dev_t(devname);
		if (!devt)
			continue;
		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;
		fallthrough;
	case 'M':
		result *= 1024;
		fallthrough;
	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;
/* 80 for device, 12 for erase size */
static char block2mtd_paramline[80 + 12];
#endif

static int block2mtd_setup2(const char *val)
{
	/* 80 for device, 12 for erase size, 80 for name, 8 for timeout */
	char buf[80 + 12 + 80 + 8];
	char *str = buf;
	char *token[2];
	char *name;
	size_t erase_size = PAGE_SIZE;
	unsigned long timeout = MTD_DEFAULT_TIMEOUT;
	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, timeout);

	return 0;
}


static int block2mtd_setup(const char *val, const 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);
	}
}

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