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 <blogic@openwrt.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 			kfree(map[i].data.configs.configs);
57 	kfree(map);
58 }
59 
60 static void ltq_pinctrl_pin_dbg_show(struct pinctrl_dev *pctldev,
61 					struct seq_file *s,
62 					unsigned offset)
63 {
64 	seq_printf(s, " %s", dev_name(pctldev->dev));
65 }
66 
67 static int ltq_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev,
68 				struct device_node *np,
69 				struct pinctrl_map **map)
70 {
71 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctldev);
72 	unsigned long configs[3];
73 	unsigned num_configs = 0;
74 	struct property *prop;
75 	const char *group, *pin;
76 	const char *function;
77 	int ret, i;
78 
79 	ret = of_property_read_string(np, "lantiq,function", &function);
80 	if (!ret) {
81 		of_property_for_each_string(np, "lantiq,groups", prop, group) {
82 			(*map)->type = PIN_MAP_TYPE_MUX_GROUP;
83 			(*map)->name = function;
84 			(*map)->data.mux.group = group;
85 			(*map)->data.mux.function = function;
86 			(*map)++;
87 		}
88 		if (of_find_property(np, "lantiq,pins", NULL))
89 			dev_err(pctldev->dev,
90 				"%s mixes pins and groups settings\n",
91 				np->name);
92 		return 0;
93 	}
94 
95 	for (i = 0; i < info->num_params; i++) {
96 		u32 val;
97 		int ret = of_property_read_u32(np,
98 				info->params[i].property, &val);
99 		if (!ret)
100 			configs[num_configs++] =
101 				LTQ_PINCONF_PACK(info->params[i].param,
102 				val);
103 	}
104 
105 	if (!num_configs)
106 		return -EINVAL;
107 
108 	of_property_for_each_string(np, "lantiq,pins", prop, pin) {
109 		(*map)->data.configs.configs = kmemdup(configs,
110 					num_configs * sizeof(unsigned long),
111 					GFP_KERNEL);
112 		(*map)->type = PIN_MAP_TYPE_CONFIGS_PIN;
113 		(*map)->name = pin;
114 		(*map)->data.configs.group_or_pin = pin;
115 		(*map)->data.configs.num_configs = num_configs;
116 		(*map)++;
117 	}
118 	return 0;
119 }
120 
121 static int ltq_pinctrl_dt_subnode_size(struct device_node *np)
122 {
123 	int ret;
124 
125 	ret = of_property_count_strings(np, "lantiq,groups");
126 	if (ret < 0)
127 		ret = of_property_count_strings(np, "lantiq,pins");
128 	return ret;
129 }
130 
131 static int ltq_pinctrl_dt_node_to_map(struct pinctrl_dev *pctldev,
132 				      struct device_node *np_config,
133 				      struct pinctrl_map **map,
134 				      unsigned *num_maps)
135 {
136 	struct pinctrl_map *tmp;
137 	struct device_node *np;
138 	int ret;
139 
140 	*num_maps = 0;
141 	for_each_child_of_node(np_config, np)
142 		*num_maps += ltq_pinctrl_dt_subnode_size(np);
143 	*map = kzalloc(*num_maps * sizeof(struct pinctrl_map), GFP_KERNEL);
144 	if (!*map)
145 		return -ENOMEM;
146 	tmp = *map;
147 
148 	for_each_child_of_node(np_config, np) {
149 		ret = ltq_pinctrl_dt_subnode_to_map(pctldev, np, &tmp);
150 		if (ret < 0) {
151 			ltq_pinctrl_dt_free_map(pctldev, *map, *num_maps);
152 			return ret;
153 		}
154 	}
155 	return 0;
156 }
157 
158 static struct pinctrl_ops ltq_pctrl_ops = {
159 	.get_groups_count	= ltq_get_group_count,
160 	.get_group_name		= ltq_get_group_name,
161 	.get_group_pins		= ltq_get_group_pins,
162 	.pin_dbg_show		= ltq_pinctrl_pin_dbg_show,
163 	.dt_node_to_map		= ltq_pinctrl_dt_node_to_map,
164 	.dt_free_map		= ltq_pinctrl_dt_free_map,
165 };
166 
167 static int ltq_pmx_func_count(struct pinctrl_dev *pctrldev)
168 {
169 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
170 
171 	return info->num_funcs;
172 }
173 
174 static const char *ltq_pmx_func_name(struct pinctrl_dev *pctrldev,
175 					 unsigned selector)
176 {
177 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
178 
179 	if (selector >= info->num_funcs)
180 		return NULL;
181 
182 	return info->funcs[selector].name;
183 }
184 
185 static int ltq_pmx_get_groups(struct pinctrl_dev *pctrldev,
186 				unsigned func,
187 				const char * const **groups,
188 				unsigned * const num_groups)
189 {
190 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
191 
192 	*groups = info->funcs[func].groups;
193 	*num_groups = info->funcs[func].num_groups;
194 
195 	return 0;
196 }
197 
198 /* Return function number. If failure, return negative value. */
199 static int match_mux(const struct ltq_mfp_pin *mfp, unsigned mux)
200 {
201 	int i;
202 	for (i = 0; i < LTQ_MAX_MUX; i++) {
203 		if (mfp->func[i] == mux)
204 			break;
205 	}
206 	if (i >= LTQ_MAX_MUX)
207 		return -EINVAL;
208 	return i;
209 }
210 
211 /* dont assume .mfp is linearly mapped. find the mfp with the correct .pin */
212 static int match_mfp(const struct ltq_pinmux_info *info, int pin)
213 {
214 	int i;
215 	for (i = 0; i < info->num_mfp; i++) {
216 		if (info->mfp[i].pin == pin)
217 			return i;
218 	}
219 	return -1;
220 }
221 
222 /* check whether current pin configuration is valid. Negative for failure */
223 static int match_group_mux(const struct ltq_pin_group *grp,
224 			   const struct ltq_pinmux_info *info,
225 			   unsigned mux)
226 {
227 	int i, pin, ret = 0;
228 	for (i = 0; i < grp->npins; i++) {
229 		pin = match_mfp(info, grp->pins[i]);
230 		if (pin < 0) {
231 			dev_err(info->dev, "could not find mfp for pin %d\n",
232 				grp->pins[i]);
233 			return -EINVAL;
234 		}
235 		ret = match_mux(&info->mfp[pin], mux);
236 		if (ret < 0) {
237 			dev_err(info->dev, "Can't find mux %d on pin%d\n",
238 				mux, pin);
239 			break;
240 		}
241 	}
242 	return ret;
243 }
244 
245 static int ltq_pmx_enable(struct pinctrl_dev *pctrldev,
246 				unsigned func,
247 				unsigned group)
248 {
249 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
250 	const struct ltq_pin_group *pin_grp = &info->grps[group];
251 	int i, pin, pin_func, ret;
252 
253 	if (!pin_grp->npins ||
254 		(match_group_mux(pin_grp, info, pin_grp->mux) < 0)) {
255 		dev_err(info->dev, "Failed to set the pin group: %s\n",
256 			info->grps[group].name);
257 		return -EINVAL;
258 	}
259 	for (i = 0; i < pin_grp->npins; i++) {
260 		pin = match_mfp(info, pin_grp->pins[i]);
261 		if (pin < 0) {
262 			dev_err(info->dev, "could not find mfp for pin %d\n",
263 				pin_grp->pins[i]);
264 			return -EINVAL;
265 		}
266 		pin_func = match_mux(&info->mfp[pin], pin_grp->mux);
267 		ret = info->apply_mux(pctrldev, pin, pin_func);
268 		if (ret) {
269 			dev_err(info->dev,
270 				"failed to apply mux %d for pin %d\n",
271 				pin_func, pin);
272 			return ret;
273 		}
274 	}
275 	return 0;
276 }
277 
278 static int ltq_pmx_gpio_request_enable(struct pinctrl_dev *pctrldev,
279 				struct pinctrl_gpio_range *range,
280 				unsigned pin)
281 {
282 	struct ltq_pinmux_info *info = pinctrl_dev_get_drvdata(pctrldev);
283 	int mfp = match_mfp(info, pin + (range->id * 32));
284 	int pin_func;
285 
286 	if (mfp < 0) {
287 		dev_err(info->dev, "could not find mfp for pin %d\n", pin);
288 		return -EINVAL;
289 	}
290 
291 	pin_func = match_mux(&info->mfp[mfp], 0);
292 	if (pin_func < 0) {
293 		dev_err(info->dev, "No GPIO function on pin%d\n", mfp);
294 		return -EINVAL;
295 	}
296 
297 	return info->apply_mux(pctrldev, mfp, pin_func);
298 }
299 
300 static struct pinmux_ops ltq_pmx_ops = {
301 	.get_functions_count	= ltq_pmx_func_count,
302 	.get_function_name	= ltq_pmx_func_name,
303 	.get_function_groups	= ltq_pmx_get_groups,
304 	.enable			= ltq_pmx_enable,
305 	.gpio_request_enable	= ltq_pmx_gpio_request_enable,
306 };
307 
308 /*
309  * allow different socs to register with the generic part of the lanti
310  * pinctrl code
311  */
312 int ltq_pinctrl_register(struct platform_device *pdev,
313 				struct ltq_pinmux_info *info)
314 {
315 	struct pinctrl_desc *desc;
316 
317 	if (!info)
318 		return -EINVAL;
319 	desc = info->desc;
320 	desc->pctlops = &ltq_pctrl_ops;
321 	desc->pmxops = &ltq_pmx_ops;
322 	info->dev = &pdev->dev;
323 
324 	info->pctrl = pinctrl_register(desc, &pdev->dev, info);
325 	if (!info->pctrl) {
326 		dev_err(&pdev->dev, "failed to register LTQ pinmux driver\n");
327 		return -EINVAL;
328 	}
329 	platform_set_drvdata(pdev, info);
330 	return 0;
331 }
332