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 {
  57         device->resource = resources;
  58         device->num_resources = 1;
  59         resources[0].flags = IORESOURCE_MEM;
  60         resources[0].start = mapbase;
  61         resources[0].end = mapbase + size;
  62 }
  63
  64 static void fill_resources_irq(struct platform_device *device,
  65                                struct resource *resources,
  66                                resource_size_t mapbase,
  67                                resource_size_t size,
  68                                unsigned int irq)
  69 {
  70         fill_resources(device, resources, mapbase, size);
  71
  72         device->num_resources++;
  73         resources[1].flags = IORESOURCE_IRQ;
  74         resources[1].start = irq;
  75         resources[1].end = irq;
  76 }
  77
  78 /*****************************************************************************
  79  * UART
  80  ****************************************************************************/
  81 static unsigned long __init uart_get_clk_rate(struct clk *clk)
  82 {
  83         clk_prepare_enable(clk);
  84         return clk_get_rate(clk);
  85 }
  86
  87 static void __init uart_complete(
  88         struct platform_device *orion_uart,
  89         struct plat_serial8250_port *data,
  90         struct resource *resources,
  91         void __iomem *membase,
  92         resource_size_t mapbase,
  93         unsigned int irq,
  94         struct clk *clk)
  95 {
  96         data->mapbase = mapbase;
  97         data->membase = membase;
  98         data->irq = irq;
  99         data->uartclk = uart_get_clk_rate(clk);
 100         orion_uart->dev.platform_data = data;
 101
 102         fill_resources_irq(orion_uart, resources, mapbase, 0xff, irq);
 103         platform_device_register(orion_uart);
 104 }
 105
 106 /*****************************************************************************
 107  * UART0
 108  ****************************************************************************/
 109 static struct plat_serial8250_port orion_uart0_data[] = {
 110         {
 111                 .flags          = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF,
 112                 .iotype         = UPIO_MEM,
 113                 .regshift       = 2,
 114         }, {
 115         },
 116 };
 117
 118 static struct resource orion_uart0_resources[2];
 119
 120 static struct platform_device orion_uart0 = {
 121         .name                   = "serial8250",
 122         .id                     = PLAT8250_DEV_PLATFORM,
 123 };
 124
 125 void __init orion_uart0_init(void __iomem *membase,
 126                              resource_size_t mapbase,
 127                              unsigned int irq,
 128                              struct clk *clk)
 129 {
 130         uart_complete(&orion_uart0, orion_uart0_data, orion_uart0_resources,
 131                       membase, mapbase, irq, clk);
 132 }
 133
 134 /*****************************************************************************
 135  * UART1
 136  ****************************************************************************/
 137 static struct plat_serial8250_port orion_uart1_data[] = {
 138         {
 139                 .flags          = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF,
 140                 .iotype         = UPIO_MEM,
 141                 .regshift       = 2,
 142         }, {
 143         },
 144 };
 145
 146 static struct resource orion_uart1_resources[2];
 147
 148 static struct platform_device orion_uart1 = {
 149         .name                   = "serial8250",
 150         .id                     = PLAT8250_DEV_PLATFORM1,
 151 };
 152
 153 void __init orion_uart1_init(void __iomem *membase,
 154                              resource_size_t mapbase,
 155                              unsigned int irq,
 156                              struct clk *clk)
 157 {
 158         uart_complete(&orion_uart1, orion_uart1_data, orion_uart1_resources,
 159                       membase, mapbase, irq, clk);
 160 }
 161
 162 /*****************************************************************************
 163  * UART2
 164  ****************************************************************************/
 165 static struct plat_serial8250_port orion_uart2_data[] = {
 166         {
 167                 .flags          = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF,
 168                 .iotype         = UPIO_MEM,
 169                 .regshift       = 2,
 170         }, {
 171         },
 172 };
 173
 174 static struct resource orion_uart2_resources[2];
 175
 176 static struct platform_device orion_uart2 = {
 177         .name                   = "serial8250",
 178         .id                     = PLAT8250_DEV_PLATFORM2,
 179 };
 180
 181 void __init orion_uart2_init(void __iomem *membase,
 182                              resource_size_t mapbase,
 183                              unsigned int irq,
 184                              struct clk *clk)
 185 {
 186         uart_complete(&orion_uart2, orion_uart2_data, orion_uart2_resources,
 187                       membase, mapbase, irq, clk);
 188 }
 189
 190 /*****************************************************************************
 191  * UART3
 192  ****************************************************************************/
 193 static struct plat_serial8250_port orion_uart3_data[] = {
 194         {
 195                 .flags          = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF,
 196                 .iotype         = UPIO_MEM,
 197                 .regshift       = 2,
 198         }, {
 199         },
 200 };
 201
 202 static struct resource orion_uart3_resources[2];
 203
 204 static struct platform_device orion_uart3 = {
 205         .name                   = "serial8250",
 206         .id                     = 3,
 207 };
 208
 209 void __init orion_uart3_init(void __iomem *membase,
 210                              resource_size_t mapbase,
 211                              unsigned int irq,
 212                              struct clk *clk)
 213 {
 214         uart_complete(&orion_uart3, orion_uart3_data, orion_uart3_resources,
 215                       membase, mapbase, irq, clk);
 216 }
 217
 218 /*****************************************************************************
 219  * SoC RTC
 220  ****************************************************************************/
 221 static struct resource orion_rtc_resource[2];
 222
 223 void __init orion_rtc_init(unsigned long mapbase,
 224                            unsigned long irq)
 225 {
 226         orion_rtc_resource[0].start = mapbase;
 227         orion_rtc_resource[0].end = mapbase + SZ_32 - 1;
 228         orion_rtc_resource[0].flags = IORESOURCE_MEM;
 229         orion_rtc_resource[1].start = irq;
 230         orion_rtc_resource[1].end = irq;
 231         orion_rtc_resource[1].flags = IORESOURCE_IRQ;
 232
 233         platform_device_register_simple("rtc-mv", -1, orion_rtc_resource, 2);
 234 }
 235
 236 /*****************************************************************************
 237  * GE
 238  ****************************************************************************/
 239 static __init void ge_complete(
 240         struct mv643xx_eth_shared_platform_data *orion_ge_shared_data,
 241         struct resource *orion_ge_resource, unsigned long irq,
 242         struct platform_device *orion_ge_shared,
 243         struct platform_device *orion_ge_mvmdio,
 244         struct mv643xx_eth_platform_data *eth_data,
 245         struct platform_device *orion_ge)
 246 {
 247         orion_ge_resource->start = irq;
 248         orion_ge_resource->end = irq;
 249         eth_data->shared = orion_ge_shared;
 250         orion_ge->dev.platform_data = eth_data;
 251
 252         platform_device_register(orion_ge_shared);
 253         if (orion_ge_mvmdio)
 254                 platform_device_register(orion_ge_mvmdio);
 255         platform_device_register(orion_ge);
 256 }
 257
 258 /*****************************************************************************
 259  * GE00
 260  ****************************************************************************/
 261 static struct mv643xx_eth_shared_platform_data orion_ge00_shared_data;
 262
 263 static struct resource orion_ge00_shared_resources[] = {
 264         {
 265                 .name   = "ge00 base",
 266         },
 267 };
 268
 269 static struct platform_device orion_ge00_shared = {
 270         .name           = MV643XX_ETH_SHARED_NAME,
 271         .id             = 0,
 272         .dev            = {
 273                 .platform_data  = &orion_ge00_shared_data,
 274         },
 275 };
 276
 277 static struct resource orion_ge_mvmdio_resources[] = {
 278         {
 279                 .name   = "ge00 mvmdio base",
 280         }, {
 281                 .name   = "ge00 mvmdio err irq",
 282         },
 283 };
 284
 285 static struct platform_device orion_ge_mvmdio = {
 286         .name           = "orion-mdio",
 287         .id             = -1,
 288 };
 289
 290 static struct resource orion_ge00_resources[] = {
 291         {
 292                 .name   = "ge00 irq",
 293                 .flags  = IORESOURCE_IRQ,
 294         },
 295 };
 296
 297 static struct platform_device orion_ge00 = {
 298         .name           = MV643XX_ETH_NAME,
 299         .id             = 0,
 300         .num_resources  = 1,
 301         .resource       = orion_ge00_resources,
 302         .dev            = {
 303                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 304         },
 305 };
 306
 307 void __init orion_ge00_init(struct mv643xx_eth_platform_data *eth_data,
 308                             unsigned long mapbase,
 309                             unsigned long irq,
 310                             unsigned long irq_err,
 311                             unsigned int tx_csum_limit)
 312 {
 313         fill_resources(&orion_ge00_shared, orion_ge00_shared_resources,
 314                        mapbase + 0x2000, SZ_16K - 1);
 315         fill_resources_irq(&orion_ge_mvmdio, orion_ge_mvmdio_resources,
 316                         mapbase + 0x2004, 0x84 - 1, irq_err);
 317         orion_ge00_shared_data.tx_csum_limit = tx_csum_limit;
 318         ge_complete(&orion_ge00_shared_data,
 319                     orion_ge00_resources, irq, &orion_ge00_shared,
 320                     &orion_ge_mvmdio,
 321                     eth_data, &orion_ge00);
 322 }
 323
 324 /*****************************************************************************
 325  * GE01
 326  ****************************************************************************/
 327 static struct mv643xx_eth_shared_platform_data orion_ge01_shared_data;
 328
 329 static struct resource orion_ge01_shared_resources[] = {
 330         {
 331                 .name   = "ge01 base",
 332         }
 333 };
 334
 335 static struct platform_device orion_ge01_shared = {
 336         .name           = MV643XX_ETH_SHARED_NAME,
 337         .id             = 1,
 338         .dev            = {
 339                 .platform_data  = &orion_ge01_shared_data,
 340         },
 341 };
 342
 343 static struct resource orion_ge01_resources[] = {
 344         {
 345                 .name   = "ge01 irq",
 346                 .flags  = IORESOURCE_IRQ,
 347         },
 348 };
 349
 350 static struct platform_device orion_ge01 = {
 351         .name           = MV643XX_ETH_NAME,
 352         .id             = 1,
 353         .num_resources  = 1,
 354         .resource       = orion_ge01_resources,
 355         .dev            = {
 356                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 357         },
 358 };
 359
 360 void __init orion_ge01_init(struct mv643xx_eth_platform_data *eth_data,
 361                             unsigned long mapbase,
 362                             unsigned long irq,
 363                             unsigned int tx_csum_limit)
 364 {
 365         fill_resources(&orion_ge01_shared, orion_ge01_shared_resources,
 366                        mapbase + 0x2000, SZ_16K - 1);
 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 {
 414         fill_resources(&orion_ge10_shared, orion_ge10_shared_resources,
 415                        mapbase + 0x2000, SZ_16K - 1);
 416         ge_complete(&orion_ge10_shared_data,
 417                     orion_ge10_resources, irq, &orion_ge10_shared,
 418                     NULL,
 419                     eth_data, &orion_ge10);
 420 }
 421
 422 /*****************************************************************************
 423  * GE11
 424  ****************************************************************************/
 425 static struct mv643xx_eth_shared_platform_data orion_ge11_shared_data;
 426
 427 static struct resource orion_ge11_shared_resources[] = {
 428         {
 429                 .name   = "ge11 base",
 430         },
 431 };
 432
 433 static struct platform_device orion_ge11_shared = {
 434         .name           = MV643XX_ETH_SHARED_NAME,
 435         .id             = 3,
 436         .dev            = {
 437                 .platform_data  = &orion_ge11_shared_data,
 438         },
 439 };
 440
 441 static struct resource orion_ge11_resources[] = {
 442         {
 443                 .name   = "ge11 irq",
 444                 .flags  = IORESOURCE_IRQ,
 445         },
 446 };
 447
 448 static struct platform_device orion_ge11 = {
 449         .name           = MV643XX_ETH_NAME,
 450         .id             = 3,
 451         .num_resources  = 1,
 452         .resource       = orion_ge11_resources,
 453         .dev            = {
 454                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 455         },
 456 };
 457
 458 void __init orion_ge11_init(struct mv643xx_eth_platform_data *eth_data,
 459                             unsigned long mapbase,
 460                             unsigned long irq)
 461 {
 462         fill_resources(&orion_ge11_shared, orion_ge11_shared_resources,
 463                        mapbase + 0x2000, SZ_16K - 1);
 464         ge_complete(&orion_ge11_shared_data,
 465                     orion_ge11_resources, irq, &orion_ge11_shared,
 466                     NULL,
 467                     eth_data, &orion_ge11);
 468 }
 469
 470 /*****************************************************************************
 471  * Ethernet switch
 472  ****************************************************************************/
 473 void __init orion_ge00_switch_init(struct dsa_platform_data *d)
 474 {
 475         int i;
 476
 477         d->netdev = &orion_ge00.dev;
 478         for (i = 0; i < d->nr_chips; i++)
 479                 d->chip[i].host_dev = &orion_ge_mvmdio.dev;
 480
 481         platform_device_register_data(NULL, "dsa", 0, d, sizeof(d));
 482 }
 483
 484 /*****************************************************************************
 485  * I2C
 486  ****************************************************************************/
 487 static struct mv64xxx_i2c_pdata orion_i2c_pdata = {
 488         .freq_n         = 3,
 489         .timeout        = 1000, /* Default timeout of 1 second */
 490 };
 491
 492 static struct resource orion_i2c_resources[2];
 493
 494 static struct platform_device orion_i2c = {
 495         .name           = MV64XXX_I2C_CTLR_NAME,
 496         .id             = 0,
 497         .dev            = {
 498                 .platform_data  = &orion_i2c_pdata,
 499         },
 500 };
 501
 502 static struct mv64xxx_i2c_pdata orion_i2c_1_pdata = {
 503         .freq_n         = 3,
 504         .timeout        = 1000, /* Default timeout of 1 second */
 505 };
 506
 507 static struct resource orion_i2c_1_resources[2];
 508
 509 static struct platform_device orion_i2c_1 = {
 510         .name           = MV64XXX_I2C_CTLR_NAME,
 511         .id             = 1,
 512         .dev            = {
 513                 .platform_data  = &orion_i2c_1_pdata,
 514         },
 515 };
 516
 517 void __init orion_i2c_init(unsigned long mapbase,
 518                            unsigned long irq,
 519                            unsigned long freq_m)
 520 {
 521         orion_i2c_pdata.freq_m = freq_m;
 522         fill_resources_irq(&orion_i2c, orion_i2c_resources, mapbase,
 523                        SZ_32 - 1, irq);
 524         platform_device_register(&orion_i2c);
 525 }
 526
 527 void __init orion_i2c_1_init(unsigned long mapbase,
 528                              unsigned long irq,
 529                              unsigned long freq_m)
 530 {
 531         orion_i2c_1_pdata.freq_m = freq_m;
 532         fill_resources_irq(&orion_i2c_1, orion_i2c_1_resources, mapbase,
 533                        SZ_32 - 1, irq);
 534         platform_device_register(&orion_i2c_1);
 535 }
 536
 537 /*****************************************************************************
 538  * SPI
 539  ****************************************************************************/
 540 static struct resource orion_spi_resources;
 541
 542 static struct platform_device orion_spi = {
 543         .name           = "orion_spi",
 544         .id             = 0,
 545 };
 546
 547 static struct resource orion_spi_1_resources;
 548
 549 static struct platform_device orion_spi_1 = {
 550         .name           = "orion_spi",
 551         .id             = 1,
 552 };
 553
 554 /* Note: The SPI silicon core does have interrupts. However the
 555  * current Linux software driver does not use interrupts. */
 556
 557 void __init orion_spi_init(unsigned long mapbase)
 558 {
 559         fill_resources(&orion_spi, &orion_spi_resources,
 560                        mapbase, SZ_512 - 1);
 561         platform_device_register(&orion_spi);
 562 }
 563
 564 void __init orion_spi_1_init(unsigned long mapbase)
 565 {
 566         fill_resources(&orion_spi_1, &orion_spi_1_resources,
 567                        mapbase, SZ_512 - 1);
 568         platform_device_register(&orion_spi_1);
 569 }
 570
 571 /*****************************************************************************
 572  * XOR
 573  ****************************************************************************/
 574 static u64 orion_xor_dmamask = DMA_BIT_MASK(32);
 575
 576 /*****************************************************************************
 577  * XOR0
 578  ****************************************************************************/
 579 static struct resource orion_xor0_shared_resources[] = {
 580         {
 581                 .name   = "xor 0 low",
 582                 .flags  = IORESOURCE_MEM,
 583         }, {
 584                 .name   = "xor 0 high",
 585                 .flags  = IORESOURCE_MEM,
 586         }, {
 587                 .name   = "irq channel 0",
 588                 .flags  = IORESOURCE_IRQ,
 589         }, {
 590                 .name   = "irq channel 1",
 591                 .flags  = IORESOURCE_IRQ,
 592         },
 593 };
 594
 595 static struct mv_xor_channel_data orion_xor0_channels_data[2];
 596
 597 static struct mv_xor_platform_data orion_xor0_pdata = {
 598         .channels = orion_xor0_channels_data,
 599 };
 600
 601 static struct platform_device orion_xor0_shared = {
 602         .name           = MV_XOR_NAME,
 603         .id             = 0,
 604         .num_resources  = ARRAY_SIZE(orion_xor0_shared_resources),
 605         .resource       = orion_xor0_shared_resources,
 606         .dev            = {
 607                 .dma_mask               = &orion_xor_dmamask,
 608                 .coherent_dma_mask      = DMA_BIT_MASK(64),
 609                 .platform_data          = &orion_xor0_pdata,
 610         },
 611 };
 612
 613 void __init orion_xor0_init(unsigned long mapbase_low,
 614                             unsigned long mapbase_high,
 615                             unsigned long irq_0,
 616                             unsigned long irq_1)
 617 {
 618         orion_xor0_shared_resources[0].start = mapbase_low;
 619         orion_xor0_shared_resources[0].end = mapbase_low + 0xff;
 620         orion_xor0_shared_resources[1].start = mapbase_high;
 621         orion_xor0_shared_resources[1].end = mapbase_high + 0xff;
 622
 623         orion_xor0_shared_resources[2].start = irq_0;
 624         orion_xor0_shared_resources[2].end = irq_0;
 625         orion_xor0_shared_resources[3].start = irq_1;
 626         orion_xor0_shared_resources[3].end = irq_1;
 627
 628         dma_cap_set(DMA_MEMCPY, orion_xor0_channels_data[0].cap_mask);
 629         dma_cap_set(DMA_XOR, orion_xor0_channels_data[0].cap_mask);
 630
 631         dma_cap_set(DMA_MEMCPY, orion_xor0_channels_data[1].cap_mask);
 632         dma_cap_set(DMA_XOR, orion_xor0_channels_data[1].cap_mask);
 633
 634         platform_device_register(&orion_xor0_shared);
 635 }
 636
 637 /*****************************************************************************
 638  * XOR1
 639  ****************************************************************************/
 640 static struct resource orion_xor1_shared_resources[] = {
 641         {
 642                 .name   = "xor 1 low",
 643                 .flags  = IORESOURCE_MEM,
 644         }, {
 645                 .name   = "xor 1 high",
 646                 .flags  = IORESOURCE_MEM,
 647         }, {
 648                 .name   = "irq channel 0",
 649                 .flags  = IORESOURCE_IRQ,
 650         }, {
 651                 .name   = "irq channel 1",
 652                 .flags  = IORESOURCE_IRQ,
 653         },
 654 };
 655
 656 static struct mv_xor_channel_data orion_xor1_channels_data[2];
 657
 658 static struct mv_xor_platform_data orion_xor1_pdata = {
 659         .channels = orion_xor1_channels_data,
 660 };
 661
 662 static struct platform_device orion_xor1_shared = {
 663         .name           = MV_XOR_NAME,
 664         .id             = 1,
 665         .num_resources  = ARRAY_SIZE(orion_xor1_shared_resources),
 666         .resource       = orion_xor1_shared_resources,
 667         .dev            = {
 668                 .dma_mask               = &orion_xor_dmamask,
 669                 .coherent_dma_mask      = DMA_BIT_MASK(64),
 670                 .platform_data          = &orion_xor1_pdata,
 671         },
 672 };
 673
 674 void __init orion_xor1_init(unsigned long mapbase_low,
 675                             unsigned long mapbase_high,
 676                             unsigned long irq_0,
 677                             unsigned long irq_1)
 678 {
 679         orion_xor1_shared_resources[0].start = mapbase_low;
 680         orion_xor1_shared_resources[0].end = mapbase_low + 0xff;
 681         orion_xor1_shared_resources[1].start = mapbase_high;
 682         orion_xor1_shared_resources[1].end = mapbase_high + 0xff;
 683
 684         orion_xor1_shared_resources[2].start = irq_0;
 685         orion_xor1_shared_resources[2].end = irq_0;
 686         orion_xor1_shared_resources[3].start = irq_1;
 687         orion_xor1_shared_resources[3].end = irq_1;
 688
 689         dma_cap_set(DMA_MEMCPY, orion_xor1_channels_data[0].cap_mask);
 690         dma_cap_set(DMA_XOR, orion_xor1_channels_data[0].cap_mask);
 691
 692         dma_cap_set(DMA_MEMCPY, orion_xor1_channels_data[1].cap_mask);
 693         dma_cap_set(DMA_XOR, orion_xor1_channels_data[1].cap_mask);
 694
 695         platform_device_register(&orion_xor1_shared);
 696 }
 697
 698 /*****************************************************************************
 699  * EHCI
 700  ****************************************************************************/
 701 static struct orion_ehci_data orion_ehci_data;
 702 static u64 ehci_dmamask = DMA_BIT_MASK(32);
 703
 704
 705 /*****************************************************************************
 706  * EHCI0
 707  ****************************************************************************/
 708 static struct resource orion_ehci_resources[2];
 709
 710 static struct platform_device orion_ehci = {
 711         .name           = "orion-ehci",
 712         .id             = 0,
 713         .dev            = {
 714                 .dma_mask               = &ehci_dmamask,
 715                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 716                 .platform_data          = &orion_ehci_data,
 717         },
 718 };
 719
 720 void __init orion_ehci_init(unsigned long mapbase,
 721                             unsigned long irq,
 722                             enum orion_ehci_phy_ver phy_version)
 723 {
 724         orion_ehci_data.phy_version = phy_version;
 725         fill_resources_irq(&orion_ehci, orion_ehci_resources, mapbase, SZ_4K - 1,
 726                        irq);
 727
 728         platform_device_register(&orion_ehci);
 729 }
 730
 731 /*****************************************************************************
 732  * EHCI1
 733  ****************************************************************************/
 734 static struct resource orion_ehci_1_resources[2];
 735
 736 static struct platform_device orion_ehci_1 = {
 737         .name           = "orion-ehci",
 738         .id             = 1,
 739         .dev            = {
 740                 .dma_mask               = &ehci_dmamask,
 741                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 742                 .platform_data          = &orion_ehci_data,
 743         },
 744 };
 745
 746 void __init orion_ehci_1_init(unsigned long mapbase,
 747                               unsigned long irq)
 748 {
 749         fill_resources_irq(&orion_ehci_1, orion_ehci_1_resources,
 750                        mapbase, SZ_4K - 1, irq);
 751
 752         platform_device_register(&orion_ehci_1);
 753 }
 754
 755 /*****************************************************************************
 756  * EHCI2
 757  ****************************************************************************/
 758 static struct resource orion_ehci_2_resources[2];
 759
 760 static struct platform_device orion_ehci_2 = {
 761         .name           = "orion-ehci",
 762         .id             = 2,
 763         .dev            = {
 764                 .dma_mask               = &ehci_dmamask,
 765                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 766                 .platform_data          = &orion_ehci_data,
 767         },
 768 };
 769
 770 void __init orion_ehci_2_init(unsigned long mapbase,
 771                               unsigned long irq)
 772 {
 773         fill_resources_irq(&orion_ehci_2, orion_ehci_2_resources,
 774                        mapbase, SZ_4K - 1, irq);
 775
 776         platform_device_register(&orion_ehci_2);
 777 }
 778
 779 /*****************************************************************************
 780  * SATA
 781  ****************************************************************************/
 782 static struct resource orion_sata_resources[2] = {
 783         {
 784                 .name   = "sata base",
 785         }, {
 786                 .name   = "sata irq",
 787         },
 788 };
 789
 790 static struct platform_device orion_sata = {
 791         .name           = "sata_mv",
 792         .id             = 0,
 793         .dev            = {
 794                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 795         },
 796 };
 797
 798 void __init orion_sata_init(struct mv_sata_platform_data *sata_data,
 799                             unsigned long mapbase,
 800                             unsigned long irq)
 801 {
 802         orion_sata.dev.platform_data = sata_data;
 803         fill_resources_irq(&orion_sata, orion_sata_resources,
 804                        mapbase, 0x5000 - 1, irq);
 805
 806         platform_device_register(&orion_sata);
 807 }
 808
 809 /*****************************************************************************
 810  * Cryptographic Engines and Security Accelerator (CESA)
 811  ****************************************************************************/
 812 static struct resource orion_crypto_resources[] = {
 813         {
 814                 .name   = "regs",
 815         }, {
 816                 .name   = "crypto interrupt",
 817         }, {
 818                 .name   = "sram",
 819                 .flags  = IORESOURCE_MEM,
 820         },
 821 };
 822
 823 static struct platform_device orion_crypto = {
 824         .name           = "mv_crypto",
 825         .id             = -1,
 826 };
 827
 828 void __init orion_crypto_init(unsigned long mapbase,
 829                               unsigned long srambase,
 830                               unsigned long sram_size,
 831                               unsigned long irq)
 832 {
 833         fill_resources_irq(&orion_crypto, orion_crypto_resources,
 834                        mapbase, 0xffff, irq);
 835         orion_crypto.num_resources = 3;
 836         orion_crypto_resources[2].start = srambase;
 837         orion_crypto_resources[2].end = srambase + sram_size - 1;
 838
 839         platform_device_register(&orion_crypto);
 840 }