1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Core driver for the pin muxing portions of the pin control subsystem |
4 | * |
5 | * Copyright (C) 2011-2012 ST-Ericsson SA |
6 | * Written on behalf of Linaro for ST-Ericsson |
7 | * Based on bits of regulator core, gpio core and clk core |
8 | * |
9 | * Author: Linus Walleij <linus.walleij@linaro.org> |
10 | * |
11 | * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved. |
12 | */ |
13 | #define pr_fmt(fmt) "pinmux core: " fmt |
14 | |
15 | #include <linux/array_size.h> |
16 | #include <linux/ctype.h> |
17 | #include <linux/debugfs.h> |
18 | #include <linux/device.h> |
19 | #include <linux/err.h> |
20 | #include <linux/init.h> |
21 | #include <linux/list.h> |
22 | #include <linux/module.h> |
23 | #include <linux/radix-tree.h> |
24 | #include <linux/seq_file.h> |
25 | #include <linux/slab.h> |
26 | #include <linux/string.h> |
27 | |
28 | #include <linux/pinctrl/machine.h> |
29 | #include <linux/pinctrl/pinctrl.h> |
30 | #include <linux/pinctrl/pinmux.h> |
31 | |
32 | #include "core.h" |
33 | #include "pinmux.h" |
34 | |
35 | int pinmux_check_ops(struct pinctrl_dev *pctldev) |
36 | { |
37 | const struct pinmux_ops *ops = pctldev->desc->pmxops; |
38 | unsigned nfuncs; |
39 | unsigned selector = 0; |
40 | |
41 | /* Check that we implement required operations */ |
42 | if (!ops || |
43 | !ops->get_functions_count || |
44 | !ops->get_function_name || |
45 | !ops->get_function_groups || |
46 | !ops->set_mux) { |
47 | dev_err(pctldev->dev, "pinmux ops lacks necessary functions\n" ); |
48 | return -EINVAL; |
49 | } |
50 | /* Check that all functions registered have names */ |
51 | nfuncs = ops->get_functions_count(pctldev); |
52 | while (selector < nfuncs) { |
53 | const char *fname = ops->get_function_name(pctldev, |
54 | selector); |
55 | if (!fname) { |
56 | dev_err(pctldev->dev, "pinmux ops has no name for function%u\n" , |
57 | selector); |
58 | return -EINVAL; |
59 | } |
60 | selector++; |
61 | } |
62 | |
63 | return 0; |
64 | } |
65 | |
66 | int pinmux_validate_map(const struct pinctrl_map *map, int i) |
67 | { |
68 | if (!map->data.mux.function) { |
69 | pr_err("failed to register map %s (%d): no function given\n" , |
70 | map->name, i); |
71 | return -EINVAL; |
72 | } |
73 | |
74 | return 0; |
75 | } |
76 | |
77 | /** |
78 | * pinmux_can_be_used_for_gpio() - check if a specific pin |
79 | * is either muxed to a different function or used as gpio. |
80 | * |
81 | * @pctldev: the associated pin controller device |
82 | * @pin: the pin number in the global pin space |
83 | * |
84 | * Controllers not defined as strict will always return true, |
85 | * menaning that the gpio can be used. |
86 | */ |
87 | bool pinmux_can_be_used_for_gpio(struct pinctrl_dev *pctldev, unsigned pin) |
88 | { |
89 | struct pin_desc *desc = pin_desc_get(pctldev, pin); |
90 | const struct pinmux_ops *ops = pctldev->desc->pmxops; |
91 | |
92 | /* Can't inspect pin, assume it can be used */ |
93 | if (!desc || !ops) |
94 | return true; |
95 | |
96 | if (ops->strict && desc->mux_usecount) |
97 | return false; |
98 | |
99 | return !(ops->strict && !!desc->gpio_owner); |
100 | } |
101 | |
102 | /** |
103 | * pin_request() - request a single pin to be muxed in, typically for GPIO |
104 | * @pctldev: the associated pin controller device |
105 | * @pin: the pin number in the global pin space |
106 | * @owner: a representation of the owner of this pin; typically the device |
107 | * name that controls its mux function, or the requested GPIO name |
108 | * @gpio_range: the range matching the GPIO pin if this is a request for a |
109 | * single GPIO pin |
110 | */ |
111 | static int pin_request(struct pinctrl_dev *pctldev, |
112 | int pin, const char *owner, |
113 | struct pinctrl_gpio_range *gpio_range) |
114 | { |
115 | struct pin_desc *desc; |
116 | const struct pinmux_ops *ops = pctldev->desc->pmxops; |
117 | int status = -EINVAL; |
118 | |
119 | desc = pin_desc_get(pctldev, pin); |
120 | if (desc == NULL) { |
121 | dev_err(pctldev->dev, |
122 | "pin %d is not registered so it cannot be requested\n" , |
123 | pin); |
124 | goto out; |
125 | } |
126 | |
127 | dev_dbg(pctldev->dev, "request pin %d (%s) for %s\n" , |
128 | pin, desc->name, owner); |
129 | |
130 | if ((!gpio_range || ops->strict) && |
131 | desc->mux_usecount && strcmp(desc->mux_owner, owner)) { |
132 | dev_err(pctldev->dev, |
133 | "pin %s already requested by %s; cannot claim for %s\n" , |
134 | desc->name, desc->mux_owner, owner); |
135 | goto out; |
136 | } |
137 | |
138 | if ((gpio_range || ops->strict) && desc->gpio_owner) { |
139 | dev_err(pctldev->dev, |
140 | "pin %s already requested by %s; cannot claim for %s\n" , |
141 | desc->name, desc->gpio_owner, owner); |
142 | goto out; |
143 | } |
144 | |
145 | if (gpio_range) { |
146 | desc->gpio_owner = owner; |
147 | } else { |
148 | desc->mux_usecount++; |
149 | if (desc->mux_usecount > 1) |
150 | return 0; |
151 | |
152 | desc->mux_owner = owner; |
153 | } |
154 | |
155 | /* Let each pin increase references to this module */ |
156 | if (!try_module_get(module: pctldev->owner)) { |
157 | dev_err(pctldev->dev, |
158 | "could not increase module refcount for pin %d\n" , |
159 | pin); |
160 | status = -EINVAL; |
161 | goto out_free_pin; |
162 | } |
163 | |
164 | /* |
165 | * If there is no kind of request function for the pin we just assume |
166 | * we got it by default and proceed. |
167 | */ |
168 | if (gpio_range && ops->gpio_request_enable) |
169 | /* This requests and enables a single GPIO pin */ |
170 | status = ops->gpio_request_enable(pctldev, gpio_range, pin); |
171 | else if (ops->request) |
172 | status = ops->request(pctldev, pin); |
173 | else |
174 | status = 0; |
175 | |
176 | if (status) |
177 | module_put(module: pctldev->owner); |
178 | |
179 | out_free_pin: |
180 | if (status) { |
181 | if (gpio_range) { |
182 | desc->gpio_owner = NULL; |
183 | } else { |
184 | desc->mux_usecount--; |
185 | if (!desc->mux_usecount) |
186 | desc->mux_owner = NULL; |
187 | } |
188 | } |
189 | out: |
190 | if (status) |
191 | dev_err(pctldev->dev, "pin-%d (%s) status %d\n" , |
192 | pin, owner, status); |
193 | |
194 | return status; |
195 | } |
196 | |
197 | /** |
198 | * pin_free() - release a single muxed in pin so something else can be muxed |
199 | * @pctldev: pin controller device handling this pin |
200 | * @pin: the pin to free |
201 | * @gpio_range: the range matching the GPIO pin if this is a request for a |
202 | * single GPIO pin |
203 | * |
204 | * This function returns a pointer to the previous owner. This is used |
205 | * for callers that dynamically allocate an owner name so it can be freed |
206 | * once the pin is free. This is done for GPIO request functions. |
207 | */ |
208 | static const char *pin_free(struct pinctrl_dev *pctldev, int pin, |
209 | struct pinctrl_gpio_range *gpio_range) |
210 | { |
211 | const struct pinmux_ops *ops = pctldev->desc->pmxops; |
212 | struct pin_desc *desc; |
213 | const char *owner; |
214 | |
215 | desc = pin_desc_get(pctldev, pin); |
216 | if (desc == NULL) { |
217 | dev_err(pctldev->dev, |
218 | "pin is not registered so it cannot be freed\n" ); |
219 | return NULL; |
220 | } |
221 | |
222 | if (!gpio_range) { |
223 | /* |
224 | * A pin should not be freed more times than allocated. |
225 | */ |
226 | if (WARN_ON(!desc->mux_usecount)) |
227 | return NULL; |
228 | desc->mux_usecount--; |
229 | if (desc->mux_usecount) |
230 | return NULL; |
231 | } |
232 | |
233 | /* |
234 | * If there is no kind of request function for the pin we just assume |
235 | * we got it by default and proceed. |
236 | */ |
237 | if (gpio_range && ops->gpio_disable_free) |
238 | ops->gpio_disable_free(pctldev, gpio_range, pin); |
239 | else if (ops->free) |
240 | ops->free(pctldev, pin); |
241 | |
242 | if (gpio_range) { |
243 | owner = desc->gpio_owner; |
244 | desc->gpio_owner = NULL; |
245 | } else { |
246 | owner = desc->mux_owner; |
247 | desc->mux_owner = NULL; |
248 | desc->mux_setting = NULL; |
249 | } |
250 | |
251 | module_put(module: pctldev->owner); |
252 | |
253 | return owner; |
254 | } |
255 | |
256 | /** |
257 | * pinmux_request_gpio() - request pinmuxing for a GPIO pin |
258 | * @pctldev: pin controller device affected |
259 | * @pin: the pin to mux in for GPIO |
260 | * @range: the applicable GPIO range |
261 | * @gpio: number of requested GPIO |
262 | */ |
263 | int pinmux_request_gpio(struct pinctrl_dev *pctldev, |
264 | struct pinctrl_gpio_range *range, |
265 | unsigned pin, unsigned gpio) |
266 | { |
267 | const char *owner; |
268 | int ret; |
269 | |
270 | /* Conjure some name stating what chip and pin this is taken by */ |
271 | owner = kasprintf(GFP_KERNEL, fmt: "%s:%d" , range->name, gpio); |
272 | if (!owner) |
273 | return -ENOMEM; |
274 | |
275 | ret = pin_request(pctldev, pin, owner, gpio_range: range); |
276 | if (ret < 0) |
277 | kfree(objp: owner); |
278 | |
279 | return ret; |
280 | } |
281 | |
282 | /** |
283 | * pinmux_free_gpio() - release a pin from GPIO muxing |
284 | * @pctldev: the pin controller device for the pin |
285 | * @pin: the affected currently GPIO-muxed in pin |
286 | * @range: applicable GPIO range |
287 | */ |
288 | void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin, |
289 | struct pinctrl_gpio_range *range) |
290 | { |
291 | const char *owner; |
292 | |
293 | owner = pin_free(pctldev, pin, gpio_range: range); |
294 | kfree(objp: owner); |
295 | } |
296 | |
297 | /** |
298 | * pinmux_gpio_direction() - set the direction of a single muxed-in GPIO pin |
299 | * @pctldev: the pin controller handling this pin |
300 | * @range: applicable GPIO range |
301 | * @pin: the affected GPIO pin in this controller |
302 | * @input: true if we set the pin as input, false for output |
303 | */ |
304 | int pinmux_gpio_direction(struct pinctrl_dev *pctldev, |
305 | struct pinctrl_gpio_range *range, |
306 | unsigned pin, bool input) |
307 | { |
308 | const struct pinmux_ops *ops; |
309 | int ret; |
310 | |
311 | ops = pctldev->desc->pmxops; |
312 | |
313 | if (ops->gpio_set_direction) |
314 | ret = ops->gpio_set_direction(pctldev, range, pin, input); |
315 | else |
316 | ret = 0; |
317 | |
318 | return ret; |
319 | } |
320 | |
321 | static int pinmux_func_name_to_selector(struct pinctrl_dev *pctldev, |
322 | const char *function) |
323 | { |
324 | const struct pinmux_ops *ops = pctldev->desc->pmxops; |
325 | unsigned nfuncs = ops->get_functions_count(pctldev); |
326 | unsigned selector = 0; |
327 | |
328 | /* See if this pctldev has this function */ |
329 | while (selector < nfuncs) { |
330 | const char *fname = ops->get_function_name(pctldev, selector); |
331 | |
332 | if (!strcmp(function, fname)) |
333 | return selector; |
334 | |
335 | selector++; |
336 | } |
337 | |
338 | return -EINVAL; |
339 | } |
340 | |
341 | int pinmux_map_to_setting(const struct pinctrl_map *map, |
342 | struct pinctrl_setting *setting) |
343 | { |
344 | struct pinctrl_dev *pctldev = setting->pctldev; |
345 | const struct pinmux_ops *pmxops = pctldev->desc->pmxops; |
346 | char const * const *groups; |
347 | unsigned num_groups; |
348 | int ret; |
349 | const char *group; |
350 | |
351 | if (!pmxops) { |
352 | dev_err(pctldev->dev, "does not support mux function\n" ); |
353 | return -EINVAL; |
354 | } |
355 | |
356 | ret = pinmux_func_name_to_selector(pctldev, function: map->data.mux.function); |
357 | if (ret < 0) { |
358 | dev_err(pctldev->dev, "invalid function %s in map table\n" , |
359 | map->data.mux.function); |
360 | return ret; |
361 | } |
362 | setting->data.mux.func = ret; |
363 | |
364 | ret = pmxops->get_function_groups(pctldev, setting->data.mux.func, |
365 | &groups, &num_groups); |
366 | if (ret < 0) { |
367 | dev_err(pctldev->dev, "can't query groups for function %s\n" , |
368 | map->data.mux.function); |
369 | return ret; |
370 | } |
371 | if (!num_groups) { |
372 | dev_err(pctldev->dev, |
373 | "function %s can't be selected on any group\n" , |
374 | map->data.mux.function); |
375 | return -EINVAL; |
376 | } |
377 | if (map->data.mux.group) { |
378 | group = map->data.mux.group; |
379 | ret = match_string(array: groups, n: num_groups, string: group); |
380 | if (ret < 0) { |
381 | dev_err(pctldev->dev, |
382 | "invalid group \"%s\" for function \"%s\"\n" , |
383 | group, map->data.mux.function); |
384 | return ret; |
385 | } |
386 | } else { |
387 | group = groups[0]; |
388 | } |
389 | |
390 | ret = pinctrl_get_group_selector(pctldev, pin_group: group); |
391 | if (ret < 0) { |
392 | dev_err(pctldev->dev, "invalid group %s in map table\n" , |
393 | map->data.mux.group); |
394 | return ret; |
395 | } |
396 | setting->data.mux.group = ret; |
397 | |
398 | return 0; |
399 | } |
400 | |
401 | void pinmux_free_setting(const struct pinctrl_setting *setting) |
402 | { |
403 | /* This function is currently unused */ |
404 | } |
405 | |
406 | int pinmux_enable_setting(const struct pinctrl_setting *setting) |
407 | { |
408 | struct pinctrl_dev *pctldev = setting->pctldev; |
409 | const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; |
410 | const struct pinmux_ops *ops = pctldev->desc->pmxops; |
411 | int ret = 0; |
412 | const unsigned *pins = NULL; |
413 | unsigned num_pins = 0; |
414 | int i; |
415 | struct pin_desc *desc; |
416 | |
417 | if (pctlops->get_group_pins) |
418 | ret = pctlops->get_group_pins(pctldev, setting->data.mux.group, |
419 | &pins, &num_pins); |
420 | |
421 | if (ret) { |
422 | const char *gname; |
423 | |
424 | /* errors only affect debug data, so just warn */ |
425 | gname = pctlops->get_group_name(pctldev, |
426 | setting->data.mux.group); |
427 | dev_warn(pctldev->dev, |
428 | "could not get pins for group %s\n" , |
429 | gname); |
430 | num_pins = 0; |
431 | } |
432 | |
433 | /* Try to allocate all pins in this group, one by one */ |
434 | for (i = 0; i < num_pins; i++) { |
435 | ret = pin_request(pctldev, pin: pins[i], owner: setting->dev_name, NULL); |
436 | if (ret) { |
437 | const char *gname; |
438 | const char *pname; |
439 | |
440 | desc = pin_desc_get(pctldev, pin: pins[i]); |
441 | pname = desc ? desc->name : "non-existing" ; |
442 | gname = pctlops->get_group_name(pctldev, |
443 | setting->data.mux.group); |
444 | dev_err(pctldev->dev, |
445 | "could not request pin %d (%s) from group %s " |
446 | " on device %s\n" , |
447 | pins[i], pname, gname, |
448 | pinctrl_dev_get_name(pctldev)); |
449 | goto err_pin_request; |
450 | } |
451 | } |
452 | |
453 | /* Now that we have acquired the pins, encode the mux setting */ |
454 | for (i = 0; i < num_pins; i++) { |
455 | desc = pin_desc_get(pctldev, pin: pins[i]); |
456 | if (desc == NULL) { |
457 | dev_warn(pctldev->dev, |
458 | "could not get pin desc for pin %d\n" , |
459 | pins[i]); |
460 | continue; |
461 | } |
462 | desc->mux_setting = &(setting->data.mux); |
463 | } |
464 | |
465 | ret = ops->set_mux(pctldev, setting->data.mux.func, |
466 | setting->data.mux.group); |
467 | |
468 | if (ret) |
469 | goto err_set_mux; |
470 | |
471 | return 0; |
472 | |
473 | err_set_mux: |
474 | for (i = 0; i < num_pins; i++) { |
475 | desc = pin_desc_get(pctldev, pin: pins[i]); |
476 | if (desc) |
477 | desc->mux_setting = NULL; |
478 | } |
479 | err_pin_request: |
480 | /* On error release all taken pins */ |
481 | while (--i >= 0) |
482 | pin_free(pctldev, pin: pins[i], NULL); |
483 | |
484 | return ret; |
485 | } |
486 | |
487 | void pinmux_disable_setting(const struct pinctrl_setting *setting) |
488 | { |
489 | struct pinctrl_dev *pctldev = setting->pctldev; |
490 | const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; |
491 | int ret = 0; |
492 | const unsigned *pins = NULL; |
493 | unsigned num_pins = 0; |
494 | int i; |
495 | struct pin_desc *desc; |
496 | |
497 | if (pctlops->get_group_pins) |
498 | ret = pctlops->get_group_pins(pctldev, setting->data.mux.group, |
499 | &pins, &num_pins); |
500 | if (ret) { |
501 | const char *gname; |
502 | |
503 | /* errors only affect debug data, so just warn */ |
504 | gname = pctlops->get_group_name(pctldev, |
505 | setting->data.mux.group); |
506 | dev_warn(pctldev->dev, |
507 | "could not get pins for group %s\n" , |
508 | gname); |
509 | num_pins = 0; |
510 | } |
511 | |
512 | /* Flag the descs that no setting is active */ |
513 | for (i = 0; i < num_pins; i++) { |
514 | desc = pin_desc_get(pctldev, pin: pins[i]); |
515 | if (desc == NULL) { |
516 | dev_warn(pctldev->dev, |
517 | "could not get pin desc for pin %d\n" , |
518 | pins[i]); |
519 | continue; |
520 | } |
521 | if (desc->mux_setting == &(setting->data.mux)) { |
522 | pin_free(pctldev, pin: pins[i], NULL); |
523 | } else { |
524 | const char *gname; |
525 | |
526 | gname = pctlops->get_group_name(pctldev, |
527 | setting->data.mux.group); |
528 | dev_warn(pctldev->dev, |
529 | "not freeing pin %d (%s) as part of " |
530 | "deactivating group %s - it is already " |
531 | "used for some other setting" , |
532 | pins[i], desc->name, gname); |
533 | } |
534 | } |
535 | } |
536 | |
537 | #ifdef CONFIG_DEBUG_FS |
538 | |
539 | /* Called from pincontrol core */ |
540 | static int pinmux_functions_show(struct seq_file *s, void *what) |
541 | { |
542 | struct pinctrl_dev *pctldev = s->private; |
543 | const struct pinmux_ops *pmxops = pctldev->desc->pmxops; |
544 | unsigned nfuncs; |
545 | unsigned func_selector = 0; |
546 | |
547 | if (!pmxops) |
548 | return 0; |
549 | |
550 | mutex_lock(&pctldev->mutex); |
551 | nfuncs = pmxops->get_functions_count(pctldev); |
552 | while (func_selector < nfuncs) { |
553 | const char *func = pmxops->get_function_name(pctldev, |
554 | func_selector); |
555 | const char * const *groups; |
556 | unsigned num_groups; |
557 | int ret; |
558 | int i; |
559 | |
560 | ret = pmxops->get_function_groups(pctldev, func_selector, |
561 | &groups, &num_groups); |
562 | if (ret) { |
563 | seq_printf(m: s, fmt: "function %s: COULD NOT GET GROUPS\n" , |
564 | func); |
565 | func_selector++; |
566 | continue; |
567 | } |
568 | |
569 | seq_printf(m: s, fmt: "function %d: %s, groups = [ " , func_selector, func); |
570 | for (i = 0; i < num_groups; i++) |
571 | seq_printf(m: s, fmt: "%s " , groups[i]); |
572 | seq_puts(m: s, s: "]\n" ); |
573 | |
574 | func_selector++; |
575 | } |
576 | |
577 | mutex_unlock(lock: &pctldev->mutex); |
578 | |
579 | return 0; |
580 | } |
581 | |
582 | static int pinmux_pins_show(struct seq_file *s, void *what) |
583 | { |
584 | struct pinctrl_dev *pctldev = s->private; |
585 | const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; |
586 | const struct pinmux_ops *pmxops = pctldev->desc->pmxops; |
587 | unsigned i, pin; |
588 | |
589 | if (!pmxops) |
590 | return 0; |
591 | |
592 | seq_puts(m: s, s: "Pinmux settings per pin\n" ); |
593 | if (pmxops->strict) |
594 | seq_puts(m: s, |
595 | s: "Format: pin (name): mux_owner|gpio_owner (strict) hog?\n" ); |
596 | else |
597 | seq_puts(m: s, |
598 | s: "Format: pin (name): mux_owner gpio_owner hog?\n" ); |
599 | |
600 | mutex_lock(&pctldev->mutex); |
601 | |
602 | /* The pin number can be retrived from the pin controller descriptor */ |
603 | for (i = 0; i < pctldev->desc->npins; i++) { |
604 | struct pin_desc *desc; |
605 | bool is_hog = false; |
606 | |
607 | pin = pctldev->desc->pins[i].number; |
608 | desc = pin_desc_get(pctldev, pin); |
609 | /* Skip if we cannot search the pin */ |
610 | if (desc == NULL) |
611 | continue; |
612 | |
613 | if (desc->mux_owner && |
614 | !strcmp(desc->mux_owner, pinctrl_dev_get_name(pctldev))) |
615 | is_hog = true; |
616 | |
617 | if (pmxops->strict) { |
618 | if (desc->mux_owner) |
619 | seq_printf(m: s, fmt: "pin %d (%s): device %s%s" , |
620 | pin, desc->name, desc->mux_owner, |
621 | is_hog ? " (HOG)" : "" ); |
622 | else if (desc->gpio_owner) |
623 | seq_printf(m: s, fmt: "pin %d (%s): GPIO %s" , |
624 | pin, desc->name, desc->gpio_owner); |
625 | else |
626 | seq_printf(m: s, fmt: "pin %d (%s): UNCLAIMED" , |
627 | pin, desc->name); |
628 | } else { |
629 | /* For non-strict controllers */ |
630 | seq_printf(m: s, fmt: "pin %d (%s): %s %s%s" , pin, desc->name, |
631 | desc->mux_owner ? desc->mux_owner |
632 | : "(MUX UNCLAIMED)" , |
633 | desc->gpio_owner ? desc->gpio_owner |
634 | : "(GPIO UNCLAIMED)" , |
635 | is_hog ? " (HOG)" : "" ); |
636 | } |
637 | |
638 | /* If mux: print function+group claiming the pin */ |
639 | if (desc->mux_setting) |
640 | seq_printf(m: s, fmt: " function %s group %s\n" , |
641 | pmxops->get_function_name(pctldev, |
642 | desc->mux_setting->func), |
643 | pctlops->get_group_name(pctldev, |
644 | desc->mux_setting->group)); |
645 | else |
646 | seq_putc(m: s, c: '\n'); |
647 | } |
648 | |
649 | mutex_unlock(lock: &pctldev->mutex); |
650 | |
651 | return 0; |
652 | } |
653 | |
654 | void pinmux_show_map(struct seq_file *s, const struct pinctrl_map *map) |
655 | { |
656 | seq_printf(m: s, fmt: "group %s\nfunction %s\n" , |
657 | map->data.mux.group ? map->data.mux.group : "(default)" , |
658 | map->data.mux.function); |
659 | } |
660 | |
661 | void pinmux_show_setting(struct seq_file *s, |
662 | const struct pinctrl_setting *setting) |
663 | { |
664 | struct pinctrl_dev *pctldev = setting->pctldev; |
665 | const struct pinmux_ops *pmxops = pctldev->desc->pmxops; |
666 | const struct pinctrl_ops *pctlops = pctldev->desc->pctlops; |
667 | |
668 | seq_printf(m: s, fmt: "group: %s (%u) function: %s (%u)\n" , |
669 | pctlops->get_group_name(pctldev, setting->data.mux.group), |
670 | setting->data.mux.group, |
671 | pmxops->get_function_name(pctldev, setting->data.mux.func), |
672 | setting->data.mux.func); |
673 | } |
674 | |
675 | DEFINE_SHOW_ATTRIBUTE(pinmux_functions); |
676 | DEFINE_SHOW_ATTRIBUTE(pinmux_pins); |
677 | |
678 | static ssize_t pinmux_select(struct file *file, const char __user *user_buf, |
679 | size_t len, loff_t *ppos) |
680 | { |
681 | struct seq_file *sfile = file->private_data; |
682 | struct pinctrl_dev *pctldev = sfile->private; |
683 | const struct pinmux_ops *pmxops = pctldev->desc->pmxops; |
684 | const char *const *groups; |
685 | char *buf, *gname, *fname; |
686 | unsigned int num_groups; |
687 | int fsel, gsel, ret; |
688 | |
689 | buf = memdup_user_nul(user_buf, len); |
690 | if (IS_ERR(ptr: buf)) |
691 | return PTR_ERR(ptr: buf); |
692 | |
693 | /* remove leading and trailing spaces of input buffer */ |
694 | gname = strstrip(str: buf); |
695 | if (*gname == '\0') { |
696 | ret = -EINVAL; |
697 | goto exit_free_buf; |
698 | } |
699 | |
700 | /* find a separator which is a spacelike character */ |
701 | for (fname = gname; !isspace(*fname); fname++) { |
702 | if (*fname == '\0') { |
703 | ret = -EINVAL; |
704 | goto exit_free_buf; |
705 | } |
706 | } |
707 | *fname = '\0'; |
708 | |
709 | /* drop extra spaces between function and group names */ |
710 | fname = skip_spaces(fname + 1); |
711 | if (*fname == '\0') { |
712 | ret = -EINVAL; |
713 | goto exit_free_buf; |
714 | } |
715 | |
716 | ret = pinmux_func_name_to_selector(pctldev, function: fname); |
717 | if (ret < 0) { |
718 | dev_err(pctldev->dev, "invalid function %s in map table\n" , fname); |
719 | goto exit_free_buf; |
720 | } |
721 | fsel = ret; |
722 | |
723 | ret = pmxops->get_function_groups(pctldev, fsel, &groups, &num_groups); |
724 | if (ret) { |
725 | dev_err(pctldev->dev, "no groups for function %d (%s)" , fsel, fname); |
726 | goto exit_free_buf; |
727 | } |
728 | |
729 | ret = match_string(array: groups, n: num_groups, string: gname); |
730 | if (ret < 0) { |
731 | dev_err(pctldev->dev, "invalid group %s" , gname); |
732 | goto exit_free_buf; |
733 | } |
734 | |
735 | ret = pinctrl_get_group_selector(pctldev, pin_group: gname); |
736 | if (ret < 0) |
737 | goto exit_free_buf; |
738 | gsel = ret; |
739 | |
740 | ret = pmxops->set_mux(pctldev, fsel, gsel); |
741 | if (ret) { |
742 | dev_err(pctldev->dev, "set_mux() failed: %d" , ret); |
743 | goto exit_free_buf; |
744 | } |
745 | ret = len; |
746 | |
747 | exit_free_buf: |
748 | kfree(objp: buf); |
749 | |
750 | return ret; |
751 | } |
752 | |
753 | static int pinmux_select_open(struct inode *inode, struct file *file) |
754 | { |
755 | return single_open(file, NULL, inode->i_private); |
756 | } |
757 | |
758 | static const struct file_operations pinmux_select_ops = { |
759 | .owner = THIS_MODULE, |
760 | .open = pinmux_select_open, |
761 | .write = pinmux_select, |
762 | .llseek = no_llseek, |
763 | .release = single_release, |
764 | }; |
765 | |
766 | void pinmux_init_device_debugfs(struct dentry *devroot, |
767 | struct pinctrl_dev *pctldev) |
768 | { |
769 | debugfs_create_file(name: "pinmux-functions" , mode: 0444, |
770 | parent: devroot, data: pctldev, fops: &pinmux_functions_fops); |
771 | debugfs_create_file(name: "pinmux-pins" , mode: 0444, |
772 | parent: devroot, data: pctldev, fops: &pinmux_pins_fops); |
773 | debugfs_create_file(name: "pinmux-select" , mode: 0200, |
774 | parent: devroot, data: pctldev, fops: &pinmux_select_ops); |
775 | } |
776 | |
777 | #endif /* CONFIG_DEBUG_FS */ |
778 | |
779 | #ifdef CONFIG_GENERIC_PINMUX_FUNCTIONS |
780 | |
781 | /** |
782 | * pinmux_generic_get_function_count() - returns number of functions |
783 | * @pctldev: pin controller device |
784 | */ |
785 | int pinmux_generic_get_function_count(struct pinctrl_dev *pctldev) |
786 | { |
787 | return pctldev->num_functions; |
788 | } |
789 | EXPORT_SYMBOL_GPL(pinmux_generic_get_function_count); |
790 | |
791 | /** |
792 | * pinmux_generic_get_function_name() - returns the function name |
793 | * @pctldev: pin controller device |
794 | * @selector: function number |
795 | */ |
796 | const char * |
797 | pinmux_generic_get_function_name(struct pinctrl_dev *pctldev, |
798 | unsigned int selector) |
799 | { |
800 | struct function_desc *function; |
801 | |
802 | function = radix_tree_lookup(&pctldev->pin_function_tree, |
803 | selector); |
804 | if (!function) |
805 | return NULL; |
806 | |
807 | return function->name; |
808 | } |
809 | EXPORT_SYMBOL_GPL(pinmux_generic_get_function_name); |
810 | |
811 | /** |
812 | * pinmux_generic_get_function_groups() - gets the function groups |
813 | * @pctldev: pin controller device |
814 | * @selector: function number |
815 | * @groups: array of pin groups |
816 | * @num_groups: number of pin groups |
817 | */ |
818 | int pinmux_generic_get_function_groups(struct pinctrl_dev *pctldev, |
819 | unsigned int selector, |
820 | const char * const **groups, |
821 | unsigned * const num_groups) |
822 | { |
823 | struct function_desc *function; |
824 | |
825 | function = radix_tree_lookup(&pctldev->pin_function_tree, |
826 | selector); |
827 | if (!function) { |
828 | dev_err(pctldev->dev, "%s could not find function%i\n" , |
829 | __func__, selector); |
830 | return -EINVAL; |
831 | } |
832 | *groups = function->group_names; |
833 | *num_groups = function->num_group_names; |
834 | |
835 | return 0; |
836 | } |
837 | EXPORT_SYMBOL_GPL(pinmux_generic_get_function_groups); |
838 | |
839 | /** |
840 | * pinmux_generic_get_function() - returns a function based on the number |
841 | * @pctldev: pin controller device |
842 | * @selector: function number |
843 | */ |
844 | struct function_desc *pinmux_generic_get_function(struct pinctrl_dev *pctldev, |
845 | unsigned int selector) |
846 | { |
847 | struct function_desc *function; |
848 | |
849 | function = radix_tree_lookup(&pctldev->pin_function_tree, |
850 | selector); |
851 | if (!function) |
852 | return NULL; |
853 | |
854 | return function; |
855 | } |
856 | EXPORT_SYMBOL_GPL(pinmux_generic_get_function); |
857 | |
858 | /** |
859 | * pinmux_generic_add_function() - adds a function group |
860 | * @pctldev: pin controller device |
861 | * @name: name of the function |
862 | * @groups: array of pin groups |
863 | * @num_groups: number of pin groups |
864 | * @data: pin controller driver specific data |
865 | */ |
866 | int pinmux_generic_add_function(struct pinctrl_dev *pctldev, |
867 | const char *name, |
868 | const char * const *groups, |
869 | const unsigned int num_groups, |
870 | void *data) |
871 | { |
872 | struct function_desc *function; |
873 | int selector, error; |
874 | |
875 | if (!name) |
876 | return -EINVAL; |
877 | |
878 | selector = pinmux_func_name_to_selector(pctldev, function: name); |
879 | if (selector >= 0) |
880 | return selector; |
881 | |
882 | selector = pctldev->num_functions; |
883 | |
884 | function = devm_kzalloc(dev: pctldev->dev, size: sizeof(*function), GFP_KERNEL); |
885 | if (!function) |
886 | return -ENOMEM; |
887 | |
888 | function->name = name; |
889 | function->group_names = groups; |
890 | function->num_group_names = num_groups; |
891 | function->data = data; |
892 | |
893 | error = radix_tree_insert(&pctldev->pin_function_tree, index: selector, function); |
894 | if (error) |
895 | return error; |
896 | |
897 | pctldev->num_functions++; |
898 | |
899 | return selector; |
900 | } |
901 | EXPORT_SYMBOL_GPL(pinmux_generic_add_function); |
902 | |
903 | /** |
904 | * pinmux_generic_remove_function() - removes a numbered function |
905 | * @pctldev: pin controller device |
906 | * @selector: function number |
907 | * |
908 | * Note that the caller must take care of locking. |
909 | */ |
910 | int pinmux_generic_remove_function(struct pinctrl_dev *pctldev, |
911 | unsigned int selector) |
912 | { |
913 | struct function_desc *function; |
914 | |
915 | function = radix_tree_lookup(&pctldev->pin_function_tree, |
916 | selector); |
917 | if (!function) |
918 | return -ENOENT; |
919 | |
920 | radix_tree_delete(&pctldev->pin_function_tree, selector); |
921 | devm_kfree(dev: pctldev->dev, p: function); |
922 | |
923 | pctldev->num_functions--; |
924 | |
925 | return 0; |
926 | } |
927 | EXPORT_SYMBOL_GPL(pinmux_generic_remove_function); |
928 | |
929 | /** |
930 | * pinmux_generic_free_functions() - removes all functions |
931 | * @pctldev: pin controller device |
932 | * |
933 | * Note that the caller must take care of locking. The pinctrl |
934 | * functions are allocated with devm_kzalloc() so no need to free |
935 | * them here. |
936 | */ |
937 | void pinmux_generic_free_functions(struct pinctrl_dev *pctldev) |
938 | { |
939 | struct radix_tree_iter iter; |
940 | void __rcu **slot; |
941 | |
942 | radix_tree_for_each_slot(slot, &pctldev->pin_function_tree, &iter, 0) |
943 | radix_tree_delete(&pctldev->pin_function_tree, iter.index); |
944 | |
945 | pctldev->num_functions = 0; |
946 | } |
947 | |
948 | #endif /* CONFIG_GENERIC_PINMUX_FUNCTIONS */ |
949 | |