drivers/of/platform.c

   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/of_device.h>
  19 #include <linux/of_platform.h>
  20
  21 extern struct device_attribute of_platform_device_attrs[];
  22
  23 static int of_platform_bus_match(struct device *dev, struct device_driver *drv)
  24 {
  25         const struct of_device_id *matches = drv->of_match_table;
  26
  27         if (!matches)
  28                 return 0;
  29
  30         return of_match_device(matches, dev) != NULL;
  31 }
  32
  33 static int of_platform_device_probe(struct device *dev)
  34 {
  35         int error = -ENODEV;
  36         struct of_platform_driver *drv;
  37         struct of_device *of_dev;
  38         const struct of_device_id *match;
  39
  40         drv = to_of_platform_driver(dev->driver);
  41         of_dev = to_of_device(dev);
  42
  43         if (!drv->probe)
  44                 return error;
  45
  46         of_dev_get(of_dev);
  47
  48         match = of_match_device(drv->driver.of_match_table, dev);
  49         if (match)
  50                 error = drv->probe(of_dev, match);
  51         if (error)
  52                 of_dev_put(of_dev);
  53
  54         return error;
  55 }
  56
  57 static int of_platform_device_remove(struct device *dev)
  58 {
  59         struct of_device *of_dev = to_of_device(dev);
  60         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
  61
  62         if (dev->driver && drv->remove)
  63                 drv->remove(of_dev);
  64         return 0;
  65 }
  66
  67 static void of_platform_device_shutdown(struct device *dev)
  68 {
  69         struct of_device *of_dev = to_of_device(dev);
  70         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
  71
  72         if (dev->driver && drv->shutdown)
  73                 drv->shutdown(of_dev);
  74 }
  75
  76 #ifdef CONFIG_PM_SLEEP
  77
  78 static int of_platform_legacy_suspend(struct device *dev, pm_message_t mesg)
  79 {
  80         struct of_device *of_dev = to_of_device(dev);
  81         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
  82         int ret = 0;
  83
  84         if (dev->driver && drv->suspend)
  85                 ret = drv->suspend(of_dev, mesg);
  86         return ret;
  87 }
  88
  89 static int of_platform_legacy_resume(struct device *dev)
  90 {
  91         struct of_device *of_dev = to_of_device(dev);
  92         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
  93         int ret = 0;
  94
  95         if (dev->driver && drv->resume)
  96                 ret = drv->resume(of_dev);
  97         return ret;
  98 }
  99
 100 static int of_platform_pm_prepare(struct device *dev)
 101 {
 102         struct device_driver *drv = dev->driver;
 103         int ret = 0;
 104
 105         if (drv && drv->pm && drv->pm->prepare)
 106                 ret = drv->pm->prepare(dev);
 107
 108         return ret;
 109 }
 110
 111 static void of_platform_pm_complete(struct device *dev)
 112 {
 113         struct device_driver *drv = dev->driver;
 114
 115         if (drv && drv->pm && drv->pm->complete)
 116                 drv->pm->complete(dev);
 117 }
 118
 119 #ifdef CONFIG_SUSPEND
 120
 121 static int of_platform_pm_suspend(struct device *dev)
 122 {
 123         struct device_driver *drv = dev->driver;
 124         int ret = 0;
 125
 126         if (!drv)
 127                 return 0;
 128
 129         if (drv->pm) {
 130                 if (drv->pm->suspend)
 131                         ret = drv->pm->suspend(dev);
 132         } else {
 133                 ret = of_platform_legacy_suspend(dev, PMSG_SUSPEND);
 134         }
 135
 136         return ret;
 137 }
 138
 139 static int of_platform_pm_suspend_noirq(struct device *dev)
 140 {
 141         struct device_driver *drv = dev->driver;
 142         int ret = 0;
 143
 144         if (!drv)
 145                 return 0;
 146
 147         if (drv->pm) {
 148                 if (drv->pm->suspend_noirq)
 149                         ret = drv->pm->suspend_noirq(dev);
 150         }
 151
 152         return ret;
 153 }
 154
 155 static int of_platform_pm_resume(struct device *dev)
 156 {
 157         struct device_driver *drv = dev->driver;
 158         int ret = 0;
 159
 160         if (!drv)
 161                 return 0;
 162
 163         if (drv->pm) {
 164                 if (drv->pm->resume)
 165                         ret = drv->pm->resume(dev);
 166         } else {
 167                 ret = of_platform_legacy_resume(dev);
 168         }
 169
 170         return ret;
 171 }
 172
 173 static int of_platform_pm_resume_noirq(struct device *dev)
 174 {
 175         struct device_driver *drv = dev->driver;
 176         int ret = 0;
 177
 178         if (!drv)
 179                 return 0;
 180
 181         if (drv->pm) {
 182                 if (drv->pm->resume_noirq)
 183                         ret = drv->pm->resume_noirq(dev);
 184         }
 185
 186         return ret;
 187 }
 188
 189 #else /* !CONFIG_SUSPEND */
 190
 191 #define of_platform_pm_suspend          NULL
 192 #define of_platform_pm_resume           NULL
 193 #define of_platform_pm_suspend_noirq    NULL
 194 #define of_platform_pm_resume_noirq     NULL
 195
 196 #endif /* !CONFIG_SUSPEND */
 197
 198 #ifdef CONFIG_HIBERNATION
 199
 200 static int of_platform_pm_freeze(struct device *dev)
 201 {
 202         struct device_driver *drv = dev->driver;
 203         int ret = 0;
 204
 205         if (!drv)
 206                 return 0;
 207
 208         if (drv->pm) {
 209                 if (drv->pm->freeze)
 210                         ret = drv->pm->freeze(dev);
 211         } else {
 212                 ret = of_platform_legacy_suspend(dev, PMSG_FREEZE);
 213         }
 214
 215         return ret;
 216 }
 217
 218 static int of_platform_pm_freeze_noirq(struct device *dev)
 219 {
 220         struct device_driver *drv = dev->driver;
 221         int ret = 0;
 222
 223         if (!drv)
 224                 return 0;
 225
 226         if (drv->pm) {
 227                 if (drv->pm->freeze_noirq)
 228                         ret = drv->pm->freeze_noirq(dev);
 229         }
 230
 231         return ret;
 232 }
 233
 234 static int of_platform_pm_thaw(struct device *dev)
 235 {
 236         struct device_driver *drv = dev->driver;
 237         int ret = 0;
 238
 239         if (!drv)
 240                 return 0;
 241
 242         if (drv->pm) {
 243                 if (drv->pm->thaw)
 244                         ret = drv->pm->thaw(dev);
 245         } else {
 246                 ret = of_platform_legacy_resume(dev);
 247         }
 248
 249         return ret;
 250 }
 251
 252 static int of_platform_pm_thaw_noirq(struct device *dev)
 253 {
 254         struct device_driver *drv = dev->driver;
 255         int ret = 0;
 256
 257         if (!drv)
 258                 return 0;
 259
 260         if (drv->pm) {
 261                 if (drv->pm->thaw_noirq)
 262                         ret = drv->pm->thaw_noirq(dev);
 263         }
 264
 265         return ret;
 266 }
 267
 268 static int of_platform_pm_poweroff(struct device *dev)
 269 {
 270         struct device_driver *drv = dev->driver;
 271         int ret = 0;
 272
 273         if (!drv)
 274                 return 0;
 275
 276         if (drv->pm) {
 277                 if (drv->pm->poweroff)
 278                         ret = drv->pm->poweroff(dev);
 279         } else {
 280                 ret = of_platform_legacy_suspend(dev, PMSG_HIBERNATE);
 281         }
 282
 283         return ret;
 284 }
 285
 286 static int of_platform_pm_poweroff_noirq(struct device *dev)
 287 {
 288         struct device_driver *drv = dev->driver;
 289         int ret = 0;
 290
 291         if (!drv)
 292                 return 0;
 293
 294         if (drv->pm) {
 295                 if (drv->pm->poweroff_noirq)
 296                         ret = drv->pm->poweroff_noirq(dev);
 297         }
 298
 299         return ret;
 300 }
 301
 302 static int of_platform_pm_restore(struct device *dev)
 303 {
 304         struct device_driver *drv = dev->driver;
 305         int ret = 0;
 306
 307         if (!drv)
 308                 return 0;
 309
 310         if (drv->pm) {
 311                 if (drv->pm->restore)
 312                         ret = drv->pm->restore(dev);
 313         } else {
 314                 ret = of_platform_legacy_resume(dev);
 315         }
 316
 317         return ret;
 318 }
 319
 320 static int of_platform_pm_restore_noirq(struct device *dev)
 321 {
 322         struct device_driver *drv = dev->driver;
 323         int ret = 0;
 324
 325         if (!drv)
 326                 return 0;
 327
 328         if (drv->pm) {
 329                 if (drv->pm->restore_noirq)
 330                         ret = drv->pm->restore_noirq(dev);
 331         }
 332
 333         return ret;
 334 }
 335
 336 #else /* !CONFIG_HIBERNATION */
 337
 338 #define of_platform_pm_freeze           NULL
 339 #define of_platform_pm_thaw             NULL
 340 #define of_platform_pm_poweroff         NULL
 341 #define of_platform_pm_restore          NULL
 342 #define of_platform_pm_freeze_noirq     NULL
 343 #define of_platform_pm_thaw_noirq               NULL
 344 #define of_platform_pm_poweroff_noirq   NULL
 345 #define of_platform_pm_restore_noirq    NULL
 346
 347 #endif /* !CONFIG_HIBERNATION */
 348
 349 static struct dev_pm_ops of_platform_dev_pm_ops = {
 350         .prepare = of_platform_pm_prepare,
 351         .complete = of_platform_pm_complete,
 352         .suspend = of_platform_pm_suspend,
 353         .resume = of_platform_pm_resume,
 354         .freeze = of_platform_pm_freeze,
 355         .thaw = of_platform_pm_thaw,
 356         .poweroff = of_platform_pm_poweroff,
 357         .restore = of_platform_pm_restore,
 358         .suspend_noirq = of_platform_pm_suspend_noirq,
 359         .resume_noirq = of_platform_pm_resume_noirq,
 360         .freeze_noirq = of_platform_pm_freeze_noirq,
 361         .thaw_noirq = of_platform_pm_thaw_noirq,
 362         .poweroff_noirq = of_platform_pm_poweroff_noirq,
 363         .restore_noirq = of_platform_pm_restore_noirq,
 364 };
 365
 366 #define OF_PLATFORM_PM_OPS_PTR  (&of_platform_dev_pm_ops)
 367
 368 #else /* !CONFIG_PM_SLEEP */
 369
 370 #define OF_PLATFORM_PM_OPS_PTR  NULL
 371
 372 #endif /* !CONFIG_PM_SLEEP */
 373
 374 int of_bus_type_init(struct bus_type *bus, const char *name)
 375 {
 376         bus->name = name;
 377         bus->match = of_platform_bus_match;
 378         bus->probe = of_platform_device_probe;
 379         bus->remove = of_platform_device_remove;
 380         bus->shutdown = of_platform_device_shutdown;
 381         bus->dev_attrs = of_platform_device_attrs;
 382         bus->pm = OF_PLATFORM_PM_OPS_PTR;
 383         return bus_register(bus);
 384 }
 385
 386 int of_register_driver(struct of_platform_driver *drv, struct bus_type *bus)
 387 {
 388         drv->driver.bus = bus;
 389
 390         /* register with core */
 391         return driver_register(&drv->driver);
 392 }
 393 EXPORT_SYMBOL(of_register_driver);
 394
 395 void of_unregister_driver(struct of_platform_driver *drv)
 396 {
 397         driver_unregister(&drv->driver);
 398 }
 399 EXPORT_SYMBOL(of_unregister_driver);
 400
 401 #if !defined(CONFIG_SPARC)
 402 /*
 403  * The following routines scan a subtree and registers a device for
 404  * each applicable node.
 405  *
 406  * Note: sparc doesn't use these routines because it has a different
 407  * mechanism for creating devices from device tree nodes.
 408  */
 409
 410 /**
 411  * of_device_make_bus_id - Use the device node data to assign a unique name
 412  * @dev: pointer to device structure that is linked to a device tree node
 413  *
 414  * This routine will first try using either the dcr-reg or the reg property
 415  * value to derive a unique name.  As a last resort it will use the node
 416  * name followed by a unique number.
 417  */
 418 static void of_device_make_bus_id(struct device *dev)
 419 {
 420         static atomic_t bus_no_reg_magic;
 421         struct device_node *node = dev->of_node;
 422         const u32 *reg;
 423         u64 addr;
 424         int magic;
 425
 426 #ifdef CONFIG_PPC_DCR
 427         /*
 428          * If it's a DCR based device, use 'd' for native DCRs
 429          * and 'D' for MMIO DCRs.
 430          */
 431         reg = of_get_property(node, "dcr-reg", NULL);
 432         if (reg) {
 433 #ifdef CONFIG_PPC_DCR_NATIVE
 434                 dev_set_name(dev, "d%x.%s", *reg, node->name);
 435 #else /* CONFIG_PPC_DCR_NATIVE */
 436                 u64 addr = of_translate_dcr_address(node, *reg, NULL);
 437                 if (addr != OF_BAD_ADDR) {
 438                         dev_set_name(dev, "D%llx.%s",
 439                                      (unsigned long long)addr, node->name);
 440                         return;
 441                 }
 442 #endif /* !CONFIG_PPC_DCR_NATIVE */
 443         }
 444 #endif /* CONFIG_PPC_DCR */
 445
 446         /*
 447          * For MMIO, get the physical address
 448          */
 449         reg = of_get_property(node, "reg", NULL);
 450         if (reg) {
 451                 addr = of_translate_address(node, reg);
 452                 if (addr != OF_BAD_ADDR) {
 453                         dev_set_name(dev, "%llx.%s",
 454                                      (unsigned long long)addr, node->name);
 455                         return;
 456                 }
 457         }
 458
 459         /*
 460          * No BusID, use the node name and add a globally incremented
 461          * counter (and pray...)
 462          */
 463         magic = atomic_add_return(1, &bus_no_reg_magic);
 464         dev_set_name(dev, "%s.%d", node->name, magic - 1);
 465 }
 466
 467 /**
 468  * of_device_alloc - Allocate and initialize an of_device
 469  * @np: device node to assign to device
 470  * @bus_id: Name to assign to the device.  May be null to use default name.
 471  * @parent: Parent device.
 472  */
 473 struct of_device *of_device_alloc(struct device_node *np,
 474                                   const char *bus_id,
 475                                   struct device *parent)
 476 {
 477         struct of_device *dev;
 478
 479         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 480         if (!dev)
 481                 return NULL;
 482
 483         dev->dev.of_node = of_node_get(np);
 484         dev->dev.dma_mask = &dev->archdata.dma_mask;
 485         dev->dev.parent = parent;
 486         dev->dev.release = of_release_dev;
 487
 488         if (bus_id)
 489                 dev_set_name(&dev->dev, "%s", bus_id);
 490         else
 491                 of_device_make_bus_id(&dev->dev);
 492
 493         return dev;
 494 }
 495 EXPORT_SYMBOL(of_device_alloc);
 496
 497 /**
 498  * of_platform_device_create - Alloc, initialize and register an of_device
 499  * @np: pointer to node to create device for
 500  * @bus_id: name to assign device
 501  * @parent: Linux device model parent device.
 502  */
 503 struct of_device *of_platform_device_create(struct device_node *np,
 504                                             const char *bus_id,
 505                                             struct device *parent)
 506 {
 507         struct of_device *dev;
 508
 509         dev = of_device_alloc(np, bus_id, parent);
 510         if (!dev)
 511                 return NULL;
 512
 513         dev->archdata.dma_mask = 0xffffffffUL;
 514         dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
 515         dev->dev.bus = &of_platform_bus_type;
 516
 517         /* We do not fill the DMA ops for platform devices by default.
 518          * This is currently the responsibility of the platform code
 519          * to do such, possibly using a device notifier
 520          */
 521
 522         if (of_device_register(dev) != 0) {
 523                 of_device_free(dev);
 524                 return NULL;
 525         }
 526
 527         return dev;
 528 }
 529 EXPORT_SYMBOL(of_platform_device_create);
 530
 531 /**
 532  * of_platform_bus_create - Create an OF device for a bus node and all its
 533  * children. Optionally recursively instantiate matching busses.
 534  * @bus: device node of the bus to instantiate
 535  * @matches: match table, NULL to use the default, OF_NO_DEEP_PROBE to
 536  * disallow recursive creation of child busses
 537  */
 538 static int of_platform_bus_create(const struct device_node *bus,
 539                                   const struct of_device_id *matches,
 540                                   struct device *parent)
 541 {
 542         struct device_node *child;
 543         struct of_device *dev;
 544         int rc = 0;
 545
 546         for_each_child_of_node(bus, child) {
 547                 pr_debug("   create child: %s\n", child->full_name);
 548                 dev = of_platform_device_create(child, NULL, parent);
 549                 if (dev == NULL)
 550                         rc = -ENOMEM;
 551                 else if (!of_match_node(matches, child))
 552                         continue;
 553                 if (rc == 0) {
 554                         pr_debug("   and sub busses\n");
 555                         rc = of_platform_bus_create(child, matches, &dev->dev);
 556                 }
 557                 if (rc) {
 558                         of_node_put(child);
 559                         break;
 560                 }
 561         }
 562         return rc;
 563 }
 564
 565 /**
 566  * of_platform_bus_probe - Probe the device-tree for platform busses
 567  * @root: parent of the first level to probe or NULL for the root of the tree
 568  * @matches: match table, NULL to use the default
 569  * @parent: parent to hook devices from, NULL for toplevel
 570  *
 571  * Note that children of the provided root are not instantiated as devices
 572  * unless the specified root itself matches the bus list and is not NULL.
 573  */
 574 int of_platform_bus_probe(struct device_node *root,
 575                           const struct of_device_id *matches,
 576                           struct device *parent)
 577 {
 578         struct device_node *child;
 579         struct of_device *dev;
 580         int rc = 0;
 581
 582         if (matches == NULL)
 583                 matches = of_default_bus_ids;
 584         if (matches == OF_NO_DEEP_PROBE)
 585                 return -EINVAL;
 586         if (root == NULL)
 587                 root = of_find_node_by_path("/");
 588         else
 589                 of_node_get(root);
 590
 591         pr_debug("of_platform_bus_probe()\n");
 592         pr_debug(" starting at: %s\n", root->full_name);
 593
 594         /* Do a self check of bus type, if there's a match, create
 595          * children
 596          */
 597         if (of_match_node(matches, root)) {
 598                 pr_debug(" root match, create all sub devices\n");
 599                 dev = of_platform_device_create(root, NULL, parent);
 600                 if (dev == NULL) {
 601                         rc = -ENOMEM;
 602                         goto bail;
 603                 }
 604                 pr_debug(" create all sub busses\n");
 605                 rc = of_platform_bus_create(root, matches, &dev->dev);
 606                 goto bail;
 607         }
 608         for_each_child_of_node(root, child) {
 609                 if (!of_match_node(matches, child))
 610                         continue;
 611
 612                 pr_debug("  match: %s\n", child->full_name);
 613                 dev = of_platform_device_create(child, NULL, parent);
 614                 if (dev == NULL)
 615                         rc = -ENOMEM;
 616                 else
 617                         rc = of_platform_bus_create(child, matches, &dev->dev);
 618                 if (rc) {
 619                         of_node_put(child);
 620                         break;
 621                 }
 622         }
 623  bail:
 624         of_node_put(root);
 625         return rc;
 626 }
 627 EXPORT_SYMBOL(of_platform_bus_probe);
 628 #endif /* !CONFIG_SPARC */