ARM: orion: Fix USB phy for orion5x.
[linux-3.10.git] / arch / arm / plat-orion / common.c
1 /*
2  * arch/arm/plat-orion/common.c
3  *
4  * Marvell Orion SoC common setup code used by multiple mach-/common.c
5  *
6  * This file is licensed under the terms of the GNU General Public
7  * License version 2.  This program is licensed "as is" without any
8  * warranty of any kind, whether express or implied.
9  */
10
11 #include <linux/kernel.h>
12 #include <linux/init.h>
13 #include <linux/platform_device.h>
14 #include <linux/dma-mapping.h>
15 #include <linux/serial_8250.h>
16 #include <linux/ata_platform.h>
17 #include <linux/mv643xx_eth.h>
18 #include <linux/mv643xx_i2c.h>
19 #include <net/dsa.h>
20 #include <linux/spi/orion_spi.h>
21 #include <plat/orion_wdt.h>
22 #include <plat/mv_xor.h>
23 #include <plat/ehci-orion.h>
24
25 /* Fill in the resources structure and link it into the platform
26    device structure. There is always a memory region, and nearly
27    always an interrupt.*/
28 static void fill_resources(struct platform_device *device,
29                            struct resource *resources,
30                            resource_size_t mapbase,
31                            resource_size_t size,
32                            unsigned int irq)
33 {
34         device->resource = resources;
35         device->num_resources = 1;
36         resources[0].flags = IORESOURCE_MEM;
37         resources[0].start = mapbase;
38         resources[0].end = mapbase + size;
39
40         if (irq != NO_IRQ) {
41                 device->num_resources++;
42                 resources[1].flags = IORESOURCE_IRQ;
43                 resources[1].start = irq;
44                 resources[1].end = irq;
45         }
46 }
47
48 /*****************************************************************************
49  * UART
50  ****************************************************************************/
51 static void __init uart_complete(
52         struct platform_device *orion_uart,
53         struct plat_serial8250_port *data,
54         struct resource *resources,
55         unsigned int membase,
56         resource_size_t mapbase,
57         unsigned int irq,
58         unsigned int uartclk)
59 {
60         data->mapbase = mapbase;
61         data->membase = (void __iomem *)membase;
62         data->irq = irq;
63         data->uartclk = uartclk;
64         orion_uart->dev.platform_data = data;
65
66         fill_resources(orion_uart, resources, mapbase, 0xff, irq);
67         platform_device_register(orion_uart);
68 }
69
70 /*****************************************************************************
71  * UART0
72  ****************************************************************************/
73 static struct plat_serial8250_port orion_uart0_data[] = {
74         {
75                 .flags          = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF,
76                 .iotype         = UPIO_MEM,
77                 .regshift       = 2,
78         }, {
79         },
80 };
81
82 static struct resource orion_uart0_resources[2];
83
84 static struct platform_device orion_uart0 = {
85         .name                   = "serial8250",
86         .id                     = PLAT8250_DEV_PLATFORM,
87 };
88
89 void __init orion_uart0_init(unsigned int membase,
90                              resource_size_t mapbase,
91                              unsigned int irq,
92                              unsigned int uartclk)
93 {
94         uart_complete(&orion_uart0, orion_uart0_data, orion_uart0_resources,
95                       membase, mapbase, irq, uartclk);
96 }
97
98 /*****************************************************************************
99  * UART1
100  ****************************************************************************/
101 static struct plat_serial8250_port orion_uart1_data[] = {
102         {
103                 .flags          = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF,
104                 .iotype         = UPIO_MEM,
105                 .regshift       = 2,
106         }, {
107         },
108 };
109
110 static struct resource orion_uart1_resources[2];
111
112 static struct platform_device orion_uart1 = {
113         .name                   = "serial8250",
114         .id                     = PLAT8250_DEV_PLATFORM1,
115 };
116
117 void __init orion_uart1_init(unsigned int membase,
118                              resource_size_t mapbase,
119                              unsigned int irq,
120                              unsigned int uartclk)
121 {
122         uart_complete(&orion_uart1, orion_uart1_data, orion_uart1_resources,
123                       membase, mapbase, irq, uartclk);
124 }
125
126 /*****************************************************************************
127  * UART2
128  ****************************************************************************/
129 static struct plat_serial8250_port orion_uart2_data[] = {
130         {
131                 .flags          = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF,
132                 .iotype         = UPIO_MEM,
133                 .regshift       = 2,
134         }, {
135         },
136 };
137
138 static struct resource orion_uart2_resources[2];
139
140 static struct platform_device orion_uart2 = {
141         .name                   = "serial8250",
142         .id                     = PLAT8250_DEV_PLATFORM2,
143 };
144
145 void __init orion_uart2_init(unsigned int membase,
146                              resource_size_t mapbase,
147                              unsigned int irq,
148                              unsigned int uartclk)
149 {
150         uart_complete(&orion_uart2, orion_uart2_data, orion_uart2_resources,
151                       membase, mapbase, irq, uartclk);
152 }
153
154 /*****************************************************************************
155  * UART3
156  ****************************************************************************/
157 static struct plat_serial8250_port orion_uart3_data[] = {
158         {
159                 .flags          = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF,
160                 .iotype         = UPIO_MEM,
161                 .regshift       = 2,
162         }, {
163         },
164 };
165
166 static struct resource orion_uart3_resources[2];
167
168 static struct platform_device orion_uart3 = {
169         .name                   = "serial8250",
170         .id                     = 3,
171 };
172
173 void __init orion_uart3_init(unsigned int membase,
174                              resource_size_t mapbase,
175                              unsigned int irq,
176                              unsigned int uartclk)
177 {
178         uart_complete(&orion_uart3, orion_uart3_data, orion_uart3_resources,
179                       membase, mapbase, irq, uartclk);
180 }
181
182 /*****************************************************************************
183  * SoC RTC
184  ****************************************************************************/
185 static struct resource orion_rtc_resource[2];
186
187 void __init orion_rtc_init(unsigned long mapbase,
188                            unsigned long irq)
189 {
190         orion_rtc_resource[0].start = mapbase;
191         orion_rtc_resource[0].end = mapbase + SZ_32 - 1;
192         orion_rtc_resource[0].flags = IORESOURCE_MEM;
193         orion_rtc_resource[1].start = irq;
194         orion_rtc_resource[1].end = irq;
195         orion_rtc_resource[1].flags = IORESOURCE_IRQ;
196
197         platform_device_register_simple("rtc-mv", -1, orion_rtc_resource, 2);
198 }
199
200 /*****************************************************************************
201  * GE
202  ****************************************************************************/
203 static __init void ge_complete(
204         struct mv643xx_eth_shared_platform_data *orion_ge_shared_data,
205         int tclk,
206         struct resource *orion_ge_resource, unsigned long irq,
207         struct platform_device *orion_ge_shared,
208         struct mv643xx_eth_platform_data *eth_data,
209         struct platform_device *orion_ge)
210 {
211         orion_ge_shared_data->t_clk = tclk;
212         orion_ge_resource->start = irq;
213         orion_ge_resource->end = irq;
214         eth_data->shared = orion_ge_shared;
215         orion_ge->dev.platform_data = eth_data;
216
217         platform_device_register(orion_ge_shared);
218         platform_device_register(orion_ge);
219 }
220
221 /*****************************************************************************
222  * GE00
223  ****************************************************************************/
224 struct mv643xx_eth_shared_platform_data orion_ge00_shared_data;
225
226 static struct resource orion_ge00_shared_resources[] = {
227         {
228                 .name   = "ge00 base",
229         }, {
230                 .name   = "ge00 err irq",
231         },
232 };
233
234 static struct platform_device orion_ge00_shared = {
235         .name           = MV643XX_ETH_SHARED_NAME,
236         .id             = 0,
237         .dev            = {
238                 .platform_data  = &orion_ge00_shared_data,
239         },
240 };
241
242 static struct resource orion_ge00_resources[] = {
243         {
244                 .name   = "ge00 irq",
245                 .flags  = IORESOURCE_IRQ,
246         },
247 };
248
249 static struct platform_device orion_ge00 = {
250         .name           = MV643XX_ETH_NAME,
251         .id             = 0,
252         .num_resources  = 1,
253         .resource       = orion_ge00_resources,
254         .dev            = {
255                 .coherent_dma_mask      = DMA_BIT_MASK(32),
256         },
257 };
258
259 void __init orion_ge00_init(struct mv643xx_eth_platform_data *eth_data,
260                             unsigned long mapbase,
261                             unsigned long irq,
262                             unsigned long irq_err,
263                             int tclk)
264 {
265         fill_resources(&orion_ge00_shared, orion_ge00_shared_resources,
266                        mapbase + 0x2000, SZ_16K - 1, irq_err);
267         ge_complete(&orion_ge00_shared_data, tclk,
268                     orion_ge00_resources, irq, &orion_ge00_shared,
269                     eth_data, &orion_ge00);
270 }
271
272 /*****************************************************************************
273  * GE01
274  ****************************************************************************/
275 struct mv643xx_eth_shared_platform_data orion_ge01_shared_data = {
276         .shared_smi     = &orion_ge00_shared,
277 };
278
279 static struct resource orion_ge01_shared_resources[] = {
280         {
281                 .name   = "ge01 base",
282         }, {
283                 .name   = "ge01 err irq",
284         },
285 };
286
287 static struct platform_device orion_ge01_shared = {
288         .name           = MV643XX_ETH_SHARED_NAME,
289         .id             = 1,
290         .dev            = {
291                 .platform_data  = &orion_ge01_shared_data,
292         },
293 };
294
295 static struct resource orion_ge01_resources[] = {
296         {
297                 .name   = "ge01 irq",
298                 .flags  = IORESOURCE_IRQ,
299         },
300 };
301
302 static struct platform_device orion_ge01 = {
303         .name           = MV643XX_ETH_NAME,
304         .id             = 1,
305         .num_resources  = 1,
306         .resource       = orion_ge01_resources,
307         .dev            = {
308                 .coherent_dma_mask      = DMA_BIT_MASK(32),
309         },
310 };
311
312 void __init orion_ge01_init(struct mv643xx_eth_platform_data *eth_data,
313                             unsigned long mapbase,
314                             unsigned long irq,
315                             unsigned long irq_err,
316                             int tclk)
317 {
318         fill_resources(&orion_ge01_shared, orion_ge01_shared_resources,
319                        mapbase + 0x2000, SZ_16K - 1, irq_err);
320         ge_complete(&orion_ge01_shared_data, tclk,
321                     orion_ge01_resources, irq, &orion_ge01_shared,
322                     eth_data, &orion_ge01);
323 }
324
325 /*****************************************************************************
326  * GE10
327  ****************************************************************************/
328 struct mv643xx_eth_shared_platform_data orion_ge10_shared_data = {
329         .shared_smi     = &orion_ge00_shared,
330 };
331
332 static struct resource orion_ge10_shared_resources[] = {
333         {
334                 .name   = "ge10 base",
335         }, {
336                 .name   = "ge10 err irq",
337         },
338 };
339
340 static struct platform_device orion_ge10_shared = {
341         .name           = MV643XX_ETH_SHARED_NAME,
342         .id             = 1,
343         .dev            = {
344                 .platform_data  = &orion_ge10_shared_data,
345         },
346 };
347
348 static struct resource orion_ge10_resources[] = {
349         {
350                 .name   = "ge10 irq",
351                 .flags  = IORESOURCE_IRQ,
352         },
353 };
354
355 static struct platform_device orion_ge10 = {
356         .name           = MV643XX_ETH_NAME,
357         .id             = 1,
358         .num_resources  = 2,
359         .resource       = orion_ge10_resources,
360         .dev            = {
361                 .coherent_dma_mask      = DMA_BIT_MASK(32),
362         },
363 };
364
365 void __init orion_ge10_init(struct mv643xx_eth_platform_data *eth_data,
366                             unsigned long mapbase,
367                             unsigned long irq,
368                             unsigned long irq_err,
369                             int tclk)
370 {
371         fill_resources(&orion_ge10_shared, orion_ge10_shared_resources,
372                        mapbase + 0x2000, SZ_16K - 1, irq_err);
373         ge_complete(&orion_ge10_shared_data, tclk,
374                     orion_ge10_resources, irq, &orion_ge10_shared,
375                     eth_data, &orion_ge10);
376 }
377
378 /*****************************************************************************
379  * GE11
380  ****************************************************************************/
381 struct mv643xx_eth_shared_platform_data orion_ge11_shared_data = {
382         .shared_smi     = &orion_ge00_shared,
383 };
384
385 static struct resource orion_ge11_shared_resources[] = {
386         {
387                 .name   = "ge11 base",
388         }, {
389                 .name   = "ge11 err irq",
390         },
391 };
392
393 static struct platform_device orion_ge11_shared = {
394         .name           = MV643XX_ETH_SHARED_NAME,
395         .id             = 1,
396         .dev            = {
397                 .platform_data  = &orion_ge11_shared_data,
398         },
399 };
400
401 static struct resource orion_ge11_resources[] = {
402         {
403                 .name   = "ge11 irq",
404                 .flags  = IORESOURCE_IRQ,
405         },
406 };
407
408 static struct platform_device orion_ge11 = {
409         .name           = MV643XX_ETH_NAME,
410         .id             = 1,
411         .num_resources  = 2,
412         .resource       = orion_ge11_resources,
413         .dev            = {
414                 .coherent_dma_mask      = DMA_BIT_MASK(32),
415         },
416 };
417
418 void __init orion_ge11_init(struct mv643xx_eth_platform_data *eth_data,
419                             unsigned long mapbase,
420                             unsigned long irq,
421                             unsigned long irq_err,
422                             int tclk)
423 {
424         fill_resources(&orion_ge11_shared, orion_ge11_shared_resources,
425                        mapbase + 0x2000, SZ_16K - 1, irq_err);
426         ge_complete(&orion_ge11_shared_data, tclk,
427                     orion_ge11_resources, irq, &orion_ge11_shared,
428                     eth_data, &orion_ge11);
429 }
430
431 /*****************************************************************************
432  * Ethernet switch
433  ****************************************************************************/
434 static struct resource orion_switch_resources[] = {
435         {
436                 .start  = 0,
437                 .end    = 0,
438                 .flags  = IORESOURCE_IRQ,
439         },
440 };
441
442 static struct platform_device orion_switch_device = {
443         .name           = "dsa",
444         .id             = 0,
445         .num_resources  = 0,
446         .resource       = orion_switch_resources,
447 };
448
449 void __init orion_ge00_switch_init(struct dsa_platform_data *d, int irq)
450 {
451         int i;
452
453         if (irq != NO_IRQ) {
454                 orion_switch_resources[0].start = irq;
455                 orion_switch_resources[0].end = irq;
456                 orion_switch_device.num_resources = 1;
457         }
458
459         d->netdev = &orion_ge00.dev;
460         for (i = 0; i < d->nr_chips; i++)
461                 d->chip[i].mii_bus = &orion_ge00_shared.dev;
462         orion_switch_device.dev.platform_data = d;
463
464         platform_device_register(&orion_switch_device);
465 }
466
467 /*****************************************************************************
468  * I2C
469  ****************************************************************************/
470 static struct mv64xxx_i2c_pdata orion_i2c_pdata = {
471         .freq_n         = 3,
472         .timeout        = 1000, /* Default timeout of 1 second */
473 };
474
475 static struct resource orion_i2c_resources[2];
476
477 static struct platform_device orion_i2c = {
478         .name           = MV64XXX_I2C_CTLR_NAME,
479         .id             = 0,
480         .dev            = {
481                 .platform_data  = &orion_i2c_pdata,
482         },
483 };
484
485 static struct mv64xxx_i2c_pdata orion_i2c_1_pdata = {
486         .freq_n         = 3,
487         .timeout        = 1000, /* Default timeout of 1 second */
488 };
489
490 static struct resource orion_i2c_1_resources[2];
491
492 static struct platform_device orion_i2c_1 = {
493         .name           = MV64XXX_I2C_CTLR_NAME,
494         .id             = 1,
495         .dev            = {
496                 .platform_data  = &orion_i2c_1_pdata,
497         },
498 };
499
500 void __init orion_i2c_init(unsigned long mapbase,
501                            unsigned long irq,
502                            unsigned long freq_m)
503 {
504         orion_i2c_pdata.freq_m = freq_m;
505         fill_resources(&orion_i2c, orion_i2c_resources, mapbase,
506                        SZ_32 - 1, irq);
507         platform_device_register(&orion_i2c);
508 }
509
510 void __init orion_i2c_1_init(unsigned long mapbase,
511                              unsigned long irq,
512                              unsigned long freq_m)
513 {
514         orion_i2c_1_pdata.freq_m = freq_m;
515         fill_resources(&orion_i2c_1, orion_i2c_1_resources, mapbase,
516                        SZ_32 - 1, irq);
517         platform_device_register(&orion_i2c_1);
518 }
519
520 /*****************************************************************************
521  * SPI
522  ****************************************************************************/
523 static struct orion_spi_info orion_spi_plat_data;
524 static struct resource orion_spi_resources;
525
526 static struct platform_device orion_spi = {
527         .name           = "orion_spi",
528         .id             = 0,
529         .dev            = {
530                 .platform_data  = &orion_spi_plat_data,
531         },
532 };
533
534 static struct orion_spi_info orion_spi_1_plat_data;
535 static struct resource orion_spi_1_resources;
536
537 static struct platform_device orion_spi_1 = {
538         .name           = "orion_spi",
539         .id             = 1,
540         .dev            = {
541                 .platform_data  = &orion_spi_1_plat_data,
542         },
543 };
544
545 /* Note: The SPI silicon core does have interrupts. However the
546  * current Linux software driver does not use interrupts. */
547
548 void __init orion_spi_init(unsigned long mapbase,
549                            unsigned long tclk)
550 {
551         orion_spi_plat_data.tclk = tclk;
552         fill_resources(&orion_spi, &orion_spi_resources,
553                        mapbase, SZ_512 - 1, NO_IRQ);
554         platform_device_register(&orion_spi);
555 }
556
557 void __init orion_spi_1_init(unsigned long mapbase,
558                              unsigned long tclk)
559 {
560         orion_spi_1_plat_data.tclk = tclk;
561         fill_resources(&orion_spi_1, &orion_spi_1_resources,
562                        mapbase, SZ_512 - 1, NO_IRQ);
563         platform_device_register(&orion_spi_1);
564 }
565
566 /*****************************************************************************
567  * Watchdog
568  ****************************************************************************/
569 static struct orion_wdt_platform_data orion_wdt_data;
570
571 static struct platform_device orion_wdt_device = {
572         .name           = "orion_wdt",
573         .id             = -1,
574         .dev            = {
575                 .platform_data  = &orion_wdt_data,
576         },
577         .num_resources  = 0,
578 };
579
580 void __init orion_wdt_init(unsigned long tclk)
581 {
582         orion_wdt_data.tclk = tclk;
583         platform_device_register(&orion_wdt_device);
584 }
585
586 /*****************************************************************************
587  * XOR
588  ****************************************************************************/
589 static u64 orion_xor_dmamask = DMA_BIT_MASK(32);
590
591 void __init orion_xor_init_channels(
592         struct mv_xor_platform_data *orion_xor0_data,
593         struct platform_device *orion_xor0_channel,
594         struct mv_xor_platform_data *orion_xor1_data,
595         struct platform_device *orion_xor1_channel)
596 {
597         /*
598          * two engines can't do memset simultaneously, this limitation
599          * satisfied by removing memset support from one of the engines.
600          */
601         dma_cap_set(DMA_MEMCPY, orion_xor0_data->cap_mask);
602         dma_cap_set(DMA_XOR, orion_xor0_data->cap_mask);
603         platform_device_register(orion_xor0_channel);
604
605         dma_cap_set(DMA_MEMCPY, orion_xor1_data->cap_mask);
606         dma_cap_set(DMA_MEMSET, orion_xor1_data->cap_mask);
607         dma_cap_set(DMA_XOR, orion_xor1_data->cap_mask);
608         platform_device_register(orion_xor1_channel);
609 }
610
611 /*****************************************************************************
612  * XOR0
613  ****************************************************************************/
614 static struct resource orion_xor0_shared_resources[] = {
615         {
616                 .name   = "xor 0 low",
617                 .flags  = IORESOURCE_MEM,
618         }, {
619                 .name   = "xor 0 high",
620                 .flags  = IORESOURCE_MEM,
621         },
622 };
623
624 static struct platform_device orion_xor0_shared = {
625         .name           = MV_XOR_SHARED_NAME,
626         .id             = 0,
627         .num_resources  = ARRAY_SIZE(orion_xor0_shared_resources),
628         .resource       = orion_xor0_shared_resources,
629 };
630
631 static struct resource orion_xor00_resources[] = {
632         [0] = {
633                 .flags  = IORESOURCE_IRQ,
634         },
635 };
636
637 static struct mv_xor_platform_data orion_xor00_data = {
638         .shared         = &orion_xor0_shared,
639         .hw_id          = 0,
640         .pool_size      = PAGE_SIZE,
641 };
642
643 static struct platform_device orion_xor00_channel = {
644         .name           = MV_XOR_NAME,
645         .id             = 0,
646         .num_resources  = ARRAY_SIZE(orion_xor00_resources),
647         .resource       = orion_xor00_resources,
648         .dev            = {
649                 .dma_mask               = &orion_xor_dmamask,
650                 .coherent_dma_mask      = DMA_BIT_MASK(64),
651                 .platform_data          = &orion_xor00_data,
652         },
653 };
654
655 static struct resource orion_xor01_resources[] = {
656         [0] = {
657                 .flags  = IORESOURCE_IRQ,
658         },
659 };
660
661 static struct mv_xor_platform_data orion_xor01_data = {
662         .shared         = &orion_xor0_shared,
663         .hw_id          = 1,
664         .pool_size      = PAGE_SIZE,
665 };
666
667 static struct platform_device orion_xor01_channel = {
668         .name           = MV_XOR_NAME,
669         .id             = 1,
670         .num_resources  = ARRAY_SIZE(orion_xor01_resources),
671         .resource       = orion_xor01_resources,
672         .dev            = {
673                 .dma_mask               = &orion_xor_dmamask,
674                 .coherent_dma_mask      = DMA_BIT_MASK(64),
675                 .platform_data          = &orion_xor01_data,
676         },
677 };
678
679 void __init orion_xor0_init(unsigned long mapbase_low,
680                             unsigned long mapbase_high,
681                             unsigned long irq_0,
682                             unsigned long irq_1)
683 {
684         orion_xor0_shared_resources[0].start = mapbase_low;
685         orion_xor0_shared_resources[0].end = mapbase_low + 0xff;
686         orion_xor0_shared_resources[1].start = mapbase_high;
687         orion_xor0_shared_resources[1].end = mapbase_high + 0xff;
688
689         orion_xor00_resources[0].start = irq_0;
690         orion_xor00_resources[0].end = irq_0;
691         orion_xor01_resources[0].start = irq_1;
692         orion_xor01_resources[0].end = irq_1;
693
694         platform_device_register(&orion_xor0_shared);
695
696         orion_xor_init_channels(&orion_xor00_data, &orion_xor00_channel,
697                                 &orion_xor01_data, &orion_xor01_channel);
698 }
699
700 /*****************************************************************************
701  * XOR1
702  ****************************************************************************/
703 static struct resource orion_xor1_shared_resources[] = {
704         {
705                 .name   = "xor 1 low",
706                 .flags  = IORESOURCE_MEM,
707         }, {
708                 .name   = "xor 1 high",
709                 .flags  = IORESOURCE_MEM,
710         },
711 };
712
713 static struct platform_device orion_xor1_shared = {
714         .name           = MV_XOR_SHARED_NAME,
715         .id             = 1,
716         .num_resources  = ARRAY_SIZE(orion_xor1_shared_resources),
717         .resource       = orion_xor1_shared_resources,
718 };
719
720 static struct resource orion_xor10_resources[] = {
721         [0] = {
722                 .flags  = IORESOURCE_IRQ,
723         },
724 };
725
726 static struct mv_xor_platform_data orion_xor10_data = {
727         .shared         = &orion_xor1_shared,
728         .hw_id          = 0,
729         .pool_size      = PAGE_SIZE,
730 };
731
732 static struct platform_device orion_xor10_channel = {
733         .name           = MV_XOR_NAME,
734         .id             = 2,
735         .num_resources  = ARRAY_SIZE(orion_xor10_resources),
736         .resource       = orion_xor10_resources,
737         .dev            = {
738                 .dma_mask               = &orion_xor_dmamask,
739                 .coherent_dma_mask      = DMA_BIT_MASK(64),
740                 .platform_data          = &orion_xor10_data,
741         },
742 };
743
744 static struct resource orion_xor11_resources[] = {
745         [0] = {
746                 .flags  = IORESOURCE_IRQ,
747         },
748 };
749
750 static struct mv_xor_platform_data orion_xor11_data = {
751         .shared         = &orion_xor1_shared,
752         .hw_id          = 1,
753         .pool_size      = PAGE_SIZE,
754 };
755
756 static struct platform_device orion_xor11_channel = {
757         .name           = MV_XOR_NAME,
758         .id             = 3,
759         .num_resources  = ARRAY_SIZE(orion_xor11_resources),
760         .resource       = orion_xor11_resources,
761         .dev            = {
762                 .dma_mask               = &orion_xor_dmamask,
763                 .coherent_dma_mask      = DMA_BIT_MASK(64),
764                 .platform_data          = &orion_xor11_data,
765         },
766 };
767
768 void __init orion_xor1_init(unsigned long mapbase_low,
769                             unsigned long mapbase_high,
770                             unsigned long irq_0,
771                             unsigned long irq_1)
772 {
773         orion_xor1_shared_resources[0].start = mapbase_low;
774         orion_xor1_shared_resources[0].end = mapbase_low + 0xff;
775         orion_xor1_shared_resources[1].start = mapbase_high;
776         orion_xor1_shared_resources[1].end = mapbase_high + 0xff;
777
778         orion_xor10_resources[0].start = irq_0;
779         orion_xor10_resources[0].end = irq_0;
780         orion_xor11_resources[0].start = irq_1;
781         orion_xor11_resources[0].end = irq_1;
782
783         platform_device_register(&orion_xor1_shared);
784
785         orion_xor_init_channels(&orion_xor10_data, &orion_xor10_channel,
786                                 &orion_xor11_data, &orion_xor11_channel);
787 }
788
789 /*****************************************************************************
790  * EHCI
791  ****************************************************************************/
792 static struct orion_ehci_data orion_ehci_data;
793 static u64 ehci_dmamask = DMA_BIT_MASK(32);
794
795
796 /*****************************************************************************
797  * EHCI0
798  ****************************************************************************/
799 static struct resource orion_ehci_resources[2];
800
801 static struct platform_device orion_ehci = {
802         .name           = "orion-ehci",
803         .id             = 0,
804         .dev            = {
805                 .dma_mask               = &ehci_dmamask,
806                 .coherent_dma_mask      = DMA_BIT_MASK(32),
807                 .platform_data          = &orion_ehci_data,
808         },
809 };
810
811 void __init orion_ehci_init(unsigned long mapbase,
812                             unsigned long irq,
813                             enum orion_ehci_phy_ver phy_version)
814 {
815         orion_ehci_data.phy_version = phy_version;
816         fill_resources(&orion_ehci, orion_ehci_resources, mapbase, SZ_4K - 1,
817                        irq);
818
819         platform_device_register(&orion_ehci);
820 }
821
822 /*****************************************************************************
823  * EHCI1
824  ****************************************************************************/
825 static struct resource orion_ehci_1_resources[2];
826
827 static struct platform_device orion_ehci_1 = {
828         .name           = "orion-ehci",
829         .id             = 1,
830         .dev            = {
831                 .dma_mask               = &ehci_dmamask,
832                 .coherent_dma_mask      = DMA_BIT_MASK(32),
833                 .platform_data          = &orion_ehci_data,
834         },
835 };
836
837 void __init orion_ehci_1_init(unsigned long mapbase,
838                               unsigned long irq)
839 {
840         fill_resources(&orion_ehci_1, orion_ehci_1_resources,
841                        mapbase, SZ_4K - 1, irq);
842
843         platform_device_register(&orion_ehci_1);
844 }
845
846 /*****************************************************************************
847  * EHCI2
848  ****************************************************************************/
849 static struct resource orion_ehci_2_resources[2];
850
851 static struct platform_device orion_ehci_2 = {
852         .name           = "orion-ehci",
853         .id             = 2,
854         .dev            = {
855                 .dma_mask               = &ehci_dmamask,
856                 .coherent_dma_mask      = DMA_BIT_MASK(32),
857                 .platform_data          = &orion_ehci_data,
858         },
859 };
860
861 void __init orion_ehci_2_init(unsigned long mapbase,
862                               unsigned long irq)
863 {
864         fill_resources(&orion_ehci_2, orion_ehci_2_resources,
865                        mapbase, SZ_4K - 1, irq);
866
867         platform_device_register(&orion_ehci_2);
868 }
869
870 /*****************************************************************************
871  * SATA
872  ****************************************************************************/
873 static struct resource orion_sata_resources[2] = {
874         {
875                 .name   = "sata base",
876         }, {
877                 .name   = "sata irq",
878         },
879 };
880
881 static struct platform_device orion_sata = {
882         .name           = "sata_mv",
883         .id             = 0,
884         .dev            = {
885                 .coherent_dma_mask      = DMA_BIT_MASK(32),
886         },
887 };
888
889 void __init orion_sata_init(struct mv_sata_platform_data *sata_data,
890                             unsigned long mapbase,
891                             unsigned long irq)
892 {
893         orion_sata.dev.platform_data = sata_data;
894         fill_resources(&orion_sata, orion_sata_resources,
895                        mapbase, 0x5000 - 1, irq);
896
897         platform_device_register(&orion_sata);
898 }
899
900 /*****************************************************************************
901  * Cryptographic Engines and Security Accelerator (CESA)
902  ****************************************************************************/
903 static struct resource orion_crypto_resources[] = {
904         {
905                 .name   = "regs",
906         }, {
907                 .name   = "crypto interrupt",
908         }, {
909                 .name   = "sram",
910                 .flags  = IORESOURCE_MEM,
911         },
912 };
913
914 static struct platform_device orion_crypto = {
915         .name           = "mv_crypto",
916         .id             = -1,
917 };
918
919 void __init orion_crypto_init(unsigned long mapbase,
920                               unsigned long srambase,
921                               unsigned long sram_size,
922                               unsigned long irq)
923 {
924         fill_resources(&orion_crypto, orion_crypto_resources,
925                        mapbase, 0xffff, irq);
926         orion_crypto.num_resources = 3;
927         orion_crypto_resources[2].start = srambase;
928         orion_crypto_resources[2].end = srambase + sram_size - 1;
929
930         platform_device_register(&orion_crypto);
931 }