]>
Commit | Line | Data |
---|---|---|
9d2cb8e8 SG |
1 | /* |
2 | * Copyright (c) 2011 The Chromium OS Authors. | |
5f533aeb | 3 | * Copyright (c) 2011, NVIDIA Corp. All rights reserved. |
1a459660 | 4 | * SPDX-License-Identifier: GPL-2.0+ |
9d2cb8e8 SG |
5 | */ |
6 | ||
5f533aeb JH |
7 | #ifndef _ASM_GENERIC_GPIO_H_ |
8 | #define _ASM_GENERIC_GPIO_H_ | |
9 | ||
9d2cb8e8 SG |
10 | /* |
11 | * Generic GPIO API for U-Boot | |
12 | * | |
5d1c17e9 SG |
13 | * -- |
14 | * NB: This is deprecated. Please use the driver model functions instead: | |
15 | * | |
16 | * - gpio_request_by_name() | |
17 | * - dm_gpio_get_value() etc. | |
18 | * | |
19 | * For now we need a dm_ prefix on some functions to avoid name collision. | |
20 | * -- | |
21 | * | |
9d2cb8e8 SG |
22 | * GPIOs are numbered from 0 to GPIO_COUNT-1 which value is defined |
23 | * by the SOC/architecture. | |
24 | * | |
25 | * Each GPIO can be an input or output. If an input then its value can | |
26 | * be read as 0 or 1. If an output then its value can be set to 0 or 1. | |
27 | * If you try to write an input then the value is undefined. If you try | |
28 | * to read an output, barring something very unusual, you will get | |
29 | * back the value of the output that you previously set. | |
30 | * | |
31 | * In some cases the operation may fail, for example if the GPIO number | |
32 | * is out of range, or the GPIO is not available because its pin is | |
33 | * being used by another function. In that case, functions may return | |
34 | * an error value of -1. | |
35 | */ | |
36 | ||
5f533aeb | 37 | /** |
5d1c17e9 | 38 | * @deprecated Please use driver model instead |
25ca385d MZ |
39 | * Request a GPIO. This should be called before any of the other functions |
40 | * are used on this GPIO. | |
5f533aeb | 41 | * |
b892d127 SG |
42 | * Note: With driver model, the label is allocated so there is no need for |
43 | * the caller to preserve it. | |
44 | * | |
94740e47 NK |
45 | * @param gp GPIO number |
46 | * @param label User label for this GPIO | |
5f533aeb JH |
47 | * @return 0 if ok, -1 on error |
48 | */ | |
49 | int gpio_request(unsigned gpio, const char *label); | |
50 | ||
51 | /** | |
5d1c17e9 | 52 | * @deprecated Please use driver model instead |
5f533aeb JH |
53 | * Stop using the GPIO. This function should not alter pin configuration. |
54 | * | |
55 | * @param gpio GPIO number | |
56 | * @return 0 if ok, -1 on error | |
57 | */ | |
58 | int gpio_free(unsigned gpio); | |
59 | ||
9d2cb8e8 | 60 | /** |
5d1c17e9 | 61 | * @deprecated Please use driver model instead |
9d2cb8e8 SG |
62 | * Make a GPIO an input. |
63 | * | |
5f533aeb | 64 | * @param gpio GPIO number |
9d2cb8e8 SG |
65 | * @return 0 if ok, -1 on error |
66 | */ | |
5f533aeb | 67 | int gpio_direction_input(unsigned gpio); |
9d2cb8e8 SG |
68 | |
69 | /** | |
5d1c17e9 | 70 | * @deprecated Please use driver model instead |
9d2cb8e8 SG |
71 | * Make a GPIO an output, and set its value. |
72 | * | |
5f533aeb | 73 | * @param gpio GPIO number |
9d2cb8e8 SG |
74 | * @param value GPIO value (0 for low or 1 for high) |
75 | * @return 0 if ok, -1 on error | |
76 | */ | |
5f533aeb | 77 | int gpio_direction_output(unsigned gpio, int value); |
9d2cb8e8 SG |
78 | |
79 | /** | |
5d1c17e9 | 80 | * @deprecated Please use driver model instead |
9d2cb8e8 SG |
81 | * Get a GPIO's value. This will work whether the GPIO is an input |
82 | * or an output. | |
83 | * | |
5f533aeb | 84 | * @param gpio GPIO number |
9d2cb8e8 SG |
85 | * @return 0 if low, 1 if high, -1 on error |
86 | */ | |
5f533aeb | 87 | int gpio_get_value(unsigned gpio); |
9d2cb8e8 SG |
88 | |
89 | /** | |
5d1c17e9 | 90 | * @deprecated Please use driver model instead |
5f533aeb | 91 | * Set an output GPIO's value. The GPIO must already be an output or |
9d2cb8e8 SG |
92 | * this function may have no effect. |
93 | * | |
5f533aeb | 94 | * @param gpio GPIO number |
9d2cb8e8 SG |
95 | * @param value GPIO value (0 for low or 1 for high) |
96 | * @return 0 if ok, -1 on error | |
97 | */ | |
5f533aeb | 98 | int gpio_set_value(unsigned gpio, int value); |
96495d90 | 99 | |
89e64054 | 100 | /* State of a GPIO, as reported by get_function() */ |
6449a506 | 101 | enum gpio_func_t { |
96495d90 SG |
102 | GPIOF_INPUT = 0, |
103 | GPIOF_OUTPUT, | |
89e64054 SG |
104 | GPIOF_UNUSED, /* Not claimed */ |
105 | GPIOF_UNKNOWN, /* Not known */ | |
106 | GPIOF_FUNC, /* Not used as a GPIO */ | |
107 | ||
108 | GPIOF_COUNT, | |
96495d90 SG |
109 | }; |
110 | ||
54c5d08a | 111 | struct udevice; |
96495d90 | 112 | |
ae7123f8 SG |
113 | struct gpio_desc { |
114 | struct udevice *dev; /* Device, NULL for invalid GPIO */ | |
115 | unsigned long flags; | |
116 | #define GPIOD_REQUESTED (1 << 0) /* Requested/claimed */ | |
117 | #define GPIOD_IS_OUT (1 << 1) /* GPIO is an output */ | |
f9523961 | 118 | #define GPIOD_IS_IN (1 << 2) /* GPIO is an input */ |
ae7123f8 SG |
119 | #define GPIOD_ACTIVE_LOW (1 << 3) /* value has active low */ |
120 | #define GPIOD_IS_OUT_ACTIVE (1 << 4) /* set output active */ | |
121 | ||
122 | uint offset; /* GPIO offset within the device */ | |
123 | /* | |
124 | * We could consider adding the GPIO label in here. Possibly we could | |
125 | * use this structure for internal GPIO information. | |
126 | */ | |
127 | }; | |
128 | ||
3669e0e7 SG |
129 | /** |
130 | * dm_gpio_is_valid() - Check if a GPIO is gpio_is_valie | |
131 | * | |
132 | * @desc: GPIO description containing device, offset and flags, | |
133 | * previously returned by gpio_request_by_name() | |
134 | * @return true if valid, false if not | |
135 | */ | |
136 | static inline bool dm_gpio_is_valid(struct gpio_desc *desc) | |
137 | { | |
138 | return desc->dev != NULL; | |
139 | } | |
140 | ||
0757535a SG |
141 | /** |
142 | * gpio_get_status() - get the current GPIO status as a string | |
143 | * | |
144 | * Obtain the current GPIO status as a string which can be presented to the | |
145 | * user. A typical string is: | |
146 | * | |
147 | * "b4: in: 1 [x] sdmmc_cd" | |
148 | * | |
149 | * which means this is GPIO bank b, offset 4, currently set to input, current | |
150 | * value 1, [x] means that it is requested and the owner is 'sdmmc_cd' | |
151 | * | |
5d1c17e9 SG |
152 | * TODO(sjg@chromium.org): This should use struct gpio_desc |
153 | * | |
0757535a SG |
154 | * @dev: Device to check |
155 | * @offset: Offset of device GPIO to check | |
156 | * @buf: Place to put string | |
157 | * @buffsize: Size of string including \0 | |
158 | */ | |
159 | int gpio_get_status(struct udevice *dev, int offset, char *buf, int buffsize); | |
160 | ||
6449a506 SG |
161 | /** |
162 | * gpio_get_function() - get the current function for a GPIO pin | |
163 | * | |
164 | * Note this returns GPIOF_UNUSED if the GPIO is not requested. | |
165 | * | |
5d1c17e9 SG |
166 | * TODO(sjg@chromium.org): This should use struct gpio_desc |
167 | * | |
6449a506 SG |
168 | * @dev: Device to check |
169 | * @offset: Offset of device GPIO to check | |
170 | * @namep: If non-NULL, this is set to the nane given when the GPIO | |
171 | * was requested, or -1 if it has not been requested | |
172 | * @return -ENODATA if the driver returned an unknown function, | |
173 | * -ENODEV if the device is not active, -EINVAL if the offset is invalid. | |
174 | * GPIOF_UNUSED if the GPIO has not been requested. Otherwise returns the | |
175 | * function from enum gpio_func_t. | |
176 | */ | |
177 | int gpio_get_function(struct udevice *dev, int offset, const char **namep); | |
178 | ||
179 | /** | |
180 | * gpio_get_raw_function() - get the current raw function for a GPIO pin | |
181 | * | |
182 | * Note this does not return GPIOF_UNUSED - it will always return the GPIO | |
183 | * driver's view of a pin function, even if it is not correctly set up. | |
184 | * | |
5d1c17e9 SG |
185 | * TODO(sjg@chromium.org): This should use struct gpio_desc |
186 | * | |
6449a506 SG |
187 | * @dev: Device to check |
188 | * @offset: Offset of device GPIO to check | |
189 | * @namep: If non-NULL, this is set to the nane given when the GPIO | |
190 | * was requested, or -1 if it has not been requested | |
191 | * @return -ENODATA if the driver returned an unknown function, | |
192 | * -ENODEV if the device is not active, -EINVAL if the offset is invalid. | |
193 | * Otherwise returns the function from enum gpio_func_t. | |
194 | */ | |
195 | int gpio_get_raw_function(struct udevice *dev, int offset, const char **namep); | |
196 | ||
d44f597b SG |
197 | /** |
198 | * gpio_requestf() - request a GPIO using a format string for the owner | |
199 | * | |
200 | * This is a helper function for gpio_request(). It allows you to provide | |
201 | * a printf()-format string for the GPIO owner. It calls gpio_request() with | |
202 | * the string that is created | |
203 | */ | |
204 | int gpio_requestf(unsigned gpio, const char *fmt, ...) | |
205 | __attribute__ ((format (__printf__, 2, 3))); | |
206 | ||
0dac4d51 SG |
207 | struct fdtdec_phandle_args; |
208 | ||
96495d90 SG |
209 | /** |
210 | * struct struct dm_gpio_ops - Driver model GPIO operations | |
211 | * | |
212 | * Refer to functions above for description. These function largely copy | |
213 | * the old API. | |
214 | * | |
215 | * This is trying to be close to Linux GPIO API. Once the U-Boot uses the | |
216 | * new DM GPIO API, this should be really easy to flip over to the Linux | |
217 | * GPIO API-alike interface. | |
218 | * | |
25ca385d | 219 | * Also it would be useful to standardise additional functions like |
96495d90 SG |
220 | * pullup, slew rate and drive strength. |
221 | * | |
222 | * gpio_request)( and gpio_free() are optional - if NULL then they will | |
223 | * not be called. | |
224 | * | |
225 | * Note that @offset is the offset from the base GPIO of the device. So | |
226 | * offset 0 is the device's first GPIO and offset o-1 is the last GPIO, | |
227 | * where o is the number of GPIO lines controlled by the device. A device | |
228 | * is typically used to control a single bank of GPIOs. Within complex | |
229 | * SoCs there may be many banks and therefore many devices all referring | |
230 | * to the different IO addresses within the SoC. | |
231 | * | |
25ca385d | 232 | * The uclass combines all GPIO devices together to provide a consistent |
96495d90 SG |
233 | * numbering from 0 to n-1, where n is the number of GPIOs in total across |
234 | * all devices. Be careful not to confuse offset with gpio in the parameters. | |
235 | */ | |
236 | struct dm_gpio_ops { | |
54c5d08a HS |
237 | int (*request)(struct udevice *dev, unsigned offset, const char *label); |
238 | int (*free)(struct udevice *dev, unsigned offset); | |
239 | int (*direction_input)(struct udevice *dev, unsigned offset); | |
240 | int (*direction_output)(struct udevice *dev, unsigned offset, | |
96495d90 | 241 | int value); |
54c5d08a HS |
242 | int (*get_value)(struct udevice *dev, unsigned offset); |
243 | int (*set_value)(struct udevice *dev, unsigned offset, int value); | |
89e64054 SG |
244 | /** |
245 | * get_function() Get the GPIO function | |
246 | * | |
247 | * @dev: Device to check | |
248 | * @offset: GPIO offset within that device | |
249 | * @return current function - GPIOF_... | |
250 | */ | |
54c5d08a | 251 | int (*get_function)(struct udevice *dev, unsigned offset); |
0dac4d51 SG |
252 | |
253 | /** | |
254 | * xlate() - Translate phandle arguments into a GPIO description | |
255 | * | |
256 | * This function should set up the fields in desc according to the | |
257 | * information in the arguments. The uclass will have set up: | |
258 | * | |
259 | * @desc->dev to @dev | |
260 | * @desc->flags to 0 | |
261 | * @desc->offset to the value of the first argument in args, if any, | |
262 | * otherwise -1 (which is invalid) | |
263 | * | |
264 | * This method is optional so if the above defaults suit it can be | |
265 | * omitted. Typical behaviour is to set up the GPIOD_ACTIVE_LOW flag | |
266 | * in desc->flags. | |
267 | * | |
268 | * Note that @dev is passed in as a parameter to follow driver model | |
269 | * uclass conventions, even though it is already available as | |
270 | * desc->dev. | |
271 | * | |
272 | * @dev: GPIO device | |
273 | * @desc: Place to put GPIO description | |
274 | * @args: Arguments provided in descripion | |
275 | * @return 0 if OK, -ve on error | |
276 | */ | |
277 | int (*xlate)(struct udevice *dev, struct gpio_desc *desc, | |
278 | struct fdtdec_phandle_args *args); | |
96495d90 SG |
279 | }; |
280 | ||
281 | /** | |
282 | * struct gpio_dev_priv - information about a device used by the uclass | |
283 | * | |
284 | * The uclass combines all active GPIO devices into a unified numbering | |
25ca385d | 285 | * scheme. To do this it maintains some private information about each |
96495d90 SG |
286 | * device. |
287 | * | |
288 | * To implement driver model support in your GPIO driver, add a probe | |
289 | * handler, and set @gpio_count and @bank_name correctly in that handler. | |
290 | * This tells the uclass the name of the GPIO bank and the number of GPIOs | |
291 | * it contains. | |
292 | * | |
293 | * @bank_name: Name of the GPIO device (e.g 'a' means GPIOs will be called | |
294 | * 'A0', 'A1', etc. | |
295 | * @gpio_count: Number of GPIOs in this device | |
296 | * @gpio_base: Base GPIO number for this device. For the first active device | |
297 | * this will be 0; the numbering for others will follow sequentially so that | |
298 | * @gpio_base for device 1 will equal the number of GPIOs in device 0. | |
b892d127 SG |
299 | * @name: Array of pointers to the name for each GPIO in this bank. The |
300 | * value of the pointer will be NULL if the GPIO has not been claimed. | |
96495d90 SG |
301 | */ |
302 | struct gpio_dev_priv { | |
303 | const char *bank_name; | |
304 | unsigned gpio_count; | |
305 | unsigned gpio_base; | |
b892d127 | 306 | char **name; |
96495d90 SG |
307 | }; |
308 | ||
309 | /* Access the GPIO operations for a device */ | |
310 | #define gpio_get_ops(dev) ((struct dm_gpio_ops *)(dev)->driver->ops) | |
311 | ||
312 | /** | |
313 | * gpio_get_bank_info - Return information about a GPIO bank/device | |
314 | * | |
315 | * This looks up a device and returns both its GPIO base name and the number | |
316 | * of GPIOs it controls. | |
317 | * | |
318 | * @dev: Device to look up | |
319 | * @offset_count: Returns number of GPIOs within this bank | |
320 | * @return bank name of this device | |
321 | */ | |
54c5d08a | 322 | const char *gpio_get_bank_info(struct udevice *dev, int *offset_count); |
96495d90 SG |
323 | |
324 | /** | |
325 | * gpio_lookup_name - Look up a GPIO name and return its details | |
326 | * | |
327 | * This is used to convert a named GPIO into a device, offset and GPIO | |
328 | * number. | |
329 | * | |
330 | * @name: GPIO name to look up | |
331 | * @devp: Returns pointer to device which contains this GPIO | |
332 | * @offsetp: Returns the offset number within this device | |
333 | * @gpiop: Returns the absolute GPIO number, numbered from 0 | |
334 | */ | |
54c5d08a | 335 | int gpio_lookup_name(const char *name, struct udevice **devp, |
96495d90 SG |
336 | unsigned int *offsetp, unsigned int *gpiop); |
337 | ||
e5901c94 | 338 | /** |
962f5caf | 339 | * gpio_get_values_as_int() - Turn the values of a list of GPIOs into an int |
e5901c94 SG |
340 | * |
341 | * This puts the value of the first GPIO into bit 0, the second into bit 1, | |
342 | * etc. then returns the resulting integer. | |
343 | * | |
344 | * @gpio_list: List of GPIOs to collect | |
962f5caf | 345 | * @return resulting integer value, or -ve on error |
e5901c94 | 346 | */ |
962f5caf SG |
347 | int gpio_get_values_as_int(const int *gpio_list); |
348 | ||
349 | /** | |
350 | * gpio_claim_vector() - claim a number of GPIOs for input | |
351 | * | |
352 | * @gpio_num_array: array of gpios to claim, terminated by -1 | |
353 | * @fmt: format string for GPIO names, e.g. "board_id%d" | |
354 | * @return 0 if OK, -ve on error | |
355 | */ | |
356 | int gpio_claim_vector(const int *gpio_num_array, const char *fmt); | |
5b5ac645 | 357 | |
3669e0e7 SG |
358 | /** |
359 | * gpio_request_by_name() - Locate and request a GPIO by name | |
360 | * | |
361 | * This operates by looking up the given list name in the device (device | |
362 | * tree property) and requesting the GPIO for use. The property must exist | |
363 | * in @dev's node. | |
364 | * | |
365 | * Use @flags to specify whether the GPIO should be an input or output. In | |
366 | * principle this can also come from the device tree binding but most | |
367 | * bindings don't provide this information. Specifically, when the GPIO uclass | |
368 | * calls the xlate() method, it can return default flags, which are then | |
369 | * ORed with this @flags. | |
370 | * | |
371 | * If we find that requesting the GPIO is not always needed we could add a | |
372 | * new function or a new GPIOD_NO_REQUEST flag. | |
373 | * | |
374 | * At present driver model has no reference counting so if one device | |
375 | * requests a GPIO which subsequently is unbound, the @desc->dev pointer | |
376 | * will be invalid. However this will only happen if the GPIO device is | |
377 | * unbound, not if it is removed, so this seems like a reasonable limitation | |
378 | * for now. There is no real use case for unbinding drivers in normal | |
379 | * operation. | |
380 | * | |
381 | * The device tree binding is doc/device-tree-bindings/gpio/gpio.txt in | |
382 | * generate terms and each specific device may add additional details in | |
383 | * a binding file in the same directory. | |
384 | * | |
385 | * @dev: Device requesting the GPIO | |
386 | * @list_name: Name of GPIO list (e.g. "board-id-gpios") | |
387 | * @index: Index number of the GPIO in that list use request (0=first) | |
388 | * @desc: Returns GPIO description information. If there is no such | |
389 | * GPIO, dev->dev will be NULL. | |
390 | * @flags: Indicates the GPIO input/output settings (GPIOD_...) | |
391 | * @return 0 if OK, -ENOENT if the GPIO does not exist, -EINVAL if there is | |
392 | * something wrong with the list, or other -ve for another error (e.g. | |
393 | * -EBUSY if a GPIO was already requested) | |
394 | */ | |
395 | int gpio_request_by_name(struct udevice *dev, const char *list_name, | |
396 | int index, struct gpio_desc *desc, int flags); | |
397 | ||
398 | /** | |
399 | * gpio_request_list_by_name() - Request a list of GPIOs | |
400 | * | |
401 | * Reads all the GPIOs from a list and requetss them. See | |
402 | * gpio_request_by_name() for additional details. Lists should not be | |
403 | * misused to hold unrelated or optional GPIOs. They should only be used | |
404 | * for things like parallel data lines. A zero phandle terminates the list | |
405 | * the list. | |
406 | * | |
407 | * This function will either succeed, and request all GPIOs in the list, or | |
408 | * fail and request none (it will free already-requested GPIOs in case of | |
409 | * an error part-way through). | |
410 | * | |
411 | * @dev: Device requesting the GPIO | |
412 | * @list_name: Name of GPIO list (e.g. "board-id-gpios") | |
413 | * @desc_list: Returns a list of GPIO description information | |
414 | * @max_count: Maximum number of GPIOs to return (@desc_list must be at least | |
415 | * this big) | |
416 | * @flags: Indicates the GPIO input/output settings (GPIOD_...) | |
417 | * @return number of GPIOs requested, or -ve on error | |
418 | */ | |
419 | int gpio_request_list_by_name(struct udevice *dev, const char *list_name, | |
420 | struct gpio_desc *desc_list, int max_count, | |
421 | int flags); | |
422 | ||
423 | /** | |
424 | * gpio_get_list_count() - Returns the number of GPIOs in a list | |
425 | * | |
426 | * Counts the GPIOs in a list. See gpio_request_by_name() for additional | |
427 | * details. | |
428 | * | |
429 | * @dev: Device requesting the GPIO | |
430 | * @list_name: Name of GPIO list (e.g. "board-id-gpios") | |
431 | * @return number of GPIOs (0 for an empty property) or -ENOENT if the list | |
432 | * does not exist | |
433 | */ | |
434 | int gpio_get_list_count(struct udevice *dev, const char *list_name); | |
435 | ||
436 | /** | |
437 | * gpio_request_by_name_nodev() - request GPIOs without a device | |
438 | * | |
439 | * This is a version of gpio_request_list_by_name() that does not use a | |
440 | * device. Avoid it unless the caller is not yet using driver model | |
441 | */ | |
442 | int gpio_request_by_name_nodev(const void *blob, int node, | |
443 | const char *list_name, | |
444 | int index, struct gpio_desc *desc, int flags); | |
445 | ||
446 | /** | |
447 | * gpio_request_list_by_name_nodev() - request GPIOs without a device | |
448 | * | |
449 | * This is a version of gpio_request_list_by_name() that does not use a | |
450 | * device. Avoid it unless the caller is not yet using driver model | |
451 | */ | |
452 | int gpio_request_list_by_name_nodev(const void *blob, int node, | |
453 | const char *list_name, | |
454 | struct gpio_desc *desc_list, int max_count, | |
455 | int flags); | |
456 | ||
457 | /** | |
458 | * dm_gpio_free() - Free a single GPIO | |
459 | * | |
460 | * This frees a single GPIOs previously returned from gpio_request_by_name(). | |
461 | * | |
462 | * @dev: Device which requested the GPIO | |
463 | * @desc: GPIO to free | |
464 | * @return 0 if OK, -ve on error | |
465 | */ | |
466 | int dm_gpio_free(struct udevice *dev, struct gpio_desc *desc); | |
467 | ||
468 | /** | |
469 | * gpio_free_list() - Free a list of GPIOs | |
470 | * | |
471 | * This frees a list of GPIOs previously returned from | |
472 | * gpio_request_list_by_name(). | |
473 | * | |
474 | * @dev: Device which requested the GPIOs | |
475 | * @desc: List of GPIOs to free | |
476 | * @count: Number of GPIOs in the list | |
477 | * @return 0 if OK, -ve on error | |
478 | */ | |
479 | int gpio_free_list(struct udevice *dev, struct gpio_desc *desc, int count); | |
480 | ||
481 | /** | |
482 | * gpio_free_list_nodev() - free GPIOs without a device | |
483 | * | |
484 | * This is a version of gpio_free_list() that does not use a | |
485 | * device. Avoid it unless the caller is not yet using driver model | |
486 | */ | |
487 | int gpio_free_list_nodev(struct gpio_desc *desc, int count); | |
488 | ||
489 | /** | |
490 | * dm_gpio_get_value() - Get the value of a GPIO | |
491 | * | |
492 | * This is the driver model version of the existing gpio_get_value() function | |
493 | * and should be used instead of that. | |
494 | * | |
495 | * For now, these functions have a dm_ prefix since they conflict with | |
496 | * existing names. | |
497 | * | |
498 | * @desc: GPIO description containing device, offset and flags, | |
499 | * previously returned by gpio_request_by_name() | |
500 | * @return GPIO value (0 for inactive, 1 for active) or -ve on error | |
501 | */ | |
502 | int dm_gpio_get_value(struct gpio_desc *desc); | |
503 | ||
504 | int dm_gpio_set_value(struct gpio_desc *desc, int value); | |
505 | ||
506 | /** | |
507 | * dm_gpio_set_dir() - Set the direction for a GPIO | |
508 | * | |
509 | * This sets up the direction according tot the provided flags. It will do | |
510 | * nothing unless the direction is actually specified. | |
511 | * | |
512 | * @desc: GPIO description containing device, offset and flags, | |
513 | * previously returned by gpio_request_by_name() | |
514 | * @return 0 if OK, -ve on error | |
515 | */ | |
516 | int dm_gpio_set_dir(struct gpio_desc *desc); | |
517 | ||
518 | /** | |
519 | * dm_gpio_set_dir_flags() - Set direction using specific flags | |
520 | * | |
521 | * This is like dm_gpio_set_dir() except that the flags value is provided | |
522 | * instead of being used from desc->flags. This is needed because in many | |
523 | * cases the GPIO description does not include direction information. | |
524 | * Note that desc->flags is updated by this function. | |
525 | * | |
526 | * @desc: GPIO description containing device, offset and flags, | |
527 | * previously returned by gpio_request_by_name() | |
528 | * @flags: New flags to use | |
529 | * @return 0 if OK, -ve on error, in which case desc->flags is not updated | |
530 | */ | |
531 | int dm_gpio_set_dir_flags(struct gpio_desc *desc, ulong flags); | |
532 | ||
533 | /** | |
534 | * gpio_get_number() - Get the global GPIO number of a GPIO | |
535 | * | |
536 | * This should only be used for debugging or interest. It returns the nummber | |
537 | * that should be used for gpio_get_value() etc. to access this GPIO. | |
538 | * | |
539 | * @desc: GPIO description containing device, offset and flags, | |
540 | * previously returned by gpio_request_by_name() | |
541 | * @return GPIO number, or -ve if not found | |
542 | */ | |
543 | int gpio_get_number(struct gpio_desc *desc); | |
544 | ||
5f533aeb | 545 | #endif /* _ASM_GENERIC_GPIO_H_ */ |