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