1/* SPDX-License-Identifier: GPL-2.0+ */ 2/* 3 * Copyright (c) 2011 The Chromium OS Authors. 4 * Copyright (c) 2011, NVIDIA Corp. All rights reserved. 5 */ 6 7#ifndef _ASM_GENERIC_GPIO_H_ 8#define _ASM_GENERIC_GPIO_H_ 9 10#include <dm/ofnode.h> 11#include <linux/bitops.h> 12 13struct acpi_gpio; 14struct ofnode_phandle_args; 15 16/* 17 * Generic GPIO API for U-Boot 18 * 19 * -- 20 * NB: This is deprecated. Please use the driver model functions instead: 21 * 22 * - gpio_request_by_name() 23 * - dm_gpio_get_value() etc. 24 * 25 * For now we need a dm_ prefix on some functions to avoid name collision. 26 * -- 27 * 28 * GPIOs are numbered from 0 to GPIO_COUNT-1 which value is defined 29 * by the SOC/architecture. 30 * 31 * Each GPIO can be an input or output. If an input then its value can 32 * be read as 0 or 1. If an output then its value can be set to 0 or 1. 33 * If you try to write an input then the value is undefined. If you try 34 * to read an output, barring something very unusual, you will get 35 * back the value of the output that you previously set. 36 * 37 * In some cases the operation may fail, for example if the GPIO number 38 * is out of range, or the GPIO is not available because its pin is 39 * being used by another function. In that case, functions may return 40 * an error value of -1. 41 */ 42 43/** 44 * @deprecated Please use driver model instead 45 * Request a GPIO. This should be called before any of the other functions 46 * are used on this GPIO. 47 * 48 * Note: With driver model, the label is allocated so there is no need for 49 * the caller to preserve it. 50 * 51 * @param gpio GPIO number 52 * @param label User label for this GPIO 53 * Return: 0 if ok, -1 on error 54 */ 55int gpio_request(unsigned gpio, const char *label); 56 57/** 58 * @deprecated Please use driver model instead 59 * Stop using the GPIO. This function should not alter pin configuration. 60 * 61 * @param gpio GPIO number 62 * Return: 0 if ok, -1 on error 63 */ 64int gpio_free(unsigned gpio); 65 66/** 67 * @deprecated Please use driver model instead 68 * Make a GPIO an input. 69 * 70 * @param gpio GPIO number 71 * Return: 0 if ok, -1 on error 72 */ 73int gpio_direction_input(unsigned gpio); 74 75/** 76 * @deprecated Please use driver model instead 77 * Make a GPIO an output, and set its value. 78 * 79 * @param gpio GPIO number 80 * @param value GPIO value (0 for low or 1 for high) 81 * Return: 0 if ok, -1 on error 82 */ 83int gpio_direction_output(unsigned gpio, int value); 84 85/** 86 * @deprecated Please use driver model instead 87 * Get a GPIO's value. This will work whether the GPIO is an input 88 * or an output. 89 * 90 * @param gpio GPIO number 91 * Return: 0 if low, 1 if high, -1 on error 92 */ 93int gpio_get_value(unsigned gpio); 94 95/** 96 * @deprecated Please use driver model instead 97 * Set an output GPIO's value. The GPIO must already be an output or 98 * this function may have no effect. 99 * 100 * @param gpio GPIO number 101 * @param value GPIO value (0 for low or 1 for high) 102 * Return: 0 if ok, -1 on error 103 */ 104int gpio_set_value(unsigned gpio, int value); 105 106/* State of a GPIO, as reported by get_function() */ 107enum gpio_func_t { 108 GPIOF_INPUT = 0, 109 GPIOF_OUTPUT, 110 GPIOF_UNUSED, /* Not claimed */ 111 GPIOF_UNKNOWN, /* Not known */ 112 GPIOF_FUNC, /* Not used as a GPIO */ 113 114 GPIOF_COUNT, 115}; 116 117struct udevice; 118 119struct gpio_desc { 120 struct udevice *dev; /* Device, NULL for invalid GPIO */ 121 unsigned long flags; 122#define GPIOD_IS_OUT BIT(1) /* GPIO is an output */ 123#define GPIOD_IS_IN BIT(2) /* GPIO is an input */ 124#define GPIOD_ACTIVE_LOW BIT(3) /* GPIO is active when value is low */ 125#define GPIOD_IS_OUT_ACTIVE BIT(4) /* set output active */ 126#define GPIOD_OPEN_DRAIN BIT(5) /* GPIO is open drain type */ 127#define GPIOD_OPEN_SOURCE BIT(6) /* GPIO is open source type */ 128#define GPIOD_PULL_UP BIT(7) /* GPIO has pull-up enabled */ 129#define GPIOD_PULL_DOWN BIT(8) /* GPIO has pull-down enabled */ 130#define GPIOD_IS_AF BIT(9) /* GPIO is an alternate function */ 131 132/* Flags for updating the above */ 133#define GPIOD_MASK_DIR (GPIOD_IS_OUT | GPIOD_IS_IN | \ 134 GPIOD_IS_OUT_ACTIVE) 135#define GPIOD_MASK_DSTYPE (GPIOD_OPEN_DRAIN | GPIOD_OPEN_SOURCE) 136#define GPIOD_MASK_PULL (GPIOD_PULL_UP | GPIOD_PULL_DOWN) 137 138 uint offset; /* GPIO offset within the device */ 139 /* 140 * We could consider adding the GPIO label in here. Possibly we could 141 * use this structure for internal GPIO information. 142 */ 143}; 144 145/** 146 * dm_gpio_is_valid() - Check if a GPIO is valid 147 * 148 * @desc: GPIO description containing device, offset and flags, 149 * previously returned by gpio_request_by_name() 150 * Return: true if valid, false if not 151 */ 152static inline bool dm_gpio_is_valid(const struct gpio_desc *desc) 153{ 154 return desc->dev != NULL; 155} 156 157/** 158 * gpio_get_status() - get the current GPIO status as a string 159 * 160 * Obtain the current GPIO status as a string which can be presented to the 161 * user. A typical string is: 162 * 163 * "b4: in: 1 [x] sdmmc_cd" 164 * 165 * which means this is GPIO bank b, offset 4, currently set to input, current 166 * value 1, [x] means that it is requested and the owner is 'sdmmc_cd' 167 * 168 * TODO(sjg@chromium.org): This should use struct gpio_desc 169 * 170 * @dev: Device to check 171 * @offset: Offset of device GPIO to check 172 * @buf: Place to put string 173 * @buffsize: Size of string including \0 174 */ 175int gpio_get_status(struct udevice *dev, int offset, char *buf, int buffsize); 176 177/** 178 * gpio_get_function() - get the current function for a GPIO pin 179 * 180 * Note this returns GPIOF_UNUSED if the GPIO is not requested. 181 * 182 * TODO(sjg@chromium.org): This should use struct gpio_desc 183 * 184 * @dev: Device to check 185 * @offset: Offset of device GPIO to check 186 * @namep: If non-NULL, this is set to the name given when the GPIO 187 * was requested, or -1 if it has not been requested 188 * Return: -ENODATA if the driver returned an unknown function, 189 * -ENODEV if the device is not active, -EINVAL if the offset is invalid. 190 * GPIOF_UNUSED if the GPIO has not been requested. Otherwise returns the 191 * function from enum gpio_func_t. 192 */ 193int gpio_get_function(struct udevice *dev, int offset, const char **namep); 194 195/** 196 * gpio_get_raw_function() - get the current raw function for a GPIO pin 197 * 198 * Note this does not return GPIOF_UNUSED - it will always return the GPIO 199 * driver's view of a pin function, even if it is not correctly set up. 200 * 201 * TODO(sjg@chromium.org): This should use struct gpio_desc 202 * 203 * @dev: Device to check 204 * @offset: Offset of device GPIO to check 205 * @namep: If non-NULL, this is set to the name given when the GPIO 206 * was requested, or -1 if it has not been requested 207 * Return: -ENODATA if the driver returned an unknown function, 208 * -ENODEV if the device is not active, -EINVAL if the offset is invalid. 209 * Otherwise returns the function from enum gpio_func_t. 210 */ 211int gpio_get_raw_function(struct udevice *dev, int offset, const char **namep); 212 213/** 214 * gpio_requestf() - request a GPIO using a format string for the owner 215 * 216 * This is a helper function for gpio_request(). It allows you to provide 217 * a printf()-format string for the GPIO owner. It calls gpio_request() with 218 * the string that is created 219 */ 220int gpio_requestf(unsigned gpio, const char *fmt, ...) 221 __attribute__ ((format (__printf__, 2, 3))); 222 223struct fdtdec_phandle_args; 224 225/** 226 * gpio_flags_xlate() - convert DT flags to internal flags 227 * 228 * This routine converts the GPIO_* flags from the generic DT binding to the 229 * GPIOD_* flags used internally. It can be called from driver xlate functions. 230 */ 231unsigned long gpio_flags_xlate(uint32_t arg); 232 233/** 234 * gpio_xlate_offs_flags() - implementation for common use of dm_gpio_ops.xlate 235 * 236 * This routine sets the offset field to args[0] and the flags field to 237 * GPIOD_ACTIVE_LOW if the GPIO_ACTIVE_LOW flag is present in args[1]. 238 */ 239int gpio_xlate_offs_flags(struct udevice *dev, struct gpio_desc *desc, 240 struct ofnode_phandle_args *args); 241 242/** 243 * struct struct dm_gpio_ops - Driver model GPIO operations 244 * 245 * Refer to functions above for description. These function largely copy 246 * the old API. 247 * 248 * This is trying to be close to Linux GPIO API. Once the U-Boot uses the 249 * new DM GPIO API, this should be really easy to flip over to the Linux 250 * GPIO API-alike interface. 251 * 252 * Also it would be useful to standardise additional functions like 253 * pullup, slew rate and drive strength. 254 * 255 * gpio_request() and gpio_free() are optional - if NULL then they will 256 * not be called. 257 * 258 * Note that @offset is the offset from the base GPIO of the device. So 259 * offset 0 is the device's first GPIO and offset o-1 is the last GPIO, 260 * where o is the number of GPIO lines controlled by the device. A device 261 * is typically used to control a single bank of GPIOs. Within complex 262 * SoCs there may be many banks and therefore many devices all referring 263 * to the different IO addresses within the SoC. 264 * 265 * The uclass combines all GPIO devices together to provide a consistent 266 * numbering from 0 to n-1, where n is the number of GPIOs in total across 267 * all devices. Be careful not to confuse offset with gpio in the parameters. 268 */ 269struct dm_gpio_ops { 270 int (*request)(struct udevice *dev, unsigned offset, const char *label); 271 int (*rfree)(struct udevice *dev, unsigned int offset); 272 273 /** 274 * direction_input() - deprecated 275 * 276 * Equivalent to set_flags(...GPIOD_IS_IN) 277 */ 278 int (*direction_input)(struct udevice *dev, unsigned offset); 279 280 /** 281 * direction_output() - deprecated 282 * 283 * Equivalent to set_flags(...GPIOD_IS_OUT) with GPIOD_IS_OUT_ACTIVE 284 * also set if @value 285 */ 286 int (*direction_output)(struct udevice *dev, unsigned offset, 287 int value); 288 289 int (*get_value)(struct udevice *dev, unsigned offset); 290 291 /** 292 * set_value() - Sets the GPIO value of an output 293 * 294 * If the driver provides an @set_flags() method then that is used 295 * in preference to this, with GPIOD_IS_OUT_ACTIVE set according to 296 * @value. 297 */ 298 int (*set_value)(struct udevice *dev, unsigned offset, int value); 299 /** 300 * get_function() Get the GPIO function 301 * 302 * @dev: Device to check 303 * @offset: GPIO offset within that device 304 * @return current function - GPIOF_... 305 */ 306 int (*get_function)(struct udevice *dev, unsigned offset); 307 308 /** 309 * xlate() - Translate phandle arguments into a GPIO description 310 * 311 * This function should set up the fields in desc according to the 312 * information in the arguments. The uclass will have set up: 313 * 314 * @desc->dev to @dev 315 * @desc->flags to 0 316 * @desc->offset to 0 317 * 318 * This method is optional and defaults to gpio_xlate_offs_flags, 319 * which will parse offset and the GPIO_ACTIVE_LOW flag in the first 320 * two arguments. 321 * 322 * Note that @dev is passed in as a parameter to follow driver model 323 * uclass conventions, even though it is already available as 324 * desc->dev. 325 * 326 * @dev: GPIO device 327 * @desc: Place to put GPIO description 328 * @args: Arguments provided in description 329 * @return 0 if OK, -ve on error 330 */ 331 int (*xlate)(struct udevice *dev, struct gpio_desc *desc, 332 struct ofnode_phandle_args *args); 333 334 /** 335 * set_flags() - Adjust GPIO flags 336 * 337 * This function should set up the GPIO configuration according to the 338 * information provided by @flags. 339 * 340 * If any flags cannot be set (e.g. the driver or hardware does not 341 * support them or this particular GPIO does not have the requested 342 * feature), the driver should return -EINVAL. 343 * 344 * The uclass checks that flags do not obviously conflict (e.g. input 345 * and output). If the driver finds other conflicts it should return 346 * -ERECALLCONFLICT 347 * 348 * Note that GPIOD_ACTIVE_LOW should be ignored, since the uclass 349 * adjusts for it automatically. For example, for an output GPIO, 350 * GPIOD_ACTIVE_LOW causes GPIOD_IS_OUT_ACTIVE to be inverted by the 351 * uclass, so the driver always sees the value that should be set at the 352 * pin (1=high, 0=low). 353 * 354 * This method is required and should be implemented by new drivers. At 355 * some point, it will supersede direction_input() and 356 * direction_output(), which wil be removed. 357 * 358 * @dev: GPIO device 359 * @offset: GPIO offset within that device 360 * @flags: New flags value (GPIOD_...) 361 * 362 * @return 0 if OK, -EINVAL if unsupported, -ERECALLCONFLICT if flags 363 * conflict in some * non-obvious way and were not applied, 364 * other -ve on error 365 */ 366 int (*set_flags)(struct udevice *dev, unsigned int offset, ulong flags); 367 368 /** 369 * get_flags() - Get GPIO flags 370 * 371 * This function return the GPIO flags used. It should read this from 372 * the hardware directly. 373 * 374 * This method is optional. 375 * 376 * @dev: GPIO device 377 * @offset: GPIO offset within that device 378 * @flagsp: place to put the current flags value 379 * @return 0 if OK, -ve on error 380 */ 381 int (*get_flags)(struct udevice *dev, unsigned int offset, 382 ulong *flagsp); 383 384#if CONFIG_IS_ENABLED(ACPIGEN) 385 /** 386 * get_acpi() - Get the ACPI info for a GPIO 387 * 388 * This converts a GPIO to an ACPI structure for adding to the ACPI 389 * tables. 390 * 391 * @desc: GPIO description to convert 392 * @gpio: Output ACPI GPIO information 393 * @return ACPI pin number or -ve on error 394 */ 395 int (*get_acpi)(const struct gpio_desc *desc, struct acpi_gpio *gpio); 396#endif 397}; 398 399/** 400 * struct gpio_dev_priv - information about a device used by the uclass 401 * 402 * The uclass combines all active GPIO devices into a unified numbering 403 * scheme. To do this it maintains some private information about each 404 * device. 405 * 406 * To implement driver model support in your GPIO driver, add a probe 407 * handler, and set @gpio_count and @bank_name correctly in that handler. 408 * This tells the uclass the name of the GPIO bank and the number of GPIOs 409 * it contains. 410 * 411 * @bank_name: Name of the GPIO device (e.g 'a' means GPIOs will be called 412 * 'A0', 'A1', etc. 413 * @gpio_count: Number of GPIOs in this device 414 * @gpio_base: Base GPIO number for this device. For the first active device 415 * this will be 0; the numbering for others will follow sequentially so that 416 * @gpio_base for device 1 will equal the number of GPIOs in device 0. 417 * @claimed: Array of bits indicating which GPIOs in the bank are claimed. 418 * @name: Array of pointers to the name for each GPIO in this bank. The 419 * value of the pointer will be NULL if the GPIO has not been claimed. 420 */ 421struct gpio_dev_priv { 422 const char *bank_name; 423 unsigned gpio_count; 424 unsigned gpio_base; 425 u32 *claimed; 426 char **name; 427}; 428 429/* Access the GPIO operations for a device */ 430#define gpio_get_ops(dev) ((struct dm_gpio_ops *)(dev)->driver->ops) 431 432/** 433 * gpio_get_bank_info - Return information about a GPIO bank/device 434 * 435 * This looks up a device and returns both its GPIO base name and the number 436 * of GPIOs it controls. 437 * 438 * @dev: Device to look up 439 * @offset_count: Returns number of GPIOs within this bank 440 * Return: bank name of this device 441 */ 442const char *gpio_get_bank_info(struct udevice *dev, int *offset_count); 443 444/** 445 * dm_gpio_lookup_name() - Look up a named GPIO and return its description 446 * 447 * The name of a GPIO is typically its bank name followed by a number from 0. 448 * For example A0 is the first GPIO in bank A. Each bank is a separate driver 449 * model device. 450 * 451 * @name: Name to look up 452 * @desc: Returns description, on success 453 * Return: 0 if OK, -ve on error 454 */ 455int dm_gpio_lookup_name(const char *name, struct gpio_desc *desc); 456 457/** 458 * gpio_hog_lookup_name() - Look up a named GPIO and return the gpio descr. 459 * 460 * @name: Name to look up 461 * @desc: Returns GPIO description, on success, else NULL 462 * @return: Returns 0 if OK, else -ENODEV 463 */ 464int gpio_hog_lookup_name(const char *name, struct gpio_desc **desc); 465 466/** 467 * gpio_lookup_name - Look up a GPIO name and return its details 468 * 469 * This is used to convert a named GPIO into a device, offset and GPIO 470 * number. 471 * 472 * @name: GPIO name to look up 473 * @devp: Returns pointer to device which contains this GPIO 474 * @offsetp: Returns the offset number within this device 475 * @gpiop: Returns the absolute GPIO number, numbered from 0 476 */ 477int gpio_lookup_name(const char *name, struct udevice **devp, 478 unsigned int *offsetp, unsigned int *gpiop); 479 480/** 481 * gpio_get_values_as_int() - Turn the values of a list of GPIOs into an int 482 * 483 * This puts the value of the first GPIO into bit 0, the second into bit 1, 484 * etc. then returns the resulting integer. 485 * 486 * @gpio_list: List of GPIOs to collect 487 * Return: resulting integer value, or -ve on error 488 */ 489int gpio_get_values_as_int(const int *gpio_list); 490 491/** 492 * dm_gpio_get_values_as_int() - Turn the values of a list of GPIOs into an int 493 * 494 * This puts the value of the first GPIO into bit 0, the second into bit 1, 495 * etc. then returns the resulting integer. 496 * 497 * @desc_list: List of GPIOs to collect 498 * @count: Number of GPIOs 499 * Return: resulting integer value, or -ve on error 500 */ 501int dm_gpio_get_values_as_int(const struct gpio_desc *desc_list, int count); 502 503/** 504 * dm_gpio_get_values_as_int_base3() - Create a base-3 int from a list of GPIOs 505 * 506 * This uses pull-ups/pull-downs to figure out whether a GPIO line is externally 507 * pulled down, pulled up or floating. This allows three different strap values 508 * for each pin: 509 * 0 : external pull-down 510 * 1 : external pull-up 511 * 2 : floating 512 * 513 * With this it is possible to obtain more combinations from the same number of 514 * strapping pins, when compared to dm_gpio_get_values_as_int(). The external 515 * pull resistors should be made stronger that the internal SoC pull resistors, 516 * for this to work. 517 * 518 * With 2 pins, 6 combinations are possible, compared with 4 519 * With 3 pins, 27 are possible, compared with 8 520 * 521 * @desc_list: List of GPIOs to collect 522 * @count: Number of GPIOs 523 * Return: resulting integer value, or -ve on error 524 */ 525int dm_gpio_get_values_as_int_base3(struct gpio_desc *desc_list, 526 int count); 527 528/** 529 * gpio_claim_vector() - claim a number of GPIOs for input 530 * 531 * @gpio_num_array: array of gpios to claim, terminated by -1 532 * @fmt: format string for GPIO names, e.g. "board_id%d" 533 * Return: 0 if OK, -ve on error 534 */ 535int gpio_claim_vector(const int *gpio_num_array, const char *fmt); 536 537/** 538 * gpio_request_by_name() - Locate and request a GPIO by name 539 * 540 * This operates by looking up the given list name in the device (device 541 * tree property) and requesting the GPIO for use. The property must exist 542 * in @dev's node. 543 * 544 * Use @flags to specify whether the GPIO should be an input or output. In 545 * principle this can also come from the device tree binding but most 546 * bindings don't provide this information. Specifically, when the GPIO uclass 547 * calls the xlate() method, it can return default flags, which are then 548 * ORed with this @flags. 549 * 550 * If we find that requesting the GPIO is not always needed we could add a 551 * new function or a new GPIOD_NO_REQUEST flag. 552 * 553 * At present driver model has no reference counting so if one device 554 * requests a GPIO which subsequently is unbound, the @desc->dev pointer 555 * will be invalid. However this will only happen if the GPIO device is 556 * unbound, not if it is removed, so this seems like a reasonable limitation 557 * for now. There is no real use case for unbinding drivers in normal 558 * operation. 559 * 560 * The device tree binding is doc/device-tree-bindings/gpio/gpio.txt in 561 * generate terms and each specific device may add additional details in 562 * a binding file in the same directory. 563 * 564 * @dev: Device requesting the GPIO 565 * @list_name: Name of GPIO list (e.g. "board-id-gpios") 566 * @index: Index number of the GPIO in that list use request (0=first) 567 * @desc: Returns GPIO description information. If there is no such 568 * GPIO, @desc->dev will be NULL. 569 * @flags: Indicates the GPIO input/output settings (GPIOD_...) 570 * Return: 0 if OK, -ENOENT if the GPIO does not exist, -EINVAL if there is 571 * something wrong with the list, or other -ve for another error (e.g. 572 * -EBUSY if a GPIO was already requested) 573 */ 574int gpio_request_by_name(struct udevice *dev, const char *list_name, 575 int index, struct gpio_desc *desc, int flags); 576 577/* gpio_request_by_line_name - Locate and request a GPIO by line name 578 * 579 * Request a GPIO using the offset of the provided line name in the 580 * gpio-line-names property found in the OF node of the GPIO udevice. 581 * 582 * This allows boards to implement common behaviours using GPIOs while not 583 * requiring specific GPIO offsets be used. 584 * 585 * @dev: An instance of a GPIO controller udevice, or NULL to search 586 * all GPIO controller devices 587 * @line_name: The name of the GPIO (e.g. "bmc-secure-boot") 588 * @desc: A GPIO descriptor that is populated with the requested GPIO 589 * upon return 590 * @flags: The GPIO settings apply to the request 591 * @return 0 if the named line was found and requested successfully, or a 592 * negative error code if the GPIO cannot be found or the request failed. 593 */ 594int gpio_request_by_line_name(struct udevice *dev, const char *line_name, 595 struct gpio_desc *desc, int flags); 596 597/** 598 * gpio_request_list_by_name() - Request a list of GPIOs 599 * 600 * Reads all the GPIOs from a list and requests them. See 601 * gpio_request_by_name() for additional details. Lists should not be 602 * misused to hold unrelated or optional GPIOs. They should only be used 603 * for things like parallel data lines. A zero phandle terminates the list 604 * the list. 605 * 606 * This function will either succeed, and request all GPIOs in the list, or 607 * fail and request none (it will free already-requested GPIOs in case of 608 * an error part-way through). 609 * 610 * @dev: Device requesting the GPIO 611 * @list_name: Name of GPIO list (e.g. "board-id-gpios") 612 * @desc_list: Returns a list of GPIO description information 613 * @max_count: Maximum number of GPIOs to return (@desc_list must be at least 614 * this big) 615 * @flags: Indicates the GPIO input/output settings (GPIOD_...) 616 * Return: number of GPIOs requested, or -ve on error 617 */ 618int gpio_request_list_by_name(struct udevice *dev, const char *list_name, 619 struct gpio_desc *desc_list, int max_count, 620 int flags); 621 622/** 623 * dm_gpio_request() - manually request a GPIO 624 * 625 * Note: This function should only be used for testing / debugging. Instead. 626 * use gpio_request_by_name() to pull GPIOs from the device tree. 627 * 628 * @desc: GPIO description of GPIO to request (see dm_gpio_lookup_name()) 629 * @label: Label to attach to the GPIO while claimed 630 * Return: 0 if OK, -ve on error 631 */ 632int dm_gpio_request(struct gpio_desc *desc, const char *label); 633 634struct phandle_2_arg; 635int gpio_request_by_phandle(struct udevice *dev, 636 const struct phandle_2_arg *cells, 637 struct gpio_desc *desc, int flags); 638 639/** 640 * gpio_get_list_count() - Returns the number of GPIOs in a list 641 * 642 * Counts the GPIOs in a list. See gpio_request_by_name() for additional 643 * details. 644 * 645 * @dev: Device requesting the GPIO 646 * @list_name: Name of GPIO list (e.g. "board-id-gpios") 647 * Return: number of GPIOs (0 for an empty property) or -ENOENT if the list 648 * does not exist 649 */ 650int gpio_get_list_count(struct udevice *dev, const char *list_name); 651 652/** 653 * gpio_request_by_name_nodev() - request GPIOs without a device 654 * 655 * This is a version of gpio_request_list_by_name() that does not use a 656 * device. Avoid it unless the caller is not yet using driver model 657 */ 658int gpio_request_by_name_nodev(ofnode node, const char *list_name, int index, 659 struct gpio_desc *desc, int flags); 660 661/** 662 * gpio_request_list_by_name_nodev() - request GPIOs without a device 663 * 664 * This is a version of gpio_request_list_by_name() that does not use a 665 * device. Avoid it unless the caller is not yet using driver model 666 */ 667int gpio_request_list_by_name_nodev(ofnode node, const char *list_name, 668 struct gpio_desc *desc_list, int max_count, 669 int flags); 670 671/** 672 * gpio_dev_request_index() - request single GPIO from gpio device 673 * 674 * @dev: GPIO device 675 * @nodename: Name of node for which gpio gets requested, used 676 * for the gpio label name 677 * @list_name: Name of GPIO list (e.g. "board-id-gpios") 678 * @index: Index number of the GPIO in that list use request (0=first) 679 * @flags: GPIOD_* flags 680 * @dtflags: GPIO flags read from DT defined see GPIOD_* 681 * @desc: returns GPIO descriptor filled from this function 682 * @return: return value from gpio_request_tail() 683 */ 684int gpio_dev_request_index(struct udevice *dev, const char *nodename, 685 char *list_name, int index, int flags, 686 int dtflags, struct gpio_desc *desc); 687 688/** 689 * dm_gpio_free() - Free a single GPIO 690 * 691 * This frees a single GPIOs previously returned from gpio_request_by_name(). 692 * 693 * @dev: Device which requested the GPIO 694 * @desc: GPIO to free 695 * Return: 0 if OK, -ve on error 696 */ 697int dm_gpio_free(struct udevice *dev, struct gpio_desc *desc); 698 699/** 700 * gpio_free_list() - Free a list of GPIOs 701 * 702 * This frees a list of GPIOs previously returned from 703 * gpio_request_list_by_name(). 704 * 705 * @dev: Device which requested the GPIOs 706 * @desc: List of GPIOs to free 707 * @count: Number of GPIOs in the list 708 * Return: 0 if OK, -ve on error 709 */ 710int gpio_free_list(struct udevice *dev, struct gpio_desc *desc, int count); 711 712/** 713 * gpio_free_list_nodev() - free GPIOs without a device 714 * 715 * This is a version of gpio_free_list() that does not use a 716 * device. Avoid it unless the caller is not yet using driver model 717 */ 718int gpio_free_list_nodev(struct gpio_desc *desc, int count); 719 720/** 721 * dm_gpio_get_value() - Get the value of a GPIO 722 * 723 * This is the driver model version of the existing gpio_get_value() function 724 * and should be used instead of that. 725 * 726 * For now, these functions have a dm_ prefix since they conflict with 727 * existing names. 728 * 729 * @desc: GPIO description containing device, offset and flags, 730 * previously returned by gpio_request_by_name() 731 * Return: GPIO value (0 for inactive, 1 for active) or -ve on error 732 */ 733int dm_gpio_get_value(const struct gpio_desc *desc); 734 735int dm_gpio_set_value(const struct gpio_desc *desc, int value); 736 737/** 738 * dm_gpio_clrset_flags() - Update flags 739 * 740 * This updates the flags as directled. Note that desc->flags is updated by this 741 * function on success. If any changes cannot be made, best efforts are made. 742 * 743 * By use of @clr and @set any of flags can be individually updated, or left 744 * alone 745 * 746 * @desc: GPIO description containing device, offset and flags, 747 * previously returned by gpio_request_by_name() 748 * @clr: Flags to clear (GPIOD_...) 749 * @set: Flags to set (GPIOD_...) 750 * Return: 0 if OK, -EINVAL if the flags had obvious conflicts, 751 * -ERECALLCONFLICT if there was a non-obvious hardware conflict when attempting 752 * to set the flags 753 */ 754int dm_gpio_clrset_flags(struct gpio_desc *desc, ulong clr, ulong set); 755 756/** 757 * dm_gpio_set_dir_flags() - Set direction using description and added flags 758 * 759 * This sets up the direction according to the provided flags and the GPIO 760 * description (desc->flags) which include direction information. 761 * Note that desc->flags is updated by this function. 762 * 763 * @desc: GPIO description containing device, offset and flags, 764 * previously returned by gpio_request_by_name() 765 * @flags: New flags to use 766 * Return: 0 if OK, -ve on error, in which case desc->flags is not updated 767 */ 768int dm_gpio_set_dir_flags(struct gpio_desc *desc, ulong flags); 769 770/** 771 * dm_gpios_clrset_flags() - Sets flags for a set of GPIOs 772 * 773 * This clears and sets flags individually for each GPIO. 774 * 775 * @desc: List of GPIOs to update 776 * @count: Number of GPIOs in the list 777 * @clr: Flags to clear (GPIOD_...), e.g. GPIOD_MASK_DIR if you are 778 * changing the direction 779 * @set: Flags to set (GPIOD_...) 780 * Return: 0 if OK, -ve on error 781 */ 782int dm_gpios_clrset_flags(struct gpio_desc *desc, int count, ulong clr, 783 ulong set); 784 785/** 786 * dm_gpio_get_flags() - Get flags 787 * 788 * Read the current flags 789 * 790 * @desc: GPIO description containing device, offset and flags, 791 * previously returned by gpio_request_by_name() 792 * @flags: place to put the used flags 793 * Return: 0 if OK, -ve on error, in which case desc->flags is not updated 794 */ 795int dm_gpio_get_flags(struct gpio_desc *desc, ulong *flags); 796 797/** 798 * gpio_get_number() - Get the global GPIO number of a GPIO 799 * 800 * This should only be used for debugging or interest. It returns the number 801 * that should be used for gpio_get_value() etc. to access this GPIO. 802 * 803 * @desc: GPIO description containing device, offset and flags, 804 * previously returned by gpio_request_by_name() 805 * Return: GPIO number, or -ve if not found 806 */ 807int gpio_get_number(const struct gpio_desc *desc); 808 809/** 810 * gpio_get_acpi() - Get the ACPI pin for a GPIO 811 * 812 * This converts a GPIO to an ACPI pin number for adding to the ACPI 813 * tables. If the GPIO is invalid, the pin_count and pins[0] are set to 0 814 * 815 * @desc: GPIO description to convert 816 * @gpio: Output ACPI GPIO information 817 * Return: ACPI pin number or -ve on error 818 */ 819int gpio_get_acpi(const struct gpio_desc *desc, struct acpi_gpio *gpio); 820 821/** 822 * devm_gpiod_get_index - Resource-managed gpiod_get() 823 * @dev: GPIO consumer 824 * @con_id: function within the GPIO consumer 825 * @index: index of the GPIO to obtain in the consumer 826 * @flags: optional GPIO initialization flags 827 * 828 * Managed gpiod_get(). GPIO descriptors returned from this function are 829 * automatically disposed on device unbind. 830 * Return the GPIO descriptor corresponding to the function con_id of device 831 * dev, -ENOENT if no GPIO has been assigned to the requested function, or 832 * another IS_ERR() code if an error occurred while trying to acquire the GPIO. 833 */ 834struct gpio_desc *devm_gpiod_get_index(struct udevice *dev, const char *id, 835 unsigned int index, int flags); 836 837#define devm_gpiod_get(dev, id, flags) devm_gpiod_get_index(dev, id, 0, flags) 838/** 839 * gpiod_get_optional - obtain an optional GPIO for a given GPIO function 840 * @dev: GPIO consumer, can be NULL for system-global GPIOs 841 * @con_id: function within the GPIO consumer 842 * @index: index of the GPIO to obtain in the consumer 843 * @flags: optional GPIO initialization flags 844 * 845 * This is equivalent to devm_gpiod_get(), except that when no GPIO was 846 * assigned to the requested function it will return NULL. This is convenient 847 * for drivers that need to handle optional GPIOs. 848 */ 849struct gpio_desc *devm_gpiod_get_index_optional(struct udevice *dev, 850 const char *id, 851 unsigned int index, 852 int flags); 853 854#define devm_gpiod_get_optional(dev, id, flags) \ 855 devm_gpiod_get_index_optional(dev, id, 0, flags) 856 857/** 858 * devm_gpiod_put - Resource-managed gpiod_put() 859 * @dev: GPIO consumer 860 * @desc: GPIO descriptor to dispose of 861 * 862 * Dispose of a GPIO descriptor obtained with devm_gpiod_get() or 863 * devm_gpiod_get_index(). Normally this function will not be called as the GPIO 864 * will be disposed of by the resource management code. 865 */ 866void devm_gpiod_put(struct udevice *dev, struct gpio_desc *desc); 867 868#endif /* _ASM_GENERIC_GPIO_H_ */ 869