Mapping for AMD SC520 CDP

Hi,

I have written a new flash mapping module for the SC520 CDP board by AMD, which I would like to contribute (see attachment). Most of the code has obviously been stol^H^H^H^H derived from various existing mapping modules. Hope I have not introduced any bugs. It works for me so far.

The physmap.c driver works for that board too, but it seems I can only get support for one of the two flash banks this way.

Cheers

Rob

----------------------------------------------------------------
Robert Kaiser email: [email protected]
SYSGO RTS GmbH
Am Pfaffenstein 14 phone: (49) 6136 9948-762
D-55270 Klein-Winternheim / Germany fax: (49) 6136 9948-10

@@ -177,6 +177,12 @@
   devices. This board utilizes Intel StrataFlash. More info at
   (http://www.arcomcontrols.com/products/icp/pc104/processors/).
 
+Flash chip mapping on AMD SC520 CDP board
+CONFIG_MTD_SC520CDP
+  The SC520 CDP board has two banks of CFI-compliant chips. This
+  'mapping' driver supports that arrangement, implementing two
+  MTD devices.
+
 Flash chip mapping on Arcom Control Systems' ELAN-104NC
 CONFIG_MTD_ELAN_104NC
   This provides a driver for the on-board flash of the Arcom Control

@@ -84,6 +84,7 @@
    dep_tristate '  CFI Flash device mapped on Photron PNC-2000' CONFIG_MTD_PNC2000 $CONFIG_MTD_CFI
    dep_tristate '  CFI Flash device mapped on RPX Lite or CLLF' CONFIG_MTD_RPXLITE $CONFIG_MTD_CFI
    dep_tristate '  CFI Flash device mapped on Arcom SBC-MediaGX' CONFIG_MTD_SBC_MEDIAGX $CONFIG_MTD_CFI_INTELEXT
+   dep_tristate '  CFI Flash devices mapped on AMD SC520 CDP' CONFIG_MTD_SC520CDP $CONFIG_MTD_CFI
    dep_tristate '  CFI Flash device mapped on Arcom ELAN-104NC' CONFIG_MTD_ELAN_104NC $CONFIG_MTD_CFI_INTELEXT
    dep_tristate '  CFI Flash device mapped on StrongARM SA11x0' CONFIG_MTD_SA1100 $CONFIG_MTD_CFI
    dep_tristate '  CFI Flash device mapped on DC21285 Footbridge' CONFIG_MTD_DC21285 $CONFIG_MTD_CFI

/* 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);