drivers/of/device.c

   1 #include <linux/string.h>
   2 #include <linux/kernel.h>
   3 #include <linux/of.h>
   4 #include <linux/of_device.h>
   5 #include <linux/init.h>
   6 #include <linux/module.h>
   7 #include <linux/mod_devicetable.h>
   8 #include <linux/slab.h>
   9
  10 #include <asm/errno.h>
  11
  12 /**
  13  * of_match_device - Tell if a struct device matches an of_device_id list
  14  * @ids: array of of device match structures to search in
  15  * @dev: the of device structure to match against
  16  *
  17  * Used by a driver to check whether an of_device present in the
  18  * system is in its list of supported devices.
  19  */
  20 const struct of_device_id *of_match_device(const struct of_device_id *matches,
  21                                            const struct device *dev)
  22 {
  23         if (!dev->of_node)
  24                 return NULL;
  25         return of_match_node(matches, dev->of_node);
  26 }
  27 EXPORT_SYMBOL(of_match_device);
  28
  29 struct of_device *of_dev_get(struct of_device *dev)
  30 {
  31         struct device *tmp;
  32
  33         if (!dev)
  34                 return NULL;
  35         tmp = get_device(&dev->dev);
  36         if (tmp)
  37                 return to_of_device(tmp);
  38         else
  39                 return NULL;
  40 }
  41 EXPORT_SYMBOL(of_dev_get);
  42
  43 void of_dev_put(struct of_device *dev)
  44 {
  45         if (dev)
  46                 put_device(&dev->dev);
  47 }
  48 EXPORT_SYMBOL(of_dev_put);
  49
  50 static ssize_t devspec_show(struct device *dev,
  51                                 struct device_attribute *attr, char *buf)
  52 {
  53         struct of_device *ofdev;
  54
  55         ofdev = to_of_device(dev);
  56         return sprintf(buf, "%s\n", ofdev->dev.of_node->full_name);
  57 }
  58
  59 static ssize_t name_show(struct device *dev,
  60                                 struct device_attribute *attr, char *buf)
  61 {
  62         struct of_device *ofdev;
  63
  64         ofdev = to_of_device(dev);
  65         return sprintf(buf, "%s\n", ofdev->dev.of_node->name);
  66 }
  67
  68 static ssize_t modalias_show(struct device *dev,
  69                                 struct device_attribute *attr, char *buf)
  70 {
  71         struct of_device *ofdev = to_of_device(dev);
  72         ssize_t len = 0;
  73
  74         len = of_device_get_modalias(ofdev, buf, PAGE_SIZE - 2);
  75         buf[len] = '\n';
  76         buf[len+1] = 0;
  77         return len+1;
  78 }
  79
  80 struct device_attribute of_platform_device_attrs[] = {
  81         __ATTR_RO(devspec),
  82         __ATTR_RO(name),
  83         __ATTR_RO(modalias),
  84         __ATTR_NULL
  85 };
  86
  87 /**
  88  * of_release_dev - free an of device structure when all users of it are finished.
  89  * @dev: device that's been disconnected
  90  *
  91  * Will be called only by the device core when all users of this of device are
  92  * done.
  93  */
  94 void of_release_dev(struct device *dev)
  95 {
  96         struct of_device *ofdev;
  97
  98         ofdev = to_of_device(dev);
  99         of_node_put(ofdev->dev.of_node);
 100         kfree(ofdev);
 101 }
 102 EXPORT_SYMBOL(of_release_dev);
 103
 104 int of_device_register(struct of_device *ofdev)
 105 {
 106         BUG_ON(ofdev->dev.of_node == NULL);
 107
 108         device_initialize(&ofdev->dev);
 109
 110         /* device_add will assume that this device is on the same node as
 111          * the parent. If there is no parent defined, set the node
 112          * explicitly */
 113         if (!ofdev->dev.parent)
 114                 set_dev_node(&ofdev->dev, of_node_to_nid(ofdev->dev.of_node));
 115
 116         return device_add(&ofdev->dev);
 117 }
 118 EXPORT_SYMBOL(of_device_register);
 119
 120 void of_device_unregister(struct of_device *ofdev)
 121 {
 122         device_unregister(&ofdev->dev);
 123 }
 124 EXPORT_SYMBOL(of_device_unregister);
 125
 126 ssize_t of_device_get_modalias(struct of_device *ofdev,
 127                                 char *str, ssize_t len)
 128 {
 129         const char *compat;
 130         int cplen, i;
 131         ssize_t tsize, csize, repend;
 132
 133         /* Name & Type */
 134         csize = snprintf(str, len, "of:N%sT%s", ofdev->dev.of_node->name,
 135                          ofdev->dev.of_node->type);
 136
 137         /* Get compatible property if any */
 138         compat = of_get_property(ofdev->dev.of_node, "compatible", &cplen);
 139         if (!compat)
 140                 return csize;
 141
 142         /* Find true end (we tolerate multiple \0 at the end */
 143         for (i = (cplen - 1); i >= 0 && !compat[i]; i--)
 144                 cplen--;
 145         if (!cplen)
 146                 return csize;
 147         cplen++;
 148
 149         /* Check space (need cplen+1 chars including final \0) */
 150         tsize = csize + cplen;
 151         repend = tsize;
 152
 153         if (csize >= len)               /* @ the limit, all is already filled */
 154                 return tsize;
 155
 156         if (tsize >= len) {             /* limit compat list */
 157                 cplen = len - csize - 1;
 158                 repend = len;
 159         }
 160
 161         /* Copy and do char replacement */
 162         memcpy(&str[csize + 1], compat, cplen);
 163         for (i = csize; i < repend; i++) {
 164                 char c = str[i];
 165                 if (c == '\0')
 166                         str[i] = 'C';
 167                 else if (c == ' ')
 168                         str[i] = '_';
 169         }
 170
 171         return tsize;
 172 }