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