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