pinctrl: core device tree mapping table parsing support

During pinctrl_get(), if the client device has a device tree node, look
for the common pinctrl properties there. If found, parse the referenced
device tree nodes, with the help of the pinctrl drivers, and generate
mapping table entries from them.

During pinctrl_put(), free any results of device tree parsing.

Acked-by: Dong Aisheng <dong.aisheng@linaro.org>
Signed-off-by: Stephen Warren <swarren@wwwdotorg.org>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>

5 files changed, 350 insertions, 18 deletions

diff --git a/drivers/pinctrl/Makefile b/drivers/pinctrl/Makefile
index 6d4150b4eced..049c9fb39dab 100644
--- a/drivers/pinctrl/Makefile
+++ b/drivers/pinctrl/Makefile
@@ -5,6 +5,7 @@ ccflags-$(CONFIG_DEBUG_PINCTRL)	+= -DDEBUG
 obj-$(CONFIG_PINCTRL)           += core.o
 obj-$(CONFIG_PINMUX)            += pinmux.o
 obj-$(CONFIG_PINCONF)           += pinconf.o
+obj-$(CONFIG_OF)                += devicetree.o
 obj-$(CONFIG_GENERIC_PINCONF)   += pinconf-generic.o
 obj-$(CONFIG_PINCTRL_PXA3xx)    += pinctrl-pxa3xx.o
 obj-$(CONFIG_PINCTRL_MMP2)      += pinctrl-mmp2.o
diff --git a/drivers/pinctrl/core.c b/drivers/pinctrl/core.c
index df6296c5f47b..832f71dcd8c4 100644
--- a/drivers/pinctrl/core.c
+++ b/drivers/pinctrl/core.c
@@ -26,6 +26,7 @@
 #include <linux/pinctrl/pinctrl.h>
 #include <linux/pinctrl/machine.h>
 #include "core.h"
+#include "devicetree.h"
 #include "pinmux.h"
 #include "pinconf.h"
 
@@ -45,7 +46,7 @@ struct pinctrl_maps {
 DEFINE_MUTEX(pinctrl_mutex);
 
 /* Global list of pin control devices (struct pinctrl_dev) */
-static LIST_HEAD(pinctrldev_list);
+LIST_HEAD(pinctrldev_list);
 
 /* List of pin controller handles (struct pinctrl) */
 static LIST_HEAD(pinctrl_list);
@@ -579,6 +580,13 @@ static struct pinctrl *create_pinctrl(struct device *dev)
         }
         p->dev = dev;
         INIT_LIST_HEAD(&p->states);
+        INIT_LIST_HEAD(&p->dt_maps);
+
+        ret = pinctrl_dt_to_map(p);
+        if (ret < 0) {
+                kfree(p);
+                return ERR_PTR(ret);
+        }
 
         devname = dev_name(dev);
 
@@ -662,6 +670,8 @@ static void pinctrl_put_locked(struct pinctrl *p, bool inlist)
                 kfree(state);
         }
 
+        pinctrl_dt_free_maps(p);
+
         if (inlist)
                 list_del(&p->node);
         kfree(p);
@@ -787,15 +797,8 @@ int pinctrl_select_state(struct pinctrl *p, struct pinctrl_state *state)
 }
 EXPORT_SYMBOL_GPL(pinctrl_select_state);
 
-/**
- * pinctrl_register_mappings() - register a set of pin controller mappings
- * @maps: the pincontrol mappings table to register. This should probably be
- *      marked with __initdata so it can be discarded after boot. This
- *      function will perform a shallow copy for the mapping entries.
- * @num_maps: the number of maps in the mapping table
- */
-int pinctrl_register_mappings(struct pinctrl_map const *maps,
-                              unsigned num_maps)
+int pinctrl_register_map(struct pinctrl_map const *maps, unsigned num_maps,
+                         bool dup, bool locked)
 {
         int i, ret;
         struct pinctrl_maps *maps_node;
@@ -851,20 +854,52 @@ int pinctrl_register_mappings(struct pinctrl_map const *maps,
         }
 
         maps_node->num_maps = num_maps;
-        maps_node->maps = kmemdup(maps, sizeof(*maps) * num_maps, GFP_KERNEL);
-        if (!maps_node->maps) {
-                pr_err("failed to duplicate mapping table\n");
-                kfree(maps_node);
-                return -ENOMEM;
+        if (dup) {
+                maps_node->maps = kmemdup(maps, sizeof(*maps) * num_maps,
+                                          GFP_KERNEL);
+                if (!maps_node->maps) {
+                        pr_err("failed to duplicate mapping table\n");
+                        kfree(maps_node);
+                        return -ENOMEM;
+                }
+        } else {
+                maps_node->maps = maps;
         }
 
-        mutex_lock(&pinctrl_mutex);
+        if (!locked)
+                mutex_lock(&pinctrl_mutex);
         list_add_tail(&maps_node->node, &pinctrl_maps);
-        mutex_unlock(&pinctrl_mutex);
+        if (!locked)
+                mutex_unlock(&pinctrl_mutex);
 
         return 0;
 }
 
+/**
+ * pinctrl_register_mappings() - register a set of pin controller mappings
+ * @maps: the pincontrol mappings table to register. This should probably be
+ *      marked with __initdata so it can be discarded after boot. This
+ *      function will perform a shallow copy for the mapping entries.
+ * @num_maps: the number of maps in the mapping table
+ */
+int pinctrl_register_mappings(struct pinctrl_map const *maps,
+                              unsigned num_maps)
+{
+        return pinctrl_register_map(maps, num_maps, true, false);
+}
+
+void pinctrl_unregister_map(struct pinctrl_map const *map)
+{
+        struct pinctrl_maps *maps_node;
+
+        list_for_each_entry(maps_node, &pinctrl_maps, node) {
+                if (maps_node->maps == map) {
+                        list_del(&maps_node->node);
+                        return;
+                }
+        }
+}
+
 #ifdef CONFIG_DEBUG_FS
 
 static int pinctrl_pins_show(struct seq_file *s, void *what)
@@ -1231,6 +1266,9 @@ static int pinctrl_check_ops(struct pinctrl_dev *pctldev)
             !ops->get_group_pins)
                 return -EINVAL;
 
+        if (ops->dt_node_to_map && !ops->dt_free_map)
+                return -EINVAL;
+
         return 0;
 }
 
diff --git a/drivers/pinctrl/core.h b/drivers/pinctrl/core.h
index 17ecf651b123..98ae8085e735 100644
--- a/drivers/pinctrl/core.h
+++ b/drivers/pinctrl/core.h
@@ -52,12 +52,15 @@ struct pinctrl_dev {
  * @dev: the device using this pin control handle
  * @states: a list of states for this device
  * @state: the current state
+ * @dt_maps: the mapping table chunks dynamically parsed from device tree for
+ *      this device, if any
  */
 struct pinctrl {
         struct list_head node;
         struct device *dev;
         struct list_head states;
         struct pinctrl_state *state;
+        struct list_head dt_maps;
 };
 
 /**
@@ -100,7 +103,8 @@ struct pinctrl_setting_configs {
  * struct pinctrl_setting - an individual mux or config setting
  * @node: list node for struct pinctrl_settings's @settings field
  * @type: the type of setting
- * @pctldev: pin control device handling to be programmed
+ * @pctldev: pin control device handling to be programmed. Not used for
+ *   PIN_MAP_TYPE_DUMMY_STATE.
  * @data: Data specific to the setting type
  */
 struct pinctrl_setting {
@@ -153,4 +157,9 @@ static inline struct pin_desc *pin_desc_get(struct pinctrl_dev *pctldev,
         return radix_tree_lookup(&pctldev->pin_desc_tree, pin);
 }
 
+int pinctrl_register_map(struct pinctrl_map const *maps, unsigned num_maps,
+                         bool dup, bool locked);
+void pinctrl_unregister_map(struct pinctrl_map const *map);
+
 extern struct mutex pinctrl_mutex;
+extern struct list_head pinctrldev_list;
diff --git a/drivers/pinctrl/devicetree.c b/drivers/pinctrl/devicetree.c
new file mode 100644
index 000000000000..5ef2feb44395
--- /dev/null
+++ b/drivers/pinctrl/devicetree.c
@@ -0,0 +1,249 @@
+/*
+ * Device tree integration for the pin control subsystem
+ *
+ * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/device.h>
+#include <linux/of.h>
+#include <linux/pinctrl/pinctrl.h>
+#include <linux/slab.h>
+
+#include "core.h"
+#include "devicetree.h"
+
+/**
+ * struct pinctrl_dt_map - mapping table chunk parsed from device tree
+ * @node: list node for struct pinctrl's @dt_maps field
+ * @pctldev: the pin controller that allocated this struct, and will free it
+ * @maps: the mapping table entries
+ */
+struct pinctrl_dt_map {
+        struct list_head node;
+        struct pinctrl_dev *pctldev;
+        struct pinctrl_map *map;
+        unsigned num_maps;
+};
+
+static void dt_free_map(struct pinctrl_dev *pctldev,
+                     struct pinctrl_map *map, unsigned num_maps)
+{
+        if (pctldev) {
+                struct pinctrl_ops *ops = pctldev->desc->pctlops;
+                ops->dt_free_map(pctldev, map, num_maps);
+        } else {
+                /* There is no pctldev for PIN_MAP_TYPE_DUMMY_STATE */
+                kfree(map);
+        }
+}
+
+void pinctrl_dt_free_maps(struct pinctrl *p)
+{
+        struct pinctrl_dt_map *dt_map, *n1;
+
+        list_for_each_entry_safe(dt_map, n1, &p->dt_maps, node) {
+                pinctrl_unregister_map(dt_map->map);
+                list_del(&dt_map->node);
+                dt_free_map(dt_map->pctldev, dt_map->map,
+                            dt_map->num_maps);
+                kfree(dt_map);
+        }
+
+        of_node_put(p->dev->of_node);
+}
+
+static int dt_remember_or_free_map(struct pinctrl *p, const char *statename,
+                                   struct pinctrl_dev *pctldev,
+                                   struct pinctrl_map *map, unsigned num_maps)
+{
+        int i;
+        struct pinctrl_dt_map *dt_map;
+
+        /* Initialize common mapping table entry fields */
+        for (i = 0; i < num_maps; i++) {
+                map[i].dev_name = dev_name(p->dev);
+                map[i].name = statename;
+                if (pctldev)
+                        map[i].ctrl_dev_name = dev_name(pctldev->dev);
+        }
+
+        /* Remember the converted mapping table entries */
+        dt_map = kzalloc(sizeof(*dt_map), GFP_KERNEL);
+        if (!dt_map) {
+                dev_err(p->dev, "failed to alloc struct pinctrl_dt_map\n");
+                dt_free_map(pctldev, map, num_maps);
+                return -ENOMEM;
+        }
+
+        dt_map->pctldev = pctldev;
+        dt_map->map = map;
+        dt_map->num_maps = num_maps;
+        list_add_tail(&dt_map->node, &p->dt_maps);
+
+        return pinctrl_register_map(map, num_maps, false, true);
+}
+
+static struct pinctrl_dev *find_pinctrl_by_of_node(struct device_node *np)
+{
+        struct pinctrl_dev *pctldev;
+
+        list_for_each_entry(pctldev, &pinctrldev_list, node)
+                if (pctldev->dev->of_node == np)
+                        return pctldev;
+
+        return NULL;
+}
+
+static int dt_to_map_one_config(struct pinctrl *p, const char *statename,
+                                struct device_node *np_config)
+{
+        struct device_node *np_pctldev;
+        struct pinctrl_dev *pctldev;
+        struct pinctrl_ops *ops;
+        int ret;
+        struct pinctrl_map *map;
+        unsigned num_maps;
+
+        /* Find the pin controller containing np_config */
+        np_pctldev = of_node_get(np_config);
+        for (;;) {
+                np_pctldev = of_get_next_parent(np_pctldev);
+                if (!np_pctldev || of_node_is_root(np_pctldev)) {
+                        dev_err(p->dev, "could not find pctldev for node %s\n",
+                                np_config->full_name);
+                        of_node_put(np_pctldev);
+                        /* FIXME: This should trigger deferrered probe */
+                        return -ENODEV;
+                }
+                pctldev = find_pinctrl_by_of_node(np_pctldev);
+                if (pctldev)
+                        break;
+        }
+        of_node_put(np_pctldev);
+
+        /*
+         * Call pinctrl driver to parse device tree node, and
+         * generate mapping table entries
+         */
+        ops = pctldev->desc->pctlops;
+        if (!ops->dt_node_to_map) {
+                dev_err(p->dev, "pctldev %s doesn't support DT\n",
+                        dev_name(pctldev->dev));
+                return -ENODEV;
+        }
+        ret = ops->dt_node_to_map(pctldev, np_config, &map, &num_maps);
+        if (ret < 0)
+                return ret;
+
+        /* Stash the mapping table chunk away for later use */
+        return dt_remember_or_free_map(p, statename, pctldev, map, num_maps);
+}
+
+static int dt_remember_dummy_state(struct pinctrl *p, const char *statename)
+{
+        struct pinctrl_map *map;
+
+        map = kzalloc(sizeof(*map), GFP_KERNEL);
+        if (!map) {
+                dev_err(p->dev, "failed to alloc struct pinctrl_map\n");
+                return -ENOMEM;
+        }
+
+        /* There is no pctldev for PIN_MAP_TYPE_DUMMY_STATE */
+        map->type = PIN_MAP_TYPE_DUMMY_STATE;
+
+        return dt_remember_or_free_map(p, statename, NULL, map, 1);
+}
+
+int pinctrl_dt_to_map(struct pinctrl *p)
+{
+        struct device_node *np = p->dev->of_node;
+        int state, ret;
+        char *propname;
+        struct property *prop;
+        const char *statename;
+        const __be32 *list;
+        int size, config;
+        phandle phandle;
+        struct device_node *np_config;
+
+        /* CONFIG_OF enabled, p->dev not instantiated from DT */
+        if (!np) {
+                dev_dbg(p->dev, "no of_node; not parsing pinctrl DT\n");
+                return 0;
+        }
+
+        /* We may store pointers to property names within the node */
+        of_node_get(np);
+
+        /* For each defined state ID */
+        for (state = 0; ; state++) {
+                /* Retrieve the pinctrl-* property */
+                propname = kasprintf(GFP_KERNEL, "pinctrl-%d", state);
+                prop = of_find_property(np, propname, &size);
+                kfree(propname);
+                if (!prop)
+                        break;
+                list = prop->value;
+                size /= sizeof(*list);
+
+                /* Determine whether pinctrl-names property names the state */
+                ret = of_property_read_string_index(np, "pinctrl-names",
+                                                    state, &statename);
+                /*
+                 * If not, statename is just the integer state ID. But rather
+                 * than dynamically allocate it and have to free it later,
+                 * just point part way into the property name for the string.
+                 */
+                if (ret < 0) {
+                        /* strlen("pinctrl-") == 8 */
+                        statename = prop->name + 8;
+                }
+
+                /* For every referenced pin configuration node in it */
+                for (config = 0; config < size; config++) {
+                        phandle = be32_to_cpup(list++);
+
+                        /* Look up the pin configuration node */
+                        np_config = of_find_node_by_phandle(phandle);
+                        if (!np_config) {
+                                dev_err(p->dev,
+                                        "prop %s index %i invalid phandle\n",
+                                        prop->name, config);
+                                ret = -EINVAL;
+                                goto err;
+                        }
+
+                        /* Parse the node */
+                        ret = dt_to_map_one_config(p, statename, np_config);
+                        of_node_put(np_config);
+                        if (ret < 0)
+                                goto err;
+                }
+
+                /* No entries in DT? Generate a dummy state table entry */
+                if (!size) {
+                        ret = dt_remember_dummy_state(p, statename);
+                        if (ret < 0)
+                                goto err;
+                }
+        }
+
+        return 0;
+
+err:
+        pinctrl_dt_free_maps(p);
+        return ret;
+}
diff --git a/drivers/pinctrl/devicetree.h b/drivers/pinctrl/devicetree.h
new file mode 100644
index 000000000000..760bc4960f58
--- /dev/null
+++ b/drivers/pinctrl/devicetree.h
@@ -0,0 +1,35 @@
+/*
+ * Internal interface to pinctrl device tree integration
+ *
+ * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef CONFIG_OF
+
+void pinctrl_dt_free_maps(struct pinctrl *p);
+int pinctrl_dt_to_map(struct pinctrl *p);
+
+#else
+
+static inline int pinctrl_dt_to_map(struct pinctrl *p)
+{
+        return 0;
+}
+
+static inline void pinctrl_dt_free_maps(struct pinctrl *p)
+{
+}
+
+#endif