~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/arm/mach-pxa/devices.c

Version: ~ [ linux-5.11-rc1 ] ~ [ linux-5.10.4 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.86 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.164 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.213 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.249 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.249 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp