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

/*
 * Flash on Cirrus CDB89712
 *
 * $Id: cdb89712.c,v 1.11 2005/11/07 11:14:26 gleixner Exp $
 */

#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 <asm/arch/hardware.h>
#include <linux/mtd/mtd.h>
#include <linux/mtd/map.h>
#include <linux/mtd/partitions.h>


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