1 /* 2 * Copyright (c) 2011 The Chromium OS Authors. 3 * Copyright (c) 2011, NVIDIA Corp. All rights reserved. 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 #ifndef _ASM_GENERIC_GPIO_H_ 8 #define _ASM_GENERIC_GPIO_H_ 9 10 /* 11 * Generic GPIO API for U-Boot 12 * 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 * 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 37 /** 38 * @deprecated Please use driver model instead 39 * Request a GPIO. This should be called before any of the other functions 40 * are used on this GPIO. 41 * 42 * Note: With driver model, the label is allocated so there is no need for 43 * the caller to preserve it. 44 * 45 * @param gpio GPIO number 46 * @param label User label for this GPIO 47 * @return 0 if ok, -1 on error 48 */ 49 int gpio_request(unsigned gpio, const char *label); 50 51 /** 52 * @deprecated Please use driver model instead 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 /** 61 * @deprecated Please use driver model instead 62 * Make a GPIO an input. 63 * 64 * @param gpio GPIO number 65 * @return 0 if ok, -1 on error 66 */ 67 int gpio_direction_input(unsigned gpio); 68 69 /** 70 * @deprecated Please use driver model instead 71 * Make a GPIO an output, and set its value. 72 * 73 * @param gpio GPIO number 74 * @param value GPIO value (0 for low or 1 for high) 75 * @return 0 if ok, -1 on error 76 */ 77 int gpio_direction_output(unsigned gpio, int value); 78 79 /** 80 * @deprecated Please use driver model instead 81 * Get a GPIO's value. This will work whether the GPIO is an input 82 * or an output. 83 * 84 * @param gpio GPIO number 85 * @return 0 if low, 1 if high, -1 on error 86 */ 87 int gpio_get_value(unsigned gpio); 88 89 /** 90 * @deprecated Please use driver model instead 91 * Set an output GPIO's value. The GPIO must already be an output or 92 * this function may have no effect. 93 * 94 * @param gpio GPIO number 95 * @param value GPIO value (0 for low or 1 for high) 96 * @return 0 if ok, -1 on error 97 */ 98 int gpio_set_value(unsigned gpio, int value); 99 100 /* State of a GPIO, as reported by get_function() */ 101 enum gpio_func_t { 102 GPIOF_INPUT = 0, 103 GPIOF_OUTPUT, 104 GPIOF_UNUSED, /* Not claimed */ 105 GPIOF_UNKNOWN, /* Not known */ 106 GPIOF_FUNC, /* Not used as a GPIO */ 107 108 GPIOF_COUNT, 109 }; 110 111 struct udevice; 112 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 */ 118 #define GPIOD_IS_IN (1 << 2) /* GPIO is an input */ 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 129 /** 130 * dm_gpio_is_valid() - Check if a GPIO is valid 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 /** 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 * 152 * TODO(sjg@chromium.org): This should use struct gpio_desc 153 * 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 /** 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 * 166 * TODO(sjg@chromium.org): This should use struct gpio_desc 167 * 168 * @dev: Device to check 169 * @offset: Offset of device GPIO to check 170 * @namep: If non-NULL, this is set to the name 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 * 185 * TODO(sjg@chromium.org): This should use struct gpio_desc 186 * 187 * @dev: Device to check 188 * @offset: Offset of device GPIO to check 189 * @namep: If non-NULL, this is set to the name 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 /** 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 207 struct fdtdec_phandle_args; 208 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 * 219 * Also it would be useful to standardise additional functions like 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 * 232 * The uclass combines all GPIO devices together to provide a consistent 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 { 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, 241 int value); 242 int (*get_value)(struct udevice *dev, unsigned offset); 243 int (*set_value)(struct udevice *dev, unsigned offset, int value); 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 */ 251 int (*get_function)(struct udevice *dev, unsigned offset); 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 description 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); 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 285 * scheme. To do this it maintains some private information about each 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. 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. 301 */ 302 struct gpio_dev_priv { 303 const char *bank_name; 304 unsigned gpio_count; 305 unsigned gpio_base; 306 char **name; 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 */ 322 const char *gpio_get_bank_info(struct udevice *dev, int *offset_count); 323 324 /** 325 * dm_gpio_lookup_name() - Look up a named GPIO and return its description 326 * 327 * The name of a GPIO is typically its bank name followed by a number from 0. 328 * For example A0 is the first GPIO in bank A. Each bank is a separate driver 329 * model device. 330 * 331 * @name: Name to look up 332 * @desc: Returns description, on success 333 * @return 0 if OK, -ve on error 334 */ 335 int dm_gpio_lookup_name(const char *name, struct gpio_desc *desc); 336 337 /** 338 * gpio_lookup_name - Look up a GPIO name and return its details 339 * 340 * This is used to convert a named GPIO into a device, offset and GPIO 341 * number. 342 * 343 * @name: GPIO name to look up 344 * @devp: Returns pointer to device which contains this GPIO 345 * @offsetp: Returns the offset number within this device 346 * @gpiop: Returns the absolute GPIO number, numbered from 0 347 */ 348 int gpio_lookup_name(const char *name, struct udevice **devp, 349 unsigned int *offsetp, unsigned int *gpiop); 350 351 /** 352 * gpio_get_values_as_int() - Turn the values of a list of GPIOs into an int 353 * 354 * This puts the value of the first GPIO into bit 0, the second into bit 1, 355 * etc. then returns the resulting integer. 356 * 357 * @gpio_list: List of GPIOs to collect 358 * @return resulting integer value, or -ve on error 359 */ 360 int gpio_get_values_as_int(const int *gpio_list); 361 362 /** 363 * gpio_claim_vector() - claim a number of GPIOs for input 364 * 365 * @gpio_num_array: array of gpios to claim, terminated by -1 366 * @fmt: format string for GPIO names, e.g. "board_id%d" 367 * @return 0 if OK, -ve on error 368 */ 369 int gpio_claim_vector(const int *gpio_num_array, const char *fmt); 370 371 /** 372 * gpio_request_by_name() - Locate and request a GPIO by name 373 * 374 * This operates by looking up the given list name in the device (device 375 * tree property) and requesting the GPIO for use. The property must exist 376 * in @dev's node. 377 * 378 * Use @flags to specify whether the GPIO should be an input or output. In 379 * principle this can also come from the device tree binding but most 380 * bindings don't provide this information. Specifically, when the GPIO uclass 381 * calls the xlate() method, it can return default flags, which are then 382 * ORed with this @flags. 383 * 384 * If we find that requesting the GPIO is not always needed we could add a 385 * new function or a new GPIOD_NO_REQUEST flag. 386 * 387 * At present driver model has no reference counting so if one device 388 * requests a GPIO which subsequently is unbound, the @desc->dev pointer 389 * will be invalid. However this will only happen if the GPIO device is 390 * unbound, not if it is removed, so this seems like a reasonable limitation 391 * for now. There is no real use case for unbinding drivers in normal 392 * operation. 393 * 394 * The device tree binding is doc/device-tree-bindings/gpio/gpio.txt in 395 * generate terms and each specific device may add additional details in 396 * a binding file in the same directory. 397 * 398 * @dev: Device requesting the GPIO 399 * @list_name: Name of GPIO list (e.g. "board-id-gpios") 400 * @index: Index number of the GPIO in that list use request (0=first) 401 * @desc: Returns GPIO description information. If there is no such 402 * GPIO, dev->dev will be NULL. 403 * @flags: Indicates the GPIO input/output settings (GPIOD_...) 404 * @return 0 if OK, -ENOENT if the GPIO does not exist, -EINVAL if there is 405 * something wrong with the list, or other -ve for another error (e.g. 406 * -EBUSY if a GPIO was already requested) 407 */ 408 int gpio_request_by_name(struct udevice *dev, const char *list_name, 409 int index, struct gpio_desc *desc, int flags); 410 411 /** 412 * gpio_request_list_by_name() - Request a list of GPIOs 413 * 414 * Reads all the GPIOs from a list and requests them. See 415 * gpio_request_by_name() for additional details. Lists should not be 416 * misused to hold unrelated or optional GPIOs. They should only be used 417 * for things like parallel data lines. A zero phandle terminates the list 418 * the list. 419 * 420 * This function will either succeed, and request all GPIOs in the list, or 421 * fail and request none (it will free already-requested GPIOs in case of 422 * an error part-way through). 423 * 424 * @dev: Device requesting the GPIO 425 * @list_name: Name of GPIO list (e.g. "board-id-gpios") 426 * @desc_list: Returns a list of GPIO description information 427 * @max_count: Maximum number of GPIOs to return (@desc_list must be at least 428 * this big) 429 * @flags: Indicates the GPIO input/output settings (GPIOD_...) 430 * @return number of GPIOs requested, or -ve on error 431 */ 432 int gpio_request_list_by_name(struct udevice *dev, const char *list_name, 433 struct gpio_desc *desc_list, int max_count, 434 int flags); 435 436 /** 437 * dm_gpio_request() - manually request a GPIO 438 * 439 * Note: This function should only be used for testing / debugging. Instead. 440 * use gpio_request_by_name() to pull GPIOs from the device tree. 441 * 442 * @desc: GPIO description of GPIO to request (see dm_gpio_lookup_name()) 443 * @label: Label to attach to the GPIO while claimed 444 * @return 0 if OK, -ve on error 445 */ 446 int dm_gpio_request(struct gpio_desc *desc, const char *label); 447 448 /** 449 * gpio_get_list_count() - Returns the number of GPIOs in a list 450 * 451 * Counts the GPIOs in a list. See gpio_request_by_name() for additional 452 * details. 453 * 454 * @dev: Device requesting the GPIO 455 * @list_name: Name of GPIO list (e.g. "board-id-gpios") 456 * @return number of GPIOs (0 for an empty property) or -ENOENT if the list 457 * does not exist 458 */ 459 int gpio_get_list_count(struct udevice *dev, const char *list_name); 460 461 /** 462 * gpio_request_by_name_nodev() - request GPIOs without a device 463 * 464 * This is a version of gpio_request_list_by_name() that does not use a 465 * device. Avoid it unless the caller is not yet using driver model 466 */ 467 int gpio_request_by_name_nodev(const void *blob, int node, 468 const char *list_name, 469 int index, struct gpio_desc *desc, int flags); 470 471 /** 472 * gpio_request_list_by_name_nodev() - request GPIOs without a device 473 * 474 * This is a version of gpio_request_list_by_name() that does not use a 475 * device. Avoid it unless the caller is not yet using driver model 476 */ 477 int gpio_request_list_by_name_nodev(const void *blob, int node, 478 const char *list_name, 479 struct gpio_desc *desc_list, int max_count, 480 int flags); 481 482 /** 483 * dm_gpio_free() - Free a single GPIO 484 * 485 * This frees a single GPIOs previously returned from gpio_request_by_name(). 486 * 487 * @dev: Device which requested the GPIO 488 * @desc: GPIO to free 489 * @return 0 if OK, -ve on error 490 */ 491 int dm_gpio_free(struct udevice *dev, struct gpio_desc *desc); 492 493 /** 494 * gpio_free_list() - Free a list of GPIOs 495 * 496 * This frees a list of GPIOs previously returned from 497 * gpio_request_list_by_name(). 498 * 499 * @dev: Device which requested the GPIOs 500 * @desc: List of GPIOs to free 501 * @count: Number of GPIOs in the list 502 * @return 0 if OK, -ve on error 503 */ 504 int gpio_free_list(struct udevice *dev, struct gpio_desc *desc, int count); 505 506 /** 507 * gpio_free_list_nodev() - free GPIOs without a device 508 * 509 * This is a version of gpio_free_list() that does not use a 510 * device. Avoid it unless the caller is not yet using driver model 511 */ 512 int gpio_free_list_nodev(struct gpio_desc *desc, int count); 513 514 /** 515 * dm_gpio_get_value() - Get the value of a GPIO 516 * 517 * This is the driver model version of the existing gpio_get_value() function 518 * and should be used instead of that. 519 * 520 * For now, these functions have a dm_ prefix since they conflict with 521 * existing names. 522 * 523 * @desc: GPIO description containing device, offset and flags, 524 * previously returned by gpio_request_by_name() 525 * @return GPIO value (0 for inactive, 1 for active) or -ve on error 526 */ 527 int dm_gpio_get_value(struct gpio_desc *desc); 528 529 int dm_gpio_set_value(struct gpio_desc *desc, int value); 530 531 /** 532 * dm_gpio_set_dir() - Set the direction for a GPIO 533 * 534 * This sets up the direction according tot the provided flags. It will do 535 * nothing unless the direction is actually specified. 536 * 537 * @desc: GPIO description containing device, offset and flags, 538 * previously returned by gpio_request_by_name() 539 * @return 0 if OK, -ve on error 540 */ 541 int dm_gpio_set_dir(struct gpio_desc *desc); 542 543 /** 544 * dm_gpio_set_dir_flags() - Set direction using specific flags 545 * 546 * This is like dm_gpio_set_dir() except that the flags value is provided 547 * instead of being used from desc->flags. This is needed because in many 548 * cases the GPIO description does not include direction information. 549 * Note that desc->flags is updated by this function. 550 * 551 * @desc: GPIO description containing device, offset and flags, 552 * previously returned by gpio_request_by_name() 553 * @flags: New flags to use 554 * @return 0 if OK, -ve on error, in which case desc->flags is not updated 555 */ 556 int dm_gpio_set_dir_flags(struct gpio_desc *desc, ulong flags); 557 558 /** 559 * gpio_get_number() - Get the global GPIO number of a GPIO 560 * 561 * This should only be used for debugging or interest. It returns the number 562 * that should be used for gpio_get_value() etc. to access this GPIO. 563 * 564 * @desc: GPIO description containing device, offset and flags, 565 * previously returned by gpio_request_by_name() 566 * @return GPIO number, or -ve if not found 567 */ 568 int gpio_get_number(struct gpio_desc *desc); 569 570 #endif /* _ASM_GENERIC_GPIO_H_ */ 571