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
  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 int tx_csum_limit)
 358 {
 359         fill_resources(&orion_ge01_shared, orion_ge01_shared_resources,
 360                        mapbase + 0x2000, SZ_16K - 1, NO_IRQ);
 361         orion_ge01_shared_data.tx_csum_limit = tx_csum_limit;
 362         ge_complete(&orion_ge01_shared_data,
 363                     orion_ge01_resources, irq, &orion_ge01_shared,
 364                     NULL,
 365                     eth_data, &orion_ge01);
 366 }
 367
 368 /*****************************************************************************
 369  * GE10
 370  ****************************************************************************/
 371 static struct mv643xx_eth_shared_platform_data orion_ge10_shared_data;
 372
 373 static struct resource orion_ge10_shared_resources[] = {
 374         {
 375                 .name   = "ge10 base",
 376         }
 377 };
 378
 379 static struct platform_device orion_ge10_shared = {
 380         .name           = MV643XX_ETH_SHARED_NAME,
 381         .id             = 2,
 382         .dev            = {
 383                 .platform_data  = &orion_ge10_shared_data,
 384         },
 385 };
 386
 387 static struct resource orion_ge10_resources[] = {
 388         {
 389                 .name   = "ge10 irq",
 390                 .flags  = IORESOURCE_IRQ,
 391         },
 392 };
 393
 394 static struct platform_device orion_ge10 = {
 395         .name           = MV643XX_ETH_NAME,
 396         .id             = 2,
 397         .num_resources  = 1,
 398         .resource       = orion_ge10_resources,
 399         .dev            = {
 400                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 401         },
 402 };
 403
 404 void __init orion_ge10_init(struct mv643xx_eth_platform_data *eth_data,
 405                             unsigned long mapbase,
 406                             unsigned long irq)
 407 {
 408         fill_resources(&orion_ge10_shared, orion_ge10_shared_resources,
 409                        mapbase + 0x2000, SZ_16K - 1, NO_IRQ);
 410         ge_complete(&orion_ge10_shared_data,
 411                     orion_ge10_resources, irq, &orion_ge10_shared,
 412                     NULL,
 413                     eth_data, &orion_ge10);
 414 }
 415
 416 /*****************************************************************************
 417  * GE11
 418  ****************************************************************************/
 419 static struct mv643xx_eth_shared_platform_data orion_ge11_shared_data;
 420
 421 static struct resource orion_ge11_shared_resources[] = {
 422         {
 423                 .name   = "ge11 base",
 424         },
 425 };
 426
 427 static struct platform_device orion_ge11_shared = {
 428         .name           = MV643XX_ETH_SHARED_NAME,
 429         .id             = 3,
 430         .dev            = {
 431                 .platform_data  = &orion_ge11_shared_data,
 432         },
 433 };
 434
 435 static struct resource orion_ge11_resources[] = {
 436         {
 437                 .name   = "ge11 irq",
 438                 .flags  = IORESOURCE_IRQ,
 439         },
 440 };
 441
 442 static struct platform_device orion_ge11 = {
 443         .name           = MV643XX_ETH_NAME,
 444         .id             = 3,
 445         .num_resources  = 1,
 446         .resource       = orion_ge11_resources,
 447         .dev            = {
 448                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 449         },
 450 };
 451
 452 void __init orion_ge11_init(struct mv643xx_eth_platform_data *eth_data,
 453                             unsigned long mapbase,
 454                             unsigned long irq)
 455 {
 456         fill_resources(&orion_ge11_shared, orion_ge11_shared_resources,
 457                        mapbase + 0x2000, SZ_16K - 1, NO_IRQ);
 458         ge_complete(&orion_ge11_shared_data,
 459                     orion_ge11_resources, irq, &orion_ge11_shared,
 460                     NULL,
 461                     eth_data, &orion_ge11);
 462 }
 463
 464 /*****************************************************************************
 465  * Ethernet switch
 466  ****************************************************************************/
 467 static struct resource orion_switch_resources[] = {
 468         {
 469                 .start  = 0,
 470                 .end    = 0,
 471                 .flags  = IORESOURCE_IRQ,
 472         },
 473 };
 474
 475 static struct platform_device orion_switch_device = {
 476         .name           = "dsa",
 477         .id             = 0,
 478         .num_resources  = 0,
 479         .resource       = orion_switch_resources,
 480 };
 481
 482 void __init orion_ge00_switch_init(struct dsa_platform_data *d, int irq)
 483 {
 484         int i;
 485
 486         if (irq != NO_IRQ) {
 487                 orion_switch_resources[0].start = irq;
 488                 orion_switch_resources[0].end = irq;
 489                 orion_switch_device.num_resources = 1;
 490         }
 491
 492         d->netdev = &orion_ge00.dev;
 493         for (i = 0; i < d->nr_chips; i++)
 494                 d->chip[i].host_dev = &orion_ge_mvmdio.dev;
 495         orion_switch_device.dev.platform_data = d;
 496
 497         platform_device_register(&orion_switch_device);
 498 }
 499
 500 /*****************************************************************************
 501  * I2C
 502  ****************************************************************************/
 503 static struct mv64xxx_i2c_pdata orion_i2c_pdata = {
 504         .freq_n         = 3,
 505         .timeout        = 1000, /* Default timeout of 1 second */
 506 };
 507
 508 static struct resource orion_i2c_resources[2];
 509
 510 static struct platform_device orion_i2c = {
 511         .name           = MV64XXX_I2C_CTLR_NAME,
 512         .id             = 0,
 513         .dev            = {
 514                 .platform_data  = &orion_i2c_pdata,
 515         },
 516 };
 517
 518 static struct mv64xxx_i2c_pdata orion_i2c_1_pdata = {
 519         .freq_n         = 3,
 520         .timeout        = 1000, /* Default timeout of 1 second */
 521 };
 522
 523 static struct resource orion_i2c_1_resources[2];
 524
 525 static struct platform_device orion_i2c_1 = {
 526         .name           = MV64XXX_I2C_CTLR_NAME,
 527         .id             = 1,
 528         .dev            = {
 529                 .platform_data  = &orion_i2c_1_pdata,
 530         },
 531 };
 532
 533 void __init orion_i2c_init(unsigned long mapbase,
 534                            unsigned long irq,
 535                            unsigned long freq_m)
 536 {
 537         orion_i2c_pdata.freq_m = freq_m;
 538         fill_resources(&orion_i2c, orion_i2c_resources, mapbase,
 539                        SZ_32 - 1, irq);
 540         platform_device_register(&orion_i2c);
 541 }
 542
 543 void __init orion_i2c_1_init(unsigned long mapbase,
 544                              unsigned long irq,
 545                              unsigned long freq_m)
 546 {
 547         orion_i2c_1_pdata.freq_m = freq_m;
 548         fill_resources(&orion_i2c_1, orion_i2c_1_resources, mapbase,
 549                        SZ_32 - 1, irq);
 550         platform_device_register(&orion_i2c_1);
 551 }
 552
 553 /*****************************************************************************
 554  * SPI
 555  ****************************************************************************/
 556 static struct resource orion_spi_resources;
 557
 558 static struct platform_device orion_spi = {
 559         .name           = "orion_spi",
 560         .id             = 0,
 561 };
 562
 563 static struct resource orion_spi_1_resources;
 564
 565 static struct platform_device orion_spi_1 = {
 566         .name           = "orion_spi",
 567         .id             = 1,
 568 };
 569
 570 /* Note: The SPI silicon core does have interrupts. However the
 571  * current Linux software driver does not use interrupts. */
 572
 573 void __init orion_spi_init(unsigned long mapbase)
 574 {
 575         fill_resources(&orion_spi, &orion_spi_resources,
 576                        mapbase, SZ_512 - 1, NO_IRQ);
 577         platform_device_register(&orion_spi);
 578 }
 579
 580 void __init orion_spi_1_init(unsigned long mapbase)
 581 {
 582         fill_resources(&orion_spi_1, &orion_spi_1_resources,
 583                        mapbase, SZ_512 - 1, NO_IRQ);
 584         platform_device_register(&orion_spi_1);
 585 }
 586
 587 /*****************************************************************************
 588  * XOR
 589  ****************************************************************************/
 590 static u64 orion_xor_dmamask = DMA_BIT_MASK(32);
 591
 592 /*****************************************************************************
 593  * XOR0
 594  ****************************************************************************/
 595 static struct resource orion_xor0_shared_resources[] = {
 596         {
 597                 .name   = "xor 0 low",
 598                 .flags  = IORESOURCE_MEM,
 599         }, {
 600                 .name   = "xor 0 high",
 601                 .flags  = IORESOURCE_MEM,
 602         }, {
 603                 .name   = "irq channel 0",
 604                 .flags  = IORESOURCE_IRQ,
 605         }, {
 606                 .name   = "irq channel 1",
 607                 .flags  = IORESOURCE_IRQ,
 608         },
 609 };
 610
 611 static struct mv_xor_channel_data orion_xor0_channels_data[2];
 612
 613 static struct mv_xor_platform_data orion_xor0_pdata = {
 614         .channels = orion_xor0_channels_data,
 615 };
 616
 617 static struct platform_device orion_xor0_shared = {
 618         .name           = MV_XOR_NAME,
 619         .id             = 0,
 620         .num_resources  = ARRAY_SIZE(orion_xor0_shared_resources),
 621         .resource       = orion_xor0_shared_resources,
 622         .dev            = {
 623                 .dma_mask               = &orion_xor_dmamask,
 624                 .coherent_dma_mask      = DMA_BIT_MASK(64),
 625                 .platform_data          = &orion_xor0_pdata,
 626         },
 627 };
 628
 629 void __init orion_xor0_init(unsigned long mapbase_low,
 630                             unsigned long mapbase_high,
 631                             unsigned long irq_0,
 632                             unsigned long irq_1)
 633 {
 634         orion_xor0_shared_resources[0].start = mapbase_low;
 635         orion_xor0_shared_resources[0].end = mapbase_low + 0xff;
 636         orion_xor0_shared_resources[1].start = mapbase_high;
 637         orion_xor0_shared_resources[1].end = mapbase_high + 0xff;
 638
 639         orion_xor0_shared_resources[2].start = irq_0;
 640         orion_xor0_shared_resources[2].end = irq_0;
 641         orion_xor0_shared_resources[3].start = irq_1;
 642         orion_xor0_shared_resources[3].end = irq_1;
 643
 644         dma_cap_set(DMA_MEMCPY, orion_xor0_channels_data[0].cap_mask);
 645         dma_cap_set(DMA_XOR, orion_xor0_channels_data[0].cap_mask);
 646
 647         dma_cap_set(DMA_MEMCPY, orion_xor0_channels_data[1].cap_mask);
 648         dma_cap_set(DMA_XOR, orion_xor0_channels_data[1].cap_mask);
 649
 650         platform_device_register(&orion_xor0_shared);
 651 }
 652
 653 /*****************************************************************************
 654  * XOR1
 655  ****************************************************************************/
 656 static struct resource orion_xor1_shared_resources[] = {
 657         {
 658                 .name   = "xor 1 low",
 659                 .flags  = IORESOURCE_MEM,
 660         }, {
 661                 .name   = "xor 1 high",
 662                 .flags  = IORESOURCE_MEM,
 663         }, {
 664                 .name   = "irq channel 0",
 665                 .flags  = IORESOURCE_IRQ,
 666         }, {
 667                 .name   = "irq channel 1",
 668                 .flags  = IORESOURCE_IRQ,
 669         },
 670 };
 671
 672 static struct mv_xor_channel_data orion_xor1_channels_data[2];
 673
 674 static struct mv_xor_platform_data orion_xor1_pdata = {
 675         .channels = orion_xor1_channels_data,
 676 };
 677
 678 static struct platform_device orion_xor1_shared = {
 679         .name           = MV_XOR_NAME,
 680         .id             = 1,
 681         .num_resources  = ARRAY_SIZE(orion_xor1_shared_resources),
 682         .resource       = orion_xor1_shared_resources,
 683         .dev            = {
 684                 .dma_mask               = &orion_xor_dmamask,
 685                 .coherent_dma_mask      = DMA_BIT_MASK(64),
 686                 .platform_data          = &orion_xor1_pdata,
 687         },
 688 };
 689
 690 void __init orion_xor1_init(unsigned long mapbase_low,
 691                             unsigned long mapbase_high,
 692                             unsigned long irq_0,
 693                             unsigned long irq_1)
 694 {
 695         orion_xor1_shared_resources[0].start = mapbase_low;
 696         orion_xor1_shared_resources[0].end = mapbase_low + 0xff;
 697         orion_xor1_shared_resources[1].start = mapbase_high;
 698         orion_xor1_shared_resources[1].end = mapbase_high + 0xff;
 699
 700         orion_xor1_shared_resources[2].start = irq_0;
 701         orion_xor1_shared_resources[2].end = irq_0;
 702         orion_xor1_shared_resources[3].start = irq_1;
 703         orion_xor1_shared_resources[3].end = irq_1;
 704
 705         dma_cap_set(DMA_MEMCPY, orion_xor1_channels_data[0].cap_mask);
 706         dma_cap_set(DMA_XOR, orion_xor1_channels_data[0].cap_mask);
 707
 708         dma_cap_set(DMA_MEMCPY, orion_xor1_channels_data[1].cap_mask);
 709         dma_cap_set(DMA_XOR, orion_xor1_channels_data[1].cap_mask);
 710
 711         platform_device_register(&orion_xor1_shared);
 712 }
 713
 714 /*****************************************************************************
 715  * EHCI
 716  ****************************************************************************/
 717 static struct orion_ehci_data orion_ehci_data;
 718 static u64 ehci_dmamask = DMA_BIT_MASK(32);
 719
 720
 721 /*****************************************************************************
 722  * EHCI0
 723  ****************************************************************************/
 724 static struct resource orion_ehci_resources[2];
 725
 726 static struct platform_device orion_ehci = {
 727         .name           = "orion-ehci",
 728         .id             = 0,
 729         .dev            = {
 730                 .dma_mask               = &ehci_dmamask,
 731                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 732                 .platform_data          = &orion_ehci_data,
 733         },
 734 };
 735
 736 void __init orion_ehci_init(unsigned long mapbase,
 737                             unsigned long irq,
 738                             enum orion_ehci_phy_ver phy_version)
 739 {
 740         orion_ehci_data.phy_version = phy_version;
 741         fill_resources(&orion_ehci, orion_ehci_resources, mapbase, SZ_4K - 1,
 742                        irq);
 743
 744         platform_device_register(&orion_ehci);
 745 }
 746
 747 /*****************************************************************************
 748  * EHCI1
 749  ****************************************************************************/
 750 static struct resource orion_ehci_1_resources[2];
 751
 752 static struct platform_device orion_ehci_1 = {
 753         .name           = "orion-ehci",
 754         .id             = 1,
 755         .dev            = {
 756                 .dma_mask               = &ehci_dmamask,
 757                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 758                 .platform_data          = &orion_ehci_data,
 759         },
 760 };
 761
 762 void __init orion_ehci_1_init(unsigned long mapbase,
 763                               unsigned long irq)
 764 {
 765         fill_resources(&orion_ehci_1, orion_ehci_1_resources,
 766                        mapbase, SZ_4K - 1, irq);
 767
 768         platform_device_register(&orion_ehci_1);
 769 }
 770
 771 /*****************************************************************************
 772  * EHCI2
 773  ****************************************************************************/
 774 static struct resource orion_ehci_2_resources[2];
 775
 776 static struct platform_device orion_ehci_2 = {
 777         .name           = "orion-ehci",
 778         .id             = 2,
 779         .dev            = {
 780                 .dma_mask               = &ehci_dmamask,
 781                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 782                 .platform_data          = &orion_ehci_data,
 783         },
 784 };
 785
 786 void __init orion_ehci_2_init(unsigned long mapbase,
 787                               unsigned long irq)
 788 {
 789         fill_resources(&orion_ehci_2, orion_ehci_2_resources,
 790                        mapbase, SZ_4K - 1, irq);
 791
 792         platform_device_register(&orion_ehci_2);
 793 }
 794
 795 /*****************************************************************************
 796  * SATA
 797  ****************************************************************************/
 798 static struct resource orion_sata_resources[2] = {
 799         {
 800                 .name   = "sata base",
 801         }, {
 802                 .name   = "sata irq",
 803         },
 804 };
 805
 806 static struct platform_device orion_sata = {
 807         .name           = "sata_mv",
 808         .id             = 0,
 809         .dev            = {
 810                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 811         },
 812 };
 813
 814 void __init orion_sata_init(struct mv_sata_platform_data *sata_data,
 815                             unsigned long mapbase,
 816                             unsigned long irq)
 817 {
 818         orion_sata.dev.platform_data = sata_data;
 819         fill_resources(&orion_sata, orion_sata_resources,
 820                        mapbase, 0x5000 - 1, irq);
 821
 822         platform_device_register(&orion_sata);
 823 }
 824
 825 /*****************************************************************************
 826  * Cryptographic Engines and Security Accelerator (CESA)
 827  ****************************************************************************/
 828 static struct resource orion_crypto_resources[] = {
 829         {
 830                 .name   = "regs",
 831         }, {
 832                 .name   = "crypto interrupt",
 833         }, {
 834                 .name   = "sram",
 835                 .flags  = IORESOURCE_MEM,
 836         },
 837 };
 838
 839 static struct platform_device orion_crypto = {
 840         .name           = "mv_crypto",
 841         .id             = -1,
 842 };
 843
 844 void __init orion_crypto_init(unsigned long mapbase,
 845                               unsigned long srambase,
 846                               unsigned long sram_size,
 847                               unsigned long irq)
 848 {
 849         fill_resources(&orion_crypto, orion_crypto_resources,
 850                        mapbase, 0xffff, irq);
 851         orion_crypto.num_resources = 3;
 852         orion_crypto_resources[2].start = srambase;
 853         orion_crypto_resources[2].end = srambase + sram_size - 1;
 854
 855         platform_device_register(&orion_crypto);
 856 }