i2c-atr.c

  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 */
 39struct 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 */
 55struct 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 */
 81struct 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 */
114struct 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
135static 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
164err_free_aliases:
165	kfree(alias_pool->aliases);
166err_free_alias_pool:
167	kfree(alias_pool);
168	return ERR_PTR(ret);
169}
170
171static 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 */
179static 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 */
199static 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
206static 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
227static 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
244static struct i2c_atr_alias_pair *
245i2c_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
259static struct i2c_atr_alias_pair *
260i2c_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
288err_del_c2a:
289	i2c_atr_destroy_c2a(&c2a);
290err_release_alias:
291	i2c_atr_release_alias(chan->alias_pool, alias);
292	return NULL;
293}
294
295static struct i2c_atr_alias_pair *
296i2c_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
341static struct i2c_atr_alias_pair *
342i2c_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 */
368static 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
416out_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 */
428static 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
447out_unlock:
448	mutex_unlock(&chan->alias_pairs_lock);
449}
450
451static 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
472err_unlock:
473	mutex_unlock(&chan->orig_addrs_lock);
474
475	return ret;
476}
477
478static 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
506static 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
514static 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
522static 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
530static 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
538static 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
544static 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
567out_unlock:
568	mutex_unlock(&chan->alias_pairs_lock);
569	return ret;
570}
571
572static 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
600static 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
642static 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
707err_free_aliases32:
708	kfree(aliases32);
709err_free_alias_pool:
710	i2c_atr_free_alias_pool(alias_pool);
711	return ret;
712}
713
714struct 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
757err_free_alias_pool:
758	i2c_atr_free_alias_pool(atr->alias_pool);
759err_destroy_mutex:
760	mutex_destroy(&atr->lock);
761	lockdep_unregister_key(&atr->lock_key);
762	kfree(atr);
763
764	return ERR_PTR(ret);
765}
766EXPORT_SYMBOL_NS_GPL(i2c_atr_new, "I2C_ATR");
767
768void 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}
781EXPORT_SYMBOL_NS_GPL(i2c_atr_delete, "I2C_ATR");
782
783int 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", &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
886err_free_alias_pool:
887	if (!chan->alias_pool->shared)
888		i2c_atr_free_alias_pool(chan->alias_pool);
889err_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}
898EXPORT_SYMBOL_NS_GPL(i2c_atr_add_adapter, "I2C_ATR");
899
900void 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}
937EXPORT_SYMBOL_NS_GPL(i2c_atr_del_adapter, "I2C_ATR");
938
939void i2c_atr_set_driver_data(struct i2c_atr *atr, void *data)
940{
941	atr->priv = data;
942}
943EXPORT_SYMBOL_NS_GPL(i2c_atr_set_driver_data, "I2C_ATR");
944
945void *i2c_atr_get_driver_data(struct i2c_atr *atr)
946{
947	return atr->priv;
948}
949EXPORT_SYMBOL_NS_GPL(i2c_atr_get_driver_data, "I2C_ATR");
950
951MODULE_AUTHOR("Luca Ceresoli <luca.ceresoli@bootlin.com>");
952MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ideasonboard.com>");
953MODULE_DESCRIPTION("I2C Address Translator");
954MODULE_LICENSE("GPL");