~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/gpio/consumer.h

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SPDX-License-Identifier: GPL-2.0 */
  2 #ifndef __LINUX_GPIO_CONSUMER_H
  3 #define __LINUX_GPIO_CONSUMER_H
  4 
  5 #include <linux/bug.h>
  6 #include <linux/err.h>
  7 #include <linux/kernel.h>
  8 
  9 struct device;
 10 
 11 /**
 12  * Opaque descriptor for a GPIO. These are obtained using gpiod_get() and are
 13  * preferable to the old integer-based handles.
 14  *
 15  * Contrary to integers, a pointer to a gpio_desc is guaranteed to be valid
 16  * until the GPIO is released.
 17  */
 18 struct gpio_desc;
 19 
 20 /**
 21  * Opaque descriptor for a structure of GPIO array attributes.  This structure
 22  * is attached to struct gpiod_descs obtained from gpiod_get_array() and can be
 23  * passed back to get/set array functions in order to activate fast processing
 24  * path if applicable.
 25  */
 26 struct gpio_array;
 27 
 28 /**
 29  * Struct containing an array of descriptors that can be obtained using
 30  * gpiod_get_array().
 31  */
 32 struct gpio_descs {
 33         struct gpio_array *info;
 34         unsigned int ndescs;
 35         struct gpio_desc *desc[];
 36 };
 37 
 38 #define GPIOD_FLAGS_BIT_DIR_SET         BIT(0)
 39 #define GPIOD_FLAGS_BIT_DIR_OUT         BIT(1)
 40 #define GPIOD_FLAGS_BIT_DIR_VAL         BIT(2)
 41 #define GPIOD_FLAGS_BIT_OPEN_DRAIN      BIT(3)
 42 #define GPIOD_FLAGS_BIT_NONEXCLUSIVE    BIT(4)
 43 
 44 /**
 45  * Optional flags that can be passed to one of gpiod_* to configure direction
 46  * and output value. These values cannot be OR'd.
 47  */
 48 enum gpiod_flags {
 49         GPIOD_ASIS      = 0,
 50         GPIOD_IN        = GPIOD_FLAGS_BIT_DIR_SET,
 51         GPIOD_OUT_LOW   = GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT,
 52         GPIOD_OUT_HIGH  = GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT |
 53                           GPIOD_FLAGS_BIT_DIR_VAL,
 54         GPIOD_OUT_LOW_OPEN_DRAIN = GPIOD_OUT_LOW | GPIOD_FLAGS_BIT_OPEN_DRAIN,
 55         GPIOD_OUT_HIGH_OPEN_DRAIN = GPIOD_OUT_HIGH | GPIOD_FLAGS_BIT_OPEN_DRAIN,
 56 };
 57 
 58 #ifdef CONFIG_GPIOLIB
 59 
 60 /* Return the number of GPIOs associated with a device / function */
 61 int gpiod_count(struct device *dev, const char *con_id);
 62 
 63 /* Acquire and dispose GPIOs */
 64 struct gpio_desc *__must_check gpiod_get(struct device *dev,
 65                                          const char *con_id,
 66                                          enum gpiod_flags flags);
 67 struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
 68                                                const char *con_id,
 69                                                unsigned int idx,
 70                                                enum gpiod_flags flags);
 71 struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
 72                                                   const char *con_id,
 73                                                   enum gpiod_flags flags);
 74 struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
 75                                                         const char *con_id,
 76                                                         unsigned int index,
 77                                                         enum gpiod_flags flags);
 78 struct gpio_descs *__must_check gpiod_get_array(struct device *dev,
 79                                                 const char *con_id,
 80                                                 enum gpiod_flags flags);
 81 struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev,
 82                                                         const char *con_id,
 83                                                         enum gpiod_flags flags);
 84 void gpiod_put(struct gpio_desc *desc);
 85 void gpiod_put_array(struct gpio_descs *descs);
 86 
 87 struct gpio_desc *__must_check devm_gpiod_get(struct device *dev,
 88                                               const char *con_id,
 89                                               enum gpiod_flags flags);
 90 struct gpio_desc *__must_check devm_gpiod_get_index(struct device *dev,
 91                                                     const char *con_id,
 92                                                     unsigned int idx,
 93                                                     enum gpiod_flags flags);
 94 struct gpio_desc *__must_check devm_gpiod_get_optional(struct device *dev,
 95                                                        const char *con_id,
 96                                                        enum gpiod_flags flags);
 97 struct gpio_desc *__must_check
 98 devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
 99                               unsigned int index, enum gpiod_flags flags);
100 struct gpio_descs *__must_check devm_gpiod_get_array(struct device *dev,
101                                                      const char *con_id,
102                                                      enum gpiod_flags flags);
103 struct gpio_descs *__must_check
104 devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
105                               enum gpiod_flags flags);
106 void devm_gpiod_put(struct device *dev, struct gpio_desc *desc);
107 void devm_gpiod_unhinge(struct device *dev, struct gpio_desc *desc);
108 void devm_gpiod_put_array(struct device *dev, struct gpio_descs *descs);
109 
110 int gpiod_get_direction(struct gpio_desc *desc);
111 int gpiod_direction_input(struct gpio_desc *desc);
112 int gpiod_direction_output(struct gpio_desc *desc, int value);
113 int gpiod_direction_output_raw(struct gpio_desc *desc, int value);
114 
115 /* Value get/set from non-sleeping context */
116 int gpiod_get_value(const struct gpio_desc *desc);
117 int gpiod_get_array_value(unsigned int array_size,
118                           struct gpio_desc **desc_array,
119                           struct gpio_array *array_info,
120                           unsigned long *value_bitmap);
121 void gpiod_set_value(struct gpio_desc *desc, int value);
122 int gpiod_set_array_value(unsigned int array_size,
123                           struct gpio_desc **desc_array,
124                           struct gpio_array *array_info,
125                           unsigned long *value_bitmap);
126 int gpiod_get_raw_value(const struct gpio_desc *desc);
127 int gpiod_get_raw_array_value(unsigned int array_size,
128                               struct gpio_desc **desc_array,
129                               struct gpio_array *array_info,
130                               unsigned long *value_bitmap);
131 void gpiod_set_raw_value(struct gpio_desc *desc, int value);
132 int gpiod_set_raw_array_value(unsigned int array_size,
133                               struct gpio_desc **desc_array,
134                               struct gpio_array *array_info,
135                               unsigned long *value_bitmap);
136 
137 /* Value get/set from sleeping context */
138 int gpiod_get_value_cansleep(const struct gpio_desc *desc);
139 int gpiod_get_array_value_cansleep(unsigned int array_size,
140                                    struct gpio_desc **desc_array,
141                                    struct gpio_array *array_info,
142                                    unsigned long *value_bitmap);
143 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
144 int gpiod_set_array_value_cansleep(unsigned int array_size,
145                                    struct gpio_desc **desc_array,
146                                    struct gpio_array *array_info,
147                                    unsigned long *value_bitmap);
148 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
149 int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
150                                        struct gpio_desc **desc_array,
151                                        struct gpio_array *array_info,
152                                        unsigned long *value_bitmap);
153 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
154 int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
155                                        struct gpio_desc **desc_array,
156                                        struct gpio_array *array_info,
157                                        unsigned long *value_bitmap);
158 
159 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
160 int gpiod_set_transitory(struct gpio_desc *desc, bool transitory);
161 void gpiod_toggle_active_low(struct gpio_desc *desc);
162 
163 int gpiod_is_active_low(const struct gpio_desc *desc);
164 int gpiod_cansleep(const struct gpio_desc *desc);
165 
166 int gpiod_to_irq(const struct gpio_desc *desc);
167 int gpiod_set_consumer_name(struct gpio_desc *desc, const char *name);
168 
169 /* Convert between the old gpio_ and new gpiod_ interfaces */
170 struct gpio_desc *gpio_to_desc(unsigned gpio);
171 int desc_to_gpio(const struct gpio_desc *desc);
172 
173 /* Child properties interface */
174 struct fwnode_handle;
175 
176 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
177                                          const char *propname, int index,
178                                          enum gpiod_flags dflags,
179                                          const char *label);
180 struct gpio_desc *fwnode_gpiod_get_index(struct fwnode_handle *fwnode,
181                                          const char *con_id, int index,
182                                          enum gpiod_flags flags,
183                                          const char *label);
184 struct gpio_desc *devm_fwnode_gpiod_get_index(struct device *dev,
185                                               struct fwnode_handle *child,
186                                               const char *con_id, int index,
187                                               enum gpiod_flags flags,
188                                               const char *label);
189 
190 #else /* CONFIG_GPIOLIB */
191 
192 static inline int gpiod_count(struct device *dev, const char *con_id)
193 {
194         return 0;
195 }
196 
197 static inline struct gpio_desc *__must_check gpiod_get(struct device *dev,
198                                                        const char *con_id,
199                                                        enum gpiod_flags flags)
200 {
201         return ERR_PTR(-ENOSYS);
202 }
203 static inline struct gpio_desc *__must_check
204 gpiod_get_index(struct device *dev,
205                 const char *con_id,
206                 unsigned int idx,
207                 enum gpiod_flags flags)
208 {
209         return ERR_PTR(-ENOSYS);
210 }
211 
212 static inline struct gpio_desc *__must_check
213 gpiod_get_optional(struct device *dev, const char *con_id,
214                    enum gpiod_flags flags)
215 {
216         return NULL;
217 }
218 
219 static inline struct gpio_desc *__must_check
220 gpiod_get_index_optional(struct device *dev, const char *con_id,
221                          unsigned int index, enum gpiod_flags flags)
222 {
223         return NULL;
224 }
225 
226 static inline struct gpio_descs *__must_check
227 gpiod_get_array(struct device *dev, const char *con_id,
228                 enum gpiod_flags flags)
229 {
230         return ERR_PTR(-ENOSYS);
231 }
232 
233 static inline struct gpio_descs *__must_check
234 gpiod_get_array_optional(struct device *dev, const char *con_id,
235                          enum gpiod_flags flags)
236 {
237         return NULL;
238 }
239 
240 static inline void gpiod_put(struct gpio_desc *desc)
241 {
242         might_sleep();
243 
244         /* GPIO can never have been requested */
245         WARN_ON(desc);
246 }
247 
248 static inline void devm_gpiod_unhinge(struct device *dev,
249                                       struct gpio_desc *desc)
250 {
251         might_sleep();
252 
253         /* GPIO can never have been requested */
254         WARN_ON(desc);
255 }
256 
257 static inline void gpiod_put_array(struct gpio_descs *descs)
258 {
259         might_sleep();
260 
261         /* GPIO can never have been requested */
262         WARN_ON(descs);
263 }
264 
265 static inline struct gpio_desc *__must_check
266 devm_gpiod_get(struct device *dev,
267                  const char *con_id,
268                  enum gpiod_flags flags)
269 {
270         return ERR_PTR(-ENOSYS);
271 }
272 static inline
273 struct gpio_desc *__must_check
274 devm_gpiod_get_index(struct device *dev,
275                        const char *con_id,
276                        unsigned int idx,
277                        enum gpiod_flags flags)
278 {
279         return ERR_PTR(-ENOSYS);
280 }
281 
282 static inline struct gpio_desc *__must_check
283 devm_gpiod_get_optional(struct device *dev, const char *con_id,
284                           enum gpiod_flags flags)
285 {
286         return NULL;
287 }
288 
289 static inline struct gpio_desc *__must_check
290 devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
291                                 unsigned int index, enum gpiod_flags flags)
292 {
293         return NULL;
294 }
295 
296 static inline struct gpio_descs *__must_check
297 devm_gpiod_get_array(struct device *dev, const char *con_id,
298                      enum gpiod_flags flags)
299 {
300         return ERR_PTR(-ENOSYS);
301 }
302 
303 static inline struct gpio_descs *__must_check
304 devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
305                               enum gpiod_flags flags)
306 {
307         return NULL;
308 }
309 
310 static inline void devm_gpiod_put(struct device *dev, struct gpio_desc *desc)
311 {
312         might_sleep();
313 
314         /* GPIO can never have been requested */
315         WARN_ON(desc);
316 }
317 
318 static inline void devm_gpiod_put_array(struct device *dev,
319                                         struct gpio_descs *descs)
320 {
321         might_sleep();
322 
323         /* GPIO can never have been requested */
324         WARN_ON(descs);
325 }
326 
327 
328 static inline int gpiod_get_direction(const struct gpio_desc *desc)
329 {
330         /* GPIO can never have been requested */
331         WARN_ON(desc);
332         return -ENOSYS;
333 }
334 static inline int gpiod_direction_input(struct gpio_desc *desc)
335 {
336         /* GPIO can never have been requested */
337         WARN_ON(desc);
338         return -ENOSYS;
339 }
340 static inline int gpiod_direction_output(struct gpio_desc *desc, int value)
341 {
342         /* GPIO can never have been requested */
343         WARN_ON(desc);
344         return -ENOSYS;
345 }
346 static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
347 {
348         /* GPIO can never have been requested */
349         WARN_ON(desc);
350         return -ENOSYS;
351 }
352 
353 
354 static inline int gpiod_get_value(const struct gpio_desc *desc)
355 {
356         /* GPIO can never have been requested */
357         WARN_ON(desc);
358         return 0;
359 }
360 static inline int gpiod_get_array_value(unsigned int array_size,
361                                         struct gpio_desc **desc_array,
362                                         struct gpio_array *array_info,
363                                         unsigned long *value_bitmap)
364 {
365         /* GPIO can never have been requested */
366         WARN_ON(desc_array);
367         return 0;
368 }
369 static inline void gpiod_set_value(struct gpio_desc *desc, int value)
370 {
371         /* GPIO can never have been requested */
372         WARN_ON(desc);
373 }
374 static inline int gpiod_set_array_value(unsigned int array_size,
375                                         struct gpio_desc **desc_array,
376                                         struct gpio_array *array_info,
377                                         unsigned long *value_bitmap)
378 {
379         /* GPIO can never have been requested */
380         WARN_ON(desc_array);
381         return 0;
382 }
383 static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
384 {
385         /* GPIO can never have been requested */
386         WARN_ON(desc);
387         return 0;
388 }
389 static inline int gpiod_get_raw_array_value(unsigned int array_size,
390                                             struct gpio_desc **desc_array,
391                                             struct gpio_array *array_info,
392                                             unsigned long *value_bitmap)
393 {
394         /* GPIO can never have been requested */
395         WARN_ON(desc_array);
396         return 0;
397 }
398 static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
399 {
400         /* GPIO can never have been requested */
401         WARN_ON(desc);
402 }
403 static inline int gpiod_set_raw_array_value(unsigned int array_size,
404                                             struct gpio_desc **desc_array,
405                                             struct gpio_array *array_info,
406                                             unsigned long *value_bitmap)
407 {
408         /* GPIO can never have been requested */
409         WARN_ON(desc_array);
410         return 0;
411 }
412 
413 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
414 {
415         /* GPIO can never have been requested */
416         WARN_ON(desc);
417         return 0;
418 }
419 static inline int gpiod_get_array_value_cansleep(unsigned int array_size,
420                                      struct gpio_desc **desc_array,
421                                      struct gpio_array *array_info,
422                                      unsigned long *value_bitmap)
423 {
424         /* GPIO can never have been requested */
425         WARN_ON(desc_array);
426         return 0;
427 }
428 static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
429 {
430         /* GPIO can never have been requested */
431         WARN_ON(desc);
432 }
433 static inline int gpiod_set_array_value_cansleep(unsigned int array_size,
434                                             struct gpio_desc **desc_array,
435                                             struct gpio_array *array_info,
436                                             unsigned long *value_bitmap)
437 {
438         /* GPIO can never have been requested */
439         WARN_ON(desc_array);
440         return 0;
441 }
442 static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
443 {
444         /* GPIO can never have been requested */
445         WARN_ON(desc);
446         return 0;
447 }
448 static inline int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
449                                                struct gpio_desc **desc_array,
450                                                struct gpio_array *array_info,
451                                                unsigned long *value_bitmap)
452 {
453         /* GPIO can never have been requested */
454         WARN_ON(desc_array);
455         return 0;
456 }
457 static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
458                                                 int value)
459 {
460         /* GPIO can never have been requested */
461         WARN_ON(desc);
462 }
463 static inline int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
464                                                 struct gpio_desc **desc_array,
465                                                 struct gpio_array *array_info,
466                                                 unsigned long *value_bitmap)
467 {
468         /* GPIO can never have been requested */
469         WARN_ON(desc_array);
470         return 0;
471 }
472 
473 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
474 {
475         /* GPIO can never have been requested */
476         WARN_ON(desc);
477         return -ENOSYS;
478 }
479 
480 static inline int gpiod_set_transitory(struct gpio_desc *desc, bool transitory)
481 {
482         /* GPIO can never have been requested */
483         WARN_ON(desc);
484         return -ENOSYS;
485 }
486 
487 static inline void gpiod_toggle_active_low(struct gpio_desc *desc)
488 {
489         /* GPIO can never have been requested */
490         WARN_ON(desc);
491 }
492 
493 static inline int gpiod_is_active_low(const struct gpio_desc *desc)
494 {
495         /* GPIO can never have been requested */
496         WARN_ON(desc);
497         return 0;
498 }
499 static inline int gpiod_cansleep(const struct gpio_desc *desc)
500 {
501         /* GPIO can never have been requested */
502         WARN_ON(desc);
503         return 0;
504 }
505 
506 static inline int gpiod_to_irq(const struct gpio_desc *desc)
507 {
508         /* GPIO can never have been requested */
509         WARN_ON(desc);
510         return -EINVAL;
511 }
512 
513 static inline int gpiod_set_consumer_name(struct gpio_desc *desc,
514                                           const char *name)
515 {
516         /* GPIO can never have been requested */
517         WARN_ON(desc);
518         return -EINVAL;
519 }
520 
521 static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
522 {
523         return NULL;
524 }
525 
526 static inline int desc_to_gpio(const struct gpio_desc *desc)
527 {
528         /* GPIO can never have been requested */
529         WARN_ON(desc);
530         return -EINVAL;
531 }
532 
533 /* Child properties interface */
534 struct fwnode_handle;
535 
536 static inline
537 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
538                                          const char *propname, int index,
539                                          enum gpiod_flags dflags,
540                                          const char *label)
541 {
542         return ERR_PTR(-ENOSYS);
543 }
544 
545 static inline
546 struct gpio_desc *fwnode_gpiod_get_index(struct fwnode_handle *fwnode,
547                                          const char *con_id, int index,
548                                          enum gpiod_flags flags,
549                                          const char *label)
550 {
551         return ERR_PTR(-ENOSYS);
552 }
553 
554 static inline
555 struct gpio_desc *devm_fwnode_gpiod_get_index(struct device *dev,
556                                               struct fwnode_handle *fwnode,
557                                               const char *con_id, int index,
558                                               enum gpiod_flags flags,
559                                               const char *label)
560 {
561         return ERR_PTR(-ENOSYS);
562 }
563 
564 #endif /* CONFIG_GPIOLIB */
565 
566 static inline
567 struct gpio_desc *devm_fwnode_gpiod_get(struct device *dev,
568                                         struct fwnode_handle *fwnode,
569                                         const char *con_id,
570                                         enum gpiod_flags flags,
571                                         const char *label)
572 {
573         return devm_fwnode_gpiod_get_index(dev, fwnode, con_id, 0,
574                                            flags, label);
575 }
576 
577 static inline
578 struct gpio_desc *devm_fwnode_get_index_gpiod_from_child(struct device *dev,
579                                                 const char *con_id, int index,
580                                                 struct fwnode_handle *child,
581                                                 enum gpiod_flags flags,
582                                                 const char *label)
583 {
584         return devm_fwnode_gpiod_get_index(dev, child, con_id, index,
585                                            flags, label);
586 }
587 
588 static inline
589 struct gpio_desc *devm_fwnode_get_gpiod_from_child(struct device *dev,
590                                                    const char *con_id,
591                                                    struct fwnode_handle *child,
592                                                    enum gpiod_flags flags,
593                                                    const char *label)
594 {
595         return devm_fwnode_gpiod_get_index(dev, child, con_id, 0, flags, label);
596 }
597 
598 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_OF_GPIO)
599 struct device_node;
600 
601 struct gpio_desc *gpiod_get_from_of_node(struct device_node *node,
602                                          const char *propname, int index,
603                                          enum gpiod_flags dflags,
604                                          const char *label);
605 
606 #else  /* CONFIG_GPIOLIB && CONFIG_OF_GPIO */
607 
608 struct device_node;
609 
610 static inline
611 struct gpio_desc *gpiod_get_from_of_node(struct device_node *node,
612                                          const char *propname, int index,
613                                          enum gpiod_flags dflags,
614                                          const char *label)
615 {
616         return ERR_PTR(-ENOSYS);
617 }
618 
619 #endif /* CONFIG_GPIOLIB && CONFIG_OF_GPIO */
620 
621 #ifdef CONFIG_GPIOLIB
622 struct device_node;
623 
624 struct gpio_desc *devm_gpiod_get_from_of_node(struct device *dev,
625                                               struct device_node *node,
626                                               const char *propname, int index,
627                                               enum gpiod_flags dflags,
628                                               const char *label);
629 
630 #else  /* CONFIG_GPIOLIB */
631 
632 struct device_node;
633 
634 static inline
635 struct gpio_desc *devm_gpiod_get_from_of_node(struct device *dev,
636                                               struct device_node *node,
637                                               const char *propname, int index,
638                                               enum gpiod_flags dflags,
639                                               const char *label)
640 {
641         return ERR_PTR(-ENOSYS);
642 }
643 
644 #endif /* CONFIG_GPIOLIB */
645 
646 struct acpi_gpio_params {
647         unsigned int crs_entry_index;
648         unsigned int line_index;
649         bool active_low;
650 };
651 
652 struct acpi_gpio_mapping {
653         const char *name;
654         const struct acpi_gpio_params *data;
655         unsigned int size;
656 
657 /* Ignore IoRestriction field */
658 #define ACPI_GPIO_QUIRK_NO_IO_RESTRICTION       BIT(0)
659 /*
660  * When ACPI GPIO mapping table is in use the index parameter inside it
661  * refers to the GPIO resource in _CRS method. That index has no
662  * distinction of actual type of the resource. When consumer wants to
663  * get GpioIo type explicitly, this quirk may be used.
664  */
665 #define ACPI_GPIO_QUIRK_ONLY_GPIOIO             BIT(1)
666 
667         unsigned int quirks;
668 };
669 
670 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_ACPI)
671 
672 struct acpi_device;
673 
674 int acpi_dev_add_driver_gpios(struct acpi_device *adev,
675                               const struct acpi_gpio_mapping *gpios);
676 void acpi_dev_remove_driver_gpios(struct acpi_device *adev);
677 
678 int devm_acpi_dev_add_driver_gpios(struct device *dev,
679                                    const struct acpi_gpio_mapping *gpios);
680 void devm_acpi_dev_remove_driver_gpios(struct device *dev);
681 
682 #else  /* CONFIG_GPIOLIB && CONFIG_ACPI */
683 
684 struct acpi_device;
685 
686 static inline int acpi_dev_add_driver_gpios(struct acpi_device *adev,
687                               const struct acpi_gpio_mapping *gpios)
688 {
689         return -ENXIO;
690 }
691 static inline void acpi_dev_remove_driver_gpios(struct acpi_device *adev) {}
692 
693 static inline int devm_acpi_dev_add_driver_gpios(struct device *dev,
694                               const struct acpi_gpio_mapping *gpios)
695 {
696         return -ENXIO;
697 }
698 static inline void devm_acpi_dev_remove_driver_gpios(struct device *dev) {}
699 
700 #endif /* CONFIG_GPIOLIB && CONFIG_ACPI */
701 
702 
703 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS)
704 
705 int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
706 int gpiod_export_link(struct device *dev, const char *name,
707                       struct gpio_desc *desc);
708 void gpiod_unexport(struct gpio_desc *desc);
709 
710 #else  /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
711 
712 static inline int gpiod_export(struct gpio_desc *desc,
713                                bool direction_may_change)
714 {
715         return -ENOSYS;
716 }
717 
718 static inline int gpiod_export_link(struct device *dev, const char *name,
719                                     struct gpio_desc *desc)
720 {
721         return -ENOSYS;
722 }
723 
724 static inline void gpiod_unexport(struct gpio_desc *desc)
725 {
726 }
727 
728 #endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
729 
730 #endif
731 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp