/* sc520cdp.c -- MTD map driver for AMD SC520 Customer Development Platform
 *
 * Copyright (C) 2001 Sysgo Real-Time Solutions GmbH
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 *
 * $Id$
 *
 *
 * The SC520CDP is an evaluation board for the Elan SC520 processor available
 * from AMD. It has two banks of 32-bit Flash ROM, each 8 Megabytes in size.
 * For details see http://www.amd.com/products/epd/desiging/evalboards/18.elansc520/520_cdp_brief/index.html
 */

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


#define WINDOW_ADDR_0	0x08400000
#define WINDOW_ADDR_1	0x08C00000
#define WINDOW_SIZE		0x00800000

static __u8 sc520cdp_read8(struct map_info *map, unsigned long ofs)
{
	return readb(map->map_priv_1 + ofs);
}

static __u16 sc520cdp_read16(struct map_info *map, unsigned long ofs)
{
	return readw(map->map_priv_1 + ofs);
}

static __u32 sc520cdp_read32(struct map_info *map, unsigned long ofs)
{
	return readl(map->map_priv_1 + ofs);
}

static void sc520cdp_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len)
{
	memcpy_fromio(to, (void *)(map->map_priv_1 + from), len);
}

static void sc520cdp_write8(struct map_info *map, __u8 d, unsigned long adr)
{
	writeb(d, map->map_priv_1 + adr);
}

static void sc520cdp_write16(struct map_info *map, __u16 d, unsigned long adr)
{
	writew(d, map->map_priv_1 + adr);
}

static void sc520cdp_write32(struct map_info *map, __u32 d, unsigned long adr)
{
	writel(d, map->map_priv_1 + adr);
}

static void sc520cdp_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len)
{
	memcpy_toio((void *)(map->map_priv_1 + to), from, len);
}

static struct map_info sc520cdp_map[] = {
	{
		name: "SC520CDP Flash Bank #0",
		size: WINDOW_SIZE,
		buswidth: 4,
		read8: sc520cdp_read8,
		read16: sc520cdp_read16,
		read32: sc520cdp_read32,
		copy_from: sc520cdp_copy_from,
		write8: sc520cdp_write8,
		write16: sc520cdp_write16,
		write32: sc520cdp_write32,
		copy_to: sc520cdp_copy_to,
		map_priv_2: WINDOW_ADDR_0
	},
	{
		name: "SC520CDP Flash Bank #1",
		size: WINDOW_SIZE,
		buswidth: 4,
		read8: sc520cdp_read8,
		read16: sc520cdp_read16,
		read32: sc520cdp_read32,
		copy_from: sc520cdp_copy_from,
		write8: sc520cdp_write8,
		write16: sc520cdp_write16,
		write32: sc520cdp_write32,
		copy_to: sc520cdp_copy_to,
		map_priv_2: WINDOW_ADDR_1
	},
};

#define NUM_FLASH_BANKS	(sizeof(sc520cdp_map)/sizeof(struct map_info))

static struct mtd_info *mymtd[NUM_FLASH_BANKS];



#if LINUX_VERSION_CODE < 0x20212 && defined(MODULE)
#define init_sc520cdp init_module
#define cleanup_sc520cdp cleanup_module
#endif

static int __init init_sc520cdp(void)
{
	int i;
	
	for (i = 0; i < NUM_FLASH_BANKS; i++) {
		printk(KERN_NOTICE "SC520 CDP flash device: %x at %lx\n", WINDOW_SIZE, sc520cdp_map[i].map_priv_2);
		sc520cdp_map[i].map_priv_1 = (unsigned long)ioremap(sc520cdp_map[i].map_priv_2, WINDOW_SIZE);

		if (!sc520cdp_map[i].map_priv_1) {
			printk("Failed to ioremap\n");
			return -EIO;
		}
		mymtd[i] = do_cfi_probe(&sc520cdp_map[i]);
		if (mymtd[i]) {
#ifdef MODULE
			mymtd[i]->module = &__this_module;
#endif
			add_mtd_device(mymtd[i]);
		}
		else {
			iounmap((void *)sc520cdp_map[i].map_priv_1);
			return -ENXIO;
		}
	}
	return 0;
}

static void __exit cleanup_sc520cdp(void)
{
	int i;
	
	for (i = 0; i < NUM_FLASH_BANKS; i++) {
		if (mymtd[i]) {
			del_mtd_device(mymtd[i]);
			map_destroy(mymtd[i]);
		}
		if (sc520cdp_map[i].map_priv_1) {
			iounmap((void *)sc520cdp_map[i].map_priv_1);
			sc520cdp_map[i].map_priv_1 = 0;
		}
	}
}

module_init(init_sc520cdp);
module_exit(cleanup_sc520cdp);