pinctrl: record a pin owner, not mux function, when requesting pins

When pins are requested/acquired/got, some device becomes the owner of
their mux setting. At this point, it isn't certain which mux function
will be selected for the pin, since this may vary between each of the
device's states in the pinctrl mapping table. As such, we should record
the owning device, not what we think the initial mux setting will be,
when requesting pins.

This doesn't make a lot of difference right now since pinctrl_get gets
only one single device/state combination, but this will make a difference
when pinctrl_get gets all states, and pinctrl_select_state can switch
between states.

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

2 files changed, 32 insertions, 41 deletions

diff --git a/drivers/pinctrl/core.h b/drivers/pinctrl/core.h
index 7c305672919e..061c57d0e8f9 100644
--- a/drivers/pinctrl/core.h
+++ b/drivers/pinctrl/core.h
@@ -94,7 +94,7 @@ struct pin_desc {
         spinlock_t lock;
         /* These fields only added when supporting pinmux drivers */
 #ifdef CONFIG_PINMUX
-        const char *mux_function;
+        const char *owner;
 #endif
 };
 
diff --git a/drivers/pinctrl/pinmux.c b/drivers/pinctrl/pinmux.c
index ea31c4655667..288789750f96 100644
--- a/drivers/pinctrl/pinmux.c
+++ b/drivers/pinctrl/pinmux.c
@@ -71,21 +71,20 @@ int pinmux_check_ops(struct pinctrl_dev *pctldev)
 /**
  * pin_request() - request a single pin to be muxed in, typically for GPIO
  * @pin: the pin number in the global pin space
- * @function: a functional name to give to this pin, passed to the driver
- *      so it knows what function to mux in, e.g. the string "gpioNN"
- *      means that you want to mux in the pin for use as GPIO number NN
+ * @owner: a representation of the owner of this pin; typically the device
+ *      name that controls its mux function, or the requested GPIO name
  * @gpio_range: the range matching the GPIO pin if this is a request for a
  *      single GPIO pin
  */
 static int pin_request(struct pinctrl_dev *pctldev,
-                       int pin, const char *function,
+                       int pin, const char *owner,
                        struct pinctrl_gpio_range *gpio_range)
 {
         struct pin_desc *desc;
         const struct pinmux_ops *ops = pctldev->desc->pmxops;
         int status = -EINVAL;
 
-        dev_dbg(pctldev->dev, "request pin %d for %s\n", pin, function);
+        dev_dbg(pctldev->dev, "request pin %d for %s\n", pin, owner);
 
         desc = pin_desc_get(pctldev, pin);
         if (desc == NULL) {
@@ -94,19 +93,14 @@ static int pin_request(struct pinctrl_dev *pctldev,
                 goto out;
         }
 
-        if (!function) {
-                dev_err(pctldev->dev, "no function name given\n");
-                return -EINVAL;
-        }
-
         spin_lock(&desc->lock);
-        if (desc->mux_function) {
+        if (desc->owner && strcmp(desc->owner, owner)) {
                 spin_unlock(&desc->lock);
                 dev_err(pctldev->dev,
                         "pin already requested\n");
                 goto out;
         }
-        desc->mux_function = function;
+        desc->owner = owner;
         spin_unlock(&desc->lock);
 
         /* Let each pin increase references to this module */
@@ -136,13 +130,13 @@ static int pin_request(struct pinctrl_dev *pctldev,
 out_free_pin:
         if (status) {
                 spin_lock(&desc->lock);
-                desc->mux_function = NULL;
+                desc->owner = NULL;
                 spin_unlock(&desc->lock);
         }
 out:
         if (status)
                 dev_err(pctldev->dev, "pin-%d (%s) status %d\n",
-                       pin, function ? : "?", status);
+                       pin, owner, status);
 
         return status;
 }
@@ -154,8 +148,8 @@ out:
  * @gpio_range: the range matching the GPIO pin if this is a request for a
  *      single GPIO pin
  *
- * This function returns a pointer to the function name in use. This is used
- * for callers that dynamically allocate a function name so it can be freed
+ * This function returns a pointer to the previous owner. This is used
+ * for callers that dynamically allocate an owner name so it can be freed
  * once the pin is free. This is done for GPIO request functions.
  */
 static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
@@ -163,7 +157,7 @@ static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
 {
         const struct pinmux_ops *ops = pctldev->desc->pmxops;
         struct pin_desc *desc;
-        const char *func;
+        const char *owner;
 
         desc = pin_desc_get(pctldev, pin);
         if (desc == NULL) {
@@ -182,12 +176,12 @@ static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
                 ops->free(pctldev, pin);
 
         spin_lock(&desc->lock);
-        func = desc->mux_function;
-        desc->mux_function = NULL;
+        owner = desc->owner;
+        desc->owner = NULL;
         spin_unlock(&desc->lock);
         module_put(pctldev->owner);
 
-        return func;
+        return owner;
 }
 
 /**
@@ -201,19 +195,19 @@ int pinmux_request_gpio(struct pinctrl_dev *pctldev,
                         unsigned pin, unsigned gpio)
 {
         char gpiostr[16];
-        const char *function;
+        const char *owner;
         int ret;
 
         /* Conjure some name stating what chip and pin this is taken by */
         snprintf(gpiostr, 15, "%s:%d", range->name, gpio);
 
-        function = kstrdup(gpiostr, GFP_KERNEL);
-        if (!function)
+        owner = kstrdup(gpiostr, GFP_KERNEL);
+        if (!owner)
                 return -EINVAL;
 
-        ret = pin_request(pctldev, pin, function, range);
+        ret = pin_request(pctldev, pin, owner, range);
         if (ret < 0)
-                kfree(function);
+                kfree(owner);
 
         return ret;
 }
@@ -227,10 +221,10 @@ int pinmux_request_gpio(struct pinctrl_dev *pctldev,
 void pinmux_free_gpio(struct pinctrl_dev *pctldev, unsigned pin,
                       struct pinctrl_gpio_range *range)
 {
-        const char *func;
+        const char *owner;
 
-        func = pin_free(pctldev, pin, range);
-        kfree(func);
+        owner = pin_free(pctldev, pin, range);
+        kfree(owner);
 }
 
 /**
@@ -260,17 +254,15 @@ int pinmux_gpio_direction(struct pinctrl_dev *pctldev,
 /**
  * acquire_pins() - acquire all the pins for a certain function on a pinmux