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 } 937