1
2#include <linux/bitmap.h>
3#include <linux/kernel.h>
4#include <linux/module.h>
5#include <linux/interrupt.h>
6#include <linux/irq.h>
7#include <linux/spinlock.h>
8#include <linux/list.h>
9#include <linux/device.h>
10#include <linux/err.h>
11#include <linux/debugfs.h>
12#include <linux/seq_file.h>
13#include <linux/gpio.h>
14#include <linux/idr.h>
15#include <linux/slab.h>
16#include <linux/acpi.h>
17#include <linux/gpio/driver.h>
18#include <linux/gpio/machine.h>
19#include <linux/pinctrl/consumer.h>
20#include <linux/cdev.h>
21#include <linux/fs.h>
22#include <linux/uaccess.h>
23#include <linux/compat.h>
24#include <linux/anon_inodes.h>
25#include <linux/file.h>
26#include <linux/kfifo.h>
27#include <linux/poll.h>
28#include <linux/timekeeping.h>
29#include <uapi/linux/gpio.h>
30
31#include "gpiolib.h"
32#include "gpiolib-of.h"
33#include "gpiolib-acpi.h"
34
35#define CREATE_TRACE_POINTS
36#include <trace/events/gpio.h>
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52#ifdef DEBUG
53#define extra_checks 1
54#else
55#define extra_checks 0
56#endif
57
58
59static DEFINE_IDA(gpio_ida);
60static dev_t gpio_devt;
61#define GPIO_DEV_MAX 256
62static struct bus_type gpio_bus_type = {
63 .name = "gpio",
64};
65
66
67
68
69#define FASTPATH_NGPIO CONFIG_GPIOLIB_FASTPATH_LIMIT
70
71
72
73
74
75DEFINE_SPINLOCK(gpio_lock);
76
77static DEFINE_MUTEX(gpio_lookup_lock);
78static LIST_HEAD(gpio_lookup_list);
79LIST_HEAD(gpio_devices);
80
81static DEFINE_MUTEX(gpio_machine_hogs_mutex);
82static LIST_HEAD(gpio_machine_hogs);
83
84static void gpiochip_free_hogs(struct gpio_chip *chip);
85static int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
86 struct lock_class_key *lock_key,
87 struct lock_class_key *request_key);
88static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);
89static int gpiochip_irqchip_init_hw(struct gpio_chip *gpiochip);
90static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip);
91static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip);
92
93static bool gpiolib_initialized;
94
95static inline void desc_set_label(struct gpio_desc *d, const char *label)
96{
97 d->label = label;
98}
99
100
101
102
103
104
105
106
107
108struct gpio_desc *gpio_to_desc(unsigned gpio)
109{
110 struct gpio_device *gdev;
111 unsigned long flags;
112
113 spin_lock_irqsave(&gpio_lock, flags);
114
115 list_for_each_entry(gdev, &gpio_devices, list) {
116 if (gdev->base <= gpio &&
117 gdev->base + gdev->ngpio > gpio) {
118 spin_unlock_irqrestore(&gpio_lock, flags);
119 return &gdev->descs[gpio - gdev->base];
120 }
121 }
122
123 spin_unlock_irqrestore(&gpio_lock, flags);
124
125 if (!gpio_is_valid(gpio))
126 WARN(1, "invalid GPIO %d\n", gpio);
127
128 return NULL;
129}
130EXPORT_SYMBOL_GPL(gpio_to_desc);
131
132
133
134
135
136
137
138
139
140
141
142struct gpio_desc *gpiochip_get_desc(struct gpio_chip *chip,
143 unsigned int hwnum)
144{
145 struct gpio_device *gdev = chip->gpiodev;
146
147 if (hwnum >= gdev->ngpio)
148 return ERR_PTR(-EINVAL);
149
150 return &gdev->descs[hwnum];
151}
152
153
154
155
156
157
158
159
160
161
162
163int desc_to_gpio(const struct gpio_desc *desc)
164{
165 return desc->gdev->base + (desc - &desc->gdev->descs[0]);
166}
167EXPORT_SYMBOL_GPL(desc_to_gpio);
168
169
170
171
172
173
174struct gpio_chip *gpiod_to_chip(const struct gpio_desc *desc)
175{
176 if (!desc || !desc->gdev)
177 return NULL;
178 return desc->gdev->chip;
179}
180EXPORT_SYMBOL_GPL(gpiod_to_chip);
181
182
183static int gpiochip_find_base(int ngpio)
184{
185 struct gpio_device *gdev;
186 int base = ARCH_NR_GPIOS - ngpio;
187
188 list_for_each_entry_reverse(gdev, &gpio_devices, list) {
189
190 if (gdev->base + gdev->ngpio <= base)
191 break;
192 else
193
194 base = gdev->base - ngpio;
195 }
196
197 if (gpio_is_valid(base)) {
198 pr_debug("%s: found new base at %d\n", __func__, base);
199 return base;
200 } else {
201 pr_err("%s: cannot find free range\n", __func__);
202 return -ENOSPC;
203 }
204}
205
206
207
208
209
210
211
212
213
214int gpiod_get_direction(struct gpio_desc *desc)
215{
216 struct gpio_chip *chip;
217 unsigned offset;
218 int ret;
219
220 chip = gpiod_to_chip(desc);
221 offset = gpio_chip_hwgpio(desc);
222
223
224
225
226
227 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) &&
228 test_bit(FLAG_IS_OUT, &desc->flags))
229 return 0;
230
231 if (!chip->get_direction)
232 return -ENOTSUPP;
233
234 ret = chip->get_direction(chip, offset);
235 if (ret < 0)
236 return ret;
237
238
239 if (ret > 0)
240 ret = 1;
241
242 assign_bit(FLAG_IS_OUT, &desc->flags, !ret);
243
244 return ret;
245}
246EXPORT_SYMBOL_GPL(gpiod_get_direction);
247
248
249
250
251
252
253
254
255static int gpiodev_add_to_list(struct gpio_device *gdev)
256{
257 struct gpio_device *prev, *next;
258
259 if (list_empty(&gpio_devices)) {
260
261 list_add_tail(&gdev->list, &gpio_devices);
262 return 0;
263 }
264
265 next = list_entry(gpio_devices.next, struct gpio_device, list);
266 if (gdev->base + gdev->ngpio <= next->base) {
267
268 list_add(&gdev->list, &gpio_devices);
269 return 0;
270 }
271
272 prev = list_entry(gpio_devices.prev, struct gpio_device, list);
273 if (prev->base + prev->ngpio <= gdev->base) {
274
275 list_add_tail(&gdev->list, &gpio_devices);
276 return 0;
277 }
278
279 list_for_each_entry_safe(prev, next, &gpio_devices, list) {
280
281 if (&next->list == &gpio_devices)
282 break;
283
284
285 if (prev->base + prev->ngpio <= gdev->base
286 && gdev->base + gdev->ngpio <= next->base) {
287 list_add(&gdev->list, &prev->list);
288 return 0;
289 }
290 }
291
292 dev_err(&gdev->dev, "GPIO integer space overlap, cannot add chip\n");
293 return -EBUSY;
294}
295
296
297
298
299static struct gpio_desc *gpio_name_to_desc(const char * const name)
300{
301 struct gpio_device *gdev;
302 unsigned long flags;
303
304 spin_lock_irqsave(&gpio_lock, flags);
305
306 list_for_each_entry(gdev, &gpio_devices, list) {
307 int i;
308
309 for (i = 0; i != gdev->ngpio; ++i) {
310 struct gpio_desc *desc = &gdev->descs[i];
311
312 if (!desc->name || !name)
313 continue;
314
315 if (!strcmp(desc->name, name)) {
316 spin_unlock_irqrestore(&gpio_lock, flags);
317 return desc;
318 }
319 }
320 }
321
322 spin_unlock_irqrestore(&gpio_lock, flags);
323
324 return NULL;
325}
326
327
328
329
330
331
332
333static int gpiochip_set_desc_names(struct gpio_chip *gc)
334{
335 struct gpio_device *gdev = gc->gpiodev;
336 int i;
337
338 if (!gc->names)
339 return 0;
340
341
342 for (i = 0; i != gc->ngpio; ++i) {
343 struct gpio_desc *gpio;
344
345 gpio = gpio_name_to_desc(gc->names[i]);
346 if (gpio)
347 dev_warn(&gdev->dev,
348 "Detected name collision for GPIO name '%s'\n",
349 gc->names[i]);
350 }
351
352
353 for (i = 0; i != gc->ngpio; ++i)
354 gdev->descs[i].name = gc->names[i];
355
356 return 0;
357}
358
359static unsigned long *gpiochip_allocate_mask(struct gpio_chip *chip)
360{
361 unsigned long *p;
362
363 p = bitmap_alloc(chip->ngpio, GFP_KERNEL);
364 if (!p)
365 return NULL;
366
367
368 bitmap_fill(p, chip->ngpio);
369
370 return p;
371}
372
373static int gpiochip_alloc_valid_mask(struct gpio_chip *gc)
374{
375 if (!(of_gpio_need_valid_mask(gc) || gc->init_valid_mask))
376 return 0;
377
378 gc->valid_mask = gpiochip_allocate_mask(gc);
379 if (!gc->valid_mask)
380 return -ENOMEM;
381
382 return 0;
383}
384
385static int gpiochip_init_valid_mask(struct gpio_chip *gc)
386{
387 if (gc->init_valid_mask)
388 return gc->init_valid_mask(gc,
389 gc->valid_mask,
390 gc->ngpio);
391
392 return 0;
393}
394
395static void gpiochip_free_valid_mask(struct gpio_chip *gpiochip)
396{
397 bitmap_free(gpiochip->valid_mask);
398 gpiochip->valid_mask = NULL;
399}
400
401static int gpiochip_add_pin_ranges(struct gpio_chip *gc)
402{
403 if (gc->add_pin_ranges)
404 return gc->add_pin_ranges(gc);
405
406 return 0;
407}
408
409bool gpiochip_line_is_valid(const struct gpio_chip *gpiochip,
410 unsigned int offset)
411{
412
413 if (likely(!gpiochip->valid_mask))
414 return true;
415 return test_bit(offset, gpiochip->valid_mask);
416}
417EXPORT_SYMBOL_GPL(gpiochip_line_is_valid);
418
419
420
421
422
423
424
425
426
427
428
429
430struct linehandle_state {
431 struct gpio_device *gdev;
432 const char *label;
433 struct gpio_desc *descs[GPIOHANDLES_MAX];
434 u32 numdescs;
435};
436
437#define GPIOHANDLE_REQUEST_VALID_FLAGS \
438 (GPIOHANDLE_REQUEST_INPUT | \
439 GPIOHANDLE_REQUEST_OUTPUT | \
440 GPIOHANDLE_REQUEST_ACTIVE_LOW | \
441 GPIOHANDLE_REQUEST_BIAS_PULL_UP | \
442 GPIOHANDLE_REQUEST_BIAS_PULL_DOWN | \
443 GPIOHANDLE_REQUEST_BIAS_DISABLE | \
444 GPIOHANDLE_REQUEST_OPEN_DRAIN | \
445 GPIOHANDLE_REQUEST_OPEN_SOURCE)
446
447static int linehandle_validate_flags(u32 flags)
448{
449
450 if (flags & ~GPIOHANDLE_REQUEST_VALID_FLAGS)
451 return -EINVAL;
452
453
454
455
456
457 if ((flags & GPIOHANDLE_REQUEST_INPUT) &&
458 (flags & GPIOHANDLE_REQUEST_OUTPUT))
459 return -EINVAL;
460
461
462
463
464
465
466 if ((flags & GPIOHANDLE_REQUEST_OPEN_DRAIN) &&
467 (flags & GPIOHANDLE_REQUEST_OPEN_SOURCE))
468 return -EINVAL;
469
470
471 if (!(flags & GPIOHANDLE_REQUEST_OUTPUT) &&
472 ((flags & GPIOHANDLE_REQUEST_OPEN_DRAIN) ||
473 (flags & GPIOHANDLE_REQUEST_OPEN_SOURCE)))
474 return -EINVAL;
475
476
477 if (!((flags & GPIOHANDLE_REQUEST_INPUT) ||
478 (flags & GPIOHANDLE_REQUEST_OUTPUT)) &&
479 ((flags & GPIOHANDLE_REQUEST_BIAS_DISABLE) ||
480 (flags & GPIOHANDLE_REQUEST_BIAS_PULL_UP) ||
481 (flags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN)))
482 return -EINVAL;
483
484
485 if (((flags & GPIOHANDLE_REQUEST_BIAS_DISABLE) &&
486 (flags & (GPIOHANDLE_REQUEST_BIAS_PULL_DOWN |
487 GPIOHANDLE_REQUEST_BIAS_PULL_UP))) ||
488 ((flags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN) &&
489 (flags & GPIOHANDLE_REQUEST_BIAS_PULL_UP)))
490 return -EINVAL;
491
492 return 0;
493}
494
495static long linehandle_set_config(struct linehandle_state *lh,
496 void __user *ip)
497{
498 struct gpiohandle_config gcnf;
499 struct gpio_desc *desc;
500 int i, ret;
501 u32 lflags;
502 unsigned long *flagsp;
503
504 if (copy_from_user(&gcnf, ip, sizeof(gcnf)))
505 return -EFAULT;
506
507 lflags = gcnf.flags;
508 ret = linehandle_validate_flags(lflags);
509 if (ret)
510 return ret;
511
512 for (i = 0; i < lh->numdescs; i++) {
513 desc = lh->descs[i];
514 flagsp = &desc->flags;
515
516 assign_bit(FLAG_ACTIVE_LOW, flagsp,
517 lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW);
518
519 assign_bit(FLAG_OPEN_DRAIN, flagsp,
520 lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN);
521
522 assign_bit(FLAG_OPEN_SOURCE, flagsp,
523 lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE);
524
525 assign_bit(FLAG_PULL_UP, flagsp,
526 lflags & GPIOHANDLE_REQUEST_BIAS_PULL_UP);
527
528 assign_bit(FLAG_PULL_DOWN, flagsp,
529 lflags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN);
530
531 assign_bit(FLAG_BIAS_DISABLE, flagsp,
532 lflags & GPIOHANDLE_REQUEST_BIAS_DISABLE);
533
534
535
536
537
538 if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
539 int val = !!gcnf.default_values[i];
540
541 ret = gpiod_direction_output(desc, val);
542 if (ret)
543 return ret;
544 } else if (lflags & GPIOHANDLE_REQUEST_INPUT) {
545 ret = gpiod_direction_input(desc);
546 if (ret)
547 return ret;
548 }
549 }
550 return 0;
551}
552
553static long linehandle_ioctl(struct file *filep, unsigned int cmd,
554 unsigned long arg)
555{
556 struct linehandle_state *lh = filep->private_data;
557 void __user *ip = (void __user *)arg;
558 struct gpiohandle_data ghd;
559 DECLARE_BITMAP(vals, GPIOHANDLES_MAX);
560 int i;
561
562 if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
563
564 int ret = gpiod_get_array_value_complex(false,
565 true,
566 lh->numdescs,
567 lh->descs,
568 NULL,
569 vals);
570 if (ret)
571 return ret;
572
573 memset(&ghd, 0, sizeof(ghd));
574 for (i = 0; i < lh->numdescs; i++)
575 ghd.values[i] = test_bit(i, vals);
576
577 if (copy_to_user(ip, &ghd, sizeof(ghd)))
578 return -EFAULT;
579
580 return 0;
581 } else if (cmd == GPIOHANDLE_SET_LINE_VALUES_IOCTL) {
582
583
584
585
586 if (!test_bit(FLAG_IS_OUT, &lh->descs[0]->flags))
587 return -EPERM;
588
589 if (copy_from_user(&ghd, ip, sizeof(ghd)))
590 return -EFAULT;
591
592
593 for (i = 0; i < lh->numdescs; i++)
594 __assign_bit(i, vals, ghd.values[i]);
595
596
597 return gpiod_set_array_value_complex(false,
598 true,
599 lh->numdescs,
600 lh->descs,
601 NULL,
602 vals);
603 } else if (cmd == GPIOHANDLE_SET_CONFIG_IOCTL) {
604 return linehandle_set_config(lh, ip);
605 }
606 return -EINVAL;
607}
608
609#ifdef CONFIG_COMPAT
610static long linehandle_ioctl_compat(struct file *filep, unsigned int cmd,
611 unsigned long arg)
612{
613 return linehandle_ioctl(filep, cmd, (unsigned long)compat_ptr(arg));
614}
615#endif
616
617static int linehandle_release(struct inode *inode, struct file *filep)
618{
619 struct linehandle_state *lh = filep->private_data;
620 struct gpio_device *gdev = lh->gdev;
621 int i;
622
623 for (i = 0; i < lh->numdescs; i++)
624 gpiod_free(lh->descs[i]);
625 kfree(lh->label);
626 kfree(lh);
627 put_device(&gdev->dev);
628 return 0;
629}
630
631static const struct file_operations linehandle_fileops = {
632 .release = linehandle_release,
633 .owner = THIS_MODULE,
634 .llseek = noop_llseek,
635 .unlocked_ioctl = linehandle_ioctl,
636#ifdef CONFIG_COMPAT
637 .compat_ioctl = linehandle_ioctl_compat,
638#endif
639};
640
641static int linehandle_create(struct gpio_device *gdev, void __user *ip)
642{
643 struct gpiohandle_request handlereq;
644 struct linehandle_state *lh;
645 struct file *file;
646 int fd, i, count = 0, ret;
647 u32 lflags;
648
649 if (copy_from_user(&handlereq, ip, sizeof(handlereq)))
650 return -EFAULT;
651 if ((handlereq.lines == 0) || (handlereq.lines > GPIOHANDLES_MAX))
652 return -EINVAL;
653
654 lflags = handlereq.flags;
655
656 ret = linehandle_validate_flags(lflags);
657 if (ret)
658 return ret;
659
660 lh = kzalloc(sizeof(*lh), GFP_KERNEL);
661 if (!lh)
662 return -ENOMEM;
663 lh->gdev = gdev;
664 get_device(&gdev->dev);
665
666
667 handlereq.consumer_label[sizeof(handlereq.consumer_label)-1] = '\0';
668 if (strlen(handlereq.consumer_label)) {
669 lh->label = kstrdup(handlereq.consumer_label,
670 GFP_KERNEL);
671 if (!lh->label) {
672 ret = -ENOMEM;
673 goto out_free_lh;
674 }
675 }
676
677
678 for (i = 0; i < handlereq.lines; i++) {
679 u32 offset = handlereq.lineoffsets[i];
680 struct gpio_desc *desc = gpiochip_get_desc(gdev->chip, offset);
681
682 if (IS_ERR(desc)) {
683 ret = PTR_ERR(desc);
684 goto out_free_descs;
685 }
686
687 ret = gpiod_request(desc, lh->label);
688 if (ret)
689 goto out_free_descs;
690 lh->descs[i] = desc;
691 count = i + 1;
692
693 if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
694 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
695 if (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN)
696 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
697 if (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE)
698 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
699 if (lflags & GPIOHANDLE_REQUEST_BIAS_DISABLE)
700 set_bit(FLAG_BIAS_DISABLE, &desc->flags);
701 if (lflags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN)
702 set_bit(FLAG_PULL_DOWN, &desc->flags);
703 if (lflags & GPIOHANDLE_REQUEST_BIAS_PULL_UP)
704 set_bit(FLAG_PULL_UP, &desc->flags);
705
706 ret = gpiod_set_transitory(desc, false);
707 if (ret < 0)
708 goto out_free_descs;
709
710
711
712
713
714 if (lflags & GPIOHANDLE_REQUEST_OUTPUT) {
715 int val = !!handlereq.default_values[i];
716
717 ret = gpiod_direction_output(desc, val);
718 if (ret)
719 goto out_free_descs;
720 } else if (lflags & GPIOHANDLE_REQUEST_INPUT) {
721 ret = gpiod_direction_input(desc);
722 if (ret)
723 goto out_free_descs;
724 }
725 dev_dbg(&gdev->dev, "registered chardev handle for line %d\n",
726 offset);
727 }
728
729 i--;
730 lh->numdescs = handlereq.lines;
731
732 fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
733 if (fd < 0) {
734 ret = fd;
735 goto out_free_descs;
736 }
737
738 file = anon_inode_getfile("gpio-linehandle",
739 &linehandle_fileops,
740 lh,
741 O_RDONLY | O_CLOEXEC);
742 if (IS_ERR(file)) {
743 ret = PTR_ERR(file);
744 goto out_put_unused_fd;
745 }
746
747 handlereq.fd = fd;
748 if (copy_to_user(ip, &handlereq, sizeof(handlereq))) {
749
750
751
752
753 fput(file);
754 put_unused_fd(fd);
755 return -EFAULT;
756 }
757
758 fd_install(fd, file);
759
760 dev_dbg(&gdev->dev, "registered chardev handle for %d lines\n",
761 lh->numdescs);
762
763 return 0;
764
765out_put_unused_fd:
766 put_unused_fd(fd);
767out_free_descs:
768 for (i = 0; i < count; i++)
769 gpiod_free(lh->descs[i]);
770 kfree(lh->label);
771out_free_lh:
772 kfree(lh);
773 put_device(&gdev->dev);
774 return ret;
775}
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796struct lineevent_state {
797 struct gpio_device *gdev;
798 const char *label;
799 struct gpio_desc *desc;
800 u32 eflags;
801 int irq;
802 wait_queue_head_t wait;
803 DECLARE_KFIFO(events, struct gpioevent_data, 16);
804 struct mutex read_lock;
805 u64 timestamp;
806};
807
808#define GPIOEVENT_REQUEST_VALID_FLAGS \
809 (GPIOEVENT_REQUEST_RISING_EDGE | \
810 GPIOEVENT_REQUEST_FALLING_EDGE)
811
812static __poll_t lineevent_poll(struct file *filep,
813 struct poll_table_struct *wait)
814{
815 struct lineevent_state *le = filep->private_data;
816 __poll_t events = 0;
817
818 poll_wait(filep, &le->wait, wait);
819
820 if (!kfifo_is_empty(&le->events))
821 events = EPOLLIN | EPOLLRDNORM;
822
823 return events;
824}
825
826
827static ssize_t lineevent_read(struct file *filep,
828 char __user *buf,
829 size_t count,
830 loff_t *f_ps)
831{
832 struct lineevent_state *le = filep->private_data;
833 unsigned int copied;
834 int ret;
835
836 if (count < sizeof(struct gpioevent_data))
837 return -EINVAL;
838
839 do {
840 if (kfifo_is_empty(&le->events)) {
841 if (filep->f_flags & O_NONBLOCK)
842 return -EAGAIN;
843
844 ret = wait_event_interruptible(le->wait,
845 !kfifo_is_empty(&le->events));
846 if (ret)
847 return ret;
848 }
849
850 if (mutex_lock_interruptible(&le->read_lock))
851 return -ERESTARTSYS;
852 ret = kfifo_to_user(&le->events, buf, count, &copied);
853 mutex_unlock(&le->read_lock);
854
855 if (ret)
856 return ret;
857
858
859
860
861
862
863
864 if (copied == 0 && (filep->f_flags & O_NONBLOCK))
865 return -EAGAIN;
866
867 } while (copied == 0);
868
869 return copied;
870}
871
872static int lineevent_release(struct inode *inode, struct file *filep)
873{
874 struct lineevent_state *le = filep->private_data;
875 struct gpio_device *gdev = le->gdev;
876
877 free_irq(le->irq, le);
878 gpiod_free(le->desc);
879 kfree(le->label);
880 kfree(le);
881 put_device(&gdev->dev);
882 return 0;
883}
884
885static long lineevent_ioctl(struct file *filep, unsigned int cmd,
886 unsigned long arg)
887{
888 struct lineevent_state *le = filep->private_data;
889 void __user *ip = (void __user *)arg;
890 struct gpiohandle_data ghd;
891
892
893
894
895
896 if (cmd == GPIOHANDLE_GET_LINE_VALUES_IOCTL) {
897 int val;
898
899 memset(&ghd, 0, sizeof(ghd));
900
901 val = gpiod_get_value_cansleep(le->desc);
902 if (val < 0)
903 return val;
904 ghd.values[0] = val;
905
906 if (copy_to_user(ip, &ghd, sizeof(ghd)))
907 return -EFAULT;
908
909 return 0;
910 }
911 return -EINVAL;
912}
913
914#ifdef CONFIG_COMPAT
915static long lineevent_ioctl_compat(struct file *filep, unsigned int cmd,
916 unsigned long arg)
917{
918 return lineevent_ioctl(filep, cmd, (unsigned long)compat_ptr(arg));
919}
920#endif
921
922static const struct file_operations lineevent_fileops = {
923 .release = lineevent_release,
924 .read = lineevent_read,
925 .poll = lineevent_poll,
926 .owner = THIS_MODULE,
927 .llseek = noop_llseek,
928 .unlocked_ioctl = lineevent_ioctl,
929#ifdef CONFIG_COMPAT
930 .compat_ioctl = lineevent_ioctl_compat,
931#endif
932};
933
934static irqreturn_t lineevent_irq_thread(int irq, void *p)
935{
936 struct lineevent_state *le = p;
937 struct gpioevent_data ge;
938 int ret;
939
940
941 memset(&ge, 0, sizeof(ge));
942
943
944
945
946
947 if (!le->timestamp)
948 ge.timestamp = ktime_get_real_ns();
949 else
950 ge.timestamp = le->timestamp;
951
952 if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE
953 && le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
954 int level = gpiod_get_value_cansleep(le->desc);
955 if (level)
956
957 ge.id = GPIOEVENT_EVENT_RISING_EDGE;
958 else
959
960 ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
961 } else if (le->eflags & GPIOEVENT_REQUEST_RISING_EDGE) {
962
963 ge.id = GPIOEVENT_EVENT_RISING_EDGE;
964 } else if (le->eflags & GPIOEVENT_REQUEST_FALLING_EDGE) {
965
966 ge.id = GPIOEVENT_EVENT_FALLING_EDGE;
967 } else {
968 return IRQ_NONE;
969 }
970
971 ret = kfifo_put(&le->events, ge);
972 if (ret)
973 wake_up_poll(&le->wait, EPOLLIN);
974
975 return IRQ_HANDLED;
976}
977
978static irqreturn_t lineevent_irq_handler(int irq, void *p)
979{
980 struct lineevent_state *le = p;
981
982
983
984
985
986 le->timestamp = ktime_get_real_ns();
987
988 return IRQ_WAKE_THREAD;
989}
990
991static int lineevent_create(struct gpio_device *gdev, void __user *ip)
992{
993 struct gpioevent_request eventreq;
994 struct lineevent_state *le;
995 struct gpio_desc *desc;
996 struct file *file;
997 u32 offset;
998 u32 lflags;
999 u32 eflags;
1000 int fd;
1001 int ret;
1002 int irqflags = 0;
1003
1004 if (copy_from_user(&eventreq, ip, sizeof(eventreq)))
1005 return -EFAULT;
1006
1007 offset = eventreq.lineoffset;
1008 lflags = eventreq.handleflags;
1009 eflags = eventreq.eventflags;
1010
1011 desc = gpiochip_get_desc(gdev->chip, offset);
1012 if (IS_ERR(desc))
1013 return PTR_ERR(desc);
1014
1015
1016 if ((lflags & ~GPIOHANDLE_REQUEST_VALID_FLAGS) ||
1017 (eflags & ~GPIOEVENT_REQUEST_VALID_FLAGS))
1018 return -EINVAL;
1019
1020
1021 if ((lflags & GPIOHANDLE_REQUEST_OUTPUT) ||
1022 (lflags & GPIOHANDLE_REQUEST_OPEN_DRAIN) ||
1023 (lflags & GPIOHANDLE_REQUEST_OPEN_SOURCE))
1024 return -EINVAL;
1025
1026
1027 if (((lflags & GPIOHANDLE_REQUEST_BIAS_DISABLE) &&
1028 (lflags & (GPIOHANDLE_REQUEST_BIAS_PULL_DOWN |
1029 GPIOHANDLE_REQUEST_BIAS_PULL_UP))) ||
1030 ((lflags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN) &&
1031 (lflags & GPIOHANDLE_REQUEST_BIAS_PULL_UP)))
1032 return -EINVAL;
1033
1034 le = kzalloc(sizeof(*le), GFP_KERNEL);
1035 if (!le)
1036 return -ENOMEM;
1037 le->gdev = gdev;
1038 get_device(&gdev->dev);
1039
1040
1041 eventreq.consumer_label[sizeof(eventreq.consumer_label)-1] = '\0';
1042 if (strlen(eventreq.consumer_label)) {
1043 le->label = kstrdup(eventreq.consumer_label,
1044 GFP_KERNEL);
1045 if (!le->label) {
1046 ret = -ENOMEM;
1047 goto out_free_le;
1048 }
1049 }
1050
1051 ret = gpiod_request(desc, le->label);
1052 if (ret)
1053 goto out_free_label;
1054 le->desc = desc;
1055 le->eflags = eflags;
1056
1057 if (lflags & GPIOHANDLE_REQUEST_ACTIVE_LOW)
1058 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
1059 if (lflags & GPIOHANDLE_REQUEST_BIAS_DISABLE)
1060 set_bit(FLAG_BIAS_DISABLE, &desc->flags);
1061 if (lflags & GPIOHANDLE_REQUEST_BIAS_PULL_DOWN)
1062 set_bit(FLAG_PULL_DOWN, &desc->flags);
1063 if (lflags & GPIOHANDLE_REQUEST_BIAS_PULL_UP)
1064 set_bit(FLAG_PULL_UP, &desc->flags);
1065
1066 ret = gpiod_direction_input(desc);
1067 if (ret)
1068 goto out_free_desc;
1069
1070 le->irq = gpiod_to_irq(desc);
1071 if (le->irq <= 0) {
1072 ret = -ENODEV;
1073 goto out_free_desc;
1074 }
1075
1076 if (eflags & GPIOEVENT_REQUEST_RISING_EDGE)
1077 irqflags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
1078 IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1079 if (eflags & GPIOEVENT_REQUEST_FALLING_EDGE)
1080 irqflags |= test_bit(FLAG_ACTIVE_LOW, &desc->flags) ?
1081 IRQF_TRIGGER_RISING : IRQF_TRIGGER_FALLING;
1082 irqflags |= IRQF_ONESHOT;
1083
1084 INIT_KFIFO(le->events);
1085 init_waitqueue_head(&le->wait);
1086 mutex_init(&le->read_lock);
1087
1088
1089 ret = request_threaded_irq(le->irq,
1090 lineevent_irq_handler,
1091 lineevent_irq_thread,
1092 irqflags,
1093 le->label,
1094 le);
1095 if (ret)
1096 goto out_free_desc;
1097
1098 fd = get_unused_fd_flags(O_RDONLY | O_CLOEXEC);
1099 if (fd < 0) {
1100 ret = fd;
1101 goto out_free_irq;
1102 }
1103
1104 file = anon_inode_getfile("gpio-event",
1105 &lineevent_fileops,
1106 le,
1107 O_RDONLY | O_CLOEXEC);
1108 if (IS_ERR(file)) {
1109 ret = PTR_ERR(file);
1110 goto out_put_unused_fd;
1111 }
1112
1113 eventreq.fd = fd;
1114 if (copy_to_user(ip, &eventreq, sizeof(eventreq))) {
1115
1116
1117
1118
1119 fput(file);
1120 put_unused_fd(fd);
1121 return -EFAULT;
1122 }
1123
1124 fd_install(fd, file);
1125
1126 return 0;
1127
1128out_put_unused_fd:
1129 put_unused_fd(fd);
1130out_free_irq:
1131 free_irq(le->irq, le);
1132out_free_desc:
1133 gpiod_free(le->desc);
1134out_free_label:
1135 kfree(le->label);
1136out_free_le:
1137 kfree(le);
1138 put_device(&gdev->dev);
1139 return ret;
1140}
1141
1142
1143
1144
1145static long gpio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1146{
1147 struct gpio_device *gdev = filp->private_data;
1148 struct gpio_chip *chip = gdev->chip;
1149 void __user *ip = (void __user *)arg;
1150
1151
1152 if (!chip)
1153 return -ENODEV;
1154
1155
1156 if (cmd == GPIO_GET_CHIPINFO_IOCTL) {
1157 struct gpiochip_info chipinfo;
1158
1159 memset(&chipinfo, 0, sizeof(chipinfo));
1160
1161 strncpy(chipinfo.name, dev_name(&gdev->dev),
1162 sizeof(chipinfo.name));
1163 chipinfo.name[sizeof(chipinfo.name)-1] = '\0';
1164 strncpy(chipinfo.label, gdev->label,
1165 sizeof(chipinfo.label));
1166 chipinfo.label[sizeof(chipinfo.label)-1] = '\0';
1167 chipinfo.lines = gdev->ngpio;
1168 if (copy_to_user(ip, &chipinfo, sizeof(chipinfo)))
1169 return -EFAULT;
1170 return 0;
1171 } else if (cmd == GPIO_GET_LINEINFO_IOCTL) {
1172 struct gpioline_info lineinfo;
1173 struct gpio_desc *desc;
1174
1175 if (copy_from_user(&lineinfo, ip, sizeof(lineinfo)))
1176 return -EFAULT;
1177
1178 desc = gpiochip_get_desc(chip, lineinfo.line_offset);
1179 if (IS_ERR(desc))
1180 return PTR_ERR(desc);
1181
1182 if (desc->name) {
1183 strncpy(lineinfo.name, desc->name,
1184 sizeof(lineinfo.name));
1185 lineinfo.name[sizeof(lineinfo.name)-1] = '\0';
1186 } else {
1187 lineinfo.name[0] = '\0';
1188 }
1189 if (desc->label) {
1190 strncpy(lineinfo.consumer, desc->label,
1191 sizeof(lineinfo.consumer));
1192 lineinfo.consumer[sizeof(lineinfo.consumer)-1] = '\0';
1193 } else {
1194 lineinfo.consumer[0] = '\0';
1195 }
1196
1197
1198
1199
1200
1201 lineinfo.flags = 0;
1202 if (test_bit(FLAG_REQUESTED, &desc->flags) ||
1203 test_bit(FLAG_IS_HOGGED, &desc->flags) ||
1204 test_bit(FLAG_USED_AS_IRQ, &desc->flags) ||
1205 test_bit(FLAG_EXPORT, &desc->flags) ||
1206 test_bit(FLAG_SYSFS, &desc->flags) ||
1207 !pinctrl_gpio_can_use_line(chip->base + lineinfo.line_offset))
1208 lineinfo.flags |= GPIOLINE_FLAG_KERNEL;
1209 if (test_bit(FLAG_IS_OUT, &desc->flags))
1210 lineinfo.flags |= GPIOLINE_FLAG_IS_OUT;
1211 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
1212 lineinfo.flags |= GPIOLINE_FLAG_ACTIVE_LOW;
1213 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
1214 lineinfo.flags |= (GPIOLINE_FLAG_OPEN_DRAIN |
1215 GPIOLINE_FLAG_IS_OUT);
1216 if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
1217 lineinfo.flags |= (GPIOLINE_FLAG_OPEN_SOURCE |
1218 GPIOLINE_FLAG_IS_OUT);
1219 if (test_bit(FLAG_BIAS_DISABLE, &desc->flags))
1220 lineinfo.flags |= GPIOLINE_FLAG_BIAS_DISABLE;
1221 if (test_bit(FLAG_PULL_DOWN, &desc->flags))
1222 lineinfo.flags |= GPIOLINE_FLAG_BIAS_PULL_DOWN;
1223 if (test_bit(FLAG_PULL_UP, &desc->flags))
1224 lineinfo.flags |= GPIOLINE_FLAG_BIAS_PULL_UP;
1225
1226 if (copy_to_user(ip, &lineinfo, sizeof(lineinfo)))
1227 return -EFAULT;
1228 return 0;
1229 } else if (cmd == GPIO_GET_LINEHANDLE_IOCTL) {
1230 return linehandle_create(gdev, ip);
1231 } else if (cmd == GPIO_GET_LINEEVENT_IOCTL) {
1232 return lineevent_create(gdev, ip);
1233 }
1234 return -EINVAL;
1235}
1236
1237#ifdef CONFIG_COMPAT
1238static long gpio_ioctl_compat(struct file *filp, unsigned int cmd,
1239 unsigned long arg)
1240{
1241 return gpio_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
1242}
1243#endif
1244
1245
1246
1247
1248
1249
1250
1251static int gpio_chrdev_open(struct inode *inode, struct file *filp)
1252{
1253 struct gpio_device *gdev = container_of(inode->i_cdev,
1254 struct gpio_device, chrdev);
1255
1256
1257 if (!gdev->chip)
1258 return -ENODEV;
1259 get_device(&gdev->dev);
1260 filp->private_data = gdev;
1261
1262 return nonseekable_open(inode, filp);
1263}
1264
1265
1266
1267
1268
1269
1270
1271static int gpio_chrdev_release(struct inode *inode, struct file *filp)
1272{
1273 struct gpio_device *gdev = container_of(inode->i_cdev,
1274 struct gpio_device, chrdev);
1275
1276 put_device(&gdev->dev);
1277 return 0;
1278}
1279
1280
1281static const struct file_operations gpio_fileops = {
1282 .release = gpio_chrdev_release,
1283 .open = gpio_chrdev_open,
1284 .owner = THIS_MODULE,
1285 .llseek = no_llseek,
1286 .unlocked_ioctl = gpio_ioctl,
1287#ifdef CONFIG_COMPAT
1288 .compat_ioctl = gpio_ioctl_compat,
1289#endif
1290};
1291
1292static void gpiodevice_release(struct device *dev)
1293{
1294 struct gpio_device *gdev = dev_get_drvdata(dev);
1295
1296 list_del(&gdev->list);
1297 ida_simple_remove(&gpio_ida, gdev->id);
1298 kfree_const(gdev->label);
1299 kfree(gdev->descs);
1300 kfree(gdev);
1301}
1302
1303static int gpiochip_setup_dev(struct gpio_device *gdev)
1304{
1305 int ret;
1306
1307 cdev_init(&gdev->chrdev, &gpio_fileops);
1308 gdev->chrdev.owner = THIS_MODULE;
1309 gdev->dev.devt = MKDEV(MAJOR(gpio_devt), gdev->id);
1310
1311 ret = cdev_device_add(&gdev->chrdev, &gdev->dev);
1312 if (ret)
1313 return ret;
1314
1315 chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
1316 MAJOR(gpio_devt), gdev->id);
1317
1318 ret = gpiochip_sysfs_register(gdev);
1319 if (ret)
1320 goto err_remove_device;
1321
1322
1323 gdev->dev.release = gpiodevice_release;
1324 pr_debug("%s: registered GPIOs %d to %d on device: %s (%s)\n",
1325 __func__, gdev->base, gdev->base + gdev->ngpio - 1,
1326 dev_name(&gdev->dev), gdev->chip->label ? : "generic");
1327
1328 return 0;
1329
1330err_remove_device:
1331 cdev_device_del(&gdev->chrdev, &gdev->dev);
1332 return ret;
1333}
1334
1335static void gpiochip_machine_hog(struct gpio_chip *chip, struct gpiod_hog *hog)
1336{
1337 struct gpio_desc *desc;
1338 int rv;
1339
1340 desc = gpiochip_get_desc(chip, hog->chip_hwnum);
1341 if (IS_ERR(desc)) {
1342 pr_err("%s: unable to get GPIO desc: %ld\n",
1343 __func__, PTR_ERR(desc));
1344 return;
1345 }
1346
1347 if (test_bit(FLAG_IS_HOGGED, &desc->flags))
1348 return;
1349
1350 rv = gpiod_hog(desc, hog->line_name, hog->lflags, hog->dflags);
1351 if (rv)
1352 pr_err("%s: unable to hog GPIO line (%s:%u): %d\n",
1353 __func__, chip->label, hog->chip_hwnum, rv);
1354}
1355
1356static void machine_gpiochip_add(struct gpio_chip *chip)
1357{
1358 struct gpiod_hog *hog;
1359
1360 mutex_lock(&gpio_machine_hogs_mutex);
1361
1362 list_for_each_entry(hog, &gpio_machine_hogs, list) {
1363 if (!strcmp(chip->label, hog->chip_label))
1364 gpiochip_machine_hog(chip, hog);
1365 }
1366
1367 mutex_unlock(&gpio_machine_hogs_mutex);
1368}
1369
1370static void gpiochip_setup_devs(void)
1371{
1372 struct gpio_device *gdev;
1373 int ret;
1374
1375 list_for_each_entry(gdev, &gpio_devices, list) {
1376 ret = gpiochip_setup_dev(gdev);
1377 if (ret)
1378 pr_err("%s: Failed to initialize gpio device (%d)\n",
1379 dev_name(&gdev->dev), ret);
1380 }
1381}
1382
1383int gpiochip_add_data_with_key(struct gpio_chip *chip, void *data,
1384 struct lock_class_key *lock_key,
1385 struct lock_class_key *request_key)
1386{
1387 unsigned long flags;
1388 int ret = 0;
1389 unsigned i;
1390 int base = chip->base;
1391 struct gpio_device *gdev;
1392
1393
1394
1395
1396
1397 gdev = kzalloc(sizeof(*gdev), GFP_KERNEL);
1398 if (!gdev)
1399 return -ENOMEM;
1400 gdev->dev.bus = &gpio_bus_type;
1401 gdev->chip = chip;
1402 chip->gpiodev = gdev;
1403 if (chip->parent) {
1404 gdev->dev.parent = chip->parent;
1405 gdev->dev.of_node = chip->parent->of_node;
1406 }
1407
1408#ifdef CONFIG_OF_GPIO
1409
1410 if (chip->of_node)
1411 gdev->dev.of_node = chip->of_node;
1412 else
1413 chip->of_node = gdev->dev.of_node;
1414#endif
1415
1416 gdev->id = ida_simple_get(&gpio_ida, 0, 0, GFP_KERNEL);
1417 if (gdev->id < 0) {
1418 ret = gdev->id;
1419 goto err_free_gdev;
1420 }
1421 dev_set_name(&gdev->dev, GPIOCHIP_NAME "%d", gdev->id);
1422 device_initialize(&gdev->dev);
1423 dev_set_drvdata(&gdev->dev, gdev);
1424 if (chip->parent && chip->parent->driver)
1425 gdev->owner = chip->parent->driver->owner;
1426 else if (chip->owner)
1427
1428 gdev->owner = chip->owner;
1429 else
1430 gdev->owner = THIS_MODULE;
1431
1432 gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
1433 if (!gdev->descs) {
1434 ret = -ENOMEM;
1435 goto err_free_ida;
1436 }
1437
1438 if (chip->ngpio == 0) {
1439 chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
1440 ret = -EINVAL;
1441 goto err_free_descs;
1442 }
1443
1444 if (chip->ngpio > FASTPATH_NGPIO)
1445 chip_warn(chip, "line cnt %u is greater than fast path cnt %u\n",
1446 chip->ngpio, FASTPATH_NGPIO);
1447
1448 gdev->label = kstrdup_const(chip->label ?: "unknown", GFP_KERNEL);
1449 if (!gdev->label) {
1450 ret = -ENOMEM;
1451 goto err_free_descs;
1452 }
1453
1454 gdev->ngpio = chip->ngpio;
1455 gdev->data = data;
1456
1457 spin_lock_irqsave(&gpio_lock, flags);
1458
1459
1460
1461
1462
1463
1464
1465
1466 if (base < 0) {
1467 base = gpiochip_find_base(chip->ngpio);
1468 if (base < 0) {
1469 ret = base;
1470 spin_unlock_irqrestore(&gpio_lock, flags);
1471 goto err_free_label;
1472 }
1473
1474
1475
1476
1477
1478
1479 chip->base = base;
1480 }
1481 gdev->base = base;
1482
1483 ret = gpiodev_add_to_list(gdev);
1484 if (ret) {
1485 spin_unlock_irqrestore(&gpio_lock, flags);
1486 goto err_free_label;
1487 }
1488
1489 for (i = 0; i < chip->ngpio; i++)
1490 gdev->descs[i].gdev = gdev;
1491
1492 spin_unlock_irqrestore(&gpio_lock, flags);
1493
1494#ifdef CONFIG_PINCTRL
1495 INIT_LIST_HEAD(&gdev->pin_ranges);
1496#endif
1497
1498 ret = gpiochip_set_desc_names(chip);
1499 if (ret)
1500 goto err_remove_from_list;
1501
1502 ret = gpiochip_alloc_valid_mask(chip);
1503 if (ret)
1504 goto err_remove_from_list;
1505
1506 ret = of_gpiochip_add(chip);
1507 if (ret)
1508 goto err_free_gpiochip_mask;
1509
1510 ret = gpiochip_add_pin_ranges(chip);
1511 if (ret)
1512 goto err_remove_of_chip;
1513
1514 ret = gpiochip_init_valid_mask(chip);
1515 if (ret)
1516 goto err_remove_of_chip;
1517
1518 for (i = 0; i < chip->ngpio; i++) {
1519 struct gpio_desc *desc = &gdev->descs[i];
1520
1521 if (chip->get_direction && gpiochip_line_is_valid(chip, i)) {
1522 assign_bit(FLAG_IS_OUT,
1523 &desc->flags, !chip->get_direction(chip, i));
1524 } else {
1525 assign_bit(FLAG_IS_OUT,
1526 &desc->flags, !chip->direction_input);
1527 }
1528 }
1529
1530 acpi_gpiochip_add(chip);
1531
1532 machine_gpiochip_add(chip);
1533
1534 ret = gpiochip_irqchip_init_valid_mask(chip);
1535 if (ret)
1536 goto err_remove_acpi_chip;
1537
1538 ret = gpiochip_irqchip_init_hw(chip);
1539 if (ret)
1540 goto err_remove_acpi_chip;
1541
1542 ret = gpiochip_add_irqchip(chip, lock_key, request_key);
1543 if (ret)
1544 goto err_remove_irqchip_mask;
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554 if (gpiolib_initialized) {
1555 ret = gpiochip_setup_dev(gdev);
1556 if (ret)
1557 goto err_remove_irqchip;
1558 }
1559 return 0;
1560
1561err_remove_irqchip:
1562 gpiochip_irqchip_remove(chip);
1563err_remove_irqchip_mask:
1564 gpiochip_irqchip_free_valid_mask(chip);
1565err_remove_acpi_chip:
1566 acpi_gpiochip_remove(chip);
1567err_remove_of_chip:
1568 gpiochip_free_hogs(chip);
1569 of_gpiochip_remove(chip);
1570err_free_gpiochip_mask:
1571 gpiochip_remove_pin_ranges(chip);
1572 gpiochip_free_valid_mask(chip);
1573err_remove_from_list:
1574 spin_lock_irqsave(&gpio_lock, flags);
1575 list_del(&gdev->list);
1576 spin_unlock_irqrestore(&gpio_lock, flags);
1577err_free_label:
1578 kfree_const(gdev->label);
1579err_free_descs:
1580 kfree(gdev->descs);
1581err_free_ida:
1582 ida_simple_remove(&gpio_ida, gdev->id);
1583err_free_gdev:
1584
1585 pr_err("%s: GPIOs %d..%d (%s) failed to register, %d\n", __func__,
1586 gdev->base, gdev->base + gdev->ngpio - 1,
1587 chip->label ? : "generic", ret);
1588 kfree(gdev);
1589 return ret;
1590}
1591EXPORT_SYMBOL_GPL(gpiochip_add_data_with_key);
1592
1593
1594
1595
1596
1597
1598
1599
1600void *gpiochip_get_data(struct gpio_chip *chip)
1601{
1602 return chip->gpiodev->data;
1603}
1604EXPORT_SYMBOL_GPL(gpiochip_get_data);
1605
1606
1607
1608
1609
1610
1611
1612void gpiochip_remove(struct gpio_chip *chip)
1613{
1614 struct gpio_device *gdev = chip->gpiodev;
1615 struct gpio_desc *desc;
1616 unsigned long flags;
1617 unsigned i;
1618 bool requested = false;
1619
1620
1621 gpiochip_sysfs_unregister(gdev);
1622 gpiochip_free_hogs(chip);
1623
1624 gdev->chip = NULL;
1625 gpiochip_irqchip_remove(chip);
1626 acpi_gpiochip_remove(chip);
1627 of_gpiochip_remove(chip);
1628 gpiochip_remove_pin_ranges(chip);
1629 gpiochip_free_valid_mask(chip);
1630
1631
1632
1633
1634 gdev->data = NULL;
1635
1636 spin_lock_irqsave(&gpio_lock, flags);
1637 for (i = 0; i < gdev->ngpio; i++) {
1638 desc = &gdev->descs[i];
1639 if (test_bit(FLAG_REQUESTED, &desc->flags))
1640 requested = true;
1641 }
1642 spin_unlock_irqrestore(&gpio_lock, flags);
1643
1644 if (requested)
1645 dev_crit(&gdev->dev,
1646 "REMOVING GPIOCHIP WITH GPIOS STILL REQUESTED\n");
1647
1648
1649
1650
1651
1652
1653
1654 cdev_device_del(&gdev->chrdev, &gdev->dev);
1655 put_device(&gdev->dev);
1656}
1657EXPORT_SYMBOL_GPL(gpiochip_remove);
1658
1659static void devm_gpio_chip_release(struct device *dev, void *res)
1660{
1661 struct gpio_chip *chip = *(struct gpio_chip **)res;
1662
1663 gpiochip_remove(chip);
1664}
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681int devm_gpiochip_add_data(struct device *dev, struct gpio_chip *chip,
1682 void *data)
1683{
1684 struct gpio_chip **ptr;
1685 int ret;
1686
1687 ptr = devres_alloc(devm_gpio_chip_release, sizeof(*ptr),
1688 GFP_KERNEL);
1689 if (!ptr)
1690 return -ENOMEM;
1691
1692 ret = gpiochip_add_data(chip, data);
1693 if (ret < 0) {
1694 devres_free(ptr);
1695 return ret;
1696 }
1697
1698 *ptr = chip;
1699 devres_add(dev, ptr);
1700
1701 return 0;
1702}
1703EXPORT_SYMBOL_GPL(devm_gpiochip_add_data);
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716struct gpio_chip *gpiochip_find(void *data,
1717 int (*match)(struct gpio_chip *chip,
1718 void *data))
1719{
1720 struct gpio_device *gdev;
1721 struct gpio_chip *chip = NULL;
1722 unsigned long flags;
1723
1724 spin_lock_irqsave(&gpio_lock, flags);
1725 list_for_each_entry(gdev, &gpio_devices, list)
1726 if (gdev->chip && match(gdev->chip, data)) {
1727 chip = gdev->chip;
1728 break;
1729 }
1730
1731 spin_unlock_irqrestore(&gpio_lock, flags);
1732
1733 return chip;
1734}
1735EXPORT_SYMBOL_GPL(gpiochip_find);
1736
1737static int gpiochip_match_name(struct gpio_chip *chip, void *data)
1738{
1739 const char *name = data;
1740
1741 return !strcmp(chip->label, name);
1742}
1743
1744static struct gpio_chip *find_chip_by_name(const char *name)
1745{
1746 return gpiochip_find((void *)name, gpiochip_match_name);
1747}
1748
1749#ifdef CONFIG_GPIOLIB_IRQCHIP
1750
1751
1752
1753
1754
1755static int gpiochip_irqchip_init_hw(struct gpio_chip *gc)
1756{
1757 struct gpio_irq_chip *girq = &gc->irq;
1758
1759 if (!girq->init_hw)
1760 return 0;
1761
1762 return girq->init_hw(gc);
1763}
1764
1765static int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gc)
1766{
1767 struct gpio_irq_chip *girq = &gc->irq;
1768
1769 if (!girq->init_valid_mask)
1770 return 0;
1771
1772 girq->valid_mask = gpiochip_allocate_mask(gc);
1773 if (!girq->valid_mask)
1774 return -ENOMEM;
1775
1776 girq->init_valid_mask(gc, girq->valid_mask, gc->ngpio);
1777
1778 return 0;
1779}
1780
1781static void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
1782{
1783 bitmap_free(gpiochip->irq.valid_mask);
1784 gpiochip->irq.valid_mask = NULL;
1785}
1786
1787bool gpiochip_irqchip_irq_valid(const struct gpio_chip *gpiochip,
1788 unsigned int offset)
1789{
1790 if (!gpiochip_line_is_valid(gpiochip, offset))
1791 return false;
1792
1793 if (likely(!gpiochip->irq.valid_mask))
1794 return true;
1795 return test_bit(offset, gpiochip->irq.valid_mask);
1796}
1797EXPORT_SYMBOL_GPL(gpiochip_irqchip_irq_valid);
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808static void gpiochip_set_cascaded_irqchip(struct gpio_chip *gc,
1809 unsigned int parent_irq,
1810 irq_flow_handler_t parent_handler)
1811{
1812 struct gpio_irq_chip *girq = &gc->irq;
1813 struct device *dev = &gc->gpiodev->dev;
1814
1815 if (!girq->domain) {
1816 chip_err(gc, "called %s before setting up irqchip\n",
1817 __func__);
1818 return;
1819 }
1820
1821 if (parent_handler) {
1822 if (gc->can_sleep) {
1823 chip_err(gc,
1824 "you cannot have chained interrupts on a chip that may sleep\n");
1825 return;
1826 }
1827 girq->parents = devm_kcalloc(dev, 1,
1828 sizeof(*girq->parents),
1829 GFP_KERNEL);
1830 if (!girq->parents) {
1831 chip_err(gc, "out of memory allocating parent IRQ\n");
1832 return;
1833 }
1834 girq->parents[0] = parent_irq;
1835 girq->num_parents = 1;
1836
1837
1838
1839
1840 irq_set_chained_handler_and_data(parent_irq, parent_handler,
1841 gc);
1842 }
1843}
1844
1845
1846
1847
1848
1849
1850
1851
1852void gpiochip_set_nested_irqchip(struct gpio_chip *gpiochip,
1853 struct irq_chip *irqchip,
1854 unsigned int parent_irq)
1855{
1856 gpiochip_set_cascaded_irqchip(gpiochip, parent_irq, NULL);
1857}
1858EXPORT_SYMBOL_GPL(gpiochip_set_nested_irqchip);
1859
1860#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
1861
1862
1863
1864
1865
1866
1867
1868
1869static void gpiochip_set_hierarchical_irqchip(struct gpio_chip *gc,
1870 struct irq_chip *irqchip)
1871{
1872
1873 if (is_of_node(gc->irq.fwnode))
1874 return;
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884 if (is_fwnode_irqchip(gc->irq.fwnode)) {
1885 int i;
1886 int ret;
1887
1888 for (i = 0; i < gc->ngpio; i++) {
1889 struct irq_fwspec fwspec;
1890 unsigned int parent_hwirq;
1891 unsigned int parent_type;
1892 struct gpio_irq_chip *girq = &gc->irq;
1893
1894
1895
1896
1897
1898
1899
1900 ret = girq->child_to_parent_hwirq(gc, i,
1901 IRQ_TYPE_EDGE_RISING,
1902 &parent_hwirq,
1903 &parent_type);
1904 if (ret) {
1905 chip_err(gc, "skip set-up on hwirq %d\n",
1906 i);
1907 continue;
1908 }
1909
1910 fwspec.fwnode = gc->irq.fwnode;
1911
1912 fwspec.param[0] = girq->child_offset_to_irq(gc, i);
1913
1914 fwspec.param[1] = IRQ_TYPE_EDGE_RISING;
1915 fwspec.param_count = 2;
1916 ret = __irq_domain_alloc_irqs(gc->irq.domain,
1917
1918 -1,
1919 1,
1920 NUMA_NO_NODE,
1921 &fwspec,
1922 false,
1923 NULL);
1924 if (ret < 0) {
1925 chip_err(gc,
1926 "can not allocate irq for GPIO line %d parent hwirq %d in hierarchy domain: %d\n",
1927 i, parent_hwirq,
1928 ret);
1929 }
1930 }
1931 }
1932
1933 chip_err(gc, "%s unknown fwnode type proceed anyway\n", __func__);
1934
1935 return;
1936}
1937
1938static int gpiochip_hierarchy_irq_domain_translate(struct irq_domain *d,
1939 struct irq_fwspec *fwspec,
1940 unsigned long *hwirq,
1941 unsigned int *type)
1942{
1943
1944 if (is_of_node(fwspec->fwnode) && fwspec->param_count == 2) {
1945 return irq_domain_translate_twocell(d, fwspec, hwirq, type);
1946 }
1947
1948
1949 if (is_fwnode_irqchip(fwspec->fwnode)) {
1950 int ret;
1951
1952 ret = irq_domain_translate_twocell(d, fwspec, hwirq, type);
1953 if (ret)
1954 return ret;
1955 WARN_ON(*type == IRQ_TYPE_NONE);
1956 return 0;
1957 }
1958 return -EINVAL;
1959}
1960
1961static int gpiochip_hierarchy_irq_domain_alloc(struct irq_domain *d,
1962 unsigned int irq,
1963 unsigned int nr_irqs,
1964 void *data)
1965{
1966 struct gpio_chip *gc = d->host_data;
1967 irq_hw_number_t hwirq;
1968 unsigned int type = IRQ_TYPE_NONE;
1969 struct irq_fwspec *fwspec = data;
1970 void *parent_arg;
1971 unsigned int parent_hwirq;
1972 unsigned int parent_type;
1973 struct gpio_irq_chip *girq = &gc->irq;
1974 int ret;
1975
1976
1977
1978
1979
1980 WARN_ON(nr_irqs != 1);
1981
1982 ret = gc->irq.child_irq_domain_ops.translate(d, fwspec, &hwirq, &type);
1983 if (ret)
1984 return ret;
1985
1986 chip_dbg(gc, "allocate IRQ %d, hwirq %lu\n", irq, hwirq);
1987
1988 ret = girq->child_to_parent_hwirq(gc, hwirq, type,
1989 &parent_hwirq, &parent_type);
1990 if (ret) {
1991 chip_err(gc, "can't look up hwirq %lu\n", hwirq);
1992 return ret;
1993 }
1994 chip_dbg(gc, "found parent hwirq %u\n", parent_hwirq);
1995
1996
1997
1998
1999
2000 irq_domain_set_info(d,
2001 irq,
2002 hwirq,
2003 gc->irq.chip,
2004 gc,
2005 girq->handler,
2006 NULL, NULL);
2007 irq_set_probe(irq);
2008
2009
2010 parent_arg = girq->populate_parent_alloc_arg(gc, parent_hwirq, parent_type);
2011 if (!parent_arg)
2012 return -ENOMEM;
2013
2014 chip_dbg(gc, "alloc_irqs_parent for %d parent hwirq %d\n",
2015 irq, parent_hwirq);
2016 irq_set_lockdep_class(irq, gc->irq.lock_key, gc->irq.request_key);
2017 ret = irq_domain_alloc_irqs_parent(d, irq, 1, parent_arg);
2018
2019
2020
2021
2022 if (irq_domain_is_msi(d->parent) && (ret == -EEXIST))
2023 ret = 0;
2024 if (ret)
2025 chip_err(gc,
2026 "failed to allocate parent hwirq %d for hwirq %lu\n",
2027 parent_hwirq, hwirq);
2028
2029 kfree(parent_arg);
2030 return ret;
2031}
2032
2033static unsigned int gpiochip_child_offset_to_irq_noop(struct gpio_chip *chip,
2034 unsigned int offset)
2035{
2036 return offset;
2037}
2038
2039static void gpiochip_hierarchy_setup_domain_ops(struct irq_domain_ops *ops)
2040{
2041 ops->activate = gpiochip_irq_domain_activate;
2042 ops->deactivate = gpiochip_irq_domain_deactivate;
2043 ops->alloc = gpiochip_hierarchy_irq_domain_alloc;
2044 ops->free = irq_domain_free_irqs_common;
2045
2046
2047
2048
2049
2050
2051 if (!ops->translate)
2052 ops->translate = gpiochip_hierarchy_irq_domain_translate;
2053}
2054
2055static int gpiochip_hierarchy_add_domain(struct gpio_chip *gc)
2056{
2057 if (!gc->irq.child_to_parent_hwirq ||
2058 !gc->irq.fwnode) {
2059 chip_err(gc, "missing irqdomain vital data\n");
2060 return -EINVAL;
2061 }
2062
2063 if (!gc->irq.child_offset_to_irq)
2064 gc->irq.child_offset_to_irq = gpiochip_child_offset_to_irq_noop;
2065
2066 if (!gc->irq.populate_parent_alloc_arg)
2067 gc->irq.populate_parent_alloc_arg =
2068 gpiochip_populate_parent_fwspec_twocell;
2069
2070 gpiochip_hierarchy_setup_domain_ops(&gc->irq.child_irq_domain_ops);
2071
2072 gc->irq.domain = irq_domain_create_hierarchy(
2073 gc->irq.parent_domain,
2074 0,
2075 gc->ngpio,
2076 gc->irq.fwnode,
2077 &gc->irq.child_irq_domain_ops,
2078 gc);
2079
2080 if (!gc->irq.domain)
2081 return -ENOMEM;
2082
2083 gpiochip_set_hierarchical_irqchip(gc, gc->irq.chip);
2084
2085 return 0;
2086}
2087
2088static bool gpiochip_hierarchy_is_hierarchical(struct gpio_chip *gc)
2089{
2090 return !!gc->irq.parent_domain;
2091}
2092
2093void *gpiochip_populate_parent_fwspec_twocell(struct gpio_chip *chip,
2094 unsigned int parent_hwirq,
2095 unsigned int parent_type)
2096{
2097 struct irq_fwspec *fwspec;
2098
2099 fwspec = kmalloc(sizeof(*fwspec), GFP_KERNEL);
2100 if (!fwspec)
2101 return NULL;
2102
2103 fwspec->fwnode = chip->irq.parent_domain->fwnode;
2104 fwspec->param_count = 2;
2105 fwspec->param[0] = parent_hwirq;
2106 fwspec->param[1] = parent_type;
2107
2108 return fwspec;
2109}
2110EXPORT_SYMBOL_GPL(gpiochip_populate_parent_fwspec_twocell);
2111
2112void *gpiochip_populate_parent_fwspec_fourcell(struct gpio_chip *chip,
2113 unsigned int parent_hwirq,
2114 unsigned int parent_type)
2115{
2116 struct irq_fwspec *fwspec;
2117
2118 fwspec = kmalloc(sizeof(*fwspec), GFP_KERNEL);
2119 if (!fwspec)
2120 return NULL;
2121
2122 fwspec->fwnode = chip->irq.parent_domain->fwnode;
2123 fwspec->param_count = 4;
2124 fwspec->param[0] = 0;
2125 fwspec->param[1] = parent_hwirq;
2126 fwspec->param[2] = 0;
2127 fwspec->param[3] = parent_type;
2128
2129 return fwspec;
2130}
2131EXPORT_SYMBOL_GPL(gpiochip_populate_parent_fwspec_fourcell);
2132
2133#else
2134
2135static int gpiochip_hierarchy_add_domain(struct gpio_chip *gc)
2136{
2137 return -EINVAL;
2138}
2139
2140static bool gpiochip_hierarchy_is_hierarchical(struct gpio_chip *gc)
2141{
2142 return false;
2143}
2144
2145#endif
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157int gpiochip_irq_map(struct irq_domain *d, unsigned int irq,
2158 irq_hw_number_t hwirq)
2159{
2160 struct gpio_chip *chip = d->host_data;
2161 int ret = 0;
2162
2163 if (!gpiochip_irqchip_irq_valid(chip, hwirq))
2164 return -ENXIO;
2165
2166 irq_set_chip_data(irq, chip);
2167
2168
2169
2170
2171 irq_set_lockdep_class(irq, chip->irq.lock_key, chip->irq.request_key);
2172 irq_set_chip_and_handler(irq, chip->irq.chip, chip->irq.handler);
2173
2174 if (chip->irq.threaded)
2175 irq_set_nested_thread(irq, 1);
2176 irq_set_noprobe(irq);
2177
2178 if (chip->irq.num_parents == 1)
2179 ret = irq_set_parent(irq, chip->irq.parents[0]);
2180 else if (chip->irq.map)
2181 ret = irq_set_parent(irq, chip->irq.map[hwirq]);
2182
2183 if (ret < 0)
2184 return ret;
2185
2186
2187
2188
2189
2190 if (chip->irq.default_type != IRQ_TYPE_NONE)
2191 irq_set_irq_type(irq, chip->irq.default_type);
2192
2193 return 0;
2194}
2195EXPORT_SYMBOL_GPL(gpiochip_irq_map);
2196
2197void gpiochip_irq_unmap(struct irq_domain *d, unsigned int irq)
2198{
2199 struct gpio_chip *chip = d->host_data;
2200
2201 if (chip->irq.threaded)
2202 irq_set_nested_thread(irq, 0);
2203 irq_set_chip_and_handler(irq, NULL, NULL);
2204 irq_set_chip_data(irq, NULL);
2205}
2206EXPORT_SYMBOL_GPL(gpiochip_irq_unmap);
2207
2208static const struct irq_domain_ops gpiochip_domain_ops = {
2209 .map = gpiochip_irq_map,
2210 .unmap = gpiochip_irq_unmap,
2211
2212 .xlate = irq_domain_xlate_twocell,
2213};
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230int gpiochip_irq_domain_activate(struct irq_domain *domain,
2231 struct irq_data *data, bool reserve)
2232{
2233 struct gpio_chip *chip = domain->host_data;
2234
2235 return gpiochip_lock_as_irq(chip, data->hwirq);
2236}
2237EXPORT_SYMBOL_GPL(gpiochip_irq_domain_activate);
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248void gpiochip_irq_domain_deactivate(struct irq_domain *domain,
2249 struct irq_data *data)
2250{
2251 struct gpio_chip *chip = domain->host_data;
2252
2253 return gpiochip_unlock_as_irq(chip, data->hwirq);
2254}
2255EXPORT_SYMBOL_GPL(gpiochip_irq_domain_deactivate);
2256
2257static int gpiochip_to_irq(struct gpio_chip *chip, unsigned offset)
2258{
2259 struct irq_domain *domain = chip->irq.domain;
2260
2261 if (!gpiochip_irqchip_irq_valid(chip, offset))
2262 return -ENXIO;
2263
2264#ifdef CONFIG_IRQ_DOMAIN_HIERARCHY
2265 if (irq_domain_is_hierarchy(domain)) {
2266 struct irq_fwspec spec;
2267
2268 spec.fwnode = domain->fwnode;
2269 spec.param_count = 2;
2270 spec.param[0] = chip->irq.child_offset_to_irq(chip, offset);
2271 spec.param[1] = IRQ_TYPE_NONE;
2272
2273 return irq_create_fwspec_mapping(&spec);
2274 }
2275#endif
2276
2277 return irq_create_mapping(domain, offset);
2278}
2279
2280static int gpiochip_irq_reqres(struct irq_data *d)
2281{
2282 struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
2283
2284 return gpiochip_reqres_irq(chip, d->hwirq);
2285}
2286
2287static void gpiochip_irq_relres(struct irq_data *d)
2288{
2289 struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
2290
2291 gpiochip_relres_irq(chip, d->hwirq);
2292}
2293
2294static void gpiochip_irq_enable(struct irq_data *d)
2295{
2296 struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
2297
2298 gpiochip_enable_irq(chip, d->hwirq);
2299 if (chip->irq.irq_enable)
2300 chip->irq.irq_enable(d);
2301 else
2302 chip->irq.chip->irq_unmask(d);
2303}
2304
2305static void gpiochip_irq_disable(struct irq_data *d)
2306{
2307 struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
2308
2309
2310
2311
2312
2313
2314
2315
2316 if (chip->irq.irq_disable)
2317 chip->irq.irq_disable(d);
2318 else if (chip->irq.chip->irq_mask)
2319 chip->irq.chip->irq_mask(d);
2320 gpiochip_disable_irq(chip, d->hwirq);
2321}
2322
2323static void gpiochip_set_irq_hooks(struct gpio_chip *gpiochip)
2324{
2325 struct irq_chip *irqchip = gpiochip->irq.chip;
2326
2327 if (!irqchip->irq_request_resources &&
2328 !irqchip->irq_release_resources) {
2329 irqchip->irq_request_resources = gpiochip_irq_reqres;
2330 irqchip->irq_release_resources = gpiochip_irq_relres;
2331 }
2332 if (WARN_ON(gpiochip->irq.irq_enable))
2333 return;
2334
2335 if (irqchip->irq_enable == gpiochip_irq_enable) {
2336
2337
2338
2339
2340 chip_info(gpiochip,
2341 "detected irqchip that is shared with multiple gpiochips: please fix the driver.\n");
2342 return;
2343 }
2344 gpiochip->irq.irq_enable = irqchip->irq_enable;
2345 gpiochip->irq.irq_disable = irqchip->irq_disable;
2346 irqchip->irq_enable = gpiochip_irq_enable;
2347 irqchip->irq_disable = gpiochip_irq_disable;
2348}
2349
2350
2351
2352
2353
2354
2355
2356static int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
2357 struct lock_class_key *lock_key,
2358 struct lock_class_key *request_key)
2359{
2360 struct irq_chip *irqchip = gpiochip->irq.chip;
2361 const struct irq_domain_ops *ops = NULL;
2362 struct device_node *np;
2363 unsigned int type;
2364 unsigned int i;
2365
2366 if (!irqchip)
2367 return 0;
2368
2369 if (gpiochip->irq.parent_handler && gpiochip->can_sleep) {
2370 chip_err(gpiochip, "you cannot have chained interrupts on a chip that may sleep\n");
2371 return -EINVAL;
2372 }
2373
2374 np = gpiochip->gpiodev->dev.of_node;
2375 type = gpiochip->irq.default_type;
2376
2377
2378
2379
2380
2381
2382 if (WARN(np && type != IRQ_TYPE_NONE,
2383 "%s: Ignoring %u default trigger\n", np->full_name, type))
2384 type = IRQ_TYPE_NONE;
2385
2386 if (has_acpi_companion(gpiochip->parent) && type != IRQ_TYPE_NONE) {
2387 acpi_handle_warn(ACPI_HANDLE(gpiochip->parent),
2388 "Ignoring %u default trigger\n", type);
2389 type = IRQ_TYPE_NONE;
2390 }
2391
2392 gpiochip->to_irq = gpiochip_to_irq;
2393 gpiochip->irq.default_type = type;
2394 gpiochip->irq.lock_key = lock_key;
2395 gpiochip->irq.request_key = request_key;
2396
2397
2398 if (gpiochip_hierarchy_is_hierarchical(gpiochip)) {
2399 int ret = gpiochip_hierarchy_add_domain(gpiochip);
2400 if (ret)
2401 return ret;
2402 } else {
2403
2404 if (gpiochip->irq.domain_ops)
2405 ops = gpiochip->irq.domain_ops;
2406
2407 if (!ops)
2408 ops = &gpiochip_domain_ops;
2409 gpiochip->irq.domain = irq_domain_add_simple(np,
2410 gpiochip->ngpio,
2411 gpiochip->irq.first,
2412 ops, gpiochip);
2413 if (!gpiochip->irq.domain)
2414 return -EINVAL;
2415 }
2416
2417 if (gpiochip->irq.parent_handler) {
2418 void *data = gpiochip->irq.parent_handler_data ?: gpiochip;
2419
2420 for (i = 0; i < gpiochip->irq.num_parents; i++) {
2421
2422
2423
2424
2425
2426 irq_set_chained_handler_and_data(gpiochip->irq.parents[i],
2427 gpiochip->irq.parent_handler,
2428 data);
2429 }
2430 }
2431
2432 gpiochip_set_irq_hooks(gpiochip);
2433
2434 acpi_gpiochip_request_interrupts(gpiochip);
2435
2436 return 0;
2437}
2438
2439
2440
2441
2442
2443
2444
2445static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip)
2446{
2447 struct irq_chip *irqchip = gpiochip->irq.chip;
2448 unsigned int offset;
2449
2450 acpi_gpiochip_free_interrupts(gpiochip);
2451
2452 if (irqchip && gpiochip->irq.parent_handler) {
2453 struct gpio_irq_chip *irq = &gpiochip->irq;
2454 unsigned int i;
2455
2456 for (i = 0; i < irq->num_parents; i++)
2457 irq_set_chained_handler_and_data(irq->parents[i],
2458 NULL, NULL);
2459 }
2460
2461
2462 if (gpiochip->irq.domain) {
2463 unsigned int irq;
2464
2465 for (offset = 0; offset < gpiochip->ngpio; offset++) {
2466 if (!gpiochip_irqchip_irq_valid(gpiochip, offset))
2467 continue;
2468
2469 irq = irq_find_mapping(gpiochip->irq.domain, offset);
2470 irq_dispose_mapping(irq);
2471 }
2472
2473 irq_domain_remove(gpiochip->irq.domain);
2474 }
2475
2476 if (irqchip) {
2477 if (irqchip->irq_request_resources == gpiochip_irq_reqres) {
2478 irqchip->irq_request_resources = NULL;
2479 irqchip->irq_release_resources = NULL;
2480 }
2481 if (irqchip->irq_enable == gpiochip_irq_enable) {
2482 irqchip->irq_enable = gpiochip->irq.irq_enable;
2483 irqchip->irq_disable = gpiochip->irq.irq_disable;
2484 }
2485 }
2486 gpiochip->irq.irq_enable = NULL;
2487 gpiochip->irq.irq_disable = NULL;
2488 gpiochip->irq.chip = NULL;
2489
2490 gpiochip_irqchip_free_valid_mask(gpiochip);
2491}
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505
2506
2507
2508
2509
2510
2511
2512
2513
2514
2515
2516
2517
2518
2519
2520int gpiochip_irqchip_add_key(struct gpio_chip *gpiochip,
2521 struct irq_chip *irqchip,
2522 unsigned int first_irq,
2523 irq_flow_handler_t handler,
2524 unsigned int type,
2525 bool threaded,
2526 struct lock_class_key *lock_key,
2527 struct lock_class_key *request_key)
2528{
2529 struct device_node *of_node;
2530
2531 if (!gpiochip || !irqchip)
2532 return -EINVAL;
2533
2534 if (!gpiochip->parent) {
2535 pr_err("missing gpiochip .dev parent pointer\n");
2536 return -EINVAL;
2537 }
2538 gpiochip->irq.threaded = threaded;
2539 of_node = gpiochip->parent->of_node;
2540#ifdef CONFIG_OF_GPIO
2541
2542
2543
2544
2545
2546 if (gpiochip->of_node)
2547 of_node = gpiochip->of_node;
2548#endif
2549
2550
2551
2552
2553
2554 if (WARN(of_node && type != IRQ_TYPE_NONE,
2555 "%pOF: Ignoring %d default trigger\n", of_node, type))
2556 type = IRQ_TYPE_NONE;
2557 if (has_acpi_companion(gpiochip->parent) && type != IRQ_TYPE_NONE) {
2558 acpi_handle_warn(ACPI_HANDLE(gpiochip->parent),
2559 "Ignoring %d default trigger\n", type);
2560 type = IRQ_TYPE_NONE;
2561 }
2562
2563 gpiochip->irq.chip = irqchip;
2564 gpiochip->irq.handler = handler;
2565 gpiochip->irq.default_type = type;
2566 gpiochip->to_irq = gpiochip_to_irq;
2567 gpiochip->irq.lock_key = lock_key;
2568 gpiochip->irq.request_key = request_key;
2569 gpiochip->irq.domain = irq_domain_add_simple(of_node,
2570 gpiochip->ngpio, first_irq,
2571 &gpiochip_domain_ops, gpiochip);
2572 if (!gpiochip->irq.domain) {
2573 gpiochip->irq.chip = NULL;
2574 return -EINVAL;
2575 }
2576
2577 gpiochip_set_irq_hooks(gpiochip);
2578
2579 acpi_gpiochip_request_interrupts(gpiochip);
2580
2581 return 0;
2582}
2583EXPORT_SYMBOL_GPL(gpiochip_irqchip_add_key);
2584
2585#else
2586
2587static inline int gpiochip_add_irqchip(struct gpio_chip *gpiochip,
2588 struct lock_class_key *lock_key,
2589 struct lock_class_key *request_key)
2590{
2591 return 0;
2592}
2593static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip) {}
2594
2595static inline int gpiochip_irqchip_init_hw(struct gpio_chip *gpiochip)
2596{
2597 return 0;
2598}
2599
2600static inline int gpiochip_irqchip_init_valid_mask(struct gpio_chip *gpiochip)
2601{
2602 return 0;
2603}
2604static inline void gpiochip_irqchip_free_valid_mask(struct gpio_chip *gpiochip)
2605{ }
2606
2607#endif
2608
2609
2610
2611
2612
2613
2614int gpiochip_generic_request(struct gpio_chip *chip, unsigned offset)
2615{
2616 return pinctrl_gpio_request(chip->gpiodev->base + offset);
2617}
2618EXPORT_SYMBOL_GPL(gpiochip_generic_request);
2619
2620
2621
2622
2623
2624
2625void gpiochip_generic_free(struct gpio_chip *chip, unsigned offset)
2626{
2627 pinctrl_gpio_free(chip->gpiodev->base + offset);
2628}
2629EXPORT_SYMBOL_GPL(gpiochip_generic_free);
2630
2631
2632
2633
2634
2635
2636
2637int gpiochip_generic_config(struct gpio_chip *chip, unsigned offset,
2638 unsigned long config)
2639{
2640 return pinctrl_gpio_set_config(chip->gpiodev->base + offset, config);
2641}
2642EXPORT_SYMBOL_GPL(gpiochip_generic_config);
2643
2644#ifdef CONFIG_PINCTRL
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
2656
2657
2658int gpiochip_add_pingroup_range(struct gpio_chip *chip,
2659 struct pinctrl_dev *pctldev,
2660 unsigned int gpio_offset, const char *pin_group)
2661{
2662 struct gpio_pin_range *pin_range;
2663 struct gpio_device *gdev = chip->gpiodev;
2664 int ret;
2665
2666 pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
2667 if (!pin_range) {
2668 chip_err(chip, "failed to allocate pin ranges\n");
2669 return -ENOMEM;
2670 }
2671
2672
2673 pin_range->range.id = gpio_offset;
2674 pin_range->range.gc = chip;
2675 pin_range->range.name = chip->label;
2676 pin_range->range.base = gdev->base + gpio_offset;
2677 pin_range->pctldev = pctldev;
2678
2679 ret = pinctrl_get_group_pins(pctldev, pin_group,
2680 &pin_range->range.pins,
2681 &pin_range->range.npins);
2682 if (ret < 0) {
2683 kfree(pin_range);
2684 return ret;
2685 }
2686
2687 pinctrl_add_gpio_range(pctldev, &pin_range->range);
2688
2689 chip_dbg(chip, "created GPIO range %d->%d ==> %s PINGRP %s\n",
2690 gpio_offset, gpio_offset + pin_range->range.npins - 1,
2691 pinctrl_dev_get_devname(pctldev), pin_group);
2692
2693 list_add_tail(&pin_range->node, &gdev->pin_ranges);
2694
2695 return 0;
2696}
2697EXPORT_SYMBOL_GPL(gpiochip_add_pingroup_range);
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
2712
2713
2714
2715
2716int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
2717 unsigned int gpio_offset, unsigned int pin_offset,
2718 unsigned int npins)
2719{
2720 struct gpio_pin_range *pin_range;
2721 struct gpio_device *gdev = chip->gpiodev;
2722 int ret;
2723
2724 pin_range = kzalloc(sizeof(*pin_range), GFP_KERNEL);
2725 if (!pin_range) {
2726 chip_err(chip, "failed to allocate pin ranges\n");
2727 return -ENOMEM;
2728 }
2729
2730
2731 pin_range->range.id = gpio_offset;
2732 pin_range->range.gc = chip;
2733 pin_range->range.name = chip->label;
2734 pin_range->range.base = gdev->base + gpio_offset;
2735 pin_range->range.pin_base = pin_offset;
2736 pin_range->range.npins = npins;
2737 pin_range->pctldev = pinctrl_find_and_add_gpio_range(pinctl_name,
2738 &pin_range->range);
2739 if (IS_ERR(pin_range->pctldev)) {
2740 ret = PTR_ERR(pin_range->pctldev);
2741 chip_err(chip, "could not create pin range\n");
2742 kfree(pin_range);
2743 return ret;
2744 }
2745 chip_dbg(chip, "created GPIO range %d->%d ==> %s PIN %d->%d\n",
2746 gpio_offset, gpio_offset + npins - 1,
2747 pinctl_name,
2748 pin_offset, pin_offset + npins - 1);
2749
2750 list_add_tail(&pin_range->node, &gdev->pin_ranges);
2751
2752 return 0;
2753}
2754EXPORT_SYMBOL_GPL(gpiochip_add_pin_range);
2755
2756
2757
2758
2759
2760void gpiochip_remove_pin_ranges(struct gpio_chip *chip)
2761{
2762 struct gpio_pin_range *pin_range, *tmp;
2763 struct gpio_device *gdev = chip->gpiodev;
2764
2765 list_for_each_entry_safe(pin_range, tmp, &gdev->pin_ranges, node) {
2766 list_del(&pin_range->node);
2767 pinctrl_remove_gpio_range(pin_range->pctldev,
2768 &pin_range->range);
2769 kfree(pin_range);
2770 }
2771}
2772EXPORT_SYMBOL_GPL(gpiochip_remove_pin_ranges);
2773
2774#endif
2775
2776
2777
2778
2779
2780static int gpiod_request_commit(struct gpio_desc *desc, const char *label)
2781{
2782 struct gpio_chip *chip = desc->gdev->chip;
2783 int ret;
2784 unsigned long flags;
2785 unsigned offset;
2786
2787 if (label) {
2788 label = kstrdup_const(label, GFP_KERNEL);
2789 if (!label)
2790 return -ENOMEM;
2791 }
2792
2793 spin_lock_irqsave(&gpio_lock, flags);
2794
2795
2796
2797
2798
2799 if (test_and_set_bit(FLAG_REQUESTED, &desc->flags) == 0) {
2800 desc_set_label(desc, label ? : "?");
2801 ret = 0;
2802 } else {
2803 kfree_const(label);
2804 ret = -EBUSY;
2805 goto done;
2806 }
2807
2808 if (chip->request) {
2809
2810 spin_unlock_irqrestore(&gpio_lock, flags);
2811 offset = gpio_chip_hwgpio(desc);
2812 if (gpiochip_line_is_valid(chip, offset))
2813 ret = chip->request(chip, offset);
2814 else
2815 ret = -EINVAL;
2816 spin_lock_irqsave(&gpio_lock, flags);
2817
2818 if (ret < 0) {
2819 desc_set_label(desc, NULL);
2820 kfree_const(label);
2821 clear_bit(FLAG_REQUESTED, &desc->flags);
2822 goto done;
2823 }
2824 }
2825 if (chip->get_direction) {
2826
2827 spin_unlock_irqrestore(&gpio_lock, flags);
2828 gpiod_get_direction(desc);
2829 spin_lock_irqsave(&gpio_lock, flags);
2830 }
2831done:
2832 spin_unlock_irqrestore(&gpio_lock, flags);
2833 return ret;
2834}
2835
2836
2837
2838
2839
2840
2841
2842static int validate_desc(const struct gpio_desc *desc, const char *func)
2843{
2844 if (!desc)
2845 return 0;
2846 if (IS_ERR(desc)) {
2847 pr_warn("%s: invalid GPIO (errorpointer)\n", func);
2848 return PTR_ERR(desc);
2849 }
2850 if (!desc->gdev) {
2851 pr_warn("%s: invalid GPIO (no device)\n", func);
2852 return -EINVAL;
2853 }
2854 if (!desc->gdev->chip) {
2855 dev_warn(&desc->gdev->dev,
2856 "%s: backing chip is gone\n", func);
2857 return 0;
2858 }
2859 return 1;
2860}
2861
2862#define VALIDATE_DESC(desc) do { \
2863 int __valid = validate_desc(desc, __func__); \
2864 if (__valid <= 0) \
2865 return __valid; \
2866 } while (0)
2867
2868#define VALIDATE_DESC_VOID(desc) do { \
2869 int __valid = validate_desc(desc, __func__); \
2870 if (__valid <= 0) \
2871 return; \
2872 } while (0)
2873
2874int gpiod_request(struct gpio_desc *desc, const char *label)
2875{
2876 int ret = -EPROBE_DEFER;
2877 struct gpio_device *gdev;
2878
2879 VALIDATE_DESC(desc);
2880 gdev = desc->gdev;
2881
2882 if (try_module_get(gdev->owner)) {
2883 ret = gpiod_request_commit(desc, label);
2884 if (ret < 0)
2885 module_put(gdev->owner);
2886 else
2887 get_device(&gdev->dev);
2888 }
2889
2890 if (ret)
2891 gpiod_dbg(desc, "%s: status %d\n", __func__, ret);
2892
2893 return ret;
2894}
2895
2896static bool gpiod_free_commit(struct gpio_desc *desc)
2897{
2898 bool ret = false;
2899 unsigned long flags;
2900 struct gpio_chip *chip;
2901
2902 might_sleep();
2903
2904 gpiod_unexport(desc);
2905
2906 spin_lock_irqsave(&gpio_lock, flags);
2907
2908 chip = desc->gdev->chip;
2909 if (chip && test_bit(FLAG_REQUESTED, &desc->flags)) {
2910 if (chip->free) {
2911 spin_unlock_irqrestore(&gpio_lock, flags);
2912 might_sleep_if(chip->can_sleep);
2913 chip->free(chip, gpio_chip_hwgpio(desc));
2914 spin_lock_irqsave(&gpio_lock, flags);
2915 }
2916 kfree_const(desc->label);
2917 desc_set_label(desc, NULL);
2918 clear_bit(FLAG_ACTIVE_LOW, &desc->flags);
2919 clear_bit(FLAG_REQUESTED, &desc->flags);
2920 clear_bit(FLAG_OPEN_DRAIN, &desc->flags);
2921 clear_bit(FLAG_OPEN_SOURCE, &desc->flags);
2922 clear_bit(FLAG_PULL_UP, &desc->flags);
2923 clear_bit(FLAG_PULL_DOWN, &desc->flags);
2924 clear_bit(FLAG_BIAS_DISABLE, &desc->flags);
2925 clear_bit(FLAG_IS_HOGGED, &desc->flags);
2926 ret = true;
2927 }
2928
2929 spin_unlock_irqrestore(&gpio_lock, flags);
2930 return ret;
2931}
2932
2933void gpiod_free(struct gpio_desc *desc)
2934{
2935 if (desc && desc->gdev && gpiod_free_commit(desc)) {
2936 module_put(desc->gdev->owner);
2937 put_device(&desc->gdev->dev);
2938 } else {
2939 WARN_ON(extra_checks);
2940 }
2941}
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952
2953
2954
2955
2956const char *gpiochip_is_requested(struct gpio_chip *chip, unsigned offset)
2957{
2958 struct gpio_desc *desc;
2959
2960 if (offset >= chip->ngpio)
2961 return NULL;
2962
2963 desc = &chip->gpiodev->descs[offset];
2964
2965 if (test_bit(FLAG_REQUESTED, &desc->flags) == 0)
2966 return NULL;
2967 return desc->label;
2968}
2969EXPORT_SYMBOL_GPL(gpiochip_is_requested);
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992struct gpio_desc *gpiochip_request_own_desc(struct gpio_chip *chip,
2993 unsigned int hwnum,
2994 const char *label,
2995 enum gpio_lookup_flags lflags,
2996 enum gpiod_flags dflags)
2997{
2998 struct gpio_desc *desc = gpiochip_get_desc(chip, hwnum);
2999 int ret;
3000
3001 if (IS_ERR(desc)) {
3002 chip_err(chip, "failed to get GPIO descriptor\n");
3003 return desc;
3004 }
3005
3006 ret = gpiod_request_commit(desc, label);
3007 if (ret < 0)
3008 return ERR_PTR(ret);
3009
3010 ret = gpiod_configure_flags(desc, label, lflags, dflags);
3011 if (ret) {
3012 chip_err(chip, "setup of own GPIO %s failed\n", label);
3013 gpiod_free_commit(desc);
3014 return ERR_PTR(ret);
3015 }
3016
3017 return desc;
3018}
3019EXPORT_SYMBOL_GPL(gpiochip_request_own_desc);
3020
3021
3022
3023
3024
3025
3026
3027
3028void gpiochip_free_own_desc(struct gpio_desc *desc)
3029{
3030 if (desc)
3031 gpiod_free_commit(desc);
3032}
3033EXPORT_SYMBOL_GPL(gpiochip_free_own_desc);
3034
3035
3036
3037
3038
3039
3040
3041
3042
3043
3044
3045static int gpio_do_set_config(struct gpio_chip *gc, unsigned int offset,
3046 unsigned long config)
3047{
3048 if (!gc->set_config)
3049 return -ENOTSUPP;
3050
3051 return gc->set_config(gc, offset, config);
3052}
3053
3054static int gpio_set_config(struct gpio_chip *gc, unsigned int offset,
3055 enum pin_config_param mode)
3056{
3057 unsigned long config;
3058 unsigned arg;
3059
3060 switch (mode) {
3061 case PIN_CONFIG_BIAS_PULL_DOWN:
3062 case PIN_CONFIG_BIAS_PULL_UP:
3063 arg = 1;
3064 break;
3065
3066 default:
3067 arg = 0;
3068 }
3069
3070 config = PIN_CONF_PACKED(mode, arg);
3071 return gpio_do_set_config(gc, offset, config);
3072}
3073
3074static int gpio_set_bias(struct gpio_chip *chip, struct gpio_desc *desc)
3075{
3076 int bias = 0;
3077 int ret = 0;
3078
3079 if (test_bit(FLAG_BIAS_DISABLE, &desc->flags))
3080 bias = PIN_CONFIG_BIAS_DISABLE;
3081 else if (test_bit(FLAG_PULL_UP, &desc->flags))
3082 bias = PIN_CONFIG_BIAS_PULL_UP;
3083 else if (test_bit(FLAG_PULL_DOWN, &desc->flags))
3084 bias = PIN_CONFIG_BIAS_PULL_DOWN;
3085
3086 if (bias) {
3087 ret = gpio_set_config(chip, gpio_chip_hwgpio(desc), bias);
3088 if (ret != -ENOTSUPP)
3089 return ret;
3090 }
3091 return 0;
3092}
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102
3103int gpiod_direction_input(struct gpio_desc *desc)
3104{
3105 struct gpio_chip *chip;
3106 int ret = 0;
3107
3108 VALIDATE_DESC(desc);
3109 chip = desc->gdev->chip;
3110
3111
3112
3113
3114
3115
3116 if (!chip->get && chip->direction_input) {
3117 gpiod_warn(desc,
3118 "%s: missing get() but have direction_input()\n",
3119 __func__);
3120 return -EIO;
3121 }
3122
3123
3124
3125
3126
3127
3128
3129 if (chip->direction_input) {
3130 ret = chip->direction_input(chip, gpio_chip_hwgpio(desc));
3131 } else if (chip->get_direction &&
3132 (chip->get_direction(chip, gpio_chip_hwgpio(desc)) != 1)) {
3133 gpiod_warn(desc,
3134 "%s: missing direction_input() operation and line is output\n",
3135 __func__);
3136 return -EIO;
3137 }
3138 if (ret == 0) {
3139 clear_bit(FLAG_IS_OUT, &desc->flags);
3140 ret = gpio_set_bias(chip, desc);
3141 }
3142
3143 trace_gpio_direction(desc_to_gpio(desc), 1, ret);
3144
3145 return ret;
3146}
3147EXPORT_SYMBOL_GPL(gpiod_direction_input);
3148
3149static int gpiod_direction_output_raw_commit(struct gpio_desc *desc, int value)
3150{
3151 struct gpio_chip *gc = desc->gdev->chip;
3152 int val = !!value;
3153 int ret = 0;
3154
3155
3156
3157
3158
3159
3160 if (!gc->set && !gc->direction_output) {
3161 gpiod_warn(desc,
3162 "%s: missing set() and direction_output() operations\n",
3163 __func__);
3164 return -EIO;
3165 }
3166
3167 if (gc->direction_output) {
3168 ret = gc->direction_output(gc, gpio_chip_hwgpio(desc), val);
3169 } else {
3170
3171 if (gc->get_direction &&
3172 gc->get_direction(gc, gpio_chip_hwgpio(desc))) {
3173 gpiod_warn(desc,
3174 "%s: missing direction_output() operation\n",
3175 __func__);
3176 return -EIO;
3177 }
3178
3179
3180
3181
3182 gc->set(gc, gpio_chip_hwgpio(desc), val);
3183 }
3184
3185 if (!ret)
3186 set_bit(FLAG_IS_OUT, &desc->flags);
3187 trace_gpio_value(desc_to_gpio(desc), 0, val);
3188 trace_gpio_direction(desc_to_gpio(desc), 0, ret);
3189 return ret;
3190}
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200
3201
3202
3203int gpiod_direction_output_raw(struct gpio_desc *desc, int value)
3204{
3205 VALIDATE_DESC(desc);
3206 return gpiod_direction_output_raw_commit(desc, value);
3207}
3208EXPORT_SYMBOL_GPL(gpiod_direction_output_raw);
3209
3210
3211
3212
3213
3214
3215
3216
3217
3218
3219
3220
3221
3222int gpiod_direction_output(struct gpio_desc *desc, int value)
3223{
3224 struct gpio_chip *gc;
3225 int ret;
3226
3227 VALIDATE_DESC(desc);
3228 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3229 value = !value;
3230 else
3231 value = !!value;
3232
3233
3234 if (test_bit(FLAG_USED_AS_IRQ, &desc->flags) &&
3235 test_bit(FLAG_IRQ_IS_ENABLED, &desc->flags)) {
3236 gpiod_err(desc,
3237 "%s: tried to set a GPIO tied to an IRQ as output\n",
3238 __func__);
3239 return -EIO;
3240 }
3241
3242 gc = desc->gdev->chip;
3243 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags)) {
3244
3245 ret = gpio_set_config(gc, gpio_chip_hwgpio(desc),
3246 PIN_CONFIG_DRIVE_OPEN_DRAIN);
3247 if (!ret)
3248 goto set_output_value;
3249
3250 if (value) {
3251 ret = gpiod_direction_input(desc);
3252 goto set_output_flag;
3253 }
3254 }
3255 else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags)) {
3256 ret = gpio_set_config(gc, gpio_chip_hwgpio(desc),
3257 PIN_CONFIG_DRIVE_OPEN_SOURCE);
3258 if (!ret)
3259 goto set_output_value;
3260
3261 if (!value) {
3262 ret = gpiod_direction_input(desc);
3263 goto set_output_flag;
3264 }
3265 } else {
3266 gpio_set_config(gc, gpio_chip_hwgpio(desc),
3267 PIN_CONFIG_DRIVE_PUSH_PULL);
3268 }
3269
3270set_output_value:
3271 ret = gpio_set_bias(gc, desc);
3272 if (ret)
3273 return ret;
3274 return gpiod_direction_output_raw_commit(desc, value);
3275
3276set_output_flag:
3277
3278
3279
3280
3281
3282
3283 if (ret == 0)
3284 set_bit(FLAG_IS_OUT, &desc->flags);
3285 return ret;
3286}
3287EXPORT_SYMBOL_GPL(gpiod_direction_output);
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
3299{
3300 struct gpio_chip *chip;
3301 unsigned long config;
3302
3303 VALIDATE_DESC(desc);
3304 chip = desc->gdev->chip;
3305
3306 config = pinconf_to_config_packed(PIN_CONFIG_INPUT_DEBOUNCE, debounce);
3307 return gpio_do_set_config(chip, gpio_chip_hwgpio(desc), config);
3308}
3309EXPORT_SYMBOL_GPL(gpiod_set_debounce);
3310
3311
3312
3313
3314
3315
3316
3317
3318
3319int gpiod_set_transitory(struct gpio_desc *desc, bool transitory)
3320{
3321 struct gpio_chip *chip;
3322 unsigned long packed;
3323 int gpio;
3324 int rc;
3325
3326 VALIDATE_DESC(desc);
3327
3328
3329
3330
3331 assign_bit(FLAG_TRANSITORY, &desc->flags, transitory);
3332
3333
3334 chip = desc->gdev->chip;
3335 if (!chip->set_config)
3336 return 0;
3337
3338 packed = pinconf_to_config_packed(PIN_CONFIG_PERSIST_STATE,
3339 !transitory);
3340 gpio = gpio_chip_hwgpio(desc);
3341 rc = gpio_do_set_config(chip, gpio, packed);
3342 if (rc == -ENOTSUPP) {
3343 dev_dbg(&desc->gdev->dev, "Persistence not supported for GPIO %d\n",
3344 gpio);
3345 return 0;
3346 }
3347
3348 return rc;
3349}
3350EXPORT_SYMBOL_GPL(gpiod_set_transitory);
3351
3352
3353
3354
3355
3356
3357
3358int gpiod_is_active_low(const struct gpio_desc *desc)
3359{
3360 VALIDATE_DESC(desc);
3361 return test_bit(FLAG_ACTIVE_LOW, &desc->flags);
3362}
3363EXPORT_SYMBOL_GPL(gpiod_is_active_low);
3364
3365
3366
3367
3368
3369void gpiod_toggle_active_low(struct gpio_desc *desc)
3370{
3371 VALIDATE_DESC_VOID(desc);
3372 change_bit(FLAG_ACTIVE_LOW, &desc->flags);
3373}
3374EXPORT_SYMBOL_GPL(gpiod_toggle_active_low);
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
3397
3398static int gpiod_get_raw_value_commit(const struct gpio_desc *desc)
3399{
3400 struct gpio_chip *chip;
3401 int offset;
3402 int value;
3403
3404 chip = desc->gdev->chip;
3405 offset = gpio_chip_hwgpio(desc);
3406 value = chip->get ? chip->get(chip, offset) : -EIO;
3407 value = value < 0 ? value : !!value;
3408 trace_gpio_value(desc_to_gpio(desc), 1, value);
3409 return value;
3410}
3411
3412static int gpio_chip_get_multiple(struct gpio_chip *chip,
3413 unsigned long *mask, unsigned long *bits)
3414{
3415 if (chip->get_multiple) {
3416 return chip->get_multiple(chip, mask, bits);
3417 } else if (chip->get) {
3418 int i, value;
3419
3420 for_each_set_bit(i, mask, chip->ngpio) {
3421 value = chip->get(chip, i);
3422 if (value < 0)
3423 return value;
3424 __assign_bit(i, bits, value);
3425 }
3426 return 0;
3427 }
3428 return -EIO;
3429}
3430
3431int gpiod_get_array_value_complex(bool raw, bool can_sleep,
3432 unsigned int array_size,
3433 struct gpio_desc **desc_array,
3434 struct gpio_array *array_info,
3435 unsigned long *value_bitmap)
3436{
3437 int ret, i = 0;
3438
3439
3440
3441
3442
3443
3444 if (array_info && array_info->desc == desc_array &&
3445 array_size <= array_info->size &&
3446 (void *)array_info == desc_array + array_info->size) {
3447 if (!can_sleep)
3448 WARN_ON(array_info->chip->can_sleep);
3449
3450 ret = gpio_chip_get_multiple(array_info->chip,
3451 array_info->get_mask,
3452 value_bitmap);
3453 if (ret)
3454 return ret;
3455
3456 if (!raw && !bitmap_empty(array_info->invert_mask, array_size))
3457 bitmap_xor(value_bitmap, value_bitmap,
3458 array_info->invert_mask, array_size);
3459
3460 if (bitmap_full(array_info->get_mask, array_size))
3461 return 0;
3462
3463 i = find_first_zero_bit(array_info->get_mask, array_size);
3464 } else {
3465 array_info = NULL;
3466 }
3467
3468 while (i < array_size) {
3469 struct gpio_chip *chip = desc_array[i]->gdev->chip;
3470 unsigned long fastpath[2 * BITS_TO_LONGS(FASTPATH_NGPIO)];
3471 unsigned long *mask, *bits;
3472 int first, j, ret;
3473
3474 if (likely(chip->ngpio <= FASTPATH_NGPIO)) {
3475 mask = fastpath;
3476 } else {
3477 mask = kmalloc_array(2 * BITS_TO_LONGS(chip->ngpio),
3478 sizeof(*mask),
3479 can_sleep ? GFP_KERNEL : GFP_ATOMIC);
3480 if (!mask)
3481 return -ENOMEM;
3482 }
3483
3484 bits = mask + BITS_TO_LONGS(chip->ngpio);
3485 bitmap_zero(mask, chip->ngpio);
3486
3487 if (!can_sleep)
3488 WARN_ON(chip->can_sleep);
3489
3490
3491 first = i;
3492 do {
3493 const struct gpio_desc *desc = desc_array[i];
3494 int hwgpio = gpio_chip_hwgpio(desc);
3495
3496 __set_bit(hwgpio, mask);
3497 i++;
3498
3499 if (array_info)
3500 i = find_next_zero_bit(array_info->get_mask,
3501 array_size, i);
3502 } while ((i < array_size) &&
3503 (desc_array[i]->gdev->chip == chip));
3504
3505 ret = gpio_chip_get_multiple(chip, mask, bits);
3506 if (ret) {
3507 if (mask != fastpath)
3508 kfree(mask);
3509 return ret;
3510 }
3511
3512 for (j = first; j < i; ) {
3513 const struct gpio_desc *desc = desc_array[j];
3514 int hwgpio = gpio_chip_hwgpio(desc);
3515 int value = test_bit(hwgpio, bits);
3516
3517 if (!raw && test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3518 value = !value;
3519 __assign_bit(j, value_bitmap, value);
3520 trace_gpio_value(desc_to_gpio(desc), 1, value);
3521 j++;
3522
3523 if (array_info)
3524 j = find_next_zero_bit(array_info->get_mask, i,
3525 j);
3526 }
3527
3528 if (mask != fastpath)
3529 kfree(mask);
3530 }
3531 return 0;
3532}
3533
3534
3535
3536
3537
3538
3539
3540
3541
3542
3543
3544int gpiod_get_raw_value(const struct gpio_desc *desc)
3545{
3546 VALIDATE_DESC(desc);
3547
3548 WARN_ON(desc->gdev->chip->can_sleep);
3549 return gpiod_get_raw_value_commit(desc);
3550}
3551EXPORT_SYMBOL_GPL(gpiod_get_raw_value);
3552
3553
3554
3555
3556
3557
3558
3559
3560
3561
3562
3563int gpiod_get_value(const struct gpio_desc *desc)
3564{
3565 int value;
3566
3567 VALIDATE_DESC(desc);
3568
3569 WARN_ON(desc->gdev->chip->can_sleep);
3570
3571 value = gpiod_get_raw_value_commit(desc);
3572 if (value < 0)
3573 return value;
3574
3575 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3576 value = !value;
3577
3578 return value;
3579}
3580EXPORT_SYMBOL_GPL(gpiod_get_value);
3581
3582
3583
3584
3585
3586
3587
3588
3589
3590
3591
3592
3593
3594
3595
3596int gpiod_get_raw_array_value(unsigned int array_size,
3597 struct gpio_desc **desc_array,
3598 struct gpio_array *array_info,
3599 unsigned long *value_bitmap)
3600{
3601 if (!desc_array)
3602 return -EINVAL;
3603 return gpiod_get_array_value_complex(true, false, array_size,
3604 desc_array, array_info,
3605 value_bitmap);
3606}
3607EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value);
3608
3609
3610
3611
3612
3613
3614
3615
3616
3617
3618
3619
3620
3621
3622int gpiod_get_array_value(unsigned int array_size,
3623 struct gpio_desc **desc_array,
3624 struct gpio_array *array_info,
3625 unsigned long *value_bitmap)
3626{
3627 if (!desc_array)
3628 return -EINVAL;
3629 return gpiod_get_array_value_complex(false, false, array_size,
3630 desc_array, array_info,
3631 value_bitmap);
3632}
3633EXPORT_SYMBOL_GPL(gpiod_get_array_value);
3634
3635
3636
3637
3638
3639
3640static void gpio_set_open_drain_value_commit(struct gpio_desc *desc, bool value)
3641{
3642 int ret = 0;
3643 struct gpio_chip *chip = desc->gdev->chip;
3644 int offset = gpio_chip_hwgpio(desc);
3645
3646 if (value) {
3647 ret = chip->direction_input(chip, offset);
3648 } else {
3649 ret = chip->direction_output(chip, offset, 0);
3650 if (!ret)
3651 set_bit(FLAG_IS_OUT, &desc->flags);
3652 }
3653 trace_gpio_direction(desc_to_gpio(desc), value, ret);
3654 if (ret < 0)
3655 gpiod_err(desc,
3656 "%s: Error in set_value for open drain err %d\n",
3657 __func__, ret);
3658}
3659
3660
3661
3662
3663
3664
3665static void gpio_set_open_source_value_commit(struct gpio_desc *desc, bool value)
3666{
3667 int ret = 0;
3668 struct gpio_chip *chip = desc->gdev->chip;
3669 int offset = gpio_chip_hwgpio(desc);
3670
3671 if (value) {
3672 ret = chip->direction_output(chip, offset, 1);
3673 if (!ret)
3674 set_bit(FLAG_IS_OUT, &desc->flags);
3675 } else {
3676 ret = chip->direction_input(chip, offset);
3677 }
3678 trace_gpio_direction(desc_to_gpio(desc), !value, ret);
3679 if (ret < 0)
3680 gpiod_err(desc,
3681 "%s: Error in set_value for open source err %d\n",
3682 __func__, ret);
3683}
3684
3685static void gpiod_set_raw_value_commit(struct gpio_desc *desc, bool value)
3686{
3687 struct gpio_chip *chip;
3688
3689 chip = desc->gdev->chip;
3690 trace_gpio_value(desc_to_gpio(desc), 0, value);
3691 chip->set(chip, gpio_chip_hwgpio(desc), value);
3692}
3693
3694
3695
3696
3697
3698
3699
3700
3701
3702
3703static void gpio_chip_set_multiple(struct gpio_chip *chip,
3704 unsigned long *mask, unsigned long *bits)
3705{
3706 if (chip->set_multiple) {
3707 chip->set_multiple(chip, mask, bits);
3708 } else {
3709 unsigned int i;
3710
3711
3712 for_each_set_bit(i, mask, chip->ngpio)
3713 chip->set(chip, i, test_bit(i, bits));
3714 }
3715}
3716
3717int gpiod_set_array_value_complex(bool raw, bool can_sleep,
3718 unsigned int array_size,
3719 struct gpio_desc **desc_array,
3720 struct gpio_array *array_info,
3721 unsigned long *value_bitmap)
3722{
3723 int i = 0;
3724
3725
3726
3727
3728
3729
3730 if (array_info && array_info->desc == desc_array &&
3731 array_size <= array_info->size &&
3732 (void *)array_info == desc_array + array_info->size) {
3733 if (!can_sleep)
3734 WARN_ON(array_info->chip->can_sleep);
3735
3736 if (!raw && !bitmap_empty(array_info->invert_mask, array_size))
3737 bitmap_xor(value_bitmap, value_bitmap,
3738 array_info->invert_mask, array_size);
3739
3740 gpio_chip_set_multiple(array_info->chip, array_info->set_mask,
3741 value_bitmap);
3742
3743 if (bitmap_full(array_info->set_mask, array_size))
3744 return 0;
3745
3746 i = find_first_zero_bit(array_info->set_mask, array_size);
3747 } else {
3748 array_info = NULL;
3749 }
3750
3751 while (i < array_size) {
3752 struct gpio_chip *chip = desc_array[i]->gdev->chip;
3753 unsigned long fastpath[2 * BITS_TO_LONGS(FASTPATH_NGPIO)];
3754 unsigned long *mask, *bits;
3755 int count = 0;
3756
3757 if (likely(chip->ngpio <= FASTPATH_NGPIO)) {
3758 mask = fastpath;
3759 } else {
3760 mask = kmalloc_array(2 * BITS_TO_LONGS(chip->ngpio),
3761 sizeof(*mask),
3762 can_sleep ? GFP_KERNEL : GFP_ATOMIC);
3763 if (!mask)
3764 return -ENOMEM;
3765 }
3766
3767 bits = mask + BITS_TO_LONGS(chip->ngpio);
3768 bitmap_zero(mask, chip->ngpio);
3769
3770 if (!can_sleep)
3771 WARN_ON(chip->can_sleep);
3772
3773 do {
3774 struct gpio_desc *desc = desc_array[i];
3775 int hwgpio = gpio_chip_hwgpio(desc);
3776 int value = test_bit(i, value_bitmap);
3777
3778
3779
3780
3781
3782
3783 if (!raw && !(array_info &&
3784 test_bit(i, array_info->invert_mask)) &&
3785 test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3786 value = !value;
3787 trace_gpio_value(desc_to_gpio(desc), 0, value);
3788
3789
3790
3791
3792 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags) && !raw) {
3793 gpio_set_open_drain_value_commit(desc, value);
3794 } else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags) && !raw) {
3795 gpio_set_open_source_value_commit(desc, value);
3796 } else {
3797 __set_bit(hwgpio, mask);
3798 __assign_bit(hwgpio, bits, value);
3799 count++;
3800 }
3801 i++;
3802
3803 if (array_info)
3804 i = find_next_zero_bit(array_info->set_mask,
3805 array_size, i);
3806 } while ((i < array_size) &&
3807 (desc_array[i]->gdev->chip == chip));
3808
3809 if (count != 0)
3810 gpio_chip_set_multiple(chip, mask, bits);
3811
3812 if (mask != fastpath)
3813 kfree(mask);
3814 }
3815 return 0;
3816}
3817
3818
3819
3820
3821
3822
3823
3824
3825
3826
3827
3828
3829void gpiod_set_raw_value(struct gpio_desc *desc, int value)
3830{
3831 VALIDATE_DESC_VOID(desc);
3832
3833 WARN_ON(desc->gdev->chip->can_sleep);
3834 gpiod_set_raw_value_commit(desc, value);
3835}
3836EXPORT_SYMBOL_GPL(gpiod_set_raw_value);
3837
3838
3839
3840
3841
3842
3843
3844
3845
3846
3847static void gpiod_set_value_nocheck(struct gpio_desc *desc, int value)
3848{
3849 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
3850 value = !value;
3851 if (test_bit(FLAG_OPEN_DRAIN, &desc->flags))
3852 gpio_set_open_drain_value_commit(desc, value);
3853 else if (test_bit(FLAG_OPEN_SOURCE, &desc->flags))
3854 gpio_set_open_source_value_commit(desc, value);
3855 else
3856 gpiod_set_raw_value_commit(desc, value);
3857}
3858
3859
3860
3861
3862
3863
3864
3865
3866
3867
3868
3869
3870void gpiod_set_value(struct gpio_desc *desc, int value)
3871{
3872 VALIDATE_DESC_VOID(desc);
3873
3874 WARN_ON(desc->gdev->chip->can_sleep);
3875 gpiod_set_value_nocheck(desc, value);
3876}
3877EXPORT_SYMBOL_GPL(gpiod_set_value);
3878
3879
3880
3881
3882
3883
3884
3885
3886
3887
3888
3889
3890
3891
3892int gpiod_set_raw_array_value(unsigned int array_size,
3893 struct gpio_desc **desc_array,
3894 struct gpio_array *array_info,
3895 unsigned long *value_bitmap)
3896{
3897 if (!desc_array)
3898 return -EINVAL;
3899 return gpiod_set_array_value_complex(true, false, array_size,
3900 desc_array, array_info, value_bitmap);
3901}
3902EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value);
3903
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916
3917int gpiod_set_array_value(unsigned int array_size,
3918 struct gpio_desc **desc_array,
3919 struct gpio_array *array_info,
3920 unsigned long *value_bitmap)
3921{
3922 if (!desc_array)
3923 return -EINVAL;
3924 return gpiod_set_array_value_complex(false, false, array_size,
3925 desc_array, array_info,
3926 value_bitmap);
3927}
3928EXPORT_SYMBOL_GPL(gpiod_set_array_value);
3929
3930
3931
3932
3933
3934
3935int gpiod_cansleep(const struct gpio_desc *desc)
3936{
3937 VALIDATE_DESC(desc);
3938 return desc->gdev->chip->can_sleep;
3939}
3940EXPORT_SYMBOL_GPL(gpiod_cansleep);
3941
3942
3943
3944
3945
3946
3947int gpiod_set_consumer_name(struct gpio_desc *desc, const char *name)
3948{
3949 VALIDATE_DESC(desc);
3950 if (name) {
3951 name = kstrdup_const(name, GFP_KERNEL);
3952 if (!name)
3953 return -ENOMEM;
3954 }
3955
3956 kfree_const(desc->label);
3957 desc_set_label(desc, name);
3958
3959 return 0;
3960}
3961EXPORT_SYMBOL_GPL(gpiod_set_consumer_name);
3962
3963
3964
3965
3966
3967
3968
3969
3970int gpiod_to_irq(const struct gpio_desc *desc)
3971{
3972 struct gpio_chip *chip;
3973 int offset;
3974
3975
3976
3977
3978
3979
3980 if (!desc || IS_ERR(desc) || !desc->gdev || !desc->gdev->chip)
3981 return -EINVAL;
3982
3983 chip = desc->gdev->chip;
3984 offset = gpio_chip_hwgpio(desc);
3985 if (chip->to_irq) {
3986 int retirq = chip->to_irq(chip, offset);
3987
3988
3989 if (!retirq)
3990 return -ENXIO;
3991
3992 return retirq;
3993 }
3994 return -ENXIO;
3995}
3996EXPORT_SYMBOL_GPL(gpiod_to_irq);
3997
3998
3999
4000
4001
4002
4003
4004
4005
4006int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset)
4007{
4008 struct gpio_desc *desc;
4009
4010 desc = gpiochip_get_desc(chip, offset);
4011 if (IS_ERR(desc))
4012 return PTR_ERR(desc);
4013
4014
4015
4016
4017
4018 if (!chip->can_sleep && chip->get_direction) {
4019 int dir = gpiod_get_direction(desc);
4020
4021 if (dir < 0) {
4022 chip_err(chip, "%s: cannot get GPIO direction\n",
4023 __func__);
4024 return dir;
4025 }
4026 }
4027
4028 if (test_bit(FLAG_IS_OUT, &desc->flags)) {
4029 chip_err(chip,
4030 "%s: tried to flag a GPIO set as output for IRQ\n",
4031 __func__);
4032 return -EIO;
4033 }
4034
4035 set_bit(FLAG_USED_AS_IRQ, &desc->flags);
4036 set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
4037
4038
4039
4040
4041
4042
4043 if (!desc->label)
4044 desc_set_label(desc, "interrupt");
4045
4046 return 0;
4047}
4048EXPORT_SYMBOL_GPL(gpiochip_lock_as_irq);
4049
4050
4051
4052
4053
4054
4055
4056
4057
4058void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset)
4059{
4060 struct gpio_desc *desc;
4061
4062 desc = gpiochip_get_desc(chip, offset);
4063 if (IS_ERR(desc))
4064 return;
4065
4066 clear_bit(FLAG_USED_AS_IRQ, &desc->flags);
4067 clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
4068
4069
4070 if (desc->label && !strcmp(desc->label, "interrupt"))
4071 desc_set_label(desc, NULL);
4072}
4073EXPORT_SYMBOL_GPL(gpiochip_unlock_as_irq);
4074
4075void gpiochip_disable_irq(struct gpio_chip *chip, unsigned int offset)
4076{
4077 struct gpio_desc *desc = gpiochip_get_desc(chip, offset);
4078
4079 if (!IS_ERR(desc) &&
4080 !WARN_ON(!test_bit(FLAG_USED_AS_IRQ, &desc->flags)))
4081 clear_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
4082}
4083EXPORT_SYMBOL_GPL(gpiochip_disable_irq);
4084
4085void gpiochip_enable_irq(struct gpio_chip *chip, unsigned int offset)
4086{
4087 struct gpio_desc *desc = gpiochip_get_desc(chip, offset);
4088
4089 if (!IS_ERR(desc) &&
4090 !WARN_ON(!test_bit(FLAG_USED_AS_IRQ, &desc->flags))) {
4091 WARN_ON(test_bit(FLAG_IS_OUT, &desc->flags));
4092 set_bit(FLAG_IRQ_IS_ENABLED, &desc->flags);
4093 }
4094}
4095EXPORT_SYMBOL_GPL(gpiochip_enable_irq);
4096
4097bool gpiochip_line_is_irq(struct gpio_chip *chip, unsigned int offset)
4098{
4099 if (offset >= chip->ngpio)
4100 return false;
4101
4102 return test_bit(FLAG_USED_AS_IRQ, &chip->gpiodev->descs[offset].flags);
4103}
4104EXPORT_SYMBOL_GPL(gpiochip_line_is_irq);
4105
4106int gpiochip_reqres_irq(struct gpio_chip *chip, unsigned int offset)
4107{
4108 int ret;
4109
4110 if (!try_module_get(chip->gpiodev->owner))
4111 return -ENODEV;
4112
4113 ret = gpiochip_lock_as_irq(chip, offset);
4114 if (ret) {
4115 chip_err(chip, "unable to lock HW IRQ %u for IRQ\n", offset);
4116 module_put(chip->gpiodev->owner);
4117 return ret;
4118 }
4119 return 0;
4120}
4121EXPORT_SYMBOL_GPL(gpiochip_reqres_irq);
4122
4123void gpiochip_relres_irq(struct gpio_chip *chip, unsigned int offset)
4124{
4125 gpiochip_unlock_as_irq(chip, offset);
4126 module_put(chip->gpiodev->owner);
4127}
4128EXPORT_SYMBOL_GPL(gpiochip_relres_irq);
4129
4130bool gpiochip_line_is_open_drain(struct gpio_chip *chip, unsigned int offset)
4131{
4132 if (offset >= chip->ngpio)
4133 return false;
4134
4135 return test_bit(FLAG_OPEN_DRAIN, &chip->gpiodev->descs[offset].flags);
4136}
4137EXPORT_SYMBOL_GPL(gpiochip_line_is_open_drain);
4138
4139bool gpiochip_line_is_open_source(struct gpio_chip *chip, unsigned int offset)
4140{
4141 if (offset >= chip->ngpio)
4142 return false;
4143
4144 return test_bit(FLAG_OPEN_SOURCE, &chip->gpiodev->descs[offset].flags);
4145}
4146EXPORT_SYMBOL_GPL(gpiochip_line_is_open_source);
4147
4148bool gpiochip_line_is_persistent(struct gpio_chip *chip, unsigned int offset)
4149{
4150 if (offset >= chip->ngpio)
4151 return false;
4152
4153 return !test_bit(FLAG_TRANSITORY, &chip->gpiodev->descs[offset].flags);
4154}
4155EXPORT_SYMBOL_GPL(gpiochip_line_is_persistent);
4156
4157
4158
4159
4160
4161
4162
4163
4164
4165
4166int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
4167{
4168 might_sleep_if(extra_checks);
4169 VALIDATE_DESC(desc);
4170 return gpiod_get_raw_value_commit(desc);
4171}
4172EXPORT_SYMBOL_GPL(gpiod_get_raw_value_cansleep);
4173
4174
4175
4176
4177
4178
4179
4180
4181
4182
4183int gpiod_get_value_cansleep(const struct gpio_desc *desc)
4184{
4185 int value;
4186
4187 might_sleep_if(extra_checks);
4188 VALIDATE_DESC(desc);
4189 value = gpiod_get_raw_value_commit(desc);
4190 if (value < 0)
4191 return value;
4192
4193 if (test_bit(FLAG_ACTIVE_LOW, &desc->flags))
4194 value = !value;
4195
4196 return value;
4197}
4198EXPORT_SYMBOL_GPL(gpiod_get_value_cansleep);
4199
4200
4201
4202
4203
4204
4205
4206
4207
4208
4209
4210
4211
4212
4213int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
4214 struct gpio_desc **desc_array,
4215 struct gpio_array *array_info,
4216 unsigned long *value_bitmap)
4217{
4218 might_sleep_if(extra_checks);
4219 if (!desc_array)
4220 return -EINVAL;
4221 return gpiod_get_array_value_complex(true, true, array_size,
4222 desc_array, array_info,
4223 value_bitmap);
4224}
4225EXPORT_SYMBOL_GPL(gpiod_get_raw_array_value_cansleep);
4226
4227
4228
4229
4230
4231
4232
4233
4234
4235
4236
4237
4238
4239int gpiod_get_array_value_cansleep(unsigned int array_size,
4240 struct gpio_desc **desc_array,
4241 struct gpio_array *array_info,
4242 unsigned long *value_bitmap)
4243{
4244 might_sleep_if(extra_checks);
4245 if (!desc_array)
4246 return -EINVAL;
4247 return gpiod_get_array_value_complex(false, true, array_size,
4248 desc_array, array_info,
4249 value_bitmap);
4250}
4251EXPORT_SYMBOL_GPL(gpiod_get_array_value_cansleep);
4252
4253
4254
4255
4256
4257
4258
4259
4260
4261
4262
4263void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value)
4264{
4265 might_sleep_if(extra_checks);
4266 VALIDATE_DESC_VOID(desc);
4267 gpiod_set_raw_value_commit(desc, value);
4268}
4269EXPORT_SYMBOL_GPL(gpiod_set_raw_value_cansleep);
4270
4271
4272
4273
4274
4275
4276
4277
4278
4279
4280
4281void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
4282{
4283 might_sleep_if(extra_checks);
4284 VALIDATE_DESC_VOID(desc);
4285 gpiod_set_value_nocheck(desc, value);
4286}
4287EXPORT_SYMBOL_GPL(gpiod_set_value_cansleep);
4288
4289
4290
4291
4292
4293
4294
4295
4296
4297
4298
4299
4300
4301int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
4302 struct gpio_desc **desc_array,
4303 struct gpio_array *array_info,
4304 unsigned long *value_bitmap)
4305{
4306 might_sleep_if(extra_checks);
4307 if (!desc_array)
4308 return -EINVAL;
4309 return gpiod_set_array_value_complex(true, true, array_size, desc_array,
4310 array_info, value_bitmap);
4311}
4312EXPORT_SYMBOL_GPL(gpiod_set_raw_array_value_cansleep);
4313
4314
4315
4316
4317
4318
4319void gpiod_add_lookup_tables(struct gpiod_lookup_table **tables, size_t n)
4320{
4321 unsigned int i;
4322
4323 mutex_lock(&gpio_lookup_lock);
4324
4325 for (i = 0; i < n; i++)
4326 list_add_tail(&tables[i]->list, &gpio_lookup_list);
4327
4328 mutex_unlock(&gpio_lookup_lock);
4329}
4330
4331
4332
4333
4334
4335
4336
4337
4338
4339
4340
4341
4342
4343int gpiod_set_array_value_cansleep(unsigned int array_size,
4344 struct gpio_desc **desc_array,
4345 struct gpio_array *array_info,
4346 unsigned long *value_bitmap)
4347{
4348 might_sleep_if(extra_checks);
4349 if (!desc_array)
4350 return -EINVAL;
4351 return gpiod_set_array_value_complex(false, true, array_size,
4352 desc_array, array_info,
4353 value_bitmap);
4354}
4355EXPORT_SYMBOL_GPL(gpiod_set_array_value_cansleep);
4356
4357
4358
4359
4360
4361void gpiod_add_lookup_table(struct gpiod_lookup_table *table)
4362{
4363 mutex_lock(&gpio_lookup_lock);
4364
4365 list_add_tail(&table->list, &gpio_lookup_list);
4366
4367 mutex_unlock(&gpio_lookup_lock);
4368}
4369EXPORT_SYMBOL_GPL(gpiod_add_lookup_table);
4370
4371
4372
4373
4374
4375void gpiod_remove_lookup_table(struct gpiod_lookup_table *table)
4376{
4377 mutex_lock(&gpio_lookup_lock);
4378
4379 list_del(&table->list);
4380
4381 mutex_unlock(&gpio_lookup_lock);
4382}
4383EXPORT_SYMBOL_GPL(gpiod_remove_lookup_table);
4384
4385
4386
4387
4388
4389void gpiod_add_hogs(struct gpiod_hog *hogs)
4390{
4391 struct gpio_chip *chip;
4392 struct gpiod_hog *hog;
4393
4394 mutex_lock(&gpio_machine_hogs_mutex);
4395
4396 for (hog = &hogs[0]; hog->chip_label; hog++) {
4397 list_add_tail(&hog->list, &gpio_machine_hogs);
4398
4399
4400
4401
4402
4403 chip = find_chip_by_name(hog->chip_label);
4404 if (chip)
4405 gpiochip_machine_hog(chip, hog);
4406 }
4407
4408 mutex_unlock(&gpio_machine_hogs_mutex);
4409}
4410EXPORT_SYMBOL_GPL(gpiod_add_hogs);
4411
4412static struct gpiod_lookup_table *gpiod_find_lookup_table(struct device *dev)
4413{
4414 const char *dev_id = dev ? dev_name(dev) : NULL;
4415 struct gpiod_lookup_table *table;
4416
4417 mutex_lock(&gpio_lookup_lock);
4418
4419 list_for_each_entry(table, &gpio_lookup_list, list) {
4420 if (table->dev_id && dev_id) {
4421
4422
4423
4424
4425 if (!strcmp(table->dev_id, dev_id))
4426 goto found;
4427 } else {
4428
4429
4430
4431
4432 if (dev_id == table->dev_id)
4433 goto found;
4434 }
4435 }
4436 table = NULL;
4437
4438found:
4439 mutex_unlock(&gpio_lookup_lock);
4440 return table;
4441}
4442
4443static struct gpio_desc *gpiod_find(struct device *dev, const char *con_id,
4444 unsigned int idx, unsigned long *flags)
4445{
4446 struct gpio_desc *desc = ERR_PTR(-ENOENT);
4447 struct gpiod_lookup_table *table;
4448 struct gpiod_lookup *p;
4449
4450 table = gpiod_find_lookup_table(dev);
4451 if (!table)
4452 return desc;
4453
4454 for (p = &table->table[0]; p->chip_label; p++) {
4455 struct gpio_chip *chip;
4456
4457
4458 if (p->idx != idx)
4459 continue;
4460
4461
4462 if (p->con_id && (!con_id || strcmp(p->con_id, con_id)))
4463 continue;
4464
4465 chip = find_chip_by_name(p->chip_label);
4466
4467 if (!chip) {
4468
4469
4470
4471
4472
4473
4474
4475 dev_warn(dev, "cannot find GPIO chip %s, deferring\n",
4476 p->chip_label);
4477 return ERR_PTR(-EPROBE_DEFER);
4478 }
4479
4480 if (chip->ngpio <= p->chip_hwnum) {
4481 dev_err(dev,
4482 "requested GPIO %u (%u) is out of range [0..%u] for chip %s\n",
4483 idx, p->chip_hwnum, chip->ngpio - 1,
4484 chip->label);
4485 return ERR_PTR(-EINVAL);
4486 }
4487
4488 desc = gpiochip_get_desc(chip, p->chip_hwnum);
4489 *flags = p->flags;
4490
4491 return desc;
4492 }
4493
4494 return desc;
4495}
4496
4497static int platform_gpio_count(struct device *dev, const char *con_id)
4498{
4499 struct gpiod_lookup_table *table;
4500 struct gpiod_lookup *p;
4501 unsigned int count = 0;
4502
4503 table = gpiod_find_lookup_table(dev);
4504 if (!table)
4505 return -ENOENT;
4506
4507 for (p = &table->table[0]; p->chip_label; p++) {
4508 if ((con_id && p->con_id && !strcmp(con_id, p->con_id)) ||
4509 (!con_id && !p->con_id))
4510 count++;
4511 }
4512 if (!count)
4513 return -ENOENT;
4514
4515 return count;
4516}
4517
4518
4519
4520
4521
4522
4523
4524
4525
4526
4527
4528
4529
4530
4531
4532
4533
4534
4535
4536
4537
4538
4539struct gpio_desc *fwnode_gpiod_get_index(struct fwnode_handle *fwnode,
4540 const char *con_id, int index,
4541 enum gpiod_flags flags,
4542 const char *label)
4543{
4544 struct gpio_desc *desc;
4545 char prop_name[32];
4546 unsigned int i;
4547
4548 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
4549 if (con_id)
4550 snprintf(prop_name, sizeof(prop_name), "%s-%s",
4551 con_id, gpio_suffixes[i]);
4552 else
4553 snprintf(prop_name, sizeof(prop_name), "%s",
4554 gpio_suffixes[i]);
4555
4556 desc = fwnode_get_named_gpiod(fwnode, prop_name, index, flags,
4557 label);
4558 if (!gpiod_not_found(desc))
4559 break;
4560 }
4561
4562 return desc;
4563}
4564EXPORT_SYMBOL_GPL(fwnode_gpiod_get_index);
4565
4566
4567
4568
4569
4570
4571
4572int gpiod_count(struct device *dev, const char *con_id)
4573{
4574 int count = -ENOENT;
4575
4576 if (IS_ENABLED(CONFIG_OF) && dev && dev->of_node)
4577 count = of_gpio_get_count(dev, con_id);
4578 else if (IS_ENABLED(CONFIG_ACPI) && dev && ACPI_HANDLE(dev))
4579 count = acpi_gpio_count(dev, con_id);
4580
4581 if (count < 0)
4582 count = platform_gpio_count(dev, con_id);
4583
4584 return count;
4585}
4586EXPORT_SYMBOL_GPL(gpiod_count);
4587
4588
4589
4590
4591
4592
4593
4594
4595
4596
4597
4598struct gpio_desc *__must_check gpiod_get(struct device *dev, const char *con_id,
4599 enum gpiod_flags flags)
4600{
4601 return gpiod_get_index(dev, con_id, 0, flags);
4602}
4603EXPORT_SYMBOL_GPL(gpiod_get);
4604
4605
4606
4607
4608
4609
4610
4611
4612
4613
4614
4615struct gpio_desc *__must_check gpiod_get_optional(struct device *dev,
4616 const char *con_id,
4617 enum gpiod_flags flags)
4618{
4619 return gpiod_get_index_optional(dev, con_id, 0, flags);
4620}
4621EXPORT_SYMBOL_GPL(gpiod_get_optional);
4622
4623
4624
4625
4626
4627
4628
4629
4630
4631
4632
4633
4634
4635
4636int gpiod_configure_flags(struct gpio_desc *desc, const char *con_id,
4637 unsigned long lflags, enum gpiod_flags dflags)
4638{
4639 int ret;
4640
4641 if (lflags & GPIO_ACTIVE_LOW)
4642 set_bit(FLAG_ACTIVE_LOW, &desc->flags);
4643
4644 if (lflags & GPIO_OPEN_DRAIN)
4645 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
4646 else if (dflags & GPIOD_FLAGS_BIT_OPEN_DRAIN) {
4647
4648
4649
4650
4651
4652
4653 set_bit(FLAG_OPEN_DRAIN, &desc->flags);
4654 gpiod_warn(desc,
4655 "enforced open drain please flag it properly in DT/ACPI DSDT/board file\n");
4656 }
4657
4658 if (lflags & GPIO_OPEN_SOURCE)
4659 set_bit(FLAG_OPEN_SOURCE, &desc->flags);
4660
4661 if ((lflags & GPIO_PULL_UP) && (lflags & GPIO_PULL_DOWN)) {
4662 gpiod_err(desc,
4663 "both pull-up and pull-down enabled, invalid configuration\n");
4664 return -EINVAL;
4665 }
4666
4667 if (lflags & GPIO_PULL_UP)
4668 set_bit(FLAG_PULL_UP, &desc->flags);
4669 else if (lflags & GPIO_PULL_DOWN)
4670 set_bit(FLAG_PULL_DOWN, &desc->flags);
4671
4672 ret = gpiod_set_transitory(desc, (lflags & GPIO_TRANSITORY));
4673 if (ret < 0)
4674 return ret;
4675
4676
4677 if (!(dflags & GPIOD_FLAGS_BIT_DIR_SET)) {
4678 pr_debug("no flags found for %s\n", con_id);
4679 return 0;
4680 }
4681
4682
4683 if (dflags & GPIOD_FLAGS_BIT_DIR_OUT)
4684 ret = gpiod_direction_output(desc,
4685 !!(dflags & GPIOD_FLAGS_BIT_DIR_VAL));
4686 else
4687 ret = gpiod_direction_input(desc);
4688
4689 return ret;
4690}
4691
4692
4693
4694
4695
4696
4697
4698
4699
4700
4701
4702
4703
4704
4705
4706struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
4707 const char *con_id,
4708 unsigned int idx,
4709 enum gpiod_flags flags)
4710{
4711 unsigned long lookupflags = GPIO_LOOKUP_FLAGS_DEFAULT;
4712 struct gpio_desc *desc = NULL;
4713 int ret;
4714
4715 const char *devname = dev ? dev_name(dev) : "?";
4716
4717 dev_dbg(dev, "GPIO lookup for consumer %s\n", con_id);
4718
4719 if (dev) {
4720
4721 if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
4722 dev_dbg(dev, "using device tree for GPIO lookup\n");
4723 desc = of_find_gpio(dev, con_id, idx, &lookupflags);
4724 } else if (ACPI_COMPANION(dev)) {
4725 dev_dbg(dev, "using ACPI for GPIO lookup\n");
4726 desc = acpi_find_gpio(dev, con_id, idx, &flags, &lookupflags);
4727 }
4728 }
4729
4730
4731
4732
4733
4734 if (!desc || gpiod_not_found(desc)) {
4735 dev_dbg(dev, "using lookup tables for GPIO lookup\n");
4736 desc = gpiod_find(dev, con_id, idx, &lookupflags);
4737 }
4738
4739 if (IS_ERR(desc)) {
4740 dev_dbg(dev, "No GPIO consumer %s found\n", con_id);
4741 return desc;
4742 }
4743
4744
4745
4746
4747
4748 ret = gpiod_request(desc, con_id ? con_id : devname);
4749 if (ret < 0) {
4750 if (ret == -EBUSY && flags & GPIOD_FLAGS_BIT_NONEXCLUSIVE) {
4751
4752
4753
4754
4755
4756
4757
4758
4759 dev_info(dev, "nonexclusive access to GPIO for %s\n",
4760 con_id ? con_id : devname);
4761 return desc;
4762 } else {
4763 return ERR_PTR(ret);
4764 }
4765 }
4766
4767 ret = gpiod_configure_flags(desc, con_id, lookupflags, flags);
4768 if (ret < 0) {
4769 dev_dbg(dev, "setup of GPIO %s failed\n", con_id);
4770 gpiod_put(desc);
4771 return ERR_PTR(ret);
4772 }
4773
4774 return desc;
4775}
4776EXPORT_SYMBOL_GPL(gpiod_get_index);
4777
4778
4779
4780
4781
4782
4783
4784
4785
4786
4787
4788
4789
4790
4791
4792
4793
4794
4795
4796
4797
4798
4799struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
4800 const char *propname, int index,
4801 enum gpiod_flags dflags,
4802 const char *label)
4803{
4804 unsigned long lflags = GPIO_LOOKUP_FLAGS_DEFAULT;
4805 struct gpio_desc *desc = ERR_PTR(-ENODEV);
4806 int ret;
4807
4808 if (!fwnode)
4809 return ERR_PTR(-EINVAL);
4810
4811 if (is_of_node(fwnode)) {
4812 desc = gpiod_get_from_of_node(to_of_node(fwnode),
4813 propname, index,
4814 dflags,
4815 label);
4816 return desc;
4817 } else if (is_acpi_node(fwnode)) {
4818 struct acpi_gpio_info info;
4819
4820 desc = acpi_node_get_gpiod(fwnode, propname, index, &info);
4821 if (IS_ERR(desc))
4822 return desc;
4823
4824 acpi_gpio_update_gpiod_flags(&dflags, &info);
4825 acpi_gpio_update_gpiod_lookup_flags(&lflags, &info);
4826 }
4827
4828
4829 ret = gpiod_request(desc, label);
4830 if (ret)
4831 return ERR_PTR(ret);
4832
4833 ret = gpiod_configure_flags(desc, propname, lflags, dflags);
4834 if (ret < 0) {
4835 gpiod_put(desc);
4836 return ERR_PTR(ret);
4837 }
4838
4839 return desc;
4840}
4841EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);
4842
4843
4844
4845
4846
4847
4848
4849
4850
4851
4852
4853
4854
4855struct gpio_desc *__must_check gpiod_get_index_optional(struct device *dev,
4856 const char *con_id,
4857 unsigned int index,
4858 enum gpiod_flags flags)
4859{
4860 struct gpio_desc *desc;
4861
4862 desc = gpiod_get_index(dev, con_id, index, flags);
4863 if (gpiod_not_found(desc))
4864 return NULL;
4865
4866 return desc;
4867}
4868EXPORT_SYMBOL_GPL(gpiod_get_index_optional);
4869
4870
4871
4872
4873
4874
4875
4876
4877
4878int gpiod_hog(struct gpio_desc *desc, const char *name,
4879 unsigned long lflags, enum gpiod_flags dflags)
4880{
4881 struct gpio_chip *chip;
4882 struct gpio_desc *local_desc;
4883 int hwnum;
4884 int ret;
4885
4886 chip = gpiod_to_chip(desc);
4887 hwnum = gpio_chip_hwgpio(desc);
4888
4889 local_desc = gpiochip_request_own_desc(chip, hwnum, name,
4890 lflags, dflags);
4891 if (IS_ERR(local_desc)) {
4892 ret = PTR_ERR(local_desc);
4893 pr_err("requesting hog GPIO %s (chip %s, offset %d) failed, %d\n",
4894 name, chip->label, hwnum, ret);
4895 return ret;
4896 }
4897
4898
4899 set_bit(FLAG_IS_HOGGED, &desc->flags);
4900
4901 pr_info("GPIO line %d (%s) hogged as %s%s\n",
4902 desc_to_gpio(desc), name,
4903 (dflags & GPIOD_FLAGS_BIT_DIR_OUT) ? "output" : "input",
4904 (dflags & GPIOD_FLAGS_BIT_DIR_OUT) ?
4905 (dflags & GPIOD_FLAGS_BIT_DIR_VAL) ? "/high" : "/low" : "");
4906
4907 return 0;
4908}
4909
4910
4911
4912
4913
4914static void gpiochip_free_hogs(struct gpio_chip *chip)
4915{
4916 int id;
4917
4918 for (id = 0; id < chip->ngpio; id++) {
4919 if (test_bit(FLAG_IS_HOGGED, &chip->gpiodev->descs[id].flags))
4920 gpiochip_free_own_desc(&chip->gpiodev->descs[id]);
4921 }
4922}
4923
4924
4925
4926
4927
4928
4929
4930
4931
4932
4933
4934
4935
4936struct gpio_descs *__must_check gpiod_get_array(struct device *dev,
4937 const char *con_id,
4938 enum gpiod_flags flags)
4939{
4940 struct gpio_desc *desc;
4941 struct gpio_descs *descs;
4942 struct gpio_array *array_info = NULL;
4943 struct gpio_chip *chip;
4944 int count, bitmap_size;
4945
4946 count = gpiod_count(dev, con_id);
4947 if (count < 0)
4948 return ERR_PTR(count);
4949
4950 descs = kzalloc(struct_size(descs, desc, count), GFP_KERNEL);
4951 if (!descs)
4952 return ERR_PTR(-ENOMEM);
4953
4954 for (descs->ndescs = 0; descs->ndescs < count; ) {
4955 desc = gpiod_get_index(dev, con_id, descs->ndescs, flags);
4956 if (IS_ERR(desc)) {
4957 gpiod_put_array(descs);
4958 return ERR_CAST(desc);
4959 }
4960
4961 descs->desc[descs->ndescs] = desc;
4962
4963 chip = gpiod_to_chip(desc);
4964
4965
4966
4967
4968 if (descs->ndescs == 0 && gpio_chip_hwgpio(desc) == 0) {
4969 struct gpio_descs *array;
4970
4971 bitmap_size = BITS_TO_LONGS(chip->ngpio > count ?
4972 chip->ngpio : count);
4973
4974 array = kzalloc(struct_size(descs, desc, count) +
4975 struct_size(array_info, invert_mask,
4976 3 * bitmap_size), GFP_KERNEL);
4977 if (!array) {
4978 gpiod_put_array(descs);
4979 return ERR_PTR(-ENOMEM);
4980 }
4981
4982 memcpy(array, descs,
4983 struct_size(descs, desc, descs->ndescs + 1));
4984 kfree(descs);
4985
4986 descs = array;
4987 array_info = (void *)(descs->desc + count);
4988 array_info->get_mask = array_info->invert_mask +
4989 bitmap_size;
4990 array_info->set_mask = array_info->get_mask +
4991 bitmap_size;
4992
4993 array_info->desc = descs->desc;
4994 array_info->size = count;
4995 array_info->chip = chip;
4996 bitmap_set(array_info->get_mask, descs->ndescs,
4997 count - descs->ndescs);
4998 bitmap_set(array_info->set_mask, descs->ndescs,
4999 count - descs->ndescs);
5000 descs->info = array_info;
5001 }
5002
5003 if (array_info && array_info->chip != chip) {
5004 __clear_bit(descs->ndescs, array_info->get_mask);
5005 __clear_bit(descs->ndescs, array_info->set_mask);
5006 }
5007
5008
5009
5010
5011 else if (array_info &&
5012 gpio_chip_hwgpio(desc) != descs->ndescs) {
5013
5014
5015
5016
5017
5018 if (bitmap_full(array_info->get_mask, descs->ndescs)) {
5019 array_info = NULL;
5020 } else {
5021 __clear_bit(descs->ndescs,
5022 array_info->get_mask);
5023 __clear_bit(descs->ndescs,
5024 array_info->set_mask);
5025 }
5026 } else if (array_info) {
5027
5028 if (gpiochip_line_is_open_drain(chip, descs->ndescs) ||
5029 gpiochip_line_is_open_source(chip, descs->ndescs))
5030 __clear_bit(descs->ndescs,
5031 array_info->set_mask);
5032
5033 if (gpiod_is_active_low(desc))
5034 __set_bit(descs->ndescs,
5035 array_info->invert_mask);
5036 }
5037
5038 descs->ndescs++;
5039 }
5040 if (array_info)
5041 dev_dbg(dev,
5042 "GPIO array info: chip=%s, size=%d, get_mask=%lx, set_mask=%lx, invert_mask=%lx\n",
5043 array_info->chip->label, array_info->size,
5044 *array_info->get_mask, *array_info->set_mask,
5045 *array_info->invert_mask);
5046 return descs;
5047}
5048EXPORT_SYMBOL_GPL(gpiod_get_array);
5049
5050
5051
5052
5053
5054
5055
5056
5057
5058
5059
5060struct gpio_descs *__must_check gpiod_get_array_optional(struct device *dev,
5061 const char *con_id,
5062 enum gpiod_flags flags)
5063{
5064 struct gpio_descs *descs;
5065
5066 descs = gpiod_get_array(dev, con_id, flags);
5067 if (gpiod_not_found(descs))
5068 return NULL;
5069
5070 return descs;
5071}
5072EXPORT_SYMBOL_GPL(gpiod_get_array_optional);
5073
5074
5075
5076
5077
5078
5079
5080void gpiod_put(struct gpio_desc *desc)
5081{
5082 if (desc)
5083 gpiod_free(desc);
5084}
5085EXPORT_SYMBOL_GPL(gpiod_put);
5086
5087
5088
5089
5090
5091void gpiod_put_array(struct gpio_descs *descs)
5092{
5093 unsigned int i;
5094
5095 for (i = 0; i < descs->ndescs; i++)
5096 gpiod_put(descs->desc[i]);
5097
5098 kfree(descs);
5099}
5100EXPORT_SYMBOL_GPL(gpiod_put_array);
5101
5102static int __init gpiolib_dev_init(void)
5103{
5104 int ret;
5105
5106
5107 ret = bus_register(&gpio_bus_type);
5108 if (ret < 0) {
5109 pr_err("gpiolib: could not register GPIO bus type\n");
5110 return ret;
5111 }
5112
5113 ret = alloc_chrdev_region(&gpio_devt, 0, GPIO_DEV_MAX, GPIOCHIP_NAME);
5114 if (ret < 0) {
5115 pr_err("gpiolib: failed to allocate char dev region\n");
5116 bus_unregister(&gpio_bus_type);
5117 } else {
5118 gpiolib_initialized = true;
5119 gpiochip_setup_devs();
5120 }
5121 return ret;
5122}
5123core_initcall(gpiolib_dev_init);
5124
5125#ifdef CONFIG_DEBUG_FS
5126
5127static void gpiolib_dbg_show(struct seq_file *s, struct gpio_device *gdev)
5128{
5129 unsigned i;
5130 struct gpio_chip *chip = gdev->chip;
5131 unsigned gpio = gdev->base;
5132 struct gpio_desc *gdesc = &gdev->descs[0];
5133 bool is_out;
5134 bool is_irq;
5135 bool active_low;
5136
5137 for (i = 0; i < gdev->ngpio; i++, gpio++, gdesc++) {
5138 if (!test_bit(FLAG_REQUESTED, &gdesc->flags)) {
5139 if (gdesc->name) {
5140 seq_printf(s, " gpio-%-3d (%-20.20s)\n",
5141 gpio, gdesc->name);
5142 }
5143 continue;
5144 }
5145
5146 gpiod_get_direction(gdesc);
5147 is_out = test_bit(FLAG_IS_OUT, &gdesc->flags);
5148 is_irq = test_bit(FLAG_USED_AS_IRQ, &gdesc->flags);
5149 active_low = test_bit(FLAG_ACTIVE_LOW, &gdesc->flags);
5150 seq_printf(s, " gpio-%-3d (%-20.20s|%-20.20s) %s %s %s%s",
5151 gpio, gdesc->name ? gdesc->name : "", gdesc->label,
5152 is_out ? "out" : "in ",
5153 chip->get ? (chip->get(chip, i) ? "hi" : "lo") : "? ",
5154 is_irq ? "IRQ " : "",
5155 active_low ? "ACTIVE LOW" : "");
5156 seq_printf(s, "\n");
5157 }
5158}
5159
5160static void *gpiolib_seq_start(struct seq_file *s, loff_t *pos)
5161{
5162 unsigned long flags;
5163 struct gpio_device *gdev = NULL;
5164 loff_t index = *pos;
5165
5166 s->private = "";
5167
5168 spin_lock_irqsave(&gpio_lock, flags);
5169 list_for_each_entry(gdev, &gpio_devices, list)
5170 if (index-- == 0) {
5171 spin_unlock_irqrestore(&gpio_lock, flags);
5172 return gdev;
5173 }
5174 spin_unlock_irqrestore(&gpio_lock, flags);
5175
5176 return NULL;
5177}
5178
5179static void *gpiolib_seq_next(struct seq_file *s, void *v, loff_t *pos)
5180{
5181 unsigned long flags;
5182 struct gpio_device *gdev = v;
5183 void *ret = NULL;
5184
5185 spin_lock_irqsave(&gpio_lock, flags);
5186 if (list_is_last(&gdev->list, &gpio_devices))
5187 ret = NULL;
5188 else
5189 ret = list_entry(gdev->list.next, struct gpio_device, list);
5190 spin_unlock_irqrestore(&gpio_lock, flags);
5191
5192 s->private = "\n";
5193 ++*pos;
5194
5195 return ret;
5196}
5197
5198static void gpiolib_seq_stop(struct seq_file *s, void *v)
5199{
5200}
5201
5202static int gpiolib_seq_show(struct seq_file *s, void *v)
5203{
5204 struct gpio_device *gdev = v;
5205 struct gpio_chip *chip = gdev->chip;
5206 struct device *parent;
5207
5208 if (!chip) {
5209 seq_printf(s, "%s%s: (dangling chip)", (char *)s->private,
5210 dev_name(&gdev->dev));
5211 return 0;
5212 }
5213
5214 seq_printf(s, "%s%s: GPIOs %d-%d", (char *)s->private,
5215 dev_name(&gdev->dev),
5216 gdev->base, gdev->base + gdev->ngpio - 1);
5217 parent = chip->parent;
5218 if (parent)
5219 seq_printf(s, ", parent: %s/%s",
5220 parent->bus ? parent->bus->name : "no-bus",
5221 dev_name(parent));
5222 if (chip->label)
5223 seq_printf(s, ", %s", chip->label);
5224 if (chip->can_sleep)
5225 seq_printf(s, ", can sleep");
5226 seq_printf(s, ":\n");
5227
5228 if (chip->dbg_show)
5229 chip->dbg_show(s, chip);
5230 else
5231 gpiolib_dbg_show(s, gdev);
5232
5233 return 0;
5234}
5235
5236static const struct seq_operations gpiolib_seq_ops = {
5237 .start = gpiolib_seq_start,
5238 .next = gpiolib_seq_next,
5239 .stop = gpiolib_seq_stop,
5240 .show = gpiolib_seq_show,
5241};
5242
5243static int gpiolib_open(struct inode *inode, struct file *file)
5244{
5245 return seq_open(file, &gpiolib_seq_ops);
5246}
5247
5248static const struct file_operations gpiolib_operations = {
5249 .owner = THIS_MODULE,
5250 .open = gpiolib_open,
5251 .read = seq_read,
5252 .llseek = seq_lseek,
5253 .release = seq_release,
5254};
5255
5256static int __init gpiolib_debugfs_init(void)
5257{
5258
5259 debugfs_create_file("gpio", S_IFREG | S_IRUGO, NULL, NULL,
5260 &gpiolib_operations);
5261 return 0;
5262}
5263subsys_initcall(gpiolib_debugfs_init);
5264
5265#endif
5266