arch/arm/plat-orion/common.c

   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 }