arch/powerpc/kernel/of_device.c

   1 #include <linux/string.h>
   2 #include <linux/kernel.h>
   3 #include <linux/init.h>
   4 #include <linux/module.h>
   5 #include <linux/mod_devicetable.h>
   6 #include <linux/slab.h>
   7
   8 #include <asm/errno.h>
   9 #include <asm/of_device.h>
  10
  11 /**
  12  * of_match_node - Tell if an device_node has a matching of_match structure
  13  * @ids: array of of device match structures to search in
  14  * @node: the of device structure to match against
  15  *
  16  * Low level utility function used by device matching.
  17  */
  18 const struct of_device_id *of_match_node(const struct of_device_id *matches,
  19                                          const struct device_node *node)
  20 {
  21         while (matches->name[0] || matches->type[0] || matches->compatible[0]) {
  22                 int match = 1;
  23                 if (matches->name[0])
  24                         match &= node->name
  25                                 && !strcmp(matches->name, node->name);
  26                 if (matches->type[0])
  27                         match &= node->type
  28                                 && !strcmp(matches->type, node->type);
  29                 if (matches->compatible[0])
  30                         match &= device_is_compatible(node,
  31                                                       matches->compatible);
  32                 if (match)
  33                         return matches;
  34                 matches++;
  35         }
  36         return NULL;
  37 }
  38
  39 /**
  40  * of_match_device - Tell if an of_device structure has a matching
  41  * of_match structure
  42  * @ids: array of of device match structures to search in
  43  * @dev: the of device structure to match against
  44  *
  45  * Used by a driver to check whether an of_device present in the
  46  * system is in its list of supported devices.
  47  */
  48 const struct of_device_id *of_match_device(const struct of_device_id *matches,
  49                                         const struct of_device *dev)
  50 {
  51         if (!dev->node)
  52                 return NULL;
  53         return of_match_node(matches, dev->node);
  54 }
  55
  56 struct of_device *of_dev_get(struct of_device *dev)
  57 {
  58         struct device *tmp;
  59
  60         if (!dev)
  61                 return NULL;
  62         tmp = get_device(&dev->dev);
  63         if (tmp)
  64                 return to_of_device(tmp);
  65         else
  66                 return NULL;
  67 }
  68
  69 void of_dev_put(struct of_device *dev)
  70 {
  71         if (dev)
  72                 put_device(&dev->dev);
  73 }
  74
  75 static ssize_t dev_show_devspec(struct device *dev,
  76                                 struct device_attribute *attr, char *buf)
  77 {
  78         struct of_device *ofdev;
  79
  80         ofdev = to_of_device(dev);
  81         return sprintf(buf, "%s", ofdev->node->full_name);
  82 }
  83
  84 static DEVICE_ATTR(devspec, S_IRUGO, dev_show_devspec, NULL);
  85
  86 /**
  87  * of_release_dev - free an of device structure when all users of it are finished.
  88  * @dev: device that's been disconnected
  89  *
  90  * Will be called only by the device core when all users of this of device are
  91  * done.
  92  */
  93 void of_release_dev(struct device *dev)
  94 {
  95         struct of_device *ofdev;
  96
  97         ofdev = to_of_device(dev);
  98         of_node_put(ofdev->node);
  99         kfree(ofdev);
 100 }
 101
 102 int of_device_register(struct of_device *ofdev)
 103 {
 104         int rc;
 105
 106         BUG_ON(ofdev->node == NULL);
 107
 108         rc = device_register(&ofdev->dev);
 109         if (rc)
 110                 return rc;
 111
 112         return device_create_file(&ofdev->dev, &dev_attr_devspec);
 113 }
 114
 115 void of_device_unregister(struct of_device *ofdev)
 116 {
 117         device_remove_file(&ofdev->dev, &dev_attr_devspec);
 118
 119         device_unregister(&ofdev->dev);
 120 }
 121
 122
 123 EXPORT_SYMBOL(of_match_node);
 124 EXPORT_SYMBOL(of_match_device);
 125 EXPORT_SYMBOL(of_device_register);
 126 EXPORT_SYMBOL(of_device_unregister);
 127 EXPORT_SYMBOL(of_dev_get);
 128 EXPORT_SYMBOL(of_dev_put);
 129 EXPORT_SYMBOL(of_release_dev);