1 /*
2 * I2C multiplexer using GPIO API
3 *
4 * Peter Korsgaard <peter.korsgaard@barco.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
10
11 #include <linux/i2c.h>
12 #include <linux/i2c-mux.h>
13 #include <linux/i2c-mux-gpio.h>
14 #include <linux/platform_device.h>
15 #include <linux/init.h>
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/gpio.h>
19 #include <linux/of_i2c.h>
20 #include <linux/of_gpio.h>
21
22 struct gpiomux {
23 struct i2c_adapter *parent;
24 struct i2c_adapter **adap; /* child busses */
25 struct i2c_mux_gpio_platform_data data;
26 unsigned gpio_base;
27 };
28
i2c_mux_gpio_set(const struct gpiomux * mux,unsigned val)29 static void i2c_mux_gpio_set(const struct gpiomux *mux, unsigned val)
30 {
31 int i;
32
33 for (i = 0; i < mux->data.n_gpios; i++)
34 gpio_set_value(mux->gpio_base + mux->data.gpios[i],
35 val & (1 << i));
36 }
37
i2c_mux_gpio_select(struct i2c_adapter * adap,void * data,u32 chan)38 static int i2c_mux_gpio_select(struct i2c_adapter *adap, void *data, u32 chan)
39 {
40 struct gpiomux *mux = data;
41
42 i2c_mux_gpio_set(mux, mux->data.values[chan]);
43
44 return 0;
45 }
46
i2c_mux_gpio_deselect(struct i2c_adapter * adap,void * data,u32 chan)47 static int i2c_mux_gpio_deselect(struct i2c_adapter *adap, void *data, u32 chan)
48 {
49 struct gpiomux *mux = data;
50
51 i2c_mux_gpio_set(mux, mux->data.idle);
52
53 return 0;
54 }
55
match_gpio_chip_by_label(struct gpio_chip * chip,void * data)56 static int match_gpio_chip_by_label(struct gpio_chip *chip,
57 void *data)
58 {
59 return !strcmp(chip->label, data);
60 }
61
62 #ifdef CONFIG_OF
i2c_mux_gpio_probe_dt(struct gpiomux * mux,struct platform_device * pdev)63 static int i2c_mux_gpio_probe_dt(struct gpiomux *mux,
64 struct platform_device *pdev)
65 {
66 struct device_node *np = pdev->dev.of_node;
67 struct device_node *adapter_np, *child;
68 struct i2c_adapter *adapter;
69 unsigned *values, *gpios;
70 int i = 0;
71
72 if (!np)
73 return -ENODEV;
74
75 adapter_np = of_parse_phandle(np, "i2c-parent", 0);
76 if (!adapter_np) {
77 dev_err(&pdev->dev, "Cannot parse i2c-parent\n");
78 return -ENODEV;
79 }
80 adapter = of_find_i2c_adapter_by_node(adapter_np);
81 if (!adapter) {
82 dev_err(&pdev->dev, "Cannot find parent bus\n");
83 return -ENODEV;
84 }
85 mux->data.parent = i2c_adapter_id(adapter);
86 put_device(&adapter->dev);
87
88 mux->data.n_values = of_get_child_count(np);
89
90 values = devm_kzalloc(&pdev->dev,
91 sizeof(*mux->data.values) * mux->data.n_values,
92 GFP_KERNEL);
93 if (!values) {
94 dev_err(&pdev->dev, "Cannot allocate values array");
95 return -ENOMEM;
96 }
97
98 for_each_child_of_node(np, child) {
99 of_property_read_u32(child, "reg", values + i);
100 i++;
101 }
102 mux->data.values = values;
103
104 if (of_property_read_u32(np, "idle-state", &mux->data.idle))
105 mux->data.idle = I2C_MUX_GPIO_NO_IDLE;
106
107 mux->data.n_gpios = of_gpio_named_count(np, "mux-gpios");
108 if (mux->data.n_gpios < 0) {
109 dev_err(&pdev->dev, "Missing mux-gpios property in the DT.\n");
110 return -EINVAL;
111 }
112
113 gpios = devm_kzalloc(&pdev->dev,
114 sizeof(*mux->data.gpios) * mux->data.n_gpios, GFP_KERNEL);
115 if (!gpios) {
116 dev_err(&pdev->dev, "Cannot allocate gpios array");
117 return -ENOMEM;
118 }
119
120 for (i = 0; i < mux->data.n_gpios; i++)
121 gpios[i] = of_get_named_gpio(np, "mux-gpios", i);
122
123 mux->data.gpios = gpios;
124
125 return 0;
126 }
127 #else
i2c_mux_gpio_probe_dt(struct gpiomux * mux,struct platform_device * pdev)128 static int i2c_mux_gpio_probe_dt(struct gpiomux *mux,
129 struct platform_device *pdev)
130 {
131 return 0;
132 }
133 #endif
134
i2c_mux_gpio_probe(struct platform_device * pdev)135 static int i2c_mux_gpio_probe(struct platform_device *pdev)
136 {
137 struct gpiomux *mux;
138 struct i2c_adapter *parent;
139 int (*deselect) (struct i2c_adapter *, void *, u32);
140 unsigned initial_state, gpio_base;
141 int i, ret;
142
143 mux = devm_kzalloc(&pdev->dev, sizeof(*mux), GFP_KERNEL);
144 if (!mux) {
145 dev_err(&pdev->dev, "Cannot allocate gpiomux structure");
146 return -ENOMEM;
147 }
148
149 platform_set_drvdata(pdev, mux);
150
151 if (!pdev->dev.platform_data) {
152 ret = i2c_mux_gpio_probe_dt(mux, pdev);
153 if (ret < 0)
154 return ret;
155 } else
156 memcpy(&mux->data, pdev->dev.platform_data, sizeof(mux->data));
157
158 /*
159 * If a GPIO chip name is provided, the GPIO pin numbers provided are
160 * relative to its base GPIO number. Otherwise they are absolute.
161 */
162 if (mux->data.gpio_chip) {
163 struct gpio_chip *gpio;
164
165 gpio = gpiochip_find(mux->data.gpio_chip,
166 match_gpio_chip_by_label);
167 if (!gpio)
168 return -EPROBE_DEFER;
169
170 gpio_base = gpio->base;
171 } else {
172 gpio_base = 0;
173 }
174
175 parent = i2c_get_adapter(mux->data.parent);
176 if (!parent) {
177 dev_err(&pdev->dev, "Parent adapter (%d) not found\n",
178 mux->data.parent);
179 return -ENODEV;
180 }
181
182 mux->parent = parent;
183 mux->gpio_base = gpio_base;
184
185 mux->adap = devm_kzalloc(&pdev->dev,
186 sizeof(*mux->adap) * mux->data.n_values,
187 GFP_KERNEL);
188 if (!mux->adap) {
189 dev_err(&pdev->dev, "Cannot allocate i2c_adapter structure");
190 ret = -ENOMEM;
191 goto alloc_failed;
192 }
193
194 if (mux->data.idle != I2C_MUX_GPIO_NO_IDLE) {
195 initial_state = mux->data.idle;
196 deselect = i2c_mux_gpio_deselect;
197 } else {
198 initial_state = mux->data.values[0];
199 deselect = NULL;
200 }
201
202 for (i = 0; i < mux->data.n_gpios; i++) {
203 ret = gpio_request(gpio_base + mux->data.gpios[i], "i2c-mux-gpio");
204 if (ret) {
205 dev_err(&pdev->dev, "Failed to request GPIO %d\n",
206 mux->data.gpios[i]);
207 goto err_request_gpio;
208 }
209
210 ret = gpio_direction_output(gpio_base + mux->data.gpios[i],
211 initial_state & (1 << i));
212 if (ret) {
213 dev_err(&pdev->dev,
214 "Failed to set direction of GPIO %d to output\n",
215 mux->data.gpios[i]);
216 i++; /* gpio_request above succeeded, so must free */
217 goto err_request_gpio;
218 }
219 }
220
221 for (i = 0; i < mux->data.n_values; i++) {
222 u32 nr = mux->data.base_nr ? (mux->data.base_nr + i) : 0;
223 unsigned int class = mux->data.classes ? mux->data.classes[i] : 0;
224
225 mux->adap[i] = i2c_add_mux_adapter(parent, &pdev->dev, mux, nr,
226 i, class,
227 i2c_mux_gpio_select, deselect);
228 if (!mux->adap[i]) {
229 ret = -ENODEV;
230 dev_err(&pdev->dev, "Failed to add adapter %d\n", i);
231 goto add_adapter_failed;
232 }
233 }
234
235 dev_info(&pdev->dev, "%d port mux on %s adapter\n",
236 mux->data.n_values, parent->name);
237
238 return 0;
239
240 add_adapter_failed:
241 for (; i > 0; i--)
242 i2c_del_mux_adapter(mux->adap[i - 1]);
243 i = mux->data.n_gpios;
244 err_request_gpio:
245 for (; i > 0; i--)
246 gpio_free(gpio_base + mux->data.gpios[i - 1]);
247 alloc_failed:
248 i2c_put_adapter(parent);
249
250 return ret;
251 }
252
i2c_mux_gpio_remove(struct platform_device * pdev)253 static int i2c_mux_gpio_remove(struct platform_device *pdev)
254 {
255 struct gpiomux *mux = platform_get_drvdata(pdev);
256 int i;
257
258 for (i = 0; i < mux->data.n_values; i++)
259 i2c_del_mux_adapter(mux->adap[i]);
260
261 for (i = 0; i < mux->data.n_gpios; i++)
262 gpio_free(mux->gpio_base + mux->data.gpios[i]);
263
264 i2c_put_adapter(mux->parent);
265
266 return 0;
267 }
268
269 static const struct of_device_id i2c_mux_gpio_of_match[] = {
270 { .compatible = "i2c-mux-gpio", },
271 {},
272 };
273 MODULE_DEVICE_TABLE(of, i2c_mux_gpio_of_match);
274
275 static struct platform_driver i2c_mux_gpio_driver = {
276 .probe = i2c_mux_gpio_probe,
277 .remove = i2c_mux_gpio_remove,
278 .driver = {
279 .owner = THIS_MODULE,
280 .name = "i2c-mux-gpio",
281 .of_match_table = of_match_ptr(i2c_mux_gpio_of_match),
282 },
283 };
284
285 module_platform_driver(i2c_mux_gpio_driver);
286
287 MODULE_DESCRIPTION("GPIO-based I2C multiplexer driver");
288 MODULE_AUTHOR("Peter Korsgaard <peter.korsgaard@barco.com>");
289 MODULE_LICENSE("GPL");
290 MODULE_ALIAS("platform:i2c-mux-gpio");
291