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