xref: /openbmc/linux/arch/arm/plat-orion/common.c (revision 0edbfea5)
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 */
27 void __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. */
37 void __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.*/
52 static 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  ****************************************************************************/
75 static unsigned long __init uart_get_clk_rate(struct clk *clk)
76 {
77 	clk_prepare_enable(clk);
78 	return clk_get_rate(clk);
79 }
80 
81 static 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  ****************************************************************************/
103 static 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 
112 static struct resource orion_uart0_resources[2];
113 
114 static struct platform_device orion_uart0 = {
115 	.name			= "serial8250",
116 	.id			= PLAT8250_DEV_PLATFORM,
117 };
118 
119 void __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  ****************************************************************************/
131 static 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 
140 static struct resource orion_uart1_resources[2];
141 
142 static struct platform_device orion_uart1 = {
143 	.name			= "serial8250",
144 	.id			= PLAT8250_DEV_PLATFORM1,
145 };
146 
147 void __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  ****************************************************************************/
159 static 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 
168 static struct resource orion_uart2_resources[2];
169 
170 static struct platform_device orion_uart2 = {
171 	.name			= "serial8250",
172 	.id			= PLAT8250_DEV_PLATFORM2,
173 };
174 
175 void __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  ****************************************************************************/
187 static 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 
196 static struct resource orion_uart3_resources[2];
197 
198 static struct platform_device orion_uart3 = {
199 	.name			= "serial8250",
200 	.id			= 3,
201 };
202 
203 void __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  ****************************************************************************/
215 static struct resource orion_rtc_resource[2];
216 
217 void __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  ****************************************************************************/
233 static __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  ****************************************************************************/
255 static struct mv643xx_eth_shared_platform_data orion_ge00_shared_data;
256 
257 static struct resource orion_ge00_shared_resources[] = {
258 	{
259 		.name	= "ge00 base",
260 	},
261 };
262 
263 static 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 
271 static struct resource orion_ge_mvmdio_resources[] = {
272 	{
273 		.name	= "ge00 mvmdio base",
274 	}, {
275 		.name	= "ge00 mvmdio err irq",
276 	},
277 };
278 
279 static struct platform_device orion_ge_mvmdio = {
280 	.name		= "orion-mdio",
281 	.id		= -1,
282 };
283 
284 static struct resource orion_ge00_resources[] = {
285 	{
286 		.name	= "ge00 irq",
287 		.flags	= IORESOURCE_IRQ,
288 	},
289 };
290 
291 static 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 
301 void __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  ****************************************************************************/
321 static struct mv643xx_eth_shared_platform_data orion_ge01_shared_data;
322 
323 static struct resource orion_ge01_shared_resources[] = {
324 	{
325 		.name	= "ge01 base",
326 	}
327 };
328 
329 static 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 
337 static struct resource orion_ge01_resources[] = {
338 	{
339 		.name	= "ge01 irq",
340 		.flags	= IORESOURCE_IRQ,
341 	},
342 };
343 
344 static 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 
354 void __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  ****************************************************************************/
372 static struct mv643xx_eth_shared_platform_data orion_ge10_shared_data;
373 
374 static struct resource orion_ge10_shared_resources[] = {
375 	{
376 		.name	= "ge10 base",
377 	}
378 };
379 
380 static 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 
388 static struct resource orion_ge10_resources[] = {
389 	{
390 		.name	= "ge10 irq",
391 		.flags	= IORESOURCE_IRQ,
392 	},
393 };
394 
395 static 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 
405 void __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  ****************************************************************************/
421 static struct mv643xx_eth_shared_platform_data orion_ge11_shared_data;
422 
423 static struct resource orion_ge11_shared_resources[] = {
424 	{
425 		.name	= "ge11 base",
426 	},
427 };
428 
429 static 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 
437 static struct resource orion_ge11_resources[] = {
438 	{
439 		.name	= "ge11 irq",
440 		.flags	= IORESOURCE_IRQ,
441 	},
442 };
443 
444 static 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 
454 void __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  ****************************************************************************/
470 static struct resource orion_switch_resources[] = {
471 	{
472 		.start	= 0,
473 		.end	= 0,
474 		.flags	= IORESOURCE_IRQ,
475 	},
476 };
477 
478 static struct platform_device orion_switch_device = {
479 	.name		= "dsa",
480 	.id		= 0,
481 	.num_resources	= 0,
482 	.resource	= orion_switch_resources,
483 };
484 
485 void __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  ****************************************************************************/
506 static struct mv64xxx_i2c_pdata orion_i2c_pdata = {
507 	.freq_n		= 3,
508 	.timeout	= 1000, /* Default timeout of 1 second */
509 };
510 
511 static struct resource orion_i2c_resources[2];
512 
513 static 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 
521 static struct mv64xxx_i2c_pdata orion_i2c_1_pdata = {
522 	.freq_n		= 3,
523 	.timeout	= 1000, /* Default timeout of 1 second */
524 };
525 
526 static struct resource orion_i2c_1_resources[2];
527 
528 static 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 
536 void __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 
546 void __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  ****************************************************************************/
559 static struct resource orion_spi_resources;
560 
561 static struct platform_device orion_spi = {
562 	.name		= "orion_spi",
563 	.id		= 0,
564 };
565 
566 static struct resource orion_spi_1_resources;
567 
568 static 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 
576 void __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 
583 void __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  ****************************************************************************/
593 static u64 orion_xor_dmamask = DMA_BIT_MASK(32);
594 
595 /*****************************************************************************
596  * XOR0
597  ****************************************************************************/
598 static 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 
614 static struct mv_xor_channel_data orion_xor0_channels_data[2];
615 
616 static struct mv_xor_platform_data orion_xor0_pdata = {
617 	.channels = orion_xor0_channels_data,
618 };
619 
620 static 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 
632 void __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  ****************************************************************************/
659 static 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 
675 static struct mv_xor_channel_data orion_xor1_channels_data[2];
676 
677 static struct mv_xor_platform_data orion_xor1_pdata = {
678 	.channels = orion_xor1_channels_data,
679 };
680 
681 static 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 
693 void __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  ****************************************************************************/
720 static struct orion_ehci_data orion_ehci_data;
721 static u64 ehci_dmamask = DMA_BIT_MASK(32);
722 
723 
724 /*****************************************************************************
725  * EHCI0
726  ****************************************************************************/
727 static struct resource orion_ehci_resources[2];
728 
729 static 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 
739 void __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  ****************************************************************************/
753 static struct resource orion_ehci_1_resources[2];
754 
755 static 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 
765 void __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  ****************************************************************************/
777 static struct resource orion_ehci_2_resources[2];
778 
779 static 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 
789 void __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  ****************************************************************************/
801 static struct resource orion_sata_resources[2] = {
802 	{
803 		.name	= "sata base",
804 	}, {
805 		.name	= "sata irq",
806 	},
807 };
808 
809 static 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 
817 void __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  ****************************************************************************/
831 static 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 
842 static struct platform_device orion_crypto = {
843 	.name           = "mv_crypto",
844 	.id             = -1,
845 };
846 
847 void __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