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 struct gpio_desc *gpio_name_to_desc(const char *name);
 134
 135 /* Child properties interface */
 136 struct fwnode_handle;
 137
 138 struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
 139                                          const char *propname);
 140 struct gpio_desc *devm_get_gpiod_from_child(struct device *dev,
 141                                             const char *con_id,
 142                                             struct fwnode_handle *child);
 143 #else /* CONFIG_GPIOLIB */
 144
 145 static inline int gpiod_count(struct device *dev, const char *con_id)
 146 {
 147         return 0;
 148 }
 149
 150 static inline struct gpio_desc *__must_check gpiod_get(struct device *dev,
 151                                                        const char *con_id,
 152                                                        enum gpiod_flags flags)
 153 {
 154         return ERR_PTR(-ENOSYS);
 155 }
 156 static inline struct gpio_desc *__must_check
 157 gpiod_get_index(struct device *dev,
 158                 const char *con_id,
 159                 unsigned int idx,
 160                 enum gpiod_flags flags)
 161 {
 162         return ERR_PTR(-ENOSYS);
 163 }
 164
 165 static inline struct gpio_desc *__must_check
 166 gpiod_get_optional(struct device *dev, const char *con_id,
 167                    enum gpiod_flags flags)
 168 {
 169         return ERR_PTR(-ENOSYS);
 170 }
 171
 172 static inline struct gpio_desc *__must_check
 173 gpiod_get_index_optional(struct device *dev, const char *con_id,
 174                          unsigned int index, enum gpiod_flags flags)
 175 {
 176         return ERR_PTR(-ENOSYS);
 177 }
 178
 179 static inline struct gpio_descs *__must_check
 180 gpiod_get_array(struct device *dev, const char *con_id,
 181                 enum gpiod_flags flags)
 182 {
 183         return ERR_PTR(-ENOSYS);
 184 }
 185
 186 static inline struct gpio_descs *__must_check
 187 gpiod_get_array_optional(struct device *dev, const char *con_id,
 188                          enum gpiod_flags flags)
 189 {
 190         return ERR_PTR(-ENOSYS);
 191 }
 192
 193 static inline void gpiod_put(struct gpio_desc *desc)
 194 {
 195         might_sleep();
 196
 197         /* GPIO can never have been requested */
 198         WARN_ON(1);
 199 }
 200
 201 static inline void gpiod_put_array(struct gpio_descs *descs)
 202 {
 203         might_sleep();
 204
 205         /* GPIO can never have been requested */
 206         WARN_ON(1);
 207 }
 208
 209 static inline struct gpio_desc *__must_check
 210 devm_gpiod_get(struct device *dev,
 211                  const char *con_id,
 212                  enum gpiod_flags flags)
 213 {
 214         return ERR_PTR(-ENOSYS);
 215 }
 216 static inline
 217 struct gpio_desc *__must_check
 218 devm_gpiod_get_index(struct device *dev,
 219                        const char *con_id,
 220                        unsigned int idx,
 221                        enum gpiod_flags flags)
 222 {
 223         return ERR_PTR(-ENOSYS);
 224 }
 225
 226 static inline struct gpio_desc *__must_check
 227 devm_gpiod_get_optional(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_desc *__must_check
 234 devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
 235                                 unsigned int index, enum gpiod_flags flags)
 236 {
 237         return ERR_PTR(-ENOSYS);
 238 }
 239
 240 static inline struct gpio_descs *__must_check
 241 devm_gpiod_get_array(struct device *dev, const char *con_id,
 242                      enum gpiod_flags flags)
 243 {
 244         return ERR_PTR(-ENOSYS);
 245 }
 246
 247 static inline struct gpio_descs *__must_check
 248 devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
 249                               enum gpiod_flags flags)
 250 {
 251         return ERR_PTR(-ENOSYS);
 252 }
 253
 254 static inline void devm_gpiod_put(struct device *dev, struct gpio_desc *desc)
 255 {
 256         might_sleep();
 257
 258         /* GPIO can never have been requested */
 259         WARN_ON(1);
 260 }
 261
 262 static inline void devm_gpiod_put_array(struct device *dev,
 263                                         struct gpio_descs *descs)
 264 {
 265         might_sleep();
 266
 267         /* GPIO can never have been requested */
 268         WARN_ON(1);
 269 }
 270
 271
 272 static inline int gpiod_get_direction(const struct gpio_desc *desc)
 273 {
 274         /* GPIO can never have been requested */
 275         WARN_ON(1);
 276         return -ENOSYS;
 277 }
 278 static inline int gpiod_direction_input(struct gpio_desc *desc)
 279 {
 280         /* GPIO can never have been requested */
 281         WARN_ON(1);
 282         return -ENOSYS;
 283 }
 284 static inline int gpiod_direction_output(struct gpio_desc *desc, int value)
 285 {
 286         /* GPIO can never have been requested */
 287         WARN_ON(1);
 288         return -ENOSYS;
 289 }
 290 static inline int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
 291 {
 292         /* GPIO can never have been requested */
 293         WARN_ON(1);
 294         return -ENOSYS;
 295 }
 296
 297
 298 static inline int gpiod_get_value(const struct gpio_desc *desc)
 299 {
 300         /* GPIO can never have been requested */
 301         WARN_ON(1);
 302         return 0;
 303 }
 304 static inline void gpiod_set_value(struct gpio_desc *desc, int value)
 305 {
 306         /* GPIO can never have been requested */
 307         WARN_ON(1);
 308 }
 309 static inline void gpiod_set_array_value(unsigned int array_size,
 310                                          struct gpio_desc **desc_array,
 311                                          int *value_array)
 312 {
 313         /* GPIO can never have been requested */
 314         WARN_ON(1);
 315 }
 316 static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
 317 {
 318         /* GPIO can never have been requested */
 319         WARN_ON(1);
 320         return 0;
 321 }
 322 static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
 323 {
 324         /* GPIO can never have been requested */
 325         WARN_ON(1);
 326 }
 327 static inline void gpiod_set_raw_array_value(unsigned int array_size,
 328                                              struct gpio_desc **desc_array,
 329                                              int *value_array)
 330 {
 331         /* GPIO can never have been requested */
 332         WARN_ON(1);
 333 }
 334
 335 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 336 {
 337         /* GPIO can never have been requested */
 338         WARN_ON(1);
 339         return 0;
 340 }
 341 static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
 342 {
 343         /* GPIO can never have been requested */
 344         WARN_ON(1);
 345 }
 346 static inline void gpiod_set_array_value_cansleep(unsigned int array_size,
 347                                             struct gpio_desc **desc_array,
 348                                             int *value_array)
 349 {
 350         /* GPIO can never have been requested */
 351         WARN_ON(1);
 352 }
 353 static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
 354 {
 355         /* GPIO can never have been requested */
 356         WARN_ON(1);
 357         return 0;
 358 }
 359 static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
 360                                                 int value)
 361 {
 362         /* GPIO can never have been requested */
 363         WARN_ON(1);
 364 }
 365 static inline void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
 366                                                 struct gpio_desc **desc_array,
 367                                                 int *value_array)
 368 {
 369         /* GPIO can never have been requested */
 370         WARN_ON(1);
 371 }
 372
 373 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
 374 {
 375         /* GPIO can never have been requested */
 376         WARN_ON(1);
 377         return -ENOSYS;
 378 }
 379
 380 static inline int gpiod_is_active_low(const struct gpio_desc *desc)
 381 {
 382         /* GPIO can never have been requested */
 383         WARN_ON(1);
 384         return 0;
 385 }
 386 static inline int gpiod_cansleep(const struct gpio_desc *desc)
 387 {
 388         /* GPIO can never have been requested */
 389         WARN_ON(1);
 390         return 0;
 391 }
 392
 393 static inline int gpiod_to_irq(const struct gpio_desc *desc)
 394 {
 395         /* GPIO can never have been requested */
 396         WARN_ON(1);
 397         return -EINVAL;
 398 }
 399
 400 static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
 401 {
 402         return ERR_PTR(-EINVAL);
 403 }
 404
 405 static inline struct gpio_desc *gpio_name_to_desc(const char *name)
 406 {
 407         return ERR_PTR(-EINVAL);
 408 }
 409
 410 static inline int desc_to_gpio(const struct gpio_desc *desc)
 411 {
 412         /* GPIO can never have been requested */
 413         WARN_ON(1);
 414         return -EINVAL;
 415 }
 416
 417 /* Child properties interface */
 418 struct fwnode_handle;
 419
 420 static inline struct gpio_desc *fwnode_get_named_gpiod(
 421         struct fwnode_handle *fwnode, const char *propname)
 422 {
 423         return ERR_PTR(-ENOSYS);
 424 }
 425
 426 static inline struct gpio_desc *devm_get_gpiod_from_child(
 427         struct device *dev, const char *con_id, struct fwnode_handle *child)
 428 {
 429         return ERR_PTR(-ENOSYS);
 430 }
 431
 432 #endif /* CONFIG_GPIOLIB */
 433
 434 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS)
 435
 436 int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
 437 int gpiod_export_link(struct device *dev, const char *name,
 438                       struct gpio_desc *desc);
 439 void gpiod_unexport(struct gpio_desc *desc);
 440
 441 #else  /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 442
 443 static inline int gpiod_export(struct gpio_desc *desc,
 444                                bool direction_may_change)
 445 {
 446         return -ENOSYS;
 447 }
 448
 449 static inline int gpiod_export_link(struct device *dev, const char *name,
 450                                     struct gpio_desc *desc)
 451 {
 452         return -ENOSYS;
 453 }
 454
 455 static inline void gpiod_unexport(struct gpio_desc *desc)
 456 {
 457 }
 458
 459 #endif /* CONFIG_GPIOLIB && CONFIG_GPIO_SYSFS */
 460
 461 #endif