[deliverable/linux.git] / arch / arm / mach-ep93xx / ts72xx.c

/*
 * arch/arm/mach-ep93xx/ts72xx.c
 * Technologic Systems TS72xx SBC support.
 *
 * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
 *
 * 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.
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <linux/mtd/physmap.h>
#include <linux/platform_device.h>
#include <linux/m48t86.h>
#include <linux/io.h>
#include <linux/i2c.h>
#include <mach/hardware.h>
#include <asm/mach-types.h>
#include <asm/mach/arch.h>
#include <asm/mach/map.h>

static struct map_desc ts72xx_io_desc[] __initdata = {
	{
		.virtual	= TS72XX_MODEL_VIRT_BASE,
		.pfn		= __phys_to_pfn(TS72XX_MODEL_PHYS_BASE),
		.length		= TS72XX_MODEL_SIZE,
		.type		= MT_DEVICE,
	}, {
		.virtual	= TS72XX_OPTIONS_VIRT_BASE,
		.pfn		= __phys_to_pfn(TS72XX_OPTIONS_PHYS_BASE),
		.length		= TS72XX_OPTIONS_SIZE,
		.type		= MT_DEVICE,
	}, {
		.virtual	= TS72XX_OPTIONS2_VIRT_BASE,
		.pfn		= __phys_to_pfn(TS72XX_OPTIONS2_PHYS_BASE),
		.length		= TS72XX_OPTIONS2_SIZE,
		.type		= MT_DEVICE,
	}, {
		.virtual	= TS72XX_RTC_INDEX_VIRT_BASE,
		.pfn		= __phys_to_pfn(TS72XX_RTC_INDEX_PHYS_BASE),
		.length		= TS72XX_RTC_INDEX_SIZE,
		.type		= MT_DEVICE,
	}, {
		.virtual	= TS72XX_RTC_DATA_VIRT_BASE,
		.pfn		= __phys_to_pfn(TS72XX_RTC_DATA_PHYS_BASE),
		.length		= TS72XX_RTC_DATA_SIZE,
		.type		= MT_DEVICE,
	}
};

static struct map_desc ts72xx_nand_io_desc[] __initdata = {
	{
		.virtual	= TS72XX_NAND_DATA_VIRT_BASE,
		.pfn		= __phys_to_pfn(TS72XX_NAND1_DATA_PHYS_BASE),
		.length		= TS72XX_NAND_DATA_SIZE,
		.type		= MT_DEVICE,
	}, {
		.virtual	= TS72XX_NAND_CONTROL_VIRT_BASE,
		.pfn		= __phys_to_pfn(TS72XX_NAND1_CONTROL_PHYS_BASE),
		.length		= TS72XX_NAND_CONTROL_SIZE,
		.type		= MT_DEVICE,
	}, {
		.virtual	= TS72XX_NAND_BUSY_VIRT_BASE,
		.pfn		= __phys_to_pfn(TS72XX_NAND1_BUSY_PHYS_BASE),
		.length		= TS72XX_NAND_BUSY_SIZE,
		.type		= MT_DEVICE,
	}
};

static struct map_desc ts72xx_alternate_nand_io_desc[] __initdata = {
	{
		.virtual	= TS72XX_NAND_DATA_VIRT_BASE,
		.pfn		= __phys_to_pfn(TS72XX_NAND2_DATA_PHYS_BASE),
		.length		= TS72XX_NAND_DATA_SIZE,
		.type		= MT_DEVICE,
	}, {
		.virtual	= TS72XX_NAND_CONTROL_VIRT_BASE,
		.pfn		= __phys_to_pfn(TS72XX_NAND2_CONTROL_PHYS_BASE),
		.length		= TS72XX_NAND_CONTROL_SIZE,
		.type		= MT_DEVICE,
	}, {
		.virtual	= TS72XX_NAND_BUSY_VIRT_BASE,
		.pfn		= __phys_to_pfn(TS72XX_NAND2_BUSY_PHYS_BASE),
		.length		= TS72XX_NAND_BUSY_SIZE,
		.type		= MT_DEVICE,
	}
};

static void __init ts72xx_map_io(void)
{
	ep93xx_map_io();
	iotable_init(ts72xx_io_desc, ARRAY_SIZE(ts72xx_io_desc));

	/*
	 * The TS-7200 has NOR flash, the other models have NAND flash.
	 */
	if (!board_is_ts7200()) {
		if (is_ts9420_installed()) {
			iotable_init(ts72xx_alternate_nand_io_desc,
				ARRAY_SIZE(ts72xx_alternate_nand_io_desc));
		} else {
			iotable_init(ts72xx_nand_io_desc,
				ARRAY_SIZE(ts72xx_nand_io_desc));
		}
	}
}

static struct physmap_flash_data ts72xx_flash_data = {
	.width		= 1,
};

static struct resource ts72xx_flash_resource = {
	.start		= TS72XX_NOR_PHYS_BASE,
	.end		= TS72XX_NOR_PHYS_BASE + SZ_16M - 1,
	.flags		= IORESOURCE_MEM,
};

static struct platform_device ts72xx_flash = {
	.name		= "physmap-flash",
	.id		= 0,
	.dev		= {
		.platform_data	= &ts72xx_flash_data,
	},
	.num_resources	= 1,
	.resource	= &ts72xx_flash_resource,
};

static unsigned char ts72xx_rtc_readbyte(unsigned long addr)
{
	__raw_writeb(addr, TS72XX_RTC_INDEX_VIRT_BASE);
	return __raw_readb(TS72XX_RTC_DATA_VIRT_BASE);
}

static void ts72xx_rtc_writebyte(unsigned char value, unsigned long addr)
{
	__raw_writeb(addr, TS72XX_RTC_INDEX_VIRT_BASE);
	__raw_writeb(value, TS72XX_RTC_DATA_VIRT_BASE);
}

static struct m48t86_ops ts72xx_rtc_ops = {
	.readbyte	= ts72xx_rtc_readbyte,
	.writebyte	= ts72xx_rtc_writebyte,
};

static struct platform_device ts72xx_rtc_device = {
	.name		= "rtc-m48t86",
	.id		= -1,
	.dev		= {
		.platform_data	= &ts72xx_rtc_ops,
	},
	.num_resources	= 0,
};

static struct ep93xx_eth_data ts72xx_eth_data = {
	.phy_id		= 1,
};

static void __init ts72xx_init_machine(void)
{
	ep93xx_init_devices();
	if (board_is_ts7200())
		platform_device_register(&ts72xx_flash);
	platform_device_register(&ts72xx_rtc_device);

	ep93xx_register_eth(&ts72xx_eth_data, 1);
}

MACHINE_START(TS72XX, "Technologic Systems TS-72xx SBC")
	/* Maintainer: Lennert Buytenhek <buytenh@wantstofly.org> */
	.phys_io	= EP93XX_APB_PHYS_BASE,
	.io_pg_offst	= ((EP93XX_APB_VIRT_BASE) >> 18) & 0xfffc,
	.boot_params	= EP93XX_SDCE3_PHYS_BASE_SYNC + 0x100,
	.map_io		= ts72xx_map_io,
	.init_irq	= ep93xx_init_irq,
	.timer		= &ep93xx_timer,
	.init_machine	= ts72xx_init_machine,
MACHINE_END
Commit	Line	Data
e7736d47 LB	1	/*
	2	* arch/arm/mach-ep93xx/ts72xx.c
	3	* Technologic Systems TS72xx SBC support.
	4	*
	5	* Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or (at
	10	* your option) any later version.
	11	*/
	12
e7736d47 LB	13	#include <linux/kernel.h>
	14	#include <linux/init.h>
	15	#include <linux/mm.h>
	16	#include <linux/sched.h>
	17	#include <linux/interrupt.h>
0967b5f0	18	#include <linux/ioport.h>
e7736d47	19	#include <linux/mtd/physmap.h>
7ba01f97 LB	20	#include <linux/platform_device.h>
7ba01f97 LB	21	#include <linux/m48t86.h>
fced80c7	22	#include <linux/io.h>
3e7a7281	23	#include <linux/i2c.h>
a09e64fb	24	#include <mach/hardware.h>
e7736d47 LB	25	#include <asm/mach-types.h>
	26	#include <asm/mach/arch.h>
	27	#include <asm/mach/map.h>
	28
	29	static struct map_desc ts72xx_io_desc[] __initdata = {
	30	{
	31	.virtual = TS72XX_MODEL_VIRT_BASE,
	32	.pfn = __phys_to_pfn(TS72XX_MODEL_PHYS_BASE),
	33	.length = TS72XX_MODEL_SIZE,
	34	.type = MT_DEVICE,
	35	}, {
	36	.virtual = TS72XX_OPTIONS_VIRT_BASE,
	37	.pfn = __phys_to_pfn(TS72XX_OPTIONS_PHYS_BASE),
	38	.length = TS72XX_OPTIONS_SIZE,
	39	.type = MT_DEVICE,
	40	}, {
	41	.virtual = TS72XX_OPTIONS2_VIRT_BASE,
	42	.pfn = __phys_to_pfn(TS72XX_OPTIONS2_PHYS_BASE),
	43	.length = TS72XX_OPTIONS2_SIZE,
	44	.type = MT_DEVICE,
7ba01f97 LB	45	}, {
	46	.virtual = TS72XX_RTC_INDEX_VIRT_BASE,
	47	.pfn = __phys_to_pfn(TS72XX_RTC_INDEX_PHYS_BASE),
	48	.length = TS72XX_RTC_INDEX_SIZE,
	49	.type = MT_DEVICE,
	50	}, {
	51	.virtual = TS72XX_RTC_DATA_VIRT_BASE,
	52	.pfn = __phys_to_pfn(TS72XX_RTC_DATA_PHYS_BASE),
	53	.length = TS72XX_RTC_DATA_SIZE,
	54	.type = MT_DEVICE,
e7736d47 LB	55	}
	56	};
	57
	58	static struct map_desc ts72xx_nand_io_desc[] __initdata = {
	59	{
	60	.virtual = TS72XX_NAND_DATA_VIRT_BASE,
	61	.pfn = __phys_to_pfn(TS72XX_NAND1_DATA_PHYS_BASE),
	62	.length = TS72XX_NAND_DATA_SIZE,
	63	.type = MT_DEVICE,
	64	}, {
	65	.virtual = TS72XX_NAND_CONTROL_VIRT_BASE,
	66	.pfn = __phys_to_pfn(TS72XX_NAND1_CONTROL_PHYS_BASE),
	67	.length = TS72XX_NAND_CONTROL_SIZE,
	68	.type = MT_DEVICE,
	69	}, {
	70	.virtual = TS72XX_NAND_BUSY_VIRT_BASE,
	71	.pfn = __phys_to_pfn(TS72XX_NAND1_BUSY_PHYS_BASE),
	72	.length = TS72XX_NAND_BUSY_SIZE,
	73	.type = MT_DEVICE,
	74	}
	75	};
	76
	77	static struct map_desc ts72xx_alternate_nand_io_desc[] __initdata = {
	78	{
	79	.virtual = TS72XX_NAND_DATA_VIRT_BASE,
	80	.pfn = __phys_to_pfn(TS72XX_NAND2_DATA_PHYS_BASE),
	81	.length = TS72XX_NAND_DATA_SIZE,
	82	.type = MT_DEVICE,
	83	}, {
	84	.virtual = TS72XX_NAND_CONTROL_VIRT_BASE,
	85	.pfn = __phys_to_pfn(TS72XX_NAND2_CONTROL_PHYS_BASE),
	86	.length = TS72XX_NAND_CONTROL_SIZE,
	87	.type = MT_DEVICE,
	88	}, {
	89	.virtual = TS72XX_NAND_BUSY_VIRT_BASE,
	90	.pfn = __phys_to_pfn(TS72XX_NAND2_BUSY_PHYS_BASE),
	91	.length = TS72XX_NAND_BUSY_SIZE,
	92	.type = MT_DEVICE,
	93	}
	94	};
	95
	96	static void __init ts72xx_map_io(void)
	97	{
	98	ep93xx_map_io();
	99	iotable_init(ts72xx_io_desc, ARRAY_SIZE(ts72xx_io_desc));
	100
	101	/*
	102	* The TS-7200 has NOR flash, the other models have NAND flash.
	103	*/
	104	if (!board_is_ts7200()) {
	105	if (is_ts9420_installed()) {
	106	iotable_init(ts72xx_alternate_nand_io_desc,
	107	ARRAY_SIZE(ts72xx_alternate_nand_io_desc));
	108	} else {
	109	iotable_init(ts72xx_nand_io_desc,
	110	ARRAY_SIZE(ts72xx_nand_io_desc));
	111	}
	112	}
	113	}
	114
0967b5f0 LB	115	static struct physmap_flash_data ts72xx_flash_data = {
	116	.width = 1,
	117	};
	118
	119	static struct resource ts72xx_flash_resource = {
	120	.start = TS72XX_NOR_PHYS_BASE,
e48f3fa3	121	.end = TS72XX_NOR_PHYS_BASE + SZ_16M - 1,
0967b5f0 LB	122	.flags = IORESOURCE_MEM,
	123	};
	124
	125	static struct platform_device ts72xx_flash = {
	126	.name = "physmap-flash",
	127	.id = 0,
	128	.dev = {
	129	.platform_data = &ts72xx_flash_data,
	130	},
	131	.num_resources = 1,
	132	.resource = &ts72xx_flash_resource,
	133	};
	134
fd0a0ac1	135	static unsigned char ts72xx_rtc_readbyte(unsigned long addr)
7ba01f97 LB	136	{
	137	__raw_writeb(addr, TS72XX_RTC_INDEX_VIRT_BASE);
	138	return __raw_readb(TS72XX_RTC_DATA_VIRT_BASE);
	139	}
	140
fd0a0ac1	141	static void ts72xx_rtc_writebyte(unsigned char value, unsigned long addr)
7ba01f97 LB	142	{
	143	__raw_writeb(addr, TS72XX_RTC_INDEX_VIRT_BASE);
	144	__raw_writeb(value, TS72XX_RTC_DATA_VIRT_BASE);
	145	}
	146
	147	static struct m48t86_ops ts72xx_rtc_ops = {
e48f3fa3 HS	148	.readbyte = ts72xx_rtc_readbyte,
e48f3fa3 HS	149	.writebyte = ts72xx_rtc_writebyte,
7ba01f97 LB	150	};
	151
	152	static struct platform_device ts72xx_rtc_device = {
e48f3fa3 HS	153	.name = "rtc-m48t86",
	154	.id = -1,
	155	.dev = {
	156	.platform_data = &ts72xx_rtc_ops,
7ba01f97	157	},
e48f3fa3	158	.num_resources = 0,
7ba01f97 LB	159	};
7ba01f97 LB	160
730ee9f3	161	static struct ep93xx_eth_data ts72xx_eth_data = {
e48f3fa3	162	.phy_id = 1,
730ee9f3 LB	163	};
730ee9f3 LB	164
e7736d47 LB	165	static void __init ts72xx_init_machine(void)
	166	{
	167	ep93xx_init_devices();
	168	if (board_is_ts7200())
0967b5f0	169	platform_device_register(&ts72xx_flash);
7ba01f97	170	platform_device_register(&ts72xx_rtc_device);
730ee9f3	171
a0a08fdc	172	ep93xx_register_eth(&ts72xx_eth_data, 1);
e7736d47 LB	173	}
	174
	175	MACHINE_START(TS72XX, "Technologic Systems TS-72xx SBC")
	176	/* Maintainer: Lennert Buytenhek <buytenh@wantstofly.org> */
	177	.phys_io = EP93XX_APB_PHYS_BASE,
	178	.io_pg_offst = ((EP93XX_APB_VIRT_BASE) >> 18) & 0xfffc,
e48f3fa3	179	.boot_params = EP93XX_SDCE3_PHYS_BASE_SYNC + 0x100,
e7736d47 LB	180	.map_io = ts72xx_map_io,
	181	.init_irq = ep93xx_init_irq,
	182	.timer = &ep93xx_timer,
	183	.init_machine = ts72xx_init_machine,
	184	MACHINE_END