1
2
3
4
5
6
7
8
9
10#include <linux/dmi.h>
11#include <linux/errno.h>
12#include <linux/gpio/consumer.h>
13#include <linux/gpio/driver.h>
14#include <linux/gpio/machine.h>
15#include <linux/export.h>
16#include <linux/acpi.h>
17#include <linux/interrupt.h>
18#include <linux/mutex.h>
19#include <linux/pinctrl/pinctrl.h>
20
21#include "gpiolib.h"
22
23static int run_edge_events_on_boot = -1;
24module_param(run_edge_events_on_boot, int, 0444);
25MODULE_PARM_DESC(run_edge_events_on_boot,
26 "Run edge _AEI event-handlers at boot: 0=no, 1=yes, -1=auto");
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41struct acpi_gpio_event {
42 struct list_head node;
43 acpi_handle handle;
44 irq_handler_t handler;
45 unsigned int pin;
46 unsigned int irq;
47 unsigned long irqflags;
48 bool irq_is_wake;
49 bool irq_requested;
50 struct gpio_desc *desc;
51};
52
53struct acpi_gpio_connection {
54 struct list_head node;
55 unsigned int pin;
56 struct gpio_desc *desc;
57};
58
59struct acpi_gpio_chip {
60
61
62
63
64
65 struct acpi_connection_info conn_info;
66 struct list_head conns;
67 struct mutex conn_lock;
68 struct gpio_chip *chip;
69 struct list_head events;
70 struct list_head deferred_req_irqs_list_entry;
71};
72
73
74
75
76
77
78
79
80static DEFINE_MUTEX(acpi_gpio_deferred_req_irqs_lock);
81static LIST_HEAD(acpi_gpio_deferred_req_irqs_list);
82static bool acpi_gpio_deferred_req_irqs_done;
83
84static int acpi_gpiochip_find(struct gpio_chip *gc, void *data)
85{
86 if (!gc->parent)
87 return false;
88
89 return ACPI_HANDLE(gc->parent) == data;
90}
91
92
93
94
95
96
97
98
99
100
101
102static struct gpio_desc *acpi_get_gpiod(char *path, int pin)
103{
104 struct gpio_chip *chip;
105 acpi_handle handle;
106 acpi_status status;
107
108 status = acpi_get_handle(NULL, path, &handle);
109 if (ACPI_FAILURE(status))
110 return ERR_PTR(-ENODEV);
111
112 chip = gpiochip_find(handle, acpi_gpiochip_find);
113 if (!chip)
114 return ERR_PTR(-EPROBE_DEFER);
115
116 return gpiochip_get_desc(chip, pin);
117}
118
119static irqreturn_t acpi_gpio_irq_handler(int irq, void *data)
120{
121 struct acpi_gpio_event *event = data;
122
123 acpi_evaluate_object(event->handle, NULL, NULL, NULL);
124
125 return IRQ_HANDLED;
126}
127
128static irqreturn_t acpi_gpio_irq_handler_evt(int irq, void *data)
129{
130 struct acpi_gpio_event *event = data;
131
132 acpi_execute_simple_method(event->handle, NULL, event->pin);
133
134 return IRQ_HANDLED;
135}
136
137static void acpi_gpio_chip_dh(acpi_handle handle, void *data)
138{
139
140}
141
142bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,
143 struct acpi_resource_gpio **agpio)
144{
145 struct acpi_resource_gpio *gpio;
146
147 if (ares->type != ACPI_RESOURCE_TYPE_GPIO)
148 return false;
149
150 gpio = &ares->data.gpio;
151 if (gpio->connection_type != ACPI_RESOURCE_GPIO_TYPE_INT)
152 return false;
153
154 *agpio = gpio;
155 return true;
156}
157EXPORT_SYMBOL_GPL(acpi_gpio_get_irq_resource);
158
159static void acpi_gpiochip_request_irq(struct acpi_gpio_chip *acpi_gpio,
160 struct acpi_gpio_event *event)
161{
162 int ret, value;
163
164 ret = request_threaded_irq(event->irq, NULL, event->handler,
165 event->irqflags, "ACPI:Event", event);
166 if (ret) {
167 dev_err(acpi_gpio->chip->parent,
168 "Failed to setup interrupt handler for %d\n",
169 event->irq);
170 return;
171 }
172
173 if (event->irq_is_wake)
174 enable_irq_wake(event->irq);
175
176 event->irq_requested = true;
177
178
179 if (run_edge_events_on_boot &&
180 (event->irqflags & (IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING))) {
181 value = gpiod_get_raw_value_cansleep(event->desc);
182 if (((event->irqflags & IRQF_TRIGGER_RISING) && value == 1) ||
183 ((event->irqflags & IRQF_TRIGGER_FALLING) && value == 0))
184 event->handler(event->irq, event);
185 }
186}
187
188static void acpi_gpiochip_request_irqs(struct acpi_gpio_chip *acpi_gpio)
189{
190 struct acpi_gpio_event *event;
191
192 list_for_each_entry(event, &acpi_gpio->events, node)
193 acpi_gpiochip_request_irq(acpi_gpio, event);
194}
195
196static acpi_status acpi_gpiochip_alloc_event(struct acpi_resource *ares,
197 void *context)
198{
199 struct acpi_gpio_chip *acpi_gpio = context;
200 struct gpio_chip *chip = acpi_gpio->chip;
201 struct acpi_resource_gpio *agpio;
202 acpi_handle handle, evt_handle;
203 struct acpi_gpio_event *event;
204 irq_handler_t handler = NULL;
205 struct gpio_desc *desc;
206 int ret, pin, irq;
207
208 if (!acpi_gpio_get_irq_resource(ares, &agpio))
209 return AE_OK;
210
211 handle = ACPI_HANDLE(chip->parent);
212 pin = agpio->pin_table[0];
213
214 if (pin <= 255) {
215 char ev_name[5];
216 sprintf(ev_name, "_%c%02hhX",
217 agpio->triggering == ACPI_EDGE_SENSITIVE ? 'E' : 'L',
218 pin);
219 if (ACPI_SUCCESS(acpi_get_handle(handle, ev_name, &evt_handle)))
220 handler = acpi_gpio_irq_handler;
221 }
222 if (!handler) {
223 if (ACPI_SUCCESS(acpi_get_handle(handle, "_EVT", &evt_handle)))
224 handler = acpi_gpio_irq_handler_evt;
225 }
226 if (!handler)
227 return AE_OK;
228
229 desc = gpiochip_request_own_desc(chip, pin, "ACPI:Event",
230 GPIO_ACTIVE_HIGH, GPIOD_IN);
231 if (IS_ERR(desc)) {
232 dev_err(chip->parent, "Failed to request GPIO\n");
233 return AE_ERROR;
234 }
235
236 ret = gpiochip_lock_as_irq(chip, pin);
237 if (ret) {
238 dev_err(chip->parent, "Failed to lock GPIO as interrupt\n");
239 goto fail_free_desc;
240 }
241
242 irq = gpiod_to_irq(desc);
243 if (irq < 0) {
244 dev_err(chip->parent, "Failed to translate GPIO to IRQ\n");
245 goto fail_unlock_irq;
246 }
247
248 event = kzalloc(sizeof(*event), GFP_KERNEL);
249 if (!event)
250 goto fail_unlock_irq;
251
252 event->irqflags = IRQF_ONESHOT;
253 if (agpio->triggering == ACPI_LEVEL_SENSITIVE) {
254 if (agpio->polarity == ACPI_ACTIVE_HIGH)
255 event->irqflags |= IRQF_TRIGGER_HIGH;
256 else
257 event->irqflags |= IRQF_TRIGGER_LOW;
258 } else {
259 switch (agpio->polarity) {
260 case ACPI_ACTIVE_HIGH:
261 event->irqflags |= IRQF_TRIGGER_RISING;
262 break;
263 case ACPI_ACTIVE_LOW:
264 event->irqflags |= IRQF_TRIGGER_FALLING;
265 break;
266 default:
267 event->irqflags |= IRQF_TRIGGER_RISING |
268 IRQF_TRIGGER_FALLING;
269 break;
270 }
271 }
272
273 event->handle = evt_handle;
274 event->handler = handler;
275 event->irq = irq;
276 event->irq_is_wake = agpio->wake_capable == ACPI_WAKE_CAPABLE;
277 event->pin = pin;
278 event->desc = desc;
279
280 list_add_tail(&event->node, &acpi_gpio->events);
281
282 return AE_OK;
283
284fail_unlock_irq:
285 gpiochip_unlock_as_irq(chip, pin);
286fail_free_desc:
287 gpiochip_free_own_desc(desc);
288
289 return AE_ERROR;
290}
291
292
293
294
295
296
297
298
299
300
301
302void acpi_gpiochip_request_interrupts(struct gpio_chip *chip)
303{
304 struct acpi_gpio_chip *acpi_gpio;
305 acpi_handle handle;
306 acpi_status status;
307 bool defer;
308
309 if (!chip->parent || !chip->to_irq)
310 return;
311
312 handle = ACPI_HANDLE(chip->parent);
313 if (!handle)
314 return;
315
316 status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
317 if (ACPI_FAILURE(status))
318 return;
319
320 acpi_walk_resources(handle, "_AEI",
321 acpi_gpiochip_alloc_event, acpi_gpio);
322
323 mutex_lock(&acpi_gpio_deferred_req_irqs_lock);
324 defer = !acpi_gpio_deferred_req_irqs_done;
325 if (defer)
326 list_add(&acpi_gpio->deferred_req_irqs_list_entry,
327 &acpi_gpio_deferred_req_irqs_list);
328 mutex_unlock(&acpi_gpio_deferred_req_irqs_lock);
329
330 if (defer)
331 return;
332
333 acpi_gpiochip_request_irqs(acpi_gpio);
334}
335EXPORT_SYMBOL_GPL(acpi_gpiochip_request_interrupts);
336
337
338
339
340
341
342
343
344void acpi_gpiochip_free_interrupts(struct gpio_chip *chip)
345{
346 struct acpi_gpio_chip *acpi_gpio;
347 struct acpi_gpio_event *event, *ep;
348 acpi_handle handle;
349 acpi_status status;
350
351 if (!chip->parent || !chip->to_irq)
352 return;
353
354 handle = ACPI_HANDLE(chip->parent);
355 if (!handle)
356 return;
357
358 status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
359 if (ACPI_FAILURE(status))
360 return;
361
362 mutex_lock(&acpi_gpio_deferred_req_irqs_lock);
363 if (!list_empty(&acpi_gpio->deferred_req_irqs_list_entry))
364 list_del_init(&acpi_gpio->deferred_req_irqs_list_entry);
365 mutex_unlock(&acpi_gpio_deferred_req_irqs_lock);
366
367 list_for_each_entry_safe_reverse(event, ep, &acpi_gpio->events, node) {
368 if (event->irq_requested) {
369 if (event->irq_is_wake)
370 disable_irq_wake(event->irq);
371
372 free_irq(event->irq, event);
373 }
374
375 gpiochip_unlock_as_irq(chip, event->pin);
376 gpiochip_free_own_desc(event->desc);
377 list_del(&event->node);
378 kfree(event);
379 }
380}
381EXPORT_SYMBOL_GPL(acpi_gpiochip_free_interrupts);
382
383int acpi_dev_add_driver_gpios(struct acpi_device *adev,
384 const struct acpi_gpio_mapping *gpios)
385{
386 if (adev && gpios) {
387 adev->driver_gpios = gpios;
388 return 0;
389 }
390 return -EINVAL;
391}
392EXPORT_SYMBOL_GPL(acpi_dev_add_driver_gpios);
393
394static void devm_acpi_dev_release_driver_gpios(struct device *dev, void *res)
395{
396 acpi_dev_remove_driver_gpios(ACPI_COMPANION(dev));
397}
398
399int devm_acpi_dev_add_driver_gpios(struct device *dev,
400 const struct acpi_gpio_mapping *gpios)
401{
402 void *res;
403 int ret;
404
405 res = devres_alloc(devm_acpi_dev_release_driver_gpios, 0, GFP_KERNEL);
406 if (!res)
407 return -ENOMEM;
408
409 ret = acpi_dev_add_driver_gpios(ACPI_COMPANION(dev), gpios);
410 if (ret) {
411 devres_free(res);
412 return ret;
413 }
414 devres_add(dev, res);
415 return 0;
416}
417EXPORT_SYMBOL_GPL(devm_acpi_dev_add_driver_gpios);
418
419void devm_acpi_dev_remove_driver_gpios(struct device *dev)
420{
421 WARN_ON(devres_release(dev, devm_acpi_dev_release_driver_gpios, NULL, NULL));
422}
423EXPORT_SYMBOL_GPL(devm_acpi_dev_remove_driver_gpios);
424
425static bool acpi_get_driver_gpio_data(struct acpi_device *adev,
426 const char *name, int index,
427 struct fwnode_reference_args *args,
428 unsigned int *quirks)
429{
430 const struct acpi_gpio_mapping *gm;
431
432 if (!adev->driver_gpios)
433 return false;
434
435 for (gm = adev->driver_gpios; gm->name; gm++)
436 if (!strcmp(name, gm->name) && gm->data && index < gm->size) {
437 const struct acpi_gpio_params *par = gm->data + index;
438
439 args->fwnode = acpi_fwnode_handle(adev);
440 args->args[0] = par->crs_entry_index;
441 args->args[1] = par->line_index;
442 args->args[2] = par->active_low;
443 args->nargs = 3;
444
445 *quirks = gm->quirks;
446 return true;
447 }
448
449 return false;
450}
451
452static enum gpiod_flags
453acpi_gpio_to_gpiod_flags(const struct acpi_resource_gpio *agpio)
454{
455 switch (agpio->io_restriction) {
456 case ACPI_IO_RESTRICT_INPUT:
457 return GPIOD_IN;
458 case ACPI_IO_RESTRICT_OUTPUT:
459
460
461
462
463
464
465
466 switch (agpio->pin_config) {
467 case ACPI_PIN_CONFIG_PULLUP:
468 return GPIOD_OUT_HIGH;
469 case ACPI_PIN_CONFIG_PULLDOWN:
470 return GPIOD_OUT_LOW;
471 default:
472 break;
473 }
474 default:
475 break;
476 }
477
478
479
480
481
482 return GPIOD_ASIS;
483}
484
485static int
486__acpi_gpio_update_gpiod_flags(enum gpiod_flags *flags, enum gpiod_flags update)
487{
488 const enum gpiod_flags mask =
489 GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT |
490 GPIOD_FLAGS_BIT_DIR_VAL;
491 int ret = 0;
492
493
494
495
496
497
498 if (update & GPIOD_FLAGS_BIT_DIR_SET) {
499 enum gpiod_flags diff = *flags ^ update;
500
501
502
503
504
505
506
507
508 if (((*flags & GPIOD_FLAGS_BIT_DIR_SET) && (diff & GPIOD_FLAGS_BIT_DIR_OUT)) ||
509 ((*flags & GPIOD_FLAGS_BIT_DIR_OUT) && (diff & GPIOD_FLAGS_BIT_DIR_VAL)))
510 ret = -EINVAL;
511 *flags = (*flags & ~mask) | (update & mask);
512 }
513 return ret;
514}
515
516int
517acpi_gpio_update_gpiod_flags(enum gpiod_flags *flags, struct acpi_gpio_info *info)
518{
519 struct device *dev = &info->adev->dev;
520 enum gpiod_flags old = *flags;
521 int ret;
522
523 ret = __acpi_gpio_update_gpiod_flags(&old, info->flags);
524 if (info->quirks & ACPI_GPIO_QUIRK_NO_IO_RESTRICTION) {
525 if (ret)
526 dev_warn(dev, FW_BUG "GPIO not in correct mode, fixing\n");
527 } else {
528 if (ret)
529 dev_dbg(dev, "Override GPIO initialization flags\n");
530 *flags = old;
531 }
532
533 return ret;
534}
535
536int acpi_gpio_update_gpiod_lookup_flags(unsigned long *lookupflags,
537 struct acpi_gpio_info *info)
538{
539 switch (info->pin_config) {
540 case ACPI_PIN_CONFIG_PULLUP:
541 *lookupflags |= GPIO_PULL_UP;
542 break;
543 case ACPI_PIN_CONFIG_PULLDOWN:
544 *lookupflags |= GPIO_PULL_DOWN;
545 break;
546 default:
547 break;
548 }
549
550 if (info->polarity == GPIO_ACTIVE_LOW)
551 *lookupflags |= GPIO_ACTIVE_LOW;
552
553 return 0;
554}
555
556struct acpi_gpio_lookup {
557 struct acpi_gpio_info info;
558 int index;
559 int pin_index;
560 bool active_low;
561 struct gpio_desc *desc;
562 int n;
563};
564
565static int acpi_populate_gpio_lookup(struct acpi_resource *ares, void *data)
566{
567 struct acpi_gpio_lookup *lookup = data;
568
569 if (ares->type != ACPI_RESOURCE_TYPE_GPIO)
570 return 1;
571
572 if (!lookup->desc) {
573 const struct acpi_resource_gpio *agpio = &ares->data.gpio;
574 bool gpioint = agpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT;
575 int pin_index;
576
577 if (lookup->info.quirks & ACPI_GPIO_QUIRK_ONLY_GPIOIO && gpioint)
578 lookup->index++;
579
580 if (lookup->n++ != lookup->index)
581 return 1;
582
583 pin_index = lookup->pin_index;
584 if (pin_index >= agpio->pin_table_length)
585 return 1;
586
587 lookup->desc = acpi_get_gpiod(agpio->resource_source.string_ptr,
588 agpio->pin_table[pin_index]);
589 lookup->info.pin_config = agpio->pin_config;
590 lookup->info.gpioint = gpioint;
591
592
593
594
595
596
597
598
599 if (lookup->info.gpioint) {
600 lookup->info.flags = GPIOD_IN;
601 lookup->info.polarity = agpio->polarity;
602 lookup->info.triggering = agpio->triggering;
603 } else {
604 lookup->info.flags = acpi_gpio_to_gpiod_flags(agpio);
605 lookup->info.polarity = lookup->active_low;
606 }
607 }
608
609 return 1;
610}
611
612static int acpi_gpio_resource_lookup(struct acpi_gpio_lookup *lookup,
613 struct acpi_gpio_info *info)
614{
615 struct acpi_device *adev = lookup->info.adev;
616 struct list_head res_list;
617 int ret;
618
619 INIT_LIST_HEAD(&res_list);
620
621 ret = acpi_dev_get_resources(adev, &res_list,
622 acpi_populate_gpio_lookup,
623 lookup);
624 if (ret < 0)
625 return ret;
626
627 acpi_dev_free_resource_list(&res_list);
628
629 if (!lookup->desc)
630 return -ENOENT;
631
632 if (info)
633 *info = lookup->info;
634 return 0;
635}
636
637static int acpi_gpio_property_lookup(struct fwnode_handle *fwnode,
638 const char *propname, int index,
639 struct acpi_gpio_lookup *lookup)
640{
641 struct fwnode_reference_args args;
642 unsigned int quirks = 0;
643 int ret;
644
645 memset(&args, 0, sizeof(args));
646 ret = __acpi_node_get_property_reference(fwnode, propname, index, 3,
647 &args);
648 if (ret) {
649 struct acpi_device *adev = to_acpi_device_node(fwnode);
650
651 if (!adev)
652 return ret;
653
654 if (!acpi_get_driver_gpio_data(adev, propname, index, &args,
655 &quirks))
656 return ret;
657 }
658
659
660
661
662 if (!to_acpi_device_node(args.fwnode))
663 return -EINVAL;
664 if (args.nargs != 3)
665 return -EPROTO;
666
667 lookup->index = args.args[0];
668 lookup->pin_index = args.args[1];
669 lookup->active_low = !!args.args[2];
670
671 lookup->info.adev = to_acpi_device_node(args.fwnode);
672 lookup->info.quirks = quirks;
673
674 return 0;
675}
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699static struct gpio_desc *acpi_get_gpiod_by_index(struct acpi_device *adev,
700 const char *propname, int index,
701 struct acpi_gpio_info *info)
702{
703 struct acpi_gpio_lookup lookup;
704 int ret;
705
706 if (!adev)
707 return ERR_PTR(-ENODEV);
708
709 memset(&lookup, 0, sizeof(lookup));
710 lookup.index = index;
711
712 if (propname) {
713 dev_dbg(&adev->dev, "GPIO: looking up %s\n", propname);
714
715 ret = acpi_gpio_property_lookup(acpi_fwnode_handle(adev),
716 propname, index, &lookup);
717 if (ret)
718 return ERR_PTR(ret);
719
720 dev_dbg(&adev->dev, "GPIO: _DSD returned %s %d %d %u\n",
721 dev_name(&lookup.info.adev->dev), lookup.index,
722 lookup.pin_index, lookup.active_low);
723 } else {
724 dev_dbg(&adev->dev, "GPIO: looking up %d in _CRS\n", index);
725 lookup.info.adev = adev;
726 }
727
728 ret = acpi_gpio_resource_lookup(&lookup, info);
729 return ret ? ERR_PTR(ret) : lookup.desc;
730}
731
732struct gpio_desc *acpi_find_gpio(struct device *dev,
733 const char *con_id,
734 unsigned int idx,
735 enum gpiod_flags *dflags,
736 unsigned long *lookupflags)
737{
738 struct acpi_device *adev = ACPI_COMPANION(dev);
739 struct acpi_gpio_info info;
740 struct gpio_desc *desc;
741 char propname[32];
742 int i;
743
744
745 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
746 if (con_id) {
747 snprintf(propname, sizeof(propname), "%s-%s",
748 con_id, gpio_suffixes[i]);
749 } else {
750 snprintf(propname, sizeof(propname), "%s",
751 gpio_suffixes[i]);
752 }
753
754 desc = acpi_get_gpiod_by_index(adev, propname, idx, &info);
755 if (!IS_ERR(desc))
756 break;
757 if (PTR_ERR(desc) == -EPROBE_DEFER)
758 return ERR_CAST(desc);
759 }
760
761
762 if (IS_ERR(desc)) {
763 if (!acpi_can_fallback_to_crs(adev, con_id))
764 return ERR_PTR(-ENOENT);
765
766 desc = acpi_get_gpiod_by_index(adev, NULL, idx, &info);
767 if (IS_ERR(desc))
768 return desc;
769 }
770
771 if (info.gpioint &&
772 (*dflags == GPIOD_OUT_LOW || *dflags == GPIOD_OUT_HIGH)) {
773 dev_dbg(dev, "refusing GpioInt() entry when doing GPIOD_OUT_* lookup\n");
774 return ERR_PTR(-ENOENT);
775 }
776
777 acpi_gpio_update_gpiod_flags(dflags, &info);
778 acpi_gpio_update_gpiod_lookup_flags(lookupflags, &info);
779 return desc;
780}
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797struct gpio_desc *acpi_node_get_gpiod(struct fwnode_handle *fwnode,
798 const char *propname, int index,
799 struct acpi_gpio_info *info)
800{
801 struct acpi_gpio_lookup lookup;
802 struct acpi_device *adev;
803 int ret;
804
805 adev = to_acpi_device_node(fwnode);
806 if (adev)
807 return acpi_get_gpiod_by_index(adev, propname, index, info);
808
809 if (!is_acpi_data_node(fwnode))
810 return ERR_PTR(-ENODEV);
811
812 if (!propname)
813 return ERR_PTR(-EINVAL);
814
815 memset(&lookup, 0, sizeof(lookup));
816 lookup.index = index;
817
818 ret = acpi_gpio_property_lookup(fwnode, propname, index, &lookup);
819 if (ret)
820 return ERR_PTR(ret);
821
822 ret = acpi_gpio_resource_lookup(&lookup, info);
823 return ret ? ERR_PTR(ret) : lookup.desc;
824}
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index)
841{
842 int idx, i;
843 unsigned int irq_flags;
844 int ret;
845
846 for (i = 0, idx = 0; idx <= index; i++) {
847 struct acpi_gpio_info info;
848 struct gpio_desc *desc;
849
850 desc = acpi_get_gpiod_by_index(adev, NULL, i, &info);
851
852
853 if (IS_ERR(desc) && PTR_ERR(desc) != -EPROBE_DEFER)
854 return PTR_ERR(desc);
855
856 if (info.gpioint && idx++ == index) {
857 unsigned long lflags = GPIO_LOOKUP_FLAGS_DEFAULT;
858 char label[32];
859 int irq;
860
861 if (IS_ERR(desc))
862 return PTR_ERR(desc);
863
864 irq = gpiod_to_irq(desc);
865 if (irq < 0)
866 return irq;
867
868 snprintf(label, sizeof(label), "GpioInt() %d", index);
869 ret = gpiod_configure_flags(desc, label, lflags, info.flags);
870 if (ret < 0)
871 return ret;
872
873 irq_flags = acpi_dev_get_irq_type(info.triggering,
874 info.polarity);
875
876
877 if (irq_flags != IRQ_TYPE_NONE &&
878 irq_flags != irq_get_trigger_type(irq))
879 irq_set_irq_type(irq, irq_flags);
880
881 return irq;
882 }
883
884 }
885 return -ENOENT;
886}
887EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_get);
888
889static acpi_status
890acpi_gpio_adr_space_handler(u32 function, acpi_physical_address address,
891 u32 bits, u64 *value, void *handler_context,
892 void *region_context)
893{
894 struct acpi_gpio_chip *achip = region_context;
895 struct gpio_chip *chip = achip->chip;
896 struct acpi_resource_gpio *agpio;
897 struct acpi_resource *ares;
898 int pin_index = (int)address;
899 acpi_status status;
900 int length;
901 int i;
902
903 status = acpi_buffer_to_resource(achip->conn_info.connection,
904 achip->conn_info.length, &ares);
905 if (ACPI_FAILURE(status))
906 return status;
907
908 if (WARN_ON(ares->type != ACPI_RESOURCE_TYPE_GPIO)) {
909 ACPI_FREE(ares);
910 return AE_BAD_PARAMETER;
911 }
912
913 agpio = &ares->data.gpio;
914
915 if (WARN_ON(agpio->io_restriction == ACPI_IO_RESTRICT_INPUT &&
916 function == ACPI_WRITE)) {
917 ACPI_FREE(ares);
918 return AE_BAD_PARAMETER;
919 }
920
921 length = min(agpio->pin_table_length, (u16)(pin_index + bits));
922 for (i = pin_index; i < length; ++i) {
923 int pin = agpio->pin_table[i];
924 struct acpi_gpio_connection *conn;
925 struct gpio_desc *desc;
926 bool found;
927
928 mutex_lock(&achip->conn_lock);
929
930 found = false;
931 list_for_each_entry(conn, &achip->conns, node) {
932 if (conn->pin == pin) {
933 found = true;
934 desc = conn->desc;
935 break;
936 }
937 }
938
939
940
941
942
943
944 if (!found && agpio->shareable == ACPI_SHARED &&
945 function == ACPI_READ) {
946 struct acpi_gpio_event *event;
947
948 list_for_each_entry(event, &achip->events, node) {
949 if (event->pin == pin) {
950 desc = event->desc;
951 found = true;
952 break;
953 }
954 }
955 }
956
957 if (!found) {
958 enum gpiod_flags flags = acpi_gpio_to_gpiod_flags(agpio);
959 const char *label = "ACPI:OpRegion";
960
961 desc = gpiochip_request_own_desc(chip, pin, label,
962 GPIO_ACTIVE_HIGH,
963 flags);
964 if (IS_ERR(desc)) {
965 status = AE_ERROR;
966 mutex_unlock(&achip->conn_lock);
967 goto out;
968 }
969
970 conn = kzalloc(sizeof(*conn), GFP_KERNEL);
971 if (!conn) {
972 status = AE_NO_MEMORY;
973 gpiochip_free_own_desc(desc);
974 mutex_unlock(&achip->conn_lock);
975 goto out;
976 }
977
978 conn->pin = pin;
979 conn->desc = desc;
980 list_add_tail(&conn->node, &achip->conns);
981 }
982
983 mutex_unlock(&achip->conn_lock);
984
985 if (function == ACPI_WRITE)
986 gpiod_set_raw_value_cansleep(desc,
987 !!((1 << i) & *value));
988 else
989 *value |= (u64)gpiod_get_raw_value_cansleep(desc) << i;
990 }
991
992out:
993 ACPI_FREE(ares);
994 return status;
995}
996
997static void acpi_gpiochip_request_regions(struct acpi_gpio_chip *achip)
998{
999 struct gpio_chip *chip = achip->chip;
1000 acpi_handle handle = ACPI_HANDLE(chip->parent);
1001 acpi_status status;
1002
1003 INIT_LIST_HEAD(&achip->conns);
1004 mutex_init(&achip->conn_lock);
1005 status = acpi_install_address_space_handler(handle, ACPI_ADR_SPACE_GPIO,
1006 acpi_gpio_adr_space_handler,
1007 NULL, achip);
1008 if (ACPI_FAILURE(status))
1009 dev_err(chip->parent,
1010 "Failed to install GPIO OpRegion handler\n");
1011}
1012
1013static void acpi_gpiochip_free_regions(struct acpi_gpio_chip *achip)
1014{
1015 struct gpio_chip *chip = achip->chip;
1016 acpi_handle handle = ACPI_HANDLE(chip->parent);
1017 struct acpi_gpio_connection *conn, *tmp;
1018 acpi_status status;
1019
1020 status = acpi_remove_address_space_handler(handle, ACPI_ADR_SPACE_GPIO,
1021 acpi_gpio_adr_space_handler);
1022 if (ACPI_FAILURE(status)) {
1023 dev_err(chip->parent,
1024 "Failed to remove GPIO OpRegion handler\n");
1025 return;
1026 }
1027
1028 list_for_each_entry_safe_reverse(conn, tmp, &achip->conns, node) {
1029 gpiochip_free_own_desc(conn->desc);
1030 list_del(&conn->node);
1031 kfree(conn);
1032 }
1033}
1034
1035static struct gpio_desc *
1036acpi_gpiochip_parse_own_gpio(struct acpi_gpio_chip *achip,
1037 struct fwnode_handle *fwnode,
1038 const char **name,
1039 unsigned long *lflags,
1040 enum gpiod_flags *dflags)
1041{
1042 struct gpio_chip *chip = achip->chip;
1043 struct gpio_desc *desc;
1044 u32 gpios[2];
1045 int ret;
1046
1047 *lflags = GPIO_LOOKUP_FLAGS_DEFAULT;
1048 *dflags = 0;
1049 *name = NULL;
1050
1051 ret = fwnode_property_read_u32_array(fwnode, "gpios", gpios,
1052 ARRAY_SIZE(gpios));
1053 if (ret < 0)
1054 return ERR_PTR(ret);
1055
1056 desc = gpiochip_get_desc(chip, gpios[0]);
1057 if (IS_ERR(desc))
1058 return desc;
1059
1060 if (gpios[1])
1061 *lflags |= GPIO_ACTIVE_LOW;
1062
1063 if (fwnode_property_present(fwnode, "input"))
1064 *dflags |= GPIOD_IN;
1065 else if (fwnode_property_present(fwnode, "output-low"))
1066 *dflags |= GPIOD_OUT_LOW;
1067 else if (fwnode_property_present(fwnode, "output-high"))
1068 *dflags |= GPIOD_OUT_HIGH;
1069 else
1070 return ERR_PTR(-EINVAL);
1071
1072 fwnode_property_read_string(fwnode, "line-name", name);
1073
1074 return desc;
1075}
1076
1077static void acpi_gpiochip_scan_gpios(struct acpi_gpio_chip *achip)
1078{
1079 struct gpio_chip *chip = achip->chip;
1080 struct fwnode_handle *fwnode;
1081
1082 device_for_each_child_node(chip->parent, fwnode) {
1083 unsigned long lflags;
1084 enum gpiod_flags dflags;
1085 struct gpio_desc *desc;
1086 const char *name;
1087 int ret;
1088
1089 if (!fwnode_property_present(fwnode, "gpio-hog"))
1090 continue;
1091
1092 desc = acpi_gpiochip_parse_own_gpio(achip, fwnode, &name,
1093 &lflags, &dflags);
1094 if (IS_ERR(desc))
1095 continue;
1096
1097 ret = gpiod_hog(desc, name, lflags, dflags);
1098 if (ret) {
1099 dev_err(chip->parent, "Failed to hog GPIO\n");
1100 fwnode_handle_put(fwnode);
1101 return;
1102 }
1103 }
1104}
1105
1106void acpi_gpiochip_add(struct gpio_chip *chip)
1107{
1108 struct acpi_gpio_chip *acpi_gpio;
1109 acpi_handle handle;
1110 acpi_status status;
1111
1112 if (!chip || !chip->parent)
1113 return;
1114
1115 handle = ACPI_HANDLE(chip->parent);
1116 if (!handle)
1117 return;
1118
1119 acpi_gpio = kzalloc(sizeof(*acpi_gpio), GFP_KERNEL);
1120 if (!acpi_gpio) {
1121 dev_err(chip->parent,
1122 "Failed to allocate memory for ACPI GPIO chip\n");
1123 return;
1124 }
1125
1126 acpi_gpio->chip = chip;
1127 INIT_LIST_HEAD(&acpi_gpio->events);
1128 INIT_LIST_HEAD(&acpi_gpio->deferred_req_irqs_list_entry);
1129
1130 status = acpi_attach_data(handle, acpi_gpio_chip_dh, acpi_gpio);
1131 if (ACPI_FAILURE(status)) {
1132 dev_err(chip->parent, "Failed to attach ACPI GPIO chip\n");
1133 kfree(acpi_gpio);
1134 return;
1135 }
1136
1137 if (!chip->names)
1138 devprop_gpiochip_set_names(chip, dev_fwnode(chip->parent));
1139
1140 acpi_gpiochip_request_regions(acpi_gpio);
1141 acpi_gpiochip_scan_gpios(acpi_gpio);
1142 acpi_walk_dep_device_list(handle);
1143}
1144
1145void acpi_gpiochip_remove(struct gpio_chip *chip)
1146{
1147 struct acpi_gpio_chip *acpi_gpio;
1148 acpi_handle handle;
1149 acpi_status status;
1150
1151 if (!chip || !chip->parent)
1152 return;
1153
1154 handle = ACPI_HANDLE(chip->parent);
1155 if (!handle)
1156 return;
1157
1158 status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
1159 if (ACPI_FAILURE(status)) {
1160 dev_warn(chip->parent, "Failed to retrieve ACPI GPIO chip\n");
1161 return;
1162 }
1163
1164 acpi_gpiochip_free_regions(acpi_gpio);
1165
1166 acpi_detach_data(handle, acpi_gpio_chip_dh);
1167 kfree(acpi_gpio);
1168}
1169
1170static int acpi_gpio_package_count(const union acpi_object *obj)
1171{
1172 const union acpi_object *element = obj->package.elements;
1173 const union acpi_object *end = element + obj->package.count;
1174 unsigned int count = 0;
1175
1176 while (element < end) {
1177 switch (element->type) {
1178 case ACPI_TYPE_LOCAL_REFERENCE:
1179 element += 3;
1180
1181 case ACPI_TYPE_INTEGER:
1182 element++;
1183 count++;
1184 break;
1185
1186 default:
1187 return -EPROTO;
1188 }
1189 }
1190
1191 return count;
1192}
1193
1194static int acpi_find_gpio_count(struct acpi_resource *ares, void *data)
1195{
1196 unsigned int *count = data;
1197
1198 if (ares->type == ACPI_RESOURCE_TYPE_GPIO)
1199 *count += ares->data.gpio.pin_table_length;
1200
1201 return 1;
1202}
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213int acpi_gpio_count(struct device *dev, const char *con_id)
1214{
1215 struct acpi_device *adev = ACPI_COMPANION(dev);
1216 const union acpi_object *obj;
1217 const struct acpi_gpio_mapping *gm;
1218 int count = -ENOENT;
1219 int ret;
1220 char propname[32];
1221 unsigned int i;
1222
1223
1224 for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
1225 if (con_id)
1226 snprintf(propname, sizeof(propname), "%s-%s",
1227 con_id, gpio_suffixes[i]);
1228 else
1229 snprintf(propname, sizeof(propname), "%s",
1230 gpio_suffixes[i]);
1231
1232 ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_ANY,
1233 &obj);
1234 if (ret == 0) {
1235 if (obj->type == ACPI_TYPE_LOCAL_REFERENCE)
1236 count = 1;
1237 else if (obj->type == ACPI_TYPE_PACKAGE)
1238 count = acpi_gpio_package_count(obj);
1239 } else if (adev->driver_gpios) {
1240 for (gm = adev->driver_gpios; gm->name; gm++)
1241 if (strcmp(propname, gm->name) == 0) {
1242 count = gm->size;
1243 break;
1244 }
1245 }
1246 if (count > 0)
1247 break;
1248 }
1249
1250
1251 if (count < 0) {
1252 struct list_head resource_list;
1253 unsigned int crs_count = 0;
1254
1255 if (!acpi_can_fallback_to_crs(adev, con_id))
1256 return count;
1257
1258 INIT_LIST_HEAD(&resource_list);
1259 acpi_dev_get_resources(adev, &resource_list,
1260 acpi_find_gpio_count, &crs_count);
1261 acpi_dev_free_resource_list(&resource_list);
1262 if (crs_count > 0)
1263 count = crs_count;
1264 }
1265 return count ? count : -ENOENT;
1266}
1267
1268bool acpi_can_fallback_to_crs(struct acpi_device *adev, const char *con_id)
1269{
1270
1271 if (acpi_dev_has_props(adev) || adev->driver_gpios)
1272 return false;
1273
1274 return con_id == NULL;
1275}
1276
1277
1278static int acpi_gpio_handle_deferred_request_irqs(void)
1279{
1280 struct acpi_gpio_chip *acpi_gpio, *tmp;
1281
1282 mutex_lock(&acpi_gpio_deferred_req_irqs_lock);
1283 list_for_each_entry_safe(acpi_gpio, tmp,
1284 &acpi_gpio_deferred_req_irqs_list,
1285 deferred_req_irqs_list_entry)
1286 acpi_gpiochip_request_irqs(acpi_gpio);
1287
1288 acpi_gpio_deferred_req_irqs_done = true;
1289 mutex_unlock(&acpi_gpio_deferred_req_irqs_lock);
1290
1291 return 0;
1292}
1293
1294late_initcall_sync(acpi_gpio_handle_deferred_request_irqs);
1295
1296static const struct dmi_system_id run_edge_events_on_boot_blacklist[] = {
1297 {
1298 .matches = {
1299 DMI_MATCH(DMI_SYS_VENDOR, "MINIX"),
1300 DMI_MATCH(DMI_PRODUCT_NAME, "Z83-4"),
1301 }
1302 },
1303 {}
1304};
1305
1306static int acpi_gpio_setup_params(void)
1307{
1308 if (run_edge_events_on_boot < 0) {
1309 if (dmi_check_system(run_edge_events_on_boot_blacklist))
1310 run_edge_events_on_boot = 0;
1311 else
1312 run_edge_events_on_boot = 1;
1313 }
1314
1315 return 0;
1316}
1317
1318
1319postcore_initcall(acpi_gpio_setup_params);
1320