cd5b41d0b5a406122a76e382dd525d58cd25ac3f
[linux-2.6.git] / arch / arm / plat-s3c24xx / devs.c
1 /* linux/arch/arm/plat-s3c24xx/devs.c
2  *
3  * Copyright (c) 2004 Simtec Electronics
4  *      Ben Dooks <ben@simtec.co.uk>
5  *
6  * Base S3C24XX platform device definitions
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  *
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>
20 #include <linux/serial_core.h>
21 #include <linux/platform_device.h>
22 #include <linux/io.h>
23 #include <linux/slab.h>
24 #include <linux/string.h>
25
26 #include <asm/mach/arch.h>
27 #include <asm/mach/map.h>
28 #include <asm/mach/irq.h>
29 #include <mach/fb.h>
30 #include <mach/hardware.h>
31 #include <mach/dma.h>
32 #include <mach/irqs.h>
33 #include <asm/irq.h>
34
35 #include <plat/regs-serial.h>
36 #include <plat/udc.h>
37 #include <plat/mci.h>
38
39 #include <plat/devs.h>
40 #include <plat/cpu.h>
41 #include <plat/regs-spi.h>
42
43 #include <mach/ts.h>
44
45 /* Serial port registrations */
46
47 static struct resource s3c2410_uart0_resource[] = {
48         [0] = {
49                 .start = S3C2410_PA_UART0,
50                 .end   = S3C2410_PA_UART0 + 0x3fff,
51                 .flags = IORESOURCE_MEM,
52         },
53         [1] = {
54                 .start = IRQ_S3CUART_RX0,
55                 .end   = IRQ_S3CUART_ERR0,
56                 .flags = IORESOURCE_IRQ,
57         }
58 };
59
60 static struct resource s3c2410_uart1_resource[] = {
61         [0] = {
62                 .start = S3C2410_PA_UART1,
63                 .end   = S3C2410_PA_UART1 + 0x3fff,
64                 .flags = IORESOURCE_MEM,
65         },
66         [1] = {
67                 .start = IRQ_S3CUART_RX1,
68                 .end   = IRQ_S3CUART_ERR1,
69                 .flags = IORESOURCE_IRQ,
70         }
71 };
72
73 static struct resource s3c2410_uart2_resource[] = {
74         [0] = {
75                 .start = S3C2410_PA_UART2,
76                 .end   = S3C2410_PA_UART2 + 0x3fff,
77                 .flags = IORESOURCE_MEM,
78         },
79         [1] = {
80                 .start = IRQ_S3CUART_RX2,
81                 .end   = IRQ_S3CUART_ERR2,
82                 .flags = IORESOURCE_IRQ,
83         }
84 };
85
86 static struct resource s3c2410_uart3_resource[] = {
87         [0] = {
88                 .start = S3C2443_PA_UART3,
89                 .end   = S3C2443_PA_UART3 + 0x3fff,
90                 .flags = IORESOURCE_MEM,
91         },
92         [1] = {
93                 .start = IRQ_S3CUART_RX3,
94                 .end   = IRQ_S3CUART_ERR3,
95                 .flags = IORESOURCE_IRQ,
96         },
97 };
98
99 struct s3c24xx_uart_resources s3c2410_uart_resources[] __initdata = {
100         [0] = {
101                 .resources      = s3c2410_uart0_resource,
102                 .nr_resources   = ARRAY_SIZE(s3c2410_uart0_resource),
103         },
104         [1] = {
105                 .resources      = s3c2410_uart1_resource,
106                 .nr_resources   = ARRAY_SIZE(s3c2410_uart1_resource),
107         },
108         [2] = {
109                 .resources      = s3c2410_uart2_resource,
110                 .nr_resources   = ARRAY_SIZE(s3c2410_uart2_resource),
111         },
112         [3] = {
113                 .resources      = s3c2410_uart3_resource,
114                 .nr_resources   = ARRAY_SIZE(s3c2410_uart3_resource),
115         },
116 };
117
118 /* LCD Controller */
119
120 static struct resource s3c_lcd_resource[] = {
121         [0] = {
122                 .start = S3C24XX_PA_LCD,
123                 .end   = S3C24XX_PA_LCD + S3C24XX_SZ_LCD - 1,
124                 .flags = IORESOURCE_MEM,
125         },
126         [1] = {
127                 .start = IRQ_LCD,
128                 .end   = IRQ_LCD,
129                 .flags = IORESOURCE_IRQ,
130         }
131
132 };
133
134 static u64 s3c_device_lcd_dmamask = 0xffffffffUL;
135
136 struct platform_device s3c_device_lcd = {
137         .name             = "s3c2410-lcd",
138         .id               = -1,
139         .num_resources    = ARRAY_SIZE(s3c_lcd_resource),
140         .resource         = s3c_lcd_resource,
141         .dev              = {
142                 .dma_mask               = &s3c_device_lcd_dmamask,
143                 .coherent_dma_mask      = 0xffffffffUL
144         }
145 };
146
147 EXPORT_SYMBOL(s3c_device_lcd);
148
149 void __init s3c24xx_fb_set_platdata(struct s3c2410fb_mach_info *pd)
150 {
151         struct s3c2410fb_mach_info *npd;
152
153         npd = kmemdup(pd, sizeof(*npd), GFP_KERNEL);
154         if (npd) {
155                 s3c_device_lcd.dev.platform_data = npd;
156                 npd->displays = kmemdup(pd->displays,
157                         sizeof(struct s3c2410fb_display) * npd->num_displays,
158                         GFP_KERNEL);
159                 if (!npd->displays)
160                         printk(KERN_ERR "no memory for LCD display data\n");
161         } else {
162                 printk(KERN_ERR "no memory for LCD platform data\n");
163         }
164 }
165
166 /* Touchscreen */
167
168 static struct resource s3c_ts_resource[] = {
169         [0] = {
170                 .start = S3C24XX_PA_ADC,
171                 .end   = S3C24XX_PA_ADC + S3C24XX_SZ_ADC - 1,
172                 .flags = IORESOURCE_MEM,
173         },
174         [1] = {
175                 .start = IRQ_TC,
176                 .end   = IRQ_TC,
177                 .flags = IORESOURCE_IRQ,
178         },
179
180 };
181
182 struct platform_device s3c_device_ts = {
183         .name             = "s3c2410-ts",
184         .id               = -1,
185         .dev.parent     = &s3c_device_adc.dev,
186         .num_resources    = ARRAY_SIZE(s3c_ts_resource),
187         .resource         = s3c_ts_resource,
188 };
189 EXPORT_SYMBOL(s3c_device_ts);
190
191 static struct s3c2410_ts_mach_info s3c2410ts_info;
192
193 void __init s3c24xx_ts_set_platdata(struct s3c2410_ts_mach_info *hard_s3c2410ts_info)
194 {
195         memcpy(&s3c2410ts_info, hard_s3c2410ts_info, sizeof(struct s3c2410_ts_mach_info));
196         s3c_device_ts.dev.platform_data = &s3c2410ts_info;
197 }
198 EXPORT_SYMBOL(s3c24xx_ts_set_platdata);
199
200 /* USB Device (Gadget)*/
201
202 static struct resource s3c_usbgadget_resource[] = {
203         [0] = {
204                 .start = S3C24XX_PA_USBDEV,
205                 .end   = S3C24XX_PA_USBDEV + S3C24XX_SZ_USBDEV - 1,
206                 .flags = IORESOURCE_MEM,
207         },
208         [1] = {
209                 .start = IRQ_USBD,
210                 .end   = IRQ_USBD,
211                 .flags = IORESOURCE_IRQ,
212         }
213
214 };
215
216 struct platform_device s3c_device_usbgadget = {
217         .name             = "s3c2410-usbgadget",
218         .id               = -1,
219         .num_resources    = ARRAY_SIZE(s3c_usbgadget_resource),
220         .resource         = s3c_usbgadget_resource,
221 };
222
223 EXPORT_SYMBOL(s3c_device_usbgadget);
224
225 void __init s3c24xx_udc_set_platdata(struct s3c2410_udc_mach_info *pd)
226 {
227         struct s3c2410_udc_mach_info *npd;
228
229         npd = kmalloc(sizeof(*npd), GFP_KERNEL);
230         if (npd) {
231                 memcpy(npd, pd, sizeof(*npd));
232                 s3c_device_usbgadget.dev.platform_data = npd;
233         } else {
234                 printk(KERN_ERR "no memory for udc platform data\n");
235         }
236 }
237
238
239 /* Watchdog */
240
241 static struct resource s3c_wdt_resource[] = {
242         [0] = {
243                 .start = S3C24XX_PA_WATCHDOG,
244                 .end   = S3C24XX_PA_WATCHDOG + S3C24XX_SZ_WATCHDOG - 1,
245                 .flags = IORESOURCE_MEM,
246         },
247         [1] = {
248                 .start = IRQ_WDT,
249                 .end   = IRQ_WDT,
250                 .flags = IORESOURCE_IRQ,
251         }
252
253 };
254
255 struct platform_device s3c_device_wdt = {
256         .name             = "s3c2410-wdt",
257         .id               = -1,
258         .num_resources    = ARRAY_SIZE(s3c_wdt_resource),
259         .resource         = s3c_wdt_resource,
260 };
261
262 EXPORT_SYMBOL(s3c_device_wdt);
263
264 /* IIS */
265
266 static struct resource s3c_iis_resource[] = {
267         [0] = {
268                 .start = S3C24XX_PA_IIS,
269                 .end   = S3C24XX_PA_IIS + S3C24XX_SZ_IIS -1,
270                 .flags = IORESOURCE_MEM,
271         }
272 };
273
274 static u64 s3c_device_iis_dmamask = 0xffffffffUL;
275
276 struct platform_device s3c_device_iis = {
277         .name             = "s3c2410-iis",
278         .id               = -1,
279         .num_resources    = ARRAY_SIZE(s3c_iis_resource),
280         .resource         = s3c_iis_resource,
281         .dev              = {
282                 .dma_mask = &s3c_device_iis_dmamask,
283                 .coherent_dma_mask = 0xffffffffUL
284         }
285 };
286
287 EXPORT_SYMBOL(s3c_device_iis);
288
289 /* RTC */
290
291 static struct resource s3c_rtc_resource[] = {
292         [0] = {
293                 .start = S3C24XX_PA_RTC,
294                 .end   = S3C24XX_PA_RTC + 0xff,
295                 .flags = IORESOURCE_MEM,
296         },
297         [1] = {
298                 .start = IRQ_RTC,
299                 .end   = IRQ_RTC,
300                 .flags = IORESOURCE_IRQ,
301         },
302         [2] = {
303                 .start = IRQ_TICK,
304                 .end   = IRQ_TICK,
305                 .flags = IORESOURCE_IRQ
306         }
307 };
308
309 struct platform_device s3c_device_rtc = {
310         .name             = "s3c2410-rtc",
311         .id               = -1,
312         .num_resources    = ARRAY_SIZE(s3c_rtc_resource),
313         .resource         = s3c_rtc_resource,
314 };
315
316 EXPORT_SYMBOL(s3c_device_rtc);
317
318 /* ADC */
319
320 static struct resource s3c_adc_resource[] = {
321         [0] = {
322                 .start = S3C24XX_PA_ADC,
323                 .end   = S3C24XX_PA_ADC + S3C24XX_SZ_ADC - 1,
324                 .flags = IORESOURCE_MEM,
325         },
326         [1] = {
327                 .start = IRQ_TC,
328                 .end   = IRQ_TC,
329                 .flags = IORESOURCE_IRQ,
330         },
331         [2] = {
332                 .start = IRQ_ADC,
333                 .end   = IRQ_ADC,
334                 .flags = IORESOURCE_IRQ,
335         }
336
337 };
338
339 struct platform_device s3c_device_adc = {
340         .name             = "s3c24xx-adc",
341         .id               = -1,
342         .num_resources    = ARRAY_SIZE(s3c_adc_resource),
343         .resource         = s3c_adc_resource,
344 };
345
346 /* SDI */
347
348 static struct resource s3c_sdi_resource[] = {
349         [0] = {
350                 .start = S3C24XX_PA_SDI,
351                 .end   = S3C24XX_PA_SDI + S3C24XX_SZ_SDI - 1,
352                 .flags = IORESOURCE_MEM,
353         },
354         [1] = {
355                 .start = IRQ_SDI,
356                 .end   = IRQ_SDI,
357                 .flags = IORESOURCE_IRQ,
358         }
359
360 };
361
362 struct platform_device s3c_device_sdi = {
363         .name             = "s3c2410-sdi",
364         .id               = -1,
365         .num_resources    = ARRAY_SIZE(s3c_sdi_resource),
366         .resource         = s3c_sdi_resource,
367 };
368
369 EXPORT_SYMBOL(s3c_device_sdi);
370
371 void __init s3c24xx_mci_set_platdata(struct s3c24xx_mci_pdata *pdata)
372 {
373         struct s3c24xx_mci_pdata *npd;
374
375         npd = kmemdup(pdata, sizeof(struct s3c24xx_mci_pdata), GFP_KERNEL);
376         if (!npd)
377                 printk(KERN_ERR "%s: no memory to copy pdata", __func__);
378
379         s3c_device_sdi.dev.platform_data = npd;
380 }
381
382
383 /* SPI (0) */
384
385 static struct resource s3c_spi0_resource[] = {
386         [0] = {
387                 .start = S3C24XX_PA_SPI,
388                 .end   = S3C24XX_PA_SPI + 0x1f,
389                 .flags = IORESOURCE_MEM,
390         },
391         [1] = {
392                 .start = IRQ_SPI0,
393                 .end   = IRQ_SPI0,
394                 .flags = IORESOURCE_IRQ,
395         }
396
397 };
398
399 static u64 s3c_device_spi0_dmamask = 0xffffffffUL;
400
401 struct platform_device s3c_device_spi0 = {
402         .name             = "s3c2410-spi",
403         .id               = 0,
404         .num_resources    = ARRAY_SIZE(s3c_spi0_resource),
405         .resource         = s3c_spi0_resource,
406         .dev              = {
407                 .dma_mask = &s3c_device_spi0_dmamask,
408                 .coherent_dma_mask = 0xffffffffUL
409         }
410 };
411
412 EXPORT_SYMBOL(s3c_device_spi0);
413
414 /* SPI (1) */
415
416 static struct resource s3c_spi1_resource[] = {
417         [0] = {
418                 .start = S3C24XX_PA_SPI + S3C2410_SPI1,
419                 .end   = S3C24XX_PA_SPI + S3C2410_SPI1 + 0x1f,
420                 .flags = IORESOURCE_MEM,
421         },
422         [1] = {
423                 .start = IRQ_SPI1,
424                 .end   = IRQ_SPI1,
425                 .flags = IORESOURCE_IRQ,
426         }
427
428 };
429
430 static u64 s3c_device_spi1_dmamask = 0xffffffffUL;
431
432 struct platform_device s3c_device_spi1 = {
433         .name             = "s3c2410-spi",
434         .id               = 1,
435         .num_resources    = ARRAY_SIZE(s3c_spi1_resource),
436         .resource         = s3c_spi1_resource,
437         .dev              = {
438                 .dma_mask = &s3c_device_spi1_dmamask,
439                 .coherent_dma_mask = 0xffffffffUL
440         }
441 };
442
443 EXPORT_SYMBOL(s3c_device_spi1);
444
445 #ifdef CONFIG_CPU_S3C2440
446
447 /* Camif Controller */
448
449 static struct resource s3c_camif_resource[] = {
450         [0] = {
451                 .start = S3C2440_PA_CAMIF,
452                 .end   = S3C2440_PA_CAMIF + S3C2440_SZ_CAMIF - 1,
453                 .flags = IORESOURCE_MEM,
454         },
455         [1] = {
456                 .start = IRQ_CAM,
457                 .end   = IRQ_CAM,
458                 .flags = IORESOURCE_IRQ,
459         }
460
461 };
462
463 static u64 s3c_device_camif_dmamask = 0xffffffffUL;
464
465 struct platform_device s3c_device_camif = {
466         .name             = "s3c2440-camif",
467         .id               = -1,
468         .num_resources    = ARRAY_SIZE(s3c_camif_resource),
469         .resource         = s3c_camif_resource,
470         .dev              = {
471                 .dma_mask = &s3c_device_camif_dmamask,
472                 .coherent_dma_mask = 0xffffffffUL
473         }
474 };
475
476 EXPORT_SYMBOL(s3c_device_camif);
477
478 /* AC97 */
479
480 static struct resource s3c_ac97_resource[] = {
481         [0] = {
482                 .start = S3C2440_PA_AC97,
483                 .end   = S3C2440_PA_AC97 + S3C2440_SZ_AC97 -1,
484                 .flags = IORESOURCE_MEM,
485         },
486         [1] = {
487                 .start = IRQ_S3C244x_AC97,
488                 .end   = IRQ_S3C244x_AC97,
489                 .flags = IORESOURCE_IRQ,
490         },
491         [2] = {
492                 .name  = "PCM out",
493                 .start = DMACH_PCM_OUT,
494                 .end   = DMACH_PCM_OUT,
495                 .flags = IORESOURCE_DMA,
496         },
497         [3] = {
498                 .name  = "PCM in",
499                 .start = DMACH_PCM_IN,
500                 .end   = DMACH_PCM_IN,
501                 .flags = IORESOURCE_DMA,
502         },
503         [4] = {
504                 .name  = "Mic in",
505                 .start = DMACH_MIC_IN,
506                 .end   = DMACH_MIC_IN,
507                 .flags = IORESOURCE_DMA,
508         },
509 };
510
511 static u64 s3c_device_ac97_dmamask = 0xffffffffUL;
512
513 struct platform_device s3c_device_ac97 = {
514         .name             = "s3c-ac97",
515         .id               = -1,
516         .num_resources    = ARRAY_SIZE(s3c_ac97_resource),
517         .resource         = s3c_ac97_resource,
518         .dev              = {
519                 .dma_mask = &s3c_device_ac97_dmamask,
520                 .coherent_dma_mask = 0xffffffffUL
521         }
522 };
523
524 EXPORT_SYMBOL(s3c_device_ac97);
525
526 #endif // CONFIG_CPU_S32440