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> | |
ae58d1e4 | 21 | #include <linux/module.h> |
ae58d1e4 SW |
22 | #include <linux/pinctrl/consumer.h> |
23 | #include <linux/i2c-mux-pinctrl.h> | |
24 | #include <linux/platform_device.h> | |
25 | #include <linux/slab.h> | |
4edd65e6 | 26 | #include <linux/of.h> |
ae58d1e4 SW |
27 | |
28 | struct 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 | ||
38 | static 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 | ||
46 | static 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 | |
55 | static 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"); | |
2737de46 | 116 | return -EPROBE_DEFER; |
ae58d1e4 SW |
117 | } |
118 | mux->pdata->parent_bus_num = i2c_adapter_id(adapter); | |
119 | put_device(&adapter->dev); | |
120 | ||
121 | return 0; | |
122 | } | |
123 | #else | |
124 | static 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 | ||
0b255e92 | 131 | static int i2c_mux_pinctrl_probe(struct platform_device *pdev) |
ae58d1e4 SW |
132 | { |
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 | ||
6d4028c6 | 147 | mux->pdata = dev_get_platdata(&pdev->dev); |
ae58d1e4 SW |
148 | 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, | |
43a2bd42 | 169 | sizeof(*mux->busses) * mux->pdata->bus_count, |
ae58d1e4 | 170 | GFP_KERNEL); |
aa1e3e81 | 171 | if (!mux->busses) { |
ae58d1e4 SW |
172 | 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); | |
2737de46 | 214 | ret = -EPROBE_DEFER; |
ae58d1e4 SW |
215 | 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, | |
eee543e8 | 223 | mux, bus, i, 0, |
ae58d1e4 SW |
224 | 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 | ||
235 | err_del_adapter: | |
236 | for (; i > 0; i--) | |
237 | i2c_del_mux_adapter(mux->busses[i - 1]); | |
238 | i2c_put_adapter(mux->parent); | |
239 | err: | |
240 | return ret; | |
241 | } | |
242 | ||
0b255e92 | 243 | static int i2c_mux_pinctrl_remove(struct platform_device *pdev) |
ae58d1e4 SW |
244 | { |
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 | |
0b255e92 | 257 | static const struct of_device_id i2c_mux_pinctrl_of_match[] = { |
ae58d1e4 SW |
258 | { .compatible = "i2c-mux-pinctrl", }, |
259 | {}, | |
260 | }; | |
261 | MODULE_DEVICE_TABLE(of, i2c_mux_pinctrl_of_match); | |
262 | #endif | |
263 | ||
264 | static struct platform_driver i2c_mux_pinctrl_driver = { | |
265 | .driver = { | |
266 | .name = "i2c-mux-pinctrl", | |
ae58d1e4 SW |
267 | .of_match_table = of_match_ptr(i2c_mux_pinctrl_of_match), |
268 | }, | |
269 | .probe = i2c_mux_pinctrl_probe, | |
0b255e92 | 270 | .remove = i2c_mux_pinctrl_remove, |
ae58d1e4 SW |
271 | }; |
272 | module_platform_driver(i2c_mux_pinctrl_driver); | |
273 | ||
274 | MODULE_DESCRIPTION("pinctrl-based I2C multiplexer driver"); | |
275 | MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>"); | |
276 | MODULE_LICENSE("GPL v2"); | |
277 | MODULE_ALIAS("platform:i2c-mux-pinctrl"); |