HWPOISON: Add a madvise() injector for soft page offlining
[linux-2.6.git] / include / asm-generic / gpio.h
1 #ifndef _ASM_GENERIC_GPIO_H
2 #define _ASM_GENERIC_GPIO_H
3
4 #include <linux/kernel.h>
5 #include <linux/types.h>
6 #include <linux/errno.h>
7
8 #ifdef CONFIG_GPIOLIB
9
10 #include <linux/compiler.h>
11
12 /* Platforms may implement their GPIO interface with library code,
13  * at a small performance cost for non-inlined operations and some
14  * extra memory (for code and for per-GPIO table entries).
15  *
16  * While the GPIO programming interface defines valid GPIO numbers
17  * to be in the range 0..MAX_INT, this library restricts them to the
18  * smaller range 0..ARCH_NR_GPIOS-1.
19  */
20
21 #ifndef ARCH_NR_GPIOS
22 #define ARCH_NR_GPIOS           256
23 #endif
24
25 static inline int gpio_is_valid(int number)
26 {
27         /* only some non-negative numbers are valid */
28         return ((unsigned)number) < ARCH_NR_GPIOS;
29 }
30
31 struct device;
32 struct seq_file;
33 struct module;
34
35 /**
36  * struct gpio_chip - abstract a GPIO controller
37  * @label: for diagnostics
38  * @dev: optional device providing the GPIOs
39  * @owner: helps prevent removal of modules exporting active GPIOs
40  * @request: optional hook for chip-specific activation, such as
41  *      enabling module power and clock; may sleep
42  * @free: optional hook for chip-specific deactivation, such as
43  *      disabling module power and clock; may sleep
44  * @direction_input: configures signal "offset" as input, or returns error
45  * @get: returns value for signal "offset"; for output signals this
46  *      returns either the value actually sensed, or zero
47  * @direction_output: configures signal "offset" as output, or returns error
48  * @set: assigns output value for signal "offset"
49  * @to_irq: optional hook supporting non-static gpio_to_irq() mappings;
50  *      implementation may not sleep
51  * @dbg_show: optional routine to show contents in debugfs; default code
52  *      will be used when this is omitted, but custom code can show extra
53  *      state (such as pullup/pulldown configuration).
54  * @base: identifies the first GPIO number handled by this chip; or, if
55  *      negative during registration, requests dynamic ID allocation.
56  * @ngpio: the number of GPIOs handled by this controller; the last GPIO
57  *      handled is (base + ngpio - 1).
58  * @can_sleep: flag must be set iff get()/set() methods sleep, as they
59  *      must while accessing GPIO expander chips over I2C or SPI
60  * @names: if set, must be an array of strings to use as alternative
61  *      names for the GPIOs in this chip. Any entry in the array
62  *      may be NULL if there is no alias for the GPIO, however the
63  *      array must be @ngpio entries long.
64  *
65  * A gpio_chip can help platforms abstract various sources of GPIOs so
66  * they can all be accessed through a common programing interface.
67  * Example sources would be SOC controllers, FPGAs, multifunction
68  * chips, dedicated GPIO expanders, and so on.
69  *
70  * Each chip controls a number of signals, identified in method calls
71  * by "offset" values in the range 0..(@ngpio - 1).  When those signals
72  * are referenced through calls like gpio_get_value(gpio), the offset
73  * is calculated by subtracting @base from the gpio number.
74  */
75 struct gpio_chip {
76         const char              *label;
77         struct device           *dev;
78         struct module           *owner;
79
80         int                     (*request)(struct gpio_chip *chip,
81                                                 unsigned offset);
82         void                    (*free)(struct gpio_chip *chip,
83                                                 unsigned offset);
84
85         int                     (*direction_input)(struct gpio_chip *chip,
86                                                 unsigned offset);
87         int                     (*get)(struct gpio_chip *chip,
88                                                 unsigned offset);
89         int                     (*direction_output)(struct gpio_chip *chip,
90                                                 unsigned offset, int value);
91         void                    (*set)(struct gpio_chip *chip,
92                                                 unsigned offset, int value);
93
94         int                     (*to_irq)(struct gpio_chip *chip,
95                                                 unsigned offset);
96
97         void                    (*dbg_show)(struct seq_file *s,
98                                                 struct gpio_chip *chip);
99         int                     base;
100         u16                     ngpio;
101         char                    **names;
102         unsigned                can_sleep:1;
103         unsigned                exported:1;
104 };
105
106 extern const char *gpiochip_is_requested(struct gpio_chip *chip,
107                         unsigned offset);
108 extern int __must_check gpiochip_reserve(int start, int ngpio);
109
110 /* add/remove chips */
111 extern int gpiochip_add(struct gpio_chip *chip);
112 extern int __must_check gpiochip_remove(struct gpio_chip *chip);
113
114
115 /* Always use the library code for GPIO management calls,
116  * or when sleeping may be involved.
117  */
118 extern int gpio_request(unsigned gpio, const char *label);
119 extern void gpio_free(unsigned gpio);
120
121 extern int gpio_direction_input(unsigned gpio);
122 extern int gpio_direction_output(unsigned gpio, int value);
123
124 extern int gpio_get_value_cansleep(unsigned gpio);
125 extern void gpio_set_value_cansleep(unsigned gpio, int value);
126
127
128 /* A platform's <asm/gpio.h> code may want to inline the I/O calls when
129  * the GPIO is constant and refers to some always-present controller,
130  * giving direct access to chip registers and tight bitbanging loops.
131  */
132 extern int __gpio_get_value(unsigned gpio);
133 extern void __gpio_set_value(unsigned gpio, int value);
134
135 extern int __gpio_cansleep(unsigned gpio);
136
137 extern int __gpio_to_irq(unsigned gpio);
138
139 #ifdef CONFIG_GPIO_SYSFS
140
141 /*
142  * A sysfs interface can be exported by individual drivers if they want,
143  * but more typically is configured entirely from userspace.
144  */
145 extern int gpio_export(unsigned gpio, bool direction_may_change);
146 extern int gpio_export_link(struct device *dev, const char *name,
147                         unsigned gpio);
148 extern void gpio_unexport(unsigned gpio);
149
150 #endif  /* CONFIG_GPIO_SYSFS */
151
152 #else   /* !CONFIG_HAVE_GPIO_LIB */
153
154 static inline int gpio_is_valid(int number)
155 {
156         /* only non-negative numbers are valid */
157         return number >= 0;
158 }
159
160 /* platforms that don't directly support access to GPIOs through I2C, SPI,
161  * or other blocking infrastructure can use these wrappers.
162  */
163
164 static inline int gpio_cansleep(unsigned gpio)
165 {
166         return 0;
167 }
168
169 static inline int gpio_get_value_cansleep(unsigned gpio)
170 {
171         might_sleep();
172         return gpio_get_value(gpio);
173 }
174
175 static inline void gpio_set_value_cansleep(unsigned gpio, int value)
176 {
177         might_sleep();
178         gpio_set_value(gpio, value);
179 }
180
181 #endif /* !CONFIG_HAVE_GPIO_LIB */
182
183 #ifndef CONFIG_GPIO_SYSFS
184
185 struct device;
186
187 /* sysfs support is only available with gpiolib, where it's optional */
188
189 static inline int gpio_export(unsigned gpio, bool direction_may_change)
190 {
191         return -ENOSYS;
192 }
193
194 static inline int gpio_export_link(struct device *dev, const char *name,
195                                 unsigned gpio)
196 {
197         return -ENOSYS;
198 }
199
200 static inline void gpio_unexport(unsigned gpio)
201 {
202 }
203 #endif  /* CONFIG_GPIO_SYSFS */
204
205 #endif /* _ASM_GENERIC_GPIO_H */