diff options
author | Alexandre Courbot <acourbot@nvidia.com> | 2013-10-17 13:21:36 -0400 |
---|---|---|
committer | Linus Walleij <linus.walleij@linaro.org> | 2013-10-19 17:24:45 -0400 |
commit | 79a9becda8940deb2274b5aa4577c86d52ee7ecb (patch) | |
tree | 2e10b344abcf76446ff97855d280fe9b7fb34ef0 /include/linux/gpio | |
parent | b41fb43911b4cb864812adec88d028cc6219f23e (diff) |
gpiolib: export descriptor-based GPIO interface
This patch exports the gpiod_* family of API functions, a safer
alternative to the legacy GPIO interface. Differences between the gpiod
and legacy gpio APIs are:
- gpio works with integers, whereas gpiod operates on opaque handlers
which cannot be forged or used before proper acquisition
- gpiod get/set functions are aware of the active low state of a GPIO
- gpio consumers should now include <linux/gpio/consumer.h> to access
the new interface, whereas chips drivers will use
<linux/gpio/driver.h>
The legacy gpio API is now built as inline functions on top of gpiod.
Signed-off-by: Alexandre Courbot <acourbot@nvidia.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
Diffstat (limited to 'include/linux/gpio')
-rw-r--r-- | include/linux/gpio/consumer.h | 238 | ||||
-rw-r--r-- | include/linux/gpio/driver.h | 127 |
2 files changed, 365 insertions, 0 deletions
diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h new file mode 100644 index 000000000000..2088eb50421c --- /dev/null +++ b/include/linux/gpio/consumer.h | |||
@@ -0,0 +1,238 @@ | |||
1 | #ifndef __LINUX_GPIO_CONSUMER_H | ||
2 | #define __LINUX_GPIO_CONSUMER_H | ||
3 | |||
4 | #include <linux/err.h> | ||
5 | #include <linux/kernel.h> | ||
6 | |||
7 | #ifdef CONFIG_GPIOLIB | ||
8 | |||
9 | struct device; | ||
10 | struct gpio_chip; | ||
11 | |||
12 | /** | ||
13 | * Opaque descriptor for a GPIO. These are obtained using gpiod_get() and are | ||
14 | * preferable to the old integer-based handles. | ||
15 | * | ||
16 | * Contrary to integers, a pointer to a gpio_desc is guaranteed to be valid | ||
17 | * until the GPIO is released. | ||
18 | */ | ||
19 | struct gpio_desc; | ||
20 | |||
21 | int gpiod_get_direction(const struct gpio_desc *desc); | ||
22 | int gpiod_direction_input(struct gpio_desc *desc); | ||
23 | int gpiod_direction_output(struct gpio_desc *desc, int value); | ||
24 | |||
25 | /* Value get/set from non-sleeping context */ | ||
26 | int gpiod_get_value(const struct gpio_desc *desc); | ||
27 | void gpiod_set_value(struct gpio_desc *desc, int value); | ||
28 | int gpiod_get_raw_value(const struct gpio_desc *desc); | ||
29 | void gpiod_set_raw_value(struct gpio_desc *desc, int value); | ||
30 | |||
31 | /* Value get/set from sleeping context */ | ||
32 | int gpiod_get_value_cansleep(const struct gpio_desc *desc); | ||
33 | void gpiod_set_value_cansleep(struct gpio_desc *desc, int value); | ||
34 | int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc); | ||
35 | void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value); | ||
36 | |||
37 | int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce); | ||
38 | |||
39 | int gpiod_is_active_low(const struct gpio_desc *desc); | ||
40 | int gpiod_cansleep(const struct gpio_desc *desc); | ||
41 | |||
42 | int gpiod_to_irq(const struct gpio_desc *desc); | ||
43 | |||
44 | /* Convert between the old gpio_ and new gpiod_ interfaces */ | ||
45 | struct gpio_desc *gpio_to_desc(unsigned gpio); | ||
46 | int desc_to_gpio(const struct gpio_desc *desc); | ||
47 | struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc); | ||
48 | |||
49 | #else /* CONFIG_GPIOLIB */ | ||
50 | |||
51 | static inline struct gpio_desc *__must_check gpiod_get(struct device *dev, | ||
52 | const char *con_id) | ||
53 | { | ||
54 | return ERR_PTR(-ENOSYS); | ||
55 | } | ||
56 | static inline struct gpio_desc *__must_check gpiod_get_index(struct device *dev, | ||
57 | const char *con_id, | ||
58 | unsigned int idx) | ||
59 | { | ||
60 | return ERR_PTR(-ENOSYS); | ||
61 | } | ||
62 | static inline void gpiod_put(struct gpio_desc *desc) | ||
63 | { | ||
64 | might_sleep(); | ||
65 | |||
66 | /* GPIO can never have been requested */ | ||
67 | WARN_ON(1); | ||
68 | } | ||
69 | |||
70 | static inline struct gpio_desc *__must_check devm_gpiod_get(struct device *dev, | ||
71 | const char *con_id) | ||
72 | { | ||
73 | return ERR_PTR(-ENOSYS); | ||
74 | } | ||
75 | static inline | ||
76 | struct gpio_desc *__must_check devm_gpiod_get_index(struct device *dev, | ||
77 | const char *con_id, | ||
78 | unsigned int idx) | ||
79 | { | ||
80 | return ERR_PTR(-ENOSYS); | ||
81 | } | ||
82 | static inline void devm_gpiod_put(struct device *dev, struct gpio_desc *desc) | ||
83 | { | ||
84 | might_sleep(); | ||
85 | |||
86 | /* GPIO can never have been requested */ | ||
87 | WARN_ON(1); | ||
88 | } | ||
89 | |||
90 | |||
91 | static inline int gpiod_get_direction(const struct gpio_desc *desc) | ||
92 | { | ||
93 | /* GPIO can never have been requested */ | ||
94 | WARN_ON(1); | ||
95 | return -ENOSYS; | ||
96 | } | ||
97 | static inline int gpiod_direction_input(struct gpio_desc *desc) | ||
98 | { | ||
99 | /* GPIO can never have been requested */ | ||
100 | WARN_ON(1); | ||
101 | return -ENOSYS; | ||
102 | } | ||
103 | static inline int gpiod_direction_output(struct gpio_desc *desc, int value) | ||
104 | { | ||
105 | /* GPIO can never have been requested */ | ||
106 | WARN_ON(1); | ||
107 | return -ENOSYS; | ||
108 | } | ||
109 | |||
110 | |||
111 | static inline int gpiod_get_value(const struct gpio_desc *desc) | ||
112 | { | ||
113 | /* GPIO can never have been requested */ | ||
114 | WARN_ON(1); | ||
115 | return 0; | ||
116 | } | ||
117 | static inline void gpiod_set_value(struct gpio_desc *desc, int value) | ||
118 | { | ||
119 | /* GPIO can never have been requested */ | ||
120 | WARN_ON(1); | ||
121 | } | ||
122 | static inline int gpiod_get_raw_value(const struct gpio_desc *desc) | ||
123 | { | ||
124 | /* GPIO can never have been requested */ | ||
125 | WARN_ON(1); | ||
126 | return 0; | ||
127 | } | ||
128 | static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value) | ||
129 | { | ||
130 | /* GPIO can never have been requested */ | ||
131 | WARN_ON(1); | ||
132 | } | ||
133 | |||
134 | static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc) | ||
135 | { | ||
136 | /* GPIO can never have been requested */ | ||
137 | WARN_ON(1); | ||
138 | return 0; | ||
139 | } | ||
140 | static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value) | ||
141 | { | ||
142 | /* GPIO can never have been requested */ | ||
143 | WARN_ON(1); | ||
144 | } | ||
145 | static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc) | ||
146 | { | ||
147 | /* GPIO can never have been requested */ | ||
148 | WARN_ON(1); | ||
149 | return 0; | ||
150 | } | ||
151 | static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, | ||
152 | int value) | ||
153 | { | ||
154 | /* GPIO can never have been requested */ | ||
155 | WARN_ON(1); | ||
156 | } | ||
157 | |||
158 | static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce) | ||
159 | { | ||
160 | /* GPIO can never have been requested */ | ||
161 | WARN_ON(1); | ||
162 | return -ENOSYS; | ||
163 | } | ||
164 | |||
165 | static inline int gpiod_is_active_low(const struct gpio_desc *desc) | ||
166 | { | ||
167 | /* GPIO can never have been requested */ | ||
168 | WARN_ON(1); | ||
169 | return 0; | ||
170 | } | ||
171 | static inline int gpiod_cansleep(const struct gpio_desc *desc) | ||
172 | { | ||
173 | /* GPIO can never have been requested */ | ||
174 | WARN_ON(1); | ||
175 | return 0; | ||
176 | } | ||
177 | |||
178 | static inline int gpiod_to_irq(const struct gpio_desc *desc) | ||
179 | { | ||
180 | /* GPIO can never have been requested */ | ||
181 | WARN_ON(1); | ||
182 | return -EINVAL; | ||
183 | } | ||
184 | |||
185 | static inline struct gpio_desc *gpio_to_desc(unsigned gpio) | ||
186 | { | ||
187 | return ERR_PTR(-EINVAL); | ||
188 | } | ||
189 | static inline int desc_to_gpio(const struct gpio_desc *desc) | ||
190 | { | ||
191 | /* GPIO can never have been requested */ | ||
192 | WARN_ON(1); | ||
193 | return -EINVAL; | ||
194 | } | ||
195 | static inline struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc) | ||
196 | { | ||
197 | /* GPIO can never have been requested */ | ||
198 | WARN_ON(1); | ||
199 | return ERR_PTR(-ENODEV); | ||
200 | } | ||
201 | |||
202 | |||
203 | #endif /* CONFIG_GPIOLIB */ | ||
204 | |||
205 | #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS) | ||
206 | |||
207 | int gpiod_export(struct gpio_desc *desc, bool direction_may_change); | ||
208 | int gpiod_export_link(struct device *dev, const char *name, | ||
209 | struct gpio_desc *desc); | ||
210 | int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value); | ||
211 | void gpiod_unexport(struct gpio_desc *desc); | ||
212 | |||
213 | #else /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */ | ||
214 | |||
215 | static inline int gpiod_export(struct gpio_desc *desc, | ||
216 | bool direction_may_change) | ||
217 | { | ||
218 | return -ENOSYS; | ||
219 | } | ||
220 | |||
221 | static inline int gpiod_export_link(struct device *dev, const char *name, | ||
222 | struct gpio_desc *desc) | ||
223 | { | ||
224 | return -ENOSYS; | ||
225 | } | ||
226 | |||
227 | static inline int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value) | ||
228 | { | ||
229 | return -ENOSYS; | ||
230 | } | ||
231 | |||
232 | static inline void gpiod_unexport(struct gpio_desc *desc) | ||
233 | { | ||
234 | } | ||
235 | |||
236 | #endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */ | ||
237 | |||
238 | #endif | ||
diff --git a/include/linux/gpio/driver.h b/include/linux/gpio/driver.h new file mode 100644 index 000000000000..5dc172c72f0f --- /dev/null +++ b/include/linux/gpio/driver.h | |||
@@ -0,0 +1,127 @@ | |||
1 | #ifndef __LINUX_GPIO_DRIVER_H | ||
2 | #define __LINUX_GPIO_DRIVER_H | ||
3 | |||
4 | #include <linux/types.h> | ||
5 | |||
6 | struct device; | ||
7 | struct gpio_desc; | ||
8 | |||
9 | /** | ||
10 | * struct gpio_chip - abstract a GPIO controller | ||
11 | * @label: for diagnostics | ||
12 | * @dev: optional device providing the GPIOs | ||
13 | * @owner: helps prevent removal of modules exporting active GPIOs | ||
14 | * @list: links gpio_chips together for traversal | ||
15 | * @request: optional hook for chip-specific activation, such as | ||
16 | * enabling module power and clock; may sleep | ||
17 | * @free: optional hook for chip-specific deactivation, such as | ||
18 | * disabling module power and clock; may sleep | ||
19 | * @get_direction: returns direction for signal "offset", 0=out, 1=in, | ||
20 | * (same as GPIOF_DIR_XXX), or negative error | ||
21 | * @direction_input: configures signal "offset" as input, or returns error | ||
22 | * @direction_output: configures signal "offset" as output, or returns error | ||
23 | * @get: returns value for signal "offset"; for output signals this | ||
24 | * returns either the value actually sensed, or zero | ||
25 | * @set: assigns output value for signal "offset" | ||
26 | * @set_debounce: optional hook for setting debounce time for specified gpio in | ||
27 | * interrupt triggered gpio chips | ||
28 | * @to_irq: optional hook supporting non-static gpio_to_irq() mappings; | ||
29 | * implementation may not sleep | ||
30 | * @dbg_show: optional routine to show contents in debugfs; default code | ||
31 | * will be used when this is omitted, but custom code can show extra | ||
32 | * state (such as pullup/pulldown configuration). | ||
33 | * @base: identifies the first GPIO number handled by this chip; or, if | ||
34 | * negative during registration, requests dynamic ID allocation. | ||
35 | * @ngpio: the number of GPIOs handled by this controller; the last GPIO | ||
36 | * handled is (base + ngpio - 1). | ||
37 | * @desc: array of ngpio descriptors. Private. | ||
38 | * @can_sleep: flag must be set iff get()/set() methods sleep, as they | ||
39 | * must while accessing GPIO expander chips over I2C or SPI | ||
40 | * @names: if set, must be an array of strings to use as alternative | ||
41 | * names for the GPIOs in this chip. Any entry in the array | ||
42 | * may be NULL if there is no alias for the GPIO, however the | ||
43 | * array must be @ngpio entries long. A name can include a single printk | ||
44 | * format specifier for an unsigned int. It is substituted by the actual | ||
45 | * number of the gpio. | ||
46 | * | ||
47 | * A gpio_chip can help platforms abstract various sources of GPIOs so | ||
48 | * they can all be accessed through a common programing interface. | ||
49 | * Example sources would be SOC controllers, FPGAs, multifunction | ||
50 | * chips, dedicated GPIO expanders, and so on. | ||
51 | * | ||
52 | * Each chip controls a number of signals, identified in method calls | ||
53 | * by "offset" values in the range 0..(@ngpio - 1). When those signals | ||
54 | * are referenced through calls like gpio_get_value(gpio), the offset | ||
55 | * is calculated by subtracting @base from the gpio number. | ||
56 | */ | ||
57 | struct gpio_chip { | ||
58 | const char *label; | ||
59 | struct device *dev; | ||
60 | struct module *owner; | ||
61 | struct list_head list; | ||
62 | |||
63 | int (*request)(struct gpio_chip *chip, | ||
64 | unsigned offset); | ||
65 | void (*free)(struct gpio_chip *chip, | ||
66 | unsigned offset); | ||
67 | int (*get_direction)(struct gpio_chip *chip, | ||
68 | unsigned offset); | ||
69 | int (*direction_input)(struct gpio_chip *chip, | ||
70 | unsigned offset); | ||
71 | int (*direction_output)(struct gpio_chip *chip, | ||
72 | unsigned offset, int value); | ||
73 | int (*get)(struct gpio_chip *chip, | ||
74 | unsigned offset); | ||
75 | void (*set)(struct gpio_chip *chip, | ||
76 | unsigned offset, int value); | ||
77 | int (*set_debounce)(struct gpio_chip *chip, | ||
78 | unsigned offset, | ||
79 | unsigned debounce); | ||
80 | |||
81 | int (*to_irq)(struct gpio_chip *chip, | ||
82 | unsigned offset); | ||
83 | |||
84 | void (*dbg_show)(struct seq_file *s, | ||
85 | struct gpio_chip *chip); | ||
86 | int base; | ||
87 | u16 ngpio; | ||
88 | struct gpio_desc *desc; | ||
89 | const char *const *names; | ||
90 | unsigned can_sleep:1; | ||
91 | unsigned exported:1; | ||
92 | |||
93 | #if defined(CONFIG_OF_GPIO) | ||
94 | /* | ||
95 | * If CONFIG_OF is enabled, then all GPIO controllers described in the | ||
96 | * device tree automatically may have an OF translation | ||
97 | */ | ||
98 | struct device_node *of_node; | ||
99 | int of_gpio_n_cells; | ||
100 | int (*of_xlate)(struct gpio_chip *gc, | ||
101 | const struct of_phandle_args *gpiospec, u32 *flags); | ||
102 | #endif | ||
103 | #ifdef CONFIG_PINCTRL | ||
104 | /* | ||
105 | * If CONFIG_PINCTRL is enabled, then gpio controllers can optionally | ||
106 | * describe the actual pin range which they serve in an SoC. This | ||
107 | * information would be used by pinctrl subsystem to configure | ||
108 | * corresponding pins for gpio usage. | ||
109 | */ | ||
110 | struct list_head pin_ranges; | ||
111 | #endif | ||
112 | }; | ||
113 | |||
114 | extern const char *gpiochip_is_requested(struct gpio_chip *chip, | ||
115 | unsigned offset); | ||
116 | |||
117 | /* add/remove chips */ | ||
118 | extern int gpiochip_add(struct gpio_chip *chip); | ||
119 | extern int __must_check gpiochip_remove(struct gpio_chip *chip); | ||
120 | extern struct gpio_chip *gpiochip_find(void *data, | ||
121 | int (*match)(struct gpio_chip *chip, void *data)); | ||
122 | |||
123 | /* lock/unlock as IRQ */ | ||
124 | int gpiod_lock_as_irq(struct gpio_desc *desc); | ||
125 | void gpiod_unlock_as_irq(struct gpio_desc *desc); | ||
126 | |||
127 | #endif | ||