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