pinctrl: refactor struct pinctrl handling in core.c vs pinmux.c

This change separates two aspects of struct pinctrl:

a) The data representation of the parsed mapping table, into:

   1) The top-level struct pinctrl object, a single entity returned
      by pinctrl_get().

   2) The parsed version of each mapping table entry, struct
      pinctrl_setting, of which there is one per mapping table entry.

b) The code that handles this; the code for (1) above is in core.c, and
   the code to parse/execute each entry in (2) above is in pinmux.c, while
   the iteration over multiple settings is lifted to core.c.

This will allow the following future changes:

1) pinctrl_get() API rework, so that struct pinctrl represents all states
   for the device, and the device can select between them without calling
   put()/get() again.

2) To support that, a struct pinctrl_state object will be inserted into
   the data model between the struct pinctrl and struct pinctrl_setting.

3) The mapping table will be extended to allow specification of pin config
   settings too. To support this, struct pinctrl_setting will be enhanced
   to store either mux settings or config settings, and functions will be
   added to pinconf.c to parse/execute pin configuration settings.

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

1 files changed, 98 insertions, 304 deletions

diff --git a/drivers/pinctrl/pinmux.c b/drivers/pinctrl/pinmux.c
index 7342c26f4246..f0fb98d252e8 100644
--- a/drivers/pinctrl/pinmux.c
+++ b/drivers/pinctrl/pinmux.c
@@ -7,6 +7,8 @@
  *
  * Author: Linus Walleij <linus.walleij@linaro.org>
  *
+ * Copyright (C) 2012 NVIDIA CORPORATION. All rights reserved.
+ *
  * License terms: GNU General Public License (GPL) version 2
  */
 #define pr_fmt(fmt) "pinmux core: " fmt
@@ -28,19 +30,6 @@
 #include "core.h"
 #include "pinmux.h"
 
-/**
- * struct pinmux_group - group list item for pinmux groups
- * @node: pinmux group list node
- * @func_selector: the function selector for the pinmux device handling
- *      this pinmux
- * @group_selector: the group selector for this group
- */
-struct pinmux_group {
-        struct list_head node;
-        unsigned func_selector;
-        unsigned group_selector;
-};
-
 int pinmux_check_ops(struct pinctrl_dev *pctldev)
 {
         const struct pinmux_ops *ops = pctldev->desc->pmxops;
@@ -244,164 +233,8 @@ int pinmux_gpio_direction(struct pinctrl_dev *pctldev,
         return ret;
 }
 
-/**
- * acquire_pins() - acquire all the pins for a certain function on a pinmux
- * @pctldev: the device to take the pins on
- * @owner: a representation of the owner of this pin; typically the device
- *      name that controls its mux function
- * @group_selector: the group selector containing the pins to acquire
- */
-static int acquire_pins(struct pinctrl_dev *pctldev,
-                        const char *owner,
-                        unsigned group_selector)
-{
-        const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
-        const unsigned *pins;
-        unsigned num_pins;
-        int ret;
-        int i;
-
-        ret = pctlops->get_group_pins(pctldev, group_selector,
-                                      &pins, &num_pins);
-        if (ret)
-                return ret;
-
-        dev_dbg(pctldev->dev, "requesting the %u pins from group %u\n",
-                num_pins, group_selector);
-
-        /* Try to allocate all pins in this group, one by one */
-        for (i = 0; i < num_pins; i++) {
-                ret = pin_request(pctldev, pins[i], owner, NULL);
-                if (ret) {
-                        dev_err(pctldev->dev,
-                                "could not get request pin %d on device %s - conflicting mux mappings?\n",
-                                pins[i],
-                                pinctrl_dev_get_name(pctldev));
-                        /* On error release all taken pins */
-                        i--; /* this pin just failed */
-                        for (; i >= 0; i--)
-                                pin_free(pctldev, pins[i], NULL);
-                        return -ENODEV;
-                }
-        }
-        return 0;
-}
-
-/**
- * release_pins() - release pins taken by earlier acquirement
- * @pctldev: the device to free the pins on
- * @group_selector: the group selector containing the pins to free
- */
-static void release_pins(struct pinctrl_dev *pctldev,
-                         unsigned group_selector)
-{
-        const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
-        const unsigned *pins;
-        unsigned num_pins;
-        int ret;
-        int i;
-
-        ret = pctlops->get_group_pins(pctldev, group_selector,
-                                      &pins, &num_pins);
-        if (ret) {
-                dev_err(pctldev->dev, "could not get pins to release for group selector %d\n",
-                        group_selector);
-                return;
-        }
-        for (i = 0; i < num_pins; i++)
-                pin_free(pctldev, pins[i], NULL);
-}
-
-/**
- * pinmux_check_pin_group() - check function and pin group combo
- * @pctldev: device to check the pin group vs function for
- * @func_selector: the function selector to check the pin group for, we have
- *      already looked this up in the calling function
- * @pin_group: the pin group to match to the function
- *
- * This function will check that the pinmux driver can supply the
- * selected pin group for a certain function, returns the group selector if
- * the group and function selector will work fine together, else returns
- * negative
- */
-static int pinmux_check_pin_group(struct pinctrl_dev *pctldev,
-                                  unsigned func_selector,
-                                  const char *pin_group)
-{
-        const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
-        const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
-        int ret;
-
-        /*
-         * If the driver does not support different pin groups for the
-         * functions, we only support group 0, and assume this exists.
-         */
-        if (!pctlops || !pctlops->list_groups)
-                return 0;
-
-        /*
-         * Passing NULL (no specific group) will select the first and
-         * hopefully only group of pins available for this function.
-         */
-        if (!pin_group) {
-                char const * const *groups;
-                unsigned num_groups;
-
-                ret = pmxops->get_function_groups(pctldev, func_selector,
-                                                  &groups, &num_groups);
-                if (ret)
-                        return ret;
-                if (num_groups < 1)
-                        return -EINVAL;
-                ret = pinctrl_get_group_selector(pctldev, groups[0]);
-                if (ret < 0) {
-                        dev_err(pctldev->dev,
-                                "function %s wants group %s but the pin controller does not seem to have that group\n",
-                                pmxops->get_function_name(pctldev, func_selector),
-                                groups[0]);
-                        return ret;
-                }
-
-                if (num_groups > 1)
-                        dev_dbg(pctldev->dev,
-                                "function %s support more than one group, default-selecting first group %s (%d)\n",
-                                pmxops->get_function_name(pctldev, func_selector),
-                                groups[0],
-                                ret);
-
-                return ret;
-        }
-
-        dev_dbg(pctldev->dev,
-                "check if we have pin group %s on controller %s\n",
-                pin_group, pinctrl_dev_get_name(pctldev));
-
-        ret = pinctrl_get_group_selector(pctldev, pin_group);
-        if (ret < 0) {
-                dev_dbg(pctldev->dev,
-                        "%s does not support pin group %s with function %s\n",
-                        pinctrl_dev_get_name(pctldev),
-                        pin_group,
-                        pmxops->get_function_name(pctldev, func_selector));
-        }
-        return ret;
-}
-
-/**
- * pinmux_search_function() - check pin control driver for a certain function
- * @pctldev: device to check for function and position
- * @map: function map containing the function and position to look for
- * @func_selector: returns the applicable function selector if found
- * @group_selector: returns the applicable group selector if found
- *
- * This will search the pinmux driver for an applicable
- * function with a specific pin group, returns 0 if these can be mapped
- * negative otherwise
- */
-static int pinmux_search_function(struct pinctrl_dev *pctldev,
-                                  struct pinctrl_map const *map,
-                                  unsigned *func_selector,
-                                  unsigned *group_selector)
+static int pinmux_func_name_to_selector(struct pinctrl_dev *pctldev,
+                                        const char *function)
 {
         const struct pinmux_ops *ops = pctldev->desc->pmxops;
         unsigned selector = 0;
@@ -410,155 +243,128 @@ static int pinmux_search_function(struct pinctrl_dev *pctldev,
         while (ops->list_functions(pctldev, selector) >= 0) {
                 const char *fname = ops->get_function_name(pctldev,
                                                            selector);
-                int ret;
 
-                if (!strcmp(map->function, fname)) {
-                        /* Found the function, check pin group */
-                        ret = pinmux_check_pin_group(pctldev, selector,
-                                                     map->group);
-                        if (ret < 0)
-                                return ret;
+                if (!strcmp(function, fname))
+                        return selector;
 
-                        /* This function and group selector can be used */
-                        *func_selector = selector;
-                        *group_selector = ret;
-                        return 0;
-
-                }
                 selector++;
         }
 
         pr_err("%s does not support function %s\n",
-               pinctrl_dev_get_name(pctldev), map->function);
+               pinctrl_dev_get_name(pctldev), function);
         return -EINVAL;
 }
 
-/**
- * pinmux_enable_muxmap() - enable a map entry for a certain pinmux
- */
-static int pinmux_enable_muxmap(struct pinctrl_dev *pctldev,
-                                struct pinctrl *p,
-                                struct device *dev,
-                                const char *devname,
-                                struct pinctrl_map const *map)
+int pinmux_map_to_setting(struct pinctrl_map const *map,
+                          struct pinctrl_setting *setting)
 {
-        unsigned func_selector;
-        unsigned group_selector;
-        struct pinmux_group *grp;
+        struct pinctrl_dev *pctldev = setting->pctldev;
+        const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
+        const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
+        char const * const *groups;
+        unsigned num_groups;
         int ret;
+        const char *group;
+        int i;
+        const unsigned *pins;
+        unsigned num_pins;
 
-        /*
-         * Note that we're not locking the pinmux mutex here, because
-         * this is only called at pinmux initialization time when it
-         * has not been added to any list and thus is not reachable
-         * by anyone else.
-         */
+        setting->func_selector =
+                pinmux_func_name_to_selector(pctldev, map->function);
+        if (setting->func_selector < 0)
+                return setting->func_selector;
 
-        if (p->pctldev && p->pctldev != pctldev) {
-                dev_err(pctldev->dev,
-                        "different pin control devices given for device %s, function %s\n",
-                        devname, map->function);
+        ret = pmxops->get_function_groups(pctldev, setting->func_selector,
+                                          &groups, &num_groups);
+        if (ret < 0)
+                return ret;
+        if (!num_groups)
                 return -EINVAL;
+
+        if (map->group) {
+                bool found = false;
+                group = map->group;
+                for (i = 0; i < num_groups; i++) {
+                        if (!strcmp(group, groups[i])) {
+                                found = true;
+                                break;
+                        }
+                }
+                if (!found)
+                        return -EINVAL;
+        } else {
+                group = groups[0];
         }
-        p->dev = dev;
-        p->pctldev = pctldev;
 
-        /* Now go into the driver and try to match a function and group */
-        ret = pinmux_search_function(pctldev, map, &func_selector,
-                                     &group_selector);
-        if (ret < 0)
-                return ret;
+        setting->group_selector =
+                pinctrl_get_group_selector(pctldev, group);
+        if (setting->group_selector < 0)
+                return setting->group_selector;
 
-        /* Now add this group selector, we may have many of them */
-        grp = kmalloc(sizeof(*grp), GFP_KERNEL);
-        if (!grp)
-                return -ENOMEM;
-        grp->func_selector = func_selector;
-        grp->group_selector = group_selector;
-        ret = acquire_pins(pctldev, devname, group_selector);
+        ret = pctlops->get_group_pins(pctldev, setting->group_selector,
+                                      &pins, &num_pins);
         if (ret) {
-                kfree(grp);
-                return ret;
+                dev_err(pctldev->dev,
+                        "could not get pins for device %s group selector %d\n",
+                        pinctrl_dev_get_name(pctldev), setting->group_selector);
+                        return -ENODEV;
+        }
+
+        /* Try to allocate all pins in this group, one by one */
+        for (i = 0; i < num_pins; i++) {
+                ret = pin_request(pctldev, pins[i], map->dev_name, NULL);
+                if (ret) {
+                        dev_err(pctldev->dev,
+                                "could not get request pin %d on device %s\n",
+                                pins[i], pinctrl_dev_get_name(pctldev));
+                        /* On error release all taken pins */
+                        i--; /* this pin just failed */
+                        for (; i >= 0; i--)
+                                pin_free(pctldev, pins[i], NULL);
+                        return -ENODEV;
+                }
         }
-        list_add_tail(&grp->node, &p->groups);
 
         return 0;
 }
 
-/**
- * pinmux_apply_muxmap() - apply a certain mux mapping entry
- */
-int pinmux_apply_muxmap(struct pinctrl_dev *pctldev,
-                        struct pinctrl *p,
-                        struct device *dev,
-                        const char *devname,
-                        struct pinctrl_map const *map)
+void pinmux_free_setting(struct pinctrl_setting const *setting)
 {
+        struct pinctrl_dev *pctldev = setting->pctldev;
+        const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
+        const unsigned *pins;
+        unsigned num_pins;
         int ret;
+        int i;
 
-        ret = pinmux_enable_muxmap(pctldev, p, dev,
-                                   devname, map);
+        ret = pctlops->get_group_pins(pctldev, setting->group_selector,
+                                      &pins, &num_pins);
         if (ret) {
-                pinmux_put(p);
-                return ret;
+                dev_err(pctldev->dev,
+                        "could not get pins for device %s group selector %d\n",
+                        pinctrl_dev_get_name(pctldev), setting->group_selector);
+                return;
         }
 
-        return 0;
-}
-
-/**
- * pinmux_put() - free up the pinmux portions of a pin controller handle
- */
-void pinmux_put(struct pinctrl *p)
-{
-        struct list_head *node, *tmp;
-
-        list_for_each_safe(node, tmp, &p->groups) {
-                struct pinmux_group *grp =
-                        list_entry(node, struct pinmux_group, node);
-                /* Release all pins taken by this group */
-                release_pins(p->pctldev, grp->group_selector);
-                list_del(node);
-                kfree(grp);
-        }
+        for (i = 0; i < num_pins; i++)
+                pin_free(pctldev, pins[i], NULL);
 }
 
-/**
- * pinmux_enable() - enable the pinmux portion of a pin control handle
- */
-int pinmux_enable(struct pinctrl *p)
+int pinmux_enable_setting(struct pinctrl_setting const *setting)
 {
-        struct pinctrl_dev *pctldev = p->pctldev;
+        struct pinctrl_dev *pctldev = setting->pctldev;
         const struct pinmux_ops *ops = pctldev->desc->pmxops;
-        struct pinmux_group *grp;
-        int ret;
 
-        list_for_each_entry(grp, &p->groups, node) {
-                ret = ops->enable(pctldev, grp->func_selector,
-                                  grp->group_selector);
-                if (ret)
-                        /*
-                         * TODO: call disable() on all groups we called
-                         * enable() on to this point?
-                         */
-                        return ret;
-        }
-        return 0;
+        return ops->enable(pctldev, setting->func_selector,
+                           setting->group_selector);
 }
 
-/**
- * pinmux_disable() - disable the pinmux portions of a pin control handle
- */
-void pinmux_disable(struct pinctrl *p)
+void pinmux_disable_setting(struct pinctrl_setting const *setting)
 {
-        struct pinctrl_dev *pctldev = p->pctldev;
+        struct pinctrl_dev *pctldev = setting->pctldev;
         const struct pinmux_ops *ops = pctldev->desc->pmxops;
-        struct pinmux_group *grp;
 
-        list_for_each_entry(grp, &p->groups, node) {
-                ops->disable(pctldev, grp->func_selector,
-                             grp->group_selector);
-        }
+        ops->disable(pctldev, setting->func_selector, setting->group_selector);
 }
 
 #ifdef CONFIG_DEBUG_FS
@@ -635,30 +441,18 @@ static int pinmux_pins_show(struct seq_file *s, void *what)
         return 0;
 }
 
-void pinmux_dbg_show(struct seq_file *s, struct pinctrl *p)
+void pinmux_dbg_show(struct seq_file *s, struct pinctrl_setting const *setting)
 {
-        struct pinctrl_dev *pctldev = p->pctldev;
-        const struct pinmux_ops *pmxops;
-        const struct pinctrl_ops *pctlops;
-        struct pinmux_group *grp;
-        const char *sep = "";
-
-        pmxops = pctldev->desc->pmxops;
-        pctlops = pctldev->desc->pctlops;
-
-        seq_printf(s, " groups: [");
-        list_for_each_entry(grp, &p->groups, node) {
-                seq_printf(s, "%s%s (%u)=%s (%u)",
-                           sep,
-                           pctlops->get_group_name(pctldev,
-                                                   grp->group_selector),
-                           grp->group_selector,
-                           pmxops->get_function_name(pctldev,
-                                                     grp->func_selector),
-                           grp->func_selector);
-                sep = ", ";
-        }
-        seq_printf(s, " ]");
+        struct pinctrl_dev *pctldev = setting->pctldev;
+        const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
+        const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
+
+        seq_printf(s, "controller: %s group: %s (%u) function: %s (%u)\n",
+                   pinctrl_dev_get_name(pctldev),
+                   pctlops->get_group_name(pctldev, setting->group_selector),
+                   setting->group_selector,
+                   pmxops->get_function_name(pctldev, setting->func_selector),
+                   setting->func_selector);
 }
 
 static int pinmux_functions_open(struct inode *inode, struct file *file)