blob: f3e4f031fe1ceae29eed55a1aa89b9d9e2fdf6a2 [file] [log] [blame]
Linus Walleij2744e8a2011-05-02 20:50:54 +02001/*
2 * Core driver for the pin muxing portions of the pin control subsystem
3 *
4 * Copyright (C) 2011 ST-Ericsson SA
5 * Written on behalf of Linaro for ST-Ericsson
6 * Based on bits of regulator core, gpio core and clk core
7 *
8 * Author: Linus Walleij <linus.walleij@linaro.org>
9 *
10 * License terms: GNU General Public License (GPL) version 2
11 */
12#define pr_fmt(fmt) "pinmux core: " fmt
13
14#include <linux/kernel.h>
15#include <linux/module.h>
16#include <linux/init.h>
17#include <linux/device.h>
18#include <linux/slab.h>
19#include <linux/radix-tree.h>
20#include <linux/err.h>
21#include <linux/list.h>
22#include <linux/mutex.h>
23#include <linux/spinlock.h>
24#include <linux/sysfs.h>
25#include <linux/debugfs.h>
26#include <linux/seq_file.h>
27#include <linux/pinctrl/machine.h>
28#include <linux/pinctrl/pinmux.h>
29#include "core.h"
30
31/* List of pinmuxes */
32static DEFINE_MUTEX(pinmux_list_mutex);
33static LIST_HEAD(pinmux_list);
34
Linus Walleij2744e8a2011-05-02 20:50:54 +020035/* Global pinmux maps, we allow one set only */
36static struct pinmux_map const *pinmux_maps;
37static unsigned pinmux_maps_num;
38
39/**
40 * struct pinmux_group - group list item for pinmux groups
41 * @node: pinmux group list node
42 * @group_selector: the group selector for this group
43 */
44struct pinmux_group {
45 struct list_head node;
46 unsigned group_selector;
47};
48
49/**
50 * struct pinmux - per-device pinmux state holder
51 * @node: global list node
52 * @dev: the device using this pinmux
53 * @usecount: the number of active users of this mux setting, used to keep
54 * track of nested use cases
55 * @pins: an array of discrete physical pins used in this mapping, taken
56 * from the global pin enumeration space (copied from pinmux map)
57 * @num_pins: the number of pins in this mapping array, i.e. the number of
58 * elements in .pins so we can iterate over that array (copied from
59 * pinmux map)
60 * @pctldev: pin control device handling this pinmux
61 * @func_selector: the function selector for the pinmux device handling
62 * this pinmux
63 * @groups: the group selectors for the pinmux device and
64 * selector combination handling this pinmux, this is a list that
65 * will be traversed on all pinmux operations such as
66 * get/put/enable/disable
67 * @mutex: a lock for the pinmux state holder
68 */
69struct pinmux {
70 struct list_head node;
71 struct device *dev;
72 unsigned usecount;
73 struct pinctrl_dev *pctldev;
74 unsigned func_selector;
75 struct list_head groups;
76 struct mutex mutex;
77};
78
79/**
80 * struct pinmux_hog - a list item to stash mux hogs
81 * @node: pinmux hog list node
82 * @map: map entry responsible for this hogging
83 * @pmx: the pinmux hogged by this item
84 */
85struct pinmux_hog {
86 struct list_head node;
87 struct pinmux_map const *map;
88 struct pinmux *pmx;
89};
90
91/**
92 * pin_request() - request a single pin to be muxed in, typically for GPIO
93 * @pin: the pin number in the global pin space
94 * @function: a functional name to give to this pin, passed to the driver
95 * so it knows what function to mux in, e.g. the string "gpioNN"
96 * means that you want to mux in the pin for use as GPIO number NN
Linus Walleij2744e8a2011-05-02 20:50:54 +020097 * @gpio_range: the range matching the GPIO pin if this is a request for a
98 * single GPIO pin
99 */
100static int pin_request(struct pinctrl_dev *pctldev,
Stephen Warren3712a3c2011-10-21 12:25:53 -0600101 int pin, const char *function,
Linus Walleij2744e8a2011-05-02 20:50:54 +0200102 struct pinctrl_gpio_range *gpio_range)
103{
104 struct pin_desc *desc;
105 const struct pinmux_ops *ops = pctldev->desc->pmxops;
106 int status = -EINVAL;
107
108 dev_dbg(&pctldev->dev, "request pin %d for %s\n", pin, function);
109
Linus Walleij2744e8a2011-05-02 20:50:54 +0200110 desc = pin_desc_get(pctldev, pin);
111 if (desc == NULL) {
112 dev_err(&pctldev->dev,
113 "pin is not registered so it cannot be requested\n");
114 goto out;
115 }
116
Marek Beliskod2f6a1c2011-10-26 22:57:20 +0200117 if (!function) {
118 dev_err(&pctldev->dev, "no function name given\n");
119 return -EINVAL;
120 }
121
Linus Walleij2744e8a2011-05-02 20:50:54 +0200122 spin_lock(&desc->lock);
Stephen Warren5d2eaf82011-10-19 16:19:28 -0600123 if (desc->mux_function) {
Linus Walleij2744e8a2011-05-02 20:50:54 +0200124 spin_unlock(&desc->lock);
125 dev_err(&pctldev->dev,
126 "pin already requested\n");
127 goto out;
128 }
Stephen Warren5d2eaf82011-10-19 16:19:28 -0600129 desc->mux_function = function;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200130 spin_unlock(&desc->lock);
131
132 /* Let each pin increase references to this module */
133 if (!try_module_get(pctldev->owner)) {
134 dev_err(&pctldev->dev,
135 "could not increase module refcount for pin %d\n",
136 pin);
137 status = -EINVAL;
138 goto out_free_pin;
139 }
140
141 /*
142 * If there is no kind of request function for the pin we just assume
143 * we got it by default and proceed.
144 */
Stephen Warren3712a3c2011-10-21 12:25:53 -0600145 if (gpio_range && ops->gpio_request_enable)
Linus Walleij2744e8a2011-05-02 20:50:54 +0200146 /* This requests and enables a single GPIO pin */
147 status = ops->gpio_request_enable(pctldev, gpio_range, pin);
148 else if (ops->request)
149 status = ops->request(pctldev, pin);
150 else
151 status = 0;
152
153 if (status)
154 dev_err(&pctldev->dev, "->request on device %s failed "
155 "for pin %d\n",
156 pctldev->desc->name, pin);
157out_free_pin:
158 if (status) {
159 spin_lock(&desc->lock);
Stephen Warren5d2eaf82011-10-19 16:19:28 -0600160 desc->mux_function = NULL;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200161 spin_unlock(&desc->lock);
162 }
163out:
164 if (status)
165 dev_err(&pctldev->dev, "pin-%d (%s) status %d\n",
166 pin, function ? : "?", status);
167
168 return status;
169}
170
171/**
172 * pin_free() - release a single muxed in pin so something else can be muxed
173 * @pctldev: pin controller device handling this pin
174 * @pin: the pin to free
Stephen Warren3712a3c2011-10-21 12:25:53 -0600175 * @gpio_range: the range matching the GPIO pin if this is a request for a
176 * single GPIO pin
Linus Walleij336cdba02011-11-10 09:27:41 +0100177 *
178 * This function returns a pointer to the function name in use. This is used
179 * for callers that dynamically allocate a function name so it can be freed
180 * once the pin is free. This is done for GPIO request functions.
Linus Walleij2744e8a2011-05-02 20:50:54 +0200181 */
Stephen Warren3712a3c2011-10-21 12:25:53 -0600182static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
183 struct pinctrl_gpio_range *gpio_range)
Linus Walleij2744e8a2011-05-02 20:50:54 +0200184{
185 const struct pinmux_ops *ops = pctldev->desc->pmxops;
186 struct pin_desc *desc;
Stephen Warren3712a3c2011-10-21 12:25:53 -0600187 const char *func;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200188
189 desc = pin_desc_get(pctldev, pin);
190 if (desc == NULL) {
191 dev_err(&pctldev->dev,
192 "pin is not registered so it cannot be freed\n");
Stephen Warren3712a3c2011-10-21 12:25:53 -0600193 return NULL;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200194 }
195
Stephen Warren3712a3c2011-10-21 12:25:53 -0600196 /*
197 * If there is no kind of request function for the pin we just assume
198 * we got it by default and proceed.
199 */
200 if (gpio_range && ops->gpio_disable_free)
201 ops->gpio_disable_free(pctldev, gpio_range, pin);
202 else if (ops->free)
Linus Walleij2744e8a2011-05-02 20:50:54 +0200203 ops->free(pctldev, pin);
204
205 spin_lock(&desc->lock);
Stephen Warren3712a3c2011-10-21 12:25:53 -0600206 func = desc->mux_function;
Stephen Warren5d2eaf82011-10-19 16:19:28 -0600207 desc->mux_function = NULL;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200208 spin_unlock(&desc->lock);
209 module_put(pctldev->owner);
Stephen Warren3712a3c2011-10-21 12:25:53 -0600210
211 return func;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200212}
213
214/**
215 * pinmux_request_gpio() - request a single pin to be muxed in as GPIO
216 * @gpio: the GPIO pin number from the GPIO subsystem number space
Linus Walleij542e7042011-11-14 10:06:22 +0100217 *
218 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
219 * as part of their gpio_request() semantics, platforms and individual drivers
220 * shall *NOT* request GPIO pins to be muxed in.
Linus Walleij2744e8a2011-05-02 20:50:54 +0200221 */
222int pinmux_request_gpio(unsigned gpio)
223{
224 char gpiostr[16];
Stephen Warren5d2eaf82011-10-19 16:19:28 -0600225 const char *function;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200226 struct pinctrl_dev *pctldev;
227 struct pinctrl_gpio_range *range;
228 int ret;
229 int pin;
230
231 ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
232 if (ret)
233 return -EINVAL;
234
235 /* Convert to the pin controllers number space */
Chanho Park3c739ad2011-11-11 18:47:58 +0900236 pin = gpio - range->base + range->pin_base;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200237
238 /* Conjure some name stating what chip and pin this is taken by */
239 snprintf(gpiostr, 15, "%s:%d", range->name, gpio);
240
Stephen Warren5d2eaf82011-10-19 16:19:28 -0600241 function = kstrdup(gpiostr, GFP_KERNEL);
242 if (!function)
243 return -EINVAL;
244
Stephen Warren3712a3c2011-10-21 12:25:53 -0600245 ret = pin_request(pctldev, pin, function, range);
Stephen Warren5d2eaf82011-10-19 16:19:28 -0600246 if (ret < 0)
247 kfree(function);
248
249 return ret;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200250}
251EXPORT_SYMBOL_GPL(pinmux_request_gpio);
252
253/**
254 * pinmux_free_gpio() - free a single pin, currently used as GPIO
255 * @gpio: the GPIO pin number from the GPIO subsystem number space
Linus Walleij542e7042011-11-14 10:06:22 +0100256 *
257 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
258 * as part of their gpio_free() semantics, platforms and individual drivers
259 * shall *NOT* request GPIO pins to be muxed out.
Linus Walleij2744e8a2011-05-02 20:50:54 +0200260 */
261void pinmux_free_gpio(unsigned gpio)
262{
263 struct pinctrl_dev *pctldev;
264 struct pinctrl_gpio_range *range;
265 int ret;
266 int pin;
Stephen Warren3712a3c2011-10-21 12:25:53 -0600267 const char *func;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200268
269 ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
270 if (ret)
271 return;
272
273 /* Convert to the pin controllers number space */
Chanho Park3c739ad2011-11-11 18:47:58 +0900274 pin = gpio - range->base + range->pin_base;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200275
Stephen Warren3712a3c2011-10-21 12:25:53 -0600276 func = pin_free(pctldev, pin, range);
277 kfree(func);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200278}
279EXPORT_SYMBOL_GPL(pinmux_free_gpio);
280
Linus Walleij542e7042011-11-14 10:06:22 +0100281static int pinmux_gpio_direction(unsigned gpio, bool input)
282{
283 struct pinctrl_dev *pctldev;
284 struct pinctrl_gpio_range *range;
285 const struct pinmux_ops *ops;
286 int ret;
287 int pin;
288
289 ret = pinctrl_get_device_gpio_range(gpio, &pctldev, &range);
290 if (ret)
291 return ret;
292
293 ops = pctldev->desc->pmxops;
294
295 /* Convert to the pin controllers number space */
296 pin = gpio - range->base + range->pin_base;
297
298 if (ops->gpio_set_direction)
299 ret = ops->gpio_set_direction(pctldev, range, pin, input);
300 else
301 ret = 0;
302
303 return ret;
304}
305
306/**
307 * pinmux_gpio_direction_input() - request a GPIO pin to go into input mode
308 * @gpio: the GPIO pin number from the GPIO subsystem number space
309 *
310 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
311 * as part of their gpio_direction_input() semantics, platforms and individual
312 * drivers shall *NOT* touch pinmux GPIO calls.
313 */
314int pinmux_gpio_direction_input(unsigned gpio)
315{
316 return pinmux_gpio_direction(gpio, true);
317}
318EXPORT_SYMBOL_GPL(pinmux_gpio_direction_input);
319
320/**
321 * pinmux_gpio_direction_output() - request a GPIO pin to go into output mode
322 * @gpio: the GPIO pin number from the GPIO subsystem number space
323 *
324 * This function should *ONLY* be used from gpiolib-based GPIO drivers,
325 * as part of their gpio_direction_output() semantics, platforms and individual
326 * drivers shall *NOT* touch pinmux GPIO calls.
327 */
328int pinmux_gpio_direction_output(unsigned gpio)
329{
330 return pinmux_gpio_direction(gpio, false);
331}
332EXPORT_SYMBOL_GPL(pinmux_gpio_direction_output);
333
Linus Walleij2744e8a2011-05-02 20:50:54 +0200334/**
335 * pinmux_register_mappings() - register a set of pinmux mappings
336 * @maps: the pinmux mappings table to register
337 * @num_maps: the number of maps in the mapping table
338 *
339 * Only call this once during initialization of your machine, the function is
340 * tagged as __init and won't be callable after init has completed. The map
341 * passed into this function will be owned by the pinmux core and cannot be
342 * free:d.
343 */
344int __init pinmux_register_mappings(struct pinmux_map const *maps,
345 unsigned num_maps)
346{
347 int i;
348
349 if (pinmux_maps != NULL) {
350 pr_err("pinmux mappings already registered, you can only "
351 "register one set of maps\n");
352 return -EINVAL;
353 }
354
355 pr_debug("add %d pinmux maps\n", num_maps);
356 for (i = 0; i < num_maps; i++) {
357 /* Sanity check the mapping */
358 if (!maps[i].name) {
359 pr_err("failed to register map %d: "
360 "no map name given\n", i);
361 return -EINVAL;
362 }
363 if (!maps[i].ctrl_dev && !maps[i].ctrl_dev_name) {
364 pr_err("failed to register map %s (%d): "
365 "no pin control device given\n",
366 maps[i].name, i);
367 return -EINVAL;
368 }
369 if (!maps[i].function) {
370 pr_err("failed to register map %s (%d): "
371 "no function ID given\n", maps[i].name, i);
372 return -EINVAL;
373 }
374
375 if (!maps[i].dev && !maps[i].dev_name)
376 pr_debug("add system map %s function %s with no device\n",
377 maps[i].name,
378 maps[i].function);
379 else
380 pr_debug("register map %s, function %s\n",
381 maps[i].name,
382 maps[i].function);
383 }
384
385 pinmux_maps = maps;
386 pinmux_maps_num = num_maps;
387
388 return 0;
389}
390
391/**
392 * acquire_pins() - acquire all the pins for a certain funcion on a pinmux
393 * @pctldev: the device to take the pins on
394 * @func_selector: the function selector to acquire the pins for
395 * @group_selector: the group selector containing the pins to acquire
396 */
397static int acquire_pins(struct pinctrl_dev *pctldev,
398 unsigned func_selector,
399 unsigned group_selector)
400{
401 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
402 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
403 const char *func = pmxops->get_function_name(pctldev,
404 func_selector);
Stephen Warrena5818a82011-10-19 16:19:25 -0600405 const unsigned *pins;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200406 unsigned num_pins;
407 int ret;
408 int i;
409
410 ret = pctlops->get_group_pins(pctldev, group_selector,
411 &pins, &num_pins);
412 if (ret)
413 return ret;
414
415 dev_dbg(&pctldev->dev, "requesting the %u pins from group %u\n",
416 num_pins, group_selector);
417
418 /* Try to allocate all pins in this group, one by one */
419 for (i = 0; i < num_pins; i++) {
Stephen Warren3712a3c2011-10-21 12:25:53 -0600420 ret = pin_request(pctldev, pins[i], func, NULL);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200421 if (ret) {
422 dev_err(&pctldev->dev,
423 "could not get pin %d for function %s "
424 "on device %s - conflicting mux mappings?\n",
425 pins[i], func ? : "(undefined)",
426 pinctrl_dev_get_name(pctldev));
427 /* On error release all taken pins */
428 i--; /* this pin just failed */
429 for (; i >= 0; i--)
Stephen Warren3712a3c2011-10-21 12:25:53 -0600430 pin_free(pctldev, pins[i], NULL);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200431 return -ENODEV;
432 }
433 }
434 return 0;
435}
436
437/**
438 * release_pins() - release pins taken by earlier acquirement
439 * @pctldev: the device to free the pinx on
440 * @group_selector: the group selector containing the pins to free
441 */
442static void release_pins(struct pinctrl_dev *pctldev,
443 unsigned group_selector)
444{
445 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
Stephen Warrena5818a82011-10-19 16:19:25 -0600446 const unsigned *pins;
Linus Walleij2744e8a2011-05-02 20:50:54 +0200447 unsigned num_pins;
448 int ret;
449 int i;
450
451 ret = pctlops->get_group_pins(pctldev, group_selector,
452 &pins, &num_pins);
453 if (ret) {
454 dev_err(&pctldev->dev, "could not get pins to release for "
455 "group selector %d\n",
456 group_selector);
457 return;
458 }
459 for (i = 0; i < num_pins; i++)
Stephen Warren3712a3c2011-10-21 12:25:53 -0600460 pin_free(pctldev, pins[i], NULL);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200461}
462
463/**
Linus Walleij2744e8a2011-05-02 20:50:54 +0200464 * pinmux_check_pin_group() - check function and pin group combo
465 * @pctldev: device to check the pin group vs function for
466 * @func_selector: the function selector to check the pin group for, we have
467 * already looked this up in the calling function
468 * @pin_group: the pin group to match to the function
469 *
470 * This function will check that the pinmux driver can supply the
471 * selected pin group for a certain function, returns the group selector if
472 * the group and function selector will work fine together, else returns
473 * negative
474 */
475static int pinmux_check_pin_group(struct pinctrl_dev *pctldev,
476 unsigned func_selector,
477 const char *pin_group)
478{
479 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
480 const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
481 int ret;
482
483 /*
484 * If the driver does not support different pin groups for the
485 * functions, we only support group 0, and assume this exists.
486 */
487 if (!pctlops || !pctlops->list_groups)
488 return 0;
489
490 /*
491 * Passing NULL (no specific group) will select the first and
492 * hopefully only group of pins available for this function.
493 */
494 if (!pin_group) {
495 char const * const *groups;
496 unsigned num_groups;
497
498 ret = pmxops->get_function_groups(pctldev, func_selector,
499 &groups, &num_groups);
500 if (ret)
501 return ret;
502 if (num_groups < 1)
503 return -EINVAL;
Linus Walleij7afde8b2011-10-19 17:07:16 +0200504 ret = pinctrl_get_group_selector(pctldev, groups[0]);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200505 if (ret < 0) {
506 dev_err(&pctldev->dev,
507 "function %s wants group %s but the pin "
508 "controller does not seem to have that group\n",
509 pmxops->get_function_name(pctldev, func_selector),
510 groups[0]);
511 return ret;
512 }
513
514 if (num_groups > 1)
515 dev_dbg(&pctldev->dev,
516 "function %s support more than one group, "
517 "default-selecting first group %s (%d)\n",
518 pmxops->get_function_name(pctldev, func_selector),
519 groups[0],
520 ret);
521
522 return ret;
523 }
524
525 dev_dbg(&pctldev->dev,
526 "check if we have pin group %s on controller %s\n",
527 pin_group, pinctrl_dev_get_name(pctldev));
528
Linus Walleij7afde8b2011-10-19 17:07:16 +0200529 ret = pinctrl_get_group_selector(pctldev, pin_group);
Linus Walleij2744e8a2011-05-02 20:50:54 +0200530 if (ret < 0) {
531 dev_dbg(&pctldev->dev,
532 "%s does not support pin group %s with function %s\n",
533 pinctrl_dev_get_name(pctldev),
534 pin_group,
535 pmxops->get_function_name(pctldev, func_selector));
536 }
537 return ret;
538}
539
540/**
541 * pinmux_search_function() - check pin control driver for a certain function
542 * @pctldev: device to check for function and position
543 * @map: function map containing the function and position to look for
544 * @func_selector: returns the applicable function selector if found
545 * @group_selector: returns the applicable group selector if found
546 *
547 * This will search the pinmux driver for an applicable
548 * function with a specific pin group, returns 0 if these can be mapped
549 * negative otherwise
550 */
551static int pinmux_search_function(struct pinctrl_dev *pctldev,
552 struct pinmux_map const *map,
553 unsigned *func_selector,
554 unsigned *group_selector)
555{
556 const struct pinmux_ops *ops = pctldev->desc->pmxops;
557 unsigned selector = 0;
558
559 /* See if this pctldev has this function */
560 while (ops->list_functions(pctldev, selector) >= 0) {
561 const char *fname = ops->get_function_name(pctldev,
562 selector);
563 int ret;
564
565 if (!strcmp(map->function, fname)) {
566 /* Found the function, check pin group */
567 ret = pinmux_check_pin_group(pctldev, selector,
568 map->group);
569 if (ret < 0)
570 return ret;
571
572 /* This function and group selector can be used */
573 *func_selector = selector;
574 *group_selector = ret;
575 return 0;
576
577 }
578 selector++;
579 }
580
581 pr_err("%s does not support function %s\n",
582 pinctrl_dev_get_name(pctldev), map->function);
583 return -EINVAL;
584}
585
586/**
587 * pinmux_enable_muxmap() - enable a map entry for a certain pinmux
588 */
589static int pinmux_enable_muxmap(struct pinctrl_dev *pctldev,
590 struct pinmux *pmx,
591 struct device *dev,
592 const char *devname,
593 struct pinmux_map const *map)
594{
595 unsigned func_selector;
596 unsigned group_selector;
597 struct pinmux_group *grp;
598 int ret;
599
600 /*
601 * Note that we're not locking the pinmux mutex here, because
602 * this is only called at pinmux initialization time when it
603 * has not been added to any list and thus is not reachable
604 * by anyone else.
605 */
606
607 if (pmx->pctldev && pmx->pctldev != pctldev) {
608 dev_err(&pctldev->dev,
609 "different pin control devices given for device %s, "
610 "function %s\n",
611 devname,
612 map->function);
613 return -EINVAL;
614 }
615 pmx->dev = dev;
616 pmx->pctldev = pctldev;
617
618 /* Now go into the driver and try to match a function and group */
619 ret = pinmux_search_function(pctldev, map, &func_selector,
620 &group_selector);
621 if (ret < 0)
622 return ret;
623
624 /*
625 * If the function selector is already set, it needs to be identical,
626 * we support several groups with one function but not several
627 * functions with one or several groups in the same pinmux.
628 */
629 if (pmx->func_selector != UINT_MAX &&
630 pmx->func_selector != func_selector) {
631 dev_err(&pctldev->dev,
632 "dual function defines in the map for device %s\n",
633 devname);
634 return -EINVAL;
635 }
636 pmx->func_selector = func_selector;
637
638 /* Now add this group selector, we may have many of them */
639 grp = kmalloc(sizeof(struct pinmux_group), GFP_KERNEL);
640 if (!grp)
641 return -ENOMEM;
642 grp->group_selector = group_selector;
643 ret = acquire_pins(pctldev, func_selector, group_selector);
644 if (ret) {
645 kfree(grp);
646 return ret;
647 }
648 list_add(&grp->node, &pmx->groups);
649
650 return 0;
651}
652
653static void pinmux_free_groups(struct pinmux *pmx)
654{
655 struct list_head *node, *tmp;
656
657 list_for_each_safe(node, tmp, &pmx->groups) {
658 struct pinmux_group *grp =
659 list_entry(node, struct pinmux_group, node);
660 /* Release all pins taken by this group */
661 release_pins(pmx->pctldev, grp->group_selector);
662 list_del(node);
663 kfree(grp);
664 }
665}
666
667/**
668 * pinmux_get() - retrieves the pinmux for a certain device
669 * @dev: the device to get the pinmux for
670 * @name: an optional specific mux mapping name or NULL, the name is only
671 * needed if you want to have more than one mapping per device, or if you
672 * need an anonymous pinmux (not tied to any specific device)
673 */
674struct pinmux *pinmux_get(struct device *dev, const char *name)
675{
676
677 struct pinmux_map const *map = NULL;
678 struct pinctrl_dev *pctldev = NULL;
679 const char *devname = NULL;
680 struct pinmux *pmx;
681 bool found_map;
682 unsigned num_maps = 0;
683 int ret = -ENODEV;
684 int i;
685
686 /* We must have dev or ID or both */
687 if (!dev && !name)
688 return ERR_PTR(-EINVAL);
689
690 if (dev)
691 devname = dev_name(dev);
692
693 pr_debug("get mux %s for device %s\n", name,
694 devname ? devname : "(none)");
695
696 /*
697 * create the state cookie holder struct pinmux for each
698 * mapping, this is what consumers will get when requesting
699 * a pinmux handle with pinmux_get()
700 */
701 pmx = kzalloc(sizeof(struct pinmux), GFP_KERNEL);
702 if (pmx == NULL)
703 return ERR_PTR(-ENOMEM);
704 mutex_init(&pmx->mutex);
705 pmx->func_selector = UINT_MAX;
706 INIT_LIST_HEAD(&pmx->groups);
707
708 /* Iterate over the pinmux maps to locate the right ones */
709 for (i = 0; i < pinmux_maps_num; i++) {
710 map = &pinmux_maps[i];
711 found_map = false;
712
713 /*
714 * First, try to find the pctldev given in the map
715 */
716 pctldev = get_pinctrl_dev_from_dev(map->ctrl_dev,
717 map->ctrl_dev_name);
718 if (!pctldev) {
719 const char *devname = NULL;
720
721 if (map->ctrl_dev)
722 devname = dev_name(map->ctrl_dev);
723 else if (map->ctrl_dev_name)
724 devname = map->ctrl_dev_name;
725
726 pr_warning("could not find a pinctrl device for pinmux "
727 "function %s, fishy, they shall all have one\n",
728 map->function);
729 pr_warning("given pinctrl device name: %s",
730 devname ? devname : "UNDEFINED");
731
732 /* Continue to check the other mappings anyway... */
733 continue;
734 }
735
736 pr_debug("in map, found pctldev %s to handle function %s",
737 dev_name(&pctldev->dev), map->function);
738
739
740 /*
741 * If we're looking for a specific named map, this must match,
742 * else we loop and look for the next.
743 */
744 if (name != NULL) {
745 if (map->name == NULL)
746 continue;
747 if (strcmp(map->name, name))
748 continue;
749 }
750
751 /*
752 * This is for the case where no device name is given, we
753 * already know that the function name matches from above
754 * code.
755 */
756 if (!map->dev_name && (name != NULL))
757 found_map = true;
758
759 /* If the mapping has a device set up it must match */
760 if (map->dev_name &&
761 (!devname || !strcmp(map->dev_name, devname)))
762 /* MATCH! */
763 found_map = true;
764
765 /* If this map is applicable, then apply it */
766 if (found_map) {
767 ret = pinmux_enable_muxmap(pctldev, pmx, dev,
768 devname, map);
769 if (ret) {
770 pinmux_free_groups(pmx);
771 kfree(pmx);
772 return ERR_PTR(ret);
773 }
774 num_maps++;
775 }
776 }
777
778
779 /* We should have atleast one map, right */
780 if (!num_maps) {
781 pr_err("could not find any mux maps for device %s, ID %s\n",
782 devname ? devname : "(anonymous)",
783 name ? name : "(undefined)");
784 kfree(pmx);
785 return ERR_PTR(-EINVAL);
786 }
787
788 pr_debug("found %u mux maps for device %s, UD %s\n",
789 num_maps,
790 devname ? devname : "(anonymous)",
791 name ? name : "(undefined)");
792
793 /* Add the pinmux to the global list */
794 mutex_lock(&pinmux_list_mutex);
795 list_add(&pmx->node, &pinmux_list);
796 mutex_unlock(&pinmux_list_mutex);
797
798 return pmx;
799}
800EXPORT_SYMBOL_GPL(pinmux_get);
801
802/**
803 * pinmux_put() - release a previously claimed pinmux
804 * @pmx: a pinmux previously claimed by pinmux_get()
805 */
806void pinmux_put(struct pinmux *pmx)
807{
808 if (pmx == NULL)
809 return;
810
811 mutex_lock(&pmx->mutex);
812 if (pmx->usecount)
813 pr_warn("releasing pinmux with active users!\n");
814 /* Free the groups and all acquired pins */
815 pinmux_free_groups(pmx);
816 mutex_unlock(&pmx->mutex);
817
818 /* Remove from list */
819 mutex_lock(&pinmux_list_mutex);
820 list_del(&pmx->node);
821 mutex_unlock(&pinmux_list_mutex);
822
823 kfree(pmx);
824}
825EXPORT_SYMBOL_GPL(pinmux_put);
826
827/**
828 * pinmux_enable() - enable a certain pinmux setting
829 * @pmx: the pinmux to enable, previously claimed by pinmux_get()
830 */
831int pinmux_enable(struct pinmux *pmx)
832{
833 int ret = 0;
834
835 if (pmx == NULL)
836 return -EINVAL;
837 mutex_lock(&pmx->mutex);
838 if (pmx->usecount++ == 0) {
839 struct pinctrl_dev *pctldev = pmx->pctldev;
840 const struct pinmux_ops *ops = pctldev->desc->pmxops;
841 struct pinmux_group *grp;
842
843 list_for_each_entry(grp, &pmx->groups, node) {
844 ret = ops->enable(pctldev, pmx->func_selector,
845 grp->group_selector);
846 if (ret) {
847 /*
848 * TODO: call disable() on all groups we called
849 * enable() on to this point?
850 */
851 pmx->usecount--;
852 break;
853 }
854 }
855 }
856 mutex_unlock(&pmx->mutex);
857 return ret;
858}
859EXPORT_SYMBOL_GPL(pinmux_enable);
860
861/**
862 * pinmux_disable() - disable a certain pinmux setting
863 * @pmx: the pinmux to disable, previously claimed by pinmux_get()
864 */
865void pinmux_disable(struct pinmux *pmx)
866{
867 if (pmx == NULL)
868 return;
869
870 mutex_lock(&pmx->mutex);
871 if (--pmx->usecount == 0) {
872 struct pinctrl_dev *pctldev = pmx->pctldev;
873 const struct pinmux_ops *ops = pctldev->desc->pmxops;
874 struct pinmux_group *grp;
875
876 list_for_each_entry(grp, &pmx->groups, node) {
877 ops->disable(pctldev, pmx->func_selector,
878 grp->group_selector);
879 }
880 }
881 mutex_unlock(&pmx->mutex);
882}
883EXPORT_SYMBOL_GPL(pinmux_disable);
884
885int pinmux_check_ops(const struct pinmux_ops *ops)
886{
887 /* Check that we implement required operations */
888 if (!ops->list_functions ||
889 !ops->get_function_name ||
890 !ops->get_function_groups ||
891 !ops->enable ||
892 !ops->disable)
893 return -EINVAL;
894
895 return 0;
896}
897
898/* Hog a single map entry and add to the hoglist */
899static int pinmux_hog_map(struct pinctrl_dev *pctldev,
900 struct pinmux_map const *map)
901{
902 struct pinmux_hog *hog;
903 struct pinmux *pmx;
904 int ret;
905
906 if (map->dev || map->dev_name) {
907 /*
908 * TODO: the day we have device tree support, we can
909 * traverse the device tree and hog to specific device nodes
910 * without any problems, so then we can hog pinmuxes for
911 * all devices that just want a static pin mux at this point.
912 */
913 dev_err(&pctldev->dev, "map %s wants to hog a non-system "
914 "pinmux, this is not going to work\n", map->name);
915 return -EINVAL;
916 }
917
918 hog = kzalloc(sizeof(struct pinmux_hog), GFP_KERNEL);
919 if (!hog)
920 return -ENOMEM;
921
922 pmx = pinmux_get(NULL, map->name);
923 if (IS_ERR(pmx)) {
924 kfree(hog);
925 dev_err(&pctldev->dev,
926 "could not get the %s pinmux mapping for hogging\n",
927 map->name);
928 return PTR_ERR(pmx);
929 }
930
931 ret = pinmux_enable(pmx);
932 if (ret) {
933 pinmux_put(pmx);
934 kfree(hog);
935 dev_err(&pctldev->dev,
936 "could not enable the %s pinmux mapping for hogging\n",
937 map->name);
938 return ret;
939 }
940
941 hog->map = map;
942 hog->pmx = pmx;
943
944 dev_info(&pctldev->dev, "hogged map %s, function %s\n", map->name,
945 map->function);
946 mutex_lock(&pctldev->pinmux_hogs_lock);
947 list_add(&hog->node, &pctldev->pinmux_hogs);
948 mutex_unlock(&pctldev->pinmux_hogs_lock);
949
950 return 0;
951}
952
953/**
954 * pinmux_hog_maps() - hog specific map entries on controller device
955 * @pctldev: the pin control device to hog entries on
956 *
957 * When the pin controllers are registered, there may be some specific pinmux
958 * map entries that need to be hogged, i.e. get+enabled until the system shuts
959 * down.
960 */
961int pinmux_hog_maps(struct pinctrl_dev *pctldev)
962{
963 struct device *dev = &pctldev->dev;
964 const char *devname = dev_name(dev);
965 int ret;
966 int i;
967
968 INIT_LIST_HEAD(&pctldev->pinmux_hogs);
969 mutex_init(&pctldev->pinmux_hogs_lock);
970
971 for (i = 0; i < pinmux_maps_num; i++) {
972 struct pinmux_map const *map = &pinmux_maps[i];
973
974 if (((map->ctrl_dev == dev) ||
975 !strcmp(map->ctrl_dev_name, devname)) &&
976 map->hog_on_boot) {
977 /* OK time to hog! */
978 ret = pinmux_hog_map(pctldev, map);
979 if (ret)
980 return ret;
981 }
982 }
983 return 0;
984}
985
986/**
Linus Walleij336cdba02011-11-10 09:27:41 +0100987 * pinmux_unhog_maps() - unhog specific map entries on controller device
Linus Walleij2744e8a2011-05-02 20:50:54 +0200988 * @pctldev: the pin control device to unhog entries on
989 */
990void pinmux_unhog_maps(struct pinctrl_dev *pctldev)
991{
992 struct list_head *node, *tmp;
993
994 mutex_lock(&pctldev->pinmux_hogs_lock);
995 list_for_each_safe(node, tmp, &pctldev->pinmux_hogs) {
996 struct pinmux_hog *hog =
997 list_entry(node, struct pinmux_hog, node);
998 pinmux_disable(hog->pmx);
999 pinmux_put(hog->pmx);
1000 list_del(node);
1001 kfree(hog);
1002 }
1003 mutex_unlock(&pctldev->pinmux_hogs_lock);
1004}
1005
1006#ifdef CONFIG_DEBUG_FS
1007
1008/* Called from pincontrol core */
1009static int pinmux_functions_show(struct seq_file *s, void *what)
1010{
1011 struct pinctrl_dev *pctldev = s->private;
1012 const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
1013 unsigned func_selector = 0;
1014
1015 while (pmxops->list_functions(pctldev, func_selector) >= 0) {
1016 const char *func = pmxops->get_function_name(pctldev,
1017 func_selector);
1018 const char * const *groups;
1019 unsigned num_groups;
1020 int ret;
1021 int i;
1022
1023 ret = pmxops->get_function_groups(pctldev, func_selector,
1024 &groups, &num_groups);
1025 if (ret)
1026 seq_printf(s, "function %s: COULD NOT GET GROUPS\n",
1027 func);
1028
1029 seq_printf(s, "function: %s, groups = [ ", func);
1030 for (i = 0; i < num_groups; i++)
1031 seq_printf(s, "%s ", groups[i]);
1032 seq_puts(s, "]\n");
1033
1034 func_selector++;
1035
1036 }
1037
1038 return 0;
1039}
1040
1041static int pinmux_pins_show(struct seq_file *s, void *what)
1042{
1043 struct pinctrl_dev *pctldev = s->private;
1044 unsigned pin;
1045
1046 seq_puts(s, "Pinmux settings per pin\n");
1047 seq_puts(s, "Format: pin (name): pinmuxfunction\n");
1048
1049 /* The highest pin number need to be included in the loop, thus <= */
1050 for (pin = 0; pin <= pctldev->desc->maxpin; pin++) {
1051
1052 struct pin_desc *desc;
1053
1054 desc = pin_desc_get(pctldev, pin);
1055 /* Pin space may be sparse */
1056 if (desc == NULL)
1057 continue;
1058
1059 seq_printf(s, "pin %d (%s): %s\n", pin,
1060 desc->name ? desc->name : "unnamed",
Stephen Warren5d2eaf82011-10-19 16:19:28 -06001061 desc->mux_function ? desc->mux_function
1062 : "UNCLAIMED");
Linus Walleij2744e8a2011-05-02 20:50:54 +02001063 }
1064
1065 return 0;
1066}
1067
1068static int pinmux_hogs_show(struct seq_file *s, void *what)
1069{
1070 struct pinctrl_dev *pctldev = s->private;
1071 struct pinmux_hog *hog;
1072
1073 seq_puts(s, "Pinmux map hogs held by device\n");
1074
1075 list_for_each_entry(hog, &pctldev->pinmux_hogs, node)
1076 seq_printf(s, "%s\n", hog->map->name);
1077
1078 return 0;
1079}
1080
1081static int pinmux_show(struct seq_file *s, void *what)
1082{
1083 struct pinmux *pmx;
1084
1085 seq_puts(s, "Requested pinmuxes and their maps:\n");
1086 list_for_each_entry(pmx, &pinmux_list, node) {
1087 struct pinctrl_dev *pctldev = pmx->pctldev;
1088 const struct pinmux_ops *pmxops;
1089 const struct pinctrl_ops *pctlops;
1090 struct pinmux_group *grp;
1091
1092 if (!pctldev) {
1093 seq_puts(s, "NO PIN CONTROLLER DEVICE\n");
1094 continue;
1095 }
1096
1097 pmxops = pctldev->desc->pmxops;
1098 pctlops = pctldev->desc->pctlops;
1099
1100 seq_printf(s, "device: %s function: %s (%u),",
1101 pinctrl_dev_get_name(pmx->pctldev),
1102 pmxops->get_function_name(pctldev, pmx->func_selector),
1103 pmx->func_selector);
1104
1105 seq_printf(s, " groups: [");
1106 list_for_each_entry(grp, &pmx->groups, node) {
1107 seq_printf(s, " %s (%u)",
1108 pctlops->get_group_name(pctldev, grp->group_selector),
1109 grp->group_selector);
1110 }
1111 seq_printf(s, " ]");
1112
1113 seq_printf(s, " users: %u map-> %s\n",
1114 pmx->usecount,
1115 pmx->dev ? dev_name(pmx->dev) : "(system)");
1116 }
1117
1118 return 0;
1119}
1120
1121static int pinmux_maps_show(struct seq_file *s, void *what)
1122{
1123 int i;
1124
1125 seq_puts(s, "Pinmux maps:\n");
1126
1127 for (i = 0; i < pinmux_maps_num; i++) {
1128 struct pinmux_map const *map = &pinmux_maps[i];
1129
1130 seq_printf(s, "%s:\n", map->name);
1131 if (map->dev || map->dev_name)
1132 seq_printf(s, " device: %s\n",
1133 map->dev ? dev_name(map->dev) :
1134 map->dev_name);
1135 else
1136 seq_printf(s, " SYSTEM MUX\n");
1137 seq_printf(s, " controlling device %s\n",
1138 map->ctrl_dev ? dev_name(map->ctrl_dev) :
1139 map->ctrl_dev_name);
1140 seq_printf(s, " function: %s\n", map->function);
1141 seq_printf(s, " group: %s\n", map->group ? map->group :
1142 "(default)");
1143 }
1144 return 0;
1145}
1146
1147static int pinmux_functions_open(struct inode *inode, struct file *file)
1148{
1149 return single_open(file, pinmux_functions_show, inode->i_private);
1150}
1151
1152static int pinmux_pins_open(struct inode *inode, struct file *file)
1153{
1154 return single_open(file, pinmux_pins_show, inode->i_private);
1155}
1156
1157static int pinmux_hogs_open(struct inode *inode, struct file *file)
1158{
1159 return single_open(file, pinmux_hogs_show, inode->i_private);
1160}
1161
1162static int pinmux_open(struct inode *inode, struct file *file)
1163{
1164 return single_open(file, pinmux_show, NULL);
1165}
1166
1167static int pinmux_maps_open(struct inode *inode, struct file *file)
1168{
1169 return single_open(file, pinmux_maps_show, NULL);
1170}
1171
1172static const struct file_operations pinmux_functions_ops = {
1173 .open = pinmux_functions_open,
1174 .read = seq_read,
1175 .llseek = seq_lseek,
1176 .release = single_release,
1177};
1178
1179static const struct file_operations pinmux_pins_ops = {
1180 .open = pinmux_pins_open,
1181 .read = seq_read,
1182 .llseek = seq_lseek,
1183 .release = single_release,
1184};
1185
1186static const struct file_operations pinmux_hogs_ops = {
1187 .open = pinmux_hogs_open,
1188 .read = seq_read,
1189 .llseek = seq_lseek,
1190 .release = single_release,
1191};
1192
1193static const struct file_operations pinmux_ops = {
1194 .open = pinmux_open,
1195 .read = seq_read,
1196 .llseek = seq_lseek,
1197 .release = single_release,
1198};
1199
1200static const struct file_operations pinmux_maps_ops = {
1201 .open = pinmux_maps_open,
1202 .read = seq_read,
1203 .llseek = seq_lseek,
1204 .release = single_release,
1205};
1206
1207void pinmux_init_device_debugfs(struct dentry *devroot,
1208 struct pinctrl_dev *pctldev)
1209{
1210 debugfs_create_file("pinmux-functions", S_IFREG | S_IRUGO,
1211 devroot, pctldev, &pinmux_functions_ops);
1212 debugfs_create_file("pinmux-pins", S_IFREG | S_IRUGO,
1213 devroot, pctldev, &pinmux_pins_ops);
1214 debugfs_create_file("pinmux-hogs", S_IFREG | S_IRUGO,
1215 devroot, pctldev, &pinmux_hogs_ops);
1216}
1217
1218void pinmux_init_debugfs(struct dentry *subsys_root)
1219{
1220 debugfs_create_file("pinmuxes", S_IFREG | S_IRUGO,
1221 subsys_root, NULL, &pinmux_ops);
1222 debugfs_create_file("pinmux-maps", S_IFREG | S_IRUGO,
1223 subsys_root, NULL, &pinmux_maps_ops);
1224}
1225
1226#endif /* CONFIG_DEBUG_FS */