blob: a18f00fc1bb87544cc59182e6f4a5515464a2f29 [file] [log] [blame]
David Brownelld2876d02008-02-04 22:28:20 -08001#include <linux/kernel.h>
2#include <linux/module.h>
Daniel Glöcknerff77c352009-09-22 16:46:38 -07003#include <linux/interrupt.h>
David Brownelld2876d02008-02-04 22:28:20 -08004#include <linux/irq.h>
5#include <linux/spinlock.h>
Alexandre Courbot1a989d02013-02-03 01:29:24 +09006#include <linux/list.h>
David Brownelld8f388d2008-07-25 01:46:07 -07007#include <linux/device.h>
8#include <linux/err.h>
9#include <linux/debugfs.h>
10#include <linux/seq_file.h>
11#include <linux/gpio.h>
Anton Vorontsov391c9702010-06-08 07:48:17 -060012#include <linux/of_gpio.h>
Daniel Glöcknerff77c352009-09-22 16:46:38 -070013#include <linux/idr.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090014#include <linux/slab.h>
Rafael J. Wysocki7b199812013-11-11 22:41:56 +010015#include <linux/acpi.h>
Alexandre Courbot53e7cac2013-11-16 21:44:52 +090016#include <linux/gpio/driver.h>
Linus Walleij0a6d3152014-07-24 20:08:55 +020017#include <linux/gpio/machine.h>
Jonas Gorskic771c2f2015-10-11 17:34:15 +020018#include <linux/pinctrl/consumer.h>
David Brownelld2876d02008-02-04 22:28:20 -080019
Mika Westerberg664e3e52014-01-08 12:40:54 +020020#include "gpiolib.h"
21
Uwe Kleine-König3f397c212011-05-20 00:40:19 -060022#define CREATE_TRACE_POINTS
23#include <trace/events/gpio.h>
David Brownelld2876d02008-02-04 22:28:20 -080024
Alexandre Courbot79a9bec2013-10-17 10:21:36 -070025/* Implementation infrastructure for GPIO interfaces.
David Brownelld2876d02008-02-04 22:28:20 -080026 *
Alexandre Courbot79a9bec2013-10-17 10:21:36 -070027 * The GPIO programming interface allows for inlining speed-critical
28 * get/set operations for common cases, so that access to SOC-integrated
29 * GPIOs can sometimes cost only an instruction or two per bit.
David Brownelld2876d02008-02-04 22:28:20 -080030 */
31
32
33/* When debugging, extend minimal trust to callers and platform code.
34 * Also emit diagnostic messages that may help initial bringup, when
35 * board setup or driver bugs are most common.
36 *
37 * Otherwise, minimize overhead in what may be bitbanging codepaths.
38 */
39#ifdef DEBUG
40#define extra_checks 1
41#else
42#define extra_checks 0
43#endif
44
45/* gpio_lock prevents conflicts during gpio_desc[] table updates.
46 * While any GPIO is requested, its gpio_chip is not removable;
47 * each GPIO's "requested" flag serves as a lock and refcount.
48 */
Alexandre Courbot0eb4c6c2014-07-01 14:45:15 +090049DEFINE_SPINLOCK(gpio_lock);
David Brownelld2876d02008-02-04 22:28:20 -080050
Alexandre Courbotbae48da2013-10-17 10:21:38 -070051static DEFINE_MUTEX(gpio_lookup_lock);
52static LIST_HEAD(gpio_lookup_list);
Alexandre Courbot0eb4c6c2014-07-01 14:45:15 +090053LIST_HEAD(gpio_chips);
Andy Shevchenko1a2a99c2013-12-05 11:26:24 +020054
Johan Hovold6d867502015-05-04 17:23:25 +020055
56static void gpiochip_free_hogs(struct gpio_chip *chip);
57static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);
58
59
David Brownelld2876d02008-02-04 22:28:20 -080060static inline void desc_set_label(struct gpio_desc *d, const char *label)
61{
David Brownelld2876d02008-02-04 22:28:20 -080062 d->label = label;
David Brownelld2876d02008-02-04 22:28:20 -080063}
64
Alexandre Courbot372e7222013-02-03 01:29:29 +090065/**
66 * Convert a GPIO number to its descriptor
67 */
Alexandre Courbot79a9bec2013-10-17 10:21:36 -070068struct gpio_desc *gpio_to_desc(unsigned gpio)
Alexandre Courbot372e7222013-02-03 01:29:29 +090069{
Alexandre Courbot14e85c02014-11-19 16:51:27 +090070 struct gpio_chip *chip;
71 unsigned long flags;
72
73 spin_lock_irqsave(&gpio_lock, flags);
74
75 list_for_each_entry(chip, &gpio_chips, list) {
76 if (chip->base <= gpio && chip->base + chip->ngpio > gpio) {
77 spin_unlock_irqrestore(&gpio_lock, flags);
78 return &chip->desc[gpio - chip->base];
79 }
80 }
81
82 spin_unlock_irqrestore(&gpio_lock, flags);
83
Alexandre Courbot0e9a5ed2014-12-02 23:15:05 +090084 if (!gpio_is_valid(gpio))
85 WARN(1, "invalid GPIO %d\n", gpio);
86
Alexandre Courbot14e85c02014-11-19 16:51:27 +090087 return NULL;
Alexandre Courbot372e7222013-02-03 01:29:29 +090088}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -070089EXPORT_SYMBOL_GPL(gpio_to_desc);
Alexandre Courbot372e7222013-02-03 01:29:29 +090090
91/**
Alexandre Courbotbb1e88c2014-02-09 17:43:54 +090092 * Get the GPIO descriptor corresponding to the given hw number for this chip.
Linus Walleijd468bf92013-09-24 11:54:38 +020093 */
Alexandre Courbotbb1e88c2014-02-09 17:43:54 +090094struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip,
95 u16 hwnum)
Linus Walleijd468bf92013-09-24 11:54:38 +020096{
Alexandre Courbotbb1e88c2014-02-09 17:43:54 +090097 if (hwnum >= chip->ngpio)
Alexandre Courbotb7d0a282013-12-03 12:31:11 +090098 return ERR_PTR(-EINVAL);
Linus Walleijd468bf92013-09-24 11:54:38 +020099
Alexandre Courbotbb1e88c2014-02-09 17:43:54 +0900100 return &chip->desc[hwnum];
Linus Walleijd468bf92013-09-24 11:54:38 +0200101}
Alexandre Courbot372e7222013-02-03 01:29:29 +0900102
103/**
104 * Convert a GPIO descriptor to the integer namespace.
105 * This should disappear in the future but is needed since we still
106 * use GPIO numbers for error messages and sysfs nodes
107 */
Alexandre Courbot79a9bec2013-10-17 10:21:36 -0700108int desc_to_gpio(const struct gpio_desc *desc)
Alexandre Courbot372e7222013-02-03 01:29:29 +0900109{
Alexandre Courbot14e85c02014-11-19 16:51:27 +0900110 return desc->chip->base + (desc - &desc->chip->desc[0]);
Alexandre Courbot372e7222013-02-03 01:29:29 +0900111}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -0700112EXPORT_SYMBOL_GPL(desc_to_gpio);
Alexandre Courbot372e7222013-02-03 01:29:29 +0900113
114
Alexandre Courbot79a9bec2013-10-17 10:21:36 -0700115/**
116 * gpiod_to_chip - Return the GPIO chip to which a GPIO descriptor belongs
117 * @desc: descriptor to return the chip of
118 */
119struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
Alexandre Courbot372e7222013-02-03 01:29:29 +0900120{
Alexandre Courbotbcabdef2013-02-15 14:46:14 +0900121 return desc ? desc->chip : NULL;
Alexandre Courbot372e7222013-02-03 01:29:29 +0900122}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -0700123EXPORT_SYMBOL_GPL(gpiod_to_chip);
David Brownelld2876d02008-02-04 22:28:20 -0800124
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700125/* dynamic allocation of GPIOs, e.g. on a hotplugged device */
126static int gpiochip_find_base(int ngpio)
127{
Alexandre Courbot83cabe32013-02-03 01:29:28 +0900128 struct gpio_chip *chip;
129 int base = ARCH_NR_GPIOS - ngpio;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700130
Alexandre Courbot83cabe32013-02-03 01:29:28 +0900131 list_for_each_entry_reverse(chip, &gpio_chips, list) {
132 /* found a free space? */
133 if (chip->base + chip->ngpio <= base)
134 break;
135 else
136 /* nope, check the space right before the chip */
137 base = chip->base - ngpio;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700138 }
139
Alexandre Courbot83cabe32013-02-03 01:29:28 +0900140 if (gpio_is_valid(base)) {
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700141 pr_debug("%s: found new base at %d\n", __func__, base);
Alexandre Courbot83cabe32013-02-03 01:29:28 +0900142 return base;
143 } else {
144 pr_err("%s: cannot find free range\n", __func__);
145 return -ENOSPC;
Anton Vorontsov169b6a72008-04-28 02:14:47 -0700146 }
Anton Vorontsov169b6a72008-04-28 02:14:47 -0700147}
148
Alexandre Courbot79a9bec2013-10-17 10:21:36 -0700149/**
150 * gpiod_get_direction - return the current direction of a GPIO
151 * @desc: GPIO to get the direction of
152 *
153 * Return GPIOF_DIR_IN or GPIOF_DIR_OUT, or an error code in case of error.
154 *
155 * This function may sleep if gpiod_cansleep() is true.
156 */
Alexandre Courbot8e53b0f2014-11-25 17:16:31 +0900157int gpiod_get_direction(struct gpio_desc *desc)
Mathias Nyman80b0a602012-10-24 17:25:27 +0300158{
159 struct gpio_chip *chip;
Alexandre Courbot372e7222013-02-03 01:29:29 +0900160 unsigned offset;
Mathias Nyman80b0a602012-10-24 17:25:27 +0300161 int status = -EINVAL;
162
Alexandre Courbot372e7222013-02-03 01:29:29 +0900163 chip = gpiod_to_chip(desc);
164 offset = gpio_chip_hwgpio(desc);
Mathias Nyman80b0a602012-10-24 17:25:27 +0300165
166 if (!chip->get_direction)
167 return status;
168
Alexandre Courbot372e7222013-02-03 01:29:29 +0900169 status = chip->get_direction(chip, offset);
Mathias Nyman80b0a602012-10-24 17:25:27 +0300170 if (status > 0) {
171 /* GPIOF_DIR_IN, or other positive */
172 status = 1;
Alexandre Courbot8e53b0f2014-11-25 17:16:31 +0900173 clear_bit(FLAG_IS_OUT, &desc->flags);
Mathias Nyman80b0a602012-10-24 17:25:27 +0300174 }
175 if (status == 0) {
176 /* GPIOF_DIR_OUT */
Alexandre Courbot8e53b0f2014-11-25 17:16:31 +0900177 set_bit(FLAG_IS_OUT, &desc->flags);
Mathias Nyman80b0a602012-10-24 17:25:27 +0300178 }
179 return status;
180}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -0700181EXPORT_SYMBOL_GPL(gpiod_get_direction);
Mathias Nyman80b0a602012-10-24 17:25:27 +0300182
Alexandre Courbot1a989d02013-02-03 01:29:24 +0900183/*
184 * Add a new chip to the global chips list, keeping the list of chips sorted
185 * by base order.
186 *
187 * Return -EBUSY if the new chip overlaps with some other chip's integer
188 * space.
189 */
190static int gpiochip_add_to_list(struct gpio_chip *chip)
191{
Masahiro Yamadad1aceb82015-07-21 14:45:40 +0900192 struct list_head *pos;
Alexandre Courbot1a989d02013-02-03 01:29:24 +0900193 struct gpio_chip *_chip;
194 int err = 0;
195
196 /* find where to insert our chip */
197 list_for_each(pos, &gpio_chips) {
198 _chip = list_entry(pos, struct gpio_chip, list);
199 /* shall we insert before _chip? */
200 if (_chip->base >= chip->base + chip->ngpio)
201 break;
202 }
203
204 /* are we stepping on the chip right before? */
205 if (pos != &gpio_chips && pos->prev != &gpio_chips) {
206 _chip = list_entry(pos->prev, struct gpio_chip, list);
207 if (_chip->base + _chip->ngpio > chip->base) {
208 dev_err(chip->dev,
209 "GPIO integer space overlap, cannot add chip\n");
210 err = -EBUSY;
211 }
212 }
213
214 if (!err)
215 list_add_tail(&chip->list, pos);
216
217 return err;
218}
219
Linus Walleijf881bab2015-09-23 16:20:43 -0700220/**
221 * Convert a GPIO name to its descriptor
222 */
223static struct gpio_desc *gpio_name_to_desc(const char * const name)
224{
225 struct gpio_chip *chip;
226 unsigned long flags;
227
228 spin_lock_irqsave(&gpio_lock, flags);
229
230 list_for_each_entry(chip, &gpio_chips, list) {
231 int i;
232
233 for (i = 0; i != chip->ngpio; ++i) {
234 struct gpio_desc *gpio = &chip->desc[i];
235
236 if (!gpio->name)
237 continue;
238
239 if (!strcmp(gpio->name, name)) {
240 spin_unlock_irqrestore(&gpio_lock, flags);
241 return gpio;
242 }
243 }
244 }
245
246 spin_unlock_irqrestore(&gpio_lock, flags);
247
248 return NULL;
249}
250
Markus Pargmann5f3ca732015-08-14 16:11:00 +0200251/*
252 * Takes the names from gc->names and checks if they are all unique. If they
253 * are, they are assigned to their gpio descriptors.
254 *
255 * Returns -EEXIST if one of the names is already used for a different GPIO.
256 */
257static int gpiochip_set_desc_names(struct gpio_chip *gc)
258{
259 int i;
260
261 if (!gc->names)
262 return 0;
263
264 /* First check all names if they are unique */
265 for (i = 0; i != gc->ngpio; ++i) {
266 struct gpio_desc *gpio;
267
268 gpio = gpio_name_to_desc(gc->names[i]);
Linus Walleijf881bab2015-09-23 16:20:43 -0700269 if (gpio)
270 dev_warn(gc->dev, "Detected name collision for "
271 "GPIO name '%s'\n",
272 gc->names[i]);
Markus Pargmann5f3ca732015-08-14 16:11:00 +0200273 }
274
275 /* Then add all names to the GPIO descriptors */
276 for (i = 0; i != gc->ngpio; ++i)
277 gc->desc[i].name = gc->names[i];
278
279 return 0;
280}
281
Anton Vorontsov169b6a72008-04-28 02:14:47 -0700282/**
David Brownelld2876d02008-02-04 22:28:20 -0800283 * gpiochip_add() - register a gpio_chip
284 * @chip: the chip to register, with chip->base initialized
Alexandre Courbot14e85c02014-11-19 16:51:27 +0900285 * Context: potentially before irqs will work
David Brownelld2876d02008-02-04 22:28:20 -0800286 *
287 * Returns a negative errno if the chip can't be registered, such as
288 * because the chip->base is invalid or already associated with a
289 * different chip. Otherwise it returns zero as a success code.
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700290 *
David Brownelld8f388d2008-07-25 01:46:07 -0700291 * When gpiochip_add() is called very early during boot, so that GPIOs
292 * can be freely used, the chip->dev device must be registered before
293 * the gpio framework's arch_initcall(). Otherwise sysfs initialization
294 * for GPIOs will fail rudely.
295 *
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700296 * If chip->base is negative, this requests dynamic assignment of
297 * a range of valid GPIOs.
David Brownelld2876d02008-02-04 22:28:20 -0800298 */
299int gpiochip_add(struct gpio_chip *chip)
300{
301 unsigned long flags;
302 int status = 0;
303 unsigned id;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700304 int base = chip->base;
Alexandre Courbot14e85c02014-11-19 16:51:27 +0900305 struct gpio_desc *descs;
David Brownelld2876d02008-02-04 22:28:20 -0800306
Alexandre Courbot14e85c02014-11-19 16:51:27 +0900307 descs = kcalloc(chip->ngpio, sizeof(descs[0]), GFP_KERNEL);
308 if (!descs)
309 return -ENOMEM;
David Brownelld2876d02008-02-04 22:28:20 -0800310
311 spin_lock_irqsave(&gpio_lock, flags);
312
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700313 if (base < 0) {
314 base = gpiochip_find_base(chip->ngpio);
315 if (base < 0) {
316 status = base;
Johan Hovold225fce82015-01-12 17:12:25 +0100317 spin_unlock_irqrestore(&gpio_lock, flags);
318 goto err_free_descs;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700319 }
320 chip->base = base;
321 }
322
Alexandre Courbot1a989d02013-02-03 01:29:24 +0900323 status = gpiochip_add_to_list(chip);
Johan Hovold05aa5202015-01-12 17:12:26 +0100324 if (status) {
325 spin_unlock_irqrestore(&gpio_lock, flags);
326 goto err_free_descs;
327 }
Alexandre Courbot1a989d02013-02-03 01:29:24 +0900328
Johan Hovold05aa5202015-01-12 17:12:26 +0100329 for (id = 0; id < chip->ngpio; id++) {
330 struct gpio_desc *desc = &descs[id];
David Brownelld8f388d2008-07-25 01:46:07 -0700331
Johan Hovold05aa5202015-01-12 17:12:26 +0100332 desc->chip = chip;
333
334 /* REVISIT: most hardware initializes GPIOs as inputs (often
335 * with pullups enabled) so power usage is minimized. Linux
336 * code should set the gpio direction first thing; but until
337 * it does, and in case chip->get_direction is not set, we may
338 * expose the wrong direction in sysfs.
339 */
340 desc->flags = !chip->direction_input ? (1 << FLAG_IS_OUT) : 0;
David Brownelld2876d02008-02-04 22:28:20 -0800341 }
342
Alexandre Courbot14e85c02014-11-19 16:51:27 +0900343 chip->desc = descs;
344
Zhangfei Gao3bae4812013-06-09 11:08:32 +0800345 spin_unlock_irqrestore(&gpio_lock, flags);
346
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530347#ifdef CONFIG_PINCTRL
348 INIT_LIST_HEAD(&chip->pin_ranges);
349#endif
350
Grygorii Strashko37269602015-06-25 20:30:51 +0300351 if (!chip->owner && chip->dev && chip->dev->driver)
352 chip->owner = chip->dev->driver->owner;
353
Markus Pargmann5f3ca732015-08-14 16:11:00 +0200354 status = gpiochip_set_desc_names(chip);
355 if (status)
356 goto err_remove_from_list;
357
Tomeu Vizoso28355f82015-07-14 10:29:54 +0200358 status = of_gpiochip_add(chip);
359 if (status)
360 goto err_remove_chip;
361
Mika Westerberg664e3e52014-01-08 12:40:54 +0200362 acpi_gpiochip_add(chip);
Anton Vorontsov391c9702010-06-08 07:48:17 -0600363
Johan Hovold426577b2015-05-04 17:10:32 +0200364 status = gpiochip_sysfs_register(chip);
Johan Hovold225fce82015-01-12 17:12:25 +0100365 if (status)
366 goto err_remove_chip;
Anton Vorontsovcedb1882010-06-08 07:48:15 -0600367
Andy Shevchenko7589e592013-12-05 11:26:23 +0200368 pr_debug("%s: registered GPIOs %d to %d on device: %s\n", __func__,
Grant Likely64842aa2011-11-06 11:36:18 -0700369 chip->base, chip->base + chip->ngpio - 1,
370 chip->label ? : "generic");
371
Anton Vorontsovcedb1882010-06-08 07:48:15 -0600372 return 0;
Zhangfei Gao3bae4812013-06-09 11:08:32 +0800373
Johan Hovold225fce82015-01-12 17:12:25 +0100374err_remove_chip:
375 acpi_gpiochip_remove(chip);
Johan Hovold6d867502015-05-04 17:23:25 +0200376 gpiochip_free_hogs(chip);
Johan Hovold225fce82015-01-12 17:12:25 +0100377 of_gpiochip_remove(chip);
Markus Pargmann5f3ca732015-08-14 16:11:00 +0200378err_remove_from_list:
Johan Hovold225fce82015-01-12 17:12:25 +0100379 spin_lock_irqsave(&gpio_lock, flags);
380 list_del(&chip->list);
Zhangfei Gao3bae4812013-06-09 11:08:32 +0800381 spin_unlock_irqrestore(&gpio_lock, flags);
Johan Hovold05aa5202015-01-12 17:12:26 +0100382 chip->desc = NULL;
Johan Hovold225fce82015-01-12 17:12:25 +0100383err_free_descs:
Alexandre Courbot14e85c02014-11-19 16:51:27 +0900384 kfree(descs);
Alexandre Courbot14e85c02014-11-19 16:51:27 +0900385
David Brownelld2876d02008-02-04 22:28:20 -0800386 /* failures here can mean systems won't boot... */
Andy Shevchenko7589e592013-12-05 11:26:23 +0200387 pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
Anton Vorontsovcedb1882010-06-08 07:48:15 -0600388 chip->base, chip->base + chip->ngpio - 1,
389 chip->label ? : "generic");
David Brownelld2876d02008-02-04 22:28:20 -0800390 return status;
391}
392EXPORT_SYMBOL_GPL(gpiochip_add);
393
394/**
395 * gpiochip_remove() - unregister a gpio_chip
396 * @chip: the chip to unregister
397 *
398 * A gpio_chip with any GPIOs still requested may not be removed.
399 */
abdoulaye berthee1db1702014-07-05 18:28:50 +0200400void gpiochip_remove(struct gpio_chip *chip)
David Brownelld2876d02008-02-04 22:28:20 -0800401{
Johan Hovoldfab28b82015-05-04 17:10:27 +0200402 struct gpio_desc *desc;
David Brownelld2876d02008-02-04 22:28:20 -0800403 unsigned long flags;
David Brownelld2876d02008-02-04 22:28:20 -0800404 unsigned id;
Johan Hovoldfab28b82015-05-04 17:10:27 +0200405 bool requested = false;
David Brownelld2876d02008-02-04 22:28:20 -0800406
Johan Hovold426577b2015-05-04 17:10:32 +0200407 gpiochip_sysfs_unregister(chip);
Johan Hovold01cca932015-01-12 17:12:29 +0100408
Johan Hovold00acc3d2015-01-12 17:12:27 +0100409 gpiochip_irqchip_remove(chip);
410
Mika Westerberg6072b9d2014-03-10 14:54:53 +0200411 acpi_gpiochip_remove(chip);
Linus Walleij9ef0d6f2012-11-06 15:15:44 +0100412 gpiochip_remove_pin_ranges(chip);
Benoit Parrotf625d462015-02-02 11:44:44 -0600413 gpiochip_free_hogs(chip);
Anton Vorontsov391c9702010-06-08 07:48:17 -0600414 of_gpiochip_remove(chip);
415
Johan Hovold6798aca2015-01-12 17:12:28 +0100416 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +0900417 for (id = 0; id < chip->ngpio; id++) {
Johan Hovoldfab28b82015-05-04 17:10:27 +0200418 desc = &chip->desc[id];
419 desc->chip = NULL;
420 if (test_bit(FLAG_REQUESTED, &desc->flags))
421 requested = true;
David Brownelld2876d02008-02-04 22:28:20 -0800422 }
abdoulaye berthee1db1702014-07-05 18:28:50 +0200423 list_del(&chip->list);
David Brownelld2876d02008-02-04 22:28:20 -0800424 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbot14e85c02014-11-19 16:51:27 +0900425
Johan Hovoldfab28b82015-05-04 17:10:27 +0200426 if (requested)
427 dev_crit(chip->dev, "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
428
Alexandre Courbot14e85c02014-11-19 16:51:27 +0900429 kfree(chip->desc);
430 chip->desc = NULL;
David Brownelld2876d02008-02-04 22:28:20 -0800431}
432EXPORT_SYMBOL_GPL(gpiochip_remove);
433
Grant Likely594fa262010-06-08 07:48:16 -0600434/**
435 * gpiochip_find() - iterator for locating a specific gpio_chip
436 * @data: data to pass to match function
437 * @callback: Callback function to check gpio_chip
438 *
439 * Similar to bus_find_device. It returns a reference to a gpio_chip as
440 * determined by a user supplied @match callback. The callback should return
441 * 0 if the device doesn't match and non-zero if it does. If the callback is
442 * non-zero, this function will return to the caller and not iterate over any
443 * more gpio_chips.
444 */
Grant Likely07ce8ec2012-05-18 23:01:05 -0600445struct gpio_chip *gpiochip_find(void *data,
Grant Likely6e2cf652012-03-02 15:56:03 -0700446 int (*match)(struct gpio_chip *chip,
Grant Likely3d0f7cf2012-05-17 13:54:40 -0600447 void *data))
Grant Likely594fa262010-06-08 07:48:16 -0600448{
Alexandre Courbot125eef92013-02-03 01:29:26 +0900449 struct gpio_chip *chip;
Grant Likely594fa262010-06-08 07:48:16 -0600450 unsigned long flags;
Grant Likely594fa262010-06-08 07:48:16 -0600451
452 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbot125eef92013-02-03 01:29:26 +0900453 list_for_each_entry(chip, &gpio_chips, list)
454 if (match(chip, data))
Grant Likely594fa262010-06-08 07:48:16 -0600455 break;
Alexandre Courbot125eef92013-02-03 01:29:26 +0900456
457 /* No match? */
458 if (&chip->list == &gpio_chips)
459 chip = NULL;
Grant Likely594fa262010-06-08 07:48:16 -0600460 spin_unlock_irqrestore(&gpio_lock, flags);
461
462 return chip;
463}
Jean Delvare8fa0c9b2011-05-20 00:40:18 -0600464EXPORT_SYMBOL_GPL(gpiochip_find);
David Brownelld2876d02008-02-04 22:28:20 -0800465
Alexandre Courbot79697ef2013-11-16 21:39:32 +0900466static int gpiochip_match_name(struct gpio_chip *chip, void *data)
467{
468 const char *name = data;
469
470 return !strcmp(chip->label, name);
471}
472
473static struct gpio_chip *find_chip_by_name(const char *name)
474{
475 return gpiochip_find((void *)name, gpiochip_match_name);
476}
477
Linus Walleij14250522014-03-25 10:40:18 +0100478#ifdef CONFIG_GPIOLIB_IRQCHIP
479
480/*
481 * The following is irqchip helper code for gpiochips.
482 */
483
484/**
Linus Walleij3f97d5fc2014-09-26 14:19:52 +0200485 * gpiochip_set_chained_irqchip() - sets a chained irqchip to a gpiochip
486 * @gpiochip: the gpiochip to set the irqchip chain to
487 * @irqchip: the irqchip to chain to the gpiochip
Linus Walleij14250522014-03-25 10:40:18 +0100488 * @parent_irq: the irq number corresponding to the parent IRQ for this
489 * chained irqchip
490 * @parent_handler: the parent interrupt handler for the accumulated IRQ
Linus Walleij3f97d5fc2014-09-26 14:19:52 +0200491 * coming out of the gpiochip. If the interrupt is nested rather than
492 * cascaded, pass NULL in this handler argument
Linus Walleij14250522014-03-25 10:40:18 +0100493 */
494void gpiochip_set_chained_irqchip(struct gpio_chip *gpiochip,
495 struct irq_chip *irqchip,
496 int parent_irq,
497 irq_flow_handler_t parent_handler)
498{
Linus Walleij83141a72014-09-26 13:50:12 +0200499 unsigned int offset;
500
Linus Walleij83141a72014-09-26 13:50:12 +0200501 if (!gpiochip->irqdomain) {
502 chip_err(gpiochip, "called %s before setting up irqchip\n",
503 __func__);
Linus Walleij1c8732b2014-04-09 13:34:39 +0200504 return;
505 }
506
Linus Walleij3f97d5fc2014-09-26 14:19:52 +0200507 if (parent_handler) {
508 if (gpiochip->can_sleep) {
509 chip_err(gpiochip,
510 "you cannot have chained interrupts on a "
511 "chip that may sleep\n");
512 return;
513 }
Linus Walleij3f97d5fc2014-09-26 14:19:52 +0200514 /*
515 * The parent irqchip is already using the chip_data for this
516 * irqchip, so our callbacks simply use the handler_data.
517 */
Thomas Gleixnerf7f87752015-06-21 21:10:48 +0200518 irq_set_chained_handler_and_data(parent_irq, parent_handler,
519 gpiochip);
Dmitry Eremin-Solenikov25e4fe92015-05-12 20:12:23 +0300520
521 gpiochip->irq_parent = parent_irq;
Linus Walleij3f97d5fc2014-09-26 14:19:52 +0200522 }
Linus Walleij83141a72014-09-26 13:50:12 +0200523
524 /* Set the parent IRQ for all affected IRQs */
525 for (offset = 0; offset < gpiochip->ngpio; offset++)
526 irq_set_parent(irq_find_mapping(gpiochip->irqdomain, offset),
527 parent_irq);
Linus Walleij14250522014-03-25 10:40:18 +0100528}
529EXPORT_SYMBOL_GPL(gpiochip_set_chained_irqchip);
530
531/**
532 * gpiochip_irq_map() - maps an IRQ into a GPIO irqchip
533 * @d: the irqdomain used by this irqchip
534 * @irq: the global irq number used by this GPIO irqchip irq
535 * @hwirq: the local IRQ/GPIO line offset on this gpiochip
536 *
537 * This function will set up the mapping for a certain IRQ line on a
538 * gpiochip by assigning the gpiochip as chip data, and using the irqchip
539 * stored inside the gpiochip.
540 */
541static int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
542 irq_hw_number_t hwirq)
543{
544 struct gpio_chip *chip = d->host_data;
545
Linus Walleij14250522014-03-25 10:40:18 +0100546 irq_set_chip_data(irq, chip);
Grygorii Strashkoa0a8bcf2015-08-17 15:35:23 +0300547 /*
548 * This lock class tells lockdep that GPIO irqs are in a different
549 * category than their parents, so it won't report false recursion.
550 */
551 irq_set_lockdep_class(irq, chip->lock_key);
Linus Walleij7633fb92014-04-09 13:20:38 +0200552 irq_set_chip_and_handler(irq, chip->irqchip, chip->irq_handler);
Linus Walleij1c8732b2014-04-09 13:34:39 +0200553 /* Chips that can sleep need nested thread handlers */
Octavian Purdila295494a2014-09-19 23:22:44 +0300554 if (chip->can_sleep && !chip->irq_not_threaded)
Linus Walleij1c8732b2014-04-09 13:34:39 +0200555 irq_set_nested_thread(irq, 1);
Linus Walleij14250522014-03-25 10:40:18 +0100556 irq_set_noprobe(irq);
Rob Herring23393d42015-07-27 15:55:16 -0500557
Linus Walleij1333b902014-04-23 16:45:12 +0200558 /*
559 * No set-up of the hardware will happen if IRQ_TYPE_NONE
560 * is passed as default type.
561 */
562 if (chip->irq_default_type != IRQ_TYPE_NONE)
563 irq_set_irq_type(irq, chip->irq_default_type);
Linus Walleij14250522014-03-25 10:40:18 +0100564
565 return 0;
566}
567
Linus Walleijc3626fd2014-03-28 20:42:01 +0100568static void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
569{
Linus Walleij1c8732b2014-04-09 13:34:39 +0200570 struct gpio_chip *chip = d->host_data;
571
Linus Walleij1c8732b2014-04-09 13:34:39 +0200572 if (chip->can_sleep)
573 irq_set_nested_thread(irq, 0);
Linus Walleijc3626fd2014-03-28 20:42:01 +0100574 irq_set_chip_and_handler(irq, NULL, NULL);
575 irq_set_chip_data(irq, NULL);
576}
577
Linus Walleij14250522014-03-25 10:40:18 +0100578static const struct irq_domain_ops gpiochip_domain_ops = {
579 .map = gpiochip_irq_map,
Linus Walleijc3626fd2014-03-28 20:42:01 +0100580 .unmap = gpiochip_irq_unmap,
Linus Walleij14250522014-03-25 10:40:18 +0100581 /* Virtually all GPIO irqchips are twocell:ed */
582 .xlate = irq_domain_xlate_twocell,
583};
584
585static int gpiochip_irq_reqres(struct irq_data *d)
586{
587 struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
588
Grygorii Strashko5b76e792015-06-25 20:30:50 +0300589 if (!try_module_get(chip->owner))
590 return -ENODEV;
591
Alexandre Courbote3a2e872014-10-23 17:27:07 +0900592 if (gpiochip_lock_as_irq(chip, d->hwirq)) {
Linus Walleij14250522014-03-25 10:40:18 +0100593 chip_err(chip,
594 "unable to lock HW IRQ %lu for IRQ\n",
595 d->hwirq);
Grygorii Strashko5b76e792015-06-25 20:30:50 +0300596 module_put(chip->owner);
Linus Walleij14250522014-03-25 10:40:18 +0100597 return -EINVAL;
598 }
599 return 0;
600}
601
602static void gpiochip_irq_relres(struct irq_data *d)
603{
604 struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
605
Alexandre Courbote3a2e872014-10-23 17:27:07 +0900606 gpiochip_unlock_as_irq(chip, d->hwirq);
Grygorii Strashko5b76e792015-06-25 20:30:50 +0300607 module_put(chip->owner);
Linus Walleij14250522014-03-25 10:40:18 +0100608}
609
610static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
611{
612 return irq_find_mapping(chip->irqdomain, offset);
613}
614
615/**
616 * gpiochip_irqchip_remove() - removes an irqchip added to a gpiochip
617 * @gpiochip: the gpiochip to remove the irqchip from
618 *
619 * This is called only from gpiochip_remove()
620 */
621static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
622{
Linus Walleijc3626fd2014-03-28 20:42:01 +0100623 unsigned int offset;
624
Mika Westerbergafa82fa2014-07-25 09:54:48 +0300625 acpi_gpiochip_free_interrupts(gpiochip);
626
Dmitry Eremin-Solenikov25e4fe92015-05-12 20:12:23 +0300627 if (gpiochip->irq_parent) {
628 irq_set_chained_handler(gpiochip->irq_parent, NULL);
629 irq_set_handler_data(gpiochip->irq_parent, NULL);
630 }
631
Linus Walleijc3626fd2014-03-28 20:42:01 +0100632 /* Remove all IRQ mappings and delete the domain */
633 if (gpiochip->irqdomain) {
634 for (offset = 0; offset < gpiochip->ngpio; offset++)
Grygorii Strashkoe3893382014-09-25 19:09:23 +0300635 irq_dispose_mapping(
636 irq_find_mapping(gpiochip->irqdomain, offset));
Linus Walleij14250522014-03-25 10:40:18 +0100637 irq_domain_remove(gpiochip->irqdomain);
Linus Walleijc3626fd2014-03-28 20:42:01 +0100638 }
Linus Walleij14250522014-03-25 10:40:18 +0100639
640 if (gpiochip->irqchip) {
641 gpiochip->irqchip->irq_request_resources = NULL;
642 gpiochip->irqchip->irq_release_resources = NULL;
643 gpiochip->irqchip = NULL;
644 }
645}
646
647/**
648 * gpiochip_irqchip_add() - adds an irqchip to a gpiochip
649 * @gpiochip: the gpiochip to add the irqchip to
650 * @irqchip: the irqchip to add to the gpiochip
651 * @first_irq: if not dynamically assigned, the base (first) IRQ to
652 * allocate gpiochip irqs from
653 * @handler: the irq handler to use (often a predefined irq core function)
Linus Walleij1333b902014-04-23 16:45:12 +0200654 * @type: the default type for IRQs on this irqchip, pass IRQ_TYPE_NONE
655 * to have the core avoid setting up any default type in the hardware.
Grygorii Strashkoa0a8bcf2015-08-17 15:35:23 +0300656 * @lock_key: lockdep class
Linus Walleij14250522014-03-25 10:40:18 +0100657 *
658 * This function closely associates a certain irqchip with a certain
659 * gpiochip, providing an irq domain to translate the local IRQs to
660 * global irqs in the gpiolib core, and making sure that the gpiochip
661 * is passed as chip data to all related functions. Driver callbacks
662 * need to use container_of() to get their local state containers back
663 * from the gpiochip passed as chip data. An irqdomain will be stored
664 * in the gpiochip that shall be used by the driver to handle IRQ number
665 * translation. The gpiochip will need to be initialized and registered
666 * before calling this function.
667 *
Linus Walleijc3626fd2014-03-28 20:42:01 +0100668 * This function will handle two cell:ed simple IRQs and assumes all
669 * the pins on the gpiochip can generate a unique IRQ. Everything else
Linus Walleij14250522014-03-25 10:40:18 +0100670 * need to be open coded.
671 */
Grygorii Strashkoa0a8bcf2015-08-17 15:35:23 +0300672int _gpiochip_irqchip_add(struct gpio_chip *gpiochip,
673 struct irq_chip *irqchip,
674 unsigned int first_irq,
675 irq_flow_handler_t handler,
676 unsigned int type,
677 struct lock_class_key *lock_key)
Linus Walleij14250522014-03-25 10:40:18 +0100678{
679 struct device_node *of_node;
680 unsigned int offset;
Linus Walleijc3626fd2014-03-28 20:42:01 +0100681 unsigned irq_base = 0;
Linus Walleij14250522014-03-25 10:40:18 +0100682
683 if (!gpiochip || !irqchip)
684 return -EINVAL;
685
686 if (!gpiochip->dev) {
687 pr_err("missing gpiochip .dev parent pointer\n");
688 return -EINVAL;
689 }
690 of_node = gpiochip->dev->of_node;
691#ifdef CONFIG_OF_GPIO
692 /*
Colin Cronin20a8a962015-05-18 11:41:43 -0700693 * If the gpiochip has an assigned OF node this takes precedence
Linus Walleij14250522014-03-25 10:40:18 +0100694 * FIXME: get rid of this and use gpiochip->dev->of_node everywhere
695 */
696 if (gpiochip->of_node)
697 of_node = gpiochip->of_node;
698#endif
699 gpiochip->irqchip = irqchip;
700 gpiochip->irq_handler = handler;
701 gpiochip->irq_default_type = type;
702 gpiochip->to_irq = gpiochip_to_irq;
Grygorii Strashkoa0a8bcf2015-08-17 15:35:23 +0300703 gpiochip->lock_key = lock_key;
Linus Walleij14250522014-03-25 10:40:18 +0100704 gpiochip->irqdomain = irq_domain_add_simple(of_node,
705 gpiochip->ngpio, first_irq,
706 &gpiochip_domain_ops, gpiochip);
707 if (!gpiochip->irqdomain) {
708 gpiochip->irqchip = NULL;
709 return -EINVAL;
710 }
Rabin Vincent8b67a1f2015-07-31 14:48:56 +0200711
712 /*
713 * It is possible for a driver to override this, but only if the
714 * alternative functions are both implemented.
715 */
716 if (!irqchip->irq_request_resources &&
717 !irqchip->irq_release_resources) {
718 irqchip->irq_request_resources = gpiochip_irq_reqres;
719 irqchip->irq_release_resources = gpiochip_irq_relres;
720 }
Linus Walleij14250522014-03-25 10:40:18 +0100721
722 /*
723 * Prepare the mapping since the irqchip shall be orthogonal to
724 * any gpiochip calls. If the first_irq was zero, this is
725 * necessary to allocate descriptors for all IRQs.
726 */
Linus Walleijc3626fd2014-03-28 20:42:01 +0100727 for (offset = 0; offset < gpiochip->ngpio; offset++) {
728 irq_base = irq_create_mapping(gpiochip->irqdomain, offset);
729 if (offset == 0)
730 /*
731 * Store the base into the gpiochip to be used when
732 * unmapping the irqs.
733 */
734 gpiochip->irq_base = irq_base;
735 }
Linus Walleij14250522014-03-25 10:40:18 +0100736
Mika Westerbergafa82fa2014-07-25 09:54:48 +0300737 acpi_gpiochip_request_interrupts(gpiochip);
738
Linus Walleij14250522014-03-25 10:40:18 +0100739 return 0;
740}
Grygorii Strashkoa0a8bcf2015-08-17 15:35:23 +0300741EXPORT_SYMBOL_GPL(_gpiochip_irqchip_add);
Linus Walleij14250522014-03-25 10:40:18 +0100742
743#else /* CONFIG_GPIOLIB_IRQCHIP */
744
745static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
746
747#endif /* CONFIG_GPIOLIB_IRQCHIP */
748
Jonas Gorskic771c2f2015-10-11 17:34:15 +0200749/**
750 * gpiochip_generic_request() - request the gpio function for a pin
751 * @chip: the gpiochip owning the GPIO
752 * @offset: the offset of the GPIO to request for GPIO function
753 */
754int gpiochip_generic_request(struct gpio_chip *chip, unsigned offset)
755{
756 return pinctrl_request_gpio(chip->base + offset);
757}
758EXPORT_SYMBOL_GPL(gpiochip_generic_request);
759
760/**
761 * gpiochip_generic_free() - free the gpio function from a pin
762 * @chip: the gpiochip to request the gpio function for
763 * @offset: the offset of the GPIO to free from GPIO function
764 */
765void gpiochip_generic_free(struct gpio_chip *chip, unsigned offset)
766{
767 pinctrl_free_gpio(chip->base + offset);
768}
769EXPORT_SYMBOL_GPL(gpiochip_generic_free);
770
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530771#ifdef CONFIG_PINCTRL
Linus Walleij165adc92012-11-06 14:49:39 +0100772
Linus Walleij3f0f8672012-11-20 12:40:15 +0100773/**
Christian Ruppert586a87e2013-10-15 15:37:54 +0200774 * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
775 * @chip: the gpiochip to add the range for
Tomeu Vizosod32651f2015-06-17 15:42:11 +0200776 * @pctldev: the pin controller to map to
Christian Ruppert586a87e2013-10-15 15:37:54 +0200777 * @gpio_offset: the start offset in the current gpio_chip number space
778 * @pin_group: name of the pin group inside the pin controller
779 */
780int gpiochip_add_pingroup_range(struct gpio_chip *chip,
781 struct pinctrl_dev *pctldev,
782 unsigned int gpio_offset, const char *pin_group)
783{
784 struct gpio_pin_range *pin_range;
785 int ret;
786
787 pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
788 if (!pin_range) {
Andy Shevchenko1a2a99c2013-12-05 11:26:24 +0200789 chip_err(chip, "failed to allocate pin ranges\n");
Christian Ruppert586a87e2013-10-15 15:37:54 +0200790 return -ENOMEM;
791 }
792
793 /* Use local offset as range ID */
794 pin_range->range.id = gpio_offset;
795 pin_range->range.gc = chip;
796 pin_range->range.name = chip->label;
797 pin_range->range.base = chip->base + gpio_offset;
798 pin_range->pctldev = pctldev;
799
800 ret = pinctrl_get_group_pins(pctldev, pin_group,
801 &pin_range->range.pins,
802 &pin_range->range.npins);
Michal Nazarewicz61c63752013-11-13 21:20:39 +0100803 if (ret < 0) {
804 kfree(pin_range);
Christian Ruppert586a87e2013-10-15 15:37:54 +0200805 return ret;
Michal Nazarewicz61c63752013-11-13 21:20:39 +0100806 }
Christian Ruppert586a87e2013-10-15 15:37:54 +0200807
808 pinctrl_add_gpio_range(pctldev, &pin_range->range);
809
Andy Shevchenko1a2a99c2013-12-05 11:26:24 +0200810 chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
811 gpio_offset, gpio_offset + pin_range->range.npins - 1,
Christian Ruppert586a87e2013-10-15 15:37:54 +0200812 pinctrl_dev_get_devname(pctldev), pin_group);
813
814 list_add_tail(&pin_range->node, &chip->pin_ranges);
815
816 return 0;
817}
818EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);
819
820/**
Linus Walleij3f0f8672012-11-20 12:40:15 +0100821 * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
822 * @chip: the gpiochip to add the range for
823 * @pinctrl_name: the dev_name() of the pin controller to map to
Linus Walleij316511c2012-11-21 08:48:09 +0100824 * @gpio_offset: the start offset in the current gpio_chip number space
825 * @pin_offset: the start offset in the pin controller number space
Linus Walleij3f0f8672012-11-20 12:40:15 +0100826 * @npins: the number of pins from the offset of each pin space (GPIO and
827 * pin controller) to accumulate in this range
828 */
Linus Walleij1e63d7b2012-11-06 16:03:35 +0100829int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
Linus Walleij316511c2012-11-21 08:48:09 +0100830 unsigned int gpio_offset, unsigned int pin_offset,
Linus Walleij3f0f8672012-11-20 12:40:15 +0100831 unsigned int npins)
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530832{
833 struct gpio_pin_range *pin_range;
Axel Linb4d4b1f2012-11-21 14:33:56 +0800834 int ret;
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530835
Linus Walleij3f0f8672012-11-20 12:40:15 +0100836 pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530837 if (!pin_range) {
Andy Shevchenko1a2a99c2013-12-05 11:26:24 +0200838 chip_err(chip, "failed to allocate pin ranges\n");
Linus Walleij1e63d7b2012-11-06 16:03:35 +0100839 return -ENOMEM;
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530840 }
841
Linus Walleij3f0f8672012-11-20 12:40:15 +0100842 /* Use local offset as range ID */
Linus Walleij316511c2012-11-21 08:48:09 +0100843 pin_range->range.id = gpio_offset;
Linus Walleij3f0f8672012-11-20 12:40:15 +0100844 pin_range->range.gc = chip;
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530845 pin_range->range.name = chip->label;
Linus Walleij316511c2012-11-21 08:48:09 +0100846 pin_range->range.base = chip->base + gpio_offset;
847 pin_range->range.pin_base = pin_offset;
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530848 pin_range->range.npins = npins;
Linus Walleij192c3692012-11-20 14:03:37 +0100849 pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530850 &pin_range->range);
Linus Walleij8f23ca12012-11-20 14:56:25 +0100851 if (IS_ERR(pin_range->pctldev)) {
Axel Linb4d4b1f2012-11-21 14:33:56 +0800852 ret = PTR_ERR(pin_range->pctldev);
Andy Shevchenko1a2a99c2013-12-05 11:26:24 +0200853 chip_err(chip, "could not create pin range\n");
Linus Walleij3f0f8672012-11-20 12:40:15 +0100854 kfree(pin_range);
Axel Linb4d4b1f2012-11-21 14:33:56 +0800855 return ret;
Linus Walleij3f0f8672012-11-20 12:40:15 +0100856 }
Andy Shevchenko1a2a99c2013-12-05 11:26:24 +0200857 chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
858 gpio_offset, gpio_offset + npins - 1,
Linus Walleij316511c2012-11-21 08:48:09 +0100859 pinctl_name,
860 pin_offset, pin_offset + npins - 1);
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530861
862 list_add_tail(&pin_range->node, &chip->pin_ranges);
Linus Walleij1e63d7b2012-11-06 16:03:35 +0100863
864 return 0;
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530865}
Linus Walleij165adc92012-11-06 14:49:39 +0100866EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530867
Linus Walleij3f0f8672012-11-20 12:40:15 +0100868/**
869 * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
870 * @chip: the chip to remove all the mappings for
871 */
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530872void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
873{
874 struct gpio_pin_range *pin_range, *tmp;
875
876 list_for_each_entry_safe(pin_range, tmp, &chip->pin_ranges, node) {
877 list_del(&pin_range->node);
878 pinctrl_remove_gpio_range(pin_range->pctldev,
879 &pin_range->range);
Linus Walleij3f0f8672012-11-20 12:40:15 +0100880 kfree(pin_range);
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530881 }
882}
Linus Walleij165adc92012-11-06 14:49:39 +0100883EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
884
885#endif /* CONFIG_PINCTRL */
Shiraz Hashimf23f1512012-10-27 15:21:36 +0530886
David Brownelld2876d02008-02-04 22:28:20 -0800887/* These "optional" allocation calls help prevent drivers from stomping
888 * on each other, and help provide better diagnostics in debugfs.
889 * They're called even less than the "set direction" calls.
890 */
Mika Westerberg77c2d792014-03-10 14:54:50 +0200891static int __gpiod_request(struct gpio_desc *desc, const char *label)
David Brownelld2876d02008-02-04 22:28:20 -0800892{
Mika Westerberg77c2d792014-03-10 14:54:50 +0200893 struct gpio_chip *chip = desc->chip;
894 int status;
David Brownelld2876d02008-02-04 22:28:20 -0800895 unsigned long flags;
896
897 spin_lock_irqsave(&gpio_lock, flags);
898
David Brownelld2876d02008-02-04 22:28:20 -0800899 /* NOTE: gpio_request() can be called in early boot,
David Brownell35e8bb52008-10-15 22:03:16 -0700900 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
David Brownelld2876d02008-02-04 22:28:20 -0800901 */
902
903 if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
904 desc_set_label(desc, label ? : "?");
905 status = 0;
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -0700906 } else {
David Brownelld2876d02008-02-04 22:28:20 -0800907 status = -EBUSY;
Magnus Damm7460db52009-01-29 14:25:12 -0800908 goto done;
David Brownell35e8bb52008-10-15 22:03:16 -0700909 }
910
911 if (chip->request) {
912 /* chip->request may sleep */
913 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbot372e7222013-02-03 01:29:29 +0900914 status = chip->request(chip, gpio_chip_hwgpio(desc));
David Brownell35e8bb52008-10-15 22:03:16 -0700915 spin_lock_irqsave(&gpio_lock, flags);
916
917 if (status < 0) {
918 desc_set_label(desc, NULL);
David Brownell35e8bb52008-10-15 22:03:16 -0700919 clear_bit(FLAG_REQUESTED, &desc->flags);
Mathias Nyman80b0a602012-10-24 17:25:27 +0300920 goto done;
David Brownell35e8bb52008-10-15 22:03:16 -0700921 }
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -0700922 }
Mathias Nyman80b0a602012-10-24 17:25:27 +0300923 if (chip->get_direction) {
924 /* chip->get_direction may sleep */
925 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbot372e7222013-02-03 01:29:29 +0900926 gpiod_get_direction(desc);
Mathias Nyman80b0a602012-10-24 17:25:27 +0300927 spin_lock_irqsave(&gpio_lock, flags);
928 }
David Brownelld2876d02008-02-04 22:28:20 -0800929done:
Laurent Pinchart923b93e2015-10-13 00:20:20 +0300930 if (status < 0) {
931 /* Clear flags that might have been set by the caller before
932 * requesting the GPIO.
933 */
934 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
935 clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
936 clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
937 }
Mika Westerberg77c2d792014-03-10 14:54:50 +0200938 spin_unlock_irqrestore(&gpio_lock, flags);
939 return status;
940}
941
Alexandre Courbot0eb4c6c2014-07-01 14:45:15 +0900942int gpiod_request(struct gpio_desc *desc, const char *label)
Mika Westerberg77c2d792014-03-10 14:54:50 +0200943{
944 int status = -EPROBE_DEFER;
945 struct gpio_chip *chip;
946
947 if (!desc) {
948 pr_warn("%s: invalid GPIO\n", __func__);
949 return -EINVAL;
950 }
951
952 chip = desc->chip;
953 if (!chip)
954 goto done;
955
956 if (try_module_get(chip->owner)) {
957 status = __gpiod_request(desc, label);
958 if (status < 0)
959 module_put(chip->owner);
960 }
961
962done:
David Brownelld2876d02008-02-04 22:28:20 -0800963 if (status)
Andy Shevchenko7589e592013-12-05 11:26:23 +0200964 gpiod_dbg(desc, "%s: status %d\n", __func__, status);
Mika Westerberg77c2d792014-03-10 14:54:50 +0200965
David Brownelld2876d02008-02-04 22:28:20 -0800966 return status;
967}
Alexandre Courbot372e7222013-02-03 01:29:29 +0900968
Mika Westerberg77c2d792014-03-10 14:54:50 +0200969static bool __gpiod_free(struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -0800970{
Mika Westerberg77c2d792014-03-10 14:54:50 +0200971 bool ret = false;
David Brownelld2876d02008-02-04 22:28:20 -0800972 unsigned long flags;
David Brownell35e8bb52008-10-15 22:03:16 -0700973 struct gpio_chip *chip;
David Brownelld2876d02008-02-04 22:28:20 -0800974
Uwe Kleine-König3d599d12008-10-15 22:03:12 -0700975 might_sleep();
976
Alexandre Courbot372e7222013-02-03 01:29:29 +0900977 gpiod_unexport(desc);
David Brownelld8f388d2008-07-25 01:46:07 -0700978
David Brownelld2876d02008-02-04 22:28:20 -0800979 spin_lock_irqsave(&gpio_lock, flags);
980
David Brownell35e8bb52008-10-15 22:03:16 -0700981 chip = desc->chip;
982 if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
983 if (chip->free) {
984 spin_unlock_irqrestore(&gpio_lock, flags);
David Brownell9c4ba942010-08-10 18:02:24 -0700985 might_sleep_if(chip->can_sleep);
Alexandre Courbot372e7222013-02-03 01:29:29 +0900986 chip->free(chip, gpio_chip_hwgpio(desc));
David Brownell35e8bb52008-10-15 22:03:16 -0700987 spin_lock_irqsave(&gpio_lock, flags);
988 }
David Brownelld2876d02008-02-04 22:28:20 -0800989 desc_set_label(desc, NULL);
Jani Nikula07697462009-12-15 16:46:20 -0800990 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
David Brownell35e8bb52008-10-15 22:03:16 -0700991 clear_bit(FLAG_REQUESTED, &desc->flags);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +0530992 clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
Laxman Dewangan25553ff2012-02-17 20:26:22 +0530993 clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
Benoit Parrotf625d462015-02-02 11:44:44 -0600994 clear_bit(FLAG_IS_HOGGED, &desc->flags);
Mika Westerberg77c2d792014-03-10 14:54:50 +0200995 ret = true;
996 }
David Brownelld2876d02008-02-04 22:28:20 -0800997
998 spin_unlock_irqrestore(&gpio_lock, flags);
Mika Westerberg77c2d792014-03-10 14:54:50 +0200999 return ret;
1000}
1001
Alexandre Courbot0eb4c6c2014-07-01 14:45:15 +09001002void gpiod_free(struct gpio_desc *desc)
Mika Westerberg77c2d792014-03-10 14:54:50 +02001003{
1004 if (desc && __gpiod_free(desc))
1005 module_put(desc->chip->owner);
1006 else
1007 WARN_ON(extra_checks);
David Brownelld2876d02008-02-04 22:28:20 -08001008}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001009
David Brownelld2876d02008-02-04 22:28:20 -08001010/**
1011 * gpiochip_is_requested - return string iff signal was requested
1012 * @chip: controller managing the signal
1013 * @offset: of signal within controller's 0..(ngpio - 1) range
1014 *
1015 * Returns NULL if the GPIO is not currently requested, else a string.
Alexandre Courbot9c8318f2014-07-01 14:45:14 +09001016 * The string returned is the label passed to gpio_request(); if none has been
1017 * passed it is a meaningless, non-NULL constant.
David Brownelld2876d02008-02-04 22:28:20 -08001018 *
1019 * This function is for use by GPIO controller drivers. The label can
1020 * help with diagnostics, and knowing that the signal is used as a GPIO
1021 * can help avoid accidentally multiplexing it to another controller.
1022 */
1023const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
1024{
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001025 struct gpio_desc *desc;
David Brownelld2876d02008-02-04 22:28:20 -08001026
Dirk Behme48b59532015-08-18 18:02:32 +02001027 if (offset >= chip->ngpio)
David Brownelld2876d02008-02-04 22:28:20 -08001028 return NULL;
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001029
1030 desc = &chip->desc[offset];
1031
Alexandre Courbot372e7222013-02-03 01:29:29 +09001032 if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
David Brownelld2876d02008-02-04 22:28:20 -08001033 return NULL;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001034 return desc->label;
David Brownelld2876d02008-02-04 22:28:20 -08001035}
1036EXPORT_SYMBOL_GPL(gpiochip_is_requested);
1037
Mika Westerberg77c2d792014-03-10 14:54:50 +02001038/**
1039 * gpiochip_request_own_desc - Allow GPIO chip to request its own descriptor
1040 * @desc: GPIO descriptor to request
1041 * @label: label for the GPIO
1042 *
1043 * Function allows GPIO chip drivers to request and use their own GPIO
1044 * descriptors via gpiolib API. Difference to gpiod_request() is that this
1045 * function will not increase reference count of the GPIO chip module. This
1046 * allows the GPIO chip module to be unloaded as needed (we assume that the
1047 * GPIO chip driver handles freeing the GPIOs it has requested).
1048 */
Alexandre Courbotabdc08a2014-08-19 10:06:09 -07001049struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip, u16 hwnum,
1050 const char *label)
Mika Westerberg77c2d792014-03-10 14:54:50 +02001051{
Alexandre Courbotabdc08a2014-08-19 10:06:09 -07001052 struct gpio_desc *desc = gpiochip_get_desc(chip, hwnum);
1053 int err;
Mika Westerberg77c2d792014-03-10 14:54:50 +02001054
Alexandre Courbotabdc08a2014-08-19 10:06:09 -07001055 if (IS_ERR(desc)) {
1056 chip_err(chip, "failed to get GPIO descriptor\n");
1057 return desc;
1058 }
1059
1060 err = __gpiod_request(desc, label);
1061 if (err < 0)
1062 return ERR_PTR(err);
1063
1064 return desc;
Mika Westerberg77c2d792014-03-10 14:54:50 +02001065}
Guenter Roeckf7d4ad92014-07-22 08:01:01 -07001066EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
Mika Westerberg77c2d792014-03-10 14:54:50 +02001067
1068/**
1069 * gpiochip_free_own_desc - Free GPIO requested by the chip driver
1070 * @desc: GPIO descriptor to free
1071 *
1072 * Function frees the given GPIO requested previously with
1073 * gpiochip_request_own_desc().
1074 */
1075void gpiochip_free_own_desc(struct gpio_desc *desc)
1076{
1077 if (desc)
1078 __gpiod_free(desc);
1079}
Guenter Roeckf7d4ad92014-07-22 08:01:01 -07001080EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
David Brownelld2876d02008-02-04 22:28:20 -08001081
1082/* Drivers MUST set GPIO direction before making get/set calls. In
1083 * some cases this is done in early boot, before IRQs are enabled.
1084 *
1085 * As a rule these aren't called more than once (except for drivers
1086 * using the open-drain emulation idiom) so these are natural places
1087 * to accumulate extra debugging checks. Note that we can't (yet)
1088 * rely on gpio_request() having been called beforehand.
1089 */
1090
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001091/**
1092 * gpiod_direction_input - set the GPIO direction to input
1093 * @desc: GPIO to set to input
1094 *
1095 * Set the direction of the passed GPIO to input, such as gpiod_get_value() can
1096 * be called safely on it.
1097 *
1098 * Return 0 in case of success, else an error code.
1099 */
1100int gpiod_direction_input(struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -08001101{
David Brownelld2876d02008-02-04 22:28:20 -08001102 struct gpio_chip *chip;
David Brownelld2876d02008-02-04 22:28:20 -08001103 int status = -EINVAL;
1104
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001105 if (!desc || !desc->chip) {
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001106 pr_warn("%s: invalid GPIO\n", __func__);
1107 return -EINVAL;
1108 }
1109
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001110 chip = desc->chip;
1111 if (!chip->get || !chip->direction_input) {
Mark Brown6424de52013-09-09 10:33:49 +01001112 gpiod_warn(desc,
1113 "%s: missing get() or direction_input() operations\n",
Andy Shevchenko7589e592013-12-05 11:26:23 +02001114 __func__);
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001115 return -EIO;
1116 }
1117
Alexandre Courbotd82da792014-07-22 16:17:43 +09001118 status = chip->direction_input(chip, gpio_chip_hwgpio(desc));
David Brownelld2876d02008-02-04 22:28:20 -08001119 if (status == 0)
1120 clear_bit(FLAG_IS_OUT, &desc->flags);
Uwe Kleine-König3f397c212011-05-20 00:40:19 -06001121
Alexandre Courbot372e7222013-02-03 01:29:29 +09001122 trace_gpio_direction(desc_to_gpio(desc), 1, status);
Alexandre Courbotd82da792014-07-22 16:17:43 +09001123
David Brownelld2876d02008-02-04 22:28:20 -08001124 return status;
1125}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001126EXPORT_SYMBOL_GPL(gpiod_direction_input);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001127
Philipp Zabelef70bbe2014-01-07 12:34:11 +01001128static int _gpiod_direction_output_raw(struct gpio_desc *desc, int value)
David Brownelld2876d02008-02-04 22:28:20 -08001129{
David Brownelld2876d02008-02-04 22:28:20 -08001130 struct gpio_chip *chip;
David Brownelld2876d02008-02-04 22:28:20 -08001131 int status = -EINVAL;
1132
Linus Walleijd468bf92013-09-24 11:54:38 +02001133 /* GPIOs used for IRQs shall not be set as output */
1134 if (test_bit(FLAG_USED_AS_IRQ, &desc->flags)) {
1135 gpiod_err(desc,
1136 "%s: tried to set a GPIO tied to an IRQ as output\n",
1137 __func__);
1138 return -EIO;
1139 }
1140
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301141 /* Open drain pin should not be driven to 1 */
1142 if (value && test_bit(FLAG_OPEN_DRAIN, &desc->flags))
Alexandre Courbot372e7222013-02-03 01:29:29 +09001143 return gpiod_direction_input(desc);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301144
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301145 /* Open source pin should not be driven to 0 */
1146 if (!value && test_bit(FLAG_OPEN_SOURCE, &desc->flags))
Alexandre Courbot372e7222013-02-03 01:29:29 +09001147 return gpiod_direction_input(desc);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301148
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001149 chip = desc->chip;
1150 if (!chip->set || !chip->direction_output) {
Mark Brown6424de52013-09-09 10:33:49 +01001151 gpiod_warn(desc,
1152 "%s: missing set() or direction_output() operations\n",
1153 __func__);
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001154 return -EIO;
1155 }
1156
Alexandre Courbotd82da792014-07-22 16:17:43 +09001157 status = chip->direction_output(chip, gpio_chip_hwgpio(desc), value);
David Brownelld2876d02008-02-04 22:28:20 -08001158 if (status == 0)
1159 set_bit(FLAG_IS_OUT, &desc->flags);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001160 trace_gpio_value(desc_to_gpio(desc), 0, value);
1161 trace_gpio_direction(desc_to_gpio(desc), 0, status);
David Brownelld2876d02008-02-04 22:28:20 -08001162 return status;
1163}
Philipp Zabelef70bbe2014-01-07 12:34:11 +01001164
1165/**
1166 * gpiod_direction_output_raw - set the GPIO direction to output
1167 * @desc: GPIO to set to output
1168 * @value: initial output value of the GPIO
1169 *
1170 * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
1171 * be called safely on it. The initial value of the output must be specified
1172 * as raw value on the physical line without regard for the ACTIVE_LOW status.
1173 *
1174 * Return 0 in case of success, else an error code.
1175 */
1176int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
1177{
1178 if (!desc || !desc->chip) {
1179 pr_warn("%s: invalid GPIO\n", __func__);
1180 return -EINVAL;
1181 }
1182 return _gpiod_direction_output_raw(desc, value);
1183}
1184EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);
1185
1186/**
Rahul Bedarkar90df4fe2014-02-08 11:55:25 +05301187 * gpiod_direction_output - set the GPIO direction to output
Philipp Zabelef70bbe2014-01-07 12:34:11 +01001188 * @desc: GPIO to set to output
1189 * @value: initial output value of the GPIO
1190 *
1191 * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
1192 * be called safely on it. The initial value of the output must be specified
1193 * as the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
1194 * account.
1195 *
1196 * Return 0 in case of success, else an error code.
1197 */
1198int gpiod_direction_output(struct gpio_desc *desc, int value)
1199{
1200 if (!desc || !desc->chip) {
1201 pr_warn("%s: invalid GPIO\n", __func__);
1202 return -EINVAL;
1203 }
1204 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
1205 value = !value;
1206 return _gpiod_direction_output_raw(desc, value);
1207}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001208EXPORT_SYMBOL_GPL(gpiod_direction_output);
David Brownelld2876d02008-02-04 22:28:20 -08001209
Felipe Balbic4b5be92010-05-26 14:42:23 -07001210/**
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001211 * gpiod_set_debounce - sets @debounce time for a @gpio
Felipe Balbic4b5be92010-05-26 14:42:23 -07001212 * @gpio: the gpio to set debounce time
1213 * @debounce: debounce time is microseconds
Linus Walleij65d87652013-09-04 14:17:08 +02001214 *
1215 * returns -ENOTSUPP if the controller does not support setting
1216 * debounce.
Felipe Balbic4b5be92010-05-26 14:42:23 -07001217 */
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001218int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
Felipe Balbic4b5be92010-05-26 14:42:23 -07001219{
Felipe Balbic4b5be92010-05-26 14:42:23 -07001220 struct gpio_chip *chip;
Felipe Balbic4b5be92010-05-26 14:42:23 -07001221
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001222 if (!desc || !desc->chip) {
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001223 pr_warn("%s: invalid GPIO\n", __func__);
1224 return -EINVAL;
1225 }
1226
Felipe Balbic4b5be92010-05-26 14:42:23 -07001227 chip = desc->chip;
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001228 if (!chip->set || !chip->set_debounce) {
Mark Brown6424de52013-09-09 10:33:49 +01001229 gpiod_dbg(desc,
1230 "%s: missing set() or set_debounce() operations\n",
1231 __func__);
Linus Walleij65d87652013-09-04 14:17:08 +02001232 return -ENOTSUPP;
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001233 }
1234
Alexandre Courbotd82da792014-07-22 16:17:43 +09001235 return chip->set_debounce(chip, gpio_chip_hwgpio(desc), debounce);
Felipe Balbic4b5be92010-05-26 14:42:23 -07001236}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001237EXPORT_SYMBOL_GPL(gpiod_set_debounce);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001238
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001239/**
1240 * gpiod_is_active_low - test whether a GPIO is active-low or not
1241 * @desc: the gpio descriptor to test
1242 *
1243 * Returns 1 if the GPIO is active-low, 0 otherwise.
1244 */
1245int gpiod_is_active_low(const struct gpio_desc *desc)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001246{
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001247 return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001248}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001249EXPORT_SYMBOL_GPL(gpiod_is_active_low);
David Brownelld2876d02008-02-04 22:28:20 -08001250
1251/* I/O calls are only valid after configuration completed; the relevant
1252 * "is this a valid GPIO" error checks should already have been done.
1253 *
1254 * "Get" operations are often inlinable as reading a pin value register,
1255 * and masking the relevant bit in that register.
1256 *
1257 * When "set" operations are inlinable, they involve writing that mask to
1258 * one register to set a low value, or a different register to set it high.
1259 * Otherwise locking is needed, so there may be little value to inlining.
1260 *
1261 *------------------------------------------------------------------------
1262 *
1263 * IMPORTANT!!! The hot paths -- get/set value -- assume that callers
1264 * have requested the GPIO. That can include implicit requesting by
1265 * a direction setting call. Marking a gpio as requested locks its chip
1266 * in memory, guaranteeing that these table lookups need no more locking
1267 * and that gpiochip_remove() will fail.
1268 *
1269 * REVISIT when debugging, consider adding some instrumentation to ensure
1270 * that the GPIO was actually requested.
1271 */
1272
Bjorn Anderssone20538b2015-08-28 09:44:18 -07001273static int _gpiod_get_raw_value(const struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -08001274{
1275 struct gpio_chip *chip;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001276 int offset;
Bjorn Anderssone20538b2015-08-28 09:44:18 -07001277 int value;
David Brownelld2876d02008-02-04 22:28:20 -08001278
Alexandre Courbot372e7222013-02-03 01:29:29 +09001279 chip = desc->chip;
1280 offset = gpio_chip_hwgpio(desc);
Bjorn Anderssone20538b2015-08-28 09:44:18 -07001281 value = chip->get ? chip->get(chip, offset) : -EIO;
1282 value = value < 0 ? value : !!value;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001283 trace_gpio_value(desc_to_gpio(desc), 1, value);
Uwe Kleine-König3f397c212011-05-20 00:40:19 -06001284 return value;
David Brownelld2876d02008-02-04 22:28:20 -08001285}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001286
David Brownelld2876d02008-02-04 22:28:20 -08001287/**
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001288 * gpiod_get_raw_value() - return a gpio's raw value
1289 * @desc: gpio whose value will be returned
David Brownelld2876d02008-02-04 22:28:20 -08001290 *
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001291 * Return the GPIO's raw value, i.e. the value of the physical line disregarding
Bjorn Anderssone20538b2015-08-28 09:44:18 -07001292 * its ACTIVE_LOW status, or negative errno on failure.
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001293 *
1294 * This function should be called from contexts where we cannot sleep, and will
1295 * complain if the GPIO chip functions potentially sleep.
David Brownelld2876d02008-02-04 22:28:20 -08001296 */
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001297int gpiod_get_raw_value(const struct gpio_desc *desc)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001298{
David Brownelld2876d02008-02-04 22:28:20 -08001299 if (!desc)
1300 return 0;
David Brownelld2876d02008-02-04 22:28:20 -08001301 /* Should be using gpio_get_value_cansleep() */
Alexandre Courbotd8e0ac02013-09-04 20:29:25 +09001302 WARN_ON(desc->chip->can_sleep);
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001303 return _gpiod_get_raw_value(desc);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001304}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001305EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
David Brownelld2876d02008-02-04 22:28:20 -08001306
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001307/**
1308 * gpiod_get_value() - return a gpio's value
1309 * @desc: gpio whose value will be returned
1310 *
1311 * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
Bjorn Anderssone20538b2015-08-28 09:44:18 -07001312 * account, or negative errno on failure.
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001313 *
1314 * This function should be called from contexts where we cannot sleep, and will
1315 * complain if the GPIO chip functions potentially sleep.
1316 */
1317int gpiod_get_value(const struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -08001318{
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001319 int value;
1320 if (!desc)
1321 return 0;
1322 /* Should be using gpio_get_value_cansleep() */
1323 WARN_ON(desc->chip->can_sleep);
1324
1325 value = _gpiod_get_raw_value(desc);
Bjorn Anderssone20538b2015-08-28 09:44:18 -07001326 if (value < 0)
1327 return value;
1328
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001329 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
1330 value = !value;
1331
1332 return value;
David Brownelld2876d02008-02-04 22:28:20 -08001333}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001334EXPORT_SYMBOL_GPL(gpiod_get_value);
David Brownelld2876d02008-02-04 22:28:20 -08001335
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301336/*
1337 * _gpio_set_open_drain_value() - Set the open drain gpio's value.
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001338 * @desc: gpio descriptor whose state need to be set.
Colin Cronin20a8a962015-05-18 11:41:43 -07001339 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301340 */
Alexandre Courbot23600962014-03-11 15:52:09 +09001341static void _gpio_set_open_drain_value(struct gpio_desc *desc, bool value)
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301342{
1343 int err = 0;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001344 struct gpio_chip *chip = desc->chip;
1345 int offset = gpio_chip_hwgpio(desc);
1346
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301347 if (value) {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001348 err = chip->direction_input(chip, offset);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301349 if (!err)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001350 clear_bit(FLAG_IS_OUT, &desc->flags);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301351 } else {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001352 err = chip->direction_output(chip, offset, 0);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301353 if (!err)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001354 set_bit(FLAG_IS_OUT, &desc->flags);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301355 }
Alexandre Courbot372e7222013-02-03 01:29:29 +09001356 trace_gpio_direction(desc_to_gpio(desc), value, err);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301357 if (err < 0)
Mark Brown6424de52013-09-09 10:33:49 +01001358 gpiod_err(desc,
1359 "%s: Error in set_value for open drain err %d\n",
1360 __func__, err);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301361}
1362
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301363/*
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001364 * _gpio_set_open_source_value() - Set the open source gpio's value.
1365 * @desc: gpio descriptor whose state need to be set.
Colin Cronin20a8a962015-05-18 11:41:43 -07001366 * @value: Non-zero for setting it HIGH otherwise it will set to LOW.
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301367 */
Alexandre Courbot23600962014-03-11 15:52:09 +09001368static void _gpio_set_open_source_value(struct gpio_desc *desc, bool value)
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301369{
1370 int err = 0;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001371 struct gpio_chip *chip = desc->chip;
1372 int offset = gpio_chip_hwgpio(desc);
1373
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301374 if (value) {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001375 err = chip->direction_output(chip, offset, 1);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301376 if (!err)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001377 set_bit(FLAG_IS_OUT, &desc->flags);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301378 } else {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001379 err = chip->direction_input(chip, offset);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301380 if (!err)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001381 clear_bit(FLAG_IS_OUT, &desc->flags);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301382 }
Alexandre Courbot372e7222013-02-03 01:29:29 +09001383 trace_gpio_direction(desc_to_gpio(desc), !value, err);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301384 if (err < 0)
Mark Brown6424de52013-09-09 10:33:49 +01001385 gpiod_err(desc,
1386 "%s: Error in set_value for open source err %d\n",
1387 __func__, err);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301388}
1389
Alexandre Courbot23600962014-03-11 15:52:09 +09001390static void _gpiod_set_raw_value(struct gpio_desc *desc, bool value)
David Brownelld2876d02008-02-04 22:28:20 -08001391{
1392 struct gpio_chip *chip;
1393
Alexandre Courbot372e7222013-02-03 01:29:29 +09001394 chip = desc->chip;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001395 trace_gpio_value(desc_to_gpio(desc), 0, value);
1396 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
1397 _gpio_set_open_drain_value(desc, value);
1398 else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
1399 _gpio_set_open_source_value(desc, value);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301400 else
Alexandre Courbot372e7222013-02-03 01:29:29 +09001401 chip->set(chip, gpio_chip_hwgpio(desc), value);
1402}
1403
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001404/*
1405 * set multiple outputs on the same chip;
1406 * use the chip's set_multiple function if available;
1407 * otherwise set the outputs sequentially;
1408 * @mask: bit mask array; one bit per output; BITS_PER_LONG bits per word
1409 * defines which outputs are to be changed
1410 * @bits: bit value array; one bit per output; BITS_PER_LONG bits per word
1411 * defines the values the outputs specified by mask are to be set to
1412 */
1413static void gpio_chip_set_multiple(struct gpio_chip *chip,
1414 unsigned long *mask, unsigned long *bits)
1415{
1416 if (chip->set_multiple) {
1417 chip->set_multiple(chip, mask, bits);
1418 } else {
1419 int i;
1420 for (i = 0; i < chip->ngpio; i++) {
1421 if (mask[BIT_WORD(i)] == 0) {
1422 /* no more set bits in this mask word;
1423 * skip ahead to the next word */
1424 i = (BIT_WORD(i) + 1) * BITS_PER_LONG - 1;
1425 continue;
1426 }
1427 /* set outputs if the corresponding mask bit is set */
Daniel Lockyer38e003f2015-06-10 14:26:27 +01001428 if (__test_and_clear_bit(i, mask))
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001429 chip->set(chip, i, test_bit(i, bits));
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001430 }
1431 }
1432}
1433
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001434static void gpiod_set_array_value_priv(bool raw, bool can_sleep,
1435 unsigned int array_size,
1436 struct gpio_desc **desc_array,
1437 int *value_array)
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001438{
1439 int i = 0;
1440
1441 while (i < array_size) {
1442 struct gpio_chip *chip = desc_array[i]->chip;
1443 unsigned long mask[BITS_TO_LONGS(chip->ngpio)];
1444 unsigned long bits[BITS_TO_LONGS(chip->ngpio)];
1445 int count = 0;
1446
Daniel Lockyer38e003f2015-06-10 14:26:27 +01001447 if (!can_sleep)
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001448 WARN_ON(chip->can_sleep);
Daniel Lockyer38e003f2015-06-10 14:26:27 +01001449
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001450 memset(mask, 0, sizeof(mask));
1451 do {
1452 struct gpio_desc *desc = desc_array[i];
1453 int hwgpio = gpio_chip_hwgpio(desc);
1454 int value = value_array[i];
1455
1456 if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags))
1457 value = !value;
1458 trace_gpio_value(desc_to_gpio(desc), 0, value);
1459 /*
1460 * collect all normal outputs belonging to the same chip
1461 * open drain and open source outputs are set individually
1462 */
1463 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
Daniel Lockyer38e003f2015-06-10 14:26:27 +01001464 _gpio_set_open_drain_value(desc, value);
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001465 } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
1466 _gpio_set_open_source_value(desc, value);
1467 } else {
1468 __set_bit(hwgpio, mask);
Daniel Lockyer38e003f2015-06-10 14:26:27 +01001469 if (value)
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001470 __set_bit(hwgpio, bits);
Daniel Lockyer38e003f2015-06-10 14:26:27 +01001471 else
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001472 __clear_bit(hwgpio, bits);
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001473 count++;
1474 }
1475 i++;
1476 } while ((i < array_size) && (desc_array[i]->chip == chip));
1477 /* push collected bits to outputs */
Daniel Lockyer38e003f2015-06-10 14:26:27 +01001478 if (count != 0)
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001479 gpio_chip_set_multiple(chip, mask, bits);
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001480 }
1481}
1482
David Brownelld2876d02008-02-04 22:28:20 -08001483/**
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001484 * gpiod_set_raw_value() - assign a gpio's raw value
1485 * @desc: gpio whose value will be assigned
David Brownelld2876d02008-02-04 22:28:20 -08001486 * @value: value to assign
David Brownelld2876d02008-02-04 22:28:20 -08001487 *
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001488 * Set the raw value of the GPIO, i.e. the value of its physical line without
1489 * regard for its ACTIVE_LOW status.
1490 *
1491 * This function should be called from contexts where we cannot sleep, and will
1492 * complain if the GPIO chip functions potentially sleep.
David Brownelld2876d02008-02-04 22:28:20 -08001493 */
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001494void gpiod_set_raw_value(struct gpio_desc *desc, int value)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001495{
David Brownelld2876d02008-02-04 22:28:20 -08001496 if (!desc)
1497 return;
David Brownelld2876d02008-02-04 22:28:20 -08001498 /* Should be using gpio_set_value_cansleep() */
Alexandre Courbotd8e0ac02013-09-04 20:29:25 +09001499 WARN_ON(desc->chip->can_sleep);
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001500 _gpiod_set_raw_value(desc, value);
David Brownelld2876d02008-02-04 22:28:20 -08001501}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001502EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
David Brownelld2876d02008-02-04 22:28:20 -08001503
1504/**
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001505 * gpiod_set_value() - assign a gpio's value
1506 * @desc: gpio whose value will be assigned
1507 * @value: value to assign
David Brownelld2876d02008-02-04 22:28:20 -08001508 *
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001509 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
1510 * account
1511 *
1512 * This function should be called from contexts where we cannot sleep, and will
1513 * complain if the GPIO chip functions potentially sleep.
David Brownelld2876d02008-02-04 22:28:20 -08001514 */
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001515void gpiod_set_value(struct gpio_desc *desc, int value)
1516{
1517 if (!desc)
1518 return;
1519 /* Should be using gpio_set_value_cansleep() */
1520 WARN_ON(desc->chip->can_sleep);
1521 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
1522 value = !value;
1523 _gpiod_set_raw_value(desc, value);
1524}
1525EXPORT_SYMBOL_GPL(gpiod_set_value);
1526
1527/**
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001528 * gpiod_set_raw_array_value() - assign values to an array of GPIOs
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001529 * @array_size: number of elements in the descriptor / value arrays
1530 * @desc_array: array of GPIO descriptors whose values will be assigned
1531 * @value_array: array of values to assign
1532 *
1533 * Set the raw values of the GPIOs, i.e. the values of the physical lines
1534 * without regard for their ACTIVE_LOW status.
1535 *
1536 * This function should be called from contexts where we cannot sleep, and will
1537 * complain if the GPIO chip functions potentially sleep.
1538 */
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001539void gpiod_set_raw_array_value(unsigned int array_size,
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001540 struct gpio_desc **desc_array, int *value_array)
1541{
1542 if (!desc_array)
1543 return;
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001544 gpiod_set_array_value_priv(true, false, array_size, desc_array,
1545 value_array);
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001546}
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001547EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value);
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001548
1549/**
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001550 * gpiod_set_array_value() - assign values to an array of GPIOs
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001551 * @array_size: number of elements in the descriptor / value arrays
1552 * @desc_array: array of GPIO descriptors whose values will be assigned
1553 * @value_array: array of values to assign
1554 *
1555 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
1556 * into account.
1557 *
1558 * This function should be called from contexts where we cannot sleep, and will
1559 * complain if the GPIO chip functions potentially sleep.
1560 */
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001561void gpiod_set_array_value(unsigned int array_size,
1562 struct gpio_desc **desc_array, int *value_array)
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001563{
1564 if (!desc_array)
1565 return;
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001566 gpiod_set_array_value_priv(false, false, array_size, desc_array,
1567 value_array);
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001568}
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001569EXPORT_SYMBOL_GPL(gpiod_set_array_value);
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001570
1571/**
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001572 * gpiod_cansleep() - report whether gpio value access may sleep
1573 * @desc: gpio to check
1574 *
1575 */
1576int gpiod_cansleep(const struct gpio_desc *desc)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001577{
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001578 if (!desc)
1579 return 0;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001580 return desc->chip->can_sleep;
1581}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001582EXPORT_SYMBOL_GPL(gpiod_cansleep);
David Brownelld2876d02008-02-04 22:28:20 -08001583
David Brownell0f6d5042008-10-15 22:03:14 -07001584/**
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001585 * gpiod_to_irq() - return the IRQ corresponding to a GPIO
1586 * @desc: gpio whose IRQ will be returned (already requested)
David Brownell0f6d5042008-10-15 22:03:14 -07001587 *
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001588 * Return the IRQ corresponding to the passed GPIO, or an error code in case of
1589 * error.
David Brownell0f6d5042008-10-15 22:03:14 -07001590 */
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001591int gpiod_to_irq(const struct gpio_desc *desc)
David Brownell0f6d5042008-10-15 22:03:14 -07001592{
1593 struct gpio_chip *chip;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001594 int offset;
David Brownell0f6d5042008-10-15 22:03:14 -07001595
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001596 if (!desc)
1597 return -EINVAL;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001598 chip = desc->chip;
1599 offset = gpio_chip_hwgpio(desc);
1600 return chip->to_irq ? chip->to_irq(chip, offset) : -ENXIO;
1601}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001602EXPORT_SYMBOL_GPL(gpiod_to_irq);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001603
Linus Walleijd468bf92013-09-24 11:54:38 +02001604/**
Alexandre Courbote3a2e872014-10-23 17:27:07 +09001605 * gpiochip_lock_as_irq() - lock a GPIO to be used as IRQ
Alexandre Courbotd74be6d2014-07-22 16:17:42 +09001606 * @chip: the chip the GPIO to lock belongs to
1607 * @offset: the offset of the GPIO to lock as IRQ
Linus Walleijd468bf92013-09-24 11:54:38 +02001608 *
1609 * This is used directly by GPIO drivers that want to lock down
Linus Walleijf438acd2014-03-07 10:12:49 +08001610 * a certain GPIO line to be used for IRQs.
David Brownelld2876d02008-02-04 22:28:20 -08001611 */
Alexandre Courbote3a2e872014-10-23 17:27:07 +09001612int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
David Brownelld2876d02008-02-04 22:28:20 -08001613{
Alexandre Courbotd74be6d2014-07-22 16:17:42 +09001614 if (offset >= chip->ngpio)
Linus Walleijd468bf92013-09-24 11:54:38 +02001615 return -EINVAL;
1616
Alexandre Courbotd74be6d2014-07-22 16:17:42 +09001617 if (test_bit(FLAG_IS_OUT, &chip->desc[offset].flags)) {
1618 chip_err(chip,
Linus Walleijd468bf92013-09-24 11:54:38 +02001619 "%s: tried to flag a GPIO set as output for IRQ\n",
1620 __func__);
1621 return -EIO;
1622 }
1623
Alexandre Courbotd74be6d2014-07-22 16:17:42 +09001624 set_bit(FLAG_USED_AS_IRQ, &chip->desc[offset].flags);
Linus Walleijd468bf92013-09-24 11:54:38 +02001625 return 0;
1626}
Alexandre Courbote3a2e872014-10-23 17:27:07 +09001627EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
Linus Walleijd468bf92013-09-24 11:54:38 +02001628
Linus Walleijd468bf92013-09-24 11:54:38 +02001629/**
Alexandre Courbote3a2e872014-10-23 17:27:07 +09001630 * gpiochip_unlock_as_irq() - unlock a GPIO used as IRQ
Alexandre Courbotd74be6d2014-07-22 16:17:42 +09001631 * @chip: the chip the GPIO to lock belongs to
1632 * @offset: the offset of the GPIO to lock as IRQ
Linus Walleijd468bf92013-09-24 11:54:38 +02001633 *
1634 * This is used directly by GPIO drivers that want to indicate
1635 * that a certain GPIO is no longer used exclusively for IRQ.
1636 */
Alexandre Courbote3a2e872014-10-23 17:27:07 +09001637void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
Linus Walleijd468bf92013-09-24 11:54:38 +02001638{
Alexandre Courbotd74be6d2014-07-22 16:17:42 +09001639 if (offset >= chip->ngpio)
Linus Walleijd468bf92013-09-24 11:54:38 +02001640 return;
1641
Alexandre Courbotd74be6d2014-07-22 16:17:42 +09001642 clear_bit(FLAG_USED_AS_IRQ, &chip->desc[offset].flags);
Linus Walleijd468bf92013-09-24 11:54:38 +02001643}
Alexandre Courbote3a2e872014-10-23 17:27:07 +09001644EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq);
Linus Walleijd468bf92013-09-24 11:54:38 +02001645
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001646/**
1647 * gpiod_get_raw_value_cansleep() - return a gpio's raw value
1648 * @desc: gpio whose value will be returned
1649 *
1650 * Return the GPIO's raw value, i.e. the value of the physical line disregarding
Bjorn Anderssone20538b2015-08-28 09:44:18 -07001651 * its ACTIVE_LOW status, or negative errno on failure.
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001652 *
1653 * This function is to be called from contexts that can sleep.
David Brownelld2876d02008-02-04 22:28:20 -08001654 */
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001655int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -08001656{
David Brownelld2876d02008-02-04 22:28:20 -08001657 might_sleep_if(extra_checks);
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001658 if (!desc)
1659 return 0;
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001660 return _gpiod_get_raw_value(desc);
David Brownelld2876d02008-02-04 22:28:20 -08001661}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001662EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001663
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001664/**
1665 * gpiod_get_value_cansleep() - return a gpio's value
1666 * @desc: gpio whose value will be returned
1667 *
1668 * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
Bjorn Anderssone20538b2015-08-28 09:44:18 -07001669 * account, or negative errno on failure.
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001670 *
1671 * This function is to be called from contexts that can sleep.
1672 */
1673int gpiod_get_value_cansleep(const struct gpio_desc *desc)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001674{
David Brownelld2876d02008-02-04 22:28:20 -08001675 int value;
David Brownelld2876d02008-02-04 22:28:20 -08001676
1677 might_sleep_if(extra_checks);
1678 if (!desc)
1679 return 0;
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001680
1681 value = _gpiod_get_raw_value(desc);
Bjorn Anderssone20538b2015-08-28 09:44:18 -07001682 if (value < 0)
1683 return value;
1684
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001685 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
1686 value = !value;
1687
David Brownelld2876d02008-02-04 22:28:20 -08001688 return value;
1689}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001690EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001691
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001692/**
1693 * gpiod_set_raw_value_cansleep() - assign a gpio's raw value
1694 * @desc: gpio whose value will be assigned
1695 * @value: value to assign
1696 *
1697 * Set the raw value of the GPIO, i.e. the value of its physical line without
1698 * regard for its ACTIVE_LOW status.
1699 *
1700 * This function is to be called from contexts that can sleep.
1701 */
1702void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001703{
David Brownelld2876d02008-02-04 22:28:20 -08001704 might_sleep_if(extra_checks);
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001705 if (!desc)
1706 return;
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001707 _gpiod_set_raw_value(desc, value);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001708}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001709EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001710
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001711/**
1712 * gpiod_set_value_cansleep() - assign a gpio's value
1713 * @desc: gpio whose value will be assigned
1714 * @value: value to assign
1715 *
1716 * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
1717 * account
1718 *
1719 * This function is to be called from contexts that can sleep.
1720 */
1721void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001722{
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001723 might_sleep_if(extra_checks);
1724 if (!desc)
1725 return;
1726
1727 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
1728 value = !value;
1729 _gpiod_set_raw_value(desc, value);
David Brownelld2876d02008-02-04 22:28:20 -08001730}
Alexandre Courbot79a9bec2013-10-17 10:21:36 -07001731EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
David Brownelld2876d02008-02-04 22:28:20 -08001732
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001733/**
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001734 * gpiod_set_raw_array_value_cansleep() - assign values to an array of GPIOs
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001735 * @array_size: number of elements in the descriptor / value arrays
1736 * @desc_array: array of GPIO descriptors whose values will be assigned
1737 * @value_array: array of values to assign
1738 *
1739 * Set the raw values of the GPIOs, i.e. the values of the physical lines
1740 * without regard for their ACTIVE_LOW status.
1741 *
1742 * This function is to be called from contexts that can sleep.
1743 */
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001744void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
1745 struct gpio_desc **desc_array,
1746 int *value_array)
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001747{
1748 might_sleep_if(extra_checks);
1749 if (!desc_array)
1750 return;
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001751 gpiod_set_array_value_priv(true, true, array_size, desc_array,
1752 value_array);
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001753}
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001754EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep);
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001755
1756/**
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001757 * gpiod_set_array_value_cansleep() - assign values to an array of GPIOs
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001758 * @array_size: number of elements in the descriptor / value arrays
1759 * @desc_array: array of GPIO descriptors whose values will be assigned
1760 * @value_array: array of values to assign
1761 *
1762 * Set the logical values of the GPIOs, i.e. taking their ACTIVE_LOW status
1763 * into account.
1764 *
1765 * This function is to be called from contexts that can sleep.
1766 */
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001767void gpiod_set_array_value_cansleep(unsigned int array_size,
1768 struct gpio_desc **desc_array,
1769 int *value_array)
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001770{
1771 might_sleep_if(extra_checks);
1772 if (!desc_array)
1773 return;
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001774 gpiod_set_array_value_priv(false, true, array_size, desc_array,
1775 value_array);
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001776}
Rojhalat Ibrahim3fff99b2015-05-13 11:04:56 +02001777EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep);
Rojhalat Ibrahim5f424242014-11-04 17:12:06 +01001778
1779/**
Alexandre Courbotad824782013-12-03 12:20:11 +09001780 * gpiod_add_lookup_table() - register GPIO device consumers
1781 * @table: table of consumers to register
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001782 */
Alexandre Courbotad824782013-12-03 12:20:11 +09001783void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001784{
1785 mutex_lock(&gpio_lookup_lock);
1786
Alexandre Courbotad824782013-12-03 12:20:11 +09001787 list_add_tail(&table->list, &gpio_lookup_list);
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001788
1789 mutex_unlock(&gpio_lookup_lock);
David Brownelld2876d02008-02-04 22:28:20 -08001790}
1791
Shobhit Kumarbe9015a2015-06-26 14:32:04 +05301792/**
1793 * gpiod_remove_lookup_table() - unregister GPIO device consumers
1794 * @table: table of consumers to unregister
1795 */
1796void gpiod_remove_lookup_table(struct gpiod_lookup_table *table)
1797{
1798 mutex_lock(&gpio_lookup_lock);
1799
1800 list_del(&table->list);
1801
1802 mutex_unlock(&gpio_lookup_lock);
1803}
1804
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001805static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
Alexandre Courbot53e7cac2013-11-16 21:44:52 +09001806 unsigned int idx,
1807 enum gpio_lookup_flags *flags)
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001808{
1809 char prop_name[32]; /* 32 is max size of property name */
1810 enum of_gpio_flags of_flags;
1811 struct gpio_desc *desc;
Thierry Redingdd34c372014-04-23 17:28:09 +02001812 unsigned int i;
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001813
Rojhalat Ibrahim7f2e5532015-02-11 17:27:55 +01001814 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
Thierry Redingdd34c372014-04-23 17:28:09 +02001815 if (con_id)
Olliver Schinagl9e089242015-01-21 22:33:45 +01001816 snprintf(prop_name, sizeof(prop_name), "%s-%s", con_id,
Rojhalat Ibrahim7f2e5532015-02-11 17:27:55 +01001817 gpio_suffixes[i]);
Thierry Redingdd34c372014-04-23 17:28:09 +02001818 else
Olliver Schinagl9e089242015-01-21 22:33:45 +01001819 snprintf(prop_name, sizeof(prop_name), "%s",
Rojhalat Ibrahim7f2e5532015-02-11 17:27:55 +01001820 gpio_suffixes[i]);
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001821
Thierry Redingdd34c372014-04-23 17:28:09 +02001822 desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx,
1823 &of_flags);
Tony Lindgren06fc3b72014-06-02 16:13:46 -07001824 if (!IS_ERR(desc) || (PTR_ERR(desc) == -EPROBE_DEFER))
Thierry Redingdd34c372014-04-23 17:28:09 +02001825 break;
1826 }
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001827
1828 if (IS_ERR(desc))
1829 return desc;
1830
1831 if (of_flags & OF_GPIO_ACTIVE_LOW)
Alexandre Courbot53e7cac2013-11-16 21:44:52 +09001832 *flags |= GPIO_ACTIVE_LOW;
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001833
Laurent Pinchart90b665f2015-10-13 00:20:21 +03001834 if (of_flags & OF_GPIO_SINGLE_ENDED) {
1835 if (of_flags & OF_GPIO_ACTIVE_LOW)
1836 *flags |= GPIO_OPEN_DRAIN;
1837 else
1838 *flags |= GPIO_OPEN_SOURCE;
1839 }
1840
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001841 return desc;
1842}
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001843
Mika Westerberg81f59e92013-10-10 11:01:09 +03001844static struct gpio_desc *acpi_find_gpio(struct device *dev, const char *con_id,
Alexandre Courbot53e7cac2013-11-16 21:44:52 +09001845 unsigned int idx,
1846 enum gpio_lookup_flags *flags)
Mika Westerberg81f59e92013-10-10 11:01:09 +03001847{
Mika Westerberg0d9a6932014-10-29 15:41:01 +01001848 struct acpi_device *adev = ACPI_COMPANION(dev);
Mika Westerberge01f4402013-10-10 11:01:10 +03001849 struct acpi_gpio_info info;
1850 struct gpio_desc *desc;
Mika Westerberg0d9a6932014-10-29 15:41:01 +01001851 char propname[32];
1852 int i;
Mika Westerberge01f4402013-10-10 11:01:10 +03001853
Mika Westerberg0d9a6932014-10-29 15:41:01 +01001854 /* Try first from _DSD */
Rojhalat Ibrahim7f2e5532015-02-11 17:27:55 +01001855 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
Mika Westerberg0d9a6932014-10-29 15:41:01 +01001856 if (con_id && strcmp(con_id, "gpios")) {
1857 snprintf(propname, sizeof(propname), "%s-%s",
Rojhalat Ibrahim7f2e5532015-02-11 17:27:55 +01001858 con_id, gpio_suffixes[i]);
Mika Westerberg0d9a6932014-10-29 15:41:01 +01001859 } else {
1860 snprintf(propname, sizeof(propname), "%s",
Rojhalat Ibrahim7f2e5532015-02-11 17:27:55 +01001861 gpio_suffixes[i]);
Mika Westerberg0d9a6932014-10-29 15:41:01 +01001862 }
Mika Westerberge01f4402013-10-10 11:01:10 +03001863
Mika Westerberg0d9a6932014-10-29 15:41:01 +01001864 desc = acpi_get_gpiod_by_index(adev, propname, idx, &info);
1865 if (!IS_ERR(desc) || (PTR_ERR(desc) == -EPROBE_DEFER))
1866 break;
1867 }
1868
1869 /* Then from plain _CRS GPIOs */
1870 if (IS_ERR(desc)) {
1871 desc = acpi_get_gpiod_by_index(adev, NULL, idx, &info);
1872 if (IS_ERR(desc))
1873 return desc;
1874 }
1875
1876 if (info.active_low)
Alexandre Courbot53e7cac2013-11-16 21:44:52 +09001877 *flags |= GPIO_ACTIVE_LOW;
Mika Westerberge01f4402013-10-10 11:01:10 +03001878
1879 return desc;
Mika Westerberg81f59e92013-10-10 11:01:09 +03001880}
1881
Alexandre Courbotad824782013-12-03 12:20:11 +09001882static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
1883{
1884 const char *dev_id = dev ? dev_name(dev) : NULL;
1885 struct gpiod_lookup_table *table;
1886
1887 mutex_lock(&gpio_lookup_lock);
1888
1889 list_for_each_entry(table, &gpio_lookup_list, list) {
1890 if (table->dev_id && dev_id) {
1891 /*
1892 * Valid strings on both ends, must be identical to have
1893 * a match
1894 */
1895 if (!strcmp(table->dev_id, dev_id))
1896 goto found;
1897 } else {
1898 /*
1899 * One of the pointers is NULL, so both must be to have
1900 * a match
1901 */
1902 if (dev_id == table->dev_id)
1903 goto found;
1904 }
1905 }
1906 table = NULL;
1907
1908found:
1909 mutex_unlock(&gpio_lookup_lock);
1910 return table;
1911}
1912
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001913static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
Alexandre Courbot53e7cac2013-11-16 21:44:52 +09001914 unsigned int idx,
1915 enum gpio_lookup_flags *flags)
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001916{
Alexandre Courbot2a3cf6a2013-12-11 11:32:28 +09001917 struct gpio_desc *desc = ERR_PTR(-ENOENT);
Alexandre Courbotad824782013-12-03 12:20:11 +09001918 struct gpiod_lookup_table *table;
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001919 struct gpiod_lookup *p;
1920
Alexandre Courbotad824782013-12-03 12:20:11 +09001921 table = gpiod_find_lookup_table(dev);
1922 if (!table)
1923 return desc;
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001924
Alexandre Courbotad824782013-12-03 12:20:11 +09001925 for (p = &table->table[0]; p->chip_label; p++) {
1926 struct gpio_chip *chip;
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001927
Alexandre Courbotad824782013-12-03 12:20:11 +09001928 /* idx must always match exactly */
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001929 if (p->idx != idx)
1930 continue;
1931
Alexandre Courbotad824782013-12-03 12:20:11 +09001932 /* If the lookup entry has a con_id, require exact match */
1933 if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
1934 continue;
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001935
Alexandre Courbotad824782013-12-03 12:20:11 +09001936 chip = find_chip_by_name(p->chip_label);
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001937
Alexandre Courbotad824782013-12-03 12:20:11 +09001938 if (!chip) {
Alexandre Courbot2a3cf6a2013-12-11 11:32:28 +09001939 dev_err(dev, "cannot find GPIO chip %s\n",
1940 p->chip_label);
1941 return ERR_PTR(-ENODEV);
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001942 }
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001943
Alexandre Courbotad824782013-12-03 12:20:11 +09001944 if (chip->ngpio <= p->chip_hwnum) {
Alexandre Courbot2a3cf6a2013-12-11 11:32:28 +09001945 dev_err(dev,
1946 "requested GPIO %d is out of range [0..%d] for chip %s\n",
1947 idx, chip->ngpio, chip->label);
1948 return ERR_PTR(-EINVAL);
Alexandre Courbotad824782013-12-03 12:20:11 +09001949 }
1950
Alexandre Courbotbb1e88c2014-02-09 17:43:54 +09001951 desc = gpiochip_get_desc(chip, p->chip_hwnum);
Alexandre Courbotad824782013-12-03 12:20:11 +09001952 *flags = p->flags;
Alexandre Courbot2a3cf6a2013-12-11 11:32:28 +09001953
1954 return desc;
Alexandre Courbotad824782013-12-03 12:20:11 +09001955 }
Alexandre Courbotbae48da2013-10-17 10:21:38 -07001956
1957 return desc;
1958}
1959
Rojhalat Ibrahim66858522015-02-11 17:27:58 +01001960static int dt_gpio_count(struct device *dev, const char *con_id)
1961{
1962 int ret;
1963 char propname[32];
1964 unsigned int i;
1965
1966 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
1967 if (con_id)
1968 snprintf(propname, sizeof(propname), "%s-%s",
1969 con_id, gpio_suffixes[i]);
1970 else
1971 snprintf(propname, sizeof(propname), "%s",
1972 gpio_suffixes[i]);
1973
1974 ret = of_gpio_named_count(dev->of_node, propname);
1975 if (ret >= 0)
1976 break;
1977 }
1978 return ret;
1979}
1980
1981static int platform_gpio_count(struct device *dev, const char *con_id)
1982{
1983 struct gpiod_lookup_table *table;
1984 struct gpiod_lookup *p;
1985 unsigned int count = 0;
1986
1987 table = gpiod_find_lookup_table(dev);
1988 if (!table)
1989 return -ENOENT;
1990
1991 for (p = &table->table[0]; p->chip_label; p++) {
1992 if ((con_id && p->con_id && !strcmp(con_id, p->con_id)) ||
1993 (!con_id && !p->con_id))
1994 count++;
1995 }
1996 if (!count)
1997 return -ENOENT;
1998
1999 return count;
2000}
2001
2002/**
2003 * gpiod_count - return the number of GPIOs associated with a device / function
2004 * or -ENOENT if no GPIO has been assigned to the requested function
2005 * @dev: GPIO consumer, can be NULL for system-global GPIOs
2006 * @con_id: function within the GPIO consumer
2007 */
2008int gpiod_count(struct device *dev, const char *con_id)
2009{
2010 int count = -ENOENT;
2011
2012 if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
2013 count = dt_gpio_count(dev, con_id);
2014 else if (IS_ENABLED(CONFIG_ACPI) && dev && ACPI_HANDLE(dev))
2015 count = acpi_gpio_count(dev, con_id);
2016
2017 if (count < 0)
2018 count = platform_gpio_count(dev, con_id);
2019
2020 return count;
2021}
2022EXPORT_SYMBOL_GPL(gpiod_count);
2023
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002024/**
Thierry Reding08791622014-04-25 16:54:22 +02002025 * gpiod_get - obtain a GPIO for a given GPIO function
Alexandre Courbotad824782013-12-03 12:20:11 +09002026 * @dev: GPIO consumer, can be NULL for system-global GPIOs
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002027 * @con_id: function within the GPIO consumer
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +09002028 * @flags: optional GPIO initialization flags
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002029 *
2030 * Return the GPIO descriptor corresponding to the function con_id of device
Alexandre Courbot2a3cf6a2013-12-11 11:32:28 +09002031 * dev, -ENOENT if no GPIO has been assigned to the requested function, or
Colin Cronin20a8a962015-05-18 11:41:43 -07002032 * another IS_ERR() code if an error occurred while trying to acquire the GPIO.
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002033 */
Uwe Kleine-Königb17d1bf2015-02-11 11:52:37 +01002034struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id,
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +09002035 enum gpiod_flags flags)
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002036{
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +09002037 return gpiod_get_index(dev, con_id, 0, flags);
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002038}
Uwe Kleine-Königb17d1bf2015-02-11 11:52:37 +01002039EXPORT_SYMBOL_GPL(gpiod_get);
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002040
2041/**
Thierry Reding29a1f2332014-04-25 17:10:06 +02002042 * gpiod_get_optional - obtain an optional GPIO for a given GPIO function
2043 * @dev: GPIO consumer, can be NULL for system-global GPIOs
2044 * @con_id: function within the GPIO consumer
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +09002045 * @flags: optional GPIO initialization flags
Thierry Reding29a1f2332014-04-25 17:10:06 +02002046 *
2047 * This is equivalent to gpiod_get(), except that when no GPIO was assigned to
2048 * the requested function it will return NULL. This is convenient for drivers
2049 * that need to handle optional GPIOs.
2050 */
Uwe Kleine-Königb17d1bf2015-02-11 11:52:37 +01002051struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +09002052 const char *con_id,
2053 enum gpiod_flags flags)
Thierry Reding29a1f2332014-04-25 17:10:06 +02002054{
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +09002055 return gpiod_get_index_optional(dev, con_id, 0, flags);
Thierry Reding29a1f2332014-04-25 17:10:06 +02002056}
Uwe Kleine-Königb17d1bf2015-02-11 11:52:37 +01002057EXPORT_SYMBOL_GPL(gpiod_get_optional);
Thierry Reding29a1f2332014-04-25 17:10:06 +02002058
Laurent Pinchart923b93e2015-10-13 00:20:20 +03002059/**
2060 * gpiod_parse_flags - helper function to parse GPIO lookup flags
2061 * @desc: gpio to be setup
2062 * @lflags: gpio_lookup_flags - returned from of_find_gpio() or
2063 * of_get_gpio_hog()
2064 *
2065 * Set the GPIO descriptor flags based on the given GPIO lookup flags.
2066 */
2067static void gpiod_parse_flags(struct gpio_desc *desc, unsigned long lflags)
2068{
2069 if (lflags & GPIO_ACTIVE_LOW)
2070 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
2071 if (lflags & GPIO_OPEN_DRAIN)
2072 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
2073 if (lflags & GPIO_OPEN_SOURCE)
2074 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
2075}
Benoit Parrotf625d462015-02-02 11:44:44 -06002076
2077/**
2078 * gpiod_configure_flags - helper function to configure a given GPIO
2079 * @desc: gpio whose value will be assigned
2080 * @con_id: function within the GPIO consumer
Benoit Parrotf625d462015-02-02 11:44:44 -06002081 * @dflags: gpiod_flags - optional GPIO initialization flags
2082 *
2083 * Return 0 on success, -ENOENT if no GPIO has been assigned to the
2084 * requested function and/or index, or another IS_ERR() code if an error
2085 * occurred while trying to acquire the GPIO.
2086 */
2087static int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id,
Laurent Pinchart923b93e2015-10-13 00:20:20 +03002088 enum gpiod_flags dflags)
Benoit Parrotf625d462015-02-02 11:44:44 -06002089{
2090 int status;
2091
Benoit Parrotf625d462015-02-02 11:44:44 -06002092 /* No particular flag request, return here... */
2093 if (!(dflags & GPIOD_FLAGS_BIT_DIR_SET)) {
2094 pr_debug("no flags found for %s\n", con_id);
2095 return 0;
2096 }
2097
2098 /* Process flags */
2099 if (dflags & GPIOD_FLAGS_BIT_DIR_OUT)
2100 status = gpiod_direction_output(desc,
2101 dflags & GPIOD_FLAGS_BIT_DIR_VAL);
2102 else
2103 status = gpiod_direction_input(desc);
2104
2105 return status;
2106}
2107
Thierry Reding29a1f2332014-04-25 17:10:06 +02002108/**
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002109 * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
Andy Shevchenkofdd6a5f2013-12-05 11:26:26 +02002110 * @dev: GPIO consumer, can be NULL for system-global GPIOs
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002111 * @con_id: function within the GPIO consumer
2112 * @idx: index of the GPIO to obtain in the consumer
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +09002113 * @flags: optional GPIO initialization flags
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002114 *
2115 * This variant of gpiod_get() allows to access GPIOs other than the first
2116 * defined one for functions that define several GPIOs.
2117 *
Alexandre Courbot2a3cf6a2013-12-11 11:32:28 +09002118 * Return a valid GPIO descriptor, -ENOENT if no GPIO has been assigned to the
2119 * requested function and/or index, or another IS_ERR() code if an error
Colin Cronin20a8a962015-05-18 11:41:43 -07002120 * occurred while trying to acquire the GPIO.
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002121 */
Uwe Kleine-Königb17d1bf2015-02-11 11:52:37 +01002122struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002123 const char *con_id,
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +09002124 unsigned int idx,
2125 enum gpiod_flags flags)
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002126{
Alexandre Courbot35c5d7f2013-11-23 19:34:50 +09002127 struct gpio_desc *desc = NULL;
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002128 int status;
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +09002129 enum gpio_lookup_flags lookupflags = 0;
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002130
2131 dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id);
2132
Rafael J. Wysocki4d8440b2015-03-10 23:08:57 +01002133 if (dev) {
2134 /* Using device tree? */
2135 if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
2136 dev_dbg(dev, "using device tree for GPIO lookup\n");
2137 desc = of_find_gpio(dev, con_id, idx, &lookupflags);
2138 } else if (ACPI_COMPANION(dev)) {
2139 dev_dbg(dev, "using ACPI for GPIO lookup\n");
2140 desc = acpi_find_gpio(dev, con_id, idx, &lookupflags);
2141 }
Alexandre Courbot35c5d7f2013-11-23 19:34:50 +09002142 }
2143
2144 /*
2145 * Either we are not using DT or ACPI, or their lookup did not return
2146 * a result. In that case, use platform lookup as a fallback.
2147 */
Alexandre Courbot2a3cf6a2013-12-11 11:32:28 +09002148 if (!desc || desc == ERR_PTR(-ENOENT)) {
Alexander Shiyan43a87852014-09-19 11:39:25 +04002149 dev_dbg(dev, "using lookup tables for GPIO lookup\n");
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +09002150 desc = gpiod_find(dev, con_id, idx, &lookupflags);
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002151 }
2152
2153 if (IS_ERR(desc)) {
Heikki Krogerus351cfe02013-11-29 15:47:34 +02002154 dev_dbg(dev, "lookup for GPIO %s failed\n", con_id);
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002155 return desc;
2156 }
2157
Laurent Pinchart923b93e2015-10-13 00:20:20 +03002158 gpiod_parse_flags(desc, lookupflags);
2159
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002160 status = gpiod_request(desc, con_id);
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002161 if (status < 0)
2162 return ERR_PTR(status);
2163
Laurent Pinchart923b93e2015-10-13 00:20:20 +03002164 status = gpiod_configure_flags(desc, con_id, flags);
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +09002165 if (status < 0) {
2166 dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
2167 gpiod_put(desc);
2168 return ERR_PTR(status);
2169 }
2170
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002171 return desc;
2172}
Uwe Kleine-Königb17d1bf2015-02-11 11:52:37 +01002173EXPORT_SYMBOL_GPL(gpiod_get_index);
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002174
2175/**
Mika Westerberg40b73182014-10-21 13:33:59 +02002176 * fwnode_get_named_gpiod - obtain a GPIO from firmware node
2177 * @fwnode: handle of the firmware node
2178 * @propname: name of the firmware property representing the GPIO
2179 *
2180 * This function can be used for drivers that get their configuration
2181 * from firmware.
2182 *
2183 * Function properly finds the corresponding GPIO using whatever is the
2184 * underlying firmware interface and then makes sure that the GPIO
2185 * descriptor is requested before it is returned to the caller.
2186 *
2187 * In case of error an ERR_PTR() is returned.
2188 */
2189struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
2190 const char *propname)
2191{
2192 struct gpio_desc *desc = ERR_PTR(-ENODEV);
2193 bool active_low = false;
Laurent Pinchart90b665f2015-10-13 00:20:21 +03002194 bool single_ended = false;
Mika Westerberg40b73182014-10-21 13:33:59 +02002195 int ret;
2196
2197 if (!fwnode)
2198 return ERR_PTR(-EINVAL);
2199
2200 if (is_of_node(fwnode)) {
2201 enum of_gpio_flags flags;
2202
Alexander Sverdlinc181fb32015-06-22 22:38:53 +02002203 desc = of_get_named_gpiod_flags(to_of_node(fwnode), propname, 0,
Mika Westerberg40b73182014-10-21 13:33:59 +02002204 &flags);
Laurent Pinchart90b665f2015-10-13 00:20:21 +03002205 if (!IS_ERR(desc)) {
Mika Westerberg40b73182014-10-21 13:33:59 +02002206 active_low = flags & OF_GPIO_ACTIVE_LOW;
Laurent Pinchart90b665f2015-10-13 00:20:21 +03002207 single_ended = flags & OF_GPIO_SINGLE_ENDED;
2208 }
Mika Westerberg40b73182014-10-21 13:33:59 +02002209 } else if (is_acpi_node(fwnode)) {
2210 struct acpi_gpio_info info;
2211
Rafael J. Wysocki504a3372015-08-27 04:42:33 +02002212 desc = acpi_node_get_gpiod(fwnode, propname, 0, &info);
Mika Westerberg40b73182014-10-21 13:33:59 +02002213 if (!IS_ERR(desc))
2214 active_low = info.active_low;
2215 }
2216
2217 if (IS_ERR(desc))
2218 return desc;
2219
Mika Westerberg40b73182014-10-21 13:33:59 +02002220 if (active_low)
2221 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
2222
Laurent Pinchart90b665f2015-10-13 00:20:21 +03002223 if (single_ended) {
2224 if (active_low)
2225 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
2226 else
2227 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
2228 }
2229
Laurent Pinchart923b93e2015-10-13 00:20:20 +03002230 ret = gpiod_request(desc, NULL);
2231 if (ret)
2232 return ERR_PTR(ret);
2233
Mika Westerberg40b73182014-10-21 13:33:59 +02002234 return desc;
2235}
2236EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);
2237
2238/**
Thierry Reding29a1f2332014-04-25 17:10:06 +02002239 * gpiod_get_index_optional - obtain an optional GPIO from a multi-index GPIO
2240 * function
2241 * @dev: GPIO consumer, can be NULL for system-global GPIOs
2242 * @con_id: function within the GPIO consumer
2243 * @index: index of the GPIO to obtain in the consumer
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +09002244 * @flags: optional GPIO initialization flags
Thierry Reding29a1f2332014-04-25 17:10:06 +02002245 *
2246 * This is equivalent to gpiod_get_index(), except that when no GPIO with the
2247 * specified index was assigned to the requested function it will return NULL.
2248 * This is convenient for drivers that need to handle optional GPIOs.
2249 */
Uwe Kleine-Königb17d1bf2015-02-11 11:52:37 +01002250struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
Thierry Reding29a1f2332014-04-25 17:10:06 +02002251 const char *con_id,
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +09002252 unsigned int index,
2253 enum gpiod_flags flags)
Thierry Reding29a1f2332014-04-25 17:10:06 +02002254{
2255 struct gpio_desc *desc;
2256
Alexandre Courbot39b2bbe2014-07-25 23:38:36 +09002257 desc = gpiod_get_index(dev, con_id, index, flags);
Thierry Reding29a1f2332014-04-25 17:10:06 +02002258 if (IS_ERR(desc)) {
2259 if (PTR_ERR(desc) == -ENOENT)
2260 return NULL;
2261 }
2262
2263 return desc;
2264}
Uwe Kleine-Königb17d1bf2015-02-11 11:52:37 +01002265EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
Thierry Reding29a1f2332014-04-25 17:10:06 +02002266
2267/**
Benoit Parrotf625d462015-02-02 11:44:44 -06002268 * gpiod_hog - Hog the specified GPIO desc given the provided flags
2269 * @desc: gpio whose value will be assigned
2270 * @name: gpio line name
2271 * @lflags: gpio_lookup_flags - returned from of_find_gpio() or
2272 * of_get_gpio_hog()
2273 * @dflags: gpiod_flags - optional GPIO initialization flags
2274 */
2275int gpiod_hog(struct gpio_desc *desc, const char *name,
2276 unsigned long lflags, enum gpiod_flags dflags)
2277{
2278 struct gpio_chip *chip;
2279 struct gpio_desc *local_desc;
2280 int hwnum;
2281 int status;
2282
2283 chip = gpiod_to_chip(desc);
2284 hwnum = gpio_chip_hwgpio(desc);
2285
Laurent Pinchart923b93e2015-10-13 00:20:20 +03002286 gpiod_parse_flags(desc, lflags);
2287
Benoit Parrotf625d462015-02-02 11:44:44 -06002288 local_desc = gpiochip_request_own_desc(chip, hwnum, name);
2289 if (IS_ERR(local_desc)) {
Linus Walleija7138902015-06-05 11:36:10 +02002290 pr_err("requesting hog GPIO %s (chip %s, offset %d) failed\n",
2291 name, chip->label, hwnum);
Benoit Parrotf625d462015-02-02 11:44:44 -06002292 return PTR_ERR(local_desc);
2293 }
2294
Laurent Pinchart923b93e2015-10-13 00:20:20 +03002295 status = gpiod_configure_flags(desc, name, dflags);
Benoit Parrotf625d462015-02-02 11:44:44 -06002296 if (status < 0) {
Linus Walleija7138902015-06-05 11:36:10 +02002297 pr_err("setup of hog GPIO %s (chip %s, offset %d) failed\n",
2298 name, chip->label, hwnum);
Benoit Parrotf625d462015-02-02 11:44:44 -06002299 gpiochip_free_own_desc(desc);
2300 return status;
2301 }
2302
2303 /* Mark GPIO as hogged so it can be identified and removed later */
2304 set_bit(FLAG_IS_HOGGED, &desc->flags);
2305
2306 pr_info("GPIO line %d (%s) hogged as %s%s\n",
2307 desc_to_gpio(desc), name,
2308 (dflags&GPIOD_FLAGS_BIT_DIR_OUT) ? "output" : "input",
2309 (dflags&GPIOD_FLAGS_BIT_DIR_OUT) ?
2310 (dflags&GPIOD_FLAGS_BIT_DIR_VAL) ? "/high" : "/low":"");
2311
2312 return 0;
2313}
2314
2315/**
2316 * gpiochip_free_hogs - Scan gpio-controller chip and release GPIO hog
2317 * @chip: gpio chip to act on
2318 *
2319 * This is only used by of_gpiochip_remove to free hogged gpios
2320 */
2321static void gpiochip_free_hogs(struct gpio_chip *chip)
2322{
2323 int id;
2324
2325 for (id = 0; id < chip->ngpio; id++) {
2326 if (test_bit(FLAG_IS_HOGGED, &chip->desc[id].flags))
2327 gpiochip_free_own_desc(&chip->desc[id]);
2328 }
2329}
2330
2331/**
Rojhalat Ibrahim66858522015-02-11 17:27:58 +01002332 * gpiod_get_array - obtain multiple GPIOs from a multi-index GPIO function
2333 * @dev: GPIO consumer, can be NULL for system-global GPIOs
2334 * @con_id: function within the GPIO consumer
2335 * @flags: optional GPIO initialization flags
2336 *
2337 * This function acquires all the GPIOs defined under a given function.
2338 *
2339 * Return a struct gpio_descs containing an array of descriptors, -ENOENT if
2340 * no GPIO has been assigned to the requested function, or another IS_ERR()
2341 * code if an error occurred while trying to acquire the GPIOs.
2342 */
2343struct gpio_descs *__must_check gpiod_get_array(struct device *dev,
2344 const char *con_id,
2345 enum gpiod_flags flags)
2346{
2347 struct gpio_desc *desc;
2348 struct gpio_descs *descs;
2349 int count;
2350
2351 count = gpiod_count(dev, con_id);
2352 if (count < 0)
2353 return ERR_PTR(count);
2354
2355 descs = kzalloc(sizeof(*descs) + sizeof(descs->desc[0]) * count,
2356 GFP_KERNEL);
2357 if (!descs)
2358 return ERR_PTR(-ENOMEM);
2359
2360 for (descs->ndescs = 0; descs->ndescs < count; ) {
2361 desc = gpiod_get_index(dev, con_id, descs->ndescs, flags);
2362 if (IS_ERR(desc)) {
2363 gpiod_put_array(descs);
2364 return ERR_CAST(desc);
2365 }
2366 descs->desc[descs->ndescs] = desc;
2367 descs->ndescs++;
2368 }
2369 return descs;
2370}
2371EXPORT_SYMBOL_GPL(gpiod_get_array);
2372
2373/**
2374 * gpiod_get_array_optional - obtain multiple GPIOs from a multi-index GPIO
2375 * function
2376 * @dev: GPIO consumer, can be NULL for system-global GPIOs
2377 * @con_id: function within the GPIO consumer
2378 * @flags: optional GPIO initialization flags
2379 *
2380 * This is equivalent to gpiod_get_array(), except that when no GPIO was
2381 * assigned to the requested function it will return NULL.
2382 */
2383struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev,
2384 const char *con_id,
2385 enum gpiod_flags flags)
2386{
2387 struct gpio_descs *descs;
2388
2389 descs = gpiod_get_array(dev, con_id, flags);
2390 if (IS_ERR(descs) && (PTR_ERR(descs) == -ENOENT))
2391 return NULL;
2392
2393 return descs;
2394}
2395EXPORT_SYMBOL_GPL(gpiod_get_array_optional);
2396
2397/**
Alexandre Courbotbae48da2013-10-17 10:21:38 -07002398 * gpiod_put - dispose of a GPIO descriptor
2399 * @desc: GPIO descriptor to dispose of
2400 *
2401 * No descriptor can be used after gpiod_put() has been called on it.
2402 */
2403void gpiod_put(struct gpio_desc *desc)
2404{
2405 gpiod_free(desc);
2406}
2407EXPORT_SYMBOL_GPL(gpiod_put);
David Brownelld2876d02008-02-04 22:28:20 -08002408
Rojhalat Ibrahim66858522015-02-11 17:27:58 +01002409/**
2410 * gpiod_put_array - dispose of multiple GPIO descriptors
2411 * @descs: struct gpio_descs containing an array of descriptors
2412 */
2413void gpiod_put_array(struct gpio_descs *descs)
2414{
2415 unsigned int i;
2416
2417 for (i = 0; i < descs->ndescs; i++)
2418 gpiod_put(descs->desc[i]);
2419
2420 kfree(descs);
2421}
2422EXPORT_SYMBOL_GPL(gpiod_put_array);
2423
David Brownelld2876d02008-02-04 22:28:20 -08002424#ifdef CONFIG_DEBUG_FS
2425
2426static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
2427{
2428 unsigned i;
2429 unsigned gpio = chip->base;
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09002430 struct gpio_desc *gdesc = &chip->desc[0];
David Brownelld2876d02008-02-04 22:28:20 -08002431 int is_out;
Linus Walleijd468bf92013-09-24 11:54:38 +02002432 int is_irq;
David Brownelld2876d02008-02-04 22:28:20 -08002433
2434 for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
Markus Pargmannced433e2015-08-14 16:11:02 +02002435 if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) {
2436 if (gdesc->name) {
2437 seq_printf(s, " gpio-%-3d (%-20.20s)\n",
2438 gpio, gdesc->name);
2439 }
David Brownelld2876d02008-02-04 22:28:20 -08002440 continue;
Markus Pargmannced433e2015-08-14 16:11:02 +02002441 }
David Brownelld2876d02008-02-04 22:28:20 -08002442
Alexandre Courbot372e7222013-02-03 01:29:29 +09002443 gpiod_get_direction(gdesc);
David Brownelld2876d02008-02-04 22:28:20 -08002444 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
Linus Walleijd468bf92013-09-24 11:54:38 +02002445 is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
Markus Pargmannced433e2015-08-14 16:11:02 +02002446 seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s",
2447 gpio, gdesc->name ? gdesc->name : "", gdesc->label,
David Brownelld2876d02008-02-04 22:28:20 -08002448 is_out ? "out" : "in ",
2449 chip->get
2450 ? (chip->get(chip, i) ? "hi" : "lo")
Linus Walleijd468bf92013-09-24 11:54:38 +02002451 : "? ",
2452 is_irq ? "IRQ" : " ");
David Brownelld2876d02008-02-04 22:28:20 -08002453 seq_printf(s, "\n");
2454 }
2455}
2456
Thierry Redingf9c4a312012-04-12 13:26:01 +02002457static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
David Brownelld2876d02008-02-04 22:28:20 -08002458{
Grant Likely362432a2013-02-09 09:41:49 +00002459 unsigned long flags;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002460 struct gpio_chip *chip = NULL;
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002461 loff_t index = *pos;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002462
2463 s->private = "";
2464
Grant Likely362432a2013-02-09 09:41:49 +00002465 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002466 list_for_each_entry(chip, &gpio_chips, list)
Grant Likely362432a2013-02-09 09:41:49 +00002467 if (index-- == 0) {
2468 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002469 return chip;
Grant Likely362432a2013-02-09 09:41:49 +00002470 }
2471 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002472
2473 return NULL;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002474}
2475
2476static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
2477{
Grant Likely362432a2013-02-09 09:41:49 +00002478 unsigned long flags;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002479 struct gpio_chip *chip = v;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002480 void *ret = NULL;
2481
Grant Likely362432a2013-02-09 09:41:49 +00002482 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002483 if (list_is_last(&chip->list, &gpio_chips))
2484 ret = NULL;
2485 else
2486 ret = list_entry(chip->list.next, struct gpio_chip, list);
Grant Likely362432a2013-02-09 09:41:49 +00002487 spin_unlock_irqrestore(&gpio_lock, flags);
Thierry Redingf9c4a312012-04-12 13:26:01 +02002488
2489 s->private = "\n";
2490 ++*pos;
2491
2492 return ret;
2493}
2494
2495static void gpiolib_seq_stop(struct seq_file *s, void *v)
2496{
2497}
2498
2499static int gpiolib_seq_show(struct seq_file *s, void *v)
2500{
2501 struct gpio_chip *chip = v;
2502 struct device *dev;
2503
2504 seq_printf(s, "%sGPIOs %d-%d", (char *)s->private,
2505 chip->base, chip->base + chip->ngpio - 1);
2506 dev = chip->dev;
2507 if (dev)
2508 seq_printf(s, ", %s/%s", dev->bus ? dev->bus->name : "no-bus",
2509 dev_name(dev));
2510 if (chip->label)
2511 seq_printf(s, ", %s", chip->label);
2512 if (chip->can_sleep)
2513 seq_printf(s, ", can sleep");
2514 seq_printf(s, ":\n");
2515
2516 if (chip->dbg_show)
2517 chip->dbg_show(s, chip);
2518 else
2519 gpiolib_dbg_show(s, chip);
2520
David Brownelld2876d02008-02-04 22:28:20 -08002521 return 0;
2522}
2523
Thierry Redingf9c4a312012-04-12 13:26:01 +02002524static const struct seq_operations gpiolib_seq_ops = {
2525 .start = gpiolib_seq_start,
2526 .next = gpiolib_seq_next,
2527 .stop = gpiolib_seq_stop,
2528 .show = gpiolib_seq_show,
2529};
2530
David Brownelld2876d02008-02-04 22:28:20 -08002531static int gpiolib_open(struct inode *inode, struct file *file)
2532{
Thierry Redingf9c4a312012-04-12 13:26:01 +02002533 return seq_open(file, &gpiolib_seq_ops);
David Brownelld2876d02008-02-04 22:28:20 -08002534}
2535
Alexey Dobriyan828c0952009-10-01 15:43:56 -07002536static const struct file_operations gpiolib_operations = {
Thierry Redingf9c4a312012-04-12 13:26:01 +02002537 .owner = THIS_MODULE,
David Brownelld2876d02008-02-04 22:28:20 -08002538 .open = gpiolib_open,
2539 .read = seq_read,
2540 .llseek = seq_lseek,
Thierry Redingf9c4a312012-04-12 13:26:01 +02002541 .release = seq_release,
David Brownelld2876d02008-02-04 22:28:20 -08002542};
2543
2544static int __init gpiolib_debugfs_init(void)
2545{
2546 /* /sys/kernel/debug/gpio */
2547 (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
2548 NULL, NULL, &gpiolib_operations);
2549 return 0;
2550}
2551subsys_initcall(gpiolib_debugfs_init);
2552
2553#endif /* DEBUG_FS */