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

/*
 * $Id: ocelot.c,v 1.17 2005/11/07 11:14:27 gleixner Exp $
 *
 * Flash on Momenco Ocelot
 */

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

#define OCELOT_PLD 0x2c000000
#define FLASH_WINDOW_ADDR 0x2fc00000
#define FLASH_WINDOW_SIZE 0x00080000
#define FLASH_BUSWIDTH 1
#define NVRAM_WINDOW_ADDR 0x2c800000
#define NVRAM_WINDOW_SIZE 0x00007FF0
#define NVRAM_BUSWIDTH 1

static unsigned int cacheflush = 0;

static struct mtd_info *flash_mtd;
static struct mtd_info *nvram_mtd;

static void ocelot_ram_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf)
{
        struct map_info *map = mtd->priv;
	size_t done = 0;

	/* If we use memcpy, it does word-wide writes. Even though we told the
	   GT64120A that it's an 8-bit wide region, word-wide writes don't work.
	   We end up just writing the first byte of the four to all four bytes.
	   So we have this loop instead */
	*retlen = len;
	while(len) {
		__raw_writeb(*(unsigned char *) from, map->virt + to);
		from++;
		to++;
		len--;
	}
}

static struct mtd_partition *parsed_parts;

struct map_info ocelot_flash_map = {
	.name = "Ocelot boot flash",
	.size = FLASH_WINDOW_SIZE,
	.bankwidth = FLASH_BUSWIDTH,
	.phys = FLASH_WINDOW_ADDR,
};

struct map_info ocelot_nvram_map = {
	.name = "Ocelot NVRAM",
	.size = NVRAM_WINDOW_SIZE,
	.bankwidth = NVRAM_BUSWIDTH,
	.phys = NVRAM_WINDOW_ADDR,
};

static const char *probes[] = { "RedBoot", NULL };

static int __init init_ocelot_maps(void)
{
	void *pld;
	int nr_parts;
	unsigned char brd_status;

       	printk(KERN_INFO "Momenco Ocelot MTD mappings: Flash 0x%x at 0x%x, NVRAM 0x%x at 0x%x\n",
	       FLASH_WINDOW_SIZE, FLASH_WINDOW_ADDR, NVRAM_WINDOW_SIZE, NVRAM_WINDOW_ADDR);

	/* First check whether the flash jumper is present */
	pld = ioremap(OCELOT_PLD, 0x10);
	if (!pld) {
		printk(KERN_NOTICE "Failed to ioremap Ocelot PLD\n");
		return -EIO;
	}
	brd_status = readb(pld+4);
	iounmap(pld);

	/* Now ioremap the NVRAM space */
	ocelot_nvram_map.virt = ioremap_nocache(NVRAM_WINDOW_ADDR, NVRAM_WINDOW_SIZE);
	if (!ocelot_nvram_map.virt) {
		printk(KERN_NOTICE "Failed to ioremap Ocelot NVRAM space\n");
		return -EIO;
	}

	simple_map_init(&ocelot_nvram_map);

	/* And do the RAM probe on it to get an MTD device */
	nvram_mtd = do_map_probe("map_ram", &ocelot_nvram_map);
	if (!nvram_mtd) {
		printk("NVRAM probe failed\n");
		goto fail_1;
	}
	nvram_mtd->owner = THIS_MODULE;
	nvram_mtd->erasesize = 16;
	/* Override the write() method */
	nvram_mtd->write = ocelot_ram_write;

	/* Now map the flash space */
	ocelot_flash_map.virt = ioremap_nocache(FLASH_WINDOW_ADDR, FLASH_WINDOW_SIZE);
	if (!ocelot_flash_map.virt) {
		printk(KERN_NOTICE "Failed to ioremap Ocelot flash space\n");
		goto fail_2;
	}
	/* Now the cached version */
	ocelot_flash_map.cached = (unsigned long)__ioremap(FLASH_WINDOW_ADDR, FLASH_WINDOW_SIZE, 0);

	simple_map_init(&ocelot_flash_map);

	/* Only probe for flash if the write jumper is present */
	if (brd_status & 0x40) {
		flash_mtd = do_map_probe("jedec", &ocelot_flash_map);
	} else {
		printk(KERN_NOTICE "Ocelot flash write jumper not present. Treating as ROM\n");
	}
	/* If that failed or the jumper's absent, pretend it's ROM */
	if (!flash_mtd) {
		flash_mtd = do_map_probe("map_rom", &ocelot_flash_map);
		/* If we're treating it as ROM, set the erase size */
		if (flash_mtd)
			flash_mtd->erasesize = 0x10000;
	}
	if (!flash_mtd)
		goto fail3;

	add_mtd_device(nvram_mtd);

	flash_mtd->owner = THIS_MODULE;
	nr_parts = parse_mtd_partitions(flash_mtd, probes, &parsed_parts, 0);

	if (nr_parts > 0)
		add_mtd_partitions(flash_mtd, parsed_parts, nr_parts);
	else
		add_mtd_device(flash_mtd);

	return 0;

 fail3:
	iounmap((void *)ocelot_flash_map.virt);
	if (ocelot_flash_map.cached)
			iounmap((void *)ocelot_flash_map.cached);
 fail_2:
	map_destroy(nvram_mtd);
 fail_1:
	iounmap((void *)ocelot_nvram_map.virt);

	return -ENXIO;
}

static void __exit cleanup_ocelot_maps(void)
{
	del_mtd_device(nvram_mtd);
	map_destroy(nvram_mtd);
	iounmap((void *)ocelot_nvram_map.virt);

	if (parsed_parts)
		del_mtd_partitions(flash_mtd);
	else
		del_mtd_device(flash_mtd);
	map_destroy(flash_mtd);
	iounmap((void *)ocelot_flash_map.virt);
	if (ocelot_flash_map.cached)
		iounmap((void *)ocelot_flash_map.cached);
}

module_init(init_ocelot_maps);
module_exit(cleanup_ocelot_maps);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Red Hat, Inc. - David Woodhouse <dwmw2@cambridge.redhat.com>");
MODULE_DESCRIPTION("MTD map driver for Momenco Ocelot board");
Commit	Line	Data
1da177e4	1	/*
69f34c98	2	* $Id: ocelot.c,v 1.17 2005/11/07 11:14:27 gleixner Exp $
1da177e4 LT	3	*
	4	* Flash on Momenco Ocelot
	5	*/
	6
	7	#include <linux/module.h>
	8	#include <linux/types.h>
	9	#include <linux/kernel.h>
	10	#include <linux/init.h>
	11	#include <asm/io.h>
	12	#include <linux/mtd/mtd.h>
	13	#include <linux/mtd/map.h>
	14	#include <linux/mtd/partitions.h>
	15
	16	#define OCELOT_PLD 0x2c000000
	17	#define FLASH_WINDOW_ADDR 0x2fc00000
	18	#define FLASH_WINDOW_SIZE 0x00080000
	19	#define FLASH_BUSWIDTH 1
	20	#define NVRAM_WINDOW_ADDR 0x2c800000
	21	#define NVRAM_WINDOW_SIZE 0x00007FF0
	22	#define NVRAM_BUSWIDTH 1
	23
	24	static unsigned int cacheflush = 0;
	25
	26	static struct mtd_info *flash_mtd;
	27	static struct mtd_info *nvram_mtd;
	28
	29	static void ocelot_ram_write(struct mtd_info mtd, loff_t to, size_t len, size_t retlen, const u_char *buf)
	30	{
	31	struct map_info *map = mtd->priv;
	32	size_t done = 0;
	33
69f34c98	34	/* If we use memcpy, it does word-wide writes. Even though we told the
1da177e4 LT	35	GT64120A that it's an 8-bit wide region, word-wide writes don't work.
	36	We end up just writing the first byte of the four to all four bytes.
	37	So we have this loop instead */
	38	*retlen = len;
	39	while(len) {
	40	__raw_writeb((unsigned char ) from, map->virt + to);
	41	from++;
	42	to++;
	43	len--;
	44	}
	45	}
	46
	47	static struct mtd_partition *parsed_parts;
	48
	49	struct map_info ocelot_flash_map = {
	50	.name = "Ocelot boot flash",
	51	.size = FLASH_WINDOW_SIZE,
	52	.bankwidth = FLASH_BUSWIDTH,
	53	.phys = FLASH_WINDOW_ADDR,
	54	};
	55
	56	struct map_info ocelot_nvram_map = {
	57	.name = "Ocelot NVRAM",
	58	.size = NVRAM_WINDOW_SIZE,
	59	.bankwidth = NVRAM_BUSWIDTH,
	60	.phys = NVRAM_WINDOW_ADDR,
	61	};
	62
	63	static const char *probes[] = { "RedBoot", NULL };
	64
	65	static int __init init_ocelot_maps(void)
	66	{
	67	void *pld;
	68	int nr_parts;
	69	unsigned char brd_status;
	70
69f34c98	71	printk(KERN_INFO "Momenco Ocelot MTD mappings: Flash 0x%x at 0x%x, NVRAM 0x%x at 0x%x\n",
1da177e4 LT	72	FLASH_WINDOW_SIZE, FLASH_WINDOW_ADDR, NVRAM_WINDOW_SIZE, NVRAM_WINDOW_ADDR);
	73
	74	/* First check whether the flash jumper is present */
	75	pld = ioremap(OCELOT_PLD, 0x10);
	76	if (!pld) {
	77	printk(KERN_NOTICE "Failed to ioremap Ocelot PLD\n");
	78	return -EIO;
	79	}
	80	brd_status = readb(pld+4);
	81	iounmap(pld);
	82
	83	/* Now ioremap the NVRAM space */
	84	ocelot_nvram_map.virt = ioremap_nocache(NVRAM_WINDOW_ADDR, NVRAM_WINDOW_SIZE);
	85	if (!ocelot_nvram_map.virt) {
	86	printk(KERN_NOTICE "Failed to ioremap Ocelot NVRAM space\n");
	87	return -EIO;
	88	}
	89
	90	simple_map_init(&ocelot_nvram_map);
	91
	92	/* And do the RAM probe on it to get an MTD device */
	93	nvram_mtd = do_map_probe("map_ram", &ocelot_nvram_map);
	94	if (!nvram_mtd) {
	95	printk("NVRAM probe failed\n");
	96	goto fail_1;
	97	}
	98	nvram_mtd->owner = THIS_MODULE;
	99	nvram_mtd->erasesize = 16;
	100	/* Override the write() method */
	101	nvram_mtd->write = ocelot_ram_write;
	102
	103	/* Now map the flash space */
	104	ocelot_flash_map.virt = ioremap_nocache(FLASH_WINDOW_ADDR, FLASH_WINDOW_SIZE);
	105	if (!ocelot_flash_map.virt) {
	106	printk(KERN_NOTICE "Failed to ioremap Ocelot flash space\n");
	107	goto fail_2;
	108	}
	109	/* Now the cached version */
	110	ocelot_flash_map.cached = (unsigned long)__ioremap(FLASH_WINDOW_ADDR, FLASH_WINDOW_SIZE, 0);
	111
	112	simple_map_init(&ocelot_flash_map);
	113
	114	/* Only probe for flash if the write jumper is present */
	115	if (brd_status & 0x40) {
	116	flash_mtd = do_map_probe("jedec", &ocelot_flash_map);
	117	} else {
	118	printk(KERN_NOTICE "Ocelot flash write jumper not present. Treating as ROM\n");
	119	}
	120	/* If that failed or the jumper's absent, pretend it's ROM */
	121	if (!flash_mtd) {
	122	flash_mtd = do_map_probe("map_rom", &ocelot_flash_map);
	123	/* If we're treating it as ROM, set the erase size */
	124	if (flash_mtd)
	125	flash_mtd->erasesize = 0x10000;
	126	}
	127	if (!flash_mtd)
	128	goto fail3;
	129
	130	add_mtd_device(nvram_mtd);
	131
	132	flash_mtd->owner = THIS_MODULE;
	133	nr_parts = parse_mtd_partitions(flash_mtd, probes, &parsed_parts, 0);
	134
	135	if (nr_parts > 0)
136	add_mtd_partitions(flash_mtd, parsed_parts, nr_parts);
137	else
138	add_mtd_device(flash_mtd);
139
140	return 0;
69f34c98 TG	141
69f34c98 TG	142	fail3:
1da177e4 LT	143	iounmap((void *)ocelot_flash_map.virt);
	144	if (ocelot_flash_map.cached)
	145	iounmap((void *)ocelot_flash_map.cached);
	146	fail_2:
	147	map_destroy(nvram_mtd);
	148	fail_1:
	149	iounmap((void *)ocelot_nvram_map.virt);
	150
	151	return -ENXIO;
	152	}
	153
	154	static void __exit cleanup_ocelot_maps(void)
	155	{
	156	del_mtd_device(nvram_mtd);
	157	map_destroy(nvram_mtd);
	158	iounmap((void *)ocelot_nvram_map.virt);
	159
	160	if (parsed_parts)
	161	del_mtd_partitions(flash_mtd);
	162	else
	163	del_mtd_device(flash_mtd);
	164	map_destroy(flash_mtd);
	165	iounmap((void *)ocelot_flash_map.virt);
	166	if (ocelot_flash_map.cached)
	167	iounmap((void *)ocelot_flash_map.cached);
	168	}
	169
	170	module_init(init_ocelot_maps);
	171	module_exit(cleanup_ocelot_maps);
	172
	173	MODULE_LICENSE("GPL");
	174	MODULE_AUTHOR("Red Hat, Inc. - David Woodhouse <dwmw2@cambridge.redhat.com>");
	175	MODULE_DESCRIPTION("MTD map driver for Momenco Ocelot board");