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