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