Commit | Line | Data |
---|---|---|
5bf4fa7d WS |
1 | /* |
2 | * Linux I2C core OF support code | |
3 | * | |
4 | * Copyright (C) 2008 Jochen Friedrich <jochen@scram.de> | |
5 | * based on a previous patch from Jon Smirl <jonsmirl@gmail.com> | |
6 | * | |
a1671af2 | 7 | * Copyright (C) 2013, 2018 Wolfram Sang <wsa@the-dreams.de> |
5bf4fa7d WS |
8 | * |
9 | * This program is free software; you can redistribute it and/or modify it | |
10 | * under the terms of the GNU General Public License as published by the Free | |
11 | * Software Foundation; either version 2 of the License, or (at your option) | |
12 | * any later version. | |
13 | */ | |
14 | ||
15 | #include <dt-bindings/i2c/i2c.h> | |
16 | #include <linux/device.h> | |
17 | #include <linux/err.h> | |
18 | #include <linux/i2c.h> | |
19 | #include <linux/module.h> | |
20 | #include <linux/of.h> | |
21 | #include <linux/of_device.h> | |
22 | ||
23 | #include "i2c-core.h" | |
24 | ||
da0086d0 BB |
25 | int of_i2c_get_board_info(struct device *dev, struct device_node *node, |
26 | struct i2c_board_info *info) | |
5bf4fa7d | 27 | { |
5bf4fa7d | 28 | u32 addr; |
a1671af2 | 29 | int ret; |
5bf4fa7d | 30 | |
da0086d0 | 31 | memset(info, 0, sizeof(*info)); |
5bf4fa7d | 32 | |
da0086d0 BB |
33 | if (of_modalias_node(node, info->type, sizeof(info->type)) < 0) { |
34 | dev_err(dev, "of_i2c: modalias failure on %pOF\n", node); | |
35 | return -EINVAL; | |
5bf4fa7d WS |
36 | } |
37 | ||
a1671af2 WS |
38 | ret = of_property_read_u32(node, "reg", &addr); |
39 | if (ret) { | |
da0086d0 BB |
40 | dev_err(dev, "of_i2c: invalid reg on %pOF\n", node); |
41 | return ret; | |
5bf4fa7d WS |
42 | } |
43 | ||
5bf4fa7d WS |
44 | if (addr & I2C_TEN_BIT_ADDRESS) { |
45 | addr &= ~I2C_TEN_BIT_ADDRESS; | |
da0086d0 | 46 | info->flags |= I2C_CLIENT_TEN; |
5bf4fa7d WS |
47 | } |
48 | ||
49 | if (addr & I2C_OWN_SLAVE_ADDRESS) { | |
50 | addr &= ~I2C_OWN_SLAVE_ADDRESS; | |
da0086d0 | 51 | info->flags |= I2C_CLIENT_SLAVE; |
5bf4fa7d WS |
52 | } |
53 | ||
da0086d0 BB |
54 | info->addr = addr; |
55 | info->of_node = node; | |
5bf4fa7d WS |
56 | |
57 | if (of_property_read_bool(node, "host-notify")) | |
da0086d0 | 58 | info->flags |= I2C_CLIENT_HOST_NOTIFY; |
5bf4fa7d WS |
59 | |
60 | if (of_get_property(node, "wakeup-source", NULL)) | |
da0086d0 BB |
61 | info->flags |= I2C_CLIENT_WAKE; |
62 | ||
63 | return 0; | |
64 | } | |
65 | EXPORT_SYMBOL_GPL(of_i2c_get_board_info); | |
66 | ||
67 | static struct i2c_client *of_i2c_register_device(struct i2c_adapter *adap, | |
68 | struct device_node *node) | |
69 | { | |
70 | struct i2c_client *client; | |
71 | struct i2c_board_info info; | |
72 | int ret; | |
73 | ||
74 | dev_dbg(&adap->dev, "of_i2c: register %pOF\n", node); | |
75 | ||
76 | ret = of_i2c_get_board_info(&adap->dev, node, &info); | |
77 | if (ret) | |
78 | return ERR_PTR(ret); | |
5bf4fa7d | 79 | |
c49b0e07 WS |
80 | client = i2c_new_device(adap, &info); |
81 | if (!client) { | |
453a237c | 82 | dev_err(&adap->dev, "of_i2c: Failure registering %pOF\n", node); |
5bf4fa7d WS |
83 | return ERR_PTR(-EINVAL); |
84 | } | |
c49b0e07 | 85 | return client; |
5bf4fa7d WS |
86 | } |
87 | ||
88 | void of_i2c_register_devices(struct i2c_adapter *adap) | |
89 | { | |
90 | struct device_node *bus, *node; | |
91 | struct i2c_client *client; | |
92 | ||
93 | /* Only register child devices if the adapter has a node pointer set */ | |
94 | if (!adap->dev.of_node) | |
95 | return; | |
96 | ||
97 | dev_dbg(&adap->dev, "of_i2c: walking child nodes\n"); | |
98 | ||
99 | bus = of_get_child_by_name(adap->dev.of_node, "i2c-bus"); | |
100 | if (!bus) | |
101 | bus = of_node_get(adap->dev.of_node); | |
102 | ||
103 | for_each_available_child_of_node(bus, node) { | |
104 | if (of_node_test_and_set_flag(node, OF_POPULATED)) | |
105 | continue; | |
106 | ||
107 | client = of_i2c_register_device(adap, node); | |
108 | if (IS_ERR(client)) { | |
f1c87ceb | 109 | dev_err(&adap->dev, |
453a237c RH |
110 | "Failed to create I2C device for %pOF\n", |
111 | node); | |
5bf4fa7d WS |
112 | of_node_clear_flag(node, OF_POPULATED); |
113 | } | |
114 | } | |
115 | ||
116 | of_node_put(bus); | |
117 | } | |
118 | ||
119 | static int of_dev_node_match(struct device *dev, void *data) | |
120 | { | |
121 | return dev->of_node == data; | |
122 | } | |
123 | ||
e814e688 TR |
124 | static int of_dev_or_parent_node_match(struct device *dev, void *data) |
125 | { | |
126 | if (dev->of_node == data) | |
127 | return 1; | |
128 | ||
129 | if (dev->parent) | |
130 | return dev->parent->of_node == data; | |
131 | ||
132 | return 0; | |
133 | } | |
134 | ||
5bf4fa7d WS |
135 | /* must call put_device() when done with returned i2c_client device */ |
136 | struct i2c_client *of_find_i2c_device_by_node(struct device_node *node) | |
137 | { | |
138 | struct device *dev; | |
139 | struct i2c_client *client; | |
140 | ||
141 | dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match); | |
142 | if (!dev) | |
143 | return NULL; | |
144 | ||
145 | client = i2c_verify_client(dev); | |
146 | if (!client) | |
147 | put_device(dev); | |
148 | ||
149 | return client; | |
150 | } | |
151 | EXPORT_SYMBOL(of_find_i2c_device_by_node); | |
152 | ||
153 | /* must call put_device() when done with returned i2c_adapter device */ | |
154 | struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node) | |
155 | { | |
156 | struct device *dev; | |
157 | struct i2c_adapter *adapter; | |
158 | ||
e814e688 TR |
159 | dev = bus_find_device(&i2c_bus_type, NULL, node, |
160 | of_dev_or_parent_node_match); | |
5bf4fa7d WS |
161 | if (!dev) |
162 | return NULL; | |
163 | ||
164 | adapter = i2c_verify_adapter(dev); | |
165 | if (!adapter) | |
166 | put_device(dev); | |
167 | ||
168 | return adapter; | |
169 | } | |
170 | EXPORT_SYMBOL(of_find_i2c_adapter_by_node); | |
171 | ||
172 | /* must call i2c_put_adapter() when done with returned i2c_adapter device */ | |
173 | struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node) | |
174 | { | |
175 | struct i2c_adapter *adapter; | |
176 | ||
177 | adapter = of_find_i2c_adapter_by_node(node); | |
178 | if (!adapter) | |
179 | return NULL; | |
180 | ||
181 | if (!try_module_get(adapter->owner)) { | |
182 | put_device(&adapter->dev); | |
183 | adapter = NULL; | |
184 | } | |
185 | ||
186 | return adapter; | |
187 | } | |
188 | EXPORT_SYMBOL(of_get_i2c_adapter_by_node); | |
189 | ||
190 | static const struct of_device_id* | |
191 | i2c_of_match_device_sysfs(const struct of_device_id *matches, | |
192 | struct i2c_client *client) | |
193 | { | |
194 | const char *name; | |
195 | ||
196 | for (; matches->compatible[0]; matches++) { | |
197 | /* | |
198 | * Adding devices through the i2c sysfs interface provides us | |
199 | * a string to match which may be compatible with the device | |
200 | * tree compatible strings, however with no actual of_node the | |
201 | * of_match_device() will not match | |
202 | */ | |
203 | if (sysfs_streq(client->name, matches->compatible)) | |
204 | return matches; | |
205 | ||
206 | name = strchr(matches->compatible, ','); | |
207 | if (!name) | |
208 | name = matches->compatible; | |
209 | else | |
210 | name++; | |
211 | ||
212 | if (sysfs_streq(client->name, name)) | |
213 | return matches; | |
214 | } | |
215 | ||
216 | return NULL; | |
217 | } | |
218 | ||
219 | const struct of_device_id | |
220 | *i2c_of_match_device(const struct of_device_id *matches, | |
221 | struct i2c_client *client) | |
222 | { | |
223 | const struct of_device_id *match; | |
224 | ||
225 | if (!(client && matches)) | |
226 | return NULL; | |
227 | ||
228 | match = of_match_device(matches, &client->dev); | |
229 | if (match) | |
230 | return match; | |
231 | ||
232 | return i2c_of_match_device_sysfs(matches, client); | |
233 | } | |
234 | EXPORT_SYMBOL_GPL(i2c_of_match_device); | |
235 | ||
236 | #if IS_ENABLED(CONFIG_OF_DYNAMIC) | |
237 | static int of_i2c_notify(struct notifier_block *nb, unsigned long action, | |
238 | void *arg) | |
239 | { | |
240 | struct of_reconfig_data *rd = arg; | |
241 | struct i2c_adapter *adap; | |
242 | struct i2c_client *client; | |
243 | ||
244 | switch (of_reconfig_get_state_change(action, rd)) { | |
245 | case OF_RECONFIG_CHANGE_ADD: | |
246 | adap = of_find_i2c_adapter_by_node(rd->dn->parent); | |
247 | if (adap == NULL) | |
248 | return NOTIFY_OK; /* not for us */ | |
249 | ||
250 | if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) { | |
251 | put_device(&adap->dev); | |
252 | return NOTIFY_OK; | |
253 | } | |
254 | ||
255 | client = of_i2c_register_device(adap, rd->dn); | |
256 | put_device(&adap->dev); | |
257 | ||
258 | if (IS_ERR(client)) { | |
453a237c RH |
259 | dev_err(&adap->dev, "failed to create client for '%pOF'\n", |
260 | rd->dn); | |
5bf4fa7d WS |
261 | of_node_clear_flag(rd->dn, OF_POPULATED); |
262 | return notifier_from_errno(PTR_ERR(client)); | |
263 | } | |
264 | break; | |
265 | case OF_RECONFIG_CHANGE_REMOVE: | |
266 | /* already depopulated? */ | |
267 | if (!of_node_check_flag(rd->dn, OF_POPULATED)) | |
268 | return NOTIFY_OK; | |
269 | ||
270 | /* find our device by node */ | |
271 | client = of_find_i2c_device_by_node(rd->dn); | |
272 | if (client == NULL) | |
273 | return NOTIFY_OK; /* no? not meant for us */ | |
274 | ||
275 | /* unregister takes one ref away */ | |
276 | i2c_unregister_device(client); | |
277 | ||
278 | /* and put the reference of the find */ | |
279 | put_device(&client->dev); | |
280 | break; | |
281 | } | |
282 | ||
283 | return NOTIFY_OK; | |
284 | } | |
285 | ||
286 | struct notifier_block i2c_of_notifier = { | |
287 | .notifier_call = of_i2c_notify, | |
288 | }; | |
289 | #endif /* CONFIG_OF_DYNAMIC */ |