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