gpio.h 23 KB

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