Merge branch 'next-spi' of git://git.secretlab.ca/git/linux-2.6
[linux-2.6.git] / arch / arm / mach-pxa / devices.c
1 #include <linux/module.h>
2 #include <linux/kernel.h>
3 #include <linux/init.h>
4 #include <linux/platform_device.h>
5 #include <linux/dma-mapping.h>
6 #include <linux/spi/pxa2xx_spi.h>
7
8 #include <asm/pmu.h>
9 #include <mach/udc.h>
10 #include <mach/pxa3xx-u2d.h>
11 #include <mach/pxafb.h>
12 #include <mach/mmc.h>
13 #include <mach/irda.h>
14 #include <mach/ohci.h>
15 #include <plat/pxa27x_keypad.h>
16 #include <mach/camera.h>
17 #include <mach/audio.h>
18 #include <mach/hardware.h>
19 #include <plat/i2c.h>
20 #include <plat/pxa3xx_nand.h>
21
22 #include "devices.h"
23 #include "generic.h"
24
25 void __init pxa_register_device(struct platform_device *dev, void *data)
26 {
27         int ret;
28
29         dev->dev.platform_data = data;
30
31         ret = platform_device_register(dev);
32         if (ret)
33                 dev_err(&dev->dev, "unable to register device: %d\n", ret);
34 }
35
36 static struct resource pxa_resource_pmu = {
37         .start  = IRQ_PMU,
38         .end    = IRQ_PMU,
39         .flags  = IORESOURCE_IRQ,
40 };
41
42 struct platform_device pxa_device_pmu = {
43         .name           = "arm-pmu",
44         .id             = ARM_PMU_DEVICE_CPU,
45         .resource       = &pxa_resource_pmu,
46         .num_resources  = 1,
47 };
48
49 static struct resource pxamci_resources[] = {
50         [0] = {
51                 .start  = 0x41100000,
52                 .end    = 0x41100fff,
53                 .flags  = IORESOURCE_MEM,
54         },
55         [1] = {
56                 .start  = IRQ_MMC,
57                 .end    = IRQ_MMC,
58                 .flags  = IORESOURCE_IRQ,
59         },
60         [2] = {
61                 .start  = 21,
62                 .end    = 21,
63                 .flags  = IORESOURCE_DMA,
64         },
65         [3] = {
66                 .start  = 22,
67                 .end    = 22,
68                 .flags  = IORESOURCE_DMA,
69         },
70 };
71
72 static u64 pxamci_dmamask = 0xffffffffUL;
73
74 struct platform_device pxa_device_mci = {
75         .name           = "pxa2xx-mci",
76         .id             = 0,
77         .dev            = {
78                 .dma_mask = &pxamci_dmamask,
79                 .coherent_dma_mask = 0xffffffff,
80         },
81         .num_resources  = ARRAY_SIZE(pxamci_resources),
82         .resource       = pxamci_resources,
83 };
84
85 void __init pxa_set_mci_info(struct pxamci_platform_data *info)
86 {
87         pxa_register_device(&pxa_device_mci, info);
88 }
89
90
91 static struct pxa2xx_udc_mach_info pxa_udc_info = {
92         .gpio_pullup = -1,
93         .gpio_vbus   = -1,
94 };
95
96 void __init pxa_set_udc_info(struct pxa2xx_udc_mach_info *info)
97 {
98         memcpy(&pxa_udc_info, info, sizeof *info);
99 }
100
101 static struct resource pxa2xx_udc_resources[] = {
102         [0] = {
103                 .start  = 0x40600000,
104                 .end    = 0x4060ffff,
105                 .flags  = IORESOURCE_MEM,
106         },
107         [1] = {
108                 .start  = IRQ_USB,
109                 .end    = IRQ_USB,
110                 .flags  = IORESOURCE_IRQ,
111         },
112 };
113
114 static u64 udc_dma_mask = ~(u32)0;
115
116 struct platform_device pxa25x_device_udc = {
117         .name           = "pxa25x-udc",
118         .id             = -1,
119         .resource       = pxa2xx_udc_resources,
120         .num_resources  = ARRAY_SIZE(pxa2xx_udc_resources),
121         .dev            =  {
122                 .platform_data  = &pxa_udc_info,
123                 .dma_mask       = &udc_dma_mask,
124         }
125 };
126
127 struct platform_device pxa27x_device_udc = {
128         .name           = "pxa27x-udc",
129         .id             = -1,
130         .resource       = pxa2xx_udc_resources,
131         .num_resources  = ARRAY_SIZE(pxa2xx_udc_resources),
132         .dev            =  {
133                 .platform_data  = &pxa_udc_info,
134                 .dma_mask       = &udc_dma_mask,
135         }
136 };
137
138 #ifdef CONFIG_PXA3xx
139 static struct resource pxa3xx_u2d_resources[] = {
140         [0] = {
141                 .start  = 0x54100000,
142                 .end    = 0x54100fff,
143                 .flags  = IORESOURCE_MEM,
144         },
145         [1] = {
146                 .start  = IRQ_USB2,
147                 .end    = IRQ_USB2,
148                 .flags  = IORESOURCE_IRQ,
149         },
150 };
151
152 struct platform_device pxa3xx_device_u2d = {
153         .name           = "pxa3xx-u2d",
154         .id             = -1,
155         .resource       = pxa3xx_u2d_resources,
156         .num_resources  = ARRAY_SIZE(pxa3xx_u2d_resources),
157 };
158
159 void __init pxa3xx_set_u2d_info(struct pxa3xx_u2d_platform_data *info)
160 {
161         pxa_register_device(&pxa3xx_device_u2d, info);
162 }
163 #endif /* CONFIG_PXA3xx */
164
165 static struct resource pxafb_resources[] = {
166         [0] = {
167                 .start  = 0x44000000,
168                 .end    = 0x4400ffff,
169                 .flags  = IORESOURCE_MEM,
170         },
171         [1] = {
172                 .start  = IRQ_LCD,
173                 .end    = IRQ_LCD,
174                 .flags  = IORESOURCE_IRQ,
175         },
176 };
177
178 static u64 fb_dma_mask = ~(u64)0;
179
180 struct platform_device pxa_device_fb = {
181         .name           = "pxa2xx-fb",
182         .id             = -1,
183         .dev            = {
184                 .dma_mask       = &fb_dma_mask,
185                 .coherent_dma_mask = 0xffffffff,
186         },
187         .num_resources  = ARRAY_SIZE(pxafb_resources),
188         .resource       = pxafb_resources,
189 };
190
191 void __init set_pxa_fb_info(struct pxafb_mach_info *info)
192 {
193         pxa_register_device(&pxa_device_fb, info);
194 }
195
196 void __init set_pxa_fb_parent(struct device *parent_dev)
197 {
198         pxa_device_fb.dev.parent = parent_dev;
199 }
200
201 static struct resource pxa_resource_ffuart[] = {
202         {
203                 .start  = 0x40100000,
204                 .end    = 0x40100023,
205                 .flags  = IORESOURCE_MEM,
206         }, {
207                 .start  = IRQ_FFUART,
208                 .end    = IRQ_FFUART,
209                 .flags  = IORESOURCE_IRQ,
210         }
211 };
212
213 struct platform_device pxa_device_ffuart = {
214         .name           = "pxa2xx-uart",
215         .id             = 0,
216         .resource       = pxa_resource_ffuart,
217         .num_resources  = ARRAY_SIZE(pxa_resource_ffuart),
218 };
219
220 void __init pxa_set_ffuart_info(void *info)
221 {
222         pxa_register_device(&pxa_device_ffuart, info);
223 }
224
225 static struct resource pxa_resource_btuart[] = {
226         {
227                 .start  = 0x40200000,
228                 .end    = 0x40200023,
229                 .flags  = IORESOURCE_MEM,
230         }, {
231                 .start  = IRQ_BTUART,
232                 .end    = IRQ_BTUART,
233                 .flags  = IORESOURCE_IRQ,
234         }
235 };
236
237 struct platform_device pxa_device_btuart = {
238         .name           = "pxa2xx-uart",
239         .id             = 1,
240         .resource       = pxa_resource_btuart,
241         .num_resources  = ARRAY_SIZE(pxa_resource_btuart),
242 };
243
244 void __init pxa_set_btuart_info(void *info)
245 {
246         pxa_register_device(&pxa_device_btuart, info);
247 }
248
249 static struct resource pxa_resource_stuart[] = {
250         {
251                 .start  = 0x40700000,
252                 .end    = 0x40700023,
253                 .flags  = IORESOURCE_MEM,
254         }, {
255                 .start  = IRQ_STUART,
256                 .end    = IRQ_STUART,
257                 .flags  = IORESOURCE_IRQ,
258         }
259 };
260
261 struct platform_device pxa_device_stuart = {
262         .name           = "pxa2xx-uart",
263         .id             = 2,
264         .resource       = pxa_resource_stuart,
265         .num_resources  = ARRAY_SIZE(pxa_resource_stuart),
266 };
267
268 void __init pxa_set_stuart_info(void *info)
269 {
270         pxa_register_device(&pxa_device_stuart, info);
271 }
272
273 static struct resource pxa_resource_hwuart[] = {
274         {
275                 .start  = 0x41600000,
276                 .end    = 0x4160002F,
277                 .flags  = IORESOURCE_MEM,
278         }, {
279                 .start  = IRQ_HWUART,
280                 .end    = IRQ_HWUART,
281                 .flags  = IORESOURCE_IRQ,
282         }
283 };
284
285 struct platform_device pxa_device_hwuart = {
286         .name           = "pxa2xx-uart",
287         .id             = 3,
288         .resource       = pxa_resource_hwuart,
289         .num_resources  = ARRAY_SIZE(pxa_resource_hwuart),
290 };
291
292 void __init pxa_set_hwuart_info(void *info)
293 {
294         if (cpu_is_pxa255())
295                 pxa_register_device(&pxa_device_hwuart, info);
296         else
297                 pr_info("UART: Ignoring attempt to register HWUART on non-PXA255 hardware");
298 }
299
300 static struct resource pxai2c_resources[] = {
301         {
302                 .start  = 0x40301680,
303                 .end    = 0x403016a3,
304                 .flags  = IORESOURCE_MEM,
305         }, {
306                 .start  = IRQ_I2C,
307                 .end    = IRQ_I2C,
308                 .flags  = IORESOURCE_IRQ,
309         },
310 };
311
312 struct platform_device pxa_device_i2c = {
313         .name           = "pxa2xx-i2c",
314         .id             = 0,
315         .resource       = pxai2c_resources,
316         .num_resources  = ARRAY_SIZE(pxai2c_resources),
317 };
318
319 void __init pxa_set_i2c_info(struct i2c_pxa_platform_data *info)
320 {
321         pxa_register_device(&pxa_device_i2c, info);
322 }
323
324 #ifdef CONFIG_PXA27x
325 static struct resource pxa27x_resources_i2c_power[] = {
326         {
327                 .start  = 0x40f00180,
328                 .end    = 0x40f001a3,
329                 .flags  = IORESOURCE_MEM,
330         }, {
331                 .start  = IRQ_PWRI2C,
332                 .end    = IRQ_PWRI2C,
333                 .flags  = IORESOURCE_IRQ,
334         },
335 };
336
337 struct platform_device pxa27x_device_i2c_power = {
338         .name           = "pxa2xx-i2c",
339         .id             = 1,
340         .resource       = pxa27x_resources_i2c_power,
341         .num_resources  = ARRAY_SIZE(pxa27x_resources_i2c_power),
342 };
343 #endif
344
345 static struct resource pxai2s_resources[] = {
346         {
347                 .start  = 0x40400000,
348                 .end    = 0x40400083,
349                 .flags  = IORESOURCE_MEM,
350         }, {
351                 .start  = IRQ_I2S,
352                 .end    = IRQ_I2S,
353                 .flags  = IORESOURCE_IRQ,
354         },
355 };
356
357 struct platform_device pxa_device_i2s = {
358         .name           = "pxa2xx-i2s",
359         .id             = -1,
360         .resource       = pxai2s_resources,
361         .num_resources  = ARRAY_SIZE(pxai2s_resources),
362 };
363
364 struct platform_device pxa_device_asoc_ssp1 = {
365         .name           = "pxa-ssp-dai",
366         .id             = 0,
367 };
368
369 struct platform_device pxa_device_asoc_ssp2= {
370         .name           = "pxa-ssp-dai",
371         .id             = 1,
372 };
373
374 struct platform_device pxa_device_asoc_ssp3 = {
375         .name           = "pxa-ssp-dai",
376         .id             = 2,
377 };
378
379 struct platform_device pxa_device_asoc_ssp4 = {
380         .name           = "pxa-ssp-dai",
381         .id             = 3,
382 };
383
384 struct platform_device pxa_device_asoc_platform = {
385         .name           = "pxa-pcm-audio",
386         .id             = -1,
387 };
388
389 static u64 pxaficp_dmamask = ~(u32)0;
390
391 struct platform_device pxa_device_ficp = {
392         .name           = "pxa2xx-ir",
393         .id             = -1,
394         .dev            = {
395                 .dma_mask = &pxaficp_dmamask,
396                 .coherent_dma_mask = 0xffffffff,
397         },
398 };
399
400 void __init pxa_set_ficp_info(struct pxaficp_platform_data *info)
401 {
402         pxa_register_device(&pxa_device_ficp, info);
403 }
404
405 static struct resource pxa_rtc_resources[] = {
406         [0] = {
407                 .start  = 0x40900000,
408                 .end    = 0x40900000 + 0x3b,
409                 .flags  = IORESOURCE_MEM,
410         },
411         [1] = {
412                 .start  = IRQ_RTC1Hz,
413                 .end    = IRQ_RTC1Hz,
414                 .flags  = IORESOURCE_IRQ,
415         },
416         [2] = {
417                 .start  = IRQ_RTCAlrm,
418                 .end    = IRQ_RTCAlrm,
419                 .flags  = IORESOURCE_IRQ,
420         },
421 };
422
423 struct platform_device sa1100_device_rtc = {
424         .name           = "sa1100-rtc",
425         .id             = -1,
426 };
427
428 struct platform_device pxa_device_rtc = {
429         .name           = "pxa-rtc",
430         .id             = -1,
431         .num_resources  = ARRAY_SIZE(pxa_rtc_resources),
432         .resource       = pxa_rtc_resources,
433 };
434
435 static struct resource pxa_ac97_resources[] = {
436         [0] = {
437                 .start  = 0x40500000,
438                 .end    = 0x40500000 + 0xfff,
439                 .flags  = IORESOURCE_MEM,
440         },
441         [1] = {
442                 .start  = IRQ_AC97,
443                 .end    = IRQ_AC97,
444                 .flags  = IORESOURCE_IRQ,
445         },
446 };
447
448 static u64 pxa_ac97_dmamask = 0xffffffffUL;
449
450 struct platform_device pxa_device_ac97 = {
451         .name           = "pxa2xx-ac97",
452         .id             = -1,
453         .dev            = {
454                 .dma_mask = &pxa_ac97_dmamask,
455                 .coherent_dma_mask = 0xffffffff,
456         },
457         .num_resources  = ARRAY_SIZE(pxa_ac97_resources),
458         .resource       = pxa_ac97_resources,
459 };
460
461 void __init pxa_set_ac97_info(pxa2xx_audio_ops_t *ops)
462 {
463         pxa_register_device(&pxa_device_ac97, ops);
464 }
465
466 #ifdef CONFIG_PXA25x
467
468 static struct resource pxa25x_resource_pwm0[] = {
469         [0] = {
470                 .start  = 0x40b00000,
471                 .end    = 0x40b0000f,
472                 .flags  = IORESOURCE_MEM,
473         },
474 };
475
476 struct platform_device pxa25x_device_pwm0 = {
477         .name           = "pxa25x-pwm",
478         .id             = 0,
479         .resource       = pxa25x_resource_pwm0,
480         .num_resources  = ARRAY_SIZE(pxa25x_resource_pwm0),
481 };
482
483 static struct resource pxa25x_resource_pwm1[] = {
484         [0] = {
485                 .start  = 0x40c00000,
486                 .end    = 0x40c0000f,
487                 .flags  = IORESOURCE_MEM,
488         },
489 };
490
491 struct platform_device pxa25x_device_pwm1 = {
492         .name           = "pxa25x-pwm",
493         .id             = 1,
494         .resource       = pxa25x_resource_pwm1,
495         .num_resources  = ARRAY_SIZE(pxa25x_resource_pwm1),
496 };
497
498 static u64 pxa25x_ssp_dma_mask = DMA_BIT_MASK(32);
499
500 static struct resource pxa25x_resource_ssp[] = {
501         [0] = {
502                 .start  = 0x41000000,
503                 .end    = 0x4100001f,
504                 .flags  = IORESOURCE_MEM,
505         },
506         [1] = {
507                 .start  = IRQ_SSP,
508                 .end    = IRQ_SSP,
509                 .flags  = IORESOURCE_IRQ,
510         },
511         [2] = {
512                 /* DRCMR for RX */
513                 .start  = 13,
514                 .end    = 13,
515                 .flags  = IORESOURCE_DMA,
516         },
517         [3] = {
518                 /* DRCMR for TX */
519                 .start  = 14,
520                 .end    = 14,
521                 .flags  = IORESOURCE_DMA,
522         },
523 };
524
525 struct platform_device pxa25x_device_ssp = {
526         .name           = "pxa25x-ssp",
527         .id             = 0,
528         .dev            = {
529                 .dma_mask = &pxa25x_ssp_dma_mask,
530                 .coherent_dma_mask = DMA_BIT_MASK(32),
531         },
532         .resource       = pxa25x_resource_ssp,
533         .num_resources  = ARRAY_SIZE(pxa25x_resource_ssp),
534 };
535
536 static u64 pxa25x_nssp_dma_mask = DMA_BIT_MASK(32);
537
538 static struct resource pxa25x_resource_nssp[] = {
539         [0] = {
540                 .start  = 0x41400000,
541                 .end    = 0x4140002f,
542                 .flags  = IORESOURCE_MEM,
543         },
544         [1] = {
545                 .start  = IRQ_NSSP,
546                 .end    = IRQ_NSSP,
547                 .flags  = IORESOURCE_IRQ,
548         },
549         [2] = {
550                 /* DRCMR for RX */
551                 .start  = 15,
552                 .end    = 15,
553                 .flags  = IORESOURCE_DMA,
554         },
555         [3] = {
556                 /* DRCMR for TX */
557                 .start  = 16,
558                 .end    = 16,
559                 .flags  = IORESOURCE_DMA,
560         },
561 };
562
563 struct platform_device pxa25x_device_nssp = {
564         .name           = "pxa25x-nssp",
565         .id             = 1,
566         .dev            = {
567                 .dma_mask = &pxa25x_nssp_dma_mask,
568                 .coherent_dma_mask = DMA_BIT_MASK(32),
569         },
570         .resource       = pxa25x_resource_nssp,
571         .num_resources  = ARRAY_SIZE(pxa25x_resource_nssp),
572 };
573
574 static u64 pxa25x_assp_dma_mask = DMA_BIT_MASK(32);
575
576 static struct resource pxa25x_resource_assp[] = {
577         [0] = {
578                 .start  = 0x41500000,
579                 .end    = 0x4150002f,
580                 .flags  = IORESOURCE_MEM,
581         },
582         [1] = {
583                 .start  = IRQ_ASSP,
584                 .end    = IRQ_ASSP,
585                 .flags  = IORESOURCE_IRQ,
586         },
587         [2] = {
588                 /* DRCMR for RX */
589                 .start  = 23,
590                 .end    = 23,
591                 .flags  = IORESOURCE_DMA,
592         },
593         [3] = {
594                 /* DRCMR for TX */
595                 .start  = 24,
596                 .end    = 24,
597                 .flags  = IORESOURCE_DMA,
598         },
599 };
600
601 struct platform_device pxa25x_device_assp = {
602         /* ASSP is basically equivalent to NSSP */
603         .name           = "pxa25x-nssp",
604         .id             = 2,
605         .dev            = {
606                 .dma_mask = &pxa25x_assp_dma_mask,
607                 .coherent_dma_mask = DMA_BIT_MASK(32),
608         },
609         .resource       = pxa25x_resource_assp,
610         .num_resources  = ARRAY_SIZE(pxa25x_resource_assp),
611 };
612 #endif /* CONFIG_PXA25x */
613
614 #if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx)
615 static struct resource pxa27x_resource_camera[] = {
616         [0] = {
617                 .start  = 0x50000000,
618                 .end    = 0x50000fff,
619                 .flags  = IORESOURCE_MEM,
620         },
621         [1] = {
622                 .start  = IRQ_CAMERA,
623                 .end    = IRQ_CAMERA,
624                 .flags  = IORESOURCE_IRQ,
625         },
626 };
627
628 static u64 pxa27x_dma_mask_camera = DMA_BIT_MASK(32);
629
630 static struct platform_device pxa27x_device_camera = {
631         .name           = "pxa27x-camera",
632         .id             = 0, /* This is used to put cameras on this interface */
633         .dev            = {
634                 .dma_mask               = &pxa27x_dma_mask_camera,
635                 .coherent_dma_mask      = 0xffffffff,
636         },
637         .num_resources  = ARRAY_SIZE(pxa27x_resource_camera),
638         .resource       = pxa27x_resource_camera,
639 };
640
641 void __init pxa_set_camera_info(struct pxacamera_platform_data *info)
642 {
643         pxa_register_device(&pxa27x_device_camera, info);
644 }
645
646 static u64 pxa27x_ohci_dma_mask = DMA_BIT_MASK(32);
647
648 static struct resource pxa27x_resource_ohci[] = {
649         [0] = {
650                 .start  = 0x4C000000,
651                 .end    = 0x4C00ff6f,
652                 .flags  = IORESOURCE_MEM,
653         },
654         [1] = {
655                 .start  = IRQ_USBH1,
656                 .end    = IRQ_USBH1,
657                 .flags  = IORESOURCE_IRQ,
658         },
659 };
660
661 struct platform_device pxa27x_device_ohci = {
662         .name           = "pxa27x-ohci",
663         .id             = -1,
664         .dev            = {
665                 .dma_mask = &pxa27x_ohci_dma_mask,
666                 .coherent_dma_mask = DMA_BIT_MASK(32),
667         },
668         .num_resources  = ARRAY_SIZE(pxa27x_resource_ohci),
669         .resource       = pxa27x_resource_ohci,
670 };
671
672 void __init pxa_set_ohci_info(struct pxaohci_platform_data *info)
673 {
674         pxa_register_device(&pxa27x_device_ohci, info);
675 }
676 #endif /* CONFIG_PXA27x || CONFIG_PXA3xx */
677
678 #if defined(CONFIG_PXA27x) || defined(CONFIG_PXA3xx) || defined(CONFIG_PXA95x)
679 static struct resource pxa27x_resource_keypad[] = {
680         [0] = {
681                 .start  = 0x41500000,
682                 .end    = 0x4150004c,
683                 .flags  = IORESOURCE_MEM,
684         },
685         [1] = {
686                 .start  = IRQ_KEYPAD,
687                 .end    = IRQ_KEYPAD,
688                 .flags  = IORESOURCE_IRQ,
689         },
690 };
691
692 struct platform_device pxa27x_device_keypad = {
693         .name           = "pxa27x-keypad",
694         .id             = -1,
695         .resource       = pxa27x_resource_keypad,
696         .num_resources  = ARRAY_SIZE(pxa27x_resource_keypad),
697 };
698
699 void __init pxa_set_keypad_info(struct pxa27x_keypad_platform_data *info)
700 {
701         pxa_register_device(&pxa27x_device_keypad, info);
702 }
703
704 static u64 pxa27x_ssp1_dma_mask = DMA_BIT_MASK(32);
705
706 static struct resource pxa27x_resource_ssp1[] = {
707         [0] = {
708                 .start  = 0x41000000,
709                 .end    = 0x4100003f,
710                 .flags  = IORESOURCE_MEM,
711         },
712         [1] = {
713                 .start  = IRQ_SSP,
714                 .end    = IRQ_SSP,
715                 .flags  = IORESOURCE_IRQ,
716         },
717         [2] = {
718                 /* DRCMR for RX */
719                 .start  = 13,
720                 .end    = 13,
721                 .flags  = IORESOURCE_DMA,
722         },
723         [3] = {
724                 /* DRCMR for TX */
725                 .start  = 14,
726                 .end    = 14,
727                 .flags  = IORESOURCE_DMA,
728         },
729 };
730
731 struct platform_device pxa27x_device_ssp1 = {
732         .name           = "pxa27x-ssp",
733         .id             = 0,
734         .dev            = {
735                 .dma_mask = &pxa27x_ssp1_dma_mask,
736                 .coherent_dma_mask = DMA_BIT_MASK(32),
737         },
738         .resource       = pxa27x_resource_ssp1,
739         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp1),
740 };
741
742 static u64 pxa27x_ssp2_dma_mask = DMA_BIT_MASK(32);
743
744 static struct resource pxa27x_resource_ssp2[] = {
745         [0] = {
746                 .start  = 0x41700000,
747                 .end    = 0x4170003f,
748                 .flags  = IORESOURCE_MEM,
749         },
750         [1] = {
751                 .start  = IRQ_SSP2,
752                 .end    = IRQ_SSP2,
753                 .flags  = IORESOURCE_IRQ,
754         },
755         [2] = {
756                 /* DRCMR for RX */
757                 .start  = 15,
758                 .end    = 15,
759                 .flags  = IORESOURCE_DMA,
760         },
761         [3] = {
762                 /* DRCMR for TX */
763                 .start  = 16,
764                 .end    = 16,
765                 .flags  = IORESOURCE_DMA,
766         },
767 };
768
769 struct platform_device pxa27x_device_ssp2 = {
770         .name           = "pxa27x-ssp",
771         .id             = 1,
772         .dev            = {
773                 .dma_mask = &pxa27x_ssp2_dma_mask,
774                 .coherent_dma_mask = DMA_BIT_MASK(32),
775         },
776         .resource       = pxa27x_resource_ssp2,
777         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp2),
778 };
779
780 static u64 pxa27x_ssp3_dma_mask = DMA_BIT_MASK(32);
781
782 static struct resource pxa27x_resource_ssp3[] = {
783         [0] = {
784                 .start  = 0x41900000,
785                 .end    = 0x4190003f,
786                 .flags  = IORESOURCE_MEM,
787         },
788         [1] = {
789                 .start  = IRQ_SSP3,
790                 .end    = IRQ_SSP3,
791                 .flags  = IORESOURCE_IRQ,
792         },
793         [2] = {
794                 /* DRCMR for RX */
795                 .start  = 66,
796                 .end    = 66,
797                 .flags  = IORESOURCE_DMA,
798         },
799         [3] = {
800                 /* DRCMR for TX */
801                 .start  = 67,
802                 .end    = 67,
803                 .flags  = IORESOURCE_DMA,
804         },
805 };
806
807 struct platform_device pxa27x_device_ssp3 = {
808         .name           = "pxa27x-ssp",
809         .id             = 2,
810         .dev            = {
811                 .dma_mask = &pxa27x_ssp3_dma_mask,
812                 .coherent_dma_mask = DMA_BIT_MASK(32),
813         },
814         .resource       = pxa27x_resource_ssp3,
815         .num_resources  = ARRAY_SIZE(pxa27x_resource_ssp3),
816 };
817
818 static struct resource pxa27x_resource_pwm0[] = {
819         [0] = {
820                 .start  = 0x40b00000,
821                 .end    = 0x40b0001f,
822                 .flags  = IORESOURCE_MEM,
823         },
824 };
825
826 struct platform_device pxa27x_device_pwm0 = {
827         .name           = "pxa27x-pwm",
828         .id             = 0,
829         .resource       = pxa27x_resource_pwm0,
830         .num_resources  = ARRAY_SIZE(pxa27x_resource_pwm0),
831 };
832
833 static struct resource pxa27x_resource_pwm1[] = {
834         [0] = {
835                 .start  = 0x40c00000,
836                 .end    = 0x40c0001f,
837                 .flags  = IORESOURCE_MEM,
838         },
839 };
840
841 struct platform_device pxa27x_device_pwm1 = {
842         .name           = "pxa27x-pwm",
843         .id             = 1,
844         .resource       = pxa27x_resource_pwm1,
845         .num_resources  = ARRAY_SIZE(pxa27x_resource_pwm1),
846 };
847 #endif /* CONFIG_PXA27x || CONFIG_PXA3xx || CONFIG_PXA95x*/
848
849 #ifdef CONFIG_PXA3xx
850 static struct resource pxa3xx_resources_mci2[] = {
851         [0] = {
852                 .start  = 0x42000000,
853                 .end    = 0x42000fff,
854                 .flags  = IORESOURCE_MEM,
855         },
856         [1] = {
857                 .start  = IRQ_MMC2,
858                 .end    = IRQ_MMC2,
859                 .flags  = IORESOURCE_IRQ,
860         },
861         [2] = {
862                 .start  = 93,
863                 .end    = 93,
864                 .flags  = IORESOURCE_DMA,
865         },
866         [3] = {
867                 .start  = 94,
868                 .end    = 94,
869                 .flags  = IORESOURCE_DMA,
870         },
871 };
872
873 struct platform_device pxa3xx_device_mci2 = {
874         .name           = "pxa2xx-mci",
875         .id             = 1,
876         .dev            = {
877                 .dma_mask = &pxamci_dmamask,
878                 .coherent_dma_mask =    0xffffffff,
879         },
880         .num_resources  = ARRAY_SIZE(pxa3xx_resources_mci2),
881         .resource       = pxa3xx_resources_mci2,
882 };
883
884 void __init pxa3xx_set_mci2_info(struct pxamci_platform_data *info)
885 {
886         pxa_register_device(&pxa3xx_device_mci2, info);
887 }
888
889 static struct resource pxa3xx_resources_mci3[] = {
890         [0] = {
891                 .start  = 0x42500000,
892                 .end    = 0x42500fff,
893                 .flags  = IORESOURCE_MEM,
894         },
895         [1] = {
896                 .start  = IRQ_MMC3,
897                 .end    = IRQ_MMC3,
898                 .flags  = IORESOURCE_IRQ,
899         },
900         [2] = {
901                 .start  = 100,
902                 .end    = 100,
903                 .flags  = IORESOURCE_DMA,
904         },
905         [3] = {
906                 .start  = 101,
907                 .end    = 101,
908                 .flags  = IORESOURCE_DMA,
909         },
910 };
911
912 struct platform_device pxa3xx_device_mci3 = {
913         .name           = "pxa2xx-mci",
914         .id             = 2,
915         .dev            = {
916                 .dma_mask = &pxamci_dmamask,
917                 .coherent_dma_mask = 0xffffffff,
918         },
919         .num_resources  = ARRAY_SIZE(pxa3xx_resources_mci3),
920         .resource       = pxa3xx_resources_mci3,
921 };
922
923 void __init pxa3xx_set_mci3_info(struct pxamci_platform_data *info)
924 {
925         pxa_register_device(&pxa3xx_device_mci3, info);
926 }
927
928 static struct resource pxa3xx_resources_gcu[] = {
929         {
930                 .start  = 0x54000000,
931                 .end    = 0x54000fff,
932                 .flags  = IORESOURCE_MEM,
933         },
934         {
935                 .start  = IRQ_GCU,
936                 .end    = IRQ_GCU,
937                 .flags  = IORESOURCE_IRQ,
938         },
939 };
940
941 static u64 pxa3xx_gcu_dmamask = DMA_BIT_MASK(32);
942
943 struct platform_device pxa3xx_device_gcu = {
944         .name           = "pxa3xx-gcu",
945         .id             = -1,
946         .num_resources  = ARRAY_SIZE(pxa3xx_resources_gcu),
947         .resource       = pxa3xx_resources_gcu,
948         .dev            = {
949                 .dma_mask = &pxa3xx_gcu_dmamask,
950                 .coherent_dma_mask = 0xffffffff,
951         },
952 };
953
954 #endif /* CONFIG_PXA3xx */
955
956 #if defined(CONFIG_PXA3xx) || defined(CONFIG_PXA95x)
957 static struct resource pxa3xx_resources_i2c_power[] = {
958         {
959                 .start  = 0x40f500c0,
960                 .end    = 0x40f500d3,
961                 .flags  = IORESOURCE_MEM,
962         }, {
963                 .start  = IRQ_PWRI2C,
964                 .end    = IRQ_PWRI2C,
965                 .flags  = IORESOURCE_IRQ,
966         },
967 };
968
969 struct platform_device pxa3xx_device_i2c_power = {
970         .name           = "pxa3xx-pwri2c",
971         .id             = 1,
972         .resource       = pxa3xx_resources_i2c_power,
973         .num_resources  = ARRAY_SIZE(pxa3xx_resources_i2c_power),
974 };
975
976 static struct resource pxa3xx_resources_nand[] = {
977         [0] = {
978                 .start  = 0x43100000,
979                 .end    = 0x43100053,
980                 .flags  = IORESOURCE_MEM,
981         },
982         [1] = {
983                 .start  = IRQ_NAND,
984                 .end    = IRQ_NAND,
985                 .flags  = IORESOURCE_IRQ,
986         },
987         [2] = {
988                 /* DRCMR for Data DMA */
989                 .start  = 97,
990                 .end    = 97,
991                 .flags  = IORESOURCE_DMA,
992         },
993         [3] = {
994                 /* DRCMR for Command DMA */
995                 .start  = 99,
996                 .end    = 99,
997                 .flags  = IORESOURCE_DMA,
998         },
999 };
1000
1001 static u64 pxa3xx_nand_dma_mask = DMA_BIT_MASK(32);
1002
1003 struct platform_device pxa3xx_device_nand = {
1004         .name           = "pxa3xx-nand",
1005         .id             = -1,
1006         .dev            = {
1007                 .dma_mask = &pxa3xx_nand_dma_mask,
1008                 .coherent_dma_mask = DMA_BIT_MASK(32),
1009         },
1010         .num_resources  = ARRAY_SIZE(pxa3xx_resources_nand),
1011         .resource       = pxa3xx_resources_nand,
1012 };
1013
1014 void __init pxa3xx_set_nand_info(struct pxa3xx_nand_platform_data *info)
1015 {
1016         pxa_register_device(&pxa3xx_device_nand, info);
1017 }
1018
1019 static u64 pxa3xx_ssp4_dma_mask = DMA_BIT_MASK(32);
1020
1021 static struct resource pxa3xx_resource_ssp4[] = {
1022         [0] = {
1023                 .start  = 0x41a00000,
1024                 .end    = 0x41a0003f,
1025                 .flags  = IORESOURCE_MEM,
1026         },
1027         [1] = {
1028                 .start  = IRQ_SSP4,
1029                 .end    = IRQ_SSP4,
1030                 .flags  = IORESOURCE_IRQ,
1031         },
1032         [2] = {
1033                 /* DRCMR for RX */
1034                 .start  = 2,
1035                 .end    = 2,
1036                 .flags  = IORESOURCE_DMA,
1037         },
1038         [3] = {
1039                 /* DRCMR for TX */
1040                 .start  = 3,
1041                 .end    = 3,
1042                 .flags  = IORESOURCE_DMA,
1043         },
1044 };
1045
1046 struct platform_device pxa3xx_device_ssp4 = {
1047         /* PXA3xx SSP is basically equivalent to PXA27x */
1048         .name           = "pxa27x-ssp",
1049         .id             = 3,
1050         .dev            = {
1051                 .dma_mask = &pxa3xx_ssp4_dma_mask,
1052                 .coherent_dma_mask = DMA_BIT_MASK(32),
1053         },
1054         .resource       = pxa3xx_resource_ssp4,
1055         .num_resources  = ARRAY_SIZE(pxa3xx_resource_ssp4),
1056 };
1057 #endif /* CONFIG_PXA3xx || CONFIG_PXA95x */
1058
1059 /* pxa2xx-spi platform-device ID equals respective SSP platform-device ID + 1.
1060  * See comment in arch/arm/mach-pxa/ssp.c::ssp_probe() */
1061 void __init pxa2xx_set_spi_info(unsigned id, struct pxa2xx_spi_master *info)
1062 {
1063         struct platform_device *pd;
1064
1065         pd = platform_device_alloc("pxa2xx-spi", id);
1066         if (pd == NULL) {
1067                 printk(KERN_ERR "pxa2xx-spi: failed to allocate device id %d\n",
1068                        id);
1069                 return;
1070         }
1071
1072         pd->dev.platform_data = info;
1073         platform_device_add(pd);
1074 }