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