Commit | Line | Data |
---|---|---|
ae58d1e4 SW |
1 | /* |
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> | |
23 | #include <linux/of_i2c.h> | |
24 | #include <linux/pinctrl/consumer.h> | |
25 | #include <linux/i2c-mux-pinctrl.h> | |
26 | #include <linux/platform_device.h> | |
27 | #include <linux/slab.h> | |
28 | ||
29 | struct i2c_mux_pinctrl { | |
30 | struct device *dev; | |
31 | struct i2c_mux_pinctrl_platform_data *pdata; | |
32 | struct pinctrl *pinctrl; | |
33 | struct pinctrl_state **states; | |
34 | struct pinctrl_state *state_idle; | |
35 | struct i2c_adapter *parent; | |
36 | struct i2c_adapter **busses; | |
37 | }; | |
38 | ||
39 | static int i2c_mux_pinctrl_select(struct i2c_adapter *adap, void *data, | |
40 | u32 chan) | |
41 | { | |
42 | struct i2c_mux_pinctrl *mux = data; | |
43 | ||
44 | return pinctrl_select_state(mux->pinctrl, mux->states[chan]); | |
45 | } | |
46 | ||
47 | static int i2c_mux_pinctrl_deselect(struct i2c_adapter *adap, void *data, | |
48 | u32 chan) | |
49 | { | |
50 | struct i2c_mux_pinctrl *mux = data; | |
51 | ||
52 | return pinctrl_select_state(mux->pinctrl, mux->state_idle); | |
53 | } | |
54 | ||
55 | #ifdef CONFIG_OF | |
56 | static int i2c_mux_pinctrl_parse_dt(struct i2c_mux_pinctrl *mux, | |
57 | struct platform_device *pdev) | |
58 | { | |
59 | struct device_node *np = pdev->dev.of_node; | |
60 | int num_names, i, ret; | |
61 | struct device_node *adapter_np; | |
62 | struct i2c_adapter *adapter; | |
63 | ||
64 | if (!np) | |
65 | return 0; | |
66 | ||
67 | mux->pdata = devm_kzalloc(&pdev->dev, sizeof(*mux->pdata), GFP_KERNEL); | |
68 | if (!mux->pdata) { | |
69 | dev_err(mux->dev, | |
70 | "Cannot allocate i2c_mux_pinctrl_platform_data\n"); | |
71 | return -ENOMEM; | |
72 | } | |
73 | ||
74 | num_names = of_property_count_strings(np, "pinctrl-names"); | |
75 | if (num_names < 0) { | |
76 | dev_err(mux->dev, "Cannot parse pinctrl-names: %d\n", | |
77 | num_names); | |
78 | return num_names; | |
79 | } | |
80 | ||
81 | mux->pdata->pinctrl_states = devm_kzalloc(&pdev->dev, | |
82 | sizeof(*mux->pdata->pinctrl_states) * num_names, | |
83 | GFP_KERNEL); | |
84 | if (!mux->pdata->pinctrl_states) { | |
85 | dev_err(mux->dev, "Cannot allocate pinctrl_states\n"); | |
86 | return -ENOMEM; | |
87 | } | |
88 | ||
89 | for (i = 0; i < num_names; i++) { | |
90 | ret = of_property_read_string_index(np, "pinctrl-names", i, | |
91 | &mux->pdata->pinctrl_states[mux->pdata->bus_count]); | |
92 | if (ret < 0) { | |
93 | dev_err(mux->dev, "Cannot parse pinctrl-names: %d\n", | |
94 | ret); | |
95 | return ret; | |
96 | } | |
97 | if (!strcmp(mux->pdata->pinctrl_states[mux->pdata->bus_count], | |
98 | "idle")) { | |
99 | if (i != num_names - 1) { | |
100 | dev_err(mux->dev, "idle state must be last\n"); | |
101 | return -EINVAL; | |
102 | } | |
103 | mux->pdata->pinctrl_state_idle = "idle"; | |
104 | } else { | |
105 | mux->pdata->bus_count++; | |
106 | } | |
107 | } | |
108 | ||
109 | adapter_np = of_parse_phandle(np, "i2c-parent", 0); | |
110 | if (!adapter_np) { | |
111 | dev_err(mux->dev, "Cannot parse i2c-parent\n"); | |
112 | return -ENODEV; | |
113 | } | |
114 | adapter = of_find_i2c_adapter_by_node(adapter_np); | |
115 | if (!adapter) { | |
116 | dev_err(mux->dev, "Cannot find parent bus\n"); | |
117 | return -ENODEV; | |
118 | } | |
119 | mux->pdata->parent_bus_num = i2c_adapter_id(adapter); | |
120 | put_device(&adapter->dev); | |
121 | ||
122 | return 0; | |
123 | } | |
124 | #else | |
125 | static inline int i2c_mux_pinctrl_parse_dt(struct i2c_mux_pinctrl *mux, | |
126 | struct platform_device *pdev) | |
127 | { | |
128 | return 0; | |
129 | } | |
130 | #endif | |
131 | ||
132 | static int __devinit i2c_mux_pinctrl_probe(struct platform_device *pdev) | |
133 | { | |
134 | struct i2c_mux_pinctrl *mux; | |
135 | int (*deselect)(struct i2c_adapter *, void *, u32); | |
136 | int i, ret; | |
137 | ||
138 | mux = devm_kzalloc(&pdev->dev, sizeof(*mux), GFP_KERNEL); | |
139 | if (!mux) { | |
140 | dev_err(&pdev->dev, "Cannot allocate i2c_mux_pinctrl\n"); | |
141 | ret = -ENOMEM; | |
142 | goto err; | |
143 | } | |
144 | platform_set_drvdata(pdev, mux); | |
145 | ||
146 | mux->dev = &pdev->dev; | |
147 | ||
148 | mux->pdata = pdev->dev.platform_data; | |
149 | if (!mux->pdata) { | |
150 | ret = i2c_mux_pinctrl_parse_dt(mux, pdev); | |
151 | if (ret < 0) | |
152 | goto err; | |
153 | } | |
154 | if (!mux->pdata) { | |
155 | dev_err(&pdev->dev, "Missing platform data\n"); | |
156 | ret = -ENODEV; | |
157 | goto err; | |
158 | } | |
159 | ||
160 | mux->states = devm_kzalloc(&pdev->dev, | |
161 | sizeof(*mux->states) * mux->pdata->bus_count, | |
162 | GFP_KERNEL); | |
163 | if (!mux->states) { | |
164 | dev_err(&pdev->dev, "Cannot allocate states\n"); | |
165 | ret = -ENOMEM; | |
166 | goto err; | |
167 | } | |
168 | ||
169 | mux->busses = devm_kzalloc(&pdev->dev, | |
170 | sizeof(mux->busses) * mux->pdata->bus_count, | |
171 | GFP_KERNEL); | |
172 | if (!mux->states) { | |
173 | dev_err(&pdev->dev, "Cannot allocate busses\n"); | |
174 | ret = -ENOMEM; | |
175 | goto err; | |
176 | } | |
177 | ||
178 | mux->pinctrl = devm_pinctrl_get(&pdev->dev); | |
179 | if (IS_ERR(mux->pinctrl)) { | |
180 | ret = PTR_ERR(mux->pinctrl); | |
181 | dev_err(&pdev->dev, "Cannot get pinctrl: %d\n", ret); | |
182 | goto err; | |
183 | } | |
184 | for (i = 0; i < mux->pdata->bus_count; i++) { | |
185 | mux->states[i] = pinctrl_lookup_state(mux->pinctrl, | |
186 | mux->pdata->pinctrl_states[i]); | |
187 | if (IS_ERR(mux->states[i])) { | |
188 | ret = PTR_ERR(mux->states[i]); | |
189 | dev_err(&pdev->dev, | |
190 | "Cannot look up pinctrl state %s: %d\n", | |
191 | mux->pdata->pinctrl_states[i], ret); | |
192 | goto err; | |
193 | } | |
194 | } | |
195 | if (mux->pdata->pinctrl_state_idle) { | |
196 | mux->state_idle = pinctrl_lookup_state(mux->pinctrl, | |
197 | mux->pdata->pinctrl_state_idle); | |
198 | if (IS_ERR(mux->state_idle)) { | |
199 | ret = PTR_ERR(mux->state_idle); | |
200 | dev_err(&pdev->dev, | |
201 | "Cannot look up pinctrl state %s: %d\n", | |
202 | mux->pdata->pinctrl_state_idle, ret); | |
203 | goto err; | |
204 | } | |
205 | ||
206 | deselect = i2c_mux_pinctrl_deselect; | |
207 | } else { | |
208 | deselect = NULL; | |
209 | } | |
210 | ||
211 | mux->parent = i2c_get_adapter(mux->pdata->parent_bus_num); | |
212 | if (!mux->parent) { | |
213 | dev_err(&pdev->dev, "Parent adapter (%d) not found\n", | |
214 | mux->pdata->parent_bus_num); | |
215 | ret = -ENODEV; | |
216 | goto err; | |
217 | } | |
218 | ||
219 | for (i = 0; i < mux->pdata->bus_count; i++) { | |
220 | u32 bus = mux->pdata->base_bus_num ? | |
221 | (mux->pdata->base_bus_num + i) : 0; | |
222 | ||
223 | mux->busses[i] = i2c_add_mux_adapter(mux->parent, &pdev->dev, | |
224 | mux, bus, i, | |
225 | i2c_mux_pinctrl_select, | |
226 | deselect); | |
227 | if (!mux->busses[i]) { | |
228 | ret = -ENODEV; | |
229 | dev_err(&pdev->dev, "Failed to add adapter %d\n", i); | |
230 | goto err_del_adapter; | |
231 | } | |
232 | } | |
233 | ||
234 | return 0; | |
235 | ||
236 | err_del_adapter: | |
237 | for (; i > 0; i--) | |
238 | i2c_del_mux_adapter(mux->busses[i - 1]); | |
239 | i2c_put_adapter(mux->parent); | |
240 | err: | |
241 | return ret; | |
242 | } | |
243 | ||
244 | static int __devexit i2c_mux_pinctrl_remove(struct platform_device *pdev) | |
245 | { | |
246 | struct i2c_mux_pinctrl *mux = platform_get_drvdata(pdev); | |
247 | int i; | |
248 | ||
249 | for (i = 0; i < mux->pdata->bus_count; i++) | |
250 | i2c_del_mux_adapter(mux->busses[i]); | |
251 | ||
252 | i2c_put_adapter(mux->parent); | |
253 | ||
254 | return 0; | |
255 | } | |
256 | ||
257 | #ifdef CONFIG_OF | |
258 | static const struct of_device_id i2c_mux_pinctrl_of_match[] __devinitconst = { | |
259 | { .compatible = "i2c-mux-pinctrl", }, | |
260 | {}, | |
261 | }; | |
262 | MODULE_DEVICE_TABLE(of, i2c_mux_pinctrl_of_match); | |
263 | #endif | |
264 | ||
265 | static struct platform_driver i2c_mux_pinctrl_driver = { | |
266 | .driver = { | |
267 | .name = "i2c-mux-pinctrl", | |
268 | .owner = THIS_MODULE, | |
269 | .of_match_table = of_match_ptr(i2c_mux_pinctrl_of_match), | |
270 | }, | |
271 | .probe = i2c_mux_pinctrl_probe, | |
272 | .remove = __devexit_p(i2c_mux_pinctrl_remove), | |
273 | }; | |
274 | module_platform_driver(i2c_mux_pinctrl_driver); | |
275 | ||
276 | MODULE_DESCRIPTION("pinctrl-based I2C multiplexer driver"); | |
277 | MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>"); | |
278 | MODULE_LICENSE("GPL v2"); | |
279 | MODULE_ALIAS("platform:i2c-mux-pinctrl"); |