[linux-2.6-block.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 <linux/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);
		READ_ONCE(*buffer);
		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 = kmap_atomic(bvec.bv_page) + bvec.bv_offset;
		unsigned len = bvec.bv_len >> SECTOR_SHIFT;

		simdisk_transfer(dev, sector, len, buffer,
				bio_data_dir(bio) == WRITE);
		sector += len;
		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_array(simdisk_count, sizeof(*sddev), 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>
7c0f6ba6	20	#include <linux/uaccess.h>
b6c7e873 VP	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);
549409b4	89	READ_ONCE(*buffer);
b6c7e873 VP	90	if (write)
	91	io = simc_write(dev->fd, buffer, nbytes);
	92	else
	93	io = simc_read(dev->fd, buffer, nbytes);
	94	if (io == -1) {
	95	pr_err("SIMDISK: IO error %d\n", errno);
	96	break;
	97	}
	98	buffer += io;
	99	offset += io;
	100	nbytes -= io;
	101	}
	102	spin_unlock(&dev->lock);
	103	}
	104
dece1635	105	static blk_qc_t simdisk_make_request(struct request_queue q, struct bio bio)
b6c7e873	106	{
4246a0b6	107	struct simdisk *dev = q->queuedata;
675675ad JA	108	struct bio_vec bvec;
	109	struct bvec_iter iter;
	110	sector_t sector = bio->bi_iter.bi_sector;
b6c7e873	111
675675ad	112	bio_for_each_segment(bvec, bio, iter) {
d004a5e7	113	char *buffer = kmap_atomic(bvec.bv_page) + bvec.bv_offset;
675675ad	114	unsigned len = bvec.bv_len >> SECTOR_SHIFT;
b6c7e873 VP	115
	116	simdisk_transfer(dev, sector, len, buffer,
	117	bio_data_dir(bio) == WRITE);
	118	sector += len;
0e78eccc	119	kunmap_atomic(buffer);
b6c7e873	120	}
b6c7e873	121
4246a0b6	122	bio_endio(bio);
dece1635	123	return BLK_QC_T_NONE;
b6c7e873 VP	124	}
b6c7e873 VP	125
b6c7e873 VP	126	static int simdisk_open(struct block_device *bdev, fmode_t mode)
	127	{
	128	struct simdisk *dev = bdev->bd_disk->private_data;
	129
	130	spin_lock(&dev->lock);
	131	if (!dev->users)
	132	check_disk_change(bdev);
	133	++dev->users;
	134	spin_unlock(&dev->lock);
	135	return 0;
	136	}
	137
db2a144b	138	static void simdisk_release(struct gendisk *disk, fmode_t mode)
b6c7e873 VP	139	{
	140	struct simdisk *dev = disk->private_data;
	141	spin_lock(&dev->lock);
	142	--dev->users;
	143	spin_unlock(&dev->lock);
b6c7e873 VP	144	}
	145
	146	static const struct block_device_operations simdisk_ops = {
	147	.owner = THIS_MODULE,
	148	.open = simdisk_open,
	149	.release = simdisk_release,
	150	};
	151
	152	static struct simdisk *sddev;
	153	static struct proc_dir_entry *simdisk_procdir;
	154
	155	static int simdisk_attach(struct simdisk dev, const char filename)
	156	{
	157	int err = 0;
	158
	159	filename = kstrdup(filename, GFP_KERNEL);
	160	if (filename == NULL)
	161	return -ENOMEM;
	162
	163	spin_lock(&dev->lock);
	164
	165	if (dev->fd != -1) {
	166	err = -EBUSY;
	167	goto out;
	168	}
	169	dev->fd = simc_open(filename, O_RDWR, 0);
	170	if (dev->fd == -1) {
	171	pr_err("SIMDISK: Can't open %s: %d\n", filename, errno);
	172	err = -ENODEV;
	173	goto out;
	174	}
f4b93ba9	175	dev->size = simc_lseek(dev->fd, 0, SEEK_END);
b6c7e873 VP	176	set_capacity(dev->gd, dev->size >> SECTOR_SHIFT);
	177	dev->filename = filename;
	178	pr_info("SIMDISK: %s=%s\n", dev->gd->disk_name, dev->filename);
	179	out:
	180	if (err)
	181	kfree(filename);
	182	spin_unlock(&dev->lock);
	183
	184	return err;
	185	}
	186
	187	static int simdisk_detach(struct simdisk *dev)
	188	{
	189	int err = 0;
	190
	191	spin_lock(&dev->lock);
	192
	193	if (dev->users != 0) {
	194	err = -EBUSY;
	195	} else if (dev->fd != -1) {
	196	if (simc_close(dev->fd)) {
	197	pr_err("SIMDISK: error closing %s: %d\n",
	198	dev->filename, errno);
	199	err = -EIO;
	200	} else {
	201	pr_info("SIMDISK: %s detached from %s\n",
	202	dev->gd->disk_name, dev->filename);
	203	dev->fd = -1;
	204	kfree(dev->filename);
	205	dev->filename = NULL;
	206	}
	207	}
	208	spin_unlock(&dev->lock);
	209	return err;
	210	}
	211
a69755b1 AV	212	static ssize_t proc_read_simdisk(struct file file, char __user buf,
a69755b1 AV	213	size_t size, loff_t *ppos)
b6c7e873	214	{
d9dda78b	215	struct simdisk *dev = PDE_DATA(file_inode(file));
0757f615	216	const char *s = dev->filename;
a69755b1 AV	217	if (s) {
	218	ssize_t n = simple_read_from_buffer(buf, size, ppos,
	219	s, strlen(s));
	220	if (n < 0)
	221	return n;
	222	buf += n;
	223	size -= n;
	224	}
	225	return simple_read_from_buffer(buf, size, ppos, "\n", 1);
b6c7e873 VP	226	}
b6c7e873 VP	227
a69755b1	228	static ssize_t proc_write_simdisk(struct file file, const char __user buf,
4fe56e80	229	size_t count, loff_t *ppos)
b6c7e873	230	{
16e5c1fc	231	char *tmp = memdup_user_nul(buf, count);
d9dda78b	232	struct simdisk *dev = PDE_DATA(file_inode(file));
b6c7e873 VP	233	int err;
b6c7e873 VP	234
16e5c1fc AV	235	if (IS_ERR(tmp))
16e5c1fc AV	236	return PTR_ERR(tmp);
b6c7e873 VP	237
	238	err = simdisk_detach(dev);
	239	if (err != 0)
	240	goto out_free;
	241
	242	if (count > 0 && tmp[count - 1] == '\n')
	243	tmp[count - 1] = 0;
b6c7e873 VP	244
	245	if (tmp[0])
	246	err = simdisk_attach(dev, tmp);
	247
	248	if (err == 0)
	249	err = count;
	250	out_free:
	251	kfree(tmp);
	252	return err;
	253	}
	254
a69755b1 AV	255	static const struct file_operations fops = {
	256	.read = proc_read_simdisk,
	257	.write = proc_write_simdisk,
	258	.llseek = default_llseek,
	259	};
	260
b6c7e873 VP	261	static int __init simdisk_setup(struct simdisk *dev, int which,
	262	struct proc_dir_entry *procdir)
	263	{
	264	char tmp[2] = { '0' + which, 0 };
	265
	266	dev->fd = -1;
	267	dev->filename = NULL;
	268	spin_lock_init(&dev->lock);
	269	dev->users = 0;
	270
	271	dev->queue = blk_alloc_queue(GFP_KERNEL);
	272	if (dev->queue == NULL) {
	273	pr_err("blk_alloc_queue failed\n");
	274	goto out_alloc_queue;
	275	}
	276
	277	blk_queue_make_request(dev->queue, simdisk_make_request);
	278	dev->queue->queuedata = dev;
	279
	280	dev->gd = alloc_disk(SIMDISK_MINORS);
	281	if (dev->gd == NULL) {
	282	pr_err("alloc_disk failed\n");
	283	goto out_alloc_disk;
	284	}
	285	dev->gd->major = simdisk_major;
	286	dev->gd->first_minor = which;
	287	dev->gd->fops = &simdisk_ops;
	288	dev->gd->queue = dev->queue;
	289	dev->gd->private_data = dev;
	290	snprintf(dev->gd->disk_name, 32, "simdisk%d", which);
	291	set_capacity(dev->gd, 0);
	292	add_disk(dev->gd);
	293
a69755b1	294	dev->procfile = proc_create_data(tmp, 0644, procdir, &fops, dev);
b6c7e873 VP	295	return 0;
	296
	297	out_alloc_disk:
	298	blk_cleanup_queue(dev->queue);
	299	dev->queue = NULL;
	300	out_alloc_queue:
	301	simc_close(dev->fd);
	302	return -EIO;
	303	}
	304
	305	static int __init simdisk_init(void)
	306	{
	307	int i;
	308
	309	if (register_blkdev(simdisk_major, "simdisk") < 0) {
	310	pr_err("SIMDISK: register_blkdev: %d\n", simdisk_major);
	311	return -EIO;
	312	}
	313	pr_info("SIMDISK: major: %d\n", simdisk_major);
	314
	315	if (n_files > simdisk_count)
	316	simdisk_count = n_files;
	317	if (simdisk_count > MAX_SIMDISK_COUNT)
	318	simdisk_count = MAX_SIMDISK_COUNT;
	319
5e78e465	320	sddev = kmalloc_array(simdisk_count, sizeof(*sddev), GFP_KERNEL);
b6c7e873 VP	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");