linux/include/asm-generic/gpio.h
<<
>>
Prefs
   1#ifndef _ASM_GENERIC_GPIO_H
   2#define _ASM_GENERIC_GPIO_H
   3
   4#include <linux/kernel.h>
   5#include <linux/types.h>
   6#include <linux/errno.h>
   7#include <linux/of.h>
   8
   9#ifdef CONFIG_GPIOLIB
  10
  11#include <linux/compiler.h>
  12
  13/* Platforms may implement their GPIO interface with library code,
  14 * at a small performance cost for non-inlined operations and some
  15 * extra memory (for code and for per-GPIO table entries).
  16 *
  17 * While the GPIO programming interface defines valid GPIO numbers
  18 * to be in the range 0..MAX_INT, this library restricts them to the
  19 * smaller range 0..ARCH_NR_GPIOS-1.
  20 *
  21 * ARCH_NR_GPIOS is somewhat arbitrary; it usually reflects the sum of
  22 * builtin/SoC GPIOs plus a number of GPIOs on expanders; the latter is
  23 * actually an estimate of a board-specific value.
  24 */
  25
  26#ifndef ARCH_NR_GPIOS
  27#define ARCH_NR_GPIOS           256
  28#endif
  29
  30/*
  31 * "valid" GPIO numbers are nonnegative and may be passed to
  32 * setup routines like gpio_request().  only some valid numbers
  33 * can successfully be requested and used.
  34 *
  35 * Invalid GPIO numbers are useful for indicating no-such-GPIO in
  36 * platform data and other tables.
  37 */
  38
  39static inline bool gpio_is_valid(int number)
  40{
  41        return number >= 0 && number < ARCH_NR_GPIOS;
  42}
  43
  44struct device;
  45struct gpio;
  46struct seq_file;
  47struct module;
  48struct device_node;
  49
  50/**
  51 * struct gpio_chip - abstract a GPIO controller
  52 * @label: for diagnostics
  53 * @dev: optional device providing the GPIOs
  54 * @owner: helps prevent removal of modules exporting active GPIOs
  55 * @request: optional hook for chip-specific activation, such as
  56 *      enabling module power and clock; may sleep
  57 * @free: optional hook for chip-specific deactivation, such as
  58 *      disabling module power and clock; may sleep
  59 * @direction_input: configures signal "offset" as input, or returns error
  60 * @get: returns value for signal "offset"; for output signals this
  61 *      returns either the value actually sensed, or zero
  62 * @direction_output: configures signal "offset" as output, or returns error
  63 * @set: assigns output value for signal "offset"
  64 * @to_irq: optional hook supporting non-static gpio_to_irq() mappings;
  65 *      implementation may not sleep
  66 * @dbg_show: optional routine to show contents in debugfs; default code
  67 *      will be used when this is omitted, but custom code can show extra
  68 *      state (such as pullup/pulldown configuration).
  69 * @base: identifies the first GPIO number handled by this chip; or, if
  70 *      negative during registration, requests dynamic ID allocation.
  71 * @ngpio: the number of GPIOs handled by this controller; the last GPIO
  72 *      handled is (base + ngpio - 1).
  73 * @can_sleep: flag must be set iff get()/set() methods sleep, as they
  74 *      must while accessing GPIO expander chips over I2C or SPI
  75 * @names: if set, must be an array of strings to use as alternative
  76 *      names for the GPIOs in this chip. Any entry in the array
  77 *      may be NULL if there is no alias for the GPIO, however the
  78 *      array must be @ngpio entries long.  A name can include a single printk
  79 *      format specifier for an unsigned int.  It is substituted by the actual
  80 *      number of the gpio.
  81 *
  82 * A gpio_chip can help platforms abstract various sources of GPIOs so
  83 * they can all be accessed through a common programing interface.
  84 * Example sources would be SOC controllers, FPGAs, multifunction
  85 * chips, dedicated GPIO expanders, and so on.
  86 *
  87 * Each chip controls a number of signals, identified in method calls
  88 * by "offset" values in the range 0..(@ngpio - 1).  When those signals
  89 * are referenced through calls like gpio_get_value(gpio), the offset
  90 * is calculated by subtracting @base from the gpio number.
  91 */
  92struct gpio_chip {
  93        const char              *label;
  94        struct device           *dev;
  95        struct module           *owner;
  96
  97        int                     (*request)(struct gpio_chip *chip,
  98                                                unsigned offset);
  99        void                    (*free)(struct gpio_chip *chip,
 100                                                unsigned offset);
 101
 102        int                     (*direction_input)(struct gpio_chip *chip,
 103                                                unsigned offset);
 104        int                     (*get)(struct gpio_chip *chip,
 105                                                unsigned offset);
 106        int                     (*direction_output)(struct gpio_chip *chip,
 107                                                unsigned offset, int value);
 108        int                     (*set_debounce)(struct gpio_chip *chip,
 109                                                unsigned offset, unsigned debounce);
 110
 111        void                    (*set)(struct gpio_chip *chip,
 112                                                unsigned offset, int value);
 113
 114        int                     (*to_irq)(struct gpio_chip *chip,
 115                                                unsigned offset);
 116
 117        void                    (*dbg_show)(struct seq_file *s,
 118                                                struct gpio_chip *chip);
 119        int                     base;
 120        u16                     ngpio;
 121        const char              *const *names;
 122        unsigned                can_sleep:1;
 123        unsigned                exported:1;
 124
 125#if defined(CONFIG_OF_GPIO)
 126        /*
 127         * If CONFIG_OF is enabled, then all GPIO controllers described in the
 128         * device tree automatically may have an OF translation
 129         */
 130        struct device_node *of_node;
 131        int of_gpio_n_cells;
 132        int (*of_xlate)(struct gpio_chip *gc,
 133                        const struct of_phandle_args *gpiospec, u32 *flags);
 134#endif
 135};
 136
 137extern const char *gpiochip_is_requested(struct gpio_chip *chip,
 138                        unsigned offset);
 139extern struct gpio_chip *gpio_to_chip(unsigned gpio);
 140extern int __must_check gpiochip_reserve(int start, int ngpio);
 141
 142/* add/remove chips */
 143extern int gpiochip_add(struct gpio_chip *chip);
 144extern int __must_check gpiochip_remove(struct gpio_chip *chip);
 145extern struct gpio_chip *gpiochip_find(void *data,
 146                                        int (*match)(struct gpio_chip *chip,
 147                                                     void *data));
 148
 149
 150/* Always use the library code for GPIO management calls,
 151 * or when sleeping may be involved.
 152 */
 153extern int gpio_request(unsigned gpio, const char *label);
 154extern void gpio_free(unsigned gpio);
 155
 156extern int gpio_direction_input(unsigned gpio);
 157extern int gpio_direction_output(unsigned gpio, int value);
 158
 159extern int gpio_set_debounce(unsigned gpio, unsigned debounce);
 160
 161extern int gpio_get_value_cansleep(unsigned gpio);
 162extern void gpio_set_value_cansleep(unsigned gpio, int value);
 163
 164
 165/* A platform's <asm/gpio.h> code may want to inline the I/O calls when
 166 * the GPIO is constant and refers to some always-present controller,
 167 * giving direct access to chip registers and tight bitbanging loops.
 168 */
 169extern int __gpio_get_value(unsigned gpio);
 170extern void __gpio_set_value(unsigned gpio, int value);
 171
 172extern int __gpio_cansleep(unsigned gpio);
 173
 174extern int __gpio_to_irq(unsigned gpio);
 175
 176extern int gpio_request_one(unsigned gpio, unsigned long flags, const char *label);
 177extern int gpio_request_array(const struct gpio *array, size_t num);
 178extern void gpio_free_array(const struct gpio *array, size_t num);
 179
 180/* bindings for managed devices that want to request gpios */
 181int devm_gpio_request(struct device *dev, unsigned gpio, const char *label);
 182int devm_gpio_request_one(struct device *dev, unsigned gpio,
 183                          unsigned long flags, const char *label);
 184void devm_gpio_free(struct device *dev, unsigned int gpio);
 185
 186#ifdef CONFIG_GPIO_SYSFS
 187
 188/*
 189 * A sysfs interface can be exported by individual drivers if they want,
 190 * but more typically is configured entirely from userspace.
 191 */
 192extern int gpio_export(unsigned gpio, bool direction_may_change);
 193extern int gpio_export_link(struct device *dev, const char *name,
 194                        unsigned gpio);
 195extern int gpio_sysfs_set_active_low(unsigned gpio, int value);
 196extern void gpio_unexport(unsigned gpio);
 197
 198#endif  /* CONFIG_GPIO_SYSFS */
 199
 200#else   /* !CONFIG_GPIOLIB */
 201
 202static inline bool gpio_is_valid(int number)
 203{
 204        /* only non-negative numbers are valid */
 205        return number >= 0;
 206}
 207
 208/* platforms that don't directly support access to GPIOs through I2C, SPI,
 209 * or other blocking infrastructure can use these wrappers.
 210 */
 211
 212static inline int gpio_cansleep(unsigned gpio)
 213{
 214        return 0;
 215}
 216
 217static inline int gpio_get_value_cansleep(unsigned gpio)
 218{
 219        might_sleep();
 220        return __gpio_get_value(gpio);
 221}
 222
 223static inline void gpio_set_value_cansleep(unsigned gpio, int value)
 224{
 225        might_sleep();
 226        __gpio_set_value(gpio, value);
 227}
 228
 229#endif /* !CONFIG_GPIOLIB */
 230
 231#ifndef CONFIG_GPIO_SYSFS
 232
 233struct device;
 234
 235/* sysfs support is only available with gpiolib, where it's optional */
 236
 237static inline int gpio_export(unsigned gpio, bool direction_may_change)
 238{
 239        return -ENOSYS;
 240}
 241
 242static inline int gpio_export_link(struct device *dev, const char *name,
 243                                unsigned gpio)
 244{
 245        return -ENOSYS;
 246}
 247
 248static inline int gpio_sysfs_set_active_low(unsigned gpio, int value)
 249{
 250        return -ENOSYS;
 251}
 252
 253static inline void gpio_unexport(unsigned gpio)
 254{
 255}
 256#endif  /* CONFIG_GPIO_SYSFS */
 257
 258#endif /* _ASM_GENERIC_GPIO_H */
 259
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.