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