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
  * @pctldev: the device to take the pins on
- * @func_selector: the function selector to acquire the pins for
+ * @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,
-                        unsigned func_selector,
+                        const char *owner,
                         unsigned group_selector)
 {
         const struct pinctrl_ops *pctlops = pctldev->desc->pctlops;
-        const struct pinmux_ops *pmxops = pctldev->desc->pmxops;
-        const char *func = pmxops->get_function_name(pctldev,
-                                                     func_selector);
         const unsigned *pins;
         unsigned num_pins;
         int ret;
@@ -286,11 +278,11 @@ static int acquire_pins(struct pinctrl_dev *pctldev,
 
         /* Try to allocate all pins in this group, one by one */
         for (i = 0; i < num_pins; i++) {
-                ret = pin_request(pctldev, pins[i], func, NULL);
+                ret = pin_request(pctldev, pins[i], owner, NULL);
                 if (ret) {
                         dev_err(pctldev->dev,
-                                "could not get pin %d for function %s on device %s - conflicting mux mappings?\n",
-                                pins[i], func ? : "(undefined)",
+                                "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 */
@@ -503,7 +495,7 @@ static int pinmux_enable_muxmap(struct pinctrl_dev *pctldev,
         if (!grp)
                 return -ENOMEM;
         grp->group_selector = group_selector;
-        ret = acquire_pins(pctldev, func_selector, group_selector);
+        ret = acquire_pins(pctldev, devname, group_selector);
         if (ret) {
                 kfree(grp);
                 return ret;
@@ -630,7 +622,7 @@ static int pinmux_pins_show(struct seq_file *s, void *what)
         unsigned i, pin;
 
         seq_puts(s, "Pinmux settings per pin\n");
-        seq_puts(s, "Format: pin (name): pinmuxfunction\n");
+        seq_puts(s, "Format: pin (name): owner\n");
 
         /* The pin number can be retrived from the pin controller descriptor */
         for (i = 0; i < pctldev->desc->npins; i++) {
@@ -645,8 +637,7 @@ static int pinmux_pins_show(struct seq_file *s, void *what)
 
                 seq_printf(s, "pin %d (%s): %s\n", pin,
                            desc->name ? desc->name : "unnamed",
-                           desc->mux_function ? desc->mux_function
-                                              : "UNCLAIMED");
+                           desc->owner ? desc->owner : "UNCLAIMED");
         }
 
         return 0;