1
2
3
4
5
6#include <common.h>
7#include <dm.h>
8#include <dm/device_compat.h>
9#include <linux/compat.h>
10#include <dm/pinctrl.h>
11
12
13
14
15
16
17
18
19static int pinctrl_pin_name_to_selector(struct udevice *dev, const char *pin)
20{
21 const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
22 unsigned npins, selector;
23
24 if (!ops->get_pins_count || !ops->get_pin_name) {
25 dev_dbg(dev, "get_pins_count or get_pin_name missing\n");
26 return -ENOSYS;
27 }
28
29 npins = ops->get_pins_count(dev);
30
31
32 for (selector = 0; selector < npins; selector++) {
33 const char *pname = ops->get_pin_name(dev, selector);
34
35 if (!strcmp(pin, pname))
36 return selector;
37 }
38
39 return -ENOSYS;
40}
41
42
43
44
45
46
47
48
49static int pinctrl_group_name_to_selector(struct udevice *dev,
50 const char *group)
51{
52 const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
53 unsigned ngroups, selector;
54
55 if (!ops->get_groups_count || !ops->get_group_name) {
56 dev_dbg(dev, "get_groups_count or get_group_name missing\n");
57 return -ENOSYS;
58 }
59
60 ngroups = ops->get_groups_count(dev);
61
62
63 for (selector = 0; selector < ngroups; selector++) {
64 const char *gname = ops->get_group_name(dev, selector);
65
66 if (!strcmp(group, gname))
67 return selector;
68 }
69
70 return -ENOSYS;
71}
72
73#if CONFIG_IS_ENABLED(PINMUX)
74
75
76
77
78
79
80
81static int pinmux_func_name_to_selector(struct udevice *dev,
82 const char *function)
83{
84 const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
85 unsigned nfuncs, selector = 0;
86
87 if (!ops->get_functions_count || !ops->get_function_name) {
88 dev_dbg(dev,
89 "get_functions_count or get_function_name missing\n");
90 return -ENOSYS;
91 }
92
93 nfuncs = ops->get_functions_count(dev);
94
95
96 for (selector = 0; selector < nfuncs; selector++) {
97 const char *fname = ops->get_function_name(dev, selector);
98
99 if (!strcmp(function, fname))
100 return selector;
101 }
102
103 return -ENOSYS;
104}
105
106
107
108
109
110
111
112
113
114
115static int pinmux_enable_setting(struct udevice *dev, bool is_group,
116 unsigned selector, unsigned func_selector)
117{
118 const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
119
120 if (is_group) {
121 if (!ops->pinmux_group_set) {
122 dev_dbg(dev, "pinmux_group_set op missing\n");
123 return -ENOSYS;
124 }
125
126 return ops->pinmux_group_set(dev, selector, func_selector);
127 } else {
128 if (!ops->pinmux_set) {
129 dev_dbg(dev, "pinmux_set op missing\n");
130 return -ENOSYS;
131 }
132 return ops->pinmux_set(dev, selector, func_selector);
133 }
134}
135#else
136static int pinmux_func_name_to_selector(struct udevice *dev,
137 const char *function)
138{
139 return 0;
140}
141
142static int pinmux_enable_setting(struct udevice *dev, bool is_group,
143 unsigned selector, unsigned func_selector)
144{
145 return 0;
146}
147#endif
148
149#if CONFIG_IS_ENABLED(PINCONF)
150
151
152
153
154
155
156
157
158static int pinconf_prop_name_to_param(struct udevice *dev,
159 const char *property, u32 *default_value)
160{
161 const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
162 const struct pinconf_param *p, *end;
163
164 if (!ops->pinconf_num_params || !ops->pinconf_params) {
165 dev_dbg(dev, "pinconf_num_params or pinconf_params missing\n");
166 return -ENOSYS;
167 }
168
169 p = ops->pinconf_params;
170 end = p + ops->pinconf_num_params;
171
172
173 for (; p < end; p++) {
174 if (!strcmp(property, p->property)) {
175 *default_value = p->default_value;
176 return p->param;
177 }
178 }
179
180 return -ENOSYS;
181}
182
183
184
185
186
187
188
189
190
191
192
193static int pinconf_enable_setting(struct udevice *dev, bool is_group,
194 unsigned selector, unsigned param,
195 u32 argument)
196{
197 const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
198
199 if (is_group) {
200 if (!ops->pinconf_group_set) {
201 dev_dbg(dev, "pinconf_group_set op missing\n");
202 return -ENOSYS;
203 }
204
205 return ops->pinconf_group_set(dev, selector, param,
206 argument);
207 } else {
208 if (!ops->pinconf_set) {
209 dev_dbg(dev, "pinconf_set op missing\n");
210 return -ENOSYS;
211 }
212 return ops->pinconf_set(dev, selector, param, argument);
213 }
214}
215#else
216static int pinconf_prop_name_to_param(struct udevice *dev,
217 const char *property, u32 *default_value)
218{
219 return -ENOSYS;
220}
221
222static int pinconf_enable_setting(struct udevice *dev, bool is_group,
223 unsigned selector, unsigned param,
224 u32 argument)
225{
226 return 0;
227}
228#endif
229
230enum pinmux_subnode_type {
231 PST_NONE = 0,
232 PST_PIN,
233 PST_GROUP,
234 PST_PINMUX,
235};
236
237static const char *alloc_name_with_prefix(const char *name, const char *prefix)
238{
239 if (prefix) {
240 char *name_with_prefix = malloc(strlen(prefix) + strlen(name) + 1);
241 if (name_with_prefix)
242 sprintf(name_with_prefix, "%s%s", prefix, name);
243 return name_with_prefix;
244 } else {
245 return name;
246 }
247}
248
249static void free_name_with_prefix(const char *name_with_prefix, const char *prefix)
250{
251 if (prefix)
252 free((char *)name_with_prefix);
253}
254
255
256
257
258
259
260
261
262
263
264
265
266
267static int pinctrl_generic_set_state_one(struct udevice *dev,
268 struct udevice *config,
269 const char *prefix,
270 enum pinmux_subnode_type subnode_type,
271 unsigned selector)
272{
273 const char *function_propname;
274 const char *propname;
275 const void *value;
276 struct ofprop property;
277 int len, func_selector, param, ret;
278 u32 arg, default_val;
279
280 assert(subnode_type != PST_NONE);
281
282 function_propname = alloc_name_with_prefix("function", prefix);
283 if (!function_propname)
284 return -ENOMEM;
285
286 dev_for_each_property(property, config) {
287 value = dev_read_prop_by_prop(&property, &propname, &len);
288 if (!value) {
289 free_name_with_prefix(function_propname, prefix);
290 return -EINVAL;
291 }
292
293
294 if (subnode_type != PST_PINMUX &&
295 !strcmp(propname, function_propname)) {
296 func_selector = pinmux_func_name_to_selector(dev,
297 value);
298 if (func_selector < 0) {
299 free_name_with_prefix(function_propname, prefix);
300 return func_selector;
301 }
302 ret = pinmux_enable_setting(dev,
303 subnode_type == PST_GROUP,
304 selector,
305 func_selector);
306 } else {
307 param = pinconf_prop_name_to_param(dev, propname,
308 &default_val);
309 if (param < 0)
310 continue;
311
312 if (len >= sizeof(fdt32_t))
313 arg = fdt32_to_cpu(*(fdt32_t *)value);
314 else
315 arg = default_val;
316
317 ret = pinconf_enable_setting(dev,
318 subnode_type == PST_GROUP,
319 selector, param, arg);
320 }
321
322 if (ret) {
323 free_name_with_prefix(function_propname, prefix);
324 return ret;
325 }
326 }
327
328 free_name_with_prefix(function_propname, prefix);
329 return 0;
330}
331
332
333
334
335
336
337
338
339
340
341static enum pinmux_subnode_type pinctrl_generic_get_subnode_type(struct udevice *dev,
342 struct udevice *config,
343 const char *prefix,
344 int *count)
345{
346 const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
347 const char *propname;
348
349 propname = alloc_name_with_prefix("pins", prefix);
350 if (!propname)
351 return -ENOMEM;
352 *count = dev_read_string_count(config, propname);
353 free_name_with_prefix(propname, prefix);
354 if (*count >= 0)
355 return PST_PIN;
356
357 propname = alloc_name_with_prefix("groups", prefix);
358 if (!propname)
359 return -ENOMEM;
360 *count = dev_read_string_count(config, propname);
361 free_name_with_prefix(propname, prefix);
362 if (*count >= 0)
363 return PST_GROUP;
364
365 if (ops->pinmux_property_set) {
366 propname = alloc_name_with_prefix("pinmux", prefix);
367 if (!propname)
368 return -ENOMEM;
369 *count = dev_read_size(config, propname);
370 free_name_with_prefix(propname, prefix);
371 if (*count >= 0 && !(*count % sizeof(u32))) {
372 *count /= sizeof(u32);
373 return PST_PINMUX;
374 }
375 }
376
377 *count = 0;
378 return PST_NONE;
379}
380
381
382
383
384
385
386
387
388
389static int pinctrl_generic_set_state_subnode(struct udevice *dev,
390 struct udevice *config,
391 const char *prefix)
392{
393 enum pinmux_subnode_type subnode_type;
394 const char *propname;
395 const char *name;
396 int count, selector, i, ret, scratch;
397 const u32 *pinmux_groups = NULL;
398
399 subnode_type = pinctrl_generic_get_subnode_type(dev, config, prefix, &count);
400
401 debug("%s(%s, %s): count=%d\n", __func__, dev->name, config->name,
402 count);
403
404 if (subnode_type == PST_PINMUX) {
405 propname = alloc_name_with_prefix("pinmux", prefix);
406 if (!propname)
407 return -ENOMEM;
408 pinmux_groups = dev_read_prop(config, propname, &scratch);
409 free_name_with_prefix(propname, prefix);
410 if (!pinmux_groups)
411 return -EINVAL;
412 }
413
414 for (i = 0; i < count; i++) {
415 switch (subnode_type) {
416 case PST_PIN:
417 propname = alloc_name_with_prefix("pins", prefix);
418 if (!propname)
419 return -ENOMEM;
420 ret = dev_read_string_index(config, propname, i, &name);
421 free_name_with_prefix(propname, prefix);
422 if (ret)
423 return ret;
424 selector = pinctrl_pin_name_to_selector(dev, name);
425 break;
426 case PST_GROUP:
427 propname = alloc_name_with_prefix("groups", prefix);
428 if (!propname)
429 return -ENOMEM;
430 ret = dev_read_string_index(config, propname, i, &name);
431 free_name_with_prefix(propname, prefix);
432 if (ret)
433 return ret;
434 selector = pinctrl_group_name_to_selector(dev, name);
435 break;
436 case PST_PINMUX: {
437 const struct pinctrl_ops *ops = pinctrl_get_ops(dev);
438 u32 pinmux_group = fdt32_to_cpu(pinmux_groups[i]);
439
440
441 selector = ops->pinmux_property_set(dev, pinmux_group);
442 break;
443 }
444 case PST_NONE:
445 default:
446
447 return 0;
448 }
449
450 if (selector < 0)
451 return selector;
452
453 ret = pinctrl_generic_set_state_one(dev, config, prefix,
454 subnode_type, selector);
455 if (ret)
456 return ret;
457 }
458
459 return 0;
460}
461
462int pinctrl_generic_set_state_prefix(struct udevice *dev, struct udevice *config,
463 const char *prefix)
464{
465 struct udevice *child;
466 int ret;
467
468 ret = pinctrl_generic_set_state_subnode(dev, config, prefix);
469 if (ret)
470 return ret;
471
472 for (device_find_first_child(config, &child);
473 child;
474 device_find_next_child(&child)) {
475 ret = pinctrl_generic_set_state_subnode(dev, child, prefix);
476 if (ret)
477 return ret;
478 }
479
480 return 0;
481}
482
483int pinctrl_generic_set_state(struct udevice *dev, struct udevice *config)
484{
485 return pinctrl_generic_set_state_prefix(dev, config, NULL);
486}
487