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 <plat/common.h>
25
26
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
34
35
36
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
50
51
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
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
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
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
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
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
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
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
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
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
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
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
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
505
506static struct mv64xxx_i2c_pdata orion_i2c_pdata = {
507 .freq_n = 3,
508 .timeout = 1000,
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,
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
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
574
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
592
593static u64 orion_xor_dmamask = DMA_BIT_MASK(32);
594
595
596
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
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
719
720static struct orion_ehci_data orion_ehci_data;
721static u64 ehci_dmamask = DMA_BIT_MASK(32);
722
723
724
725
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
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
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
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
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}
860
