xref: /linux/drivers/i2c/muxes/i2c-mux-gpio.c (revision b889fcf63cb62e7fdb7816565e28f44dbe4a76a5)
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 
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 
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 
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 
56 static int __devinit 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
63 static int __devinit 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
128 static int __devinit i2c_mux_gpio_probe_dt(struct gpiomux *mux,
129 					struct platform_device *pdev)
130 {
131 	return 0;
132 }
133 #endif
134 
135 static int __devinit 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 			goto err_request_gpio;
206 		gpio_direction_output(gpio_base + mux->data.gpios[i],
207 				      initial_state & (1 << i));
208 	}
209 
210 	for (i = 0; i < mux->data.n_values; i++) {
211 		u32 nr = mux->data.base_nr ? (mux->data.base_nr + i) : 0;
212 		unsigned int class = mux->data.classes ? mux->data.classes[i] : 0;
213 
214 		mux->adap[i] = i2c_add_mux_adapter(parent, &pdev->dev, mux, nr,
215 						   i, class,
216 						   i2c_mux_gpio_select, deselect);
217 		if (!mux->adap[i]) {
218 			ret = -ENODEV;
219 			dev_err(&pdev->dev, "Failed to add adapter %d\n", i);
220 			goto add_adapter_failed;
221 		}
222 	}
223 
224 	dev_info(&pdev->dev, "%d port mux on %s adapter\n",
225 		 mux->data.n_values, parent->name);
226 
227 	return 0;
228 
229 add_adapter_failed:
230 	for (; i > 0; i--)
231 		i2c_del_mux_adapter(mux->adap[i - 1]);
232 	i = mux->data.n_gpios;
233 err_request_gpio:
234 	for (; i > 0; i--)
235 		gpio_free(gpio_base + mux->data.gpios[i - 1]);
236 alloc_failed:
237 	i2c_put_adapter(parent);
238 
239 	return ret;
240 }
241 
242 static int __devexit i2c_mux_gpio_remove(struct platform_device *pdev)
243 {
244 	struct gpiomux *mux = platform_get_drvdata(pdev);
245 	int i;
246 
247 	for (i = 0; i < mux->data.n_values; i++)
248 		i2c_del_mux_adapter(mux->adap[i]);
249 
250 	for (i = 0; i < mux->data.n_gpios; i++)
251 		gpio_free(mux->gpio_base + mux->data.gpios[i]);
252 
253 	platform_set_drvdata(pdev, NULL);
254 	i2c_put_adapter(mux->parent);
255 
256 	return 0;
257 }
258 
259 static const struct of_device_id i2c_mux_gpio_of_match[] __devinitconst = {
260 	{ .compatible = "i2c-mux-gpio", },
261 	{},
262 };
263 MODULE_DEVICE_TABLE(of, i2c_mux_gpio_of_match);
264 
265 static struct platform_driver i2c_mux_gpio_driver = {
266 	.probe	= i2c_mux_gpio_probe,
267 	.remove	= __devexit_p(i2c_mux_gpio_remove),
268 	.driver	= {
269 		.owner	= THIS_MODULE,
270 		.name	= "i2c-mux-gpio",
271 		.of_match_table = of_match_ptr(i2c_mux_gpio_of_match),
272 	},
273 };
274 
275 module_platform_driver(i2c_mux_gpio_driver);
276 
277 MODULE_DESCRIPTION("GPIO-based I2C multiplexer driver");
278 MODULE_AUTHOR("Peter Korsgaard <peter.korsgaard@barco.com>");
279 MODULE_LICENSE("GPL");
280 MODULE_ALIAS("platform:i2c-mux-gpio");
281