Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
common.c
Go to the documentation of this file.
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>
24 #include <mach/bridge-regs.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  struct clk_lookup *cl;
31 
32  cl = clkdev_alloc(clk, con_id, dev_id);
33  if (cl)
34  clkdev_add(cl);
35 }
36 
37 /* Create clkdev entries for all orion platforms except kirkwood.
38  Kirkwood has gated clocks for some of its peripherals, so creates
39  its own clkdev entries. For all the other orion devices, create
40  clkdev entries to the tclk. */
41 void __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);
49  orion_clkdev_add(NULL, "orion_wdt", tclk);
51 }
52 
53 /* Fill in the resources structure and link it into the platform
54  device structure. There is always a memory region, and nearly
55  always an interrupt.*/
56 static void fill_resources(struct platform_device *device,
57  struct resource *resources,
58  resource_size_t mapbase,
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  * UART
78  ****************************************************************************/
79 static unsigned long __init uart_get_clk_rate(struct clk *clk)
80 {
81  clk_prepare_enable(clk);
82  return clk_get_rate(clk);
83 }
84 
85 static 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  * UART0
106  ****************************************************************************/
107 static 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 
116 static struct resource orion_uart0_resources[2];
117 
118 static struct platform_device orion_uart0 = {
119  .name = "serial8250",
120  .id = PLAT8250_DEV_PLATFORM,
121 };
122 
123 void __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  * UART1
134  ****************************************************************************/
135 static 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 
144 static struct resource orion_uart1_resources[2];
145 
146 static struct platform_device orion_uart1 = {
147  .name = "serial8250",
149 };
150 
151 void __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  * UART2
162  ****************************************************************************/
163 static 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 
172 static struct resource orion_uart2_resources[2];
173 
174 static struct platform_device orion_uart2 = {
175  .name = "serial8250",
177 };
178 
179 void __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  * UART3
190  ****************************************************************************/
191 static 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 
200 static struct resource orion_uart3_resources[2];
201 
202 static struct platform_device orion_uart3 = {
203  .name = "serial8250",
204  .id = 3,
205 };
206 
207 void __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  * SoC RTC
218  ****************************************************************************/
219 static struct resource orion_rtc_resource[2];
220 
221 void __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  * GE
236  ****************************************************************************/
237 static __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 mv643xx_eth_platform_data *eth_data,
242  struct platform_device *orion_ge)
243 {
244  orion_ge_resource->start = irq;
245  orion_ge_resource->end = irq;
246  eth_data->shared = orion_ge_shared;
247  orion_ge->dev.platform_data = eth_data;
248 
249  platform_device_register(orion_ge_shared);
250  platform_device_register(orion_ge);
251 }
252 
253 /*****************************************************************************
254  * GE00
255  ****************************************************************************/
257 
258 static struct resource orion_ge00_shared_resources[] = {
259  {
260  .name = "ge00 base",
261  }, {
262  .name = "ge00 err irq",
263  },
264 };
265 
266 static struct platform_device orion_ge00_shared = {
267  .name = MV643XX_ETH_SHARED_NAME,
268  .id = 0,
269  .dev = {
270  .platform_data = &orion_ge00_shared_data,
271  },
272 };
273 
274 static struct resource orion_ge00_resources[] = {
275  {
276  .name = "ge00 irq",
277  .flags = IORESOURCE_IRQ,
278  },
279 };
280 
281 static struct platform_device orion_ge00 = {
282  .name = MV643XX_ETH_NAME,
283  .id = 0,
284  .num_resources = 1,
285  .resource = orion_ge00_resources,
286  .dev = {
287  .coherent_dma_mask = DMA_BIT_MASK(32),
288  },
289 };
290 
292  unsigned long mapbase,
293  unsigned long irq,
294  unsigned long irq_err,
295  unsigned int tx_csum_limit)
296 {
297  fill_resources(&orion_ge00_shared, orion_ge00_shared_resources,
298  mapbase + 0x2000, SZ_16K - 1, irq_err);
299  orion_ge00_shared_data.tx_csum_limit = tx_csum_limit;
300  ge_complete(&orion_ge00_shared_data,
301  orion_ge00_resources, irq, &orion_ge00_shared,
302  eth_data, &orion_ge00);
303 }
304 
305 /*****************************************************************************
306  * GE01
307  ****************************************************************************/
309  .shared_smi = &orion_ge00_shared,
310 };
311 
312 static struct resource orion_ge01_shared_resources[] = {
313  {
314  .name = "ge01 base",
315  }, {
316  .name = "ge01 err irq",
317  },
318 };
319 
320 static struct platform_device orion_ge01_shared = {
321  .name = MV643XX_ETH_SHARED_NAME,
322  .id = 1,
323  .dev = {
324  .platform_data = &orion_ge01_shared_data,
325  },
326 };
327 
328 static struct resource orion_ge01_resources[] = {
329  {
330  .name = "ge01 irq",
331  .flags = IORESOURCE_IRQ,
332  },
333 };
334 
335 static struct platform_device orion_ge01 = {
336  .name = MV643XX_ETH_NAME,
337  .id = 1,
338  .num_resources = 1,
339  .resource = orion_ge01_resources,
340  .dev = {
341  .coherent_dma_mask = DMA_BIT_MASK(32),
342  },
343 };
344 
346  unsigned long mapbase,
347  unsigned long irq,
348  unsigned long irq_err,
349  unsigned int tx_csum_limit)
350 {
351  fill_resources(&orion_ge01_shared, orion_ge01_shared_resources,
352  mapbase + 0x2000, SZ_16K - 1, irq_err);
353  orion_ge01_shared_data.tx_csum_limit = tx_csum_limit;
354  ge_complete(&orion_ge01_shared_data,
355  orion_ge01_resources, irq, &orion_ge01_shared,
356  eth_data, &orion_ge01);
357 }
358 
359 /*****************************************************************************
360  * GE10
361  ****************************************************************************/
363  .shared_smi = &orion_ge00_shared,
364 };
365 
366 static struct resource orion_ge10_shared_resources[] = {
367  {
368  .name = "ge10 base",
369  }, {
370  .name = "ge10 err irq",
371  },
372 };
373 
374 static struct platform_device orion_ge10_shared = {
375  .name = MV643XX_ETH_SHARED_NAME,
376  .id = 1,
377  .dev = {
378  .platform_data = &orion_ge10_shared_data,
379  },
380 };
381 
382 static struct resource orion_ge10_resources[] = {
383  {
384  .name = "ge10 irq",
385  .flags = IORESOURCE_IRQ,
386  },
387 };
388 
389 static struct platform_device orion_ge10 = {
390  .name = MV643XX_ETH_NAME,
391  .id = 1,
392  .num_resources = 2,
393  .resource = orion_ge10_resources,
394  .dev = {
395  .coherent_dma_mask = DMA_BIT_MASK(32),
396  },
397 };
398 
400  unsigned long mapbase,
401  unsigned long irq,
402  unsigned long irq_err)
403 {
404  fill_resources(&orion_ge10_shared, orion_ge10_shared_resources,
405  mapbase + 0x2000, SZ_16K - 1, irq_err);
406  ge_complete(&orion_ge10_shared_data,
407  orion_ge10_resources, irq, &orion_ge10_shared,
408  eth_data, &orion_ge10);
409 }
410 
411 /*****************************************************************************
412  * GE11
413  ****************************************************************************/
415  .shared_smi = &orion_ge00_shared,
416 };
417 
418 static struct resource orion_ge11_shared_resources[] = {
419  {
420  .name = "ge11 base",
421  }, {
422  .name = "ge11 err irq",
423  },
424 };
425 
426 static struct platform_device orion_ge11_shared = {
427  .name = MV643XX_ETH_SHARED_NAME,
428  .id = 1,
429  .dev = {
430  .platform_data = &orion_ge11_shared_data,
431  },
432 };
433 
434 static struct resource orion_ge11_resources[] = {
435  {
436  .name = "ge11 irq",
437  .flags = IORESOURCE_IRQ,
438  },
439 };
440 
441 static struct platform_device orion_ge11 = {
442  .name = MV643XX_ETH_NAME,
443  .id = 1,
444  .num_resources = 2,
445  .resource = orion_ge11_resources,
446  .dev = {
447  .coherent_dma_mask = DMA_BIT_MASK(32),
448  },
449 };
450 
452  unsigned long mapbase,
453  unsigned long irq,
454  unsigned long irq_err)
455 {
456  fill_resources(&orion_ge11_shared, orion_ge11_shared_resources,
457  mapbase + 0x2000, SZ_16K - 1, irq_err);
458  ge_complete(&orion_ge11_shared_data,
459  orion_ge11_resources, irq, &orion_ge11_shared,
460  eth_data, &orion_ge11);
461 }
462 
463 /*****************************************************************************
464  * Ethernet switch
465  ****************************************************************************/
466 static struct resource orion_switch_resources[] = {
467  {
468  .start = 0,
469  .end = 0,
470  .flags = IORESOURCE_IRQ,
471  },
472 };
473 
474 static struct platform_device orion_switch_device = {
475  .name = "dsa",
476  .id = 0,
477  .num_resources = 0,
478  .resource = orion_switch_resources,
479 };
480 
482 {
483  int i;
484 
485  if (irq != NO_IRQ) {
486  orion_switch_resources[0].start = irq;
487  orion_switch_resources[0].end = irq;
488  orion_switch_device.num_resources = 1;
489  }
490 
491  d->netdev = &orion_ge00.dev;
492  for (i = 0; i < d->nr_chips; i++)
493  d->chip[i].mii_bus = &orion_ge00_shared.dev;
494  orion_switch_device.dev.platform_data = d;
495 
496  platform_device_register(&orion_switch_device);
497 }
498 
499 /*****************************************************************************
500  * I2C
501  ****************************************************************************/
502 static struct mv64xxx_i2c_pdata orion_i2c_pdata = {
503  .freq_n = 3,
504  .timeout = 1000, /* Default timeout of 1 second */
505 };
506 
507 static struct resource orion_i2c_resources[2];
508 
509 static struct platform_device orion_i2c = {
510  .name = MV64XXX_I2C_CTLR_NAME,
511  .id = 0,
512  .dev = {
513  .platform_data = &orion_i2c_pdata,
514  },
515 };
516 
517 static struct mv64xxx_i2c_pdata orion_i2c_1_pdata = {
518  .freq_n = 3,
519  .timeout = 1000, /* Default timeout of 1 second */
520 };
521 
522 static struct resource orion_i2c_1_resources[2];
523 
524 static struct platform_device orion_i2c_1 = {
525  .name = MV64XXX_I2C_CTLR_NAME,
526  .id = 1,
527  .dev = {
528  .platform_data = &orion_i2c_1_pdata,
529  },
530 };
531 
532 void __init orion_i2c_init(unsigned long mapbase,
533  unsigned long irq,
534  unsigned long freq_m)
535 {
536  orion_i2c_pdata.freq_m = freq_m;
537  fill_resources(&orion_i2c, orion_i2c_resources, mapbase,
538  SZ_32 - 1, irq);
539  platform_device_register(&orion_i2c);
540 }
541 
542 void __init orion_i2c_1_init(unsigned long mapbase,
543  unsigned long irq,
544  unsigned long freq_m)
545 {
546  orion_i2c_1_pdata.freq_m = freq_m;
547  fill_resources(&orion_i2c_1, orion_i2c_1_resources, mapbase,
548  SZ_32 - 1, irq);
549  platform_device_register(&orion_i2c_1);
550 }
551 
552 /*****************************************************************************
553  * SPI
554  ****************************************************************************/
555 static struct resource orion_spi_resources;
556 
557 static struct platform_device orion_spi = {
558  .name = "orion_spi",
559  .id = 0,
560 };
561 
562 static struct resource orion_spi_1_resources;
563 
564 static struct platform_device orion_spi_1 = {
565  .name = "orion_spi",
566  .id = 1,
567 };
568 
569 /* Note: The SPI silicon core does have interrupts. However the
570  * current Linux software driver does not use interrupts. */
571 
572 void __init orion_spi_init(unsigned long mapbase)
573 {
574  fill_resources(&orion_spi, &orion_spi_resources,
575  mapbase, SZ_512 - 1, NO_IRQ);
576  platform_device_register(&orion_spi);
577 }
578 
579 void __init orion_spi_1_init(unsigned long mapbase)
580 {
581  fill_resources(&orion_spi_1, &orion_spi_1_resources,
582  mapbase, SZ_512 - 1, NO_IRQ);
583  platform_device_register(&orion_spi_1);
584 }
585 
586 /*****************************************************************************
587  * Watchdog
588  ****************************************************************************/
589 static struct resource orion_wdt_resource =
591 
592 static struct platform_device orion_wdt_device = {
593  .name = "orion_wdt",
594  .id = -1,
595  .num_resources = 1,
596  .resource = &orion_wdt_resource,
597 };
598 
600 {
601  platform_device_register(&orion_wdt_device);
602 }
603 
604 /*****************************************************************************
605  * XOR
606  ****************************************************************************/
607 static u64 orion_xor_dmamask = DMA_BIT_MASK(32);
608 
610  struct mv_xor_platform_data *orion_xor0_data,
611  struct platform_device *orion_xor0_channel,
612  struct mv_xor_platform_data *orion_xor1_data,
613  struct platform_device *orion_xor1_channel)
614 {
615  /*
616  * two engines can't do memset simultaneously, this limitation
617  * satisfied by removing memset support from one of the engines.
618  */
619  dma_cap_set(DMA_MEMCPY, orion_xor0_data->cap_mask);
620  dma_cap_set(DMA_XOR, orion_xor0_data->cap_mask);
621  platform_device_register(orion_xor0_channel);
622 
623  dma_cap_set(DMA_MEMCPY, orion_xor1_data->cap_mask);
624  dma_cap_set(DMA_MEMSET, orion_xor1_data->cap_mask);
625  dma_cap_set(DMA_XOR, orion_xor1_data->cap_mask);
626  platform_device_register(orion_xor1_channel);
627 }
628 
629 /*****************************************************************************
630  * XOR0
631  ****************************************************************************/
632 static struct resource orion_xor0_shared_resources[] = {
633  {
634  .name = "xor 0 low",
635  .flags = IORESOURCE_MEM,
636  }, {
637  .name = "xor 0 high",
638  .flags = IORESOURCE_MEM,
639  },
640 };
641 
642 static struct platform_device orion_xor0_shared = {
643  .name = MV_XOR_SHARED_NAME,
644  .id = 0,
645  .num_resources = ARRAY_SIZE(orion_xor0_shared_resources),
646  .resource = orion_xor0_shared_resources,
647 };
648 
649 static struct resource orion_xor00_resources[] = {
650  [0] = {
651  .flags = IORESOURCE_IRQ,
652  },
653 };
654 
655 static struct mv_xor_platform_data orion_xor00_data = {
656  .shared = &orion_xor0_shared,
657  .hw_id = 0,
658  .pool_size = PAGE_SIZE,
659 };
660 
661 static struct platform_device orion_xor00_channel = {
662  .name = MV_XOR_NAME,
663  .id = 0,
664  .num_resources = ARRAY_SIZE(orion_xor00_resources),
665  .resource = orion_xor00_resources,
666  .dev = {
667  .dma_mask = &orion_xor_dmamask,
668  .coherent_dma_mask = DMA_BIT_MASK(64),
669  .platform_data = &orion_xor00_data,
670  },
671 };
672 
673 static struct resource orion_xor01_resources[] = {
674  [0] = {
675  .flags = IORESOURCE_IRQ,
676  },
677 };
678 
679 static struct mv_xor_platform_data orion_xor01_data = {
680  .shared = &orion_xor0_shared,
681  .hw_id = 1,
682  .pool_size = PAGE_SIZE,
683 };
684 
685 static struct platform_device orion_xor01_channel = {
686  .name = MV_XOR_NAME,
687  .id = 1,
688  .num_resources = ARRAY_SIZE(orion_xor01_resources),
689  .resource = orion_xor01_resources,
690  .dev = {
691  .dma_mask = &orion_xor_dmamask,
692  .coherent_dma_mask = DMA_BIT_MASK(64),
693  .platform_data = &orion_xor01_data,
694  },
695 };
696 
697 void __init orion_xor0_init(unsigned long mapbase_low,
698  unsigned long mapbase_high,
699  unsigned long irq_0,
700  unsigned long irq_1)
701 {
702  orion_xor0_shared_resources[0].start = mapbase_low;
703  orion_xor0_shared_resources[0].end = mapbase_low + 0xff;
704  orion_xor0_shared_resources[1].start = mapbase_high;
705  orion_xor0_shared_resources[1].end = mapbase_high + 0xff;
706 
707  orion_xor00_resources[0].start = irq_0;
708  orion_xor00_resources[0].end = irq_0;
709  orion_xor01_resources[0].start = irq_1;
710  orion_xor01_resources[0].end = irq_1;
711 
712  platform_device_register(&orion_xor0_shared);
713 
714  orion_xor_init_channels(&orion_xor00_data, &orion_xor00_channel,
715  &orion_xor01_data, &orion_xor01_channel);
716 }
717 
718 /*****************************************************************************
719  * XOR1
720  ****************************************************************************/
721 static struct resource orion_xor1_shared_resources[] = {
722  {
723  .name = "xor 1 low",
724  .flags = IORESOURCE_MEM,
725  }, {
726  .name = "xor 1 high",
727  .flags = IORESOURCE_MEM,
728  },
729 };
730 
731 static struct platform_device orion_xor1_shared = {
732  .name = MV_XOR_SHARED_NAME,
733  .id = 1,
734  .num_resources = ARRAY_SIZE(orion_xor1_shared_resources),
735  .resource = orion_xor1_shared_resources,
736 };
737 
738 static struct resource orion_xor10_resources[] = {
739  [0] = {
740  .flags = IORESOURCE_IRQ,
741  },
742 };
743 
744 static struct mv_xor_platform_data orion_xor10_data = {
745  .shared = &orion_xor1_shared,
746  .hw_id = 0,
747  .pool_size = PAGE_SIZE,
748 };
749 
750 static struct platform_device orion_xor10_channel = {
751  .name = MV_XOR_NAME,
752  .id = 2,
753  .num_resources = ARRAY_SIZE(orion_xor10_resources),
754  .resource = orion_xor10_resources,
755  .dev = {
756  .dma_mask = &orion_xor_dmamask,
757  .coherent_dma_mask = DMA_BIT_MASK(64),
758  .platform_data = &orion_xor10_data,
759  },
760 };
761 
762 static struct resource orion_xor11_resources[] = {
763  [0] = {
764  .flags = IORESOURCE_IRQ,
765  },
766 };
767 
768 static struct mv_xor_platform_data orion_xor11_data = {
769  .shared = &orion_xor1_shared,
770  .hw_id = 1,
771  .pool_size = PAGE_SIZE,
772 };
773 
774 static struct platform_device orion_xor11_channel = {
775  .name = MV_XOR_NAME,
776  .id = 3,
777  .num_resources = ARRAY_SIZE(orion_xor11_resources),
778  .resource = orion_xor11_resources,
779  .dev = {
780  .dma_mask = &orion_xor_dmamask,
781  .coherent_dma_mask = DMA_BIT_MASK(64),
782  .platform_data = &orion_xor11_data,
783  },
784 };
785 
786 void __init orion_xor1_init(unsigned long mapbase_low,
787  unsigned long mapbase_high,
788  unsigned long irq_0,
789  unsigned long irq_1)
790 {
791  orion_xor1_shared_resources[0].start = mapbase_low;
792  orion_xor1_shared_resources[0].end = mapbase_low + 0xff;
793  orion_xor1_shared_resources[1].start = mapbase_high;
794  orion_xor1_shared_resources[1].end = mapbase_high + 0xff;
795 
796  orion_xor10_resources[0].start = irq_0;
797  orion_xor10_resources[0].end = irq_0;
798  orion_xor11_resources[0].start = irq_1;
799  orion_xor11_resources[0].end = irq_1;
800 
801  platform_device_register(&orion_xor1_shared);
802 
803  orion_xor_init_channels(&orion_xor10_data, &orion_xor10_channel,
804  &orion_xor11_data, &orion_xor11_channel);
805 }
806 
807 /*****************************************************************************
808  * EHCI
809  ****************************************************************************/
810 static struct orion_ehci_data orion_ehci_data;
811 static u64 ehci_dmamask = DMA_BIT_MASK(32);
812 
813 
814 /*****************************************************************************
815  * EHCI0
816  ****************************************************************************/
817 static struct resource orion_ehci_resources[2];
818 
819 static struct platform_device orion_ehci = {
820  .name = "orion-ehci",
821  .id = 0,
822  .dev = {
823  .dma_mask = &ehci_dmamask,
824  .coherent_dma_mask = DMA_BIT_MASK(32),
825  .platform_data = &orion_ehci_data,
826  },
827 };
828 
829 void __init orion_ehci_init(unsigned long mapbase,
830  unsigned long irq,
831  enum orion_ehci_phy_ver phy_version)
832 {
833  orion_ehci_data.phy_version = phy_version;
834  fill_resources(&orion_ehci, orion_ehci_resources, mapbase, SZ_4K - 1,
835  irq);
836 
837  platform_device_register(&orion_ehci);
838 }
839 
840 /*****************************************************************************
841  * EHCI1
842  ****************************************************************************/
843 static struct resource orion_ehci_1_resources[2];
844 
845 static struct platform_device orion_ehci_1 = {
846  .name = "orion-ehci",
847  .id = 1,
848  .dev = {
849  .dma_mask = &ehci_dmamask,
850  .coherent_dma_mask = DMA_BIT_MASK(32),
851  .platform_data = &orion_ehci_data,
852  },
853 };
854 
855 void __init orion_ehci_1_init(unsigned long mapbase,
856  unsigned long irq)
857 {
858  fill_resources(&orion_ehci_1, orion_ehci_1_resources,
859  mapbase, SZ_4K - 1, irq);
860 
861  platform_device_register(&orion_ehci_1);
862 }
863 
864 /*****************************************************************************
865  * EHCI2
866  ****************************************************************************/
867 static struct resource orion_ehci_2_resources[2];
868 
869 static struct platform_device orion_ehci_2 = {
870  .name = "orion-ehci",
871  .id = 2,
872  .dev = {
873  .dma_mask = &ehci_dmamask,
874  .coherent_dma_mask = DMA_BIT_MASK(32),
875  .platform_data = &orion_ehci_data,
876  },
877 };
878 
879 void __init orion_ehci_2_init(unsigned long mapbase,
880  unsigned long irq)
881 {
882  fill_resources(&orion_ehci_2, orion_ehci_2_resources,
883  mapbase, SZ_4K - 1, irq);
884 
885  platform_device_register(&orion_ehci_2);
886 }
887 
888 /*****************************************************************************
889  * SATA
890  ****************************************************************************/
891 static struct resource orion_sata_resources[2] = {
892  {
893  .name = "sata base",
894  }, {
895  .name = "sata irq",
896  },
897 };
898 
899 static struct platform_device orion_sata = {
900  .name = "sata_mv",
901  .id = 0,
902  .dev = {
903  .coherent_dma_mask = DMA_BIT_MASK(32),
904  },
905 };
906 
908  unsigned long mapbase,
909  unsigned long irq)
910 {
911  orion_sata.dev.platform_data = sata_data;
912  fill_resources(&orion_sata, orion_sata_resources,
913  mapbase, 0x5000 - 1, irq);
914 
915  platform_device_register(&orion_sata);
916 }
917 
918 /*****************************************************************************
919  * Cryptographic Engines and Security Accelerator (CESA)
920  ****************************************************************************/
921 static struct resource orion_crypto_resources[] = {
922  {
923  .name = "regs",
924  }, {
925  .name = "crypto interrupt",
926  }, {
927  .name = "sram",
928  .flags = IORESOURCE_MEM,
929  },
930 };
931 
932 static struct platform_device orion_crypto = {
933  .name = "mv_crypto",
934  .id = -1,
935 };
936 
937 void __init orion_crypto_init(unsigned long mapbase,
938  unsigned long srambase,
939  unsigned long sram_size,
940  unsigned long irq)
941 {
942  fill_resources(&orion_crypto, orion_crypto_resources,
943  mapbase, 0xffff, irq);
944  orion_crypto.num_resources = 3;
945  orion_crypto_resources[2].start = srambase;
946  orion_crypto_resources[2].end = srambase + sram_size - 1;
947 
948  platform_device_register(&orion_crypto);
949 }