Commit | Line | Data |
---|---|---|
af873fce | 1 | // SPDX-License-Identifier: GPL-2.0-only |
394349f7 LW |
2 | /* |
3 | * Core driver for the generic pin config portions of the pin control subsystem | |
4 | * | |
5 | * Copyright (C) 2011 ST-Ericsson SA | |
6 | * Written on behalf of Linaro for ST-Ericsson | |
7 | * | |
8 | * Author: Linus Walleij <linus.walleij@linaro.org> | |
394349f7 LW |
9 | */ |
10 | ||
11 | #define pr_fmt(fmt) "generic pinconfig core: " fmt | |
12 | ||
82cc14c9 AS |
13 | #include <linux/array_size.h> |
14 | #include <linux/debugfs.h> | |
394349f7 | 15 | #include <linux/device.h> |
82cc14c9 AS |
16 | #include <linux/init.h> |
17 | #include <linux/module.h> | |
18 | #include <linux/of.h> | |
394349f7 | 19 | #include <linux/slab.h> |
394349f7 | 20 | #include <linux/seq_file.h> |
82cc14c9 | 21 | |
394349f7 | 22 | #include <linux/pinctrl/pinconf-generic.h> |
82cc14c9 AS |
23 | #include <linux/pinctrl/pinconf.h> |
24 | #include <linux/pinctrl/pinctrl.h> | |
25 | ||
394349f7 LW |
26 | #include "core.h" |
27 | #include "pinconf.h" | |
e81c8f18 | 28 | #include "pinctrl-utils.h" |
394349f7 LW |
29 | |
30 | #ifdef CONFIG_DEBUG_FS | |
2500bcc9 | 31 | static const struct pin_config_item conf_items[] = { |
3c4b23dd | 32 | PCONFDUMP(PIN_CONFIG_BIAS_BUS_HOLD, "input bias bus hold", NULL, false), |
eec45071 SB |
33 | PCONFDUMP(PIN_CONFIG_BIAS_DISABLE, "input bias disabled", NULL, false), |
34 | PCONFDUMP(PIN_CONFIG_BIAS_HIGH_IMPEDANCE, "input bias high impedance", NULL, false), | |
188e5834 | 35 | PCONFDUMP(PIN_CONFIG_BIAS_PULL_DOWN, "input bias pull down", "ohms", true), |
7970cb77 | 36 | PCONFDUMP(PIN_CONFIG_BIAS_PULL_PIN_DEFAULT, |
188e5834 CYT |
37 | "input bias pull to pin specific state", "ohms", true), |
38 | PCONFDUMP(PIN_CONFIG_BIAS_PULL_UP, "input bias pull up", "ohms", true), | |
eec45071 SB |
39 | PCONFDUMP(PIN_CONFIG_DRIVE_OPEN_DRAIN, "output drive open drain", NULL, false), |
40 | PCONFDUMP(PIN_CONFIG_DRIVE_OPEN_SOURCE, "output drive open source", NULL, false), | |
3c4b23dd | 41 | PCONFDUMP(PIN_CONFIG_DRIVE_PUSH_PULL, "output drive push pull", NULL, false), |
eec45071 | 42 | PCONFDUMP(PIN_CONFIG_DRIVE_STRENGTH, "output drive strength", "mA", true), |
c08e7e4c | 43 | PCONFDUMP(PIN_CONFIG_DRIVE_STRENGTH_UA, "output drive strength", "uA", true), |
3c4b23dd | 44 | PCONFDUMP(PIN_CONFIG_INPUT_DEBOUNCE, "input debounce", "usec", true), |
eec45071 | 45 | PCONFDUMP(PIN_CONFIG_INPUT_ENABLE, "input enabled", NULL, false), |
eec45071 | 46 | PCONFDUMP(PIN_CONFIG_INPUT_SCHMITT, "input schmitt trigger", NULL, false), |
3c4b23dd | 47 | PCONFDUMP(PIN_CONFIG_INPUT_SCHMITT_ENABLE, "input schmitt enabled", NULL, false), |
31f9a421 | 48 | PCONFDUMP(PIN_CONFIG_MODE_LOW_POWER, "pin low power", "mode", true), |
42556242 | 49 | PCONFDUMP(PIN_CONFIG_OUTPUT_ENABLE, "output enabled", NULL, false), |
eec45071 | 50 | PCONFDUMP(PIN_CONFIG_OUTPUT, "pin output", "level", true), |
032816fb | 51 | PCONFDUMP(PIN_CONFIG_OUTPUT_IMPEDANCE_OHMS, "output impedance", "ohms", true), |
3c4b23dd | 52 | PCONFDUMP(PIN_CONFIG_POWER_SOURCE, "pin power source", "selector", true), |
6606bc9d | 53 | PCONFDUMP(PIN_CONFIG_SLEEP_HARDWARE_STATE, "sleep hardware state", NULL, false), |
3c4b23dd | 54 | PCONFDUMP(PIN_CONFIG_SLEW_RATE, "slew rate", NULL, true), |
e0e1e39d | 55 | PCONFDUMP(PIN_CONFIG_SKEW_DELAY, "skew delay", NULL, true), |
394349f7 LW |
56 | }; |
57 | ||
dd4d01f7 SB |
58 | static void pinconf_generic_dump_one(struct pinctrl_dev *pctldev, |
59 | struct seq_file *s, const char *gname, | |
60 | unsigned pin, | |
61 | const struct pin_config_item *items, | |
a672eb5e | 62 | int nitems, int *print_sep) |
394349f7 | 63 | { |
394349f7 LW |
64 | int i; |
65 | ||
dd4d01f7 | 66 | for (i = 0; i < nitems; i++) { |
394349f7 LW |
67 | unsigned long config; |
68 | int ret; | |
69 | ||
70 | /* We want to check out this parameter */ | |
dd4d01f7 SB |
71 | config = pinconf_to_config_packed(items[i].param, 0); |
72 | if (gname) | |
73 | ret = pin_config_group_get(dev_name(pctldev->dev), | |
74 | gname, &config); | |
75 | else | |
76 | ret = pin_config_get_for_pin(pctldev, pin, &config); | |
394349f7 LW |
77 | /* These are legal errors */ |
78 | if (ret == -EINVAL || ret == -ENOTSUPP) | |
79 | continue; | |
80 | if (ret) { | |
81 | seq_printf(s, "ERROR READING CONFIG SETTING %d ", i); | |
82 | continue; | |
83 | } | |
a672eb5e MY |
84 | /* comma between multiple configs */ |
85 | if (*print_sep) | |
86 | seq_puts(s, ", "); | |
87 | *print_sep = 1; | |
dd4d01f7 | 88 | seq_puts(s, items[i].display); |
394349f7 | 89 | /* Print unit if available */ |
dd4d01f7 | 90 | if (items[i].has_arg) { |
eec45071 SB |
91 | seq_printf(s, " (%u", |
92 | pinconf_to_config_argument(config)); | |
dd4d01f7 SB |
93 | if (items[i].format) |
94 | seq_printf(s, " %s)", items[i].format); | |
eec45071 SB |
95 | else |
96 | seq_puts(s, ")"); | |
97 | } | |
394349f7 LW |
98 | } |
99 | } | |
100 | ||
dd4d01f7 SB |
101 | /** |
102 | * pinconf_generic_dump_pins - Print information about pin or group of pins | |
103 | * @pctldev: Pincontrol device | |
104 | * @s: File to print to | |
105 | * @gname: Group name specifying pins | |
106 | * @pin: Pin number specyfying pin | |
107 | * | |
108 | * Print the pinconf configuration for the requested pin(s) to @s. Pins can be | |
109 | * specified either by pin using @pin or by group using @gname. Only one needs | |
110 | * to be specified the other can be NULL/0. | |
111 | */ | |
112 | void pinconf_generic_dump_pins(struct pinctrl_dev *pctldev, struct seq_file *s, | |
113 | const char *gname, unsigned pin) | |
394349f7 LW |
114 | { |
115 | const struct pinconf_ops *ops = pctldev->desc->confops; | |
a672eb5e | 116 | int print_sep = 0; |
394349f7 LW |
117 | |
118 | if (!ops->is_generic) | |
119 | return; | |
120 | ||
dd4d01f7 SB |
121 | /* generic parameters */ |
122 | pinconf_generic_dump_one(pctldev, s, gname, pin, conf_items, | |
a672eb5e | 123 | ARRAY_SIZE(conf_items), &print_sep); |
dd4d01f7 | 124 | /* driver-specific parameters */ |
f684e4ac LW |
125 | if (pctldev->desc->num_custom_params && |
126 | pctldev->desc->custom_conf_items) | |
dd4d01f7 | 127 | pinconf_generic_dump_one(pctldev, s, gname, pin, |
f684e4ac | 128 | pctldev->desc->custom_conf_items, |
a672eb5e MY |
129 | pctldev->desc->num_custom_params, |
130 | &print_sep); | |
394349f7 LW |
131 | } |
132 | ||
9cfd1724 HZ |
133 | void pinconf_generic_dump_config(struct pinctrl_dev *pctldev, |
134 | struct seq_file *s, unsigned long config) | |
135 | { | |
136 | int i; | |
137 | ||
b6465424 | 138 | for (i = 0; i < ARRAY_SIZE(conf_items); i++) { |
9cfd1724 HZ |
139 | if (pinconf_to_config_param(config) != conf_items[i].param) |
140 | continue; | |
141 | seq_printf(s, "%s: 0x%x", conf_items[i].display, | |
142 | pinconf_to_config_argument(config)); | |
143 | } | |
dd4d01f7 | 144 | |
f684e4ac LW |
145 | if (!pctldev->desc->num_custom_params || |
146 | !pctldev->desc->custom_conf_items) | |
dd4d01f7 SB |
147 | return; |
148 | ||
f684e4ac LW |
149 | for (i = 0; i < pctldev->desc->num_custom_params; i++) { |
150 | if (pinconf_to_config_param(config) != | |
151 | pctldev->desc->custom_conf_items[i].param) | |
dd4d01f7 | 152 | continue; |
f684e4ac LW |
153 | seq_printf(s, "%s: 0x%x", |
154 | pctldev->desc->custom_conf_items[i].display, | |
155 | pinconf_to_config_argument(config)); | |
dd4d01f7 | 156 | } |
9cfd1724 HZ |
157 | } |
158 | EXPORT_SYMBOL_GPL(pinconf_generic_dump_config); | |
394349f7 | 159 | #endif |
7db9af4b HS |
160 | |
161 | #ifdef CONFIG_OF | |
f684e4ac | 162 | static const struct pinconf_generic_params dt_params[] = { |
3c4b23dd | 163 | { "bias-bus-hold", PIN_CONFIG_BIAS_BUS_HOLD, 0 }, |
7db9af4b HS |
164 | { "bias-disable", PIN_CONFIG_BIAS_DISABLE, 0 }, |
165 | { "bias-high-impedance", PIN_CONFIG_BIAS_HIGH_IMPEDANCE, 0 }, | |
9ee1f7d2 | 166 | { "bias-pull-up", PIN_CONFIG_BIAS_PULL_UP, 1 }, |
9ee1f7d2 | 167 | { "bias-pull-pin-default", PIN_CONFIG_BIAS_PULL_PIN_DEFAULT, 1 }, |
3c4b23dd | 168 | { "bias-pull-down", PIN_CONFIG_BIAS_PULL_DOWN, 1 }, |
7db9af4b HS |
169 | { "drive-open-drain", PIN_CONFIG_DRIVE_OPEN_DRAIN, 0 }, |
170 | { "drive-open-source", PIN_CONFIG_DRIVE_OPEN_SOURCE, 0 }, | |
3c4b23dd | 171 | { "drive-push-pull", PIN_CONFIG_DRIVE_PUSH_PULL, 0 }, |
7db9af4b | 172 | { "drive-strength", PIN_CONFIG_DRIVE_STRENGTH, 0 }, |
c08e7e4c | 173 | { "drive-strength-microamp", PIN_CONFIG_DRIVE_STRENGTH_UA, 0 }, |
3c4b23dd | 174 | { "input-debounce", PIN_CONFIG_INPUT_DEBOUNCE, 0 }, |
8ba3f4d0 | 175 | { "input-disable", PIN_CONFIG_INPUT_ENABLE, 0 }, |
3c4b23dd | 176 | { "input-enable", PIN_CONFIG_INPUT_ENABLE, 1 }, |
69c308e2 | 177 | { "input-schmitt", PIN_CONFIG_INPUT_SCHMITT, 0 }, |
7db9af4b | 178 | { "input-schmitt-disable", PIN_CONFIG_INPUT_SCHMITT_ENABLE, 0 }, |
3c4b23dd | 179 | { "input-schmitt-enable", PIN_CONFIG_INPUT_SCHMITT_ENABLE, 1 }, |
31f9a421 AS |
180 | { "low-power-disable", PIN_CONFIG_MODE_LOW_POWER, 0 }, |
181 | { "low-power-enable", PIN_CONFIG_MODE_LOW_POWER, 1 }, | |
42556242 JM |
182 | { "output-disable", PIN_CONFIG_OUTPUT_ENABLE, 0 }, |
183 | { "output-enable", PIN_CONFIG_OUTPUT_ENABLE, 1 }, | |
7db9af4b | 184 | { "output-high", PIN_CONFIG_OUTPUT, 1, }, |
032816fb | 185 | { "output-impedance-ohms", PIN_CONFIG_OUTPUT_IMPEDANCE_OHMS, 0 }, |
3c4b23dd MY |
186 | { "output-low", PIN_CONFIG_OUTPUT, 0, }, |
187 | { "power-source", PIN_CONFIG_POWER_SOURCE, 0 }, | |
6606bc9d | 188 | { "sleep-hardware-state", PIN_CONFIG_SLEEP_HARDWARE_STATE, 0 }, |
3c4b23dd | 189 | { "slew-rate", PIN_CONFIG_SLEW_RATE, 0 }, |
e0e1e39d | 190 | { "skew-delay", PIN_CONFIG_SKEW_DELAY, 0 }, |
7db9af4b HS |
191 | }; |
192 | ||
dd4d01f7 | 193 | /** |
f684e4ac | 194 | * parse_dt_cfg() - Parse DT pinconf parameters |
dd4d01f7 | 195 | * @np: DT node |
f684e4ac | 196 | * @params: Array of describing generic parameters |
dd4d01f7 SB |
197 | * @count: Number of entries in @params |
198 | * @cfg: Array of parsed config options | |
199 | * @ncfg: Number of entries in @cfg | |
200 | * | |
201 | * Parse the config options described in @params from @np and puts the result | |
3ec440e3 | 202 | * in @cfg. @cfg does not need to be empty, entries are added beginning at |
dd4d01f7 SB |
203 | * @ncfg. @ncfg is updated to reflect the number of entries after parsing. @cfg |
204 | * needs to have enough memory allocated to hold all possible entries. | |
205 | */ | |
206 | static void parse_dt_cfg(struct device_node *np, | |
f684e4ac | 207 | const struct pinconf_generic_params *params, |
dd4d01f7 SB |
208 | unsigned int count, unsigned long *cfg, |
209 | unsigned int *ncfg) | |
210 | { | |
211 | int i; | |
212 | ||
213 | for (i = 0; i < count; i++) { | |
214 | u32 val; | |
215 | int ret; | |
f684e4ac | 216 | const struct pinconf_generic_params *par = ¶ms[i]; |
dd4d01f7 SB |
217 | |
218 | ret = of_property_read_u32(np, par->property, &val); | |
219 | ||
220 | /* property not found */ | |
221 | if (ret == -EINVAL) | |
222 | continue; | |
223 | ||
224 | /* use default value, when no value is specified */ | |
225 | if (ret) | |
226 | val = par->default_value; | |
227 | ||
228 | pr_debug("found %s with value %u\n", par->property, val); | |
229 | cfg[*ncfg] = pinconf_to_config_packed(par->param, val); | |
230 | (*ncfg)++; | |
231 | } | |
232 | } | |
233 | ||
7db9af4b HS |
234 | /** |
235 | * pinconf_generic_parse_dt_config() | |
236 | * parse the config properties into generic pinconfig values. | |
237 | * @np: node containing the pinconfig properties | |
b4dab774 | 238 | * @pctldev: pincontrol device |
7db9af4b | 239 | * @configs: array with nconfigs entries containing the generic pinconf values |
d9ac5e25 | 240 | * must be freed when no longer necessary. |
b4dab774 | 241 | * @nconfigs: number of configurations |
7db9af4b HS |
242 | */ |
243 | int pinconf_generic_parse_dt_config(struct device_node *np, | |
dd4d01f7 | 244 | struct pinctrl_dev *pctldev, |
7db9af4b HS |
245 | unsigned long **configs, |
246 | unsigned int *nconfigs) | |
247 | { | |
6abab2d4 | 248 | unsigned long *cfg; |
dd4d01f7 | 249 | unsigned int max_cfg, ncfg = 0; |
7db9af4b | 250 | int ret; |
7db9af4b HS |
251 | |
252 | if (!np) | |
253 | return -EINVAL; | |
254 | ||
6abab2d4 | 255 | /* allocate a temporary array big enough to hold one of each option */ |
dd4d01f7 SB |
256 | max_cfg = ARRAY_SIZE(dt_params); |
257 | if (pctldev) | |
f684e4ac | 258 | max_cfg += pctldev->desc->num_custom_params; |
dd4d01f7 | 259 | cfg = kcalloc(max_cfg, sizeof(*cfg), GFP_KERNEL); |
6abab2d4 HS |
260 | if (!cfg) |
261 | return -ENOMEM; | |
262 | ||
dd4d01f7 | 263 | parse_dt_cfg(np, dt_params, ARRAY_SIZE(dt_params), cfg, &ncfg); |
f684e4ac LW |
264 | if (pctldev && pctldev->desc->num_custom_params && |
265 | pctldev->desc->custom_params) | |
266 | parse_dt_cfg(np, pctldev->desc->custom_params, | |
267 | pctldev->desc->num_custom_params, cfg, &ncfg); | |
7db9af4b | 268 | |
6abab2d4 HS |
269 | ret = 0; |
270 | ||
e4a8844c HS |
271 | /* no configs found at all */ |
272 | if (ncfg == 0) { | |
273 | *configs = NULL; | |
274 | *nconfigs = 0; | |
6abab2d4 | 275 | goto out; |
e4a8844c HS |
276 | } |
277 | ||
7db9af4b HS |
278 | /* |
279 | * Now limit the number of configs to the real number of | |
280 | * found properties. | |
281 | */ | |
db388dfb | 282 | *configs = kmemdup(cfg, ncfg * sizeof(unsigned long), GFP_KERNEL); |
6abab2d4 HS |
283 | if (!*configs) { |
284 | ret = -ENOMEM; | |
285 | goto out; | |
286 | } | |
7db9af4b | 287 | |
7db9af4b | 288 | *nconfigs = ncfg; |
6abab2d4 HS |
289 | |
290 | out: | |
291 | kfree(cfg); | |
292 | return ret; | |
7db9af4b | 293 | } |
b88d1451 | 294 | EXPORT_SYMBOL_GPL(pinconf_generic_parse_dt_config); |
e81c8f18 LD |
295 | |
296 | int pinconf_generic_dt_subnode_to_map(struct pinctrl_dev *pctldev, | |
297 | struct device_node *np, struct pinctrl_map **map, | |
3287c240 LD |
298 | unsigned *reserved_maps, unsigned *num_maps, |
299 | enum pinctrl_map_type type) | |
e81c8f18 LD |
300 | { |
301 | int ret; | |
302 | const char *function; | |
303 | struct device *dev = pctldev->dev; | |
304 | unsigned long *configs = NULL; | |
305 | unsigned num_configs = 0; | |
c7289500 | 306 | unsigned reserve, strings_count; |
e81c8f18 LD |
307 | struct property *prop; |
308 | const char *group; | |
31c89c95 | 309 | const char *subnode_target_type = "pins"; |
e81c8f18 | 310 | |
c7289500 BS |
311 | ret = of_property_count_strings(np, "pins"); |
312 | if (ret < 0) { | |
313 | ret = of_property_count_strings(np, "groups"); | |
314 | if (ret < 0) | |
315 | /* skip this node; may contain config child nodes */ | |
316 | return 0; | |
317 | if (type == PIN_MAP_TYPE_INVALID) | |
318 | type = PIN_MAP_TYPE_CONFIGS_GROUP; | |
319 | subnode_target_type = "groups"; | |
320 | } else { | |
321 | if (type == PIN_MAP_TYPE_INVALID) | |
322 | type = PIN_MAP_TYPE_CONFIGS_PIN; | |
323 | } | |
324 | strings_count = ret; | |
325 | ||
e81c8f18 LD |
326 | ret = of_property_read_string(np, "function", &function); |
327 | if (ret < 0) { | |
328 | /* EINVAL=missing, which is fine since it's optional */ | |
329 | if (ret != -EINVAL) | |
f5292d06 RH |
330 | dev_err(dev, "%pOF: could not parse property function\n", |
331 | np); | |
e81c8f18 LD |
332 | function = NULL; |
333 | } | |
334 | ||
dd4d01f7 SB |
335 | ret = pinconf_generic_parse_dt_config(np, pctldev, &configs, |
336 | &num_configs); | |
e81c8f18 | 337 | if (ret < 0) { |
f5292d06 | 338 | dev_err(dev, "%pOF: could not parse node property\n", np); |
e81c8f18 LD |
339 | return ret; |
340 | } | |
341 | ||
342 | reserve = 0; | |
343 | if (function != NULL) | |
344 | reserve++; | |
345 | if (num_configs) | |
346 | reserve++; | |
31c89c95 | 347 | |
c7289500 | 348 | reserve *= strings_count; |
e81c8f18 LD |
349 | |
350 | ret = pinctrl_utils_reserve_map(pctldev, map, reserved_maps, | |
351 | num_maps, reserve); | |
352 | if (ret < 0) | |
353 | goto exit; | |
354 | ||
31c89c95 | 355 | of_property_for_each_string(np, subnode_target_type, prop, group) { |
e81c8f18 LD |
356 | if (function) { |
357 | ret = pinctrl_utils_add_map_mux(pctldev, map, | |
358 | reserved_maps, num_maps, group, | |
359 | function); | |
360 | if (ret < 0) | |
361 | goto exit; | |
362 | } | |
363 | ||
364 | if (num_configs) { | |
365 | ret = pinctrl_utils_add_map_configs(pctldev, map, | |
366 | reserved_maps, num_maps, group, configs, | |
3287c240 | 367 | num_configs, type); |
e81c8f18 LD |
368 | if (ret < 0) |
369 | goto exit; | |
370 | } | |
371 | } | |
372 | ret = 0; | |
373 | ||
374 | exit: | |
375 | kfree(configs); | |
376 | return ret; | |
377 | } | |
378 | EXPORT_SYMBOL_GPL(pinconf_generic_dt_subnode_to_map); | |
379 | ||
380 | int pinconf_generic_dt_node_to_map(struct pinctrl_dev *pctldev, | |
381 | struct device_node *np_config, struct pinctrl_map **map, | |
3287c240 | 382 | unsigned *num_maps, enum pinctrl_map_type type) |
e81c8f18 LD |
383 | { |
384 | unsigned reserved_maps; | |
385 | struct device_node *np; | |
386 | int ret; | |
387 | ||
388 | reserved_maps = 0; | |
389 | *map = NULL; | |
390 | *num_maps = 0; | |
391 | ||
c7289500 BS |
392 | ret = pinconf_generic_dt_subnode_to_map(pctldev, np_config, map, |
393 | &reserved_maps, num_maps, type); | |
394 | if (ret < 0) | |
395 | goto exit; | |
396 | ||
e06c2ee5 | 397 | for_each_available_child_of_node(np_config, np) { |
e81c8f18 | 398 | ret = pinconf_generic_dt_subnode_to_map(pctldev, np, map, |
3287c240 | 399 | &reserved_maps, num_maps, type); |
5ead9328 Z |
400 | if (ret < 0) { |
401 | of_node_put(np); | |
c7289500 | 402 | goto exit; |
5ead9328 | 403 | } |
e81c8f18 LD |
404 | } |
405 | return 0; | |
c7289500 BS |
406 | |
407 | exit: | |
d32f7fd3 | 408 | pinctrl_utils_free_map(pctldev, *map, *num_maps); |
c7289500 | 409 | return ret; |
e81c8f18 LD |
410 | } |
411 | EXPORT_SYMBOL_GPL(pinconf_generic_dt_node_to_map); | |
412 | ||
8dfebf57 JH |
413 | void pinconf_generic_dt_free_map(struct pinctrl_dev *pctldev, |
414 | struct pinctrl_map *map, | |
415 | unsigned num_maps) | |
416 | { | |
417 | pinctrl_utils_free_map(pctldev, map, num_maps); | |
418 | } | |
419 | EXPORT_SYMBOL_GPL(pinconf_generic_dt_free_map); | |
420 | ||
7db9af4b | 421 | #endif |