5f72a49d1aa334d0be9f1f5cc131efcd16c5413e
[sfrench/cifs-2.6.git] / include / linux / gpio / consumer.h
1 #ifndef __LINUX_GPIO_CONSUMER_H
2 #define __LINUX_GPIO_CONSUMER_H
3
4 #include <linux/bug.h>
5 #include <linux/err.h>
6 #include <linux/kernel.h>
7
8 struct device;
9
10 /**
11  * Opaque descriptor for a GPIO. These are obtained using gpiod_get() and are
12  * preferable to the old integer-based handles.
13  *
14  * Contrary to integers, a pointer to a gpio_desc is guaranteed to be valid
15  * until the GPIO is released.
16  */
17 struct gpio_desc;
18
19 /**
20  * Struct containing an array of descriptors that can be obtained using
21  * gpiod_get_array().
22  */
23 struct gpio_descs {
24         unsigned int ndescs;
25         struct gpio_desc *desc[];
26 };
27
28 #define GPIOD_FLAGS_BIT_DIR_SET         BIT(0)
29 #define GPIOD_FLAGS_BIT_DIR_OUT         BIT(1)
30 #define GPIOD_FLAGS_BIT_DIR_VAL         BIT(2)
31 #define GPIOD_FLAGS_BIT_OPEN_DRAIN      BIT(3)
32
33 /**
34  * Optional flags that can be passed to one of gpiod_* to configure direction
35  * and output value. These values cannot be OR'd.
36  */
37 enum gpiod_flags {
38         GPIOD_ASIS      = 0,
39         GPIOD_IN        = GPIOD_FLAGS_BIT_DIR_SET,
40         GPIOD_OUT_LOW   = GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT,
41         GPIOD_OUT_HIGH  = GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT |
42                           GPIOD_FLAGS_BIT_DIR_VAL,
43         GPIOD_OUT_LOW_OPEN_DRAIN = GPIOD_FLAGS_BIT_DIR_SET |
44                           GPIOD_FLAGS_BIT_DIR_OUT | GPIOD_FLAGS_BIT_OPEN_DRAIN,
45         GPIOD_OUT_HIGH_OPEN_DRAIN = GPIOD_FLAGS_BIT_DIR_SET |
46                           GPIOD_FLAGS_BIT_DIR_OUT | GPIOD_FLAGS_BIT_DIR_VAL |
47                           GPIOD_FLAGS_BIT_OPEN_DRAIN,
48 };
49
50 #ifdef CONFIG_GPIOLIB
51
52 /* Return the number of GPIOs associated with a device / function */
53 int gpiod_count(struct device *dev, const char *con_id);
54
55 /* Acquire and dispose GPIOs */
56 struct gpio_desc *__must_check gpiod_get(struct device *dev,
57                                          const char *con_id,
58                                          enum gpiod_flags flags);
59 struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
60                                                const char *con_id,
61                                                unsigned int idx,
62                                                enum gpiod_flags flags);
63 struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
64                                                   const char *con_id,
65                                                   enum gpiod_flags flags);
66 struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
67                                                         const char *con_id,
68                                                         unsigned int index,
69                                                         enum gpiod_flags flags);
70 struct gpio_descs *__must_check gpiod_get_array(struct device *dev,
71                                                 const char *con_id,
72                                                 enum gpiod_flags flags);
73 struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev,
74                                                         const char *con_id,
75                                                         enum gpiod_flags flags);
76 void gpiod_put(struct gpio_desc *desc);
77 void gpiod_put_array(struct gpio_descs *descs);
78
79 struct gpio_desc *__must_check devm_gpiod_get(struct device *dev,
80                                               const char *con_id,
81                                               enum gpiod_flags flags);
82 struct gpio_desc *__must_check devm_gpiod_get_index(struct device *dev,
83                                                     const char *con_id,
84                                                     unsigned int idx,
85                                                     enum gpiod_flags flags);
86 struct gpio_desc *__must_check devm_gpiod_get_optional(struct device *dev,
87                                                        const char *con_id,
88                                                        enum gpiod_flags flags);
89 struct gpio_desc *__must_check
90 devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
91                               unsigned int index, enum gpiod_flags flags);
92 struct gpio_descs *__must_check devm_gpiod_get_array(struct device *dev,
93                                                      const char *con_id,
94                                                      enum gpiod_flags flags);
95 struct gpio_descs *__must_check
96 devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
97                               enum gpiod_flags flags);
98 void devm_gpiod_put(struct device *dev, struct gpio_desc *desc);
99 void devm_gpiod_put_array(struct device *dev, struct gpio_descs *descs);
100
101 int gpiod_get_direction(struct gpio_desc *desc);
102 int gpiod_direction_input(struct gpio_desc *desc);
103 int gpiod_direction_output(struct gpio_desc *desc, int value);
104 int gpiod_direction_output_raw(struct gpio_desc *desc, int value);
105
106 /* Value get/set from non-sleeping context */
107 int gpiod_get_value(const struct gpio_desc *desc);
108 void gpiod_set_value(struct gpio_desc *desc, int value);
109 void gpiod_set_array_value(unsigned int array_size,
110                            struct gpio_desc **desc_array, int *value_array);
111 int gpiod_get_raw_value(const struct gpio_desc *desc);
112 void gpiod_set_raw_value(struct gpio_desc *desc, int value);
113 void gpiod_set_raw_array_value(unsigned int array_size,
114                                struct gpio_desc **desc_array,
115                                int *value_array);
116
117 /* Value get/set from sleeping context */
118 int gpiod_get_value_cansleep(const struct gpio_desc *desc);
119 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
120 void gpiod_set_array_value_cansleep(unsigned int array_size,
121                                     struct gpio_desc **desc_array,
122                                     int *value_array);
123 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
124 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
125 void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
126                                         struct gpio_desc **desc_array,
127                                         int *value_array);
128
129 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
130
131 int gpiod_is_active_low(const struct gpio_desc *desc);
132 int gpiod_cansleep(const struct gpio_desc *desc);
133
134 int gpiod_to_irq(const struct gpio_desc *desc);
135
136 /* Convert between the old gpio_ and new gpiod_ interfaces */
137 struct gpio_desc *gpio_to_desc(unsigned gpio);
138 int desc_to_gpio(const struct gpio_desc *desc);
139
140 /* Child properties interface */
141 struct fwnode_handle;
142
143 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
144                                          const char *propname, int index,
145                                          enum gpiod_flags dflags,
146                                          const char *label);
147 struct gpio_desc *devm_fwnode_get_index_gpiod_from_child(struct device *dev,
148                                                 const char *con_id, int index,
149                                                 struct fwnode_handle *child,
150                                                 enum gpiod_flags flags,
151                                                 const char *label);
152
153 #else /* CONFIG_GPIOLIB */
154
155 static inline int gpiod_count(struct device *dev, const char *con_id)
156 {
157         return 0;
158 }
159
160 static inline struct gpio_desc *__must_check gpiod_get(struct device *dev,
161                                                        const char *con_id,
162                                                        enum gpiod_flags flags)
163 {
164         return ERR_PTR(-ENOSYS);
165 }
166 static inline struct gpio_desc *__must_check
167 gpiod_get_index(struct device *dev,
168                 const char *con_id,
169                 unsigned int idx,
170                 enum gpiod_flags flags)
171 {
172         return ERR_PTR(-ENOSYS);
173 }
174
175 static inline struct gpio_desc *__must_check
176 gpiod_get_optional(struct device *dev, const char *con_id,
177                    enum gpiod_flags flags)
178 {
179         return NULL;
180 }
181
182 static inline struct gpio_desc *__must_check
183 gpiod_get_index_optional(struct device *dev, const char *con_id,
184                          unsigned int index, enum gpiod_flags flags)
185 {
186         return NULL;
187 }
188
189 static inline struct gpio_descs *__must_check
190 gpiod_get_array(struct device *dev, const char *con_id,
191                 enum gpiod_flags flags)
192 {
193         return ERR_PTR(-ENOSYS);
194 }
195
196 static inline struct gpio_descs *__must_check
197 gpiod_get_array_optional(struct device *dev, const char *con_id,
198                          enum gpiod_flags flags)
199 {
200         return NULL;
201 }
202
203 static inline void gpiod_put(struct gpio_desc *desc)
204 {
205         might_sleep();
206
207         /* GPIO can never have been requested */
208         WARN_ON(1);
209 }
210
211 static inline void gpiod_put_array(struct gpio_descs *descs)
212 {
213         might_sleep();
214
215         /* GPIO can never have been requested */
216         WARN_ON(1);
217 }
218
219 static inline struct gpio_desc *__must_check
220 devm_gpiod_get(struct device *dev,
221                  const char *con_id,
222                  enum gpiod_flags flags)
223 {
224         return ERR_PTR(-ENOSYS);
225 }
226 static inline
227 struct gpio_desc *__must_check
228 devm_gpiod_get_index(struct device *dev,
229                        const char *con_id,
230                        unsigned int idx,
231                        enum gpiod_flags flags)
232 {
233         return ERR_PTR(-ENOSYS);
234 }
235
236 static inline struct gpio_desc *__must_check
237 devm_gpiod_get_optional(struct device *dev, const char *con_id,
238                           enum gpiod_flags flags)
239 {
240         return NULL;
241 }
242
243 static inline struct gpio_desc *__must_check
244 devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
245                                 unsigned int index, enum gpiod_flags flags)
246 {
247         return NULL;
248 }
249
250 static inline struct gpio_descs *__must_check
251 devm_gpiod_get_array(struct device *dev, const char *con_id,
252                      enum gpiod_flags flags)
253 {
254         return ERR_PTR(-ENOSYS);
255 }
256
257 static inline struct gpio_descs *__must_check
258 devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
259                               enum gpiod_flags flags)
260 {
261         return NULL;
262 }
263
264 static inline void devm_gpiod_put(struct device *dev, struct gpio_desc *desc)
265 {
266         might_sleep();
267
268         /* GPIO can never have been requested */
269         WARN_ON(1);
270 }
271
272 static inline void devm_gpiod_put_array(struct device *dev,
273                                         struct gpio_descs *descs)
274 {
275         might_sleep();
276
277         /* GPIO can never have been requested */
278         WARN_ON(1);
279 }
280
281
282 static inline int gpiod_get_direction(const struct gpio_desc *desc)
283 {
284         /* GPIO can never have been requested */
285         WARN_ON(1);
286         return -ENOSYS;
287 }
288 static inline int gpiod_direction_input(struct gpio_desc *desc)
289 {
290         /* GPIO can never have been requested */
291         WARN_ON(1);
292         return -ENOSYS;
293 }
294 static inline int gpiod_direction_output(struct gpio_desc *desc, int value)
295 {
296         /* GPIO can never have been requested */
297         WARN_ON(1);
298         return -ENOSYS;
299 }
300 static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
301 {
302         /* GPIO can never have been requested */
303         WARN_ON(1);
304         return -ENOSYS;
305 }
306
307
308 static inline int gpiod_get_value(const struct gpio_desc *desc)
309 {
310         /* GPIO can never have been requested */
311         WARN_ON(1);
312         return 0;
313 }
314 static inline void gpiod_set_value(struct gpio_desc *desc, int value)
315 {
316         /* GPIO can never have been requested */
317         WARN_ON(1);
318 }
319 static inline void gpiod_set_array_value(unsigned int array_size,
320                                          struct gpio_desc **desc_array,
321                                          int *value_array)
322 {
323         /* GPIO can never have been requested */
324         WARN_ON(1);
325 }
326 static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
327 {
328         /* GPIO can never have been requested */
329         WARN_ON(1);
330         return 0;
331 }
332 static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
333 {
334         /* GPIO can never have been requested */
335         WARN_ON(1);
336 }
337 static inline void gpiod_set_raw_array_value(unsigned int array_size,
338                                              struct gpio_desc **desc_array,
339                                              int *value_array)
340 {
341         /* GPIO can never have been requested */
342         WARN_ON(1);
343 }
344
345 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
346 {
347         /* GPIO can never have been requested */
348         WARN_ON(1);
349         return 0;
350 }
351 static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
352 {
353         /* GPIO can never have been requested */
354         WARN_ON(1);
355 }
356 static inline void gpiod_set_array_value_cansleep(unsigned int array_size,
357                                             struct gpio_desc **desc_array,
358                                             int *value_array)
359 {
360         /* GPIO can never have been requested */
361         WARN_ON(1);
362 }
363 static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
364 {
365         /* GPIO can never have been requested */
366         WARN_ON(1);
367         return 0;
368 }
369 static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
370                                                 int value)
371 {
372         /* GPIO can never have been requested */
373         WARN_ON(1);
374 }
375 static inline void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
376                                                 struct gpio_desc **desc_array,
377                                                 int *value_array)
378 {
379         /* GPIO can never have been requested */
380         WARN_ON(1);
381 }
382
383 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
384 {
385         /* GPIO can never have been requested */
386         WARN_ON(1);
387         return -ENOSYS;
388 }
389
390 static inline int gpiod_is_active_low(const struct gpio_desc *desc)
391 {
392         /* GPIO can never have been requested */
393         WARN_ON(1);
394         return 0;
395 }
396 static inline int gpiod_cansleep(const struct gpio_desc *desc)
397 {
398         /* GPIO can never have been requested */
399         WARN_ON(1);
400         return 0;
401 }
402
403 static inline int gpiod_to_irq(const struct gpio_desc *desc)
404 {
405         /* GPIO can never have been requested */
406         WARN_ON(1);
407         return -EINVAL;
408 }
409
410 static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
411 {
412         return ERR_PTR(-EINVAL);
413 }
414
415 static inline int desc_to_gpio(const struct gpio_desc *desc)
416 {
417         /* GPIO can never have been requested */
418         WARN_ON(1);
419         return -EINVAL;
420 }
421
422 /* Child properties interface */
423 struct fwnode_handle;
424
425 static inline
426 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
427                                          const char *propname, int index,
428                                          enum gpiod_flags dflags,
429                                          const char *label)
430 {
431         return ERR_PTR(-ENOSYS);
432 }
433
434 static inline
435 struct gpio_desc *devm_fwnode_get_index_gpiod_from_child(struct device *dev,
436                                                 const char *con_id, int index,
437                                                 struct fwnode_handle *child,
438                                                 enum gpiod_flags flags,
439                                                 const char *label)
440 {
441         return ERR_PTR(-ENOSYS);
442 }
443
444 #endif /* CONFIG_GPIOLIB */
445
446 static inline
447 struct gpio_desc *devm_fwnode_get_gpiod_from_child(struct device *dev,
448                                                    const char *con_id,
449                                                    struct fwnode_handle *child,
450                                                    enum gpiod_flags flags,
451                                                    const char *label)
452 {
453         return devm_fwnode_get_index_gpiod_from_child(dev, con_id, 0, child,
454                                                       flags, label);
455 }
456
457 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS)
458
459 int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
460 int gpiod_export_link(struct device *dev, const char *name,
461                       struct gpio_desc *desc);
462 void gpiod_unexport(struct gpio_desc *desc);
463
464 #else  /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
465
466 static inline int gpiod_export(struct gpio_desc *desc,
467                                bool direction_may_change)
468 {
469         return -ENOSYS;
470 }
471
472 static inline int gpiod_export_link(struct device *dev, const char *name,
473                                     struct gpio_desc *desc)
474 {
475         return -ENOSYS;
476 }
477
478 static inline void gpiod_unexport(struct gpio_desc *desc)
479 {
480 }
481
482 #endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
483
484 #endif