]>
Commit | Line | Data |
---|---|---|
f85ff305 SR |
1 | #include <linux/string.h> |
2 | #include <linux/kernel.h> | |
3 | #include <linux/of.h> | |
f898f8db | 4 | #include <linux/of_device.h> |
f85ff305 SR |
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> | |
f85ff305 | 11 | |
f85ff305 | 12 | /** |
44504b2b | 13 | * of_match_device - Tell if a struct device matches an of_device_id list |
f85ff305 SR |
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, | |
44504b2b | 21 | const struct device *dev) |
f85ff305 | 22 | { |
44504b2b | 23 | if (!dev->of_node) |
f85ff305 | 24 | return NULL; |
44504b2b | 25 | return of_match_node(matches, dev->of_node); |
f85ff305 SR |
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 | ||
140b932f | 50 | static ssize_t devspec_show(struct device *dev, |
f85ff305 SR |
51 | struct device_attribute *attr, char *buf) |
52 | { | |
53 | struct of_device *ofdev; | |
54 | ||
55 | ofdev = to_of_device(dev); | |
61c7a080 | 56 | return sprintf(buf, "%s\n", ofdev->dev.of_node->full_name); |
f85ff305 SR |
57 | } |
58 | ||
4589f1fe JF |
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); | |
61c7a080 | 65 | return sprintf(buf, "%s\n", ofdev->dev.of_node->name); |
4589f1fe JF |
66 | } |
67 | ||
140b932f OH |
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), | |
4589f1fe | 82 | __ATTR_RO(name), |
140b932f OH |
83 | __ATTR_RO(modalias), |
84 | __ATTR_NULL | |
85 | }; | |
f85ff305 SR |
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); | |
61c7a080 | 99 | of_node_put(ofdev->dev.of_node); |
f85ff305 SR |
100 | kfree(ofdev); |
101 | } | |
102 | EXPORT_SYMBOL(of_release_dev); | |
103 | ||
104 | int of_device_register(struct of_device *ofdev) | |
105 | { | |
61c7a080 | 106 | BUG_ON(ofdev->dev.of_node == NULL); |
6098e2ee JK |
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) | |
61c7a080 | 114 | set_dev_node(&ofdev->dev, of_node_to_nid(ofdev->dev.of_node)); |
6098e2ee JK |
115 | |
116 | return device_add(&ofdev->dev); | |
f85ff305 SR |
117 | } |
118 | EXPORT_SYMBOL(of_device_register); | |
119 | ||
120 | void of_device_unregister(struct of_device *ofdev) | |
121 | { | |
f85ff305 SR |
122 | device_unregister(&ofdev->dev); |
123 | } | |
124 | EXPORT_SYMBOL(of_device_unregister); | |
09e67ca2 SR |
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 */ | |
61c7a080 GL |
134 | csize = snprintf(str, len, "of:N%sT%s", ofdev->dev.of_node->name, |
135 | ofdev->dev.of_node->type); | |
09e67ca2 SR |
136 | |
137 | /* Get compatible property if any */ | |
61c7a080 | 138 | compat = of_get_property(ofdev->dev.of_node, "compatible", &cplen); |
09e67ca2 SR |
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 | } |