711 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * I2C Address Translator4 *5 * Copyright (c) 2019,2022 Luca Ceresoli <luca@lucaceresoli.net>6 * Copyright (c) 2022,2023 Tomi Valkeinen <tomi.valkeinen@ideasonboard.com>7 *8 * Originally based on i2c-mux.c9 */10 11#include <linux/fwnode.h>12#include <linux/i2c-atr.h>13#include <linux/i2c.h>14#include <linux/kernel.h>15#include <linux/module.h>16#include <linux/mutex.h>17#include <linux/slab.h>18#include <linux/spinlock.h>19 20#define ATR_MAX_ADAPTERS 100 /* Just a sanity limit */21#define ATR_MAX_SYMLINK_LEN 11 /* Longest name is 10 chars: "channel-99" */22 23/**24 * struct i2c_atr_alias_pair - Holds the alias assigned to a client.25 * @node: List node26 * @client: Pointer to the client on the child bus27 * @alias: I2C alias address assigned by the driver.28 * This is the address that will be used to issue I2C transactions29 * on the parent (physical) bus.30 */31struct i2c_atr_alias_pair {32 struct list_head node;33 const struct i2c_client *client;34 u16 alias;35};36 37/**38 * struct i2c_atr_chan - Data for a channel.39 * @adap: The &struct i2c_adapter for the channel40 * @atr: The parent I2C ATR41 * @chan_id: The ID of this channel42 * @alias_list: List of @struct i2c_atr_alias_pair containing the43 * assigned aliases44 * @orig_addrs_lock: Mutex protecting @orig_addrs45 * @orig_addrs: Buffer used to store the original addresses during transmit46 * @orig_addrs_size: Size of @orig_addrs47 */48struct i2c_atr_chan {49 struct i2c_adapter adap;50 struct i2c_atr *atr;51 u32 chan_id;52 53 struct list_head alias_list;54 55 /* Lock orig_addrs during xfer */56 struct mutex orig_addrs_lock;57 u16 *orig_addrs;58 unsigned int orig_addrs_size;59};60 61/**62 * struct i2c_atr - The I2C ATR instance63 * @parent: The parent &struct i2c_adapter64 * @dev: The device that owns the I2C ATR instance65 * @ops: &struct i2c_atr_ops66 * @priv: Private driver data, set with i2c_atr_set_driver_data()67 * @algo: The &struct i2c_algorithm for adapters68 * @lock: Lock for the I2C bus segment (see &struct i2c_lock_operations)69 * @max_adapters: Maximum number of adapters this I2C ATR can have70 * @num_aliases: Number of aliases in the aliases array71 * @aliases: The aliases array72 * @alias_mask_lock: Lock protecting alias_use_mask73 * @alias_use_mask: Bitmask for used aliases in aliases array74 * @i2c_nb: Notifier for remote client add & del events75 * @adapter: Array of adapters76 */77struct i2c_atr {78 struct i2c_adapter *parent;79 struct device *dev;80 const struct i2c_atr_ops *ops;81 82 void *priv;83 84 struct i2c_algorithm algo;85 /* lock for the I2C bus segment (see struct i2c_lock_operations) */86 struct mutex lock;87 int max_adapters;88 89 size_t num_aliases;90 const u16 *aliases;91 /* Protects alias_use_mask */92 spinlock_t alias_mask_lock;93 unsigned long *alias_use_mask;94 95 struct notifier_block i2c_nb;96 97 struct i2c_adapter *adapter[] __counted_by(max_adapters);98};99 100static struct i2c_atr_alias_pair *101i2c_atr_find_mapping_by_client(const struct list_head *list,102 const struct i2c_client *client)103{104 struct i2c_atr_alias_pair *c2a;105 106 list_for_each_entry(c2a, list, node) {107 if (c2a->client == client)108 return c2a;109 }110 111 return NULL;112}113 114static struct i2c_atr_alias_pair *115i2c_atr_find_mapping_by_addr(const struct list_head *list, u16 phys_addr)116{117 struct i2c_atr_alias_pair *c2a;118 119 list_for_each_entry(c2a, list, node) {120 if (c2a->client->addr == phys_addr)121 return c2a;122 }123 124 return NULL;125}126 127/*128 * Replace all message addresses with their aliases, saving the original129 * addresses.130 *131 * This function is internal for use in i2c_atr_master_xfer(). It must be132 * followed by i2c_atr_unmap_msgs() to restore the original addresses.133 */134static int i2c_atr_map_msgs(struct i2c_atr_chan *chan, struct i2c_msg *msgs,135 int num)136{137 struct i2c_atr *atr = chan->atr;138 static struct i2c_atr_alias_pair *c2a;139 int i;140 141 /* Ensure we have enough room to save the original addresses */142 if (unlikely(chan->orig_addrs_size < num)) {143 u16 *new_buf;144 145 /* We don't care about old data, hence no realloc() */146 new_buf = kmalloc_array(num, sizeof(*new_buf), GFP_KERNEL);147 if (!new_buf)148 return -ENOMEM;149 150 kfree(chan->orig_addrs);151 chan->orig_addrs = new_buf;152 chan->orig_addrs_size = num;153 }154 155 for (i = 0; i < num; i++) {156 chan->orig_addrs[i] = msgs[i].addr;157 158 c2a = i2c_atr_find_mapping_by_addr(&chan->alias_list,159 msgs[i].addr);160 if (!c2a) {161 dev_err(atr->dev, "client 0x%02x not mapped!\n",162 msgs[i].addr);163 164 while (i--)165 msgs[i].addr = chan->orig_addrs[i];166 167 return -ENXIO;168 }169 170 msgs[i].addr = c2a->alias;171 }172 173 return 0;174}175 176/*177 * Restore all message address aliases with the original addresses. This178 * function is internal for use in i2c_atr_master_xfer() and for this reason it179 * needs no null and size checks on orig_addr.180 *181 * @see i2c_atr_map_msgs()182 */183static void i2c_atr_unmap_msgs(struct i2c_atr_chan *chan, struct i2c_msg *msgs,184 int num)185{186 int i;187 188 for (i = 0; i < num; i++)189 msgs[i].addr = chan->orig_addrs[i];190}191 192static int i2c_atr_master_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,193 int num)194{195 struct i2c_atr_chan *chan = adap->algo_data;196 struct i2c_atr *atr = chan->atr;197 struct i2c_adapter *parent = atr->parent;198 int ret;199 200 /* Translate addresses */201 mutex_lock(&chan->orig_addrs_lock);202 203 ret = i2c_atr_map_msgs(chan, msgs, num);204 if (ret < 0)205 goto err_unlock;206 207 /* Perform the transfer */208 ret = i2c_transfer(parent, msgs, num);209 210 /* Restore addresses */211 i2c_atr_unmap_msgs(chan, msgs, num);212 213err_unlock:214 mutex_unlock(&chan->orig_addrs_lock);215 216 return ret;217}218 219static int i2c_atr_smbus_xfer(struct i2c_adapter *adap, u16 addr,220 unsigned short flags, char read_write, u8 command,221 int size, union i2c_smbus_data *data)222{223 struct i2c_atr_chan *chan = adap->algo_data;224 struct i2c_atr *atr = chan->atr;225 struct i2c_adapter *parent = atr->parent;226 struct i2c_atr_alias_pair *c2a;227 228 c2a = i2c_atr_find_mapping_by_addr(&chan->alias_list, addr);229 if (!c2a) {230 dev_err(atr->dev, "client 0x%02x not mapped!\n", addr);231 return -ENXIO;232 }233 234 return i2c_smbus_xfer(parent, c2a->alias, flags, read_write, command,235 size, data);236}237 238static u32 i2c_atr_functionality(struct i2c_adapter *adap)239{240 struct i2c_atr_chan *chan = adap->algo_data;241 struct i2c_adapter *parent = chan->atr->parent;242 243 return parent->algo->functionality(parent);244}245 246static void i2c_atr_lock_bus(struct i2c_adapter *adapter, unsigned int flags)247{248 struct i2c_atr_chan *chan = adapter->algo_data;249 struct i2c_atr *atr = chan->atr;250 251 mutex_lock(&atr->lock);252}253 254static int i2c_atr_trylock_bus(struct i2c_adapter *adapter, unsigned int flags)255{256 struct i2c_atr_chan *chan = adapter->algo_data;257 struct i2c_atr *atr = chan->atr;258 259 return mutex_trylock(&atr->lock);260}261 262static void i2c_atr_unlock_bus(struct i2c_adapter *adapter, unsigned int flags)263{264 struct i2c_atr_chan *chan = adapter->algo_data;265 struct i2c_atr *atr = chan->atr;266 267 mutex_unlock(&atr->lock);268}269 270static const struct i2c_lock_operations i2c_atr_lock_ops = {271 .lock_bus = i2c_atr_lock_bus,272 .trylock_bus = i2c_atr_trylock_bus,273 .unlock_bus = i2c_atr_unlock_bus,274};275 276static int i2c_atr_reserve_alias(struct i2c_atr *atr)277{278 unsigned long idx;279 280 spin_lock(&atr->alias_mask_lock);281 282 idx = find_first_zero_bit(atr->alias_use_mask, atr->num_aliases);283 if (idx >= atr->num_aliases) {284 spin_unlock(&atr->alias_mask_lock);285 dev_err(atr->dev, "failed to find a free alias\n");286 return -EBUSY;287 }288 289 set_bit(idx, atr->alias_use_mask);290 291 spin_unlock(&atr->alias_mask_lock);292 293 return atr->aliases[idx];294}295 296static void i2c_atr_release_alias(struct i2c_atr *atr, u16 alias)297{298 unsigned int idx;299 300 spin_lock(&atr->alias_mask_lock);301 302 for (idx = 0; idx < atr->num_aliases; ++idx) {303 if (atr->aliases[idx] == alias) {304 clear_bit(idx, atr->alias_use_mask);305 spin_unlock(&atr->alias_mask_lock);306 return;307 }308 }309 310 spin_unlock(&atr->alias_mask_lock);311 312 /* This should never happen */313 dev_warn(atr->dev, "Unable to find mapped alias\n");314}315 316static int i2c_atr_attach_client(struct i2c_adapter *adapter,317 const struct i2c_client *client)318{319 struct i2c_atr_chan *chan = adapter->algo_data;320 struct i2c_atr *atr = chan->atr;321 struct i2c_atr_alias_pair *c2a;322 u16 alias;323 int ret;324 325 ret = i2c_atr_reserve_alias(atr);326 if (ret < 0)327 return ret;328 329 alias = ret;330 331 c2a = kzalloc(sizeof(*c2a), GFP_KERNEL);332 if (!c2a) {333 ret = -ENOMEM;334 goto err_release_alias;335 }336 337 ret = atr->ops->attach_client(atr, chan->chan_id, client, alias);338 if (ret)339 goto err_free;340 341 dev_dbg(atr->dev, "chan%u: client 0x%02x mapped at alias 0x%02x (%s)\n",342 chan->chan_id, client->addr, alias, client->name);343 344 c2a->client = client;345 c2a->alias = alias;346 list_add(&c2a->node, &chan->alias_list);347 348 return 0;349 350err_free:351 kfree(c2a);352err_release_alias:353 i2c_atr_release_alias(atr, alias);354 355 return ret;356}357 358static void i2c_atr_detach_client(struct i2c_adapter *adapter,359 const struct i2c_client *client)360{361 struct i2c_atr_chan *chan = adapter->algo_data;362 struct i2c_atr *atr = chan->atr;363 struct i2c_atr_alias_pair *c2a;364 365 atr->ops->detach_client(atr, chan->chan_id, client);366 367 c2a = i2c_atr_find_mapping_by_client(&chan->alias_list, client);368 if (!c2a) {369 /* This should never happen */370 dev_warn(atr->dev, "Unable to find address mapping\n");371 return;372 }373 374 i2c_atr_release_alias(atr, c2a->alias);375 376 dev_dbg(atr->dev,377 "chan%u: client 0x%02x unmapped from alias 0x%02x (%s)\n",378 chan->chan_id, client->addr, c2a->alias, client->name);379 380 list_del(&c2a->node);381 kfree(c2a);382}383 384static int i2c_atr_bus_notifier_call(struct notifier_block *nb,385 unsigned long event, void *device)386{387 struct i2c_atr *atr = container_of(nb, struct i2c_atr, i2c_nb);388 struct device *dev = device;389 struct i2c_client *client;390 u32 chan_id;391 int ret;392 393 client = i2c_verify_client(dev);394 if (!client)395 return NOTIFY_DONE;396 397 /* Is the client in one of our adapters? */398 for (chan_id = 0; chan_id < atr->max_adapters; ++chan_id) {399 if (client->adapter == atr->adapter[chan_id])400 break;401 }402 403 if (chan_id == atr->max_adapters)404 return NOTIFY_DONE;405 406 switch (event) {407 case BUS_NOTIFY_ADD_DEVICE:408 ret = i2c_atr_attach_client(client->adapter, client);409 if (ret)410 dev_err(atr->dev,411 "Failed to attach remote client '%s': %d\n",412 dev_name(dev), ret);413 break;414 415 case BUS_NOTIFY_DEL_DEVICE:416 i2c_atr_detach_client(client->adapter, client);417 break;418 419 default:420 break;421 }422 423 return NOTIFY_DONE;424}425 426static int i2c_atr_parse_alias_pool(struct i2c_atr *atr)427{428 struct device *dev = atr->dev;429 unsigned long *alias_use_mask;430 size_t num_aliases;431 unsigned int i;432 u32 *aliases32;433 u16 *aliases16;434 int ret;435 436 ret = fwnode_property_count_u32(dev_fwnode(dev), "i2c-alias-pool");437 if (ret < 0) {438 dev_err(dev, "Failed to count 'i2c-alias-pool' property: %d\n",439 ret);440 return ret;441 }442 443 num_aliases = ret;444 445 if (!num_aliases)446 return 0;447 448 aliases32 = kcalloc(num_aliases, sizeof(*aliases32), GFP_KERNEL);449 if (!aliases32)450 return -ENOMEM;451 452 ret = fwnode_property_read_u32_array(dev_fwnode(dev), "i2c-alias-pool",453 aliases32, num_aliases);454 if (ret < 0) {455 dev_err(dev, "Failed to read 'i2c-alias-pool' property: %d\n",456 ret);457 goto err_free_aliases32;458 }459 460 aliases16 = kcalloc(num_aliases, sizeof(*aliases16), GFP_KERNEL);461 if (!aliases16) {462 ret = -ENOMEM;463 goto err_free_aliases32;464 }465 466 for (i = 0; i < num_aliases; i++) {467 if (!(aliases32[i] & 0xffff0000)) {468 aliases16[i] = aliases32[i];469 continue;470 }471 472 dev_err(dev, "Failed to parse 'i2c-alias-pool' property: I2C flags are not supported\n");473 ret = -EINVAL;474 goto err_free_aliases16;475 }476 477 alias_use_mask = bitmap_zalloc(num_aliases, GFP_KERNEL);478 if (!alias_use_mask) {479 ret = -ENOMEM;480 goto err_free_aliases16;481 }482 483 kfree(aliases32);484 485 atr->num_aliases = num_aliases;486 atr->aliases = aliases16;487 atr->alias_use_mask = alias_use_mask;488 489 dev_dbg(dev, "i2c-alias-pool has %zu aliases", atr->num_aliases);490 491 return 0;492 493err_free_aliases16:494 kfree(aliases16);495err_free_aliases32:496 kfree(aliases32);497 return ret;498}499 500struct i2c_atr *i2c_atr_new(struct i2c_adapter *parent, struct device *dev,501 const struct i2c_atr_ops *ops, int max_adapters)502{503 struct i2c_atr *atr;504 int ret;505 506 if (max_adapters > ATR_MAX_ADAPTERS)507 return ERR_PTR(-EINVAL);508 509 if (!ops || !ops->attach_client || !ops->detach_client)510 return ERR_PTR(-EINVAL);511 512 atr = kzalloc(struct_size(atr, adapter, max_adapters), GFP_KERNEL);513 if (!atr)514 return ERR_PTR(-ENOMEM);515 516 mutex_init(&atr->lock);517 spin_lock_init(&atr->alias_mask_lock);518 519 atr->parent = parent;520 atr->dev = dev;521 atr->ops = ops;522 atr->max_adapters = max_adapters;523 524 if (parent->algo->master_xfer)525 atr->algo.master_xfer = i2c_atr_master_xfer;526 if (parent->algo->smbus_xfer)527 atr->algo.smbus_xfer = i2c_atr_smbus_xfer;528 atr->algo.functionality = i2c_atr_functionality;529 530 ret = i2c_atr_parse_alias_pool(atr);531 if (ret)532 goto err_destroy_mutex;533 534 atr->i2c_nb.notifier_call = i2c_atr_bus_notifier_call;535 ret = bus_register_notifier(&i2c_bus_type, &atr->i2c_nb);536 if (ret)537 goto err_free_aliases;538 539 return atr;540 541err_free_aliases:542 bitmap_free(atr->alias_use_mask);543 kfree(atr->aliases);544err_destroy_mutex:545 mutex_destroy(&atr->lock);546 kfree(atr);547 548 return ERR_PTR(ret);549}550EXPORT_SYMBOL_NS_GPL(i2c_atr_new, I2C_ATR);551 552void i2c_atr_delete(struct i2c_atr *atr)553{554 unsigned int i;555 556 for (i = 0; i < atr->max_adapters; ++i)557 WARN_ON(atr->adapter[i]);558 559 bus_unregister_notifier(&i2c_bus_type, &atr->i2c_nb);560 bitmap_free(atr->alias_use_mask);561 kfree(atr->aliases);562 mutex_destroy(&atr->lock);563 kfree(atr);564}565EXPORT_SYMBOL_NS_GPL(i2c_atr_delete, I2C_ATR);566 567int i2c_atr_add_adapter(struct i2c_atr *atr, u32 chan_id,568 struct device *adapter_parent,569 struct fwnode_handle *bus_handle)570{571 struct i2c_adapter *parent = atr->parent;572 struct device *dev = atr->dev;573 struct i2c_atr_chan *chan;574 char symlink_name[ATR_MAX_SYMLINK_LEN];575 int ret;576 577 if (chan_id >= atr->max_adapters) {578 dev_err(dev, "No room for more i2c-atr adapters\n");579 return -EINVAL;580 }581 582 if (atr->adapter[chan_id]) {583 dev_err(dev, "Adapter %d already present\n", chan_id);584 return -EEXIST;585 }586 587 chan = kzalloc(sizeof(*chan), GFP_KERNEL);588 if (!chan)589 return -ENOMEM;590 591 if (!adapter_parent)592 adapter_parent = dev;593 594 chan->atr = atr;595 chan->chan_id = chan_id;596 INIT_LIST_HEAD(&chan->alias_list);597 mutex_init(&chan->orig_addrs_lock);598 599 snprintf(chan->adap.name, sizeof(chan->adap.name), "i2c-%d-atr-%d",600 i2c_adapter_id(parent), chan_id);601 chan->adap.owner = THIS_MODULE;602 chan->adap.algo = &atr->algo;603 chan->adap.algo_data = chan;604 chan->adap.dev.parent = adapter_parent;605 chan->adap.retries = parent->retries;606 chan->adap.timeout = parent->timeout;607 chan->adap.quirks = parent->quirks;608 chan->adap.lock_ops = &i2c_atr_lock_ops;609 610 if (bus_handle) {611 device_set_node(&chan->adap.dev, fwnode_handle_get(bus_handle));612 } else {613 struct fwnode_handle *atr_node;614 struct fwnode_handle *child;615 u32 reg;616 617 atr_node = device_get_named_child_node(dev, "i2c-atr");618 619 fwnode_for_each_child_node(atr_node, child) {620 ret = fwnode_property_read_u32(child, "reg", ®);621 if (ret)622 continue;623 if (chan_id == reg)624 break;625 }626 627 device_set_node(&chan->adap.dev, child);628 fwnode_handle_put(atr_node);629 }630 631 atr->adapter[chan_id] = &chan->adap;632 633 ret = i2c_add_adapter(&chan->adap);634 if (ret) {635 dev_err(dev, "failed to add atr-adapter %u (error=%d)\n",636 chan_id, ret);637 goto err_fwnode_put;638 }639 640 snprintf(symlink_name, sizeof(symlink_name), "channel-%u",641 chan->chan_id);642 643 ret = sysfs_create_link(&chan->adap.dev.kobj, &dev->kobj, "atr_device");644 if (ret)645 dev_warn(dev, "can't create symlink to atr device\n");646 ret = sysfs_create_link(&dev->kobj, &chan->adap.dev.kobj, symlink_name);647 if (ret)648 dev_warn(dev, "can't create symlink for channel %u\n", chan_id);649 650 dev_dbg(dev, "Added ATR child bus %d\n", i2c_adapter_id(&chan->adap));651 652 return 0;653 654err_fwnode_put:655 fwnode_handle_put(dev_fwnode(&chan->adap.dev));656 mutex_destroy(&chan->orig_addrs_lock);657 kfree(chan);658 return ret;659}660EXPORT_SYMBOL_NS_GPL(i2c_atr_add_adapter, I2C_ATR);661 662void i2c_atr_del_adapter(struct i2c_atr *atr, u32 chan_id)663{664 char symlink_name[ATR_MAX_SYMLINK_LEN];665 struct i2c_adapter *adap;666 struct i2c_atr_chan *chan;667 struct fwnode_handle *fwnode;668 struct device *dev = atr->dev;669 670 adap = atr->adapter[chan_id];671 if (!adap)672 return;673 674 chan = adap->algo_data;675 fwnode = dev_fwnode(&adap->dev);676 677 dev_dbg(dev, "Removing ATR child bus %d\n", i2c_adapter_id(adap));678 679 snprintf(symlink_name, sizeof(symlink_name), "channel-%u",680 chan->chan_id);681 sysfs_remove_link(&dev->kobj, symlink_name);682 sysfs_remove_link(&chan->adap.dev.kobj, "atr_device");683 684 i2c_del_adapter(adap);685 686 atr->adapter[chan_id] = NULL;687 688 fwnode_handle_put(fwnode);689 mutex_destroy(&chan->orig_addrs_lock);690 kfree(chan->orig_addrs);691 kfree(chan);692}693EXPORT_SYMBOL_NS_GPL(i2c_atr_del_adapter, I2C_ATR);694 695void i2c_atr_set_driver_data(struct i2c_atr *atr, void *data)696{697 atr->priv = data;698}699EXPORT_SYMBOL_NS_GPL(i2c_atr_set_driver_data, I2C_ATR);700 701void *i2c_atr_get_driver_data(struct i2c_atr *atr)702{703 return atr->priv;704}705EXPORT_SYMBOL_NS_GPL(i2c_atr_get_driver_data, I2C_ATR);706 707MODULE_AUTHOR("Luca Ceresoli <luca.ceresoli@bootlin.com>");708MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ideasonboard.com>");709MODULE_DESCRIPTION("I2C Address Translator");710MODULE_LICENSE("GPL");711