← Back to branch summary

~ubuntu-branches/debian/experimental/linux-tools/experimental

« back to all changes in this revision

Viewing changes to include/asm-generic/gpio.h

  • Committer: Package Import Robot
  • Author(s): Ben Hutchings
  • Date: 2014-02-02 16:57:49 UTC
  • mfrom: (1.1.10) (0.1.21 sid)
  • Revision ID: package-import@ubuntu.com-20140202165749-tw94o9t1t0a8txk6
Tags: 3.13-1~exp2
Merge changes from sid up to 3.12.6-3

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/asm-generic/gpio.h
10
10
#ifdef CONFIG_GPIOLIB
11
11
 
12
12
#include <linux/compiler.h>
 
13
#include <linux/gpio/driver.h>
 
14
#include <linux/gpio/consumer.h>
13
15
 
14
16
/* Platforms may implement their GPIO interface with library code,
15
17
 * at a small performance cost for non-inlined operations and some
49
51
struct device_node;
50
52
struct gpio_desc;
51
53
 
52
 
/**
53
 
 * struct gpio_chip - abstract a GPIO controller
54
 
 * @label: for diagnostics
55
 
 * @dev: optional device providing the GPIOs
56
 
 * @owner: helps prevent removal of modules exporting active GPIOs
57
 
 * @list: links gpio_chips together for traversal
58
 
 * @request: optional hook for chip-specific activation, such as
59
 
 *      enabling module power and clock; may sleep
60
 
 * @free: optional hook for chip-specific deactivation, such as
61
 
 *      disabling module power and clock; may sleep
62
 
 * @get_direction: returns direction for signal "offset", 0=out, 1=in,
63
 
 *      (same as GPIOF_DIR_XXX), or negative error
64
 
 * @direction_input: configures signal "offset" as input, or returns error
65
 
 * @get: returns value for signal "offset"; for output signals this
66
 
 *      returns either the value actually sensed, or zero
67
 
 * @direction_output: configures signal "offset" as output, or returns error
68
 
 * @set_debounce: optional hook for setting debounce time for specified gpio in
69
 
 *      interrupt triggered gpio chips
70
 
 * @set: assigns output value for signal "offset"
71
 
 * @to_irq: optional hook supporting non-static gpio_to_irq() mappings;
72
 
 *      implementation may not sleep
73
 
 * @dbg_show: optional routine to show contents in debugfs; default code
74
 
 *      will be used when this is omitted, but custom code can show extra
75
 
 *      state (such as pullup/pulldown configuration).
76
 
 * @base: identifies the first GPIO number handled by this chip; or, if
77
 
 *      negative during registration, requests dynamic ID allocation.
78
 
 * @ngpio: the number of GPIOs handled by this controller; the last GPIO
79
 
 *      handled is (base + ngpio - 1).
80
 
 * @desc: array of ngpio descriptors. Private.
81
 
 * @can_sleep: flag must be set iff get()/set() methods sleep, as they
82
 
 *      must while accessing GPIO expander chips over I2C or SPI
83
 
 * @names: if set, must be an array of strings to use as alternative
84
 
 *      names for the GPIOs in this chip. Any entry in the array
85
 
 *      may be NULL if there is no alias for the GPIO, however the
86
 
 *      array must be @ngpio entries long.  A name can include a single printk
87
 
 *      format specifier for an unsigned int.  It is substituted by the actual
88
 
 *      number of the gpio.
89
 
 *
90
 
 * A gpio_chip can help platforms abstract various sources of GPIOs so
91
 
 * they can all be accessed through a common programing interface.
92
 
 * Example sources would be SOC controllers, FPGAs, multifunction
93
 
 * chips, dedicated GPIO expanders, and so on.
94
 
 *
95
 
 * Each chip controls a number of signals, identified in method calls
96
 
 * by "offset" values in the range 0..(@ngpio - 1).  When those signals
97
 
 * are referenced through calls like gpio_get_value(gpio), the offset
98
 
 * is calculated by subtracting @base from the gpio number.
99
 
 */
100
 
struct gpio_chip {
101
 
        const char              *label;
102
 
        struct device           *dev;
103
 
        struct module           *owner;
104
 
        struct list_head        list;
105
 
 
106
 
        int                     (*request)(struct gpio_chip *chip,
107
 
                                                unsigned offset);
108
 
        void                    (*free)(struct gpio_chip *chip,
109
 
                                                unsigned offset);
110
 
        int                     (*get_direction)(struct gpio_chip *chip,
111
 
                                                unsigned offset);
112
 
        int                     (*direction_input)(struct gpio_chip *chip,
113
 
                                                unsigned offset);
114
 
        int                     (*get)(struct gpio_chip *chip,
115
 
                                                unsigned offset);
116
 
        int                     (*direction_output)(struct gpio_chip *chip,
117
 
                                                unsigned offset, int value);
118
 
        int                     (*set_debounce)(struct gpio_chip *chip,
119
 
                                                unsigned offset, unsigned debounce);
120
 
 
121
 
        void                    (*set)(struct gpio_chip *chip,
122
 
                                                unsigned offset, int value);
123
 
 
124
 
        int                     (*to_irq)(struct gpio_chip *chip,
125
 
                                                unsigned offset);
126
 
 
127
 
        void                    (*dbg_show)(struct seq_file *s,
128
 
                                                struct gpio_chip *chip);
129
 
        int                     base;
130
 
        u16                     ngpio;
131
 
        struct gpio_desc        *desc;
132
 
        const char              *const *names;
133
 
        unsigned                can_sleep:1;
134
 
        unsigned                exported:1;
135
 
 
136
 
#if defined(CONFIG_OF_GPIO)
137
 
        /*
138
 
         * If CONFIG_OF is enabled, then all GPIO controllers described in the
139
 
         * device tree automatically may have an OF translation
140
 
         */
141
 
        struct device_node *of_node;
142
 
        int of_gpio_n_cells;
143
 
        int (*of_xlate)(struct gpio_chip *gc,
144
 
                        const struct of_phandle_args *gpiospec, u32 *flags);
145
 
#endif
146
 
#ifdef CONFIG_PINCTRL
147
 
        /*
148
 
         * If CONFIG_PINCTRL is enabled, then gpio controllers can optionally
149
 
         * describe the actual pin range which they serve in an SoC. This
150
 
         * information would be used by pinctrl subsystem to configure
151
 
         * corresponding pins for gpio usage.
152
 
         */
153
 
        struct list_head pin_ranges;
154
 
#endif
155
 
};
156
 
 
157
 
extern const char *gpiochip_is_requested(struct gpio_chip *chip,
158
 
                        unsigned offset);
159
 
extern struct gpio_chip *gpio_to_chip(unsigned gpio);
160
 
 
161
 
/* add/remove chips */
162
 
extern int gpiochip_add(struct gpio_chip *chip);
163
 
extern int __must_check gpiochip_remove(struct gpio_chip *chip);
164
 
extern struct gpio_chip *gpiochip_find(void *data,
165
 
                                        int (*match)(struct gpio_chip *chip,
166
 
                                                     void *data));
167
 
 
 
54
/* caller holds gpio_lock *OR* gpio is marked as requested */
 
55
static inline struct gpio_chip *gpio_to_chip(unsigned gpio)
 
56
{
 
57
        return gpiod_to_chip(gpio_to_desc(gpio));
 
58
}
168
59
 
169
60
/* Always use the library code for GPIO management calls,
170
61
 * or when sleeping may be involved.
172
63
extern int gpio_request(unsigned gpio, const char *label);
173
64
extern void gpio_free(unsigned gpio);
174
65
 
175
 
extern int gpio_direction_input(unsigned gpio);
176
 
extern int gpio_direction_output(unsigned gpio, int value);
177
 
 
178
 
extern int gpio_set_debounce(unsigned gpio, unsigned debounce);
179
 
 
180
 
extern int gpio_get_value_cansleep(unsigned gpio);
181
 
extern void gpio_set_value_cansleep(unsigned gpio, int value);
 
66
static inline int gpio_direction_input(unsigned gpio)
 
67
{
 
68
        return gpiod_direction_input(gpio_to_desc(gpio));
 
69
}
 
70
static inline int gpio_direction_output(unsigned gpio, int value)
 
71
{
 
72
        return gpiod_direction_output(gpio_to_desc(gpio), value);
 
73
}
 
74
 
 
75
static inline int gpio_set_debounce(unsigned gpio, unsigned debounce)
 
76
{
 
77
        return gpiod_set_debounce(gpio_to_desc(gpio), debounce);
 
78
}
 
79
 
 
80
static inline int gpio_get_value_cansleep(unsigned gpio)
 
81
{
 
82
        return gpiod_get_raw_value_cansleep(gpio_to_desc(gpio));
 
83
}
 
84
static inline void gpio_set_value_cansleep(unsigned gpio, int value)
 
85
{
 
86
        return gpiod_set_raw_value_cansleep(gpio_to_desc(gpio), value);
 
87
}
182
88
 
183
89
 
184
90
/* A platform's <asm/gpio.h> code may want to inline the I/O calls when
185
91
 * the GPIO is constant and refers to some always-present controller,
186
92
 * giving direct access to chip registers and tight bitbanging loops.
187
93
 */
188
 
extern int __gpio_get_value(unsigned gpio);
189
 
extern void __gpio_set_value(unsigned gpio, int value);
190
 
 
191
 
extern int __gpio_cansleep(unsigned gpio);
192
 
 
193
 
extern int __gpio_to_irq(unsigned gpio);
 
94
static inline int __gpio_get_value(unsigned gpio)
 
95
{
 
96
        return gpiod_get_raw_value(gpio_to_desc(gpio));
 
97
}
 
98
static inline void __gpio_set_value(unsigned gpio, int value)
 
99
{
 
100
        return gpiod_set_raw_value(gpio_to_desc(gpio), value);
 
101
}
 
102
 
 
103
static inline int __gpio_cansleep(unsigned gpio)
 
104
{
 
105
        return gpiod_cansleep(gpio_to_desc(gpio));
 
106
}
 
107
 
 
108
static inline int __gpio_to_irq(unsigned gpio)
 
109
{
 
110
        return gpiod_to_irq(gpio_to_desc(gpio));
 
111
}
 
112
 
 
113
extern int gpio_lock_as_irq(struct gpio_chip *chip, unsigned int offset);
 
114
extern void gpio_unlock_as_irq(struct gpio_chip *chip, unsigned int offset);
194
115
 
195
116
extern int gpio_request_one(unsigned gpio, unsigned long flags, const char *label);
196
117
extern int gpio_request_array(const struct gpio *array, size_t num);
197
118
extern void gpio_free_array(const struct gpio *array, size_t num);
198
119
 
199
 
#ifdef CONFIG_GPIO_SYSFS
200
 
 
201
120
/*
202
121
 * A sysfs interface can be exported by individual drivers if they want,
203
122
 * but more typically is configured entirely from userspace.
204
123
 */
205
 
extern int gpio_export(unsigned gpio, bool direction_may_change);
206
 
extern int gpio_export_link(struct device *dev, const char *name,
207
 
                        unsigned gpio);
208
 
extern int gpio_sysfs_set_active_low(unsigned gpio, int value);
209
 
extern void gpio_unexport(unsigned gpio);
210
 
 
211
 
#endif  /* CONFIG_GPIO_SYSFS */
 
124
static inline int gpio_export(unsigned gpio, bool direction_may_change)
 
125
{
 
126
        return gpiod_export(gpio_to_desc(gpio), direction_may_change);
 
127
}
 
128
 
 
129
static inline int gpio_export_link(struct device *dev, const char *name,
 
130
                                   unsigned gpio)
 
131
{
 
132
        return gpiod_export_link(dev, name, gpio_to_desc(gpio));
 
133
}
 
134
 
 
135
static inline int gpio_sysfs_set_active_low(unsigned gpio, int value)
 
136
{
 
137
        return gpiod_sysfs_set_active_low(gpio_to_desc(gpio), value);
 
138
}
 
139
 
 
140
static inline void gpio_unexport(unsigned gpio)
 
141
{
 
142
        gpiod_unexport(gpio_to_desc(gpio));
 
143
}
212
144
 
213
145
#ifdef CONFIG_PINCTRL
214
146
 
228
160
int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
229
161
                           unsigned int gpio_offset, unsigned int pin_offset,
230
162
                           unsigned int npins);
 
163
int gpiochip_add_pingroup_range(struct gpio_chip *chip,
 
164
                        struct pinctrl_dev *pctldev,
 
165
                        unsigned int gpio_offset, const char *pin_group);
231
166
void gpiochip_remove_pin_ranges(struct gpio_chip *chip);
232
167
 
233
168
#else
239
174
{
240
175
        return 0;
241
176
}
 
177
static inline int
 
178
gpiochip_add_pingroup_range(struct gpio_chip *chip,
 
179
                        struct pinctrl_dev *pctldev,
 
180
                        unsigned int gpio_offset, const char *pin_group)
 
181
{
 
182
        return 0;
 
183
}
242
184
 
243
185
static inline void
244
186
gpiochip_remove_pin_ranges(struct gpio_chip *chip)
278
220
 
279
221
#endif /* !CONFIG_GPIOLIB */
280
222
 
281
 
#ifndef CONFIG_GPIO_SYSFS
282
 
 
283
 
struct device;
284
 
 
285
 
/* sysfs support is only available with gpiolib, where it's optional */
286
 
 
287
 
static inline int gpio_export(unsigned gpio, bool direction_may_change)
288
 
{
289
 
        return -ENOSYS;
290
 
}
291
 
 
292
 
static inline int gpio_export_link(struct device *dev, const char *name,
293
 
                                unsigned gpio)
294
 
{
295
 
        return -ENOSYS;
296
 
}
297
 
 
298
 
static inline int gpio_sysfs_set_active_low(unsigned gpio, int value)
299
 
{
300
 
        return -ENOSYS;
301
 
}
302
 
 
303
 
static inline void gpio_unexport(unsigned gpio)
304
 
{
305
 
}
306
 
#endif  /* CONFIG_GPIO_SYSFS */
307
 
 
308
223
#endif /* _ASM_GENERIC_GPIO_H */