1 files changed, 341 insertions, 51 deletions

diff --git a/drivers/pinctrl/pinctrl-nomadik.c b/drivers/pinctrl/pinctrl-nomadik.c
index 3197870d740a..36d20293de5c 100644
--- a/drivers/pinctrl/pinctrl-nomadik.c
+++ b/drivers/pinctrl/pinctrl-nomadik.c
@@ -25,6 +25,8 @@
 #include <linux/irqdomain.h>
 #include <linux/slab.h>
 #include <linux/of_device.h>
+#include <linux/of_address.h>
+#include <linux/pinctrl/machine.h>
 #include <linux/pinctrl/pinctrl.h>
 #include <linux/pinctrl/pinmux.h>
 #include <linux/pinctrl/pinconf.h>
@@ -32,8 +34,8 @@
 #include <linux/pinctrl/consumer.h>
 #include <linux/platform_data/pinctrl-nomadik.h>
 #include <asm/mach/irq.h>
-#include <mach/irqs.h>
 #include "pinctrl-nomadik.h"
+#include "core.h"
 
 /*
  * The GPIO module in the Nomadik family of Systems-on-Chip is an
@@ -216,7 +218,7 @@ nmk_gpio_disable_lazy_irq(struct nmk_gpio_chip *nmk_chip, unsigned offset)
         u32 falling = nmk_chip->fimsc & BIT(offset);
         u32 rising = nmk_chip->rimsc & BIT(offset);
         int gpio = nmk_chip->chip.base + offset;
-        int irq = NOMADIK_GPIO_TO_IRQ(gpio);
+        int irq = irq_find_mapping(nmk_chip->domain, offset);
         struct irq_data *d = irq_get_irq_data(irq);
 
         if (!rising && !falling)
@@ -1341,8 +1343,7 @@ static int nmk_gpio_probe(struct platform_device *dev)
 
                 if (of_property_read_u32(np, "gpio-bank", &dev->id)) {
                         dev_err(&dev->dev, "gpio-bank property not found\n");
-                        ret = -EINVAL;
-                        goto out;
+                        return -EINVAL;
                 }
 
                 pdata->first_gpio = dev->id * NMK_GPIO_PER_CHIP;
@@ -1350,41 +1351,29 @@ static int nmk_gpio_probe(struct platform_device *dev)
         }
 
         res = platform_get_resource(dev, IORESOURCE_MEM, 0);
-        if (!res) {
-                ret = -ENOENT;
-                goto out;
-        }
+        if (!res)
+                return -ENOENT;
 
         irq = platform_get_irq(dev, 0);
-        if (irq < 0) {
-                ret = irq;
-                goto out;
-        }
+        if (irq < 0)
+                return irq;
 
         secondary_irq = platform_get_irq(dev, 1);
-        if (secondary_irq >= 0 && !pdata->get_secondary_status) {
-                ret = -EINVAL;
-                goto out;
-        }
+        if (secondary_irq >= 0 && !pdata->get_secondary_status)
+                return -EINVAL;
 
-        base = devm_request_and_ioremap(&dev->dev, res);
-        if (!base) {
-                ret = -ENOMEM;
-                goto out;
-        }
+        base = devm_ioremap_resource(&dev->dev, res);
+        if (IS_ERR(base))
+                return PTR_ERR(base);
 
         clk = devm_clk_get(&dev->dev, NULL);
-        if (IS_ERR(clk)) {
-                ret = PTR_ERR(clk);
-                goto out;
-        }
+        if (IS_ERR(clk))
+                return PTR_ERR(clk);
         clk_prepare(clk);
 
         nmk_chip = devm_kzalloc(&dev->dev, sizeof(*nmk_chip), GFP_KERNEL);
-        if (!nmk_chip) {
-                ret = -ENOMEM;
-                goto out;
-        }
+        if (!nmk_chip)
+                return -ENOMEM;
 
         /*
          * The virt address in nmk_chip->addr is in the nomadik register space,
@@ -1418,7 +1407,7 @@ static int nmk_gpio_probe(struct platform_device *dev)
 
         ret = gpiochip_add(&nmk_chip->chip);
         if (ret)
-                goto out;
+                return ret;
 
         BUG_ON(nmk_chip->bank >= ARRAY_SIZE(nmk_gpio_chips));
 
@@ -1427,14 +1416,15 @@ static int nmk_gpio_probe(struct platform_device *dev)
         platform_set_drvdata(dev, nmk_chip);
 
         if (!np)
-                irq_start = NOMADIK_GPIO_TO_IRQ(pdata->first_gpio);
+                irq_start = pdata->first_irq;
         nmk_chip->domain = irq_domain_add_simple(np,
                                 NMK_GPIO_PER_CHIP, irq_start,
                                 &nmk_gpio_irq_simple_ops, nmk_chip);
         if (!nmk_chip->domain) {
                 dev_err(&dev->dev, "failed to create irqdomain\n");
-                ret = -ENOSYS;
-                goto out;
+                /* Just do this, no matter if it fails */
+                ret = gpiochip_remove(&nmk_chip->chip);
+                return -ENOSYS;
         }
 
         nmk_gpio_init_irq(nmk_chip);
@@ -1442,12 +1432,6 @@ static int nmk_gpio_probe(struct platform_device *dev)
         dev_info(&dev->dev, "at address %p\n", nmk_chip->addr);
 
         return 0;
-
-out:
-        dev_err(&dev->dev, "Failure %i for GPIO %i-%i\n", ret,
-                  pdata->first_gpio, pdata->first_gpio+31);
-
-        return ret;
 }
 
 static int nmk_get_groups_cnt(struct pinctrl_dev *pctldev)
@@ -1508,11 +1492,285 @@ static void nmk_pin_dbg_show(struct pinctrl_dev *pctldev, struct seq_file *s,
         nmk_gpio_dbg_show_one(s, pctldev, chip, offset - chip->base, offset);
 }
 
+static void nmk_pinctrl_dt_free_map(struct pinctrl_dev *pctldev,
+                struct pinctrl_map *map, unsigned num_maps)
+{
+        int i;
+
+        for (i = 0; i < num_maps; i++)
+                if (map[i].type == PIN_MAP_TYPE_CONFIGS_PIN)
+                        kfree(map[i].data.configs.configs);
+        kfree(map);
+}
+
+static int nmk_dt_reserve_map(struct pinctrl_map **map, unsigned *reserved_maps,
+                unsigned *num_maps, unsigned reserve)
+{
+        unsigned old_num = *reserved_maps;
+        unsigned new_num = *num_maps + reserve;
+        struct pinctrl_map *new_map;
+
+        if (old_num >= new_num)
+                return 0;
+
+        new_map = krealloc(*map, sizeof(*new_map) * new_num, GFP_KERNEL);
+        if (!new_map)
+                return -ENOMEM;
+
+        memset(new_map + old_num, 0, (new_num - old_num) * sizeof(*new_map));
+
+        *map = new_map;
+        *reserved_maps = new_num;
+
+        return 0;
+}
+
+static int nmk_dt_add_map_mux(struct pinctrl_map **map, unsigned *reserved_maps,
+                unsigned *num_maps, const char *group,
+                const char *function)
+{
+        if (*num_maps == *reserved_maps)
+                return -ENOSPC;
+
+        (*map)[*num_maps].type = PIN_MAP_TYPE_MUX_GROUP;
+        (*map)[*num_maps].data.mux.group = group;
+        (*map)[*num_maps].data.mux.function = function;
+        (*num_maps)++;
+
+        return 0;
+}
+
+static int nmk_dt_add_map_configs(struct pinctrl_map **map,
+                unsigned *reserved_maps,
+                unsigned *num_maps, const char *group,
+                unsigned long *configs, unsigned num_configs)
+{
+        unsigned long *dup_configs;
+
+        if (*num_maps == *reserved_maps)
+                return -ENOSPC;
+
+        dup_configs = kmemdup(configs, num_configs * sizeof(*dup_configs),
+                              GFP_KERNEL);
+        if (!dup_configs)
+                return -ENOMEM;
+
+        (*map)[*num_maps].type = PIN_MAP_TYPE_CONFIGS_PIN;
+
+        (*map)[*num_maps].data.configs.group_or_pin = group;
+        (*map)[*num_maps].data.configs.configs = dup_configs;
+        (*map)[*num_maps].data.configs.num_configs = num_configs;
+        (*num_maps)++;
+
+        return 0;
+}
+
+#define NMK_CONFIG_PIN(x,y) { .property = x, .config = y, }
+#define NMK_CONFIG_PIN_ARRAY(x,y) { .property = x, .choice = y, \
+        .size = ARRAY_SIZE(y), }
+
+static const unsigned long nmk_pin_input_modes[] = {
+        PIN_INPUT_NOPULL,
+        PIN_INPUT_PULLUP,
+        PIN_INPUT_PULLDOWN,
+};
+
+static const unsigned long nmk_pin_output_modes[] = {
+        PIN_OUTPUT_LOW,
+        PIN_OUTPUT_HIGH,
+        PIN_DIR_OUTPUT,
+};
+
+static const unsigned long nmk_pin_sleep_modes[] = {
+        PIN_SLEEPMODE_DISABLED,
+        PIN_SLEEPMODE_ENABLED,
+};
+
+static const unsigned long nmk_pin_sleep_input_modes[] = {
+        PIN_SLPM_INPUT_NOPULL,
+        PIN_SLPM_INPUT_PULLUP,
+        PIN_SLPM_INPUT_PULLDOWN,
+        PIN_SLPM_DIR_INPUT,
+};
+
+static const unsigned long nmk_pin_sleep_output_modes[] = {
+        PIN_SLPM_OUTPUT_LOW,
+        PIN_SLPM_OUTPUT_HIGH,
+        PIN_SLPM_DIR_OUTPUT,
+};
+
+static const unsigned long nmk_pin_sleep_wakeup_modes[] = {
+        PIN_SLPM_WAKEUP_DISABLE,
+        PIN_SLPM_WAKEUP_ENABLE,
+};
+
+static const unsigned long nmk_pin_gpio_modes[] = {
+        PIN_GPIOMODE_DISABLED,
+        PIN_GPIOMODE_ENABLED,
+};
+
+static const unsigned long nmk_pin_sleep_pdis_modes[] = {
+        PIN_SLPM_PDIS_DISABLED,
+        PIN_SLPM_PDIS_ENABLED,
+};
+
+struct nmk_cfg_param {
+        const char *property;
+        unsigned long config;
+        const unsigned long *choice;
+        int size;
+};
+
+static const struct nmk_cfg_param nmk_cfg_params[] = {
+        NMK_CONFIG_PIN_ARRAY("ste,input",               nmk_pin_input_modes),
+        NMK_CONFIG_PIN_ARRAY("ste,output",              nmk_pin_output_modes),
+        NMK_CONFIG_PIN_ARRAY("ste,sleep",               nmk_pin_sleep_modes),
+        NMK_CONFIG_PIN_ARRAY("ste,sleep-input",         nmk_pin_sleep_input_modes),
+        NMK_CONFIG_PIN_ARRAY("ste,sleep-output",        nmk_pin_sleep_output_modes),
+        NMK_CONFIG_PIN_ARRAY("ste,sleep-wakeup",        nmk_pin_sleep_wakeup_modes),
+        NMK_CONFIG_PIN_ARRAY("ste,gpio",                nmk_pin_gpio_modes),
+        NMK_CONFIG_PIN_ARRAY("ste,sleep-pull-disable",  nmk_pin_sleep_pdis_modes),
+};
+
+static int nmk_dt_pin_config(int index, int val, unsigned long *config)
+{
+        int ret = 0;
+
+        if (nmk_cfg_params[index].choice == NULL)
+                *config = nmk_cfg_params[index].config;
+        else {
+                /* test if out of range */
+                if  (val < nmk_cfg_params[index].size) {
+                        *config = nmk_cfg_params[index].config |
+                                nmk_cfg_params[index].choice[val];
+                }
+        }
+        return ret;
+}
+
+static const char *nmk_find_pin_name(struct pinctrl_dev *pctldev, const char *pin_name)
+{
+        int i, pin_number;
+        struct nmk_pinctrl *npct = pinctrl_dev_get_drvdata(pctldev);
+
+        if (sscanf((char *)pin_name, "GPIO%d", &pin_number) == 1)
+                for (i = 0; i < npct->soc->npins; i++)
+                        if (npct->soc->pins[i].number == pin_number)
+                                return npct->soc->pins[i].name;
+        return NULL;
+}
+
+static bool nmk_pinctrl_dt_get_config(struct device_node *np,
+                unsigned long *configs)
+{
+        bool has_config = 0;
+        unsigned long cfg = 0;
+        int i, val, ret;
+
+        for (i = 0; i < ARRAY_SIZE(nmk_cfg_params); i++) {
+                ret = of_property_read_u32(np,
+                                nmk_cfg_params[i].property, &val);
+                if (ret != -EINVAL) {
+                        if (nmk_dt_pin_config(i, val, &cfg) == 0) {
+                                *configs |= cfg;
+                                has_config = 1;
+                        }
+                }
+        }
+
+        return has_config;
+}
+
+int nmk_pinctrl_dt_subnode_to_map(struct pinctrl_dev *pctldev,
+                struct device_node *np,
+                struct pinctrl_map **map,
+                unsigned *reserved_maps,
+                unsigned *num_maps)
+{
+        int ret;
+        const char *function = NULL;
+        unsigned long configs = 0;
+        bool has_config = 0;
+        unsigned reserve = 0;
+        struct property *prop;
+        const char *group, *gpio_name;
+        struct device_node *np_config;
+
+        ret = of_property_read_string(np, "ste,function", &function);
+        if (ret >= 0)
+                reserve = 1;
+
+        has_config = nmk_pinctrl_dt_get_config(np, &configs);
+
+        np_config = of_parse_phandle(np, "ste,config", 0);
+        if (np_config)
+                has_config |= nmk_pinctrl_dt_get_config(np_config, &configs);
+
+        ret = of_property_count_strings(np, "ste,pins");
+        if (ret < 0)
+                goto exit;
+
+        if (has_config)
+                reserve++;
+
+        reserve *= ret;
+
+        ret = nmk_dt_reserve_map(map, reserved_maps, num_maps, reserve);
+        if (ret < 0)
+                goto exit;
+
+        of_property_for_each_string(np, "ste,pins", prop, group) {
+                if (function) {
+                        ret = nmk_dt_add_map_mux(map, reserved_maps, num_maps,
+                                          group, function);
+                        if (ret < 0)
+                                goto exit;
+                }
+                if (has_config) {
+                        gpio_name = nmk_find_pin_name(pctldev, group);
+
+                        ret = nmk_dt_add_map_configs(map, reserved_maps, num_maps,
+                                              gpio_name, &configs, 1);
+                        if (ret < 0)
+                                goto exit;
+                }
+
+        }
+exit:
+        return ret;
+}
+
+int nmk_pinctrl_dt_node_to_map(struct pinctrl_dev *pctldev,
+                                 struct device_node *np_config,
+                                 struct pinctrl_map **map, unsigned *num_maps)
+{
+        unsigned reserved_maps;
+        struct device_node *np;
+        int ret;
+
+        reserved_maps = 0;
+        *map = NULL;
+        *num_maps = 0;
+
+        for_each_child_of_node(np_config, np) {
+                ret = nmk_pinctrl_dt_subnode_to_map(pctldev, np, map,
+                                &reserved_maps, num_maps);
+                if (ret < 0) {
+                        nmk_pinctrl_dt_free_map(pctldev, *map, *num_maps);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
 static struct pinctrl_ops nmk_pinctrl_ops = {
         .get_groups_count = nmk_get_groups_cnt,
         .get_group_name = nmk_get_group_name,
         .get_group_pins = nmk_get_group_pins,
         .pin_dbg_show = nmk_pin_dbg_show,
+        .dt_node_to_map = nmk_pinctrl_dt_node_to_map,
+        .dt_free_map = nmk_pinctrl_dt_free_map,
 };
 
 static int nmk_pmx_get_funcs_cnt(struct pinctrl_dev *pctldev)
@@ -1850,16 +2108,39 @@ static const struct of_device_id nmk_pinctrl_match[] = {
                 .data = (void *)PINCTRL_NMK_STN8815,
         },
         {
-                .compatible = "stericsson,nmk_pinctrl",
+                .compatible = "stericsson,nmk-pinctrl",
                 .data = (void *)PINCTRL_NMK_DB8500,
         },
         {},
 };
 
+static int nmk_pinctrl_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct nmk_pinctrl *npct;
+
+        npct = platform_get_drvdata(pdev);
+        if (!npct)
+                return -EINVAL;
+
+        return pinctrl_force_sleep(npct->pctl);
+}
+
+static int nmk_pinctrl_resume(struct platform_device *pdev)
+{
+        struct nmk_pinctrl *npct;
+
+        npct = platform_get_drvdata(pdev);
+        if (!npct)
+                return -EINVAL;
+
+        return pinctrl_force_default(npct->pctl);
+}
+
 static int nmk_pinctrl_probe(struct platform_device *pdev)
 {
         const struct platform_device_id *platid = platform_get_device_id(pdev);
         struct device_node *np = pdev->dev.of_node;
+        struct device_node *prcm_np;
         struct nmk_pinctrl *npct;
         struct resource *res;
         unsigned int version = 0;
@@ -1888,21 +2169,26 @@ static int nmk_pinctrl_probe(struct platform_device *pdev)
         if (version == PINCTRL_NMK_DB8540)
                 nmk_pinctrl_db8540_init(&npct->soc);
 
+        if (np) {
+                prcm_np = of_parse_phandle(np, "prcm", 0);
+                if (prcm_np)
+                        npct->prcm_base = of_iomap(prcm_np, 0);
+        }
+
+        /* Allow platform passed information to over-write DT. */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (res) {
+        if (res)
                 npct->prcm_base = devm_ioremap(&pdev->dev, res->start,
                                                resource_size(res));
-                if (!npct->prcm_base) {
-                        dev_err(&pdev->dev,
-                                "failed to ioremap PRCM registers\n");
-                        return -ENOMEM;
+        if (!npct->prcm_base) {
+                if (version == PINCTRL_NMK_STN8815) {
+                        dev_info(&pdev->dev,
+                                 "No PRCM base, "
+                                 "assuming no ALT-Cx control is available\n");
+                } else {
+                        dev_err(&pdev->dev, "missing PRCM base address\n");
+                        return -EINVAL;
                 }
-        } else if (version == PINCTRL_NMK_STN8815) {
-                dev_info(&pdev->dev,
-                         "No PRCM base, assume no ALT-Cx control is available\n");
-        } else {
-                dev_err(&pdev->dev, "missing PRCM base address\n");
-                return -EINVAL;
         }
 
         /*
@@ -1967,6 +2253,10 @@ static struct platform_driver nmk_pinctrl_driver = {
         },
         .probe = nmk_pinctrl_probe,
         .id_table = nmk_pinctrl_id,
+#ifdef CONFIG_PM
+        .suspend = nmk_pinctrl_suspend,
+        .resume = nmk_pinctrl_resume,
+#endif
 };
 
 static int __init nmk_gpio_init(void)