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