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