CRISv32: ETRAXFS: Fix recursive spinlock

Move pinmux alloc/dealloc code into functions that don't take
the spinlock so we can use from code that has the spinlock already.

CRISv32 has no working SMP, so spinlocks becomes a NOP,
so deadlock was never seen.

Signed-off-by: Jesper Nilsson <jesper.nilsson@axis.com>

diff --git a/arch/cris/arch-v32/mach-fs/pinmux.c b/arch/cris/arch-v32/mach-fs/pinmux.c
index 38f29ee..05a0470 100644 (file)
--- a/arch/cris/arch-v32/mach-fs/pinmux.c
+++ b/arch/cris/arch-v32/mach-fs/pinmux.c
@@ -26,7 +26,29 @@ static DEFINE_SPINLOCK(pinmux_lock);
 
 static void crisv32_pinmux_set(int port);
 
-int crisv32_pinmux_init(void)
+static int __crisv32_pinmux_alloc(int port, int first_pin, int last_pin,
+                                enum pin_mode mode)
+{
+       int i;
+
+       for (i = first_pin; i <= last_pin; i++) {
+               if ((pins[port][i] != pinmux_none)
+                   && (pins[port][i] != pinmux_gpio)
+                   && (pins[port][i] != mode)) {
+#ifdef DEBUG
+                       panic("Pinmux alloc failed!\n");
+#endif
+                       return -EPERM;
+               }
+       }
+
+       for (i = first_pin; i <= last_pin; i++)
+               pins[port][i] = mode;
+
+       crisv32_pinmux_set(port);
+}
+
+static int crisv32_pinmux_init(void)
 {
        static int initialized;
 
@@ -37,20 +59,20 @@ int crisv32_pinmux_init(void)
                pa.pa0 = pa.pa1 = pa.pa2 = pa.pa3 =
                    pa.pa4 = pa.pa5 = pa.pa6 = pa.pa7 = regk_pinmux_yes;
                REG_WR(pinmux, regi_pinmux, rw_pa, pa);
-               crisv32_pinmux_alloc(PORT_B, 0, PORT_PINS - 1, pinmux_gpio);
-               crisv32_pinmux_alloc(PORT_C, 0, PORT_PINS - 1, pinmux_gpio);
-               crisv32_pinmux_alloc(PORT_D, 0, PORT_PINS - 1, pinmux_gpio);
-               crisv32_pinmux_alloc(PORT_E, 0, PORT_PINS - 1, pinmux_gpio);
+               __crisv32_pinmux_alloc(PORT_B, 0, PORT_PINS - 1, pinmux_gpio);
+               __crisv32_pinmux_alloc(PORT_C, 0, PORT_PINS - 1, pinmux_gpio);
+               __crisv32_pinmux_alloc(PORT_D, 0, PORT_PINS - 1, pinmux_gpio);
+               __crisv32_pinmux_alloc(PORT_E, 0, PORT_PINS - 1, pinmux_gpio);
        }
 
        return 0;
 }
 
-int
-crisv32_pinmux_alloc(int port, int first_pin, int last_pin, enum pin_mode mode)
+int crisv32_pinmux_alloc(int port, int first_pin, int last_pin,
+                        enum pin_mode mode)
 {
-       int i;
        unsigned long flags;
+       int ret;
 
        crisv32_pinmux_init();
 
@@ -59,26 +81,11 @@ crisv32_pinmux_alloc(int port, int first_pin, int last_pin, enum pin_mode mode)
 
        spin_lock_irqsave(&pinmux_lock, flags);
 
-       for (i = first_pin; i <= last_pin; i++) {
-               if ((pins[port][i] != pinmux_none)
-                   && (pins[port][i] != pinmux_gpio)
-                   && (pins[port][i] != mode)) {
-                       spin_unlock_irqrestore(&pinmux_lock, flags);
-#ifdef DEBUG
-                       panic("Pinmux alloc failed!\n");
-#endif
-                       return -EPERM;
-               }
-       }
-
-       for (i = first_pin; i <= last_pin; i++)
-               pins[port][i] = mode;
-
-       crisv32_pinmux_set(port);
+       ret = __crisv32_pinmux_alloc(port, first_pin, last_pin, mode);
 
        spin_unlock_irqrestore(&pinmux_lock, flags);
 
-       return 0;
+       return ret;
 }
 
 int crisv32_pinmux_alloc_fixed(enum fixed_function function)
@@ -98,58 +105,58 @@ int crisv32_pinmux_alloc_fixed(enum fixed_function function)
 
        switch (function) {
        case pinmux_ser1:
-               ret = crisv32_pinmux_alloc(PORT_C, 4, 7, pinmux_fixed);
+               ret = __crisv32_pinmux_alloc(PORT_C, 4, 7, pinmux_fixed);
                hwprot.ser1 = regk_pinmux_yes;
                break;
        case pinmux_ser2:
-               ret = crisv32_pinmux_alloc(PORT_C, 8, 11, pinmux_fixed);
+               ret = __crisv32_pinmux_alloc(PORT_C, 8, 11, pinmux_fixed);
                hwprot.ser2 = regk_pinmux_yes;
                break;
        case pinmux_ser3:
-               ret = crisv32_pinmux_alloc(PORT_C, 12, 15, pinmux_fixed);
+               ret = __crisv32_pinmux_alloc(PORT_C, 12, 15, pinmux_fixed);
                hwprot.ser3 = regk_pinmux_yes;
                break;
        case pinmux_sser0:
-               ret = crisv32_pinmux_alloc(PORT_C, 0, 3, pinmux_fixed);
-               ret |= crisv32_pinmux_alloc(PORT_C, 16, 16, pinmux_fixed);
+               ret = __crisv32_pinmux_alloc(PORT_C, 0, 3, pinmux_fixed);
+               ret |= __crisv32_pinmux_alloc(PORT_C, 16, 16, pinmux_fixed);
                hwprot.sser0 = regk_pinmux_yes;
                break;
        case pinmux_sser1:
-               ret = crisv32_pinmux_alloc(PORT_D, 0, 4, pinmux_fixed);
+               ret = __crisv32_pinmux_alloc(PORT_D, 0, 4, pinmux_fixed);
                hwprot.sser1 = regk_pinmux_yes;
                break;
        case pinmux_ata0:
-               ret = crisv32_pinmux_alloc(PORT_D, 5, 7, pinmux_fixed);
-               ret |= crisv32_pinmux_alloc(PORT_D, 15, 17, pinmux_fixed);
+               ret = __crisv32_pinmux_alloc(PORT_D, 5, 7, pinmux_fixed);
+               ret |= __crisv32_pinmux_alloc(PORT_D, 15, 17, pinmux_fixed);
                hwprot.ata0 = regk_pinmux_yes;
                break;
        case pinmux_ata1:
-               ret = crisv32_pinmux_alloc(PORT_D, 0, 4, pinmux_fixed);
-               ret |= crisv32_pinmux_alloc(PORT_E, 17, 17, pinmux_fixed);
+               ret = __crisv32_pinmux_alloc(PORT_D, 0, 4, pinmux_fixed);
+               ret |= __crisv32_pinmux_alloc(PORT_E, 17, 17, pinmux_fixed);
                hwprot.ata1 = regk_pinmux_yes;
                break;
        case pinmux_ata2:
-               ret = crisv32_pinmux_alloc(PORT_C, 11, 15, pinmux_fixed);
-               ret |= crisv32_pinmux_alloc(PORT_E, 3, 3, pinmux_fixed);
+               ret = __crisv32_pinmux_alloc(PORT_C, 11, 15, pinmux_fixed);
+               ret |= __crisv32_pinmux_alloc(PORT_E, 3, 3, pinmux_fixed);
                hwprot.ata2 = regk_pinmux_yes;
                break;
        case pinmux_ata3:
-               ret = crisv32_pinmux_alloc(PORT_C, 8, 10, pinmux_fixed);
-               ret |= crisv32_pinmux_alloc(PORT_C, 0, 2, pinmux_fixed);
+               ret = __crisv32_pinmux_alloc(PORT_C, 8, 10, pinmux_fixed);
+               ret |= __crisv32_pinmux_alloc(PORT_C, 0, 2, pinmux_fixed);
                hwprot.ata2 = regk_pinmux_yes;
                break;
        case pinmux_ata:
-               ret = crisv32_pinmux_alloc(PORT_B, 0, 15, pinmux_fixed);
-               ret |= crisv32_pinmux_alloc(PORT_D, 8, 15, pinmux_fixed);
+               ret = __crisv32_pinmux_alloc(PORT_B, 0, 15, pinmux_fixed);
+               ret |= __crisv32_pinmux_alloc(PORT_D, 8, 15, pinmux_fixed);
                hwprot.ata = regk_pinmux_yes;
                break;
        case pinmux_eth1:
-               ret = crisv32_pinmux_alloc(PORT_E, 0, 17, pinmux_fixed);
+               ret = __crisv32_pinmux_alloc(PORT_E, 0, 17, pinmux_fixed);
                hwprot.eth1 = regk_pinmux_yes;
                hwprot.eth1_mgm = regk_pinmux_yes;
                break;
        case pinmux_timer:
-               ret = crisv32_pinmux_alloc(PORT_C, 16, 16, pinmux_fixed);
+               ret = __crisv32_pinmux_alloc(PORT_C, 16, 16, pinmux_fixed);
                hwprot.timer = regk_pinmux_yes;
                spin_unlock_irqrestore(&pinmux_lock, flags);
                return ret;
@@ -188,9 +195,19 @@ void crisv32_pinmux_set(int port)
 #endif
 }
 
-int crisv32_pinmux_dealloc(int port, int first_pin, int last_pin)
+static int __crisv32_pinmux_dealloc(int port, int first_pin, int last_pin)
 {
        int i;
+
+       for (i = first_pin; i <= last_pin; i++)
+               pins[port][i] = pinmux_none;
+
+       crisv32_pinmux_set(port);
+       return 0;
+}
+
+int crisv32_pinmux_dealloc(int port, int first_pin, int last_pin)
+{
        unsigned long flags;
 
        crisv32_pinmux_init();
@@ -199,11 +216,7 @@ int crisv32_pinmux_dealloc(int port, int first_pin, int last_pin)
                return -EINVAL;
 
        spin_lock_irqsave(&pinmux_lock, flags);
-
-       for (i = first_pin; i <= last_pin; i++)
-               pins[port][i] = pinmux_none;
-
-       crisv32_pinmux_set(port);
+       __crisv32_pinmux_dealloc(port, first_pin, last_pin);
        spin_unlock_irqrestore(&pinmux_lock, flags);
 
        return 0;
@@ -226,58 +239,58 @@ int crisv32_pinmux_dealloc_fixed(enum fixed_function function)
 
        switch (function) {
        case pinmux_ser1:
-               ret = crisv32_pinmux_dealloc(PORT_C, 4, 7);
+               ret = __crisv32_pinmux_dealloc(PORT_C, 4, 7);
                hwprot.ser1 = regk_pinmux_no;
                break;
        case pinmux_ser2:
-               ret = crisv32_pinmux_dealloc(PORT_C, 8, 11);
+               ret = __crisv32_pinmux_dealloc(PORT_C, 8, 11);
                hwprot.ser2 = regk_pinmux_no;
                break;
        case pinmux_ser3:
-               ret = crisv32_pinmux_dealloc(PORT_C, 12, 15);
+               ret = __crisv32_pinmux_dealloc(PORT_C, 12, 15);
                hwprot.ser3 = regk_pinmux_no;
                break;
        case pinmux_sser0:
-               ret = crisv32_pinmux_dealloc(PORT_C, 0, 3);
-               ret |= crisv32_pinmux_dealloc(PORT_C, 16, 16);
+               ret = __crisv32_pinmux_dealloc(PORT_C, 0, 3);
+               ret |= __crisv32_pinmux_dealloc(PORT_C, 16, 16);
                hwprot.sser0 = regk_pinmux_no;
                break;
        case pinmux_sser1:
-               ret = crisv32_pinmux_dealloc(PORT_D, 0, 4);
+               ret = __crisv32_pinmux_dealloc(PORT_D, 0, 4);
                hwprot.sser1 = regk_pinmux_no;
                break;
        case pinmux_ata0:
-               ret = crisv32_pinmux_dealloc(PORT_D, 5, 7);
-               ret |= crisv32_pinmux_dealloc(PORT_D, 15, 17);
+               ret = __crisv32_pinmux_dealloc(PORT_D, 5, 7);
+               ret |= __crisv32_pinmux_dealloc(PORT_D, 15, 17);
                hwprot.ata0 = regk_pinmux_no;
                break;
        case pinmux_ata1:
-               ret = crisv32_pinmux_dealloc(PORT_D, 0, 4);
-               ret |= crisv32_pinmux_dealloc(PORT_E, 17, 17);
+               ret = __crisv32_pinmux_dealloc(PORT_D, 0, 4);
+               ret |= __crisv32_pinmux_dealloc(PORT_E, 17, 17);
                hwprot.ata1 = regk_pinmux_no;
                break;
        case pinmux_ata2:
-               ret = crisv32_pinmux_dealloc(PORT_C, 11, 15);
-               ret |= crisv32_pinmux_dealloc(PORT_E, 3, 3);
+               ret = __crisv32_pinmux_dealloc(PORT_C, 11, 15);
+               ret |= __crisv32_pinmux_dealloc(PORT_E, 3, 3);
                hwprot.ata2 = regk_pinmux_no;
                break;
        case pinmux_ata3:
-               ret = crisv32_pinmux_dealloc(PORT_C, 8, 10);
-               ret |= crisv32_pinmux_dealloc(PORT_C, 0, 2);
+               ret = __crisv32_pinmux_dealloc(PORT_C, 8, 10);
+               ret |= __crisv32_pinmux_dealloc(PORT_C, 0, 2);
                hwprot.ata2 = regk_pinmux_no;
                break;
        case pinmux_ata:
-               ret = crisv32_pinmux_dealloc(PORT_B, 0, 15);
-               ret |= crisv32_pinmux_dealloc(PORT_D, 8, 15);
+               ret = __crisv32_pinmux_dealloc(PORT_B, 0, 15);
+               ret |= __crisv32_pinmux_dealloc(PORT_D, 8, 15);
                hwprot.ata = regk_pinmux_no;
                break;
        case pinmux_eth1:
-               ret = crisv32_pinmux_dealloc(PORT_E, 0, 17);
+               ret = __crisv32_pinmux_dealloc(PORT_E, 0, 17);
                hwprot.eth1 = regk_pinmux_no;
                hwprot.eth1_mgm = regk_pinmux_no;
                break;
        case pinmux_timer:
-               ret = crisv32_pinmux_dealloc(PORT_C, 16, 16);
+               ret = __crisv32_pinmux_dealloc(PORT_C, 16, 16);
                hwprot.timer = regk_pinmux_no;
                spin_unlock_irqrestore(&pinmux_lock, flags);
                return ret;
@@ -293,7 +306,8 @@ int crisv32_pinmux_dealloc_fixed(enum fixed_function function)
        return ret;
 }
 
-void crisv32_pinmux_dump(void)
+#ifdef DEBUG
+static void crisv32_pinmux_dump(void)
 {
        int i, j;
 
@@ -305,5 +319,5 @@ void crisv32_pinmux_dump(void)
                        printk(KERN_DEBUG "  Pin %d = %d\n", j, pins[i][j]);
        }
 }
-
+#endif
 __initcall(crisv32_pinmux_init);

diff --git a/arch/cris/include/arch-v32/mach-fs/mach/pinmux.h b/arch/cris/include/arch-v32/mach-fs/mach/pinmux.h
index c2b3036..09bf0c9 100644 (file)
--- a/arch/cris/include/arch-v32/mach-fs/mach/pinmux.h
+++ b/arch/cris/include/arch-v32/mach-fs/mach/pinmux.h
@@ -28,11 +28,9 @@ enum fixed_function {
   pinmux_timer
 };
 
-int crisv32_pinmux_init(void);
 int crisv32_pinmux_alloc(int port, int first_pin, int last_pin, enum pin_mode);
 int crisv32_pinmux_alloc_fixed(enum fixed_function function);
 int crisv32_pinmux_dealloc(int port, int first_pin, int last_pin);
 int crisv32_pinmux_dealloc_fixed(enum fixed_function function);
-void crisv32_pinmux_dump(void);
 
 #endif