blob: 86ef3461ec0647b42f1e1ff94a9f47225151f7f6 [file] [log] [blame]
David Brownelld2876d02008-02-04 22:28:20 -08001#include <linux/kernel.h>
2#include <linux/module.h>
Daniel Glöcknerff77c352009-09-22 16:46:38 -07003#include <linux/interrupt.h>
David Brownelld2876d02008-02-04 22:28:20 -08004#include <linux/irq.h>
5#include <linux/spinlock.h>
Alexandre Courbot1a989d02013-02-03 01:29:24 +09006#include <linux/list.h>
David Brownelld8f388d2008-07-25 01:46:07 -07007#include <linux/device.h>
8#include <linux/err.h>
9#include <linux/debugfs.h>
10#include <linux/seq_file.h>
11#include <linux/gpio.h>
Anton Vorontsov391c9702010-06-08 07:48:17 -060012#include <linux/of_gpio.h>
Daniel Glöcknerff77c352009-09-22 16:46:38 -070013#include <linux/idr.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090014#include <linux/slab.h>
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);
Alexandre Courbotdef63432013-02-15 14:46:15 +090091static int gpiod_get_direction(const struct gpio_desc *desc);
Alexandre Courbot372e7222013-02-03 01:29:29 +090092static int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
Alexandre Courbotdef63432013-02-15 14:46:15 +090093static int gpiod_get_value_cansleep(const struct gpio_desc *desc);
Alexandre Courbot372e7222013-02-03 01:29:29 +090094static void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
Alexandre Courbotdef63432013-02-15 14:46:15 +090095static int gpiod_get_value(const struct gpio_desc *desc);
Alexandre Courbot372e7222013-02-03 01:29:29 +090096static void gpiod_set_value(struct gpio_desc *desc, int value);
Alexandre Courbotdef63432013-02-15 14:46:15 +090097static int gpiod_cansleep(const struct gpio_desc *desc);
98static int gpiod_to_irq(const struct gpio_desc *desc);
Alexandre Courbot372e7222013-02-03 01:29:29 +090099static int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
100static int gpiod_export_link(struct device *dev, const char *name,
101 struct gpio_desc *desc);
102static int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value);
103static void gpiod_unexport(struct gpio_desc *desc);
104
105
David Brownelld2876d02008-02-04 22:28:20 -0800106static inline void desc_set_label(struct gpio_desc *d, const char *label)
107{
108#ifdef CONFIG_DEBUG_FS
109 d->label = label;
110#endif
111}
112
Alexandre Courbot372e7222013-02-03 01:29:29 +0900113/*
114 * Return the GPIO number of the passed descriptor relative to its chip
115 */
116static int gpio_chip_hwgpio(const struct gpio_desc *desc)
117{
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +0900118 return desc - &desc->chip->desc[0];
Alexandre Courbot372e7222013-02-03 01:29:29 +0900119}
120
121/**
122 * Convert a GPIO number to its descriptor
123 */
124static struct gpio_desc *gpio_to_desc(unsigned gpio)
125{
126 if (WARN(!gpio_is_valid(gpio), "invalid GPIO %d\n", gpio))
127 return NULL;
128 else
129 return &gpio_desc[gpio];
130}
131
132/**
133 * Convert a GPIO descriptor to the integer namespace.
134 * This should disappear in the future but is needed since we still
135 * use GPIO numbers for error messages and sysfs nodes
136 */
137static int desc_to_gpio(const struct gpio_desc *desc)
138{
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +0900139 return desc->chip->base + gpio_chip_hwgpio(desc);
Alexandre Courbot372e7222013-02-03 01:29:29 +0900140}
141
142
David Brownelld2876d02008-02-04 22:28:20 -0800143/* Warn when drivers omit gpio_request() calls -- legal but ill-advised
144 * when setting direction, and otherwise illegal. Until board setup code
145 * and drivers use explicit requests everywhere (which won't happen when
146 * those calls have no teeth) we can't avoid autorequesting. This nag
David Brownell35e8bb52008-10-15 22:03:16 -0700147 * message should motivate switching to explicit requests... so should
148 * the weaker cleanup after faults, compared to gpio_request().
David Brownell8a0cecf2009-04-02 16:57:06 -0700149 *
150 * NOTE: the autorequest mechanism is going away; at this point it's
151 * only "legal" in the sense that (old) code using it won't break yet,
152 * but instead only triggers a WARN() stack dump.
David Brownelld2876d02008-02-04 22:28:20 -0800153 */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900154static int gpio_ensure_requested(struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -0800155{
David Brownell8a0cecf2009-04-02 16:57:06 -0700156 const struct gpio_chip *chip = desc->chip;
Alexandre Courbot372e7222013-02-03 01:29:29 +0900157 const int gpio = desc_to_gpio(desc);
David Brownell35e8bb52008-10-15 22:03:16 -0700158
David Brownell8a0cecf2009-04-02 16:57:06 -0700159 if (WARN(test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0,
160 "autorequest GPIO-%d\n", gpio)) {
David Brownell35e8bb52008-10-15 22:03:16 -0700161 if (!try_module_get(chip->owner)) {
162 pr_err("GPIO-%d: module can't be gotten \n", gpio);
163 clear_bit(FLAG_REQUESTED, &desc->flags);
164 /* lose */
165 return -EIO;
166 }
David Brownelld2876d02008-02-04 22:28:20 -0800167 desc_set_label(desc, "[auto]");
David Brownell35e8bb52008-10-15 22:03:16 -0700168 /* caller must chip->request() w/o spinlock */
169 if (chip->request)
170 return 1;
David Brownelld2876d02008-02-04 22:28:20 -0800171 }
David Brownell35e8bb52008-10-15 22:03:16 -0700172 return 0;
David Brownelld2876d02008-02-04 22:28:20 -0800173}
174
Alexandre Courbotdef63432013-02-15 14:46:15 +0900175static struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
Alexandre Courbot372e7222013-02-03 01:29:29 +0900176{
Alexandre Courbotbcabdef2013-02-15 14:46:14 +0900177 return desc ? desc->chip : NULL;
Alexandre Courbot372e7222013-02-03 01:29:29 +0900178}
179
Alexandre Courbot24d76282013-02-15 14:46:16 +0900180/* caller holds gpio_lock *OR* gpio is marked as requested */
Grant Likely1a2d3972011-12-12 09:25:57 -0700181struct gpio_chip *gpio_to_chip(unsigned gpio)
David Brownelld2876d02008-02-04 22:28:20 -0800182{
Alexandre Courbot372e7222013-02-03 01:29:29 +0900183 return gpiod_to_chip(gpio_to_desc(gpio));
David Brownelld2876d02008-02-04 22:28:20 -0800184}
185
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700186/* dynamic allocation of GPIOs, e.g. on a hotplugged device */
187static int gpiochip_find_base(int ngpio)
188{
Alexandre Courbot83cabe32013-02-03 01:29:28 +0900189 struct gpio_chip *chip;
190 int base = ARCH_NR_GPIOS - ngpio;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700191
Alexandre Courbot83cabe32013-02-03 01:29:28 +0900192 list_for_each_entry_reverse(chip, &gpio_chips, list) {
193 /* found a free space? */
194 if (chip->base + chip->ngpio <= base)
195 break;
196 else
197 /* nope, check the space right before the chip */
198 base = chip->base - ngpio;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700199 }
200
Alexandre Courbot83cabe32013-02-03 01:29:28 +0900201 if (gpio_is_valid(base)) {
Anton Vorontsov8d0aab22008-04-28 02:14:46 -0700202 pr_debug("%s: found new base at %d\n", __func__, base);
Alexandre Courbot83cabe32013-02-03 01:29:28 +0900203 return base;
204 } else {
205 pr_err("%s: cannot find free range\n", __func__);
206 return -ENOSPC;
Anton Vorontsov169b6a72008-04-28 02:14:47 -0700207 }
Anton Vorontsov169b6a72008-04-28 02:14:47 -0700208}
209
Mathias Nyman80b0a602012-10-24 17:25:27 +0300210/* caller ensures gpio is valid and requested, chip->get_direction may sleep */
Alexandre Courbotdef63432013-02-15 14:46:15 +0900211static int gpiod_get_direction(const struct gpio_desc *desc)
Mathias Nyman80b0a602012-10-24 17:25:27 +0300212{
213 struct gpio_chip *chip;
Alexandre Courbot372e7222013-02-03 01:29:29 +0900214 unsigned offset;
Mathias Nyman80b0a602012-10-24 17:25:27 +0300215 int status = -EINVAL;
216
Alexandre Courbot372e7222013-02-03 01:29:29 +0900217 chip = gpiod_to_chip(desc);
218 offset = gpio_chip_hwgpio(desc);
Mathias Nyman80b0a602012-10-24 17:25:27 +0300219
220 if (!chip->get_direction)
221 return status;
222
Alexandre Courbot372e7222013-02-03 01:29:29 +0900223 status = chip->get_direction(chip, offset);
Mathias Nyman80b0a602012-10-24 17:25:27 +0300224 if (status > 0) {
225 /* GPIOF_DIR_IN, or other positive */
226 status = 1;
Alexandre Courbotdef63432013-02-15 14:46:15 +0900227 /* FLAG_IS_OUT is just a cache of the result of get_direction(),
228 * so it does not affect constness per se */
229 clear_bit(FLAG_IS_OUT, &((struct gpio_desc *)desc)->flags);
Mathias Nyman80b0a602012-10-24 17:25:27 +0300230 }
231 if (status == 0) {
232 /* GPIOF_DIR_OUT */
Alexandre Courbotdef63432013-02-15 14:46:15 +0900233 set_bit(FLAG_IS_OUT, &((struct gpio_desc *)desc)->flags);
Mathias Nyman80b0a602012-10-24 17:25:27 +0300234 }
235 return status;
236}
237
David Brownelld8f388d2008-07-25 01:46:07 -0700238#ifdef CONFIG_GPIO_SYSFS
239
240/* lock protects against unexport_gpio() being called while
241 * sysfs files are active.
242 */
243static DEFINE_MUTEX(sysfs_lock);
244
245/*
246 * /sys/class/gpio/gpioN... only for GPIOs that are exported
247 * /direction
248 * * MAY BE OMITTED if kernel won't allow direction changes
249 * * is read/write as "in" or "out"
250 * * may also be written as "high" or "low", initializing
251 * output value as specified ("out" implies "low")
252 * /value
253 * * always readable, subject to hardware behavior
254 * * may be writable, as zero/nonzero
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700255 * /edge
256 * * configures behavior of poll(2) on /value
257 * * available only if pin can generate IRQs on input
258 * * is read/write as "none", "falling", "rising", or "both"
Jani Nikula07697462009-12-15 16:46:20 -0800259 * /active_low
260 * * configures polarity of /value
261 * * is read/write as zero/nonzero
262 * * also affects existing and subsequent "falling" and "rising"
263 * /edge configuration
David Brownelld8f388d2008-07-25 01:46:07 -0700264 */
265
266static ssize_t gpio_direction_show(struct device *dev,
267 struct device_attribute *attr, char *buf)
268{
Alexandre Courbotdef63432013-02-15 14:46:15 +0900269 const struct gpio_desc *desc = dev_get_drvdata(dev);
David Brownelld8f388d2008-07-25 01:46:07 -0700270 ssize_t status;
271
272 mutex_lock(&sysfs_lock);
273
Alexandre Courbot476171ce2013-02-04 17:42:04 +0900274 if (!test_bit(FLAG_EXPORT, &desc->flags)) {
David Brownelld8f388d2008-07-25 01:46:07 -0700275 status = -EIO;
Alexandre Courbot476171ce2013-02-04 17:42:04 +0900276 } else {
Alexandre Courbot372e7222013-02-03 01:29:29 +0900277 gpiod_get_direction(desc);
David Brownelld8f388d2008-07-25 01:46:07 -0700278 status = sprintf(buf, "%s\n",
279 test_bit(FLAG_IS_OUT, &desc->flags)
280 ? "out" : "in");
Alexandre Courbot476171ce2013-02-04 17:42:04 +0900281 }
David Brownelld8f388d2008-07-25 01:46:07 -0700282
283 mutex_unlock(&sysfs_lock);
284 return status;
285}
286
287static ssize_t gpio_direction_store(struct device *dev,
288 struct device_attribute *attr, const char *buf, size_t size)
289{
Alexandre Courbot372e7222013-02-03 01:29:29 +0900290 struct gpio_desc *desc = dev_get_drvdata(dev);
David Brownelld8f388d2008-07-25 01:46:07 -0700291 ssize_t status;
292
293 mutex_lock(&sysfs_lock);
294
295 if (!test_bit(FLAG_EXPORT, &desc->flags))
296 status = -EIO;
297 else if (sysfs_streq(buf, "high"))
Alexandre Courbot372e7222013-02-03 01:29:29 +0900298 status = gpiod_direction_output(desc, 1);
David Brownelld8f388d2008-07-25 01:46:07 -0700299 else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
Alexandre Courbot372e7222013-02-03 01:29:29 +0900300 status = gpiod_direction_output(desc, 0);
David Brownelld8f388d2008-07-25 01:46:07 -0700301 else if (sysfs_streq(buf, "in"))
Alexandre Courbot372e7222013-02-03 01:29:29 +0900302 status = gpiod_direction_input(desc);
David Brownelld8f388d2008-07-25 01:46:07 -0700303 else
304 status = -EINVAL;
305
306 mutex_unlock(&sysfs_lock);
307 return status ? : size;
308}
309
Jani Nikula07697462009-12-15 16:46:20 -0800310static /* const */ DEVICE_ATTR(direction, 0644,
David Brownelld8f388d2008-07-25 01:46:07 -0700311 gpio_direction_show, gpio_direction_store);
312
313static ssize_t gpio_value_show(struct device *dev,
314 struct device_attribute *attr, char *buf)
315{
Alexandre Courbot372e7222013-02-03 01:29:29 +0900316 struct gpio_desc *desc = dev_get_drvdata(dev);
David Brownelld8f388d2008-07-25 01:46:07 -0700317 ssize_t status;
318
319 mutex_lock(&sysfs_lock);
320
Jani Nikula07697462009-12-15 16:46:20 -0800321 if (!test_bit(FLAG_EXPORT, &desc->flags)) {
David Brownelld8f388d2008-07-25 01:46:07 -0700322 status = -EIO;
Jani Nikula07697462009-12-15 16:46:20 -0800323 } else {
324 int value;
325
Alexandre Courbot372e7222013-02-03 01:29:29 +0900326 value = !!gpiod_get_value_cansleep(desc);
Jani Nikula07697462009-12-15 16:46:20 -0800327 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
328 value = !value;
329
330 status = sprintf(buf, "%d\n", value);
331 }
David Brownelld8f388d2008-07-25 01:46:07 -0700332
333 mutex_unlock(&sysfs_lock);
334 return status;
335}
336
337static ssize_t gpio_value_store(struct device *dev,
338 struct device_attribute *attr, const char *buf, size_t size)
339{
Alexandre Courbot372e7222013-02-03 01:29:29 +0900340 struct gpio_desc *desc = dev_get_drvdata(dev);
David Brownelld8f388d2008-07-25 01:46:07 -0700341 ssize_t status;
342
343 mutex_lock(&sysfs_lock);
344
345 if (!test_bit(FLAG_EXPORT, &desc->flags))
346 status = -EIO;
347 else if (!test_bit(FLAG_IS_OUT, &desc->flags))
348 status = -EPERM;
349 else {
350 long value;
351
Jingoo Hana3d88c92013-07-19 16:12:50 +0900352 status = kstrtol(buf, 0, &value);
David Brownelld8f388d2008-07-25 01:46:07 -0700353 if (status == 0) {
Jani Nikula07697462009-12-15 16:46:20 -0800354 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
355 value = !value;
Alexandre Courbot372e7222013-02-03 01:29:29 +0900356 gpiod_set_value_cansleep(desc, value != 0);
David Brownelld8f388d2008-07-25 01:46:07 -0700357 status = size;
358 }
359 }
360
361 mutex_unlock(&sysfs_lock);
362 return status;
363}
364
Jani Nikula07697462009-12-15 16:46:20 -0800365static const DEVICE_ATTR(value, 0644,
David Brownelld8f388d2008-07-25 01:46:07 -0700366 gpio_value_show, gpio_value_store);
367
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700368static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
369{
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700370 struct sysfs_dirent *value_sd = priv;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700371
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700372 sysfs_notify_dirent(value_sd);
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700373 return IRQ_HANDLED;
374}
375
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700376static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
377 unsigned long gpio_flags)
378{
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700379 struct sysfs_dirent *value_sd;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700380 unsigned long irq_flags;
381 int ret, irq, id;
382
383 if ((desc->flags & GPIO_TRIGGER_MASK) == gpio_flags)
384 return 0;
385
Alexandre Courbot372e7222013-02-03 01:29:29 +0900386 irq = gpiod_to_irq(desc);
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700387 if (irq < 0)
388 return -EIO;
389
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700390 id = desc->flags >> ID_SHIFT;
391 value_sd = idr_find(&dirent_idr, id);
392 if (value_sd)
393 free_irq(irq, value_sd);
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700394
395 desc->flags &= ~GPIO_TRIGGER_MASK;
396
397 if (!gpio_flags) {
398 ret = 0;
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700399 goto free_id;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700400 }
401
402 irq_flags = IRQF_SHARED;
403 if (test_bit(FLAG_TRIG_FALL, &gpio_flags))
Jani Nikula07697462009-12-15 16:46:20 -0800404 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
405 IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700406 if (test_bit(FLAG_TRIG_RISE, &gpio_flags))
Jani Nikula07697462009-12-15 16:46:20 -0800407 irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
408 IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700409
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700410 if (!value_sd) {
411 value_sd = sysfs_get_dirent(dev->kobj.sd, NULL, "value");
412 if (!value_sd) {
413 ret = -ENODEV;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700414 goto err_out;
415 }
416
Tejun Heo62f516b2013-02-27 17:04:06 -0800417 ret = idr_alloc(&dirent_idr, value_sd, 1, 0, GFP_KERNEL);
418 if (ret < 0)
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700419 goto free_sd;
Tejun Heo62f516b2013-02-27 17:04:06 -0800420 id = ret;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700421
422 desc->flags &= GPIO_FLAGS_MASK;
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700423 desc->flags |= (unsigned long)id << ID_SHIFT;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700424
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700425 if (desc->flags >> ID_SHIFT != id) {
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700426 ret = -ERANGE;
427 goto free_id;
428 }
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700429 }
430
Daniel Gl?ckner364fadb32010-08-10 18:02:26 -0700431 ret = request_any_context_irq(irq, gpio_sysfs_irq, irq_flags,
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700432 "gpiolib", value_sd);
Daniel Gl?ckner364fadb32010-08-10 18:02:26 -0700433 if (ret < 0)
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700434 goto free_id;
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700435
436 desc->flags |= gpio_flags;
437 return 0;
438
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700439free_id:
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700440 idr_remove(&dirent_idr, id);
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700441 desc->flags &= GPIO_FLAGS_MASK;
Daniel Gl?ckner5ba18212010-08-10 18:02:25 -0700442free_sd:
443 if (value_sd)
444 sysfs_put(value_sd);
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700445err_out:
446 return ret;
447}
448
449static const struct {
450 const char *name;
451 unsigned long flags;
452} trigger_types[] = {
453 { "none", 0 },
454 { "falling", BIT(FLAG_TRIG_FALL) },
455 { "rising", BIT(FLAG_TRIG_RISE) },
456 { "both", BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE) },
457};
458
459static ssize_t gpio_edge_show(struct device *dev,
460 struct device_attribute *attr, char *buf)
461{
462 const struct gpio_desc *desc = dev_get_drvdata(dev);
463 ssize_t status;
464
465 mutex_lock(&sysfs_lock);
466
467 if (!test_bit(FLAG_EXPORT, &desc->flags))
468 status = -EIO;
469 else {
470 int i;
471
472 status = 0;
473 for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
474 if ((desc->flags & GPIO_TRIGGER_MASK)
475 == trigger_types[i].flags) {
476 status = sprintf(buf, "%s\n",
477 trigger_types[i].name);
478 break;
479 }
480 }
481
482 mutex_unlock(&sysfs_lock);
483 return status;
484}
485
486static ssize_t gpio_edge_store(struct device *dev,
487 struct device_attribute *attr, const char *buf, size_t size)
488{
489 struct gpio_desc *desc = dev_get_drvdata(dev);
490 ssize_t status;
491 int i;
492
493 for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
494 if (sysfs_streq(trigger_types[i].name, buf))
495 goto found;
496 return -EINVAL;
497
498found:
499 mutex_lock(&sysfs_lock);
500
501 if (!test_bit(FLAG_EXPORT, &desc->flags))
502 status = -EIO;
503 else {
504 status = gpio_setup_irq(desc, dev, trigger_types[i].flags);
505 if (!status)
506 status = size;
507 }
508
509 mutex_unlock(&sysfs_lock);
510
511 return status;
512}
513
514static DEVICE_ATTR(edge, 0644, gpio_edge_show, gpio_edge_store);
515
Jani Nikula07697462009-12-15 16:46:20 -0800516static int sysfs_set_active_low(struct gpio_desc *desc, struct device *dev,
517 int value)
518{
519 int status = 0;
520
521 if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
522 return 0;
523
524 if (value)
525 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
526 else
527 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
528
529 /* reconfigure poll(2) support if enabled on one edge only */
530 if (dev != NULL && (!!test_bit(FLAG_TRIG_RISE, &desc->flags) ^
531 !!test_bit(FLAG_TRIG_FALL, &desc->flags))) {
532 unsigned long trigger_flags = desc->flags & GPIO_TRIGGER_MASK;
533
534 gpio_setup_irq(desc, dev, 0);
535 status = gpio_setup_irq(desc, dev, trigger_flags);
536 }
537
538 return status;
539}
540
541static ssize_t gpio_active_low_show(struct device *dev,
542 struct device_attribute *attr, char *buf)
543{
544 const struct gpio_desc *desc = dev_get_drvdata(dev);
545 ssize_t status;
546
547 mutex_lock(&sysfs_lock);
548
549 if (!test_bit(FLAG_EXPORT, &desc->flags))
550 status = -EIO;
551 else
552 status = sprintf(buf, "%d\n",
553 !!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
554
555 mutex_unlock(&sysfs_lock);
556
557 return status;
558}
559
560static ssize_t gpio_active_low_store(struct device *dev,
561 struct device_attribute *attr, const char *buf, size_t size)
562{
563 struct gpio_desc *desc = dev_get_drvdata(dev);
564 ssize_t status;
565
566 mutex_lock(&sysfs_lock);
567
568 if (!test_bit(FLAG_EXPORT, &desc->flags)) {
569 status = -EIO;
570 } else {
571 long value;
572
Jingoo Hana3d88c92013-07-19 16:12:50 +0900573 status = kstrtol(buf, 0, &value);
Jani Nikula07697462009-12-15 16:46:20 -0800574 if (status == 0)
575 status = sysfs_set_active_low(desc, dev, value != 0);
576 }
577
578 mutex_unlock(&sysfs_lock);
579
580 return status ? : size;
581}
582
583static const DEVICE_ATTR(active_low, 0644,
584 gpio_active_low_show, gpio_active_low_store);
585
David Brownelld8f388d2008-07-25 01:46:07 -0700586static const struct attribute *gpio_attrs[] = {
David Brownelld8f388d2008-07-25 01:46:07 -0700587 &dev_attr_value.attr,
Jani Nikula07697462009-12-15 16:46:20 -0800588 &dev_attr_active_low.attr,
David Brownelld8f388d2008-07-25 01:46:07 -0700589 NULL,
590};
591
592static const struct attribute_group gpio_attr_group = {
593 .attrs = (struct attribute **) gpio_attrs,
594};
595
596/*
597 * /sys/class/gpio/gpiochipN/
598 * /base ... matching gpio_chip.base (N)
599 * /label ... matching gpio_chip.label
600 * /ngpio ... matching gpio_chip.ngpio
601 */
602
603static ssize_t chip_base_show(struct device *dev,
604 struct device_attribute *attr, char *buf)
605{
606 const struct gpio_chip *chip = dev_get_drvdata(dev);
607
608 return sprintf(buf, "%d\n", chip->base);
609}
610static DEVICE_ATTR(base, 0444, chip_base_show, NULL);
611
612static ssize_t chip_label_show(struct device *dev,
613 struct device_attribute *attr, char *buf)
614{
615 const struct gpio_chip *chip = dev_get_drvdata(dev);
616
617 return sprintf(buf, "%s\n", chip->label ? : "");
618}
619static DEVICE_ATTR(label, 0444, chip_label_show, NULL);
620
621static ssize_t chip_ngpio_show(struct device *dev,
622 struct device_attribute *attr, char *buf)
623{
624 const struct gpio_chip *chip = dev_get_drvdata(dev);
625
626 return sprintf(buf, "%u\n", chip->ngpio);
627}
628static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
629
630static const struct attribute *gpiochip_attrs[] = {
631 &dev_attr_base.attr,
632 &dev_attr_label.attr,
633 &dev_attr_ngpio.attr,
634 NULL,
635};
636
637static const struct attribute_group gpiochip_attr_group = {
638 .attrs = (struct attribute **) gpiochip_attrs,
639};
640
641/*
642 * /sys/class/gpio/export ... write-only
643 * integer N ... number of GPIO to export (full access)
644 * /sys/class/gpio/unexport ... write-only
645 * integer N ... number of GPIO to unexport
646 */
Andi Kleen28812fe2010-01-05 12:48:07 +0100647static ssize_t export_store(struct class *class,
648 struct class_attribute *attr,
649 const char *buf, size_t len)
David Brownelld8f388d2008-07-25 01:46:07 -0700650{
Alexandre Courbot372e7222013-02-03 01:29:29 +0900651 long gpio;
652 struct gpio_desc *desc;
653 int status;
David Brownelld8f388d2008-07-25 01:46:07 -0700654
Jingoo Hana3d88c92013-07-19 16:12:50 +0900655 status = kstrtol(buf, 0, &gpio);
David Brownelld8f388d2008-07-25 01:46:07 -0700656 if (status < 0)
657 goto done;
658
Alexandre Courbot372e7222013-02-03 01:29:29 +0900659 desc = gpio_to_desc(gpio);
Alexandre Courbotbcabdef2013-02-15 14:46:14 +0900660 /* reject invalid GPIOs */
661 if (!desc) {
662 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
663 return -EINVAL;
664 }
Alexandre Courbot372e7222013-02-03 01:29:29 +0900665
David Brownelld8f388d2008-07-25 01:46:07 -0700666 /* No extra locking here; FLAG_SYSFS just signifies that the
667 * request and export were done by on behalf of userspace, so
668 * they may be undone on its behalf too.
669 */
670
Alexandre Courbot372e7222013-02-03 01:29:29 +0900671 status = gpiod_request(desc, "sysfs");
Mathias Nymanad2fab32012-10-25 14:03:03 +0300672 if (status < 0) {
673 if (status == -EPROBE_DEFER)
674 status = -ENODEV;
David Brownelld8f388d2008-07-25 01:46:07 -0700675 goto done;
Mathias Nymanad2fab32012-10-25 14:03:03 +0300676 }
Alexandre Courbot372e7222013-02-03 01:29:29 +0900677 status = gpiod_export(desc, true);
David Brownelld8f388d2008-07-25 01:46:07 -0700678 if (status < 0)
Alexandre Courbot372e7222013-02-03 01:29:29 +0900679 gpiod_free(desc);
David Brownelld8f388d2008-07-25 01:46:07 -0700680 else
Alexandre Courbot372e7222013-02-03 01:29:29 +0900681 set_bit(FLAG_SYSFS, &desc->flags);
David Brownelld8f388d2008-07-25 01:46:07 -0700682
683done:
684 if (status)
685 pr_debug("%s: status %d\n", __func__, status);
686 return status ? : len;
687}
688
Andi Kleen28812fe2010-01-05 12:48:07 +0100689static ssize_t unexport_store(struct class *class,
690 struct class_attribute *attr,
691 const char *buf, size_t len)
David Brownelld8f388d2008-07-25 01:46:07 -0700692{
Alexandre Courbot372e7222013-02-03 01:29:29 +0900693 long gpio;
694 struct gpio_desc *desc;
695 int status;
David Brownelld8f388d2008-07-25 01:46:07 -0700696
Jingoo Hana3d88c92013-07-19 16:12:50 +0900697 status = kstrtol(buf, 0, &gpio);
David Brownelld8f388d2008-07-25 01:46:07 -0700698 if (status < 0)
699 goto done;
700
Alexandre Courbot372e7222013-02-03 01:29:29 +0900701 desc = gpio_to_desc(gpio);
David Brownelld8f388d2008-07-25 01:46:07 -0700702 /* reject bogus commands (gpio_unexport ignores them) */
Alexandre Courbotbcabdef2013-02-15 14:46:14 +0900703 if (!desc) {
704 pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
705 return -EINVAL;
706 }
707
708 status = -EINVAL;
David Brownelld8f388d2008-07-25 01:46:07 -0700709
710 /* No extra locking here; FLAG_SYSFS just signifies that the
711 * request and export were done by on behalf of userspace, so
712 * they may be undone on its behalf too.
713 */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900714 if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
David Brownelld8f388d2008-07-25 01:46:07 -0700715 status = 0;
Alexandre Courbot372e7222013-02-03 01:29:29 +0900716 gpiod_free(desc);
David Brownelld8f388d2008-07-25 01:46:07 -0700717 }
718done:
719 if (status)
720 pr_debug("%s: status %d\n", __func__, status);
721 return status ? : len;
722}
723
724static struct class_attribute gpio_class_attrs[] = {
725 __ATTR(export, 0200, NULL, export_store),
726 __ATTR(unexport, 0200, NULL, unexport_store),
727 __ATTR_NULL,
728};
729
730static struct class gpio_class = {
731 .name = "gpio",
732 .owner = THIS_MODULE,
733
734 .class_attrs = gpio_class_attrs,
735};
736
737
738/**
739 * gpio_export - export a GPIO through sysfs
740 * @gpio: gpio to make available, already requested
741 * @direction_may_change: true if userspace may change gpio direction
742 * Context: arch_initcall or later
743 *
744 * When drivers want to make a GPIO accessible to userspace after they
745 * have requested it -- perhaps while debugging, or as part of their
746 * public interface -- they may use this routine. If the GPIO can
747 * change direction (some can't) and the caller allows it, userspace
748 * will see "direction" sysfs attribute which may be used to change
749 * the gpio's direction. A "value" attribute will always be provided.
750 *
751 * Returns zero on success, else an error.
752 */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900753static int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
David Brownelld8f388d2008-07-25 01:46:07 -0700754{
755 unsigned long flags;
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100756 int status;
Uwe Kleine-König62154992010-05-26 14:42:17 -0700757 const char *ioname = NULL;
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100758 struct device *dev;
Alexandre Courbot372e7222013-02-03 01:29:29 +0900759 int offset;
David Brownelld8f388d2008-07-25 01:46:07 -0700760
761 /* can't export until sysfs is available ... */
762 if (!gpio_class.p) {
763 pr_debug("%s: called too early!\n", __func__);
764 return -ENOENT;
765 }
766
Alexandre Courbot372e7222013-02-03 01:29:29 +0900767 if (!desc) {
768 pr_debug("%s: invalid gpio descriptor\n", __func__);
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100769 return -EINVAL;
770 }
David Brownelld8f388d2008-07-25 01:46:07 -0700771
772 mutex_lock(&sysfs_lock);
773
774 spin_lock_irqsave(&gpio_lock, flags);
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100775 if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
776 test_bit(FLAG_EXPORT, &desc->flags)) {
777 spin_unlock_irqrestore(&gpio_lock, flags);
778 pr_debug("%s: gpio %d unavailable (requested=%d, exported=%d)\n",
Alexandre Courbot372e7222013-02-03 01:29:29 +0900779 __func__, desc_to_gpio(desc),
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100780 test_bit(FLAG_REQUESTED, &desc->flags),
781 test_bit(FLAG_EXPORT, &desc->flags));
Dan Carpenter529f2ad2012-10-26 09:59:43 +0300782 status = -EPERM;
783 goto fail_unlock;
David Brownelld8f388d2008-07-25 01:46:07 -0700784 }
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100785
786 if (!desc->chip->direction_input || !desc->chip->direction_output)
787 direction_may_change = false;
David Brownelld8f388d2008-07-25 01:46:07 -0700788 spin_unlock_irqrestore(&gpio_lock, flags);
789
Alexandre Courbot372e7222013-02-03 01:29:29 +0900790 offset = gpio_chip_hwgpio(desc);
791 if (desc->chip->names && desc->chip->names[offset])
792 ioname = desc->chip->names[offset];
Daniel Silverstone926b6632009-04-02 16:57:05 -0700793
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100794 dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
Alexandre Courbot372e7222013-02-03 01:29:29 +0900795 desc, ioname ? ioname : "gpio%u",
796 desc_to_gpio(desc));
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100797 if (IS_ERR(dev)) {
798 status = PTR_ERR(dev);
799 goto fail_unlock;
David Brownelld8f388d2008-07-25 01:46:07 -0700800 }
801
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100802 status = sysfs_create_group(&dev->kobj, &gpio_attr_group);
David Brownelld8f388d2008-07-25 01:46:07 -0700803 if (status)
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100804 goto fail_unregister_device;
David Brownelld8f388d2008-07-25 01:46:07 -0700805
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100806 if (direction_may_change) {
807 status = device_create_file(dev, &dev_attr_direction);
808 if (status)
809 goto fail_unregister_device;
810 }
811
Alexandre Courbot372e7222013-02-03 01:29:29 +0900812 if (gpiod_to_irq(desc) >= 0 && (direction_may_change ||
Ryan Mallonfc4e2512012-10-22 11:39:12 +1100813 !test_bit(FLAG_IS_OUT, &desc->flags))) {
814 status = device_create_file(dev, &dev_attr_edge);
815 if (status)
816 goto fail_unregister_device;
817 }
818
819 set_bit(FLAG_EXPORT, &desc->flags);
820 mutex_unlock(&sysfs_lock);
821 return 0;
822
823fail_unregister_device:
824 device_unregister(dev);
825fail_unlock:
826 mutex_unlock(&sysfs_lock);
Alexandre Courbot372e7222013-02-03 01:29:29 +0900827 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
828 status);
David Brownelld8f388d2008-07-25 01:46:07 -0700829 return status;
830}
Alexandre Courbot372e7222013-02-03 01:29:29 +0900831
832int gpio_export(unsigned gpio, bool direction_may_change)
833{
834 return gpiod_export(gpio_to_desc(gpio), direction_may_change);
835}
David Brownelld8f388d2008-07-25 01:46:07 -0700836EXPORT_SYMBOL_GPL(gpio_export);
837
Michał Mirosław9f3b7952013-02-01 20:40:17 +0100838static int match_export(struct device *dev, const void *data)
David Brownelld8f388d2008-07-25 01:46:07 -0700839{
840 return dev_get_drvdata(dev) == data;
841}
842
843/**
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700844 * gpio_export_link - create a sysfs link to an exported GPIO node
845 * @dev: device under which to create symlink
846 * @name: name of the symlink
847 * @gpio: gpio to create symlink to, already exported
848 *
849 * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
850 * node. Caller is responsible for unlinking.
851 *
852 * Returns zero on success, else an error.
853 */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900854static int gpiod_export_link(struct device *dev, const char *name,
855 struct gpio_desc *desc)
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700856{
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700857 int status = -EINVAL;
858
Alexandre Courbotbcabdef2013-02-15 14:46:14 +0900859 if (!desc) {
860 pr_warn("%s: invalid GPIO\n", __func__);
861 return -EINVAL;
862 }
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700863
864 mutex_lock(&sysfs_lock);
865
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700866 if (test_bit(FLAG_EXPORT, &desc->flags)) {
867 struct device *tdev;
868
869 tdev = class_find_device(&gpio_class, NULL, desc, match_export);
870 if (tdev != NULL) {
871 status = sysfs_create_link(&dev->kobj, &tdev->kobj,
872 name);
873 } else {
874 status = -ENODEV;
875 }
876 }
877
878 mutex_unlock(&sysfs_lock);
879
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700880 if (status)
Alexandre Courbot372e7222013-02-03 01:29:29 +0900881 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
882 status);
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700883
884 return status;
885}
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700886
Alexandre Courbot372e7222013-02-03 01:29:29 +0900887int gpio_export_link(struct device *dev, const char *name, unsigned gpio)
888{
889 return gpiod_export_link(dev, name, gpio_to_desc(gpio));
890}
891EXPORT_SYMBOL_GPL(gpio_export_link);
Jani Nikula07697462009-12-15 16:46:20 -0800892
893/**
894 * gpio_sysfs_set_active_low - set the polarity of gpio sysfs value
895 * @gpio: gpio to change
896 * @value: non-zero to use active low, i.e. inverted values
897 *
898 * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
899 * The GPIO does not have to be exported yet. If poll(2) support has
900 * been enabled for either rising or falling edge, it will be
901 * reconfigured to follow the new polarity.
902 *
903 * Returns zero on success, else an error.
904 */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900905static int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
Jani Nikula07697462009-12-15 16:46:20 -0800906{
Jani Nikula07697462009-12-15 16:46:20 -0800907 struct device *dev = NULL;
908 int status = -EINVAL;
909
Alexandre Courbotbcabdef2013-02-15 14:46:14 +0900910 if (!desc) {
911 pr_warn("%s: invalid GPIO\n", __func__);
912 return -EINVAL;
913 }
Jani Nikula07697462009-12-15 16:46:20 -0800914
915 mutex_lock(&sysfs_lock);
916
Jani Nikula07697462009-12-15 16:46:20 -0800917 if (test_bit(FLAG_EXPORT, &desc->flags)) {
Jani Nikula07697462009-12-15 16:46:20 -0800918 dev = class_find_device(&gpio_class, NULL, desc, match_export);
919 if (dev == NULL) {
920 status = -ENODEV;
921 goto unlock;
922 }
923 }
924
925 status = sysfs_set_active_low(desc, dev, value);
926
927unlock:
928 mutex_unlock(&sysfs_lock);
929
Jani Nikula07697462009-12-15 16:46:20 -0800930 if (status)
Alexandre Courbot372e7222013-02-03 01:29:29 +0900931 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
932 status);
Jani Nikula07697462009-12-15 16:46:20 -0800933
934 return status;
935}
Alexandre Courbot372e7222013-02-03 01:29:29 +0900936
937int gpio_sysfs_set_active_low(unsigned gpio, int value)
938{
939 return gpiod_sysfs_set_active_low(gpio_to_desc(gpio), value);
940}
Jani Nikula07697462009-12-15 16:46:20 -0800941EXPORT_SYMBOL_GPL(gpio_sysfs_set_active_low);
942
Jani Nikulaa4177ee2009-09-22 16:46:33 -0700943/**
David Brownelld8f388d2008-07-25 01:46:07 -0700944 * gpio_unexport - reverse effect of gpio_export()
945 * @gpio: gpio to make unavailable
946 *
947 * This is implicit on gpio_free().
948 */
Alexandre Courbot372e7222013-02-03 01:29:29 +0900949static void gpiod_unexport(struct gpio_desc *desc)
David Brownelld8f388d2008-07-25 01:46:07 -0700950{
Jon Povey6a99ad42010-07-27 13:18:06 -0700951 int status = 0;
Ming Lei864533c2012-02-13 22:53:20 +0800952 struct device *dev = NULL;
David Brownelld8f388d2008-07-25 01:46:07 -0700953
Alexandre Courbot372e7222013-02-03 01:29:29 +0900954 if (!desc) {
Alexandre Courbotbcabdef2013-02-15 14:46:14 +0900955 pr_warn("%s: invalid GPIO\n", __func__);
956 return;
Jon Povey6a99ad42010-07-27 13:18:06 -0700957 }
David Brownelld8f388d2008-07-25 01:46:07 -0700958
959 mutex_lock(&sysfs_lock);
960
David Brownelld8f388d2008-07-25 01:46:07 -0700961 if (test_bit(FLAG_EXPORT, &desc->flags)) {
David Brownelld8f388d2008-07-25 01:46:07 -0700962
963 dev = class_find_device(&gpio_class, NULL, desc, match_export);
964 if (dev) {
Daniel Glöcknerff77c352009-09-22 16:46:38 -0700965 gpio_setup_irq(desc, dev, 0);
David Brownelld8f388d2008-07-25 01:46:07 -0700966 clear_bit(FLAG_EXPORT, &desc->flags);
David Brownelld8f388d2008-07-25 01:46:07 -0700967 } else
968 status = -ENODEV;
969 }
970
971 mutex_unlock(&sysfs_lock);
Alexandre Courbot372e7222013-02-03 01:29:29 +0900972
Ming Lei864533c2012-02-13 22:53:20 +0800973 if (dev) {
974 device_unregister(dev);
975 put_device(dev);
976 }
Alexandre Courbotbcabdef2013-02-15 14:46:14 +0900977
David Brownelld8f388d2008-07-25 01:46:07 -0700978 if (status)
Alexandre Courbot372e7222013-02-03 01:29:29 +0900979 pr_debug("%s: gpio%d status %d\n", __func__, desc_to_gpio(desc),
980 status);
981}
982
983void gpio_unexport(unsigned gpio)
984{
985 gpiod_unexport(gpio_to_desc(gpio));
David Brownelld8f388d2008-07-25 01:46:07 -0700986}
987EXPORT_SYMBOL_GPL(gpio_unexport);
988
989static int gpiochip_export(struct gpio_chip *chip)
990{
991 int status;
992 struct device *dev;
993
994 /* Many systems register gpio chips for SOC support very early,
995 * before driver model support is available. In those cases we
996 * export this later, in gpiolib_sysfs_init() ... here we just
997 * verify that _some_ field of gpio_class got initialized.
998 */
999 if (!gpio_class.p)
1000 return 0;
1001
1002 /* use chip->base for the ID; it's already known to be unique */
1003 mutex_lock(&sysfs_lock);
1004 dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
1005 "gpiochip%d", chip->base);
Sergei Shtylyovd62668e2009-11-11 14:26:50 -08001006 if (!IS_ERR(dev)) {
David Brownelld8f388d2008-07-25 01:46:07 -07001007 status = sysfs_create_group(&dev->kobj,
1008 &gpiochip_attr_group);
1009 } else
Sergei Shtylyovd62668e2009-11-11 14:26:50 -08001010 status = PTR_ERR(dev);
David Brownelld8f388d2008-07-25 01:46:07 -07001011 chip->exported = (status == 0);
1012 mutex_unlock(&sysfs_lock);
1013
1014 if (status) {
1015 unsigned long flags;
1016 unsigned gpio;
1017
1018 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001019 gpio = 0;
1020 while (gpio < chip->ngpio)
1021 chip->desc[gpio++].chip = NULL;
David Brownelld8f388d2008-07-25 01:46:07 -07001022 spin_unlock_irqrestore(&gpio_lock, flags);
1023
1024 pr_debug("%s: chip %s status %d\n", __func__,
1025 chip->label, status);
1026 }
1027
1028 return status;
1029}
1030
1031static void gpiochip_unexport(struct gpio_chip *chip)
1032{
1033 int status;
1034 struct device *dev;
1035
1036 mutex_lock(&sysfs_lock);
1037 dev = class_find_device(&gpio_class, NULL, chip, match_export);
1038 if (dev) {
1039 put_device(dev);
1040 device_unregister(dev);
1041 chip->exported = 0;
1042 status = 0;
1043 } else
1044 status = -ENODEV;
1045 mutex_unlock(&sysfs_lock);
1046
1047 if (status)
1048 pr_debug("%s: chip %s status %d\n", __func__,
1049 chip->label, status);
1050}
1051
1052static int __init gpiolib_sysfs_init(void)
1053{
1054 int status;
1055 unsigned long flags;
Alexandre Courbot65493e32013-02-03 01:29:25 +09001056 struct gpio_chip *chip;
David Brownelld8f388d2008-07-25 01:46:07 -07001057
1058 status = class_register(&gpio_class);
1059 if (status < 0)
1060 return status;
1061
1062 /* Scan and register the gpio_chips which registered very
1063 * early (e.g. before the class_register above was called).
1064 *
1065 * We run before arch_initcall() so chip->dev nodes can have
1066 * registered, and so arch_initcall() can always gpio_export().
1067 */
1068 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbot65493e32013-02-03 01:29:25 +09001069 list_for_each_entry(chip, &gpio_chips, list) {
David Brownelld8f388d2008-07-25 01:46:07 -07001070 if (!chip || chip->exported)
1071 continue;
1072
1073 spin_unlock_irqrestore(&gpio_lock, flags);
1074 status = gpiochip_export(chip);
1075 spin_lock_irqsave(&gpio_lock, flags);
1076 }
1077 spin_unlock_irqrestore(&gpio_lock, flags);
1078
1079
1080 return status;
1081}
1082postcore_initcall(gpiolib_sysfs_init);
1083
1084#else
1085static inline int gpiochip_export(struct gpio_chip *chip)
1086{
1087 return 0;
1088}
1089
1090static inline void gpiochip_unexport(struct gpio_chip *chip)
1091{
1092}
1093
Alexandre Courbot372e7222013-02-03 01:29:29 +09001094static inline int gpiod_export(struct gpio_desc *desc,
1095 bool direction_may_change)
1096{
1097 return -ENOSYS;
1098}
1099
1100static inline int gpiod_export_link(struct device *dev, const char *name,
1101 struct gpio_desc *desc)
1102{
1103 return -ENOSYS;
1104}
1105
1106static inline int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
1107{
1108 return -ENOSYS;
1109}
1110
1111static inline void gpiod_unexport(struct gpio_desc *desc)
1112{
1113}
1114
David Brownelld8f388d2008-07-25 01:46:07 -07001115#endif /* CONFIG_GPIO_SYSFS */
1116
Alexandre Courbot1a989d02013-02-03 01:29:24 +09001117/*
1118 * Add a new chip to the global chips list, keeping the list of chips sorted
1119 * by base order.
1120 *
1121 * Return -EBUSY if the new chip overlaps with some other chip's integer
1122 * space.
1123 */
1124static int gpiochip_add_to_list(struct gpio_chip *chip)
1125{
1126 struct list_head *pos = &gpio_chips;
1127 struct gpio_chip *_chip;
1128 int err = 0;
1129
1130 /* find where to insert our chip */
1131 list_for_each(pos, &gpio_chips) {
1132 _chip = list_entry(pos, struct gpio_chip, list);
1133 /* shall we insert before _chip? */
1134 if (_chip->base >= chip->base + chip->ngpio)
1135 break;
1136 }
1137
1138 /* are we stepping on the chip right before? */
1139 if (pos != &gpio_chips && pos->prev != &gpio_chips) {
1140 _chip = list_entry(pos->prev, struct gpio_chip, list);
1141 if (_chip->base + _chip->ngpio > chip->base) {
1142 dev_err(chip->dev,
1143 "GPIO integer space overlap, cannot add chip\n");
1144 err = -EBUSY;
1145 }
1146 }
1147
1148 if (!err)
1149 list_add_tail(&chip->list, pos);
1150
1151 return err;
1152}
1153
Anton Vorontsov169b6a72008-04-28 02:14:47 -07001154/**
David Brownelld2876d02008-02-04 22:28:20 -08001155 * gpiochip_add() - register a gpio_chip
1156 * @chip: the chip to register, with chip->base initialized
1157 * Context: potentially before irqs or kmalloc will work
1158 *
1159 * Returns a negative errno if the chip can't be registered, such as
1160 * because the chip->base is invalid or already associated with a
1161 * different chip. Otherwise it returns zero as a success code.
Anton Vorontsov8d0aab22008-04-28 02:14:46 -07001162 *
David Brownelld8f388d2008-07-25 01:46:07 -07001163 * When gpiochip_add() is called very early during boot, so that GPIOs
1164 * can be freely used, the chip->dev device must be registered before
1165 * the gpio framework's arch_initcall(). Otherwise sysfs initialization
1166 * for GPIOs will fail rudely.
1167 *
Anton Vorontsov8d0aab22008-04-28 02:14:46 -07001168 * If chip->base is negative, this requests dynamic assignment of
1169 * a range of valid GPIOs.
David Brownelld2876d02008-02-04 22:28:20 -08001170 */
1171int gpiochip_add(struct gpio_chip *chip)
1172{
1173 unsigned long flags;
1174 int status = 0;
1175 unsigned id;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -07001176 int base = chip->base;
David Brownelld2876d02008-02-04 22:28:20 -08001177
Trent Piephobff5fda2008-05-23 13:04:44 -07001178 if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
Anton Vorontsov8d0aab22008-04-28 02:14:46 -07001179 && base >= 0) {
David Brownelld2876d02008-02-04 22:28:20 -08001180 status = -EINVAL;
1181 goto fail;
1182 }
1183
1184 spin_lock_irqsave(&gpio_lock, flags);
1185
Anton Vorontsov8d0aab22008-04-28 02:14:46 -07001186 if (base < 0) {
1187 base = gpiochip_find_base(chip->ngpio);
1188 if (base < 0) {
1189 status = base;
David Brownelld8f388d2008-07-25 01:46:07 -07001190 goto unlock;
Anton Vorontsov8d0aab22008-04-28 02:14:46 -07001191 }
1192 chip->base = base;
1193 }
1194
Alexandre Courbot1a989d02013-02-03 01:29:24 +09001195 status = gpiochip_add_to_list(chip);
1196
David Brownelld2876d02008-02-04 22:28:20 -08001197 if (status == 0) {
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001198 chip->desc = &gpio_desc[chip->base];
1199
1200 for (id = 0; id < chip->ngpio; id++) {
1201 struct gpio_desc *desc = &chip->desc[id];
1202 desc->chip = chip;
David Brownelld8f388d2008-07-25 01:46:07 -07001203
1204 /* REVISIT: most hardware initializes GPIOs as
1205 * inputs (often with pullups enabled) so power
1206 * usage is minimized. Linux code should set the
1207 * gpio direction first thing; but until it does,
Mathias Nyman80b0a602012-10-24 17:25:27 +03001208 * and in case chip->get_direction is not set,
David Brownelld8f388d2008-07-25 01:46:07 -07001209 * we may expose the wrong direction in sysfs.
1210 */
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001211 desc->flags = !chip->direction_input
David Brownelld8f388d2008-07-25 01:46:07 -07001212 ? (1 << FLAG_IS_OUT)
1213 : 0;
David Brownelld2876d02008-02-04 22:28:20 -08001214 }
1215 }
1216
Zhangfei Gao3bae4812013-06-09 11:08:32 +08001217 spin_unlock_irqrestore(&gpio_lock, flags);
1218
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301219#ifdef CONFIG_PINCTRL
1220 INIT_LIST_HEAD(&chip->pin_ranges);
1221#endif
1222
Anton Vorontsov391c9702010-06-08 07:48:17 -06001223 of_gpiochip_add(chip);
1224
Anton Vorontsovcedb1882010-06-08 07:48:15 -06001225 if (status)
1226 goto fail;
1227
1228 status = gpiochip_export(chip);
1229 if (status)
1230 goto fail;
1231
H Hartley Sweetenee1c1e72012-05-11 16:58:33 -07001232 pr_debug("gpiochip_add: registered GPIOs %d to %d on device: %s\n",
Grant Likely64842aa2011-11-06 11:36:18 -07001233 chip->base, chip->base + chip->ngpio - 1,
1234 chip->label ? : "generic");
1235
Anton Vorontsovcedb1882010-06-08 07:48:15 -06001236 return 0;
Zhangfei Gao3bae4812013-06-09 11:08:32 +08001237
1238unlock:
1239 spin_unlock_irqrestore(&gpio_lock, flags);
David Brownelld2876d02008-02-04 22:28:20 -08001240fail:
1241 /* failures here can mean systems won't boot... */
Anton Vorontsovcedb1882010-06-08 07:48:15 -06001242 pr_err("gpiochip_add: gpios %d..%d (%s) failed to register\n",
1243 chip->base, chip->base + chip->ngpio - 1,
1244 chip->label ? : "generic");
David Brownelld2876d02008-02-04 22:28:20 -08001245 return status;
1246}
1247EXPORT_SYMBOL_GPL(gpiochip_add);
1248
1249/**
1250 * gpiochip_remove() - unregister a gpio_chip
1251 * @chip: the chip to unregister
1252 *
1253 * A gpio_chip with any GPIOs still requested may not be removed.
1254 */
1255int gpiochip_remove(struct gpio_chip *chip)
1256{
1257 unsigned long flags;
1258 int status = 0;
1259 unsigned id;
1260
1261 spin_lock_irqsave(&gpio_lock, flags);
1262
Linus Walleij9ef0d6f2012-11-06 15:15:44 +01001263 gpiochip_remove_pin_ranges(chip);
Anton Vorontsov391c9702010-06-08 07:48:17 -06001264 of_gpiochip_remove(chip);
1265
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001266 for (id = 0; id < chip->ngpio; id++) {
1267 if (test_bit(FLAG_REQUESTED, &chip->desc[id].flags)) {
David Brownelld2876d02008-02-04 22:28:20 -08001268 status = -EBUSY;
1269 break;
1270 }
1271 }
1272 if (status == 0) {
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001273 for (id = 0; id < chip->ngpio; id++)
1274 chip->desc[id].chip = NULL;
Alexandre Courbot1a989d02013-02-03 01:29:24 +09001275
1276 list_del(&chip->list);
David Brownelld2876d02008-02-04 22:28:20 -08001277 }
1278
1279 spin_unlock_irqrestore(&gpio_lock, flags);
David Brownelld8f388d2008-07-25 01:46:07 -07001280
1281 if (status == 0)
1282 gpiochip_unexport(chip);
1283
David Brownelld2876d02008-02-04 22:28:20 -08001284 return status;
1285}
1286EXPORT_SYMBOL_GPL(gpiochip_remove);
1287
Grant Likely594fa262010-06-08 07:48:16 -06001288/**
1289 * gpiochip_find() - iterator for locating a specific gpio_chip
1290 * @data: data to pass to match function
1291 * @callback: Callback function to check gpio_chip
1292 *
1293 * Similar to bus_find_device. It returns a reference to a gpio_chip as
1294 * determined by a user supplied @match callback. The callback should return
1295 * 0 if the device doesn't match and non-zero if it does. If the callback is
1296 * non-zero, this function will return to the caller and not iterate over any
1297 * more gpio_chips.
1298 */
Grant Likely07ce8ec2012-05-18 23:01:05 -06001299struct gpio_chip *gpiochip_find(void *data,
Grant Likely6e2cf652012-03-02 15:56:03 -07001300 int (*match)(struct gpio_chip *chip,
Grant Likely3d0f7cf2012-05-17 13:54:40 -06001301 void *data))
Grant Likely594fa262010-06-08 07:48:16 -06001302{
Alexandre Courbot125eef92013-02-03 01:29:26 +09001303 struct gpio_chip *chip;
Grant Likely594fa262010-06-08 07:48:16 -06001304 unsigned long flags;
Grant Likely594fa262010-06-08 07:48:16 -06001305
1306 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbot125eef92013-02-03 01:29:26 +09001307 list_for_each_entry(chip, &gpio_chips, list)
1308 if (match(chip, data))
Grant Likely594fa262010-06-08 07:48:16 -06001309 break;
Alexandre Courbot125eef92013-02-03 01:29:26 +09001310
1311 /* No match? */
1312 if (&chip->list == &gpio_chips)
1313 chip = NULL;
Grant Likely594fa262010-06-08 07:48:16 -06001314 spin_unlock_irqrestore(&gpio_lock, flags);
1315
1316 return chip;
1317}
Jean Delvare8fa0c9b2011-05-20 00:40:18 -06001318EXPORT_SYMBOL_GPL(gpiochip_find);
David Brownelld2876d02008-02-04 22:28:20 -08001319
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301320#ifdef CONFIG_PINCTRL
Linus Walleij165adc92012-11-06 14:49:39 +01001321
Linus Walleij3f0f8672012-11-20 12:40:15 +01001322/**
1323 * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
1324 * @chip: the gpiochip to add the range for
1325 * @pinctrl_name: the dev_name() of the pin controller to map to
Linus Walleij316511c2012-11-21 08:48:09 +01001326 * @gpio_offset: the start offset in the current gpio_chip number space
1327 * @pin_offset: the start offset in the pin controller number space
Linus Walleij3f0f8672012-11-20 12:40:15 +01001328 * @npins: the number of pins from the offset of each pin space (GPIO and
1329 * pin controller) to accumulate in this range
1330 */
Linus Walleij1e63d7b2012-11-06 16:03:35 +01001331int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
Linus Walleij316511c2012-11-21 08:48:09 +01001332 unsigned int gpio_offset, unsigned int pin_offset,
Linus Walleij3f0f8672012-11-20 12:40:15 +01001333 unsigned int npins)
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301334{
1335 struct gpio_pin_range *pin_range;
Axel Linb4d4b1f2012-11-21 14:33:56 +08001336 int ret;
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301337
Linus Walleij3f0f8672012-11-20 12:40:15 +01001338 pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301339 if (!pin_range) {
1340 pr_err("%s: GPIO chip: failed to allocate pin ranges\n",
1341 chip->label);
Linus Walleij1e63d7b2012-11-06 16:03:35 +01001342 return -ENOMEM;
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301343 }
1344
Linus Walleij3f0f8672012-11-20 12:40:15 +01001345 /* Use local offset as range ID */
Linus Walleij316511c2012-11-21 08:48:09 +01001346 pin_range->range.id = gpio_offset;
Linus Walleij3f0f8672012-11-20 12:40:15 +01001347 pin_range->range.gc = chip;
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301348 pin_range->range.name = chip->label;
Linus Walleij316511c2012-11-21 08:48:09 +01001349 pin_range->range.base = chip->base + gpio_offset;
1350 pin_range->range.pin_base = pin_offset;
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301351 pin_range->range.npins = npins;
Linus Walleij192c3692012-11-20 14:03:37 +01001352 pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301353 &pin_range->range);
Linus Walleij8f23ca12012-11-20 14:56:25 +01001354 if (IS_ERR(pin_range->pctldev)) {
Axel Linb4d4b1f2012-11-21 14:33:56 +08001355 ret = PTR_ERR(pin_range->pctldev);
Linus Walleij3f0f8672012-11-20 12:40:15 +01001356 pr_err("%s: GPIO chip: could not create pin range\n",
1357 chip->label);
1358 kfree(pin_range);
Axel Linb4d4b1f2012-11-21 14:33:56 +08001359 return ret;
Linus Walleij3f0f8672012-11-20 12:40:15 +01001360 }
Linus Walleij316511c2012-11-21 08:48:09 +01001361 pr_debug("GPIO chip %s: created GPIO range %d->%d ==> %s PIN %d->%d\n",
1362 chip->label, gpio_offset, gpio_offset + npins - 1,
1363 pinctl_name,
1364 pin_offset, pin_offset + npins - 1);
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301365
1366 list_add_tail(&pin_range->node, &chip->pin_ranges);
Linus Walleij1e63d7b2012-11-06 16:03:35 +01001367
1368 return 0;
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301369}
Linus Walleij165adc92012-11-06 14:49:39 +01001370EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301371
Linus Walleij3f0f8672012-11-20 12:40:15 +01001372/**
1373 * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
1374 * @chip: the chip to remove all the mappings for
1375 */
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301376void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
1377{
1378 struct gpio_pin_range *pin_range, *tmp;
1379
1380 list_for_each_entry_safe(pin_range, tmp, &chip->pin_ranges, node) {
1381 list_del(&pin_range->node);
1382 pinctrl_remove_gpio_range(pin_range->pctldev,
1383 &pin_range->range);
Linus Walleij3f0f8672012-11-20 12:40:15 +01001384 kfree(pin_range);
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301385 }
1386}
Linus Walleij165adc92012-11-06 14:49:39 +01001387EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
1388
1389#endif /* CONFIG_PINCTRL */
Shiraz Hashimf23f1512012-10-27 15:21:36 +05301390
David Brownelld2876d02008-02-04 22:28:20 -08001391/* These "optional" allocation calls help prevent drivers from stomping
1392 * on each other, and help provide better diagnostics in debugfs.
1393 * They're called even less than the "set direction" calls.
1394 */
Alexandre Courbot372e7222013-02-03 01:29:29 +09001395static int gpiod_request(struct gpio_desc *desc, const char *label)
David Brownelld2876d02008-02-04 22:28:20 -08001396{
David Brownell35e8bb52008-10-15 22:03:16 -07001397 struct gpio_chip *chip;
Mark Browne9354572012-07-09 12:22:56 +01001398 int status = -EPROBE_DEFER;
David Brownelld2876d02008-02-04 22:28:20 -08001399 unsigned long flags;
1400
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001401 if (!desc || !desc->chip) {
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001402 pr_warn("%s: invalid GPIO\n", __func__);
1403 return -EINVAL;
1404 }
1405
David Brownelld2876d02008-02-04 22:28:20 -08001406 spin_lock_irqsave(&gpio_lock, flags);
1407
David Brownell35e8bb52008-10-15 22:03:16 -07001408 chip = desc->chip;
David Brownelld2876d02008-02-04 22:28:20 -08001409
David Brownell35e8bb52008-10-15 22:03:16 -07001410 if (!try_module_get(chip->owner))
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -07001411 goto done;
1412
David Brownelld2876d02008-02-04 22:28:20 -08001413 /* NOTE: gpio_request() can be called in early boot,
David Brownell35e8bb52008-10-15 22:03:16 -07001414 * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
David Brownelld2876d02008-02-04 22:28:20 -08001415 */
1416
1417 if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
1418 desc_set_label(desc, label ? : "?");
1419 status = 0;
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -07001420 } else {
David Brownelld2876d02008-02-04 22:28:20 -08001421 status = -EBUSY;
David Brownell35e8bb52008-10-15 22:03:16 -07001422 module_put(chip->owner);
Magnus Damm7460db52009-01-29 14:25:12 -08001423 goto done;
David Brownell35e8bb52008-10-15 22:03:16 -07001424 }
1425
1426 if (chip->request) {
1427 /* chip->request may sleep */
1428 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001429 status = chip->request(chip, gpio_chip_hwgpio(desc));
David Brownell35e8bb52008-10-15 22:03:16 -07001430 spin_lock_irqsave(&gpio_lock, flags);
1431
1432 if (status < 0) {
1433 desc_set_label(desc, NULL);
1434 module_put(chip->owner);
1435 clear_bit(FLAG_REQUESTED, &desc->flags);
Mathias Nyman80b0a602012-10-24 17:25:27 +03001436 goto done;
David Brownell35e8bb52008-10-15 22:03:16 -07001437 }
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -07001438 }
Mathias Nyman80b0a602012-10-24 17:25:27 +03001439 if (chip->get_direction) {
1440 /* chip->get_direction may sleep */
1441 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001442 gpiod_get_direction(desc);
Mathias Nyman80b0a602012-10-24 17:25:27 +03001443 spin_lock_irqsave(&gpio_lock, flags);
1444 }
David Brownelld2876d02008-02-04 22:28:20 -08001445done:
1446 if (status)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001447 pr_debug("_gpio_request: gpio-%d (%s) status %d\n",
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001448 desc_to_gpio(desc), label ? : "?", status);
David Brownelld2876d02008-02-04 22:28:20 -08001449 spin_unlock_irqrestore(&gpio_lock, flags);
1450 return status;
1451}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001452
1453int gpio_request(unsigned gpio, const char *label)
1454{
1455 return gpiod_request(gpio_to_desc(gpio), label);
1456}
David Brownelld2876d02008-02-04 22:28:20 -08001457EXPORT_SYMBOL_GPL(gpio_request);
1458
Alexandre Courbot372e7222013-02-03 01:29:29 +09001459static void gpiod_free(struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -08001460{
1461 unsigned long flags;
David Brownell35e8bb52008-10-15 22:03:16 -07001462 struct gpio_chip *chip;
David Brownelld2876d02008-02-04 22:28:20 -08001463
Uwe Kleine-König3d599d12008-10-15 22:03:12 -07001464 might_sleep();
1465
Alexandre Courbot372e7222013-02-03 01:29:29 +09001466 if (!desc) {
David Brownelld2876d02008-02-04 22:28:20 -08001467 WARN_ON(extra_checks);
1468 return;
1469 }
1470
Alexandre Courbot372e7222013-02-03 01:29:29 +09001471 gpiod_unexport(desc);
David Brownelld8f388d2008-07-25 01:46:07 -07001472
David Brownelld2876d02008-02-04 22:28:20 -08001473 spin_lock_irqsave(&gpio_lock, flags);
1474
David Brownell35e8bb52008-10-15 22:03:16 -07001475 chip = desc->chip;
1476 if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
1477 if (chip->free) {
1478 spin_unlock_irqrestore(&gpio_lock, flags);
David Brownell9c4ba942010-08-10 18:02:24 -07001479 might_sleep_if(chip->can_sleep);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001480 chip->free(chip, gpio_chip_hwgpio(desc));
David Brownell35e8bb52008-10-15 22:03:16 -07001481 spin_lock_irqsave(&gpio_lock, flags);
1482 }
David Brownelld2876d02008-02-04 22:28:20 -08001483 desc_set_label(desc, NULL);
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -07001484 module_put(desc->chip->owner);
Jani Nikula07697462009-12-15 16:46:20 -08001485 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
David Brownell35e8bb52008-10-15 22:03:16 -07001486 clear_bit(FLAG_REQUESTED, &desc->flags);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301487 clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301488 clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
Guennadi Liakhovetski438d8902008-04-28 02:14:44 -07001489 } else
David Brownelld2876d02008-02-04 22:28:20 -08001490 WARN_ON(extra_checks);
1491
1492 spin_unlock_irqrestore(&gpio_lock, flags);
1493}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001494
1495void gpio_free(unsigned gpio)
1496{
1497 gpiod_free(gpio_to_desc(gpio));
1498}
David Brownelld2876d02008-02-04 22:28:20 -08001499EXPORT_SYMBOL_GPL(gpio_free);
1500
Eric Miao3e45f1d2010-03-05 13:44:35 -08001501/**
1502 * gpio_request_one - request a single GPIO with initial configuration
1503 * @gpio: the GPIO number
1504 * @flags: GPIO configuration as specified by GPIOF_*
1505 * @label: a literal description string of this GPIO
1506 */
1507int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
1508{
Alexandre Courbot372e7222013-02-03 01:29:29 +09001509 struct gpio_desc *desc;
Eric Miao3e45f1d2010-03-05 13:44:35 -08001510 int err;
1511
Alexandre Courbot372e7222013-02-03 01:29:29 +09001512 desc = gpio_to_desc(gpio);
1513
1514 err = gpiod_request(desc, label);
Eric Miao3e45f1d2010-03-05 13:44:35 -08001515 if (err)
1516 return err;
1517
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301518 if (flags & GPIOF_OPEN_DRAIN)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001519 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301520
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301521 if (flags & GPIOF_OPEN_SOURCE)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001522 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301523
Eric Miao3e45f1d2010-03-05 13:44:35 -08001524 if (flags & GPIOF_DIR_IN)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001525 err = gpiod_direction_input(desc);
Eric Miao3e45f1d2010-03-05 13:44:35 -08001526 else
Alexandre Courbot372e7222013-02-03 01:29:29 +09001527 err = gpiod_direction_output(desc,
Eric Miao3e45f1d2010-03-05 13:44:35 -08001528 (flags & GPIOF_INIT_HIGH) ? 1 : 0);
1529
Aaro Koskinene2548112010-12-21 17:24:22 -08001530 if (err)
Wolfram Sangfc3a1f02011-12-13 18:34:01 +01001531 goto free_gpio;
Aaro Koskinene2548112010-12-21 17:24:22 -08001532
Wolfram Sangfc3a1f02011-12-13 18:34:01 +01001533 if (flags & GPIOF_EXPORT) {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001534 err = gpiod_export(desc, flags & GPIOF_EXPORT_CHANGEABLE);
Wolfram Sangfc3a1f02011-12-13 18:34:01 +01001535 if (err)
1536 goto free_gpio;
1537 }
1538
1539 return 0;
1540
1541 free_gpio:
Alexandre Courbot372e7222013-02-03 01:29:29 +09001542 gpiod_free(desc);
Eric Miao3e45f1d2010-03-05 13:44:35 -08001543 return err;
1544}
1545EXPORT_SYMBOL_GPL(gpio_request_one);
1546
1547/**
1548 * gpio_request_array - request multiple GPIOs in a single call
1549 * @array: array of the 'struct gpio'
1550 * @num: how many GPIOs in the array
1551 */
Lars-Peter Clausen7c295972011-05-25 16:20:31 -07001552int gpio_request_array(const struct gpio *array, size_t num)
Eric Miao3e45f1d2010-03-05 13:44:35 -08001553{
1554 int i, err;
1555
1556 for (i = 0; i < num; i++, array++) {
1557 err = gpio_request_one(array->gpio, array->flags, array->label);
1558 if (err)
1559 goto err_free;
1560 }
1561 return 0;
1562
1563err_free:
1564 while (i--)
1565 gpio_free((--array)->gpio);
1566 return err;
1567}
1568EXPORT_SYMBOL_GPL(gpio_request_array);
1569
1570/**
1571 * gpio_free_array - release multiple GPIOs in a single call
1572 * @array: array of the 'struct gpio'
1573 * @num: how many GPIOs in the array
1574 */
Lars-Peter Clausen7c295972011-05-25 16:20:31 -07001575void gpio_free_array(const struct gpio *array, size_t num)
Eric Miao3e45f1d2010-03-05 13:44:35 -08001576{
1577 while (num--)
1578 gpio_free((array++)->gpio);
1579}
1580EXPORT_SYMBOL_GPL(gpio_free_array);
David Brownelld2876d02008-02-04 22:28:20 -08001581
1582/**
1583 * gpiochip_is_requested - return string iff signal was requested
1584 * @chip: controller managing the signal
1585 * @offset: of signal within controller's 0..(ngpio - 1) range
1586 *
1587 * Returns NULL if the GPIO is not currently requested, else a string.
1588 * If debugfs support is enabled, the string returned is the label passed
1589 * to gpio_request(); otherwise it is a meaningless constant.
1590 *
1591 * This function is for use by GPIO controller drivers. The label can
1592 * help with diagnostics, and knowing that the signal is used as a GPIO
1593 * can help avoid accidentally multiplexing it to another controller.
1594 */
1595const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
1596{
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001597 struct gpio_desc *desc;
David Brownelld2876d02008-02-04 22:28:20 -08001598
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001599 if (!GPIO_OFFSET_VALID(chip, offset))
David Brownelld2876d02008-02-04 22:28:20 -08001600 return NULL;
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09001601
1602 desc = &chip->desc[offset];
1603
Alexandre Courbot372e7222013-02-03 01:29:29 +09001604 if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
David Brownelld2876d02008-02-04 22:28:20 -08001605 return NULL;
1606#ifdef CONFIG_DEBUG_FS
Alexandre Courbot372e7222013-02-03 01:29:29 +09001607 return desc->label;
David Brownelld2876d02008-02-04 22:28:20 -08001608#else
1609 return "?";
1610#endif
1611}
1612EXPORT_SYMBOL_GPL(gpiochip_is_requested);
1613
1614
1615/* Drivers MUST set GPIO direction before making get/set calls. In
1616 * some cases this is done in early boot, before IRQs are enabled.
1617 *
1618 * As a rule these aren't called more than once (except for drivers
1619 * using the open-drain emulation idiom) so these are natural places
1620 * to accumulate extra debugging checks. Note that we can't (yet)
1621 * rely on gpio_request() having been called beforehand.
1622 */
1623
Alexandre Courbot372e7222013-02-03 01:29:29 +09001624static int gpiod_direction_input(struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -08001625{
1626 unsigned long flags;
1627 struct gpio_chip *chip;
David Brownelld2876d02008-02-04 22:28:20 -08001628 int status = -EINVAL;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001629 int offset;
David Brownelld2876d02008-02-04 22:28:20 -08001630
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001631 if (!desc || !desc->chip) {
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001632 pr_warn("%s: invalid GPIO\n", __func__);
1633 return -EINVAL;
1634 }
1635
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001636 chip = desc->chip;
1637 if (!chip->get || !chip->direction_input) {
1638 pr_warn("%s: missing get() or direction_input() operations\n",
1639 __func__);
1640 return -EIO;
1641 }
1642
David Brownelld2876d02008-02-04 22:28:20 -08001643 spin_lock_irqsave(&gpio_lock, flags);
1644
Alexandre Courbot372e7222013-02-03 01:29:29 +09001645 status = gpio_ensure_requested(desc);
David Brownell35e8bb52008-10-15 22:03:16 -07001646 if (status < 0)
1647 goto fail;
David Brownelld2876d02008-02-04 22:28:20 -08001648
1649 /* now we know the gpio is valid and chip won't vanish */
1650
1651 spin_unlock_irqrestore(&gpio_lock, flags);
1652
David Brownell9c4ba942010-08-10 18:02:24 -07001653 might_sleep_if(chip->can_sleep);
David Brownelld2876d02008-02-04 22:28:20 -08001654
Alexandre Courbot372e7222013-02-03 01:29:29 +09001655 offset = gpio_chip_hwgpio(desc);
David Brownell35e8bb52008-10-15 22:03:16 -07001656 if (status) {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001657 status = chip->request(chip, offset);
David Brownell35e8bb52008-10-15 22:03:16 -07001658 if (status < 0) {
1659 pr_debug("GPIO-%d: chip request fail, %d\n",
Alexandre Courbot372e7222013-02-03 01:29:29 +09001660 desc_to_gpio(desc), status);
David Brownell35e8bb52008-10-15 22:03:16 -07001661 /* and it's not available to anyone else ...
1662 * gpio_request() is the fully clean solution.
1663 */
1664 goto lose;
1665 }
1666 }
1667
Alexandre Courbot372e7222013-02-03 01:29:29 +09001668 status = chip->direction_input(chip, offset);
David Brownelld2876d02008-02-04 22:28:20 -08001669 if (status == 0)
1670 clear_bit(FLAG_IS_OUT, &desc->flags);
Uwe Kleine-König3f397c212011-05-20 00:40:19 -06001671
Alexandre Courbot372e7222013-02-03 01:29:29 +09001672 trace_gpio_direction(desc_to_gpio(desc), 1, status);
David Brownell35e8bb52008-10-15 22:03:16 -07001673lose:
David Brownelld2876d02008-02-04 22:28:20 -08001674 return status;
1675fail:
1676 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001677 if (status)
1678 pr_debug("%s: gpio-%d status %d\n", __func__,
1679 desc_to_gpio(desc), status);
David Brownelld2876d02008-02-04 22:28:20 -08001680 return status;
1681}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001682
1683int gpio_direction_input(unsigned gpio)
1684{
1685 return gpiod_direction_input(gpio_to_desc(gpio));
1686}
David Brownelld2876d02008-02-04 22:28:20 -08001687EXPORT_SYMBOL_GPL(gpio_direction_input);
1688
Alexandre Courbot372e7222013-02-03 01:29:29 +09001689static int gpiod_direction_output(struct gpio_desc *desc, int value)
David Brownelld2876d02008-02-04 22:28:20 -08001690{
1691 unsigned long flags;
1692 struct gpio_chip *chip;
David Brownelld2876d02008-02-04 22:28:20 -08001693 int status = -EINVAL;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001694 int offset;
David Brownelld2876d02008-02-04 22:28:20 -08001695
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001696 if (!desc || !desc->chip) {
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001697 pr_warn("%s: invalid GPIO\n", __func__);
1698 return -EINVAL;
1699 }
1700
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301701 /* Open drain pin should not be driven to 1 */
1702 if (value && test_bit(FLAG_OPEN_DRAIN, &desc->flags))
Alexandre Courbot372e7222013-02-03 01:29:29 +09001703 return gpiod_direction_input(desc);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301704
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301705 /* Open source pin should not be driven to 0 */
1706 if (!value && test_bit(FLAG_OPEN_SOURCE, &desc->flags))
Alexandre Courbot372e7222013-02-03 01:29:29 +09001707 return gpiod_direction_input(desc);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301708
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001709 chip = desc->chip;
1710 if (!chip->set || !chip->direction_output) {
1711 pr_warn("%s: missing set() or direction_output() operations\n",
1712 __func__);
1713 return -EIO;
1714 }
1715
David Brownelld2876d02008-02-04 22:28:20 -08001716 spin_lock_irqsave(&gpio_lock, flags);
1717
Alexandre Courbot372e7222013-02-03 01:29:29 +09001718 status = gpio_ensure_requested(desc);
David Brownell35e8bb52008-10-15 22:03:16 -07001719 if (status < 0)
1720 goto fail;
David Brownelld2876d02008-02-04 22:28:20 -08001721
1722 /* now we know the gpio is valid and chip won't vanish */
1723
1724 spin_unlock_irqrestore(&gpio_lock, flags);
1725
David Brownell9c4ba942010-08-10 18:02:24 -07001726 might_sleep_if(chip->can_sleep);
David Brownelld2876d02008-02-04 22:28:20 -08001727
Alexandre Courbot372e7222013-02-03 01:29:29 +09001728 offset = gpio_chip_hwgpio(desc);
David Brownell35e8bb52008-10-15 22:03:16 -07001729 if (status) {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001730 status = chip->request(chip, offset);
David Brownell35e8bb52008-10-15 22:03:16 -07001731 if (status < 0) {
1732 pr_debug("GPIO-%d: chip request fail, %d\n",
Alexandre Courbot372e7222013-02-03 01:29:29 +09001733 desc_to_gpio(desc), status);
David Brownell35e8bb52008-10-15 22:03:16 -07001734 /* and it's not available to anyone else ...
1735 * gpio_request() is the fully clean solution.
1736 */
1737 goto lose;
1738 }
1739 }
1740
Alexandre Courbot372e7222013-02-03 01:29:29 +09001741 status = chip->direction_output(chip, offset, value);
David Brownelld2876d02008-02-04 22:28:20 -08001742 if (status == 0)
1743 set_bit(FLAG_IS_OUT, &desc->flags);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001744 trace_gpio_value(desc_to_gpio(desc), 0, value);
1745 trace_gpio_direction(desc_to_gpio(desc), 0, status);
David Brownell35e8bb52008-10-15 22:03:16 -07001746lose:
David Brownelld2876d02008-02-04 22:28:20 -08001747 return status;
1748fail:
1749 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001750 if (status)
1751 pr_debug("%s: gpio-%d status %d\n", __func__,
1752 desc_to_gpio(desc), status);
David Brownelld2876d02008-02-04 22:28:20 -08001753 return status;
1754}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001755
1756int gpio_direction_output(unsigned gpio, int value)
1757{
1758 return gpiod_direction_output(gpio_to_desc(gpio), value);
1759}
David Brownelld2876d02008-02-04 22:28:20 -08001760EXPORT_SYMBOL_GPL(gpio_direction_output);
1761
Felipe Balbic4b5be92010-05-26 14:42:23 -07001762/**
1763 * gpio_set_debounce - sets @debounce time for a @gpio
1764 * @gpio: the gpio to set debounce time
1765 * @debounce: debounce time is microseconds
Linus Walleij65d87652013-09-04 14:17:08 +02001766 *
1767 * returns -ENOTSUPP if the controller does not support setting
1768 * debounce.
Felipe Balbic4b5be92010-05-26 14:42:23 -07001769 */
Alexandre Courbot372e7222013-02-03 01:29:29 +09001770static int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
Felipe Balbic4b5be92010-05-26 14:42:23 -07001771{
1772 unsigned long flags;
1773 struct gpio_chip *chip;
Felipe Balbic4b5be92010-05-26 14:42:23 -07001774 int status = -EINVAL;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001775 int offset;
Felipe Balbic4b5be92010-05-26 14:42:23 -07001776
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001777 if (!desc || !desc->chip) {
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001778 pr_warn("%s: invalid GPIO\n", __func__);
1779 return -EINVAL;
1780 }
1781
Felipe Balbic4b5be92010-05-26 14:42:23 -07001782 chip = desc->chip;
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001783 if (!chip->set || !chip->set_debounce) {
Linus Walleij65d87652013-09-04 14:17:08 +02001784 pr_debug("%s: missing set() or set_debounce() operations\n",
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001785 __func__);
Linus Walleij65d87652013-09-04 14:17:08 +02001786 return -ENOTSUPP;
Linus Walleijbe1a4b12013-08-30 09:41:45 +02001787 }
1788
1789 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001790
1791 status = gpio_ensure_requested(desc);
Felipe Balbic4b5be92010-05-26 14:42:23 -07001792 if (status < 0)
1793 goto fail;
1794
1795 /* now we know the gpio is valid and chip won't vanish */
1796
1797 spin_unlock_irqrestore(&gpio_lock, flags);
1798
David Brownell9c4ba942010-08-10 18:02:24 -07001799 might_sleep_if(chip->can_sleep);
Felipe Balbic4b5be92010-05-26 14:42:23 -07001800
Alexandre Courbot372e7222013-02-03 01:29:29 +09001801 offset = gpio_chip_hwgpio(desc);
1802 return chip->set_debounce(chip, offset, debounce);
Felipe Balbic4b5be92010-05-26 14:42:23 -07001803
1804fail:
1805 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001806 if (status)
1807 pr_debug("%s: gpio-%d status %d\n", __func__,
1808 desc_to_gpio(desc), status);
Felipe Balbic4b5be92010-05-26 14:42:23 -07001809
1810 return status;
1811}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001812
1813int gpio_set_debounce(unsigned gpio, unsigned debounce)
1814{
1815 return gpiod_set_debounce(gpio_to_desc(gpio), debounce);
1816}
Felipe Balbic4b5be92010-05-26 14:42:23 -07001817EXPORT_SYMBOL_GPL(gpio_set_debounce);
David Brownelld2876d02008-02-04 22:28:20 -08001818
1819/* I/O calls are only valid after configuration completed; the relevant
1820 * "is this a valid GPIO" error checks should already have been done.
1821 *
1822 * "Get" operations are often inlinable as reading a pin value register,
1823 * and masking the relevant bit in that register.
1824 *
1825 * When "set" operations are inlinable, they involve writing that mask to
1826 * one register to set a low value, or a different register to set it high.
1827 * Otherwise locking is needed, so there may be little value to inlining.
1828 *
1829 *------------------------------------------------------------------------
1830 *
1831 * IMPORTANT!!! The hot paths -- get/set value -- assume that callers
1832 * have requested the GPIO. That can include implicit requesting by
1833 * a direction setting call. Marking a gpio as requested locks its chip
1834 * in memory, guaranteeing that these table lookups need no more locking
1835 * and that gpiochip_remove() will fail.
1836 *
1837 * REVISIT when debugging, consider adding some instrumentation to ensure
1838 * that the GPIO was actually requested.
1839 */
1840
1841/**
1842 * __gpio_get_value() - return a gpio's value
1843 * @gpio: gpio whose value will be returned
1844 * Context: any
1845 *
1846 * This is used directly or indirectly to implement gpio_get_value().
1847 * It returns the zero or nonzero value provided by the associated
1848 * gpio_chip.get() method; or zero if no such method is provided.
1849 */
Alexandre Courbotdef63432013-02-15 14:46:15 +09001850static int gpiod_get_value(const struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -08001851{
1852 struct gpio_chip *chip;
Uwe Kleine-König3f397c212011-05-20 00:40:19 -06001853 int value;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001854 int offset;
David Brownelld2876d02008-02-04 22:28:20 -08001855
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001856 if (!desc)
1857 return 0;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001858 chip = desc->chip;
1859 offset = gpio_chip_hwgpio(desc);
Mark Browne4e449e2012-02-17 10:46:00 -08001860 /* Should be using gpio_get_value_cansleep() */
David Brownell9c4ba942010-08-10 18:02:24 -07001861 WARN_ON(chip->can_sleep);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001862 value = chip->get ? chip->get(chip, offset) : 0;
1863 trace_gpio_value(desc_to_gpio(desc), 1, value);
Uwe Kleine-König3f397c212011-05-20 00:40:19 -06001864 return value;
David Brownelld2876d02008-02-04 22:28:20 -08001865}
Alexandre Courbot372e7222013-02-03 01:29:29 +09001866
1867int __gpio_get_value(unsigned gpio)
1868{
1869 return gpiod_get_value(gpio_to_desc(gpio));
1870}
David Brownelld2876d02008-02-04 22:28:20 -08001871EXPORT_SYMBOL_GPL(__gpio_get_value);
1872
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301873/*
1874 * _gpio_set_open_drain_value() - Set the open drain gpio's value.
1875 * @gpio: Gpio whose state need to be set.
1876 * @chip: Gpio chip.
1877 * @value: Non-zero for setting it HIGH otherise it will set to LOW.
1878 */
Alexandre Courbot372e7222013-02-03 01:29:29 +09001879static void _gpio_set_open_drain_value(struct gpio_desc *desc, int value)
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301880{
1881 int err = 0;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001882 struct gpio_chip *chip = desc->chip;
1883 int offset = gpio_chip_hwgpio(desc);
1884
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301885 if (value) {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001886 err = chip->direction_input(chip, offset);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301887 if (!err)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001888 clear_bit(FLAG_IS_OUT, &desc->flags);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301889 } else {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001890 err = chip->direction_output(chip, offset, 0);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301891 if (!err)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001892 set_bit(FLAG_IS_OUT, &desc->flags);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301893 }
Alexandre Courbot372e7222013-02-03 01:29:29 +09001894 trace_gpio_direction(desc_to_gpio(desc), value, err);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301895 if (err < 0)
1896 pr_err("%s: Error in set_value for open drain gpio%d err %d\n",
Alexandre Courbot372e7222013-02-03 01:29:29 +09001897 __func__, desc_to_gpio(desc), err);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301898}
1899
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301900/*
1901 * _gpio_set_open_source() - Set the open source gpio's value.
1902 * @gpio: Gpio whose state need to be set.
1903 * @chip: Gpio chip.
1904 * @value: Non-zero for setting it HIGH otherise it will set to LOW.
1905 */
Alexandre Courbot372e7222013-02-03 01:29:29 +09001906static void _gpio_set_open_source_value(struct gpio_desc *desc, int value)
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301907{
1908 int err = 0;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001909 struct gpio_chip *chip = desc->chip;
1910 int offset = gpio_chip_hwgpio(desc);
1911
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301912 if (value) {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001913 err = chip->direction_output(chip, offset, 1);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301914 if (!err)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001915 set_bit(FLAG_IS_OUT, &desc->flags);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301916 } else {
Alexandre Courbot372e7222013-02-03 01:29:29 +09001917 err = chip->direction_input(chip, offset);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301918 if (!err)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001919 clear_bit(FLAG_IS_OUT, &desc->flags);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301920 }
Alexandre Courbot372e7222013-02-03 01:29:29 +09001921 trace_gpio_direction(desc_to_gpio(desc), !value, err);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301922 if (err < 0)
1923 pr_err("%s: Error in set_value for open source gpio%d err %d\n",
Alexandre Courbot372e7222013-02-03 01:29:29 +09001924 __func__, desc_to_gpio(desc), err);
Laxman Dewangan25553ff2012-02-17 20:26:22 +05301925}
1926
David Brownelld2876d02008-02-04 22:28:20 -08001927/**
1928 * __gpio_set_value() - assign a gpio's value
1929 * @gpio: gpio whose value will be assigned
1930 * @value: value to assign
1931 * Context: any
1932 *
1933 * This is used directly or indirectly to implement gpio_set_value().
1934 * It invokes the associated gpio_chip.set() method.
1935 */
Alexandre Courbot372e7222013-02-03 01:29:29 +09001936static void gpiod_set_value(struct gpio_desc *desc, int value)
David Brownelld2876d02008-02-04 22:28:20 -08001937{
1938 struct gpio_chip *chip;
1939
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001940 if (!desc)
1941 return;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001942 chip = desc->chip;
Mark Browne4e449e2012-02-17 10:46:00 -08001943 /* Should be using gpio_set_value_cansleep() */
David Brownell9c4ba942010-08-10 18:02:24 -07001944 WARN_ON(chip->can_sleep);
Alexandre Courbot372e7222013-02-03 01:29:29 +09001945 trace_gpio_value(desc_to_gpio(desc), 0, value);
1946 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
1947 _gpio_set_open_drain_value(desc, value);
1948 else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
1949 _gpio_set_open_source_value(desc, value);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05301950 else
Alexandre Courbot372e7222013-02-03 01:29:29 +09001951 chip->set(chip, gpio_chip_hwgpio(desc), value);
1952}
1953
1954void __gpio_set_value(unsigned gpio, int value)
1955{
1956 return gpiod_set_value(gpio_to_desc(gpio), value);
David Brownelld2876d02008-02-04 22:28:20 -08001957}
1958EXPORT_SYMBOL_GPL(__gpio_set_value);
1959
1960/**
1961 * __gpio_cansleep() - report whether gpio value access will sleep
1962 * @gpio: gpio in question
1963 * Context: any
1964 *
1965 * This is used directly or indirectly to implement gpio_cansleep(). It
1966 * returns nonzero if access reading or writing the GPIO value can sleep.
1967 */
Alexandre Courbotdef63432013-02-15 14:46:15 +09001968static int gpiod_cansleep(const struct gpio_desc *desc)
Alexandre Courbot372e7222013-02-03 01:29:29 +09001969{
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001970 if (!desc)
1971 return 0;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001972 /* only call this on GPIOs that are valid! */
1973 return desc->chip->can_sleep;
1974}
1975
David Brownelld2876d02008-02-04 22:28:20 -08001976int __gpio_cansleep(unsigned gpio)
1977{
Alexandre Courbot372e7222013-02-03 01:29:29 +09001978 return gpiod_cansleep(gpio_to_desc(gpio));
David Brownelld2876d02008-02-04 22:28:20 -08001979}
1980EXPORT_SYMBOL_GPL(__gpio_cansleep);
1981
David Brownell0f6d5042008-10-15 22:03:14 -07001982/**
1983 * __gpio_to_irq() - return the IRQ corresponding to a GPIO
1984 * @gpio: gpio whose IRQ will be returned (already requested)
1985 * Context: any
1986 *
1987 * This is used directly or indirectly to implement gpio_to_irq().
1988 * It returns the number of the IRQ signaled by this (input) GPIO,
1989 * or a negative errno.
1990 */
Alexandre Courbotdef63432013-02-15 14:46:15 +09001991static int gpiod_to_irq(const struct gpio_desc *desc)
David Brownell0f6d5042008-10-15 22:03:14 -07001992{
1993 struct gpio_chip *chip;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001994 int offset;
David Brownell0f6d5042008-10-15 22:03:14 -07001995
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09001996 if (!desc)
1997 return -EINVAL;
Alexandre Courbot372e7222013-02-03 01:29:29 +09001998 chip = desc->chip;
1999 offset = gpio_chip_hwgpio(desc);
2000 return chip->to_irq ? chip->to_irq(chip, offset) : -ENXIO;
2001}
2002
2003int __gpio_to_irq(unsigned gpio)
2004{
2005 return gpiod_to_irq(gpio_to_desc(gpio));
David Brownell0f6d5042008-10-15 22:03:14 -07002006}
2007EXPORT_SYMBOL_GPL(__gpio_to_irq);
2008
David Brownelld2876d02008-02-04 22:28:20 -08002009
David Brownelld2876d02008-02-04 22:28:20 -08002010/* There's no value in making it easy to inline GPIO calls that may sleep.
2011 * Common examples include ones connected to I2C or SPI chips.
2012 */
2013
Alexandre Courbotdef63432013-02-15 14:46:15 +09002014static int gpiod_get_value_cansleep(const struct gpio_desc *desc)
David Brownelld2876d02008-02-04 22:28:20 -08002015{
2016 struct gpio_chip *chip;
Uwe Kleine-König3f397c212011-05-20 00:40:19 -06002017 int value;
Alexandre Courbot372e7222013-02-03 01:29:29 +09002018 int offset;
David Brownelld2876d02008-02-04 22:28:20 -08002019
2020 might_sleep_if(extra_checks);
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09002021 if (!desc)
2022 return 0;
Alexandre Courbot372e7222013-02-03 01:29:29 +09002023 chip = desc->chip;
2024 offset = gpio_chip_hwgpio(desc);
2025 value = chip->get ? chip->get(chip, offset) : 0;
2026 trace_gpio_value(desc_to_gpio(desc), 1, value);
Uwe Kleine-König3f397c212011-05-20 00:40:19 -06002027 return value;
David Brownelld2876d02008-02-04 22:28:20 -08002028}
Alexandre Courbot372e7222013-02-03 01:29:29 +09002029
2030int gpio_get_value_cansleep(unsigned gpio)
2031{
2032 return gpiod_get_value_cansleep(gpio_to_desc(gpio));
2033}
David Brownelld2876d02008-02-04 22:28:20 -08002034EXPORT_SYMBOL_GPL(gpio_get_value_cansleep);
2035
Alexandre Courbot372e7222013-02-03 01:29:29 +09002036static void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
David Brownelld2876d02008-02-04 22:28:20 -08002037{
2038 struct gpio_chip *chip;
2039
2040 might_sleep_if(extra_checks);
Alexandre Courbotbcabdef2013-02-15 14:46:14 +09002041 if (!desc)
2042 return;
Alexandre Courbot372e7222013-02-03 01:29:29 +09002043 chip = desc->chip;
2044 trace_gpio_value(desc_to_gpio(desc), 0, value);
2045 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
2046 _gpio_set_open_drain_value(desc, value);
2047 else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
2048 _gpio_set_open_source_value(desc, value);
Laxman Dewanganaca5ce12012-02-17 20:26:21 +05302049 else
Alexandre Courbot372e7222013-02-03 01:29:29 +09002050 chip->set(chip, gpio_chip_hwgpio(desc), value);
2051}
2052
2053void gpio_set_value_cansleep(unsigned gpio, int value)
2054{
2055 return gpiod_set_value_cansleep(gpio_to_desc(gpio), value);
David Brownelld2876d02008-02-04 22:28:20 -08002056}
2057EXPORT_SYMBOL_GPL(gpio_set_value_cansleep);
2058
David Brownelld2876d02008-02-04 22:28:20 -08002059#ifdef CONFIG_DEBUG_FS
2060
David Brownelld2876d02008-02-04 22:28:20 -08002061static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
2062{
2063 unsigned i;
2064 unsigned gpio = chip->base;
Alexandre Courbot6c0b4e62013-02-03 01:29:30 +09002065 struct gpio_desc *gdesc = &chip->desc[0];
David Brownelld2876d02008-02-04 22:28:20 -08002066 int is_out;
2067
2068 for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
2069 if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
2070 continue;
2071
Alexandre Courbot372e7222013-02-03 01:29:29 +09002072 gpiod_get_direction(gdesc);
David Brownelld2876d02008-02-04 22:28:20 -08002073 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
Jarkko Nikula6e8ba722008-11-19 15:36:17 -08002074 seq_printf(s, " gpio-%-3d (%-20.20s) %s %s",
David Brownelld2876d02008-02-04 22:28:20 -08002075 gpio, gdesc->label,
2076 is_out ? "out" : "in ",
2077 chip->get
2078 ? (chip->get(chip, i) ? "hi" : "lo")
2079 : "? ");
David Brownelld2876d02008-02-04 22:28:20 -08002080 seq_printf(s, "\n");
2081 }
2082}
2083
Thierry Redingf9c4a312012-04-12 13:26:01 +02002084static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
David Brownelld2876d02008-02-04 22:28:20 -08002085{
Grant Likely362432a2013-02-09 09:41:49 +00002086 unsigned long flags;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002087 struct gpio_chip *chip = NULL;
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002088 loff_t index = *pos;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002089
2090 s->private = "";
2091
Grant Likely362432a2013-02-09 09:41:49 +00002092 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002093 list_for_each_entry(chip, &gpio_chips, list)
Grant Likely362432a2013-02-09 09:41:49 +00002094 if (index-- == 0) {
2095 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002096 return chip;
Grant Likely362432a2013-02-09 09:41:49 +00002097 }
2098 spin_unlock_irqrestore(&gpio_lock, flags);
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002099
2100 return NULL;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002101}
2102
2103static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
2104{
Grant Likely362432a2013-02-09 09:41:49 +00002105 unsigned long flags;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002106 struct gpio_chip *chip = v;
Thierry Redingf9c4a312012-04-12 13:26:01 +02002107 void *ret = NULL;
2108
Grant Likely362432a2013-02-09 09:41:49 +00002109 spin_lock_irqsave(&gpio_lock, flags);
Alexandre Courbotcb1650d2013-02-03 01:29:27 +09002110 if (list_is_last(&chip->list, &gpio_chips))
2111 ret = NULL;
2112 else
2113 ret = list_entry(chip->list.next, struct gpio_chip, list);
Grant Likely362432a2013-02-09 09:41:49 +00002114 spin_unlock_irqrestore(&gpio_lock, flags);
Thierry Redingf9c4a312012-04-12 13:26:01 +02002115
2116 s->private = "\n";
2117 ++*pos;
2118
2119 return ret;
2120}
2121
2122static void gpiolib_seq_stop(struct seq_file *s, void *v)
2123{
2124}
2125
2126static int gpiolib_seq_show(struct seq_file *s, void *v)
2127{
2128 struct gpio_chip *chip = v;
2129 struct device *dev;
2130
2131 seq_printf(s, "%sGPIOs %d-%d", (char *)s->private,
2132 chip->base, chip->base + chip->ngpio - 1);
2133 dev = chip->dev;
2134 if (dev)
2135 seq_printf(s, ", %s/%s", dev->bus ? dev->bus->name : "no-bus",
2136 dev_name(dev));
2137 if (chip->label)
2138 seq_printf(s, ", %s", chip->label);
2139 if (chip->can_sleep)
2140 seq_printf(s, ", can sleep");
2141 seq_printf(s, ":\n");
2142
2143 if (chip->dbg_show)
2144 chip->dbg_show(s, chip);
2145 else
2146 gpiolib_dbg_show(s, chip);
2147
David Brownelld2876d02008-02-04 22:28:20 -08002148 return 0;
2149}
2150
Thierry Redingf9c4a312012-04-12 13:26:01 +02002151static const struct seq_operations gpiolib_seq_ops = {
2152 .start = gpiolib_seq_start,
2153 .next = gpiolib_seq_next,
2154 .stop = gpiolib_seq_stop,
2155 .show = gpiolib_seq_show,
2156};
2157
David Brownelld2876d02008-02-04 22:28:20 -08002158static int gpiolib_open(struct inode *inode, struct file *file)
2159{
Thierry Redingf9c4a312012-04-12 13:26:01 +02002160 return seq_open(file, &gpiolib_seq_ops);
David Brownelld2876d02008-02-04 22:28:20 -08002161}
2162
Alexey Dobriyan828c0952009-10-01 15:43:56 -07002163static const struct file_operations gpiolib_operations = {
Thierry Redingf9c4a312012-04-12 13:26:01 +02002164 .owner = THIS_MODULE,
David Brownelld2876d02008-02-04 22:28:20 -08002165 .open = gpiolib_open,
2166 .read = seq_read,
2167 .llseek = seq_lseek,
Thierry Redingf9c4a312012-04-12 13:26:01 +02002168 .release = seq_release,
David Brownelld2876d02008-02-04 22:28:20 -08002169};
2170
2171static int __init gpiolib_debugfs_init(void)
2172{
2173 /* /sys/kernel/debug/gpio */
2174 (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
2175 NULL, NULL, &gpiolib_operations);
2176 return 0;
2177}
2178subsys_initcall(gpiolib_debugfs_init);
2179
2180#endif /* DEBUG_FS */