pinctrl: don't create a device for each pin controller

Pin controllers should already be instantiated as a device, so there's
no need for the pinctrl core to create a new struct device for each
controller.

This allows the controller's real name to be used in the mux mapping
table, rather than e.g. "pinctrl.0", "pinctrl.1", etc.

This necessitates removal of the PINMUX_MAP_PRIMARY*() macros, since
their sole purpose was to hard-code the .ctrl_dev_name field to be
"pinctrl.0".

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

4 files changed, 41 insertions, 61 deletions

diff --git a/drivers/pinctrl/core.c b/drivers/pinctrl/core.c
index 034b1ad38b32..160fb5aae591 100644
--- a/drivers/pinctrl/core.c
+++ b/drivers/pinctrl/core.c
@@ -34,12 +34,6 @@
 static DEFINE_MUTEX(pinctrldev_list_mutex);
 static LIST_HEAD(pinctrldev_list);
 
-static void pinctrl_dev_release(struct device *dev)
-{
-        struct pinctrl_dev *pctldev = dev_get_drvdata(dev);
-        kfree(pctldev);
-}
-
 const char *pinctrl_dev_get_name(struct pinctrl_dev *pctldev)
 {
         /* We're not allowed to register devices without name */
@@ -71,14 +65,14 @@ struct pinctrl_dev *get_pinctrl_dev_from_dev(struct device *dev,
 
         mutex_lock(&pinctrldev_list_mutex);
         list_for_each_entry(pctldev, &pinctrldev_list, node) {
-                if (dev &&  &pctldev->dev == dev) {
+                if (dev && pctldev->dev == dev) {
                         /* Matched on device pointer */
                         found = true;
                         break;
                 }
 
                 if (devname &&
-                    !strcmp(dev_name(&pctldev->dev), devname)) {
+                    !strcmp(dev_name(pctldev->dev), devname)) {
                         /* Matched on device name */
                         found = true;
                         break;
@@ -325,7 +319,7 @@ int pinctrl_get_group_selector(struct pinctrl_dev *pctldev,
                 const char *gname = pctlops->get_group_name(pctldev,
                                                             group_selector);
                 if (!strcmp(gname, pin_group)) {
-                        dev_dbg(&pctldev->dev,
+                        dev_dbg(pctldev->dev,
                                 "found group selector %u for %s\n",
                                 group_selector,
                                 pin_group);
@@ -335,7 +329,7 @@ int pinctrl_get_group_selector(struct pinctrl_dev *pctldev,
                 group_selector++;
         }
 
-        dev_err(&pctldev->dev, "does not have pin group %s\n",
+        dev_err(pctldev->dev, "does not have pin group %s\n",
                 pin_group);
 
         return -EINVAL;
@@ -508,11 +502,11 @@ static void pinctrl_init_device_debugfs(struct pinctrl_dev *pctldev)
 {
         static struct dentry *device_root;
 
-        device_root = debugfs_create_dir(dev_name(&pctldev->dev),
+        device_root = debugfs_create_dir(dev_name(pctldev->dev),
                                          debugfs_root);
         if (IS_ERR(device_root) || !device_root) {
                 pr_warn("failed to create debugfs directory for %s\n",
-                        dev_name(&pctldev->dev));
+                        dev_name(pctldev->dev));
                 return;
         }
         debugfs_create_file("pins", S_IFREG | S_IRUGO,
@@ -560,7 +554,6 @@ static void pinctrl_init_debugfs(void)
 struct pinctrl_dev *pinctrl_register(struct pinctrl_desc *pctldesc,
                                     struct device *dev, void *driver_data)
 {
-        static atomic_t pinmux_no = ATOMIC_INIT(0);
         struct pinctrl_dev *pctldev;
         int ret;
 
@@ -601,18 +594,7 @@ struct pinctrl_dev *pinctrl_register(struct pinctrl_desc *pctldesc,
         spin_lock_init(&pctldev->pin_desc_tree_lock);
         INIT_LIST_HEAD(&pctldev->gpio_ranges);
         mutex_init(&pctldev->gpio_ranges_lock);
-
-        /* Register device */
-        pctldev->dev.parent = dev;
-        dev_set_name(&pctldev->dev, "pinctrl.%d",
-                     atomic_inc_return(&pinmux_no) - 1);
-        pctldev->dev.release = pinctrl_dev_release;
-        ret = device_register(&pctldev->dev);
-        if (ret != 0) {
-                pr_err("error in device registration\n");
-                goto out_reg_dev_err;
-        }
-        dev_set_drvdata(&pctldev->dev, pctldev);
+        pctldev->dev = dev;
 
         /* Register all the pins */
         pr_debug("try to register %d pins on %s...\n",
@@ -622,7 +604,7 @@ struct pinctrl_dev *pinctrl_register(struct pinctrl_desc *pctldesc,
                 pr_err("error during pin registration\n");
                 pinctrl_free_pindescs(pctldev, pctldesc->pins,
                                       pctldesc->npins);
-                goto out_reg_pins_err;
+                goto out_err;
         }
 
         pinctrl_init_device_debugfs(pctldev);
@@ -632,10 +614,8 @@ struct pinctrl_dev *pinctrl_register(struct pinctrl_desc *pctldesc,
         pinmux_hog_maps(pctldev);
         return pctldev;
 
-out_reg_pins_err:
-        device_del(&pctldev->dev);
-out_reg_dev_err:
-        put_device(&pctldev->dev);
+out_err:
+        kfree(pctldev);
         return NULL;
 }
 EXPORT_SYMBOL_GPL(pinctrl_register);
@@ -659,7 +639,7 @@ void pinctrl_unregister(struct pinctrl_dev *pctldev)
         /* Destroy descriptor tree */
         pinctrl_free_pindescs(pctldev, pctldev->desc->pins,
                               pctldev->desc->npins);
-        device_unregister(&pctldev->dev);
+        kfree(pctldev);
 }
 EXPORT_SYMBOL_GPL(pinctrl_unregister);
 
diff --git a/drivers/pinctrl/core.h b/drivers/pinctrl/core.h
index 3f5b911acf18..5375582566a5 100644
--- a/drivers/pinctrl/core.h
+++ b/drivers/pinctrl/core.h
@@ -38,7 +38,7 @@ struct pinctrl_dev {
         spinlock_t pin_desc_tree_lock;
         struct list_head gpio_ranges;
         struct mutex gpio_ranges_lock;
-        struct device dev;
+        struct device *dev;
         struct module *owner;
         void *driver_data;
 #ifdef CONFIG_PINMUX
diff --git a/drivers/pinctrl/pinconf.c b/drivers/pinctrl/pinconf.c
index 9195eefe258a..124762b57024 100644
--- a/drivers/pinctrl/pinconf.c
+++ b/drivers/pinctrl/pinconf.c
@@ -29,7 +29,7 @@ int pin_config_get_for_pin(struct pinctrl_dev *pctldev, unsigned pin,
         const struct pinconf_ops *ops = pctldev->desc->confops;
 
         if (!ops || !ops->pin_config_get) {
-                dev_err(&pctldev->dev, "cannot get pin configuration, missing "
+                dev_err(pctldev->dev, "cannot get pin configuration, missing "
                         "pin_config_get() function in driver\n");
                 return -EINVAL;
         }
@@ -65,14 +65,14 @@ int pin_config_set_for_pin(struct pinctrl_dev *pctldev, unsigned pin,
         int ret;
 
         if (!ops || !ops->pin_config_set) {
-                dev_err(&pctldev->dev, "cannot configure pin, missing "
+                dev_err(pctldev->dev, "cannot configure pin, missing "
                         "config function in driver\n");
                 return -EINVAL;
         }
 
         ret = ops->pin_config_set(pctldev, pin, config);
         if (ret) {
-                dev_err(&pctldev->dev,
+                dev_err(pctldev->dev,
                         "unable to set pin configuration on pin %d\n", pin);
                 return ret;
         }
@@ -108,7 +108,7 @@ int pin_config_group_get(struct pinctrl_dev *pctldev, const char *pin_group,
         int selector;
 
         if (!ops || !ops->pin_config_group_get) {
-                dev_err(&pctldev->dev, "cannot get configuration for pin "
+                dev_err(pctldev->dev, "cannot get configuration for pin "
                         "group, missing group config get function in "
                         "driver\n");
                 return -EINVAL;
@@ -135,7 +135,7 @@ int pin_config_group_set(struct pinctrl_dev *pctldev, const char *pin_group,
         int i;
 
         if (!ops || (!ops->pin_config_group_set && !ops->pin_config_set)) {
-                dev_err(&pctldev->dev, "cannot configure pin group, missing "
+                dev_err(pctldev->dev, "cannot configure pin group, missing "
                         "config function in driver\n");
                 return -EINVAL;
         }
@@ -146,7 +146,7 @@ int pin_config_group_set(struct pinctrl_dev *pctldev, const char *pin_group,
 
         ret = pctlops->get_group_pins(pctldev, selector, &pins, &num_pins);
         if (ret) {
-                dev_err(&pctldev->dev, "cannot configure pin group, error "
+                dev_err(pctldev->dev, "cannot configure pin group, error "
                         "getting pins\n");
                 return ret;
         }
diff --git a/drivers/pinctrl/pinmux.c b/drivers/pinctrl/pinmux.c
index a11681b4bd91..3bcc64137ddc 100644
--- a/drivers/pinctrl/pinmux.c
+++ b/drivers/pinctrl/pinmux.c
@@ -106,24 +106,24 @@ static int pin_request(struct pinctrl_dev *pctldev,
         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, function);
 
         desc = pin_desc_get(pctldev, pin);
         if (desc == NULL) {
-                dev_err(&pctldev->dev,
+                dev_err(pctldev->dev,
                         "pin is not registered so it cannot be requested\n");
                 goto out;
         }
 
         if (!function) {
-                dev_err(&pctldev->dev, "no function name given\n");
+                dev_err(pctldev->dev, "no function name given\n");
                 return -EINVAL;
         }
 
         spin_lock(&desc->lock);
         if (desc->mux_function) {
                 spin_unlock(&desc->lock);
-                dev_err(&pctldev->dev,
+                dev_err(pctldev->dev,
                         "pin already requested\n");
                 goto out;
         }
@@ -132,7 +132,7 @@ static int pin_request(struct pinctrl_dev *pctldev,
 
         /* Let each pin increase references to this module */
         if (!try_module_get(pctldev->owner)) {
-                dev_err(&pctldev->dev,
+                dev_err(pctldev->dev,
                         "could not increase module refcount for pin %d\n",
                         pin);
                 status = -EINVAL;
@@ -152,7 +152,7 @@ static int pin_request(struct pinctrl_dev *pctldev,
                 status = 0;
 
         if (status)
-                dev_err(&pctldev->dev, "->request on device %s failed "
+                dev_err(pctldev->dev, "->request on device %s failed "
                        "for pin %d\n",
                        pctldev->desc->name, pin);
 out_free_pin:
@@ -163,7 +163,7 @@ out_free_pin:
         }
 out:
         if (status)
-                dev_err(&pctldev->dev, "pin-%d (%s) status %d\n",
+                dev_err(pctldev->dev, "pin-%d (%s) status %d\n",
                        pin, function ? : "?", status);
 
         return status;
@@ -189,7 +189,7 @@ static const char *pin_free(struct pinctrl_dev *pctldev, int pin,
 
         desc = pin_desc_get(pctldev, pin);
         if (desc == NULL) {
-                dev_err(&pctldev->dev,
+                dev_err(pctldev->dev,
                         "pin is not registered so it cannot be freed\n");
                 return NULL;
         }
@@ -434,14 +434,14 @@ static int acquire_pins(struct pinctrl_dev *pctldev,
         if (ret)
                 return ret;
 
-        dev_dbg(&pctldev->dev, "requesting the %u pins from group %u\n",
+        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], func, NULL);
                 if (ret) {
-                        dev_err(&pctldev->dev,
+                        dev_err(pctldev->dev,
                                 "could not get pin %d for function %s "
                                 "on device %s - conflicting mux mappings?\n",
                                 pins[i], func ? : "(undefined)",
@@ -473,7 +473,7 @@ static void release_pins(struct pinctrl_dev *pctldev,
         ret = pctlops->get_group_pins(pctldev, group_selector,
                                       &pins, &num_pins);
         if (ret) {
-                dev_err(&pctldev->dev, "could not get pins to release for "
+                dev_err(pctldev->dev, "could not get pins to release for "
                         "group selector %d\n",
                         group_selector);
                 return;
@@ -525,7 +525,7 @@ static int pinmux_check_pin_group(struct pinctrl_dev *pctldev,
                         return -EINVAL;
                 ret = pinctrl_get_group_selector(pctldev, groups[0]);
                 if (ret < 0) {
-                        dev_err(&pctldev->dev,
+                        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),
@@ -534,7 +534,7 @@ static int pinmux_check_pin_group(struct pinctrl_dev *pctldev,
                 }
 
                 if (num_groups > 1)
-                        dev_dbg(&pctldev->dev,
+                        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),
@@ -544,13 +544,13 @@ static int pinmux_check_pin_group(struct pinctrl_dev *pctldev,
                 return ret;
         }
 
-        dev_dbg(&pctldev->dev,
+        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,
+                dev_dbg(pctldev->dev,
                         "%s does not support pin group %s with function %s\n",
                         pinctrl_dev_get_name(pctldev),
                         pin_group,
@@ -627,7 +627,7 @@ static int pinmux_enable_muxmap(struct pinctrl_dev *pctldev,
          */
 
         if (pmx->pctldev && pmx->pctldev != pctldev) {
-                dev_err(&pctldev->dev,
+                dev_err(pctldev->dev,
                         "different pin control devices given for device %s, "
                         "function %s\n",
                         devname,
@@ -650,7 +650,7 @@ static int pinmux_enable_muxmap(struct pinctrl_dev *pctldev,
          */
         if (pmx->func_selector != UINT_MAX &&
             pmx->func_selector != func_selector) {
-                dev_err(&pctldev->dev,
+                dev_err(pctldev->dev,
                         "dual function defines in the map for device %s\n",
                        devname);
                 return -EINVAL;
@@ -756,7 +756,7 @@ struct pinmux *pinmux_get(struct device *dev, const char *name)
                 }
 
                 pr_debug("in map, found pctldev %s to handle function %s",
-                         dev_name(&pctldev->dev), map->function);
+                         dev_name(pctldev->dev), map->function);
 
 
                 /*
@@ -932,7 +932,7 @@ static int pinmux_hog_map(struct pinctrl_dev *pctldev,
                  * without any problems, so then we can hog pinmuxes for
                  * all devices that just want a static pin mux at this point.
                  */
-                dev_err(&pctldev->dev, "map %s wants to hog a non-system "
+                dev_err(pctldev->dev, "map %s wants to hog a non-system "
                         "pinmux, this is not going to work\n", map->name);
                 return -EINVAL;
         }
@@ -944,7 +944,7 @@ static int pinmux_hog_map(struct pinctrl_dev *pctldev,
         pmx = pinmux_get(NULL, map->name);
         if (IS_ERR(pmx)) {
                 kfree(hog);
-                dev_err(&pctldev->dev,
+                dev_err(pctldev->dev,
                         "could not get the %s pinmux mapping for hogging\n",
                         map->name);
                 return PTR_ERR(pmx);
@@ -954,7 +954,7 @@ static int pinmux_hog_map(struct pinctrl_dev *pctldev,
         if (ret) {
                 pinmux_put(pmx);
                 kfree(hog);
-                dev_err(&pctldev->dev,
+                dev_err(pctldev->dev,
                         "could not enable the %s pinmux mapping for hogging\n",
                         map->name);
                 return ret;
@@ -963,7 +963,7 @@ static int pinmux_hog_map(struct pinctrl_dev *pctldev,
         hog->map = map;
         hog->pmx = pmx;
 
-        dev_info(&pctldev->dev, "hogged map %s, function %s\n", map->name,
+        dev_info(pctldev->dev, "hogged map %s, function %s\n", map->name,
                  map->function);
         mutex_lock(&pctldev->pinmux_hogs_lock);
         list_add(&hog->node, &pctldev->pinmux_hogs);
@@ -982,7 +982,7 @@ static int pinmux_hog_map(struct pinctrl_dev *pctldev,
  */
 int pinmux_hog_maps(struct pinctrl_dev *pctldev)
 {
-        struct device *dev = &pctldev->dev;
+        struct device *dev = pctldev->dev;
         const char *devname = dev_name(dev);
         int ret;
         int i;