1 /* 2 * FSL SoC setup code 3 * 4 * Maintained by Kumar Gala (see MAINTAINERS for contact information) 5 * 6 * 2006 (c) MontaVista Software, Inc. 7 * Vitaly Bordug <vbordug@ru.mvista.com> 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License as published by the 11 * Free Software Foundation; either version 2 of the License, or (at your 12 * option) any later version. 13 */ 14 15 #include <linux/stddef.h> 16 #include <linux/kernel.h> 17 #include <linux/init.h> 18 #include <linux/errno.h> 19 #include <linux/major.h> 20 #include <linux/delay.h> 21 #include <linux/irq.h> 22 #include <linux/module.h> 23 #include <linux/device.h> 24 #include <linux/platform_device.h> 25 #include <linux/of_platform.h> 26 #include <linux/phy.h> 27 #include <linux/spi/spi.h> 28 #include <linux/fsl_devices.h> 29 #include <linux/fs_enet_pd.h> 30 #include <linux/fs_uart_pd.h> 31 32 #include <asm/system.h> 33 #include <asm/atomic.h> 34 #include <asm/io.h> 35 #include <asm/irq.h> 36 #include <asm/time.h> 37 #include <asm/prom.h> 38 #include <sysdev/fsl_soc.h> 39 #include <mm/mmu_decl.h> 40 #include <asm/cpm2.h> 41 42 extern void init_fcc_ioports(struct fs_platform_info*); 43 extern void init_fec_ioports(struct fs_platform_info*); 44 extern void init_smc_ioports(struct fs_uart_platform_info*); 45 static phys_addr_t immrbase = -1; 46 47 phys_addr_t get_immrbase(void) 48 { 49 struct device_node *soc; 50 51 if (immrbase != -1) 52 return immrbase; 53 54 soc = of_find_node_by_type(NULL, "soc"); 55 if (soc) { 56 int size; 57 const void *prop = of_get_property(soc, "reg", &size); 58 59 if (prop) 60 immrbase = of_translate_address(soc, prop); 61 of_node_put(soc); 62 } 63 64 return immrbase; 65 } 66 67 EXPORT_SYMBOL(get_immrbase); 68 69 #if defined(CONFIG_CPM2) || defined(CONFIG_8xx) 70 71 static u32 brgfreq = -1; 72 73 u32 get_brgfreq(void) 74 { 75 struct device_node *node; 76 const unsigned int *prop; 77 int size; 78 79 if (brgfreq != -1) 80 return brgfreq; 81 82 node = of_find_compatible_node(NULL, NULL, "fsl,cpm-brg"); 83 if (node) { 84 prop = of_get_property(node, "clock-frequency", &size); 85 if (prop && size == 4) 86 brgfreq = *prop; 87 88 of_node_put(node); 89 return brgfreq; 90 } 91 92 /* Legacy device binding -- will go away when no users are left. */ 93 node = of_find_node_by_type(NULL, "cpm"); 94 if (node) { 95 prop = of_get_property(node, "brg-frequency", &size); 96 if (prop && size == 4) 97 brgfreq = *prop; 98 99 of_node_put(node); 100 } 101 102 return brgfreq; 103 } 104 105 EXPORT_SYMBOL(get_brgfreq); 106 107 static u32 fs_baudrate = -1; 108 109 u32 get_baudrate(void) 110 { 111 struct device_node *node; 112 113 if (fs_baudrate != -1) 114 return fs_baudrate; 115 116 node = of_find_node_by_type(NULL, "serial"); 117 if (node) { 118 int size; 119 const unsigned int *prop = of_get_property(node, 120 "current-speed", &size); 121 122 if (prop) 123 fs_baudrate = *prop; 124 of_node_put(node); 125 } 126 127 return fs_baudrate; 128 } 129 130 EXPORT_SYMBOL(get_baudrate); 131 #endif /* CONFIG_CPM2 */ 132 133 static int __init gfar_mdio_of_init(void) 134 { 135 struct device_node *np; 136 unsigned int i; 137 struct platform_device *mdio_dev; 138 struct resource res; 139 int ret; 140 141 for (np = NULL, i = 0; 142 (np = of_find_compatible_node(np, "mdio", "gianfar")) != NULL; 143 i++) { 144 int k; 145 struct device_node *child = NULL; 146 struct gianfar_mdio_data mdio_data; 147 148 memset(&res, 0, sizeof(res)); 149 memset(&mdio_data, 0, sizeof(mdio_data)); 150 151 ret = of_address_to_resource(np, 0, &res); 152 if (ret) 153 goto err; 154 155 mdio_dev = 156 platform_device_register_simple("fsl-gianfar_mdio", 157 res.start, &res, 1); 158 if (IS_ERR(mdio_dev)) { 159 ret = PTR_ERR(mdio_dev); 160 goto err; 161 } 162 163 for (k = 0; k < 32; k++) 164 mdio_data.irq[k] = PHY_POLL; 165 166 while ((child = of_get_next_child(np, child)) != NULL) { 167 int irq = irq_of_parse_and_map(child, 0); 168 if (irq != NO_IRQ) { 169 const u32 *id = of_get_property(child, 170 "reg", NULL); 171 mdio_data.irq[*id] = irq; 172 } 173 } 174 175 ret = 176 platform_device_add_data(mdio_dev, &mdio_data, 177 sizeof(struct gianfar_mdio_data)); 178 if (ret) 179 goto unreg; 180 } 181 182 return 0; 183 184 unreg: 185 platform_device_unregister(mdio_dev); 186 err: 187 return ret; 188 } 189 190 arch_initcall(gfar_mdio_of_init); 191 192 static const char *gfar_tx_intr = "tx"; 193 static const char *gfar_rx_intr = "rx"; 194 static const char *gfar_err_intr = "error"; 195 196 197 static int __init gfar_of_init(void) 198 { 199 struct device_node *np; 200 unsigned int i; 201 struct platform_device *gfar_dev; 202 struct resource res; 203 int ret; 204 205 for (np = NULL, i = 0; 206 (np = of_find_compatible_node(np, "network", "gianfar")) != NULL; 207 i++) { 208 struct resource r[4]; 209 struct device_node *phy, *mdio; 210 struct gianfar_platform_data gfar_data; 211 const unsigned int *id; 212 const char *model; 213 const char *ctype; 214 const void *mac_addr; 215 const phandle *ph; 216 int n_res = 2; 217 218 memset(r, 0, sizeof(r)); 219 memset(&gfar_data, 0, sizeof(gfar_data)); 220 221 ret = of_address_to_resource(np, 0, &r[0]); 222 if (ret) 223 goto err; 224 225 of_irq_to_resource(np, 0, &r[1]); 226 227 model = of_get_property(np, "model", NULL); 228 229 /* If we aren't the FEC we have multiple interrupts */ 230 if (model && strcasecmp(model, "FEC")) { 231 r[1].name = gfar_tx_intr; 232 233 r[2].name = gfar_rx_intr; 234 of_irq_to_resource(np, 1, &r[2]); 235 236 r[3].name = gfar_err_intr; 237 of_irq_to_resource(np, 2, &r[3]); 238 239 n_res += 2; 240 } 241 242 gfar_dev = 243 platform_device_register_simple("fsl-gianfar", i, &r[0], 244 n_res); 245 246 if (IS_ERR(gfar_dev)) { 247 ret = PTR_ERR(gfar_dev); 248 goto err; 249 } 250 251 mac_addr = of_get_mac_address(np); 252 if (mac_addr) 253 memcpy(gfar_data.mac_addr, mac_addr, 6); 254 255 if (model && !strcasecmp(model, "TSEC")) 256 gfar_data.device_flags = 257 FSL_GIANFAR_DEV_HAS_GIGABIT | 258 FSL_GIANFAR_DEV_HAS_COALESCE | 259 FSL_GIANFAR_DEV_HAS_RMON | 260 FSL_GIANFAR_DEV_HAS_MULTI_INTR; 261 if (model && !strcasecmp(model, "eTSEC")) 262 gfar_data.device_flags = 263 FSL_GIANFAR_DEV_HAS_GIGABIT | 264 FSL_GIANFAR_DEV_HAS_COALESCE | 265 FSL_GIANFAR_DEV_HAS_RMON | 266 FSL_GIANFAR_DEV_HAS_MULTI_INTR | 267 FSL_GIANFAR_DEV_HAS_CSUM | 268 FSL_GIANFAR_DEV_HAS_VLAN | 269 FSL_GIANFAR_DEV_HAS_EXTENDED_HASH; 270 271 ctype = of_get_property(np, "phy-connection-type", NULL); 272 273 /* We only care about rgmii-id. The rest are autodetected */ 274 if (ctype && !strcmp(ctype, "rgmii-id")) 275 gfar_data.interface = PHY_INTERFACE_MODE_RGMII_ID; 276 else 277 gfar_data.interface = PHY_INTERFACE_MODE_MII; 278 279 ph = of_get_property(np, "phy-handle", NULL); 280 phy = of_find_node_by_phandle(*ph); 281 282 if (phy == NULL) { 283 ret = -ENODEV; 284 goto unreg; 285 } 286 287 mdio = of_get_parent(phy); 288 289 id = of_get_property(phy, "reg", NULL); 290 ret = of_address_to_resource(mdio, 0, &res); 291 if (ret) { 292 of_node_put(phy); 293 of_node_put(mdio); 294 goto unreg; 295 } 296 297 gfar_data.phy_id = *id; 298 gfar_data.bus_id = res.start; 299 300 of_node_put(phy); 301 of_node_put(mdio); 302 303 ret = 304 platform_device_add_data(gfar_dev, &gfar_data, 305 sizeof(struct 306 gianfar_platform_data)); 307 if (ret) 308 goto unreg; 309 } 310 311 return 0; 312 313 unreg: 314 platform_device_unregister(gfar_dev); 315 err: 316 return ret; 317 } 318 319 arch_initcall(gfar_of_init); 320 321 #ifdef CONFIG_I2C_BOARDINFO 322 #include <linux/i2c.h> 323 struct i2c_driver_device { 324 char *of_device; 325 char *i2c_driver; 326 char *i2c_type; 327 }; 328 329 static struct i2c_driver_device i2c_devices[] __initdata = { 330 {"ricoh,rs5c372a", "rtc-rs5c372", "rs5c372a",}, 331 {"ricoh,rs5c372b", "rtc-rs5c372", "rs5c372b",}, 332 {"ricoh,rv5c386", "rtc-rs5c372", "rv5c386",}, 333 {"ricoh,rv5c387a", "rtc-rs5c372", "rv5c387a",}, 334 {"dallas,ds1307", "rtc-ds1307", "ds1307",}, 335 {"dallas,ds1337", "rtc-ds1307", "ds1337",}, 336 {"dallas,ds1338", "rtc-ds1307", "ds1338",}, 337 {"dallas,ds1339", "rtc-ds1307", "ds1339",}, 338 {"dallas,ds1340", "rtc-ds1307", "ds1340",}, 339 {"stm,m41t00", "rtc-ds1307", "m41t00"}, 340 {"dallas,ds1374", "rtc-ds1374", "rtc-ds1374",}, 341 }; 342 343 static int __init of_find_i2c_driver(struct device_node *node, 344 struct i2c_board_info *info) 345 { 346 int i; 347 348 for (i = 0; i < ARRAY_SIZE(i2c_devices); i++) { 349 if (!of_device_is_compatible(node, i2c_devices[i].of_device)) 350 continue; 351 if (strlcpy(info->driver_name, i2c_devices[i].i2c_driver, 352 KOBJ_NAME_LEN) >= KOBJ_NAME_LEN || 353 strlcpy(info->type, i2c_devices[i].i2c_type, 354 I2C_NAME_SIZE) >= I2C_NAME_SIZE) 355 return -ENOMEM; 356 return 0; 357 } 358 return -ENODEV; 359 } 360 361 static void __init of_register_i2c_devices(struct device_node *adap_node, 362 int bus_num) 363 { 364 struct device_node *node = NULL; 365 366 while ((node = of_get_next_child(adap_node, node))) { 367 struct i2c_board_info info = {}; 368 const u32 *addr; 369 int len; 370 371 addr = of_get_property(node, "reg", &len); 372 if (!addr || len < sizeof(int) || *addr > (1 << 10) - 1) { 373 printk(KERN_WARNING "fsl_soc.c: invalid i2c device entry\n"); 374 continue; 375 } 376 377 info.irq = irq_of_parse_and_map(node, 0); 378 if (info.irq == NO_IRQ) 379 info.irq = -1; 380 381 if (of_find_i2c_driver(node, &info) < 0) 382 continue; 383 384 info.addr = *addr; 385 386 i2c_register_board_info(bus_num, &info, 1); 387 } 388 } 389 390 static int __init fsl_i2c_of_init(void) 391 { 392 struct device_node *np; 393 unsigned int i; 394 struct platform_device *i2c_dev; 395 int ret; 396 397 for (np = NULL, i = 0; 398 (np = of_find_compatible_node(np, "i2c", "fsl-i2c")) != NULL; 399 i++) { 400 struct resource r[2]; 401 struct fsl_i2c_platform_data i2c_data; 402 const unsigned char *flags = NULL; 403 404 memset(&r, 0, sizeof(r)); 405 memset(&i2c_data, 0, sizeof(i2c_data)); 406 407 ret = of_address_to_resource(np, 0, &r[0]); 408 if (ret) 409 goto err; 410 411 of_irq_to_resource(np, 0, &r[1]); 412 413 i2c_dev = platform_device_register_simple("fsl-i2c", i, r, 2); 414 if (IS_ERR(i2c_dev)) { 415 ret = PTR_ERR(i2c_dev); 416 goto err; 417 } 418 419 i2c_data.device_flags = 0; 420 flags = of_get_property(np, "dfsrr", NULL); 421 if (flags) 422 i2c_data.device_flags |= FSL_I2C_DEV_SEPARATE_DFSRR; 423 424 flags = of_get_property(np, "fsl5200-clocking", NULL); 425 if (flags) 426 i2c_data.device_flags |= FSL_I2C_DEV_CLOCK_5200; 427 428 ret = 429 platform_device_add_data(i2c_dev, &i2c_data, 430 sizeof(struct 431 fsl_i2c_platform_data)); 432 if (ret) 433 goto unreg; 434 435 of_register_i2c_devices(np, i); 436 } 437 438 return 0; 439 440 unreg: 441 platform_device_unregister(i2c_dev); 442 err: 443 return ret; 444 } 445 446 arch_initcall(fsl_i2c_of_init); 447 #endif 448 449 #ifdef CONFIG_PPC_83xx 450 static int __init mpc83xx_wdt_init(void) 451 { 452 struct resource r; 453 struct device_node *soc, *np; 454 struct platform_device *dev; 455 const unsigned int *freq; 456 int ret; 457 458 np = of_find_compatible_node(NULL, "watchdog", "mpc83xx_wdt"); 459 460 if (!np) { 461 ret = -ENODEV; 462 goto nodev; 463 } 464 465 soc = of_find_node_by_type(NULL, "soc"); 466 467 if (!soc) { 468 ret = -ENODEV; 469 goto nosoc; 470 } 471 472 freq = of_get_property(soc, "bus-frequency", NULL); 473 if (!freq) { 474 ret = -ENODEV; 475 goto err; 476 } 477 478 memset(&r, 0, sizeof(r)); 479 480 ret = of_address_to_resource(np, 0, &r); 481 if (ret) 482 goto err; 483 484 dev = platform_device_register_simple("mpc83xx_wdt", 0, &r, 1); 485 if (IS_ERR(dev)) { 486 ret = PTR_ERR(dev); 487 goto err; 488 } 489 490 ret = platform_device_add_data(dev, freq, sizeof(int)); 491 if (ret) 492 goto unreg; 493 494 of_node_put(soc); 495 of_node_put(np); 496 497 return 0; 498 499 unreg: 500 platform_device_unregister(dev); 501 err: 502 of_node_put(soc); 503 nosoc: 504 of_node_put(np); 505 nodev: 506 return ret; 507 } 508 509 arch_initcall(mpc83xx_wdt_init); 510 #endif 511 512 static enum fsl_usb2_phy_modes determine_usb_phy(const char *phy_type) 513 { 514 if (!phy_type) 515 return FSL_USB2_PHY_NONE; 516 if (!strcasecmp(phy_type, "ulpi")) 517 return FSL_USB2_PHY_ULPI; 518 if (!strcasecmp(phy_type, "utmi")) 519 return FSL_USB2_PHY_UTMI; 520 if (!strcasecmp(phy_type, "utmi_wide")) 521 return FSL_USB2_PHY_UTMI_WIDE; 522 if (!strcasecmp(phy_type, "serial")) 523 return FSL_USB2_PHY_SERIAL; 524 525 return FSL_USB2_PHY_NONE; 526 } 527 528 static int __init fsl_usb_of_init(void) 529 { 530 struct device_node *np; 531 unsigned int i; 532 struct platform_device *usb_dev_mph = NULL, *usb_dev_dr_host = NULL, 533 *usb_dev_dr_client = NULL; 534 int ret; 535 536 for (np = NULL, i = 0; 537 (np = of_find_compatible_node(np, "usb", "fsl-usb2-mph")) != NULL; 538 i++) { 539 struct resource r[2]; 540 struct fsl_usb2_platform_data usb_data; 541 const unsigned char *prop = NULL; 542 543 memset(&r, 0, sizeof(r)); 544 memset(&usb_data, 0, sizeof(usb_data)); 545 546 ret = of_address_to_resource(np, 0, &r[0]); 547 if (ret) 548 goto err; 549 550 of_irq_to_resource(np, 0, &r[1]); 551 552 usb_dev_mph = 553 platform_device_register_simple("fsl-ehci", i, r, 2); 554 if (IS_ERR(usb_dev_mph)) { 555 ret = PTR_ERR(usb_dev_mph); 556 goto err; 557 } 558 559 usb_dev_mph->dev.coherent_dma_mask = 0xffffffffUL; 560 usb_dev_mph->dev.dma_mask = &usb_dev_mph->dev.coherent_dma_mask; 561 562 usb_data.operating_mode = FSL_USB2_MPH_HOST; 563 564 prop = of_get_property(np, "port0", NULL); 565 if (prop) 566 usb_data.port_enables |= FSL_USB2_PORT0_ENABLED; 567 568 prop = of_get_property(np, "port1", NULL); 569 if (prop) 570 usb_data.port_enables |= FSL_USB2_PORT1_ENABLED; 571 572 prop = of_get_property(np, "phy_type", NULL); 573 usb_data.phy_mode = determine_usb_phy(prop); 574 575 ret = 576 platform_device_add_data(usb_dev_mph, &usb_data, 577 sizeof(struct 578 fsl_usb2_platform_data)); 579 if (ret) 580 goto unreg_mph; 581 } 582 583 for (np = NULL; 584 (np = of_find_compatible_node(np, "usb", "fsl-usb2-dr")) != NULL; 585 i++) { 586 struct resource r[2]; 587 struct fsl_usb2_platform_data usb_data; 588 const unsigned char *prop = NULL; 589 590 memset(&r, 0, sizeof(r)); 591 memset(&usb_data, 0, sizeof(usb_data)); 592 593 ret = of_address_to_resource(np, 0, &r[0]); 594 if (ret) 595 goto unreg_mph; 596 597 of_irq_to_resource(np, 0, &r[1]); 598 599 prop = of_get_property(np, "dr_mode", NULL); 600 601 if (!prop || !strcmp(prop, "host")) { 602 usb_data.operating_mode = FSL_USB2_DR_HOST; 603 usb_dev_dr_host = platform_device_register_simple( 604 "fsl-ehci", i, r, 2); 605 if (IS_ERR(usb_dev_dr_host)) { 606 ret = PTR_ERR(usb_dev_dr_host); 607 goto err; 608 } 609 } else if (prop && !strcmp(prop, "peripheral")) { 610 usb_data.operating_mode = FSL_USB2_DR_DEVICE; 611 usb_dev_dr_client = platform_device_register_simple( 612 "fsl-usb2-udc", i, r, 2); 613 if (IS_ERR(usb_dev_dr_client)) { 614 ret = PTR_ERR(usb_dev_dr_client); 615 goto err; 616 } 617 } else if (prop && !strcmp(prop, "otg")) { 618 usb_data.operating_mode = FSL_USB2_DR_OTG; 619 usb_dev_dr_host = platform_device_register_simple( 620 "fsl-ehci", i, r, 2); 621 if (IS_ERR(usb_dev_dr_host)) { 622 ret = PTR_ERR(usb_dev_dr_host); 623 goto err; 624 } 625 usb_dev_dr_client = platform_device_register_simple( 626 "fsl-usb2-udc", i, r, 2); 627 if (IS_ERR(usb_dev_dr_client)) { 628 ret = PTR_ERR(usb_dev_dr_client); 629 goto err; 630 } 631 } else { 632 ret = -EINVAL; 633 goto err; 634 } 635 636 prop = of_get_property(np, "phy_type", NULL); 637 usb_data.phy_mode = determine_usb_phy(prop); 638 639 if (usb_dev_dr_host) { 640 usb_dev_dr_host->dev.coherent_dma_mask = 0xffffffffUL; 641 usb_dev_dr_host->dev.dma_mask = &usb_dev_dr_host-> 642 dev.coherent_dma_mask; 643 if ((ret = platform_device_add_data(usb_dev_dr_host, 644 &usb_data, sizeof(struct 645 fsl_usb2_platform_data)))) 646 goto unreg_dr; 647 } 648 if (usb_dev_dr_client) { 649 usb_dev_dr_client->dev.coherent_dma_mask = 0xffffffffUL; 650 usb_dev_dr_client->dev.dma_mask = &usb_dev_dr_client-> 651 dev.coherent_dma_mask; 652 if ((ret = platform_device_add_data(usb_dev_dr_client, 653 &usb_data, sizeof(struct 654 fsl_usb2_platform_data)))) 655 goto unreg_dr; 656 } 657 } 658 return 0; 659 660 unreg_dr: 661 if (usb_dev_dr_host) 662 platform_device_unregister(usb_dev_dr_host); 663 if (usb_dev_dr_client) 664 platform_device_unregister(usb_dev_dr_client); 665 unreg_mph: 666 if (usb_dev_mph) 667 platform_device_unregister(usb_dev_mph); 668 err: 669 return ret; 670 } 671 672 arch_initcall(fsl_usb_of_init); 673 674 #ifndef CONFIG_PPC_CPM_NEW_BINDING 675 #ifdef CONFIG_CPM2 676 677 extern void init_scc_ioports(struct fs_uart_platform_info*); 678 679 static const char fcc_regs[] = "fcc_regs"; 680 static const char fcc_regs_c[] = "fcc_regs_c"; 681 static const char fcc_pram[] = "fcc_pram"; 682 static char bus_id[9][BUS_ID_SIZE]; 683 684 static int __init fs_enet_of_init(void) 685 { 686 struct device_node *np; 687 unsigned int i; 688 struct platform_device *fs_enet_dev; 689 struct resource res; 690 int ret; 691 692 for (np = NULL, i = 0; 693 (np = of_find_compatible_node(np, "network", "fs_enet")) != NULL; 694 i++) { 695 struct resource r[4]; 696 struct device_node *phy, *mdio; 697 struct fs_platform_info fs_enet_data; 698 const unsigned int *id, *phy_addr, *phy_irq; 699 const void *mac_addr; 700 const phandle *ph; 701 const char *model; 702 703 memset(r, 0, sizeof(r)); 704 memset(&fs_enet_data, 0, sizeof(fs_enet_data)); 705 706 ret = of_address_to_resource(np, 0, &r[0]); 707 if (ret) 708 goto err; 709 r[0].name = fcc_regs; 710 711 ret = of_address_to_resource(np, 1, &r[1]); 712 if (ret) 713 goto err; 714 r[1].name = fcc_pram; 715 716 ret = of_address_to_resource(np, 2, &r[2]); 717 if (ret) 718 goto err; 719 r[2].name = fcc_regs_c; 720 fs_enet_data.fcc_regs_c = r[2].start; 721 722 of_irq_to_resource(np, 0, &r[3]); 723 724 fs_enet_dev = 725 platform_device_register_simple("fsl-cpm-fcc", i, &r[0], 4); 726 727 if (IS_ERR(fs_enet_dev)) { 728 ret = PTR_ERR(fs_enet_dev); 729 goto err; 730 } 731 732 model = of_get_property(np, "model", NULL); 733 if (model == NULL) { 734 ret = -ENODEV; 735 goto unreg; 736 } 737 738 mac_addr = of_get_mac_address(np); 739 if (mac_addr) 740 memcpy(fs_enet_data.macaddr, mac_addr, 6); 741 742 ph = of_get_property(np, "phy-handle", NULL); 743 phy = of_find_node_by_phandle(*ph); 744 745 if (phy == NULL) { 746 ret = -ENODEV; 747 goto unreg; 748 } 749 750 phy_addr = of_get_property(phy, "reg", NULL); 751 fs_enet_data.phy_addr = *phy_addr; 752 753 phy_irq = of_get_property(phy, "interrupts", NULL); 754 755 id = of_get_property(np, "device-id", NULL); 756 fs_enet_data.fs_no = *id; 757 strcpy(fs_enet_data.fs_type, model); 758 759 mdio = of_get_parent(phy); 760 ret = of_address_to_resource(mdio, 0, &res); 761 if (ret) { 762 of_node_put(phy); 763 of_node_put(mdio); 764 goto unreg; 765 } 766 767 fs_enet_data.clk_rx = *((u32 *)of_get_property(np, 768 "rx-clock", NULL)); 769 fs_enet_data.clk_tx = *((u32 *)of_get_property(np, 770 "tx-clock", NULL)); 771 772 if (strstr(model, "FCC")) { 773 int fcc_index = *id - 1; 774 const unsigned char *mdio_bb_prop; 775 776 fs_enet_data.dpram_offset = (u32)cpm_dpram_addr(0); 777 fs_enet_data.rx_ring = 32; 778 fs_enet_data.tx_ring = 32; 779 fs_enet_data.rx_copybreak = 240; 780 fs_enet_data.use_napi = 0; 781 fs_enet_data.napi_weight = 17; 782 fs_enet_data.mem_offset = FCC_MEM_OFFSET(fcc_index); 783 fs_enet_data.cp_page = CPM_CR_FCC_PAGE(fcc_index); 784 fs_enet_data.cp_block = CPM_CR_FCC_SBLOCK(fcc_index); 785 786 snprintf((char*)&bus_id[(*id)], BUS_ID_SIZE, "%x:%02x", 787 (u32)res.start, fs_enet_data.phy_addr); 788 fs_enet_data.bus_id = (char*)&bus_id[(*id)]; 789 fs_enet_data.init_ioports = init_fcc_ioports; 790 791 mdio_bb_prop = of_get_property(phy, "bitbang", NULL); 792 if (mdio_bb_prop) { 793 struct platform_device *fs_enet_mdio_bb_dev; 794 struct fs_mii_bb_platform_info fs_enet_mdio_bb_data; 795 796 fs_enet_mdio_bb_dev = 797 platform_device_register_simple("fsl-bb-mdio", 798 i, NULL, 0); 799 memset(&fs_enet_mdio_bb_data, 0, 800 sizeof(struct fs_mii_bb_platform_info)); 801 fs_enet_mdio_bb_data.mdio_dat.bit = 802 mdio_bb_prop[0]; 803 fs_enet_mdio_bb_data.mdio_dir.bit = 804 mdio_bb_prop[1]; 805 fs_enet_mdio_bb_data.mdc_dat.bit = 806 mdio_bb_prop[2]; 807 fs_enet_mdio_bb_data.mdio_port = 808 mdio_bb_prop[3]; 809 fs_enet_mdio_bb_data.mdc_port = 810 mdio_bb_prop[4]; 811 fs_enet_mdio_bb_data.delay = 812 mdio_bb_prop[5]; 813 814 fs_enet_mdio_bb_data.irq[0] = phy_irq[0]; 815 fs_enet_mdio_bb_data.irq[1] = -1; 816 fs_enet_mdio_bb_data.irq[2] = -1; 817 fs_enet_mdio_bb_data.irq[3] = phy_irq[0]; 818 fs_enet_mdio_bb_data.irq[31] = -1; 819 820 fs_enet_mdio_bb_data.mdio_dat.offset = 821 (u32)&cpm2_immr->im_ioport.iop_pdatc; 822 fs_enet_mdio_bb_data.mdio_dir.offset = 823 (u32)&cpm2_immr->im_ioport.iop_pdirc; 824 fs_enet_mdio_bb_data.mdc_dat.offset = 825 (u32)&cpm2_immr->im_ioport.iop_pdatc; 826 827 ret = platform_device_add_data( 828 fs_enet_mdio_bb_dev, 829 &fs_enet_mdio_bb_data, 830 sizeof(struct fs_mii_bb_platform_info)); 831 if (ret) 832 goto unreg; 833 } 834 835 of_node_put(phy); 836 of_node_put(mdio); 837 838 ret = platform_device_add_data(fs_enet_dev, &fs_enet_data, 839 sizeof(struct 840 fs_platform_info)); 841 if (ret) 842 goto unreg; 843 } 844 } 845 return 0; 846 847 unreg: 848 platform_device_unregister(fs_enet_dev); 849 err: 850 return ret; 851 } 852 853 arch_initcall(fs_enet_of_init); 854 855 static const char scc_regs[] = "regs"; 856 static const char scc_pram[] = "pram"; 857 858 static int __init cpm_uart_of_init(void) 859 { 860 struct device_node *np; 861 unsigned int i; 862 struct platform_device *cpm_uart_dev; 863 int ret; 864 865 for (np = NULL, i = 0; 866 (np = of_find_compatible_node(np, "serial", "cpm_uart")) != NULL; 867 i++) { 868 struct resource r[3]; 869 struct fs_uart_platform_info cpm_uart_data; 870 const int *id; 871 const char *model; 872 873 memset(r, 0, sizeof(r)); 874 memset(&cpm_uart_data, 0, sizeof(cpm_uart_data)); 875 876 ret = of_address_to_resource(np, 0, &r[0]); 877 if (ret) 878 goto err; 879 880 r[0].name = scc_regs; 881 882 ret = of_address_to_resource(np, 1, &r[1]); 883 if (ret) 884 goto err; 885 r[1].name = scc_pram; 886 887 of_irq_to_resource(np, 0, &r[2]); 888 889 cpm_uart_dev = 890 platform_device_register_simple("fsl-cpm-scc:uart", i, &r[0], 3); 891 892 if (IS_ERR(cpm_uart_dev)) { 893 ret = PTR_ERR(cpm_uart_dev); 894 goto err; 895 } 896 897 id = of_get_property(np, "device-id", NULL); 898 cpm_uart_data.fs_no = *id; 899 900 model = of_get_property(np, "model", NULL); 901 strcpy(cpm_uart_data.fs_type, model); 902 903 cpm_uart_data.uart_clk = ppc_proc_freq; 904 905 cpm_uart_data.tx_num_fifo = 4; 906 cpm_uart_data.tx_buf_size = 32; 907 cpm_uart_data.rx_num_fifo = 4; 908 cpm_uart_data.rx_buf_size = 32; 909 cpm_uart_data.clk_rx = *((u32 *)of_get_property(np, 910 "rx-clock", NULL)); 911 cpm_uart_data.clk_tx = *((u32 *)of_get_property(np, 912 "tx-clock", NULL)); 913 914 ret = 915 platform_device_add_data(cpm_uart_dev, &cpm_uart_data, 916 sizeof(struct 917 fs_uart_platform_info)); 918 if (ret) 919 goto unreg; 920 } 921 922 return 0; 923 924 unreg: 925 platform_device_unregister(cpm_uart_dev); 926 err: 927 return ret; 928 } 929 930 arch_initcall(cpm_uart_of_init); 931 #endif /* CONFIG_CPM2 */ 932 933 #ifdef CONFIG_8xx 934 935 extern void init_scc_ioports(struct fs_platform_info*); 936 extern int platform_device_skip(const char *model, int id); 937 938 static int __init fs_enet_mdio_of_init(void) 939 { 940 struct device_node *np; 941 unsigned int i; 942 struct platform_device *mdio_dev; 943 struct resource res; 944 int ret; 945 946 for (np = NULL, i = 0; 947 (np = of_find_compatible_node(np, "mdio", "fs_enet")) != NULL; 948 i++) { 949 struct fs_mii_fec_platform_info mdio_data; 950 951 memset(&res, 0, sizeof(res)); 952 memset(&mdio_data, 0, sizeof(mdio_data)); 953 954 ret = of_address_to_resource(np, 0, &res); 955 if (ret) 956 goto err; 957 958 mdio_dev = 959 platform_device_register_simple("fsl-cpm-fec-mdio", 960 res.start, &res, 1); 961 if (IS_ERR(mdio_dev)) { 962 ret = PTR_ERR(mdio_dev); 963 goto err; 964 } 965 966 mdio_data.mii_speed = ((((ppc_proc_freq + 4999999) / 2500000) / 2) & 0x3F) << 1; 967 968 ret = 969 platform_device_add_data(mdio_dev, &mdio_data, 970 sizeof(struct fs_mii_fec_platform_info)); 971 if (ret) 972 goto unreg; 973 } 974 return 0; 975 976 unreg: 977 platform_device_unregister(mdio_dev); 978 err: 979 return ret; 980 } 981 982 arch_initcall(fs_enet_mdio_of_init); 983 984 static const char *enet_regs = "regs"; 985 static const char *enet_pram = "pram"; 986 static const char *enet_irq = "interrupt"; 987 static char bus_id[9][BUS_ID_SIZE]; 988 989 static int __init fs_enet_of_init(void) 990 { 991 struct device_node *np; 992 unsigned int i; 993 struct platform_device *fs_enet_dev = NULL; 994 struct resource res; 995 int ret; 996 997 for (np = NULL, i = 0; 998 (np = of_find_compatible_node(np, "network", "fs_enet")) != NULL; 999 i++) { 1000 struct resource r[4]; 1001 struct device_node *phy = NULL, *mdio = NULL; 1002 struct fs_platform_info fs_enet_data; 1003 const unsigned int *id; 1004 const unsigned int *phy_addr; 1005 const void *mac_addr; 1006 const phandle *ph; 1007 const char *model; 1008 1009 memset(r, 0, sizeof(r)); 1010 memset(&fs_enet_data, 0, sizeof(fs_enet_data)); 1011 1012 model = of_get_property(np, "model", NULL); 1013 if (model == NULL) { 1014 ret = -ENODEV; 1015 goto unreg; 1016 } 1017 1018 id = of_get_property(np, "device-id", NULL); 1019 fs_enet_data.fs_no = *id; 1020 1021 if (platform_device_skip(model, *id)) 1022 continue; 1023 1024 ret = of_address_to_resource(np, 0, &r[0]); 1025 if (ret) 1026 goto err; 1027 r[0].name = enet_regs; 1028 1029 mac_addr = of_get_mac_address(np); 1030 if (mac_addr) 1031 memcpy(fs_enet_data.macaddr, mac_addr, 6); 1032 1033 ph = of_get_property(np, "phy-handle", NULL); 1034 if (ph != NULL) 1035 phy = of_find_node_by_phandle(*ph); 1036 1037 if (phy != NULL) { 1038 phy_addr = of_get_property(phy, "reg", NULL); 1039 fs_enet_data.phy_addr = *phy_addr; 1040 fs_enet_data.has_phy = 1; 1041 1042 mdio = of_get_parent(phy); 1043 ret = of_address_to_resource(mdio, 0, &res); 1044 if (ret) { 1045 of_node_put(phy); 1046 of_node_put(mdio); 1047 goto unreg; 1048 } 1049 } 1050 1051 model = of_get_property(np, "model", NULL); 1052 strcpy(fs_enet_data.fs_type, model); 1053 1054 if (strstr(model, "FEC")) { 1055 r[1].start = r[1].end = irq_of_parse_and_map(np, 0); 1056 r[1].flags = IORESOURCE_IRQ; 1057 r[1].name = enet_irq; 1058 1059 fs_enet_dev = 1060 platform_device_register_simple("fsl-cpm-fec", i, &r[0], 2); 1061 1062 if (IS_ERR(fs_enet_dev)) { 1063 ret = PTR_ERR(fs_enet_dev); 1064 goto err; 1065 } 1066 1067 fs_enet_data.rx_ring = 128; 1068 fs_enet_data.tx_ring = 16; 1069 fs_enet_data.rx_copybreak = 240; 1070 fs_enet_data.use_napi = 1; 1071 fs_enet_data.napi_weight = 17; 1072 1073 snprintf((char*)&bus_id[i], BUS_ID_SIZE, "%x:%02x", 1074 (u32)res.start, fs_enet_data.phy_addr); 1075 fs_enet_data.bus_id = (char*)&bus_id[i]; 1076 fs_enet_data.init_ioports = init_fec_ioports; 1077 } 1078 if (strstr(model, "SCC")) { 1079 ret = of_address_to_resource(np, 1, &r[1]); 1080 if (ret) 1081 goto err; 1082 r[1].name = enet_pram; 1083 1084 r[2].start = r[2].end = irq_of_parse_and_map(np, 0); 1085 r[2].flags = IORESOURCE_IRQ; 1086 r[2].name = enet_irq; 1087 1088 fs_enet_dev = 1089 platform_device_register_simple("fsl-cpm-scc", i, &r[0], 3); 1090 1091 if (IS_ERR(fs_enet_dev)) { 1092 ret = PTR_ERR(fs_enet_dev); 1093 goto err; 1094 } 1095 1096 fs_enet_data.rx_ring = 64; 1097 fs_enet_data.tx_ring = 8; 1098 fs_enet_data.rx_copybreak = 240; 1099 fs_enet_data.use_napi = 1; 1100 fs_enet_data.napi_weight = 17; 1101 1102 snprintf((char*)&bus_id[i], BUS_ID_SIZE, "%s", "fixed@10:1"); 1103 fs_enet_data.bus_id = (char*)&bus_id[i]; 1104 fs_enet_data.init_ioports = init_scc_ioports; 1105 } 1106 1107 of_node_put(phy); 1108 of_node_put(mdio); 1109 1110 ret = platform_device_add_data(fs_enet_dev, &fs_enet_data, 1111 sizeof(struct 1112 fs_platform_info)); 1113 if (ret) 1114 goto unreg; 1115 } 1116 return 0; 1117 1118 unreg: 1119 platform_device_unregister(fs_enet_dev); 1120 err: 1121 return ret; 1122 } 1123 1124 arch_initcall(fs_enet_of_init); 1125 1126 static int __init fsl_pcmcia_of_init(void) 1127 { 1128 struct device_node *np = NULL; 1129 /* 1130 * Register all the devices which type is "pcmcia" 1131 */ 1132 while ((np = of_find_compatible_node(np, 1133 "pcmcia", "fsl,pq-pcmcia")) != NULL) 1134 of_platform_device_create(np, "m8xx-pcmcia", NULL); 1135 return 0; 1136 } 1137 1138 arch_initcall(fsl_pcmcia_of_init); 1139 1140 static const char *smc_regs = "regs"; 1141 static const char *smc_pram = "pram"; 1142 1143 static int __init cpm_smc_uart_of_init(void) 1144 { 1145 struct device_node *np; 1146 unsigned int i; 1147 struct platform_device *cpm_uart_dev; 1148 int ret; 1149 1150 for (np = NULL, i = 0; 1151 (np = of_find_compatible_node(np, "serial", "cpm_uart")) != NULL; 1152 i++) { 1153 struct resource r[3]; 1154 struct fs_uart_platform_info cpm_uart_data; 1155 const int *id; 1156 const char *model; 1157 1158 memset(r, 0, sizeof(r)); 1159 memset(&cpm_uart_data, 0, sizeof(cpm_uart_data)); 1160 1161 ret = of_address_to_resource(np, 0, &r[0]); 1162 if (ret) 1163 goto err; 1164 1165 r[0].name = smc_regs; 1166 1167 ret = of_address_to_resource(np, 1, &r[1]); 1168 if (ret) 1169 goto err; 1170 r[1].name = smc_pram; 1171 1172 r[2].start = r[2].end = irq_of_parse_and_map(np, 0); 1173 r[2].flags = IORESOURCE_IRQ; 1174 1175 cpm_uart_dev = 1176 platform_device_register_simple("fsl-cpm-smc:uart", i, &r[0], 3); 1177 1178 if (IS_ERR(cpm_uart_dev)) { 1179 ret = PTR_ERR(cpm_uart_dev); 1180 goto err; 1181 } 1182 1183 model = of_get_property(np, "model", NULL); 1184 strcpy(cpm_uart_data.fs_type, model); 1185 1186 id = of_get_property(np, "device-id", NULL); 1187 cpm_uart_data.fs_no = *id; 1188 cpm_uart_data.uart_clk = ppc_proc_freq; 1189 1190 cpm_uart_data.tx_num_fifo = 4; 1191 cpm_uart_data.tx_buf_size = 32; 1192 cpm_uart_data.rx_num_fifo = 4; 1193 cpm_uart_data.rx_buf_size = 32; 1194 1195 ret = 1196 platform_device_add_data(cpm_uart_dev, &cpm_uart_data, 1197 sizeof(struct 1198 fs_uart_platform_info)); 1199 if (ret) 1200 goto unreg; 1201 } 1202 1203 return 0; 1204 1205 unreg: 1206 platform_device_unregister(cpm_uart_dev); 1207 err: 1208 return ret; 1209 } 1210 1211 arch_initcall(cpm_smc_uart_of_init); 1212 1213 #endif /* CONFIG_8xx */ 1214 #endif /* CONFIG_PPC_CPM_NEW_BINDING */ 1215 1216 int __init fsl_spi_init(struct spi_board_info *board_infos, 1217 unsigned int num_board_infos, 1218 void (*activate_cs)(u8 cs, u8 polarity), 1219 void (*deactivate_cs)(u8 cs, u8 polarity)) 1220 { 1221 struct device_node *np; 1222 unsigned int i; 1223 const u32 *sysclk; 1224 1225 /* SPI controller is either clocked from QE or SoC clock */ 1226 np = of_find_node_by_type(NULL, "qe"); 1227 if (!np) 1228 np = of_find_node_by_type(NULL, "soc"); 1229 1230 if (!np) 1231 return -ENODEV; 1232 1233 sysclk = of_get_property(np, "bus-frequency", NULL); 1234 if (!sysclk) 1235 return -ENODEV; 1236 1237 for (np = NULL, i = 1; 1238 (np = of_find_compatible_node(np, "spi", "fsl_spi")) != NULL; 1239 i++) { 1240 int ret = 0; 1241 unsigned int j; 1242 const void *prop; 1243 struct resource res[2]; 1244 struct platform_device *pdev; 1245 struct fsl_spi_platform_data pdata = { 1246 .activate_cs = activate_cs, 1247 .deactivate_cs = deactivate_cs, 1248 }; 1249 1250 memset(res, 0, sizeof(res)); 1251 1252 pdata.sysclk = *sysclk; 1253 1254 prop = of_get_property(np, "reg", NULL); 1255 if (!prop) 1256 goto err; 1257 pdata.bus_num = *(u32 *)prop; 1258 1259 prop = of_get_property(np, "mode", NULL); 1260 if (prop && !strcmp(prop, "cpu-qe")) 1261 pdata.qe_mode = 1; 1262 1263 for (j = 0; j < num_board_infos; j++) { 1264 if (board_infos[j].bus_num == pdata.bus_num) 1265 pdata.max_chipselect++; 1266 } 1267 1268 if (!pdata.max_chipselect) 1269 goto err; 1270 1271 ret = of_address_to_resource(np, 0, &res[0]); 1272 if (ret) 1273 goto err; 1274 1275 ret = of_irq_to_resource(np, 0, &res[1]); 1276 if (ret == NO_IRQ) 1277 goto err; 1278 1279 pdev = platform_device_alloc("mpc83xx_spi", i); 1280 if (!pdev) 1281 goto err; 1282 1283 ret = platform_device_add_data(pdev, &pdata, sizeof(pdata)); 1284 if (ret) 1285 goto unreg; 1286 1287 ret = platform_device_add_resources(pdev, res, 1288 ARRAY_SIZE(res)); 1289 if (ret) 1290 goto unreg; 1291 1292 ret = platform_device_register(pdev); 1293 if (ret) 1294 goto unreg; 1295 1296 continue; 1297 unreg: 1298 platform_device_del(pdev); 1299 err: 1300 continue; 1301 } 1302 1303 return spi_register_board_info(board_infos, num_board_infos); 1304 } 1305 1306 #if defined(CONFIG_PPC_85xx) || defined(CONFIG_PPC_86xx) 1307 static __be32 __iomem *rstcr; 1308 1309 static int __init setup_rstcr(void) 1310 { 1311 struct device_node *np; 1312 np = of_find_node_by_name(NULL, "global-utilities"); 1313 if ((np && of_get_property(np, "fsl,has-rstcr", NULL))) { 1314 const u32 *prop = of_get_property(np, "reg", NULL); 1315 if (prop) { 1316 /* map reset control register 1317 * 0xE00B0 is offset of reset control register 1318 */ 1319 rstcr = ioremap(get_immrbase() + *prop + 0xB0, 0xff); 1320 if (!rstcr) 1321 printk (KERN_EMERG "Error: reset control " 1322 "register not mapped!\n"); 1323 } 1324 } else 1325 printk (KERN_INFO "rstcr compatible register does not exist!\n"); 1326 if (np) 1327 of_node_put(np); 1328 return 0; 1329 } 1330 1331 arch_initcall(setup_rstcr); 1332 1333 void fsl_rstcr_restart(char *cmd) 1334 { 1335 local_irq_disable(); 1336 if (rstcr) 1337 /* set reset control register */ 1338 out_be32(rstcr, 0x2); /* HRESET_REQ */ 1339 1340 while (1) ; 1341 } 1342 #endif 1343