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 <mach/bridge-regs.h>
  25 #include <plat/common.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         struct clk_lookup *cl;
  32
  33         cl = clkdev_alloc(clk, con_id, dev_id);
  34         if (cl)
  35                 clkdev_add(cl);
  36 }
  37
  38 /* Create clkdev entries for all orion platforms except kirkwood.
  39    Kirkwood has gated clocks for some of its peripherals, so creates
  40    its own clkdev entries. For all the other orion devices, create
  41    clkdev entries to the tclk. */
  42 void __init orion_clkdev_init(struct clk *tclk)
  43 {
  44         orion_clkdev_add(NULL, "orion_spi.0", tclk);
  45         orion_clkdev_add(NULL, "orion_spi.1", tclk);
  46         orion_clkdev_add(NULL, MV643XX_ETH_NAME ".0", tclk);
  47         orion_clkdev_add(NULL, MV643XX_ETH_NAME ".1", tclk);
  48         orion_clkdev_add(NULL, MV643XX_ETH_NAME ".2", tclk);
  49         orion_clkdev_add(NULL, MV643XX_ETH_NAME ".3", tclk);
  50         orion_clkdev_add(NULL, "orion_wdt", tclk);
  51         orion_clkdev_add(NULL, MV64XXX_I2C_CTLR_NAME ".0", tclk);
  52 }
  53
  54 /* Fill in the resources structure and link it into the platform
  55    device structure. There is always a memory region, and nearly
  56    always an interrupt.*/
  57 static void fill_resources(struct platform_device *device,
  58                            struct resource *resources,
  59                            resource_size_t mapbase,
  60                            resource_size_t size,
  61                            unsigned int irq)
  62 {
  63         device->resource = resources;
  64         device->num_resources = 1;
  65         resources[0].flags = IORESOURCE_MEM;
  66         resources[0].start = mapbase;
  67         resources[0].end = mapbase + size;
  68
  69         if (irq != NO_IRQ) {
  70                 device->num_resources++;
  71                 resources[1].flags = IORESOURCE_IRQ;
  72                 resources[1].start = irq;
  73                 resources[1].end = irq;
  74         }
  75 }
  76
  77 /*****************************************************************************
  78  * UART
  79  ****************************************************************************/
  80 static unsigned long __init uart_get_clk_rate(struct clk *clk)
  81 {
  82         clk_prepare_enable(clk);
  83         return clk_get_rate(clk);
  84 }
  85
  86 static void __init uart_complete(
  87         struct platform_device *orion_uart,
  88         struct plat_serial8250_port *data,
  89         struct resource *resources,
  90         void __iomem *membase,
  91         resource_size_t mapbase,
  92         unsigned int irq,
  93         struct clk *clk)
  94 {
  95         data->mapbase = mapbase;
  96         data->membase = membase;
  97         data->irq = irq;
  98         data->uartclk = uart_get_clk_rate(clk);
  99         orion_uart->dev.platform_data = data;
 100
 101         fill_resources(orion_uart, resources, mapbase, 0xff, irq);
 102         platform_device_register(orion_uart);
 103 }
 104
 105 /*****************************************************************************
 106  * UART0
 107  ****************************************************************************/
 108 static struct plat_serial8250_port orion_uart0_data[] = {
 109         {
 110                 .flags          = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF,
 111                 .iotype         = UPIO_MEM,
 112                 .regshift       = 2,
 113         }, {
 114         },
 115 };
 116
 117 static struct resource orion_uart0_resources[2];
 118
 119 static struct platform_device orion_uart0 = {
 120         .name                   = "serial8250",
 121         .id                     = PLAT8250_DEV_PLATFORM,
 122 };
 123
 124 void __init orion_uart0_init(void __iomem *membase,
 125                              resource_size_t mapbase,
 126                              unsigned int irq,
 127                              struct clk *clk)
 128 {
 129         uart_complete(&orion_uart0, orion_uart0_data, orion_uart0_resources,
 130                       membase, mapbase, irq, clk);
 131 }
 132
 133 /*****************************************************************************
 134  * UART1
 135  ****************************************************************************/
 136 static struct plat_serial8250_port orion_uart1_data[] = {
 137         {
 138                 .flags          = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF,
 139                 .iotype         = UPIO_MEM,
 140                 .regshift       = 2,
 141         }, {
 142         },
 143 };
 144
 145 static struct resource orion_uart1_resources[2];
 146
 147 static struct platform_device orion_uart1 = {
 148         .name                   = "serial8250",
 149         .id                     = PLAT8250_DEV_PLATFORM1,
 150 };
 151
 152 void __init orion_uart1_init(void __iomem *membase,
 153                              resource_size_t mapbase,
 154                              unsigned int irq,
 155                              struct clk *clk)
 156 {
 157         uart_complete(&orion_uart1, orion_uart1_data, orion_uart1_resources,
 158                       membase, mapbase, irq, clk);
 159 }
 160
 161 /*****************************************************************************
 162  * UART2
 163  ****************************************************************************/
 164 static struct plat_serial8250_port orion_uart2_data[] = {
 165         {
 166                 .flags          = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF,
 167                 .iotype         = UPIO_MEM,
 168                 .regshift       = 2,
 169         }, {
 170         },
 171 };
 172
 173 static struct resource orion_uart2_resources[2];
 174
 175 static struct platform_device orion_uart2 = {
 176         .name                   = "serial8250",
 177         .id                     = PLAT8250_DEV_PLATFORM2,
 178 };
 179
 180 void __init orion_uart2_init(void __iomem *membase,
 181                              resource_size_t mapbase,
 182                              unsigned int irq,
 183                              struct clk *clk)
 184 {
 185         uart_complete(&orion_uart2, orion_uart2_data, orion_uart2_resources,
 186                       membase, mapbase, irq, clk);
 187 }
 188
 189 /*****************************************************************************
 190  * UART3
 191  ****************************************************************************/
 192 static struct plat_serial8250_port orion_uart3_data[] = {
 193         {
 194                 .flags          = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF,
 195                 .iotype         = UPIO_MEM,
 196                 .regshift       = 2,
 197         }, {
 198         },
 199 };
 200
 201 static struct resource orion_uart3_resources[2];
 202
 203 static struct platform_device orion_uart3 = {
 204         .name                   = "serial8250",
 205         .id                     = 3,
 206 };
 207
 208 void __init orion_uart3_init(void __iomem *membase,
 209                              resource_size_t mapbase,
 210                              unsigned int irq,
 211                              struct clk *clk)
 212 {
 213         uart_complete(&orion_uart3, orion_uart3_data, orion_uart3_resources,
 214                       membase, mapbase, irq, clk);
 215 }
 216
 217 /*****************************************************************************
 218  * SoC RTC
 219  ****************************************************************************/
 220 static struct resource orion_rtc_resource[2];
 221
 222 void __init orion_rtc_init(unsigned long mapbase,
 223                            unsigned long irq)
 224 {
 225         orion_rtc_resource[0].start = mapbase;
 226         orion_rtc_resource[0].end = mapbase + SZ_32 - 1;
 227         orion_rtc_resource[0].flags = IORESOURCE_MEM;
 228         orion_rtc_resource[1].start = irq;
 229         orion_rtc_resource[1].end = irq;
 230         orion_rtc_resource[1].flags = IORESOURCE_IRQ;
 231
 232         platform_device_register_simple("rtc-mv", -1, orion_rtc_resource, 2);
 233 }
 234
 235 /*****************************************************************************
 236  * GE
 237  ****************************************************************************/
 238 static __init void ge_complete(
 239         struct mv643xx_eth_shared_platform_data *orion_ge_shared_data,
 240         struct resource *orion_ge_resource, unsigned long irq,
 241         struct platform_device *orion_ge_shared,
 242         struct platform_device *orion_ge_mvmdio,
 243         struct mv643xx_eth_platform_data *eth_data,
 244         struct platform_device *orion_ge)
 245 {
 246         orion_ge_resource->start = irq;
 247         orion_ge_resource->end = irq;
 248         eth_data->shared = orion_ge_shared;
 249         orion_ge->dev.platform_data = eth_data;
 250
 251         platform_device_register(orion_ge_shared);
 252         if (orion_ge_mvmdio)
 253                 platform_device_register(orion_ge_mvmdio);
 254         platform_device_register(orion_ge);
 255 }
 256
 257 /*****************************************************************************
 258  * GE00
 259  ****************************************************************************/
 260 static struct mv643xx_eth_shared_platform_data orion_ge00_shared_data;
 261
 262 static struct resource orion_ge00_shared_resources[] = {
 263         {
 264                 .name   = "ge00 base",
 265         },
 266 };
 267
 268 static struct platform_device orion_ge00_shared = {
 269         .name           = MV643XX_ETH_SHARED_NAME,
 270         .id             = 0,
 271         .dev            = {
 272                 .platform_data  = &orion_ge00_shared_data,
 273         },
 274 };
 275
 276 static struct resource orion_ge_mvmdio_resources[] = {
 277         {
 278                 .name   = "ge00 mvmdio base",
 279         }, {
 280                 .name   = "ge00 mvmdio err irq",
 281         },
 282 };
 283
 284 static struct platform_device orion_ge_mvmdio = {
 285         .name           = "orion-mdio",
 286         .id             = -1,
 287 };
 288
 289 static struct resource orion_ge00_resources[] = {
 290         {
 291                 .name   = "ge00 irq",
 292                 .flags  = IORESOURCE_IRQ,
 293         },
 294 };
 295
 296 static struct platform_device orion_ge00 = {
 297         .name           = MV643XX_ETH_NAME,
 298         .id             = 0,
 299         .num_resources  = 1,
 300         .resource       = orion_ge00_resources,
 301         .dev            = {
 302                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 303         },
 304 };
 305
 306 void __init orion_ge00_init(struct mv643xx_eth_platform_data *eth_data,
 307                             unsigned long mapbase,
 308                             unsigned long irq,
 309                             unsigned long irq_err,
 310                             unsigned int tx_csum_limit)
 311 {
 312         fill_resources(&orion_ge00_shared, orion_ge00_shared_resources,
 313                        mapbase + 0x2000, SZ_16K - 1, NO_IRQ);
 314         fill_resources(&orion_ge_mvmdio, orion_ge_mvmdio_resources,
 315                         mapbase + 0x2004, 0x84 - 1, irq_err);
 316         orion_ge00_shared_data.tx_csum_limit = tx_csum_limit;
 317         ge_complete(&orion_ge00_shared_data,
 318                     orion_ge00_resources, irq, &orion_ge00_shared,
 319                     &orion_ge_mvmdio,
 320                     eth_data, &orion_ge00);
 321 }
 322
 323 /*****************************************************************************
 324  * GE01
 325  ****************************************************************************/
 326 static struct mv643xx_eth_shared_platform_data orion_ge01_shared_data;
 327
 328 static struct resource orion_ge01_shared_resources[] = {
 329         {
 330                 .name   = "ge01 base",
 331         }
 332 };
 333
 334 static struct platform_device orion_ge01_shared = {
 335         .name           = MV643XX_ETH_SHARED_NAME,
 336         .id             = 1,
 337         .dev            = {
 338                 .platform_data  = &orion_ge01_shared_data,
 339         },
 340 };
 341
 342 static struct resource orion_ge01_resources[] = {
 343         {
 344                 .name   = "ge01 irq",
 345                 .flags  = IORESOURCE_IRQ,
 346         },
 347 };
 348
 349 static struct platform_device orion_ge01 = {
 350         .name           = MV643XX_ETH_NAME,
 351         .id             = 1,
 352         .num_resources  = 1,
 353         .resource       = orion_ge01_resources,
 354         .dev            = {
 355                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 356         },
 357 };
 358
 359 void __init orion_ge01_init(struct mv643xx_eth_platform_data *eth_data,
 360                             unsigned long mapbase,
 361                             unsigned long irq,
 362                             unsigned long irq_err,
 363                             unsigned int tx_csum_limit)
 364 {
 365         fill_resources(&orion_ge01_shared, orion_ge01_shared_resources,
 366                        mapbase + 0x2000, SZ_16K - 1, NO_IRQ);
 367         orion_ge01_shared_data.tx_csum_limit = tx_csum_limit;
 368         ge_complete(&orion_ge01_shared_data,
 369                     orion_ge01_resources, irq, &orion_ge01_shared,
 370                     NULL,
 371                     eth_data, &orion_ge01);
 372 }
 373
 374 /*****************************************************************************
 375  * GE10
 376  ****************************************************************************/
 377 static struct mv643xx_eth_shared_platform_data orion_ge10_shared_data;
 378
 379 static struct resource orion_ge10_shared_resources[] = {
 380         {
 381                 .name   = "ge10 base",
 382         }
 383 };
 384
 385 static struct platform_device orion_ge10_shared = {
 386         .name           = MV643XX_ETH_SHARED_NAME,
 387         .id             = 2,
 388         .dev            = {
 389                 .platform_data  = &orion_ge10_shared_data,
 390         },
 391 };
 392
 393 static struct resource orion_ge10_resources[] = {
 394         {
 395                 .name   = "ge10 irq",
 396                 .flags  = IORESOURCE_IRQ,
 397         },
 398 };
 399
 400 static struct platform_device orion_ge10 = {
 401         .name           = MV643XX_ETH_NAME,
 402         .id             = 2,
 403         .num_resources  = 1,
 404         .resource       = orion_ge10_resources,
 405         .dev            = {
 406                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 407         },
 408 };
 409
 410 void __init orion_ge10_init(struct mv643xx_eth_platform_data *eth_data,
 411                             unsigned long mapbase,
 412                             unsigned long irq,
 413                             unsigned long irq_err)
 414 {
 415         fill_resources(&orion_ge10_shared, orion_ge10_shared_resources,
 416                        mapbase + 0x2000, SZ_16K - 1, NO_IRQ);
 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                             unsigned long irq_err)
 463 {
 464         fill_resources(&orion_ge11_shared, orion_ge11_shared_resources,
 465                        mapbase + 0x2000, SZ_16K - 1, NO_IRQ);
 466         ge_complete(&orion_ge11_shared_data,
 467                     orion_ge11_resources, irq, &orion_ge11_shared,
 468                     NULL,
 469                     eth_data, &orion_ge11);
 470 }
 471
 472 /*****************************************************************************
 473  * Ethernet switch
 474  ****************************************************************************/
 475 static struct resource orion_switch_resources[] = {
 476         {
 477                 .start  = 0,
 478                 .end    = 0,
 479                 .flags  = IORESOURCE_IRQ,
 480         },
 481 };
 482
 483 static struct platform_device orion_switch_device = {
 484         .name           = "dsa",
 485         .id             = 0,
 486         .num_resources  = 0,
 487         .resource       = orion_switch_resources,
 488 };
 489
 490 void __init orion_ge00_switch_init(struct dsa_platform_data *d, int irq)
 491 {
 492         int i;
 493
 494         if (irq != NO_IRQ) {
 495                 orion_switch_resources[0].start = irq;
 496                 orion_switch_resources[0].end = irq;
 497                 orion_switch_device.num_resources = 1;
 498         }
 499
 500         d->netdev = &orion_ge00.dev;
 501         for (i = 0; i < d->nr_chips; i++)
 502                 d->chip[i].mii_bus = &orion_ge00_shared.dev;
 503         orion_switch_device.dev.platform_data = d;
 504
 505         platform_device_register(&orion_switch_device);
 506 }
 507
 508 /*****************************************************************************
 509  * I2C
 510  ****************************************************************************/
 511 static struct mv64xxx_i2c_pdata orion_i2c_pdata = {
 512         .freq_n         = 3,
 513         .timeout        = 1000, /* Default timeout of 1 second */
 514 };
 515
 516 static struct resource orion_i2c_resources[2];
 517
 518 static struct platform_device orion_i2c = {
 519         .name           = MV64XXX_I2C_CTLR_NAME,
 520         .id             = 0,
 521         .dev            = {
 522                 .platform_data  = &orion_i2c_pdata,
 523         },
 524 };
 525
 526 static struct mv64xxx_i2c_pdata orion_i2c_1_pdata = {
 527         .freq_n         = 3,
 528         .timeout        = 1000, /* Default timeout of 1 second */
 529 };
 530
 531 static struct resource orion_i2c_1_resources[2];
 532
 533 static struct platform_device orion_i2c_1 = {
 534         .name           = MV64XXX_I2C_CTLR_NAME,
 535         .id             = 1,
 536         .dev            = {
 537                 .platform_data  = &orion_i2c_1_pdata,
 538         },
 539 };
 540
 541 void __init orion_i2c_init(unsigned long mapbase,
 542                            unsigned long irq,
 543                            unsigned long freq_m)
 544 {
 545         orion_i2c_pdata.freq_m = freq_m;
 546         fill_resources(&orion_i2c, orion_i2c_resources, mapbase,
 547                        SZ_32 - 1, irq);
 548         platform_device_register(&orion_i2c);
 549 }
 550
 551 void __init orion_i2c_1_init(unsigned long mapbase,
 552                              unsigned long irq,
 553                              unsigned long freq_m)
 554 {
 555         orion_i2c_1_pdata.freq_m = freq_m;
 556         fill_resources(&orion_i2c_1, orion_i2c_1_resources, mapbase,
 557                        SZ_32 - 1, irq);
 558         platform_device_register(&orion_i2c_1);
 559 }
 560
 561 /*****************************************************************************
 562  * SPI
 563  ****************************************************************************/
 564 static struct resource orion_spi_resources;
 565
 566 static struct platform_device orion_spi = {
 567         .name           = "orion_spi",
 568         .id             = 0,
 569 };
 570
 571 static struct resource orion_spi_1_resources;
 572
 573 static struct platform_device orion_spi_1 = {
 574         .name           = "orion_spi",
 575         .id             = 1,
 576 };
 577
 578 /* Note: The SPI silicon core does have interrupts. However the
 579  * current Linux software driver does not use interrupts. */
 580
 581 void __init orion_spi_init(unsigned long mapbase)
 582 {
 583         fill_resources(&orion_spi, &orion_spi_resources,
 584                        mapbase, SZ_512 - 1, NO_IRQ);
 585         platform_device_register(&orion_spi);
 586 }
 587
 588 void __init orion_spi_1_init(unsigned long mapbase)
 589 {
 590         fill_resources(&orion_spi_1, &orion_spi_1_resources,
 591                        mapbase, SZ_512 - 1, NO_IRQ);
 592         platform_device_register(&orion_spi_1);
 593 }
 594
 595 /*****************************************************************************
 596  * Watchdog
 597  ****************************************************************************/
 598 static struct resource orion_wdt_resource =
 599                 DEFINE_RES_MEM(TIMER_PHYS_BASE, 0x28);
 600
 601 static struct platform_device orion_wdt_device = {
 602         .name           = "orion_wdt",
 603         .id             = -1,
 604         .num_resources  = 1,
 605         .resource       = &orion_wdt_resource,
 606 };
 607
 608 void __init orion_wdt_init(void)
 609 {
 610         platform_device_register(&orion_wdt_device);
 611 }
 612
 613 /*****************************************************************************
 614  * XOR
 615  ****************************************************************************/
 616 static u64 orion_xor_dmamask = DMA_BIT_MASK(32);
 617
 618 /*****************************************************************************
 619  * XOR0
 620  ****************************************************************************/
 621 static struct resource orion_xor0_shared_resources[] = {
 622         {
 623                 .name   = "xor 0 low",
 624                 .flags  = IORESOURCE_MEM,
 625         }, {
 626                 .name   = "xor 0 high",
 627                 .flags  = IORESOURCE_MEM,
 628         }, {
 629                 .name   = "irq channel 0",
 630                 .flags  = IORESOURCE_IRQ,
 631         }, {
 632                 .name   = "irq channel 1",
 633                 .flags  = IORESOURCE_IRQ,
 634         },
 635 };
 636
 637 static struct mv_xor_channel_data orion_xor0_channels_data[2];
 638
 639 static struct mv_xor_platform_data orion_xor0_pdata = {
 640         .channels = orion_xor0_channels_data,
 641 };
 642
 643 static struct platform_device orion_xor0_shared = {
 644         .name           = MV_XOR_NAME,
 645         .id             = 0,
 646         .num_resources  = ARRAY_SIZE(orion_xor0_shared_resources),
 647         .resource       = orion_xor0_shared_resources,
 648         .dev            = {
 649                 .dma_mask               = &orion_xor_dmamask,
 650                 .coherent_dma_mask      = DMA_BIT_MASK(64),
 651                 .platform_data          = &orion_xor0_pdata,
 652         },
 653 };
 654
 655 void __init orion_xor0_init(unsigned long mapbase_low,
 656                             unsigned long mapbase_high,
 657                             unsigned long irq_0,
 658                             unsigned long irq_1)
 659 {
 660         orion_xor0_shared_resources[0].start = mapbase_low;
 661         orion_xor0_shared_resources[0].end = mapbase_low + 0xff;
 662         orion_xor0_shared_resources[1].start = mapbase_high;
 663         orion_xor0_shared_resources[1].end = mapbase_high + 0xff;
 664
 665         orion_xor0_shared_resources[2].start = irq_0;
 666         orion_xor0_shared_resources[2].end = irq_0;
 667         orion_xor0_shared_resources[3].start = irq_1;
 668         orion_xor0_shared_resources[3].end = irq_1;
 669
 670         dma_cap_set(DMA_MEMCPY, orion_xor0_channels_data[0].cap_mask);
 671         dma_cap_set(DMA_XOR, orion_xor0_channels_data[0].cap_mask);
 672
 673         dma_cap_set(DMA_MEMCPY, orion_xor0_channels_data[1].cap_mask);
 674         dma_cap_set(DMA_XOR, orion_xor0_channels_data[1].cap_mask);
 675
 676         platform_device_register(&orion_xor0_shared);
 677 }
 678
 679 /*****************************************************************************
 680  * XOR1
 681  ****************************************************************************/
 682 static struct resource orion_xor1_shared_resources[] = {
 683         {
 684                 .name   = "xor 1 low",
 685                 .flags  = IORESOURCE_MEM,
 686         }, {
 687                 .name   = "xor 1 high",
 688                 .flags  = IORESOURCE_MEM,
 689         }, {
 690                 .name   = "irq channel 0",
 691                 .flags  = IORESOURCE_IRQ,
 692         }, {
 693                 .name   = "irq channel 1",
 694                 .flags  = IORESOURCE_IRQ,
 695         },
 696 };
 697
 698 static struct mv_xor_channel_data orion_xor1_channels_data[2];
 699
 700 static struct mv_xor_platform_data orion_xor1_pdata = {
 701         .channels = orion_xor1_channels_data,
 702 };
 703
 704 static struct platform_device orion_xor1_shared = {
 705         .name           = MV_XOR_NAME,
 706         .id             = 1,
 707         .num_resources  = ARRAY_SIZE(orion_xor1_shared_resources),
 708         .resource       = orion_xor1_shared_resources,
 709         .dev            = {
 710                 .dma_mask               = &orion_xor_dmamask,
 711                 .coherent_dma_mask      = DMA_BIT_MASK(64),
 712                 .platform_data          = &orion_xor1_pdata,
 713         },
 714 };
 715
 716 void __init orion_xor1_init(unsigned long mapbase_low,
 717                             unsigned long mapbase_high,
 718                             unsigned long irq_0,
 719                             unsigned long irq_1)
 720 {
 721         orion_xor1_shared_resources[0].start = mapbase_low;
 722         orion_xor1_shared_resources[0].end = mapbase_low + 0xff;
 723         orion_xor1_shared_resources[1].start = mapbase_high;
 724         orion_xor1_shared_resources[1].end = mapbase_high + 0xff;
 725
 726         orion_xor1_shared_resources[2].start = irq_0;
 727         orion_xor1_shared_resources[2].end = irq_0;
 728         orion_xor1_shared_resources[3].start = irq_1;
 729         orion_xor1_shared_resources[3].end = irq_1;
 730
 731         dma_cap_set(DMA_MEMCPY, orion_xor1_channels_data[0].cap_mask);
 732         dma_cap_set(DMA_XOR, orion_xor1_channels_data[0].cap_mask);
 733
 734         dma_cap_set(DMA_MEMCPY, orion_xor1_channels_data[1].cap_mask);
 735         dma_cap_set(DMA_XOR, orion_xor1_channels_data[1].cap_mask);
 736
 737         platform_device_register(&orion_xor1_shared);
 738 }
 739
 740 /*****************************************************************************
 741  * EHCI
 742  ****************************************************************************/
 743 static struct orion_ehci_data orion_ehci_data;
 744 static u64 ehci_dmamask = DMA_BIT_MASK(32);
 745
 746
 747 /*****************************************************************************
 748  * EHCI0
 749  ****************************************************************************/
 750 static struct resource orion_ehci_resources[2];
 751
 752 static struct platform_device orion_ehci = {
 753         .name           = "orion-ehci",
 754         .id             = 0,
 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_init(unsigned long mapbase,
 763                             unsigned long irq,
 764                             enum orion_ehci_phy_ver phy_version)
 765 {
 766         orion_ehci_data.phy_version = phy_version;
 767         fill_resources(&orion_ehci, orion_ehci_resources, mapbase, SZ_4K - 1,
 768                        irq);
 769
 770         platform_device_register(&orion_ehci);
 771 }
 772
 773 /*****************************************************************************
 774  * EHCI1
 775  ****************************************************************************/
 776 static struct resource orion_ehci_1_resources[2];
 777
 778 static struct platform_device orion_ehci_1 = {
 779         .name           = "orion-ehci",
 780         .id             = 1,
 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_1_init(unsigned long mapbase,
 789                               unsigned long irq)
 790 {
 791         fill_resources(&orion_ehci_1, orion_ehci_1_resources,
 792                        mapbase, SZ_4K - 1, irq);
 793
 794         platform_device_register(&orion_ehci_1);
 795 }
 796
 797 /*****************************************************************************
 798  * EHCI2
 799  ****************************************************************************/
 800 static struct resource orion_ehci_2_resources[2];
 801
 802 static struct platform_device orion_ehci_2 = {
 803         .name           = "orion-ehci",
 804         .id             = 2,
 805         .dev            = {
 806                 .dma_mask               = &ehci_dmamask,
 807                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 808                 .platform_data          = &orion_ehci_data,
 809         },
 810 };
 811
 812 void __init orion_ehci_2_init(unsigned long mapbase,
 813                               unsigned long irq)
 814 {
 815         fill_resources(&orion_ehci_2, orion_ehci_2_resources,
 816                        mapbase, SZ_4K - 1, irq);
 817
 818         platform_device_register(&orion_ehci_2);
 819 }
 820
 821 /*****************************************************************************
 822  * SATA
 823  ****************************************************************************/
 824 static struct resource orion_sata_resources[2] = {
 825         {
 826                 .name   = "sata base",
 827         }, {
 828                 .name   = "sata irq",
 829         },
 830 };
 831
 832 static struct platform_device orion_sata = {
 833         .name           = "sata_mv",
 834         .id             = 0,
 835         .dev            = {
 836                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 837         },
 838 };
 839
 840 void __init orion_sata_init(struct mv_sata_platform_data *sata_data,
 841                             unsigned long mapbase,
 842                             unsigned long irq)
 843 {
 844         orion_sata.dev.platform_data = sata_data;
 845         fill_resources(&orion_sata, orion_sata_resources,
 846                        mapbase, 0x5000 - 1, irq);
 847
 848         platform_device_register(&orion_sata);
 849 }
 850
 851 /*****************************************************************************
 852  * Cryptographic Engines and Security Accelerator (CESA)
 853  ****************************************************************************/
 854 static struct resource orion_crypto_resources[] = {
 855         {
 856                 .name   = "regs",
 857         }, {
 858                 .name   = "crypto interrupt",
 859         }, {
 860                 .name   = "sram",
 861                 .flags  = IORESOURCE_MEM,
 862         },
 863 };
 864
 865 static struct platform_device orion_crypto = {
 866         .name           = "mv_crypto",
 867         .id             = -1,
 868 };
 869
 870 void __init orion_crypto_init(unsigned long mapbase,
 871                               unsigned long srambase,
 872                               unsigned long sram_size,
 873                               unsigned long irq)
 874 {
 875         fill_resources(&orion_crypto, orion_crypto_resources,
 876                        mapbase, 0xffff, irq);
 877         orion_crypto.num_resources = 3;
 878         orion_crypto_resources[2].start = srambase;
 879         orion_crypto_resources[2].end = srambase + sram_size - 1;
 880
 881         platform_device_register(&orion_crypto);
 882 }