ARM: orion: Consolidate the creation of the uart platform data.
[linux-3.10.git] / arch / arm / mach-dove / common.c
1 /*
2  * arch/arm/mach-dove/common.c
3  *
4  * Core functions for Marvell Dove 88AP510 System On Chip
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/delay.h>
13 #include <linux/init.h>
14 #include <linux/platform_device.h>
15 #include <linux/pci.h>
16 #include <linux/serial_8250.h>
17 #include <linux/clk.h>
18 #include <linux/mbus.h>
19 #include <linux/mv643xx_eth.h>
20 #include <linux/mv643xx_i2c.h>
21 #include <linux/ata_platform.h>
22 #include <linux/serial_8250.h>
23 #include <linux/spi/orion_spi.h>
24 #include <linux/gpio.h>
25 #include <asm/page.h>
26 #include <asm/setup.h>
27 #include <asm/timex.h>
28 #include <asm/hardware/cache-tauros2.h>
29 #include <asm/mach/map.h>
30 #include <asm/mach/time.h>
31 #include <asm/mach/pci.h>
32 #include <mach/dove.h>
33 #include <mach/bridge-regs.h>
34 #include <asm/mach/arch.h>
35 #include <linux/irq.h>
36 #include <plat/mv_xor.h>
37 #include <plat/ehci-orion.h>
38 #include <plat/time.h>
39 #include <plat/common.h>
40 #include "common.h"
41
42 static int get_tclk(void);
43
44 /*****************************************************************************
45  * I/O Address Mapping
46  ****************************************************************************/
47 static struct map_desc dove_io_desc[] __initdata = {
48         {
49                 .virtual        = DOVE_SB_REGS_VIRT_BASE,
50                 .pfn            = __phys_to_pfn(DOVE_SB_REGS_PHYS_BASE),
51                 .length         = DOVE_SB_REGS_SIZE,
52                 .type           = MT_DEVICE,
53         }, {
54                 .virtual        = DOVE_NB_REGS_VIRT_BASE,
55                 .pfn            = __phys_to_pfn(DOVE_NB_REGS_PHYS_BASE),
56                 .length         = DOVE_NB_REGS_SIZE,
57                 .type           = MT_DEVICE,
58         }, {
59                 .virtual        = DOVE_PCIE0_IO_VIRT_BASE,
60                 .pfn            = __phys_to_pfn(DOVE_PCIE0_IO_PHYS_BASE),
61                 .length         = DOVE_PCIE0_IO_SIZE,
62                 .type           = MT_DEVICE,
63         }, {
64                 .virtual        = DOVE_PCIE1_IO_VIRT_BASE,
65                 .pfn            = __phys_to_pfn(DOVE_PCIE1_IO_PHYS_BASE),
66                 .length         = DOVE_PCIE1_IO_SIZE,
67                 .type           = MT_DEVICE,
68         },
69 };
70
71 void __init dove_map_io(void)
72 {
73         iotable_init(dove_io_desc, ARRAY_SIZE(dove_io_desc));
74 }
75
76 /*****************************************************************************
77  * EHCI
78  ****************************************************************************/
79 static struct orion_ehci_data dove_ehci_data = {
80         .dram           = &dove_mbus_dram_info,
81         .phy_version    = EHCI_PHY_NA,
82 };
83
84 static u64 ehci_dmamask = DMA_BIT_MASK(32);
85
86 /*****************************************************************************
87  * EHCI0
88  ****************************************************************************/
89 static struct resource dove_ehci0_resources[] = {
90         {
91                 .start  = DOVE_USB0_PHYS_BASE,
92                 .end    = DOVE_USB0_PHYS_BASE + SZ_4K - 1,
93                 .flags  = IORESOURCE_MEM,
94         }, {
95                 .start  = IRQ_DOVE_USB0,
96                 .end    = IRQ_DOVE_USB0,
97                 .flags  = IORESOURCE_IRQ,
98         },
99 };
100
101 static struct platform_device dove_ehci0 = {
102         .name           = "orion-ehci",
103         .id             = 0,
104         .dev            = {
105                 .dma_mask               = &ehci_dmamask,
106                 .coherent_dma_mask      = DMA_BIT_MASK(32),
107                 .platform_data          = &dove_ehci_data,
108         },
109         .resource       = dove_ehci0_resources,
110         .num_resources  = ARRAY_SIZE(dove_ehci0_resources),
111 };
112
113 void __init dove_ehci0_init(void)
114 {
115         platform_device_register(&dove_ehci0);
116 }
117
118 /*****************************************************************************
119  * EHCI1
120  ****************************************************************************/
121 static struct resource dove_ehci1_resources[] = {
122         {
123                 .start  = DOVE_USB1_PHYS_BASE,
124                 .end    = DOVE_USB1_PHYS_BASE + SZ_4K - 1,
125                 .flags  = IORESOURCE_MEM,
126         }, {
127                 .start  = IRQ_DOVE_USB1,
128                 .end    = IRQ_DOVE_USB1,
129                 .flags  = IORESOURCE_IRQ,
130         },
131 };
132
133 static struct platform_device dove_ehci1 = {
134         .name           = "orion-ehci",
135         .id             = 1,
136         .dev            = {
137                 .dma_mask               = &ehci_dmamask,
138                 .coherent_dma_mask      = DMA_BIT_MASK(32),
139                 .platform_data          = &dove_ehci_data,
140         },
141         .resource       = dove_ehci1_resources,
142         .num_resources  = ARRAY_SIZE(dove_ehci1_resources),
143 };
144
145 void __init dove_ehci1_init(void)
146 {
147         platform_device_register(&dove_ehci1);
148 }
149
150 /*****************************************************************************
151  * GE00
152  ****************************************************************************/
153 struct mv643xx_eth_shared_platform_data dove_ge00_shared_data = {
154         .t_clk          = 0,
155         .dram           = &dove_mbus_dram_info,
156 };
157
158 static struct resource dove_ge00_shared_resources[] = {
159         {
160                 .name   = "ge00 base",
161                 .start  = DOVE_GE00_PHYS_BASE + 0x2000,
162                 .end    = DOVE_GE00_PHYS_BASE + SZ_16K - 1,
163                 .flags  = IORESOURCE_MEM,
164         },
165 };
166
167 static struct platform_device dove_ge00_shared = {
168         .name           = MV643XX_ETH_SHARED_NAME,
169         .id             = 0,
170         .dev            = {
171                 .platform_data  = &dove_ge00_shared_data,
172         },
173         .num_resources  = 1,
174         .resource       = dove_ge00_shared_resources,
175 };
176
177 static struct resource dove_ge00_resources[] = {
178         {
179                 .name   = "ge00 irq",
180                 .start  = IRQ_DOVE_GE00_SUM,
181                 .end    = IRQ_DOVE_GE00_SUM,
182                 .flags  = IORESOURCE_IRQ,
183         },
184 };
185
186 static struct platform_device dove_ge00 = {
187         .name           = MV643XX_ETH_NAME,
188         .id             = 0,
189         .num_resources  = 1,
190         .resource       = dove_ge00_resources,
191         .dev            = {
192                 .coherent_dma_mask      = 0xffffffff,
193         },
194 };
195
196 void __init dove_ge00_init(struct mv643xx_eth_platform_data *eth_data)
197 {
198         eth_data->shared = &dove_ge00_shared;
199         dove_ge00.dev.platform_data = eth_data;
200
201         platform_device_register(&dove_ge00_shared);
202         platform_device_register(&dove_ge00);
203 }
204
205 /*****************************************************************************
206  * SoC RTC
207  ****************************************************************************/
208 static struct resource dove_rtc_resource[] = {
209         {
210                 .start  = DOVE_RTC_PHYS_BASE,
211                 .end    = DOVE_RTC_PHYS_BASE + 32 - 1,
212                 .flags  = IORESOURCE_MEM,
213         }, {
214                 .start  = IRQ_DOVE_RTC,
215                 .flags  = IORESOURCE_IRQ,
216         }
217 };
218
219 void __init dove_rtc_init(void)
220 {
221         platform_device_register_simple("rtc-mv", -1, dove_rtc_resource, 2);
222 }
223
224 /*****************************************************************************
225  * SATA
226  ****************************************************************************/
227 static struct resource dove_sata_resources[] = {
228         {
229                 .name   = "sata base",
230                 .start  = DOVE_SATA_PHYS_BASE,
231                 .end    = DOVE_SATA_PHYS_BASE + 0x5000 - 1,
232                 .flags  = IORESOURCE_MEM,
233         }, {
234                 .name   = "sata irq",
235                 .start  = IRQ_DOVE_SATA,
236                 .end    = IRQ_DOVE_SATA,
237                 .flags  = IORESOURCE_IRQ,
238         },
239 };
240
241 static struct platform_device dove_sata = {
242         .name           = "sata_mv",
243         .id             = 0,
244         .dev            = {
245                 .coherent_dma_mask      = DMA_BIT_MASK(32),
246         },
247         .num_resources  = ARRAY_SIZE(dove_sata_resources),
248         .resource       = dove_sata_resources,
249 };
250
251 void __init dove_sata_init(struct mv_sata_platform_data *sata_data)
252 {
253         sata_data->dram = &dove_mbus_dram_info;
254         dove_sata.dev.platform_data = sata_data;
255         platform_device_register(&dove_sata);
256 }
257
258 /*****************************************************************************
259  * UART0
260  ****************************************************************************/
261 void __init dove_uart0_init(void)
262 {
263         orion_uart0_init(DOVE_UART0_VIRT_BASE, DOVE_UART0_PHYS_BASE,
264                          IRQ_DOVE_UART_0, get_tclk());
265 }
266
267 /*****************************************************************************
268  * UART1
269  ****************************************************************************/
270 void __init dove_uart1_init(void)
271 {
272         orion_uart1_init(DOVE_UART1_VIRT_BASE, DOVE_UART1_PHYS_BASE,
273                          IRQ_DOVE_UART_1, get_tclk());
274 }
275
276 /*****************************************************************************
277  * UART2
278  ****************************************************************************/
279 void __init dove_uart2_init(void)
280 {
281         orion_uart2_init(DOVE_UART2_VIRT_BASE, DOVE_UART2_PHYS_BASE,
282                          IRQ_DOVE_UART_2, get_tclk());
283 }
284
285 /*****************************************************************************
286  * UART3
287  ****************************************************************************/
288 void __init dove_uart3_init(void)
289 {
290         orion_uart3_init(DOVE_UART3_VIRT_BASE, DOVE_UART3_PHYS_BASE,
291                          IRQ_DOVE_UART_3, get_tclk());
292 }
293
294 /*****************************************************************************
295  * SPI0
296  ****************************************************************************/
297 static struct orion_spi_info dove_spi0_data = {
298         .tclk           = 0,
299 };
300
301 static struct resource dove_spi0_resources[] = {
302         {
303                 .start  = DOVE_SPI0_PHYS_BASE,
304                 .end    = DOVE_SPI0_PHYS_BASE + SZ_512 - 1,
305                 .flags  = IORESOURCE_MEM,
306         }, {
307                 .start  = IRQ_DOVE_SPI0,
308                 .end    = IRQ_DOVE_SPI0,
309                 .flags  = IORESOURCE_IRQ,
310         },
311 };
312
313 static struct platform_device dove_spi0 = {
314         .name           = "orion_spi",
315         .id             = 0,
316         .resource       = dove_spi0_resources,
317         .dev            = {
318                 .platform_data  = &dove_spi0_data,
319         },
320         .num_resources  = ARRAY_SIZE(dove_spi0_resources),
321 };
322
323 void __init dove_spi0_init(void)
324 {
325         platform_device_register(&dove_spi0);
326 }
327
328 /*****************************************************************************
329  * SPI1
330  ****************************************************************************/
331 static struct orion_spi_info dove_spi1_data = {
332         .tclk           = 0,
333 };
334
335 static struct resource dove_spi1_resources[] = {
336         {
337                 .start  = DOVE_SPI1_PHYS_BASE,
338                 .end    = DOVE_SPI1_PHYS_BASE + SZ_512 - 1,
339                 .flags  = IORESOURCE_MEM,
340         }, {
341                 .start  = IRQ_DOVE_SPI1,
342                 .end    = IRQ_DOVE_SPI1,
343                 .flags  = IORESOURCE_IRQ,
344         },
345 };
346
347 static struct platform_device dove_spi1 = {
348         .name           = "orion_spi",
349         .id             = 1,
350         .resource       = dove_spi1_resources,
351         .dev            = {
352                 .platform_data  = &dove_spi1_data,
353         },
354         .num_resources  = ARRAY_SIZE(dove_spi1_resources),
355 };
356
357 void __init dove_spi1_init(void)
358 {
359         platform_device_register(&dove_spi1);
360 }
361
362 /*****************************************************************************
363  * I2C
364  ****************************************************************************/
365 static struct mv64xxx_i2c_pdata dove_i2c_data = {
366         .freq_m         = 10, /* assumes 166 MHz TCLK gets 94.3kHz */
367         .freq_n         = 3,
368         .timeout        = 1000, /* Default timeout of 1 second */
369 };
370
371 static struct resource dove_i2c_resources[] = {
372         {
373                 .name   = "i2c base",
374                 .start  = DOVE_I2C_PHYS_BASE,
375                 .end    = DOVE_I2C_PHYS_BASE + 0x20 - 1,
376                 .flags  = IORESOURCE_MEM,
377         }, {
378                 .name   = "i2c irq",
379                 .start  = IRQ_DOVE_I2C,
380                 .end    = IRQ_DOVE_I2C,
381                 .flags  = IORESOURCE_IRQ,
382         },
383 };
384
385 static struct platform_device dove_i2c = {
386         .name           = MV64XXX_I2C_CTLR_NAME,
387         .id             = 0,
388         .num_resources  = ARRAY_SIZE(dove_i2c_resources),
389         .resource       = dove_i2c_resources,
390         .dev            = {
391                 .platform_data = &dove_i2c_data,
392         },
393 };
394
395 void __init dove_i2c_init(void)
396 {
397         platform_device_register(&dove_i2c);
398 }
399
400 /*****************************************************************************
401  * Time handling
402  ****************************************************************************/
403 void __init dove_init_early(void)
404 {
405         orion_time_set_base(TIMER_VIRT_BASE);
406 }
407
408 static int get_tclk(void)
409 {
410         /* use DOVE_RESET_SAMPLE_HI/LO to detect tclk */
411         return 166666667;
412 }
413
414 static void dove_timer_init(void)
415 {
416         orion_time_init(BRIDGE_VIRT_BASE, BRIDGE_INT_TIMER1_CLR,
417                         IRQ_DOVE_BRIDGE, get_tclk());
418 }
419
420 struct sys_timer dove_timer = {
421         .init = dove_timer_init,
422 };
423
424 /*****************************************************************************
425  * XOR
426  ****************************************************************************/
427 static struct mv_xor_platform_shared_data dove_xor_shared_data = {
428         .dram           = &dove_mbus_dram_info,
429 };
430
431 /*****************************************************************************
432  * XOR 0
433  ****************************************************************************/
434 static u64 dove_xor0_dmamask = DMA_BIT_MASK(32);
435
436 static struct resource dove_xor0_shared_resources[] = {
437         {
438                 .name   = "xor 0 low",
439                 .start  = DOVE_XOR0_PHYS_BASE,
440                 .end    = DOVE_XOR0_PHYS_BASE + 0xff,
441                 .flags  = IORESOURCE_MEM,
442         }, {
443                 .name   = "xor 0 high",
444                 .start  = DOVE_XOR0_HIGH_PHYS_BASE,
445                 .end    = DOVE_XOR0_HIGH_PHYS_BASE + 0xff,
446                 .flags  = IORESOURCE_MEM,
447         },
448 };
449
450 static struct platform_device dove_xor0_shared = {
451         .name           = MV_XOR_SHARED_NAME,
452         .id             = 0,
453         .dev            = {
454                 .platform_data = &dove_xor_shared_data,
455         },
456         .num_resources  = ARRAY_SIZE(dove_xor0_shared_resources),
457         .resource       = dove_xor0_shared_resources,
458 };
459
460 static struct resource dove_xor00_resources[] = {
461         [0] = {
462                 .start  = IRQ_DOVE_XOR_00,
463                 .end    = IRQ_DOVE_XOR_00,
464                 .flags  = IORESOURCE_IRQ,
465         },
466 };
467
468 static struct mv_xor_platform_data dove_xor00_data = {
469         .shared         = &dove_xor0_shared,
470         .hw_id          = 0,
471         .pool_size      = PAGE_SIZE,
472 };
473
474 static struct platform_device dove_xor00_channel = {
475         .name           = MV_XOR_NAME,
476         .id             = 0,
477         .num_resources  = ARRAY_SIZE(dove_xor00_resources),
478         .resource       = dove_xor00_resources,
479         .dev            = {
480                 .dma_mask               = &dove_xor0_dmamask,
481                 .coherent_dma_mask      = DMA_BIT_MASK(64),
482                 .platform_data          = &dove_xor00_data,
483         },
484 };
485
486 static struct resource dove_xor01_resources[] = {
487         [0] = {
488                 .start  = IRQ_DOVE_XOR_01,
489                 .end    = IRQ_DOVE_XOR_01,
490                 .flags  = IORESOURCE_IRQ,
491         },
492 };
493
494 static struct mv_xor_platform_data dove_xor01_data = {
495         .shared         = &dove_xor0_shared,
496         .hw_id          = 1,
497         .pool_size      = PAGE_SIZE,
498 };
499
500 static struct platform_device dove_xor01_channel = {
501         .name           = MV_XOR_NAME,
502         .id             = 1,
503         .num_resources  = ARRAY_SIZE(dove_xor01_resources),
504         .resource       = dove_xor01_resources,
505         .dev            = {
506                 .dma_mask               = &dove_xor0_dmamask,
507                 .coherent_dma_mask      = DMA_BIT_MASK(64),
508                 .platform_data          = &dove_xor01_data,
509         },
510 };
511
512 void __init dove_xor0_init(void)
513 {
514         platform_device_register(&dove_xor0_shared);
515
516         /*
517          * two engines can't do memset simultaneously, this limitation
518          * satisfied by removing memset support from one of the engines.
519          */
520         dma_cap_set(DMA_MEMCPY, dove_xor00_data.cap_mask);
521         dma_cap_set(DMA_XOR, dove_xor00_data.cap_mask);
522         platform_device_register(&dove_xor00_channel);
523
524         dma_cap_set(DMA_MEMCPY, dove_xor01_data.cap_mask);
525         dma_cap_set(DMA_MEMSET, dove_xor01_data.cap_mask);
526         dma_cap_set(DMA_XOR, dove_xor01_data.cap_mask);
527         platform_device_register(&dove_xor01_channel);
528 }
529
530 /*****************************************************************************
531  * XOR 1
532  ****************************************************************************/
533 static u64 dove_xor1_dmamask = DMA_BIT_MASK(32);
534
535 static struct resource dove_xor1_shared_resources[] = {
536         {
537                 .name   = "xor 0 low",
538                 .start  = DOVE_XOR1_PHYS_BASE,
539                 .end    = DOVE_XOR1_PHYS_BASE + 0xff,
540                 .flags  = IORESOURCE_MEM,
541         }, {
542                 .name   = "xor 0 high",
543                 .start  = DOVE_XOR1_HIGH_PHYS_BASE,
544                 .end    = DOVE_XOR1_HIGH_PHYS_BASE + 0xff,
545                 .flags  = IORESOURCE_MEM,
546         },
547 };
548
549 static struct platform_device dove_xor1_shared = {
550         .name           = MV_XOR_SHARED_NAME,
551         .id             = 1,
552         .dev            = {
553                 .platform_data = &dove_xor_shared_data,
554         },
555         .num_resources  = ARRAY_SIZE(dove_xor1_shared_resources),
556         .resource       = dove_xor1_shared_resources,
557 };
558
559 static struct resource dove_xor10_resources[] = {
560         [0] = {
561                 .start  = IRQ_DOVE_XOR_10,
562                 .end    = IRQ_DOVE_XOR_10,
563                 .flags  = IORESOURCE_IRQ,
564         },
565 };
566
567 static struct mv_xor_platform_data dove_xor10_data = {
568         .shared         = &dove_xor1_shared,
569         .hw_id          = 0,
570         .pool_size      = PAGE_SIZE,
571 };
572
573 static struct platform_device dove_xor10_channel = {
574         .name           = MV_XOR_NAME,
575         .id             = 2,
576         .num_resources  = ARRAY_SIZE(dove_xor10_resources),
577         .resource       = dove_xor10_resources,
578         .dev            = {
579                 .dma_mask               = &dove_xor1_dmamask,
580                 .coherent_dma_mask      = DMA_BIT_MASK(64),
581                 .platform_data          = &dove_xor10_data,
582         },
583 };
584
585 static struct resource dove_xor11_resources[] = {
586         [0] = {
587                 .start  = IRQ_DOVE_XOR_11,
588                 .end    = IRQ_DOVE_XOR_11,
589                 .flags  = IORESOURCE_IRQ,
590         },
591 };
592
593 static struct mv_xor_platform_data dove_xor11_data = {
594         .shared         = &dove_xor1_shared,
595         .hw_id          = 1,
596         .pool_size      = PAGE_SIZE,
597 };
598
599 static struct platform_device dove_xor11_channel = {
600         .name           = MV_XOR_NAME,
601         .id             = 3,
602         .num_resources  = ARRAY_SIZE(dove_xor11_resources),
603         .resource       = dove_xor11_resources,
604         .dev            = {
605                 .dma_mask               = &dove_xor1_dmamask,
606                 .coherent_dma_mask      = DMA_BIT_MASK(64),
607                 .platform_data          = &dove_xor11_data,
608         },
609 };
610
611 void __init dove_xor1_init(void)
612 {
613         platform_device_register(&dove_xor1_shared);
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, dove_xor10_data.cap_mask);
620         dma_cap_set(DMA_XOR, dove_xor10_data.cap_mask);
621         platform_device_register(&dove_xor10_channel);
622
623         dma_cap_set(DMA_MEMCPY, dove_xor11_data.cap_mask);
624         dma_cap_set(DMA_MEMSET, dove_xor11_data.cap_mask);
625         dma_cap_set(DMA_XOR, dove_xor11_data.cap_mask);
626         platform_device_register(&dove_xor11_channel);
627 }
628
629 /*****************************************************************************
630  * SDIO
631  ****************************************************************************/
632 static u64 sdio_dmamask = DMA_BIT_MASK(32);
633
634 static struct resource dove_sdio0_resources[] = {
635         {
636                 .start  = DOVE_SDIO0_PHYS_BASE,
637                 .end    = DOVE_SDIO0_PHYS_BASE + 0xff,
638                 .flags  = IORESOURCE_MEM,
639         }, {
640                 .start  = IRQ_DOVE_SDIO0,
641                 .end    = IRQ_DOVE_SDIO0,
642                 .flags  = IORESOURCE_IRQ,
643         },
644 };
645
646 static struct platform_device dove_sdio0 = {
647         .name           = "sdhci-dove",
648         .id             = 0,
649         .dev            = {
650                 .dma_mask               = &sdio_dmamask,
651                 .coherent_dma_mask      = DMA_BIT_MASK(32),
652         },
653         .resource       = dove_sdio0_resources,
654         .num_resources  = ARRAY_SIZE(dove_sdio0_resources),
655 };
656
657 void __init dove_sdio0_init(void)
658 {
659         platform_device_register(&dove_sdio0);
660 }
661
662 static struct resource dove_sdio1_resources[] = {
663         {
664                 .start  = DOVE_SDIO1_PHYS_BASE,
665                 .end    = DOVE_SDIO1_PHYS_BASE + 0xff,
666                 .flags  = IORESOURCE_MEM,
667         }, {
668                 .start  = IRQ_DOVE_SDIO1,
669                 .end    = IRQ_DOVE_SDIO1,
670                 .flags  = IORESOURCE_IRQ,
671         },
672 };
673
674 static struct platform_device dove_sdio1 = {
675         .name           = "sdhci-dove",
676         .id             = 1,
677         .dev            = {
678                 .dma_mask               = &sdio_dmamask,
679                 .coherent_dma_mask      = DMA_BIT_MASK(32),
680         },
681         .resource       = dove_sdio1_resources,
682         .num_resources  = ARRAY_SIZE(dove_sdio1_resources),
683 };
684
685 void __init dove_sdio1_init(void)
686 {
687         platform_device_register(&dove_sdio1);
688 }
689
690 void __init dove_init(void)
691 {
692         int tclk;
693
694         tclk = get_tclk();
695
696         printk(KERN_INFO "Dove 88AP510 SoC, ");
697         printk(KERN_INFO "TCLK = %dMHz\n", (tclk + 499999) / 1000000);
698
699 #ifdef CONFIG_CACHE_TAUROS2
700         tauros2_init();
701 #endif
702         dove_setup_cpu_mbus();
703
704         dove_ge00_shared_data.t_clk = tclk;
705         dove_spi0_data.tclk = tclk;
706         dove_spi1_data.tclk = tclk;
707
708         /* internal devices that every board has */
709         dove_rtc_init();
710         dove_xor0_init();
711         dove_xor1_init();
712 }