1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * I2C Address Translator 4 * 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.c 9 */ 10 11 #include <linux/i2c-atr.h> 12 #include <linux/i2c.h> 13 #include <linux/kernel.h> 14 #include <linux/module.h> 15 #include <linux/mutex.h> 16 #include <linux/property.h> 17 #include <linux/slab.h> 18 #include <linux/spinlock.h> 19 #include <linux/lockdep.h> 20 21 #define ATR_MAX_ADAPTERS 100 /* Just a sanity limit */ 22 #define ATR_MAX_SYMLINK_LEN 11 /* Longest name is 10 chars: "channel-99" */ 23 24 /** 25 * struct i2c_atr_alias_pair - Holds the alias assigned to a client address. 26 * @node: List node 27 * @addr: Address of the client on the child bus. 28 * @alias: I2C alias address assigned by the driver. 29 * This is the address that will be used to issue I2C transactions 30 * on the parent (physical) bus. 31 * @fixed: Alias pair cannot be replaced during dynamic address attachment. 32 * This flag is necessary for situations where a single I2C transaction 33 * contains more distinct target addresses than the ATR channel can handle. 34 * It marks addresses that have already been attached to an alias so 35 * that their alias pair is not evicted by a subsequent address in the same 36 * transaction. 37 * 38 */ 39 struct i2c_atr_alias_pair { 40 struct list_head node; 41 bool fixed; 42 u16 addr; 43 u16 alias; 44 }; 45 46 /** 47 * struct i2c_atr_alias_pool - Pool of client aliases available for an ATR. 48 * @size: Total number of aliases 49 * @shared: Indicates if this alias pool is shared by multiple channels 50 * 51 * @lock: Lock protecting @aliases and @use_mask 52 * @aliases: Array of aliases, must hold exactly @size elements 53 * @use_mask: Mask of used aliases 54 */ 55 struct i2c_atr_alias_pool { 56 size_t size; 57 bool shared; 58 59 /* Protects aliases and use_mask */ 60 spinlock_t lock; 61 u16 *aliases; 62 unsigned long *use_mask; 63 }; 64 65 /** 66 * struct i2c_atr_chan - Data for a channel. 67 * @adap: The &struct i2c_adapter for the channel 68 * @atr: The parent I2C ATR 69 * @chan_id: The ID of this channel 70 * @alias_pairs_lock: Mutex protecting @alias_pairs 71 * @alias_pairs_lock_key: Lock key for @alias_pairs_lock 72 * @alias_pairs: List of @struct i2c_atr_alias_pair containing the 73 * assigned aliases 74 * @alias_pool: Pool of available client aliases 75 * 76 * @orig_addrs_lock: Mutex protecting @orig_addrs 77 * @orig_addrs_lock_key: Lock key for @orig_addrs_lock 78 * @orig_addrs: Buffer used to store the original addresses during transmit 79 * @orig_addrs_size: Size of @orig_addrs 80 */ 81 struct i2c_atr_chan { 82 struct i2c_adapter adap; 83 struct i2c_atr *atr; 84 u32 chan_id; 85 86 /* Lock alias_pairs during attach/detach */ 87 struct mutex alias_pairs_lock; 88 struct lock_class_key alias_pairs_lock_key; 89 struct list_head alias_pairs; 90 struct i2c_atr_alias_pool *alias_pool; 91 92 /* Lock orig_addrs during xfer */ 93 struct mutex orig_addrs_lock; 94 struct lock_class_key orig_addrs_lock_key; 95 u16 *orig_addrs; 96 unsigned int orig_addrs_size; 97 }; 98 99 /** 100 * struct i2c_atr - The I2C ATR instance 101 * @parent: The parent &struct i2c_adapter 102 * @dev: The device that owns the I2C ATR instance 103 * @ops: &struct i2c_atr_ops 104 * @priv: Private driver data, set with i2c_atr_set_driver_data() 105 * @algo: The &struct i2c_algorithm for adapters 106 * @lock: Lock for the I2C bus segment (see &struct i2c_lock_operations) 107 * @lock_key: Lock key for @lock 108 * @max_adapters: Maximum number of adapters this I2C ATR can have 109 * @flags: Flags for ATR 110 * @alias_pool: Optional common pool of available client aliases 111 * @i2c_nb: Notifier for remote client add & del events 112 * @adapter: Array of adapters 113 */ 114 struct i2c_atr { 115 struct i2c_adapter *parent; 116 struct device *dev; 117 const struct i2c_atr_ops *ops; 118 119 void *priv; 120 121 struct i2c_algorithm algo; 122 /* lock for the I2C bus segment (see struct i2c_lock_operations) */ 123 struct mutex lock; 124 struct lock_class_key lock_key; 125 int max_adapters; 126 u32 flags; 127 128 struct i2c_atr_alias_pool *alias_pool; 129 130 struct notifier_block i2c_nb; 131 132 struct i2c_adapter *adapter[] __counted_by(max_adapters); 133 }; 134 135 static struct i2c_atr_alias_pool *i2c_atr_alloc_alias_pool(size_t num_aliases, bool shared) 136 { 137 struct i2c_atr_alias_pool *alias_pool; 138 int ret; 139 140 alias_pool = kzalloc(sizeof(*alias_pool), GFP_KERNEL); 141 if (!alias_pool) 142 return ERR_PTR(-ENOMEM); 143 144 alias_pool->size = num_aliases; 145 146 alias_pool->aliases = kcalloc(num_aliases, sizeof(*alias_pool->aliases), GFP_KERNEL); 147 if (!alias_pool->aliases) { 148 ret = -ENOMEM; 149 goto err_free_alias_pool; 150 } 151 152 alias_pool->use_mask = bitmap_zalloc(num_aliases, GFP_KERNEL); 153 if (!alias_pool->use_mask) { 154 ret = -ENOMEM; 155 goto err_free_aliases; 156 } 157 158 alias_pool->shared = shared; 159 160 spin_lock_init(&alias_pool->lock); 161 162 return alias_pool; 163 164 err_free_aliases: 165 kfree(alias_pool->aliases); 166 err_free_alias_pool: 167 kfree(alias_pool); 168 return ERR_PTR(ret); 169 } 170 171 static void i2c_atr_free_alias_pool(struct i2c_atr_alias_pool *alias_pool) 172 { 173 bitmap_free(alias_pool->use_mask); 174 kfree(alias_pool->aliases); 175 kfree(alias_pool); 176 } 177 178 /* Must be called with alias_pairs_lock held */ 179 static struct i2c_atr_alias_pair *i2c_atr_create_c2a(struct i2c_atr_chan *chan, 180 u16 alias, u16 addr) 181 { 182 struct i2c_atr_alias_pair *c2a; 183 184 lockdep_assert_held(&chan->alias_pairs_lock); 185 186 c2a = kzalloc(sizeof(*c2a), GFP_KERNEL); 187 if (!c2a) 188 return NULL; 189 190 c2a->addr = addr; 191 c2a->alias = alias; 192 193 list_add(&c2a->node, &chan->alias_pairs); 194 195 return c2a; 196 } 197 198 /* Must be called with alias_pairs_lock held */ 199 static void i2c_atr_destroy_c2a(struct i2c_atr_alias_pair **pc2a) 200 { 201 list_del(&(*pc2a)->node); 202 kfree(*pc2a); 203 *pc2a = NULL; 204 } 205 206 static int i2c_atr_reserve_alias(struct i2c_atr_alias_pool *alias_pool) 207 { 208 unsigned long idx; 209 u16 alias; 210 211 spin_lock(&alias_pool->lock); 212 213 idx = find_first_zero_bit(alias_pool->use_mask, alias_pool->size); 214 if (idx >= alias_pool->size) { 215 spin_unlock(&alias_pool->lock); 216 return -EBUSY; 217 } 218 219 set_bit(idx, alias_pool->use_mask); 220 221 alias = alias_pool->aliases[idx]; 222 223 spin_unlock(&alias_pool->lock); 224 return alias; 225 } 226 227 static void i2c_atr_release_alias(struct i2c_atr_alias_pool *alias_pool, u16 alias) 228 { 229 unsigned int idx; 230 231 spin_lock(&alias_pool->lock); 232 233 for (idx = 0; idx < alias_pool->size; ++idx) { 234 if (alias_pool->aliases[idx] == alias) { 235 clear_bit(idx, alias_pool->use_mask); 236 spin_unlock(&alias_pool->lock); 237 return; 238 } 239 } 240 241 spin_unlock(&alias_pool->lock); 242 } 243 244 static struct i2c_atr_alias_pair * 245 i2c_atr_find_mapping_by_addr(struct i2c_atr_chan *chan, u16 addr) 246 { 247 struct i2c_atr_alias_pair *c2a; 248 249 lockdep_assert_held(&chan->alias_pairs_lock); 250 251 list_for_each_entry(c2a, &chan->alias_pairs, node) { 252 if (c2a->addr == addr) 253 return c2a; 254 } 255 256 return NULL; 257 } 258 259 static struct i2c_atr_alias_pair * 260 i2c_atr_create_mapping_by_addr(struct i2c_atr_chan *chan, u16 addr) 261 { 262 struct i2c_atr *atr = chan->atr; 263 struct i2c_atr_alias_pair *c2a; 264 u16 alias; 265 int ret; 266 267 lockdep_assert_held(&chan->alias_pairs_lock); 268 269 ret = i2c_atr_reserve_alias(chan->alias_pool); 270 if (ret < 0) 271 return NULL; 272 273 alias = ret; 274 275 c2a = i2c_atr_create_c2a(chan, alias, addr); 276 if (!c2a) 277 goto err_release_alias; 278 279 ret = atr->ops->attach_addr(atr, chan->chan_id, c2a->addr, c2a->alias); 280 if (ret) { 281 dev_err(atr->dev, "failed to attach 0x%02x on channel %d: err %d\n", 282 addr, chan->chan_id, ret); 283 goto err_del_c2a; 284 } 285 286 return c2a; 287 288 err_del_c2a: 289 i2c_atr_destroy_c2a(&c2a); 290 err_release_alias: 291 i2c_atr_release_alias(chan->alias_pool, alias); 292 return NULL; 293 } 294 295 static struct i2c_atr_alias_pair * 296 i2c_atr_replace_mapping_by_addr(struct i2c_atr_chan *chan, u16 addr) 297 { 298 struct i2c_atr *atr = chan->atr; 299 struct i2c_atr_alias_pair *c2a; 300 struct list_head *alias_pairs; 301 bool found = false; 302 u16 alias; 303 int ret; 304 305 lockdep_assert_held(&chan->alias_pairs_lock); 306 307 alias_pairs = &chan->alias_pairs; 308 309 if (unlikely(list_empty(alias_pairs))) 310 return NULL; 311 312 list_for_each_entry_reverse(c2a, alias_pairs, node) { 313 if (!c2a->fixed) { 314 found = true; 315 break; 316 } 317 } 318 319 if (!found) 320 return NULL; 321 322 atr->ops->detach_addr(atr, chan->chan_id, c2a->addr); 323 c2a->addr = addr; 324 325 list_move(&c2a->node, alias_pairs); 326 327 alias = c2a->alias; 328 329 ret = atr->ops->attach_addr(atr, chan->chan_id, c2a->addr, c2a->alias); 330 if (ret) { 331 dev_err(atr->dev, "failed to attach 0x%02x on channel %d: err %d\n", 332 addr, chan->chan_id, ret); 333 i2c_atr_destroy_c2a(&c2a); 334 i2c_atr_release_alias(chan->alias_pool, alias); 335 return NULL; 336 } 337 338 return c2a; 339 } 340 341 static struct i2c_atr_alias_pair * 342 i2c_atr_get_mapping_by_addr(struct i2c_atr_chan *chan, u16 addr) 343 { 344 struct i2c_atr *atr = chan->atr; 345 struct i2c_atr_alias_pair *c2a; 346 347 c2a = i2c_atr_find_mapping_by_addr(chan, addr); 348 if (c2a) 349 return c2a; 350 351 if (atr->flags & I2C_ATR_F_STATIC) 352 return NULL; 353 354 c2a = i2c_atr_create_mapping_by_addr(chan, addr); 355 if (c2a) 356 return c2a; 357 358 return i2c_atr_replace_mapping_by_addr(chan, addr); 359 } 360 361 /* 362 * Replace all message addresses with their aliases, saving the original 363 * addresses. 364 * 365 * This function is internal for use in i2c_atr_master_xfer(). It must be 366 * followed by i2c_atr_unmap_msgs() to restore the original addresses. 367 */ 368 static int i2c_atr_map_msgs(struct i2c_atr_chan *chan, struct i2c_msg *msgs, 369 int num) 370 { 371 struct i2c_atr *atr = chan->atr; 372 static struct i2c_atr_alias_pair *c2a; 373 int i, ret = 0; 374 375 /* Ensure we have enough room to save the original addresses */ 376 if (unlikely(chan->orig_addrs_size < num)) { 377 u16 *new_buf; 378 379 /* We don't care about old data, hence no realloc() */ 380 new_buf = kmalloc_array(num, sizeof(*new_buf), GFP_KERNEL); 381 if (!new_buf) 382 return -ENOMEM; 383 384 kfree(chan->orig_addrs); 385 chan->orig_addrs = new_buf; 386 chan->orig_addrs_size = num; 387 } 388 389 mutex_lock(&chan->alias_pairs_lock); 390 391 for (i = 0; i < num; i++) { 392 chan->orig_addrs[i] = msgs[i].addr; 393 394 c2a = i2c_atr_get_mapping_by_addr(chan, msgs[i].addr); 395 396 if (!c2a) { 397 if (atr->flags & I2C_ATR_F_PASSTHROUGH) 398 continue; 399 400 dev_err(atr->dev, "client 0x%02x not mapped!\n", 401 msgs[i].addr); 402 403 while (i--) 404 msgs[i].addr = chan->orig_addrs[i]; 405 406 ret = -ENXIO; 407 goto out_unlock; 408 } 409 410 // Prevent c2a from being overwritten by another client in this transaction 411 c2a->fixed = true; 412 413 msgs[i].addr = c2a->alias; 414 } 415 416 out_unlock: 417 mutex_unlock(&chan->alias_pairs_lock); 418 return ret; 419 } 420 421 /* 422 * Restore all message address aliases with the original addresses. This 423 * function is internal for use in i2c_atr_master_xfer() and for this reason it 424 * needs no null and size checks on orig_addr. 425 * 426 * @see i2c_atr_map_msgs() 427 */ 428 static void i2c_atr_unmap_msgs(struct i2c_atr_chan *chan, struct i2c_msg *msgs, 429 int num) 430 { 431 struct i2c_atr_alias_pair *c2a; 432 int i; 433 434 for (i = 0; i < num; i++) 435 msgs[i].addr = chan->orig_addrs[i]; 436 437 mutex_lock(&chan->alias_pairs_lock); 438 439 if (unlikely(list_empty(&chan->alias_pairs))) 440 goto out_unlock; 441 442 // unfix c2a entries so that subsequent transfers can reuse their aliases 443 list_for_each_entry(c2a, &chan->alias_pairs, node) { 444 c2a->fixed = false; 445 } 446 447 out_unlock: 448 mutex_unlock(&chan->alias_pairs_lock); 449 } 450 451 static int i2c_atr_master_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, 452 int num) 453 { 454 struct i2c_atr_chan *chan = adap->algo_data; 455 struct i2c_atr *atr = chan->atr; 456 struct i2c_adapter *parent = atr->parent; 457 int ret; 458 459 /* Translate addresses */ 460 mutex_lock(&chan->orig_addrs_lock); 461 462 ret = i2c_atr_map_msgs(chan, msgs, num); 463 if (ret < 0) 464 goto err_unlock; 465 466 /* Perform the transfer */ 467 ret = i2c_transfer(parent, msgs, num); 468 469 /* Restore addresses */ 470 i2c_atr_unmap_msgs(chan, msgs, num); 471 472 err_unlock: 473 mutex_unlock(&chan->orig_addrs_lock); 474 475 return ret; 476 } 477 478 static int i2c_atr_smbus_xfer(struct i2c_adapter *adap, u16 addr, 479 unsigned short flags, char read_write, u8 command, 480 int size, union i2c_smbus_data *data) 481 { 482 struct i2c_atr_chan *chan = adap->algo_data; 483 struct i2c_atr *atr = chan->atr; 484 struct i2c_adapter *parent = atr->parent; 485 struct i2c_atr_alias_pair *c2a; 486 u16 alias; 487 488 mutex_lock(&chan->alias_pairs_lock); 489 490 c2a = i2c_atr_get_mapping_by_addr(chan, addr); 491 492 if (!c2a && !(atr->flags & I2C_ATR_F_PASSTHROUGH)) { 493 dev_err(atr->dev, "client 0x%02x not mapped!\n", addr); 494 mutex_unlock(&chan->alias_pairs_lock); 495 return -ENXIO; 496 } 497 498 alias = c2a ? c2a->alias : addr; 499 500 mutex_unlock(&chan->alias_pairs_lock); 501 502 return i2c_smbus_xfer(parent, alias, flags, read_write, command, 503 size, data); 504 } 505 506 static u32 i2c_atr_functionality(struct i2c_adapter *adap) 507 { 508 struct i2c_atr_chan *chan = adap->algo_data; 509 struct i2c_adapter *parent = chan->atr->parent; 510 511 return parent->algo->functionality(parent); 512 } 513 514 static void i2c_atr_lock_bus(struct i2c_adapter *adapter, unsigned int flags) 515 { 516 struct i2c_atr_chan *chan = adapter->algo_data; 517 struct i2c_atr *atr = chan->atr; 518 519 mutex_lock(&atr->lock); 520 } 521 522 static int i2c_atr_trylock_bus(struct i2c_adapter *adapter, unsigned int flags) 523 { 524 struct i2c_atr_chan *chan = adapter->algo_data; 525 struct i2c_atr *atr = chan->atr; 526 527 return mutex_trylock(&atr->lock); 528 } 529 530 static void i2c_atr_unlock_bus(struct i2c_adapter *adapter, unsigned int flags) 531 { 532 struct i2c_atr_chan *chan = adapter->algo_data; 533 struct i2c_atr *atr = chan->atr; 534 535 mutex_unlock(&atr->lock); 536 } 537 538 static const struct i2c_lock_operations i2c_atr_lock_ops = { 539 .lock_bus = i2c_atr_lock_bus, 540 .trylock_bus = i2c_atr_trylock_bus, 541 .unlock_bus = i2c_atr_unlock_bus, 542 }; 543 544 static int i2c_atr_attach_addr(struct i2c_adapter *adapter, 545 u16 addr) 546 { 547 struct i2c_atr_chan *chan = adapter->algo_data; 548 struct i2c_atr *atr = chan->atr; 549 struct i2c_atr_alias_pair *c2a; 550 int ret = 0; 551 552 mutex_lock(&chan->alias_pairs_lock); 553 554 c2a = i2c_atr_create_mapping_by_addr(chan, addr); 555 if (!c2a && !(atr->flags & I2C_ATR_F_STATIC)) 556 c2a = i2c_atr_replace_mapping_by_addr(chan, addr); 557 558 if (!c2a) { 559 dev_err(atr->dev, "failed to find a free alias\n"); 560 ret = -EBUSY; 561 goto out_unlock; 562 } 563 564 dev_dbg(atr->dev, "chan%u: using alias 0x%02x for addr 0x%02x\n", 565 chan->chan_id, c2a->alias, addr); 566 567 out_unlock: 568 mutex_unlock(&chan->alias_pairs_lock); 569 return ret; 570 } 571 572 static void i2c_atr_detach_addr(struct i2c_adapter *adapter, 573 u16 addr) 574 { 575 struct i2c_atr_chan *chan = adapter->algo_data; 576 struct i2c_atr *atr = chan->atr; 577 struct i2c_atr_alias_pair *c2a; 578 579 atr->ops->detach_addr(atr, chan->chan_id, addr); 580 581 mutex_lock(&chan->alias_pairs_lock); 582 583 c2a = i2c_atr_find_mapping_by_addr(chan, addr); 584 if (!c2a) { 585 mutex_unlock(&chan->alias_pairs_lock); 586 return; 587 } 588 589 i2c_atr_release_alias(chan->alias_pool, c2a->alias); 590 591 dev_dbg(atr->dev, 592 "chan%u: detached alias 0x%02x from addr 0x%02x\n", 593 chan->chan_id, c2a->alias, addr); 594 595 i2c_atr_destroy_c2a(&c2a); 596 597 mutex_unlock(&chan->alias_pairs_lock); 598 } 599 600 static int i2c_atr_bus_notifier_call(struct notifier_block *nb, 601 unsigned long event, void *device) 602 { 603 struct i2c_atr *atr = container_of(nb, struct i2c_atr, i2c_nb); 604 struct device *dev = device; 605 struct i2c_client *client; 606 u32 chan_id; 607 int ret; 608 609 client = i2c_verify_client(dev); 610 if (!client) 611 return NOTIFY_DONE; 612 613 /* Is the client in one of our adapters? */ 614 for (chan_id = 0; chan_id < atr->max_adapters; ++chan_id) { 615 if (client->adapter == atr->adapter[chan_id]) 616 break; 617 } 618 619 if (chan_id == atr->max_adapters) 620 return NOTIFY_DONE; 621 622 switch (event) { 623 case BUS_NOTIFY_ADD_DEVICE: 624 ret = i2c_atr_attach_addr(client->adapter, client->addr); 625 if (ret) 626 dev_err(atr->dev, 627 "Failed to attach remote client '%s': %d\n", 628 dev_name(dev), ret); 629 break; 630 631 case BUS_NOTIFY_REMOVED_DEVICE: 632 i2c_atr_detach_addr(client->adapter, client->addr); 633 break; 634 635 default: 636 break; 637 } 638 639 return NOTIFY_DONE; 640 } 641 642 static int i2c_atr_parse_alias_pool(struct i2c_atr *atr) 643 { 644 struct i2c_atr_alias_pool *alias_pool; 645 struct device *dev = atr->dev; 646 size_t num_aliases; 647 unsigned int i; 648 u32 *aliases32; 649 int ret; 650 651 if (!fwnode_property_present(dev_fwnode(dev), "i2c-alias-pool")) { 652 num_aliases = 0; 653 } else { 654 ret = fwnode_property_count_u32(dev_fwnode(dev), "i2c-alias-pool"); 655 if (ret < 0) { 656 dev_err(dev, "Failed to count 'i2c-alias-pool' property: %d\n", 657 ret); 658 return ret; 659 } 660 661 num_aliases = ret; 662 } 663 664 alias_pool = i2c_atr_alloc_alias_pool(num_aliases, true); 665 if (IS_ERR(alias_pool)) { 666 ret = PTR_ERR(alias_pool); 667 dev_err(dev, "Failed to allocate alias pool, err %d\n", ret); 668 return ret; 669 } 670 671 atr->alias_pool = alias_pool; 672 673 if (!alias_pool->size) 674 return 0; 675 676 aliases32 = kcalloc(num_aliases, sizeof(*aliases32), GFP_KERNEL); 677 if (!aliases32) { 678 ret = -ENOMEM; 679 goto err_free_alias_pool; 680 } 681 682 ret = fwnode_property_read_u32_array(dev_fwnode(dev), "i2c-alias-pool", 683 aliases32, num_aliases); 684 if (ret < 0) { 685 dev_err(dev, "Failed to read 'i2c-alias-pool' property: %d\n", 686 ret); 687 goto err_free_aliases32; 688 } 689 690 for (i = 0; i < num_aliases; i++) { 691 if (!(aliases32[i] & 0xffff0000)) { 692 alias_pool->aliases[i] = aliases32[i]; 693 continue; 694 } 695 696 dev_err(dev, "Failed to parse 'i2c-alias-pool' property: I2C flags are not supported\n"); 697 ret = -EINVAL; 698 goto err_free_aliases32; 699 } 700 701 kfree(aliases32); 702 703 dev_dbg(dev, "i2c-alias-pool has %zu aliases\n", alias_pool->size); 704 705 return 0; 706 707 err_free_aliases32: 708 kfree(aliases32); 709 err_free_alias_pool: 710 i2c_atr_free_alias_pool(alias_pool); 711 return ret; 712 } 713 714 struct i2c_atr *i2c_atr_new(struct i2c_adapter *parent, struct device *dev, 715 const struct i2c_atr_ops *ops, int max_adapters, 716 u32 flags) 717 { 718 struct i2c_atr *atr; 719 int ret; 720 721 if (max_adapters > ATR_MAX_ADAPTERS) 722 return ERR_PTR(-EINVAL); 723 724 if (!ops || !ops->attach_addr || !ops->detach_addr) 725 return ERR_PTR(-EINVAL); 726 727 atr = kzalloc(struct_size(atr, adapter, max_adapters), GFP_KERNEL); 728 if (!atr) 729 return ERR_PTR(-ENOMEM); 730 731 lockdep_register_key(&atr->lock_key); 732 mutex_init_with_key(&atr->lock, &atr->lock_key); 733 734 atr->parent = parent; 735 atr->dev = dev; 736 atr->ops = ops; 737 atr->max_adapters = max_adapters; 738 atr->flags = flags; 739 740 if (parent->algo->master_xfer) 741 atr->algo.xfer = i2c_atr_master_xfer; 742 if (parent->algo->smbus_xfer) 743 atr->algo.smbus_xfer = i2c_atr_smbus_xfer; 744 atr->algo.functionality = i2c_atr_functionality; 745 746 ret = i2c_atr_parse_alias_pool(atr); 747 if (ret) 748 goto err_destroy_mutex; 749 750 atr->i2c_nb.notifier_call = i2c_atr_bus_notifier_call; 751 ret = bus_register_notifier(&i2c_bus_type, &atr->i2c_nb); 752 if (ret) 753 goto err_free_alias_pool; 754 755 return atr; 756 757 err_free_alias_pool: 758 i2c_atr_free_alias_pool(atr->alias_pool); 759 err_destroy_mutex: 760 mutex_destroy(&atr->lock); 761 lockdep_unregister_key(&atr->lock_key); 762 kfree(atr); 763 764 return ERR_PTR(ret); 765 } 766 EXPORT_SYMBOL_NS_GPL(i2c_atr_new, "I2C_ATR"); 767 768 void i2c_atr_delete(struct i2c_atr *atr) 769 { 770 unsigned int i; 771 772 for (i = 0; i < atr->max_adapters; ++i) 773 WARN_ON(atr->adapter[i]); 774 775 bus_unregister_notifier(&i2c_bus_type, &atr->i2c_nb); 776 i2c_atr_free_alias_pool(atr->alias_pool); 777 mutex_destroy(&atr->lock); 778 lockdep_unregister_key(&atr->lock_key); 779 kfree(atr); 780 } 781 EXPORT_SYMBOL_NS_GPL(i2c_atr_delete, "I2C_ATR"); 782 783 int i2c_atr_add_adapter(struct i2c_atr *atr, struct i2c_atr_adap_desc *desc) 784 { 785 struct fwnode_handle *bus_handle = desc->bus_handle; 786 struct i2c_adapter *parent = atr->parent; 787 char symlink_name[ATR_MAX_SYMLINK_LEN]; 788 struct device *dev = atr->dev; 789 u32 chan_id = desc->chan_id; 790 struct i2c_atr_chan *chan; 791 int ret, idx; 792 793 if (chan_id >= atr->max_adapters) { 794 dev_err(dev, "No room for more i2c-atr adapters\n"); 795 return -EINVAL; 796 } 797 798 if (atr->adapter[chan_id]) { 799 dev_err(dev, "Adapter %d already present\n", chan_id); 800 return -EEXIST; 801 } 802 803 chan = kzalloc(sizeof(*chan), GFP_KERNEL); 804 if (!chan) 805 return -ENOMEM; 806 807 if (!desc->parent) 808 desc->parent = dev; 809 810 chan->atr = atr; 811 chan->chan_id = chan_id; 812 INIT_LIST_HEAD(&chan->alias_pairs); 813 lockdep_register_key(&chan->alias_pairs_lock_key); 814 lockdep_register_key(&chan->orig_addrs_lock_key); 815 mutex_init_with_key(&chan->alias_pairs_lock, &chan->alias_pairs_lock_key); 816 mutex_init_with_key(&chan->orig_addrs_lock, &chan->orig_addrs_lock_key); 817 818 snprintf(chan->adap.name, sizeof(chan->adap.name), "i2c-%d-atr-%d", 819 i2c_adapter_id(parent), chan_id); 820 chan->adap.owner = THIS_MODULE; 821 chan->adap.algo = &atr->algo; 822 chan->adap.algo_data = chan; 823 chan->adap.dev.parent = desc->parent; 824 chan->adap.retries = parent->retries; 825 chan->adap.timeout = parent->timeout; 826 chan->adap.quirks = parent->quirks; 827 chan->adap.lock_ops = &i2c_atr_lock_ops; 828 829 if (bus_handle) { 830 device_set_node(&chan->adap.dev, fwnode_handle_get(bus_handle)); 831 } else { 832 struct fwnode_handle *atr_node; 833 struct fwnode_handle *child; 834 u32 reg; 835 836 atr_node = device_get_named_child_node(dev, "i2c-atr"); 837 838 fwnode_for_each_child_node(atr_node, child) { 839 ret = fwnode_property_read_u32(child, "reg", ®); 840 if (ret) 841 continue; 842 if (chan_id == reg) 843 break; 844 } 845 846 device_set_node(&chan->adap.dev, child); 847 fwnode_handle_put(atr_node); 848 } 849 850 if (desc->num_aliases > 0) { 851 chan->alias_pool = i2c_atr_alloc_alias_pool(desc->num_aliases, false); 852 if (IS_ERR(chan->alias_pool)) { 853 ret = PTR_ERR(chan->alias_pool); 854 goto err_fwnode_put; 855 } 856 857 for (idx = 0; idx < desc->num_aliases; idx++) 858 chan->alias_pool->aliases[idx] = desc->aliases[idx]; 859 } else { 860 chan->alias_pool = atr->alias_pool; 861 } 862 863 atr->adapter[chan_id] = &chan->adap; 864 865 ret = i2c_add_adapter(&chan->adap); 866 if (ret) { 867 dev_err(dev, "failed to add atr-adapter %u (error=%d)\n", 868 chan_id, ret); 869 goto err_free_alias_pool; 870 } 871 872 snprintf(symlink_name, sizeof(symlink_name), "channel-%u", 873 chan->chan_id); 874 875 ret = sysfs_create_link(&chan->adap.dev.kobj, &dev->kobj, "atr_device"); 876 if (ret) 877 dev_warn(dev, "can't create symlink to atr device\n"); 878 ret = sysfs_create_link(&dev->kobj, &chan->adap.dev.kobj, symlink_name); 879 if (ret) 880 dev_warn(dev, "can't create symlink for channel %u\n", chan_id); 881 882 dev_dbg(dev, "Added ATR child bus %d\n", i2c_adapter_id(&chan->adap)); 883 884 return 0; 885 886 err_free_alias_pool: 887 if (!chan->alias_pool->shared) 888 i2c_atr_free_alias_pool(chan->alias_pool); 889 err_fwnode_put: 890 fwnode_handle_put(dev_fwnode(&chan->adap.dev)); 891 mutex_destroy(&chan->orig_addrs_lock); 892 mutex_destroy(&chan->alias_pairs_lock); 893 lockdep_unregister_key(&chan->orig_addrs_lock_key); 894 lockdep_unregister_key(&chan->alias_pairs_lock_key); 895 kfree(chan); 896 return ret; 897 } 898 EXPORT_SYMBOL_NS_GPL(i2c_atr_add_adapter, "I2C_ATR"); 899 900 void i2c_atr_del_adapter(struct i2c_atr *atr, u32 chan_id) 901 { 902 char symlink_name[ATR_MAX_SYMLINK_LEN]; 903 struct i2c_adapter *adap; 904 struct i2c_atr_chan *chan; 905 struct fwnode_handle *fwnode; 906 struct device *dev = atr->dev; 907 908 adap = atr->adapter[chan_id]; 909 if (!adap) 910 return; 911 912 chan = adap->algo_data; 913 fwnode = dev_fwnode(&adap->dev); 914 915 dev_dbg(dev, "Removing ATR child bus %d\n", i2c_adapter_id(adap)); 916 917 snprintf(symlink_name, sizeof(symlink_name), "channel-%u", 918 chan->chan_id); 919 sysfs_remove_link(&dev->kobj, symlink_name); 920 sysfs_remove_link(&chan->adap.dev.kobj, "atr_device"); 921 922 i2c_del_adapter(adap); 923 924 if (!chan->alias_pool->shared) 925 i2c_atr_free_alias_pool(chan->alias_pool); 926 927 atr->adapter[chan_id] = NULL; 928 929 fwnode_handle_put(fwnode); 930 mutex_destroy(&chan->orig_addrs_lock); 931 mutex_destroy(&chan->alias_pairs_lock); 932 lockdep_unregister_key(&chan->orig_addrs_lock_key); 933 lockdep_unregister_key(&chan->alias_pairs_lock_key); 934 kfree(chan->orig_addrs); 935 kfree(chan); 936 } 937 EXPORT_SYMBOL_NS_GPL(i2c_atr_del_adapter, "I2C_ATR"); 938 939 void i2c_atr_set_driver_data(struct i2c_atr *atr, void *data) 940 { 941 atr->priv = data; 942 } 943 EXPORT_SYMBOL_NS_GPL(i2c_atr_set_driver_data, "I2C_ATR"); 944 945 void *i2c_atr_get_driver_data(struct i2c_atr *atr) 946 { 947 return atr->priv; 948 } 949 EXPORT_SYMBOL_NS_GPL(i2c_atr_get_driver_data, "I2C_ATR"); 950 951 MODULE_AUTHOR("Luca Ceresoli <luca.ceresoli@bootlin.com>"); 952 MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ideasonboard.com>"); 953 MODULE_DESCRIPTION("I2C Address Translator"); 954 MODULE_LICENSE("GPL"); 955