Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2011 The Chromium OS Authors. |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 3 | * Copyright (c) 2011, NVIDIA Corp. All rights reserved. |
Wolfgang Denk | d79de1d | 2013-07-08 09:37:19 +0200 | [diff] [blame] | 4 | * SPDX-License-Identifier: GPL-2.0+ |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 5 | */ |
| 6 | |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 7 | #ifndef _ASM_GENERIC_GPIO_H_ |
| 8 | #define _ASM_GENERIC_GPIO_H_ |
| 9 | |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 10 | /* |
| 11 | * Generic GPIO API for U-Boot |
| 12 | * |
Simon Glass | af0bb3e | 2015-01-05 20:05:30 -0700 | [diff] [blame] | 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 | * |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 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 | */ |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 36 | |
| 37 | /** |
Simon Glass | af0bb3e | 2015-01-05 20:05:30 -0700 | [diff] [blame] | 38 | * @deprecated Please use driver model instead |
Marcel Ziswiler | 8a523c5 | 2014-10-10 17:31:41 +0200 | [diff] [blame] | 39 | * Request a GPIO. This should be called before any of the other functions |
| 40 | * are used on this GPIO. |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 41 | * |
Simon Glass | 0f4517d | 2014-10-04 11:29:42 -0600 | [diff] [blame] | 42 | * Note: With driver model, the label is allocated so there is no need for |
| 43 | * the caller to preserve it. |
| 44 | * |
Nikita Kiryanov | d9a6717 | 2012-11-26 23:06:32 +0000 | [diff] [blame] | 45 | * @param gp GPIO number |
| 46 | * @param label User label for this GPIO |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 47 | * @return 0 if ok, -1 on error |
| 48 | */ |
| 49 | int gpio_request(unsigned gpio, const char *label); |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 50 | |
| 51 | /** |
Simon Glass | af0bb3e | 2015-01-05 20:05:30 -0700 | [diff] [blame] | 52 | * @deprecated Please use driver model instead |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 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 | |
| 60 | /** |
Simon Glass | af0bb3e | 2015-01-05 20:05:30 -0700 | [diff] [blame] | 61 | * @deprecated Please use driver model instead |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 62 | * Make a GPIO an input. |
| 63 | * |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 64 | * @param gpio GPIO number |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 65 | * @return 0 if ok, -1 on error |
| 66 | */ |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 67 | int gpio_direction_input(unsigned gpio); |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 68 | |
| 69 | /** |
Simon Glass | af0bb3e | 2015-01-05 20:05:30 -0700 | [diff] [blame] | 70 | * @deprecated Please use driver model instead |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 71 | * Make a GPIO an output, and set its value. |
| 72 | * |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 73 | * @param gpio GPIO number |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 74 | * @param value GPIO value (0 for low or 1 for high) |
| 75 | * @return 0 if ok, -1 on error |
| 76 | */ |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 77 | int gpio_direction_output(unsigned gpio, int value); |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 78 | |
| 79 | /** |
Simon Glass | af0bb3e | 2015-01-05 20:05:30 -0700 | [diff] [blame] | 80 | * @deprecated Please use driver model instead |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 81 | * Get a GPIO's value. This will work whether the GPIO is an input |
| 82 | * or an output. |
| 83 | * |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 84 | * @param gpio GPIO number |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 85 | * @return 0 if low, 1 if high, -1 on error |
| 86 | */ |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 87 | int gpio_get_value(unsigned gpio); |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 88 | |
| 89 | /** |
Simon Glass | af0bb3e | 2015-01-05 20:05:30 -0700 | [diff] [blame] | 90 | * @deprecated Please use driver model instead |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 91 | * Set an output GPIO's value. The GPIO must already be an output or |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 92 | * this function may have no effect. |
| 93 | * |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 94 | * @param gpio GPIO number |
Simon Glass | 9c35f0e | 2011-10-07 13:53:50 +0000 | [diff] [blame] | 95 | * @param value GPIO value (0 for low or 1 for high) |
| 96 | * @return 0 if ok, -1 on error |
| 97 | */ |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 98 | int gpio_set_value(unsigned gpio, int value); |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 99 | |
Simon Glass | 2d6b923 | 2014-08-11 09:23:52 -0600 | [diff] [blame] | 100 | /* State of a GPIO, as reported by get_function() */ |
Simon Glass | 6e5e6dd | 2014-10-04 11:29:43 -0600 | [diff] [blame] | 101 | enum gpio_func_t { |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 102 | GPIOF_INPUT = 0, |
| 103 | GPIOF_OUTPUT, |
Simon Glass | 2d6b923 | 2014-08-11 09:23:52 -0600 | [diff] [blame] | 104 | GPIOF_UNUSED, /* Not claimed */ |
| 105 | GPIOF_UNKNOWN, /* Not known */ |
| 106 | GPIOF_FUNC, /* Not used as a GPIO */ |
| 107 | |
| 108 | GPIOF_COUNT, |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 109 | }; |
| 110 | |
Heiko Schocher | b74fcb4 | 2014-05-22 12:43:05 +0200 | [diff] [blame] | 111 | struct udevice; |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 112 | |
Simon Glass | ce55529 | 2015-01-05 20:05:27 -0700 | [diff] [blame] | 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 */ |
Simon Glass | 518827e | 2015-05-04 11:31:01 -0600 | [diff] [blame] | 118 | #define GPIOD_IS_IN (1 << 2) /* GPIO is an input */ |
Simon Glass | ce55529 | 2015-01-05 20:05:27 -0700 | [diff] [blame] | 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 | |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 129 | /** |
Simon Glass | 16e1040 | 2015-01-05 20:05:29 -0700 | [diff] [blame] | 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 | |
| 141 | /** |
Simon Glass | 6b1ef59 | 2014-10-04 11:29:44 -0600 | [diff] [blame] | 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 | * |
Simon Glass | af0bb3e | 2015-01-05 20:05:30 -0700 | [diff] [blame] | 152 | * TODO(sjg@chromium.org): This should use struct gpio_desc |
| 153 | * |
Simon Glass | 6b1ef59 | 2014-10-04 11:29:44 -0600 | [diff] [blame] | 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 | |
| 161 | /** |
Simon Glass | 6e5e6dd | 2014-10-04 11:29:43 -0600 | [diff] [blame] | 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 | * |
Simon Glass | af0bb3e | 2015-01-05 20:05:30 -0700 | [diff] [blame] | 166 | * TODO(sjg@chromium.org): This should use struct gpio_desc |
| 167 | * |
Simon Glass | 6e5e6dd | 2014-10-04 11:29:43 -0600 | [diff] [blame] | 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 | * |
Simon Glass | af0bb3e | 2015-01-05 20:05:30 -0700 | [diff] [blame] | 185 | * TODO(sjg@chromium.org): This should use struct gpio_desc |
| 186 | * |
Simon Glass | 6e5e6dd | 2014-10-04 11:29:43 -0600 | [diff] [blame] | 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 | |
| 197 | /** |
Simon Glass | 1b27d60 | 2014-10-04 11:29:49 -0600 | [diff] [blame] | 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 | |
Simon Glass | d3322bb | 2015-01-05 20:05:28 -0700 | [diff] [blame] | 207 | struct fdtdec_phandle_args; |
| 208 | |
Simon Glass | 1b27d60 | 2014-10-04 11:29:49 -0600 | [diff] [blame] | 209 | /** |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 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 | * |
Marcel Ziswiler | 8a523c5 | 2014-10-10 17:31:41 +0200 | [diff] [blame] | 219 | * Also it would be useful to standardise additional functions like |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 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 | * |
Marcel Ziswiler | 8a523c5 | 2014-10-10 17:31:41 +0200 | [diff] [blame] | 232 | * The uclass combines all GPIO devices together to provide a consistent |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 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 { |
Heiko Schocher | b74fcb4 | 2014-05-22 12:43:05 +0200 | [diff] [blame] | 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, |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 241 | int value); |
Heiko Schocher | b74fcb4 | 2014-05-22 12:43:05 +0200 | [diff] [blame] | 242 | int (*get_value)(struct udevice *dev, unsigned offset); |
| 243 | int (*set_value)(struct udevice *dev, unsigned offset, int value); |
Simon Glass | 2d6b923 | 2014-08-11 09:23:52 -0600 | [diff] [blame] | 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 | */ |
Heiko Schocher | b74fcb4 | 2014-05-22 12:43:05 +0200 | [diff] [blame] | 251 | int (*get_function)(struct udevice *dev, unsigned offset); |
Simon Glass | d3322bb | 2015-01-05 20:05:28 -0700 | [diff] [blame] | 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); |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 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 |
Marcel Ziswiler | 8a523c5 | 2014-10-10 17:31:41 +0200 | [diff] [blame] | 285 | * scheme. To do this it maintains some private information about each |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 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. |
Simon Glass | 0f4517d | 2014-10-04 11:29:42 -0600 | [diff] [blame] | 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. |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 301 | */ |
| 302 | struct gpio_dev_priv { |
| 303 | const char *bank_name; |
| 304 | unsigned gpio_count; |
| 305 | unsigned gpio_base; |
Simon Glass | 0f4517d | 2014-10-04 11:29:42 -0600 | [diff] [blame] | 306 | char **name; |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 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 | */ |
Heiko Schocher | b74fcb4 | 2014-05-22 12:43:05 +0200 | [diff] [blame] | 322 | const char *gpio_get_bank_info(struct udevice *dev, int *offset_count); |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 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 | */ |
Heiko Schocher | b74fcb4 | 2014-05-22 12:43:05 +0200 | [diff] [blame] | 335 | int gpio_lookup_name(const char *name, struct udevice **devp, |
Simon Glass | e821d18 | 2014-02-26 15:59:24 -0700 | [diff] [blame] | 336 | unsigned int *offsetp, unsigned int *gpiop); |
| 337 | |
Simon Glass | 2c97a8f | 2014-11-10 18:00:21 -0700 | [diff] [blame] | 338 | /** |
Simon Glass | bef54db | 2015-04-14 21:03:20 -0600 | [diff] [blame] | 339 | * gpio_get_values_as_int() - Turn the values of a list of GPIOs into an int |
Simon Glass | 2c97a8f | 2014-11-10 18:00:21 -0700 | [diff] [blame] | 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 |
Simon Glass | bef54db | 2015-04-14 21:03:20 -0600 | [diff] [blame] | 345 | * @return resulting integer value, or -ve on error |
| 346 | */ |
| 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 |
Simon Glass | 2c97a8f | 2014-11-10 18:00:21 -0700 | [diff] [blame] | 355 | */ |
Simon Glass | bef54db | 2015-04-14 21:03:20 -0600 | [diff] [blame] | 356 | int gpio_claim_vector(const int *gpio_num_array, const char *fmt); |
Jeroen Hofstee | b613b10 | 2014-10-08 22:58:03 +0200 | [diff] [blame] | 357 | |
Simon Glass | 16e1040 | 2015-01-05 20:05:29 -0700 | [diff] [blame] | 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 | |
Joe Hershberger | 334b232 | 2011-11-11 15:55:35 -0600 | [diff] [blame] | 545 | #endif /* _ASM_GENERIC_GPIO_H_ */ |