drivers/i2c/i2c-core-of.c

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