[deliverable/linux.git] / arch / xtensa / platforms / iss / simdisk.c

/*
 * arch/xtensa/platforms/iss/simdisk.c
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 2001-2013 Tensilica Inc.
 *   Authors	Victor Prupis
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/blkdev.h>
#include <linux/bio.h>
#include <linux/proc_fs.h>
#include <asm/uaccess.h>
#include <platform/simcall.h>

#define SIMDISK_MAJOR 240
#define SECTOR_SHIFT 9
#define SIMDISK_MINORS 1
#define MAX_SIMDISK_COUNT 10

struct simdisk {
	const char *filename;
	spinlock_t lock;
	struct request_queue *queue;
	struct gendisk *gd;
	struct proc_dir_entry *procfile;
	int users;
	unsigned long size;
	int fd;
};


static int simdisk_count = CONFIG_BLK_DEV_SIMDISK_COUNT;
module_param(simdisk_count, int, S_IRUGO);
MODULE_PARM_DESC(simdisk_count, "Number of simdisk units.");

static int n_files;
static const char *filename[MAX_SIMDISK_COUNT] = {
#ifdef CONFIG_SIMDISK0_FILENAME
	CONFIG_SIMDISK0_FILENAME,
#ifdef CONFIG_SIMDISK1_FILENAME
	CONFIG_SIMDISK1_FILENAME,
#endif
#endif
};

static int simdisk_param_set_filename(const char *val,
		const struct kernel_param *kp)
{
	if (n_files < ARRAY_SIZE(filename))
		filename[n_files++] = val;
	else
		return -EINVAL;
	return 0;
}

static const struct kernel_param_ops simdisk_param_ops_filename = {
	.set = simdisk_param_set_filename,
};
module_param_cb(filename, &simdisk_param_ops_filename, &n_files, 0);
MODULE_PARM_DESC(filename, "Backing storage filename.");

static int simdisk_major = SIMDISK_MAJOR;

static void simdisk_transfer(struct simdisk *dev, unsigned long sector,
		unsigned long nsect, char *buffer, int write)
{
	unsigned long offset = sector << SECTOR_SHIFT;
	unsigned long nbytes = nsect << SECTOR_SHIFT;

	if (offset > dev->size || dev->size - offset < nbytes) {
		pr_notice("Beyond-end %s (%ld %ld)\n",
				write ? "write" : "read", offset, nbytes);
		return;
	}

	spin_lock(&dev->lock);
	while (nbytes > 0) {
		unsigned long io;

		simc_lseek(dev->fd, offset, SEEK_SET);
		if (write)
			io = simc_write(dev->fd, buffer, nbytes);
		else
			io = simc_read(dev->fd, buffer, nbytes);
		if (io == -1) {
			pr_err("SIMDISK: IO error %d\n", errno);
			break;
		}
		buffer += io;
		offset += io;
		nbytes -= io;
	}
	spin_unlock(&dev->lock);
}

static blk_qc_t simdisk_make_request(struct request_queue *q, struct bio *bio)
{
	struct simdisk *dev = q->queuedata;
	struct bio_vec bvec;
	struct bvec_iter iter;
	sector_t sector = bio->bi_iter.bi_sector;

	bio_for_each_segment(bvec, bio, iter) {
		char *buffer = __bio_kmap_atomic(bio, iter);
		unsigned len = bvec.bv_len >> SECTOR_SHIFT;

		simdisk_transfer(dev, sector, len, buffer,
				bio_data_dir(bio) == WRITE);
		sector += len;
		__bio_kunmap_atomic(buffer);
	}

	bio_endio(bio);
	return BLK_QC_T_NONE;
}

static int simdisk_open(struct block_device *bdev, fmode_t mode)
{
	struct simdisk *dev = bdev->bd_disk->private_data;

	spin_lock(&dev->lock);
	if (!dev->users)
		check_disk_change(bdev);
	++dev->users;
	spin_unlock(&dev->lock);
	return 0;
}

static void simdisk_release(struct gendisk *disk, fmode_t mode)
{
	struct simdisk *dev = disk->private_data;
	spin_lock(&dev->lock);
	--dev->users;
	spin_unlock(&dev->lock);
}

static const struct block_device_operations simdisk_ops = {
	.owner		= THIS_MODULE,
	.open		= simdisk_open,
	.release	= simdisk_release,
};

static struct simdisk *sddev;
static struct proc_dir_entry *simdisk_procdir;

static int simdisk_attach(struct simdisk *dev, const char *filename)
{
	int err = 0;

	filename = kstrdup(filename, GFP_KERNEL);
	if (filename == NULL)
		return -ENOMEM;

	spin_lock(&dev->lock);

	if (dev->fd != -1) {
		err = -EBUSY;
		goto out;
	}
	dev->fd = simc_open(filename, O_RDWR, 0);
	if (dev->fd == -1) {
		pr_err("SIMDISK: Can't open %s: %d\n", filename, errno);
		err = -ENODEV;
		goto out;
	}
	dev->size = simc_lseek(dev->fd, 0, SEEK_END);
	set_capacity(dev->gd, dev->size >> SECTOR_SHIFT);
	dev->filename = filename;
	pr_info("SIMDISK: %s=%s\n", dev->gd->disk_name, dev->filename);
out:
	if (err)
		kfree(filename);
	spin_unlock(&dev->lock);

	return err;
}

static int simdisk_detach(struct simdisk *dev)
{
	int err = 0;

	spin_lock(&dev->lock);

	if (dev->users != 0) {
		err = -EBUSY;
	} else if (dev->fd != -1) {
		if (simc_close(dev->fd)) {
			pr_err("SIMDISK: error closing %s: %d\n",
					dev->filename, errno);
			err = -EIO;
		} else {
			pr_info("SIMDISK: %s detached from %s\n",
					dev->gd->disk_name, dev->filename);
			dev->fd = -1;
			kfree(dev->filename);
			dev->filename = NULL;
		}
	}
	spin_unlock(&dev->lock);
	return err;
}

static ssize_t proc_read_simdisk(struct file *file, char __user *buf,
			size_t size, loff_t *ppos)
{
	struct simdisk *dev = PDE_DATA(file_inode(file));
	const char *s = dev->filename;
	if (s) {
		ssize_t n = simple_read_from_buffer(buf, size, ppos,
							s, strlen(s));
		if (n < 0)
			return n;
		buf += n;
		size -= n;
	}
	return simple_read_from_buffer(buf, size, ppos, "\n", 1);
}

static ssize_t proc_write_simdisk(struct file *file, const char __user *buf,
			size_t count, loff_t *ppos)
{
	char *tmp = memdup_user_nul(buf, count);
	struct simdisk *dev = PDE_DATA(file_inode(file));
	int err;

	if (IS_ERR(tmp))
		return PTR_ERR(tmp);

	err = simdisk_detach(dev);
	if (err != 0)
		goto out_free;

	if (count > 0 && tmp[count - 1] == '\n')
		tmp[count - 1] = 0;

	if (tmp[0])
		err = simdisk_attach(dev, tmp);

	if (err == 0)
		err = count;
out_free:
	kfree(tmp);
	return err;
}

static const struct file_operations fops = {
	.read = proc_read_simdisk,
	.write = proc_write_simdisk,
	.llseek = default_llseek,
};

static int __init simdisk_setup(struct simdisk *dev, int which,
		struct proc_dir_entry *procdir)
{
	char tmp[2] = { '0' + which, 0 };

	dev->fd = -1;
	dev->filename = NULL;
	spin_lock_init(&dev->lock);
	dev->users = 0;

	dev->queue = blk_alloc_queue(GFP_KERNEL);
	if (dev->queue == NULL) {
		pr_err("blk_alloc_queue failed\n");
		goto out_alloc_queue;
	}

	blk_queue_make_request(dev->queue, simdisk_make_request);
	dev->queue->queuedata = dev;

	dev->gd = alloc_disk(SIMDISK_MINORS);
	if (dev->gd == NULL) {
		pr_err("alloc_disk failed\n");
		goto out_alloc_disk;
	}
	dev->gd->major = simdisk_major;
	dev->gd->first_minor = which;
	dev->gd->fops = &simdisk_ops;
	dev->gd->queue = dev->queue;
	dev->gd->private_data = dev;
	snprintf(dev->gd->disk_name, 32, "simdisk%d", which);
	set_capacity(dev->gd, 0);
	add_disk(dev->gd);

	dev->procfile = proc_create_data(tmp, 0644, procdir, &fops, dev);
	return 0;

out_alloc_disk:
	blk_cleanup_queue(dev->queue);
	dev->queue = NULL;
out_alloc_queue:
	simc_close(dev->fd);
	return -EIO;
}

static int __init simdisk_init(void)
{
	int i;

	if (register_blkdev(simdisk_major, "simdisk") < 0) {
		pr_err("SIMDISK: register_blkdev: %d\n", simdisk_major);
		return -EIO;
	}
	pr_info("SIMDISK: major: %d\n", simdisk_major);

	if (n_files > simdisk_count)
		simdisk_count = n_files;
	if (simdisk_count > MAX_SIMDISK_COUNT)
		simdisk_count = MAX_SIMDISK_COUNT;

	sddev = kmalloc(simdisk_count * sizeof(struct simdisk),
			GFP_KERNEL);
	if (sddev == NULL)
		goto out_unregister;

	simdisk_procdir = proc_mkdir("simdisk", 0);
	if (simdisk_procdir == NULL)
		goto out_free_unregister;

	for (i = 0; i < simdisk_count; ++i) {
		if (simdisk_setup(sddev + i, i, simdisk_procdir) == 0) {
			if (filename[i] != NULL && filename[i][0] != 0 &&
					(n_files == 0 || i < n_files))
				simdisk_attach(sddev + i, filename[i]);
		}
	}

	return 0;

out_free_unregister:
	kfree(sddev);
out_unregister:
	unregister_blkdev(simdisk_major, "simdisk");
	return -ENOMEM;
}
module_init(simdisk_init);

static void simdisk_teardown(struct simdisk *dev, int which,
		struct proc_dir_entry *procdir)
{
	char tmp[2] = { '0' + which, 0 };

	simdisk_detach(dev);
	if (dev->gd)
		del_gendisk(dev->gd);
	if (dev->queue)
		blk_cleanup_queue(dev->queue);
	remove_proc_entry(tmp, procdir);
}

static void __exit simdisk_exit(void)
{
	int i;

	for (i = 0; i < simdisk_count; ++i)
		simdisk_teardown(sddev + i, i, simdisk_procdir);
	remove_proc_entry("simdisk", 0);
	kfree(sddev);
	unregister_blkdev(simdisk_major, "simdisk");
}
module_exit(simdisk_exit);

MODULE_ALIAS_BLOCKDEV_MAJOR(SIMDISK_MAJOR);

MODULE_LICENSE("GPL");
Commit	Line	Data
b6c7e873 VP	1	/*
	2	* arch/xtensa/platforms/iss/simdisk.c
	3	*
	4	* This file is subject to the terms and conditions of the GNU General Public
	5	* License. See the file "COPYING" in the main directory of this archive
	6	* for more details.
	7	*
	8	* Copyright (C) 2001-2013 Tensilica Inc.
	9	* Authors Victor Prupis
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/moduleparam.h>
	14	#include <linux/kernel.h>
	15	#include <linux/init.h>
	16	#include <linux/string.h>
	17	#include <linux/blkdev.h>
	18	#include <linux/bio.h>
	19	#include <linux/proc_fs.h>
	20	#include <asm/uaccess.h>
	21	#include <platform/simcall.h>
	22
	23	#define SIMDISK_MAJOR 240
	24	#define SECTOR_SHIFT 9
	25	#define SIMDISK_MINORS 1
	26	#define MAX_SIMDISK_COUNT 10
	27
	28	struct simdisk {
	29	const char *filename;
	30	spinlock_t lock;
	31	struct request_queue *queue;
	32	struct gendisk *gd;
	33	struct proc_dir_entry *procfile;
	34	int users;
	35	unsigned long size;
	36	int fd;
	37	};
	38
	39
	40	static int simdisk_count = CONFIG_BLK_DEV_SIMDISK_COUNT;
	41	module_param(simdisk_count, int, S_IRUGO);
	42	MODULE_PARM_DESC(simdisk_count, "Number of simdisk units.");
	43
	44	static int n_files;
	45	static const char *filename[MAX_SIMDISK_COUNT] = {
	46	#ifdef CONFIG_SIMDISK0_FILENAME
	47	CONFIG_SIMDISK0_FILENAME,
	48	#ifdef CONFIG_SIMDISK1_FILENAME
	49	CONFIG_SIMDISK1_FILENAME,
	50	#endif
	51	#endif
	52	};
	53
	54	static int simdisk_param_set_filename(const char *val,
	55	const struct kernel_param *kp)
	56	{
	57	if (n_files < ARRAY_SIZE(filename))
	58	filename[n_files++] = val;
	59	else
	60	return -EINVAL;
	61	return 0;
	62	}
	63
	64	static const struct kernel_param_ops simdisk_param_ops_filename = {
65	.set = simdisk_param_set_filename,
66	};
67	module_param_cb(filename, &simdisk_param_ops_filename, &n_files, 0);
68	MODULE_PARM_DESC(filename, "Backing storage filename.");
69
70	static int simdisk_major = SIMDISK_MAJOR;
71
72	static void simdisk_transfer(struct simdisk *dev, unsigned long sector,
73	unsigned long nsect, char *buffer, int write)
74	{
75	unsigned long offset = sector << SECTOR_SHIFT;
76	unsigned long nbytes = nsect << SECTOR_SHIFT;
77
78	if (offset > dev->size \|\| dev->size - offset < nbytes) {
79	pr_notice("Beyond-end %s (%ld %ld)\n",
80	write ? "write" : "read", offset, nbytes);
81	return;
82	}
83
84	spin_lock(&dev->lock);
85	while (nbytes > 0) {
86	unsigned long io;
87
f4b93ba9	88	simc_lseek(dev->fd, offset, SEEK_SET);
b6c7e873 VP	89	if (write)
	90	io = simc_write(dev->fd, buffer, nbytes);
	91	else
	92	io = simc_read(dev->fd, buffer, nbytes);
	93	if (io == -1) {
	94	pr_err("SIMDISK: IO error %d\n", errno);
	95	break;
	96	}
	97	buffer += io;
	98	offset += io;
	99	nbytes -= io;
	100	}
	101	spin_unlock(&dev->lock);
	102	}
	103
dece1635	104	static blk_qc_t simdisk_make_request(struct request_queue q, struct bio bio)
b6c7e873	105	{
4246a0b6	106	struct simdisk *dev = q->queuedata;
675675ad JA	107	struct bio_vec bvec;
	108	struct bvec_iter iter;
	109	sector_t sector = bio->bi_iter.bi_sector;
b6c7e873	110
675675ad JA	111	bio_for_each_segment(bvec, bio, iter) {
	112	char *buffer = __bio_kmap_atomic(bio, iter);
	113	unsigned len = bvec.bv_len >> SECTOR_SHIFT;
b6c7e873 VP	114
	115	simdisk_transfer(dev, sector, len, buffer,
	116	bio_data_dir(bio) == WRITE);
	117	sector += len;
675675ad	118	__bio_kunmap_atomic(buffer);
b6c7e873	119	}
b6c7e873	120
4246a0b6	121	bio_endio(bio);
dece1635	122	return BLK_QC_T_NONE;
b6c7e873 VP	123	}
b6c7e873 VP	124
b6c7e873 VP	125	static int simdisk_open(struct block_device *bdev, fmode_t mode)
	126	{
	127	struct simdisk *dev = bdev->bd_disk->private_data;
	128
	129	spin_lock(&dev->lock);
	130	if (!dev->users)
	131	check_disk_change(bdev);
	132	++dev->users;
	133	spin_unlock(&dev->lock);
	134	return 0;
	135	}
	136
db2a144b	137	static void simdisk_release(struct gendisk *disk, fmode_t mode)
b6c7e873 VP	138	{
	139	struct simdisk *dev = disk->private_data;
	140	spin_lock(&dev->lock);
	141	--dev->users;
	142	spin_unlock(&dev->lock);
b6c7e873 VP	143	}
	144
	145	static const struct block_device_operations simdisk_ops = {
	146	.owner = THIS_MODULE,
	147	.open = simdisk_open,
	148	.release = simdisk_release,
	149	};
	150
	151	static struct simdisk *sddev;
	152	static struct proc_dir_entry *simdisk_procdir;
	153
	154	static int simdisk_attach(struct simdisk dev, const char filename)
	155	{
	156	int err = 0;
	157
	158	filename = kstrdup(filename, GFP_KERNEL);
	159	if (filename == NULL)
	160	return -ENOMEM;
	161
	162	spin_lock(&dev->lock);
	163
	164	if (dev->fd != -1) {
	165	err = -EBUSY;
	166	goto out;
	167	}
	168	dev->fd = simc_open(filename, O_RDWR, 0);
	169	if (dev->fd == -1) {
	170	pr_err("SIMDISK: Can't open %s: %d\n", filename, errno);
	171	err = -ENODEV;
	172	goto out;
	173	}
f4b93ba9	174	dev->size = simc_lseek(dev->fd, 0, SEEK_END);
b6c7e873 VP	175	set_capacity(dev->gd, dev->size >> SECTOR_SHIFT);
	176	dev->filename = filename;
	177	pr_info("SIMDISK: %s=%s\n", dev->gd->disk_name, dev->filename);
	178	out:
	179	if (err)
	180	kfree(filename);
	181	spin_unlock(&dev->lock);
	182
	183	return err;
	184	}
	185
	186	static int simdisk_detach(struct simdisk *dev)
	187	{
	188	int err = 0;
	189
	190	spin_lock(&dev->lock);
	191
	192	if (dev->users != 0) {
	193	err = -EBUSY;
	194	} else if (dev->fd != -1) {
	195	if (simc_close(dev->fd)) {
	196	pr_err("SIMDISK: error closing %s: %d\n",
	197	dev->filename, errno);
	198	err = -EIO;
	199	} else {
	200	pr_info("SIMDISK: %s detached from %s\n",
	201	dev->gd->disk_name, dev->filename);
	202	dev->fd = -1;
	203	kfree(dev->filename);
	204	dev->filename = NULL;
	205	}
	206	}
	207	spin_unlock(&dev->lock);
	208	return err;
	209	}
	210
a69755b1 AV	211	static ssize_t proc_read_simdisk(struct file file, char __user buf,
a69755b1 AV	212	size_t size, loff_t *ppos)
b6c7e873	213	{
d9dda78b	214	struct simdisk *dev = PDE_DATA(file_inode(file));
0757f615	215	const char *s = dev->filename;
a69755b1 AV	216	if (s) {
	217	ssize_t n = simple_read_from_buffer(buf, size, ppos,
	218	s, strlen(s));
	219	if (n < 0)
	220	return n;
	221	buf += n;
	222	size -= n;
	223	}
	224	return simple_read_from_buffer(buf, size, ppos, "\n", 1);
b6c7e873 VP	225	}
b6c7e873 VP	226
a69755b1	227	static ssize_t proc_write_simdisk(struct file file, const char __user buf,
4fe56e80	228	size_t count, loff_t *ppos)
b6c7e873	229	{
16e5c1fc	230	char *tmp = memdup_user_nul(buf, count);
d9dda78b	231	struct simdisk *dev = PDE_DATA(file_inode(file));
b6c7e873 VP	232	int err;
b6c7e873 VP	233
16e5c1fc AV	234	if (IS_ERR(tmp))
16e5c1fc AV	235	return PTR_ERR(tmp);
b6c7e873 VP	236
	237	err = simdisk_detach(dev);
	238	if (err != 0)
	239	goto out_free;
	240
	241	if (count > 0 && tmp[count - 1] == '\n')
	242	tmp[count - 1] = 0;
b6c7e873 VP	243
	244	if (tmp[0])
	245	err = simdisk_attach(dev, tmp);
	246
	247	if (err == 0)
	248	err = count;
	249	out_free:
	250	kfree(tmp);
	251	return err;
	252	}
	253
a69755b1 AV	254	static const struct file_operations fops = {
	255	.read = proc_read_simdisk,
	256	.write = proc_write_simdisk,
	257	.llseek = default_llseek,
	258	};
	259
b6c7e873 VP	260	static int __init simdisk_setup(struct simdisk *dev, int which,
	261	struct proc_dir_entry *procdir)
	262	{
	263	char tmp[2] = { '0' + which, 0 };
	264
	265	dev->fd = -1;
	266	dev->filename = NULL;
	267	spin_lock_init(&dev->lock);
	268	dev->users = 0;
	269
	270	dev->queue = blk_alloc_queue(GFP_KERNEL);
	271	if (dev->queue == NULL) {
	272	pr_err("blk_alloc_queue failed\n");
	273	goto out_alloc_queue;
	274	}
	275
	276	blk_queue_make_request(dev->queue, simdisk_make_request);
	277	dev->queue->queuedata = dev;
	278
	279	dev->gd = alloc_disk(SIMDISK_MINORS);
	280	if (dev->gd == NULL) {
	281	pr_err("alloc_disk failed\n");
	282	goto out_alloc_disk;
	283	}
	284	dev->gd->major = simdisk_major;
	285	dev->gd->first_minor = which;
	286	dev->gd->fops = &simdisk_ops;
	287	dev->gd->queue = dev->queue;
	288	dev->gd->private_data = dev;
	289	snprintf(dev->gd->disk_name, 32, "simdisk%d", which);
	290	set_capacity(dev->gd, 0);
	291	add_disk(dev->gd);
	292
a69755b1	293	dev->procfile = proc_create_data(tmp, 0644, procdir, &fops, dev);
b6c7e873 VP	294	return 0;
	295
	296	out_alloc_disk:
	297	blk_cleanup_queue(dev->queue);
	298	dev->queue = NULL;
	299	out_alloc_queue:
	300	simc_close(dev->fd);
	301	return -EIO;
	302	}
	303
	304	static int __init simdisk_init(void)
	305	{
	306	int i;
	307
	308	if (register_blkdev(simdisk_major, "simdisk") < 0) {
	309	pr_err("SIMDISK: register_blkdev: %d\n", simdisk_major);
	310	return -EIO;
	311	}
	312	pr_info("SIMDISK: major: %d\n", simdisk_major);
	313
	314	if (n_files > simdisk_count)
	315	simdisk_count = n_files;
	316	if (simdisk_count > MAX_SIMDISK_COUNT)
	317	simdisk_count = MAX_SIMDISK_COUNT;
	318
	319	sddev = kmalloc(simdisk_count * sizeof(struct simdisk),
	320	GFP_KERNEL);
	321	if (sddev == NULL)
	322	goto out_unregister;
	323
	324	simdisk_procdir = proc_mkdir("simdisk", 0);
	325	if (simdisk_procdir == NULL)
	326	goto out_free_unregister;
	327
	328	for (i = 0; i < simdisk_count; ++i) {
	329	if (simdisk_setup(sddev + i, i, simdisk_procdir) == 0) {
	330	if (filename[i] != NULL && filename[i][0] != 0 &&
	331	(n_files == 0 \|\| i < n_files))
	332	simdisk_attach(sddev + i, filename[i]);
	333	}
	334	}
	335
	336	return 0;
	337
	338	out_free_unregister:
	339	kfree(sddev);
	340	out_unregister:
	341	unregister_blkdev(simdisk_major, "simdisk");
	342	return -ENOMEM;
	343	}
	344	module_init(simdisk_init);
	345
	346	static void simdisk_teardown(struct simdisk *dev, int which,
	347	struct proc_dir_entry *procdir)
	348	{
	349	char tmp[2] = { '0' + which, 0 };
	350
	351	simdisk_detach(dev);
	352	if (dev->gd)
	353	del_gendisk(dev->gd);
	354	if (dev->queue)
	355	blk_cleanup_queue(dev->queue);
	356	remove_proc_entry(tmp, procdir);
	357	}
358
359	static void __exit simdisk_exit(void)
360	{
361	int i;
362
363	for (i = 0; i < simdisk_count; ++i)
364	simdisk_teardown(sddev + i, i, simdisk_procdir);
365	remove_proc_entry("simdisk", 0);
366	kfree(sddev);
367	unregister_blkdev(simdisk_major, "simdisk");
368	}
369	module_exit(simdisk_exit);
370
371	MODULE_ALIAS_BLOCKDEV_MAJOR(SIMDISK_MAJOR);
372
373	MODULE_LICENSE("GPL");