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