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