[mirror_ubuntu-hirsute-kernel.git] / arch / arm / mach-imx / mx1ads.c

/*
 * arch/arm/mach-imx/mx1ads.c
 *
 * Initially based on:
 *	linux-2.6.7-imx/arch/arm/mach-imx/scb9328.c
 *	Copyright (c) 2004 Sascha Hauer <sascha@saschahauer.de>
 *
 * 2004 (c) MontaVista Software, Inc.
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2. This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */

#include <linux/device.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <asm/system.h>
#include <asm/hardware.h>
#include <asm/irq.h>
#include <asm/pgtable.h>
#include <asm/page.h>

#include <asm/mach/map.h>
#include <asm/mach-types.h>

#include <asm/mach/arch.h>
#include <asm/arch/mmc.h>
#include <asm/arch/imx-uart.h>
#include <linux/interrupt.h>
#include "generic.h"

static struct resource cs89x0_resources[] = {
	[0] = {
		.start	= IMX_CS4_PHYS + 0x300,
		.end	= IMX_CS4_PHYS + 0x300 + 16,
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.start	= IRQ_GPIOC(17),
		.end	= IRQ_GPIOC(17),
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device cs89x0_device = {
	.name		= "cirrus-cs89x0",
	.num_resources	= ARRAY_SIZE(cs89x0_resources),
	.resource	= cs89x0_resources,
};

static struct imxuart_platform_data uart_pdata = {
	.flags = IMXUART_HAVE_RTSCTS,
};

static struct resource imx_uart1_resources[] = {
	[0] = {
		.start	= 0x00206000,
		.end	= 0x002060FF,
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.start	= (UART1_MINT_RX),
		.end	= (UART1_MINT_RX),
		.flags	= IORESOURCE_IRQ,
	},
	[2] = {
		.start	= (UART1_MINT_TX),
		.end	= (UART1_MINT_TX),
		.flags	= IORESOURCE_IRQ,
	},
	[3] = {
		.start	= UART1_MINT_RTS,
		.end	= UART1_MINT_RTS,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device imx_uart1_device = {
	.name		= "imx-uart",
	.id		= 0,
	.num_resources	= ARRAY_SIZE(imx_uart1_resources),
	.resource	= imx_uart1_resources,
	.dev = {
		.platform_data = &uart_pdata,
	}
};

static struct resource imx_uart2_resources[] = {
	[0] = {
		.start	= 0x00207000,
		.end	= 0x002070FF,
		.flags	= IORESOURCE_MEM,
	},
	[1] = {
		.start	= (UART2_MINT_RX),
		.end	= (UART2_MINT_RX),
		.flags	= IORESOURCE_IRQ,
	},
	[2] = {
		.start	= (UART2_MINT_TX),
		.end	= (UART2_MINT_TX),
		.flags	= IORESOURCE_IRQ,
	},
	[3] = {
		.start	= UART2_MINT_RTS,
		.end	= UART2_MINT_RTS,
		.flags	= IORESOURCE_IRQ,
	},
};

static struct platform_device imx_uart2_device = {
	.name		= "imx-uart",
	.id		= 1,
	.num_resources	= ARRAY_SIZE(imx_uart2_resources),
	.resource	= imx_uart2_resources,
	.dev = {
		.platform_data = &uart_pdata,
	}
};

static struct platform_device *devices[] __initdata = {
	&cs89x0_device,
	&imx_uart1_device,
	&imx_uart2_device,
};

#ifdef CONFIG_MMC_IMX
static int mx1ads_mmc_card_present(struct device *dev)
{
	/* MMC/SD Card Detect is PB 20 on MX1ADS V1.0.7 */
	return (SSR(1) & (1 << 20) ? 0 : 1);
}

static struct imxmmc_platform_data mx1ads_mmc_info = {
       .card_present = mx1ads_mmc_card_present,
};
#endif

static void __init
mx1ads_init(void)
{
#ifdef CONFIG_LEDS
	imx_gpio_mode(GPIO_PORTA | GPIO_OUT | 2);
#endif
#ifdef CONFIG_MMC_IMX
	/* SD/MMC card detect */
	imx_gpio_mode(GPIO_PORTB | GPIO_GIUS | GPIO_IN | 20);
	imx_set_mmc_info(&mx1ads_mmc_info);
#endif

	imx_gpio_mode(PC9_PF_UART1_CTS);
	imx_gpio_mode(PC10_PF_UART1_RTS);
	imx_gpio_mode(PC11_PF_UART1_TXD);
	imx_gpio_mode(PC12_PF_UART1_RXD);

	imx_gpio_mode(PB28_PF_UART2_CTS);
	imx_gpio_mode(PB29_PF_UART2_RTS);
	imx_gpio_mode(PB30_PF_UART2_TXD);
	imx_gpio_mode(PB31_PF_UART2_RXD);

	platform_add_devices(devices, ARRAY_SIZE(devices));
}

static void __init
mx1ads_map_io(void)
{
	imx_map_io();
}

MACHINE_START(MX1ADS, "Motorola MX1ADS")
	/* Maintainer: Sascha Hauer, Pengutronix */
	.phys_io	= 0x00200000,
	.io_pg_offst	= ((0xe0000000) >> 18) & 0xfffc,
	.boot_params	= 0x08000100,
	.map_io		= mx1ads_map_io,
	.init_irq	= imx_init_irq,
	.timer		= &imx_timer,
	.init_machine	= mx1ads_init,
MACHINE_END
Commit	Line	Data
1da177e4 LT	1	/*
	2	* arch/arm/mach-imx/mx1ads.c
	3	*
	4	* Initially based on:
	5	* linux-2.6.7-imx/arch/arm/mach-imx/scb9328.c
	6	* Copyright (c) 2004 Sascha Hauer <sascha@saschahauer.de>
	7	*
	8	* 2004 (c) MontaVista Software, Inc.
	9	*
	10	* This file is licensed under the terms of the GNU General Public
	11	* License version 2. This program is licensed "as is" without any
	12	* warranty of any kind, whether express or implied.
	13	*/
	14
	15	#include <linux/device.h>
	16	#include <linux/init.h>
d052d1be	17	#include <linux/platform_device.h>
1da177e4 LT	18	#include <asm/system.h>
	19	#include <asm/hardware.h>
	20	#include <asm/irq.h>
	21	#include <asm/pgtable.h>
	22	#include <asm/page.h>
	23
	24	#include <asm/mach/map.h>
	25	#include <asm/mach-types.h>
	26
	27	#include <asm/mach/arch.h>
d66e35fa	28	#include <asm/arch/mmc.h>
5b802344	29	#include <asm/arch/imx-uart.h>
1da177e4 LT	30	#include <linux/interrupt.h>
1da177e4 LT	31	#include "generic.h"
1da177e4	32
6a2273d6	33	static struct resource cs89x0_resources[] = {
1da177e4	34	[0] = {
6a2273d6 SH	35	.start = IMX_CS4_PHYS + 0x300,
6a2273d6 SH	36	.end = IMX_CS4_PHYS + 0x300 + 16,
1da177e4 LT	37	.flags = IORESOURCE_MEM,
	38	},
	39	[1] = {
6a2273d6 SH	40	.start = IRQ_GPIOC(17),
6a2273d6 SH	41	.end = IRQ_GPIOC(17),
1da177e4 LT	42	.flags = IORESOURCE_IRQ,
	43	},
	44	};
	45
6a2273d6 SH	46	static struct platform_device cs89x0_device = {
	47	.name = "cirrus-cs89x0",
	48	.num_resources = ARRAY_SIZE(cs89x0_resources),
	49	.resource = cs89x0_resources,
1da177e4 LT	50	};
1da177e4 LT	51
5b802344 SH	52	static struct imxuart_platform_data uart_pdata = {
	53	.flags = IMXUART_HAVE_RTSCTS,
	54	};
	55
	56	static struct resource imx_uart1_resources[] = {
	57	[0] = {
	58	.start = 0x00206000,
	59	.end = 0x002060FF,
	60	.flags = IORESOURCE_MEM,
	61	},
	62	[1] = {
	63	.start = (UART1_MINT_RX),
	64	.end = (UART1_MINT_RX),
	65	.flags = IORESOURCE_IRQ,
	66	},
	67	[2] = {
	68	.start = (UART1_MINT_TX),
	69	.end = (UART1_MINT_TX),
	70	.flags = IORESOURCE_IRQ,
	71	},
dbff4e9e SH	72	[3] = {
	73	.start = UART1_MINT_RTS,
	74	.end = UART1_MINT_RTS,
	75	.flags = IORESOURCE_IRQ,
	76	},
5b802344 SH	77	};
	78
	79	static struct platform_device imx_uart1_device = {
	80	.name = "imx-uart",
	81	.id = 0,
	82	.num_resources = ARRAY_SIZE(imx_uart1_resources),
	83	.resource = imx_uart1_resources,
	84	.dev = {
	85	.platform_data = &uart_pdata,
	86	}
	87	};
	88
	89	static struct resource imx_uart2_resources[] = {
	90	[0] = {
	91	.start = 0x00207000,
	92	.end = 0x002070FF,
	93	.flags = IORESOURCE_MEM,
	94	},
	95	[1] = {
	96	.start = (UART2_MINT_RX),
	97	.end = (UART2_MINT_RX),
	98	.flags = IORESOURCE_IRQ,
	99	},
	100	[2] = {
	101	.start = (UART2_MINT_TX),
	102	.end = (UART2_MINT_TX),
	103	.flags = IORESOURCE_IRQ,
	104	},
dbff4e9e SH	105	[3] = {
	106	.start = UART2_MINT_RTS,
	107	.end = UART2_MINT_RTS,
	108	.flags = IORESOURCE_IRQ,
	109	},
5b802344 SH	110	};
	111
	112	static struct platform_device imx_uart2_device = {
	113	.name = "imx-uart",
	114	.id = 1,
	115	.num_resources = ARRAY_SIZE(imx_uart2_resources),
	116	.resource = imx_uart2_resources,
	117	.dev = {
	118	.platform_data = &uart_pdata,
	119	}
	120	};
	121
1da177e4	122	static struct platform_device *devices[] __initdata = {
6a2273d6	123	&cs89x0_device,
5b802344 SH	124	&imx_uart1_device,
5b802344 SH	125	&imx_uart2_device,
1da177e4 LT	126	};
1da177e4 LT	127
d66e35fa	128	#ifdef CONFIG_MMC_IMX
faf39ede	129	static int mx1ads_mmc_card_present(struct device *dev)
d66e35fa PP	130	{
	131	/* MMC/SD Card Detect is PB 20 on MX1ADS V1.0.7 */
	132	return (SSR(1) & (1 << 20) ? 0 : 1);
	133	}
	134
	135	static struct imxmmc_platform_data mx1ads_mmc_info = {
	136	.card_present = mx1ads_mmc_card_present,
	137	};
	138	#endif
	139
1da177e4 LT	140	static void __init
	141	mx1ads_init(void)
	142	{
	143	#ifdef CONFIG_LEDS
0a5b0aa8	144	imx_gpio_mode(GPIO_PORTA \| GPIO_OUT \| 2);
d66e35fa PP	145	#endif
	146	#ifdef CONFIG_MMC_IMX
	147	/* SD/MMC card detect */
	148	imx_gpio_mode(GPIO_PORTB \| GPIO_GIUS \| GPIO_IN \| 20);
	149	imx_set_mmc_info(&mx1ads_mmc_info);
1da177e4	150	#endif
5b802344 SH	151
	152	imx_gpio_mode(PC9_PF_UART1_CTS);
	153	imx_gpio_mode(PC10_PF_UART1_RTS);
	154	imx_gpio_mode(PC11_PF_UART1_TXD);
	155	imx_gpio_mode(PC12_PF_UART1_RXD);
	156
	157	imx_gpio_mode(PB28_PF_UART2_CTS);
	158	imx_gpio_mode(PB29_PF_UART2_RTS);
	159	imx_gpio_mode(PB30_PF_UART2_TXD);
	160	imx_gpio_mode(PB31_PF_UART2_RXD);
	161
1da177e4 LT	162	platform_add_devices(devices, ARRAY_SIZE(devices));
	163	}
	164
1da177e4 LT	165	static void __init
	166	mx1ads_map_io(void)
	167	{
	168	imx_map_io();
1da177e4 LT	169	}
	170
	171	MACHINE_START(MX1ADS, "Motorola MX1ADS")
e9dea0c6	172	/* Maintainer: Sascha Hauer, Pengutronix */
e9dea0c6	173	.phys_io = 0x00200000,
216251cf	174	.io_pg_offst = ((0xe0000000) >> 18) & 0xfffc,
e9dea0c6 RK	175	.boot_params = 0x08000100,
	176	.map_io = mx1ads_map_io,
	177	.init_irq = imx_init_irq,
1da177e4	178	.timer = &imx_timer,
e9dea0c6	179	.init_machine = mx1ads_init,
1da177e4	180	MACHINE_END