]> git.kernelconcepts.de Git - karo-tx-linux.git/blob - drivers/gpio/gpiolib-acpi.c
KVM: svm: handle KVM_X86_QUIRK_CD_NW_CLEARED in svm_get_mt_mask
[karo-tx-linux.git] / drivers / gpio / gpiolib-acpi.c
1 /*
2  * ACPI helpers for GPIO API
3  *
4  * Copyright (C) 2012, Intel Corporation
5  * Authors: Mathias Nyman <mathias.nyman@linux.intel.com>
6  *          Mika Westerberg <mika.westerberg@linux.intel.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  */
12
13 #include <linux/errno.h>
14 #include <linux/gpio.h>
15 #include <linux/gpio/consumer.h>
16 #include <linux/gpio/driver.h>
17 #include <linux/export.h>
18 #include <linux/acpi.h>
19 #include <linux/interrupt.h>
20 #include <linux/mutex.h>
21 #include <linux/pinctrl/pinctrl.h>
22
23 #include "gpiolib.h"
24
25 struct acpi_gpio_event {
26         struct list_head node;
27         acpi_handle handle;
28         unsigned int pin;
29         unsigned int irq;
30         struct gpio_desc *desc;
31 };
32
33 struct acpi_gpio_connection {
34         struct list_head node;
35         unsigned int pin;
36         struct gpio_desc *desc;
37 };
38
39 struct acpi_gpio_chip {
40         /*
41          * ACPICA requires that the first field of the context parameter
42          * passed to acpi_install_address_space_handler() is large enough
43          * to hold struct acpi_connection_info.
44          */
45         struct acpi_connection_info conn_info;
46         struct list_head conns;
47         struct mutex conn_lock;
48         struct gpio_chip *chip;
49         struct list_head events;
50 };
51
52 static int acpi_gpiochip_find(struct gpio_chip *gc, void *data)
53 {
54         if (!gc->dev)
55                 return false;
56
57         return ACPI_HANDLE(gc->dev) == data;
58 }
59
60 #ifdef CONFIG_PINCTRL
61 /**
62  * acpi_gpiochip_pin_to_gpio_offset() - translates ACPI GPIO to Linux GPIO
63  * @chip: GPIO chip
64  * @pin: ACPI GPIO pin number from GpioIo/GpioInt resource
65  *
66  * Function takes ACPI GpioIo/GpioInt pin number as a parameter and
67  * translates it to a corresponding offset suitable to be passed to a
68  * GPIO controller driver.
69  *
70  * Typically the returned offset is same as @pin, but if the GPIO
71  * controller uses pin controller and the mapping is not contigous the
72  * offset might be different.
73  */
74 static int acpi_gpiochip_pin_to_gpio_offset(struct gpio_chip *chip, int pin)
75 {
76         struct gpio_pin_range *pin_range;
77
78         /* If there are no ranges in this chip, use 1:1 mapping */
79         if (list_empty(&chip->pin_ranges))
80                 return pin;
81
82         list_for_each_entry(pin_range, &chip->pin_ranges, node) {
83                 const struct pinctrl_gpio_range *range = &pin_range->range;
84                 int i;
85
86                 if (range->pins) {
87                         for (i = 0; i < range->npins; i++) {
88                                 if (range->pins[i] == pin)
89                                         return range->base + i - chip->base;
90                         }
91                 } else {
92                         if (pin >= range->pin_base &&
93                             pin < range->pin_base + range->npins) {
94                                 unsigned gpio_base;
95
96                                 gpio_base = range->base - chip->base;
97                                 return gpio_base + pin - range->pin_base;
98                         }
99                 }
100         }
101
102         return -EINVAL;
103 }
104 #else
105 static inline int acpi_gpiochip_pin_to_gpio_offset(struct gpio_chip *chip,
106                                                    int pin)
107 {
108         return pin;
109 }
110 #endif
111
112 /**
113  * acpi_get_gpiod() - Translate ACPI GPIO pin to GPIO descriptor usable with GPIO API
114  * @path:       ACPI GPIO controller full path name, (e.g. "\\_SB.GPO1")
115  * @pin:        ACPI GPIO pin number (0-based, controller-relative)
116  *
117  * Return: GPIO descriptor to use with Linux generic GPIO API, or ERR_PTR
118  * error value. Specifically returns %-EPROBE_DEFER if the referenced GPIO
119  * controller does not have gpiochip registered at the moment. This is to
120  * support probe deferral.
121  */
122 static struct gpio_desc *acpi_get_gpiod(char *path, int pin)
123 {
124         struct gpio_chip *chip;
125         acpi_handle handle;
126         acpi_status status;
127         int offset;
128
129         status = acpi_get_handle(NULL, path, &handle);
130         if (ACPI_FAILURE(status))
131                 return ERR_PTR(-ENODEV);
132
133         chip = gpiochip_find(handle, acpi_gpiochip_find);
134         if (!chip)
135                 return ERR_PTR(-EPROBE_DEFER);
136
137         offset = acpi_gpiochip_pin_to_gpio_offset(chip, pin);
138         if (offset < 0)
139                 return ERR_PTR(offset);
140
141         return gpiochip_get_desc(chip, offset);
142 }
143
144 static irqreturn_t acpi_gpio_irq_handler(int irq, void *data)
145 {
146         struct acpi_gpio_event *event = data;
147
148         acpi_evaluate_object(event->handle, NULL, NULL, NULL);
149
150         return IRQ_HANDLED;
151 }
152
153 static irqreturn_t acpi_gpio_irq_handler_evt(int irq, void *data)
154 {
155         struct acpi_gpio_event *event = data;
156
157         acpi_execute_simple_method(event->handle, NULL, event->pin);
158
159         return IRQ_HANDLED;
160 }
161
162 static void acpi_gpio_chip_dh(acpi_handle handle, void *data)
163 {
164         /* The address of this function is used as a key. */
165 }
166
167 static acpi_status acpi_gpiochip_request_interrupt(struct acpi_resource *ares,
168                                                    void *context)
169 {
170         struct acpi_gpio_chip *acpi_gpio = context;
171         struct gpio_chip *chip = acpi_gpio->chip;
172         struct acpi_resource_gpio *agpio;
173         acpi_handle handle, evt_handle;
174         struct acpi_gpio_event *event;
175         irq_handler_t handler = NULL;
176         struct gpio_desc *desc;
177         unsigned long irqflags;
178         int ret, pin, irq;
179
180         if (ares->type != ACPI_RESOURCE_TYPE_GPIO)
181                 return AE_OK;
182
183         agpio = &ares->data.gpio;
184         if (agpio->connection_type != ACPI_RESOURCE_GPIO_TYPE_INT)
185                 return AE_OK;
186
187         handle = ACPI_HANDLE(chip->dev);
188         pin = agpio->pin_table[0];
189
190         if (pin <= 255) {
191                 char ev_name[5];
192                 sprintf(ev_name, "_%c%02X",
193                         agpio->triggering == ACPI_EDGE_SENSITIVE ? 'E' : 'L',
194                         pin);
195                 if (ACPI_SUCCESS(acpi_get_handle(handle, ev_name, &evt_handle)))
196                         handler = acpi_gpio_irq_handler;
197         }
198         if (!handler) {
199                 if (ACPI_SUCCESS(acpi_get_handle(handle, "_EVT", &evt_handle)))
200                         handler = acpi_gpio_irq_handler_evt;
201         }
202         if (!handler)
203                 return AE_BAD_PARAMETER;
204
205         pin = acpi_gpiochip_pin_to_gpio_offset(chip, pin);
206         if (pin < 0)
207                 return AE_BAD_PARAMETER;
208
209         desc = gpiochip_request_own_desc(chip, pin, "ACPI:Event");
210         if (IS_ERR(desc)) {
211                 dev_err(chip->dev, "Failed to request GPIO\n");
212                 return AE_ERROR;
213         }
214
215         gpiod_direction_input(desc);
216
217         ret = gpiochip_lock_as_irq(chip, pin);
218         if (ret) {
219                 dev_err(chip->dev, "Failed to lock GPIO as interrupt\n");
220                 goto fail_free_desc;
221         }
222
223         irq = gpiod_to_irq(desc);
224         if (irq < 0) {
225                 dev_err(chip->dev, "Failed to translate GPIO to IRQ\n");
226                 goto fail_unlock_irq;
227         }
228
229         irqflags = IRQF_ONESHOT;
230         if (agpio->triggering == ACPI_LEVEL_SENSITIVE) {
231                 if (agpio->polarity == ACPI_ACTIVE_HIGH)
232                         irqflags |= IRQF_TRIGGER_HIGH;
233                 else
234                         irqflags |= IRQF_TRIGGER_LOW;
235         } else {
236                 switch (agpio->polarity) {
237                 case ACPI_ACTIVE_HIGH:
238                         irqflags |= IRQF_TRIGGER_RISING;
239                         break;
240                 case ACPI_ACTIVE_LOW:
241                         irqflags |= IRQF_TRIGGER_FALLING;
242                         break;
243                 default:
244                         irqflags |= IRQF_TRIGGER_RISING |
245                                     IRQF_TRIGGER_FALLING;
246                         break;
247                 }
248         }
249
250         event = kzalloc(sizeof(*event), GFP_KERNEL);
251         if (!event)
252                 goto fail_unlock_irq;
253
254         event->handle = evt_handle;
255         event->irq = irq;
256         event->pin = pin;
257         event->desc = desc;
258
259         ret = request_threaded_irq(event->irq, NULL, handler, irqflags,
260                                    "ACPI:Event", event);
261         if (ret) {
262                 dev_err(chip->dev, "Failed to setup interrupt handler for %d\n",
263                         event->irq);
264                 goto fail_free_event;
265         }
266
267         list_add_tail(&event->node, &acpi_gpio->events);
268         return AE_OK;
269
270 fail_free_event:
271         kfree(event);
272 fail_unlock_irq:
273         gpiochip_unlock_as_irq(chip, pin);
274 fail_free_desc:
275         gpiochip_free_own_desc(desc);
276
277         return AE_ERROR;
278 }
279
280 /**
281  * acpi_gpiochip_request_interrupts() - Register isr for gpio chip ACPI events
282  * @chip:      GPIO chip
283  *
284  * ACPI5 platforms can use GPIO signaled ACPI events. These GPIO interrupts are
285  * handled by ACPI event methods which need to be called from the GPIO
286  * chip's interrupt handler. acpi_gpiochip_request_interrupts finds out which
287  * gpio pins have acpi event methods and assigns interrupt handlers that calls
288  * the acpi event methods for those pins.
289  */
290 void acpi_gpiochip_request_interrupts(struct gpio_chip *chip)
291 {
292         struct acpi_gpio_chip *acpi_gpio;
293         acpi_handle handle;
294         acpi_status status;
295
296         if (!chip->dev || !chip->to_irq)
297                 return;
298
299         handle = ACPI_HANDLE(chip->dev);
300         if (!handle)
301                 return;
302
303         status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
304         if (ACPI_FAILURE(status))
305                 return;
306
307         INIT_LIST_HEAD(&acpi_gpio->events);
308         acpi_walk_resources(handle, "_AEI",
309                             acpi_gpiochip_request_interrupt, acpi_gpio);
310 }
311 EXPORT_SYMBOL_GPL(acpi_gpiochip_request_interrupts);
312
313 /**
314  * acpi_gpiochip_free_interrupts() - Free GPIO ACPI event interrupts.
315  * @chip:      GPIO chip
316  *
317  * Free interrupts associated with GPIO ACPI event method for the given
318  * GPIO chip.
319  */
320 void acpi_gpiochip_free_interrupts(struct gpio_chip *chip)
321 {
322         struct acpi_gpio_chip *acpi_gpio;
323         struct acpi_gpio_event *event, *ep;
324         acpi_handle handle;
325         acpi_status status;
326
327         if (!chip->dev || !chip->to_irq)
328                 return;
329
330         handle = ACPI_HANDLE(chip->dev);
331         if (!handle)
332                 return;
333
334         status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
335         if (ACPI_FAILURE(status))
336                 return;
337
338         list_for_each_entry_safe_reverse(event, ep, &acpi_gpio->events, node) {
339                 struct gpio_desc *desc;
340
341                 free_irq(event->irq, event);
342                 desc = event->desc;
343                 if (WARN_ON(IS_ERR(desc)))
344                         continue;
345                 gpiochip_unlock_as_irq(chip, event->pin);
346                 gpiochip_free_own_desc(desc);
347                 list_del(&event->node);
348                 kfree(event);
349         }
350 }
351 EXPORT_SYMBOL_GPL(acpi_gpiochip_free_interrupts);
352
353 int acpi_dev_add_driver_gpios(struct acpi_device *adev,
354                               const struct acpi_gpio_mapping *gpios)
355 {
356         if (adev && gpios) {
357                 adev->driver_gpios = gpios;
358                 return 0;
359         }
360         return -EINVAL;
361 }
362 EXPORT_SYMBOL_GPL(acpi_dev_add_driver_gpios);
363
364 static bool acpi_get_driver_gpio_data(struct acpi_device *adev,
365                                       const char *name, int index,
366                                       struct acpi_reference_args *args)
367 {
368         const struct acpi_gpio_mapping *gm;
369
370         if (!adev->driver_gpios)
371                 return false;
372
373         for (gm = adev->driver_gpios; gm->name; gm++)
374                 if (!strcmp(name, gm->name) && gm->data && index < gm->size) {
375                         const struct acpi_gpio_params *par = gm->data + index;
376
377                         args->adev = adev;
378                         args->args[0] = par->crs_entry_index;
379                         args->args[1] = par->line_index;
380                         args->args[2] = par->active_low;
381                         args->nargs = 3;
382                         return true;
383                 }
384
385         return false;
386 }
387
388 struct acpi_gpio_lookup {
389         struct acpi_gpio_info info;
390         int index;
391         int pin_index;
392         struct gpio_desc *desc;
393         int n;
394 };
395
396 static int acpi_find_gpio(struct acpi_resource *ares, void *data)
397 {
398         struct acpi_gpio_lookup *lookup = data;
399
400         if (ares->type != ACPI_RESOURCE_TYPE_GPIO)
401                 return 1;
402
403         if (lookup->n++ == lookup->index && !lookup->desc) {
404                 const struct acpi_resource_gpio *agpio = &ares->data.gpio;
405                 int pin_index = lookup->pin_index;
406
407                 if (pin_index >= agpio->pin_table_length)
408                         return 1;
409
410                 lookup->desc = acpi_get_gpiod(agpio->resource_source.string_ptr,
411                                               agpio->pin_table[pin_index]);
412                 lookup->info.gpioint =
413                         agpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT;
414
415                 /*
416                  * ActiveLow is only specified for GpioInt resource. If
417                  * GpioIo is used then the only way to set the flag is
418                  * to use _DSD "gpios" property.
419                  */
420                 if (lookup->info.gpioint)
421                         lookup->info.active_low =
422                                 agpio->polarity == ACPI_ACTIVE_LOW;
423         }
424
425         return 1;
426 }
427
428 /**
429  * acpi_get_gpiod_by_index() - get a GPIO descriptor from device resources
430  * @adev: pointer to a ACPI device to get GPIO from
431  * @propname: Property name of the GPIO (optional)
432  * @index: index of GpioIo/GpioInt resource (starting from %0)
433  * @info: info pointer to fill in (optional)
434  *
435  * Function goes through ACPI resources for @adev and based on @index looks
436  * up a GpioIo/GpioInt resource, translates it to the Linux GPIO descriptor,
437  * and returns it. @index matches GpioIo/GpioInt resources only so if there
438  * are total %3 GPIO resources, the index goes from %0 to %2.
439  *
440  * If @propname is specified the GPIO is looked using device property. In
441  * that case @index is used to select the GPIO entry in the property value
442  * (in case of multiple).
443  *
444  * If the GPIO cannot be translated or there is an error an ERR_PTR is
445  * returned.
446  *
447  * Note: if the GPIO resource has multiple entries in the pin list, this
448  * function only returns the first.
449  */
450 struct gpio_desc *acpi_get_gpiod_by_index(struct acpi_device *adev,
451                                           const char *propname, int index,
452                                           struct acpi_gpio_info *info)
453 {
454         struct acpi_gpio_lookup lookup;
455         struct list_head resource_list;
456         bool active_low = false;
457         int ret;
458
459         if (!adev)
460                 return ERR_PTR(-ENODEV);
461
462         memset(&lookup, 0, sizeof(lookup));
463         lookup.index = index;
464
465         if (propname) {
466                 struct acpi_reference_args args;
467
468                 dev_dbg(&adev->dev, "GPIO: looking up %s\n", propname);
469
470                 memset(&args, 0, sizeof(args));
471                 ret = acpi_dev_get_property_reference(adev, propname,
472                                                       index, &args);
473                 if (ret) {
474                         bool found = acpi_get_driver_gpio_data(adev, propname,
475                                                                index, &args);
476                         if (!found)
477                                 return ERR_PTR(ret);
478                 }
479
480                 /*
481                  * The property was found and resolved so need to
482                  * lookup the GPIO based on returned args instead.
483                  */
484                 adev = args.adev;
485                 if (args.nargs >= 2) {
486                         lookup.index = args.args[0];
487                         lookup.pin_index = args.args[1];
488                         /*
489                          * 3rd argument, if present is used to
490                          * specify active_low.
491                          */
492                         if (args.nargs >= 3)
493                                 active_low = !!args.args[2];
494                 }
495
496                 dev_dbg(&adev->dev, "GPIO: _DSD returned %s %zd %llu %llu %llu\n",
497                         dev_name(&adev->dev), args.nargs,
498                         args.args[0], args.args[1], args.args[2]);
499         } else {
500                 dev_dbg(&adev->dev, "GPIO: looking up %d in _CRS\n", index);
501         }
502
503         INIT_LIST_HEAD(&resource_list);
504         ret = acpi_dev_get_resources(adev, &resource_list, acpi_find_gpio,
505                                      &lookup);
506         if (ret < 0)
507                 return ERR_PTR(ret);
508
509         acpi_dev_free_resource_list(&resource_list);
510
511         if (lookup.desc && info) {
512                 *info = lookup.info;
513                 if (active_low)
514                         info->active_low = active_low;
515         }
516
517         return lookup.desc ? lookup.desc : ERR_PTR(-ENOENT);
518 }
519
520 /**
521  * acpi_dev_gpio_irq_get() - Find GpioInt and translate it to Linux IRQ number
522  * @adev: pointer to a ACPI device to get IRQ from
523  * @index: index of GpioInt resource (starting from %0)
524  *
525  * If the device has one or more GpioInt resources, this function can be
526  * used to translate from the GPIO offset in the resource to the Linux IRQ
527  * number.
528  *
529  * Return: Linux IRQ number (>%0) on success, negative errno on failure.
530  */
531 int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index)
532 {
533         int idx, i;
534
535         for (i = 0, idx = 0; idx <= index; i++) {
536                 struct acpi_gpio_info info;
537                 struct gpio_desc *desc;
538
539                 desc = acpi_get_gpiod_by_index(adev, NULL, i, &info);
540                 if (IS_ERR(desc))
541                         break;
542                 if (info.gpioint && idx++ == index)
543                         return gpiod_to_irq(desc);
544         }
545         return -ENOENT;
546 }
547 EXPORT_SYMBOL_GPL(acpi_dev_gpio_irq_get);
548
549 static acpi_status
550 acpi_gpio_adr_space_handler(u32 function, acpi_physical_address address,
551                             u32 bits, u64 *value, void *handler_context,
552                             void *region_context)
553 {
554         struct acpi_gpio_chip *achip = region_context;
555         struct gpio_chip *chip = achip->chip;
556         struct acpi_resource_gpio *agpio;
557         struct acpi_resource *ares;
558         int pin_index = (int)address;
559         acpi_status status;
560         bool pull_up;
561         int length;
562         int i;
563
564         status = acpi_buffer_to_resource(achip->conn_info.connection,
565                                          achip->conn_info.length, &ares);
566         if (ACPI_FAILURE(status))
567                 return status;
568
569         if (WARN_ON(ares->type != ACPI_RESOURCE_TYPE_GPIO)) {
570                 ACPI_FREE(ares);
571                 return AE_BAD_PARAMETER;
572         }
573
574         agpio = &ares->data.gpio;
575         pull_up = agpio->pin_config == ACPI_PIN_CONFIG_PULLUP;
576
577         if (WARN_ON(agpio->io_restriction == ACPI_IO_RESTRICT_INPUT &&
578             function == ACPI_WRITE)) {
579                 ACPI_FREE(ares);
580                 return AE_BAD_PARAMETER;
581         }
582
583         length = min(agpio->pin_table_length, (u16)(pin_index + bits));
584         for (i = pin_index; i < length; ++i) {
585                 int pin = agpio->pin_table[i];
586                 struct acpi_gpio_connection *conn;
587                 struct gpio_desc *desc;
588                 bool found;
589
590                 pin = acpi_gpiochip_pin_to_gpio_offset(chip, pin);
591                 if (pin < 0) {
592                         status = AE_BAD_PARAMETER;
593                         goto out;
594                 }
595
596                 mutex_lock(&achip->conn_lock);
597
598                 found = false;
599                 list_for_each_entry(conn, &achip->conns, node) {
600                         if (conn->pin == pin) {
601                                 found = true;
602                                 desc = conn->desc;
603                                 break;
604                         }
605                 }
606                 if (!found) {
607                         desc = gpiochip_request_own_desc(chip, pin,
608                                                          "ACPI:OpRegion");
609                         if (IS_ERR(desc)) {
610                                 status = AE_ERROR;
611                                 mutex_unlock(&achip->conn_lock);
612                                 goto out;
613                         }
614
615                         switch (agpio->io_restriction) {
616                         case ACPI_IO_RESTRICT_INPUT:
617                                 gpiod_direction_input(desc);
618                                 break;
619                         case ACPI_IO_RESTRICT_OUTPUT:
620                                 /*
621                                  * ACPI GPIO resources don't contain an
622                                  * initial value for the GPIO. Therefore we
623                                  * deduce that value from the pull field
624                                  * instead. If the pin is pulled up we
625                                  * assume default to be high, otherwise
626                                  * low.
627                                  */
628                                 gpiod_direction_output(desc, pull_up);
629                                 break;
630                         default:
631                                 /*
632                                  * Assume that the BIOS has configured the
633                                  * direction and pull accordingly.
634                                  */
635                                 break;
636                         }
637
638                         conn = kzalloc(sizeof(*conn), GFP_KERNEL);
639                         if (!conn) {
640                                 status = AE_NO_MEMORY;
641                                 gpiochip_free_own_desc(desc);
642                                 mutex_unlock(&achip->conn_lock);
643                                 goto out;
644                         }
645
646                         conn->pin = pin;
647                         conn->desc = desc;
648                         list_add_tail(&conn->node, &achip->conns);
649                 }
650
651                 mutex_unlock(&achip->conn_lock);
652
653                 if (function == ACPI_WRITE)
654                         gpiod_set_raw_value_cansleep(desc,
655                                                      !!((1 << i) & *value));
656                 else
657                         *value |= (u64)gpiod_get_raw_value_cansleep(desc) << i;
658         }
659
660 out:
661         ACPI_FREE(ares);
662         return status;
663 }
664
665 static void acpi_gpiochip_request_regions(struct acpi_gpio_chip *achip)
666 {
667         struct gpio_chip *chip = achip->chip;
668         acpi_handle handle = ACPI_HANDLE(chip->dev);
669         acpi_status status;
670
671         INIT_LIST_HEAD(&achip->conns);
672         mutex_init(&achip->conn_lock);
673         status = acpi_install_address_space_handler(handle, ACPI_ADR_SPACE_GPIO,
674                                                     acpi_gpio_adr_space_handler,
675                                                     NULL, achip);
676         if (ACPI_FAILURE(status))
677                 dev_err(chip->dev, "Failed to install GPIO OpRegion handler\n");
678 }
679
680 static void acpi_gpiochip_free_regions(struct acpi_gpio_chip *achip)
681 {
682         struct gpio_chip *chip = achip->chip;
683         acpi_handle handle = ACPI_HANDLE(chip->dev);
684         struct acpi_gpio_connection *conn, *tmp;
685         acpi_status status;
686
687         status = acpi_remove_address_space_handler(handle, ACPI_ADR_SPACE_GPIO,
688                                                    acpi_gpio_adr_space_handler);
689         if (ACPI_FAILURE(status)) {
690                 dev_err(chip->dev, "Failed to remove GPIO OpRegion handler\n");
691                 return;
692         }
693
694         list_for_each_entry_safe_reverse(conn, tmp, &achip->conns, node) {
695                 gpiochip_free_own_desc(conn->desc);
696                 list_del(&conn->node);
697                 kfree(conn);
698         }
699 }
700
701 void acpi_gpiochip_add(struct gpio_chip *chip)
702 {
703         struct acpi_gpio_chip *acpi_gpio;
704         acpi_handle handle;
705         acpi_status status;
706
707         if (!chip || !chip->dev)
708                 return;
709
710         handle = ACPI_HANDLE(chip->dev);
711         if (!handle)
712                 return;
713
714         acpi_gpio = kzalloc(sizeof(*acpi_gpio), GFP_KERNEL);
715         if (!acpi_gpio) {
716                 dev_err(chip->dev,
717                         "Failed to allocate memory for ACPI GPIO chip\n");
718                 return;
719         }
720
721         acpi_gpio->chip = chip;
722
723         status = acpi_attach_data(handle, acpi_gpio_chip_dh, acpi_gpio);
724         if (ACPI_FAILURE(status)) {
725                 dev_err(chip->dev, "Failed to attach ACPI GPIO chip\n");
726                 kfree(acpi_gpio);
727                 return;
728         }
729
730         acpi_gpiochip_request_regions(acpi_gpio);
731 }
732
733 void acpi_gpiochip_remove(struct gpio_chip *chip)
734 {
735         struct acpi_gpio_chip *acpi_gpio;
736         acpi_handle handle;
737         acpi_status status;
738
739         if (!chip || !chip->dev)
740                 return;
741
742         handle = ACPI_HANDLE(chip->dev);
743         if (!handle)
744                 return;
745
746         status = acpi_get_data(handle, acpi_gpio_chip_dh, (void **)&acpi_gpio);
747         if (ACPI_FAILURE(status)) {
748                 dev_warn(chip->dev, "Failed to retrieve ACPI GPIO chip\n");
749                 return;
750         }
751
752         acpi_gpiochip_free_regions(acpi_gpio);
753
754         acpi_detach_data(handle, acpi_gpio_chip_dh);
755         kfree(acpi_gpio);
756 }
757
758 static unsigned int acpi_gpio_package_count(const union acpi_object *obj)
759 {
760         const union acpi_object *element = obj->package.elements;
761         const union acpi_object *end = element + obj->package.count;
762         unsigned int count = 0;
763
764         while (element < end) {
765                 if (element->type == ACPI_TYPE_LOCAL_REFERENCE)
766                         count++;
767
768                 element++;
769         }
770         return count;
771 }
772
773 static int acpi_find_gpio_count(struct acpi_resource *ares, void *data)
774 {
775         unsigned int *count = data;
776
777         if (ares->type == ACPI_RESOURCE_TYPE_GPIO)
778                 *count += ares->data.gpio.pin_table_length;
779
780         return 1;
781 }
782
783 /**
784  * acpi_gpio_count - return the number of GPIOs associated with a
785  *              device / function or -ENOENT if no GPIO has been
786  *              assigned to the requested function.
787  * @dev:        GPIO consumer, can be NULL for system-global GPIOs
788  * @con_id:     function within the GPIO consumer
789  */
790 int acpi_gpio_count(struct device *dev, const char *con_id)
791 {
792         struct acpi_device *adev = ACPI_COMPANION(dev);
793         const union acpi_object *obj;
794         const struct acpi_gpio_mapping *gm;
795         int count = -ENOENT;
796         int ret;
797         char propname[32];
798         unsigned int i;
799
800         /* Try first from _DSD */
801         for (i = 0; i < ARRAY_SIZE(gpio_suffixes); i++) {
802                 if (con_id && strcmp(con_id, "gpios"))
803                         snprintf(propname, sizeof(propname), "%s-%s",
804                                  con_id, gpio_suffixes[i]);
805                 else
806                         snprintf(propname, sizeof(propname), "%s",
807                                  gpio_suffixes[i]);
808
809                 ret = acpi_dev_get_property(adev, propname, ACPI_TYPE_ANY,
810                                             &obj);
811                 if (ret == 0) {
812                         if (obj->type == ACPI_TYPE_LOCAL_REFERENCE)
813                                 count = 1;
814                         else if (obj->type == ACPI_TYPE_PACKAGE)
815                                 count = acpi_gpio_package_count(obj);
816                 } else if (adev->driver_gpios) {
817                         for (gm = adev->driver_gpios; gm->name; gm++)
818                                 if (strcmp(propname, gm->name) == 0) {
819                                         count = gm->size;
820                                         break;
821                                 }
822                 }
823                 if (count >= 0)
824                         break;
825         }
826
827         /* Then from plain _CRS GPIOs */
828         if (count < 0) {
829                 struct list_head resource_list;
830                 unsigned int crs_count = 0;
831
832                 INIT_LIST_HEAD(&resource_list);
833                 acpi_dev_get_resources(adev, &resource_list,
834                                        acpi_find_gpio_count, &crs_count);
835                 acpi_dev_free_resource_list(&resource_list);
836                 if (crs_count > 0)
837                         count = crs_count;
838         }
839         return count;
840 }