pinctrl: intel: Add Intel Sunrisepoint pin controller and GPIO support

This driver supports pinctrl/GPIO hardware found on Intel Sunrisepoint (a
Skylake PCH) providing users a pinctrl and GPIO interfaces (including GPIO
interrupts).

The driver is split into core and platform parts so that the same core
driver can be reused in other drivers for other Intel GPIO hardware that is
based on the same host controller design.

Signed-off-by: Mathias Nyman <mathias.nyman@linux.intel.com>
Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>

5 files changed, 1632 insertions, 0 deletions

diff --git a/drivers/pinctrl/intel/Kconfig b/drivers/pinctrl/intel/Kconfig
index b801d869e91c..fe5e07db0a95 100644
--- a/drivers/pinctrl/intel/Kconfig
+++ b/drivers/pinctrl/intel/Kconfig
@@ -25,3 +25,20 @@ config PINCTRL_CHERRYVIEW
         help
           Cherryview/Braswell pinctrl driver provides an interface that
           allows configuring of SoC pins and using them as GPIOs.
+
+config PINCTRL_INTEL
+        tristate
+        select PINMUX
+        select PINCONF
+        select GENERIC_PINCONF
+        select GPIOLIB
+        select GPIOLIB_IRQCHIP
+
+config PINCTRL_SUNRISEPOINT
+        tristate "Intel Sunrisepoint pinctrl and GPIO driver"
+        depends on ACPI
+        select PINCTRL_INTEL
+        help
+          Sunrisepoint is the PCH of Intel Skylake. This pinctrl driver
+          provides an interface that allows configuring of PCH pins and
+          using them as GPIOs.
diff --git a/drivers/pinctrl/intel/Makefile b/drivers/pinctrl/intel/Makefile
index 4c210e4139e2..fee756e1255b 100644
--- a/drivers/pinctrl/intel/Makefile
+++ b/drivers/pinctrl/intel/Makefile
@@ -2,3 +2,5 @@
 
 obj-$(CONFIG_PINCTRL_BAYTRAIL)          += pinctrl-baytrail.o
 obj-$(CONFIG_PINCTRL_CHERRYVIEW)        += pinctrl-cherryview.o
+obj-$(CONFIG_PINCTRL_INTEL)             += pinctrl-intel.o
+obj-$(CONFIG_PINCTRL_SUNRISEPOINT)      += pinctrl-sunrisepoint.o
diff --git a/drivers/pinctrl/intel/pinctrl-intel.c b/drivers/pinctrl/intel/pinctrl-intel.c
new file mode 100644
index 000000000000..00768e53deec
--- /dev/null
+++ b/drivers/pinctrl/intel/pinctrl-intel.c
@@ -0,0 +1,1149 @@
+/*
+ * Intel pinctrl/GPIO core driver.
+ *
+ * Copyright (C) 2015, Intel Corporation
+ * Authors: Mathias Nyman <mathias.nyman@linux.intel.com>
+ *          Mika Westerberg <mika.westerberg@linux.intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/acpi.h>
+#include <linux/gpio.h>
+#include <linux/gpio/driver.h>
+#include <linux/platform_device.h>
+#include <linux/pm.h>
+#include <linux/pinctrl/pinctrl.h>
+#include <linux/pinctrl/pinmux.h>
+#include <linux/pinctrl/pinconf.h>
+#include <linux/pinctrl/pinconf-generic.h>
+
+#include "pinctrl-intel.h"
+
+/* Maximum number of pads in each group */
+#define NPADS_IN_GPP                    24
+
+/* Offset from regs */
+#define PADBAR                          0x00c
+#define GPI_IS                          0x100
+#define GPI_GPE_STS                     0x140
+#define GPI_GPE_EN                      0x160
+
+#define PADOWN_BITS                     4
+#define PADOWN_SHIFT(p)                 ((p) % 8 * PADOWN_BITS)
+#define PADOWN_MASK(p)                  (0xf << PADOWN_SHIFT(p))
+
+/* Offset from pad_regs */
+#define PADCFG0                         0x000
+#define PADCFG0_RXEVCFG_SHIFT           25
+#define PADCFG0_RXEVCFG_MASK            (3 << PADCFG0_RXEVCFG_SHIFT)
+#define PADCFG0_RXEVCFG_LEVEL           0
+#define PADCFG0_RXEVCFG_EDGE            1
+#define PADCFG0_RXEVCFG_DISABLED        2
+#define PADCFG0_RXEVCFG_EDGE_BOTH       3
+#define PADCFG0_RXINV                   BIT(23)
+#define PADCFG0_GPIROUTIOXAPIC          BIT(20)
+#define PADCFG0_GPIROUTSCI              BIT(19)
+#define PADCFG0_GPIROUTSMI              BIT(18)
+#define PADCFG0_GPIROUTNMI              BIT(17)
+#define PADCFG0_PMODE_SHIFT             10
+#define PADCFG0_PMODE_MASK              (0xf << PADCFG0_PMODE_SHIFT)
+#define PADCFG0_GPIORXDIS               BIT(9)
+#define PADCFG0_GPIOTXDIS               BIT(8)
+#define PADCFG0_GPIORXSTATE             BIT(1)
+#define PADCFG0_GPIOTXSTATE             BIT(0)
+
+#define PADCFG1                         0x004
+#define PADCFG1_TERM_UP                 BIT(13)
+#define PADCFG1_TERM_SHIFT              10
+#define PADCFG1_TERM_MASK               (7 << PADCFG1_TERM_SHIFT)
+#define PADCFG1_TERM_20K                4
+#define PADCFG1_TERM_2K                 3
+#define PADCFG1_TERM_5K                 2
+#define PADCFG1_TERM_1K                 1
+
+struct intel_pad_context {
+        u32 padcfg0;
+        u32 padcfg1;
+};
+
+struct intel_community_context {
+        u32 *intmask;
+};
+
+struct intel_pinctrl_context {
+        struct intel_pad_context *pads;
+        struct intel_community_context *communities;
+};
+
+/**
+ * struct intel_pinctrl - Intel pinctrl private structure
+ * @dev: Pointer to the device structure
+ * @lock: Lock to serialize register access
+ * @pctldesc: Pin controller description
+ * @pctldev: Pointer to the pin controller device
+ * @chip: GPIO chip in this pin controller
+ * @soc: SoC/PCH specific pin configuration data
+ * @communities: All communities in this pin controller
+ * @ncommunities: Number of communities in this pin controller
+ * @context: Configuration saved over system sleep
+ */
+struct intel_pinctrl {
+        struct device *dev;
+        spinlock_t lock;
+        struct pinctrl_desc pctldesc;
+        struct pinctrl_dev *pctldev;
+        struct gpio_chip chip;
+        const struct intel_pinctrl_soc_data *soc;
+        struct intel_community *communities;
+        size_t ncommunities;
+        struct intel_pinctrl_context context;
+};
+
+#define gpiochip_to_pinctrl(c)  container_of(c, struct intel_pinctrl, chip)
+#define pin_to_padno(c, p)      ((p) - (c)->pin_base)
+
+static struct intel_community *intel_get_community(struct intel_pinctrl *pctrl,
+                                                   unsigned pin)
+{
+        struct intel_community *community;
+        int i;
+
+        for (i = 0; i < pctrl->ncommunities; i++) {
+                community = &pctrl->communities[i];
+                if (pin >= community->pin_base &&
+                    pin < community->pin_base + community->npins)
+                        return community;
+        }
+
+        dev_warn(pctrl->dev, "failed to find community for pin %u\n", pin);
+        return NULL;
+}
+
+static void __iomem *intel_get_padcfg(struct intel_pinctrl *pctrl, unsigned pin,
+                                      unsigned reg)
+{
+        const struct intel_community *community;
+        unsigned padno;
+
+        community = intel_get_community(pctrl, pin);
+        if (!community)
+                return NULL;
+
+        padno = pin_to_padno(community, pin);
+        return community->pad_regs + reg + padno * 8;
+}
+
+static bool intel_pad_owned_by_host(struct intel_pinctrl *pctrl, unsigned pin)
+{
+        const struct intel_community *community;
+        unsigned padno, gpp, gpp_offset, offset;
+        void __iomem *padown;
+
+        community = intel_get_community(pctrl, pin);
+        if (!community)
+                return false;
+        if (!community->padown_offset)
+                return true;
+
+        padno = pin_to_padno(community, pin);
+        gpp = padno / NPADS_IN_GPP;
+        gpp_offset = padno % NPADS_IN_GPP;
+        offset = community->padown_offset + gpp * 16 + (gpp_offset / 8) * 4;
+        padown = community->regs + offset;
+
+        return !(readl(padown) & PADOWN_MASK(padno));
+}
+
+static bool intel_pad_reserved_for_acpi(struct intel_pinctrl *pctrl,
+                                        unsigned pin)
+{
+        const struct intel_community *community;
+        unsigned padno, gpp, offset;
+        void __iomem *hostown;
+
+        community = intel_get_community(pctrl, pin);
+        if (!community)
+                return true;
+        if (!community->hostown_offset)
+                return false;
+
+        padno = pin_to_padno(community, pin);
+        gpp = padno / NPADS_IN_GPP;
+        offset = community->hostown_offset + gpp * 4;
+        hostown = community->regs + offset;
+
+        return !(readl(hostown) & BIT(padno % NPADS_IN_GPP));
+}
+
+static bool intel_pad_locked(struct intel_pinctrl *pctrl, unsigned pin)
+{
+        struct intel_community *community;
+        unsigned padno, gpp, offset;
+        u32 value;
+
+        community = intel_get_community(pctrl, pin);
+        if (!community)
+                return true;
+        if (!community->padcfglock_offset)
+                return false;
+
+        padno = pin_to_padno(community, pin);
+        gpp = padno / NPADS_IN_GPP;
+
+        /*
+         * If PADCFGLOCK and PADCFGLOCKTX bits are both clear for this pad,
+         * the pad is considered unlocked. Any other case means that it is
+         * either fully or partially locked and we don't touch it.
+         */
+        offset = community->padcfglock_offset + gpp * 8;
+        value = readl(community->regs + offset);
+        if (value & BIT(pin % NPADS_IN_GPP))
+                return true;
+
+        offset = community->padcfglock_offset + 4 + gpp * 8;
+        value = readl(community->regs + offset);
+        if (value & BIT(pin % NPADS_IN_GPP))
+                return true;
+
+        return false;
+}
+
+static bool intel_pad_usable(struct intel_pinctrl *pctrl, unsigned pin)
+{
+        return intel_pad_owned_by_host(pctrl, pin) &&
+                !intel_pad_reserved_for_acpi(pctrl, pin) &&
+                !intel_pad_locked(pctrl, pin);
+}
+
+static int intel_get_groups_count(struct pinctrl_dev *pctldev)
+{
+        struct intel_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+
+        return pctrl->soc->ngroups;
+}
+
+static const char *intel_get_group_name(struct pinctrl_dev *pctldev,
+                                      unsigned group)
+{
+        struct intel_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+
+        return pctrl->soc->groups[group].name;
+}
+
+static int intel_get_group_pins(struct pinctrl_dev *pctldev, unsigned group,
+                              const unsigned **pins, unsigned *npins)
+{
+        struct intel_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+
+        *pins = pctrl->soc->groups[group].pins;
+        *npins = pctrl->soc->groups[group].npins;
+        return 0;
+}
+
+static void intel_pin_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s,
+                               unsigned pin)
+{
+        struct intel_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        u32 cfg0, cfg1, mode;
+        bool locked, acpi;
+
+        if (!intel_pad_owned_by_host(pctrl, pin)) {
+                seq_puts(s, "not available");
+                return;
+        }
+
+        cfg0 = readl(intel_get_padcfg(pctrl, pin, PADCFG0));
+        cfg1 = readl(intel_get_padcfg(pctrl, pin, PADCFG1));
+
+        mode = (cfg0 & PADCFG0_PMODE_MASK) >> PADCFG0_PMODE_SHIFT;
+        if (!mode)
+                seq_puts(s, "GPIO ");
+        else
+                seq_printf(s, "mode %d ", mode);
+
+        seq_printf(s, "0x%08x 0x%08x", cfg0, cfg1);
+
+        locked = intel_pad_locked(pctrl, pin);
+        acpi = intel_pad_reserved_for_acpi(pctrl, pin);
+
+        if (locked || acpi) {
+                seq_puts(s, " [");
+                if (locked) {
+                        seq_puts(s, "LOCKED");
+                        if (acpi)
+                                seq_puts(s, ", ");
+                }
+                if (acpi)
+                        seq_puts(s, "ACPI");
+                seq_puts(s, "]");
+        }
+}
+
+static const struct pinctrl_ops intel_pinctrl_ops = {
+        .get_groups_count = intel_get_groups_count,
+        .get_group_name = intel_get_group_name,
+        .get_group_pins = intel_get_group_pins,
+        .pin_dbg_show = intel_pin_dbg_show,
+};
+
+static int intel_get_functions_count(struct pinctrl_dev *pctldev)
+{
+        struct intel_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+
+        return pctrl->soc->nfunctions;
+}
+
+static const char *intel_get_function_name(struct pinctrl_dev *pctldev,
+                                           unsigned function)
+{
+        struct intel_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+
+        return pctrl->soc->functions[function].name;
+}
+
+static int intel_get_function_groups(struct pinctrl_dev *pctldev,
+                                     unsigned function,
+                                     const char * const **groups,
+                                     unsigned * const ngroups)
+{
+        struct intel_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+
+        *groups = pctrl->soc->functions[function].groups;
+        *ngroups = pctrl->soc->functions[function].ngroups;
+        return 0;
+}
+
+static int intel_pinmux_set_mux(struct pinctrl_dev *pctldev, unsigned function,
+                                unsigned group)
+{
+        struct intel_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        const struct intel_pingroup *grp = &pctrl->soc->groups[group];
+        unsigned long flags;
+        int i;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        /*
+         * All pins in the groups needs to be accessible and writable
+         * before we can enable the mux for this group.
+         */
+        for (i = 0; i < grp->npins; i++) {
+                if (!intel_pad_usable(pctrl, grp->pins[i])) {
+                        spin_unlock_irqrestore(&pctrl->lock, flags);
+                        return -EBUSY;
+                }
+        }
+
+        /* Now enable the mux setting for each pin in the group */
+        for (i = 0; i < grp->npins; i++) {
+                void __iomem *padcfg0;
+                u32 value;
+
+                padcfg0 = intel_get_padcfg(pctrl, grp->pins[i], PADCFG0);
+                value = readl(padcfg0);
+
+                value &= ~PADCFG0_PMODE_MASK;
+                value |= grp->mode << PADCFG0_PMODE_SHIFT;
+
+                writel(value, padcfg0);
+        }
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+
+        return 0;
+}
+
+static int intel_gpio_request_enable(struct pinctrl_dev *pctldev,
+                                     struct pinctrl_gpio_range *range,
+                                     unsigned pin)
+{
+        struct intel_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        void __iomem *padcfg0;
+        unsigned long flags;
+        u32 value;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        if (!intel_pad_usable(pctrl, pin)) {
+                spin_unlock_irqrestore(&pctrl->lock, flags);
+                return -EBUSY;
+        }
+
+        padcfg0 = intel_get_padcfg(pctrl, pin, PADCFG0);
+        /* Put the pad into GPIO mode */
+        value = readl(padcfg0) & ~PADCFG0_PMODE_MASK;
+        /* Disable SCI/SMI/NMI generation */
+        value &= ~(PADCFG0_GPIROUTIOXAPIC | PADCFG0_GPIROUTSCI);
+        value &= ~(PADCFG0_GPIROUTSMI | PADCFG0_GPIROUTNMI);
+        /* Disable TX buffer and enable RX (this will be input) */
+        value &= ~PADCFG0_GPIORXDIS;
+        value |= PADCFG0_GPIOTXDIS;
+        writel(value, padcfg0);
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+
+        return 0;
+}
+
+static int intel_gpio_set_direction(struct pinctrl_dev *pctldev,
+                                    struct pinctrl_gpio_range *range,
+                                    unsigned pin, bool input)
+{
+        struct intel_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        void __iomem *padcfg0;
+        unsigned long flags;
+        u32 value;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        padcfg0 = intel_get_padcfg(pctrl, pin, PADCFG0);
+
+        value = readl(padcfg0);
+        if (input)
+                value |= PADCFG0_GPIOTXDIS;
+        else
+                value &= ~PADCFG0_GPIOTXDIS;
+        writel(value, padcfg0);
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+
+        return 0;
+}
+
+static const struct pinmux_ops intel_pinmux_ops = {
+        .get_functions_count = intel_get_functions_count,
+        .get_function_name = intel_get_function_name,
+        .get_function_groups = intel_get_function_groups,
+        .set_mux = intel_pinmux_set_mux,
+        .gpio_request_enable = intel_gpio_request_enable,
+        .gpio_set_direction = intel_gpio_set_direction,
+};
+
+static int intel_config_get(struct pinctrl_dev *pctldev, unsigned pin,
+                            unsigned long *config)
+{
+        struct intel_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        enum pin_config_param param = pinconf_to_config_param(*config);
+        u32 value, term;
+        u16 arg = 0;
+
+        if (!intel_pad_owned_by_host(pctrl, pin))
+                return -ENOTSUPP;
+
+        value = readl(intel_get_padcfg(pctrl, pin, PADCFG1));
+        term = (value & PADCFG1_TERM_MASK) >> PADCFG1_TERM_SHIFT;
+
+        switch (param) {
+        case PIN_CONFIG_BIAS_DISABLE:
+                if (term)
+                        return -EINVAL;
+                break;
+
+        case PIN_CONFIG_BIAS_PULL_UP:
+                if (!term || !(value & PADCFG1_TERM_UP))
+                        return -EINVAL;
+
+                switch (term) {
+                case PADCFG1_TERM_1K:
+                        arg = 1000;
+                        break;
+                case PADCFG1_TERM_2K:
+                        arg = 2000;
+                        break;
+                case PADCFG1_TERM_5K:
+                        arg = 5000;
+                        break;
+                case PADCFG1_TERM_20K:
+                        arg = 20000;
+                        break;
+                }
+
+                break;
+
+        case PIN_CONFIG_BIAS_PULL_DOWN:
+                if (!term || value & PADCFG1_TERM_UP)
+                        return -EINVAL;
+
+                switch (term) {
+                case PADCFG1_TERM_5K:
+                        arg = 5000;
+                        break;
+                case PADCFG1_TERM_20K:
+                        arg = 20000;
+                        break;
+                }
+
+                break;
+
+        default:
+                return -ENOTSUPP;
+        }
+
+        *config = pinconf_to_config_packed(param, arg);
+        return 0;
+}
+
+static int intel_config_set_pull(struct intel_pinctrl *pctrl, unsigned pin,
+                                 unsigned long config)
+{
+        unsigned param = pinconf_to_config_param(config);
+        unsigned arg = pinconf_to_config_argument(config);
+        void __iomem *padcfg1;
+        unsigned long flags;
+        int ret = 0;
+        u32 value;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        padcfg1 = intel_get_padcfg(pctrl, pin, PADCFG1);
+        value = readl(padcfg1);
+
+        switch (param) {
+        case PIN_CONFIG_BIAS_DISABLE:
+                value &= ~(PADCFG1_TERM_MASK | PADCFG1_TERM_UP);
+                break;
+
+        case PIN_CONFIG_BIAS_PULL_UP:
+                value &= ~PADCFG1_TERM_MASK;
+
+                value |= PADCFG1_TERM_UP;
+
+                switch (arg) {
+                case 20000:
+                        value |= PADCFG1_TERM_20K << PADCFG1_TERM_SHIFT;
+                        break;
+                case 5000:
+                        value |= PADCFG1_TERM_5K << PADCFG1_TERM_SHIFT;
+                        break;
+                case 2000:
+                        value |= PADCFG1_TERM_2K << PADCFG1_TERM_SHIFT;
+                        break;
+                case 1000:
+                        value |= PADCFG1_TERM_1K << PADCFG1_TERM_SHIFT;
+                        break;
+                default:
+                        ret = -EINVAL;
+                }
+
+                break;
+
+        case PIN_CONFIG_BIAS_PULL_DOWN:
+                value &= ~(PADCFG1_TERM_UP | PADCFG1_TERM_MASK);
+
+                switch (arg) {
+                case 20000:
+                        value |= PADCFG1_TERM_20K << PADCFG1_TERM_SHIFT;
+                        break;
+                case 5000:
+                        value |= PADCFG1_TERM_5K << PADCFG1_TERM_SHIFT;
+                        break;
+                default:
+                        ret = -EINVAL;
+                }
+
+                break;
+        }
+
+        if (!ret)
+                writel(value, padcfg1);
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+
+        return ret;
+}
+
+static int intel_config_set(struct pinctrl_dev *pctldev, unsigned pin,
+                          unsigned long *configs, unsigned nconfigs)
+{
+        struct intel_pinctrl *pctrl = pinctrl_dev_get_drvdata(pctldev);
+        int i, ret;
+
+        if (!intel_pad_usable(pctrl, pin))
+                return -ENOTSUPP;
+
+        for (i = 0; i < nconfigs; i++) {
+                switch (pinconf_to_config_param(configs[i])) {
+                case PIN_CONFIG_BIAS_DISABLE:
+                case PIN_CONFIG_BIAS_PULL_UP:
+                case PIN_CONFIG_BIAS_PULL_DOWN:
+                        ret = intel_config_set_pull(pctrl, pin, configs[i]);
+                        if (ret)
+                                return ret;
+                        break;
+
+                default:
+                        return -ENOTSUPP;
+                }
+        }
+
+        return 0;
+}
+
+static const struct pinconf_ops intel_pinconf_ops = {
+        .is_generic = true,
+        .pin_config_get = intel_config_get,
+        .pin_config_set = intel_config_set,
+};
+
+static const struct pinctrl_desc intel_pinctrl_desc = {
+        .pctlops = &intel_pinctrl_ops,
+        .pmxops = &intel_pinmux_ops,
+        .confops = &intel_pinconf_ops,
+        .owner = THIS_MODULE,
+};
+
+static int intel_gpio_request(struct gpio_chip *chip, unsigned offset)
+{
+        return pinctrl_request_gpio(chip->base + offset);
+}
+
+static void intel_gpio_free(struct gpio_chip *chip, unsigned offset)
+{
+        pinctrl_free_gpio(chip->base + offset);
+}
+
+static int intel_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        struct intel_pinctrl *pctrl = gpiochip_to_pinctrl(chip);
+        void __iomem *reg;
+
+        reg = intel_get_padcfg(pctrl, offset, PADCFG0);
+        if (!reg)
+                return -EINVAL;
+
+        return !!(readl(reg) & PADCFG0_GPIORXSTATE);
+}
+
+static void intel_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        struct intel_pinctrl *pctrl = gpiochip_to_pinctrl(chip);
+        void __iomem *reg;
+
+        reg = intel_get_padcfg(pctrl, offset, PADCFG0);
+        if (reg) {
+                unsigned long flags;
+                u32 padcfg0;
+
+                spin_lock_irqsave(&pctrl->lock, flags);
+                padcfg0 = readl(reg);
+                if (value)
+                        padcfg0 |= PADCFG0_GPIOTXSTATE;
+                else
+                        padcfg0 &= ~PADCFG0_GPIOTXSTATE;
+                writel(padcfg0, reg);
+                spin_unlock_irqrestore(&pctrl->lock, flags);
+        }
+}
+
+static int intel_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        return pinctrl_gpio_direction_input(chip->base + offset);
+}
+
+static int intel_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
+                                       int value)
+{
+        intel_gpio_set(chip, offset, value);
+        return pinctrl_gpio_direction_output(chip->base + offset);
+}
+
+static const struct gpio_chip intel_gpio_chip = {
+        .owner = THIS_MODULE,
+        .request = intel_gpio_request,
+        .free = intel_gpio_free,
+        .direction_input = intel_gpio_direction_input,
+        .direction_output = intel_gpio_direction_output,
+        .get = intel_gpio_get,
+        .set = intel_gpio_set,
+};
+
+static void intel_gpio_irq_ack(struct irq_data *d)
+{
+        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+        struct intel_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        const struct intel_community *community;
+        unsigned pin = irqd_to_hwirq(d);
+
+        spin_lock(&pctrl->lock);
+
+        community = intel_get_community(pctrl, pin);
+        if (community) {
+                unsigned padno = pin_to_padno(community, pin);
+                unsigned gpp_offset = padno % NPADS_IN_GPP;
+                unsigned gpp = padno / NPADS_IN_GPP;
+
+                writel(BIT(gpp_offset), community->regs + GPI_IS + gpp * 4);
+        }
+
+        spin_unlock(&pctrl->lock);
+}
+
+static void intel_gpio_irq_mask_unmask(struct irq_data *d, bool mask)
+{
+        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+        struct intel_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        const struct intel_community *community;
+        unsigned pin = irqd_to_hwirq(d);
+        unsigned long flags;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        community = intel_get_community(pctrl, pin);
+        if (community) {
+                unsigned padno = pin_to_padno(community, pin);
+                unsigned gpp_offset = padno % NPADS_IN_GPP;
+                unsigned gpp = padno / NPADS_IN_GPP;
+                void __iomem *reg;
+                u32 value;
+
+                reg = community->regs + community->ie_offset + gpp * 4;
+                value = readl(reg);
+                if (mask)
+                        value &= ~BIT(gpp_offset);
+                else
+                        value |= BIT(gpp_offset);
+                writel(value, reg);
+        }
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+}
+
+static void intel_gpio_irq_mask(struct irq_data *d)
+{
+        intel_gpio_irq_mask_unmask(d, true);
+}
+
+static void intel_gpio_irq_unmask(struct irq_data *d)
+{
+        intel_gpio_irq_mask_unmask(d, false);
+}
+
+static int intel_gpio_irq_type(struct irq_data *d, unsigned type)
+{
+        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+        struct intel_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        unsigned pin = irqd_to_hwirq(d);
+        unsigned long flags;
+        void __iomem *reg;
+        u32 value;
+
+        reg = intel_get_padcfg(pctrl, pin, PADCFG0);
+        if (!reg)
+                return -EINVAL;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        value = readl(reg);
+
+        value &= ~(PADCFG0_RXEVCFG_MASK | PADCFG0_RXINV);
+
+        if ((type & IRQ_TYPE_EDGE_BOTH) == IRQ_TYPE_EDGE_BOTH) {
+                value |= PADCFG0_RXEVCFG_EDGE_BOTH << PADCFG0_RXEVCFG_SHIFT;
+        } else if (type & IRQ_TYPE_EDGE_FALLING) {
+                value |= PADCFG0_RXEVCFG_EDGE << PADCFG0_RXEVCFG_SHIFT;
+                value |= PADCFG0_RXINV;
+        } else if (type & IRQ_TYPE_EDGE_RISING) {
+                value |= PADCFG0_RXEVCFG_EDGE << PADCFG0_RXEVCFG_SHIFT;
+        } else if (type & IRQ_TYPE_LEVEL_LOW) {
+                value |= PADCFG0_RXINV;
+        } else {
+                value |= PADCFG0_RXEVCFG_DISABLED << PADCFG0_RXEVCFG_SHIFT;
+        }
+
+        writel(value, reg);
+
+        if (type & IRQ_TYPE_EDGE_BOTH)
+                __irq_set_handler_locked(d->irq, handle_edge_irq);
+        else if (type & IRQ_TYPE_LEVEL_MASK)
+                __irq_set_handler_locked(d->irq, handle_level_irq);
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+
+        return 0;
+}
+
+static int intel_gpio_irq_wake(struct irq_data *d, unsigned int on)
+{
+        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+        struct intel_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        const struct intel_community *community;
+        unsigned pin = irqd_to_hwirq(d);
+        unsigned padno, gpp, gpp_offset;
+        u32 gpe_en;
+
+        community = intel_get_community(pctrl, pin);
+        if (!community)
+                return -EINVAL;
+
+        padno = pin_to_padno(community, pin);
+        gpp = padno / NPADS_IN_GPP;
+        gpp_offset = padno % NPADS_IN_GPP;
+
+        /* Clear the existing wake status */
+        writel(BIT(gpp_offset), community->regs + GPI_GPE_STS + gpp * 4);
+
+        /*
+         * The controller will generate wake when GPE of the corresponding
+         * pad is enabled and it is not routed to SCI (GPIROUTSCI is not
+         * set).
+         */
+        gpe_en = readl(community->regs + GPI_GPE_EN + gpp * 4);
+        if (on)
+                gpe_en |= BIT(gpp_offset);
+        else
+                gpe_en &= ~BIT(gpp_offset);
+        writel(gpe_en, community->regs + GPI_GPE_EN + gpp * 4);
+
+        dev_dbg(pctrl->dev, "%sable wake for pin %u\n", on ? "en" : "dis", pin);
+        return 0;
+}
+
+static void intel_gpio_community_irq_handler(struct gpio_chip *gc,
+        const struct intel_community *community)
+{
+        int gpp;
+
+        for (gpp = 0; gpp < community->ngpps; gpp++) {
+                unsigned long pending, enabled, gpp_offset;
+
+                pending = readl(community->regs + GPI_IS + gpp * 4);
+                enabled = readl(community->regs + community->ie_offset +
+                                gpp * 4);
+
+                /* Only interrupts that are enabled */
+                pending &= enabled;
+
+                for_each_set_bit(gpp_offset, &pending, NPADS_IN_GPP) {
+                        unsigned padno, irq;
+
+                        /*
+                         * The last group in community can have less pins
+                         * than NPADS_IN_GPP.
+                         */
+                        padno = gpp_offset + gpp * NPADS_IN_GPP;
+                        if (padno >= community->npins)
+                                break;
+
+                        irq = irq_find_mapping(gc->irqdomain,
+                                               community->pin_base + padno);
+                        generic_handle_irq(irq);
+                }
+        }
+}
+
+static void intel_gpio_irq_handler(unsigned irq, struct irq_desc *desc)
+{
+        struct gpio_chip *gc = irq_desc_get_handler_data(desc);
+        struct intel_pinctrl *pctrl = gpiochip_to_pinctrl(gc);
+        struct irq_chip *chip = irq_get_chip(irq);
+        int i;
+
+        chained_irq_enter(chip, desc);
+
+        /* Need to check all communities for pending interrupts */
+        for (i = 0; i < pctrl->ncommunities; i++)
+                intel_gpio_community_irq_handler(gc, &pctrl->communities[i]);
+
+        chained_irq_exit(chip, desc);
+}
+
+static struct irq_chip intel_gpio_irqchip = {
+        .name = "intel-gpio",
+        .irq_ack = intel_gpio_irq_ack,
+        .irq_mask = intel_gpio_irq_mask,
+        .irq_unmask = intel_gpio_irq_unmask,
+        .irq_set_type = intel_gpio_irq_type,
+        .irq_set_wake = intel_gpio_irq_wake,
+};
+
+static void intel_gpio_irq_init(struct intel_pinctrl *pctrl)
+{
+        size_t i;
+
+        for (i = 0; i < pctrl->ncommunities; i++) {
+                const struct intel_community *community;
+                void __iomem *base;
+                unsigned gpp;
+
+                community = &pctrl->communities[i];
+                base = community->regs;
+
+                for (gpp = 0; gpp < community->ngpps; gpp++) {
+                        /* Mask and clear all interrupts */
+                        writel(0, base + community->ie_offset + gpp * 4);
+                        writel(0xffff, base + GPI_IS + gpp * 4);
+                }
+        }
+}
+
+static int intel_gpio_probe(struct intel_pinctrl *pctrl, int irq)
+{
+        int ret;
+
+        pctrl->chip = intel_gpio_chip;
+
+        pctrl->chip.ngpio = pctrl->soc->npins;
+        pctrl->chip.label = dev_name(pctrl->dev);
+        pctrl->chip.dev = pctrl->dev;
+        pctrl->chip.base = -1;
+
+        ret = gpiochip_add(&pctrl->chip);
+        if (ret) {
+                dev_err(pctrl->dev, "failed to register gpiochip\n");
+                return ret;
+        }
+
+        ret = gpiochip_add_pin_range(&pctrl->chip, dev_name(pctrl->dev),
+                                     0, 0, pctrl->soc->npins);
+        if (ret) {
+                dev_err(pctrl->dev, "failed to add GPIO pin range\n");
+                gpiochip_remove(&pctrl->chip);
+                return ret;
+        }
+
+        ret = gpiochip_irqchip_add(&pctrl->chip, &intel_gpio_irqchip, 0,
+                                   handle_simple_irq, IRQ_TYPE_NONE);
+        if (ret) {
+                dev_err(pctrl->dev, "failed to add irqchip\n");
+                gpiochip_remove(&pctrl->chip);
+                return ret;
+        }
+
+        gpiochip_set_chained_irqchip(&pctrl->chip, &intel_gpio_irqchip, irq,
+                                     intel_gpio_irq_handler);
+        return 0;
+}
+
+static int intel_pinctrl_pm_init(struct intel_pinctrl *pctrl)
+{
+#ifdef CONFIG_PM_SLEEP
+        const struct intel_pinctrl_soc_data *soc = pctrl->soc;
+        struct intel_community_context *communities;
+        struct intel_pad_context *pads;
+        int i;
+
+        pads = devm_kcalloc(pctrl->dev, soc->npins, sizeof(*pads), GFP_KERNEL);
+        if (!pads)
+                return -ENOMEM;
+
+        communities = devm_kcalloc(pctrl->dev, pctrl->ncommunities,
+                                   sizeof(*communities), GFP_KERNEL);
+        if (!communities)
+                return -ENOMEM;
+
+
+        for (i = 0; i < pctrl->ncommunities; i++) {
+                struct intel_community *community = &pctrl->communities[i];
+                u32 *intmask;
+
+                intmask = devm_kcalloc(pctrl->dev, community->ngpps,
+                                       sizeof(*intmask), GFP_KERNEL);
+                if (!intmask)
+                        return -ENOMEM;
+
+                communities[i].intmask = intmask;
+        }
+
+        pctrl->context.pads = pads;
+        pctrl->context.communities = communities;
+#endif
+
+        return 0;
+}
+
+int intel_pinctrl_probe(struct platform_device *pdev,
+                        const struct intel_pinctrl_soc_data *soc_data)
+{
+        struct intel_pinctrl *pctrl;
+        int i, ret, irq;
+
+        if (!soc_data)
+                return -EINVAL;
+
+        pctrl = devm_kzalloc(&pdev->dev, sizeof(*pctrl), GFP_KERNEL);
+        if (!pctrl)
+                return -ENOMEM;
+
+        pctrl->dev = &pdev->dev;
+        pctrl->soc = soc_data;
+        spin_lock_init(&pctrl->lock);
+
+        /*
+         * Make a copy of the communities which we can use to hold pointers
+         * to the registers.
+         */
+        pctrl->ncommunities = pctrl->soc->ncommunities;
+        pctrl->communities = devm_kcalloc(&pdev->dev, pctrl->ncommunities,
+                                  sizeof(*pctrl->communities), GFP_KERNEL);
+        if (!pctrl->communities)
+                return -ENOMEM;
+
+        for (i = 0; i < pctrl->ncommunities; i++) {
+                struct intel_community *community = &pctrl->communities[i];
+                struct resource *res;
+                void __iomem *regs;
+                u32 padbar;
+
+                *community = pctrl->soc->communities[i];
+
+                res = platform_get_resource(pdev, IORESOURCE_MEM,
+                                            community->barno);
+                regs = devm_ioremap_resource(&pdev->dev, res);
+                if (IS_ERR(regs))
+                        return PTR_ERR(regs);
+
+                /* Read offset of the pad configuration registers */
+                padbar = readl(regs + PADBAR);
+
+                community->regs = regs;
+                community->pad_regs = regs + padbar;
+                community->ngpps = DIV_ROUND_UP(community->npins, NPADS_IN_GPP);
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "failed to get interrupt number\n");
+                return irq;
+        }
+
+        ret = intel_pinctrl_pm_init(pctrl);
+        if (ret)
+                return ret;
+
+        pctrl->pctldesc = intel_pinctrl_desc;
+        pctrl->pctldesc.name = dev_name(&pdev->dev);
+        pctrl->pctldesc.pins = pctrl->soc->pins;
+        pctrl->pctldesc.npins = pctrl->soc->npins;
+
+        pctrl->pctldev = pinctrl_register(&pctrl->pctldesc, &pdev->dev, pctrl);
+        if (!pctrl->pctldev) {
+                dev_err(&pdev->dev, "failed to register pinctrl driver\n");
+                return -ENODEV;
+        }
+
+        ret = intel_gpio_probe(pctrl, irq);
+        if (ret) {
+                pinctrl_unregister(pctrl->pctldev);
+                return ret;
+        }
+
+        platform_set_drvdata(pdev, pctrl);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(intel_pinctrl_probe);
+
+int intel_pinctrl_remove(struct platform_device *pdev)
+{
+        struct intel_pinctrl *pctrl = platform_get_drvdata(pdev);
+
+        gpiochip_remove(&pctrl->chip);
+        pinctrl_unregister(pctrl->pctldev);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(intel_pinctrl_remove);
+
+#ifdef CONFIG_PM_SLEEP
+int intel_pinctrl_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct intel_pinctrl *pctrl = platform_get_drvdata(pdev);
+        struct intel_community_context *communities;
+        struct intel_pad_context *pads;
+        int i;
+
+        pads = pctrl->context.pads;
+        for (i = 0; i < pctrl->soc->npins; i++) {
+                const struct pinctrl_pin_desc *desc = &pctrl->soc->pins[i];
+                u32 val;
+
+                if (!intel_pad_usable(pctrl, desc->number))
+                        continue;
+
+                val = readl(intel_get_padcfg(pctrl, desc->number, PADCFG0));
+                pads[i].padcfg0 = val & ~PADCFG0_GPIORXSTATE;
+                val = readl(intel_get_padcfg(pctrl, desc->number, PADCFG1));
+                pads[i].padcfg1 = val;
+        }
+
+        communities = pctrl->context.communities;
+        for (i = 0; i < pctrl->ncommunities; i++) {
+                struct intel_community *community = &pctrl->communities[i];
+                void __iomem *base;
+                unsigned gpp;
+
+                base = community->regs + community->ie_offset;
+                for (gpp = 0; gpp < community->ngpps; gpp++)
+                        communities[i].intmask[gpp] = readl(base + gpp * 4);
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(intel_pinctrl_suspend);
+
+int intel_pinctrl_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct intel_pinctrl *pctrl = platform_get_drvdata(pdev);
+        const struct intel_community_context *communities;
+        const struct intel_pad_context *pads;
+        int i;
+
+        /* Mask all interrupts */
+        intel_gpio_irq_init(pctrl);
+
+        pads = pctrl->context.pads;
+        for (i = 0; i < pctrl->soc->npins; i++) {
+                const struct pinctrl_pin_desc *desc = &pctrl->soc->pins[i];
+                void __iomem *padcfg;
+                u32 val;
+
+                if (!intel_pad_usable(pctrl, desc->number))
+                        continue;
+
+                padcfg = intel_get_padcfg(pctrl, desc->number, PADCFG0);
+                val = readl(padcfg) & ~PADCFG0_GPIORXSTATE;
+                if (val != pads[i].padcfg0) {
+                        writel(pads[i].padcfg0, padcfg);
+                        dev_dbg(dev, "restored pin %u padcfg0 %#08x\n",
+                                desc->number, readl(padcfg));
+                }
+
+                padcfg = intel_get_padcfg(pctrl, desc->number, PADCFG1);
+                val = readl(padcfg);
+                if (val != pads[i].padcfg1) {
+                        writel(pads[i].padcfg1, padcfg);
+                        dev_dbg(dev, "restored pin %u padcfg1 %#08x\n",
+                                desc->number, readl(padcfg));
+                }
+        }
+
+        communities = pctrl->context.communities;
+        for (i = 0; i < pctrl->ncommunities; i++) {
+                struct intel_community *community = &pctrl->communities[i];
+                void __iomem *base;
+                unsigned gpp;
+
+                base = community->regs + community->ie_offset;
+                for (gpp = 0; gpp < community->ngpps; gpp++) {
+                        writel(communities[i].intmask[gpp], base + gpp * 4);
+                        dev_dbg(dev, "restored mask %d/%u %#08x\n", i, gpp,
+                                readl(base + gpp * 4));
+                }
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(intel_pinctrl_resume);
+#endif
+
+MODULE_AUTHOR("Mathias Nyman <mathias.nyman@linux.intel.com>");
+MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
+MODULE_DESCRIPTION("Intel pinctrl/GPIO core driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/pinctrl/intel/pinctrl-intel.h b/drivers/pinctrl/intel/pinctrl-intel.h
new file mode 100644
index 000000000000..4ec8b572a288
--- /dev/null
+++ b/drivers/pinctrl/intel/pinctrl-intel.h
@@ -0,0 +1,128 @@
+/*
+ * Core pinctrl/GPIO driver for Intel GPIO controllers
+ *
+ * Copyright (C) 2015, Intel Corporation
+ * Authors: Mathias Nyman <mathias.nyman@linux.intel.com>
+ *          Mika Westerberg <mika.westerberg@linux.intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef PINCTRL_INTEL_H
+#define PINCTRL_INTEL_H
+
+struct pinctrl_pin_desc;
+struct platform_device;
+struct device;
+
+/**
+ * struct intel_pingroup - Description about group of pins
+ * @name: Name of the groups
+ * @pins: All pins in this group
+ * @npins: Number of pins in this groups
+ * @mode: Native mode in which the group is muxed out @pins
+ */
+struct intel_pingroup {
+        const char *name;
+        const unsigned *pins;
+        size_t npins;
+        unsigned short mode;
+};
+
+/**
+ * struct intel_function - Description about a function
+ * @name: Name of the function
+ * @groups: An array of groups for this function
+ * @ngroups: Number of groups in @groups
+ */
+struct intel_function {
+        const char *name;
+        const char * const *groups;
+        size_t ngroups;
+};
+
+/**
+ * struct intel_community - Intel pin community description
+ * @barno: MMIO BAR number where registers for this community reside
+ * @padown_offset: Register offset of PAD_OWN register from @regs. If %0
+ *                 then there is no support for owner.
+ * @padcfglock_offset: Register offset of PADCFGLOCK from @regs. If %0 then
+ *                     locking is not supported.
+ * @hostown_offset: Register offset of HOSTSW_OWN from @regs. If %0 then it
+ *                  is assumed that the host owns the pin (rather than
+ *                  ACPI).
+ * @ie_offset: Register offset of GPI_IE from @regs.
+ * @pin_base: Starting pin of pins in this community
+ * @npins: Number of pins in this community
+ * @regs: Community specific common registers (reserved for core driver)
+ * @pad_regs: Community specific pad registers (reserved for core driver)
+ * @ngpps: Number of groups (hw groups) in this community (reserved for
+ *         core driver)
+ */
+struct intel_community {
+        unsigned barno;
+        unsigned padown_offset;
+        unsigned padcfglock_offset;
+        unsigned hostown_offset;
+        unsigned ie_offset;
+        unsigned pin_base;
+        size_t npins;
+        void __iomem *regs;
+        void __iomem *pad_regs;
+        size_t ngpps;
+};
+
+#define PIN_GROUP(n, p, m)                      \
+        {                                       \
+                .name = (n),                    \
+                .pins = (p),                    \
+                .npins = ARRAY_SIZE((p)),       \
+                .mode = (m),                    \
+        }
+
+#define FUNCTION(n, g)                          \
+        {                                       \
+                .name = (n),                    \
+                .groups = (g),                  \
+                .ngroups = ARRAY_SIZE((g)),     \
+        }
+
+/**
+ * struct intel_pinctrl_soc_data - Intel pin controller per-SoC configuration
+ * @uid: ACPI _UID for the probe driver use if needed
+ * @pins: Array if pins this pinctrl controls
+ * @npins: Number of pins in the array
+ * @groups: Array of pin groups
+ * @ngroups: Number of groups in the array
+ * @functions: Array of functions
+ * @nfunctions: Number of functions in the array
+ * @communities: Array of communities this pinctrl handles
+ * @ncommunities: Number of communities in the array
+ *
+ * The @communities is used as a template by the core driver. It will make
+ * copy of all communities and fill in rest of the information.
+ */
+struct intel_pinctrl_soc_data {
+        const char *uid;
+        const struct pinctrl_pin_desc *pins;
+        size_t npins;
+        const struct intel_pingroup *groups;
+        size_t ngroups;
+        const struct intel_function *functions;
+        size_t nfunctions;
+        const struct intel_community *communities;
+        size_t ncommunities;
+};
+
+int intel_pinctrl_probe(struct platform_device *pdev,
+                        const struct intel_pinctrl_soc_data *soc_data);
+int intel_pinctrl_remove(struct platform_device *pdev);
+
+#ifdef CONFIG_PM_SLEEP
+int intel_pinctrl_suspend(struct device *dev);
+int intel_pinctrl_resume(struct device *dev);
+#endif
+
+#endif /* PINCTRL_INTEL_H */
diff --git a/drivers/pinctrl/intel/pinctrl-sunrisepoint.c b/drivers/pinctrl/intel/pinctrl-sunrisepoint.c
new file mode 100644
index 000000000000..55d025dc89e8
--- /dev/null
+++ b/drivers/pinctrl/intel/pinctrl-sunrisepoint.c
@@ -0,0 +1,336 @@
+/*
+ * Intel Sunrisepoint PCH pinctrl/GPIO driver
+ *
+ * Copyright (C) 2015, Intel Corporation
+ * Authors: Mathias Nyman <mathias.nyman@linux.intel.com>
+ *          Mika Westerberg <mika.westerberg@linux.intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/acpi.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/pm.h>
+#include <linux/pinctrl/pinctrl.h>
+
+#include "pinctrl-intel.h"
+
+#define SPT_PAD_OWN     0x020
+#define SPT_PADCFGLOCK  0x0a0
+#define SPT_HOSTSW_OWN  0x0d0
+#define SPT_GPI_IE      0x120
+
+#define SPT_COMMUNITY(b, s, e)                          \
+        {                                               \
+                .barno = (b),                           \
+                .padown_offset = SPT_PAD_OWN,           \
+                .padcfglock_offset = SPT_PADCFGLOCK,    \
+                .hostown_offset = SPT_HOSTSW_OWN,       \
+                .ie_offset = SPT_GPI_IE,                \
+                .pin_base = (s),                        \
+                .npins = ((e) - (s) + 1),               \
+        }
+
+/* Sunrisepoint-LP */
+static const struct pinctrl_pin_desc sptlp_pins[] = {
+        /* GPP_A */
+        PINCTRL_PIN(0, "RCINB"),
+        PINCTRL_PIN(1, "LAD_0"),
+        PINCTRL_PIN(2, "LAD_1"),
+        PINCTRL_PIN(3, "LAD_2"),
+        PINCTRL_PIN(4, "LAD_3"),
+        PINCTRL_PIN(5, "LFRAMEB"),
+        PINCTRL_PIN(6, "SERIQ"),
+        PINCTRL_PIN(7, "PIRQAB"),
+        PINCTRL_PIN(8, "CLKRUNB"),
+        PINCTRL_PIN(9, "CLKOUT_LPC_0"),
+        PINCTRL_PIN(10, "CLKOUT_LPC_1"),
+        PINCTRL_PIN(11, "PMEB"),
+        PINCTRL_PIN(12, "BM_BUSYB"),
+        PINCTRL_PIN(13, "SUSWARNB_SUS_PWRDNACK"),
+        PINCTRL_PIN(14, "SUS_STATB"),
+        PINCTRL_PIN(15, "SUSACKB"),
+        PINCTRL_PIN(16, "SD_1P8_SEL"),
+        PINCTRL_PIN(17, "SD_PWR_EN_B"),
+        PINCTRL_PIN(18, "ISH_GP_0"),
+        PINCTRL_PIN(19, "ISH_GP_1"),
+        PINCTRL_PIN(20, "ISH_GP_2"),
+        PINCTRL_PIN(21, "ISH_GP_3"),
+        PINCTRL_PIN(22, "ISH_GP_4"),
+        PINCTRL_PIN(23, "ISH_GP_5"),
+        /* GPP_B */
+        PINCTRL_PIN(24, "CORE_VID_0"),
+        PINCTRL_PIN(25, "CORE_VID_1"),
+        PINCTRL_PIN(26, "VRALERTB"),
+        PINCTRL_PIN(27, "CPU_GP_2"),
+        PINCTRL_PIN(28, "CPU_GP_3"),
+        PINCTRL_PIN(29, "SRCCLKREQB_0"),
+        PINCTRL_PIN(30, "SRCCLKREQB_1"),
+        PINCTRL_PIN(31, "SRCCLKREQB_2"),
+        PINCTRL_PIN(32, "SRCCLKREQB_3"),
+        PINCTRL_PIN(33, "SRCCLKREQB_4"),
+        PINCTRL_PIN(34, "SRCCLKREQB_5"),
+        PINCTRL_PIN(35, "EXT_PWR_GATEB"),
+        PINCTRL_PIN(36, "SLP_S0B"),
+        PINCTRL_PIN(37, "PLTRSTB"),
+        PINCTRL_PIN(38, "SPKR"),
+        PINCTRL_PIN(39, "GSPI0_CSB"),
+        PINCTRL_PIN(40, "GSPI0_CLK"),
+        PINCTRL_PIN(41, "GSPI0_MISO"),
+        PINCTRL_PIN(42, "GSPI0_MOSI"),
+        PINCTRL_PIN(43, "GSPI1_CSB"),
+        PINCTRL_PIN(44, "GSPI1_CLK"),
+        PINCTRL_PIN(45, "GSPI1_MISO"),
+        PINCTRL_PIN(46, "GSPI1_MOSI"),
+        PINCTRL_PIN(47, "SML1ALERTB"),
+        /* GPP_C */
+        PINCTRL_PIN(48, "SMBCLK"),
+        PINCTRL_PIN(49, "SMBDATA"),
+        PINCTRL_PIN(50, "SMBALERTB"),
+        PINCTRL_PIN(51, "SML0CLK"),
+        PINCTRL_PIN(52, "SML0DATA"),
+        PINCTRL_PIN(53, "SML0ALERTB"),
+        PINCTRL_PIN(54, "SML1CLK"),
+        PINCTRL_PIN(55, "SML1DATA"),
+        PINCTRL_PIN(56, "UART0_RXD"),
+        PINCTRL_PIN(57, "UART0_TXD"),
+        PINCTRL_PIN(58, "UART0_RTSB"),
+        PINCTRL_PIN(59, "UART0_CTSB"),
+        PINCTRL_PIN(60, "UART1_RXD"),
+        PINCTRL_PIN(61, "UART1_TXD"),
+        PINCTRL_PIN(62, "UART1_RTSB"),
+        PINCTRL_PIN(63, "UART1_CTSB"),
+        PINCTRL_PIN(64, "I2C0_SDA"),
+        PINCTRL_PIN(65, "I2C0_SCL"),
+        PINCTRL_PIN(66, "I2C1_SDA"),
+        PINCTRL_PIN(67, "I2C1_SCL"),
+        PINCTRL_PIN(68, "UART2_RXD"),
+        PINCTRL_PIN(69, "UART2_TXD"),
+        PINCTRL_PIN(70, "UART2_RTSB"),
+        PINCTRL_PIN(71, "UART2_CTSB"),
+        /* GPP_D */
+        PINCTRL_PIN(72, "SPI1_CSB"),
+        PINCTRL_PIN(73, "SPI1_CLK"),
+        PINCTRL_PIN(74, "SPI1_MISO_IO_1"),
+        PINCTRL_PIN(75, "SPI1_MOSI_IO_0"),
+        PINCTRL_PIN(76, "FLASHTRIG"),
+        PINCTRL_PIN(77, "ISH_I2C0_SDA"),
+        PINCTRL_PIN(78, "ISH_I2C0_SCL"),
+        PINCTRL_PIN(79, "ISH_I2C1_SDA"),
+        PINCTRL_PIN(80, "ISH_I2C1_SCL"),
+        PINCTRL_PIN(81, "ISH_SPI_CSB"),
+        PINCTRL_PIN(82, "ISH_SPI_CLK"),
+        PINCTRL_PIN(83, "ISH_SPI_MISO"),
+        PINCTRL_PIN(84, "ISH_SPI_MOSI"),
+        PINCTRL_PIN(85, "ISH_UART0_RXD"),
+        PINCTRL_PIN(86, "ISH_UART0_TXD"),
+        PINCTRL_PIN(87, "ISH_UART0_RTSB"),
+        PINCTRL_PIN(88, "ISH_UART0_CTSB"),
+        PINCTRL_PIN(89, "DMIC_CLK_1"),
+        PINCTRL_PIN(90, "DMIC_DATA_1"),
+        PINCTRL_PIN(91, "DMIC_CLK_0"),
+        PINCTRL_PIN(92, "DMIC_DATA_0"),
+        PINCTRL_PIN(93, "SPI1_IO_2"),
+        PINCTRL_PIN(94, "SPI1_IO_3"),
+        PINCTRL_PIN(95, "SSP_MCLK"),
+        /* GPP_E */
+        PINCTRL_PIN(96, "SATAXPCIE_0"),
+        PINCTRL_PIN(97, "SATAXPCIE_1"),
+        PINCTRL_PIN(98, "SATAXPCIE_2"),
+        PINCTRL_PIN(99, "CPU_GP_0"),
+        PINCTRL_PIN(100, "SATA_DEVSLP_0"),
+        PINCTRL_PIN(101, "SATA_DEVSLP_1"),
+        PINCTRL_PIN(102, "SATA_DEVSLP_2"),
+        PINCTRL_PIN(103, "CPU_GP_1"),
+        PINCTRL_PIN(104, "SATA_LEDB"),
+        PINCTRL_PIN(105, "USB2_OCB_0"),
+        PINCTRL_PIN(106, "USB2_OCB_1"),
+        PINCTRL_PIN(107, "USB2_OCB_2"),
+        PINCTRL_PIN(108, "USB2_OCB_3"),
+        PINCTRL_PIN(109, "DDSP_HPD_0"),
+        PINCTRL_PIN(110, "DDSP_HPD_1"),
+        PINCTRL_PIN(111, "DDSP_HPD_2"),
+        PINCTRL_PIN(112, "DDSP_HPD_3"),
+        PINCTRL_PIN(113, "EDP_HPD"),
+        PINCTRL_PIN(114, "DDPB_CTRLCLK"),
+        PINCTRL_PIN(115, "DDPB_CTRLDATA"),
+        PINCTRL_PIN(116, "DDPC_CTRLCLK"),
+        PINCTRL_PIN(117, "DDPC_CTRLDATA"),
+        PINCTRL_PIN(118, "DDPD_CTRLCLK"),
+        PINCTRL_PIN(119, "DDPD_CTRLDATA"),
+        /* GPP_F */
+        PINCTRL_PIN(120, "SSP2_SCLK"),
+        PINCTRL_PIN(121, "SSP2_SFRM"),
+        PINCTRL_PIN(122, "SSP2_TXD"),
+        PINCTRL_PIN(123, "SSP2_RXD"),
+        PINCTRL_PIN(124, "I2C2_SDA"),
+        PINCTRL_PIN(125, "I2C2_SCL"),
+        PINCTRL_PIN(126, "I2C3_SDA"),
+        PINCTRL_PIN(127, "I2C3_SCL"),
+        PINCTRL_PIN(128, "I2C4_SDA"),
+        PINCTRL_PIN(129, "I2C4_SCL"),
+        PINCTRL_PIN(130, "I2C5_SDA"),
+        PINCTRL_PIN(131, "I2C5_SCL"),
+        PINCTRL_PIN(132, "EMMC_CMD"),
+        PINCTRL_PIN(133, "EMMC_DATA_0"),
+        PINCTRL_PIN(134, "EMMC_DATA_1"),
+        PINCTRL_PIN(135, "EMMC_DATA_2"),
+        PINCTRL_PIN(136, "EMMC_DATA_3"),
+        PINCTRL_PIN(137, "EMMC_DATA_4"),
+        PINCTRL_PIN(138, "EMMC_DATA_5"),
+        PINCTRL_PIN(139, "EMMC_DATA_6"),
+        PINCTRL_PIN(140, "EMMC_DATA_7"),
+        PINCTRL_PIN(141, "EMMC_RCLK"),
+        PINCTRL_PIN(142, "EMMC_CLK"),
+        PINCTRL_PIN(143, "GPP_F_23"),
+        /* GPP_G */
+        PINCTRL_PIN(144, "SD_CMD"),
+        PINCTRL_PIN(145, "SD_DATA_0"),
+        PINCTRL_PIN(146, "SD_DATA_1"),
+        PINCTRL_PIN(147, "SD_DATA_2"),
+        PINCTRL_PIN(148, "SD_DATA_3"),
+        PINCTRL_PIN(149, "SD_CDB"),
+        PINCTRL_PIN(150, "SD_CLK"),
+        PINCTRL_PIN(151, "SD_WP"),
+};
+
+static const unsigned sptlp_spi0_pins[] = { 39, 40, 41, 42 };
+static const unsigned sptlp_spi1_pins[] = { 43, 44, 45, 46 };
+static const unsigned sptlp_uart0_pins[] = { 56, 57, 58, 59 };
+static const unsigned sptlp_uart1_pins[] = { 60, 61, 62, 63 };
+static const unsigned sptlp_uart2_pins[] = { 68, 69, 71, 71 };
+static const unsigned sptlp_i2c0_pins[] = { 64, 65 };
+static const unsigned sptlp_i2c1_pins[] = { 66, 67 };
+static const unsigned sptlp_i2c2_pins[] = { 124, 125 };
+static const unsigned sptlp_i2c3_pins[] = { 126, 127 };
+static const unsigned sptlp_i2c4_pins[] = { 128, 129 };
+static const unsigned sptlp_i2c4b_pins[] = { 85, 86 };
+static const unsigned sptlp_i2c5_pins[] = { 130, 131 };
+static const unsigned sptlp_ssp2_pins[] = { 120, 121, 122, 123 };
+static const unsigned sptlp_emmc_pins[] = {
+        132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142,
+};
+static const unsigned sptlp_sd_pins[] = {
+        144, 145, 146, 147, 148, 149, 150, 151,
+};
+
+static const struct intel_pingroup sptlp_groups[] = {
+        PIN_GROUP("spi0_grp", sptlp_spi0_pins, 1),
+        PIN_GROUP("spi1_grp", sptlp_spi1_pins, 1),
+        PIN_GROUP("uart0_grp", sptlp_uart0_pins, 1),
+        PIN_GROUP("uart1_grp", sptlp_uart1_pins, 1),
+        PIN_GROUP("uart2_grp", sptlp_uart2_pins, 1),
+        PIN_GROUP("i2c0_grp", sptlp_i2c0_pins, 1),
+        PIN_GROUP("i2c1_grp", sptlp_i2c1_pins, 1),
+        PIN_GROUP("i2c2_grp", sptlp_i2c2_pins, 1),
+        PIN_GROUP("i2c3_grp", sptlp_i2c3_pins, 1),
+        PIN_GROUP("i2c4_grp", sptlp_i2c4_pins, 1),
+        PIN_GROUP("i2c4b_grp", sptlp_i2c4b_pins, 3),
+        PIN_GROUP("i2c5_grp", sptlp_i2c5_pins, 1),
+        PIN_GROUP("ssp2_grp", sptlp_ssp2_pins, 1),
+        PIN_GROUP("emmc_grp", sptlp_emmc_pins, 1),
+        PIN_GROUP("sd_grp", sptlp_sd_pins, 1),
+};
+
+static const char * const sptlp_spi0_groups[] = { "spi0_grp" };
+static const char * const sptlp_spi1_groups[] = { "spi0_grp" };
+static const char * const sptlp_uart0_groups[] = { "uart0_grp" };
+static const char * const sptlp_uart1_groups[] = { "uart1_grp" };
+static const char * const sptlp_uart2_groups[] = { "uart2_grp" };
+static const char * const sptlp_i2c0_groups[] = { "i2c0_grp" };
+static const char * const sptlp_i2c1_groups[] = { "i2c1_grp" };
+static const char * const sptlp_i2c2_groups[] = { "i2c2_grp" };
+static const char * const sptlp_i2c3_groups[] = { "i2c3_grp" };
+static const char * const sptlp_i2c4_groups[] = { "i2c4_grp", "i2c4b_grp" };
+static const char * const sptlp_i2c5_groups[] = { "i2c5_grp" };
+static const char * const sptlp_ssp2_groups[] = { "ssp2_grp" };
+static const char * const sptlp_emmc_groups[] = { "emmc_grp" };
+static const char * const sptlp_sd_groups[] = { "sd_grp" };
+
+static const struct intel_function sptlp_functions[] = {
+        FUNCTION("spi0", sptlp_spi0_groups),
+        FUNCTION("spi1", sptlp_spi1_groups),
+        FUNCTION("uart0", sptlp_uart0_groups),
+        FUNCTION("uart1", sptlp_uart1_groups),
+        FUNCTION("uart2", sptlp_uart2_groups),
+        FUNCTION("i2c0", sptlp_i2c0_groups),
+        FUNCTION("i2c1", sptlp_i2c1_groups),
+        FUNCTION("i2c2", sptlp_i2c2_groups),
+        FUNCTION("i2c3", sptlp_i2c3_groups),
+        FUNCTION("i2c4", sptlp_i2c4_groups),
+        FUNCTION("i2c5", sptlp_i2c5_groups),
+        FUNCTION("ssp2", sptlp_ssp2_groups),
+        FUNCTION("emmc", sptlp_emmc_groups),
+        FUNCTION("sd", sptlp_sd_groups),
+};
+
+static const struct intel_community sptlp_communities[] = {
+        SPT_COMMUNITY(0, 0, 47),
+        SPT_COMMUNITY(1, 48, 119),
+        SPT_COMMUNITY(2, 120, 151),
+};
+
+static const struct intel_pinctrl_soc_data sptlp_soc_data = {
+        .pins = sptlp_pins,
+        .npins = ARRAY_SIZE(sptlp_pins),
+        .groups = sptlp_groups,
+        .ngroups = ARRAY_SIZE(sptlp_groups),
+        .functions = sptlp_functions,
+        .nfunctions = ARRAY_SIZE(sptlp_functions),
+        .communities = sptlp_communities,
+        .ncommunities = ARRAY_SIZE(sptlp_communities),
+};
+
+static const struct acpi_device_id spt_pinctrl_acpi_match[] = {
+        { "INT344B", (kernel_ulong_t)&sptlp_soc_data },
+        { }
+};
+MODULE_DEVICE_TABLE(acpi, spt_pinctrl_acpi_match);
+
+static int spt_pinctrl_probe(struct platform_device *pdev)
+{
+        const struct intel_pinctrl_soc_data *soc_data;
+        const struct acpi_device_id *id;
+
+        id = acpi_match_device(spt_pinctrl_acpi_match, &pdev->dev);
+        if (!id || !id->driver_data)
+                return -ENODEV;
+
+        soc_data = (const struct intel_pinctrl_soc_data *)id->driver_data;
+        return intel_pinctrl_probe(pdev, soc_data);
+}
+
+static const struct dev_pm_ops spt_pinctrl_pm_ops = {
+        SET_LATE_SYSTEM_SLEEP_PM_OPS(intel_pinctrl_suspend,
+                                     intel_pinctrl_resume)
+};
+
+static struct platform_driver spt_pinctrl_driver = {
+        .probe = spt_pinctrl_probe,
+        .remove = intel_pinctrl_remove,
+        .driver = {
+                .name = "sunrisepoint-pinctrl",
+                .acpi_match_table = spt_pinctrl_acpi_match,
+                .pm = &spt_pinctrl_pm_ops,
+        },
+};
+
+static int __init spt_pinctrl_init(void)
+{
+        return platform_driver_register(&spt_pinctrl_driver);
+}
+subsys_initcall(spt_pinctrl_init);
+
+static void __exit spt_pinctrl_exit(void)
+{
+        platform_driver_unregister(&spt_pinctrl_driver);
+}
+module_exit(spt_pinctrl_exit);
+
+MODULE_AUTHOR("Mathias Nyman <mathias.nyman@linux.intel.com>");
+MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
+MODULE_DESCRIPTION("Intel Sunrisepoint PCH pinctrl/GPIO driver");
+MODULE_LICENSE("GPL v2");