include/linux/pinctrl/pinmux.h

   1 /*
   2  * Interface the pinmux 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 #ifndef __LINUX_PINCTRL_PINMUX_H
  13 #define __LINUX_PINCTRL_PINMUX_H
  14
  15 #include <linux/list.h>
  16 #include <linux/seq_file.h>
  17 #include "pinctrl.h"
  18
  19 #ifdef CONFIG_PINMUX
  20
  21 struct pinctrl_dev;
  22
  23 /**
  24  * struct pinmux_ops - pinmux operations, to be implemented by pin controller
  25  * drivers that support pinmuxing
  26  * @request: called by the core to see if a certain pin can be made
  27  *      available for muxing. This is called by the core to acquire the pins
  28  *      before selecting any actual mux setting across a function. The driver
  29  *      is allowed to answer "no" by returning a negative error code
  30  * @free: the reverse function of the request() callback, frees a pin after
  31  *      being requested
  32  * @get_functions_count: returns number of selectable named functions available
  33  *      in this pinmux driver
  34  * @get_function_name: return the function name of the muxing selector,
  35  *      called by the core to figure out which mux setting it shall map a
  36  *      certain device to
  37  * @get_function_groups: return an array of groups names (in turn
  38  *      referencing pins) connected to a certain function selector. The group
  39  *      name can be used with the generic @pinctrl_ops to retrieve the
  40  *      actual pins affected. The applicable groups will be returned in
  41  *      @groups and the number of groups in @num_groups
  42  * @enable: enable a certain muxing function with a certain pin group. The
  43  *      driver does not need to figure out whether enabling this function
  44  *      conflicts some other use of the pins in that group, such collisions
  45  *      are handled by the pinmux subsystem. The @func_selector selects a
  46  *      certain function whereas @group_selector selects a certain set of pins
  47  *      to be used. On simple controllers the latter argument may be ignored
  48  * @disable: disable a certain muxing selector with a certain pin group
  49  * @gpio_request_enable: requests and enables GPIO on a certain pin.
  50  *      Implement this only if you can mux every pin individually as GPIO. The
  51  *      affected GPIO range is passed along with an offset(pin number) into that
  52  *      specific GPIO range - function selectors and pin groups are orthogonal
  53  *      to this, the core will however make sure the pins do not collide.
  54  * @gpio_disable_free: free up GPIO muxing on a certain pin, the reverse of
  55  *      @gpio_request_enable
  56  * @gpio_set_direction: Since controllers may need different configurations
  57  *      depending on whether the GPIO is configured as input or output,
  58  *      a direction selector function may be implemented as a backing
  59  *      to the GPIO controllers that need pin muxing.
  60  */
  61 struct pinmux_ops {
  62         int (*request) (struct pinctrl_dev *pctldev, unsigned offset);
  63         int (*free) (struct pinctrl_dev *pctldev, unsigned offset);
  64         int (*get_functions_count) (struct pinctrl_dev *pctldev);
  65         const char *(*get_function_name) (struct pinctrl_dev *pctldev,
  66                                           unsigned selector);
  67         int (*get_function_groups) (struct pinctrl_dev *pctldev,
  68                                   unsigned selector,
  69                                   const char * const **groups,
  70                                   unsigned * const num_groups);
  71         int (*enable) (struct pinctrl_dev *pctldev, unsigned func_selector,
  72                        unsigned group_selector);
  73         void (*disable) (struct pinctrl_dev *pctldev, unsigned func_selector,
  74                          unsigned group_selector);
  75         int (*gpio_request_enable) (struct pinctrl_dev *pctldev,
  76                                     struct pinctrl_gpio_range *range,
  77                                     unsigned offset);
  78         void (*gpio_disable_free) (struct pinctrl_dev *pctldev,
  79                                    struct pinctrl_gpio_range *range,
  80                                    unsigned offset);
  81         int (*gpio_set_direction) (struct pinctrl_dev *pctldev,
  82                                    struct pinctrl_gpio_range *range,
  83                                    unsigned offset,
  84                                    bool input);
  85 };
  86
  87 #endif /* CONFIG_PINMUX */
  88
  89 #endif /* __LINUX_PINCTRL_PINMUX_H */