]> git.sur5r.net Git - u-boot/blob - drivers/pinctrl/pinctrl-generic.c
Merge branch 'master' of git://git.denx.de/u-boot-sh
[u-boot] / drivers / pinctrl / pinctrl-generic.c
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 }