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