1 /*
2  *  linux/drivers/pinctrl/pinctrl-lantiq.c
3  *  based on linux/drivers/pinctrl/pinctrl-pxa3xx.c
4  *
5  *  This program is free software; you can redistribute it and/or modify
6  *  it under the terms of the GNU General Public License version 2 as
7  *  publishhed by the Free Software Foundation.
8  *
9  *  Copyright (C) 2012 John Crispin <john@phrozen.org>
10  */
11 
12 #include <linux/module.h>
13 #include <linux/device.h>
14 #include <linux/io.h>
15 #include <linux/platform_device.h>
16 #include <linux/slab.h>
17 #include <linux/of.h>
18 
19 #include "pinctrl-lantiq.h"
20 
21 static int ltq_get_group_count(struct pinctrl_dev *pctrldev)
22 {
23 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
24 	return info->num_grps;
25 }
26 
27 static const char *ltq_get_group_name(struct pinctrl_dev *pctrldev,
28 					 unsigned selector)
29 {
30 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
31 	if (selector >= info->num_grps)
32 		return NULL;
33 	return info->grps[selector].name;
34 }
35 
36 static int ltq_get_group_pins(struct pinctrl_dev *pctrldev,
37 				 unsigned selector,
38 				 const unsigned **pins,
39 				 unsigned *num_pins)
40 {
41 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
42 	if (selector >= info->num_grps)
43 		return -EINVAL;
44 	*pins = info->grps[selector].pins;
45 	*num_pins = info->grps[selector].npins;
46 	return 0;
47 }
48 
49 static void ltq_pinctrl_dt_free_map(struct pinctrl_dev *pctldev,
50 				    struct pinctrl_map *map, unsigned num_maps)
51 {
52 	int i;
53 
54 	for (i = 0; i < num_maps; i++)
55 		if (map[i].type == PIN_MAP_TYPE_CONFIGS_PIN ||
56 		    map[i].type == PIN_MAP_TYPE_CONFIGS_GROUP)
57 			kfree(map[i].data.configs.configs);
58 	kfree(map);
59 }
60 
61 static void ltq_pinctrl_pin_dbg_show(struct pinctrl_dev *pctldev,
62 					struct seq_file *s,
63 					unsigned offset)
64 {
65 	seq_printf(s, " %s", dev_name(pctldev->dev));
66 }
67 
68 static void ltq_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev,
69 				struct device_node *np,
70 				struct pinctrl_map **map)
71 {
72 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctldev);
73 	struct property *pins = of_find_property(np, "lantiq,pins", NULL);
74 	struct property *groups = of_find_property(np, "lantiq,groups", NULL);
75 	unsigned long configs[3];
76 	unsigned num_configs = 0;
77 	struct property *prop;
78 	const char *group, *pin;
79 	const char *function;
80 	int ret, i;
81 
82 	if (!pins && !groups) {
83 		dev_err(pctldev->dev, "%pOFn defines neither pins nor groups\n",
84 			np);
85 		return;
86 	}
87 
88 	if (pins && groups) {
89 		dev_err(pctldev->dev, "%pOFn defines both pins and groups\n",
90 			np);
91 		return;
92 	}
93 
94 	ret = of_property_read_string(np, "lantiq,function", &function);
95 	if (groups && !ret) {
96 		of_property_for_each_string(np, "lantiq,groups", prop, group) {
97 			(*map)->type = PIN_MAP_TYPE_MUX_GROUP;
98 			(*map)->name = function;
99 			(*map)->data.mux.group = group;
100 			(*map)->data.mux.function = function;
101 			(*map)++;
102 		}
103 	}
104 
105 	for (i = 0; i < info->num_params; i++) {
106 		u32 val;
107 		int ret = of_property_read_u32(np,
108 				info->params[i].property, &val);
109 		if (!ret)
110 			configs[num_configs++] =
111 				LTQ_PINCONF_PACK(info->params[i].param,
112 				val);
113 	}
114 
115 	if (!num_configs)
116 		return;
117 
118 	of_property_for_each_string(np, "lantiq,pins", prop, pin) {
119 		(*map)->data.configs.configs = kmemdup(configs,
120 					num_configs * sizeof(unsigned long),
121 					GFP_KERNEL);
122 		(*map)->type = PIN_MAP_TYPE_CONFIGS_PIN;
123 		(*map)->name = pin;
124 		(*map)->data.configs.group_or_pin = pin;
125 		(*map)->data.configs.num_configs = num_configs;
126 		(*map)++;
127 	}
128 	of_property_for_each_string(np, "lantiq,groups", prop, group) {
129 		(*map)->data.configs.configs = kmemdup(configs,
130 					num_configs * sizeof(unsigned long),
131 					GFP_KERNEL);
132 		(*map)->type = PIN_MAP_TYPE_CONFIGS_GROUP;
133 		(*map)->name = group;
134 		(*map)->data.configs.group_or_pin = group;
135 		(*map)->data.configs.num_configs = num_configs;
136 		(*map)++;
137 	}
138 }
139 
140 static int ltq_pinctrl_dt_subnode_size(struct device_node *np)
141 {
142 	int ret;
143 
144 	ret = of_property_count_strings(np, "lantiq,groups");
145 	if (ret < 0)
146 		ret = of_property_count_strings(np, "lantiq,pins");
147 	return ret;
148 }
149 
150 static int ltq_pinctrl_dt_node_to_map(struct pinctrl_dev *pctldev,
151 				      struct device_node *np_config,
152 				      struct pinctrl_map **map,
153 				      unsigned *num_maps)
154 {
155 	struct pinctrl_map *tmp;
156 	struct device_node *np;
157 	int max_maps = 0;
158 
159 	for_each_child_of_node(np_config, np)
160 		max_maps += ltq_pinctrl_dt_subnode_size(np);
161 	*map = kzalloc(array3_size(max_maps, sizeof(struct pinctrl_map), 2),
162 		       GFP_KERNEL);
163 	if (!*map)
164 		return -ENOMEM;
165 	tmp = *map;
166 
167 	for_each_child_of_node(np_config, np)
168 		ltq_pinctrl_dt_subnode_to_map(pctldev, np, &tmp);
169 	*num_maps = ((int)(tmp - *map));
170 
171 	return 0;
172 }
173 
174 static const struct pinctrl_ops ltq_pctrl_ops = {
175 	.get_groups_count	= ltq_get_group_count,
176 	.get_group_name		= ltq_get_group_name,
177 	.get_group_pins		= ltq_get_group_pins,
178 	.pin_dbg_show		= ltq_pinctrl_pin_dbg_show,
179 	.dt_node_to_map		= ltq_pinctrl_dt_node_to_map,
180 	.dt_free_map		= ltq_pinctrl_dt_free_map,
181 };
182 
183 static int ltq_pmx_func_count(struct pinctrl_dev *pctrldev)
184 {
185 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
186 
187 	return info->num_funcs;
188 }
189 
190 static const char *ltq_pmx_func_name(struct pinctrl_dev *pctrldev,
191 					 unsigned selector)
192 {
193 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
194 
195 	if (selector >= info->num_funcs)
196 		return NULL;
197 
198 	return info->funcs[selector].name;
199 }
200 
201 static int ltq_pmx_get_groups(struct pinctrl_dev *pctrldev,
202 				unsigned func,
203 				const char * const **groups,
204 				unsigned * const num_groups)
205 {
206 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
207 
208 	*groups = info->funcs[func].groups;
209 	*num_groups = info->funcs[func].num_groups;
210 
211 	return 0;
212 }
213 
214 /* Return function number. If failure, return negative value. */
215 static int match_mux(const struct ltq_mfp_pin *mfp, unsigned mux)
216 {
217 	int i;
218 	for (i = 0; i < LTQ_MAX_MUX; i++) {
219 		if (mfp->func[i] == mux)
220 			break;
221 	}
222 	if (i >= LTQ_MAX_MUX)
223 		return -EINVAL;
224 	return i;
225 }
226 
227 /* dont assume .mfp is linearly mapped. find the mfp with the correct .pin */
228 static int match_mfp(const struct ltq_pinmux_info *info, int pin)
229 {
230 	int i;
231 	for (i = 0; i < info->num_mfp; i++) {
232 		if (info->mfp[i].pin == pin)
233 			return i;
234 	}
235 	return -1;
236 }
237 
238 /* check whether current pin configuration is valid. Negative for failure */
239 static int match_group_mux(const struct ltq_pin_group *grp,
240 			   const struct ltq_pinmux_info *info,
241 			   unsigned mux)
242 {
243 	int i, pin, ret = 0;
244 	for (i = 0; i < grp->npins; i++) {
245 		pin = match_mfp(info, grp->pins[i]);
246 		if (pin < 0) {
247 			dev_err(info->dev, "could not find mfp for pin %d\n",
248 				grp->pins[i]);
249 			return -EINVAL;
250 		}
251 		ret = match_mux(&info->mfp[pin], mux);
252 		if (ret < 0) {
253 			dev_err(info->dev, "Can't find mux %d on pin%d\n",
254 				mux, pin);
255 			break;
256 		}
257 	}
258 	return ret;
259 }
260 
261 static int ltq_pmx_set(struct pinctrl_dev *pctrldev,
262 		       unsigned func,
263 		       unsigned group)
264 {
265 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
266 	const struct ltq_pin_group *pin_grp = &info->grps[group];
267 	int i, pin, pin_func, ret;
268 
269 	if (!pin_grp->npins ||
270 		(match_group_mux(pin_grp, info, pin_grp->mux) < 0)) {
271 		dev_err(info->dev, "Failed to set the pin group: %s\n",
272 			info->grps[group].name);
273 		return -EINVAL;
274 	}
275 	for (i = 0; i < pin_grp->npins; i++) {
276 		pin = match_mfp(info, pin_grp->pins[i]);
277 		if (pin < 0) {
278 			dev_err(info->dev, "could not find mfp for pin %d\n",
279 				pin_grp->pins[i]);
280 			return -EINVAL;
281 		}
282 		pin_func = match_mux(&info->mfp[pin], pin_grp->mux);
283 		ret = info->apply_mux(pctrldev, pin, pin_func);
284 		if (ret) {
285 			dev_err(info->dev,
286 				"failed to apply mux %d for pin %d\n",
287 				pin_func, pin);
288 			return ret;
289 		}
290 	}
291 	return 0;
292 }
293 
294 static int ltq_pmx_gpio_request_enable(struct pinctrl_dev *pctrldev,
295 				struct pinctrl_gpio_range *range,
296 				unsigned pin)
297 {
298 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
299 	int mfp = match_mfp(info, pin);
300 	int pin_func;
301 
302 	if (mfp < 0) {
303 		dev_err(info->dev, "could not find mfp for pin %d\n", pin);
304 		return -EINVAL;
305 	}
306 
307 	pin_func = match_mux(&info->mfp[mfp], 0);
308 	if (pin_func < 0) {
309 		dev_err(info->dev, "No GPIO function on pin%d\n", mfp);
310 		return -EINVAL;
311 	}
312 
313 	return info->apply_mux(pctrldev, mfp, pin_func);
314 }
315 
316 static const struct pinmux_ops ltq_pmx_ops = {
317 	.get_functions_count	= ltq_pmx_func_count,
318 	.get_function_name	= ltq_pmx_func_name,
319 	.get_function_groups	= ltq_pmx_get_groups,
320 	.set_mux		= ltq_pmx_set,
321 	.gpio_request_enable	= ltq_pmx_gpio_request_enable,
322 };
323 
324 /*
325  * allow different socs to register with the generic part of the lanti
326  * pinctrl code
327  */
328 int ltq_pinctrl_register(struct platform_device *pdev,
329 				struct ltq_pinmux_info *info)
330 {
331 	struct pinctrl_desc *desc;
332 
333 	if (!info)
334 		return -EINVAL;
335 	desc = info->desc;
336 	desc->pctlops = &ltq_pctrl_ops;
337 	desc->pmxops = &ltq_pmx_ops;
338 	info->dev = &pdev->dev;
339 
340 	info->pctrl = devm_pinctrl_register(&pdev->dev, desc, info);
341 	if (IS_ERR(info->pctrl)) {
342 		dev_err(&pdev->dev, "failed to register LTQ pinmux driver\n");
343 		return PTR_ERR(info->pctrl);
344 	}
345 	platform_set_drvdata(pdev, info);
346 	return 0;
347 }
348