[deliverable/linux.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 <asm/mach/arch.h>
#include <asm/mach/map.h>
#include <asm/mach/irq.h>
#include <mach/fb.h>
#include <mach/hardware.h>
#include <asm/irq.h>

#include <asm/plat-s3c/regs-serial.h>
#include <asm/plat-s3c24xx/udc.h>

#include <asm/plat-s3c24xx/devs.h>
#include <asm/plat-s3c24xx/cpu.h>
#include <asm/plat-s3c24xx/regs-spi.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,
	}
};

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),
	},
};

/* yart devices */

static struct platform_device s3c24xx_uart_device0 = {
	.id		= 0,
};

static struct platform_device s3c24xx_uart_device1 = {
	.id		= 1,
};

static struct platform_device s3c24xx_uart_device2 = {
	.id		= 2,
};

struct platform_device *s3c24xx_uart_src[3] = {
	&s3c24xx_uart_device0,
	&s3c24xx_uart_device1,
	&s3c24xx_uart_device2,
};

struct platform_device *s3c24xx_uart_devs[3] = {
};

/* USB Host Controller */

static struct resource s3c_usb_resource[] = {
	[0] = {
		.start = S3C24XX_PA_USBHOST,
		.end   = S3C24XX_PA_USBHOST + S3C24XX_SZ_USBHOST - 1,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_USBH,
		.end   = IRQ_USBH,
		.flags = IORESOURCE_IRQ,
	}
};

static u64 s3c_device_usb_dmamask = 0xffffffffUL;

struct platform_device s3c_device_usb = {
	.name		  = "s3c2410-ohci",
	.id		  = -1,
	.num_resources	  = ARRAY_SIZE(s3c_usb_resource),
	.resource	  = s3c_usb_resource,
	.dev              = {
		.dma_mask = &s3c_device_usb_dmamask,
		.coherent_dma_mask = 0xffffffffUL
	}
};

EXPORT_SYMBOL(s3c_device_usb);

/* 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 = kmalloc(sizeof(*npd), GFP_KERNEL);
	if (npd) {
		memcpy(npd, pd, sizeof(*npd));
		s3c_device_lcd.dev.platform_data = npd;
	} else {
		printk(KERN_ERR "no memory for LCD platform data\n");
	}
}

/* NAND Controller */

static struct resource s3c_nand_resource[] = {
	[0] = {
		.start = S3C2410_PA_NAND,
		.end   = S3C2410_PA_NAND + S3C24XX_SZ_NAND - 1,
		.flags = IORESOURCE_MEM,
	}
};

struct platform_device s3c_device_nand = {
	.name		  = "s3c2410-nand",
	.id		  = -1,
	.num_resources	  = ARRAY_SIZE(s3c_nand_resource),
	.resource	  = s3c_nand_resource,
};

EXPORT_SYMBOL(s3c_device_nand);

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

/* I2C */

static struct resource s3c_i2c_resource[] = {
	[0] = {
		.start = S3C24XX_PA_IIC,
		.end   = S3C24XX_PA_IIC + S3C24XX_SZ_IIC - 1,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_IIC,
		.end   = IRQ_IIC,
		.flags = IORESOURCE_IRQ,
	}

};

struct platform_device s3c_device_i2c = {
	.name		  = "s3c2410-i2c",
	.id		  = -1,
	.num_resources	  = ARRAY_SIZE(s3c_i2c_resource),
	.resource	  = s3c_i2c_resource,
};

EXPORT_SYMBOL(s3c_device_i2c);

/* 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		  = "s3c2410-adc",
	.id		  = -1,
	.num_resources	  = ARRAY_SIZE(s3c_adc_resource),
	.resource	  = s3c_adc_resource,
};

/* SDI */

static struct resource s3c_sdi_resource[] = {
	[0] = {
		.start = S3C2410_PA_SDI,
		.end   = S3C2410_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);

/* High-speed MMC/SD */

static struct resource s3c_hsmmc_resource[] = {
	[0] = {
		.start = S3C2443_PA_HSMMC,
		.end   = S3C2443_PA_HSMMC + S3C2443_SZ_HSMMC - 1,
		.flags = IORESOURCE_MEM,
	},
	[1] = {
		.start = IRQ_S3C2443_HSMMC,
		.end   = IRQ_S3C2443_HSMMC,
		.flags = IORESOURCE_IRQ,
	}
};

static u64 s3c_device_hsmmc_dmamask = 0xffffffffUL;

struct platform_device s3c_device_hsmmc = {
	.name		  = "s3c-sdhci",
	.id		  = -1,
	.num_resources	  = ARRAY_SIZE(s3c_hsmmc_resource),
	.resource	  = s3c_hsmmc_resource,
	.dev              = {
		.dma_mask = &s3c_device_hsmmc_dmamask,
		.coherent_dma_mask = 0xffffffffUL
	}
};


/* 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>
1da177e4 LT	23
	24	#include <asm/mach/arch.h>
	25	#include <asm/mach/map.h>
	26	#include <asm/mach/irq.h>
a09e64fb RK	27	#include <mach/fb.h>
a09e64fb RK	28	#include <mach/hardware.h>
1da177e4 LT	29	#include <asm/irq.h>
1da177e4 LT	30
531b617c	31	#include <asm/plat-s3c/regs-serial.h>
06cfa556	32	#include <asm/plat-s3c24xx/udc.h>
1da177e4	33
a21765a7 BD	34	#include <asm/plat-s3c24xx/devs.h>
a21765a7 BD	35	#include <asm/plat-s3c24xx/cpu.h>
06cfa556	36	#include <asm/plat-s3c24xx/regs-spi.h>
1da177e4 LT	37
	38	/* Serial port registrations */
	39
66a9b49a BD	40	static struct resource s3c2410_uart0_resource[] = {
	41	[0] = {
	42	.start = S3C2410_PA_UART0,
	43	.end = S3C2410_PA_UART0 + 0x3fff,
	44	.flags = IORESOURCE_MEM,
	45	},
	46	[1] = {
	47	.start = IRQ_S3CUART_RX0,
	48	.end = IRQ_S3CUART_ERR0,
	49	.flags = IORESOURCE_IRQ,
	50	}
	51	};
	52
	53	static struct resource s3c2410_uart1_resource[] = {
	54	[0] = {
	55	.start = S3C2410_PA_UART1,
	56	.end = S3C2410_PA_UART1 + 0x3fff,
	57	.flags = IORESOURCE_MEM,
	58	},
	59	[1] = {
	60	.start = IRQ_S3CUART_RX1,
	61	.end = IRQ_S3CUART_ERR1,
	62	.flags = IORESOURCE_IRQ,
	63	}
	64	};
	65
	66	static struct resource s3c2410_uart2_resource[] = {
	67	[0] = {
	68	.start = S3C2410_PA_UART2,
	69	.end = S3C2410_PA_UART2 + 0x3fff,
	70	.flags = IORESOURCE_MEM,
	71	},
	72	[1] = {
	73	.start = IRQ_S3CUART_RX2,
	74	.end = IRQ_S3CUART_ERR2,
	75	.flags = IORESOURCE_IRQ,
	76	}
	77	};
	78
	79	struct s3c24xx_uart_resources s3c2410_uart_resources[] __initdata = {
	80	[0] = {
	81	.resources = s3c2410_uart0_resource,
	82	.nr_resources = ARRAY_SIZE(s3c2410_uart0_resource),
	83	},
	84	[1] = {
	85	.resources = s3c2410_uart1_resource,
	86	.nr_resources = ARRAY_SIZE(s3c2410_uart1_resource),
	87	},
	88	[2] = {
	89	.resources = s3c2410_uart2_resource,
	90	.nr_resources = ARRAY_SIZE(s3c2410_uart2_resource),
	91	},
	92	};
	93
	94	/* yart devices */
	95
	96	static struct platform_device s3c24xx_uart_device0 = {
	97	.id = 0,
	98	};
	99
	100	static struct platform_device s3c24xx_uart_device1 = {
	101	.id = 1,
	102	};
	103
104	static struct platform_device s3c24xx_uart_device2 = {
105	.id = 2,
106	};
107
108	struct platform_device *s3c24xx_uart_src[3] = {
109	&s3c24xx_uart_device0,
110	&s3c24xx_uart_device1,
111	&s3c24xx_uart_device2,
112	};
113
114	struct platform_device *s3c24xx_uart_devs[3] = {
115	};
1da177e4 LT	116
	117	/* USB Host Controller */
	118
	119	static struct resource s3c_usb_resource[] = {
	120	[0] = {
0367a8d3 LCVR	121	.start = S3C24XX_PA_USBHOST,
0367a8d3 LCVR	122	.end = S3C24XX_PA_USBHOST + S3C24XX_SZ_USBHOST - 1,
1da177e4 LT	123	.flags = IORESOURCE_MEM,
	124	},
	125	[1] = {
	126	.start = IRQ_USBH,
	127	.end = IRQ_USBH,
	128	.flags = IORESOURCE_IRQ,
	129	}
	130	};
	131
	132	static u64 s3c_device_usb_dmamask = 0xffffffffUL;
	133
	134	struct platform_device s3c_device_usb = {
	135	.name = "s3c2410-ohci",
	136	.id = -1,
	137	.num_resources = ARRAY_SIZE(s3c_usb_resource),
	138	.resource = s3c_usb_resource,
	139	.dev = {
	140	.dma_mask = &s3c_device_usb_dmamask,
	141	.coherent_dma_mask = 0xffffffffUL
	142	}
	143	};
	144
	145	EXPORT_SYMBOL(s3c_device_usb);
	146
	147	/* LCD Controller */
	148
	149	static struct resource s3c_lcd_resource[] = {
	150	[0] = {
0367a8d3 LCVR	151	.start = S3C24XX_PA_LCD,
0367a8d3 LCVR	152	.end = S3C24XX_PA_LCD + S3C24XX_SZ_LCD - 1,
1da177e4 LT	153	.flags = IORESOURCE_MEM,
	154	},
	155	[1] = {
	156	.start = IRQ_LCD,
	157	.end = IRQ_LCD,
	158	.flags = IORESOURCE_IRQ,
	159	}
	160
	161	};
	162
	163	static u64 s3c_device_lcd_dmamask = 0xffffffffUL;
	164
	165	struct platform_device s3c_device_lcd = {
	166	.name = "s3c2410-lcd",
	167	.id = -1,
	168	.num_resources = ARRAY_SIZE(s3c_lcd_resource),
	169	.resource = s3c_lcd_resource,
	170	.dev = {
6904b246 BD	171	.dma_mask = &s3c_device_lcd_dmamask,
6904b246 BD	172	.coherent_dma_mask = 0xffffffffUL
1da177e4 LT	173	}
	174	};
	175
	176	EXPORT_SYMBOL(s3c_device_lcd);
	177
893b0309	178	void __init s3c24xx_fb_set_platdata(struct s3c2410fb_mach_info *pd)
f92273c1	179	{
893b0309 BD	180	struct s3c2410fb_mach_info *npd;
	181
	182	npd = kmalloc(sizeof(*npd), GFP_KERNEL);
	183	if (npd) {
	184	memcpy(npd, pd, sizeof(*npd));
	185	s3c_device_lcd.dev.platform_data = npd;
	186	} else {
	187	printk(KERN_ERR "no memory for LCD platform data\n");
	188	}
f92273c1	189	}
f92273c1	190
1da177e4 LT	191	/* NAND Controller */
	192
	193	static struct resource s3c_nand_resource[] = {
	194	[0] = {
	195	.start = S3C2410_PA_NAND,
a0e0adb9	196	.end = S3C2410_PA_NAND + S3C24XX_SZ_NAND - 1,
1da177e4 LT	197	.flags = IORESOURCE_MEM,
	198	}
	199	};
	200
	201	struct platform_device s3c_device_nand = {
	202	.name = "s3c2410-nand",
	203	.id = -1,
	204	.num_resources = ARRAY_SIZE(s3c_nand_resource),
	205	.resource = s3c_nand_resource,
	206	};
	207
	208	EXPORT_SYMBOL(s3c_device_nand);
	209
	210	/* USB Device (Gadget)*/
	211
	212	static struct resource s3c_usbgadget_resource[] = {
	213	[0] = {
0367a8d3 LCVR	214	.start = S3C24XX_PA_USBDEV,
0367a8d3 LCVR	215	.end = S3C24XX_PA_USBDEV + S3C24XX_SZ_USBDEV - 1,
1da177e4 LT	216	.flags = IORESOURCE_MEM,
	217	},
	218	[1] = {
	219	.start = IRQ_USBD,
	220	.end = IRQ_USBD,
	221	.flags = IORESOURCE_IRQ,
	222	}
	223
	224	};
	225
	226	struct platform_device s3c_device_usbgadget = {
	227	.name = "s3c2410-usbgadget",
	228	.id = -1,
	229	.num_resources = ARRAY_SIZE(s3c_usbgadget_resource),
	230	.resource = s3c_usbgadget_resource,
	231	};
	232
	233	EXPORT_SYMBOL(s3c_device_usbgadget);
	234
0dcfc328 AP	235	void __init s3c24xx_udc_set_platdata(struct s3c2410_udc_mach_info *pd)
	236	{
	237	struct s3c2410_udc_mach_info *npd;
	238
	239	npd = kmalloc(sizeof(*npd), GFP_KERNEL);
	240	if (npd) {
	241	memcpy(npd, pd, sizeof(*npd));
	242	s3c_device_usbgadget.dev.platform_data = npd;
	243	} else {
	244	printk(KERN_ERR "no memory for udc platform data\n");
	245	}
	246	}
	247
	248
1da177e4 LT	249	/* Watchdog */
	250
	251	static struct resource s3c_wdt_resource[] = {
	252	[0] = {
0367a8d3 LCVR	253	.start = S3C24XX_PA_WATCHDOG,
0367a8d3 LCVR	254	.end = S3C24XX_PA_WATCHDOG + S3C24XX_SZ_WATCHDOG - 1,
1da177e4 LT	255	.flags = IORESOURCE_MEM,
	256	},
	257	[1] = {
	258	.start = IRQ_WDT,
	259	.end = IRQ_WDT,
	260	.flags = IORESOURCE_IRQ,
	261	}
	262
	263	};
	264
	265	struct platform_device s3c_device_wdt = {
	266	.name = "s3c2410-wdt",
	267	.id = -1,
	268	.num_resources = ARRAY_SIZE(s3c_wdt_resource),
	269	.resource = s3c_wdt_resource,
	270	};
	271
	272	EXPORT_SYMBOL(s3c_device_wdt);
	273
	274	/* I2C */
	275
	276	static struct resource s3c_i2c_resource[] = {
	277	[0] = {
0367a8d3 LCVR	278	.start = S3C24XX_PA_IIC,
0367a8d3 LCVR	279	.end = S3C24XX_PA_IIC + S3C24XX_SZ_IIC - 1,
1da177e4 LT	280	.flags = IORESOURCE_MEM,
	281	},
	282	[1] = {
	283	.start = IRQ_IIC,
	284	.end = IRQ_IIC,
	285	.flags = IORESOURCE_IRQ,
	286	}
	287
	288	};
	289
	290	struct platform_device s3c_device_i2c = {
	291	.name = "s3c2410-i2c",
	292	.id = -1,
	293	.num_resources = ARRAY_SIZE(s3c_i2c_resource),
	294	.resource = s3c_i2c_resource,
	295	};
	296
	297	EXPORT_SYMBOL(s3c_device_i2c);
	298
	299	/* IIS */
	300
	301	static struct resource s3c_iis_resource[] = {
	302	[0] = {
0367a8d3 LCVR	303	.start = S3C24XX_PA_IIS,
0367a8d3 LCVR	304	.end = S3C24XX_PA_IIS + S3C24XX_SZ_IIS -1,
1da177e4 LT	305	.flags = IORESOURCE_MEM,
	306	}
	307	};
	308
	309	static u64 s3c_device_iis_dmamask = 0xffffffffUL;
	310
	311	struct platform_device s3c_device_iis = {
	312	.name = "s3c2410-iis",
	313	.id = -1,
	314	.num_resources = ARRAY_SIZE(s3c_iis_resource),
	315	.resource = s3c_iis_resource,
	316	.dev = {
	317	.dma_mask = &s3c_device_iis_dmamask,
	318	.coherent_dma_mask = 0xffffffffUL
	319	}
	320	};
	321
	322	EXPORT_SYMBOL(s3c_device_iis);
	323
	324	/* RTC */
	325
	326	static struct resource s3c_rtc_resource[] = {
	327	[0] = {
0367a8d3 LCVR	328	.start = S3C24XX_PA_RTC,
0367a8d3 LCVR	329	.end = S3C24XX_PA_RTC + 0xff,
1da177e4 LT	330	.flags = IORESOURCE_MEM,
	331	},
	332	[1] = {
	333	.start = IRQ_RTC,
	334	.end = IRQ_RTC,
	335	.flags = IORESOURCE_IRQ,
	336	},
	337	[2] = {
	338	.start = IRQ_TICK,
	339	.end = IRQ_TICK,
	340	.flags = IORESOURCE_IRQ
	341	}
	342	};
	343
	344	struct platform_device s3c_device_rtc = {
	345	.name = "s3c2410-rtc",
	346	.id = -1,
	347	.num_resources = ARRAY_SIZE(s3c_rtc_resource),
	348	.resource = s3c_rtc_resource,
	349	};
	350
	351	EXPORT_SYMBOL(s3c_device_rtc);
	352
	353	/* ADC */
	354
	355	static struct resource s3c_adc_resource[] = {
	356	[0] = {
0367a8d3 LCVR	357	.start = S3C24XX_PA_ADC,
0367a8d3 LCVR	358	.end = S3C24XX_PA_ADC + S3C24XX_SZ_ADC - 1,
1da177e4 LT	359	.flags = IORESOURCE_MEM,
	360	},
	361	[1] = {
	362	.start = IRQ_TC,
083d06ed BD	363	.end = IRQ_TC,
	364	.flags = IORESOURCE_IRQ,
	365	},
	366	[2] = {
	367	.start = IRQ_ADC,
1da177e4 LT	368	.end = IRQ_ADC,
	369	.flags = IORESOURCE_IRQ,
	370	}
	371
	372	};
	373
	374	struct platform_device s3c_device_adc = {
	375	.name = "s3c2410-adc",
	376	.id = -1,
	377	.num_resources = ARRAY_SIZE(s3c_adc_resource),
	378	.resource = s3c_adc_resource,
	379	};
	380
	381	/* SDI */
	382
	383	static struct resource s3c_sdi_resource[] = {
	384	[0] = {
	385	.start = S3C2410_PA_SDI,
a0e0adb9	386	.end = S3C2410_PA_SDI + S3C24XX_SZ_SDI - 1,
1da177e4 LT	387	.flags = IORESOURCE_MEM,
	388	},
	389	[1] = {
	390	.start = IRQ_SDI,
	391	.end = IRQ_SDI,
	392	.flags = IORESOURCE_IRQ,
	393	}
	394
	395	};
	396
	397	struct platform_device s3c_device_sdi = {
	398	.name = "s3c2410-sdi",
	399	.id = -1,
	400	.num_resources = ARRAY_SIZE(s3c_sdi_resource),
	401	.resource = s3c_sdi_resource,
	402	};
	403
	404	EXPORT_SYMBOL(s3c_device_sdi);
	405
69e9c93d BD	406	/* High-speed MMC/SD */
	407
	408	static struct resource s3c_hsmmc_resource[] = {
	409	[0] = {
	410	.start = S3C2443_PA_HSMMC,
	411	.end = S3C2443_PA_HSMMC + S3C2443_SZ_HSMMC - 1,
	412	.flags = IORESOURCE_MEM,
	413	},
	414	[1] = {
	415	.start = IRQ_S3C2443_HSMMC,
	416	.end = IRQ_S3C2443_HSMMC,
	417	.flags = IORESOURCE_IRQ,
	418	}
	419	};
	420
	421	static u64 s3c_device_hsmmc_dmamask = 0xffffffffUL;
	422
	423	struct platform_device s3c_device_hsmmc = {
	424	.name = "s3c-sdhci",
	425	.id = -1,
	426	.num_resources = ARRAY_SIZE(s3c_hsmmc_resource),
	427	.resource = s3c_hsmmc_resource,
	428	.dev = {
	429	.dma_mask = &s3c_device_hsmmc_dmamask,
	430	.coherent_dma_mask = 0xffffffffUL
	431	}
	432	};
	433
	434
	435
1da177e4 LT	436	/* SPI (0) */
	437
	438	static struct resource s3c_spi0_resource[] = {
	439	[0] = {
0367a8d3 LCVR	440	.start = S3C24XX_PA_SPI,
0367a8d3 LCVR	441	.end = S3C24XX_PA_SPI + 0x1f,
1da177e4 LT	442	.flags = IORESOURCE_MEM,
	443	},
	444	[1] = {
	445	.start = IRQ_SPI0,
	446	.end = IRQ_SPI0,
	447	.flags = IORESOURCE_IRQ,
	448	}
	449
	450	};
	451