blob: fff9786cdc643120f933154366237a8d6b332e8d [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 Brownelld8f388d82008-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>
David Brownelld2876d02008-02-04 22:28:20 -080015
Uwe Kleine-König3f397c212011-05-20 00:40:19 -060016#define CREATE_TRACE_POINTS
17#include <trace/events/gpio.h>
David Brownelld2876d02008-02-04 22:28:20 -080018
19/* Optional implementation infrastructure for GPIO interfaces.
20 *
21 * Platforms may want to use this if they tend to use very many GPIOs
22 * that aren't part of a System-On-Chip core; or across I2C/SPI/etc.
23 *
24 * When kernel footprint or instruction count is an issue, simpler
25 * implementations may be preferred. The GPIO programming interface
26 * allows for inlining speed-critical get/set operations for common
27 * cases, so that access to SOC-integrated GPIOs can sometimes cost
28 * only an instruction or two per bit.
29 */
30
31
32/* When debugging, extend minimal trust to callers and platform code.
33 * Also emit diagnostic messages that may help initial bringup, when
34 * board setup or driver bugs are most common.
35 *
36 * Otherwise, minimize overhead in what may be bitbanging codepaths.
37 */
38#ifdef DEBUG
39#define extra_checks 1
40#else
41#define extra_checks 0
42#endif
43
44/* gpio_lock prevents conflicts during gpio_desc[] table updates.
45 * While any GPIO is requested, its gpio_chip is not removable;
46 * each GPIO's "requested" flag serves as a lock and refcount.
47 */
48static DEFINE_SPINLOCK(gpio_lock);
49
50struct gpio_desc {
51 struct gpio_chip *chip;
52 unsigned long flags;
53/* flag symbols are bit numbers */
54#define FLAG_REQUESTED 0
55#define FLAG_IS_OUT 1
Alexandre Courbot710b40e2013-02-02 23:44:06 +090056#define FLAG_EXPORT 2 /* protected by sysfs_lock */
57#define FLAG_SYSFS 3 /* exported via /sys/class/gpio/control */
58#define FLAG_TRIG_FALL 4 /* trigger on falling edge */
59#define FLAG_TRIG_RISE 5 /* trigger on rising edge */
60#define FLAG_ACTIVE_LOW 6 /* sysfs value has active low */
61#define FLAG_OPEN_DRAIN 7 /* Gpio is open drain type */
62#define FLAG_OPEN_SOURCE 8 /* Gpio is open source type */
Daniel Glöcknerff77c352009-09-22 16:46:38 -070063
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -070064#define ID_SHIFT 16 /* add new flags before this one */
Daniel Glöcknerff77c352009-09-22 16:46:38 -070065
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -070066#define GPIO_FLAGS_MASK ((1 << ID_SHIFT) - 1)
Daniel Glöcknerff77c352009-09-22 16:46:38 -070067#define GPIO_TRIGGER_MASK (BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE))
David Brownelld2876d02008-02-04 22:28:20 -080068
69#ifdef CONFIG_DEBUG_FS
70 const char *label;
71#endif
72};
73static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];
74
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +090075#define GPIO_OFFSET_VALID(chip, offset) (offset >= 0 && offset < chip->ngpio)
76
Alexandre Courbot1a989d02013-02-03 01:29:24 +090077static LIST_HEAD(gpio_chips);
78
Daniel Glöcknerff77c352009-09-22 16:46:38 -070079#ifdef CONFIG_GPIO_SYSFS
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -070080static DEFINE_IDR(dirent_idr);
Daniel Glöcknerff77c352009-09-22 16:46:38 -070081#endif
82
Alexandre Courbot372e7222013-02-03 01:29:29 +090083/*
84 * Internal gpiod_* API using descriptors instead of the integer namespace.
85 * Most of this should eventually go public.
86 */
87static int gpiod_request(struct gpio_desc *desc, const char *label);
88static void gpiod_free(struct gpio_desc *desc);
89static int gpiod_direction_input(struct gpio_desc *desc);
90static int gpiod_direction_output(struct gpio_desc *desc, int value);
91static int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
92static int gpiod_get_value_cansleep(struct gpio_desc *desc);
93static void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
94static int gpiod_get_value(struct gpio_desc *desc);
95static void gpiod_set_value(struct gpio_desc *desc, int value);
96static int gpiod_cansleep(struct gpio_desc *desc);
97static int gpiod_to_irq(struct gpio_desc *desc);
98static int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
99static int gpiod_export_link(struct device *dev, const char *name,
100 struct gpio_desc *desc);
101static int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value);
102static void gpiod_unexport(struct gpio_desc *desc);
103
104
David Brownelld2876d02008-02-04 22:28:20 -0800105static inline void desc_set_label(struct gpio_desc *d, const char *label)
106{
107#ifdef CONFIG_DEBUG_FS
108 d->label = label;
109#endif
110}
111
Alexandre Courbot372e7222013-02-03 01:29:29 +0900112/*
113 * Return the GPIO number of the passed descriptor relative to its chip
114 */
115static int gpio_chip_hwgpio(const struct gpio_desc *desc)
116{
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +0900117 return desc - &desc->chip->desc[0];
Alexandre Courbot372e7222013-02-03 01:29:29 +0900118}
119
120/**
121 * Convert a GPIO number to its descriptor
122 */
123static struct gpio_desc *gpio_to_desc(unsigned gpio)
124{
125 if (WARN(!gpio_is_valid(gpio), "invalid GPIO %d\n", gpio))
126 return NULL;
127 else
128 return &gpio_desc[gpio];
129}
130
131/**
132 * Convert a GPIO descriptor to the integer namespace.
133 * This should disappear in the future but is needed since we still
134 * use GPIO numbers for error messages and sysfs nodes
135 */
136static int desc_to_gpio(const struct gpio_desc *desc)
137{
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +0900138 return desc->chip->base + gpio_chip_hwgpio(desc);
Alexandre Courbot372e7222013-02-03 01:29:29 +0900139}
140
141
David Brownelld2876d02008-02-04 22:28:20 -0800142/* Warn when drivers omit gpio_request() calls -- legal but ill-advised
143 * when setting direction, and otherwise illegal. Until board setup code
144 * and drivers use explicit requests everywhere (which won't happen when
145 * those calls have no teeth) we can't avoid autorequesting. This nag
David Brownell35e8bb52008-10-15 22:03:16 -0700146 * message should motivate switching to explicit requests... so should
147 * the weaker cleanup after faults, compared to gpio_request().
David Brownell8a0cecf2009-04-02 16:57:06 -0700148 *
149 * NOTE: the autorequest mechanism is going away; at this point it's
150 * only "legal" in the sense that (old) code using it won't break yet,
151 * but instead only triggers a WARN() stack dump.
David Brownelld2876d02008-02-04 22:28:20 -0800152 */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900153static int gpio_ensure_requested(struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -0800154{
David Brownell8a0cecf2009-04-02 16:57:06 -0700155 const struct gpio_chip *chip = desc->chip;
Alexandre Courbot372e7222013-02-03 01:29:29 +0900156 const int gpio = desc_to_gpio(desc);
David Brownell35e8bb52008-10-15 22:03:16 -0700157
David Brownell8a0cecf2009-04-02 16:57:06 -0700158 if (WARN(test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0,
159 "autorequest GPIO-%d\n", gpio)) {
David Brownell35e8bb52008-10-15 22:03:16 -0700160 if (!try_module_get(chip->owner)) {
161 pr_err("GPIO-%d: module can't be gotten \n", gpio);
162 clear_bit(FLAG_REQUESTED, &desc->flags);
163 /* lose */
164 return -EIO;
165 }
David Brownelld2876d02008-02-04 22:28:20 -0800166 desc_set_label(desc, "[auto]");
David Brownell35e8bb52008-10-15 22:03:16 -0700167 /* caller must chip->request() w/o spinlock */
168 if (chip->request)
169 return 1;
David Brownelld2876d02008-02-04 22:28:20 -0800170 }
David Brownell35e8bb52008-10-15 22:03:16 -0700171 return 0;
David Brownelld2876d02008-02-04 22:28:20 -0800172}
173
174/* caller holds gpio_lock *OR* gpio is marked as requested */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900175static struct gpio_chip *gpiod_to_chip(struct gpio_desc *desc)
176{
177 return desc->chip;
178}
179
Grant Likely1a2d3972011-12-12 09:25:57 -0700180struct gpio_chip *gpio_to_chip(unsigned gpio)
David Brownelld2876d02008-02-04 22:28:20 -0800181{
Alexandre Courbot372e7222013-02-03 01:29:29 +0900182 return gpiod_to_chip(gpio_to_desc(gpio));
David Brownelld2876d02008-02-04 22:28:20 -0800183}
184
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700185/* dynamic allocation of GPIOs, e.g. on a hotplugged device */
186static int gpiochip_find_base(int ngpio)
187{
Alexandre Courbot83cabe32013-02-03 01:29:28 +0900188 struct gpio_chip *chip;
189 int base = ARCH_NR_GPIOS - ngpio;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700190
Alexandre Courbot83cabe32013-02-03 01:29:28 +0900191 list_for_each_entry_reverse(chip, &gpio_chips, list) {
192 /* found a free space? */
193 if (chip->base + chip->ngpio <= base)
194 break;
195 else
196 /* nope, check the space right before the chip */
197 base = chip->base - ngpio;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700198 }
199
Alexandre Courbot83cabe32013-02-03 01:29:28 +0900200 if (gpio_is_valid(base)) {
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700201 pr_debug("%s: found new base at %d\n", __func__, base);
Alexandre Courbot83cabe32013-02-03 01:29:28 +0900202 return base;
203 } else {
204 pr_err("%s: cannot find free range\n", __func__);
205 return -ENOSPC;
Anton Vorontsov169b6a72008-04-28 02:14:47 -0700206 }
Anton Vorontsov169b6a72008-04-28 02:14:47 -0700207}
208
Mathias Nyman80b0a602012-10-24 17:25:27 +0300209/* caller ensures gpio is valid and requested, chip->get_direction may sleep */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900210static int gpiod_get_direction(struct gpio_desc *desc)
Mathias Nyman80b0a602012-10-24 17:25:27 +0300211{
212 struct gpio_chip *chip;
Alexandre Courbot372e7222013-02-03 01:29:29 +0900213 unsigned offset;
Mathias Nyman80b0a602012-10-24 17:25:27 +0300214 int status = -EINVAL;
215
Alexandre Courbot372e7222013-02-03 01:29:29 +0900216 chip = gpiod_to_chip(desc);
217 offset = gpio_chip_hwgpio(desc);
Mathias Nyman80b0a602012-10-24 17:25:27 +0300218
219 if (!chip->get_direction)
220 return status;
221
Alexandre Courbot372e7222013-02-03 01:29:29 +0900222 status = chip->get_direction(chip, offset);
Mathias Nyman80b0a602012-10-24 17:25:27 +0300223 if (status > 0) {
224 /* GPIOF_DIR_IN, or other positive */
225 status = 1;
226 clear_bit(FLAG_IS_OUT, &desc->flags);
227 }
228 if (status == 0) {
229 /* GPIOF_DIR_OUT */
230 set_bit(FLAG_IS_OUT, &desc->flags);
231 }
232 return status;
233}
234
David Brownelld8f388d82008-07-25 01:46:07 -0700235#ifdef CONFIG_GPIO_SYSFS
236
237/* lock protects against unexport_gpio() being called while
238 * sysfs files are active.
239 */
240static DEFINE_MUTEX(sysfs_lock);
241
242/*
243 * /sys/class/gpio/gpioN... only for GPIOs that are exported
244 * /direction
245 * * MAY BE OMITTED if kernel won't allow direction changes
246 * * is read/write as "in" or "out"
247 * * may also be written as "high" or "low", initializing
248 * output value as specified ("out" implies "low")
249 * /value
250 * * always readable, subject to hardware behavior
251 * * may be writable, as zero/nonzero
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700252 * /edge
253 * * configures behavior of poll(2) on /value
254 * * available only if pin can generate IRQs on input
255 * * is read/write as "none", "falling", "rising", or "both"
Jani Nikula07697462009-12-15 16:46:20 -0800256 * /active_low
257 * * configures polarity of /value
258 * * is read/write as zero/nonzero
259 * * also affects existing and subsequent "falling" and "rising"
260 * /edge configuration
David Brownelld8f388d82008-07-25 01:46:07 -0700261 */
262
263static ssize_t gpio_direction_show(struct device *dev,
264 struct device_attribute *attr, char *buf)
265{
Alexandre Courbot372e7222013-02-03 01:29:29 +0900266 struct gpio_desc *desc = dev_get_drvdata(dev);
David Brownelld8f388d82008-07-25 01:46:07 -0700267 ssize_t status;
268
269 mutex_lock(&sysfs_lock);
270
Alexandre Courbot476171ce2013-02-04 17:42:04 +0900271 if (!test_bit(FLAG_EXPORT, &desc->flags)) {
David Brownelld8f388d82008-07-25 01:46:07 -0700272 status = -EIO;
Alexandre Courbot476171ce2013-02-04 17:42:04 +0900273 } else {
Alexandre Courbot372e7222013-02-03 01:29:29 +0900274 gpiod_get_direction(desc);
David Brownelld8f388d82008-07-25 01:46:07 -0700275 status = sprintf(buf, "%s\n",
276 test_bit(FLAG_IS_OUT, &desc->flags)
277 ? "out" : "in");
Alexandre Courbot476171ce2013-02-04 17:42:04 +0900278 }
David Brownelld8f388d82008-07-25 01:46:07 -0700279
280 mutex_unlock(&sysfs_lock);
281 return status;
282}
283
284static ssize_t gpio_direction_store(struct device *dev,
285 struct device_attribute *attr, const char *buf, size_t size)
286{
Alexandre Courbot372e7222013-02-03 01:29:29 +0900287 struct gpio_desc *desc = dev_get_drvdata(dev);
David Brownelld8f388d82008-07-25 01:46:07 -0700288 ssize_t status;
289
290 mutex_lock(&sysfs_lock);
291
292 if (!test_bit(FLAG_EXPORT, &desc->flags))
293 status = -EIO;
294 else if (sysfs_streq(buf, "high"))
Alexandre Courbot372e7222013-02-03 01:29:29 +0900295 status = gpiod_direction_output(desc, 1);
David Brownelld8f388d82008-07-25 01:46:07 -0700296 else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
Alexandre Courbot372e7222013-02-03 01:29:29 +0900297 status = gpiod_direction_output(desc, 0);
David Brownelld8f388d82008-07-25 01:46:07 -0700298 else if (sysfs_streq(buf, "in"))
Alexandre Courbot372e7222013-02-03 01:29:29 +0900299 status = gpiod_direction_input(desc);
David Brownelld8f388d82008-07-25 01:46:07 -0700300 else
301 status = -EINVAL;
302
303 mutex_unlock(&sysfs_lock);
304 return status ? : size;
305}
306
Jani Nikula07697462009-12-15 16:46:20 -0800307static /* const */ DEVICE_ATTR(direction, 0644,
David Brownelld8f388d82008-07-25 01:46:07 -0700308 gpio_direction_show, gpio_direction_store);
309
310static ssize_t gpio_value_show(struct device *dev,
311 struct device_attribute *attr, char *buf)
312{
Alexandre Courbot372e7222013-02-03 01:29:29 +0900313 struct gpio_desc *desc = dev_get_drvdata(dev);
David Brownelld8f388d82008-07-25 01:46:07 -0700314 ssize_t status;
315
316 mutex_lock(&sysfs_lock);
317
Jani Nikula07697462009-12-15 16:46:20 -0800318 if (!test_bit(FLAG_EXPORT, &desc->flags)) {
David Brownelld8f388d82008-07-25 01:46:07 -0700319 status = -EIO;
Jani Nikula07697462009-12-15 16:46:20 -0800320 } else {
321 int value;
322
Alexandre Courbot372e7222013-02-03 01:29:29 +0900323 value = !!gpiod_get_value_cansleep(desc);
Jani Nikula07697462009-12-15 16:46:20 -0800324 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
325 value = !value;
326
327 status = sprintf(buf, "%d\n", value);
328 }
David Brownelld8f388d82008-07-25 01:46:07 -0700329
330 mutex_unlock(&sysfs_lock);
331 return status;
332}
333
334static ssize_t gpio_value_store(struct device *dev,
335 struct device_attribute *attr, const char *buf, size_t size)
336{
Alexandre Courbot372e7222013-02-03 01:29:29 +0900337 struct gpio_desc *desc = dev_get_drvdata(dev);
David Brownelld8f388d82008-07-25 01:46:07 -0700338 ssize_t status;
339
340 mutex_lock(&sysfs_lock);
341
342 if (!test_bit(FLAG_EXPORT, &desc->flags))
343 status = -EIO;
344 else if (!test_bit(FLAG_IS_OUT, &desc->flags))
345 status = -EPERM;
346 else {
347 long value;
348
349 status = strict_strtol(buf, 0, &value);
350 if (status == 0) {
Jani Nikula07697462009-12-15 16:46:20 -0800351 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
352 value = !value;
Alexandre Courbot372e7222013-02-03 01:29:29 +0900353 gpiod_set_value_cansleep(desc, value != 0);
David Brownelld8f388d82008-07-25 01:46:07 -0700354 status = size;
355 }
356 }
357
358 mutex_unlock(&sysfs_lock);
359 return status;
360}
361
Jani Nikula07697462009-12-15 16:46:20 -0800362static const DEVICE_ATTR(value, 0644,
David Brownelld8f388d82008-07-25 01:46:07 -0700363 gpio_value_show, gpio_value_store);
364
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700365static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
366{
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700367 struct sysfs_dirent *value_sd = priv;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700368
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700369 sysfs_notify_dirent(value_sd);
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700370 return IRQ_HANDLED;
371}
372
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700373static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
374 unsigned long gpio_flags)
375{
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700376 struct sysfs_dirent *value_sd;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700377 unsigned long irq_flags;
378 int ret, irq, id;
379
380 if ((desc->flags & GPIO_TRIGGER_MASK) == gpio_flags)
381 return 0;
382
Alexandre Courbot372e7222013-02-03 01:29:29 +0900383 irq = gpiod_to_irq(desc);
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700384 if (irq < 0)
385 return -EIO;
386
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700387 id = desc->flags >> ID_SHIFT;
388 value_sd = idr_find(&dirent_idr, id);
389 if (value_sd)
390 free_irq(irq, value_sd);
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700391
392 desc->flags &= ~GPIO_TRIGGER_MASK;
393
394 if (!gpio_flags) {
395 ret = 0;
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700396 goto free_id;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700397 }
398
399 irq_flags = IRQF_SHARED;
400 if (test_bit(FLAG_TRIG_FALL, &gpio_flags))
Jani Nikula07697462009-12-15 16:46:20 -0800401 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
402 IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700403 if (test_bit(FLAG_TRIG_RISE, &gpio_flags))
Jani Nikula07697462009-12-15 16:46:20 -0800404 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
405 IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700406
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700407 if (!value_sd) {
408 value_sd = sysfs_get_dirent(dev->kobj.sd, NULL, "value");
409 if (!value_sd) {
410 ret = -ENODEV;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700411 goto err_out;
412 }
413
Tejun Heo62f516b2013-02-27 17:04:06 -0800414 ret = idr_alloc(&dirent_idr, value_sd, 1, 0, GFP_KERNEL);
415 if (ret < 0)
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700416 goto free_sd;
Tejun Heo62f516b2013-02-27 17:04:06 -0800417 id = ret;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700418
419 desc->flags &= GPIO_FLAGS_MASK;
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700420 desc->flags |= (unsigned long)id << ID_SHIFT;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700421
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700422 if (desc->flags >> ID_SHIFT != id) {
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700423 ret = -ERANGE;
424 goto free_id;
425 }
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700426 }
427
Daniel Gl?ckner364fadb32010-08-10 18:02:26 -0700428 ret = request_any_context_irq(irq, gpio_sysfs_irq, irq_flags,
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700429 "gpiolib", value_sd);
Daniel Gl?ckner364fadb32010-08-10 18:02:26 -0700430 if (ret < 0)
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700431 goto free_id;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700432
433 desc->flags |= gpio_flags;
434 return 0;
435
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700436free_id:
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700437 idr_remove(&dirent_idr, id);
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700438 desc->flags &= GPIO_FLAGS_MASK;
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700439free_sd:
440 if (value_sd)
441 sysfs_put(value_sd);
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700442err_out:
443 return ret;
444}
445
446static const struct {
447 const char *name;
448 unsigned long flags;
449} trigger_types[] = {
450 { "none", 0 },
451 { "falling", BIT(FLAG_TRIG_FALL) },
452 { "rising", BIT(FLAG_TRIG_RISE) },
453 { "both", BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE) },
454};
455
456static ssize_t gpio_edge_show(struct device *dev,
457 struct device_attribute *attr, char *buf)
458{
459 const struct gpio_desc *desc = dev_get_drvdata(dev);
460 ssize_t status;
461
462 mutex_lock(&sysfs_lock);
463
464 if (!test_bit(FLAG_EXPORT, &desc->flags))
465 status = -EIO;
466 else {
467 int i;
468
469 status = 0;
470 for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
471 if ((desc->flags & GPIO_TRIGGER_MASK)
472 == trigger_types[i].flags) {
473 status = sprintf(buf, "%s\n",
474 trigger_types[i].name);
475 break;
476 }
477 }
478
479 mutex_unlock(&sysfs_lock);
480 return status;
481}
482
483static ssize_t gpio_edge_store(struct device *dev,
484 struct device_attribute *attr, const char *buf, size_t size)
485{
486 struct gpio_desc *desc = dev_get_drvdata(dev);
487 ssize_t status;
488 int i;
489
490 for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
491 if (sysfs_streq(trigger_types[i].name, buf))
492 goto found;
493 return -EINVAL;
494
495found:
496 mutex_lock(&sysfs_lock);
497
498 if (!test_bit(FLAG_EXPORT, &desc->flags))
499 status = -EIO;
500 else {
501 status = gpio_setup_irq(desc, dev, trigger_types[i].flags);
502 if (!status)
503 status = size;
504 }
505
506 mutex_unlock(&sysfs_lock);
507
508 return status;
509}
510
511static DEVICE_ATTR(edge, 0644, gpio_edge_show, gpio_edge_store);
512
Jani Nikula07697462009-12-15 16:46:20 -0800513static int sysfs_set_active_low(struct gpio_desc *desc, struct device *dev,
514 int value)
515{
516 int status = 0;
517
518 if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
519 return 0;
520
521 if (value)
522 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
523 else
524 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
525
526 /* reconfigure poll(2) support if enabled on one edge only */
527 if (dev != NULL && (!!test_bit(FLAG_TRIG_RISE, &desc->flags) ^
528 !!test_bit(FLAG_TRIG_FALL, &desc->flags))) {
529 unsigned long trigger_flags = desc->flags & GPIO_TRIGGER_MASK;
530
531 gpio_setup_irq(desc, dev, 0);
532 status = gpio_setup_irq(desc, dev, trigger_flags);
533 }
534
535 return status;
536}
537
538static ssize_t gpio_active_low_show(struct device *dev,
539 struct device_attribute *attr, char *buf)
540{
541 const struct gpio_desc *desc = dev_get_drvdata(dev);
542 ssize_t status;
543
544 mutex_lock(&sysfs_lock);
545
546 if (!test_bit(FLAG_EXPORT, &desc->flags))
547 status = -EIO;
548 else
549 status = sprintf(buf, "%d\n",
550 !!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
551
552 mutex_unlock(&sysfs_lock);
553
554 return status;
555}
556
557static ssize_t gpio_active_low_store(struct device *dev,
558 struct device_attribute *attr, const char *buf, size_t size)
559{
560 struct gpio_desc *desc = dev_get_drvdata(dev);
561 ssize_t status;
562
563 mutex_lock(&sysfs_lock);
564
565 if (!test_bit(FLAG_EXPORT, &desc->flags)) {
566 status = -EIO;
567 } else {
568 long value;
569
570 status = strict_strtol(buf, 0, &value);
571 if (status == 0)
572 status = sysfs_set_active_low(desc, dev, value != 0);
573 }
574
575 mutex_unlock(&sysfs_lock);
576
577 return status ? : size;
578}
579
580static const DEVICE_ATTR(active_low, 0644,
581 gpio_active_low_show, gpio_active_low_store);
582
David Brownelld8f388d82008-07-25 01:46:07 -0700583static const struct attribute *gpio_attrs[] = {
David Brownelld8f388d82008-07-25 01:46:07 -0700584 &dev_attr_value.attr,
Jani Nikula07697462009-12-15 16:46:20 -0800585 &dev_attr_active_low.attr,
David Brownelld8f388d82008-07-25 01:46:07 -0700586 NULL,
587};
588
589static const struct attribute_group gpio_attr_group = {
590 .attrs = (struct attribute **) gpio_attrs,
591};
592
593/*
594 * /sys/class/gpio/gpiochipN/
595 * /base ... matching gpio_chip.base (N)
596 * /label ... matching gpio_chip.label
597 * /ngpio ... matching gpio_chip.ngpio
598 */
599
600static ssize_t chip_base_show(struct device *dev,
601 struct device_attribute *attr, char *buf)
602{
603 const struct gpio_chip *chip = dev_get_drvdata(dev);
604
605 return sprintf(buf, "%d\n", chip->base);
606}
607static DEVICE_ATTR(base, 0444, chip_base_show, NULL);
608
609static ssize_t chip_label_show(struct device *dev,
610 struct device_attribute *attr, char *buf)
611{
612 const struct gpio_chip *chip = dev_get_drvdata(dev);
613
614 return sprintf(buf, "%s\n", chip->label ? : "");
615}
616static DEVICE_ATTR(label, 0444, chip_label_show, NULL);
617
618static ssize_t chip_ngpio_show(struct device *dev,
619 struct device_attribute *attr, char *buf)
620{
621 const struct gpio_chip *chip = dev_get_drvdata(dev);
622
623 return sprintf(buf, "%u\n", chip->ngpio);
624}
625static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
626
627static const struct attribute *gpiochip_attrs[] = {
628 &dev_attr_base.attr,
629 &dev_attr_label.attr,
630 &dev_attr_ngpio.attr,
631 NULL,
632};
633
634static const struct attribute_group gpiochip_attr_group = {
635 .attrs = (struct attribute **) gpiochip_attrs,
636};
637
638/*
639 * /sys/class/gpio/export ... write-only
640 * integer N ... number of GPIO to export (full access)
641 * /sys/class/gpio/unexport ... write-only
642 * integer N ... number of GPIO to unexport
643 */
Andi Kleen28812fe2010-01-05 12:48:07 +0100644static ssize_t export_store(struct class *class,
645 struct class_attribute *attr,
646 const char *buf, size_t len)
David Brownelld8f388d82008-07-25 01:46:07 -0700647{
Alexandre Courbot372e7222013-02-03 01:29:29 +0900648 long gpio;
649 struct gpio_desc *desc;
650 int status;
David Brownelld8f388d82008-07-25 01:46:07 -0700651
652 status = strict_strtol(buf, 0, &gpio);
653 if (status < 0)
654 goto done;
655
Alexandre Courbot372e7222013-02-03 01:29:29 +0900656 desc = gpio_to_desc(gpio);
657
David Brownelld8f388d82008-07-25 01:46:07 -0700658 /* No extra locking here; FLAG_SYSFS just signifies that the
659 * request and export were done by on behalf of userspace, so
660 * they may be undone on its behalf too.
661 */
662
Alexandre Courbot372e7222013-02-03 01:29:29 +0900663 status = gpiod_request(desc, "sysfs");
Mathias Nymanad2fab32012-10-25 14:03:03 +0300664 if (status < 0) {
665 if (status == -EPROBE_DEFER)
666 status = -ENODEV;
David Brownelld8f388d82008-07-25 01:46:07 -0700667 goto done;
Mathias Nymanad2fab32012-10-25 14:03:03 +0300668 }
Alexandre Courbot372e7222013-02-03 01:29:29 +0900669 status = gpiod_export(desc, true);
David Brownelld8f388d82008-07-25 01:46:07 -0700670 if (status < 0)
Alexandre Courbot372e7222013-02-03 01:29:29 +0900671 gpiod_free(desc);
David Brownelld8f388d82008-07-25 01:46:07 -0700672 else
Alexandre Courbot372e7222013-02-03 01:29:29 +0900673 set_bit(FLAG_SYSFS, &desc->flags);
David Brownelld8f388d82008-07-25 01:46:07 -0700674
675done:
676 if (status)
677 pr_debug("%s: status %d\n", __func__, status);
678 return status ? : len;
679}
680
Andi Kleen28812fe2010-01-05 12:48:07 +0100681static ssize_t unexport_store(struct class *class,
682 struct class_attribute *attr,
683 const char *buf, size_t len)
David Brownelld8f388d82008-07-25 01:46:07 -0700684{
Alexandre Courbot372e7222013-02-03 01:29:29 +0900685 long gpio;
686 struct gpio_desc *desc;
687 int status;
David Brownelld8f388d82008-07-25 01:46:07 -0700688
689 status = strict_strtol(buf, 0, &gpio);
690 if (status < 0)
691 goto done;
692
693 status = -EINVAL;
694
Alexandre Courbot372e7222013-02-03 01:29:29 +0900695 desc = gpio_to_desc(gpio);
David Brownelld8f388d82008-07-25 01:46:07 -0700696 /* reject bogus commands (gpio_unexport ignores them) */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900697 if (!desc)
David Brownelld8f388d82008-07-25 01:46:07 -0700698 goto done;
699
700 /* No extra locking here; FLAG_SYSFS just signifies that the
701 * request and export were done by on behalf of userspace, so
702 * they may be undone on its behalf too.
703 */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900704 if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
David Brownelld8f388d82008-07-25 01:46:07 -0700705 status = 0;
Alexandre Courbot372e7222013-02-03 01:29:29 +0900706 gpiod_free(desc);
David Brownelld8f388d82008-07-25 01:46:07 -0700707 }
708done:
709 if (status)
710 pr_debug("%s: status %d\n", __func__, status);
711 return status ? : len;
712}
713
714static struct class_attribute gpio_class_attrs[] = {
715 __ATTR(export, 0200, NULL, export_store),
716 __ATTR(unexport, 0200, NULL, unexport_store),
717 __ATTR_NULL,
718};
719
720static struct class gpio_class = {
721 .name = "gpio",
722 .owner = THIS_MODULE,
723
724 .class_attrs = gpio_class_attrs,
725};
726
727
728/**
729 * gpio_export - export a GPIO through sysfs
730 * @gpio: gpio to make available, already requested
731 * @direction_may_change: true if userspace may change gpio direction
732 * Context: arch_initcall or later
733 *
734 * When drivers want to make a GPIO accessible to userspace after they
735 * have requested it -- perhaps while debugging, or as part of their
736 * public interface -- they may use this routine. If the GPIO can
737 * change direction (some can't) and the caller allows it, userspace
738 * will see "direction" sysfs attribute which may be used to change
739 * the gpio's direction. A "value" attribute will always be provided.
740 *
741 * Returns zero on success, else an error.
742 */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900743static int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
David Brownelld8f388d82008-07-25 01:46:07 -0700744{
745 unsigned long flags;
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100746 int status;
Uwe Kleine-König62154992010-05-26 14:42:17 -0700747 const char *ioname = NULL;
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100748 struct device *dev;
Alexandre Courbot372e7222013-02-03 01:29:29 +0900749 int offset;
David Brownelld8f388d82008-07-25 01:46:07 -0700750
751 /* can't export until sysfs is available ... */
752 if (!gpio_class.p) {
753 pr_debug("%s: called too early!\n", __func__);
754 return -ENOENT;
755 }
756
Alexandre Courbot372e7222013-02-03 01:29:29 +0900757 if (!desc) {
758 pr_debug("%s: invalid gpio descriptor\n", __func__);
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100759 return -EINVAL;
760 }
David Brownelld8f388d82008-07-25 01:46:07 -0700761
762 mutex_lock(&sysfs_lock);
763
764 spin_lock_irqsave(&gpio_lock, flags);
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100765 if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
766 test_bit(FLAG_EXPORT, &desc->flags)) {
767 spin_unlock_irqrestore(&gpio_lock, flags);
768 pr_debug("%s: gpio %d unavailable (requested=%d, exported=%d)\n",
Alexandre Courbot372e7222013-02-03 01:29:29 +0900769 __func__, desc_to_gpio(desc),
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100770 test_bit(FLAG_REQUESTED, &desc->flags),
771 test_bit(FLAG_EXPORT, &desc->flags));
Dan Carpenter529f2ad2012-10-26 09:59:43 +0300772 status = -EPERM;
773 goto fail_unlock;
David Brownelld8f388d82008-07-25 01:46:07 -0700774 }
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100775
776 if (!desc->chip->direction_input || !desc->chip->direction_output)
777 direction_may_change = false;
David Brownelld8f388d82008-07-25 01:46:07 -0700778 spin_unlock_irqrestore(&gpio_lock, flags);
779
Alexandre Courbot372e7222013-02-03 01:29:29 +0900780 offset = gpio_chip_hwgpio(desc);
781 if (desc->chip->names && desc->chip->names[offset])
782 ioname = desc->chip->names[offset];
Daniel Silverstone926b6632009-04-02 16:57:05 -0700783
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100784 dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
Alexandre Courbot372e7222013-02-03 01:29:29 +0900785 desc, ioname ? ioname : "gpio%u",
786 desc_to_gpio(desc));
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100787 if (IS_ERR(dev)) {
788 status = PTR_ERR(dev);
789 goto fail_unlock;
David Brownelld8f388d82008-07-25 01:46:07 -0700790 }
791
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100792 status = sysfs_create_group(&dev->kobj, &gpio_attr_group);
David Brownelld8f388d82008-07-25 01:46:07 -0700793 if (status)
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100794 goto fail_unregister_device;
David Brownelld8f388d82008-07-25 01:46:07 -0700795
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100796 if (direction_may_change) {
797 status = device_create_file(dev, &dev_attr_direction);
798 if (status)
799 goto fail_unregister_device;
800 }
801
Alexandre Courbot372e7222013-02-03 01:29:29 +0900802 if (gpiod_to_irq(desc) >= 0 && (direction_may_change ||
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100803 !test_bit(FLAG_IS_OUT, &desc->flags))) {
804 status = device_create_file(dev, &dev_attr_edge);
805 if (status)
806 goto fail_unregister_device;
807 }
808
809 set_bit(FLAG_EXPORT, &desc->flags);
810 mutex_unlock(&sysfs_lock);
811 return 0;
812
813fail_unregister_device:
814 device_unregister(dev);
815fail_unlock:
816 mutex_unlock(&sysfs_lock);
Alexandre Courbot372e7222013-02-03 01:29:29 +0900817 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
818 status);
David Brownelld8f388d82008-07-25 01:46:07 -0700819 return status;
820}
Alexandre Courbot372e7222013-02-03 01:29:29 +0900821
822int gpio_export(unsigned gpio, bool direction_may_change)
823{
824 return gpiod_export(gpio_to_desc(gpio), direction_may_change);
825}
David Brownelld8f388d82008-07-25 01:46:07 -0700826EXPORT_SYMBOL_GPL(gpio_export);
827
Michał Mirosław9f3b7952013-02-01 20:40:17 +0100828static int match_export(struct device *dev, const void *data)
David Brownelld8f388d82008-07-25 01:46:07 -0700829{
830 return dev_get_drvdata(dev) == data;
831}
832
833/**
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700834 * gpio_export_link - create a sysfs link to an exported GPIO node
835 * @dev: device under which to create symlink
836 * @name: name of the symlink
837 * @gpio: gpio to create symlink to, already exported
838 *
839 * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
840 * node. Caller is responsible for unlinking.
841 *
842 * Returns zero on success, else an error.
843 */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900844static int gpiod_export_link(struct device *dev, const char *name,
845 struct gpio_desc *desc)
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700846{
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700847 int status = -EINVAL;
848
Alexandre Courbot372e7222013-02-03 01:29:29 +0900849 if (!desc)
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700850 goto done;
851
852 mutex_lock(&sysfs_lock);
853
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700854 if (test_bit(FLAG_EXPORT, &desc->flags)) {
855 struct device *tdev;
856
857 tdev = class_find_device(&gpio_class, NULL, desc, match_export);
858 if (tdev != NULL) {
859 status = sysfs_create_link(&dev->kobj, &tdev->kobj,
860 name);
861 } else {
862 status = -ENODEV;
863 }
864 }
865
866 mutex_unlock(&sysfs_lock);
867
868done:
869 if (status)
Alexandre Courbot372e7222013-02-03 01:29:29 +0900870 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
871 status);
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700872
873 return status;
874}
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700875
Alexandre Courbot372e7222013-02-03 01:29:29 +0900876int gpio_export_link(struct device *dev, const char *name, unsigned gpio)
877{
878 return gpiod_export_link(dev, name, gpio_to_desc(gpio));
879}
880EXPORT_SYMBOL_GPL(gpio_export_link);
Jani Nikula07697462009-12-15 16:46:20 -0800881
882/**
883 * gpio_sysfs_set_active_low - set the polarity of gpio sysfs value
884 * @gpio: gpio to change
885 * @value: non-zero to use active low, i.e. inverted values
886 *
887 * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
888 * The GPIO does not have to be exported yet. If poll(2) support has
889 * been enabled for either rising or falling edge, it will be
890 * reconfigured to follow the new polarity.
891 *
892 * Returns zero on success, else an error.
893 */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900894static int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
Jani Nikula07697462009-12-15 16:46:20 -0800895{
Jani Nikula07697462009-12-15 16:46:20 -0800896 struct device *dev = NULL;
897 int status = -EINVAL;
898
Alexandre Courbot372e7222013-02-03 01:29:29 +0900899 if (!desc)
Jani Nikula07697462009-12-15 16:46:20 -0800900 goto done;
901
902 mutex_lock(&sysfs_lock);
903
Jani Nikula07697462009-12-15 16:46:20 -0800904 if (test_bit(FLAG_EXPORT, &desc->flags)) {
Jani Nikula07697462009-12-15 16:46:20 -0800905 dev = class_find_device(&gpio_class, NULL, desc, match_export);
906 if (dev == NULL) {
907 status = -ENODEV;
908 goto unlock;
909 }
910 }
911
912 status = sysfs_set_active_low(desc, dev, value);
913
914unlock:
915 mutex_unlock(&sysfs_lock);
916
917done:
918 if (status)
Alexandre Courbot372e7222013-02-03 01:29:29 +0900919 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
920 status);
Jani Nikula07697462009-12-15 16:46:20 -0800921
922 return status;
923}
Alexandre Courbot372e7222013-02-03 01:29:29 +0900924
925int gpio_sysfs_set_active_low(unsigned gpio, int value)
926{
927 return gpiod_sysfs_set_active_low(gpio_to_desc(gpio), value);
928}
Jani Nikula07697462009-12-15 16:46:20 -0800929EXPORT_SYMBOL_GPL(gpio_sysfs_set_active_low);
930
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700931/**
David Brownelld8f388d82008-07-25 01:46:07 -0700932 * gpio_unexport - reverse effect of gpio_export()
933 * @gpio: gpio to make unavailable
934 *
935 * This is implicit on gpio_free().
936 */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900937static void gpiod_unexport(struct gpio_desc *desc)
David Brownelld8f388d82008-07-25 01:46:07 -0700938{
Jon Povey6a99ad42010-07-27 13:18:06 -0700939 int status = 0;
Ming Lei864533c2012-02-13 22:53:20 +0800940 struct device *dev = NULL;
David Brownelld8f388d82008-07-25 01:46:07 -0700941
Alexandre Courbot372e7222013-02-03 01:29:29 +0900942 if (!desc) {
Jon Povey6a99ad42010-07-27 13:18:06 -0700943 status = -EINVAL;
David Brownelld8f388d82008-07-25 01:46:07 -0700944 goto done;
Jon Povey6a99ad42010-07-27 13:18:06 -0700945 }
David Brownelld8f388d82008-07-25 01:46:07 -0700946
947 mutex_lock(&sysfs_lock);
948
David Brownelld8f388d82008-07-25 01:46:07 -0700949 if (test_bit(FLAG_EXPORT, &desc->flags)) {
David Brownelld8f388d82008-07-25 01:46:07 -0700950
951 dev = class_find_device(&gpio_class, NULL, desc, match_export);
952 if (dev) {
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700953 gpio_setup_irq(desc, dev, 0);
David Brownelld8f388d82008-07-25 01:46:07 -0700954 clear_bit(FLAG_EXPORT, &desc->flags);
David Brownelld8f388d82008-07-25 01:46:07 -0700955 } else
956 status = -ENODEV;
957 }
958
959 mutex_unlock(&sysfs_lock);
Alexandre Courbot372e7222013-02-03 01:29:29 +0900960
Ming Lei864533c2012-02-13 22:53:20 +0800961 if (dev) {
962 device_unregister(dev);
963 put_device(dev);
964 }
David Brownelld8f388d82008-07-25 01:46:07 -0700965done:
966 if (status)
Alexandre Courbot372e7222013-02-03 01:29:29 +0900967 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
968 status);
969}
970
971void gpio_unexport(unsigned gpio)
972{
973 gpiod_unexport(gpio_to_desc(gpio));
David Brownelld8f388d82008-07-25 01:46:07 -0700974}
975EXPORT_SYMBOL_GPL(gpio_unexport);
976
977static int gpiochip_export(struct gpio_chip *chip)
978{
979 int status;
980 struct device *dev;
981
982 /* Many systems register gpio chips for SOC support very early,
983 * before driver model support is available. In those cases we
984 * export this later, in gpiolib_sysfs_init() ... here we just
985 * verify that _some_ field of gpio_class got initialized.
986 */
987 if (!gpio_class.p)
988 return 0;
989
990 /* use chip->base for the ID; it's already known to be unique */
991 mutex_lock(&sysfs_lock);
992 dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
993 "gpiochip%d", chip->base);
Sergei Shtylyovd62668e2009-11-11 14:26:50 -0800994 if (!IS_ERR(dev)) {
David Brownelld8f388d82008-07-25 01:46:07 -0700995 status = sysfs_create_group(&dev->kobj,
996 &gpiochip_attr_group);
997 } else
Sergei Shtylyovd62668e2009-11-11 14:26:50 -0800998 status = PTR_ERR(dev);
David Brownelld8f388d82008-07-25 01:46:07 -0700999 chip->exported = (status == 0);
1000 mutex_unlock(&sysfs_lock);
1001
1002 if (status) {
1003 unsigned long flags;
1004 unsigned gpio;
1005
1006 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001007 gpio = 0;
1008 while (gpio < chip->ngpio)
1009 chip->desc[gpio++].chip = NULL;
David Brownelld8f388d82008-07-25 01:46:07 -07001010 spin_unlock_irqrestore(&gpio_lock, flags);
1011
1012 pr_debug("%s: chip %s status %d\n", __func__,
1013 chip->label, status);
1014 }
1015
1016 return status;
1017}
1018
1019static void gpiochip_unexport(struct gpio_chip *chip)
1020{
1021 int status;
1022 struct device *dev;
1023
1024 mutex_lock(&sysfs_lock);
1025 dev = class_find_device(&gpio_class, NULL, chip, match_export);
1026 if (dev) {
1027 put_device(dev);
1028 device_unregister(dev);
1029 chip->exported = 0;
1030 status = 0;
1031 } else
1032 status = -ENODEV;
1033 mutex_unlock(&sysfs_lock);
1034
1035 if (status)
1036 pr_debug("%s: chip %s status %d\n", __func__,
1037 chip->label, status);
1038}
1039
1040static int __init gpiolib_sysfs_init(void)
1041{
1042 int status;
1043 unsigned long flags;
Alexandre Courbot65493e32013-02-03 01:29:25 +09001044 struct gpio_chip *chip;
David Brownelld8f388d82008-07-25 01:46:07 -07001045
1046 status = class_register(&gpio_class);
1047 if (status < 0)
1048 return status;
1049
1050 /* Scan and register the gpio_chips which registered very
1051 * early (e.g. before the class_register above was called).
1052 *
1053 * We run before arch_initcall() so chip->dev nodes can have
1054 * registered, and so arch_initcall() can always gpio_export().
1055 */
1056 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbot65493e32013-02-03 01:29:25 +09001057 list_for_each_entry(chip, &gpio_chips, list) {
David Brownelld8f388d82008-07-25 01:46:07 -07001058 if (!chip || chip->exported)
1059 continue;
1060
1061 spin_unlock_irqrestore(&gpio_lock, flags);
1062 status = gpiochip_export(chip);
1063 spin_lock_irqsave(&gpio_lock, flags);
1064 }
1065 spin_unlock_irqrestore(&gpio_lock, flags);
1066
1067
1068 return status;
1069}
1070postcore_initcall(gpiolib_sysfs_init);
1071
1072#else
1073static inline int gpiochip_export(struct gpio_chip *chip)
1074{
1075 return 0;
1076}
1077
1078static inline void gpiochip_unexport(struct gpio_chip *chip)
1079{
1080}
1081
Alexandre Courbot372e7222013-02-03 01:29:29 +09001082static inline int gpiod_export(struct gpio_desc *desc,
1083 bool direction_may_change)
1084{
1085 return -ENOSYS;
1086}
1087
1088static inline int gpiod_export_link(struct device *dev, const char *name,
1089 struct gpio_desc *desc)
1090{
1091 return -ENOSYS;
1092}
1093
1094static inline int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
1095{
1096 return -ENOSYS;
1097}
1098
1099static inline void gpiod_unexport(struct gpio_desc *desc)
1100{
1101}
1102
David Brownelld8f388d82008-07-25 01:46:07 -07001103#endif /* CONFIG_GPIO_SYSFS */
1104
Alexandre Courbot1a989d02013-02-03 01:29:24 +09001105/*
1106 * Add a new chip to the global chips list, keeping the list of chips sorted
1107 * by base order.
1108 *
1109 * Return -EBUSY if the new chip overlaps with some other chip's integer
1110 * space.
1111 */
1112static int gpiochip_add_to_list(struct gpio_chip *chip)
1113{
1114 struct list_head *pos = &gpio_chips;
1115 struct gpio_chip *_chip;
1116 int err = 0;
1117
1118 /* find where to insert our chip */
1119 list_for_each(pos, &gpio_chips) {
1120 _chip = list_entry(pos, struct gpio_chip, list);
1121 /* shall we insert before _chip? */
1122 if (_chip->base >= chip->base + chip->ngpio)
1123 break;
1124 }
1125
1126 /* are we stepping on the chip right before? */
1127 if (pos != &gpio_chips && pos->prev != &gpio_chips) {
1128 _chip = list_entry(pos->prev, struct gpio_chip, list);
1129 if (_chip->base + _chip->ngpio > chip->base) {
1130 dev_err(chip->dev,
1131 "GPIO integer space overlap, cannot add chip\n");
1132 err = -EBUSY;
1133 }
1134 }
1135
1136 if (!err)
1137 list_add_tail(&chip->list, pos);
1138
1139 return err;
1140}
1141
Anton Vorontsov169b6a72008-04-28 02:14:47 -07001142/**
David Brownelld2876d02008-02-04 22:28:20 -08001143 * gpiochip_add() - register a gpio_chip
1144 * @chip: the chip to register, with chip->base initialized
1145 * Context: potentially before irqs or kmalloc will work
1146 *
1147 * Returns a negative errno if the chip can't be registered, such as
1148 * because the chip->base is invalid or already associated with a
1149 * different chip. Otherwise it returns zero as a success code.
Anton Vorontsov8d0aab22008-04-28 02:14:46 -07001150 *
David Brownelld8f388d82008-07-25 01:46:07 -07001151 * When gpiochip_add() is called very early during boot, so that GPIOs
1152 * can be freely used, the chip->dev device must be registered before
1153 * the gpio framework's arch_initcall(). Otherwise sysfs initialization
1154 * for GPIOs will fail rudely.
1155 *
Anton Vorontsov8d0aab22008-04-28 02:14:46 -07001156 * If chip->base is negative, this requests dynamic assignment of
1157 * a range of valid GPIOs.
David Brownelld2876d02008-02-04 22:28:20 -08001158 */
1159int gpiochip_add(struct gpio_chip *chip)
1160{
1161 unsigned long flags;
1162 int status = 0;
1163 unsigned id;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -07001164 int base = chip->base;
David Brownelld2876d02008-02-04 22:28:20 -08001165
Trent Piephobff5fda2008-05-23 13:04:44 -07001166 if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
Anton Vorontsov8d0aab22008-04-28 02:14:46 -07001167 && base >= 0) {
David Brownelld2876d02008-02-04 22:28:20 -08001168 status = -EINVAL;
1169 goto fail;
1170 }
1171
1172 spin_lock_irqsave(&gpio_lock, flags);
1173
Anton Vorontsov8d0aab22008-04-28 02:14:46 -07001174 if (base < 0) {
1175 base = gpiochip_find_base(chip->ngpio);
1176 if (base < 0) {
1177 status = base;
David Brownelld8f388d82008-07-25 01:46:07 -07001178 goto unlock;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -07001179 }
1180 chip->base = base;
1181 }
1182
Alexandre Courbot1a989d02013-02-03 01:29:24 +09001183 status = gpiochip_add_to_list(chip);
1184
David Brownelld2876d02008-02-04 22:28:20 -08001185 if (status == 0) {
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001186 chip->desc = &gpio_desc[chip->base];
1187
1188 for (id = 0; id < chip->ngpio; id++) {
1189 struct gpio_desc *desc = &chip->desc[id];
1190 desc->chip = chip;
David Brownelld8f388d82008-07-25 01:46:07 -07001191
1192 /* REVISIT: most hardware initializes GPIOs as
1193 * inputs (often with pullups enabled) so power
1194 * usage is minimized. Linux code should set the
1195 * gpio direction first thing; but until it does,
Mathias Nyman80b0a602012-10-24 17:25:27 +03001196 * and in case chip->get_direction is not set,
David Brownelld8f388d82008-07-25 01:46:07 -07001197 * we may expose the wrong direction in sysfs.
1198 */
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001199 desc->flags = !chip->direction_input
David Brownelld8f388d82008-07-25 01:46:07 -07001200 ? (1 << FLAG_IS_OUT)
1201 : 0;
David Brownelld2876d02008-02-04 22:28:20 -08001202 }
1203 }
1204
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301205#ifdef CONFIG_PINCTRL
1206 INIT_LIST_HEAD(&chip->pin_ranges);
1207#endif
1208
Anton Vorontsov391c9702010-06-08 07:48:17 -06001209 of_gpiochip_add(chip);
1210
David Brownelld8f388d82008-07-25 01:46:07 -07001211unlock:
David Brownelld2876d02008-02-04 22:28:20 -08001212 spin_unlock_irqrestore(&gpio_lock, flags);
Anton Vorontsovcedb1882010-06-08 07:48:15 -06001213
1214 if (status)
1215 goto fail;
1216
1217 status = gpiochip_export(chip);
1218 if (status)
1219 goto fail;
1220
H Hartley Sweetenee1c1e72012-05-11 16:58:33 -07001221 pr_debug("gpiochip_add: registered GPIOs %d to %d on device: %s\n",
Grant Likely64842aa2011-11-06 11:36:18 -07001222 chip->base, chip->base + chip->ngpio - 1,
1223 chip->label ? : "generic");
1224
Anton Vorontsovcedb1882010-06-08 07:48:15 -06001225 return 0;
David Brownelld2876d02008-02-04 22:28:20 -08001226fail:
1227 /* failures here can mean systems won't boot... */
Anton Vorontsovcedb1882010-06-08 07:48:15 -06001228 pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n",
1229 chip->base, chip->base + chip->ngpio - 1,
1230 chip->label ? : "generic");
David Brownelld2876d02008-02-04 22:28:20 -08001231 return status;
1232}
1233EXPORT_SYMBOL_GPL(gpiochip_add);
1234
1235/**
1236 * gpiochip_remove() - unregister a gpio_chip
1237 * @chip: the chip to unregister
1238 *
1239 * A gpio_chip with any GPIOs still requested may not be removed.
1240 */
1241int gpiochip_remove(struct gpio_chip *chip)
1242{
1243 unsigned long flags;
1244 int status = 0;
1245 unsigned id;
1246
1247 spin_lock_irqsave(&gpio_lock, flags);
1248
Linus Walleij9ef0d6f2012-11-06 15:15:44 +01001249 gpiochip_remove_pin_ranges(chip);
Anton Vorontsov391c9702010-06-08 07:48:17 -06001250 of_gpiochip_remove(chip);
1251
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001252 for (id = 0; id < chip->ngpio; id++) {
1253 if (test_bit(FLAG_REQUESTED, &chip->desc[id].flags)) {
David Brownelld2876d02008-02-04 22:28:20 -08001254 status = -EBUSY;
1255 break;
1256 }
1257 }
1258 if (status == 0) {
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001259 for (id = 0; id < chip->ngpio; id++)
1260 chip->desc[id].chip = NULL;
Alexandre Courbot1a989d02013-02-03 01:29:24 +09001261
1262 list_del(&chip->list);
David Brownelld2876d02008-02-04 22:28:20 -08001263 }
1264
1265 spin_unlock_irqrestore(&gpio_lock, flags);
David Brownelld8f388d82008-07-25 01:46:07 -07001266
1267 if (status == 0)
1268 gpiochip_unexport(chip);
1269
David Brownelld2876d02008-02-04 22:28:20 -08001270 return status;
1271}
1272EXPORT_SYMBOL_GPL(gpiochip_remove);
1273
Grant Likely594fa262010-06-08 07:48:16 -06001274/**
1275 * gpiochip_find() - iterator for locating a specific gpio_chip
1276 * @data: data to pass to match function
1277 * @callback: Callback function to check gpio_chip
1278 *
1279 * Similar to bus_find_device. It returns a reference to a gpio_chip as
1280 * determined by a user supplied @match callback. The callback should return
1281 * 0 if the device doesn't match and non-zero if it does. If the callback is
1282 * non-zero, this function will return to the caller and not iterate over any
1283 * more gpio_chips.
1284 */
Grant Likely07ce8ec2012-05-18 23:01:05 -06001285struct gpio_chip *gpiochip_find(void *data,
Grant Likely6e2cf652012-03-02 15:56:03 -07001286 int (*match)(struct gpio_chip *chip,
Grant Likely3d0f7cf2012-05-17 13:54:40 -06001287 void *data))
Grant Likely594fa262010-06-08 07:48:16 -06001288{
Alexandre Courbot125eef92013-02-03 01:29:26 +09001289 struct gpio_chip *chip;
Grant Likely594fa262010-06-08 07:48:16 -06001290 unsigned long flags;
Grant Likely594fa262010-06-08 07:48:16 -06001291
1292 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbot125eef92013-02-03 01:29:26 +09001293 list_for_each_entry(chip, &gpio_chips, list)
1294 if (match(chip, data))
Grant Likely594fa262010-06-08 07:48:16 -06001295 break;
Alexandre Courbot125eef92013-02-03 01:29:26 +09001296
1297 /* No match? */
1298 if (&chip->list == &gpio_chips)
1299 chip = NULL;
Grant Likely594fa262010-06-08 07:48:16 -06001300 spin_unlock_irqrestore(&gpio_lock, flags);
1301
1302 return chip;
1303}
Jean Delvare8fa0c9b2011-05-20 00:40:18 -06001304EXPORT_SYMBOL_GPL(gpiochip_find);
David Brownelld2876d02008-02-04 22:28:20 -08001305
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301306#ifdef CONFIG_PINCTRL
Linus Walleij165adc92012-11-06 14:49:39 +01001307
Linus Walleij3f0f8672012-11-20 12:40:15 +01001308/**
1309 * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
1310 * @chip: the gpiochip to add the range for
1311 * @pinctrl_name: the dev_name() of the pin controller to map to
Linus Walleij316511c2012-11-21 08:48:09 +01001312 * @gpio_offset: the start offset in the current gpio_chip number space
1313 * @pin_offset: the start offset in the pin controller number space
Linus Walleij3f0f8672012-11-20 12:40:15 +01001314 * @npins: the number of pins from the offset of each pin space (GPIO and
1315 * pin controller) to accumulate in this range
1316 */
Linus Walleij1e63d7b2012-11-06 16:03:35 +01001317int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
Linus Walleij316511c2012-11-21 08:48:09 +01001318 unsigned int gpio_offset, unsigned int pin_offset,
Linus Walleij3f0f8672012-11-20 12:40:15 +01001319 unsigned int npins)
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301320{
1321 struct gpio_pin_range *pin_range;
Axel Linb4d4b1f2012-11-21 14:33:56 +08001322 int ret;
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301323
Linus Walleij3f0f8672012-11-20 12:40:15 +01001324 pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301325 if (!pin_range) {
1326 pr_err("%s: GPIO chip: failed to allocate pin ranges\n",
1327 chip->label);
Linus Walleij1e63d7b2012-11-06 16:03:35 +01001328 return -ENOMEM;
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301329 }
1330
Linus Walleij3f0f8672012-11-20 12:40:15 +01001331 /* Use local offset as range ID */
Linus Walleij316511c2012-11-21 08:48:09 +01001332 pin_range->range.id = gpio_offset;
Linus Walleij3f0f8672012-11-20 12:40:15 +01001333 pin_range->range.gc = chip;
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301334 pin_range->range.name = chip->label;
Linus Walleij316511c2012-11-21 08:48:09 +01001335 pin_range->range.base = chip->base + gpio_offset;
1336 pin_range->range.pin_base = pin_offset;
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301337 pin_range->range.npins = npins;
Linus Walleij192c3692012-11-20 14:03:37 +01001338 pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301339 &pin_range->range);
Linus Walleij8f23ca12012-11-20 14:56:25 +01001340 if (IS_ERR(pin_range->pctldev)) {
Axel Linb4d4b1f2012-11-21 14:33:56 +08001341 ret = PTR_ERR(pin_range->pctldev);
Linus Walleij3f0f8672012-11-20 12:40:15 +01001342 pr_err("%s: GPIO chip: could not create pin range\n",
1343 chip->label);
1344 kfree(pin_range);
Axel Linb4d4b1f2012-11-21 14:33:56 +08001345 return ret;
Linus Walleij3f0f8672012-11-20 12:40:15 +01001346 }
Linus Walleij316511c2012-11-21 08:48:09 +01001347 pr_debug("GPIO chip %s: created GPIO range %d->%d ==> %s PIN %d->%d\n",
1348 chip->label, gpio_offset, gpio_offset + npins - 1,
1349 pinctl_name,
1350 pin_offset, pin_offset + npins - 1);
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301351
1352 list_add_tail(&pin_range->node, &chip->pin_ranges);
Linus Walleij1e63d7b2012-11-06 16:03:35 +01001353
1354 return 0;
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301355}
Linus Walleij165adc92012-11-06 14:49:39 +01001356EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301357
Linus Walleij3f0f8672012-11-20 12:40:15 +01001358/**
1359 * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
1360 * @chip: the chip to remove all the mappings for
1361 */
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301362void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
1363{
1364 struct gpio_pin_range *pin_range, *tmp;
1365
1366 list_for_each_entry_safe(pin_range, tmp, &chip->pin_ranges, node) {
1367 list_del(&pin_range->node);
1368 pinctrl_remove_gpio_range(pin_range->pctldev,
1369 &pin_range->range);
Linus Walleij3f0f8672012-11-20 12:40:15 +01001370 kfree(pin_range);
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301371 }
1372}
Linus Walleij165adc92012-11-06 14:49:39 +01001373EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
1374
1375#endif /* CONFIG_PINCTRL */
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301376
David Brownelld2876d02008-02-04 22:28:20 -08001377/* These "optional" allocation calls help prevent drivers from stomping
1378 * on each other, and help provide better diagnostics in debugfs.
1379 * They're called even less than the "set direction" calls.
1380 */
Alexandre Courbot372e7222013-02-03 01:29:29 +09001381static int gpiod_request(struct gpio_desc *desc, const char *label)
David Brownelld2876d02008-02-04 22:28:20 -08001382{
David Brownell35e8bb52008-10-15 22:03:16 -07001383 struct gpio_chip *chip;
Mark Browne9354572012-07-09 12:22:56 +01001384 int status = -EPROBE_DEFER;
David Brownelld2876d02008-02-04 22:28:20 -08001385 unsigned long flags;
1386
1387 spin_lock_irqsave(&gpio_lock, flags);
1388
Alexandre Courbot372e7222013-02-03 01:29:29 +09001389 if (!desc) {
Mathias Nymanad2fab32012-10-25 14:03:03 +03001390 status = -EINVAL;
David Brownelld2876d02008-02-04 22:28:20 -08001391 goto done;
Mathias Nymanad2fab32012-10-25 14:03:03 +03001392 }
David Brownell35e8bb52008-10-15 22:03:16 -07001393 chip = desc->chip;
1394 if (chip == NULL)
David Brownelld2876d02008-02-04 22:28:20 -08001395 goto done;
1396
David Brownell35e8bb52008-10-15 22:03:16 -07001397 if (!try_module_get(chip->owner))
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -07001398 goto done;
1399
David Brownelld2876d02008-02-04 22:28:20 -08001400 /* NOTE: gpio_request() can be called in early boot,
David Brownell35e8bb52008-10-15 22:03:16 -07001401 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
David Brownelld2876d02008-02-04 22:28:20 -08001402 */
1403
1404 if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
1405 desc_set_label(desc, label ? : "?");
1406 status = 0;
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -07001407 } else {
David Brownelld2876d02008-02-04 22:28:20 -08001408 status = -EBUSY;
David Brownell35e8bb52008-10-15 22:03:16 -07001409 module_put(chip->owner);
Magnus Damm7460db52009-01-29 14:25:12 -08001410 goto done;
David Brownell35e8bb52008-10-15 22:03:16 -07001411 }
1412
1413 if (chip->request) {
1414 /* chip->request may sleep */
1415 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001416 status = chip->request(chip, gpio_chip_hwgpio(desc));
David Brownell35e8bb52008-10-15 22:03:16 -07001417 spin_lock_irqsave(&gpio_lock, flags);
1418
1419 if (status < 0) {
1420 desc_set_label(desc, NULL);
1421 module_put(chip->owner);
1422 clear_bit(FLAG_REQUESTED, &desc->flags);
Mathias Nyman80b0a602012-10-24 17:25:27 +03001423 goto done;
David Brownell35e8bb52008-10-15 22:03:16 -07001424 }
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -07001425 }
Mathias Nyman80b0a602012-10-24 17:25:27 +03001426 if (chip->get_direction) {
1427 /* chip->get_direction may sleep */
1428 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001429 gpiod_get_direction(desc);
Mathias Nyman80b0a602012-10-24 17:25:27 +03001430 spin_lock_irqsave(&gpio_lock, flags);
1431 }
David Brownelld2876d02008-02-04 22:28:20 -08001432done:
1433 if (status)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001434 pr_debug("_gpio_request: gpio-%d (%s) status %d\n",
1435 desc ? desc_to_gpio(desc) : -1,
1436 label ? : "?", status);
David Brownelld2876d02008-02-04 22:28:20 -08001437 spin_unlock_irqrestore(&gpio_lock, flags);
1438 return status;
1439}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001440
1441int gpio_request(unsigned gpio, const char *label)
1442{
1443 return gpiod_request(gpio_to_desc(gpio), label);
1444}
David Brownelld2876d02008-02-04 22:28:20 -08001445EXPORT_SYMBOL_GPL(gpio_request);
1446
Alexandre Courbot372e7222013-02-03 01:29:29 +09001447static void gpiod_free(struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -08001448{
1449 unsigned long flags;
David Brownell35e8bb52008-10-15 22:03:16 -07001450 struct gpio_chip *chip;
David Brownelld2876d02008-02-04 22:28:20 -08001451
Uwe Kleine-König3d599d12008-10-15 22:03:12 -07001452 might_sleep();
1453
Alexandre Courbot372e7222013-02-03 01:29:29 +09001454 if (!desc) {
David Brownelld2876d02008-02-04 22:28:20 -08001455 WARN_ON(extra_checks);
1456 return;
1457 }
1458
Alexandre Courbot372e7222013-02-03 01:29:29 +09001459 gpiod_unexport(desc);
David Brownelld8f388d82008-07-25 01:46:07 -07001460
David Brownelld2876d02008-02-04 22:28:20 -08001461 spin_lock_irqsave(&gpio_lock, flags);
1462
David Brownell35e8bb52008-10-15 22:03:16 -07001463 chip = desc->chip;
1464 if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
1465 if (chip->free) {
1466 spin_unlock_irqrestore(&gpio_lock, flags);
David Brownell9c4ba942010-08-10 18:02:24 -07001467 might_sleep_if(chip->can_sleep);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001468 chip->free(chip, gpio_chip_hwgpio(desc));
David Brownell35e8bb52008-10-15 22:03:16 -07001469 spin_lock_irqsave(&gpio_lock, flags);
1470 }
David Brownelld2876d02008-02-04 22:28:20 -08001471 desc_set_label(desc, NULL);
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -07001472 module_put(desc->chip->owner);
Jani Nikula07697462009-12-15 16:46:20 -08001473 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
David Brownell35e8bb52008-10-15 22:03:16 -07001474 clear_bit(FLAG_REQUESTED, &desc->flags);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301475 clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301476 clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -07001477 } else
David Brownelld2876d02008-02-04 22:28:20 -08001478 WARN_ON(extra_checks);
1479
1480 spin_unlock_irqrestore(&gpio_lock, flags);
1481}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001482
1483void gpio_free(unsigned gpio)
1484{
1485 gpiod_free(gpio_to_desc(gpio));
1486}
David Brownelld2876d02008-02-04 22:28:20 -08001487EXPORT_SYMBOL_GPL(gpio_free);
1488
Eric Miao3e45f1d2010-03-05 13:44:35 -08001489/**
1490 * gpio_request_one - request a single GPIO with initial configuration
1491 * @gpio: the GPIO number
1492 * @flags: GPIO configuration as specified by GPIOF_*
1493 * @label: a literal description string of this GPIO
1494 */
1495int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
1496{
Alexandre Courbot372e7222013-02-03 01:29:29 +09001497 struct gpio_desc *desc;
Eric Miao3e45f1d2010-03-05 13:44:35 -08001498 int err;
1499
Alexandre Courbot372e7222013-02-03 01:29:29 +09001500 desc = gpio_to_desc(gpio);
1501
1502 err = gpiod_request(desc, label);
Eric Miao3e45f1d2010-03-05 13:44:35 -08001503 if (err)
1504 return err;
1505
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301506 if (flags & GPIOF_OPEN_DRAIN)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001507 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301508
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301509 if (flags & GPIOF_OPEN_SOURCE)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001510 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301511
Eric Miao3e45f1d2010-03-05 13:44:35 -08001512 if (flags & GPIOF_DIR_IN)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001513 err = gpiod_direction_input(desc);
Eric Miao3e45f1d2010-03-05 13:44:35 -08001514 else
Alexandre Courbot372e7222013-02-03 01:29:29 +09001515 err = gpiod_direction_output(desc,
Eric Miao3e45f1d2010-03-05 13:44:35 -08001516 (flags & GPIOF_INIT_HIGH) ? 1 : 0);
1517
Aaro Koskinene2548112010-12-21 17:24:22 -08001518 if (err)
Wolfram Sangfc3a1f02011-12-13 18:34:01 +01001519 goto free_gpio;
Aaro Koskinene2548112010-12-21 17:24:22 -08001520
Wolfram Sangfc3a1f02011-12-13 18:34:01 +01001521 if (flags & GPIOF_EXPORT) {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001522 err = gpiod_export(desc, flags & GPIOF_EXPORT_CHANGEABLE);
Wolfram Sangfc3a1f02011-12-13 18:34:01 +01001523 if (err)
1524 goto free_gpio;
1525 }
1526
1527 return 0;
1528
1529 free_gpio:
Alexandre Courbot372e7222013-02-03 01:29:29 +09001530 gpiod_free(desc);
Eric Miao3e45f1d2010-03-05 13:44:35 -08001531 return err;
1532}
1533EXPORT_SYMBOL_GPL(gpio_request_one);
1534
1535/**
1536 * gpio_request_array - request multiple GPIOs in a single call
1537 * @array: array of the 'struct gpio'
1538 * @num: how many GPIOs in the array
1539 */
Lars-Peter Clausen7c295972011-05-25 16:20:31 -07001540int gpio_request_array(const struct gpio *array, size_t num)
Eric Miao3e45f1d2010-03-05 13:44:35 -08001541{
1542 int i, err;
1543
1544 for (i = 0; i < num; i++, array++) {
1545 err = gpio_request_one(array->gpio, array->flags, array->label);
1546 if (err)
1547 goto err_free;
1548 }
1549 return 0;
1550
1551err_free:
1552 while (i--)
1553 gpio_free((--array)->gpio);
1554 return err;
1555}
1556EXPORT_SYMBOL_GPL(gpio_request_array);
1557
1558/**
1559 * gpio_free_array - release multiple GPIOs in a single call
1560 * @array: array of the 'struct gpio'
1561 * @num: how many GPIOs in the array
1562 */
Lars-Peter Clausen7c295972011-05-25 16:20:31 -07001563void gpio_free_array(const struct gpio *array, size_t num)
Eric Miao3e45f1d2010-03-05 13:44:35 -08001564{
1565 while (num--)
1566 gpio_free((array++)->gpio);
1567}
1568EXPORT_SYMBOL_GPL(gpio_free_array);
David Brownelld2876d02008-02-04 22:28:20 -08001569
1570/**
1571 * gpiochip_is_requested - return string iff signal was requested
1572 * @chip: controller managing the signal
1573 * @offset: of signal within controller's 0..(ngpio - 1) range
1574 *
1575 * Returns NULL if the GPIO is not currently requested, else a string.
1576 * If debugfs support is enabled, the string returned is the label passed
1577 * to gpio_request(); otherwise it is a meaningless constant.
1578 *
1579 * This function is for use by GPIO controller drivers. The label can
1580 * help with diagnostics, and knowing that the signal is used as a GPIO
1581 * can help avoid accidentally multiplexing it to another controller.
1582 */
1583const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
1584{
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001585 struct gpio_desc *desc;
David Brownelld2876d02008-02-04 22:28:20 -08001586
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001587 if (!GPIO_OFFSET_VALID(chip, offset))
David Brownelld2876d02008-02-04 22:28:20 -08001588 return NULL;
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001589
1590 desc = &chip->desc[offset];
1591
Alexandre Courbot372e7222013-02-03 01:29:29 +09001592 if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
David Brownelld2876d02008-02-04 22:28:20 -08001593 return NULL;
1594#ifdef CONFIG_DEBUG_FS
Alexandre Courbot372e7222013-02-03 01:29:29 +09001595 return desc->label;
David Brownelld2876d02008-02-04 22:28:20 -08001596#else
1597 return "?";
1598#endif
1599}
1600EXPORT_SYMBOL_GPL(gpiochip_is_requested);
1601
1602
1603/* Drivers MUST set GPIO direction before making get/set calls. In
1604 * some cases this is done in early boot, before IRQs are enabled.
1605 *
1606 * As a rule these aren't called more than once (except for drivers
1607 * using the open-drain emulation idiom) so these are natural places
1608 * to accumulate extra debugging checks. Note that we can't (yet)
1609 * rely on gpio_request() having been called beforehand.
1610 */
1611
Alexandre Courbot372e7222013-02-03 01:29:29 +09001612static int gpiod_direction_input(struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -08001613{
1614 unsigned long flags;
1615 struct gpio_chip *chip;
David Brownelld2876d02008-02-04 22:28:20 -08001616 int status = -EINVAL;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001617 int offset;
David Brownelld2876d02008-02-04 22:28:20 -08001618
1619 spin_lock_irqsave(&gpio_lock, flags);
1620
Alexandre Courbot372e7222013-02-03 01:29:29 +09001621 if (!desc)
David Brownelld2876d02008-02-04 22:28:20 -08001622 goto fail;
1623 chip = desc->chip;
1624 if (!chip || !chip->get || !chip->direction_input)
1625 goto fail;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001626 status = gpio_ensure_requested(desc);
David Brownell35e8bb52008-10-15 22:03:16 -07001627 if (status < 0)
1628 goto fail;
David Brownelld2876d02008-02-04 22:28:20 -08001629
1630 /* now we know the gpio is valid and chip won't vanish */
1631
1632 spin_unlock_irqrestore(&gpio_lock, flags);
1633
David Brownell9c4ba942010-08-10 18:02:24 -07001634 might_sleep_if(chip->can_sleep);
David Brownelld2876d02008-02-04 22:28:20 -08001635
Alexandre Courbot372e7222013-02-03 01:29:29 +09001636 offset = gpio_chip_hwgpio(desc);
David Brownell35e8bb52008-10-15 22:03:16 -07001637 if (status) {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001638 status = chip->request(chip, offset);
David Brownell35e8bb52008-10-15 22:03:16 -07001639 if (status < 0) {
1640 pr_debug("GPIO-%d: chip request fail, %d\n",
Alexandre Courbot372e7222013-02-03 01:29:29 +09001641 desc_to_gpio(desc), status);
David Brownell35e8bb52008-10-15 22:03:16 -07001642 /* and it's not available to anyone else ...
1643 * gpio_request() is the fully clean solution.
1644 */
1645 goto lose;
1646 }
1647 }
1648
Alexandre Courbot372e7222013-02-03 01:29:29 +09001649 status = chip->direction_input(chip, offset);
David Brownelld2876d02008-02-04 22:28:20 -08001650 if (status == 0)
1651 clear_bit(FLAG_IS_OUT, &desc->flags);
Uwe Kleine-König3f397c212011-05-20 00:40:19 -06001652
Alexandre Courbot372e7222013-02-03 01:29:29 +09001653 trace_gpio_direction(desc_to_gpio(desc), 1, status);
David Brownell35e8bb52008-10-15 22:03:16 -07001654lose:
David Brownelld2876d02008-02-04 22:28:20 -08001655 return status;
1656fail:
1657 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001658 if (status) {
1659 int gpio = -1;
1660 if (desc)
1661 gpio = desc_to_gpio(desc);
David Brownelld2876d02008-02-04 22:28:20 -08001662 pr_debug("%s: gpio-%d status %d\n",
Harvey Harrison145980a2008-04-30 00:54:57 -07001663 __func__, gpio, status);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001664 }
David Brownelld2876d02008-02-04 22:28:20 -08001665 return status;
1666}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001667
1668int gpio_direction_input(unsigned gpio)
1669{
1670 return gpiod_direction_input(gpio_to_desc(gpio));
1671}
David Brownelld2876d02008-02-04 22:28:20 -08001672EXPORT_SYMBOL_GPL(gpio_direction_input);
1673
Alexandre Courbot372e7222013-02-03 01:29:29 +09001674static int gpiod_direction_output(struct gpio_desc *desc, int value)
David Brownelld2876d02008-02-04 22:28:20 -08001675{
1676 unsigned long flags;
1677 struct gpio_chip *chip;
David Brownelld2876d02008-02-04 22:28:20 -08001678 int status = -EINVAL;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001679 int offset;
David Brownelld2876d02008-02-04 22:28:20 -08001680
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301681 /* Open drain pin should not be driven to 1 */
1682 if (value && test_bit(FLAG_OPEN_DRAIN, &desc->flags))
Alexandre Courbot372e7222013-02-03 01:29:29 +09001683 return gpiod_direction_input(desc);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301684
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301685 /* Open source pin should not be driven to 0 */
1686 if (!value && test_bit(FLAG_OPEN_SOURCE, &desc->flags))
Alexandre Courbot372e7222013-02-03 01:29:29 +09001687 return gpiod_direction_input(desc);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301688
David Brownelld2876d02008-02-04 22:28:20 -08001689 spin_lock_irqsave(&gpio_lock, flags);
1690
Alexandre Courbot372e7222013-02-03 01:29:29 +09001691 if (!desc)
David Brownelld2876d02008-02-04 22:28:20 -08001692 goto fail;
1693 chip = desc->chip;
1694 if (!chip || !chip->set || !chip->direction_output)
1695 goto fail;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001696 status = gpio_ensure_requested(desc);
David Brownell35e8bb52008-10-15 22:03:16 -07001697 if (status < 0)
1698 goto fail;
David Brownelld2876d02008-02-04 22:28:20 -08001699
1700 /* now we know the gpio is valid and chip won't vanish */
1701
1702 spin_unlock_irqrestore(&gpio_lock, flags);
1703
David Brownell9c4ba942010-08-10 18:02:24 -07001704 might_sleep_if(chip->can_sleep);
David Brownelld2876d02008-02-04 22:28:20 -08001705
Alexandre Courbot372e7222013-02-03 01:29:29 +09001706 offset = gpio_chip_hwgpio(desc);
David Brownell35e8bb52008-10-15 22:03:16 -07001707 if (status) {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001708 status = chip->request(chip, offset);
David Brownell35e8bb52008-10-15 22:03:16 -07001709 if (status < 0) {
1710 pr_debug("GPIO-%d: chip request fail, %d\n",
Alexandre Courbot372e7222013-02-03 01:29:29 +09001711 desc_to_gpio(desc), status);
David Brownell35e8bb52008-10-15 22:03:16 -07001712 /* and it's not available to anyone else ...
1713 * gpio_request() is the fully clean solution.
1714 */
1715 goto lose;
1716 }
1717 }
1718
Alexandre Courbot372e7222013-02-03 01:29:29 +09001719 status = chip->direction_output(chip, offset, value);
David Brownelld2876d02008-02-04 22:28:20 -08001720 if (status == 0)
1721 set_bit(FLAG_IS_OUT, &desc->flags);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001722 trace_gpio_value(desc_to_gpio(desc), 0, value);
1723 trace_gpio_direction(desc_to_gpio(desc), 0, status);
David Brownell35e8bb52008-10-15 22:03:16 -07001724lose:
David Brownelld2876d02008-02-04 22:28:20 -08001725 return status;
1726fail:
1727 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001728 if (status) {
1729 int gpio = -1;
1730 if (desc)
1731 gpio = desc_to_gpio(desc);
David Brownelld2876d02008-02-04 22:28:20 -08001732 pr_debug("%s: gpio-%d status %d\n",
Harvey Harrison145980a2008-04-30 00:54:57 -07001733 __func__, gpio, status);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001734 }
David Brownelld2876d02008-02-04 22:28:20 -08001735 return status;
1736}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001737
1738int gpio_direction_output(unsigned gpio, int value)
1739{
1740 return gpiod_direction_output(gpio_to_desc(gpio), value);
1741}
David Brownelld2876d02008-02-04 22:28:20 -08001742EXPORT_SYMBOL_GPL(gpio_direction_output);
1743
Felipe Balbic4b5be92010-05-26 14:42:23 -07001744/**
1745 * gpio_set_debounce - sets @debounce time for a @gpio
1746 * @gpio: the gpio to set debounce time
1747 * @debounce: debounce time is microseconds
1748 */
Alexandre Courbot372e7222013-02-03 01:29:29 +09001749static int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
Felipe Balbic4b5be92010-05-26 14:42:23 -07001750{
1751 unsigned long flags;
1752 struct gpio_chip *chip;
Felipe Balbic4b5be92010-05-26 14:42:23 -07001753 int status = -EINVAL;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001754 int offset;
Felipe Balbic4b5be92010-05-26 14:42:23 -07001755
1756 spin_lock_irqsave(&gpio_lock, flags);
1757
Alexandre Courbot372e7222013-02-03 01:29:29 +09001758 if (!desc)
Felipe Balbic4b5be92010-05-26 14:42:23 -07001759 goto fail;
1760 chip = desc->chip;
1761 if (!chip || !chip->set || !chip->set_debounce)
1762 goto fail;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001763
1764 status = gpio_ensure_requested(desc);
Felipe Balbic4b5be92010-05-26 14:42:23 -07001765 if (status < 0)
1766 goto fail;
1767
1768 /* now we know the gpio is valid and chip won't vanish */
1769
1770 spin_unlock_irqrestore(&gpio_lock, flags);
1771
David Brownell9c4ba942010-08-10 18:02:24 -07001772 might_sleep_if(chip->can_sleep);
Felipe Balbic4b5be92010-05-26 14:42:23 -07001773
Alexandre Courbot372e7222013-02-03 01:29:29 +09001774 offset = gpio_chip_hwgpio(desc);
1775 return chip->set_debounce(chip, offset, debounce);
Felipe Balbic4b5be92010-05-26 14:42:23 -07001776
1777fail:
1778 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001779 if (status) {
1780 int gpio = -1;
1781 if (desc)
1782 gpio = desc_to_gpio(desc);
Felipe Balbic4b5be92010-05-26 14:42:23 -07001783 pr_debug("%s: gpio-%d status %d\n",
1784 __func__, gpio, status);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001785 }
Felipe Balbic4b5be92010-05-26 14:42:23 -07001786
1787 return status;
1788}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001789
1790int gpio_set_debounce(unsigned gpio, unsigned debounce)
1791{
1792 return gpiod_set_debounce(gpio_to_desc(gpio), debounce);
1793}
Felipe Balbic4b5be92010-05-26 14:42:23 -07001794EXPORT_SYMBOL_GPL(gpio_set_debounce);
David Brownelld2876d02008-02-04 22:28:20 -08001795
1796/* I/O calls are only valid after configuration completed; the relevant
1797 * "is this a valid GPIO" error checks should already have been done.
1798 *
1799 * "Get" operations are often inlinable as reading a pin value register,
1800 * and masking the relevant bit in that register.
1801 *
1802 * When "set" operations are inlinable, they involve writing that mask to
1803 * one register to set a low value, or a different register to set it high.
1804 * Otherwise locking is needed, so there may be little value to inlining.
1805 *
1806 *------------------------------------------------------------------------
1807 *
1808 * IMPORTANT!!! The hot paths -- get/set value -- assume that callers
1809 * have requested the GPIO. That can include implicit requesting by
1810 * a direction setting call. Marking a gpio as requested locks its chip
1811 * in memory, guaranteeing that these table lookups need no more locking
1812 * and that gpiochip_remove() will fail.
1813 *
1814 * REVISIT when debugging, consider adding some instrumentation to ensure
1815 * that the GPIO was actually requested.
1816 */
1817
1818/**
1819 * __gpio_get_value() - return a gpio's value
1820 * @gpio: gpio whose value will be returned
1821 * Context: any
1822 *
1823 * This is used directly or indirectly to implement gpio_get_value().
1824 * It returns the zero or nonzero value provided by the associated
1825 * gpio_chip.get() method; or zero if no such method is provided.
1826 */
Alexandre Courbot372e7222013-02-03 01:29:29 +09001827static int gpiod_get_value(struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -08001828{
1829 struct gpio_chip *chip;
Uwe Kleine-König3f397c212011-05-20 00:40:19 -06001830 int value;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001831 int offset;
David Brownelld2876d02008-02-04 22:28:20 -08001832
Alexandre Courbot372e7222013-02-03 01:29:29 +09001833 chip = desc->chip;
1834 offset = gpio_chip_hwgpio(desc);
Mark Browne4e449e2012-02-17 10:46:00 -08001835 /* Should be using gpio_get_value_cansleep() */
David Brownell9c4ba942010-08-10 18:02:24 -07001836 WARN_ON(chip->can_sleep);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001837 value = chip->get ? chip->get(chip, offset) : 0;
1838 trace_gpio_value(desc_to_gpio(desc), 1, value);
Uwe Kleine-König3f397c212011-05-20 00:40:19 -06001839 return value;
David Brownelld2876d02008-02-04 22:28:20 -08001840}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001841
1842int __gpio_get_value(unsigned gpio)
1843{
1844 return gpiod_get_value(gpio_to_desc(gpio));
1845}
David Brownelld2876d02008-02-04 22:28:20 -08001846EXPORT_SYMBOL_GPL(__gpio_get_value);
1847
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301848/*
1849 * _gpio_set_open_drain_value() - Set the open drain gpio's value.
1850 * @gpio: Gpio whose state need to be set.
1851 * @chip: Gpio chip.
1852 * @value: Non-zero for setting it HIGH otherise it will set to LOW.
1853 */
Alexandre Courbot372e7222013-02-03 01:29:29 +09001854static void _gpio_set_open_drain_value(struct gpio_desc *desc, int value)
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301855{
1856 int err = 0;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001857 struct gpio_chip *chip = desc->chip;
1858 int offset = gpio_chip_hwgpio(desc);
1859
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301860 if (value) {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001861 err = chip->direction_input(chip, offset);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301862 if (!err)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001863 clear_bit(FLAG_IS_OUT, &desc->flags);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301864 } else {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001865 err = chip->direction_output(chip, offset, 0);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301866 if (!err)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001867 set_bit(FLAG_IS_OUT, &desc->flags);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301868 }
Alexandre Courbot372e7222013-02-03 01:29:29 +09001869 trace_gpio_direction(desc_to_gpio(desc), value, err);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301870 if (err < 0)
1871 pr_err("%s: Error in set_value for open drain gpio%d err %d\n",
Alexandre Courbot372e7222013-02-03 01:29:29 +09001872 __func__, desc_to_gpio(desc), err);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301873}
1874
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301875/*
1876 * _gpio_set_open_source() - Set the open source gpio's value.
1877 * @gpio: Gpio whose state need to be set.
1878 * @chip: Gpio chip.
1879 * @value: Non-zero for setting it HIGH otherise it will set to LOW.
1880 */
Alexandre Courbot372e7222013-02-03 01:29:29 +09001881static void _gpio_set_open_source_value(struct gpio_desc *desc, int value)
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301882{
1883 int err = 0;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001884 struct gpio_chip *chip = desc->chip;
1885 int offset = gpio_chip_hwgpio(desc);
1886
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301887 if (value) {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001888 err = chip->direction_output(chip, offset, 1);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301889 if (!err)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001890 set_bit(FLAG_IS_OUT, &desc->flags);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301891 } else {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001892 err = chip->direction_input(chip, offset);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301893 if (!err)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001894 clear_bit(FLAG_IS_OUT, &desc->flags);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301895 }
Alexandre Courbot372e7222013-02-03 01:29:29 +09001896 trace_gpio_direction(desc_to_gpio(desc), !value, err);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301897 if (err < 0)
1898 pr_err("%s: Error in set_value for open source gpio%d err %d\n",
Alexandre Courbot372e7222013-02-03 01:29:29 +09001899 __func__, desc_to_gpio(desc), err);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301900}
1901
David Brownelld2876d02008-02-04 22:28:20 -08001902/**
1903 * __gpio_set_value() - assign a gpio's value
1904 * @gpio: gpio whose value will be assigned
1905 * @value: value to assign
1906 * Context: any
1907 *
1908 * This is used directly or indirectly to implement gpio_set_value().
1909 * It invokes the associated gpio_chip.set() method.
1910 */
Alexandre Courbot372e7222013-02-03 01:29:29 +09001911static void gpiod_set_value(struct gpio_desc *desc, int value)
David Brownelld2876d02008-02-04 22:28:20 -08001912{
1913 struct gpio_chip *chip;
1914
Alexandre Courbot372e7222013-02-03 01:29:29 +09001915 chip = desc->chip;
Mark Browne4e449e2012-02-17 10:46:00 -08001916 /* Should be using gpio_set_value_cansleep() */
David Brownell9c4ba942010-08-10 18:02:24 -07001917 WARN_ON(chip->can_sleep);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001918 trace_gpio_value(desc_to_gpio(desc), 0, value);
1919 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
1920 _gpio_set_open_drain_value(desc, value);
1921 else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
1922 _gpio_set_open_source_value(desc, value);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301923 else
Alexandre Courbot372e7222013-02-03 01:29:29 +09001924 chip->set(chip, gpio_chip_hwgpio(desc), value);
1925}
1926
1927void __gpio_set_value(unsigned gpio, int value)
1928{
1929 return gpiod_set_value(gpio_to_desc(gpio), value);
David Brownelld2876d02008-02-04 22:28:20 -08001930}
1931EXPORT_SYMBOL_GPL(__gpio_set_value);
1932
1933/**
1934 * __gpio_cansleep() - report whether gpio value access will sleep
1935 * @gpio: gpio in question
1936 * Context: any
1937 *
1938 * This is used directly or indirectly to implement gpio_cansleep(). It
1939 * returns nonzero if access reading or writing the GPIO value can sleep.
1940 */
Alexandre Courbot372e7222013-02-03 01:29:29 +09001941static int gpiod_cansleep(struct gpio_desc *desc)
1942{
1943 /* only call this on GPIOs that are valid! */
1944 return desc->chip->can_sleep;
1945}
1946
David Brownelld2876d02008-02-04 22:28:20 -08001947int __gpio_cansleep(unsigned gpio)
1948{
Alexandre Courbot372e7222013-02-03 01:29:29 +09001949 return gpiod_cansleep(gpio_to_desc(gpio));
David Brownelld2876d02008-02-04 22:28:20 -08001950}
1951EXPORT_SYMBOL_GPL(__gpio_cansleep);
1952
David Brownell0f6d5042008-10-15 22:03:14 -07001953/**
1954 * __gpio_to_irq() - return the IRQ corresponding to a GPIO
1955 * @gpio: gpio whose IRQ will be returned (already requested)
1956 * Context: any
1957 *
1958 * This is used directly or indirectly to implement gpio_to_irq().
1959 * It returns the number of the IRQ signaled by this (input) GPIO,
1960 * or a negative errno.
1961 */
Alexandre Courbot372e7222013-02-03 01:29:29 +09001962static int gpiod_to_irq(struct gpio_desc *desc)
David Brownell0f6d5042008-10-15 22:03:14 -07001963{
1964 struct gpio_chip *chip;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001965 int offset;
David Brownell0f6d5042008-10-15 22:03:14 -07001966
Alexandre Courbot372e7222013-02-03 01:29:29 +09001967 chip = desc->chip;
1968 offset = gpio_chip_hwgpio(desc);
1969 return chip->to_irq ? chip->to_irq(chip, offset) : -ENXIO;
1970}
1971
1972int __gpio_to_irq(unsigned gpio)
1973{
1974 return gpiod_to_irq(gpio_to_desc(gpio));
David Brownell0f6d5042008-10-15 22:03:14 -07001975}
1976EXPORT_SYMBOL_GPL(__gpio_to_irq);
1977
David Brownelld2876d02008-02-04 22:28:20 -08001978
David Brownelld2876d02008-02-04 22:28:20 -08001979/* There's no value in making it easy to inline GPIO calls that may sleep.
1980 * Common examples include ones connected to I2C or SPI chips.
1981 */
1982
Alexandre Courbot372e7222013-02-03 01:29:29 +09001983static int gpiod_get_value_cansleep(struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -08001984{
1985 struct gpio_chip *chip;
Uwe Kleine-König3f397c212011-05-20 00:40:19 -06001986 int value;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001987 int offset;
David Brownelld2876d02008-02-04 22:28:20 -08001988
1989 might_sleep_if(extra_checks);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001990 chip = desc->chip;
1991 offset = gpio_chip_hwgpio(desc);
1992 value = chip->get ? chip->get(chip, offset) : 0;
1993 trace_gpio_value(desc_to_gpio(desc), 1, value);
Uwe Kleine-König3f397c212011-05-20 00:40:19 -06001994 return value;
David Brownelld2876d02008-02-04 22:28:20 -08001995}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001996
1997int gpio_get_value_cansleep(unsigned gpio)
1998{
1999 return gpiod_get_value_cansleep(gpio_to_desc(gpio));
2000}
David Brownelld2876d02008-02-04 22:28:20 -08002001EXPORT_SYMBOL_GPL(gpio_get_value_cansleep);
2002
Alexandre Courbot372e7222013-02-03 01:29:29 +09002003static void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
David Brownelld2876d02008-02-04 22:28:20 -08002004{
2005 struct gpio_chip *chip;
2006
2007 might_sleep_if(extra_checks);
Alexandre Courbot372e7222013-02-03 01:29:29 +09002008 chip = desc->chip;
2009 trace_gpio_value(desc_to_gpio(desc), 0, value);
2010 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
2011 _gpio_set_open_drain_value(desc, value);
2012 else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
2013 _gpio_set_open_source_value(desc, value);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05302014 else
Alexandre Courbot372e7222013-02-03 01:29:29 +09002015 chip->set(chip, gpio_chip_hwgpio(desc), value);
2016}
2017
2018void gpio_set_value_cansleep(unsigned gpio, int value)
2019{
2020 return gpiod_set_value_cansleep(gpio_to_desc(gpio), value);
David Brownelld2876d02008-02-04 22:28:20 -08002021}
2022EXPORT_SYMBOL_GPL(gpio_set_value_cansleep);
2023
David Brownelld2876d02008-02-04 22:28:20 -08002024#ifdef CONFIG_DEBUG_FS
2025
David Brownelld2876d02008-02-04 22:28:20 -08002026static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
2027{
2028 unsigned i;
2029 unsigned gpio = chip->base;
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09002030 struct gpio_desc *gdesc = &chip->desc[0];
David Brownelld2876d02008-02-04 22:28:20 -08002031 int is_out;
2032
2033 for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
2034 if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
2035 continue;
2036
Alexandre Courbot372e7222013-02-03 01:29:29 +09002037 gpiod_get_direction(gdesc);
David Brownelld2876d02008-02-04 22:28:20 -08002038 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
Jarkko Nikula6e8ba722008-11-19 15:36:17 -08002039 seq_printf(s, " gpio-%-3d (%-20.20s) %s %s",
David Brownelld2876d02008-02-04 22:28:20 -08002040 gpio, gdesc->label,
2041 is_out ? "out" : "in ",
2042 chip->get
2043 ? (chip->get(chip, i) ? "hi" : "lo")
2044 : "? ");
David Brownelld2876d02008-02-04 22:28:20 -08002045 seq_printf(s, "\n");
2046 }
2047}
2048
Thierry Redingf9c4a312012-04-12 13:26:01 +02002049static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
David Brownelld2876d02008-02-04 22:28:20 -08002050{
Grant Likely362432a2013-02-09 09:41:49 +00002051 unsigned long flags;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002052 struct gpio_chip *chip = NULL;
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002053 loff_t index = *pos;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002054
2055 s->private = "";
2056
Grant Likely362432a2013-02-09 09:41:49 +00002057 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002058 list_for_each_entry(chip, &gpio_chips, list)
Grant Likely362432a2013-02-09 09:41:49 +00002059 if (index-- == 0) {
2060 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002061 return chip;
Grant Likely362432a2013-02-09 09:41:49 +00002062 }
2063 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002064
2065 return NULL;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002066}
2067
2068static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
2069{
Grant Likely362432a2013-02-09 09:41:49 +00002070 unsigned long flags;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002071 struct gpio_chip *chip = v;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002072 void *ret = NULL;
2073
Grant Likely362432a2013-02-09 09:41:49 +00002074 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002075 if (list_is_last(&chip->list, &gpio_chips))
2076 ret = NULL;
2077 else
2078 ret = list_entry(chip->list.next, struct gpio_chip, list);
Grant Likely362432a2013-02-09 09:41:49 +00002079 spin_unlock_irqrestore(&gpio_lock, flags);
Thierry Redingf9c4a312012-04-12 13:26:01 +02002080
2081 s->private = "\n";
2082 ++*pos;
2083
2084 return ret;
2085}
2086
2087static void gpiolib_seq_stop(struct seq_file *s, void *v)
2088{
2089}
2090
2091static int gpiolib_seq_show(struct seq_file *s, void *v)
2092{
2093 struct gpio_chip *chip = v;
2094 struct device *dev;
2095
2096 seq_printf(s, "%sGPIOs %d-%d", (char *)s->private,
2097 chip->base, chip->base + chip->ngpio - 1);
2098 dev = chip->dev;
2099 if (dev)
2100 seq_printf(s, ", %s/%s", dev->bus ? dev->bus->name : "no-bus",
2101 dev_name(dev));
2102 if (chip->label)
2103 seq_printf(s, ", %s", chip->label);
2104 if (chip->can_sleep)
2105 seq_printf(s, ", can sleep");
2106 seq_printf(s, ":\n");
2107
2108 if (chip->dbg_show)
2109 chip->dbg_show(s, chip);
2110 else
2111 gpiolib_dbg_show(s, chip);
2112
David Brownelld2876d02008-02-04 22:28:20 -08002113 return 0;
2114}
2115
Thierry Redingf9c4a312012-04-12 13:26:01 +02002116static const struct seq_operations gpiolib_seq_ops = {
2117 .start = gpiolib_seq_start,
2118 .next = gpiolib_seq_next,
2119 .stop = gpiolib_seq_stop,
2120 .show = gpiolib_seq_show,
2121};
2122
David Brownelld2876d02008-02-04 22:28:20 -08002123static int gpiolib_open(struct inode *inode, struct file *file)
2124{
Thierry Redingf9c4a312012-04-12 13:26:01 +02002125 return seq_open(file, &gpiolib_seq_ops);
David Brownelld2876d02008-02-04 22:28:20 -08002126}
2127
Alexey Dobriyan828c0952009-10-01 15:43:56 -07002128static const struct file_operations gpiolib_operations = {
Thierry Redingf9c4a312012-04-12 13:26:01 +02002129 .owner = THIS_MODULE,
David Brownelld2876d02008-02-04 22:28:20 -08002130 .open = gpiolib_open,
2131 .read = seq_read,
2132 .llseek = seq_lseek,
Thierry Redingf9c4a312012-04-12 13:26:01 +02002133 .release = seq_release,
David Brownelld2876d02008-02-04 22:28:20 -08002134};
2135
2136static int __init gpiolib_debugfs_init(void)
2137{
2138 /* /sys/kernel/debug/gpio */
2139 (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
2140 NULL, NULL, &gpiolib_operations);
2141 return 0;
2142}
2143subsys_initcall(gpiolib_debugfs_init);
2144
2145#endif /* DEBUG_FS */