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