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