[people/ms/linux.git] / drivers / mtd / devices / slram.c

/*======================================================================

  This driver provides a method to access memory not used by the kernel
  itself (i.e. if the kernel commandline mem=xxx is used). To actually
  use slram at least mtdblock or mtdchar is required (for block or
  character device access).

  Usage:

  if compiled as loadable module:
    modprobe slram map=<name>,<start>,<end/offset>
  if statically linked into the kernel use the following kernel cmd.line
    slram=<name>,<start>,<end/offset>

  <name>: name of the device that will be listed in /proc/mtd
  <start>: start of the memory region, decimal or hex (0xabcdef)
  <end/offset>: end of the memory region. It's possible to use +0x1234
                to specify the offset instead of the absolute address

  NOTE:
  With slram it's only possible to map a contiguous memory region. Therefore
  if there's a device mapped somewhere in the region specified slram will
  fail to load (see kernel log if modprobe fails).

  -

  Jochen Schaeuble <psionic@psionic.de>

======================================================================*/


#include <linux/module.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/major.h>
#include <linux/fs.h>
#include <linux/ioctl.h>
#include <linux/init.h>
#include <linux/io.h>

#include <linux/mtd/mtd.h>

#define SLRAM_MAX_DEVICES_PARAMS 6		/* 3 parameters / device */
#define SLRAM_BLK_SZ 0x4000

#define T(fmt, args...) printk(KERN_DEBUG fmt, ## args)
#define E(fmt, args...) printk(KERN_NOTICE fmt, ## args)

typedef struct slram_priv {
	u_char *start;
	u_char *end;
} slram_priv_t;

typedef struct slram_mtd_list {
	struct mtd_info *mtdinfo;
	struct slram_mtd_list *next;
} slram_mtd_list_t;

#ifdef MODULE
static char *map[SLRAM_MAX_DEVICES_PARAMS];

module_param_array(map, charp, NULL, 0);
MODULE_PARM_DESC(map, "List of memory regions to map. \"map=<name>, <start>, <length / end>\"");
#else
static char *map;
#endif

static slram_mtd_list_t *slram_mtdlist = NULL;

static int slram_erase(struct mtd_info *, struct erase_info *);
static int slram_point(struct mtd_info *, loff_t, size_t, size_t *, void **,
		resource_size_t *);
static int slram_unpoint(struct mtd_info *, loff_t, size_t);
static int slram_read(struct mtd_info *, loff_t, size_t, size_t *, u_char *);
static int slram_write(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);

static int slram_erase(struct mtd_info *mtd, struct erase_info *instr)
{
	slram_priv_t *priv = mtd->priv;

	memset(priv->start + instr->addr, 0xff, instr->len);
	/* This'll catch a few races. Free the thing before returning :)
	 * I don't feel at all ashamed. This kind of thing is possible anyway
	 * with flash, but unlikely.
	 */
	instr->state = MTD_ERASE_DONE;
	mtd_erase_callback(instr);
	return(0);
}

static int slram_point(struct mtd_info *mtd, loff_t from, size_t len,
		size_t *retlen, void **virt, resource_size_t *phys)
{
	slram_priv_t *priv = mtd->priv;

	*virt = priv->start + from;
	*retlen = len;
	return(0);
}

static int slram_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
{
	return 0;
}

static int slram_read(struct mtd_info *mtd, loff_t from, size_t len,
		size_t *retlen, u_char *buf)
{
	slram_priv_t *priv = mtd->priv;

	memcpy(buf, priv->start + from, len);
	*retlen = len;
	return(0);
}

static int slram_write(struct mtd_info *mtd, loff_t to, size_t len,
		size_t *retlen, const u_char *buf)
{
	slram_priv_t *priv = mtd->priv;

	memcpy(priv->start + to, buf, len);
	*retlen = len;
	return(0);
}

/*====================================================================*/

static int register_device(char *name, unsigned long start, unsigned long length)
{
	slram_mtd_list_t **curmtd;

	curmtd = &slram_mtdlist;
	while (*curmtd) {
		curmtd = &(*curmtd)->next;
	}

	*curmtd = kmalloc(sizeof(slram_mtd_list_t), GFP_KERNEL);
	if (!(*curmtd)) {
		E("slram: Cannot allocate new MTD device.\n");
		return(-ENOMEM);
	}
	(*curmtd)->mtdinfo = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
	(*curmtd)->next = NULL;

	if ((*curmtd)->mtdinfo)	{
		(*curmtd)->mtdinfo->priv =
			kzalloc(sizeof(slram_priv_t), GFP_KERNEL);

		if (!(*curmtd)->mtdinfo->priv) {
			kfree((*curmtd)->mtdinfo);
			(*curmtd)->mtdinfo = NULL;
		}
	}

	if (!(*curmtd)->mtdinfo) {
		E("slram: Cannot allocate new MTD device.\n");
		return(-ENOMEM);
	}

	if (!(((slram_priv_t *)(*curmtd)->mtdinfo->priv)->start =
				ioremap(start, length))) {
		E("slram: ioremap failed\n");
		return -EIO;
	}
	((slram_priv_t *)(*curmtd)->mtdinfo->priv)->end =
		((slram_priv_t *)(*curmtd)->mtdinfo->priv)->start + length;


	(*curmtd)->mtdinfo->name = name;
	(*curmtd)->mtdinfo->size = length;
	(*curmtd)->mtdinfo->flags = MTD_CAP_RAM;
	(*curmtd)->mtdinfo->_erase = slram_erase;
	(*curmtd)->mtdinfo->_point = slram_point;
	(*curmtd)->mtdinfo->_unpoint = slram_unpoint;
	(*curmtd)->mtdinfo->_read = slram_read;
	(*curmtd)->mtdinfo->_write = slram_write;
	(*curmtd)->mtdinfo->owner = THIS_MODULE;
	(*curmtd)->mtdinfo->type = MTD_RAM;
	(*curmtd)->mtdinfo->erasesize = SLRAM_BLK_SZ;
	(*curmtd)->mtdinfo->writesize = 1;

	if (mtd_device_register((*curmtd)->mtdinfo, NULL, 0))	{
		E("slram: Failed to register new device\n");
		iounmap(((slram_priv_t *)(*curmtd)->mtdinfo->priv)->start);
		kfree((*curmtd)->mtdinfo->priv);
		kfree((*curmtd)->mtdinfo);
		return(-EAGAIN);
	}
	T("slram: Registered device %s from %luKiB to %luKiB\n", name,
			(start / 1024), ((start + length) / 1024));
	T("slram: Mapped from 0x%p to 0x%p\n",
			((slram_priv_t *)(*curmtd)->mtdinfo->priv)->start,
			((slram_priv_t *)(*curmtd)->mtdinfo->priv)->end);
	return(0);
}

static void unregister_devices(void)
{
	slram_mtd_list_t *nextitem;

	while (slram_mtdlist) {
		nextitem = slram_mtdlist->next;
		mtd_device_unregister(slram_mtdlist->mtdinfo);
		iounmap(((slram_priv_t *)slram_mtdlist->mtdinfo->priv)->start);
		kfree(slram_mtdlist->mtdinfo->priv);
		kfree(slram_mtdlist->mtdinfo);
		kfree(slram_mtdlist);
		slram_mtdlist = nextitem;
	}
}

static unsigned long handle_unit(unsigned long value, char *unit)
{
	if ((*unit == 'M') || (*unit == 'm')) {
		return(value * 1024 * 1024);
	} else if ((*unit == 'K') || (*unit == 'k')) {
		return(value * 1024);
	}
	return(value);
}

static int parse_cmdline(char *devname, char *szstart, char *szlength)
{
	char *buffer;
	unsigned long devstart;
	unsigned long devlength;

	if ((!devname) || (!szstart) || (!szlength)) {
		unregister_devices();
		return(-EINVAL);
	}

	devstart = simple_strtoul(szstart, &buffer, 0);
	devstart = handle_unit(devstart, buffer);

	if (*(szlength) != '+') {
		devlength = simple_strtoul(szlength, &buffer, 0);
		devlength = handle_unit(devlength, buffer);
		if (devlength < devstart)
			goto err_out;

		devlength -= devstart;
	} else {
		devlength = simple_strtoul(szlength + 1, &buffer, 0);
		devlength = handle_unit(devlength, buffer);
	}
	T("slram: devname=%s, devstart=0x%lx, devlength=0x%lx\n",
			devname, devstart, devlength);
	if (devlength % SLRAM_BLK_SZ != 0)
		goto err_out;

	if ((devstart = register_device(devname, devstart, devlength))){
		unregister_devices();
		return((int)devstart);
	}
	return(0);

err_out:
	E("slram: Illegal length parameter.\n");
	return(-EINVAL);
}

#ifndef MODULE

static int __init mtd_slram_setup(char *str)
{
	map = str;
	return(1);
}

__setup("slram=", mtd_slram_setup);

#endif

static int __init init_slram(void)
{
	char *devname;

#ifndef MODULE
	char *devstart;
	char *devlength;

	if (!map) {
		E("slram: not enough parameters.\n");
		return(-EINVAL);
	}
	while (map) {
		devname = devstart = devlength = NULL;

		if (!(devname = strsep(&map, ","))) {
			E("slram: No devicename specified.\n");
			break;
		}
		T("slram: devname = %s\n", devname);
		if ((!map) || (!(devstart = strsep(&map, ",")))) {
			E("slram: No devicestart specified.\n");
		}
		T("slram: devstart = %s\n", devstart);
		if ((!map) || (!(devlength = strsep(&map, ",")))) {
			E("slram: No devicelength / -end specified.\n");
		}
		T("slram: devlength = %s\n", devlength);
		if (parse_cmdline(devname, devstart, devlength) != 0) {
			return(-EINVAL);
		}
	}
#else
	int count;
	int i;

	for (count = 0; count < SLRAM_MAX_DEVICES_PARAMS && map[count];
			count++) {
	}

	if ((count % 3 != 0) || (count == 0)) {
		E("slram: not enough parameters.\n");
		return(-EINVAL);
	}
	for (i = 0; i < (count / 3); i++) {
		devname = map[i * 3];

		if (parse_cmdline(devname, map[i * 3 + 1], map[i * 3 + 2])!=0) {
			return(-EINVAL);
		}

	}
#endif /* !MODULE */

	return(0);
}

static void __exit cleanup_slram(void)
{
	unregister_devices();
}

module_init(init_slram);
module_exit(cleanup_slram);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jochen Schaeuble <psionic@psionic.de>");
MODULE_DESCRIPTION("MTD driver for uncached system RAM");
Commit	Line	Data
1da177e4 LT	1	/*======================================================================
1da177e4 LT	2
1da177e4 LT	3	This driver provides a method to access memory not used by the kernel
	4	itself (i.e. if the kernel commandline mem=xxx is used). To actually
	5	use slram at least mtdblock or mtdchar is required (for block or
	6	character device access).
	7
	8	Usage:
	9
	10	if compiled as loadable module:
	11	modprobe slram map=<name>,<start>,<end/offset>
	12	if statically linked into the kernel use the following kernel cmd.line
	13	slram=<name>,<start>,<end/offset>
	14
	15	<name>: name of the device that will be listed in /proc/mtd
	16	<start>: start of the memory region, decimal or hex (0xabcdef)
	17	<end/offset>: end of the memory region. It's possible to use +0x1234
	18	to specify the offset instead of the absolute address
e5580fbe	19
1da177e4	20	NOTE:
af901ca1	21	With slram it's only possible to map a contiguous memory region. Therefore
1da177e4 LT	22	if there's a device mapped somewhere in the region specified slram will
	23	fail to load (see kernel log if modprobe fails).
	24
	25	-
e5580fbe	26
1da177e4 LT	27	Jochen Schaeuble <psionic@psionic.de>
	28
	29	======================================================================*/
	30
	31
	32	#include <linux/module.h>
7c0f6ba6	33	#include <linux/uaccess.h>
1da177e4 LT	34	#include <linux/types.h>
1da177e4 LT	35	#include <linux/kernel.h>
1da177e4 LT	36	#include <linux/ptrace.h>
	37	#include <linux/slab.h>
	38	#include <linux/string.h>
	39	#include <linux/timer.h>
	40	#include <linux/major.h>
	41	#include <linux/fs.h>
	42	#include <linux/ioctl.h>
	43	#include <linux/init.h>
2584cf83	44	#include <linux/io.h>
1da177e4 LT	45
	46	#include <linux/mtd/mtd.h>
	47
	48	#define SLRAM_MAX_DEVICES_PARAMS 6 /* 3 parameters / device */
14f8351a	49	#define SLRAM_BLK_SZ 0x4000
1da177e4 LT	50
	51	#define T(fmt, args...) printk(KERN_DEBUG fmt, ## args)
	52	#define E(fmt, args...) printk(KERN_NOTICE fmt, ## args)
	53
	54	typedef struct slram_priv {
	55	u_char *start;
	56	u_char *end;
	57	} slram_priv_t;
	58
	59	typedef struct slram_mtd_list {
	60	struct mtd_info *mtdinfo;
	61	struct slram_mtd_list *next;
	62	} slram_mtd_list_t;
	63
	64	#ifdef MODULE
	65	static char *map[SLRAM_MAX_DEVICES_PARAMS];
	66
	67	module_param_array(map, charp, NULL, 0);
	68	MODULE_PARM_DESC(map, "List of memory regions to map. \"map=<name>, <start>, <length / end>\"");
	69	#else
	70	static char *map;
	71	#endif
	72
	73	static slram_mtd_list_t *slram_mtdlist = NULL;
	74
	75	static int slram_erase(struct mtd_info , struct erase_info );
a98889f3 JH	76	static int slram_point(struct mtd_info , loff_t, size_t, size_t , void **,
a98889f3 JH	77	resource_size_t *);
5e4e6e3f	78	static int slram_unpoint(struct mtd_info *, loff_t, size_t);
1da177e4 LT	79	static int slram_read(struct mtd_info , loff_t, size_t, size_t , u_char *);
	80	static int slram_write(struct mtd_info , loff_t, size_t, size_t , const u_char *);
	81
	82	static int slram_erase(struct mtd_info mtd, struct erase_info instr)
	83	{
	84	slram_priv_t *priv = mtd->priv;
	85
1da177e4	86	memset(priv->start + instr->addr, 0xff, instr->len);
e5580fbe	87	/* This'll catch a few races. Free the thing before returning :)
1da177e4 LT	88	* I don't feel at all ashamed. This kind of thing is possible anyway
	89	* with flash, but unlikely.
	90	*/
1da177e4	91	instr->state = MTD_ERASE_DONE;
1da177e4	92	mtd_erase_callback(instr);
1da177e4 LT	93	return(0);
	94	}
	95
	96	static int slram_point(struct mtd_info *mtd, loff_t from, size_t len,
a98889f3	97	size_t retlen, void virt, resource_size_t phys)
1da177e4 LT	98	{
	99	slram_priv_t *priv = mtd->priv;
	100
a98889f3	101	*virt = priv->start + from;
1da177e4 LT	102	*retlen = len;
	103	return(0);
	104	}
	105
5e4e6e3f	106	static int slram_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
1da177e4	107	{
5e4e6e3f	108	return 0;
1da177e4 LT	109	}
	110
	111	static int slram_read(struct mtd_info *mtd, loff_t from, size_t len,
	112	size_t retlen, u_char buf)
	113	{
	114	slram_priv_t *priv = mtd->priv;
14f8351a	115
1da177e4	116	memcpy(buf, priv->start + from, len);
1da177e4 LT	117	*retlen = len;
	118	return(0);
	119	}
	120
	121	static int slram_write(struct mtd_info *mtd, loff_t to, size_t len,
	122	size_t retlen, const u_char buf)
	123	{
	124	slram_priv_t *priv = mtd->priv;
	125
	126	memcpy(priv->start + to, buf, len);
1da177e4 LT	127	*retlen = len;
	128	return(0);
	129	}
	130
	131	/====================================================================/
	132
	133	static int register_device(char *name, unsigned long start, unsigned long length)
	134	{
	135	slram_mtd_list_t **curmtd;
	136
	137	curmtd = &slram_mtdlist;
	138	while (*curmtd) {
	139	curmtd = &(*curmtd)->next;
	140	}
	141
	142	*curmtd = kmalloc(sizeof(slram_mtd_list_t), GFP_KERNEL);
	143	if (!(*curmtd)) {
	144	E("slram: Cannot allocate new MTD device.\n");
	145	return(-ENOMEM);
	146	}
95b93a0c	147	(*curmtd)->mtdinfo = kzalloc(sizeof(struct mtd_info), GFP_KERNEL);
1da177e4	148	(*curmtd)->next = NULL;
e5580fbe	149
1da177e4	150	if ((*curmtd)->mtdinfo) {
1da177e4	151	(*curmtd)->mtdinfo->priv =
95b93a0c	152	kzalloc(sizeof(slram_priv_t), GFP_KERNEL);
e5580fbe	153
1da177e4 LT	154	if (!(*curmtd)->mtdinfo->priv) {
	155	kfree((*curmtd)->mtdinfo);
	156	(*curmtd)->mtdinfo = NULL;
1da177e4 LT	157	}
	158	}
	159
	160	if (!(*curmtd)->mtdinfo) {
	161	E("slram: Cannot allocate new MTD device.\n");
	162	return(-ENOMEM);
	163	}
e5580fbe	164
1da177e4 LT	165	if (!(((slram_priv_t )(curmtd)->mtdinfo->priv)->start =
	166	ioremap(start, length))) {
	167	E("slram: ioremap failed\n");
	168	return -EIO;
	169	}
	170	((slram_priv_t )(curmtd)->mtdinfo->priv)->end =
	171	((slram_priv_t )(curmtd)->mtdinfo->priv)->start + length;
	172
	173
	174	(*curmtd)->mtdinfo->name = name;
	175	(*curmtd)->mtdinfo->size = length;
a6c591ed	176	(*curmtd)->mtdinfo->flags = MTD_CAP_RAM;
3c3c10bb AB	177	(*curmtd)->mtdinfo->_erase = slram_erase;
	178	(*curmtd)->mtdinfo->_point = slram_point;
	179	(*curmtd)->mtdinfo->_unpoint = slram_unpoint;
	180	(*curmtd)->mtdinfo->_read = slram_read;
	181	(*curmtd)->mtdinfo->_write = slram_write;
1da177e4	182	(*curmtd)->mtdinfo->owner = THIS_MODULE;
21c8db9e	183	(*curmtd)->mtdinfo->type = MTD_RAM;
14f8351a	184	(*curmtd)->mtdinfo->erasesize = SLRAM_BLK_SZ;
17ffc7ba	185	(*curmtd)->mtdinfo->writesize = 1;
1da177e4	186
ee0e87b1	187	if (mtd_device_register((*curmtd)->mtdinfo, NULL, 0)) {
1da177e4 LT	188	E("slram: Failed to register new device\n");
	189	iounmap(((slram_priv_t )(curmtd)->mtdinfo->priv)->start);
	190	kfree((*curmtd)->mtdinfo->priv);
	191	kfree((*curmtd)->mtdinfo);
	192	return(-EAGAIN);
	193	}
	194	T("slram: Registered device %s from %luKiB to %luKiB\n", name,
	195	(start / 1024), ((start + length) / 1024));
	196	T("slram: Mapped from 0x%p to 0x%p\n",
	197	((slram_priv_t )(curmtd)->mtdinfo->priv)->start,
	198	((slram_priv_t )(curmtd)->mtdinfo->priv)->end);
e5580fbe	199	return(0);
1da177e4 LT	200	}
	201
	202	static void unregister_devices(void)
	203	{
	204	slram_mtd_list_t *nextitem;
	205
	206	while (slram_mtdlist) {
	207	nextitem = slram_mtdlist->next;
ee0e87b1	208	mtd_device_unregister(slram_mtdlist->mtdinfo);
1da177e4 LT	209	iounmap(((slram_priv_t *)slram_mtdlist->mtdinfo->priv)->start);
	210	kfree(slram_mtdlist->mtdinfo->priv);
	211	kfree(slram_mtdlist->mtdinfo);
	212	kfree(slram_mtdlist);
	213	slram_mtdlist = nextitem;
	214	}
	215	}
	216
	217	static unsigned long handle_unit(unsigned long value, char *unit)
	218	{
	219	if ((unit == 'M') \|\| (unit == 'm')) {
	220	return(value * 1024 * 1024);
	221	} else if ((unit == 'K') \|\| (unit == 'k')) {
	222	return(value * 1024);
	223	}
	224	return(value);
	225	}
	226
	227	static int parse_cmdline(char devname, char szstart, char *szlength)
	228	{
	229	char *buffer;
	230	unsigned long devstart;
	231	unsigned long devlength;
e5580fbe	232
1da177e4 LT	233	if ((!devname) \|\| (!szstart) \|\| (!szlength)) {
	234	unregister_devices();
	235	return(-EINVAL);
	236	}
	237
	238	devstart = simple_strtoul(szstart, &buffer, 0);
	239	devstart = handle_unit(devstart, buffer);
e5580fbe	240
1da177e4 LT	241	if (*(szlength) != '+') {
1da177e4 LT	242	devlength = simple_strtoul(szlength, &buffer, 0);
c36a7ff4	243	devlength = handle_unit(devlength, buffer);
3afd522d RK	244	if (devlength < devstart)
	245	goto err_out;
	246
	247	devlength -= devstart;
1da177e4 LT	248	} else {
	249	devlength = simple_strtoul(szlength + 1, &buffer, 0);
	250	devlength = handle_unit(devlength, buffer);
	251	}
	252	T("slram: devname=%s, devstart=0x%lx, devlength=0x%lx\n",
	253	devname, devstart, devlength);
3afd522d RK	254	if (devlength % SLRAM_BLK_SZ != 0)
3afd522d RK	255	goto err_out;
e5580fbe	256
1da177e4 LT	257	if ((devstart = register_device(devname, devstart, devlength))){
	258	unregister_devices();
	259	return((int)devstart);
	260	}
	261	return(0);
3afd522d RK	262
	263	err_out:
	264	E("slram: Illegal length parameter.\n");
	265	return(-EINVAL);
1da177e4 LT	266	}
	267
	268	#ifndef MODULE
	269
	270	static int __init mtd_slram_setup(char *str)
	271	{
	272	map = str;
	273	return(1);
	274	}
	275
	276	__setup("slram=", mtd_slram_setup);
	277
	278	#endif
	279
627df23c	280	static int __init init_slram(void)
1da177e4 LT	281	{
1da177e4 LT	282	char *devname;
1da177e4 LT	283
	284	#ifndef MODULE
	285	char *devstart;
	286	char *devlength;
	287
1da177e4 LT	288	if (!map) {
	289	E("slram: not enough parameters.\n");
	290	return(-EINVAL);
	291	}
	292	while (map) {
	293	devname = devstart = devlength = NULL;
	294
	295	if (!(devname = strsep(&map, ","))) {
	296	E("slram: No devicename specified.\n");
	297	break;
	298	}
	299	T("slram: devname = %s\n", devname);
	300	if ((!map) \|\| (!(devstart = strsep(&map, ",")))) {
	301	E("slram: No devicestart specified.\n");
	302	}
	303	T("slram: devstart = %s\n", devstart);
	304	if ((!map) \|\| (!(devlength = strsep(&map, ",")))) {
	305	E("slram: No devicelength / -end specified.\n");
	306	}
	307	T("slram: devlength = %s\n", devlength);
	308	if (parse_cmdline(devname, devstart, devlength) != 0) {
	309	return(-EINVAL);
	310	}
	311	}
	312	#else
	313	int count;
ed491d20	314	int i;
e5580fbe	315
269c0ee6	316	for (count = 0; count < SLRAM_MAX_DEVICES_PARAMS && map[count];
1da177e4 LT	317	count++) {
	318	}
	319
	320	if ((count % 3 != 0) \|\| (count == 0)) {
	321	E("slram: not enough parameters.\n");
	322	return(-EINVAL);
	323	}
	324	for (i = 0; i < (count / 3); i++) {
	325	devname = map[i * 3];
	326
	327	if (parse_cmdline(devname, map[i * 3 + 1], map[i * 3 + 2])!=0) {
	328	return(-EINVAL);
	329	}
e5580fbe	330
1da177e4 LT	331	}
1da177e4 LT	332	#endif /* !MODULE */
e5580fbe	333
1da177e4 LT	334	return(0);
	335	}
	336
	337	static void __exit cleanup_slram(void)
	338	{
	339	unregister_devices();
	340	}
	341
	342	module_init(init_slram);
	343	module_exit(cleanup_slram);
	344
	345	MODULE_LICENSE("GPL");
	346	MODULE_AUTHOR("Jochen Schaeuble <psionic@psionic.de>");
	347	MODULE_DESCRIPTION("MTD driver for uncached system RAM");