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/phy.h> 26 #include <linux/fsl_devices.h> 27 #include <linux/fs_enet_pd.h> 28 #include <linux/fs_uart_pd.h> 29 30 #include <asm/system.h> 31 #include <asm/atomic.h> 32 #include <asm/io.h> 33 #include <asm/irq.h> 34 #include <asm/time.h> 35 #include <asm/prom.h> 36 #include <sysdev/fsl_soc.h> 37 #include <mm/mmu_decl.h> 38 #include <asm/cpm2.h> 39 40 extern void init_fcc_ioports(struct fs_platform_info*); 41 extern void init_fec_ioports(struct fs_platform_info*); 42 extern void init_smc_ioports(struct fs_uart_platform_info*); 43 static phys_addr_t immrbase = -1; 44 45 phys_addr_t get_immrbase(void) 46 { 47 struct device_node *soc; 48 49 if (immrbase != -1) 50 return immrbase; 51 52 soc = of_find_node_by_type(NULL, "soc"); 53 if (soc) { 54 unsigned int size; 55 const void *prop = get_property(soc, "reg", &size); 56 57 if (prop) 58 immrbase = of_translate_address(soc, prop); 59 of_node_put(soc); 60 }; 61 62 return immrbase; 63 } 64 65 EXPORT_SYMBOL(get_immrbase); 66 67 #if defined(CONFIG_CPM2) || defined(CONFIG_8xx) 68 69 static u32 brgfreq = -1; 70 71 u32 get_brgfreq(void) 72 { 73 struct device_node *node; 74 75 if (brgfreq != -1) 76 return brgfreq; 77 78 node = of_find_node_by_type(NULL, "cpm"); 79 if (node) { 80 unsigned int size; 81 const unsigned int *prop = get_property(node, "brg-frequency", 82 &size); 83 84 if (prop) 85 brgfreq = *prop; 86 of_node_put(node); 87 }; 88 89 return brgfreq; 90 } 91 92 EXPORT_SYMBOL(get_brgfreq); 93 94 static u32 fs_baudrate = -1; 95 96 u32 get_baudrate(void) 97 { 98 struct device_node *node; 99 100 if (fs_baudrate != -1) 101 return fs_baudrate; 102 103 node = of_find_node_by_type(NULL, "serial"); 104 if (node) { 105 unsigned int size; 106 const unsigned int *prop = get_property(node, "current-speed", 107 &size); 108 109 if (prop) 110 fs_baudrate = *prop; 111 of_node_put(node); 112 }; 113 114 return fs_baudrate; 115 } 116 117 EXPORT_SYMBOL(get_baudrate); 118 #endif /* CONFIG_CPM2 */ 119 120 static int __init gfar_mdio_of_init(void) 121 { 122 struct device_node *np; 123 unsigned int i; 124 struct platform_device *mdio_dev; 125 struct resource res; 126 int ret; 127 128 for (np = NULL, i = 0; 129 (np = of_find_compatible_node(np, "mdio", "gianfar")) != NULL; 130 i++) { 131 int k; 132 struct device_node *child = NULL; 133 struct gianfar_mdio_data mdio_data; 134 135 memset(&res, 0, sizeof(res)); 136 memset(&mdio_data, 0, sizeof(mdio_data)); 137 138 ret = of_address_to_resource(np, 0, &res); 139 if (ret) 140 goto err; 141 142 mdio_dev = 143 platform_device_register_simple("fsl-gianfar_mdio", 144 res.start, &res, 1); 145 if (IS_ERR(mdio_dev)) { 146 ret = PTR_ERR(mdio_dev); 147 goto err; 148 } 149 150 for (k = 0; k < 32; k++) 151 mdio_data.irq[k] = PHY_POLL; 152 153 while ((child = of_get_next_child(np, child)) != NULL) { 154 int irq = irq_of_parse_and_map(child, 0); 155 if (irq != NO_IRQ) { 156 const u32 *id = get_property(child, "reg", NULL); 157 mdio_data.irq[*id] = irq; 158 } 159 } 160 161 ret = 162 platform_device_add_data(mdio_dev, &mdio_data, 163 sizeof(struct gianfar_mdio_data)); 164 if (ret) 165 goto unreg; 166 } 167 168 return 0; 169 170 unreg: 171 platform_device_unregister(mdio_dev); 172 err: 173 return ret; 174 } 175 176 arch_initcall(gfar_mdio_of_init); 177 178 static const char *gfar_tx_intr = "tx"; 179 static const char *gfar_rx_intr = "rx"; 180 static const char *gfar_err_intr = "error"; 181 182 183 static int __init gfar_of_init(void) 184 { 185 struct device_node *np; 186 unsigned int i; 187 struct platform_device *gfar_dev; 188 struct resource res; 189 int ret; 190 191 for (np = NULL, i = 0; 192 (np = of_find_compatible_node(np, "network", "gianfar")) != NULL; 193 i++) { 194 struct resource r[4]; 195 struct device_node *phy, *mdio; 196 struct gianfar_platform_data gfar_data; 197 const unsigned int *id; 198 const char *model; 199 const void *mac_addr; 200 const phandle *ph; 201 int n_res = 2; 202 203 memset(r, 0, sizeof(r)); 204 memset(&gfar_data, 0, sizeof(gfar_data)); 205 206 ret = of_address_to_resource(np, 0, &r[0]); 207 if (ret) 208 goto err; 209 210 of_irq_to_resource(np, 0, &r[1]); 211 212 model = get_property(np, "model", NULL); 213 214 /* If we aren't the FEC we have multiple interrupts */ 215 if (model && strcasecmp(model, "FEC")) { 216 r[1].name = gfar_tx_intr; 217 218 r[2].name = gfar_rx_intr; 219 of_irq_to_resource(np, 1, &r[2]); 220 221 r[3].name = gfar_err_intr; 222 of_irq_to_resource(np, 2, &r[3]); 223 224 n_res += 2; 225 } 226 227 gfar_dev = 228 platform_device_register_simple("fsl-gianfar", i, &r[0], 229 n_res); 230 231 if (IS_ERR(gfar_dev)) { 232 ret = PTR_ERR(gfar_dev); 233 goto err; 234 } 235 236 mac_addr = get_property(np, "local-mac-address", NULL); 237 if (mac_addr == NULL) 238 mac_addr = get_property(np, "mac-address", NULL); 239 if (mac_addr == NULL) { 240 /* Obsolete */ 241 mac_addr = get_property(np, "address", NULL); 242 } 243 244 if (mac_addr) 245 memcpy(gfar_data.mac_addr, mac_addr, 6); 246 247 if (model && !strcasecmp(model, "TSEC")) 248 gfar_data.device_flags = 249 FSL_GIANFAR_DEV_HAS_GIGABIT | 250 FSL_GIANFAR_DEV_HAS_COALESCE | 251 FSL_GIANFAR_DEV_HAS_RMON | 252 FSL_GIANFAR_DEV_HAS_MULTI_INTR; 253 if (model && !strcasecmp(model, "eTSEC")) 254 gfar_data.device_flags = 255 FSL_GIANFAR_DEV_HAS_GIGABIT | 256 FSL_GIANFAR_DEV_HAS_COALESCE | 257 FSL_GIANFAR_DEV_HAS_RMON | 258 FSL_GIANFAR_DEV_HAS_MULTI_INTR | 259 FSL_GIANFAR_DEV_HAS_CSUM | 260 FSL_GIANFAR_DEV_HAS_VLAN | 261 FSL_GIANFAR_DEV_HAS_EXTENDED_HASH; 262 263 ph = get_property(np, "phy-handle", NULL); 264 phy = of_find_node_by_phandle(*ph); 265 266 if (phy == NULL) { 267 ret = -ENODEV; 268 goto unreg; 269 } 270 271 mdio = of_get_parent(phy); 272 273 id = get_property(phy, "reg", NULL); 274 ret = of_address_to_resource(mdio, 0, &res); 275 if (ret) { 276 of_node_put(phy); 277 of_node_put(mdio); 278 goto unreg; 279 } 280 281 gfar_data.phy_id = *id; 282 gfar_data.bus_id = res.start; 283 284 of_node_put(phy); 285 of_node_put(mdio); 286 287 ret = 288 platform_device_add_data(gfar_dev, &gfar_data, 289 sizeof(struct 290 gianfar_platform_data)); 291 if (ret) 292 goto unreg; 293 } 294 295 return 0; 296 297 unreg: 298 platform_device_unregister(gfar_dev); 299 err: 300 return ret; 301 } 302 303 arch_initcall(gfar_of_init); 304 305 static int __init fsl_i2c_of_init(void) 306 { 307 struct device_node *np; 308 unsigned int i; 309 struct platform_device *i2c_dev; 310 int ret; 311 312 for (np = NULL, i = 0; 313 (np = of_find_compatible_node(np, "i2c", "fsl-i2c")) != NULL; 314 i++) { 315 struct resource r[2]; 316 struct fsl_i2c_platform_data i2c_data; 317 const unsigned char *flags = NULL; 318 319 memset(&r, 0, sizeof(r)); 320 memset(&i2c_data, 0, sizeof(i2c_data)); 321 322 ret = of_address_to_resource(np, 0, &r[0]); 323 if (ret) 324 goto err; 325 326 of_irq_to_resource(np, 0, &r[1]); 327 328 i2c_dev = platform_device_register_simple("fsl-i2c", i, r, 2); 329 if (IS_ERR(i2c_dev)) { 330 ret = PTR_ERR(i2c_dev); 331 goto err; 332 } 333 334 i2c_data.device_flags = 0; 335 flags = get_property(np, "dfsrr", NULL); 336 if (flags) 337 i2c_data.device_flags |= FSL_I2C_DEV_SEPARATE_DFSRR; 338 339 flags = get_property(np, "fsl5200-clocking", NULL); 340 if (flags) 341 i2c_data.device_flags |= FSL_I2C_DEV_CLOCK_5200; 342 343 ret = 344 platform_device_add_data(i2c_dev, &i2c_data, 345 sizeof(struct 346 fsl_i2c_platform_data)); 347 if (ret) 348 goto unreg; 349 } 350 351 return 0; 352 353 unreg: 354 platform_device_unregister(i2c_dev); 355 err: 356 return ret; 357 } 358 359 arch_initcall(fsl_i2c_of_init); 360 361 #ifdef CONFIG_PPC_83xx 362 static int __init mpc83xx_wdt_init(void) 363 { 364 struct resource r; 365 struct device_node *soc, *np; 366 struct platform_device *dev; 367 const unsigned int *freq; 368 int ret; 369 370 np = of_find_compatible_node(NULL, "watchdog", "mpc83xx_wdt"); 371 372 if (!np) { 373 ret = -ENODEV; 374 goto nodev; 375 } 376 377 soc = of_find_node_by_type(NULL, "soc"); 378 379 if (!soc) { 380 ret = -ENODEV; 381 goto nosoc; 382 } 383 384 freq = get_property(soc, "bus-frequency", NULL); 385 if (!freq) { 386 ret = -ENODEV; 387 goto err; 388 } 389 390 memset(&r, 0, sizeof(r)); 391 392 ret = of_address_to_resource(np, 0, &r); 393 if (ret) 394 goto err; 395 396 dev = platform_device_register_simple("mpc83xx_wdt", 0, &r, 1); 397 if (IS_ERR(dev)) { 398 ret = PTR_ERR(dev); 399 goto err; 400 } 401 402 ret = platform_device_add_data(dev, freq, sizeof(int)); 403 if (ret) 404 goto unreg; 405 406 of_node_put(soc); 407 of_node_put(np); 408 409 return 0; 410 411 unreg: 412 platform_device_unregister(dev); 413 err: 414 of_node_put(soc); 415 nosoc: 416 of_node_put(np); 417 nodev: 418 return ret; 419 } 420 421 arch_initcall(mpc83xx_wdt_init); 422 #endif 423 424 static enum fsl_usb2_phy_modes determine_usb_phy(const char *phy_type) 425 { 426 if (!phy_type) 427 return FSL_USB2_PHY_NONE; 428 if (!strcasecmp(phy_type, "ulpi")) 429 return FSL_USB2_PHY_ULPI; 430 if (!strcasecmp(phy_type, "utmi")) 431 return FSL_USB2_PHY_UTMI; 432 if (!strcasecmp(phy_type, "utmi_wide")) 433 return FSL_USB2_PHY_UTMI_WIDE; 434 if (!strcasecmp(phy_type, "serial")) 435 return FSL_USB2_PHY_SERIAL; 436 437 return FSL_USB2_PHY_NONE; 438 } 439 440 static int __init fsl_usb_of_init(void) 441 { 442 struct device_node *np; 443 unsigned int i; 444 struct platform_device *usb_dev_mph = NULL, *usb_dev_dr = NULL; 445 int ret; 446 447 for (np = NULL, i = 0; 448 (np = of_find_compatible_node(np, "usb", "fsl-usb2-mph")) != NULL; 449 i++) { 450 struct resource r[2]; 451 struct fsl_usb2_platform_data usb_data; 452 const unsigned char *prop = NULL; 453 454 memset(&r, 0, sizeof(r)); 455 memset(&usb_data, 0, sizeof(usb_data)); 456 457 ret = of_address_to_resource(np, 0, &r[0]); 458 if (ret) 459 goto err; 460 461 of_irq_to_resource(np, 0, &r[1]); 462 463 usb_dev_mph = 464 platform_device_register_simple("fsl-ehci", i, r, 2); 465 if (IS_ERR(usb_dev_mph)) { 466 ret = PTR_ERR(usb_dev_mph); 467 goto err; 468 } 469 470 usb_dev_mph->dev.coherent_dma_mask = 0xffffffffUL; 471 usb_dev_mph->dev.dma_mask = &usb_dev_mph->dev.coherent_dma_mask; 472 473 usb_data.operating_mode = FSL_USB2_MPH_HOST; 474 475 prop = get_property(np, "port0", NULL); 476 if (prop) 477 usb_data.port_enables |= FSL_USB2_PORT0_ENABLED; 478 479 prop = get_property(np, "port1", NULL); 480 if (prop) 481 usb_data.port_enables |= FSL_USB2_PORT1_ENABLED; 482 483 prop = get_property(np, "phy_type", NULL); 484 usb_data.phy_mode = determine_usb_phy(prop); 485 486 ret = 487 platform_device_add_data(usb_dev_mph, &usb_data, 488 sizeof(struct 489 fsl_usb2_platform_data)); 490 if (ret) 491 goto unreg_mph; 492 } 493 494 for (np = NULL; 495 (np = of_find_compatible_node(np, "usb", "fsl-usb2-dr")) != NULL; 496 i++) { 497 struct resource r[2]; 498 struct fsl_usb2_platform_data usb_data; 499 const unsigned char *prop = NULL; 500 501 memset(&r, 0, sizeof(r)); 502 memset(&usb_data, 0, sizeof(usb_data)); 503 504 ret = of_address_to_resource(np, 0, &r[0]); 505 if (ret) 506 goto unreg_mph; 507 508 of_irq_to_resource(np, 0, &r[1]); 509 510 usb_dev_dr = 511 platform_device_register_simple("fsl-ehci", i, r, 2); 512 if (IS_ERR(usb_dev_dr)) { 513 ret = PTR_ERR(usb_dev_dr); 514 goto err; 515 } 516 517 usb_dev_dr->dev.coherent_dma_mask = 0xffffffffUL; 518 usb_dev_dr->dev.dma_mask = &usb_dev_dr->dev.coherent_dma_mask; 519 520 usb_data.operating_mode = FSL_USB2_DR_HOST; 521 522 prop = get_property(np, "phy_type", NULL); 523 usb_data.phy_mode = determine_usb_phy(prop); 524 525 ret = 526 platform_device_add_data(usb_dev_dr, &usb_data, 527 sizeof(struct 528 fsl_usb2_platform_data)); 529 if (ret) 530 goto unreg_dr; 531 } 532 return 0; 533 534 unreg_dr: 535 if (usb_dev_dr) 536 platform_device_unregister(usb_dev_dr); 537 unreg_mph: 538 if (usb_dev_mph) 539 platform_device_unregister(usb_dev_mph); 540 err: 541 return ret; 542 } 543 544 arch_initcall(fsl_usb_of_init); 545 546 #ifdef CONFIG_CPM2 547 548 extern void init_scc_ioports(struct fs_uart_platform_info*); 549 550 static const char fcc_regs[] = "fcc_regs"; 551 static const char fcc_regs_c[] = "fcc_regs_c"; 552 static const char fcc_pram[] = "fcc_pram"; 553 static char bus_id[9][BUS_ID_SIZE]; 554 555 static int __init fs_enet_of_init(void) 556 { 557 struct device_node *np; 558 unsigned int i; 559 struct platform_device *fs_enet_dev; 560 struct resource res; 561 int ret; 562 563 for (np = NULL, i = 0; 564 (np = of_find_compatible_node(np, "network", "fs_enet")) != NULL; 565 i++) { 566 struct resource r[4]; 567 struct device_node *phy, *mdio; 568 struct fs_platform_info fs_enet_data; 569 const unsigned int *id, *phy_addr, *phy_irq; 570 const void *mac_addr; 571 const phandle *ph; 572 const char *model; 573 574 memset(r, 0, sizeof(r)); 575 memset(&fs_enet_data, 0, sizeof(fs_enet_data)); 576 577 ret = of_address_to_resource(np, 0, &r[0]); 578 if (ret) 579 goto err; 580 r[0].name = fcc_regs; 581 582 ret = of_address_to_resource(np, 1, &r[1]); 583 if (ret) 584 goto err; 585 r[1].name = fcc_pram; 586 587 ret = of_address_to_resource(np, 2, &r[2]); 588 if (ret) 589 goto err; 590 r[2].name = fcc_regs_c; 591 fs_enet_data.fcc_regs_c = r[2].start; 592 593 of_irq_to_resource(np, 0, &r[3]); 594 595 fs_enet_dev = 596 platform_device_register_simple("fsl-cpm-fcc", i, &r[0], 4); 597 598 if (IS_ERR(fs_enet_dev)) { 599 ret = PTR_ERR(fs_enet_dev); 600 goto err; 601 } 602 603 model = get_property(np, "model", NULL); 604 if (model == NULL) { 605 ret = -ENODEV; 606 goto unreg; 607 } 608 609 mac_addr = get_property(np, "mac-address", NULL); 610 memcpy(fs_enet_data.macaddr, mac_addr, 6); 611 612 ph = get_property(np, "phy-handle", NULL); 613 phy = of_find_node_by_phandle(*ph); 614 615 if (phy == NULL) { 616 ret = -ENODEV; 617 goto unreg; 618 } 619 620 phy_addr = get_property(phy, "reg", NULL); 621 fs_enet_data.phy_addr = *phy_addr; 622 623 phy_irq = get_property(phy, "interrupts", NULL); 624 625 id = get_property(np, "device-id", NULL); 626 fs_enet_data.fs_no = *id; 627 strcpy(fs_enet_data.fs_type, model); 628 629 mdio = of_get_parent(phy); 630 ret = of_address_to_resource(mdio, 0, &res); 631 if (ret) { 632 of_node_put(phy); 633 of_node_put(mdio); 634 goto unreg; 635 } 636 637 fs_enet_data.clk_rx = *((u32 *) get_property(np, "rx-clock", NULL)); 638 fs_enet_data.clk_tx = *((u32 *) get_property(np, "tx-clock", NULL)); 639 640 if (strstr(model, "FCC")) { 641 int fcc_index = *id - 1; 642 const unsigned char *mdio_bb_prop; 643 644 fs_enet_data.dpram_offset = (u32)cpm_dpram_addr(0); 645 fs_enet_data.rx_ring = 32; 646 fs_enet_data.tx_ring = 32; 647 fs_enet_data.rx_copybreak = 240; 648 fs_enet_data.use_napi = 0; 649 fs_enet_data.napi_weight = 17; 650 fs_enet_data.mem_offset = FCC_MEM_OFFSET(fcc_index); 651 fs_enet_data.cp_page = CPM_CR_FCC_PAGE(fcc_index); 652 fs_enet_data.cp_block = CPM_CR_FCC_SBLOCK(fcc_index); 653 654 snprintf((char*)&bus_id[(*id)], BUS_ID_SIZE, "%x:%02x", 655 (u32)res.start, fs_enet_data.phy_addr); 656 fs_enet_data.bus_id = (char*)&bus_id[(*id)]; 657 fs_enet_data.init_ioports = init_fcc_ioports; 658 659 mdio_bb_prop = get_property(phy, "bitbang", NULL); 660 if (mdio_bb_prop) { 661 struct platform_device *fs_enet_mdio_bb_dev; 662 struct fs_mii_bb_platform_info fs_enet_mdio_bb_data; 663 664 fs_enet_mdio_bb_dev = 665 platform_device_register_simple("fsl-bb-mdio", 666 i, NULL, 0); 667 memset(&fs_enet_mdio_bb_data, 0, 668 sizeof(struct fs_mii_bb_platform_info)); 669 fs_enet_mdio_bb_data.mdio_dat.bit = 670 mdio_bb_prop[0]; 671 fs_enet_mdio_bb_data.mdio_dir.bit = 672 mdio_bb_prop[1]; 673 fs_enet_mdio_bb_data.mdc_dat.bit = 674 mdio_bb_prop[2]; 675 fs_enet_mdio_bb_data.mdio_port = 676 mdio_bb_prop[3]; 677 fs_enet_mdio_bb_data.mdc_port = 678 mdio_bb_prop[4]; 679 fs_enet_mdio_bb_data.delay = 680 mdio_bb_prop[5]; 681 682 fs_enet_mdio_bb_data.irq[0] = phy_irq[0]; 683 fs_enet_mdio_bb_data.irq[1] = -1; 684 fs_enet_mdio_bb_data.irq[2] = -1; 685 fs_enet_mdio_bb_data.irq[3] = phy_irq[0]; 686 fs_enet_mdio_bb_data.irq[31] = -1; 687 688 fs_enet_mdio_bb_data.mdio_dat.offset = 689 (u32)&cpm2_immr->im_ioport.iop_pdatc; 690 fs_enet_mdio_bb_data.mdio_dir.offset = 691 (u32)&cpm2_immr->im_ioport.iop_pdirc; 692 fs_enet_mdio_bb_data.mdc_dat.offset = 693 (u32)&cpm2_immr->im_ioport.iop_pdatc; 694 695 ret = platform_device_add_data( 696 fs_enet_mdio_bb_dev, 697 &fs_enet_mdio_bb_data, 698 sizeof(struct fs_mii_bb_platform_info)); 699 if (ret) 700 goto unreg; 701 } 702 703 of_node_put(phy); 704 of_node_put(mdio); 705 706 ret = platform_device_add_data(fs_enet_dev, &fs_enet_data, 707 sizeof(struct 708 fs_platform_info)); 709 if (ret) 710 goto unreg; 711 } 712 } 713 return 0; 714 715 unreg: 716 platform_device_unregister(fs_enet_dev); 717 err: 718 return ret; 719 } 720 721 arch_initcall(fs_enet_of_init); 722 723 static const char scc_regs[] = "regs"; 724 static const char scc_pram[] = "pram"; 725 726 static int __init cpm_uart_of_init(void) 727 { 728 struct device_node *np; 729 unsigned int i; 730 struct platform_device *cpm_uart_dev; 731 int ret; 732 733 for (np = NULL, i = 0; 734 (np = of_find_compatible_node(np, "serial", "cpm_uart")) != NULL; 735 i++) { 736 struct resource r[3]; 737 struct fs_uart_platform_info cpm_uart_data; 738 const int *id; 739 const char *model; 740 741 memset(r, 0, sizeof(r)); 742 memset(&cpm_uart_data, 0, sizeof(cpm_uart_data)); 743 744 ret = of_address_to_resource(np, 0, &r[0]); 745 if (ret) 746 goto err; 747 748 r[0].name = scc_regs; 749 750 ret = of_address_to_resource(np, 1, &r[1]); 751 if (ret) 752 goto err; 753 r[1].name = scc_pram; 754 755 of_irq_to_resource(np, 0, &r[2]); 756 757 cpm_uart_dev = 758 platform_device_register_simple("fsl-cpm-scc:uart", i, &r[0], 3); 759 760 if (IS_ERR(cpm_uart_dev)) { 761 ret = PTR_ERR(cpm_uart_dev); 762 goto err; 763 } 764 765 id = get_property(np, "device-id", NULL); 766 cpm_uart_data.fs_no = *id; 767 768 model = (char*)get_property(np, "model", NULL); 769 strcpy(cpm_uart_data.fs_type, model); 770 771 cpm_uart_data.uart_clk = ppc_proc_freq; 772 773 cpm_uart_data.tx_num_fifo = 4; 774 cpm_uart_data.tx_buf_size = 32; 775 cpm_uart_data.rx_num_fifo = 4; 776 cpm_uart_data.rx_buf_size = 32; 777 cpm_uart_data.clk_rx = *((u32 *) get_property(np, "rx-clock", NULL)); 778 cpm_uart_data.clk_tx = *((u32 *) get_property(np, "tx-clock", NULL)); 779 780 ret = 781 platform_device_add_data(cpm_uart_dev, &cpm_uart_data, 782 sizeof(struct 783 fs_uart_platform_info)); 784 if (ret) 785 goto unreg; 786 } 787 788 return 0; 789 790 unreg: 791 platform_device_unregister(cpm_uart_dev); 792 err: 793 return ret; 794 } 795 796 arch_initcall(cpm_uart_of_init); 797 #endif /* CONFIG_CPM2 */ 798 799 #ifdef CONFIG_8xx 800 801 extern void init_scc_ioports(struct fs_platform_info*); 802 extern int platform_device_skip(char *model, int id); 803 804 static int __init fs_enet_mdio_of_init(void) 805 { 806 struct device_node *np; 807 unsigned int i; 808 struct platform_device *mdio_dev; 809 struct resource res; 810 int ret; 811 812 for (np = NULL, i = 0; 813 (np = of_find_compatible_node(np, "mdio", "fs_enet")) != NULL; 814 i++) { 815 struct fs_mii_fec_platform_info mdio_data; 816 817 memset(&res, 0, sizeof(res)); 818 memset(&mdio_data, 0, sizeof(mdio_data)); 819 820 ret = of_address_to_resource(np, 0, &res); 821 if (ret) 822 goto err; 823 824 mdio_dev = 825 platform_device_register_simple("fsl-cpm-fec-mdio", 826 res.start, &res, 1); 827 if (IS_ERR(mdio_dev)) { 828 ret = PTR_ERR(mdio_dev); 829 goto err; 830 } 831 832 mdio_data.mii_speed = ((((ppc_proc_freq + 4999999) / 2500000) / 2) & 0x3F) << 1; 833 834 ret = 835 platform_device_add_data(mdio_dev, &mdio_data, 836 sizeof(struct fs_mii_fec_platform_info)); 837 if (ret) 838 goto unreg; 839 } 840 return 0; 841 842 unreg: 843 platform_device_unregister(mdio_dev); 844 err: 845 return ret; 846 } 847 848 arch_initcall(fs_enet_mdio_of_init); 849 850 static const char *enet_regs = "regs"; 851 static const char *enet_pram = "pram"; 852 static const char *enet_irq = "interrupt"; 853 static char bus_id[9][BUS_ID_SIZE]; 854 855 static int __init fs_enet_of_init(void) 856 { 857 struct device_node *np; 858 unsigned int i; 859 struct platform_device *fs_enet_dev = NULL; 860 struct resource res; 861 int ret; 862 863 for (np = NULL, i = 0; 864 (np = of_find_compatible_node(np, "network", "fs_enet")) != NULL; 865 i++) { 866 struct resource r[4]; 867 struct device_node *phy = NULL, *mdio = NULL; 868 struct fs_platform_info fs_enet_data; 869 unsigned int *id, *phy_addr; 870 void *mac_addr; 871 phandle *ph; 872 char *model; 873 874 memset(r, 0, sizeof(r)); 875 memset(&fs_enet_data, 0, sizeof(fs_enet_data)); 876 877 model = (char *)get_property(np, "model", NULL); 878 if (model == NULL) { 879 ret = -ENODEV; 880 goto unreg; 881 } 882 883 id = (u32 *) get_property(np, "device-id", NULL); 884 fs_enet_data.fs_no = *id; 885 886 if (platform_device_skip(model, *id)) 887 continue; 888 889 ret = of_address_to_resource(np, 0, &r[0]); 890 if (ret) 891 goto err; 892 r[0].name = enet_regs; 893 894 mac_addr = (void *)get_property(np, "mac-address", NULL); 895 memcpy(fs_enet_data.macaddr, mac_addr, 6); 896 897 ph = (phandle *) get_property(np, "phy-handle", NULL); 898 if (ph != NULL) 899 phy = of_find_node_by_phandle(*ph); 900 901 if (phy != NULL) { 902 phy_addr = (u32 *) get_property(phy, "reg", NULL); 903 fs_enet_data.phy_addr = *phy_addr; 904 fs_enet_data.has_phy = 1; 905 906 mdio = of_get_parent(phy); 907 ret = of_address_to_resource(mdio, 0, &res); 908 if (ret) { 909 of_node_put(phy); 910 of_node_put(mdio); 911 goto unreg; 912 } 913 } 914 915 model = (char*)get_property(np, "model", NULL); 916 strcpy(fs_enet_data.fs_type, model); 917 918 if (strstr(model, "FEC")) { 919 r[1].start = r[1].end = irq_of_parse_and_map(np, 0); 920 r[1].flags = IORESOURCE_IRQ; 921 r[1].name = enet_irq; 922 923 fs_enet_dev = 924 platform_device_register_simple("fsl-cpm-fec", i, &r[0], 2); 925 926 if (IS_ERR(fs_enet_dev)) { 927 ret = PTR_ERR(fs_enet_dev); 928 goto err; 929 } 930 931 fs_enet_data.rx_ring = 128; 932 fs_enet_data.tx_ring = 16; 933 fs_enet_data.rx_copybreak = 240; 934 fs_enet_data.use_napi = 1; 935 fs_enet_data.napi_weight = 17; 936 937 snprintf((char*)&bus_id[i], BUS_ID_SIZE, "%x:%02x", 938 (u32)res.start, fs_enet_data.phy_addr); 939 fs_enet_data.bus_id = (char*)&bus_id[i]; 940 fs_enet_data.init_ioports = init_fec_ioports; 941 } 942 if (strstr(model, "SCC")) { 943 ret = of_address_to_resource(np, 1, &r[1]); 944 if (ret) 945 goto err; 946 r[1].name = enet_pram; 947 948 r[2].start = r[2].end = irq_of_parse_and_map(np, 0); 949 r[2].flags = IORESOURCE_IRQ; 950 r[2].name = enet_irq; 951 952 fs_enet_dev = 953 platform_device_register_simple("fsl-cpm-scc", i, &r[0], 3); 954 955 if (IS_ERR(fs_enet_dev)) { 956 ret = PTR_ERR(fs_enet_dev); 957 goto err; 958 } 959 960 fs_enet_data.rx_ring = 64; 961 fs_enet_data.tx_ring = 8; 962 fs_enet_data.rx_copybreak = 240; 963 fs_enet_data.use_napi = 1; 964 fs_enet_data.napi_weight = 17; 965 966 snprintf((char*)&bus_id[i], BUS_ID_SIZE, "%s", "fixed@10:1"); 967 fs_enet_data.bus_id = (char*)&bus_id[i]; 968 fs_enet_data.init_ioports = init_scc_ioports; 969 } 970 971 of_node_put(phy); 972 of_node_put(mdio); 973 974 ret = platform_device_add_data(fs_enet_dev, &fs_enet_data, 975 sizeof(struct 976 fs_platform_info)); 977 if (ret) 978 goto unreg; 979 } 980 return 0; 981 982 unreg: 983 platform_device_unregister(fs_enet_dev); 984 err: 985 return ret; 986 } 987 988 arch_initcall(fs_enet_of_init); 989 990 991 static const char *smc_regs = "regs"; 992 static const char *smc_pram = "pram"; 993 994 static int __init cpm_smc_uart_of_init(void) 995 { 996 struct device_node *np; 997 unsigned int i; 998 struct platform_device *cpm_uart_dev; 999 int ret; 1000 1001 for (np = NULL, i = 0; 1002 (np = of_find_compatible_node(np, "serial", "cpm_uart")) != NULL; 1003 i++) { 1004 struct resource r[3]; 1005 struct fs_uart_platform_info cpm_uart_data; 1006 int *id; 1007 char *model; 1008 1009 memset(r, 0, sizeof(r)); 1010 memset(&cpm_uart_data, 0, sizeof(cpm_uart_data)); 1011 1012 ret = of_address_to_resource(np, 0, &r[0]); 1013 if (ret) 1014 goto err; 1015 1016 r[0].name = smc_regs; 1017 1018 ret = of_address_to_resource(np, 1, &r[1]); 1019 if (ret) 1020 goto err; 1021 r[1].name = smc_pram; 1022 1023 r[2].start = r[2].end = irq_of_parse_and_map(np, 0); 1024 r[2].flags = IORESOURCE_IRQ; 1025 1026 cpm_uart_dev = 1027 platform_device_register_simple("fsl-cpm-smc:uart", i, &r[0], 3); 1028 1029 if (IS_ERR(cpm_uart_dev)) { 1030 ret = PTR_ERR(cpm_uart_dev); 1031 goto err; 1032 } 1033 1034 model = (char*)get_property(np, "model", NULL); 1035 strcpy(cpm_uart_data.fs_type, model); 1036 1037 id = (int*)get_property(np, "device-id", NULL); 1038 cpm_uart_data.fs_no = *id; 1039 cpm_uart_data.uart_clk = ppc_proc_freq; 1040 1041 cpm_uart_data.tx_num_fifo = 4; 1042 cpm_uart_data.tx_buf_size = 32; 1043 cpm_uart_data.rx_num_fifo = 4; 1044 cpm_uart_data.rx_buf_size = 32; 1045 1046 ret = 1047 platform_device_add_data(cpm_uart_dev, &cpm_uart_data, 1048 sizeof(struct 1049 fs_uart_platform_info)); 1050 if (ret) 1051 goto unreg; 1052 } 1053 1054 return 0; 1055 1056 unreg: 1057 platform_device_unregister(cpm_uart_dev); 1058 err: 1059 return ret; 1060 } 1061 1062 arch_initcall(cpm_smc_uart_of_init); 1063 1064 #endif /* CONFIG_8xx */ 1065