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