xref: /linux/drivers/i2c/i2c-mux.c (revision b889fcf63cb62e7fdb7816565e28f44dbe4a76a5)
1 /*
2  * Multiplexed I2C bus driver.
3  *
4  * Copyright (c) 2008-2009 Rodolfo Giometti <giometti@linux.it>
5  * Copyright (c) 2008-2009 Eurotech S.p.A. <info@eurotech.it>
6  * Copyright (c) 2009-2010 NSN GmbH & Co KG <michael.lawnick.ext@nsn.com>
7  *
8  * Simplifies access to complex multiplexed I2C bus topologies, by presenting
9  * each multiplexed bus segment as an additional I2C adapter.
10  * Supports multi-level mux'ing (mux behind a mux).
11  *
12  * Based on:
13  *	i2c-virt.c from Kumar Gala <galak@kernel.crashing.org>
14  *	i2c-virtual.c from Ken Harrenstien, Copyright (c) 2004 Google, Inc.
15  *	i2c-virtual.c from Brian Kuschak <bkuschak@yahoo.com>
16  *
17  * This file is licensed under the terms of the GNU General Public
18  * License version 2. This program is licensed "as is" without any
19  * warranty of any kind, whether express or implied.
20  */
21 
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/i2c.h>
26 #include <linux/i2c-mux.h>
27 #include <linux/of.h>
28 #include <linux/of_i2c.h>
29 
30 /* multiplexer per channel data */
31 struct i2c_mux_priv {
32 	struct i2c_adapter adap;
33 	struct i2c_algorithm algo;
34 
35 	struct i2c_adapter *parent;
36 	void *mux_priv;	/* the mux chip/device */
37 	u32  chan_id;	/* the channel id */
38 
39 	int (*select)(struct i2c_adapter *, void *mux_priv, u32 chan_id);
40 	int (*deselect)(struct i2c_adapter *, void *mux_priv, u32 chan_id);
41 };
42 
43 static int i2c_mux_master_xfer(struct i2c_adapter *adap,
44 			       struct i2c_msg msgs[], int num)
45 {
46 	struct i2c_mux_priv *priv = adap->algo_data;
47 	struct i2c_adapter *parent = priv->parent;
48 	int ret;
49 
50 	/* Switch to the right mux port and perform the transfer. */
51 
52 	ret = priv->select(parent, priv->mux_priv, priv->chan_id);
53 	if (ret >= 0)
54 		ret = parent->algo->master_xfer(parent, msgs, num);
55 	if (priv->deselect)
56 		priv->deselect(parent, priv->mux_priv, priv->chan_id);
57 
58 	return ret;
59 }
60 
61 static int i2c_mux_smbus_xfer(struct i2c_adapter *adap,
62 			      u16 addr, unsigned short flags,
63 			      char read_write, u8 command,
64 			      int size, union i2c_smbus_data *data)
65 {
66 	struct i2c_mux_priv *priv = adap->algo_data;
67 	struct i2c_adapter *parent = priv->parent;
68 	int ret;
69 
70 	/* Select the right mux port and perform the transfer. */
71 
72 	ret = priv->select(parent, priv->mux_priv, priv->chan_id);
73 	if (ret >= 0)
74 		ret = parent->algo->smbus_xfer(parent, addr, flags,
75 					read_write, command, size, data);
76 	if (priv->deselect)
77 		priv->deselect(parent, priv->mux_priv, priv->chan_id);
78 
79 	return ret;
80 }
81 
82 /* Return the parent's functionality */
83 static u32 i2c_mux_functionality(struct i2c_adapter *adap)
84 {
85 	struct i2c_mux_priv *priv = adap->algo_data;
86 	struct i2c_adapter *parent = priv->parent;
87 
88 	return parent->algo->functionality(parent);
89 }
90 
91 /* Return all parent classes, merged */
92 static unsigned int i2c_mux_parent_classes(struct i2c_adapter *parent)
93 {
94 	unsigned int class = 0;
95 
96 	do {
97 		class |= parent->class;
98 		parent = i2c_parent_is_i2c_adapter(parent);
99 	} while (parent);
100 
101 	return class;
102 }
103 
104 struct i2c_adapter *i2c_add_mux_adapter(struct i2c_adapter *parent,
105 				struct device *mux_dev,
106 				void *mux_priv, u32 force_nr, u32 chan_id,
107 				unsigned int class,
108 				int (*select) (struct i2c_adapter *,
109 					       void *, u32),
110 				int (*deselect) (struct i2c_adapter *,
111 						 void *, u32))
112 {
113 	struct i2c_mux_priv *priv;
114 	int ret;
115 
116 	priv = kzalloc(sizeof(struct i2c_mux_priv), GFP_KERNEL);
117 	if (!priv)
118 		return NULL;
119 
120 	/* Set up private adapter data */
121 	priv->parent = parent;
122 	priv->mux_priv = mux_priv;
123 	priv->chan_id = chan_id;
124 	priv->select = select;
125 	priv->deselect = deselect;
126 
127 	/* Need to do algo dynamically because we don't know ahead
128 	 * of time what sort of physical adapter we'll be dealing with.
129 	 */
130 	if (parent->algo->master_xfer)
131 		priv->algo.master_xfer = i2c_mux_master_xfer;
132 	if (parent->algo->smbus_xfer)
133 		priv->algo.smbus_xfer = i2c_mux_smbus_xfer;
134 	priv->algo.functionality = i2c_mux_functionality;
135 
136 	/* Now fill out new adapter structure */
137 	snprintf(priv->adap.name, sizeof(priv->adap.name),
138 		 "i2c-%d-mux (chan_id %d)", i2c_adapter_id(parent), chan_id);
139 	priv->adap.owner = THIS_MODULE;
140 	priv->adap.algo = &priv->algo;
141 	priv->adap.algo_data = priv;
142 	priv->adap.dev.parent = &parent->dev;
143 
144 	/* Sanity check on class */
145 	if (i2c_mux_parent_classes(parent) & class)
146 		dev_err(&parent->dev,
147 			"Segment %d behind mux can't share classes with ancestors\n",
148 			chan_id);
149 	else
150 		priv->adap.class = class;
151 
152 	/*
153 	 * Try to populate the mux adapter's of_node, expands to
154 	 * nothing if !CONFIG_OF.
155 	 */
156 	if (mux_dev->of_node) {
157 		struct device_node *child;
158 		u32 reg;
159 
160 		for_each_child_of_node(mux_dev->of_node, child) {
161 			ret = of_property_read_u32(child, "reg", &reg);
162 			if (ret)
163 				continue;
164 			if (chan_id == reg) {
165 				priv->adap.dev.of_node = child;
166 				break;
167 			}
168 		}
169 	}
170 
171 	if (force_nr) {
172 		priv->adap.nr = force_nr;
173 		ret = i2c_add_numbered_adapter(&priv->adap);
174 	} else {
175 		ret = i2c_add_adapter(&priv->adap);
176 	}
177 	if (ret < 0) {
178 		dev_err(&parent->dev,
179 			"failed to add mux-adapter (error=%d)\n",
180 			ret);
181 		kfree(priv);
182 		return NULL;
183 	}
184 
185 	dev_info(&parent->dev, "Added multiplexed i2c bus %d\n",
186 		 i2c_adapter_id(&priv->adap));
187 
188 	of_i2c_register_devices(&priv->adap);
189 
190 	return &priv->adap;
191 }
192 EXPORT_SYMBOL_GPL(i2c_add_mux_adapter);
193 
194 int i2c_del_mux_adapter(struct i2c_adapter *adap)
195 {
196 	struct i2c_mux_priv *priv = adap->algo_data;
197 	int ret;
198 
199 	ret = i2c_del_adapter(adap);
200 	if (ret < 0)
201 		return ret;
202 	kfree(priv);
203 
204 	return 0;
205 }
206 EXPORT_SYMBOL_GPL(i2c_del_mux_adapter);
207 
208 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
209 MODULE_DESCRIPTION("I2C driver for multiplexed I2C busses");
210 MODULE_LICENSE("GPL v2");
211