1 /*
2  * Copyright (C) 2015  Masahiro Yamada <yamada.masahiro@socionext.com>
3  *
4  * SPDX-License-Identifier:	GPL-2.0+
5  */
6 
7 #include <common.h>
8 #include <linux/compat.h>
9 #include <dm/device.h>
10 #include <dm/pinctrl.h>
11 
12 DECLARE_GLOBAL_DATA_PTR;
13 
14 /**
15  * pinctrl_pin_name_to_selector() - return the pin selector for a pin
16  *
17  * @dev: pin controller device
18  * @pin: the pin name to look up
19  * @return: pin selector, or negative error code on failure
20  */
21 static int pinctrl_pin_name_to_selector(struct udevice *dev, const char *pin)
22 {
23 	const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
24 	unsigned npins, selector;
25 
26 	if (!ops->get_pins_count || !ops->get_pin_name) {
27 		dev_dbg(dev, "get_pins_count or get_pin_name missing\n");
28 		return -ENOSYS;
29 	}
30 
31 	npins = ops->get_pins_count(dev);
32 
33 	/* See if this pctldev has this pin */
34 	for (selector = 0; selector < npins; selector++) {
35 		const char *pname = ops->get_pin_name(dev, selector);
36 
37 		if (!strcmp(pin, pname))
38 			return selector;
39 	}
40 
41 	return -ENOSYS;
42 }
43 
44 /**
45  * pinctrl_group_name_to_selector() - return the group selector for a group
46  *
47  * @dev: pin controller device
48  * @group: the pin group name to look up
49  * @return: pin group selector, or negative error code on failure
50  */
51 static int pinctrl_group_name_to_selector(struct udevice *dev,
52 					  const char *group)
53 {
54 	const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
55 	unsigned ngroups, selector;
56 
57 	if (!ops->get_groups_count || !ops->get_group_name) {
58 		dev_dbg(dev, "get_groups_count or get_group_name missing\n");
59 		return -ENOSYS;
60 	}
61 
62 	ngroups = ops->get_groups_count(dev);
63 
64 	/* See if this pctldev has this group */
65 	for (selector = 0; selector < ngroups; selector++) {
66 		const char *gname = ops->get_group_name(dev, selector);
67 
68 		if (!strcmp(group, gname))
69 			return selector;
70 	}
71 
72 	return -ENOSYS;
73 }
74 
75 #if CONFIG_IS_ENABLED(PINMUX)
76 /**
77  * pinmux_func_name_to_selector() - return the function selector for a function
78  *
79  * @dev: pin controller device
80  * @function: the function name to look up
81  * @return: function selector, or negative error code on failure
82  */
83 static int pinmux_func_name_to_selector(struct udevice *dev,
84 					const char *function)
85 {
86 	const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
87 	unsigned nfuncs, selector = 0;
88 
89 	if (!ops->get_functions_count || !ops->get_function_name) {
90 		dev_dbg(dev,
91 			"get_functions_count or get_function_name missing\n");
92 		return -ENOSYS;
93 	}
94 
95 	nfuncs = ops->get_functions_count(dev);
96 
97 	/* See if this pctldev has this function */
98 	for (selector = 0; selector < nfuncs; selector++) {
99 		const char *fname = ops->get_function_name(dev, selector);
100 
101 		if (!strcmp(function, fname))
102 			return selector;
103 	}
104 
105 	return -ENOSYS;
106 }
107 
108 /**
109  * pinmux_enable_setting() - enable pin-mux setting for a certain pin/group
110  *
111  * @dev: pin controller device
112  * @is_group: target of operation (true: pin group, false: pin)
113  * @selector: pin selector or group selector, depending on @is_group
114  * @func_selector: function selector
115  * @return: 0 on success, or negative error code on failure
116  */
117 static int pinmux_enable_setting(struct udevice *dev, bool is_group,
118 				 unsigned selector, unsigned func_selector)
119 {
120 	const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
121 
122 	if (is_group) {
123 		if (!ops->pinmux_group_set) {
124 			dev_dbg(dev, "pinmux_group_set op missing\n");
125 			return -ENOSYS;
126 		}
127 
128 		return ops->pinmux_group_set(dev, selector, func_selector);
129 	} else {
130 		if (!ops->pinmux_set) {
131 			dev_dbg(dev, "pinmux_set op missing\n");
132 			return -ENOSYS;
133 		}
134 		return ops->pinmux_set(dev, selector, func_selector);
135 	}
136 }
137 #else
138 static int pinmux_func_name_to_selector(struct udevice *dev,
139 					const char *function)
140 {
141 	return 0;
142 }
143 
144 static int pinmux_enable_setting(struct udevice *dev, bool is_group,
145 				 unsigned selector, unsigned func_selector)
146 {
147 	return 0;
148 }
149 #endif
150 
151 #if CONFIG_IS_ENABLED(PINCONF)
152 /**
153  * pinconf_prop_name_to_param() - return parameter ID for a property name
154  *
155  * @dev: pin controller device
156  * @property: property name in DTS, such as "bias-pull-up", "slew-rate", etc.
157  * @default_value: return default value in case no value is specified in DTS
158  * @return: return pamater ID, or negative error code on failure
159  */
160 static int pinconf_prop_name_to_param(struct udevice *dev,
161 				      const char *property, u32 *default_value)
162 {
163 	const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
164 	const struct pinconf_param *p, *end;
165 
166 	if (!ops->pinconf_num_params || !ops->pinconf_params) {
167 		dev_dbg(dev, "pinconf_num_params or pinconf_params missing\n");
168 		return -ENOSYS;
169 	}
170 
171 	p = ops->pinconf_params;
172 	end = p + ops->pinconf_num_params;
173 
174 	/* See if this pctldev supports this parameter */
175 	for (; p < end; p++) {
176 		if (!strcmp(property, p->property)) {
177 			*default_value = p->default_value;
178 			return p->param;
179 		}
180 	}
181 
182 	return -ENOSYS;
183 }
184 
185 /**
186  * pinconf_enable_setting() - apply pin configuration for a certain pin/group
187  *
188  * @dev: pin controller device
189  * @is_group: target of operation (true: pin group, false: pin)
190  * @selector: pin selector or group selector, depending on @is_group
191  * @param: configuration paramter
192  * @argument: argument taken by some configuration parameters
193  * @return: 0 on success, or negative error code on failure
194  */
195 static int pinconf_enable_setting(struct udevice *dev, bool is_group,
196 				  unsigned selector, unsigned param,
197 				  u32 argument)
198 {
199 	const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
200 
201 	if (is_group) {
202 		if (!ops->pinconf_group_set) {
203 			dev_dbg(dev, "pinconf_group_set op missing\n");
204 			return -ENOSYS;
205 		}
206 
207 		return ops->pinconf_group_set(dev, selector, param,
208 					      argument);
209 	} else {
210 		if (!ops->pinconf_set) {
211 			dev_dbg(dev, "pinconf_set op missing\n");
212 			return -ENOSYS;
213 		}
214 		return ops->pinconf_set(dev, selector, param, argument);
215 	}
216 }
217 #else
218 static int pinconf_prop_name_to_param(struct udevice *dev,
219 				      const char *property, u32 *default_value)
220 {
221 	return -ENOSYS;
222 }
223 
224 static int pinconf_enable_setting(struct udevice *dev, bool is_group,
225 				  unsigned selector, unsigned param,
226 				  u32 argument)
227 {
228 	return 0;
229 }
230 #endif
231 
232 /**
233  * pinctrl_generic_set_state_one() - set state for a certain pin/group
234  * Apply all pin multiplexing and pin configurations specified by @config
235  * for a given pin or pin group.
236  *
237  * @dev: pin controller device
238  * @config: pseudo device pointing to config node
239  * @is_group: target of operation (true: pin group, false: pin)
240  * @selector: pin selector or group selector, depending on @is_group
241  * @return: 0 on success, or negative error code on failure
242  */
243 static int pinctrl_generic_set_state_one(struct udevice *dev,
244 					 struct udevice *config,
245 					 bool is_group, unsigned selector)
246 {
247 	const void *fdt = gd->fdt_blob;
248 	int node_offset = config->of_offset;
249 	const char *propname;
250 	const void *value;
251 	int prop_offset, len, func_selector, param, ret;
252 	u32 arg, default_val;
253 
254 	for (prop_offset = fdt_first_property_offset(fdt, node_offset);
255 	     prop_offset > 0;
256 	     prop_offset = fdt_next_property_offset(fdt, prop_offset)) {
257 		value = fdt_getprop_by_offset(fdt, prop_offset,
258 					      &propname, &len);
259 		if (!value)
260 			return -EINVAL;
261 
262 		if (!strcmp(propname, "function")) {
263 			func_selector = pinmux_func_name_to_selector(dev,
264 								     value);
265 			if (func_selector < 0)
266 				return func_selector;
267 			ret = pinmux_enable_setting(dev, is_group,
268 						    selector,
269 						    func_selector);
270 		} else {
271 			param = pinconf_prop_name_to_param(dev, propname,
272 							   &default_val);
273 			if (param < 0)
274 				continue; /* just skip unknown properties */
275 
276 			if (len >= sizeof(fdt32_t))
277 				arg = fdt32_to_cpu(*(fdt32_t *)value);
278 			else
279 				arg = default_val;
280 
281 			ret = pinconf_enable_setting(dev, is_group,
282 						     selector, param, arg);
283 		}
284 
285 		if (ret)
286 			return ret;
287 	}
288 
289 	return 0;
290 }
291 
292 /**
293  * pinctrl_generic_set_state_subnode() - apply all settings in config node
294  *
295  * @dev: pin controller device
296  * @config: pseudo device pointing to config node
297  * @return: 0 on success, or negative error code on failure
298  */
299 static int pinctrl_generic_set_state_subnode(struct udevice *dev,
300 					     struct udevice *config)
301 {
302 	const void *fdt = gd->fdt_blob;
303 	int node = config->of_offset;
304 	const char *subnode_target_type = "pins";
305 	bool is_group = false;
306 	const char *name;
307 	int strings_count, selector, i, ret;
308 
309 	strings_count = fdt_count_strings(fdt, node, subnode_target_type);
310 	if (strings_count < 0) {
311 		subnode_target_type = "groups";
312 		is_group = true;
313 		strings_count = fdt_count_strings(fdt, node,
314 						  subnode_target_type);
315 		if (strings_count < 0) {
316 			/* skip this node; may contain config child nodes */
317 			return 0;
318 		}
319 	}
320 
321 	for (i = 0; i < strings_count; i++) {
322 		ret = fdt_get_string_index(fdt, node, subnode_target_type,
323 					   i, &name);
324 		if (ret < 0)
325 			return -EINVAL;
326 
327 		if (is_group)
328 			selector = pinctrl_group_name_to_selector(dev, name);
329 		else
330 			selector = pinctrl_pin_name_to_selector(dev, name);
331 		if (selector < 0)
332 			return selector;
333 
334 		ret = pinctrl_generic_set_state_one(dev, config,
335 						    is_group, selector);
336 		if (ret)
337 			return ret;
338 	}
339 
340 	return 0;
341 }
342 
343 int pinctrl_generic_set_state(struct udevice *dev, struct udevice *config)
344 {
345 	struct udevice *child;
346 	int ret;
347 
348 	ret = pinctrl_generic_set_state_subnode(dev, config);
349 	if (ret)
350 		return ret;
351 
352 	for (device_find_first_child(config, &child);
353 	     child;
354 	     device_find_next_child(&child)) {
355 		ret = pinctrl_generic_set_state_subnode(dev, child);
356 		if (ret)
357 			return ret;
358 	}
359 
360 	return 0;
361 }
362