mtd: change struct flchip_shared spinlock locking into mutex

This patch prevent to schedule while atomic by changing the
flchip_shared spinlock into a mutex. This should be save since no atomic
path will use this lock.

It was suggested by Arnd Bergmann and Vasiliy Kulikov.

Signed-off-by: Stefani Seibold <stefani@seibold.net>
Signed-off-by: Artem Bityutskiy <Artem.Bityutskiy@nokia.com>
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>

1 files changed, 10 insertions, 10 deletions

diff --git a/drivers/mtd/lpddr/lpddr_cmds.c b/drivers/mtd/lpddr/lpddr_cmds.c
index fece5be58715..04fdfcca93f7 100644
--- a/drivers/mtd/lpddr/lpddr_cmds.c
+++ b/drivers/mtd/lpddr/lpddr_cmds.c
@@ -98,7 +98,7 @@ struct mtd_info *lpddr_cmdset(struct map_info *map)
         numchips = lpddr->numchips / lpddr->qinfo->HWPartsNum;
         for (i = 0; i < numchips; i++) {
                 shared[i].writing = shared[i].erasing = NULL;
-                spin_lock_init(&shared[i].lock);
+                mutex_init(&shared[i].lock);
                 for (j = 0; j < lpddr->qinfo->HWPartsNum; j++) {
                         *chip = lpddr->chips[i];
                         chip->start += j << lpddr->chipshift;
@@ -217,7 +217,7 @@ static int get_chip(struct map_info *map, struct flchip *chip, int mode)
                  */
                 struct flchip_shared *shared = chip->priv;
                 struct flchip *contender;
-                spin_lock(&shared->lock);
+                mutex_lock(&shared->lock);
                 contender = shared->writing;
                 if (contender && contender != chip) {
                         /*
@@ -230,7 +230,7 @@ static int get_chip(struct map_info *map, struct flchip *chip, int mode)
                          * get_chip returns success we're clear to go ahead.
                          */
                         ret = mutex_trylock(&contender->mutex);
-                        spin_unlock(&shared->lock);
+                        mutex_unlock(&shared->lock);
                         if (!ret)
                                 goto retry;
                         mutex_unlock(&chip->mutex);
@@ -245,7 +245,7 @@ static int get_chip(struct map_info *map, struct flchip *chip, int mode)
                                 mutex_unlock(&contender->mutex);
                                 return ret;
                         }
-                        spin_lock(&shared->lock);
+                        mutex_lock(&shared->lock);
 
                         /* We should not own chip if it is already in FL_SYNCING
                          * state. Put contender and retry. */
@@ -261,7 +261,7 @@ static int get_chip(struct map_info *map, struct flchip *chip, int mode)
                    Must sleep in such a case. */
                 if (mode == FL_ERASING && shared->erasing
                     && shared->erasing->oldstate == FL_ERASING) {
-                        spin_unlock(&shared->lock);
+                        mutex_unlock(&shared->lock);
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&chip->wq, &wait);
                         mutex_unlock(&chip->mutex);
@@ -275,7 +275,7 @@ static int get_chip(struct map_info *map, struct flchip *chip, int mode)
                 shared->writing = chip;
                 if (mode == FL_ERASING)
                         shared->erasing = chip;
-                spin_unlock(&shared->lock);
+                mutex_unlock(&shared->lock);
         }
 
         ret = chip_ready(map, chip, mode);
@@ -348,7 +348,7 @@ static void put_chip(struct map_info *map, struct flchip *chip)
 {
         if (chip->priv) {
                 struct flchip_shared *shared = chip->priv;
-                spin_lock(&shared->lock);
+                mutex_lock(&shared->lock);
                 if (shared->writing == chip && chip->oldstate == FL_READY) {
                         /* We own the ability to write, but we're done */
                         shared->writing = shared->erasing;
@@ -356,7 +356,7 @@ static void put_chip(struct map_info *map, struct flchip *chip)
                                 /* give back the ownership */
                                 struct flchip *loaner = shared->writing;
                                 mutex_lock(&loaner->mutex);
-                                spin_unlock(&shared->lock);
+                                mutex_unlock(&shared->lock);
                                 mutex_unlock(&chip->mutex);
                                 put_chip(map, loaner);
                                 mutex_lock(&chip->mutex);
@@ -374,11 +374,11 @@ static void put_chip(struct map_info *map, struct flchip *chip)
                          * Don't let the switch below mess things up since
                          * we don't have ownership to resume anything.
                          */
-                        spin_unlock(&shared->lock);
+                        mutex_unlock(&shared->lock);
                         wake_up(&chip->wq);
                         return;
                 }
-                spin_unlock(&shared->lock);
+                mutex_unlock(&shared->lock);
         }
 
         switch (chip->oldstate) {