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 * 7 * Copyright (C) 2013, 2018 Wolfram Sang <wsa@the-dreams.de> 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 25 int of_i2c_get_board_info(struct device *dev, struct device_node *node, 26 struct i2c_board_info *info) 27 { 28 u32 addr; 29 int ret; 30 31 memset(info, 0, sizeof(*info)); 32 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; 36 } 37 38 ret = of_property_read_u32(node, "reg", &addr); 39 if (ret) { 40 dev_err(dev, "of_i2c: invalid reg on %pOF\n", node); 41 return ret; 42 } 43 44 if (addr & I2C_TEN_BIT_ADDRESS) { 45 addr &= ~I2C_TEN_BIT_ADDRESS; 46 info->flags |= I2C_CLIENT_TEN; 47 } 48 49 if (addr & I2C_OWN_SLAVE_ADDRESS) { 50 addr &= ~I2C_OWN_SLAVE_ADDRESS; 51 info->flags |= I2C_CLIENT_SLAVE; 52 } 53 54 info->addr = addr; 55 info->of_node = node; 56 57 if (of_property_read_bool(node, "host-notify")) 58 info->flags |= I2C_CLIENT_HOST_NOTIFY; 59 60 if (of_get_property(node, "wakeup-source", NULL)) 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); 79 80 client = i2c_new_device(adap, &info); 81 if (!client) { 82 dev_err(&adap->dev, "of_i2c: Failure registering %pOF\n", node); 83 return ERR_PTR(-EINVAL); 84 } 85 return client; 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)) { 109 dev_err(&adap->dev, 110 "Failed to create I2C device for %pOF\n", 111 node); 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 124 /* must call put_device() when done with returned i2c_client device */ 125 struct i2c_client *of_find_i2c_device_by_node(struct device_node *node) 126 { 127 struct device *dev; 128 struct i2c_client *client; 129 130 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match); 131 if (!dev) 132 return NULL; 133 134 client = i2c_verify_client(dev); 135 if (!client) 136 put_device(dev); 137 138 return client; 139 } 140 EXPORT_SYMBOL(of_find_i2c_device_by_node); 141 142 /* must call put_device() when done with returned i2c_adapter device */ 143 struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node) 144 { 145 struct device *dev; 146 struct i2c_adapter *adapter; 147 148 dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match); 149 if (!dev) 150 return NULL; 151 152 adapter = i2c_verify_adapter(dev); 153 if (!adapter) 154 put_device(dev); 155 156 return adapter; 157 } 158 EXPORT_SYMBOL(of_find_i2c_adapter_by_node); 159 160 /* must call i2c_put_adapter() when done with returned i2c_adapter device */ 161 struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node) 162 { 163 struct i2c_adapter *adapter; 164 165 adapter = of_find_i2c_adapter_by_node(node); 166 if (!adapter) 167 return NULL; 168 169 if (!try_module_get(adapter->owner)) { 170 put_device(&adapter->dev); 171 adapter = NULL; 172 } 173 174 return adapter; 175 } 176 EXPORT_SYMBOL(of_get_i2c_adapter_by_node); 177 178 static const struct of_device_id* 179 i2c_of_match_device_sysfs(const struct of_device_id *matches, 180 struct i2c_client *client) 181 { 182 const char *name; 183 184 for (; matches->compatible[0]; matches++) { 185 /* 186 * Adding devices through the i2c sysfs interface provides us 187 * a string to match which may be compatible with the device 188 * tree compatible strings, however with no actual of_node the 189 * of_match_device() will not match 190 */ 191 if (sysfs_streq(client->name, matches->compatible)) 192 return matches; 193 194 name = strchr(matches->compatible, ','); 195 if (!name) 196 name = matches->compatible; 197 else 198 name++; 199 200 if (sysfs_streq(client->name, name)) 201 return matches; 202 } 203 204 return NULL; 205 } 206 207 const struct of_device_id 208 *i2c_of_match_device(const struct of_device_id *matches, 209 struct i2c_client *client) 210 { 211 const struct of_device_id *match; 212 213 if (!(client && matches)) 214 return NULL; 215 216 match = of_match_device(matches, &client->dev); 217 if (match) 218 return match; 219 220 return i2c_of_match_device_sysfs(matches, client); 221 } 222 EXPORT_SYMBOL_GPL(i2c_of_match_device); 223 224 #if IS_ENABLED(CONFIG_OF_DYNAMIC) 225 static int of_i2c_notify(struct notifier_block *nb, unsigned long action, 226 void *arg) 227 { 228 struct of_reconfig_data *rd = arg; 229 struct i2c_adapter *adap; 230 struct i2c_client *client; 231 232 switch (of_reconfig_get_state_change(action, rd)) { 233 case OF_RECONFIG_CHANGE_ADD: 234 adap = of_find_i2c_adapter_by_node(rd->dn->parent); 235 if (adap == NULL) 236 return NOTIFY_OK; /* not for us */ 237 238 if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) { 239 put_device(&adap->dev); 240 return NOTIFY_OK; 241 } 242 243 client = of_i2c_register_device(adap, rd->dn); 244 put_device(&adap->dev); 245 246 if (IS_ERR(client)) { 247 dev_err(&adap->dev, "failed to create client for '%pOF'\n", 248 rd->dn); 249 of_node_clear_flag(rd->dn, OF_POPULATED); 250 return notifier_from_errno(PTR_ERR(client)); 251 } 252 break; 253 case OF_RECONFIG_CHANGE_REMOVE: 254 /* already depopulated? */ 255 if (!of_node_check_flag(rd->dn, OF_POPULATED)) 256 return NOTIFY_OK; 257 258 /* find our device by node */ 259 client = of_find_i2c_device_by_node(rd->dn); 260 if (client == NULL) 261 return NOTIFY_OK; /* no? not meant for us */ 262 263 /* unregister takes one ref away */ 264 i2c_unregister_device(client); 265 266 /* and put the reference of the find */ 267 put_device(&client->dev); 268 break; 269 } 270 271 return NOTIFY_OK; 272 } 273 274 struct notifier_block i2c_of_notifier = { 275 .notifier_call = of_i2c_notify, 276 }; 277 #endif /* CONFIG_OF_DYNAMIC */ 278