1/* 2 * Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp. 3 * <benh@kernel.crashing.org> 4 * and Arnd Bergmann, IBM Corp. 5 * Merged from powerpc/kernel/of_platform.c and 6 * sparc{,64}/kernel/of_device.c by Stephen Rothwell 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * as published by the Free Software Foundation; either version 11 * 2 of the License, or (at your option) any later version. 12 * 13 */ 14#include <linux/errno.h> 15#include <linux/module.h> 16#include <linux/device.h> 17#include <linux/dma-mapping.h> 18#include <linux/slab.h> 19#include <linux/of_address.h> 20#include <linux/of_device.h> 21#include <linux/of_irq.h> 22#include <linux/of_platform.h> 23#include <linux/platform_device.h> 24 25static int of_dev_node_match(struct device *dev, void *data) 26{ 27 return dev->of_node == data; 28} 29 30/** 31 * of_find_device_by_node - Find the platform_device associated with a node 32 * @np: Pointer to device tree node 33 * 34 * Returns platform_device pointer, or NULL if not found 35 */ 36struct platform_device *of_find_device_by_node(struct device_node *np) 37{ 38 struct device *dev; 39 40 dev = bus_find_device(&platform_bus_type, NULL, np, of_dev_node_match); 41 return dev ? to_platform_device(dev) : NULL; 42} 43EXPORT_SYMBOL(of_find_device_by_node); 44 45static int platform_driver_probe_shim(struct platform_device *pdev) 46{ 47 struct platform_driver *pdrv; 48 struct of_platform_driver *ofpdrv; 49 const struct of_device_id *match; 50 51 pdrv = container_of(pdev->dev.driver, struct platform_driver, driver); 52 ofpdrv = container_of(pdrv, struct of_platform_driver, platform_driver); 53 54 /* There is an unlikely chance that an of_platform driver might match 55 * on a non-OF platform device. If so, then of_match_device() will 56 * come up empty. Return -EINVAL in this case so other drivers get 57 * the chance to bind. */ 58 match = of_match_device(pdev->dev.driver->of_match_table, &pdev->dev); 59 return match ? ofpdrv->probe(pdev, match) : -EINVAL; 60} 61 62static void platform_driver_shutdown_shim(struct platform_device *pdev) 63{ 64 struct platform_driver *pdrv; 65 struct of_platform_driver *ofpdrv; 66 67 pdrv = container_of(pdev->dev.driver, struct platform_driver, driver); 68 ofpdrv = container_of(pdrv, struct of_platform_driver, platform_driver); 69 ofpdrv->shutdown(pdev); 70} 71 72/** 73 * of_register_platform_driver 74 */ 75int of_register_platform_driver(struct of_platform_driver *drv) 76{ 77 char *of_name; 78 79 /* setup of_platform_driver to platform_driver adaptors */ 80 drv->platform_driver.driver = drv->driver; 81 82 /* Prefix the driver name with 'of:' to avoid namespace collisions 83 * and bogus matches. There are some drivers in the tree that 84 * register both an of_platform_driver and a platform_driver with 85 * the same name. This is a temporary measure until they are all 86 * cleaned up --gcl July 29, 2010 */ 87 of_name = kmalloc(strlen(drv->driver.name) + 5, GFP_KERNEL); 88 if (!of_name) 89 return -ENOMEM; 90 sprintf(of_name, "of:%s", drv->driver.name); 91 drv->platform_driver.driver.name = of_name; 92 93 if (drv->probe) 94 drv->platform_driver.probe = platform_driver_probe_shim; 95 drv->platform_driver.remove = drv->remove; 96 if (drv->shutdown) 97 drv->platform_driver.shutdown = platform_driver_shutdown_shim; 98 drv->platform_driver.suspend = drv->suspend; 99 drv->platform_driver.resume = drv->resume; 100 101 return platform_driver_register(&drv->platform_driver); 102} 103EXPORT_SYMBOL(of_register_platform_driver); 104 105void of_unregister_platform_driver(struct of_platform_driver *drv) 106{ 107 platform_driver_unregister(&drv->platform_driver); 108 kfree(drv->platform_driver.driver.name); 109 drv->platform_driver.driver.name = NULL; 110} 111EXPORT_SYMBOL(of_unregister_platform_driver); 112 113#if defined(CONFIG_PPC_DCR) 114#include <asm/dcr.h> 115#endif 116 117extern struct device_attribute of_platform_device_attrs[]; 118 119static int of_platform_bus_match(struct device *dev, struct device_driver *drv) 120{ 121 const struct of_device_id *matches = drv->of_match_table; 122 123 if (!matches) 124 return 0; 125 126 return of_match_device(matches, dev) != NULL; 127} 128 129static int of_platform_device_probe(struct device *dev) 130{ 131 int error = -ENODEV; 132 struct of_platform_driver *drv; 133 struct platform_device *of_dev; 134 const struct of_device_id *match; 135 136 drv = to_of_platform_driver(dev->driver); 137 of_dev = to_platform_device(dev); 138 139 if (!drv->probe) 140 return error; 141 142 of_dev_get(of_dev); 143 144 match = of_match_device(drv->driver.of_match_table, dev); 145 if (match) 146 error = drv->probe(of_dev, match); 147 if (error) 148 of_dev_put(of_dev); 149 150 return error; 151} 152 153static int of_platform_device_remove(struct device *dev) 154{ 155 struct platform_device *of_dev = to_platform_device(dev); 156 struct of_platform_driver *drv = to_of_platform_driver(dev->driver); 157 158 if (dev->driver && drv->remove) 159 drv->remove(of_dev); 160 return 0; 161} 162 163static void of_platform_device_shutdown(struct device *dev) 164{ 165 struct platform_device *of_dev = to_platform_device(dev); 166 struct of_platform_driver *drv = to_of_platform_driver(dev->driver); 167 168 if (dev->driver && drv->shutdown) 169 drv->shutdown(of_dev); 170} 171 172#ifdef CONFIG_PM_SLEEP 173 174static int of_platform_legacy_suspend(struct device *dev, pm_message_t mesg) 175{ 176 struct platform_device *of_dev = to_platform_device(dev); 177 struct of_platform_driver *drv = to_of_platform_driver(dev->driver); 178 int ret = 0; 179 180 if (dev->driver && drv->suspend) 181 ret = drv->suspend(of_dev, mesg); 182 return ret; 183} 184 185static int of_platform_legacy_resume(struct device *dev) 186{ 187 struct platform_device *of_dev = to_platform_device(dev); 188 struct of_platform_driver *drv = to_of_platform_driver(dev->driver); 189 int ret = 0; 190 191 if (dev->driver && drv->resume) 192 ret = drv->resume(of_dev); 193 return ret; 194} 195 196static int of_platform_pm_prepare(struct device *dev) 197{ 198 struct device_driver *drv = dev->driver; 199 int ret = 0; 200 201 if (drv && drv->pm && drv->pm->prepare) 202 ret = drv->pm->prepare(dev); 203 204 return ret; 205} 206 207static void of_platform_pm_complete(struct device *dev) 208{ 209 struct device_driver *drv = dev->driver; 210 211 if (drv && drv->pm && drv->pm->complete) 212 drv->pm->complete(dev); 213} 214 215#ifdef CONFIG_SUSPEND 216 217static int of_platform_pm_suspend(struct device *dev) 218{ 219 struct device_driver *drv = dev->driver; 220 int ret = 0; 221 222 if (!drv) 223 return 0; 224 225 if (drv->pm) { 226 if (drv->pm->suspend) 227 ret = drv->pm->suspend(dev); 228 } else { 229 ret = of_platform_legacy_suspend(dev, PMSG_SUSPEND); 230 } 231 232 return ret; 233} 234 235static int of_platform_pm_suspend_noirq(struct device *dev) 236{ 237 struct device_driver *drv = dev->driver; 238 int ret = 0; 239 240 if (!drv) 241 return 0; 242 243 if (drv->pm) { 244 if (drv->pm->suspend_noirq) 245 ret = drv->pm->suspend_noirq(dev); 246 } 247 248 return ret; 249} 250 251static int of_platform_pm_resume(struct device *dev) 252{ 253 struct device_driver *drv = dev->driver; 254 int ret = 0; 255 256 if (!drv) 257 return 0; 258 259 if (drv->pm) { 260 if (drv->pm->resume) 261 ret = drv->pm->resume(dev); 262 } else { 263 ret = of_platform_legacy_resume(dev); 264 } 265 266 return ret; 267} 268 269static int of_platform_pm_resume_noirq(struct device *dev) 270{ 271 struct device_driver *drv = dev->driver; 272 int ret = 0; 273 274 if (!drv) 275 return 0; 276 277 if (drv->pm) { 278 if (drv->pm->resume_noirq) 279 ret = drv->pm->resume_noirq(dev); 280 } 281 282 return ret; 283} 284 285#else /* !CONFIG_SUSPEND */ 286 287#define of_platform_pm_suspend NULL 288#define of_platform_pm_resume NULL 289#define of_platform_pm_suspend_noirq NULL 290#define of_platform_pm_resume_noirq NULL 291 292#endif /* !CONFIG_SUSPEND */ 293 294#ifdef CONFIG_HIBERNATION 295 296static int of_platform_pm_freeze(struct device *dev) 297{ 298 struct device_driver *drv = dev->driver; 299 int ret = 0; 300 301 if (!drv) 302 return 0; 303 304 if (drv->pm) { 305 if (drv->pm->freeze) 306 ret = drv->pm->freeze(dev); 307 } else { 308 ret = of_platform_legacy_suspend(dev, PMSG_FREEZE); 309 } 310 311 return ret; 312} 313 314static int of_platform_pm_freeze_noirq(struct device *dev) 315{ 316 struct device_driver *drv = dev->driver; 317 int ret = 0; 318 319 if (!drv) 320 return 0; 321 322 if (drv->pm) { 323 if (drv->pm->freeze_noirq) 324 ret = drv->pm->freeze_noirq(dev); 325 } 326 327 return ret; 328} 329 330static int of_platform_pm_thaw(struct device *dev) 331{ 332 struct device_driver *drv = dev->driver; 333 int ret = 0; 334 335 if (!drv) 336 return 0; 337 338 if (drv->pm) { 339 if (drv->pm->thaw) 340 ret = drv->pm->thaw(dev); 341 } else { 342 ret = of_platform_legacy_resume(dev); 343 } 344 345 return ret; 346} 347 348static int of_platform_pm_thaw_noirq(struct device *dev) 349{ 350 struct device_driver *drv = dev->driver; 351 int ret = 0; 352 353 if (!drv) 354 return 0; 355 356 if (drv->pm) { 357 if (drv->pm->thaw_noirq) 358 ret = drv->pm->thaw_noirq(dev); 359 } 360 361 return ret; 362} 363 364static int of_platform_pm_poweroff(struct device *dev) 365{ 366 struct device_driver *drv = dev->driver; 367 int ret = 0; 368 369 if (!drv) 370 return 0; 371 372 if (drv->pm) { 373 if (drv->pm->poweroff) 374 ret = drv->pm->poweroff(dev); 375 } else { 376 ret = of_platform_legacy_suspend(dev, PMSG_HIBERNATE); 377 } 378 379 return ret; 380} 381 382static int of_platform_pm_poweroff_noirq(struct device *dev) 383{ 384 struct device_driver *drv = dev->driver; 385 int ret = 0; 386 387 if (!drv) 388 return 0; 389 390 if (drv->pm) { 391 if (drv->pm->poweroff_noirq) 392 ret = drv->pm->poweroff_noirq(dev); 393 } 394 395 return ret; 396} 397 398static int of_platform_pm_restore(struct device *dev) 399{ 400 struct device_driver *drv = dev->driver; 401 int ret = 0; 402 403 if (!drv) 404 return 0; 405 406 if (drv->pm) { 407 if (drv->pm->restore) 408 ret = drv->pm->restore(dev); 409 } else { 410 ret = of_platform_legacy_resume(dev); 411 } 412 413 return ret; 414} 415 416static int of_platform_pm_restore_noirq(struct device *dev) 417{ 418 struct device_driver *drv = dev->driver; 419 int ret = 0; 420 421 if (!drv) 422 return 0; 423 424 if (drv->pm) { 425 if (drv->pm->restore_noirq) 426 ret = drv->pm->restore_noirq(dev); 427 } 428 429 return ret; 430} 431 432#else /* !CONFIG_HIBERNATION */ 433 434#define of_platform_pm_freeze NULL 435#define of_platform_pm_thaw NULL 436#define of_platform_pm_poweroff NULL 437#define of_platform_pm_restore NULL 438#define of_platform_pm_freeze_noirq NULL 439#define of_platform_pm_thaw_noirq NULL 440#define of_platform_pm_poweroff_noirq NULL 441#define of_platform_pm_restore_noirq NULL 442 443#endif /* !CONFIG_HIBERNATION */ 444 445static struct dev_pm_ops of_platform_dev_pm_ops = { 446 .prepare = of_platform_pm_prepare, 447 .complete = of_platform_pm_complete, 448 .suspend = of_platform_pm_suspend, 449 .resume = of_platform_pm_resume, 450 .freeze = of_platform_pm_freeze, 451 .thaw = of_platform_pm_thaw, 452 .poweroff = of_platform_pm_poweroff, 453 .restore = of_platform_pm_restore, 454 .suspend_noirq = of_platform_pm_suspend_noirq, 455 .resume_noirq = of_platform_pm_resume_noirq, 456 .freeze_noirq = of_platform_pm_freeze_noirq, 457 .thaw_noirq = of_platform_pm_thaw_noirq, 458 .poweroff_noirq = of_platform_pm_poweroff_noirq, 459 .restore_noirq = of_platform_pm_restore_noirq, 460}; 461 462#define OF_PLATFORM_PM_OPS_PTR (&of_platform_dev_pm_ops) 463 464#else /* !CONFIG_PM_SLEEP */ 465 466#define OF_PLATFORM_PM_OPS_PTR NULL 467 468#endif /* !CONFIG_PM_SLEEP */ 469 470int of_bus_type_init(struct bus_type *bus, const char *name) 471{ 472 bus->name = name; 473 bus->match = of_platform_bus_match; 474 bus->probe = of_platform_device_probe; 475 bus->remove = of_platform_device_remove; 476 bus->shutdown = of_platform_device_shutdown; 477 bus->dev_attrs = of_platform_device_attrs; 478 bus->pm = OF_PLATFORM_PM_OPS_PTR; 479 return bus_register(bus); 480} 481 482int of_register_driver(struct of_platform_driver *drv, struct bus_type *bus) 483{ 484 /* 485 * Temporary: of_platform_bus used to be distinct from the platform 486 * bus. It isn't anymore, and so drivers on the platform bus need 487 * to be registered in a special way. 488 * 489 * After all of_platform_bus_type drivers are converted to 490 * platform_drivers, this exception can be removed. 491 */ 492 if (bus == &platform_bus_type) 493 return of_register_platform_driver(drv); 494 495 /* register with core */ 496 drv->driver.bus = bus; 497 return driver_register(&drv->driver); 498} 499EXPORT_SYMBOL(of_register_driver); 500 501void of_unregister_driver(struct of_platform_driver *drv) 502{ 503 if (drv->driver.bus == &platform_bus_type) 504 of_unregister_platform_driver(drv); 505 else 506 driver_unregister(&drv->driver); 507} 508EXPORT_SYMBOL(of_unregister_driver); 509 510#if !defined(CONFIG_SPARC) 511/* 512 * The following routines scan a subtree and registers a device for 513 * each applicable node. 514 * 515 * Note: sparc doesn't use these routines because it has a different 516 * mechanism for creating devices from device tree nodes. 517 */ 518 519/** 520 * of_device_make_bus_id - Use the device node data to assign a unique name 521 * @dev: pointer to device structure that is linked to a device tree node 522 * 523 * This routine will first try using either the dcr-reg or the reg property 524 * value to derive a unique name. As a last resort it will use the node 525 * name followed by a unique number. 526 */ 527void of_device_make_bus_id(struct device *dev) 528{ 529 static atomic_t bus_no_reg_magic; 530 struct device_node *node = dev->of_node; 531 const u32 *reg; 532 u64 addr; 533 int magic; 534 535#ifdef CONFIG_PPC_DCR 536 /* 537 * If it's a DCR based device, use 'd' for native DCRs 538 * and 'D' for MMIO DCRs. 539 */ 540 reg = of_get_property(node, "dcr-reg", NULL); 541 if (reg) { 542#ifdef CONFIG_PPC_DCR_NATIVE 543 dev_set_name(dev, "d%x.%s", *reg, node->name); 544#else /* CONFIG_PPC_DCR_NATIVE */ 545 u64 addr = of_translate_dcr_address(node, *reg, NULL); 546 if (addr != OF_BAD_ADDR) { 547 dev_set_name(dev, "D%llx.%s", 548 (unsigned long long)addr, node->name); 549 return; 550 } 551#endif /* !CONFIG_PPC_DCR_NATIVE */ 552 } 553#endif /* CONFIG_PPC_DCR */ 554 555 /* 556 * For MMIO, get the physical address 557 */ 558 reg = of_get_property(node, "reg", NULL); 559 if (reg) { 560 addr = of_translate_address(node, reg); 561 if (addr != OF_BAD_ADDR) { 562 dev_set_name(dev, "%llx.%s", 563 (unsigned long long)addr, node->name); 564 return; 565 } 566 } 567 568 /* 569 * No BusID, use the node name and add a globally incremented 570 * counter (and pray...) 571 */ 572 magic = atomic_add_return(1, &bus_no_reg_magic); 573 dev_set_name(dev, "%s.%d", node->name, magic - 1); 574} 575 576/** 577 * of_device_alloc - Allocate and initialize an of_device 578 * @np: device node to assign to device 579 * @bus_id: Name to assign to the device. May be null to use default name. 580 * @parent: Parent device. 581 */ 582struct platform_device *of_device_alloc(struct device_node *np, 583 const char *bus_id, 584 struct device *parent) 585{ 586 struct platform_device *dev; 587 int rc, i, num_reg = 0, num_irq = 0; 588 struct resource *res, temp_res; 589 590 /* First count how many resources are needed */ 591 while (of_address_to_resource(np, num_reg, &temp_res) == 0) 592 num_reg++; 593 while (of_irq_to_resource(np, num_irq, &temp_res) != NO_IRQ) 594 num_irq++; 595 596 /* Allocate memory for both the struct device and the resource table */ 597 dev = kzalloc(sizeof(*dev) + (sizeof(*res) * (num_reg + num_irq)), 598 GFP_KERNEL); 599 if (!dev) 600 return NULL; 601 res = (struct resource *) &dev[1]; 602 603 /* Populate the resource table */ 604 if (num_irq || num_reg) { 605 dev->num_resources = num_reg + num_irq; 606 dev->resource = res; 607 for (i = 0; i < num_reg; i++, res++) { 608 rc = of_address_to_resource(np, i, res); 609 WARN_ON(rc); 610 } 611 for (i = 0; i < num_irq; i++, res++) { 612 rc = of_irq_to_resource(np, i, res); 613 WARN_ON(rc == NO_IRQ); 614 } 615 } 616 617 dev->dev.of_node = of_node_get(np); 618#if defined(CONFIG_PPC) || defined(CONFIG_MICROBLAZE) 619 dev->dev.dma_mask = &dev->archdata.dma_mask; 620#endif 621 dev->dev.parent = parent; 622 dev->dev.release = of_release_dev; 623 624 if (bus_id) 625 dev_set_name(&dev->dev, "%s", bus_id); 626 else 627 of_device_make_bus_id(&dev->dev); 628 629 return dev; 630} 631EXPORT_SYMBOL(of_device_alloc); 632 633/** 634 * of_platform_device_create - Alloc, initialize and register an of_device 635 * @np: pointer to node to create device for 636 * @bus_id: name to assign device 637 * @parent: Linux device model parent device. 638 */ 639struct platform_device *of_platform_device_create(struct device_node *np, 640 const char *bus_id, 641 struct device *parent) 642{ 643 struct platform_device *dev; 644 645 dev = of_device_alloc(np, bus_id, parent); 646 if (!dev) 647 return NULL; 648 649#if defined(CONFIG_PPC) || defined(CONFIG_MICROBLAZE) 650 dev->archdata.dma_mask = 0xffffffffUL; 651#endif 652 dev->dev.coherent_dma_mask = DMA_BIT_MASK(32); 653 dev->dev.bus = &platform_bus_type; 654 655 /* We do not fill the DMA ops for platform devices by default. 656 * This is currently the responsibility of the platform code 657 * to do such, possibly using a device notifier 658 */ 659 660 if (of_device_register(dev) != 0) { 661 of_device_free(dev); 662 return NULL; 663 } 664 665 return dev; 666} 667EXPORT_SYMBOL(of_platform_device_create); 668 669/** 670 * of_platform_bus_create - Create an OF device for a bus node and all its 671 * children. Optionally recursively instantiate matching busses. 672 * @bus: device node of the bus to instantiate 673 * @matches: match table, NULL to use the default, OF_NO_DEEP_PROBE to 674 * disallow recursive creation of child busses 675 */ 676static int of_platform_bus_create(const struct device_node *bus, 677 const struct of_device_id *matches, 678 struct device *parent) 679{ 680 struct device_node *child; 681 struct platform_device *dev; 682 int rc = 0; 683 684 for_each_child_of_node(bus, child) { 685 pr_debug(" create child: %s\n", child->full_name); 686 dev = of_platform_device_create(child, NULL, parent); 687 if (dev == NULL) 688 rc = -ENOMEM; 689 else if (!of_match_node(matches, child)) 690 continue; 691 if (rc == 0) { 692 pr_debug(" and sub busses\n"); 693 rc = of_platform_bus_create(child, matches, &dev->dev); 694 } 695 if (rc) { 696 of_node_put(child); 697 break; 698 } 699 } 700 return rc; 701} 702 703/** 704 * of_platform_bus_probe - Probe the device-tree for platform busses 705 * @root: parent of the first level to probe or NULL for the root of the tree 706 * @matches: match table, NULL to use the default 707 * @parent: parent to hook devices from, NULL for toplevel 708 * 709 * Note that children of the provided root are not instantiated as devices 710 * unless the specified root itself matches the bus list and is not NULL. 711 */ 712int of_platform_bus_probe(struct device_node *root, 713 const struct of_device_id *matches, 714 struct device *parent) 715{ 716 struct device_node *child; 717 struct platform_device *dev; 718 int rc = 0; 719 720 if (WARN_ON(!matches || matches == OF_NO_DEEP_PROBE)) 721 return -EINVAL; 722 if (root == NULL) 723 root = of_find_node_by_path("/"); 724 else 725 of_node_get(root); 726 if (root == NULL) 727 return -EINVAL; 728 729 pr_debug("of_platform_bus_probe()\n"); 730 pr_debug(" starting at: %s\n", root->full_name); 731 732 /* Do a self check of bus type, if there's a match, create 733 * children 734 */ 735 if (of_match_node(matches, root)) { 736 pr_debug(" root match, create all sub devices\n"); 737 dev = of_platform_device_create(root, NULL, parent); 738 if (dev == NULL) { 739 rc = -ENOMEM; 740 goto bail; 741 } 742 pr_debug(" create all sub busses\n"); 743 rc = of_platform_bus_create(root, matches, &dev->dev); 744 goto bail; 745 } 746 for_each_child_of_node(root, child) { 747 if (!of_match_node(matches, child)) 748 continue; 749 750 pr_debug(" match: %s\n", child->full_name); 751 dev = of_platform_device_create(child, NULL, parent); 752 if (dev == NULL) 753 rc = -ENOMEM; 754 else 755 rc = of_platform_bus_create(child, matches, &dev->dev); 756 if (rc) { 757 of_node_put(child); 758 break; 759 } 760 } 761 bail: 762 of_node_put(root); 763 return rc; 764} 765EXPORT_SYMBOL(of_platform_bus_probe); 766#endif /* !CONFIG_SPARC */ 767