Merge tag 'pm+acpi-3.19-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

Pull ACPI and power management updates from Rafael Wysocki:
 "This time we have some more new material than we used to have during
  the last couple of development cycles.

  The most important part of it to me is the introduction of a unified
  interface for accessing device properties provided by platform
  firmware.  It works with Device Trees and ACPI in a uniform way and
  drivers using it need not worry about where the properties come from
  as long as the platform firmware (either DT or ACPI) makes them
  available.  It covers both devices and "bare" device node objects
  without struct device representation as that turns out to be necessary
  in some cases.  This has been in the works for quite a few months (and
  development cycles) and has been approved by all of the relevant
  maintainers.

  On top of that, some drivers are switched over to the new interface
  (at25, leds-gpio, gpio_keys_polled) and some additional changes are
  made to the core GPIO subsystem to allow device drivers to manipulate
  GPIOs in the "canonical" way on platforms that provide GPIO
  information in their ACPI tables, but don't assign names to GPIO lines
  (in which case the driver needs to do that on the basis of what it
  knows about the device in question).  That also has been approved by
  the GPIO core maintainers and the rfkill driver is now going to use
  it.

  Second is support for hardware P-states in the intel_pstate driver.
  It uses CPUID to detect whether or not the feature is supported by the
  processor in which case it will be enabled by default.  However, it
  can be disabled entirely from the kernel command line if necessary.

  Next is support for a platform firmware interface based on ACPI
  operation regions used by the PMIC (Power Management Integrated
  Circuit) chips on the Intel Baytrail-T and Baytrail-T-CR platforms.
  That interface is used for manipulating power resources and for
  thermal management: sensor temperature reporting, trip point setting
  and so on.

  Also the ACPI core is now going to support the _DEP configuration
  information in a limited way.  Basically, _DEP it supposed to reflect
  off-the-hierarchy dependencies between devices which may be very
  indirect, like when AML for one device accesses locations in an
  operation region handled by another device's driver (usually, the
  device depended on this way is a serial bus or GPIO controller).  The
  support added this time is sufficient to make the ACPI battery driver
  work on Asus T100A, but it is general enough to be able to cover some
  other use cases in the future.

  Finally, we have a new cpufreq driver for the Loongson1B processor.

  In addition to the above, there are fixes and cleanups all over the
  place as usual and a traditional ACPICA update to a recent upstream
  release.

  As far as the fixes go, the ACPI LPSS (Low-power Subsystem) driver for
  Intel platforms should be able to handle power management of the DMA
  engine correctly, the cpufreq-dt driver should interact with the
  thermal subsystem in a better way and the ACPI backlight driver should
  handle some more corner cases, among other things.

  On top of the ACPICA update there are fixes for race conditions in the
  ACPICA's interrupt handling code which might lead to some random and
  strange looking failures on some systems.

  In the cleanups department the most visible part is the series of
  commits targeted at getting rid of the CONFIG_PM_RUNTIME configuration
  option.  That was triggered by a discussion regarding the generic
  power domains code during which we realized that trying to support
  certain combinations of PM config options was painful and not really
  worth it, because nobody would use them in production anyway.  For
  this reason, we decided to make CONFIG_PM_SLEEP select
  CONFIG_PM_RUNTIME and that lead to the conclusion that the latter
  became redundant and CONFIG_PM could be used instead of it.  The
  material here makes that replacement in a major part of the tree, but
  there will be at least one more batch of that in the second part of
  the merge window.

  Specifics:

   - Support for retrieving device properties information from ACPI _DSD
     device configuration objects and a unified device properties
     interface for device drivers (and subsystems) on top of that.  As
     stated above, this works with Device Trees and ACPI and allows
     device drivers to be written in a platform firmware (DT or ACPI)
     agnostic way.  The at25, leds-gpio and gpio_keys_polled drivers are
     now going to use this new interface and the GPIO subsystem is
     additionally modified to allow device drivers to assign names to
     GPIO resources returned by ACPI _CRS objects (in case _DSD is not
     present or does not provide the expected data).  The changes in
     this set are mostly from Mika Westerberg, Rafael J Wysocki, Aaron
     Lu, and Darren Hart with some fixes from others (Fabio Estevam,
     Geert Uytterhoeven).

   - Support for Hardware Managed Performance States (HWP) as described
     in Volume 3, section 14.4, of the Intel SDM in the intel_pstate
     driver.  CPUID is used to detect whether or not the feature is
     supported by the processor.  If supported, it will be enabled
     automatically unless the intel_pstate=no_hwp switch is present in
     the kernel command line.  From Dirk Brandewie.

   - New Intel Broadwell-H ID for intel_pstate (Dirk Brandewie).

   - Support for firmware interface based on ACPI operation regions used
     by the PMIC chips on the Intel Baytrail-T and Baytrail-T-CR
     platforms for power resource control and thermal management (Aaron
     Lu).

   - Limited support for retrieving off-the-hierarchy dependencies
     between devices from ACPI _DEP device configuration objects and
     deferred probing support for the ACPI battery driver based on the
     _DEP information to make that driver work on Asus T100A (Lan
     Tianyu).

   - New cpufreq driver for the Loongson1B processor (Kelvin Cheung).

   - ACPICA update to upstream revision 20141107 which only affects
     tools (Bob Moore).

   - Fixes for race conditions in the ACPICA's interrupt handling code
     and in the ACPI code related to system suspend and resume (Lv Zheng
     and Rafael J Wysocki).

   - ACPI core fix for an RCU-related issue in the ioremap() regions
     management code that slowed down significantly after CPUs had been
     allowed to enter idle states even if they'd had RCU callbakcs
     queued and triggered some problems in certain proprietary graphics
     driver (and elsewhere).  The fix replaces synchronize_rcu() in that
     code with synchronize_rcu_expedited() which makes the issue go
     away.  From Konstantin Khlebnikov.

   - ACPI LPSS (Low-Power Subsystem) driver fix to handle power
     management of the DMA engine included into the LPSS correctly.  The
     problem is that the DMA engine doesn't have ACPI PM support of its
     own and it simply is turned off when the last LPSS device having
     ACPI PM support goes into D3cold.  To work around that, the PM
     domain used by the ACPI LPSS driver is redesigned so at least one
     device with ACPI PM support will be on as long as the DMA engine is
     in use.  From Andy Shevchenko.

   - ACPI backlight driver fix to avoid using it on "Win8-compatible"
     systems where it doesn't work and where it was used by default by
     mistake (Aaron Lu).

   - Assorted minor ACPI core fixes and cleanups from Tomasz Nowicki,
     Sudeep Holla, Huang Rui, Hanjun Guo, Fabian Frederick, and Ashwin
     Chaugule (mostly related to the upcoming ARM64 support).

   - Intel RAPL (Running Average Power Limit) power capping driver fixes
     and improvements including new processor IDs (Jacob Pan).

   - Generic power domains modification to power up domains after
     attaching devices to them to meet the expectations of device
     drivers and bus types assuming devices to be accessible at probe
     time (Ulf Hansson).

   - Preliminary support for controlling device clocks from the generic
     power domains core code and modifications of the ARM/shmobile
     platform to use that feature (Ulf Hansson).

   - Assorted minor fixes and cleanups of the generic power domains core
     code (Ulf Hansson, Geert Uytterhoeven).

   - Assorted minor fixes and cleanups of the device clocks control code
     in the PM core (Geert Uytterhoeven, Grygorii Strashko).

   - Consolidation of device power management Kconfig options by making
     CONFIG_PM_SLEEP select CONFIG_PM_RUNTIME and removing the latter
     which is now redundant (Rafael J Wysocki and Kevin Hilman).  That
     is the first batch of the changes needed for this purpose.

   - Core device runtime power management support code cleanup related
     to the execution of callbacks (Andrzej Hajda).

   - cpuidle ARM support improvements (Lorenzo Pieralisi).

   - cpuidle cleanup related to the CPUIDLE_FLAG_TIME_VALID flag and a
     new MAINTAINERS entry for ARM Exynos cpuidle (Daniel Lezcano and
     Bartlomiej Zolnierkiewicz).

   - New cpufreq driver callback (->ready) to be executed when the
     cpufreq core is ready to use a given policy object and cpufreq-dt
     driver modification to use that callback for cooling device
     registration (Viresh Kumar).

   - cpufreq core fixes and cleanups (Viresh Kumar, Vince Hsu, James
     Geboski, Tomeu Vizoso).

   - Assorted fixes and cleanups in the cpufreq-pcc, intel_pstate,
     cpufreq-dt, pxa2xx cpufreq drivers (Lenny Szubowicz, Ethan Zhao,
     Stefan Wahren, Petr Cvek).

   - OPP (Operating Performance Points) framework modification to allow
     OPPs to be removed too and update of a few cpufreq drivers
     (cpufreq-dt, exynos5440, imx6q, cpufreq) to remove OPPs (added
     during initialization) on driver removal (Viresh Kumar).

   - Hibernation core fixes and cleanups (Tina Ruchandani and Markus
     Elfring).

   - PM Kconfig fix related to CPU power management (Pankaj Dubey).

   - cpupower tool fix (Prarit Bhargava)"

* tag 'pm+acpi-3.19-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm: (120 commits)
  i2c-omap / PM: Drop CONFIG_PM_RUNTIME from i2c-omap.c
  dmaengine / PM: Replace CONFIG_PM_RUNTIME with CONFIG_PM
  tools: cpupower: fix return checks for sysfs_get_idlestate_count()
  drivers: sh / PM: Replace CONFIG_PM_RUNTIME with CONFIG_PM
  e1000e / igb / PM: Eliminate CONFIG_PM_RUNTIME
  MMC / PM: Replace CONFIG_PM_RUNTIME with CONFIG_PM
  MFD / PM: Replace CONFIG_PM_RUNTIME with CONFIG_PM
  misc / PM: Replace CONFIG_PM_RUNTIME with CONFIG_PM
  media / PM: Replace CONFIG_PM_RUNTIME with CONFIG_PM
  input / PM: Replace CONFIG_PM_RUNTIME with CONFIG_PM
  leds: leds-gpio: Fix multiple instances registration without 'label' property
  iio / PM: Replace CONFIG_PM_RUNTIME with CONFIG_PM
  hsi / OMAP / PM: Replace CONFIG_PM_RUNTIME with CONFIG_PM
  i2c-hid / PM: Replace CONFIG_PM_RUNTIME with CONFIG_PM
  drm / exynos / PM: Replace CONFIG_PM_RUNTIME with CONFIG_PM
  gpio / PM: Replace CONFIG_PM_RUNTIME with CONFIG_PM
  hwrandom / exynos / PM: Use CONFIG_PM in #ifdef
  block / PM: Replace CONFIG_PM_RUNTIME with CONFIG_PM
  USB / PM: Drop CONFIG_PM_RUNTIME from the USB core
  PM: Merge the SET*_RUNTIME_PM_OPS() macros
  ...

7 files changed, 337 insertions, 207 deletions

diff --git a/drivers/gpio/devres.c b/drivers/gpio/devres.c
index 954b9f6b0ef8..13dbd3dfc33a 100644
--- a/drivers/gpio/devres.c
+++ b/drivers/gpio/devres.c
@@ -109,6 +109,38 @@ struct gpio_desc *__must_check __devm_gpiod_get_index(struct device *dev,
 EXPORT_SYMBOL(__devm_gpiod_get_index);
 
 /**
+ * devm_get_gpiod_from_child - get a GPIO descriptor from a device's child node
+ * @dev:        GPIO consumer
+ * @child:      firmware node (child of @dev)
+ *
+ * GPIO descriptors returned from this function are automatically disposed on
+ * driver detach.
+ */
+struct gpio_desc *devm_get_gpiod_from_child(struct device *dev,
+                                            struct fwnode_handle *child)
+{
+        struct gpio_desc **dr;
+        struct gpio_desc *desc;
+
+        dr = devres_alloc(devm_gpiod_release, sizeof(struct gpio_desc *),
+                          GFP_KERNEL);
+        if (!dr)
+                return ERR_PTR(-ENOMEM);
+
+        desc = fwnode_get_named_gpiod(child, "gpios");
+        if (IS_ERR(desc)) {
+                devres_free(dr);
+                return desc;
+        }
+
+        *dr = desc;
+        devres_add(dev, dr);
+
+        return desc;
+}
+EXPORT_SYMBOL(devm_get_gpiod_from_child);
+
+/**
  * devm_gpiod_get_index_optional - Resource-managed gpiod_get_index_optional()
  * @dev: GPIO consumer
  * @con_id: function within the GPIO consumer
diff --git a/drivers/gpio/gpio-omap.c b/drivers/gpio/gpio-omap.c
index 415682f69214..3d6b445665ad 100644
--- a/drivers/gpio/gpio-omap.c
+++ b/drivers/gpio/gpio-omap.c
@@ -1259,7 +1259,7 @@ static int omap_gpio_probe(struct platform_device *pdev)
 
 #ifdef CONFIG_ARCH_OMAP2PLUS
 
-#if defined(CONFIG_PM_RUNTIME)
+#if defined(CONFIG_PM)
 static void omap_gpio_restore_context(struct gpio_bank *bank);
 
 static int omap_gpio_runtime_suspend(struct device *dev)
@@ -1440,7 +1440,7 @@ static int omap_gpio_runtime_resume(struct device *dev)
 
         return 0;
 }
-#endif /* CONFIG_PM_RUNTIME */
+#endif /* CONFIG_PM */
 
 void omap2_gpio_prepare_for_idle(int pwr_mode)
 {
@@ -1468,7 +1468,7 @@ void omap2_gpio_resume_after_idle(void)
         }
 }
 
-#if defined(CONFIG_PM_RUNTIME)
+#if defined(CONFIG_PM)
 static void omap_gpio_init_context(struct gpio_bank *p)
 {
         struct omap_gpio_reg_offs *regs = p->regs;
@@ -1525,7 +1525,7 @@ static void omap_gpio_restore_context(struct gpio_bank *bank)
         writel_relaxed(bank->context.irqenable2,
                                 bank->base + bank->regs->irqenable2);
 }
-#endif /* CONFIG_PM_RUNTIME */
+#endif /* CONFIG_PM */
 #else
 #define omap_gpio_runtime_suspend NULL
 #define omap_gpio_runtime_resume NULL
diff --git a/drivers/gpio/gpio-sch.c b/drivers/gpio/gpio-sch.c
index 41e91d70301e..99720c8bc8ed 100644
--- a/drivers/gpio/gpio-sch.c
+++ b/drivers/gpio/gpio-sch.c
@@ -29,290 +29,221 @@
 
 #include <linux/gpio.h>
 
-static DEFINE_SPINLOCK(gpio_lock);
-
-#define CGEN    (0x00)
-#define CGIO    (0x04)
-#define CGLV    (0x08)
-
-#define RGEN    (0x20)
-#define RGIO    (0x24)
-#define RGLV    (0x28)
-
-static unsigned short gpio_ba;
-
-static int sch_gpio_core_direction_in(struct gpio_chip *gc, unsigned  gpio_num)
-{
-        u8 curr_dirs;
-        unsigned short offset, bit;
-
-        spin_lock(&gpio_lock);
-
-        offset = CGIO + gpio_num / 8;
-        bit = gpio_num % 8;
-
-        curr_dirs = inb(gpio_ba + offset);
-
-        if (!(curr_dirs & (1 << bit)))
-                outb(curr_dirs | (1 << bit), gpio_ba + offset);
+#define GEN     0x00
+#define GIO     0x04
+#define GLV     0x08
+
+struct sch_gpio {
+        struct gpio_chip chip;
+        spinlock_t lock;
+        unsigned short iobase;
+        unsigned short core_base;
+        unsigned short resume_base;
+};
 
-        spin_unlock(&gpio_lock);
-        return 0;
-}
+#define to_sch_gpio(c)  container_of(c, struct sch_gpio, chip)
 
-static int sch_gpio_core_get(struct gpio_chip *gc, unsigned gpio_num)
+static unsigned sch_gpio_offset(struct sch_gpio *sch, unsigned gpio,
+                                unsigned reg)
 {
-        int res;
-        unsigned short offset, bit;
+        unsigned base = 0;
 
-        offset = CGLV + gpio_num / 8;
-        bit = gpio_num % 8;
+        if (gpio >= sch->resume_base) {
+                gpio -= sch->resume_base;
+                base += 0x20;
+        }
 
-        res = !!(inb(gpio_ba + offset) & (1 << bit));
-        return res;
+        return base + reg + gpio / 8;
 }
 
-static void sch_gpio_core_set(struct gpio_chip *gc, unsigned gpio_num, int val)
+static unsigned sch_gpio_bit(struct sch_gpio *sch, unsigned gpio)
 {
-        u8 curr_vals;
-        unsigned short offset, bit;
-
-        spin_lock(&gpio_lock);
-
-        offset = CGLV + gpio_num / 8;
-        bit = gpio_num % 8;
-
-        curr_vals = inb(gpio_ba + offset);
-
-        if (val)
-                outb(curr_vals | (1 << bit), gpio_ba + offset);
-        else
-                outb((curr_vals & ~(1 << bit)), gpio_ba + offset);
-        spin_unlock(&gpio_lock);
+        if (gpio >= sch->resume_base)
+                gpio -= sch->resume_base;
+        return gpio % 8;
 }
 
-static int sch_gpio_core_direction_out(struct gpio_chip *gc,
-                                        unsigned gpio_num, int val)
+static void sch_gpio_enable(struct sch_gpio *sch, unsigned gpio)
 {
-        u8 curr_dirs;
         unsigned short offset, bit;
+        u8 enable;
 
-        spin_lock(&gpio_lock);
+        spin_lock(&sch->lock);
 
-        offset = CGIO + gpio_num / 8;
-        bit = gpio_num % 8;
-
-        curr_dirs = inb(gpio_ba + offset);
-        if (curr_dirs & (1 << bit))
-                outb(curr_dirs & ~(1 << bit), gpio_ba + offset);
+        offset = sch_gpio_offset(sch, gpio, GEN);
+        bit = sch_gpio_bit(sch, gpio);
 
-        spin_unlock(&gpio_lock);
+        enable = inb(sch->iobase + offset);
+        if (!(enable & (1 << bit)))
+                outb(enable | (1 << bit), sch->iobase + offset);
 
-        /*
-         * according to the datasheet, writing to the level register has no
-         * effect when GPIO is programmed as input.
-         * Actually the the level register is read-only when configured as input.
-         * Thus presetting the output level before switching to output is _NOT_ possible.
-         * Hence we set the level after configuring the GPIO as output.
-         * But we cannot prevent a short low pulse if direction is set to high
-         * and an external pull-up is connected.
-         */
-        sch_gpio_core_set(gc, gpio_num, val);
-        return 0;
+        spin_unlock(&sch->lock);
 }
 
-static struct gpio_chip sch_gpio_core = {
-        .label                  = "sch_gpio_core",
-        .owner                  = THIS_MODULE,
-        .direction_input        = sch_gpio_core_direction_in,
-        .get                    = sch_gpio_core_get,
-        .direction_output       = sch_gpio_core_direction_out,
-        .set                    = sch_gpio_core_set,
-};
-
-static int sch_gpio_resume_direction_in(struct gpio_chip *gc,
-                                        unsigned gpio_num)
+static int sch_gpio_direction_in(struct gpio_chip *gc, unsigned  gpio_num)
 {
+        struct sch_gpio *sch = to_sch_gpio(gc);
         u8 curr_dirs;
         unsigned short offset, bit;
 
-        spin_lock(&gpio_lock);
+        spin_lock(&sch->lock);
 
-        offset = RGIO + gpio_num / 8;
-        bit = gpio_num % 8;
+        offset = sch_gpio_offset(sch, gpio_num, GIO);
+        bit = sch_gpio_bit(sch, gpio_num);
 
-        curr_dirs = inb(gpio_ba + offset);
+        curr_dirs = inb(sch->iobase + offset);
 
         if (!(curr_dirs & (1 << bit)))
-                outb(curr_dirs | (1 << bit), gpio_ba + offset);
+                outb(curr_dirs | (1 << bit), sch->iobase + offset);
 
-        spin_unlock(&gpio_lock);
+        spin_unlock(&sch->lock);
         return 0;
 }
 
-static int sch_gpio_resume_get(struct gpio_chip *gc, unsigned gpio_num)
+static int sch_gpio_get(struct gpio_chip *gc, unsigned gpio_num)
 {
+        struct sch_gpio *sch = to_sch_gpio(gc);
+        int res;
         unsigned short offset, bit;
 
-        offset = RGLV + gpio_num / 8;
-        bit = gpio_num % 8;
+        offset = sch_gpio_offset(sch, gpio_num, GLV);
+        bit = sch_gpio_bit(sch, gpio_num);
+
+        res = !!(inb(sch->iobase + offset) & (1 << bit));
 
-        return !!(inb(gpio_ba + offset) & (1 << bit));
+        return res;
 }
 
-static void sch_gpio_resume_set(struct gpio_chip *gc,
-                                unsigned gpio_num, int val)
+static void sch_gpio_set(struct gpio_chip *gc, unsigned gpio_num, int val)
 {
+        struct sch_gpio *sch = to_sch_gpio(gc);
         u8 curr_vals;
         unsigned short offset, bit;
 
-        spin_lock(&gpio_lock);
+        spin_lock(&sch->lock);
 
-        offset = RGLV + gpio_num / 8;
-        bit = gpio_num % 8;
+        offset = sch_gpio_offset(sch, gpio_num, GLV);
+        bit = sch_gpio_bit(sch, gpio_num);
 
-        curr_vals = inb(gpio_ba + offset);
+        curr_vals = inb(sch->iobase + offset);
 
         if (val)
-                outb(curr_vals | (1 << bit), gpio_ba + offset);
+                outb(curr_vals | (1 << bit), sch->iobase + offset);
         else
-                outb((curr_vals & ~(1 << bit)), gpio_ba + offset);
+                outb((curr_vals & ~(1 << bit)), sch->iobase + offset);
 
-        spin_unlock(&gpio_lock);
+        spin_unlock(&sch->lock);
 }
 
-static int sch_gpio_resume_direction_out(struct gpio_chip *gc,
-                                        unsigned gpio_num, int val)
+static int sch_gpio_direction_out(struct gpio_chip *gc, unsigned gpio_num,
+                                  int val)
 {
+        struct sch_gpio *sch = to_sch_gpio(gc);
         u8 curr_dirs;
         unsigned short offset, bit;
 
-        offset = RGIO + gpio_num / 8;
-        bit = gpio_num % 8;
+        spin_lock(&sch->lock);
 
-        spin_lock(&gpio_lock);
+        offset = sch_gpio_offset(sch, gpio_num, GIO);
+        bit = sch_gpio_bit(sch, gpio_num);
 
-        curr_dirs = inb(gpio_ba + offset);
+        curr_dirs = inb(sch->iobase + offset);
         if (curr_dirs & (1 << bit))
-                outb(curr_dirs & ~(1 << bit), gpio_ba + offset);
+                outb(curr_dirs & ~(1 << bit), sch->iobase + offset);
 
-        spin_unlock(&gpio_lock);
+        spin_unlock(&sch->lock);
 
         /*
-        * according to the datasheet, writing to the level register has no
-        * effect when GPIO is programmed as input.
-        * Actually the the level register is read-only when configured as input.
-        * Thus presetting the output level before switching to output is _NOT_ possible.
-        * Hence we set the level after configuring the GPIO as output.
-        * But we cannot prevent a short low pulse if direction is set to high
-        * and an external pull-up is connected.
-        */
-        sch_gpio_resume_set(gc, gpio_num, val);
+         * according to the datasheet, writing to the level register has no
+         * effect when GPIO is programmed as input.
+         * Actually the the level register is read-only when configured as input.
+         * Thus presetting the output level before switching to output is _NOT_ possible.
+         * Hence we set the level after configuring the GPIO as output.
+         * But we cannot prevent a short low pulse if direction is set to high
+         * and an external pull-up is connected.
+         */
+        sch_gpio_set(gc, gpio_num, val);
         return 0;
 }
 
-static struct gpio_chip sch_gpio_resume = {
-        .label                  = "sch_gpio_resume",
+static struct gpio_chip sch_gpio_chip = {
+        .label                  = "sch_gpio",
         .owner                  = THIS_MODULE,
-        .direction_input        = sch_gpio_resume_direction_in,
-        .get                    = sch_gpio_resume_get,
-        .direction_output       = sch_gpio_resume_direction_out,
-        .set                    = sch_gpio_resume_set,
+        .direction_input        = sch_gpio_direction_in,
+        .get                    = sch_gpio_get,
+        .direction_output       = sch_gpio_direction_out,
+        .set                    = sch_gpio_set,
 };
 
 static int sch_gpio_probe(struct platform_device *pdev)
 {
+        struct sch_gpio *sch;
         struct resource *res;
-        int err, id;
 
-        id = pdev->id;
-        if (!id)
-                return -ENODEV;
+        sch = devm_kzalloc(&pdev->dev, sizeof(*sch), GFP_KERNEL);
+        if (!sch)
+                return -ENOMEM;
 
         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
         if (!res)
                 return -EBUSY;
 
-        if (!request_region(res->start, resource_size(res), pdev->name))
+        if (!devm_request_region(&pdev->dev, res->start, resource_size(res),
+                                 pdev->name))
                 return -EBUSY;
 
-        gpio_ba = res->start;
+        spin_lock_init(&sch->lock);
+        sch->iobase = res->start;
+        sch->chip = sch_gpio_chip;
+        sch->chip.label = dev_name(&pdev->dev);
+        sch->chip.dev = &pdev->dev;
 
-        switch (id) {
+        switch (pdev->id) {
         case PCI_DEVICE_ID_INTEL_SCH_LPC:
-                sch_gpio_core.base = 0;
-                sch_gpio_core.ngpio = 10;
-                sch_gpio_resume.base = 10;
-                sch_gpio_resume.ngpio = 4;
+                sch->core_base = 0;
+                sch->resume_base = 10;
+                sch->chip.ngpio = 14;
+
                 /*
                  * GPIO[6:0] enabled by default
                  * GPIO7 is configured by the CMC as SLPIOVR
                  * Enable GPIO[9:8] core powered gpios explicitly
                  */
-                outb(0x3, gpio_ba + CGEN + 1);
+                sch_gpio_enable(sch, 8);
+                sch_gpio_enable(sch, 9);
                 /*
                  * SUS_GPIO[2:0] enabled by default
                  * Enable SUS_GPIO3 resume powered gpio explicitly
                  */
-                outb(0x8, gpio_ba + RGEN);
+                sch_gpio_enable(sch, 13);
                 break;
 
         case PCI_DEVICE_ID_INTEL_ITC_LPC:
-                sch_gpio_core.base = 0;
-                sch_gpio_core.ngpio = 5;
-                sch_gpio_resume.base = 5;
-                sch_gpio_resume.ngpio = 9;
+                sch->core_base = 0;
+                sch->resume_base = 5;
+                sch->chip.ngpio = 14;
                 break;
 
         case PCI_DEVICE_ID_INTEL_CENTERTON_ILB:
-                sch_gpio_core.base = 0;
-                sch_gpio_core.ngpio = 21;
-                sch_gpio_resume.base = 21;
-                sch_gpio_resume.ngpio = 9;
+                sch->core_base = 0;
+                sch->resume_base = 21;
+                sch->chip.ngpio = 30;
                 break;
 
         default:
-                err = -ENODEV;
-                goto err_sch_gpio_core;
+                return -ENODEV;
         }
 
-        sch_gpio_core.dev = &pdev->dev;
-        sch_gpio_resume.dev = &pdev->dev;
-
-        err = gpiochip_add(&sch_gpio_core);
-        if (err < 0)
-                goto err_sch_gpio_core;
+        platform_set_drvdata(pdev, sch);
 
-        err = gpiochip_add(&sch_gpio_resume);
-        if (err < 0)
-                goto err_sch_gpio_resume;
-
-        return 0;
-
-err_sch_gpio_resume:
-        gpiochip_remove(&sch_gpio_core);
-
-err_sch_gpio_core:
-        release_region(res->start, resource_size(res));
-        gpio_ba = 0;
-
-        return err;
+        return gpiochip_add(&sch->chip);
 }
 
 static int sch_gpio_remove(struct platform_device *pdev)
 {
-        struct resource *res;
-        if (gpio_ba) {
-
-                gpiochip_remove(&sch_gpio_core);
-                gpiochip_remove(&sch_gpio_resume);
-
-                res = platform_get_resource(pdev, IORESOURCE_IO, 0);
-
-                release_region(res->start, resource_size(res));
-                gpio_ba = 0;
-        }
+        struct sch_gpio *sch = platform_get_drvdata(pdev);
 
+        gpiochip_remove(&sch->chip);
         return 0;
 }
 
diff --git a/drivers/gpio/gpio-zynq.c b/drivers/gpio/gpio-zynq.c
index 74cd480bf8de..184c4b1b2558 100644
--- a/drivers/gpio/gpio-zynq.c
+++ b/drivers/gpio/gpio-zynq.c
@@ -578,7 +578,7 @@ static void zynq_gpio_free(struct gpio_chip *chip, unsigned offset)
 
 static const struct dev_pm_ops zynq_gpio_dev_pm_ops = {
         SET_SYSTEM_SLEEP_PM_OPS(zynq_gpio_suspend, zynq_gpio_resume)
-        SET_PM_RUNTIME_PM_OPS(zynq_gpio_runtime_suspend,
+        SET_RUNTIME_PM_OPS(zynq_gpio_runtime_suspend,
                         zynq_gpio_runtime_resume, NULL)
 };
 
diff --git a/drivers/gpio/gpiolib-acpi.c b/drivers/gpio/gpiolib-acpi.c
index 05c6275da224..ba98bb59a58f 100644
--- a/drivers/gpio/gpiolib-acpi.c
+++ b/drivers/gpio/gpiolib-acpi.c
@@ -287,9 +287,45 @@ void acpi_gpiochip_free_interrupts(struct gpio_chip *chip)
         }
 }
 
+int acpi_dev_add_driver_gpios(struct acpi_device *adev,
+                              const struct acpi_gpio_mapping *gpios)
+{
+        if (adev && gpios) {
+                adev->driver_gpios = gpios;
+                return 0;
+        }
+        return -EINVAL;
+}
+EXPORT_SYMBOL_GPL(acpi_dev_add_driver_gpios);
+
+static bool acpi_get_driver_gpio_data(struct acpi_device *adev,
+                                      const char *name, int index,
+                                      struct acpi_reference_args *args)
+{
+        const struct acpi_gpio_mapping *gm;
+
+        if (!adev->driver_gpios)
+                return false;
+
+        for (gm = adev->driver_gpios; gm->name; gm++)
+                if (!strcmp(name, gm->name) && gm->data && index < gm->size) {
+                        const struct acpi_gpio_params *par = gm->data + index;
+
+                        args->adev = adev;
+                        args->args[0] = par->crs_entry_index;
+                        args->args[1] = par->line_index;
+                        args->args[2] = par->active_low;
+                        args->nargs = 3;
+                        return true;
+                }
+
+        return false;
+}
+
 struct acpi_gpio_lookup {
         struct acpi_gpio_info info;
         int index;
+        int pin_index;
         struct gpio_desc *desc;
         int n;
 };
@@ -303,13 +339,24 @@ static int acpi_find_gpio(struct acpi_resource *ares, void *data)
 
         if (lookup->n++ == lookup->index && !lookup->desc) {
                 const struct acpi_resource_gpio *agpio = &ares->data.gpio;
+                int pin_index = lookup->pin_index;
+
+                if (pin_index >= agpio->pin_table_length)
+                        return 1;
 
                 lookup->desc = acpi_get_gpiod(agpio->resource_source.string_ptr,
-                                              agpio->pin_table[0]);
+                                              agpio->pin_table[pin_index]);
                 lookup->info.gpioint =
                         agpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT;
-                lookup->info.active_low =
-                        agpio->polarity == ACPI_ACTIVE_LOW;
+
+                /*
+                 * ActiveLow is only specified for GpioInt resource. If
+                 * GpioIo is used then the only way to set the flag is
+                 * to use _DSD "gpios" property.
+                 */
+                if (lookup->info.gpioint)
+                        lookup->info.active_low =
+                                agpio->polarity == ACPI_ACTIVE_LOW;
         }
 
         return 1;
@@ -317,40 +364,79 @@ static int acpi_find_gpio(struct acpi_resource *ares, void *data)
 
 /**
  * acpi_get_gpiod_by_index() - get a GPIO descriptor from device resources
- * @dev: pointer to a device to get GPIO from
+ * @adev: pointer to a ACPI device to get GPIO from
+ * @propname: Property name of the GPIO (optional)
  * @index: index of GpioIo/GpioInt resource (starting from %0)
  * @info: info pointer to fill in (optional)
  *
- * Function goes through ACPI resources for @dev and based on @index looks
+ * Function goes through ACPI resources for @adev and based on @index looks
  * up a GpioIo/GpioInt resource, translates it to the Linux GPIO descriptor,
  * and returns it. @index matches GpioIo/GpioInt resources only so if there
  * are total %3 GPIO resources, the index goes from %0 to %2.
  *
+ * If @propname is specified the GPIO is looked using device property. In
+ * that case @index is used to select the GPIO entry in the property value
+ * (in case of multiple).
+ *
  * If the GPIO cannot be translated or there is an error an ERR_PTR is
  * returned.
  *
  * Note: if the GPIO resource has multiple entries in the pin list, this
  * function only returns the first.
  */
-struct gpio_desc *acpi_get_gpiod_by_index(struct device *dev, int index,
+struct gpio_desc *acpi_get_gpiod_by_index(struct acpi_device *adev,
+                                          const char *propname, int index,
                                           struct acpi_gpio_info *info)
 {
         struct acpi_gpio_lookup lookup;
         struct list_head resource_list;
-        struct acpi_device *adev;
-        acpi_handle handle;
+        bool active_low = false;
         int ret;
 
-        if (!dev)
-                return ERR_PTR(-EINVAL);
-
-        handle = ACPI_HANDLE(dev);
-        if (!handle || acpi_bus_get_device(handle, &adev))
+        if (!adev)
                 return ERR_PTR(-ENODEV);
 
         memset(&lookup, 0, sizeof(lookup));
         lookup.index = index;
 
+        if (propname) {
+                struct acpi_reference_args args;
+
+                dev_dbg(&adev->dev, "GPIO: looking up %s\n", propname);
+
+                memset(&args, 0, sizeof(args));
+                ret = acpi_dev_get_property_reference(adev, propname,
+                                                      index, &args);
+                if (ret) {
+                        bool found = acpi_get_driver_gpio_data(adev, propname,
+                                                               index, &args);
+                        if (!found)
+                                return ERR_PTR(ret);
+                }
+
+                /*
+                 * The property was found and resolved so need to
+                 * lookup the GPIO based on returned args instead.
+                 */
+                adev = args.adev;
+                if (args.nargs >= 2) {
+                        lookup.index = args.args[0];
+                        lookup.pin_index = args.args[1];
+                        /*
+                         * 3rd argument, if present is used to
+                         * specify active_low.
+                         */
+                        if (args.nargs >= 3)
+                                active_low = !!args.args[2];
+                }
+
+                dev_dbg(&adev->dev, "GPIO: _DSD returned %s %zd %llu %llu %llu\n",
+                        dev_name(&adev->dev), args.nargs,
+                        args.args[0], args.args[1], args.args[2]);
+        } else {
+                dev_dbg(&adev->dev, "GPIO: looking up %d in _CRS\n", index);
+        }
+
         INIT_LIST_HEAD(&resource_list);
         ret = acpi_dev_get_resources(adev, &resource_list, acpi_find_gpio,
                                      &lookup);
@@ -359,8 +445,11 @@ struct gpio_desc *acpi_get_gpiod_by_index(struct device *dev, int index,
 
         acpi_dev_free_resource_list(&resource_list);
 
-        if (lookup.desc && info)
+        if (lookup.desc && info) {
                 *info = lookup.info;
+                if (active_low)
+                        info->active_low = active_low;
+        }
 
         return lookup.desc ? lookup.desc : ERR_PTR(-ENOENT);
 }
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index e8e98ca25ec7..58659dbe702a 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -1505,14 +1505,36 @@ static struct gpio_desc *acpi_find_gpio(struct device *dev, const char *con_id,
                                         unsigned int idx,
                                         enum gpio_lookup_flags *flags)
 {
+        static const char * const suffixes[] = { "gpios", "gpio" };
+        struct acpi_device *adev = ACPI_COMPANION(dev);
         struct acpi_gpio_info info;
         struct gpio_desc *desc;
+        char propname[32];
+        int i;
 
-        desc = acpi_get_gpiod_by_index(dev, idx, &info);
-        if (IS_ERR(desc))
-                return desc;
+        /* Try first from _DSD */
+        for (i = 0; i < ARRAY_SIZE(suffixes); i++) {
+                if (con_id && strcmp(con_id, "gpios")) {
+                        snprintf(propname, sizeof(propname), "%s-%s",
+                                 con_id, suffixes[i]);
+                } else {
+                        snprintf(propname, sizeof(propname), "%s",
+                                 suffixes[i]);
+                }
+
+                desc = acpi_get_gpiod_by_index(adev, propname, idx, &info);
+                if (!IS_ERR(desc) || (PTR_ERR(desc) == -EPROBE_DEFER))
+                        break;
+        }
 
-        if (info.gpioint && info.active_low)
+        /* Then from plain _CRS GPIOs */
+        if (IS_ERR(desc)) {
+                desc = acpi_get_gpiod_by_index(adev, NULL, idx, &info);
+                if (IS_ERR(desc))
+                        return desc;
+        }
+
+        if (info.active_low)
                 *flags |= GPIO_ACTIVE_LOW;
 
         return desc;
@@ -1713,6 +1735,61 @@ struct gpio_desc *__must_check __gpiod_get_index(struct device *dev,
 EXPORT_SYMBOL_GPL(__gpiod_get_index);
 
 /**
+ * fwnode_get_named_gpiod - obtain a GPIO from firmware node
+ * @fwnode:     handle of the firmware node
+ * @propname:   name of the firmware property representing the GPIO
+ *
+ * This function can be used for drivers that get their configuration
+ * from firmware.
+ *
+ * Function properly finds the corresponding GPIO using whatever is the
+ * underlying firmware interface and then makes sure that the GPIO
+ * descriptor is requested before it is returned to the caller.
+ *
+ * In case of error an ERR_PTR() is returned.
+ */
+struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
+                                         const char *propname)
+{
+        struct gpio_desc *desc = ERR_PTR(-ENODEV);
+        bool active_low = false;
+        int ret;
+
+        if (!fwnode)
+                return ERR_PTR(-EINVAL);
+
+        if (is_of_node(fwnode)) {
+                enum of_gpio_flags flags;
+
+                desc = of_get_named_gpiod_flags(of_node(fwnode), propname, 0,
+                                                &flags);
+                if (!IS_ERR(desc))
+                        active_low = flags & OF_GPIO_ACTIVE_LOW;
+        } else if (is_acpi_node(fwnode)) {
+                struct acpi_gpio_info info;
+
+                desc = acpi_get_gpiod_by_index(acpi_node(fwnode), propname, 0,
+                                               &info);
+                if (!IS_ERR(desc))
+                        active_low = info.active_low;
+        }
+
+        if (IS_ERR(desc))
+                return desc;
+
+        ret = gpiod_request(desc, NULL);
+        if (ret)
+                return ERR_PTR(ret);
+
+        /* Only value flag can be set from both DT and ACPI is active_low */
+        if (active_low)
+                set_bit(FLAG_ACTIVE_LOW, &desc->flags);
+
+        return desc;
+}
+EXPORT_SYMBOL_GPL(fwnode_get_named_gpiod);
+
+/**
  * gpiod_get_index_optional - obtain an optional GPIO from a multi-index GPIO
  *                            function
  * @dev: GPIO consumer, can be NULL for system-global GPIOs
diff --git a/drivers/gpio/gpiolib.h b/drivers/gpio/gpiolib.h
index 9db2b6a71c5d..e3a52113a541 100644
--- a/drivers/gpio/gpiolib.h
+++ b/drivers/gpio/gpiolib.h
@@ -34,7 +34,8 @@ void acpi_gpiochip_remove(struct gpio_chip *chip);
 void acpi_gpiochip_request_interrupts(struct gpio_chip *chip);
 void acpi_gpiochip_free_interrupts(struct gpio_chip *chip);
 
-struct gpio_desc *acpi_get_gpiod_by_index(struct device *dev, int index,
+struct gpio_desc *acpi_get_gpiod_by_index(struct acpi_device *adev,
+                                          const char *propname, int index,
                                           struct acpi_gpio_info *info);
 #else
 static inline void acpi_gpiochip_add(struct gpio_chip *chip) { }
@@ -47,8 +48,8 @@ static inline void
 acpi_gpiochip_free_interrupts(struct gpio_chip *chip) { }
 
 static inline struct gpio_desc *
-acpi_get_gpiod_by_index(struct device *dev, int index,
-                        struct acpi_gpio_info *info)
+acpi_get_gpiod_by_index(struct acpi_device *adev, const char *propname,
+                        int index, struct acpi_gpio_info *info)
 {
         return ERR_PTR(-ENOSYS);
 }