Branch data Line data Source code
1 : : #include <linux/kernel.h>
2 : : #include <linux/module.h>
3 : : #include <linux/interrupt.h>
4 : : #include <linux/irq.h>
5 : : #include <linux/spinlock.h>
6 : : #include <linux/list.h>
7 : : #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>
12 : : #include <linux/of_gpio.h>
13 : : #include <linux/idr.h>
14 : : #include <linux/slab.h>
15 : : #include <linux/acpi.h>
16 : : #include <linux/gpio/driver.h>
17 : :
18 : : #include "gpiolib.h"
19 : :
20 : : #define CREATE_TRACE_POINTS
21 : : #include <trace/events/gpio.h>
22 : :
23 : : /* Implementation infrastructure for GPIO interfaces.
24 : : *
25 : : * The GPIO programming interface allows for inlining speed-critical
26 : : * get/set operations for common cases, so that access to SOC-integrated
27 : : * GPIOs can sometimes cost only an instruction or two per bit.
28 : : */
29 : :
30 : :
31 : : /* When debugging, extend minimal trust to callers and platform code.
32 : : * Also emit diagnostic messages that may help initial bringup, when
33 : : * board setup or driver bugs are most common.
34 : : *
35 : : * Otherwise, minimize overhead in what may be bitbanging codepaths.
36 : : */
37 : : #ifdef DEBUG
38 : : #define extra_checks 1
39 : : #else
40 : : #define extra_checks 0
41 : : #endif
42 : :
43 : : /* gpio_lock prevents conflicts during gpio_desc[] table updates.
44 : : * While any GPIO is requested, its gpio_chip is not removable;
45 : : * each GPIO's "requested" flag serves as a lock and refcount.
46 : : */
47 : : static DEFINE_SPINLOCK(gpio_lock);
48 : :
49 : : struct gpio_desc {
50 : : struct gpio_chip *chip;
51 : : unsigned long flags;
52 : : /* flag symbols are bit numbers */
53 : : #define FLAG_REQUESTED 0
54 : : #define FLAG_IS_OUT 1
55 : : #define FLAG_EXPORT 2 /* protected by sysfs_lock */
56 : : #define FLAG_SYSFS 3 /* exported via /sys/class/gpio/control */
57 : : #define FLAG_TRIG_FALL 4 /* trigger on falling edge */
58 : : #define FLAG_TRIG_RISE 5 /* trigger on rising edge */
59 : : #define FLAG_ACTIVE_LOW 6 /* value has active low */
60 : : #define FLAG_OPEN_DRAIN 7 /* Gpio is open drain type */
61 : : #define FLAG_OPEN_SOURCE 8 /* Gpio is open source type */
62 : : #define FLAG_USED_AS_IRQ 9 /* GPIO is connected to an IRQ */
63 : :
64 : : #define ID_SHIFT 16 /* add new flags before this one */
65 : :
66 : : #define GPIO_FLAGS_MASK ((1 << ID_SHIFT) - 1)
67 : : #define GPIO_TRIGGER_MASK (BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE))
68 : :
69 : : #ifdef CONFIG_DEBUG_FS
70 : : const char *label;
71 : : #endif
72 : : };
73 : : static struct gpio_desc gpio_desc[ARCH_NR_GPIOS];
74 : :
75 : : #define GPIO_OFFSET_VALID(chip, offset) (offset >= 0 && offset < chip->ngpio)
76 : :
77 : : static DEFINE_MUTEX(gpio_lookup_lock);
78 : : static LIST_HEAD(gpio_lookup_list);
79 : : static LIST_HEAD(gpio_chips);
80 : :
81 : : #ifdef CONFIG_GPIO_SYSFS
82 : : static DEFINE_IDR(dirent_idr);
83 : : #endif
84 : :
85 : : static int gpiod_request(struct gpio_desc *desc, const char *label);
86 : : static void gpiod_free(struct gpio_desc *desc);
87 : :
88 : : /* With descriptor prefix */
89 : :
90 : : #ifdef CONFIG_DEBUG_FS
91 : : #define gpiod_emerg(desc, fmt, ...) \
92 : : pr_emerg("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
93 : : ##__VA_ARGS__)
94 : : #define gpiod_crit(desc, fmt, ...) \
95 : : pr_crit("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
96 : : ##__VA_ARGS__)
97 : : #define gpiod_err(desc, fmt, ...) \
98 : : pr_err("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
99 : : ##__VA_ARGS__)
100 : : #define gpiod_warn(desc, fmt, ...) \
101 : : pr_warn("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
102 : : ##__VA_ARGS__)
103 : : #define gpiod_info(desc, fmt, ...) \
104 : : pr_info("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?", \
105 : : ##__VA_ARGS__)
106 : : #define gpiod_dbg(desc, fmt, ...) \
107 : : pr_debug("gpio-%d (%s): " fmt, desc_to_gpio(desc), desc->label ? : "?",\
108 : : ##__VA_ARGS__)
109 : : #else
110 : : #define gpiod_emerg(desc, fmt, ...) \
111 : : pr_emerg("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
112 : : #define gpiod_crit(desc, fmt, ...) \
113 : : pr_crit("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
114 : : #define gpiod_err(desc, fmt, ...) \
115 : : pr_err("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
116 : : #define gpiod_warn(desc, fmt, ...) \
117 : : pr_warn("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
118 : : #define gpiod_info(desc, fmt, ...) \
119 : : pr_info("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
120 : : #define gpiod_dbg(desc, fmt, ...) \
121 : : pr_debug("gpio-%d: " fmt, desc_to_gpio(desc), ##__VA_ARGS__)
122 : : #endif
123 : :
124 : : /* With chip prefix */
125 : :
126 : : #define chip_emerg(chip, fmt, ...) \
127 : : pr_emerg("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
128 : : #define chip_crit(chip, fmt, ...) \
129 : : pr_crit("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
130 : : #define chip_err(chip, fmt, ...) \
131 : : pr_err("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
132 : : #define chip_warn(chip, fmt, ...) \
133 : : pr_warn("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
134 : : #define chip_info(chip, fmt, ...) \
135 : : pr_info("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
136 : : #define chip_dbg(chip, fmt, ...) \
137 : : pr_debug("GPIO chip %s: " fmt, chip->label, ##__VA_ARGS__)
138 : :
139 : : static inline void desc_set_label(struct gpio_desc *d, const char *label)
140 : : {
141 : : #ifdef CONFIG_DEBUG_FS
142 : 0 : d->label = label;
143 : : #endif
144 : : }
145 : :
146 : : /*
147 : : * Return the GPIO number of the passed descriptor relative to its chip
148 : : */
149 : : static int gpio_chip_hwgpio(const struct gpio_desc *desc)
150 : : {
151 : 17420512 : return desc - &desc->chip->desc[0];
152 : : }
153 : :
154 : : /**
155 : : * Convert a GPIO number to its descriptor
156 : : */
157 : 0 : struct gpio_desc *gpio_to_desc(unsigned gpio)
158 : : {
159 [ - + ][ + - ]: 17504697 : if (WARN(!gpio_is_valid(gpio), "invalid GPIO %d\n", gpio))
160 : : return NULL;
161 : : else
162 : 17493324 : return &gpio_desc[gpio];
163 : : }
164 : : EXPORT_SYMBOL_GPL(gpio_to_desc);
165 : :
166 : : /**
167 : : * Convert an offset on a certain chip to a corresponding descriptor
168 : : */
169 : : static struct gpio_desc *gpiochip_offset_to_desc(struct gpio_chip *chip,
170 : : unsigned int offset)
171 : : {
172 [ # # ][ # # ]: 0 : if (offset >= chip->ngpio)
[ # # ]
173 : : return ERR_PTR(-EINVAL);
174 : :
175 : 0 : return &chip->desc[offset];
176 : : }
177 : :
178 : : /**
179 : : * Convert a GPIO descriptor to the integer namespace.
180 : : * This should disappear in the future but is needed since we still
181 : : * use GPIO numbers for error messages and sysfs nodes
182 : : */
183 : 0 : int desc_to_gpio(const struct gpio_desc *desc)
184 : : {
185 : 17298190 : return desc - &gpio_desc[0];
186 : : }
187 : : EXPORT_SYMBOL_GPL(desc_to_gpio);
188 : :
189 : :
190 : : /* Warn when drivers omit gpio_request() calls -- legal but ill-advised
191 : : * when setting direction, and otherwise illegal. Until board setup code
192 : : * and drivers use explicit requests everywhere (which won't happen when
193 : : * those calls have no teeth) we can't avoid autorequesting. This nag
194 : : * message should motivate switching to explicit requests... so should
195 : : * the weaker cleanup after faults, compared to gpio_request().
196 : : *
197 : : * NOTE: the autorequest mechanism is going away; at this point it's
198 : : * only "legal" in the sense that (old) code using it won't break yet,
199 : : * but instead only triggers a WARN() stack dump.
200 : : */
201 : 0 : static int gpio_ensure_requested(struct gpio_desc *desc)
202 : : {
203 : 0 : const struct gpio_chip *chip = desc->chip;
204 : : const int gpio = desc_to_gpio(desc);
205 : :
206 [ # # ][ # # ]: 0 : if (WARN(test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0,
207 : : "autorequest GPIO-%d\n", gpio)) {
208 [ # # ]: 0 : if (!try_module_get(chip->owner)) {
209 [ # # ]: 0 : gpiod_err(desc, "%s: module can't be gotten\n",
210 : : __func__);
211 : 0 : clear_bit(FLAG_REQUESTED, &desc->flags);
212 : : /* lose */
213 : 0 : return -EIO;
214 : : }
215 : : desc_set_label(desc, "[auto]");
216 : : /* caller must chip->request() w/o spinlock */
217 [ # # ]: 0 : if (chip->request)
218 : : return 1;
219 : : }
220 : : return 0;
221 : : }
222 : :
223 : : /**
224 : : * gpiod_to_chip - Return the GPIO chip to which a GPIO descriptor belongs
225 : : * @desc: descriptor to return the chip of
226 : : */
227 : 0 : struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
228 : : {
229 [ # # ][ # # ]: 0 : return desc ? desc->chip : NULL;
230 : : }
231 : : EXPORT_SYMBOL_GPL(gpiod_to_chip);
232 : :
233 : : /* dynamic allocation of GPIOs, e.g. on a hotplugged device */
234 : 0 : static int gpiochip_find_base(int ngpio)
235 : : {
236 : : struct gpio_chip *chip;
237 : 0 : int base = ARCH_NR_GPIOS - ngpio;
238 : :
239 [ # # ]: 0 : list_for_each_entry_reverse(chip, &gpio_chips, list) {
240 : : /* found a free space? */
241 [ # # ]: 0 : if (chip->base + chip->ngpio <= base)
242 : : break;
243 : : else
244 : : /* nope, check the space right before the chip */
245 : 0 : base = chip->base - ngpio;
246 : : }
247 : :
248 [ # # ]: 0 : if (gpio_is_valid(base)) {
249 : : pr_debug("%s: found new base at %d\n", __func__, base);
250 : : return base;
251 : : } else {
252 : 0 : pr_err("%s: cannot find free range\n", __func__);
253 : 0 : return -ENOSPC;
254 : : }
255 : : }
256 : :
257 : : /**
258 : : * gpiod_get_direction - return the current direction of a GPIO
259 : : * @desc: GPIO to get the direction of
260 : : *
261 : : * Return GPIOF_DIR_IN or GPIOF_DIR_OUT, or an error code in case of error.
262 : : *
263 : : * This function may sleep if gpiod_cansleep() is true.
264 : : */
265 : 0 : int gpiod_get_direction(const struct gpio_desc *desc)
266 : : {
267 : : struct gpio_chip *chip;
268 : : unsigned offset;
269 : : int status = -EINVAL;
270 : :
271 : : chip = gpiod_to_chip(desc);
272 : 0 : offset = gpio_chip_hwgpio(desc);
273 : :
274 [ # # ]: 0 : if (!chip->get_direction)
275 : : return status;
276 : :
277 : 0 : status = chip->get_direction(chip, offset);
278 [ # # ]: 0 : if (status > 0) {
279 : : /* GPIOF_DIR_IN, or other positive */
280 : : status = 1;
281 : : /* FLAG_IS_OUT is just a cache of the result of get_direction(),
282 : : * so it does not affect constness per se */
283 : 0 : clear_bit(FLAG_IS_OUT, &((struct gpio_desc *)desc)->flags);
284 : : }
285 [ # # ]: 0 : if (status == 0) {
286 : : /* GPIOF_DIR_OUT */
287 : 0 : set_bit(FLAG_IS_OUT, &((struct gpio_desc *)desc)->flags);
288 : : }
289 : 0 : return status;
290 : : }
291 : : EXPORT_SYMBOL_GPL(gpiod_get_direction);
292 : :
293 : : #ifdef CONFIG_GPIO_SYSFS
294 : :
295 : : /* lock protects against unexport_gpio() being called while
296 : : * sysfs files are active.
297 : : */
298 : : static DEFINE_MUTEX(sysfs_lock);
299 : :
300 : : /*
301 : : * /sys/class/gpio/gpioN... only for GPIOs that are exported
302 : : * /direction
303 : : * * MAY BE OMITTED if kernel won't allow direction changes
304 : : * * is read/write as "in" or "out"
305 : : * * may also be written as "high" or "low", initializing
306 : : * output value as specified ("out" implies "low")
307 : : * /value
308 : : * * always readable, subject to hardware behavior
309 : : * * may be writable, as zero/nonzero
310 : : * /edge
311 : : * * configures behavior of poll(2) on /value
312 : : * * available only if pin can generate IRQs on input
313 : : * * is read/write as "none", "falling", "rising", or "both"
314 : : * /active_low
315 : : * * configures polarity of /value
316 : : * * is read/write as zero/nonzero
317 : : * * also affects existing and subsequent "falling" and "rising"
318 : : * /edge configuration
319 : : */
320 : :
321 : : static ssize_t gpio_direction_show(struct device *dev,
322 : : struct device_attribute *attr, char *buf)
323 : : {
324 : : const struct gpio_desc *desc = dev_get_drvdata(dev);
325 : : ssize_t status;
326 : :
327 : : mutex_lock(&sysfs_lock);
328 : :
329 : : if (!test_bit(FLAG_EXPORT, &desc->flags)) {
330 : : status = -EIO;
331 : : } else {
332 : : gpiod_get_direction(desc);
333 : : status = sprintf(buf, "%s\n",
334 : : test_bit(FLAG_IS_OUT, &desc->flags)
335 : : ? "out" : "in");
336 : : }
337 : :
338 : : mutex_unlock(&sysfs_lock);
339 : : return status;
340 : : }
341 : :
342 : : static ssize_t gpio_direction_store(struct device *dev,
343 : : struct device_attribute *attr, const char *buf, size_t size)
344 : : {
345 : : struct gpio_desc *desc = dev_get_drvdata(dev);
346 : : ssize_t status;
347 : :
348 : : mutex_lock(&sysfs_lock);
349 : :
350 : : if (!test_bit(FLAG_EXPORT, &desc->flags))
351 : : status = -EIO;
352 : : else if (sysfs_streq(buf, "high"))
353 : : status = gpiod_direction_output(desc, 1);
354 : : else if (sysfs_streq(buf, "out") || sysfs_streq(buf, "low"))
355 : : status = gpiod_direction_output(desc, 0);
356 : : else if (sysfs_streq(buf, "in"))
357 : : status = gpiod_direction_input(desc);
358 : : else
359 : : status = -EINVAL;
360 : :
361 : : mutex_unlock(&sysfs_lock);
362 : : return status ? : size;
363 : : }
364 : :
365 : : static /* const */ DEVICE_ATTR(direction, 0644,
366 : : gpio_direction_show, gpio_direction_store);
367 : :
368 : : static ssize_t gpio_value_show(struct device *dev,
369 : : struct device_attribute *attr, char *buf)
370 : : {
371 : : struct gpio_desc *desc = dev_get_drvdata(dev);
372 : : ssize_t status;
373 : :
374 : : mutex_lock(&sysfs_lock);
375 : :
376 : : if (!test_bit(FLAG_EXPORT, &desc->flags))
377 : : status = -EIO;
378 : : else
379 : : status = sprintf(buf, "%d\n", gpiod_get_value_cansleep(desc));
380 : :
381 : : mutex_unlock(&sysfs_lock);
382 : : return status;
383 : : }
384 : :
385 : : static ssize_t gpio_value_store(struct device *dev,
386 : : struct device_attribute *attr, const char *buf, size_t size)
387 : : {
388 : : struct gpio_desc *desc = dev_get_drvdata(dev);
389 : : ssize_t status;
390 : :
391 : : mutex_lock(&sysfs_lock);
392 : :
393 : : if (!test_bit(FLAG_EXPORT, &desc->flags))
394 : : status = -EIO;
395 : : else if (!test_bit(FLAG_IS_OUT, &desc->flags))
396 : : status = -EPERM;
397 : : else {
398 : : long value;
399 : :
400 : : status = kstrtol(buf, 0, &value);
401 : : if (status == 0) {
402 : : gpiod_set_value_cansleep(desc, value);
403 : : status = size;
404 : : }
405 : : }
406 : :
407 : : mutex_unlock(&sysfs_lock);
408 : : return status;
409 : : }
410 : :
411 : : static const DEVICE_ATTR(value, 0644,
412 : : gpio_value_show, gpio_value_store);
413 : :
414 : : static irqreturn_t gpio_sysfs_irq(int irq, void *priv)
415 : : {
416 : : struct kernfs_node *value_sd = priv;
417 : :
418 : : sysfs_notify_dirent(value_sd);
419 : : return IRQ_HANDLED;
420 : : }
421 : :
422 : : static int gpio_setup_irq(struct gpio_desc *desc, struct device *dev,
423 : : unsigned long gpio_flags)
424 : : {
425 : : struct kernfs_node *value_sd;
426 : : unsigned long irq_flags;
427 : : int ret, irq, id;
428 : :
429 : : if ((desc->flags & GPIO_TRIGGER_MASK) == gpio_flags)
430 : : return 0;
431 : :
432 : : irq = gpiod_to_irq(desc);
433 : : if (irq < 0)
434 : : return -EIO;
435 : :
436 : : id = desc->flags >> ID_SHIFT;
437 : : value_sd = idr_find(&dirent_idr, id);
438 : : if (value_sd)
439 : : free_irq(irq, value_sd);
440 : :
441 : : desc->flags &= ~GPIO_TRIGGER_MASK;
442 : :
443 : : if (!gpio_flags) {
444 : : gpiod_unlock_as_irq(desc);
445 : : ret = 0;
446 : : goto free_id;
447 : : }
448 : :
449 : : irq_flags = IRQF_SHARED;
450 : : if (test_bit(FLAG_TRIG_FALL, &gpio_flags))
451 : : irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
452 : : IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
453 : : if (test_bit(FLAG_TRIG_RISE, &gpio_flags))
454 : : irq_flags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
455 : : IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
456 : :
457 : : if (!value_sd) {
458 : : value_sd = sysfs_get_dirent(dev->kobj.sd, "value");
459 : : if (!value_sd) {
460 : : ret = -ENODEV;
461 : : goto err_out;
462 : : }
463 : :
464 : : ret = idr_alloc(&dirent_idr, value_sd, 1, 0, GFP_KERNEL);
465 : : if (ret < 0)
466 : : goto free_sd;
467 : : id = ret;
468 : :
469 : : desc->flags &= GPIO_FLAGS_MASK;
470 : : desc->flags |= (unsigned long)id << ID_SHIFT;
471 : :
472 : : if (desc->flags >> ID_SHIFT != id) {
473 : : ret = -ERANGE;
474 : : goto free_id;
475 : : }
476 : : }
477 : :
478 : : ret = request_any_context_irq(irq, gpio_sysfs_irq, irq_flags,
479 : : "gpiolib", value_sd);
480 : : if (ret < 0)
481 : : goto free_id;
482 : :
483 : : ret = gpiod_lock_as_irq(desc);
484 : : if (ret < 0) {
485 : : gpiod_warn(desc, "failed to flag the GPIO for IRQ\n");
486 : : goto free_id;
487 : : }
488 : :
489 : : desc->flags |= gpio_flags;
490 : : return 0;
491 : :
492 : : free_id:
493 : : idr_remove(&dirent_idr, id);
494 : : desc->flags &= GPIO_FLAGS_MASK;
495 : : free_sd:
496 : : if (value_sd)
497 : : sysfs_put(value_sd);
498 : : err_out:
499 : : return ret;
500 : : }
501 : :
502 : : static const struct {
503 : : const char *name;
504 : : unsigned long flags;
505 : : } trigger_types[] = {
506 : : { "none", 0 },
507 : : { "falling", BIT(FLAG_TRIG_FALL) },
508 : : { "rising", BIT(FLAG_TRIG_RISE) },
509 : : { "both", BIT(FLAG_TRIG_FALL) | BIT(FLAG_TRIG_RISE) },
510 : : };
511 : :
512 : : static ssize_t gpio_edge_show(struct device *dev,
513 : : struct device_attribute *attr, char *buf)
514 : : {
515 : : const struct gpio_desc *desc = dev_get_drvdata(dev);
516 : : ssize_t status;
517 : :
518 : : mutex_lock(&sysfs_lock);
519 : :
520 : : if (!test_bit(FLAG_EXPORT, &desc->flags))
521 : : status = -EIO;
522 : : else {
523 : : int i;
524 : :
525 : : status = 0;
526 : : for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
527 : : if ((desc->flags & GPIO_TRIGGER_MASK)
528 : : == trigger_types[i].flags) {
529 : : status = sprintf(buf, "%s\n",
530 : : trigger_types[i].name);
531 : : break;
532 : : }
533 : : }
534 : :
535 : : mutex_unlock(&sysfs_lock);
536 : : return status;
537 : : }
538 : :
539 : : static ssize_t gpio_edge_store(struct device *dev,
540 : : struct device_attribute *attr, const char *buf, size_t size)
541 : : {
542 : : struct gpio_desc *desc = dev_get_drvdata(dev);
543 : : ssize_t status;
544 : : int i;
545 : :
546 : : for (i = 0; i < ARRAY_SIZE(trigger_types); i++)
547 : : if (sysfs_streq(trigger_types[i].name, buf))
548 : : goto found;
549 : : return -EINVAL;
550 : :
551 : : found:
552 : : mutex_lock(&sysfs_lock);
553 : :
554 : : if (!test_bit(FLAG_EXPORT, &desc->flags))
555 : : status = -EIO;
556 : : else {
557 : : status = gpio_setup_irq(desc, dev, trigger_types[i].flags);
558 : : if (!status)
559 : : status = size;
560 : : }
561 : :
562 : : mutex_unlock(&sysfs_lock);
563 : :
564 : : return status;
565 : : }
566 : :
567 : : static DEVICE_ATTR(edge, 0644, gpio_edge_show, gpio_edge_store);
568 : :
569 : : static int sysfs_set_active_low(struct gpio_desc *desc, struct device *dev,
570 : : int value)
571 : : {
572 : : int status = 0;
573 : :
574 : : if (!!test_bit(FLAG_ACTIVE_LOW, &desc->flags) == !!value)
575 : : return 0;
576 : :
577 : : if (value)
578 : : set_bit(FLAG_ACTIVE_LOW, &desc->flags);
579 : : else
580 : : clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
581 : :
582 : : /* reconfigure poll(2) support if enabled on one edge only */
583 : : if (dev != NULL && (!!test_bit(FLAG_TRIG_RISE, &desc->flags) ^
584 : : !!test_bit(FLAG_TRIG_FALL, &desc->flags))) {
585 : : unsigned long trigger_flags = desc->flags & GPIO_TRIGGER_MASK;
586 : :
587 : : gpio_setup_irq(desc, dev, 0);
588 : : status = gpio_setup_irq(desc, dev, trigger_flags);
589 : : }
590 : :
591 : : return status;
592 : : }
593 : :
594 : : static ssize_t gpio_active_low_show(struct device *dev,
595 : : struct device_attribute *attr, char *buf)
596 : : {
597 : : const struct gpio_desc *desc = dev_get_drvdata(dev);
598 : : ssize_t status;
599 : :
600 : : mutex_lock(&sysfs_lock);
601 : :
602 : : if (!test_bit(FLAG_EXPORT, &desc->flags))
603 : : status = -EIO;
604 : : else
605 : : status = sprintf(buf, "%d\n",
606 : : !!test_bit(FLAG_ACTIVE_LOW, &desc->flags));
607 : :
608 : : mutex_unlock(&sysfs_lock);
609 : :
610 : : return status;
611 : : }
612 : :
613 : : static ssize_t gpio_active_low_store(struct device *dev,
614 : : struct device_attribute *attr, const char *buf, size_t size)
615 : : {
616 : : struct gpio_desc *desc = dev_get_drvdata(dev);
617 : : ssize_t status;
618 : :
619 : : mutex_lock(&sysfs_lock);
620 : :
621 : : if (!test_bit(FLAG_EXPORT, &desc->flags)) {
622 : : status = -EIO;
623 : : } else {
624 : : long value;
625 : :
626 : : status = kstrtol(buf, 0, &value);
627 : : if (status == 0)
628 : : status = sysfs_set_active_low(desc, dev, value != 0);
629 : : }
630 : :
631 : : mutex_unlock(&sysfs_lock);
632 : :
633 : : return status ? : size;
634 : : }
635 : :
636 : : static const DEVICE_ATTR(active_low, 0644,
637 : : gpio_active_low_show, gpio_active_low_store);
638 : :
639 : : static const struct attribute *gpio_attrs[] = {
640 : : &dev_attr_value.attr,
641 : : &dev_attr_active_low.attr,
642 : : NULL,
643 : : };
644 : :
645 : : static const struct attribute_group gpio_attr_group = {
646 : : .attrs = (struct attribute **) gpio_attrs,
647 : : };
648 : :
649 : : /*
650 : : * /sys/class/gpio/gpiochipN/
651 : : * /base ... matching gpio_chip.base (N)
652 : : * /label ... matching gpio_chip.label
653 : : * /ngpio ... matching gpio_chip.ngpio
654 : : */
655 : :
656 : : static ssize_t chip_base_show(struct device *dev,
657 : : struct device_attribute *attr, char *buf)
658 : : {
659 : : const struct gpio_chip *chip = dev_get_drvdata(dev);
660 : :
661 : : return sprintf(buf, "%d\n", chip->base);
662 : : }
663 : : static DEVICE_ATTR(base, 0444, chip_base_show, NULL);
664 : :
665 : : static ssize_t chip_label_show(struct device *dev,
666 : : struct device_attribute *attr, char *buf)
667 : : {
668 : : const struct gpio_chip *chip = dev_get_drvdata(dev);
669 : :
670 : : return sprintf(buf, "%s\n", chip->label ? : "");
671 : : }
672 : : static DEVICE_ATTR(label, 0444, chip_label_show, NULL);
673 : :
674 : : static ssize_t chip_ngpio_show(struct device *dev,
675 : : struct device_attribute *attr, char *buf)
676 : : {
677 : : const struct gpio_chip *chip = dev_get_drvdata(dev);
678 : :
679 : : return sprintf(buf, "%u\n", chip->ngpio);
680 : : }
681 : : static DEVICE_ATTR(ngpio, 0444, chip_ngpio_show, NULL);
682 : :
683 : : static const struct attribute *gpiochip_attrs[] = {
684 : : &dev_attr_base.attr,
685 : : &dev_attr_label.attr,
686 : : &dev_attr_ngpio.attr,
687 : : NULL,
688 : : };
689 : :
690 : : static const struct attribute_group gpiochip_attr_group = {
691 : : .attrs = (struct attribute **) gpiochip_attrs,
692 : : };
693 : :
694 : : /*
695 : : * /sys/class/gpio/export ... write-only
696 : : * integer N ... number of GPIO to export (full access)
697 : : * /sys/class/gpio/unexport ... write-only
698 : : * integer N ... number of GPIO to unexport
699 : : */
700 : : static ssize_t export_store(struct class *class,
701 : : struct class_attribute *attr,
702 : : const char *buf, size_t len)
703 : : {
704 : : long gpio;
705 : : struct gpio_desc *desc;
706 : : int status;
707 : :
708 : : status = kstrtol(buf, 0, &gpio);
709 : : if (status < 0)
710 : : goto done;
711 : :
712 : : desc = gpio_to_desc(gpio);
713 : : /* reject invalid GPIOs */
714 : : if (!desc) {
715 : : pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
716 : : return -EINVAL;
717 : : }
718 : :
719 : : /* No extra locking here; FLAG_SYSFS just signifies that the
720 : : * request and export were done by on behalf of userspace, so
721 : : * they may be undone on its behalf too.
722 : : */
723 : :
724 : : status = gpiod_request(desc, "sysfs");
725 : : if (status < 0) {
726 : : if (status == -EPROBE_DEFER)
727 : : status = -ENODEV;
728 : : goto done;
729 : : }
730 : : status = gpiod_export(desc, true);
731 : : if (status < 0)
732 : : gpiod_free(desc);
733 : : else
734 : : set_bit(FLAG_SYSFS, &desc->flags);
735 : :
736 : : done:
737 : : if (status)
738 : : pr_debug("%s: status %d\n", __func__, status);
739 : : return status ? : len;
740 : : }
741 : :
742 : : static ssize_t unexport_store(struct class *class,
743 : : struct class_attribute *attr,
744 : : const char *buf, size_t len)
745 : : {
746 : : long gpio;
747 : : struct gpio_desc *desc;
748 : : int status;
749 : :
750 : : status = kstrtol(buf, 0, &gpio);
751 : : if (status < 0)
752 : : goto done;
753 : :
754 : : desc = gpio_to_desc(gpio);
755 : : /* reject bogus commands (gpio_unexport ignores them) */
756 : : if (!desc) {
757 : : pr_warn("%s: invalid GPIO %ld\n", __func__, gpio);
758 : : return -EINVAL;
759 : : }
760 : :
761 : : status = -EINVAL;
762 : :
763 : : /* No extra locking here; FLAG_SYSFS just signifies that the
764 : : * request and export were done by on behalf of userspace, so
765 : : * they may be undone on its behalf too.
766 : : */
767 : : if (test_and_clear_bit(FLAG_SYSFS, &desc->flags)) {
768 : : status = 0;
769 : : gpiod_free(desc);
770 : : }
771 : : done:
772 : : if (status)
773 : : pr_debug("%s: status %d\n", __func__, status);
774 : : return status ? : len;
775 : : }
776 : :
777 : : static struct class_attribute gpio_class_attrs[] = {
778 : : __ATTR(export, 0200, NULL, export_store),
779 : : __ATTR(unexport, 0200, NULL, unexport_store),
780 : : __ATTR_NULL,
781 : : };
782 : :
783 : : static struct class gpio_class = {
784 : : .name = "gpio",
785 : : .owner = THIS_MODULE,
786 : :
787 : : .class_attrs = gpio_class_attrs,
788 : : };
789 : :
790 : :
791 : : /**
792 : : * gpiod_export - export a GPIO through sysfs
793 : : * @gpio: gpio to make available, already requested
794 : : * @direction_may_change: true if userspace may change gpio direction
795 : : * Context: arch_initcall or later
796 : : *
797 : : * When drivers want to make a GPIO accessible to userspace after they
798 : : * have requested it -- perhaps while debugging, or as part of their
799 : : * public interface -- they may use this routine. If the GPIO can
800 : : * change direction (some can't) and the caller allows it, userspace
801 : : * will see "direction" sysfs attribute which may be used to change
802 : : * the gpio's direction. A "value" attribute will always be provided.
803 : : *
804 : : * Returns zero on success, else an error.
805 : : */
806 : : int gpiod_export(struct gpio_desc *desc, bool direction_may_change)
807 : : {
808 : : unsigned long flags;
809 : : int status;
810 : : const char *ioname = NULL;
811 : : struct device *dev;
812 : : int offset;
813 : :
814 : : /* can't export until sysfs is available ... */
815 : : if (!gpio_class.p) {
816 : : pr_debug("%s: called too early!\n", __func__);
817 : : return -ENOENT;
818 : : }
819 : :
820 : : if (!desc) {
821 : : pr_debug("%s: invalid gpio descriptor\n", __func__);
822 : : return -EINVAL;
823 : : }
824 : :
825 : : mutex_lock(&sysfs_lock);
826 : :
827 : : spin_lock_irqsave(&gpio_lock, flags);
828 : : if (!test_bit(FLAG_REQUESTED, &desc->flags) ||
829 : : test_bit(FLAG_EXPORT, &desc->flags)) {
830 : : spin_unlock_irqrestore(&gpio_lock, flags);
831 : : gpiod_dbg(desc, "%s: unavailable (requested=%d, exported=%d)\n",
832 : : __func__,
833 : : test_bit(FLAG_REQUESTED, &desc->flags),
834 : : test_bit(FLAG_EXPORT, &desc->flags));
835 : : status = -EPERM;
836 : : goto fail_unlock;
837 : : }
838 : :
839 : : if (!desc->chip->direction_input || !desc->chip->direction_output)
840 : : direction_may_change = false;
841 : : spin_unlock_irqrestore(&gpio_lock, flags);
842 : :
843 : : offset = gpio_chip_hwgpio(desc);
844 : : if (desc->chip->names && desc->chip->names[offset])
845 : : ioname = desc->chip->names[offset];
846 : :
847 : : dev = device_create(&gpio_class, desc->chip->dev, MKDEV(0, 0),
848 : : desc, ioname ? ioname : "gpio%u",
849 : : desc_to_gpio(desc));
850 : : if (IS_ERR(dev)) {
851 : : status = PTR_ERR(dev);
852 : : goto fail_unlock;
853 : : }
854 : :
855 : : status = sysfs_create_group(&dev->kobj, &gpio_attr_group);
856 : : if (status)
857 : : goto fail_unregister_device;
858 : :
859 : : if (direction_may_change) {
860 : : status = device_create_file(dev, &dev_attr_direction);
861 : : if (status)
862 : : goto fail_unregister_device;
863 : : }
864 : :
865 : : if (gpiod_to_irq(desc) >= 0 && (direction_may_change ||
866 : : !test_bit(FLAG_IS_OUT, &desc->flags))) {
867 : : status = device_create_file(dev, &dev_attr_edge);
868 : : if (status)
869 : : goto fail_unregister_device;
870 : : }
871 : :
872 : : set_bit(FLAG_EXPORT, &desc->flags);
873 : : mutex_unlock(&sysfs_lock);
874 : : return 0;
875 : :
876 : : fail_unregister_device:
877 : : device_unregister(dev);
878 : : fail_unlock:
879 : : mutex_unlock(&sysfs_lock);
880 : : gpiod_dbg(desc, "%s: status %d\n", __func__, status);
881 : : return status;
882 : : }
883 : : EXPORT_SYMBOL_GPL(gpiod_export);
884 : :
885 : : static int match_export(struct device *dev, const void *data)
886 : : {
887 : : return dev_get_drvdata(dev) == data;
888 : : }
889 : :
890 : : /**
891 : : * gpiod_export_link - create a sysfs link to an exported GPIO node
892 : : * @dev: device under which to create symlink
893 : : * @name: name of the symlink
894 : : * @gpio: gpio to create symlink to, already exported
895 : : *
896 : : * Set up a symlink from /sys/.../dev/name to /sys/class/gpio/gpioN
897 : : * node. Caller is responsible for unlinking.
898 : : *
899 : : * Returns zero on success, else an error.
900 : : */
901 : : int gpiod_export_link(struct device *dev, const char *name,
902 : : struct gpio_desc *desc)
903 : : {
904 : : int status = -EINVAL;
905 : :
906 : : if (!desc) {
907 : : pr_warn("%s: invalid GPIO\n", __func__);
908 : : return -EINVAL;
909 : : }
910 : :
911 : : mutex_lock(&sysfs_lock);
912 : :
913 : : if (test_bit(FLAG_EXPORT, &desc->flags)) {
914 : : struct device *tdev;
915 : :
916 : : tdev = class_find_device(&gpio_class, NULL, desc, match_export);
917 : : if (tdev != NULL) {
918 : : status = sysfs_create_link(&dev->kobj, &tdev->kobj,
919 : : name);
920 : : } else {
921 : : status = -ENODEV;
922 : : }
923 : : }
924 : :
925 : : mutex_unlock(&sysfs_lock);
926 : :
927 : : if (status)
928 : : gpiod_dbg(desc, "%s: status %d\n", __func__, status);
929 : :
930 : : return status;
931 : : }
932 : : EXPORT_SYMBOL_GPL(gpiod_export_link);
933 : :
934 : : /**
935 : : * gpiod_sysfs_set_active_low - set the polarity of gpio sysfs value
936 : : * @gpio: gpio to change
937 : : * @value: non-zero to use active low, i.e. inverted values
938 : : *
939 : : * Set the polarity of /sys/class/gpio/gpioN/value sysfs attribute.
940 : : * The GPIO does not have to be exported yet. If poll(2) support has
941 : : * been enabled for either rising or falling edge, it will be
942 : : * reconfigured to follow the new polarity.
943 : : *
944 : : * Returns zero on success, else an error.
945 : : */
946 : : int gpiod_sysfs_set_active_low(struct gpio_desc *desc, int value)
947 : : {
948 : : struct device *dev = NULL;
949 : : int status = -EINVAL;
950 : :
951 : : if (!desc) {
952 : : pr_warn("%s: invalid GPIO\n", __func__);
953 : : return -EINVAL;
954 : : }
955 : :
956 : : mutex_lock(&sysfs_lock);
957 : :
958 : : if (test_bit(FLAG_EXPORT, &desc->flags)) {
959 : : dev = class_find_device(&gpio_class, NULL, desc, match_export);
960 : : if (dev == NULL) {
961 : : status = -ENODEV;
962 : : goto unlock;
963 : : }
964 : : }
965 : :
966 : : status = sysfs_set_active_low(desc, dev, value);
967 : :
968 : : unlock:
969 : : mutex_unlock(&sysfs_lock);
970 : :
971 : : if (status)
972 : : gpiod_dbg(desc, "%s: status %d\n", __func__, status);
973 : :
974 : : return status;
975 : : }
976 : : EXPORT_SYMBOL_GPL(gpiod_sysfs_set_active_low);
977 : :
978 : : /**
979 : : * gpiod_unexport - reverse effect of gpio_export()
980 : : * @gpio: gpio to make unavailable
981 : : *
982 : : * This is implicit on gpio_free().
983 : : */
984 : : void gpiod_unexport(struct gpio_desc *desc)
985 : : {
986 : : int status = 0;
987 : : struct device *dev = NULL;
988 : :
989 : : if (!desc) {
990 : : pr_warn("%s: invalid GPIO\n", __func__);
991 : : return;
992 : : }
993 : :
994 : : mutex_lock(&sysfs_lock);
995 : :
996 : : if (test_bit(FLAG_EXPORT, &desc->flags)) {
997 : :
998 : : dev = class_find_device(&gpio_class, NULL, desc, match_export);
999 : : if (dev) {
1000 : : gpio_setup_irq(desc, dev, 0);
1001 : : clear_bit(FLAG_EXPORT, &desc->flags);
1002 : : } else
1003 : : status = -ENODEV;
1004 : : }
1005 : :
1006 : : mutex_unlock(&sysfs_lock);
1007 : :
1008 : : if (dev) {
1009 : : device_unregister(dev);
1010 : : put_device(dev);
1011 : : }
1012 : :
1013 : : if (status)
1014 : : gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1015 : : }
1016 : : EXPORT_SYMBOL_GPL(gpiod_unexport);
1017 : :
1018 : : static int gpiochip_export(struct gpio_chip *chip)
1019 : : {
1020 : : int status;
1021 : : struct device *dev;
1022 : :
1023 : : /* Many systems register gpio chips for SOC support very early,
1024 : : * before driver model support is available. In those cases we
1025 : : * export this later, in gpiolib_sysfs_init() ... here we just
1026 : : * verify that _some_ field of gpio_class got initialized.
1027 : : */
1028 : : if (!gpio_class.p)
1029 : : return 0;
1030 : :
1031 : : /* use chip->base for the ID; it's already known to be unique */
1032 : : mutex_lock(&sysfs_lock);
1033 : : dev = device_create(&gpio_class, chip->dev, MKDEV(0, 0), chip,
1034 : : "gpiochip%d", chip->base);
1035 : : if (!IS_ERR(dev)) {
1036 : : status = sysfs_create_group(&dev->kobj,
1037 : : &gpiochip_attr_group);
1038 : : } else
1039 : : status = PTR_ERR(dev);
1040 : : chip->exported = (status == 0);
1041 : : mutex_unlock(&sysfs_lock);
1042 : :
1043 : : if (status) {
1044 : : unsigned long flags;
1045 : : unsigned gpio;
1046 : :
1047 : : spin_lock_irqsave(&gpio_lock, flags);
1048 : : gpio = 0;
1049 : : while (gpio < chip->ngpio)
1050 : : chip->desc[gpio++].chip = NULL;
1051 : : spin_unlock_irqrestore(&gpio_lock, flags);
1052 : :
1053 : : chip_dbg(chip, "%s: status %d\n", __func__, status);
1054 : : }
1055 : :
1056 : : return status;
1057 : : }
1058 : :
1059 : : static void gpiochip_unexport(struct gpio_chip *chip)
1060 : : {
1061 : : int status;
1062 : : struct device *dev;
1063 : :
1064 : : mutex_lock(&sysfs_lock);
1065 : : dev = class_find_device(&gpio_class, NULL, chip, match_export);
1066 : : if (dev) {
1067 : : put_device(dev);
1068 : : device_unregister(dev);
1069 : : chip->exported = false;
1070 : : status = 0;
1071 : : } else
1072 : : status = -ENODEV;
1073 : : mutex_unlock(&sysfs_lock);
1074 : :
1075 : : if (status)
1076 : : chip_dbg(chip, "%s: status %d\n", __func__, status);
1077 : : }
1078 : :
1079 : : static int __init gpiolib_sysfs_init(void)
1080 : : {
1081 : : int status;
1082 : : unsigned long flags;
1083 : : struct gpio_chip *chip;
1084 : :
1085 : : status = class_register(&gpio_class);
1086 : : if (status < 0)
1087 : : return status;
1088 : :
1089 : : /* Scan and register the gpio_chips which registered very
1090 : : * early (e.g. before the class_register above was called).
1091 : : *
1092 : : * We run before arch_initcall() so chip->dev nodes can have
1093 : : * registered, and so arch_initcall() can always gpio_export().
1094 : : */
1095 : : spin_lock_irqsave(&gpio_lock, flags);
1096 : : list_for_each_entry(chip, &gpio_chips, list) {
1097 : : if (!chip || chip->exported)
1098 : : continue;
1099 : :
1100 : : spin_unlock_irqrestore(&gpio_lock, flags);
1101 : : status = gpiochip_export(chip);
1102 : : spin_lock_irqsave(&gpio_lock, flags);
1103 : : }
1104 : : spin_unlock_irqrestore(&gpio_lock, flags);
1105 : :
1106 : :
1107 : : return status;
1108 : : }
1109 : : postcore_initcall(gpiolib_sysfs_init);
1110 : :
1111 : : #else
1112 : : static inline int gpiochip_export(struct gpio_chip *chip)
1113 : : {
1114 : : return 0;
1115 : : }
1116 : :
1117 : : static inline void gpiochip_unexport(struct gpio_chip *chip)
1118 : : {
1119 : : }
1120 : :
1121 : : #endif /* CONFIG_GPIO_SYSFS */
1122 : :
1123 : : /*
1124 : : * Add a new chip to the global chips list, keeping the list of chips sorted
1125 : : * by base order.
1126 : : *
1127 : : * Return -EBUSY if the new chip overlaps with some other chip's integer
1128 : : * space.
1129 : : */
1130 : 0 : static int gpiochip_add_to_list(struct gpio_chip *chip)
1131 : : {
1132 : : struct list_head *pos = &gpio_chips;
1133 : : struct gpio_chip *_chip;
1134 : : int err = 0;
1135 : :
1136 : : /* find where to insert our chip */
1137 [ # # ]: 0 : list_for_each(pos, &gpio_chips) {
1138 : : _chip = list_entry(pos, struct gpio_chip, list);
1139 : : /* shall we insert before _chip? */
1140 [ # # ]: 0 : if (_chip->base >= chip->base + chip->ngpio)
1141 : : break;
1142 : : }
1143 : :
1144 : : /* are we stepping on the chip right before? */
1145 [ # # ][ # # ]: 0 : if (pos != &gpio_chips && pos->prev != &gpio_chips) {
1146 : : _chip = list_entry(pos->prev, struct gpio_chip, list);
1147 [ # # ]: 0 : if (_chip->base + _chip->ngpio > chip->base) {
1148 : 0 : dev_err(chip->dev,
1149 : : "GPIO integer space overlap, cannot add chip\n");
1150 : : err = -EBUSY;
1151 : : }
1152 : : }
1153 : :
1154 [ # # ]: 0 : if (!err)
1155 : 0 : list_add_tail(&chip->list, pos);
1156 : :
1157 : 0 : return err;
1158 : : }
1159 : :
1160 : : /**
1161 : : * gpiochip_add() - register a gpio_chip
1162 : : * @chip: the chip to register, with chip->base initialized
1163 : : * Context: potentially before irqs or kmalloc will work
1164 : : *
1165 : : * Returns a negative errno if the chip can't be registered, such as
1166 : : * because the chip->base is invalid or already associated with a
1167 : : * different chip. Otherwise it returns zero as a success code.
1168 : : *
1169 : : * When gpiochip_add() is called very early during boot, so that GPIOs
1170 : : * can be freely used, the chip->dev device must be registered before
1171 : : * the gpio framework's arch_initcall(). Otherwise sysfs initialization
1172 : : * for GPIOs will fail rudely.
1173 : : *
1174 : : * If chip->base is negative, this requests dynamic assignment of
1175 : : * a range of valid GPIOs.
1176 : : */
1177 : 0 : int gpiochip_add(struct gpio_chip *chip)
1178 : : {
1179 : : unsigned long flags;
1180 : : int status = 0;
1181 : : unsigned id;
1182 : 0 : int base = chip->base;
1183 : :
1184 [ # # ][ # # ]: 0 : if ((!gpio_is_valid(base) || !gpio_is_valid(base + chip->ngpio - 1))
1185 [ # # ]: 0 : && base >= 0) {
1186 : : status = -EINVAL;
1187 : : goto fail;
1188 : : }
1189 : :
1190 : 0 : spin_lock_irqsave(&gpio_lock, flags);
1191 : :
1192 [ # # ]: 0 : if (base < 0) {
1193 : 0 : base = gpiochip_find_base(chip->ngpio);
1194 [ # # ]: 0 : if (base < 0) {
1195 : : status = base;
1196 : : goto unlock;
1197 : : }
1198 : 0 : chip->base = base;
1199 : : }
1200 : :
1201 : 0 : status = gpiochip_add_to_list(chip);
1202 : :
1203 [ # # ]: 0 : if (status == 0) {
1204 : 0 : chip->desc = &gpio_desc[chip->base];
1205 : :
1206 [ # # ]: 0 : for (id = 0; id < chip->ngpio; id++) {
1207 : 0 : struct gpio_desc *desc = &chip->desc[id];
1208 : 0 : desc->chip = chip;
1209 : :
1210 : : /* REVISIT: most hardware initializes GPIOs as
1211 : : * inputs (often with pullups enabled) so power
1212 : : * usage is minimized. Linux code should set the
1213 : : * gpio direction first thing; but until it does,
1214 : : * and in case chip->get_direction is not set,
1215 : : * we may expose the wrong direction in sysfs.
1216 : : */
1217 [ # # ]: 0 : desc->flags = !chip->direction_input
1218 : : ? (1 << FLAG_IS_OUT)
1219 : : : 0;
1220 : : }
1221 : : }
1222 : :
1223 : : spin_unlock_irqrestore(&gpio_lock, flags);
1224 : :
1225 : : #ifdef CONFIG_PINCTRL
1226 : : INIT_LIST_HEAD(&chip->pin_ranges);
1227 : : #endif
1228 : :
1229 : 0 : of_gpiochip_add(chip);
1230 : : acpi_gpiochip_add(chip);
1231 : :
1232 [ # # ]: 0 : if (status)
1233 : : goto fail;
1234 : :
1235 : : status = gpiochip_export(chip);
1236 : : if (status)
1237 : : goto fail;
1238 : :
1239 : 0 : pr_debug("%s: registered GPIOs %d to %d on device: %s\n", __func__,
1240 : : chip->base, chip->base + chip->ngpio - 1,
1241 : : chip->label ? : "generic");
1242 : :
1243 : : return 0;
1244 : :
1245 : : unlock:
1246 : : spin_unlock_irqrestore(&gpio_lock, flags);
1247 : : fail:
1248 : : /* failures here can mean systems won't boot... */
1249 [ # # ]: 0 : pr_err("%s: GPIOs %d..%d (%s) failed to register\n", __func__,
1250 : : chip->base, chip->base + chip->ngpio - 1,
1251 : : chip->label ? : "generic");
1252 : 0 : return status;
1253 : : }
1254 : : EXPORT_SYMBOL_GPL(gpiochip_add);
1255 : :
1256 : : /**
1257 : : * gpiochip_remove() - unregister a gpio_chip
1258 : : * @chip: the chip to unregister
1259 : : *
1260 : : * A gpio_chip with any GPIOs still requested may not be removed.
1261 : : */
1262 : 0 : int gpiochip_remove(struct gpio_chip *chip)
1263 : : {
1264 : : unsigned long flags;
1265 : : int status = 0;
1266 : : unsigned id;
1267 : :
1268 : 0 : spin_lock_irqsave(&gpio_lock, flags);
1269 : :
1270 : : gpiochip_remove_pin_ranges(chip);
1271 : 0 : of_gpiochip_remove(chip);
1272 : : acpi_gpiochip_remove(chip);
1273 : :
1274 [ # # ]: 0 : for (id = 0; id < chip->ngpio; id++) {
1275 [ # # ]: 0 : if (test_bit(FLAG_REQUESTED, &chip->desc[id].flags)) {
1276 : : status = -EBUSY;
1277 : : break;
1278 : : }
1279 : : }
1280 [ # # ]: 0 : if (status == 0) {
1281 [ # # ]: 0 : for (id = 0; id < chip->ngpio; id++)
1282 : 0 : chip->desc[id].chip = NULL;
1283 : :
1284 : : list_del(&chip->list);
1285 : : }
1286 : :
1287 : : spin_unlock_irqrestore(&gpio_lock, flags);
1288 : :
1289 : : if (status == 0)
1290 : : gpiochip_unexport(chip);
1291 : :
1292 : 0 : return status;
1293 : : }
1294 : : EXPORT_SYMBOL_GPL(gpiochip_remove);
1295 : :
1296 : : /**
1297 : : * gpiochip_find() - iterator for locating a specific gpio_chip
1298 : : * @data: data to pass to match function
1299 : : * @callback: Callback function to check gpio_chip
1300 : : *
1301 : : * Similar to bus_find_device. It returns a reference to a gpio_chip as
1302 : : * determined by a user supplied @match callback. The callback should return
1303 : : * 0 if the device doesn't match and non-zero if it does. If the callback is
1304 : : * non-zero, this function will return to the caller and not iterate over any
1305 : : * more gpio_chips.
1306 : : */
1307 : 0 : struct gpio_chip *gpiochip_find(void *data,
1308 : : int (*match)(struct gpio_chip *chip,
1309 : : void *data))
1310 : : {
1311 : : struct gpio_chip *chip;
1312 : : unsigned long flags;
1313 : :
1314 : 0 : spin_lock_irqsave(&gpio_lock, flags);
1315 [ # # ]: 0 : list_for_each_entry(chip, &gpio_chips, list)
1316 [ # # ]: 0 : if (match(chip, data))
1317 : : break;
1318 : :
1319 : : /* No match? */
1320 [ # # ]: 0 : if (&chip->list == &gpio_chips)
1321 : : chip = NULL;
1322 : : spin_unlock_irqrestore(&gpio_lock, flags);
1323 : :
1324 : 0 : return chip;
1325 : : }
1326 : : EXPORT_SYMBOL_GPL(gpiochip_find);
1327 : :
1328 : 0 : static int gpiochip_match_name(struct gpio_chip *chip, void *data)
1329 : : {
1330 : : const char *name = data;
1331 : :
1332 : 0 : return !strcmp(chip->label, name);
1333 : : }
1334 : :
1335 : : static struct gpio_chip *find_chip_by_name(const char *name)
1336 : : {
1337 : 0 : return gpiochip_find((void *)name, gpiochip_match_name);
1338 : : }
1339 : :
1340 : : #ifdef CONFIG_PINCTRL
1341 : :
1342 : : /**
1343 : : * gpiochip_add_pingroup_range() - add a range for GPIO <-> pin mapping
1344 : : * @chip: the gpiochip to add the range for
1345 : : * @pinctrl: the dev_name() of the pin controller to map to
1346 : : * @gpio_offset: the start offset in the current gpio_chip number space
1347 : : * @pin_group: name of the pin group inside the pin controller
1348 : : */
1349 : : int gpiochip_add_pingroup_range(struct gpio_chip *chip,
1350 : : struct pinctrl_dev *pctldev,
1351 : : unsigned int gpio_offset, const char *pin_group)
1352 : : {
1353 : : struct gpio_pin_range *pin_range;
1354 : : int ret;
1355 : :
1356 : : pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1357 : : if (!pin_range) {
1358 : : chip_err(chip, "failed to allocate pin ranges\n");
1359 : : return -ENOMEM;
1360 : : }
1361 : :
1362 : : /* Use local offset as range ID */
1363 : : pin_range->range.id = gpio_offset;
1364 : : pin_range->range.gc = chip;
1365 : : pin_range->range.name = chip->label;
1366 : : pin_range->range.base = chip->base + gpio_offset;
1367 : : pin_range->pctldev = pctldev;
1368 : :
1369 : : ret = pinctrl_get_group_pins(pctldev, pin_group,
1370 : : &pin_range->range.pins,
1371 : : &pin_range->range.npins);
1372 : : if (ret < 0) {
1373 : : kfree(pin_range);
1374 : : return ret;
1375 : : }
1376 : :
1377 : : pinctrl_add_gpio_range(pctldev, &pin_range->range);
1378 : :
1379 : : chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
1380 : : gpio_offset, gpio_offset + pin_range->range.npins - 1,
1381 : : pinctrl_dev_get_devname(pctldev), pin_group);
1382 : :
1383 : : list_add_tail(&pin_range->node, &chip->pin_ranges);
1384 : :
1385 : : return 0;
1386 : : }
1387 : : EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);
1388 : :
1389 : : /**
1390 : : * gpiochip_add_pin_range() - add a range for GPIO <-> pin mapping
1391 : : * @chip: the gpiochip to add the range for
1392 : : * @pinctrl_name: the dev_name() of the pin controller to map to
1393 : : * @gpio_offset: the start offset in the current gpio_chip number space
1394 : : * @pin_offset: the start offset in the pin controller number space
1395 : : * @npins: the number of pins from the offset of each pin space (GPIO and
1396 : : * pin controller) to accumulate in this range
1397 : : */
1398 : : int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
1399 : : unsigned int gpio_offset, unsigned int pin_offset,
1400 : : unsigned int npins)
1401 : : {
1402 : : struct gpio_pin_range *pin_range;
1403 : : int ret;
1404 : :
1405 : : pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
1406 : : if (!pin_range) {
1407 : : chip_err(chip, "failed to allocate pin ranges\n");
1408 : : return -ENOMEM;
1409 : : }
1410 : :
1411 : : /* Use local offset as range ID */
1412 : : pin_range->range.id = gpio_offset;
1413 : : pin_range->range.gc = chip;
1414 : : pin_range->range.name = chip->label;
1415 : : pin_range->range.base = chip->base + gpio_offset;
1416 : : pin_range->range.pin_base = pin_offset;
1417 : : pin_range->range.npins = npins;
1418 : : pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
1419 : : &pin_range->range);
1420 : : if (IS_ERR(pin_range->pctldev)) {
1421 : : ret = PTR_ERR(pin_range->pctldev);
1422 : : chip_err(chip, "could not create pin range\n");
1423 : : kfree(pin_range);
1424 : : return ret;
1425 : : }
1426 : : chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
1427 : : gpio_offset, gpio_offset + npins - 1,
1428 : : pinctl_name,
1429 : : pin_offset, pin_offset + npins - 1);
1430 : :
1431 : : list_add_tail(&pin_range->node, &chip->pin_ranges);
1432 : :
1433 : : return 0;
1434 : : }
1435 : : EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
1436 : :
1437 : : /**
1438 : : * gpiochip_remove_pin_ranges() - remove all the GPIO <-> pin mappings
1439 : : * @chip: the chip to remove all the mappings for
1440 : : */
1441 : : void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
1442 : : {
1443 : : struct gpio_pin_range *pin_range, *tmp;
1444 : :
1445 : : list_for_each_entry_safe(pin_range, tmp, &chip->pin_ranges, node) {
1446 : : list_del(&pin_range->node);
1447 : : pinctrl_remove_gpio_range(pin_range->pctldev,
1448 : : &pin_range->range);
1449 : : kfree(pin_range);
1450 : : }
1451 : : }
1452 : : EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
1453 : :
1454 : : #endif /* CONFIG_PINCTRL */
1455 : :
1456 : : /* These "optional" allocation calls help prevent drivers from stomping
1457 : : * on each other, and help provide better diagnostics in debugfs.
1458 : : * They're called even less than the "set direction" calls.
1459 : : */
1460 : 0 : static int gpiod_request(struct gpio_desc *desc, const char *label)
1461 : : {
1462 : : struct gpio_chip *chip;
1463 : : int status = -EPROBE_DEFER;
1464 : : unsigned long flags;
1465 : :
1466 [ # # ]: 0 : if (!desc) {
1467 : 0 : pr_warn("%s: invalid GPIO\n", __func__);
1468 : 0 : return -EINVAL;
1469 : : }
1470 : :
1471 : 0 : spin_lock_irqsave(&gpio_lock, flags);
1472 : :
1473 : 0 : chip = desc->chip;
1474 [ # # ]: 0 : if (chip == NULL)
1475 : : goto done;
1476 : :
1477 [ # # ]: 0 : if (!try_module_get(chip->owner))
1478 : : goto done;
1479 : :
1480 : : /* NOTE: gpio_request() can be called in early boot,
1481 : : * before IRQs are enabled, for non-sleeping (SOC) GPIOs.
1482 : : */
1483 : :
1484 [ # # ]: 0 : if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
1485 [ # # ]: 0 : desc_set_label(desc, label ? : "?");
1486 : : status = 0;
1487 : : } else {
1488 : : status = -EBUSY;
1489 : 0 : module_put(chip->owner);
1490 : 0 : goto done;
1491 : : }
1492 : :
1493 [ # # ]: 0 : if (chip->request) {
1494 : : /* chip->request may sleep */
1495 : : spin_unlock_irqrestore(&gpio_lock, flags);
1496 : 0 : status = chip->request(chip, gpio_chip_hwgpio(desc));
1497 : 0 : spin_lock_irqsave(&gpio_lock, flags);
1498 : :
1499 [ # # ]: 0 : if (status < 0) {
1500 : : desc_set_label(desc, NULL);
1501 : 0 : module_put(chip->owner);
1502 : 0 : clear_bit(FLAG_REQUESTED, &desc->flags);
1503 : 0 : goto done;
1504 : : }
1505 : : }
1506 [ # # ]: 0 : if (chip->get_direction) {
1507 : : /* chip->get_direction may sleep */
1508 : : spin_unlock_irqrestore(&gpio_lock, flags);
1509 : 0 : gpiod_get_direction(desc);
1510 : 0 : spin_lock_irqsave(&gpio_lock, flags);
1511 : : }
1512 : : done:
1513 : : if (status)
1514 : : gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1515 : : spin_unlock_irqrestore(&gpio_lock, flags);
1516 : 0 : return status;
1517 : : }
1518 : :
1519 : 0 : int gpio_request(unsigned gpio, const char *label)
1520 : : {
1521 : 0 : return gpiod_request(gpio_to_desc(gpio), label);
1522 : : }
1523 : : EXPORT_SYMBOL_GPL(gpio_request);
1524 : :
1525 : 0 : static void gpiod_free(struct gpio_desc *desc)
1526 : : {
1527 : : unsigned long flags;
1528 : : struct gpio_chip *chip;
1529 : :
1530 : : might_sleep();
1531 : :
1532 [ # # ]: 0 : if (!desc) {
1533 : : WARN_ON(extra_checks);
1534 : 0 : return;
1535 : : }
1536 : :
1537 : : gpiod_unexport(desc);
1538 : :
1539 : 0 : spin_lock_irqsave(&gpio_lock, flags);
1540 : :
1541 : 0 : chip = desc->chip;
1542 [ # # ][ # # ]: 0 : if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
1543 [ # # ]: 0 : if (chip->free) {
1544 : : spin_unlock_irqrestore(&gpio_lock, flags);
1545 : : might_sleep_if(chip->can_sleep);
1546 : 0 : chip->free(chip, gpio_chip_hwgpio(desc));
1547 : 0 : spin_lock_irqsave(&gpio_lock, flags);
1548 : : }
1549 : : desc_set_label(desc, NULL);
1550 : 0 : module_put(desc->chip->owner);
1551 : 0 : clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
1552 : 0 : clear_bit(FLAG_REQUESTED, &desc->flags);
1553 : 0 : clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
1554 : 0 : clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
1555 : : } else
1556 : : WARN_ON(extra_checks);
1557 : :
1558 : : spin_unlock_irqrestore(&gpio_lock, flags);
1559 : : }
1560 : :
1561 : 0 : void gpio_free(unsigned gpio)
1562 : : {
1563 : 0 : gpiod_free(gpio_to_desc(gpio));
1564 : 0 : }
1565 : : EXPORT_SYMBOL_GPL(gpio_free);
1566 : :
1567 : : /**
1568 : : * gpio_request_one - request a single GPIO with initial configuration
1569 : : * @gpio: the GPIO number
1570 : : * @flags: GPIO configuration as specified by GPIOF_*
1571 : : * @label: a literal description string of this GPIO
1572 : : */
1573 : 0 : int gpio_request_one(unsigned gpio, unsigned long flags, const char *label)
1574 : : {
1575 : : struct gpio_desc *desc;
1576 : : int err;
1577 : :
1578 : 0 : desc = gpio_to_desc(gpio);
1579 : :
1580 : 0 : err = gpiod_request(desc, label);
1581 [ # # ]: 0 : if (err)
1582 : : return err;
1583 : :
1584 [ # # ]: 0 : if (flags & GPIOF_OPEN_DRAIN)
1585 : 0 : set_bit(FLAG_OPEN_DRAIN, &desc->flags);
1586 : :
1587 [ # # ]: 0 : if (flags & GPIOF_OPEN_SOURCE)
1588 : 0 : set_bit(FLAG_OPEN_SOURCE, &desc->flags);
1589 : :
1590 [ # # ]: 0 : if (flags & GPIOF_DIR_IN)
1591 : 0 : err = gpiod_direction_input(desc);
1592 : : else
1593 : 0 : err = gpiod_direction_output(desc,
1594 : 0 : (flags & GPIOF_INIT_HIGH) ? 1 : 0);
1595 : :
1596 [ # # ]: 0 : if (err)
1597 : : goto free_gpio;
1598 : :
1599 [ # # ]: 0 : if (flags & GPIOF_EXPORT) {
1600 : : err = gpiod_export(desc, flags & GPIOF_EXPORT_CHANGEABLE);
1601 : : if (err)
1602 : : goto free_gpio;
1603 : : }
1604 : :
1605 : : return 0;
1606 : :
1607 : : free_gpio:
1608 : 0 : gpiod_free(desc);
1609 : 0 : return err;
1610 : : }
1611 : : EXPORT_SYMBOL_GPL(gpio_request_one);
1612 : :
1613 : : /**
1614 : : * gpio_request_array - request multiple GPIOs in a single call
1615 : : * @array: array of the 'struct gpio'
1616 : : * @num: how many GPIOs in the array
1617 : : */
1618 : 0 : int gpio_request_array(const struct gpio *array, size_t num)
1619 : : {
1620 : : int i, err;
1621 : :
1622 [ # # ]: 0 : for (i = 0; i < num; i++, array++) {
1623 : 0 : err = gpio_request_one(array->gpio, array->flags, array->label);
1624 [ # # ]: 0 : if (err)
1625 : : goto err_free;
1626 : : }
1627 : : return 0;
1628 : :
1629 : : err_free:
1630 [ # # ]: 0 : while (i--)
1631 : 0 : gpio_free((--array)->gpio);
1632 : : return err;
1633 : : }
1634 : : EXPORT_SYMBOL_GPL(gpio_request_array);
1635 : :
1636 : : /**
1637 : : * gpio_free_array - release multiple GPIOs in a single call
1638 : : * @array: array of the 'struct gpio'
1639 : : * @num: how many GPIOs in the array
1640 : : */
1641 : 0 : void gpio_free_array(const struct gpio *array, size_t num)
1642 : : {
1643 [ # # ]: 0 : while (num--)
1644 : 0 : gpio_free((array++)->gpio);
1645 : 0 : }
1646 : : EXPORT_SYMBOL_GPL(gpio_free_array);
1647 : :
1648 : : /**
1649 : : * gpiochip_is_requested - return string iff signal was requested
1650 : : * @chip: controller managing the signal
1651 : : * @offset: of signal within controller's 0..(ngpio - 1) range
1652 : : *
1653 : : * Returns NULL if the GPIO is not currently requested, else a string.
1654 : : * If debugfs support is enabled, the string returned is the label passed
1655 : : * to gpio_request(); otherwise it is a meaningless constant.
1656 : : *
1657 : : * This function is for use by GPIO controller drivers. The label can
1658 : : * help with diagnostics, and knowing that the signal is used as a GPIO
1659 : : * can help avoid accidentally multiplexing it to another controller.
1660 : : */
1661 : 0 : const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
1662 : : {
1663 : : struct gpio_desc *desc;
1664 : :
1665 [ # # ]: 0 : if (!GPIO_OFFSET_VALID(chip, offset))
1666 : : return NULL;
1667 : :
1668 : 0 : desc = &chip->desc[offset];
1669 : :
1670 [ # # ]: 0 : if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
1671 : : return NULL;
1672 : : #ifdef CONFIG_DEBUG_FS
1673 : 0 : return desc->label;
1674 : : #else
1675 : : return "?";
1676 : : #endif
1677 : : }
1678 : : EXPORT_SYMBOL_GPL(gpiochip_is_requested);
1679 : :
1680 : :
1681 : : /* Drivers MUST set GPIO direction before making get/set calls. In
1682 : : * some cases this is done in early boot, before IRQs are enabled.
1683 : : *
1684 : : * As a rule these aren't called more than once (except for drivers
1685 : : * using the open-drain emulation idiom) so these are natural places
1686 : : * to accumulate extra debugging checks. Note that we can't (yet)
1687 : : * rely on gpio_request() having been called beforehand.
1688 : : */
1689 : :
1690 : : /**
1691 : : * gpiod_direction_input - set the GPIO direction to input
1692 : : * @desc: GPIO to set to input
1693 : : *
1694 : : * Set the direction of the passed GPIO to input, such as gpiod_get_value() can
1695 : : * be called safely on it.
1696 : : *
1697 : : * Return 0 in case of success, else an error code.
1698 : : */
1699 : 0 : int gpiod_direction_input(struct gpio_desc *desc)
1700 : : {
1701 : : unsigned long flags;
1702 : : struct gpio_chip *chip;
1703 : : int status = -EINVAL;
1704 : : int offset;
1705 : :
1706 [ # # ][ # # ]: 0 : if (!desc || !desc->chip) {
1707 : 0 : pr_warn("%s: invalid GPIO\n", __func__);
1708 : 0 : return -EINVAL;
1709 : : }
1710 : :
1711 : : chip = desc->chip;
1712 [ # # ][ # # ]: 0 : if (!chip->get || !chip->direction_input) {
1713 [ # # ]: 0 : gpiod_warn(desc,
1714 : : "%s: missing get() or direction_input() operations\n",
1715 : : __func__);
1716 : 0 : return -EIO;
1717 : : }
1718 : :
1719 : 0 : spin_lock_irqsave(&gpio_lock, flags);
1720 : :
1721 : 0 : status = gpio_ensure_requested(desc);
1722 [ # # ]: 0 : if (status < 0)
1723 : : goto fail;
1724 : :
1725 : : /* now we know the gpio is valid and chip won't vanish */
1726 : :
1727 : : spin_unlock_irqrestore(&gpio_lock, flags);
1728 : :
1729 : : might_sleep_if(chip->can_sleep);
1730 : :
1731 : : offset = gpio_chip_hwgpio(desc);
1732 [ # # ]: 0 : if (status) {
1733 : 0 : status = chip->request(chip, offset);
1734 [ # # ]: 0 : if (status < 0) {
1735 : 0 : gpiod_dbg(desc, "%s: chip request fail, %d\n",
1736 : : __func__, status);
1737 : : /* and it's not available to anyone else ...
1738 : : * gpio_request() is the fully clean solution.
1739 : : */
1740 : : goto lose;
1741 : : }
1742 : : }
1743 : :
1744 : 0 : status = chip->direction_input(chip, offset);
1745 [ # # ]: 0 : if (status == 0)
1746 : 0 : clear_bit(FLAG_IS_OUT, &desc->flags);
1747 : :
1748 : 0 : trace_gpio_direction(desc_to_gpio(desc), 1, status);
1749 : : lose:
1750 : 0 : return status;
1751 : : fail:
1752 : : spin_unlock_irqrestore(&gpio_lock, flags);
1753 : : if (status)
1754 : : gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1755 : 0 : return status;
1756 : : }
1757 : : EXPORT_SYMBOL_GPL(gpiod_direction_input);
1758 : :
1759 : : /**
1760 : : * gpiod_direction_output - set the GPIO direction to input
1761 : : * @desc: GPIO to set to output
1762 : : * @value: initial output value of the GPIO
1763 : : *
1764 : : * Set the direction of the passed GPIO to output, such as gpiod_set_value() can
1765 : : * be called safely on it. The initial value of the output must be specified.
1766 : : *
1767 : : * Return 0 in case of success, else an error code.
1768 : : */
1769 : 0 : int gpiod_direction_output(struct gpio_desc *desc, int value)
1770 : : {
1771 : : unsigned long flags;
1772 : : struct gpio_chip *chip;
1773 : : int status = -EINVAL;
1774 : : int offset;
1775 : :
1776 [ # # ][ # # ]: 0 : if (!desc || !desc->chip) {
1777 : 0 : pr_warn("%s: invalid GPIO\n", __func__);
1778 : 0 : return -EINVAL;
1779 : : }
1780 : :
1781 : : /* GPIOs used for IRQs shall not be set as output */
1782 [ # # ]: 0 : if (test_bit(FLAG_USED_AS_IRQ, &desc->flags)) {
1783 [ # # ]: 0 : gpiod_err(desc,
1784 : : "%s: tried to set a GPIO tied to an IRQ as output\n",
1785 : : __func__);
1786 : 0 : return -EIO;
1787 : : }
1788 : :
1789 : : /* Open drain pin should not be driven to 1 */
1790 [ # # ][ # # ]: 0 : if (value && test_bit(FLAG_OPEN_DRAIN, &desc->flags))
1791 : 0 : return gpiod_direction_input(desc);
1792 : :
1793 : : /* Open source pin should not be driven to 0 */
1794 [ # # ][ # # ]: 0 : if (!value && test_bit(FLAG_OPEN_SOURCE, &desc->flags))
1795 : 0 : return gpiod_direction_input(desc);
1796 : :
1797 : : chip = desc->chip;
1798 [ # # ][ # # ]: 0 : if (!chip->set || !chip->direction_output) {
1799 [ # # ]: 0 : gpiod_warn(desc,
1800 : : "%s: missing set() or direction_output() operations\n",
1801 : : __func__);
1802 : 0 : return -EIO;
1803 : : }
1804 : :
1805 : 0 : spin_lock_irqsave(&gpio_lock, flags);
1806 : :
1807 : 0 : status = gpio_ensure_requested(desc);
1808 [ # # ]: 0 : if (status < 0)
1809 : : goto fail;
1810 : :
1811 : : /* now we know the gpio is valid and chip won't vanish */
1812 : :
1813 : : spin_unlock_irqrestore(&gpio_lock, flags);
1814 : :
1815 : : might_sleep_if(chip->can_sleep);
1816 : :
1817 : : offset = gpio_chip_hwgpio(desc);
1818 [ # # ]: 0 : if (status) {
1819 : 0 : status = chip->request(chip, offset);
1820 [ # # ]: 0 : if (status < 0) {
1821 : 0 : gpiod_dbg(desc, "%s: chip request fail, %d\n",
1822 : : __func__, status);
1823 : : /* and it's not available to anyone else ...
1824 : : * gpio_request() is the fully clean solution.
1825 : : */
1826 : : goto lose;
1827 : : }
1828 : : }
1829 : :
1830 : 0 : status = chip->direction_output(chip, offset, value);
1831 [ # # ]: 0 : if (status == 0)
1832 : 0 : set_bit(FLAG_IS_OUT, &desc->flags);
1833 : 0 : trace_gpio_value(desc_to_gpio(desc), 0, value);
1834 : : trace_gpio_direction(desc_to_gpio(desc), 0, status);
1835 : : lose:
1836 : 0 : return status;
1837 : : fail:
1838 : : spin_unlock_irqrestore(&gpio_lock, flags);
1839 : : if (status)
1840 : : gpiod_dbg(desc, "%s: gpio status %d\n", __func__, status);
1841 : 0 : return status;
1842 : : }
1843 : : EXPORT_SYMBOL_GPL(gpiod_direction_output);
1844 : :
1845 : : /**
1846 : : * gpiod_set_debounce - sets @debounce time for a @gpio
1847 : : * @gpio: the gpio to set debounce time
1848 : : * @debounce: debounce time is microseconds
1849 : : *
1850 : : * returns -ENOTSUPP if the controller does not support setting
1851 : : * debounce.
1852 : : */
1853 : 0 : int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
1854 : : {
1855 : : unsigned long flags;
1856 : : struct gpio_chip *chip;
1857 : : int status = -EINVAL;
1858 : : int offset;
1859 : :
1860 [ # # ][ # # ]: 0 : if (!desc || !desc->chip) {
1861 : 0 : pr_warn("%s: invalid GPIO\n", __func__);
1862 : 0 : return -EINVAL;
1863 : : }
1864 : :
1865 : : chip = desc->chip;
1866 [ # # ][ # # ]: 0 : if (!chip->set || !chip->set_debounce) {
1867 : 0 : gpiod_dbg(desc,
1868 : : "%s: missing set() or set_debounce() operations\n",
1869 : : __func__);
1870 : : return -ENOTSUPP;
1871 : : }
1872 : :
1873 : 0 : spin_lock_irqsave(&gpio_lock, flags);
1874 : :
1875 : 0 : status = gpio_ensure_requested(desc);
1876 [ # # ]: 0 : if (status < 0)
1877 : : goto fail;
1878 : :
1879 : : /* now we know the gpio is valid and chip won't vanish */
1880 : :
1881 : : spin_unlock_irqrestore(&gpio_lock, flags);
1882 : :
1883 : : might_sleep_if(chip->can_sleep);
1884 : :
1885 : : offset = gpio_chip_hwgpio(desc);
1886 : 0 : return chip->set_debounce(chip, offset, debounce);
1887 : :
1888 : : fail:
1889 : : spin_unlock_irqrestore(&gpio_lock, flags);
1890 : : if (status)
1891 : : gpiod_dbg(desc, "%s: status %d\n", __func__, status);
1892 : :
1893 : 0 : return status;
1894 : : }
1895 : : EXPORT_SYMBOL_GPL(gpiod_set_debounce);
1896 : :
1897 : : /**
1898 : : * gpiod_is_active_low - test whether a GPIO is active-low or not
1899 : : * @desc: the gpio descriptor to test
1900 : : *
1901 : : * Returns 1 if the GPIO is active-low, 0 otherwise.
1902 : : */
1903 : 0 : int gpiod_is_active_low(const struct gpio_desc *desc)
1904 : : {
1905 : 0 : return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
1906 : : }
1907 : : EXPORT_SYMBOL_GPL(gpiod_is_active_low);
1908 : :
1909 : : /* I/O calls are only valid after configuration completed; the relevant
1910 : : * "is this a valid GPIO" error checks should already have been done.
1911 : : *
1912 : : * "Get" operations are often inlinable as reading a pin value register,
1913 : : * and masking the relevant bit in that register.
1914 : : *
1915 : : * When "set" operations are inlinable, they involve writing that mask to
1916 : : * one register to set a low value, or a different register to set it high.
1917 : : * Otherwise locking is needed, so there may be little value to inlining.
1918 : : *
1919 : : *------------------------------------------------------------------------
1920 : : *
1921 : : * IMPORTANT!!! The hot paths -- get/set value -- assume that callers
1922 : : * have requested the GPIO. That can include implicit requesting by
1923 : : * a direction setting call. Marking a gpio as requested locks its chip
1924 : : * in memory, guaranteeing that these table lookups need no more locking
1925 : : * and that gpiochip_remove() will fail.
1926 : : *
1927 : : * REVISIT when debugging, consider adding some instrumentation to ensure
1928 : : * that the GPIO was actually requested.
1929 : : */
1930 : :
1931 : 0 : static int _gpiod_get_raw_value(const struct gpio_desc *desc)
1932 : : {
1933 : : struct gpio_chip *chip;
1934 : : int value;
1935 : : int offset;
1936 : :
1937 : 32934 : chip = desc->chip;
1938 : : offset = gpio_chip_hwgpio(desc);
1939 [ + - ]: 32934 : value = chip->get ? chip->get(chip, offset) : 0;
1940 : 32934 : trace_gpio_value(desc_to_gpio(desc), 1, value);
1941 : 32934 : return value;
1942 : : }
1943 : :
1944 : : /**
1945 : : * gpiod_get_raw_value() - return a gpio's raw value
1946 : : * @desc: gpio whose value will be returned
1947 : : *
1948 : : * Return the GPIO's raw value, i.e. the value of the physical line disregarding
1949 : : * its ACTIVE_LOW status.
1950 : : *
1951 : : * This function should be called from contexts where we cannot sleep, and will
1952 : : * complain if the GPIO chip functions potentially sleep.
1953 : : */
1954 : 0 : int gpiod_get_raw_value(const struct gpio_desc *desc)
1955 : : {
1956 [ # # ]: 0 : if (!desc)
1957 : : return 0;
1958 : : /* Should be using gpio_get_value_cansleep() */
1959 [ # # ]: 0 : WARN_ON(desc->chip->can_sleep);
1960 : 0 : return _gpiod_get_raw_value(desc);
1961 : : }
1962 : : EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
1963 : :
1964 : : /**
1965 : : * gpiod_get_value() - return a gpio's value
1966 : : * @desc: gpio whose value will be returned
1967 : : *
1968 : : * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
1969 : : * account.
1970 : : *
1971 : : * This function should be called from contexts where we cannot sleep, and will
1972 : : * complain if the GPIO chip functions potentially sleep.
1973 : : */
1974 : 0 : int gpiod_get_value(const struct gpio_desc *desc)
1975 : : {
1976 : : int value;
1977 [ # # ]: 0 : if (!desc)
1978 : : return 0;
1979 : : /* Should be using gpio_get_value_cansleep() */
1980 [ # # ]: 0 : WARN_ON(desc->chip->can_sleep);
1981 : :
1982 : 0 : value = _gpiod_get_raw_value(desc);
1983 [ # # ]: 0 : if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
1984 : 0 : value = !value;
1985 : :
1986 : 0 : return value;
1987 : : }
1988 : : EXPORT_SYMBOL_GPL(gpiod_get_value);
1989 : :
1990 : : /*
1991 : : * _gpio_set_open_drain_value() - Set the open drain gpio's value.
1992 : : * @desc: gpio descriptor whose state need to be set.
1993 : : * @value: Non-zero for setting it HIGH otherise it will set to LOW.
1994 : : */
1995 : 0 : static void _gpio_set_open_drain_value(struct gpio_desc *desc, int value)
1996 : : {
1997 : : int err = 0;
1998 : 0 : struct gpio_chip *chip = desc->chip;
1999 : : int offset = gpio_chip_hwgpio(desc);
2000 : :
2001 [ # # ]: 0 : if (value) {
2002 : 0 : err = chip->direction_input(chip, offset);
2003 [ # # ]: 0 : if (!err)
2004 : 0 : clear_bit(FLAG_IS_OUT, &desc->flags);
2005 : : } else {
2006 : 0 : err = chip->direction_output(chip, offset, 0);
2007 [ # # ]: 0 : if (!err)
2008 : 0 : set_bit(FLAG_IS_OUT, &desc->flags);
2009 : : }
2010 : 0 : trace_gpio_direction(desc_to_gpio(desc), value, err);
2011 [ # # ]: 0 : if (err < 0)
2012 [ # # ]: 0 : gpiod_err(desc,
2013 : : "%s: Error in set_value for open drain err %d\n",
2014 : : __func__, err);
2015 : 0 : }
2016 : :
2017 : : /*
2018 : : * _gpio_set_open_source_value() - Set the open source gpio's value.
2019 : : * @desc: gpio descriptor whose state need to be set.
2020 : : * @value: Non-zero for setting it HIGH otherise it will set to LOW.
2021 : : */
2022 : 0 : static void _gpio_set_open_source_value(struct gpio_desc *desc, int value)
2023 : : {
2024 : : int err = 0;
2025 : 0 : struct gpio_chip *chip = desc->chip;
2026 : : int offset = gpio_chip_hwgpio(desc);
2027 : :
2028 [ # # ]: 0 : if (value) {
2029 : 0 : err = chip->direction_output(chip, offset, 1);
2030 [ # # ]: 0 : if (!err)
2031 : 0 : set_bit(FLAG_IS_OUT, &desc->flags);
2032 : : } else {
2033 : 0 : err = chip->direction_input(chip, offset);
2034 [ # # ]: 0 : if (!err)
2035 : 0 : clear_bit(FLAG_IS_OUT, &desc->flags);
2036 : : }
2037 : 0 : trace_gpio_direction(desc_to_gpio(desc), !value, err);
2038 [ # # ]: 0 : if (err < 0)
2039 [ # # ]: 0 : gpiod_err(desc,
2040 : : "%s: Error in set_value for open source err %d\n",
2041 : : __func__, err);
2042 : 0 : }
2043 : :
2044 : 0 : static void _gpiod_set_raw_value(struct gpio_desc *desc, int value)
2045 : : {
2046 : : struct gpio_chip *chip;
2047 : :
2048 : 17265256 : chip = desc->chip;
2049 : 17265256 : trace_gpio_value(desc_to_gpio(desc), 0, value);
2050 [ - + ]: 34652834 : if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
2051 : 0 : _gpio_set_open_drain_value(desc, value);
2052 [ - + ]: 17387578 : else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
2053 : 0 : _gpio_set_open_source_value(desc, value);
2054 : : else
2055 : 17387578 : chip->set(chip, gpio_chip_hwgpio(desc), value);
2056 : 17370337 : }
2057 : :
2058 : : /**
2059 : : * gpiod_set_raw_value() - assign a gpio's raw value
2060 : : * @desc: gpio whose value will be assigned
2061 : : * @value: value to assign
2062 : : *
2063 : : * Set the raw value of the GPIO, i.e. the value of its physical line without
2064 : : * regard for its ACTIVE_LOW status.
2065 : : *
2066 : : * This function should be called from contexts where we cannot sleep, and will
2067 : : * complain if the GPIO chip functions potentially sleep.
2068 : : */
2069 : 0 : void gpiod_set_raw_value(struct gpio_desc *desc, int value)
2070 : : {
2071 [ + ]: 17471597 : if (!desc)
2072 : 17378324 : return;
2073 : : /* Should be using gpio_set_value_cansleep() */
2074 [ - + ]: 17477467 : WARN_ON(desc->chip->can_sleep);
2075 : 17477467 : _gpiod_set_raw_value(desc, value);
2076 : : }
2077 : : EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
2078 : :
2079 : : /**
2080 : : * gpiod_set_value() - assign a gpio's value
2081 : : * @desc: gpio whose value will be assigned
2082 : : * @value: value to assign
2083 : : *
2084 : : * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2085 : : * account
2086 : : *
2087 : : * This function should be called from contexts where we cannot sleep, and will
2088 : : * complain if the GPIO chip functions potentially sleep.
2089 : : */
2090 : 0 : void gpiod_set_value(struct gpio_desc *desc, int value)
2091 : : {
2092 [ # # ]: 0 : if (!desc)
2093 : 0 : return;
2094 : : /* Should be using gpio_set_value_cansleep() */
2095 [ # # ]: 0 : WARN_ON(desc->chip->can_sleep);
2096 [ # # ]: 0 : if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2097 : 0 : value = !value;
2098 : 0 : _gpiod_set_raw_value(desc, value);
2099 : : }
2100 : : EXPORT_SYMBOL_GPL(gpiod_set_value);
2101 : :
2102 : : /**
2103 : : * gpiod_cansleep() - report whether gpio value access may sleep
2104 : : * @desc: gpio to check
2105 : : *
2106 : : */
2107 : 0 : int gpiod_cansleep(const struct gpio_desc *desc)
2108 : : {
2109 [ # # ]: 0 : if (!desc)
2110 : : return 0;
2111 : 0 : return desc->chip->can_sleep;
2112 : : }
2113 : : EXPORT_SYMBOL_GPL(gpiod_cansleep);
2114 : :
2115 : : /**
2116 : : * gpiod_to_irq() - return the IRQ corresponding to a GPIO
2117 : : * @desc: gpio whose IRQ will be returned (already requested)
2118 : : *
2119 : : * Return the IRQ corresponding to the passed GPIO, or an error code in case of
2120 : : * error.
2121 : : */
2122 : 0 : int gpiod_to_irq(const struct gpio_desc *desc)
2123 : : {
2124 : : struct gpio_chip *chip;
2125 : : int offset;
2126 : :
2127 [ # # ]: 0 : if (!desc)
2128 : : return -EINVAL;
2129 : 0 : chip = desc->chip;
2130 : : offset = gpio_chip_hwgpio(desc);
2131 [ # # ]: 0 : return chip->to_irq ? chip->to_irq(chip, offset) : -ENXIO;
2132 : : }
2133 : : EXPORT_SYMBOL_GPL(gpiod_to_irq);
2134 : :
2135 : : /**
2136 : : * gpiod_lock_as_irq() - lock a GPIO to be used as IRQ
2137 : : * @gpio: the GPIO line to lock as used for IRQ
2138 : : *
2139 : : * This is used directly by GPIO drivers that want to lock down
2140 : : * a certain GPIO line to be used as IRQs, for example in the
2141 : : * .to_irq() callback of their gpio_chip, or in the .irq_enable()
2142 : : * of its irq_chip implementation if the GPIO is known from that
2143 : : * code.
2144 : : */
2145 : 0 : int gpiod_lock_as_irq(struct gpio_desc *desc)
2146 : : {
2147 [ # # ]: 0 : if (!desc)
2148 : : return -EINVAL;
2149 : :
2150 [ # # ]: 0 : if (test_bit(FLAG_IS_OUT, &desc->flags)) {
2151 [ # # ]: 0 : gpiod_err(desc,
2152 : : "%s: tried to flag a GPIO set as output for IRQ\n",
2153 : : __func__);
2154 : 0 : return -EIO;
2155 : : }
2156 : :
2157 : 0 : set_bit(FLAG_USED_AS_IRQ, &desc->flags);
2158 : 0 : return 0;
2159 : : }
2160 : : EXPORT_SYMBOL_GPL(gpiod_lock_as_irq);
2161 : :
2162 : 0 : int gpio_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
2163 : : {
2164 : 0 : return gpiod_lock_as_irq(gpiochip_offset_to_desc(chip, offset));
2165 : : }
2166 : : EXPORT_SYMBOL_GPL(gpio_lock_as_irq);
2167 : :
2168 : : /**
2169 : : * gpiod_unlock_as_irq() - unlock a GPIO used as IRQ
2170 : : * @gpio: the GPIO line to unlock from IRQ usage
2171 : : *
2172 : : * This is used directly by GPIO drivers that want to indicate
2173 : : * that a certain GPIO is no longer used exclusively for IRQ.
2174 : : */
2175 : 0 : void gpiod_unlock_as_irq(struct gpio_desc *desc)
2176 : : {
2177 [ # # ][ # # ]: 0 : if (!desc)
2178 : 0 : return;
2179 : :
2180 : 0 : clear_bit(FLAG_USED_AS_IRQ, &desc->flags);
2181 : : }
2182 : : EXPORT_SYMBOL_GPL(gpiod_unlock_as_irq);
2183 : :
2184 : 0 : void gpio_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
2185 : : {
2186 : 0 : return gpiod_unlock_as_irq(gpiochip_offset_to_desc(chip, offset));
2187 : : }
2188 : : EXPORT_SYMBOL_GPL(gpio_unlock_as_irq);
2189 : :
2190 : : /**
2191 : : * gpiod_get_raw_value_cansleep() - return a gpio's raw value
2192 : : * @desc: gpio whose value will be returned
2193 : : *
2194 : : * Return the GPIO's raw value, i.e. the value of the physical line disregarding
2195 : : * its ACTIVE_LOW status.
2196 : : *
2197 : : * This function is to be called from contexts that can sleep.
2198 : : */
2199 : 0 : int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
2200 : : {
2201 : : might_sleep_if(extra_checks);
2202 [ + - ]: 32934 : if (!desc)
2203 : : return 0;
2204 : 32934 : return _gpiod_get_raw_value(desc);
2205 : : }
2206 : : EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
2207 : :
2208 : : /**
2209 : : * gpiod_get_value_cansleep() - return a gpio's value
2210 : : * @desc: gpio whose value will be returned
2211 : : *
2212 : : * Return the GPIO's logical value, i.e. taking the ACTIVE_LOW status into
2213 : : * account.
2214 : : *
2215 : : * This function is to be called from contexts that can sleep.
2216 : : */
2217 : 0 : int gpiod_get_value_cansleep(const struct gpio_desc *desc)
2218 : : {
2219 : : int value;
2220 : :
2221 : : might_sleep_if(extra_checks);
2222 [ # # ]: 0 : if (!desc)
2223 : : return 0;
2224 : :
2225 : 0 : value = _gpiod_get_raw_value(desc);
2226 [ # # ]: 0 : if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2227 : 0 : value = !value;
2228 : :
2229 : 0 : return value;
2230 : : }
2231 : : EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
2232 : :
2233 : : /**
2234 : : * gpiod_set_raw_value_cansleep() - assign a gpio's raw value
2235 : : * @desc: gpio whose value will be assigned
2236 : : * @value: value to assign
2237 : : *
2238 : : * Set the raw value of the GPIO, i.e. the value of its physical line without
2239 : : * regard for its ACTIVE_LOW status.
2240 : : *
2241 : : * This function is to be called from contexts that can sleep.
2242 : : */
2243 : 0 : void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value)
2244 : : {
2245 : : might_sleep_if(extra_checks);
2246 [ # # ]: 0 : if (!desc)
2247 : 0 : return;
2248 : 0 : _gpiod_set_raw_value(desc, value);
2249 : : }
2250 : : EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
2251 : :
2252 : : /**
2253 : : * gpiod_set_value_cansleep() - assign a gpio's value
2254 : : * @desc: gpio whose value will be assigned
2255 : : * @value: value to assign
2256 : : *
2257 : : * Set the logical value of the GPIO, i.e. taking its ACTIVE_LOW status into
2258 : : * account
2259 : : *
2260 : : * This function is to be called from contexts that can sleep.
2261 : : */
2262 : 0 : void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
2263 : : {
2264 : : might_sleep_if(extra_checks);
2265 [ # # ]: 0 : if (!desc)
2266 : 0 : return;
2267 : :
2268 [ # # ]: 0 : if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
2269 : 0 : value = !value;
2270 : 0 : _gpiod_set_raw_value(desc, value);
2271 : : }
2272 : : EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
2273 : :
2274 : : /**
2275 : : * gpiod_add_lookup_table() - register GPIO device consumers
2276 : : * @table: table of consumers to register
2277 : : */
2278 : 0 : void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
2279 : : {
2280 : 0 : mutex_lock(&gpio_lookup_lock);
2281 : :
2282 : 0 : list_add_tail(&table->list, &gpio_lookup_list);
2283 : :
2284 : 0 : mutex_unlock(&gpio_lookup_lock);
2285 : 0 : }
2286 : :
2287 : : #ifdef CONFIG_OF
2288 : 0 : static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
2289 : : unsigned int idx,
2290 : : enum gpio_lookup_flags *flags)
2291 : : {
2292 : : char prop_name[32]; /* 32 is max size of property name */
2293 : : enum of_gpio_flags of_flags;
2294 : : struct gpio_desc *desc;
2295 : :
2296 [ # # ]: 0 : if (con_id)
2297 : 0 : snprintf(prop_name, 32, "%s-gpios", con_id);
2298 : : else
2299 : 0 : snprintf(prop_name, 32, "gpios");
2300 : :
2301 : 0 : desc = of_get_named_gpiod_flags(dev->of_node, prop_name, idx,
2302 : : &of_flags);
2303 : :
2304 [ # # ]: 0 : if (IS_ERR(desc))
2305 : : return desc;
2306 : :
2307 [ # # ]: 0 : if (of_flags & OF_GPIO_ACTIVE_LOW)
2308 : 0 : *flags |= GPIO_ACTIVE_LOW;
2309 : :
2310 : : return desc;
2311 : : }
2312 : : #else
2313 : : static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
2314 : : unsigned int idx,
2315 : : enum gpio_lookup_flags *flags)
2316 : : {
2317 : : return ERR_PTR(-ENODEV);
2318 : : }
2319 : : #endif
2320 : :
2321 : : static struct gpio_desc *acpi_find_gpio(struct device *dev, const char *con_id,
2322 : : unsigned int idx,
2323 : : enum gpio_lookup_flags *flags)
2324 : : {
2325 : : struct acpi_gpio_info info;
2326 : : struct gpio_desc *desc;
2327 : :
2328 : : desc = acpi_get_gpiod_by_index(dev, idx, &info);
2329 : : if (IS_ERR(desc))
2330 : : return desc;
2331 : :
2332 : : if (info.gpioint && info.active_low)
2333 : : *flags |= GPIO_ACTIVE_LOW;
2334 : :
2335 : : return desc;
2336 : : }
2337 : :
2338 : 0 : static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
2339 : : {
2340 [ # # ]: 0 : const char *dev_id = dev ? dev_name(dev) : NULL;
2341 : : struct gpiod_lookup_table *table;
2342 : :
2343 : 0 : mutex_lock(&gpio_lookup_lock);
2344 : :
2345 [ # # ]: 0 : list_for_each_entry(table, &gpio_lookup_list, list) {
2346 [ # # ][ # # ]: 0 : if (table->dev_id && dev_id) {
2347 : : /*
2348 : : * Valid strings on both ends, must be identical to have
2349 : : * a match
2350 : : */
2351 [ # # ]: 0 : if (!strcmp(table->dev_id, dev_id))
2352 : : goto found;
2353 : : } else {
2354 : : /*
2355 : : * One of the pointers is NULL, so both must be to have
2356 : : * a match
2357 : : */
2358 [ # # ]: 0 : if (dev_id == table->dev_id)
2359 : : goto found;
2360 : : }
2361 : : }
2362 : : table = NULL;
2363 : :
2364 : : found:
2365 : 0 : mutex_unlock(&gpio_lookup_lock);
2366 : 0 : return table;
2367 : : }
2368 : :
2369 : 0 : static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
2370 : : unsigned int idx,
2371 : : enum gpio_lookup_flags *flags)
2372 : : {
2373 : : struct gpio_desc *desc = ERR_PTR(-ENOENT);
2374 : : struct gpiod_lookup_table *table;
2375 : : struct gpiod_lookup *p;
2376 : :
2377 : 0 : table = gpiod_find_lookup_table(dev);
2378 [ # # ]: 0 : if (!table)
2379 : : return desc;
2380 : :
2381 [ # # ]: 0 : for (p = &table->table[0]; p->chip_label; p++) {
2382 : : struct gpio_chip *chip;
2383 : :
2384 : : /* idx must always match exactly */
2385 [ # # ]: 0 : if (p->idx != idx)
2386 : 0 : continue;
2387 : :
2388 : : /* If the lookup entry has a con_id, require exact match */
2389 [ # # ][ # # ]: 0 : if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
[ # # ]
2390 : 0 : continue;
2391 : :
2392 : : chip = find_chip_by_name(p->chip_label);
2393 : :
2394 [ # # ]: 0 : if (!chip) {
2395 : 0 : dev_err(dev, "cannot find GPIO chip %s\n",
2396 : : p->chip_label);
2397 : 0 : return ERR_PTR(-ENODEV);
2398 : : }
2399 : :
2400 [ # # ]: 0 : if (chip->ngpio <= p->chip_hwnum) {
2401 : 0 : dev_err(dev,
2402 : : "requested GPIO %d is out of range [0..%d] for chip %s\n",
2403 : : idx, chip->ngpio, chip->label);
2404 : 0 : return ERR_PTR(-EINVAL);
2405 : : }
2406 : :
2407 : 0 : desc = gpiochip_offset_to_desc(chip, p->chip_hwnum);
2408 : 0 : *flags = p->flags;
2409 : :
2410 : 0 : return desc;
2411 : : }
2412 : :
2413 : : return desc;
2414 : : }
2415 : :
2416 : : /**
2417 : : * gpio_get - obtain a GPIO for a given GPIO function
2418 : : * @dev: GPIO consumer, can be NULL for system-global GPIOs
2419 : : * @con_id: function within the GPIO consumer
2420 : : *
2421 : : * Return the GPIO descriptor corresponding to the function con_id of device
2422 : : * dev, -ENOENT if no GPIO has been assigned to the requested function, or
2423 : : * another IS_ERR() code if an error occured while trying to acquire the GPIO.
2424 : : */
2425 : 0 : struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id)
2426 : : {
2427 : 0 : return gpiod_get_index(dev, con_id, 0);
2428 : : }
2429 : : EXPORT_SYMBOL_GPL(gpiod_get);
2430 : :
2431 : : /**
2432 : : * gpiod_get_index - obtain a GPIO from a multi-index GPIO function
2433 : : * @dev: GPIO consumer, can be NULL for system-global GPIOs
2434 : : * @con_id: function within the GPIO consumer
2435 : : * @idx: index of the GPIO to obtain in the consumer
2436 : : *
2437 : : * This variant of gpiod_get() allows to access GPIOs other than the first
2438 : : * defined one for functions that define several GPIOs.
2439 : : *
2440 : : * Return a valid GPIO descriptor, -ENOENT if no GPIO has been assigned to the
2441 : : * requested function and/or index, or another IS_ERR() code if an error
2442 : : * occured while trying to acquire the GPIO.
2443 : : */
2444 : 0 : struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
2445 : : const char *con_id,
2446 : : unsigned int idx)
2447 : : {
2448 : : struct gpio_desc *desc = NULL;
2449 : : int status;
2450 : 0 : enum gpio_lookup_flags flags = 0;
2451 : :
2452 : : dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id);
2453 : :
2454 : : /* Using device tree? */
2455 [ # # ][ # # ]: 0 : if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node) {
2456 : : dev_dbg(dev, "using device tree for GPIO lookup\n");
2457 : 0 : desc = of_find_gpio(dev, con_id, idx, &flags);
2458 : : } else if (IS_ENABLED(CONFIG_ACPI) && dev && ACPI_HANDLE(dev)) {
2459 : : dev_dbg(dev, "using ACPI for GPIO lookup\n");
2460 : : desc = acpi_find_gpio(dev, con_id, idx, &flags);
2461 : : }
2462 : :
2463 : : /*
2464 : : * Either we are not using DT or ACPI, or their lookup did not return
2465 : : * a result. In that case, use platform lookup as a fallback.
2466 : : */
2467 [ # # ][ # # ]: 0 : if (!desc || desc == ERR_PTR(-ENOENT)) {
2468 : : dev_dbg(dev, "using lookup tables for GPIO lookup");
2469 : 0 : desc = gpiod_find(dev, con_id, idx, &flags);
2470 : : }
2471 : :
2472 [ # # ]: 0 : if (IS_ERR(desc)) {
2473 : : dev_dbg(dev, "lookup for GPIO %s failed\n", con_id);
2474 : : return desc;
2475 : : }
2476 : :
2477 : 0 : status = gpiod_request(desc, con_id);
2478 : :
2479 [ # # ]: 0 : if (status < 0)
2480 : 0 : return ERR_PTR(status);
2481 : :
2482 [ # # ]: 0 : if (flags & GPIO_ACTIVE_LOW)
2483 : 0 : set_bit(FLAG_ACTIVE_LOW, &desc->flags);
2484 [ # # ]: 0 : if (flags & GPIO_OPEN_DRAIN)
2485 : 0 : set_bit(FLAG_OPEN_DRAIN, &desc->flags);
2486 [ # # ]: 0 : if (flags & GPIO_OPEN_SOURCE)
2487 : 0 : set_bit(FLAG_OPEN_SOURCE, &desc->flags);
2488 : :
2489 : 0 : return desc;
2490 : : }
2491 : : EXPORT_SYMBOL_GPL(gpiod_get_index);
2492 : :
2493 : : /**
2494 : : * gpiod_put - dispose of a GPIO descriptor
2495 : : * @desc: GPIO descriptor to dispose of
2496 : : *
2497 : : * No descriptor can be used after gpiod_put() has been called on it.
2498 : : */
2499 : 0 : void gpiod_put(struct gpio_desc *desc)
2500 : : {
2501 : 0 : gpiod_free(desc);
2502 : 0 : }
2503 : : EXPORT_SYMBOL_GPL(gpiod_put);
2504 : :
2505 : : #ifdef CONFIG_DEBUG_FS
2506 : :
2507 : 0 : static void gpiolib_dbg_show(struct seq_file *s, struct gpio_chip *chip)
2508 : : {
2509 : : unsigned i;
2510 : 0 : unsigned gpio = chip->base;
2511 : 0 : struct gpio_desc *gdesc = &chip->desc[0];
2512 : : int is_out;
2513 : : int is_irq;
2514 : :
2515 [ # # ]: 0 : for (i = 0; i < chip->ngpio; i++, gpio++, gdesc++) {
2516 [ # # ]: 0 : if (!test_bit(FLAG_REQUESTED, &gdesc->flags))
2517 : 0 : continue;
2518 : :
2519 : 0 : gpiod_get_direction(gdesc);
2520 : : is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
2521 : : is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
2522 [ # # ][ # # ]: 0 : seq_printf(s, " gpio-%-3d (%-20.20s) %s %s %s",
[ # # ]
2523 : : gpio, gdesc->label,
2524 : : is_out ? "out" : "in ",
2525 : 0 : chip->get
2526 [ # # ]: 0 : ? (chip->get(chip, i) ? "hi" : "lo")
2527 : : : "? ",
2528 : : is_irq ? "IRQ" : " ");
2529 : 0 : seq_printf(s, "\n");
2530 : : }
2531 : 0 : }
2532 : :
2533 : 0 : static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
2534 : : {
2535 : : unsigned long flags;
2536 : : struct gpio_chip *chip = NULL;
2537 : 0 : loff_t index = *pos;
2538 : :
2539 : 0 : s->private = "";
2540 : :
2541 : 0 : spin_lock_irqsave(&gpio_lock, flags);
2542 [ # # ]: 0 : list_for_each_entry(chip, &gpio_chips, list)
2543 [ # # ]: 0 : if (index-- == 0) {
2544 : : spin_unlock_irqrestore(&gpio_lock, flags);
2545 : 0 : return chip;
2546 : : }
2547 : : spin_unlock_irqrestore(&gpio_lock, flags);
2548 : :
2549 : 0 : return NULL;
2550 : : }
2551 : :
2552 : 0 : static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
2553 : : {
2554 : : unsigned long flags;
2555 : : struct gpio_chip *chip = v;
2556 : : void *ret = NULL;
2557 : :
2558 : 0 : spin_lock_irqsave(&gpio_lock, flags);
2559 [ # # ]: 0 : if (list_is_last(&chip->list, &gpio_chips))
2560 : : ret = NULL;
2561 : : else
2562 : 0 : ret = list_entry(chip->list.next, struct gpio_chip, list);
2563 : : spin_unlock_irqrestore(&gpio_lock, flags);
2564 : :
2565 : 0 : s->private = "\n";
2566 : 0 : ++*pos;
2567 : :
2568 : 0 : return ret;
2569 : : }
2570 : :
2571 : 0 : static void gpiolib_seq_stop(struct seq_file *s, void *v)
2572 : : {
2573 : 0 : }
2574 : :
2575 : 0 : static int gpiolib_seq_show(struct seq_file *s, void *v)
2576 : : {
2577 : : struct gpio_chip *chip = v;
2578 : : struct device *dev;
2579 : :
2580 : 0 : seq_printf(s, "%sGPIOs %d-%d", (char *)s->private,
2581 : 0 : chip->base, chip->base + chip->ngpio - 1);
2582 : 0 : dev = chip->dev;
2583 [ # # ]: 0 : if (dev)
2584 [ # # ]: 0 : seq_printf(s, ", %s/%s", dev->bus ? dev->bus->name : "no-bus",
2585 : : dev_name(dev));
2586 [ # # ]: 0 : if (chip->label)
2587 : 0 : seq_printf(s, ", %s", chip->label);
2588 [ # # ]: 0 : if (chip->can_sleep)
2589 : 0 : seq_printf(s, ", can sleep");
2590 : 0 : seq_printf(s, ":\n");
2591 : :
2592 [ # # ]: 0 : if (chip->dbg_show)
2593 : 0 : chip->dbg_show(s, chip);
2594 : : else
2595 : 0 : gpiolib_dbg_show(s, chip);
2596 : :
2597 : 0 : return 0;
2598 : : }
2599 : :
2600 : : static const struct seq_operations gpiolib_seq_ops = {
2601 : : .start = gpiolib_seq_start,
2602 : : .next = gpiolib_seq_next,
2603 : : .stop = gpiolib_seq_stop,
2604 : : .show = gpiolib_seq_show,
2605 : : };
2606 : :
2607 : 0 : static int gpiolib_open(struct inode *inode, struct file *file)
2608 : : {
2609 : 0 : return seq_open(file, &gpiolib_seq_ops);
2610 : : }
2611 : :
2612 : : static const struct file_operations gpiolib_operations = {
2613 : : .owner = THIS_MODULE,
2614 : : .open = gpiolib_open,
2615 : : .read = seq_read,
2616 : : .llseek = seq_lseek,
2617 : : .release = seq_release,
2618 : : };
2619 : :
2620 : 0 : static int __init gpiolib_debugfs_init(void)
2621 : : {
2622 : : /* /sys/kernel/debug/gpio */
2623 : 0 : (void) debugfs_create_file("gpio", S_IFREG | S_IRUGO,
2624 : : NULL, NULL, &gpiolib_operations);
2625 : 0 : return 0;
2626 : : }
2627 : : subsys_initcall(gpiolib_debugfs_init);
2628 : :
2629 : : #endif /* DEBUG_FS */
|
