[deliverable/linux.git] / drivers / mtd / maps / cdb89712.c

/*
 * Flash on Cirrus CDB89712
 *
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/ioport.h>
#include <linux/init.h>
#include <asm/io.h>
#include <mach/hardware.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/map.h>
#include <linux/mtd/partitions.h>

/* dynamic ioremap() areas */
#define FLASH_START      0x00000000
#define FLASH_SIZE       0x800000
#define FLASH_WIDTH      4

#define SRAM_START       0x60000000
#define SRAM_SIZE        0xc000
#define SRAM_WIDTH       4

#define BOOTROM_START    0x70000000
#define BOOTROM_SIZE     0x80
#define BOOTROM_WIDTH    4


static struct mtd_info *flash_mtd;

struct map_info cdb89712_flash_map = {
	.name = "flash",
	.size = FLASH_SIZE,
	.bankwidth = FLASH_WIDTH,
	.phys = FLASH_START,
};

struct resource cdb89712_flash_resource = {
	.name =   "Flash",
	.start =  FLASH_START,
	.end =    FLASH_START + FLASH_SIZE - 1,
	.flags =  IORESOURCE_IO | IORESOURCE_BUSY,
};

static int __init init_cdb89712_flash (void)
{
	int err;

	if (request_resource (&ioport_resource, &cdb89712_flash_resource)) {
		printk(KERN_NOTICE "Failed to reserve Cdb89712 FLASH space\n");
		err = -EBUSY;
		goto out;
	}

	cdb89712_flash_map.virt = ioremap(FLASH_START, FLASH_SIZE);
	if (!cdb89712_flash_map.virt) {
		printk(KERN_NOTICE "Failed to ioremap Cdb89712 FLASH space\n");
		err = -EIO;
		goto out_resource;
	}
	simple_map_init(&cdb89712_flash_map);
	flash_mtd = do_map_probe("cfi_probe", &cdb89712_flash_map);
	if (!flash_mtd) {
		flash_mtd = do_map_probe("map_rom", &cdb89712_flash_map);
		if (flash_mtd)
			flash_mtd->erasesize = 0x10000;
	}
	if (!flash_mtd) {
		printk("FLASH probe failed\n");
		err = -ENXIO;
		goto out_ioremap;
	}

	flash_mtd->owner = THIS_MODULE;

	if (add_mtd_device(flash_mtd)) {
		printk("FLASH device addition failed\n");
		err = -ENOMEM;
		goto out_probe;
	}

	return 0;

out_probe:
	map_destroy(flash_mtd);
	flash_mtd = 0;
out_ioremap:
	iounmap((void *)cdb89712_flash_map.virt);
out_resource:
	release_resource (&cdb89712_flash_resource);
out:
	return err;
}


static struct mtd_info *sram_mtd;

struct map_info cdb89712_sram_map = {
	.name = "SRAM",
	.size = SRAM_SIZE,
	.bankwidth = SRAM_WIDTH,
	.phys = SRAM_START,
};

struct resource cdb89712_sram_resource = {
	.name =   "SRAM",
	.start =  SRAM_START,
	.end =    SRAM_START + SRAM_SIZE - 1,
	.flags =  IORESOURCE_IO | IORESOURCE_BUSY,
};

static int __init init_cdb89712_sram (void)
{
	int err;

	if (request_resource (&ioport_resource, &cdb89712_sram_resource)) {
		printk(KERN_NOTICE "Failed to reserve Cdb89712 SRAM space\n");
		err = -EBUSY;
		goto out;
	}

	cdb89712_sram_map.virt = ioremap(SRAM_START, SRAM_SIZE);
	if (!cdb89712_sram_map.virt) {
		printk(KERN_NOTICE "Failed to ioremap Cdb89712 SRAM space\n");
		err = -EIO;
		goto out_resource;
	}
	simple_map_init(&cdb89712_sram_map);
	sram_mtd = do_map_probe("map_ram", &cdb89712_sram_map);
	if (!sram_mtd) {
		printk("SRAM probe failed\n");
		err = -ENXIO;
		goto out_ioremap;
	}

	sram_mtd->owner = THIS_MODULE;
	sram_mtd->erasesize = 16;

	if (add_mtd_device(sram_mtd)) {
		printk("SRAM device addition failed\n");
		err = -ENOMEM;
		goto out_probe;
	}

	return 0;

out_probe:
	map_destroy(sram_mtd);
	sram_mtd = 0;
out_ioremap:
	iounmap((void *)cdb89712_sram_map.virt);
out_resource:
	release_resource (&cdb89712_sram_resource);
out:
	return err;
}


static struct mtd_info *bootrom_mtd;

struct map_info cdb89712_bootrom_map = {
	.name = "BootROM",
	.size = BOOTROM_SIZE,
	.bankwidth = BOOTROM_WIDTH,
	.phys = BOOTROM_START,
};

struct resource cdb89712_bootrom_resource = {
	.name =   "BootROM",
	.start =  BOOTROM_START,
	.end =    BOOTROM_START + BOOTROM_SIZE - 1,
	.flags =  IORESOURCE_IO | IORESOURCE_BUSY,
};

static int __init init_cdb89712_bootrom (void)
{
	int err;

	if (request_resource (&ioport_resource, &cdb89712_bootrom_resource)) {
		printk(KERN_NOTICE "Failed to reserve Cdb89712 BOOTROM space\n");
		err = -EBUSY;
		goto out;
	}

	cdb89712_bootrom_map.virt = ioremap(BOOTROM_START, BOOTROM_SIZE);
	if (!cdb89712_bootrom_map.virt) {
		printk(KERN_NOTICE "Failed to ioremap Cdb89712 BootROM space\n");
		err = -EIO;
		goto out_resource;
	}
	simple_map_init(&cdb89712_bootrom_map);
	bootrom_mtd = do_map_probe("map_rom", &cdb89712_bootrom_map);
	if (!bootrom_mtd) {
		printk("BootROM probe failed\n");
		err = -ENXIO;
		goto out_ioremap;
	}

	bootrom_mtd->owner = THIS_MODULE;
	bootrom_mtd->erasesize = 0x10000;

	if (add_mtd_device(bootrom_mtd)) {
		printk("BootROM device addition failed\n");
		err = -ENOMEM;
		goto out_probe;
	}

	return 0;

out_probe:
	map_destroy(bootrom_mtd);
	bootrom_mtd = 0;
out_ioremap:
	iounmap((void *)cdb89712_bootrom_map.virt);
out_resource:
	release_resource (&cdb89712_bootrom_resource);
out:
	return err;
}


static int __init init_cdb89712_maps(void)
{

       	printk(KERN_INFO "Cirrus CDB89712 MTD mappings:\n  Flash 0x%x at 0x%x\n  SRAM 0x%x at 0x%x\n  BootROM 0x%x at 0x%x\n",
	       FLASH_SIZE, FLASH_START, SRAM_SIZE, SRAM_START, BOOTROM_SIZE, BOOTROM_START);

	init_cdb89712_flash();
	init_cdb89712_sram();
	init_cdb89712_bootrom();

	return 0;
}


static void __exit cleanup_cdb89712_maps(void)
{
	if (sram_mtd) {
		del_mtd_device(sram_mtd);
		map_destroy(sram_mtd);
		iounmap((void *)cdb89712_sram_map.virt);
		release_resource (&cdb89712_sram_resource);
	}

	if (flash_mtd) {
		del_mtd_device(flash_mtd);
		map_destroy(flash_mtd);
		iounmap((void *)cdb89712_flash_map.virt);
		release_resource (&cdb89712_flash_resource);
	}

	if (bootrom_mtd) {
		del_mtd_device(bootrom_mtd);
		map_destroy(bootrom_mtd);
		iounmap((void *)cdb89712_bootrom_map.virt);
		release_resource (&cdb89712_bootrom_resource);
	}
}

module_init(init_cdb89712_maps);
module_exit(cleanup_cdb89712_maps);

MODULE_AUTHOR("Ray L");
MODULE_DESCRIPTION("ARM CDB89712 map driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Flash on Cirrus CDB89712
	3	*
1da177e4 LT	4	*/
	5
	6	#include <linux/module.h>
	7	#include <linux/types.h>
	8	#include <linux/kernel.h>
	9	#include <linux/ioport.h>
	10	#include <linux/init.h>
	11	#include <asm/io.h>
a09e64fb	12	#include <mach/hardware.h>
1da177e4 LT	13	#include <linux/mtd/mtd.h>
	14	#include <linux/mtd/map.h>
	15	#include <linux/mtd/partitions.h>
	16
8959dabd	17	/* dynamic ioremap() areas */
d9a682a5 RK	18	#define FLASH_START 0x00000000
	19	#define FLASH_SIZE 0x800000
	20	#define FLASH_WIDTH 4
1da177e4	21
8959dabd RK	22	#define SRAM_START 0x60000000
	23	#define SRAM_SIZE 0xc000
	24	#define SRAM_WIDTH 4
	25
	26	#define BOOTROM_START 0x70000000
	27	#define BOOTROM_SIZE 0x80
	28	#define BOOTROM_WIDTH 4
	29
	30
1da177e4 LT	31	static struct mtd_info *flash_mtd;
	32
	33	struct map_info cdb89712_flash_map = {
	34	.name = "flash",
	35	.size = FLASH_SIZE,
	36	.bankwidth = FLASH_WIDTH,
	37	.phys = FLASH_START,
	38	};
	39
	40	struct resource cdb89712_flash_resource = {
	41	.name = "Flash",
	42	.start = FLASH_START,
	43	.end = FLASH_START + FLASH_SIZE - 1,
	44	.flags = IORESOURCE_IO \| IORESOURCE_BUSY,
	45	};
	46
	47	static int __init init_cdb89712_flash (void)
	48	{
	49	int err;
69f34c98	50
1da177e4 LT	51	if (request_resource (&ioport_resource, &cdb89712_flash_resource)) {
	52	printk(KERN_NOTICE "Failed to reserve Cdb89712 FLASH space\n");
	53	err = -EBUSY;
	54	goto out;
	55	}
69f34c98	56
1da177e4 LT	57	cdb89712_flash_map.virt = ioremap(FLASH_START, FLASH_SIZE);
	58	if (!cdb89712_flash_map.virt) {
	59	printk(KERN_NOTICE "Failed to ioremap Cdb89712 FLASH space\n");
	60	err = -EIO;
	61	goto out_resource;
	62	}
	63	simple_map_init(&cdb89712_flash_map);
	64	flash_mtd = do_map_probe("cfi_probe", &cdb89712_flash_map);
	65	if (!flash_mtd) {
	66	flash_mtd = do_map_probe("map_rom", &cdb89712_flash_map);
	67	if (flash_mtd)
	68	flash_mtd->erasesize = 0x10000;
	69	}
	70	if (!flash_mtd) {
	71	printk("FLASH probe failed\n");
	72	err = -ENXIO;
	73	goto out_ioremap;
	74	}
	75
	76	flash_mtd->owner = THIS_MODULE;
69f34c98	77
1da177e4 LT	78	if (add_mtd_device(flash_mtd)) {
	79	printk("FLASH device addition failed\n");
	80	err = -ENOMEM;
	81	goto out_probe;
	82	}
69f34c98	83
1da177e4 LT	84	return 0;
	85
	86	out_probe:
	87	map_destroy(flash_mtd);
	88	flash_mtd = 0;
	89	out_ioremap:
	90	iounmap((void *)cdb89712_flash_map.virt);
	91	out_resource:
	92	release_resource (&cdb89712_flash_resource);
	93	out:
	94	return err;
	95	}
	96
	97
	98
	99
	100
	101	static struct mtd_info *sram_mtd;
	102
	103	struct map_info cdb89712_sram_map = {
	104	.name = "SRAM",
	105	.size = SRAM_SIZE,
	106	.bankwidth = SRAM_WIDTH,
	107	.phys = SRAM_START,
	108	};
	109
	110	struct resource cdb89712_sram_resource = {
	111	.name = "SRAM",
	112	.start = SRAM_START,
	113	.end = SRAM_START + SRAM_SIZE - 1,
	114	.flags = IORESOURCE_IO \| IORESOURCE_BUSY,
	115	};
	116
	117	static int __init init_cdb89712_sram (void)
	118	{
	119	int err;
69f34c98	120
1da177e4 LT	121	if (request_resource (&ioport_resource, &cdb89712_sram_resource)) {
	122	printk(KERN_NOTICE "Failed to reserve Cdb89712 SRAM space\n");
	123	err = -EBUSY;
	124	goto out;
	125	}
69f34c98	126
1da177e4 LT	127	cdb89712_sram_map.virt = ioremap(SRAM_START, SRAM_SIZE);
	128	if (!cdb89712_sram_map.virt) {
	129	printk(KERN_NOTICE "Failed to ioremap Cdb89712 SRAM space\n");
	130	err = -EIO;
	131	goto out_resource;
	132	}
	133	simple_map_init(&cdb89712_sram_map);
	134	sram_mtd = do_map_probe("map_ram", &cdb89712_sram_map);
	135	if (!sram_mtd) {
	136	printk("SRAM probe failed\n");
	137	err = -ENXIO;
	138	goto out_ioremap;
	139	}
	140
	141	sram_mtd->owner = THIS_MODULE;
	142	sram_mtd->erasesize = 16;
69f34c98	143
1da177e4 LT	144	if (add_mtd_device(sram_mtd)) {
	145	printk("SRAM device addition failed\n");
	146	err = -ENOMEM;
	147	goto out_probe;
	148	}
69f34c98	149
1da177e4 LT	150	return 0;
	151
	152	out_probe:
	153	map_destroy(sram_mtd);
	154	sram_mtd = 0;
	155	out_ioremap:
	156	iounmap((void *)cdb89712_sram_map.virt);
	157	out_resource:
	158	release_resource (&cdb89712_sram_resource);
	159	out:
	160	return err;
	161	}
	162
	163
	164
	165
	166
	167
	168
	169	static struct mtd_info *bootrom_mtd;
	170
	171	struct map_info cdb89712_bootrom_map = {
	172	.name = "BootROM",
	173	.size = BOOTROM_SIZE,
	174	.bankwidth = BOOTROM_WIDTH,
	175	.phys = BOOTROM_START,
	176	};
	177
	178	struct resource cdb89712_bootrom_resource = {
	179	.name = "BootROM",
	180	.start = BOOTROM_START,
	181	.end = BOOTROM_START + BOOTROM_SIZE - 1,
	182	.flags = IORESOURCE_IO \| IORESOURCE_BUSY,
	183	};
	184
	185	static int __init init_cdb89712_bootrom (void)
	186	{
	187	int err;
69f34c98	188
1da177e4 LT	189	if (request_resource (&ioport_resource, &cdb89712_bootrom_resource)) {
	190	printk(KERN_NOTICE "Failed to reserve Cdb89712 BOOTROM space\n");
	191	err = -EBUSY;
	192	goto out;
	193	}
69f34c98	194
1da177e4 LT	195	cdb89712_bootrom_map.virt = ioremap(BOOTROM_START, BOOTROM_SIZE);
	196	if (!cdb89712_bootrom_map.virt) {
	197	printk(KERN_NOTICE "Failed to ioremap Cdb89712 BootROM space\n");
	198	err = -EIO;
	199	goto out_resource;
	200	}
	201	simple_map_init(&cdb89712_bootrom_map);
	202	bootrom_mtd = do_map_probe("map_rom", &cdb89712_bootrom_map);
	203	if (!bootrom_mtd) {
	204	printk("BootROM probe failed\n");
	205	err = -ENXIO;
	206	goto out_ioremap;
	207	}
	208
	209	bootrom_mtd->owner = THIS_MODULE;
	210	bootrom_mtd->erasesize = 0x10000;
69f34c98	211
1da177e4 LT	212	if (add_mtd_device(bootrom_mtd)) {
	213	printk("BootROM device addition failed\n");
	214	err = -ENOMEM;
	215	goto out_probe;
	216	}
69f34c98	217
1da177e4 LT	218	return 0;
	219
	220	out_probe:
	221	map_destroy(bootrom_mtd);
	222	bootrom_mtd = 0;
	223	out_ioremap:
	224	iounmap((void *)cdb89712_bootrom_map.virt);
	225	out_resource:
	226	release_resource (&cdb89712_bootrom_resource);
	227	out:
	228	return err;
	229	}
	230
	231
	232
	233
	234
	235	static int __init init_cdb89712_maps(void)
	236	{
	237
69f34c98	238	printk(KERN_INFO "Cirrus CDB89712 MTD mappings:\n Flash 0x%x at 0x%x\n SRAM 0x%x at 0x%x\n BootROM 0x%x at 0x%x\n",
1da177e4 LT	239	FLASH_SIZE, FLASH_START, SRAM_SIZE, SRAM_START, BOOTROM_SIZE, BOOTROM_START);
	240
	241	init_cdb89712_flash();
	242	init_cdb89712_sram();
	243	init_cdb89712_bootrom();
69f34c98	244
1da177e4 LT	245	return 0;
1da177e4 LT	246	}
69f34c98	247
1da177e4 LT	248
	249	static void __exit cleanup_cdb89712_maps(void)
	250	{
	251	if (sram_mtd) {
	252	del_mtd_device(sram_mtd);
	253	map_destroy(sram_mtd);
	254	iounmap((void *)cdb89712_sram_map.virt);
	255	release_resource (&cdb89712_sram_resource);
	256	}
69f34c98	257
1da177e4 LT	258	if (flash_mtd) {
	259	del_mtd_device(flash_mtd);
	260	map_destroy(flash_mtd);
	261	iounmap((void *)cdb89712_flash_map.virt);
	262	release_resource (&cdb89712_flash_resource);
	263	}
	264
	265	if (bootrom_mtd) {
	266	del_mtd_device(bootrom_mtd);
	267	map_destroy(bootrom_mtd);
	268	iounmap((void *)cdb89712_bootrom_map.virt);
	269	release_resource (&cdb89712_bootrom_resource);
	270	}
	271	}
	272
	273	module_init(init_cdb89712_maps);
	274	module_exit(cleanup_cdb89712_maps);
	275
	276	MODULE_AUTHOR("Ray L");
	277	MODULE_DESCRIPTION("ARM CDB89712 map driver");
	278	MODULE_LICENSE("GPL");