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_debounce: optional hook for setting debounce time for specified gpio in
  64 *      interrupt triggered gpio chips
  65 * @set: assigns output value for signal "offset"
  66 * @to_irq: optional hook supporting non-static gpio_to_irq() mappings;
  67 *      implementation may not sleep
  68 * @dbg_show: optional routine to show contents in debugfs; default code
  69 *      will be used when this is omitted, but custom code can show extra
  70 *      state (such as pullup/pulldown configuration).
  71 * @base: identifies the first GPIO number handled by this chip; or, if
  72 *      negative during registration, requests dynamic ID allocation.
  73 * @ngpio: the number of GPIOs handled by this controller; the last GPIO
  74 *      handled is (base + ngpio - 1).
  75 * @can_sleep: flag must be set iff get()/set() methods sleep, as they
  76 *      must while accessing GPIO expander chips over I2C or SPI
  77 * @names: if set, must be an array of strings to use as alternative
  78 *      names for the GPIOs in this chip. Any entry in the array
  79 *      may be NULL if there is no alias for the GPIO, however the
  80 *      array must be @ngpio entries long.  A name can include a single printk
  81 *      format specifier for an unsigned int.  It is substituted by the actual
  82 *      number of the gpio.
  83 *
  84 * A gpio_chip can help platforms abstract various sources of GPIOs so
  85 * they can all be accessed through a common programing interface.
  86 * Example sources would be SOC controllers, FPGAs, multifunction
  87 * chips, dedicated GPIO expanders, and so on.
  88 *
  89 * Each chip controls a number of signals, identified in method calls
  90 * by "offset" values in the range 0..(@ngpio - 1).  When those signals
  91 * are referenced through calls like gpio_get_value(gpio), the offset
  92 * is calculated by subtracting @base from the gpio number.
  93 */
  94struct gpio_chip {
  95        const char              *label;
  96        struct device           *dev;
  97        struct module           *owner;
  98
  99        int                     (*request)(struct gpio_chip *chip,
 100                                                unsigned offset);
 101        void                    (*free)(struct gpio_chip *chip,
 102                                                unsigned offset);
 103
 104        int                     (*direction_input)(struct gpio_chip *chip,
 105                                                unsigned offset);
 106        int                     (*get)(struct gpio_chip *chip,
 107                                                unsigned offset);
 108        int                     (*direction_output)(struct gpio_chip *chip,
 109                                                unsigned offset, int value);
 110        int                     (*set_debounce)(struct gpio_chip *chip,
 111                                                unsigned offset, unsigned debounce);
 112
 113        void                    (*set)(struct gpio_chip *chip,
 114                                                unsigned offset, int value);
 115
 116        int                     (*to_irq)(struct gpio_chip *chip,
 117                                                unsigned offset);
 118
 119        void                    (*dbg_show)(struct seq_file *s,
 120                                                struct gpio_chip *chip);
 121        int                     base;
 122        u16                     ngpio;
 123        const char              *const *names;
 124        unsigned                can_sleep:1;
 125        unsigned                exported:1;
 126
 127#if defined(CONFIG_OF_GPIO)
 128        /*
 129         * If CONFIG_OF is enabled, then all GPIO controllers described in the
 130         * device tree automatically may have an OF translation
 131         */
 132        struct device_node *of_node;
 133        int of_gpio_n_cells;
 134        int (*of_xlate)(struct gpio_chip *gc,
 135                        const struct of_phandle_args *gpiospec, u32 *flags);
 136#endif
 137};
 138
 139extern const char *gpiochip_is_requested(struct gpio_chip *chip,
 140                        unsigned offset);
 141extern struct gpio_chip *gpio_to_chip(unsigned gpio);
 142extern int __must_check gpiochip_reserve(int start, int ngpio);
 143
 144/* add/remove chips */
 145extern int gpiochip_add(struct gpio_chip *chip);
 146extern int __must_check gpiochip_remove(struct gpio_chip *chip);
 147extern struct gpio_chip *gpiochip_find(void *data,
 148                                        int (*match)(struct gpio_chip *chip,
 149                                                     void *data));
 150
 151
 152/* Always use the library code for GPIO management calls,
 153 * or when sleeping may be involved.
 154 */
 155extern int gpio_request(unsigned gpio, const char *label);
 156extern void gpio_free(unsigned gpio);
 157
 158extern int gpio_direction_input(unsigned gpio);
 159extern int gpio_direction_output(unsigned gpio, int value);
 160
 161extern int gpio_set_debounce(unsigned gpio, unsigned debounce);
 162
 163extern int gpio_get_value_cansleep(unsigned gpio);
 164extern void gpio_set_value_cansleep(unsigned gpio, int value);
 165
 166
 167/* A platform's <asm/gpio.h> code may want to inline the I/O calls when
 168 * the GPIO is constant and refers to some always-present controller,
 169 * giving direct access to chip registers and tight bitbanging loops.
 170 */
 171extern int __gpio_get_value(unsigned gpio);
 172extern void __gpio_set_value(unsigned gpio, int value);
 173
 174extern int __gpio_cansleep(unsigned gpio);
 175
 176extern int __gpio_to_irq(unsigned gpio);
 177
 178extern int gpio_request_one(unsigned gpio, unsigned long flags, const char *label);
 179extern int gpio_request_array(const struct gpio *array, size_t num);
 180extern void gpio_free_array(const struct gpio *array, size_t num);
 181
 182/* bindings for managed devices that want to request gpios */
 183int devm_gpio_request(struct device *dev, unsigned gpio, const char *label);
 184int devm_gpio_request_one(struct device *dev, unsigned gpio,
 185                          unsigned long flags, const char *label);
 186void devm_gpio_free(struct device *dev, unsigned int gpio);
 187
 188#ifdef CONFIG_GPIO_SYSFS
 189
 190/*
 191 * A sysfs interface can be exported by individual drivers if they want,
 192 * but more typically is configured entirely from userspace.
 193 */
 194extern int gpio_export(unsigned gpio, bool direction_may_change);
 195extern int gpio_export_link(struct device *dev, const char *name,
 196                        unsigned gpio);
 197extern int gpio_sysfs_set_active_low(unsigned gpio, int value);
 198extern void gpio_unexport(unsigned gpio);
 199
 200#endif  /* CONFIG_GPIO_SYSFS */
 201
 202#else   /* !CONFIG_GPIOLIB */
 203
 204static inline bool gpio_is_valid(int number)
 205{
 206        /* only non-negative numbers are valid */
 207        return number >= 0;
 208}
 209
 210/* platforms that don't directly support access to GPIOs through I2C, SPI,
 211 * or other blocking infrastructure can use these wrappers.
 212 */
 213
 214static inline int gpio_cansleep(unsigned gpio)
 215{
 216        return 0;
 217}
 218
 219static inline int gpio_get_value_cansleep(unsigned gpio)
 220{
 221        might_sleep();
 222        return __gpio_get_value(gpio);
 223}
 224
 225static inline void gpio_set_value_cansleep(unsigned gpio, int value)
 226{
 227        might_sleep();
 228        __gpio_set_value(gpio, value);
 229}
 230
 231#endif /* !CONFIG_GPIOLIB */
 232
 233#ifndef CONFIG_GPIO_SYSFS
 234
 235struct device;
 236
 237/* sysfs support is only available with gpiolib, where it's optional */
 238
 239static inline int gpio_export(unsigned gpio, bool direction_may_change)
 240{
 241        return -ENOSYS;
 242}
 243
 244static inline int gpio_export_link(struct device *dev, const char *name,
 245                                unsigned gpio)
 246{
 247        return -ENOSYS;
 248}
 249
 250static inline int gpio_sysfs_set_active_low(unsigned gpio, int value)
 251{
 252        return -ENOSYS;
 253}
 254
 255static inline void gpio_unexport(unsigned gpio)
 256{
 257}
 258#endif  /* CONFIG_GPIO_SYSFS */
 259
 260#endif /* _ASM_GENERIC_GPIO_H */
 261
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.