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