[net-next-2.6.git] / arch / arm / plat-s3c24xx / devs.c

/* linux/arch/arm/plat-s3c24xx/devs.c
 *
 * Copyright (c) 2004 Simtec Electronics
 *	Ben Dooks <ben@simtec.co.uk>
 *
 * Base S3C24XX platform device definitions
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
*/

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/list.h>
#include <linux/timer.h>
#include <linux/init.h>
#include <linux/serial_core.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/string.h>

#include <asm/mach/arch.h>
#include <asm/mach/map.h>
#include <asm/mach/irq.h>
#include <mach/fb.h>
#include <mach/hardware.h>
#include <mach/dma.h>
#include <mach/irqs.h>
#include <asm/irq.h>

#include <plat/regs-serial.h>
#include <plat/udc.h>
#include <plat/mci.h>

#include <plat/devs.h>
#include <plat/cpu.h>
#include <plat/regs-spi.h>
#include <plat/ts.h>

/* Serial port registrations */

static struct resource s3c2410_uart0_resource[] = {
	[0] = {
		.start = S3C2410_PA_UART0,
		.end   = S3C2410_PA_UART0 + 0x3fff,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_S3CUART_RX0,
		.end   = IRQ_S3CUART_ERR0,
		.flags = IORESOURCE_IRQ,
	}
};

static struct resource s3c2410_uart1_resource[] = {
	[0] = {
		.start = S3C2410_PA_UART1,
		.end   = S3C2410_PA_UART1 + 0x3fff,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_S3CUART_RX1,
		.end   = IRQ_S3CUART_ERR1,
		.flags = IORESOURCE_IRQ,
	}
};

static struct resource s3c2410_uart2_resource[] = {
	[0] = {
		.start = S3C2410_PA_UART2,
		.end   = S3C2410_PA_UART2 + 0x3fff,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_S3CUART_RX2,
		.end   = IRQ_S3CUART_ERR2,
		.flags = IORESOURCE_IRQ,
	}
};

static struct resource s3c2410_uart3_resource[] = {
	[0] = {
		.start = S3C2443_PA_UART3,
		.end   = S3C2443_PA_UART3 + 0x3fff,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_S3CUART_RX3,
		.end   = IRQ_S3CUART_ERR3,
		.flags = IORESOURCE_IRQ,
	},
};

struct s3c24xx_uart_resources s3c2410_uart_resources[] __initdata = {
	[0] = {
		.resources	= s3c2410_uart0_resource,
		.nr_resources	= ARRAY_SIZE(s3c2410_uart0_resource),
	},
	[1] = {
		.resources	= s3c2410_uart1_resource,
		.nr_resources	= ARRAY_SIZE(s3c2410_uart1_resource),
	},
	[2] = {
		.resources	= s3c2410_uart2_resource,
		.nr_resources	= ARRAY_SIZE(s3c2410_uart2_resource),
	},
	[3] = {
		.resources	= s3c2410_uart3_resource,
		.nr_resources	= ARRAY_SIZE(s3c2410_uart3_resource),
	},
};

/* LCD Controller */

static struct resource s3c_lcd_resource[] = {
	[0] = {
		.start = S3C24XX_PA_LCD,
		.end   = S3C24XX_PA_LCD + S3C24XX_SZ_LCD - 1,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_LCD,
		.end   = IRQ_LCD,
		.flags = IORESOURCE_IRQ,
	}

};

static u64 s3c_device_lcd_dmamask = 0xffffffffUL;

struct platform_device s3c_device_lcd = {
	.name		  = "s3c2410-lcd",
	.id		  = -1,
	.num_resources	  = ARRAY_SIZE(s3c_lcd_resource),
	.resource	  = s3c_lcd_resource,
	.dev              = {
		.dma_mask		= &s3c_device_lcd_dmamask,
		.coherent_dma_mask	= 0xffffffffUL
	}
};

EXPORT_SYMBOL(s3c_device_lcd);

void __init s3c24xx_fb_set_platdata(struct s3c2410fb_mach_info *pd)
{
	struct s3c2410fb_mach_info *npd;

	npd = kmemdup(pd, sizeof(*npd), GFP_KERNEL);
	if (npd) {
		s3c_device_lcd.dev.platform_data = npd;
		npd->displays = kmemdup(pd->displays,
			sizeof(struct s3c2410fb_display) * npd->num_displays,
			GFP_KERNEL);
		if (!npd->displays)
			printk(KERN_ERR "no memory for LCD display data\n");
	} else {
		printk(KERN_ERR "no memory for LCD platform data\n");
	}
}

/* Touchscreen */

static struct resource s3c_ts_resource[] = {
	[0] = {
		.start = S3C24XX_PA_ADC,
		.end   = S3C24XX_PA_ADC + S3C24XX_SZ_ADC - 1,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_TC,
		.end   = IRQ_TC,
		.flags = IORESOURCE_IRQ,
	},

};

struct platform_device s3c_device_ts = {
	.name		  = "s3c2410-ts",
	.id		  = -1,
	.dev.parent	= &s3c_device_adc.dev,
	.num_resources	  = ARRAY_SIZE(s3c_ts_resource),
	.resource	  = s3c_ts_resource,
};
EXPORT_SYMBOL(s3c_device_ts);

static struct s3c2410_ts_mach_info s3c2410ts_info;

void __init s3c24xx_ts_set_platdata(struct s3c2410_ts_mach_info *hard_s3c2410ts_info)
{
	memcpy(&s3c2410ts_info, hard_s3c2410ts_info, sizeof(struct s3c2410_ts_mach_info));
	s3c_device_ts.dev.platform_data = &s3c2410ts_info;
}
EXPORT_SYMBOL(s3c24xx_ts_set_platdata);

/* USB Device (Gadget)*/

static struct resource s3c_usbgadget_resource[] = {
	[0] = {
		.start = S3C24XX_PA_USBDEV,
		.end   = S3C24XX_PA_USBDEV + S3C24XX_SZ_USBDEV - 1,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_USBD,
		.end   = IRQ_USBD,
		.flags = IORESOURCE_IRQ,
	}

};

struct platform_device s3c_device_usbgadget = {
	.name		  = "s3c2410-usbgadget",
	.id		  = -1,
	.num_resources	  = ARRAY_SIZE(s3c_usbgadget_resource),
	.resource	  = s3c_usbgadget_resource,
};

EXPORT_SYMBOL(s3c_device_usbgadget);

void __init s3c24xx_udc_set_platdata(struct s3c2410_udc_mach_info *pd)
{
	struct s3c2410_udc_mach_info *npd;

	npd = kmalloc(sizeof(*npd), GFP_KERNEL);
	if (npd) {
		memcpy(npd, pd, sizeof(*npd));
		s3c_device_usbgadget.dev.platform_data = npd;
	} else {
		printk(KERN_ERR "no memory for udc platform data\n");
	}
}


/* Watchdog */

static struct resource s3c_wdt_resource[] = {
	[0] = {
		.start = S3C24XX_PA_WATCHDOG,
		.end   = S3C24XX_PA_WATCHDOG + S3C24XX_SZ_WATCHDOG - 1,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_WDT,
		.end   = IRQ_WDT,
		.flags = IORESOURCE_IRQ,
	}

};

struct platform_device s3c_device_wdt = {
	.name		  = "s3c2410-wdt",
	.id		  = -1,
	.num_resources	  = ARRAY_SIZE(s3c_wdt_resource),
	.resource	  = s3c_wdt_resource,
};

EXPORT_SYMBOL(s3c_device_wdt);

/* IIS */

static struct resource s3c_iis_resource[] = {
	[0] = {
		.start = S3C24XX_PA_IIS,
		.end   = S3C24XX_PA_IIS + S3C24XX_SZ_IIS -1,
		.flags = IORESOURCE_MEM,
	}
};

static u64 s3c_device_iis_dmamask = 0xffffffffUL;

struct platform_device s3c_device_iis = {
	.name		  = "s3c2410-iis",
	.id		  = -1,
	.num_resources	  = ARRAY_SIZE(s3c_iis_resource),
	.resource	  = s3c_iis_resource,
	.dev              = {
		.dma_mask = &s3c_device_iis_dmamask,
		.coherent_dma_mask = 0xffffffffUL
	}
};

EXPORT_SYMBOL(s3c_device_iis);

/* RTC */

static struct resource s3c_rtc_resource[] = {
	[0] = {
		.start = S3C24XX_PA_RTC,
		.end   = S3C24XX_PA_RTC + 0xff,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_RTC,
		.end   = IRQ_RTC,
		.flags = IORESOURCE_IRQ,
	},
	[2] = {
		.start = IRQ_TICK,
		.end   = IRQ_TICK,
		.flags = IORESOURCE_IRQ
	}
};

struct platform_device s3c_device_rtc = {
	.name		  = "s3c2410-rtc",
	.id		  = -1,
	.num_resources	  = ARRAY_SIZE(s3c_rtc_resource),
	.resource	  = s3c_rtc_resource,
};

EXPORT_SYMBOL(s3c_device_rtc);

/* ADC */

static struct resource s3c_adc_resource[] = {
	[0] = {
		.start = S3C24XX_PA_ADC,
		.end   = S3C24XX_PA_ADC + S3C24XX_SZ_ADC - 1,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_TC,
		.end   = IRQ_TC,
		.flags = IORESOURCE_IRQ,
	},
	[2] = {
		.start = IRQ_ADC,
		.end   = IRQ_ADC,
		.flags = IORESOURCE_IRQ,
	}

};

struct platform_device s3c_device_adc = {
	.name		  = "s3c24xx-adc",
	.id		  = -1,
	.num_resources	  = ARRAY_SIZE(s3c_adc_resource),
	.resource	  = s3c_adc_resource,
};

/* SDI */

static struct resource s3c_sdi_resource[] = {
	[0] = {
		.start = S3C24XX_PA_SDI,
		.end   = S3C24XX_PA_SDI + S3C24XX_SZ_SDI - 1,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_SDI,
		.end   = IRQ_SDI,
		.flags = IORESOURCE_IRQ,
	}

};

struct platform_device s3c_device_sdi = {
	.name		  = "s3c2410-sdi",
	.id		  = -1,
	.num_resources	  = ARRAY_SIZE(s3c_sdi_resource),
	.resource	  = s3c_sdi_resource,
};

EXPORT_SYMBOL(s3c_device_sdi);

void __init s3c24xx_mci_set_platdata(struct s3c24xx_mci_pdata *pdata)
{
	struct s3c24xx_mci_pdata *npd;

	npd = kmemdup(pdata, sizeof(struct s3c24xx_mci_pdata), GFP_KERNEL);
	if (!npd)
		printk(KERN_ERR "%s: no memory to copy pdata", __func__);

	s3c_device_sdi.dev.platform_data = npd;
}


/* SPI (0) */

static struct resource s3c_spi0_resource[] = {
	[0] = {
		.start = S3C24XX_PA_SPI,
		.end   = S3C24XX_PA_SPI + 0x1f,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_SPI0,
		.end   = IRQ_SPI0,
		.flags = IORESOURCE_IRQ,
	}

};
Commit	Line	Data
a21765a7	1	/* linux/arch/arm/plat-s3c24xx/devs.c
1da177e4 LT	2	*
1da177e4 LT	3	* Copyright (c) 2004 Simtec Electronics
916a0021	4	* Ben Dooks <ben@simtec.co.uk>
1da177e4	5	*
916a0021	6	* Base S3C24XX platform device definitions
1da177e4 LT	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*
1da177e4 LT	12	*/
	13
	14	#include <linux/kernel.h>
	15	#include <linux/types.h>
	16	#include <linux/interrupt.h>
	17	#include <linux/list.h>
	18	#include <linux/timer.h>
	19	#include <linux/init.h>
b6d1f542	20	#include <linux/serial_core.h>
d052d1be	21	#include <linux/platform_device.h>
fced80c7	22	#include <linux/io.h>
5a0e3ad6	23	#include <linux/slab.h>
f44c67cd	24	#include <linux/string.h>
1da177e4 LT	25
	26	#include <asm/mach/arch.h>
	27	#include <asm/mach/map.h>
	28	#include <asm/mach/irq.h>
a09e64fb RK	29	#include <mach/fb.h>
a09e64fb RK	30	#include <mach/hardware.h>
d91e9a7a MB	31	#include <mach/dma.h>
d91e9a7a MB	32	#include <mach/irqs.h>
1da177e4 LT	33	#include <asm/irq.h>
1da177e4 LT	34
a2b7ba9c	35	#include <plat/regs-serial.h>
57bd4b91	36	#include <plat/udc.h>
22c810ab	37	#include <plat/mci.h>
1da177e4	38
a2b7ba9c BD	39	#include <plat/devs.h>
a2b7ba9c BD	40	#include <plat/cpu.h>
13622708	41	#include <plat/regs-spi.h>
73e59b1d	42	#include <plat/ts.h>
ce8877b5	43
1da177e4 LT	44	/* Serial port registrations */
1da177e4 LT	45
66a9b49a BD	46	static struct resource s3c2410_uart0_resource[] = {
	47	[0] = {
	48	.start = S3C2410_PA_UART0,
	49	.end = S3C2410_PA_UART0 + 0x3fff,
	50	.flags = IORESOURCE_MEM,
	51	},
	52	[1] = {
	53	.start = IRQ_S3CUART_RX0,
	54	.end = IRQ_S3CUART_ERR0,
	55	.flags = IORESOURCE_IRQ,
	56	}
	57	};
	58
	59	static struct resource s3c2410_uart1_resource[] = {
	60	[0] = {
	61	.start = S3C2410_PA_UART1,
	62	.end = S3C2410_PA_UART1 + 0x3fff,
	63	.flags = IORESOURCE_MEM,
	64	},
	65	[1] = {
	66	.start = IRQ_S3CUART_RX1,
	67	.end = IRQ_S3CUART_ERR1,
	68	.flags = IORESOURCE_IRQ,
	69	}
	70	};
	71
	72	static struct resource s3c2410_uart2_resource[] = {
	73	[0] = {
	74	.start = S3C2410_PA_UART2,
	75	.end = S3C2410_PA_UART2 + 0x3fff,
	76	.flags = IORESOURCE_MEM,
	77	},
	78	[1] = {
	79	.start = IRQ_S3CUART_RX2,
	80	.end = IRQ_S3CUART_ERR2,
	81	.flags = IORESOURCE_IRQ,
	82	}
	83	};
	84
dbf35992 BD	85	static struct resource s3c2410_uart3_resource[] = {
	86	[0] = {
	87	.start = S3C2443_PA_UART3,
	88	.end = S3C2443_PA_UART3 + 0x3fff,
	89	.flags = IORESOURCE_MEM,
	90	},
	91	[1] = {
	92	.start = IRQ_S3CUART_RX3,
	93	.end = IRQ_S3CUART_ERR3,
	94	.flags = IORESOURCE_IRQ,
	95	},
	96	};
	97
66a9b49a BD	98	struct s3c24xx_uart_resources s3c2410_uart_resources[] __initdata = {
	99	[0] = {
	100	.resources = s3c2410_uart0_resource,
	101	.nr_resources = ARRAY_SIZE(s3c2410_uart0_resource),
	102	},
	103	[1] = {
	104	.resources = s3c2410_uart1_resource,
	105	.nr_resources = ARRAY_SIZE(s3c2410_uart1_resource),
	106	},
	107	[2] = {
	108	.resources = s3c2410_uart2_resource,
	109	.nr_resources = ARRAY_SIZE(s3c2410_uart2_resource),
	110	},
dbf35992 BD	111	[3] = {
	112	.resources = s3c2410_uart3_resource,
	113	.nr_resources = ARRAY_SIZE(s3c2410_uart3_resource),
	114	},
66a9b49a BD	115	};
66a9b49a BD	116
1da177e4 LT	117	/* LCD Controller */
	118
	119	static struct resource s3c_lcd_resource[] = {
	120	[0] = {
0367a8d3 LCVR	121	.start = S3C24XX_PA_LCD,
0367a8d3 LCVR	122	.end = S3C24XX_PA_LCD + S3C24XX_SZ_LCD - 1,
1da177e4 LT	123	.flags = IORESOURCE_MEM,
	124	},
	125	[1] = {
	126	.start = IRQ_LCD,
	127	.end = IRQ_LCD,
	128	.flags = IORESOURCE_IRQ,
	129	}
	130
	131	};
	132
	133	static u64 s3c_device_lcd_dmamask = 0xffffffffUL;
	134
	135	struct platform_device s3c_device_lcd = {
	136	.name = "s3c2410-lcd",
	137	.id = -1,
	138	.num_resources = ARRAY_SIZE(s3c_lcd_resource),
	139	.resource = s3c_lcd_resource,
	140	.dev = {
6904b246 BD	141	.dma_mask = &s3c_device_lcd_dmamask,
6904b246 BD	142	.coherent_dma_mask = 0xffffffffUL
1da177e4 LT	143	}
	144	};
	145
	146	EXPORT_SYMBOL(s3c_device_lcd);
	147
893b0309	148	void __init s3c24xx_fb_set_platdata(struct s3c2410fb_mach_info *pd)
f92273c1	149	{
893b0309 BD	150	struct s3c2410fb_mach_info *npd;
893b0309 BD	151
f44c67cd	152	npd = kmemdup(pd, sizeof(*npd), GFP_KERNEL);
893b0309	153	if (npd) {
893b0309	154	s3c_device_lcd.dev.platform_data = npd;
f44c67cd AP	155	npd->displays = kmemdup(pd->displays,
	156	sizeof(struct s3c2410fb_display) * npd->num_displays,
	157	GFP_KERNEL);
	158	if (!npd->displays)
	159	printk(KERN_ERR "no memory for LCD display data\n");
893b0309 BD	160	} else {
	161	printk(KERN_ERR "no memory for LCD platform data\n");
	162	}
f92273c1	163	}
f92273c1	164
ce8877b5	165	/* Touchscreen */
0fe1309b VK	166
	167	static struct resource s3c_ts_resource[] = {
	168	[0] = {
	169	.start = S3C24XX_PA_ADC,
	170	.end = S3C24XX_PA_ADC + S3C24XX_SZ_ADC - 1,
	171	.flags = IORESOURCE_MEM,
	172	},
	173	[1] = {
	174	.start = IRQ_TC,
	175	.end = IRQ_TC,
	176	.flags = IORESOURCE_IRQ,
	177	},
	178
	179	};
	180
ce8877b5 AP	181	struct platform_device s3c_device_ts = {
	182	.name = "s3c2410-ts",
	183	.id = -1,
0fe1309b VK	184	.dev.parent = &s3c_device_adc.dev,
	185	.num_resources = ARRAY_SIZE(s3c_ts_resource),
	186	.resource = s3c_ts_resource,
ce8877b5 AP	187	};
	188	EXPORT_SYMBOL(s3c_device_ts);
	189
	190	static struct s3c2410_ts_mach_info s3c2410ts_info;
	191
	192	void __init s3c24xx_ts_set_platdata(struct s3c2410_ts_mach_info *hard_s3c2410ts_info)
	193	{
	194	memcpy(&s3c2410ts_info, hard_s3c2410ts_info, sizeof(struct s3c2410_ts_mach_info));
	195	s3c_device_ts.dev.platform_data = &s3c2410ts_info;
	196	}
	197	EXPORT_SYMBOL(s3c24xx_ts_set_platdata);
	198
1da177e4 LT	199	/* USB Device (Gadget)*/
	200
	201	static struct resource s3c_usbgadget_resource[] = {
	202	[0] = {
0367a8d3 LCVR	203	.start = S3C24XX_PA_USBDEV,
0367a8d3 LCVR	204	.end = S3C24XX_PA_USBDEV + S3C24XX_SZ_USBDEV - 1,
1da177e4 LT	205	.flags = IORESOURCE_MEM,
	206	},
	207	[1] = {
	208	.start = IRQ_USBD,
	209	.end = IRQ_USBD,
	210	.flags = IORESOURCE_IRQ,
	211	}
	212
	213	};
	214
	215	struct platform_device s3c_device_usbgadget = {
	216	.name = "s3c2410-usbgadget",
	217	.id = -1,
	218	.num_resources = ARRAY_SIZE(s3c_usbgadget_resource),
	219	.resource = s3c_usbgadget_resource,
	220	};
	221
	222	EXPORT_SYMBOL(s3c_device_usbgadget);
	223
0dcfc328 AP	224	void __init s3c24xx_udc_set_platdata(struct s3c2410_udc_mach_info *pd)
	225	{
	226	struct s3c2410_udc_mach_info *npd;
	227
	228	npd = kmalloc(sizeof(*npd), GFP_KERNEL);
	229	if (npd) {
	230	memcpy(npd, pd, sizeof(*npd));
	231	s3c_device_usbgadget.dev.platform_data = npd;
	232	} else {
	233	printk(KERN_ERR "no memory for udc platform data\n");
	234	}
	235	}
	236
	237
1da177e4 LT	238	/* Watchdog */
	239
	240	static struct resource s3c_wdt_resource[] = {
	241	[0] = {
0367a8d3 LCVR	242	.start = S3C24XX_PA_WATCHDOG,
0367a8d3 LCVR	243	.end = S3C24XX_PA_WATCHDOG + S3C24XX_SZ_WATCHDOG - 1,
1da177e4 LT	244	.flags = IORESOURCE_MEM,
	245	},
	246	[1] = {
	247	.start = IRQ_WDT,
	248	.end = IRQ_WDT,
	249	.flags = IORESOURCE_IRQ,
	250	}
	251
	252	};
	253
	254	struct platform_device s3c_device_wdt = {
	255	.name = "s3c2410-wdt",
	256	.id = -1,
	257	.num_resources = ARRAY_SIZE(s3c_wdt_resource),
	258	.resource = s3c_wdt_resource,
	259	};
	260
	261	EXPORT_SYMBOL(s3c_device_wdt);
	262
1da177e4 LT	263	/* IIS */
	264
	265	static struct resource s3c_iis_resource[] = {
	266	[0] = {
0367a8d3 LCVR	267	.start = S3C24XX_PA_IIS,
0367a8d3 LCVR	268	.end = S3C24XX_PA_IIS + S3C24XX_SZ_IIS -1,
1da177e4 LT	269	.flags = IORESOURCE_MEM,
	270	}
	271	};
	272
	273	static u64 s3c_device_iis_dmamask = 0xffffffffUL;
	274
	275	struct platform_device s3c_device_iis = {
	276	.name = "s3c2410-iis",
	277	.id = -1,
	278	.num_resources = ARRAY_SIZE(s3c_iis_resource),
	279	.resource = s3c_iis_resource,
	280	.dev = {
	281	.dma_mask = &s3c_device_iis_dmamask,
	282	.coherent_dma_mask = 0xffffffffUL
	283	}
	284	};
	285
	286	EXPORT_SYMBOL(s3c_device_iis);
	287
	288	/* RTC */
	289
	290	static struct resource s3c_rtc_resource[] = {
	291	[0] = {
0367a8d3 LCVR	292	.start = S3C24XX_PA_RTC,
0367a8d3 LCVR	293	.end = S3C24XX_PA_RTC + 0xff,
1da177e4 LT	294	.flags = IORESOURCE_MEM,
	295	},
	296	[1] = {
	297	.start = IRQ_RTC,
	298	.end = IRQ_RTC,
	299	.flags = IORESOURCE_IRQ,
	300	},
	301	[2] = {
	302	.start = IRQ_TICK,
	303	.end = IRQ_TICK,
	304	.flags = IORESOURCE_IRQ
	305	}
	306	};
	307
	308	struct platform_device s3c_device_rtc = {
	309	.name = "s3c2410-rtc",
	310	.id = -1,
	311	.num_resources = ARRAY_SIZE(s3c_rtc_resource),
	312	.resource = s3c_rtc_resource,
	313	};
	314
	315	EXPORT_SYMBOL(s3c_device_rtc);
	316
	317	/* ADC */
	318
	319	static struct resource s3c_adc_resource[] = {
	320	[0] = {
0367a8d3 LCVR	321	.start = S3C24XX_PA_ADC,
0367a8d3 LCVR	322	.end = S3C24XX_PA_ADC + S3C24XX_SZ_ADC - 1,
1da177e4 LT	323	.flags = IORESOURCE_MEM,
	324	},
	325	[1] = {
	326	.start = IRQ_TC,
083d06ed BD	327	.end = IRQ_TC,
	328	.flags = IORESOURCE_IRQ,
	329	},
	330	[2] = {
	331	.start = IRQ_ADC,
1da177e4 LT	332	.end = IRQ_ADC,
	333	.flags = IORESOURCE_IRQ,
	334	}
	335
	336	};
	337
	338	struct platform_device s3c_device_adc = {
28ab44c5	339	.name = "s3c24xx-adc",
1da177e4 LT	340	.id = -1,
	341	.num_resources = ARRAY_SIZE(s3c_adc_resource),
	342	.resource = s3c_adc_resource,
	343	};
	344
	345	/* SDI */
	346
	347	static struct resource s3c_sdi_resource[] = {
	348	[0] = {
ce46a9c4 BD	349	.start = S3C24XX_PA_SDI,
ce46a9c4 BD	350	.end = S3C24XX_PA_SDI + S3C24XX_SZ_SDI - 1,
1da177e4 LT	351	.flags = IORESOURCE_MEM,
	352	},
	353	[1] = {
	354	.start = IRQ_SDI,
	355	.end = IRQ_SDI,
	356	.flags = IORESOURCE_IRQ,
	357	}
	358
	359	};
	360
	361	struct platform_device s3c_device_sdi = {
	362	.name = "s3c2410-sdi",
	363	.id = -1,
	364	.num_resources = ARRAY_SIZE(s3c_sdi_resource),
	365	.resource = s3c_sdi_resource,
	366	};
	367
	368	EXPORT_SYMBOL(s3c_device_sdi);
	369
1f138f13	370	void __init s3c24xx_mci_set_platdata(struct s3c24xx_mci_pdata *pdata)
22c810ab BD	371	{
	372	struct s3c24xx_mci_pdata *npd;
	373
	374	npd = kmemdup(pdata, sizeof(struct s3c24xx_mci_pdata), GFP_KERNEL);
	375	if (!npd)
	376	printk(KERN_ERR "%s: no memory to copy pdata", __func__);
	377
	378	s3c_device_sdi.dev.platform_data = npd;
	379	}
	380
	381
1da177e4 LT	382	/* SPI (0) */
	383
	384	static struct resource s3c_spi0_resource[] = {
	385	[0] = {
0367a8d3 LCVR	386	.start = S3C24XX_PA_SPI,
0367a8d3 LCVR	387	.end = S3C24XX_PA_SPI + 0x1f,
1da177e4 LT	388	.flags = IORESOURCE_MEM,
	389	},
	390	[1] = {
	391	.start = IRQ_SPI0,
	392	.end = IRQ_SPI0,
	393	.flags = IORESOURCE_IRQ,
	394	}
	395
	396	};
	397