blob: 68a37157377df12797b1b122ca4568d121559112 [file] [log] [blame]
Stephen Warrenae58d1e2012-05-18 09:29:34 -06001/*
2 * I2C multiplexer using pinctrl API
3 *
4 * Copyright (c) 2012, NVIDIA CORPORATION. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 */
18
19#include <linux/i2c.h>
20#include <linux/i2c-mux.h>
21#include <linux/init.h>
22#include <linux/module.h>
Stephen Warrenae58d1e2012-05-18 09:29:34 -060023#include <linux/pinctrl/consumer.h>
24#include <linux/i2c-mux-pinctrl.h>
25#include <linux/platform_device.h>
26#include <linux/slab.h>
27
28struct i2c_mux_pinctrl {
29 struct device *dev;
30 struct i2c_mux_pinctrl_platform_data *pdata;
31 struct pinctrl *pinctrl;
32 struct pinctrl_state **states;
33 struct pinctrl_state *state_idle;
34 struct i2c_adapter *parent;
35 struct i2c_adapter **busses;
36};
37
38static int i2c_mux_pinctrl_select(struct i2c_adapter *adap, void *data,
39 u32 chan)
40{
41 struct i2c_mux_pinctrl *mux = data;
42
43 return pinctrl_select_state(mux->pinctrl, mux->states[chan]);
44}
45
46static int i2c_mux_pinctrl_deselect(struct i2c_adapter *adap, void *data,
47 u32 chan)
48{
49 struct i2c_mux_pinctrl *mux = data;
50
51 return pinctrl_select_state(mux->pinctrl, mux->state_idle);
52}
53
54#ifdef CONFIG_OF
55static int i2c_mux_pinctrl_parse_dt(struct i2c_mux_pinctrl *mux,
56 struct platform_device *pdev)
57{
58 struct device_node *np = pdev->dev.of_node;
59 int num_names, i, ret;
60 struct device_node *adapter_np;
61 struct i2c_adapter *adapter;
62
63 if (!np)
64 return 0;
65
66 mux->pdata = devm_kzalloc(&pdev->dev, sizeof(*mux->pdata), GFP_KERNEL);
67 if (!mux->pdata) {
68 dev_err(mux->dev,
69 "Cannot allocate i2c_mux_pinctrl_platform_data\n");
70 return -ENOMEM;
71 }
72
73 num_names = of_property_count_strings(np, "pinctrl-names");
74 if (num_names < 0) {
75 dev_err(mux->dev, "Cannot parse pinctrl-names: %d\n",
76 num_names);
77 return num_names;
78 }
79
80 mux->pdata->pinctrl_states = devm_kzalloc(&pdev->dev,
81 sizeof(*mux->pdata->pinctrl_states) * num_names,
82 GFP_KERNEL);
83 if (!mux->pdata->pinctrl_states) {
84 dev_err(mux->dev, "Cannot allocate pinctrl_states\n");
85 return -ENOMEM;
86 }
87
88 for (i = 0; i < num_names; i++) {
89 ret = of_property_read_string_index(np, "pinctrl-names", i,
90 &mux->pdata->pinctrl_states[mux->pdata->bus_count]);
91 if (ret < 0) {
92 dev_err(mux->dev, "Cannot parse pinctrl-names: %d\n",
93 ret);
94 return ret;
95 }
96 if (!strcmp(mux->pdata->pinctrl_states[mux->pdata->bus_count],
97 "idle")) {
98 if (i != num_names - 1) {
99 dev_err(mux->dev, "idle state must be last\n");
100 return -EINVAL;
101 }
102 mux->pdata->pinctrl_state_idle = "idle";
103 } else {
104 mux->pdata->bus_count++;
105 }
106 }
107
108 adapter_np = of_parse_phandle(np, "i2c-parent", 0);
109 if (!adapter_np) {
110 dev_err(mux->dev, "Cannot parse i2c-parent\n");
111 return -ENODEV;
112 }
113 adapter = of_find_i2c_adapter_by_node(adapter_np);
114 if (!adapter) {
115 dev_err(mux->dev, "Cannot find parent bus\n");
Wolfram Sang2737de42013-10-10 10:19:13 +0200116 return -EPROBE_DEFER;
Stephen Warrenae58d1e2012-05-18 09:29:34 -0600117 }
118 mux->pdata->parent_bus_num = i2c_adapter_id(adapter);
119 put_device(&adapter->dev);
120
121 return 0;
122}
123#else
124static inline int i2c_mux_pinctrl_parse_dt(struct i2c_mux_pinctrl *mux,
125 struct platform_device *pdev)
126{
127 return 0;
128}
129#endif
130
Bill Pemberton0b255e92012-11-27 15:59:38 -0500131static int i2c_mux_pinctrl_probe(struct platform_device *pdev)
Stephen Warrenae58d1e2012-05-18 09:29:34 -0600132{
133 struct i2c_mux_pinctrl *mux;
134 int (*deselect)(struct i2c_adapter *, void *, u32);
135 int i, ret;
136
137 mux = devm_kzalloc(&pdev->dev, sizeof(*mux), GFP_KERNEL);
138 if (!mux) {
139 dev_err(&pdev->dev, "Cannot allocate i2c_mux_pinctrl\n");
140 ret = -ENOMEM;
141 goto err;
142 }
143 platform_set_drvdata(pdev, mux);
144
145 mux->dev = &pdev->dev;
146
Jingoo Han6d4028c2013-07-30 16:59:33 +0900147 mux->pdata = dev_get_platdata(&pdev->dev);
Stephen Warrenae58d1e2012-05-18 09:29:34 -0600148 if (!mux->pdata) {
149 ret = i2c_mux_pinctrl_parse_dt(mux, pdev);
150 if (ret < 0)
151 goto err;
152 }
153 if (!mux->pdata) {
154 dev_err(&pdev->dev, "Missing platform data\n");
155 ret = -ENODEV;
156 goto err;
157 }
158
159 mux->states = devm_kzalloc(&pdev->dev,
160 sizeof(*mux->states) * mux->pdata->bus_count,
161 GFP_KERNEL);
162 if (!mux->states) {
163 dev_err(&pdev->dev, "Cannot allocate states\n");
164 ret = -ENOMEM;
165 goto err;
166 }
167
168 mux->busses = devm_kzalloc(&pdev->dev,
Laurent Navet43a2bd42013-01-08 14:40:09 +0100169 sizeof(*mux->busses) * mux->pdata->bus_count,
Stephen Warrenae58d1e2012-05-18 09:29:34 -0600170 GFP_KERNEL);
Guenter Roeckaa1e3e82012-11-13 22:27:19 +0100171 if (!mux->busses) {
Stephen Warrenae58d1e2012-05-18 09:29:34 -0600172 dev_err(&pdev->dev, "Cannot allocate busses\n");
173 ret = -ENOMEM;
174 goto err;
175 }
176
177 mux->pinctrl = devm_pinctrl_get(&pdev->dev);
178 if (IS_ERR(mux->pinctrl)) {
179 ret = PTR_ERR(mux->pinctrl);
180 dev_err(&pdev->dev, "Cannot get pinctrl: %d\n", ret);
181 goto err;
182 }
183 for (i = 0; i < mux->pdata->bus_count; i++) {
184 mux->states[i] = pinctrl_lookup_state(mux->pinctrl,
185 mux->pdata->pinctrl_states[i]);
186 if (IS_ERR(mux->states[i])) {
187 ret = PTR_ERR(mux->states[i]);
188 dev_err(&pdev->dev,
189 "Cannot look up pinctrl state %s: %d\n",
190 mux->pdata->pinctrl_states[i], ret);
191 goto err;
192 }
193 }
194 if (mux->pdata->pinctrl_state_idle) {
195 mux->state_idle = pinctrl_lookup_state(mux->pinctrl,
196 mux->pdata->pinctrl_state_idle);
197 if (IS_ERR(mux->state_idle)) {
198 ret = PTR_ERR(mux->state_idle);
199 dev_err(&pdev->dev,
200 "Cannot look up pinctrl state %s: %d\n",
201 mux->pdata->pinctrl_state_idle, ret);
202 goto err;
203 }
204
205 deselect = i2c_mux_pinctrl_deselect;
206 } else {
207 deselect = NULL;
208 }
209
210 mux->parent = i2c_get_adapter(mux->pdata->parent_bus_num);
211 if (!mux->parent) {
212 dev_err(&pdev->dev, "Parent adapter (%d) not found\n",
213 mux->pdata->parent_bus_num);
Wolfram Sang2737de42013-10-10 10:19:13 +0200214 ret = -EPROBE_DEFER;
Stephen Warrenae58d1e2012-05-18 09:29:34 -0600215 goto err;
216 }
217
218 for (i = 0; i < mux->pdata->bus_count; i++) {
219 u32 bus = mux->pdata->base_bus_num ?
220 (mux->pdata->base_bus_num + i) : 0;
221
222 mux->busses[i] = i2c_add_mux_adapter(mux->parent, &pdev->dev,
Jean Delvareeee543e2012-10-05 22:23:51 +0200223 mux, bus, i, 0,
Stephen Warrenae58d1e2012-05-18 09:29:34 -0600224 i2c_mux_pinctrl_select,
225 deselect);
226 if (!mux->busses[i]) {
227 ret = -ENODEV;
228 dev_err(&pdev->dev, "Failed to add adapter %d\n", i);
229 goto err_del_adapter;
230 }
231 }
232
233 return 0;
234
235err_del_adapter:
236 for (; i > 0; i--)
237 i2c_del_mux_adapter(mux->busses[i - 1]);
238 i2c_put_adapter(mux->parent);
239err:
240 return ret;
241}
242
Bill Pemberton0b255e92012-11-27 15:59:38 -0500243static int i2c_mux_pinctrl_remove(struct platform_device *pdev)
Stephen Warrenae58d1e2012-05-18 09:29:34 -0600244{
245 struct i2c_mux_pinctrl *mux = platform_get_drvdata(pdev);
246 int i;
247
248 for (i = 0; i < mux->pdata->bus_count; i++)
249 i2c_del_mux_adapter(mux->busses[i]);
250
251 i2c_put_adapter(mux->parent);
252
253 return 0;
254}
255
256#ifdef CONFIG_OF
Bill Pemberton0b255e92012-11-27 15:59:38 -0500257static const struct of_device_id i2c_mux_pinctrl_of_match[] = {
Stephen Warrenae58d1e2012-05-18 09:29:34 -0600258 { .compatible = "i2c-mux-pinctrl", },
259 {},
260};
261MODULE_DEVICE_TABLE(of, i2c_mux_pinctrl_of_match);
262#endif
263
264static struct platform_driver i2c_mux_pinctrl_driver = {
265 .driver = {
266 .name = "i2c-mux-pinctrl",
267 .owner = THIS_MODULE,
268 .of_match_table = of_match_ptr(i2c_mux_pinctrl_of_match),
269 },
270 .probe = i2c_mux_pinctrl_probe,
Bill Pemberton0b255e92012-11-27 15:59:38 -0500271 .remove = i2c_mux_pinctrl_remove,
Stephen Warrenae58d1e2012-05-18 09:29:34 -0600272};
273module_platform_driver(i2c_mux_pinctrl_driver);
274
275MODULE_DESCRIPTION("pinctrl-based I2C multiplexer driver");
276MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>");
277MODULE_LICENSE("GPL v2");
278MODULE_ALIAS("platform:i2c-mux-pinctrl");