[deliverable/linux.git] / arch / arm / mach-omap2 / devices.c

/*
 * linux/arch/arm/mach-omap2/devices.c
 *
 * OMAP2 platform device setup/initialization
 *
 * 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/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/io.h>

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

#include <mach/tc.h>
#include <mach/board.h>
#include <mach/mux.h>
#include <mach/gpio.h>
#include <mach/eac.h>

#if defined(CONFIG_OMAP_DSP) || defined(CONFIG_OMAP_DSP_MODULE)
#define OMAP2_MBOX_BASE		IO_ADDRESS(OMAP24XX_MAILBOX_BASE)

static struct resource mbox_resources[] = {
	{
		.start		= OMAP2_MBOX_BASE,
		.end		= OMAP2_MBOX_BASE + 0x11f,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= INT_24XX_MAIL_U0_MPU,
		.flags		= IORESOURCE_IRQ,
	},
	{
		.start		= INT_24XX_MAIL_U3_MPU,
		.flags		= IORESOURCE_IRQ,
	},
};

static struct platform_device mbox_device = {
	.name		= "mailbox",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(mbox_resources),
	.resource	= mbox_resources,
};

static inline void omap_init_mbox(void)
{
	platform_device_register(&mbox_device);
}
#else
static inline void omap_init_mbox(void) { }
#endif

#if defined(CONFIG_OMAP_STI)

#if defined(CONFIG_ARCH_OMAP2)

#define OMAP2_STI_BASE		0x48068000
#define OMAP2_STI_CHANNEL_BASE	0x54000000
#define OMAP2_STI_IRQ		4

static struct resource sti_resources[] = {
	{
		.start		= OMAP2_STI_BASE,
		.end		= OMAP2_STI_BASE + 0x7ff,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP2_STI_CHANNEL_BASE,
		.end		= OMAP2_STI_CHANNEL_BASE + SZ_64K - 1,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP2_STI_IRQ,
		.flags		= IORESOURCE_IRQ,
	}
};
#elif defined(CONFIG_ARCH_OMAP3)

#define OMAP3_SDTI_BASE		0x54500000
#define OMAP3_SDTI_CHANNEL_BASE	0x54600000

static struct resource sti_resources[] = {
	{
		.start		= OMAP3_SDTI_BASE,
		.end		= OMAP3_SDTI_BASE + 0xFFF,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= OMAP3_SDTI_CHANNEL_BASE,
		.end		= OMAP3_SDTI_CHANNEL_BASE + SZ_1M - 1,
		.flags		= IORESOURCE_MEM,
	}
};

#endif

static struct platform_device sti_device = {
	.name		= "sti",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(sti_resources),
	.resource	= sti_resources,
};

static inline void omap_init_sti(void)
{
	platform_device_register(&sti_device);
}
#else
static inline void omap_init_sti(void) {}
#endif

#if defined(CONFIG_SPI_OMAP24XX) || defined(CONFIG_SPI_OMAP24XX_MODULE)

#include <mach/mcspi.h>

#define OMAP2_MCSPI1_BASE		0x48098000
#define OMAP2_MCSPI2_BASE		0x4809a000
#define OMAP2_MCSPI3_BASE		0x480b8000
#define OMAP2_MCSPI4_BASE		0x480ba000

static struct omap2_mcspi_platform_config omap2_mcspi1_config = {
	.num_cs		= 4,
};

static struct resource omap2_mcspi1_resources[] = {
	{
		.start		= OMAP2_MCSPI1_BASE,
		.end		= OMAP2_MCSPI1_BASE + 0xff,
		.flags		= IORESOURCE_MEM,
	},
};

static struct platform_device omap2_mcspi1 = {
	.name		= "omap2_mcspi",
	.id		= 1,
	.num_resources	= ARRAY_SIZE(omap2_mcspi1_resources),
	.resource	= omap2_mcspi1_resources,
	.dev		= {
		.platform_data = &omap2_mcspi1_config,
	},
};

static struct omap2_mcspi_platform_config omap2_mcspi2_config = {
	.num_cs		= 2,
};

static struct resource omap2_mcspi2_resources[] = {
	{
		.start		= OMAP2_MCSPI2_BASE,
		.end		= OMAP2_MCSPI2_BASE + 0xff,
		.flags		= IORESOURCE_MEM,
	},
};

static struct platform_device omap2_mcspi2 = {
	.name		= "omap2_mcspi",
	.id		= 2,
	.num_resources	= ARRAY_SIZE(omap2_mcspi2_resources),
	.resource	= omap2_mcspi2_resources,
	.dev		= {
		.platform_data = &omap2_mcspi2_config,
	},
};

#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3)
static struct omap2_mcspi_platform_config omap2_mcspi3_config = {
	.num_cs		= 2,
};

static struct resource omap2_mcspi3_resources[] = {
	{
	.start		= OMAP2_MCSPI3_BASE,
	.end		= OMAP2_MCSPI3_BASE + 0xff,
	.flags		= IORESOURCE_MEM,
	},
};

static struct platform_device omap2_mcspi3 = {
	.name		= "omap2_mcspi",
	.id		= 3,
	.num_resources	= ARRAY_SIZE(omap2_mcspi3_resources),
	.resource	= omap2_mcspi3_resources,
	.dev		= {
		.platform_data = &omap2_mcspi3_config,
	},
};
#endif

#ifdef CONFIG_ARCH_OMAP3
static struct omap2_mcspi_platform_config omap2_mcspi4_config = {
	.num_cs		= 1,
};

static struct resource omap2_mcspi4_resources[] = {
	{
		.start		= OMAP2_MCSPI4_BASE,
		.end		= OMAP2_MCSPI4_BASE + 0xff,
		.flags		= IORESOURCE_MEM,
	},
};

static struct platform_device omap2_mcspi4 = {
	.name		= "omap2_mcspi",
	.id		= 4,
	.num_resources	= ARRAY_SIZE(omap2_mcspi4_resources),
	.resource	= omap2_mcspi4_resources,
	.dev		= {
		.platform_data = &omap2_mcspi4_config,
	},
};
#endif

static void omap_init_mcspi(void)
{
	platform_device_register(&omap2_mcspi1);
	platform_device_register(&omap2_mcspi2);
#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3)
	platform_device_register(&omap2_mcspi3);
#endif
#ifdef CONFIG_ARCH_OMAP3
	platform_device_register(&omap2_mcspi4);
#endif
}

#else
static inline void omap_init_mcspi(void) {}
#endif

#ifdef CONFIG_SND_OMAP24XX_EAC

#define OMAP2_EAC_BASE			0x48090000

static struct resource omap2_eac_resources[] = {
	{
		.start		= OMAP2_EAC_BASE,
		.end		= OMAP2_EAC_BASE + 0x109,
		.flags		= IORESOURCE_MEM,
	},
};

static struct platform_device omap2_eac_device = {
	.name		= "omap24xx-eac",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(omap2_eac_resources),
	.resource	= omap2_eac_resources,
	.dev = {
		.platform_data = NULL,
	},
};

void omap_init_eac(struct eac_platform_data *pdata)
{
	omap2_eac_device.dev.platform_data = pdata;
	platform_device_register(&omap2_eac_device);
}

#else
void omap_init_eac(struct eac_platform_data *pdata) {}
#endif

#ifdef CONFIG_OMAP_SHA1_MD5
static struct resource sha1_md5_resources[] = {
	{
		.start	= OMAP24XX_SEC_SHA1MD5_BASE,
		.end	= OMAP24XX_SEC_SHA1MD5_BASE + 0x64,
		.flags	= IORESOURCE_MEM,
	},
	{
		.start	= INT_24XX_SHA1MD5,
		.flags	= IORESOURCE_IRQ,
	}
};

static struct platform_device sha1_md5_device = {
	.name		= "OMAP SHA1/MD5",
	.id		= -1,
	.num_resources	= ARRAY_SIZE(sha1_md5_resources),
	.resource	= sha1_md5_resources,
};

static void omap_init_sha1_md5(void)
{
	platform_device_register(&sha1_md5_device);
}
#else
static inline void omap_init_sha1_md5(void) { }
#endif

#if defined(CONFIG_HDQ_MASTER_OMAP) || defined(CONFIG_HDQ_MASTER_OMAP_MODULE)
#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3430)
#define OMAP_HDQ_BASE	0x480B2000
#endif
static struct resource omap_hdq_resources[] = {
	{
		.start		= OMAP_HDQ_BASE,
		.end		= OMAP_HDQ_BASE + 0x1C,
		.flags		= IORESOURCE_MEM,
	},
	{
		.start		= INT_24XX_HDQ_IRQ,
		.flags		= IORESOURCE_IRQ,
	},
};
static struct platform_device omap_hdq_dev = {
	.name = "omap_hdq",
	.id = 0,
	.dev = {
		.platform_data = NULL,
	},
	.num_resources	= ARRAY_SIZE(omap_hdq_resources),
	.resource	= omap_hdq_resources,
};
static inline void omap_hdq_init(void)
{
	(void) platform_device_register(&omap_hdq_dev);
}
#else
static inline void omap_hdq_init(void) {}
#endif

/*-------------------------------------------------------------------------*/

static int __init omap2_init_devices(void)
{
	/* please keep these calls, and their implementations above,
	 * in alphabetical order so they're easier to sort through.
	 */
	omap_init_mbox();
	omap_init_mcspi();
	omap_hdq_init();
	omap_init_sti();
	omap_init_sha1_md5();

	return 0;
}
arch_initcall(omap2_init_devices);
Commit	Line	Data
1dbae815 TL	1	/*
	2	* linux/arch/arm/mach-omap2/devices.c
	3	*
	4	* OMAP2 platform device setup/initialization
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*/
	11
1dbae815 TL	12	#include <linux/module.h>
	13	#include <linux/kernel.h>
	14	#include <linux/init.h>
	15	#include <linux/platform_device.h>
fced80c7	16	#include <linux/io.h>
1dbae815	17
a09e64fb	18	#include <mach/hardware.h>
1dbae815 TL	19	#include <asm/mach-types.h>
	20	#include <asm/mach/map.h>
	21
a09e64fb RK	22	#include <mach/tc.h>
	23	#include <mach/board.h>
	24	#include <mach/mux.h>
	25	#include <mach/gpio.h>
646e3ed1	26	#include <mach/eac.h>
1dbae815	27
c40fae95 TL	28	#if defined(CONFIG_OMAP_DSP) \|\| defined(CONFIG_OMAP_DSP_MODULE)
	29	#define OMAP2_MBOX_BASE IO_ADDRESS(OMAP24XX_MAILBOX_BASE)
	30
	31	static struct resource mbox_resources[] = {
	32	{
	33	.start = OMAP2_MBOX_BASE,
	34	.end = OMAP2_MBOX_BASE + 0x11f,
	35	.flags = IORESOURCE_MEM,
	36	},
	37	{
	38	.start = INT_24XX_MAIL_U0_MPU,
	39	.flags = IORESOURCE_IRQ,
	40	},
	41	{
	42	.start = INT_24XX_MAIL_U3_MPU,
	43	.flags = IORESOURCE_IRQ,
	44	},
	45	};
	46
	47	static struct platform_device mbox_device = {
	48	.name = "mailbox",
	49	.id = -1,
	50	.num_resources = ARRAY_SIZE(mbox_resources),
	51	.resource = mbox_resources,
	52	};
	53
	54	static inline void omap_init_mbox(void)
	55	{
	56	platform_device_register(&mbox_device);
	57	}
	58	#else
	59	static inline void omap_init_mbox(void) { }
	60	#endif
	61
9b6553cd TL	62	#if defined(CONFIG_OMAP_STI)
9b6553cd TL	63
646e3ed1 TL	64	#if defined(CONFIG_ARCH_OMAP2)
	65
	66	#define OMAP2_STI_BASE 0x48068000
9b6553cd TL	67	#define OMAP2_STI_CHANNEL_BASE 0x54000000
	68	#define OMAP2_STI_IRQ 4
	69
	70	static struct resource sti_resources[] = {
	71	{
	72	.start = OMAP2_STI_BASE,
	73	.end = OMAP2_STI_BASE + 0x7ff,
	74	.flags = IORESOURCE_MEM,
	75	},
	76	{
	77	.start = OMAP2_STI_CHANNEL_BASE,
	78	.end = OMAP2_STI_CHANNEL_BASE + SZ_64K - 1,
	79	.flags = IORESOURCE_MEM,
	80	},
	81	{
	82	.start = OMAP2_STI_IRQ,
	83	.flags = IORESOURCE_IRQ,
	84	}
	85	};
646e3ed1 TL	86	#elif defined(CONFIG_ARCH_OMAP3)
	87
	88	#define OMAP3_SDTI_BASE 0x54500000
	89	#define OMAP3_SDTI_CHANNEL_BASE 0x54600000
	90
	91	static struct resource sti_resources[] = {
	92	{
	93	.start = OMAP3_SDTI_BASE,
	94	.end = OMAP3_SDTI_BASE + 0xFFF,
	95	.flags = IORESOURCE_MEM,
	96	},
	97	{
	98	.start = OMAP3_SDTI_CHANNEL_BASE,
	99	.end = OMAP3_SDTI_CHANNEL_BASE + SZ_1M - 1,
	100	.flags = IORESOURCE_MEM,
	101	}
	102	};
	103
	104	#endif
9b6553cd TL	105
	106	static struct platform_device sti_device = {
	107	.name = "sti",
	108	.id = -1,
9b6553cd TL	109	.num_resources = ARRAY_SIZE(sti_resources),
	110	.resource = sti_resources,
	111	};
	112
	113	static inline void omap_init_sti(void)
	114	{
	115	platform_device_register(&sti_device);
	116	}
	117	#else
	118	static inline void omap_init_sti(void) {}
	119	#endif
	120
646e3ed1	121	#if defined(CONFIG_SPI_OMAP24XX) \|\| defined(CONFIG_SPI_OMAP24XX_MODULE)
ed7eb9d9	122
a09e64fb	123	#include <mach/mcspi.h>
ed7eb9d9 JY	124
	125	#define OMAP2_MCSPI1_BASE 0x48098000
	126	#define OMAP2_MCSPI2_BASE 0x4809a000
646e3ed1 TL	127	#define OMAP2_MCSPI3_BASE 0x480b8000
646e3ed1 TL	128	#define OMAP2_MCSPI4_BASE 0x480ba000
ed7eb9d9	129
ed7eb9d9	130	static struct omap2_mcspi_platform_config omap2_mcspi1_config = {
ed7eb9d9 JY	131	.num_cs = 4,
	132	};
	133
c40fae95 TL	134	static struct resource omap2_mcspi1_resources[] = {
	135	{
	136	.start = OMAP2_MCSPI1_BASE,
	137	.end = OMAP2_MCSPI1_BASE + 0xff,
	138	.flags = IORESOURCE_MEM,
	139	},
	140	};
	141
646e3ed1	142	static struct platform_device omap2_mcspi1 = {
ed7eb9d9 JY	143	.name = "omap2_mcspi",
ed7eb9d9 JY	144	.id = 1,
c40fae95 TL	145	.num_resources = ARRAY_SIZE(omap2_mcspi1_resources),
c40fae95 TL	146	.resource = omap2_mcspi1_resources,
ed7eb9d9 JY	147	.dev = {
	148	.platform_data = &omap2_mcspi1_config,
	149	},
	150	};
	151
	152	static struct omap2_mcspi_platform_config omap2_mcspi2_config = {
ed7eb9d9 JY	153	.num_cs = 2,
	154	};
	155
c40fae95 TL	156	static struct resource omap2_mcspi2_resources[] = {
	157	{
	158	.start = OMAP2_MCSPI2_BASE,
	159	.end = OMAP2_MCSPI2_BASE + 0xff,
	160	.flags = IORESOURCE_MEM,
	161	},
	162	};
	163
646e3ed1	164	static struct platform_device omap2_mcspi2 = {
ed7eb9d9 JY	165	.name = "omap2_mcspi",
ed7eb9d9 JY	166	.id = 2,
c40fae95 TL	167	.num_resources = ARRAY_SIZE(omap2_mcspi2_resources),
c40fae95 TL	168	.resource = omap2_mcspi2_resources,
ed7eb9d9 JY	169	.dev = {
	170	.platform_data = &omap2_mcspi2_config,
	171	},
	172	};
	173
646e3ed1 TL	174	#if defined(CONFIG_ARCH_OMAP2430) \|\| defined(CONFIG_ARCH_OMAP3)
	175	static struct omap2_mcspi_platform_config omap2_mcspi3_config = {
	176	.num_cs = 2,
	177	};
	178
	179	static struct resource omap2_mcspi3_resources[] = {
	180	{
	181	.start = OMAP2_MCSPI3_BASE,
	182	.end = OMAP2_MCSPI3_BASE + 0xff,
	183	.flags = IORESOURCE_MEM,
	184	},
	185	};
	186
	187	static struct platform_device omap2_mcspi3 = {
	188	.name = "omap2_mcspi",
	189	.id = 3,
	190	.num_resources = ARRAY_SIZE(omap2_mcspi3_resources),
	191	.resource = omap2_mcspi3_resources,
	192	.dev = {
	193	.platform_data = &omap2_mcspi3_config,
	194	},
	195	};
	196	#endif
	197
	198	#ifdef CONFIG_ARCH_OMAP3
	199	static struct omap2_mcspi_platform_config omap2_mcspi4_config = {
	200	.num_cs = 1,
	201	};
	202
	203	static struct resource omap2_mcspi4_resources[] = {
	204	{
	205	.start = OMAP2_MCSPI4_BASE,
	206	.end = OMAP2_MCSPI4_BASE + 0xff,
	207	.flags = IORESOURCE_MEM,
	208	},
	209	};
	210
	211	static struct platform_device omap2_mcspi4 = {
	212	.name = "omap2_mcspi",
	213	.id = 4,
	214	.num_resources = ARRAY_SIZE(omap2_mcspi4_resources),
	215	.resource = omap2_mcspi4_resources,
	216	.dev = {
	217	.platform_data = &omap2_mcspi4_config,
	218	},
	219	};
	220	#endif
	221
ed7eb9d9 JY	222	static void omap_init_mcspi(void)
	223	{
	224	platform_device_register(&omap2_mcspi1);
	225	platform_device_register(&omap2_mcspi2);
646e3ed1 TL	226	#if defined(CONFIG_ARCH_OMAP2430) \|\| defined(CONFIG_ARCH_OMAP3)
	227	platform_device_register(&omap2_mcspi3);
	228	#endif
	229	#ifdef CONFIG_ARCH_OMAP3
	230	platform_device_register(&omap2_mcspi4);
	231	#endif
ed7eb9d9 JY	232	}
	233
	234	#else
	235	static inline void omap_init_mcspi(void) {}
	236	#endif
	237
646e3ed1 TL	238	#ifdef CONFIG_SND_OMAP24XX_EAC
	239
	240	#define OMAP2_EAC_BASE 0x48090000
	241
	242	static struct resource omap2_eac_resources[] = {
	243	{
	244	.start = OMAP2_EAC_BASE,
	245	.end = OMAP2_EAC_BASE + 0x109,
	246	.flags = IORESOURCE_MEM,
	247	},
	248	};
	249
	250	static struct platform_device omap2_eac_device = {
	251	.name = "omap24xx-eac",
	252	.id = -1,
	253	.num_resources = ARRAY_SIZE(omap2_eac_resources),
	254	.resource = omap2_eac_resources,
	255	.dev = {
	256	.platform_data = NULL,
	257	},
	258	};
	259
	260	void omap_init_eac(struct eac_platform_data *pdata)
	261	{
	262	omap2_eac_device.dev.platform_data = pdata;
	263	platform_device_register(&omap2_eac_device);
	264	}
	265
	266	#else
	267	void omap_init_eac(struct eac_platform_data *pdata) {}
	268	#endif
	269
	270	#ifdef CONFIG_OMAP_SHA1_MD5
	271	static struct resource sha1_md5_resources[] = {
	272	{
	273	.start = OMAP24XX_SEC_SHA1MD5_BASE,
	274	.end = OMAP24XX_SEC_SHA1MD5_BASE + 0x64,
	275	.flags = IORESOURCE_MEM,
	276	},
	277	{
	278	.start = INT_24XX_SHA1MD5,
	279	.flags = IORESOURCE_IRQ,
	280	}
	281	};
	282
	283	static struct platform_device sha1_md5_device = {
	284	.name = "OMAP SHA1/MD5",
	285	.id = -1,
	286	.num_resources = ARRAY_SIZE(sha1_md5_resources),
	287	.resource = sha1_md5_resources,
	288	};
	289
	290	static void omap_init_sha1_md5(void)
	291	{
	292	platform_device_register(&sha1_md5_device);
	293	}
	294	#else
	295	static inline void omap_init_sha1_md5(void) { }
	296	#endif
	297
	298	#if defined(CONFIG_HDQ_MASTER_OMAP) \|\| defined(CONFIG_HDQ_MASTER_OMAP_MODULE)
	299	#if defined(CONFIG_ARCH_OMAP2430) \|\| defined(CONFIG_ARCH_OMAP3430)
	300	#define OMAP_HDQ_BASE 0x480B2000
	301	#endif
302	static struct resource omap_hdq_resources[] = {
303	{
304	.start = OMAP_HDQ_BASE,
305	.end = OMAP_HDQ_BASE + 0x1C,
306	.flags = IORESOURCE_MEM,
307	},
308	{
309	.start = INT_24XX_HDQ_IRQ,
310	.flags = IORESOURCE_IRQ,
311	},
312	};
313	static struct platform_device omap_hdq_dev = {
314	.name = "omap_hdq",
315	.id = 0,
316	.dev = {
317	.platform_data = NULL,
318	},
319	.num_resources = ARRAY_SIZE(omap_hdq_resources),
320	.resource = omap_hdq_resources,
321	};
322	static inline void omap_hdq_init(void)
323	{
324	(void) platform_device_register(&omap_hdq_dev);
325	}
326	#else
327	static inline void omap_hdq_init(void) {}
328	#endif
329
1dbae815 TL	330	/-------------------------------------------------------------------------/
	331
	332	static int __init omap2_init_devices(void)
	333	{
	334	/* please keep these calls, and their implementations above,
	335	* in alphabetical order so they're easier to sort through.
	336	*/
c40fae95	337	omap_init_mbox();
ed7eb9d9	338	omap_init_mcspi();
646e3ed1	339	omap_hdq_init();
9b6553cd	340	omap_init_sti();
646e3ed1	341	omap_init_sha1_md5();
1dbae815 TL	342
	343	return 0;
	344	}
	345	arch_initcall(omap2_init_devices);