include/linux/pinctrl/consumer.h

   1 /*
   2  * Consumer interface the pin control subsystem
   3  *
   4  * Copyright (C) 2012 ST-Ericsson SA
   5  * Written on behalf of Linaro for ST-Ericsson
   6  * Based on bits of regulator core, gpio core and clk core
   7  *
   8  * Author: Linus Walleij <linus.walleij@linaro.org>
   9  *
  10  * License terms: GNU General Public License (GPL) version 2
  11  */
  12 #ifndef __LINUX_PINCTRL_CONSUMER_H
  13 #define __LINUX_PINCTRL_CONSUMER_H
  14
  15 #include <linux/err.h>
  16 #include <linux/list.h>
  17 #include <linux/seq_file.h>
  18 #include "pinctrl-state.h"
  19
  20 /* This struct is private to the core and should be regarded as a cookie */
  21 struct pinctrl;
  22 struct pinctrl_state;
  23
  24 #ifdef CONFIG_PINCTRL
  25
  26 /* External interface to pin control */
  27 extern int pinctrl_request_gpio(unsigned gpio);
  28 extern void pinctrl_free_gpio(unsigned gpio);
  29 extern int pinctrl_gpio_direction_input(unsigned gpio);
  30 extern int pinctrl_gpio_direction_output(unsigned gpio);
  31
  32 extern struct pinctrl * __must_check pinctrl_get(struct device *dev);
  33 extern void pinctrl_put(struct pinctrl *p);
  34 extern struct pinctrl_state * __must_check pinctrl_lookup_state(
  35                                                         struct pinctrl *p,
  36                                                         const char *name);
  37 extern int pinctrl_select_state(struct pinctrl *p, struct pinctrl_state *s);
  38
  39 extern struct pinctrl * __must_check devm_pinctrl_get(struct device *dev);
  40 extern void devm_pinctrl_put(struct pinctrl *p);
  41
  42 #else /* !CONFIG_PINCTRL */
  43
  44 static inline int pinctrl_request_gpio(unsigned gpio)
  45 {
  46         return 0;
  47 }
  48
  49 static inline void pinctrl_free_gpio(unsigned gpio)
  50 {
  51 }
  52
  53 static inline int pinctrl_gpio_direction_input(unsigned gpio)
  54 {
  55         return 0;
  56 }
  57
  58 static inline int pinctrl_gpio_direction_output(unsigned gpio)
  59 {
  60         return 0;
  61 }
  62
  63 static inline struct pinctrl * __must_check pinctrl_get(struct device *dev)
  64 {
  65         return NULL;
  66 }
  67
  68 static inline void pinctrl_put(struct pinctrl *p)
  69 {
  70 }
  71
  72 static inline struct pinctrl_state * __must_check pinctrl_lookup_state(
  73                                                         struct pinctrl *p,
  74                                                         const char *name)
  75 {
  76         return NULL;
  77 }
  78
  79 static inline int pinctrl_select_state(struct pinctrl *p,
  80                                        struct pinctrl_state *s)
  81 {
  82         return 0;
  83 }
  84
  85 static inline struct pinctrl * __must_check devm_pinctrl_get(struct device *dev)
  86 {
  87         return NULL;
  88 }
  89
  90 static inline void devm_pinctrl_put(struct pinctrl *p)
  91 {
  92 }
  93
  94 #endif /* CONFIG_PINCTRL */
  95
  96 static inline struct pinctrl * __must_check pinctrl_get_select(
  97                                         struct device *dev, const char *name)
  98 {
  99         struct pinctrl *p;
 100         struct pinctrl_state *s;
 101         int ret;
 102
 103         p = pinctrl_get(dev);
 104         if (IS_ERR(p))
 105                 return p;
 106
 107         s = pinctrl_lookup_state(p, name);
 108         if (IS_ERR(s)) {
 109                 pinctrl_put(p);
 110                 return ERR_PTR(PTR_ERR(s));
 111         }
 112
 113         ret = pinctrl_select_state(p, s);
 114         if (ret < 0) {
 115                 pinctrl_put(p);
 116                 return ERR_PTR(ret);
 117         }
 118
 119         return p;
 120 }
 121
 122 static inline struct pinctrl * __must_check pinctrl_get_select_default(
 123                                         struct device *dev)
 124 {
 125         return pinctrl_get_select(dev, PINCTRL_STATE_DEFAULT);
 126 }
 127
 128 static inline struct pinctrl * __must_check devm_pinctrl_get_select(
 129                                         struct device *dev, const char *name)
 130 {
 131         struct pinctrl *p;
 132         struct pinctrl_state *s;
 133         int ret;
 134
 135         p = devm_pinctrl_get(dev);
 136         if (IS_ERR(p))
 137                 return p;
 138
 139         s = pinctrl_lookup_state(p, name);
 140         if (IS_ERR(s)) {
 141                 devm_pinctrl_put(p);
 142                 return ERR_PTR(PTR_ERR(s));
 143         }
 144
 145         ret = pinctrl_select_state(p, s);
 146         if (ret < 0) {
 147                 devm_pinctrl_put(p);
 148                 return ERR_PTR(ret);
 149         }
 150
 151         return p;
 152 }
 153
 154 static inline struct pinctrl * __must_check devm_pinctrl_get_select_default(
 155                                         struct device *dev)
 156 {
 157         return devm_pinctrl_get_select(dev, PINCTRL_STATE_DEFAULT);
 158 }
 159
 160 #ifdef CONFIG_PINCONF
 161
 162 extern int pin_config_get(const char *dev_name, const char *name,
 163                           unsigned long *config);
 164 extern int pin_config_set(const char *dev_name, const char *name,
 165                           unsigned long config);
 166 extern int pin_config_group_get(const char *dev_name,
 167                                 const char *pin_group,
 168                                 unsigned long *config);
 169 extern int pin_config_group_set(const char *dev_name,
 170                                 const char *pin_group,
 171                                 unsigned long config);
 172
 173 #else
 174
 175 static inline int pin_config_get(const char *dev_name, const char *name,
 176                                  unsigned long *config)
 177 {
 178         return 0;
 179 }
 180
 181 static inline int pin_config_set(const char *dev_name, const char *name,
 182                                  unsigned long config)
 183 {
 184         return 0;
 185 }
 186
 187 static inline int pin_config_group_get(const char *dev_name,
 188                                        const char *pin_group,
 189                                        unsigned long *config)
 190 {
 191         return 0;
 192 }
 193
 194 static inline int pin_config_group_set(const char *dev_name,
 195                                        const char *pin_group,
 196                                        unsigned long config)
 197 {
 198         return 0;
 199 }
 200
 201 #endif
 202
 203 #endif /* __LINUX_PINCTRL_CONSUMER_H */