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/of_device.h>
  18 #include <linux/of_platform.h>
  19
  20 static int of_platform_bus_match(struct device *dev, struct device_driver *drv)
  21 {
  22         struct of_device *of_dev = to_of_device(dev);
  23         struct of_platform_driver *of_drv = to_of_platform_driver(drv);
  24         const struct of_device_id *matches = of_drv->match_table;
  25
  26         if (!matches)
  27                 return 0;
  28
  29         return of_match_device(matches, of_dev) != NULL;
  30 }
  31
  32 static int of_platform_device_probe(struct device *dev)
  33 {
  34         int error = -ENODEV;
  35         struct of_platform_driver *drv;
  36         struct of_device *of_dev;
  37         const struct of_device_id *match;
  38
  39         drv = to_of_platform_driver(dev->driver);
  40         of_dev = to_of_device(dev);
  41
  42         if (!drv->probe)
  43                 return error;
  44
  45         of_dev_get(of_dev);
  46
  47         match = of_match_device(drv->match_table, of_dev);
  48         if (match)
  49                 error = drv->probe(of_dev, match);
  50         if (error)
  51                 of_dev_put(of_dev);
  52
  53         return error;
  54 }
  55
  56 static int of_platform_device_remove(struct device *dev)
  57 {
  58         struct of_device *of_dev = to_of_device(dev);
  59         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
  60
  61         if (dev->driver && drv->remove)
  62                 drv->remove(of_dev);
  63         return 0;
  64 }
  65
  66 static int of_platform_device_suspend(struct device *dev, pm_message_t state)
  67 {
  68         struct of_device *of_dev = to_of_device(dev);
  69         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
  70         int error = 0;
  71
  72         if (dev->driver && drv->suspend)
  73                 error = drv->suspend(of_dev, state);
  74         return error;
  75 }
  76
  77 static int of_platform_device_resume(struct device * dev)
  78 {
  79         struct of_device *of_dev = to_of_device(dev);
  80         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
  81         int error = 0;
  82
  83         if (dev->driver && drv->resume)
  84                 error = drv->resume(of_dev);
  85         return error;
  86 }
  87
  88 static void of_platform_device_shutdown(struct device *dev)
  89 {
  90         struct of_device *of_dev = to_of_device(dev);
  91         struct of_platform_driver *drv = to_of_platform_driver(dev->driver);
  92
  93         if (dev->driver && drv->shutdown)
  94                 drv->shutdown(of_dev);
  95 }
  96
  97 int of_bus_type_init(struct bus_type *bus, const char *name)
  98 {
  99         bus->name = name;
 100         bus->match = of_platform_bus_match;
 101         bus->probe = of_platform_device_probe;
 102         bus->remove = of_platform_device_remove;
 103         bus->suspend = of_platform_device_suspend;
 104         bus->resume = of_platform_device_resume;
 105         bus->shutdown = of_platform_device_shutdown;
 106         return bus_register(bus);
 107 }
 108
 109 int of_register_driver(struct of_platform_driver *drv, struct bus_type *bus)
 110 {
 111         /* initialize common driver fields */
 112         if (!drv->driver.name)
 113                 drv->driver.name = drv->name;
 114         if (!drv->driver.owner)
 115                 drv->driver.owner = drv->owner;
 116         drv->driver.bus = bus;
 117
 118         /* register with core */
 119         return driver_register(&drv->driver);
 120 }
 121 EXPORT_SYMBOL(of_register_driver);
 122
 123 void of_unregister_driver(struct of_platform_driver *drv)
 124 {
 125         driver_unregister(&drv->driver);
 126 }
 127 EXPORT_SYMBOL(of_unregister_driver);