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