pinctrl: move subsystem mutex to pinctrl_dev struct

This mutex avoids deadlock in case of use of multiple pin
controllers. Before this modification, by using a global
mutex, deadlock appeared when, for example, a call to
pinctrl_pins_show() locked the pinctrl_mutex, called the
ops->pin_dbg_show of a particular pin controller. If this
pin controller needs I2C access to retrieve configuration
information and I2C driver is using pinctrl to drive its
pins, a call to pinctrl_select_state() try to lock again
pinctrl_mutex which leads to a deadlock.

Notice that the mutex grab from the two direction functions
was moved into pinctrl_gpio_direction().

For several cases, we can't replace pinctrl_mutex by
pctldev->mutex, because at this stage, pctldev is
not accessible :
	- pinctrl_get()/pinctrl_put()
	- pinctrl_register_maps()

So add respectively pinctrl_list_mutex and
pinctrl_maps_mutex in order to protect
pinctrl_list and pinctrl_maps list instead.

Reintroduce pinctrldev_list_mutex in
find_pinctrl_by_of_node(),
pinctrl_find_and_add_gpio_range()
pinctrl_request_gpio(), pinctrl_free_gpio(),
pinctrl_gpio_direction(), pinctrl_devices_show(),
pinctrl_register() and pinctrl_unregister() to
protect pinctrldev_list.

Changes v2->v3:
- Fix a missing EXPORT_SYMBOL_GPL() for pinctrl_select_state().

Changes v1->v2:
- pinctrl_select_state_locked() is removed, all lock mechanism
  is located inside pinctrl_select_state(). When parsing
  the state->setting list, take the per-pin-controller driver
  lock. (Patrice).
- Introduce pinctrldev_list_mutex to protect pinctrldev_list
  in all functions which parse or modify pictrldev_list.
  (Patrice).
- move find_pinctrl_by_of_node() from pinctrl/devicetree.c to
  pinctrl/core.c in order to protect pinctrldev_list.
  (Patrice).
- Sink mutex:es into some functions and remove some _locked
  variants down to where the lists are actually accessed to
  make things simpler. (Linus)
- Drop *all* mutexes completely from pinctrl_lookup_state()
  and pinctrl_select_state() - no relevant mutex was taken
  and it was unclear what this was protecting against. (Linus)

Reported by : Seraphin Bonnaffe <seraphin.bonnaffe@stericsson.com>
Signed-off-by: Patrice Chotard <patrice.chotard@st.com>
Signed-off-by: Linus Walleij <linus.walleij@linaro.org>

5 files changed, 176 insertions, 164 deletions

diff --git a/drivers/pinctrl/core.c b/drivers/pinctrl/core.c
index 8b832ce6a8e3..c3d222ed39a2 100644
--- a/drivers/pinctrl/core.c
+++ b/drivers/pinctrl/core.c
@@ -40,11 +40,17 @@
 
 static bool pinctrl_dummy_state;
 
-/* Mutex taken by all entry points */
-DEFINE_MUTEX(pinctrl_mutex);
+/* Mutex taken to protect pinctrl_list */
+DEFINE_MUTEX(pinctrl_list_mutex);
+
+/* Mutex taken to protect pinctrl_maps */
+DEFINE_MUTEX(pinctrl_maps_mutex);
+
+/* Mutex taken to protect pinctrldev_list */
+DEFINE_MUTEX(pinctrldev_list_mutex);
 
 /* Global list of pin control devices (struct pinctrl_dev) */
-LIST_HEAD(pinctrldev_list);
+static LIST_HEAD(pinctrldev_list);
 
 /* List of pin controller handles (struct pinctrl) */
 static LIST_HEAD(pinctrl_list);
@@ -111,6 +117,23 @@ struct pinctrl_dev *get_pinctrl_dev_from_devname(const char *devname)
         return found ? pctldev : NULL;
 }
 
+struct pinctrl_dev *get_pinctrl_dev_from_of_node(struct device_node *np)
+{
+        struct pinctrl_dev *pctldev;
+
+        mutex_lock(&pinctrldev_list_mutex);
+
+        list_for_each_entry(pctldev, &pinctrldev_list, node)
+                if (pctldev->dev->of_node == np) {
+                        mutex_unlock(&pinctrldev_list_mutex);
+                        return pctldev;
+                }
+
+        mutex_lock(&pinctrldev_list_mutex);
+
+        return NULL;
+}
+
 /**
  * pin_get_from_name() - look up a pin number from a name
  * @pctldev: the pin control device to lookup the pin on
@@ -170,9 +193,9 @@ bool pin_is_valid(struct pinctrl_dev *pctldev, int pin)
         if (pin < 0)
                 return false;
 
-        mutex_lock(&pinctrl_mutex);
+        mutex_lock(&pctldev->mutex);
         pindesc = pin_desc_get(pctldev, pin);
-        mutex_unlock(&pinctrl_mutex);
+        mutex_unlock(&pctldev->mutex);
 
         return pindesc != NULL;
 }
@@ -269,15 +292,17 @@ pinctrl_match_gpio_range(struct pinctrl_dev *pctldev, unsigned gpio)
 {
         struct pinctrl_gpio_range *range = NULL;
 
+        mutex_lock(&pctldev->mutex);
         /* Loop over the ranges */
         list_for_each_entry(range, &pctldev->gpio_ranges, node) {
                 /* Check if we're in the valid range */
                 if (gpio >= range->base &&
                     gpio < range->base + range->npins) {
+                        mutex_unlock(&pctldev->mutex);
                         return range;
                 }
         }
-
+        mutex_unlock(&pctldev->mutex);
         return NULL;
 }
 
@@ -361,9 +386,9 @@ static int pinctrl_get_device_gpio_range(unsigned gpio,
 void pinctrl_add_gpio_range(struct pinctrl_dev *pctldev,
                             struct pinctrl_gpio_range *range)
 {
-        mutex_lock(&pinctrl_mutex);
+        mutex_lock(&pctldev->mutex);
         list_add_tail(&range->node, &pctldev->gpio_ranges);
-        mutex_unlock(&pinctrl_mutex);
+        mutex_unlock(&pctldev->mutex);
 }
 EXPORT_SYMBOL_GPL(pinctrl_add_gpio_range);
 
@@ -381,17 +406,25 @@ EXPORT_SYMBOL_GPL(pinctrl_add_gpio_ranges);
 struct pinctrl_dev *pinctrl_find_and_add_gpio_range(const char *devname,
                 struct pinctrl_gpio_range *range)
 {
-        struct pinctrl_dev *pctldev = get_pinctrl_dev_from_devname(devname);
+        struct pinctrl_dev *pctldev;
+
+        mutex_lock(&pinctrldev_list_mutex);
+
+        pctldev = get_pinctrl_dev_from_devname(devname);
 
         /*
          * If we can't find this device, let's assume that is because
          * it has not probed yet, so the driver trying to register this
          * range need to defer probing.
          */
-        if (!pctldev)
+        if (!pctldev) {
+                mutex_unlock(&pinctrldev_list_mutex);
                 return ERR_PTR(-EPROBE_DEFER);
-
+        }
         pinctrl_add_gpio_range(pctldev, range);
+
+        mutex_unlock(&pinctrldev_list_mutex);
+
         return pctldev;
 }
 EXPORT_SYMBOL_GPL(pinctrl_find_and_add_gpio_range);
@@ -407,14 +440,17 @@ pinctrl_find_gpio_range_from_pin(struct pinctrl_dev *pctldev,
 {
         struct pinctrl_gpio_range *range = NULL;
 
+        mutex_lock(&pctldev->mutex);
         /* Loop over the ranges */
         list_for_each_entry(range, &pctldev->gpio_ranges, node) {
                 /* Check if we're in the valid range */
                 if (pin >= range->pin_base &&
                     pin < range->pin_base + range->npins) {
+                        mutex_unlock(&pctldev->mutex);
                         return range;
                 }
         }
+        mutex_unlock(&pctldev->mutex);
 
         return NULL;
 }
@@ -428,9 +464,9 @@ EXPORT_SYMBOL_GPL(pinctrl_find_gpio_range_from_pin);
 void pinctrl_remove_gpio_range(struct pinctrl_dev *pctldev,
                                struct pinctrl_gpio_range *range)
 {
-        mutex_lock(&pinctrl_mutex);
+        mutex_lock(&pctldev->mutex);
         list_del(&range->node);
-        mutex_unlock(&pinctrl_mutex);
+        mutex_unlock(&pctldev->mutex);
 }
 EXPORT_SYMBOL_GPL(pinctrl_remove_gpio_range);
 
@@ -481,13 +517,13 @@ int pinctrl_request_gpio(unsigned gpio)
         int ret;
         int pin;