1 files changed, 89 insertions, 122 deletions

diff --git a/drivers/char/stallion.c b/drivers/char/stallion.c
index 38fdd4da2427..0f7a542d9041 100644
--- a/drivers/char/stallion.c
+++ b/drivers/char/stallion.c
@@ -140,15 +140,6 @@ static char	*stl_drvversion = "5.6.0";
 static struct tty_driver        *stl_serial;
 
 /*
- *      We will need to allocate a temporary write buffer for chars that
- *      come direct from user space. The problem is that a copy from user
- *      space might cause a page fault (typically on a system that is
- *      swapping!). All ports will share one buffer - since if the system
- *      is already swapping a shared buffer won't make things any worse.
- */
-static char                     *stl_tmpwritebuf;
-
-/*
  *      Define a local default termios struct. All ports will be created
  *      with this termios initially. Basically all it defines is a raw port
  *      at 9600, 8 data bits, 1 stop bit.
@@ -362,6 +353,14 @@ static unsigned char	stl_vecmap[] = {
 };
 
 /*
+ *      Lock ordering is that you may not take stallion_lock holding
+ *      brd_lock.
+ */
+
+static spinlock_t brd_lock;             /* Guard the board mapping */
+static spinlock_t stallion_lock;        /* Guard the tty driver */
+
+/*
  *      Set up enable and disable macros for the ECH boards. They require
  *      the secondary io address space to be activated and deactivated.
  *      This way all ECH boards can share their secondary io region.
@@ -724,17 +723,7 @@ static struct class *stallion_class;
 
 static int __init stallion_module_init(void)
 {
-        unsigned long   flags;
-
-#ifdef DEBUG
-        printk("init_module()\n");
-#endif
-
-        save_flags(flags);
-        cli();
         stl_init();
-        restore_flags(flags);
-
         return 0;
 }
 
@@ -745,7 +734,6 @@ static void __exit stallion_module_exit(void)
         stlbrd_t        *brdp;
         stlpanel_t      *panelp;
         stlport_t       *portp;
-        unsigned long   flags;
         int             i, j, k;
 
 #ifdef DEBUG
@@ -755,9 +743,6 @@ static void __exit stallion_module_exit(void)
         printk(KERN_INFO "Unloading %s: version %s\n", stl_drvtitle,
                 stl_drvversion);
 
-        save_flags(flags);
-        cli();
-
 /*
  *      Free up all allocated resources used by the ports. This includes
  *      memory and interrupts. As part of this process we will also do
@@ -769,7 +754,6 @@ static void __exit stallion_module_exit(void)
         if (i) {
                 printk("STALLION: failed to un-register tty driver, "
                         "errno=%d\n", -i);
-                restore_flags(flags);
                 return;
         }
         for (i = 0; i < 4; i++)
@@ -779,8 +763,6 @@ static void __exit stallion_module_exit(void)
                         "errno=%d\n", -i);
         class_destroy(stallion_class);
 
-        kfree(stl_tmpwritebuf);
-
         for (i = 0; (i < stl_nrbrds); i++) {
                 if ((brdp = stl_brds[i]) == (stlbrd_t *) NULL)
                         continue;
@@ -810,8 +792,6 @@ static void __exit stallion_module_exit(void)
                 kfree(brdp);
                 stl_brds[i] = (stlbrd_t *) NULL;
         }
-
-        restore_flags(flags);
 }
 
 module_init(stallion_module_init);
@@ -944,7 +924,7 @@ static stlbrd_t *stl_allocbrd(void)
 
         brdp = kzalloc(sizeof(stlbrd_t), GFP_KERNEL);
         if (!brdp) {
-                printk("STALLION: failed to allocate memory (size=%d)\n",
+                printk("STALLION: failed to allocate memory (size=%Zd)\n",
                         sizeof(stlbrd_t));
                 return NULL;
         }
@@ -1062,16 +1042,17 @@ static int stl_waitcarrier(stlport_t *portp, struct file *filp)
         rc = 0;
         doclocal = 0;
 
+        spin_lock_irqsave(&stallion_lock, flags);
+
         if (portp->tty->termios->c_cflag & CLOCAL)
                 doclocal++;
 
-        save_flags(flags);
-        cli();
         portp->openwaitcnt++;
         if (! tty_hung_up_p(filp))
                 portp->refcount--;
 
         for (;;) {
+                /* Takes brd_lock internally */
                 stl_setsignals(portp, 1, 1);
                 if (tty_hung_up_p(filp) ||
                     ((portp->flags & ASYNC_INITIALIZED) == 0)) {
@@ -1089,13 +1070,14 @@ static int stl_waitcarrier(stlport_t *portp, struct file *filp)
                         rc = -ERESTARTSYS;
                         break;
                 }
+                /* FIXME */
                 interruptible_sleep_on(&portp->open_wait);
         }
 
         if (! tty_hung_up_p(filp))
                 portp->refcount++;
         portp->openwaitcnt--;
-        restore_flags(flags);
+        spin_unlock_irqrestore(&stallion_lock, flags);
 
         return rc;
 }
@@ -1115,16 +1097,15 @@ static void stl_close(struct tty_struct *tty, struct file *filp)
         if (portp == (stlport_t *) NULL)
                 return;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&stallion_lock, flags);
         if (tty_hung_up_p(filp)) {
-                restore_flags(flags);
+                spin_unlock_irqrestore(&stallion_lock, flags);
                 return;
         }
         if ((tty->count == 1) && (portp->refcount != 1))
                 portp->refcount = 1;
         if (portp->refcount-- > 1) {
-                restore_flags(flags);
+                spin_unlock_irqrestore(&stallion_lock, flags);
                 return;
         }
 
@@ -1138,11 +1119,18 @@ static void stl_close(struct tty_struct *tty, struct file *filp)
  *      (The sc26198 has no "end-of-data" interrupt only empty FIFO)
  */
         tty->closing = 1;
+
+        spin_unlock_irqrestore(&stallion_lock, flags);
+
         if (portp->closing_wait != ASYNC_CLOSING_WAIT_NONE)
                 tty_wait_until_sent(tty, portp->closing_wait);
         stl_waituntilsent(tty, (HZ / 2));
 
+
+        spin_lock_irqsave(&stallion_lock, flags);
         portp->flags &= ~ASYNC_INITIALIZED;
+        spin_unlock_irqrestore(&stallion_lock, flags);
+
         stl_disableintrs(portp);
         if (tty->termios->c_cflag & HUPCL)
                 stl_setsignals(portp, 0, 0);
@@ -1169,7 +1157,6 @@ static void stl_close(struct tty_struct *tty, struct file *filp)
 
         portp->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
         wake_up_interruptible(&portp->close_wait);
-        restore_flags(flags);
 }
 
 /*****************************************************************************/
@@ -1191,9 +1178,6 @@ static int stl_write(struct tty_struct *tty, const unsigned char *buf, int count
                 (int) tty, (int) buf, count);
 #endif
 
-        if ((tty == (struct tty_struct *) NULL) ||
-            (stl_tmpwritebuf == (char *) NULL))
-                return 0;
         portp = tty->driver_data;
         if (portp == (stlport_t *) NULL)
                 return 0;
@@ -1298,11 +1282,6 @@ static void stl_flushchars(struct tty_struct *tty)
         if (portp->tx.buf == (char *) NULL)
                 return;
 
-#if 0
-        if (tty->stopped || tty->hw_stopped ||
-            (portp->tx.head == portp->tx.tail))
-                return;
-#endif
         stl_startrxtx(portp, -1, 1);
 }
 
@@ -1973,12 +1952,14 @@ static int stl_eiointr(stlbrd_t *brdp)
         unsigned int    iobase;
         int             handled = 0;
 
+        spin_lock(&brd_lock);
         panelp = brdp->panels[0];
         iobase = panelp->iobase;
         while (inb(brdp->iostatus) & EIO_INTRPEND) {
                 handled = 1;
                 (* panelp->isr)(panelp, iobase);
         }
+        spin_unlock(&brd_lock);
         return handled;
 }
 
@@ -2164,7 +2145,7 @@ static int __init stl_initports(stlbrd_t *brdp, stlpanel_t *panelp)
                 portp = kzalloc(sizeof(stlport_t), GFP_KERNEL);
                 if (!portp) {
                         printk("STALLION: failed to allocate memory "
-                                "(size=%d)\n", sizeof(stlport_t));
+                                "(size=%Zd)\n", sizeof(stlport_t));
                         break;
                 }
 
@@ -2300,7 +2281,7 @@ static inline int stl_initeio(stlbrd_t *brdp)
         panelp = kzalloc(sizeof(stlpanel_t), GFP_KERNEL);
         if (!panelp) {
                 printk(KERN_WARNING "STALLION: failed to allocate memory "
-                        "(size=%d)\n", sizeof(stlpanel_t));
+                        "(size=%Zd)\n", sizeof(stlpanel_t));
                 return -ENOMEM;
         }
 
@@ -2474,7 +2455,7 @@ static inline int stl_initech(stlbrd_t *brdp)
                 panelp = kzalloc(sizeof(stlpanel_t), GFP_KERNEL);
                 if (!panelp) {
                         printk("STALLION: failed to allocate memory "
-                                "(size=%d)\n", sizeof(stlpanel_t));
+                                "(size=%Zd)\n", sizeof(stlpanel_t));
                         break;
                 }
                 panelp->magic = STL_PANELMAGIC;
@@ -2875,8 +2856,7 @@ static int stl_getportstats(stlport_t *portp, comstats_t __user *cp)
         portp->stats.lflags = 0;
         portp->stats.rxbuffered = 0;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&stallion_lock, flags);
         if (portp->tty != (struct tty_struct *) NULL) {
                 if (portp->tty->driver_data == portp) {
                         portp->stats.ttystate = portp->tty->flags;
@@ -2890,7 +2870,7 @@ static int stl_getportstats(stlport_t *portp, comstats_t __user *cp)
                         }
                 }
         }
-        restore_flags(flags);
+        spin_unlock_irqrestore(&stallion_lock, flags);
 
         head = portp->tx.head;
         tail = portp->tx.tail;
@@ -3045,6 +3025,9 @@ static int __init stl_init(void)
         int i;
         printk(KERN_INFO "%s: version %s\n", stl_drvtitle, stl_drvversion);
 
+        spin_lock_init(&stallion_lock);
+        spin_lock_init(&brd_lock);
+
         stl_initbrds();
 
         stl_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
@@ -3052,14 +3035,6 @@ static int __init stl_init(void)
                 return -1;
 
 /*
- *      Allocate a temporary write buffer.
- */
-        stl_tmpwritebuf = kmalloc(STL_TXBUFSIZE, GFP_KERNEL);
-        if (!stl_tmpwritebuf)
-                printk("STALLION: failed to allocate memory (size=%d)\n",
-                        STL_TXBUFSIZE);
-
-/*
  *      Set up a character driver for per board stuff. This is mainly used
  *      to do stats ioctls on the ports.
  */
@@ -3137,11 +3112,13 @@ static int stl_cd1400panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
         unsigned int    gfrcr;
         int             chipmask, i, j;
         int             nrchips, uartaddr, ioaddr;
+        unsigned long   flags;
 
 #ifdef DEBUG
         printk("stl_panelinit(brdp=%x,panelp=%x)\n", (int) brdp, (int) panelp);
 #endif
 
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(panelp->brdnr, panelp->pagenr);
 
 /*
@@ -3179,6 +3156,7 @@ static int stl_cd1400panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
         }
 
         BRDDISABLE(panelp->brdnr);
+        spin_unlock_irqrestore(&brd_lock, flags);
         return chipmask;
 }
 
@@ -3190,6 +3168,7 @@ static int stl_cd1400panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
 
 static void stl_cd1400portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp)
 {
+        unsigned long flags;
 #ifdef DEBUG
         printk("stl_cd1400portinit(brdp=%x,panelp=%x,portp=%x)\n",
                 (int) brdp, (int) panelp, (int) portp);
@@ -3199,6 +3178,7 @@ static void stl_cd1400portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *po
             (portp == (stlport_t *) NULL))
                 return;
 
+        spin_lock_irqsave(&brd_lock, flags);
         portp->ioaddr = panelp->iobase + (((brdp->brdtype == BRD_ECHPCI) ||
                 (portp->portnr < 8)) ? 0 : EREG_BANKSIZE);
         portp->uartaddr = (portp->portnr & 0x04) << 5;
@@ -3209,6 +3189,7 @@ static void stl_cd1400portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *po
         stl_cd1400setreg(portp, LIVR, (portp->portnr << 3));
         portp->hwid = stl_cd1400getreg(portp, GFRCR);
         BRDDISABLE(portp->brdnr);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -3418,8 +3399,7 @@ static void stl_cd1400setport(stlport_t *portp, struct termios *tiosp)
                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]);
 #endif
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
         srer = stl_cd1400getreg(portp, SRER);
@@ -3456,7 +3436,7 @@ static void stl_cd1400setport(stlport_t *portp, struct termios *tiosp)
                 portp->sigs &= ~TIOCM_CD;
         stl_cd1400setreg(portp, SRER, ((srer & ~sreroff) | sreron));
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -3482,8 +3462,7 @@ static void stl_cd1400setsignals(stlport_t *portp, int dtr, int rts)
         if (rts > 0)
                 msvr2 = MSVR2_RTS;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
         if (rts >= 0)
@@ -3491,7 +3470,7 @@ static void stl_cd1400setsignals(stlport_t *portp, int dtr, int rts)
         if (dtr >= 0)
                 stl_cd1400setreg(portp, MSVR1, msvr1);
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -3510,14 +3489,13 @@ static int stl_cd1400getsignals(stlport_t *portp)
         printk("stl_cd1400getsignals(portp=%x)\n", (int) portp);
 #endif
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
         msvr1 = stl_cd1400getreg(portp, MSVR1);
         msvr2 = stl_cd1400getreg(portp, MSVR2);
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 
         sigs = 0;
         sigs |= (msvr1 & MSVR1_DCD) ? TIOCM_CD : 0;
@@ -3559,15 +3537,14 @@ static void stl_cd1400enablerxtx(stlport_t *portp, int rx, int tx)
         else if (rx > 0)
                 ccr |= CCR_RXENABLE;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
         stl_cd1400ccrwait(portp);
         stl_cd1400setreg(portp, CCR, ccr);
         stl_cd1400ccrwait(portp);
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -3599,8 +3576,7 @@ static void stl_cd1400startrxtx(stlport_t *portp, int rx, int tx)
         else if (rx > 0)
                 sreron |= SRER_RXDATA;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
         stl_cd1400setreg(portp, SRER,
@@ -3608,7 +3584,7 @@ static void stl_cd1400startrxtx(stlport_t *portp, int rx, int tx)
         BRDDISABLE(portp->brdnr);
         if (tx > 0)
                 set_bit(ASYI_TXBUSY, &portp->istate);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -3624,13 +3600,12 @@ static void stl_cd1400disableintrs(stlport_t *portp)
 #ifdef DEBUG
         printk("stl_cd1400disableintrs(portp=%x)\n", (int) portp);
 #endif
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
         stl_cd1400setreg(portp, SRER, 0);
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -3643,8 +3618,7 @@ static void stl_cd1400sendbreak(stlport_t *portp, int len)
         printk("stl_cd1400sendbreak(portp=%x,len=%d)\n", (int) portp, len);
 #endif
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
         stl_cd1400setreg(portp, SRER,
@@ -3654,7 +3628,7 @@ static void stl_cd1400sendbreak(stlport_t *portp, int len)
         portp->brklen = len;
         if (len == 1)
                 portp->stats.txbreaks++;
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -3678,8 +3652,7 @@ static void stl_cd1400flowctrl(stlport_t *portp, int state)
         if (tty == (struct tty_struct *) NULL)
                 return;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
 
@@ -3719,7 +3692,7 @@ static void stl_cd1400flowctrl(stlport_t *portp, int state)
         }
 
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -3743,8 +3716,7 @@ static void stl_cd1400sendflow(stlport_t *portp, int state)
         if (tty == (struct tty_struct *) NULL)
                 return;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
         if (state) {
@@ -3759,7 +3731,7 @@ static void stl_cd1400sendflow(stlport_t *portp, int state)
                 stl_cd1400ccrwait(portp);
         }
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -3775,8 +3747,7 @@ static void stl_cd1400flush(stlport_t *portp)
         if (portp == (stlport_t *) NULL)
                 return;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
         stl_cd1400ccrwait(portp);
@@ -3784,7 +3755,7 @@ static void stl_cd1400flush(stlport_t *portp)
         stl_cd1400ccrwait(portp);
         portp->tx.tail = portp->tx.head;
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -3823,6 +3794,7 @@ static void stl_cd1400eiointr(stlpanel_t *panelp, unsigned int iobase)
                 (int) panelp, iobase);
 #endif
 
+        spin_lock(&brd_lock);
         outb(SVRR, iobase);
         svrtype = inb(iobase + EREG_DATA);
         if (panelp->nrports > 4) {
@@ -3836,6 +3808,8 @@ static void stl_cd1400eiointr(stlpanel_t *panelp, unsigned int iobase)
                 stl_cd1400txisr(panelp, iobase);
         else if (svrtype & SVRR_MDM)
                 stl_cd1400mdmisr(panelp, iobase);
+
+        spin_unlock(&brd_lock);
 }
 
 /*****************************************************************************/
@@ -4423,8 +4397,7 @@ static void stl_sc26198setport(stlport_t *portp, struct termios *tiosp)
                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]);
 #endif
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_sc26198setreg(portp, IMR, 0);
         stl_sc26198updatereg(portp, MR0, mr0);
@@ -4451,7 +4424,7 @@ static void stl_sc26198setport(stlport_t *portp, struct termios *tiosp)
         portp->imr = (portp->imr & ~imroff) | imron;
         stl_sc26198setreg(portp, IMR, portp->imr);
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -4481,13 +4454,12 @@ static void stl_sc26198setsignals(stlport_t *portp, int dtr, int rts)
         else if (rts > 0)
                 iopioron |= IPR_RTS;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_sc26198setreg(portp, IOPIOR,
                 ((stl_sc26198getreg(portp, IOPIOR) & ~iopioroff) | iopioron));
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -4506,12 +4478,11 @@ static int stl_sc26198getsignals(stlport_t *portp)
         printk("stl_sc26198getsignals(portp=%x)\n", (int) portp);
 #endif
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         ipr = stl_sc26198getreg(portp, IPR);
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 
         sigs = 0;
         sigs |= (ipr & IPR_DCD) ? 0 : TIOCM_CD;
@@ -4548,13 +4519,12 @@ static void stl_sc26198enablerxtx(stlport_t *portp, int rx, int tx)
         else if (rx > 0)
                 ccr |= CR_RXENABLE;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_sc26198setreg(portp, SCCR, ccr);
         BRDDISABLE(portp->brdnr);
         portp->crenable = ccr;
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -4583,15 +4553,14 @@ static void stl_sc26198startrxtx(stlport_t *portp, int rx, int tx)
         else if (rx > 0)
                 imr |= IR_RXRDY | IR_RXBREAK | IR_RXWATCHDOG;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_sc26198setreg(portp, IMR, imr);
         BRDDISABLE(portp->brdnr);
         portp->imr = imr;
         if (tx > 0)
                 set_bit(ASYI_TXBUSY, &portp->istate);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -4608,13 +4577,12 @@ static void stl_sc26198disableintrs(stlport_t *portp)
         printk("stl_sc26198disableintrs(portp=%x)\n", (int) portp);
 #endif
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         portp->imr = 0;
         stl_sc26198setreg(portp, IMR, 0);
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -4627,8 +4595,7 @@ static void stl_sc26198sendbreak(stlport_t *portp, int len)
         printk("stl_sc26198sendbreak(portp=%x,len=%d)\n", (int) portp, len);
 #endif
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         if (len == 1) {
                 stl_sc26198setreg(portp, SCCR, CR_TXSTARTBREAK);
@@ -4637,7 +4604,7 @@ static void stl_sc26198sendbreak(stlport_t *portp, int len)
                 stl_sc26198setreg(portp, SCCR, CR_TXSTOPBREAK);
         }
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -4662,8 +4629,7 @@ static void stl_sc26198flowctrl(stlport_t *portp, int state)
         if (tty == (struct tty_struct *) NULL)
                 return;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
 
         if (state) {
@@ -4709,7 +4675,7 @@ static void stl_sc26198flowctrl(stlport_t *portp, int state)
         }
 
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -4734,8 +4700,7 @@ static void stl_sc26198sendflow(stlport_t *portp, int state)
         if (tty == (struct tty_struct *) NULL)
                 return;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         if (state) {
                 mr0 = stl_sc26198getreg(portp, MR0);
@@ -4755,7 +4720,7 @@ static void stl_sc26198sendflow(stlport_t *portp, int state)
                 stl_sc26198setreg(portp, MR0, mr0);
         }
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -4771,14 +4736,13 @@ static void stl_sc26198flush(stlport_t *portp)
         if (portp == (stlport_t *) NULL)
                 return;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         stl_sc26198setreg(portp, SCCR, CR_TXRESET);
         stl_sc26198setreg(portp, SCCR, portp->crenable);
         BRDDISABLE(portp->brdnr);
         portp->tx.tail = portp->tx.head;
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -4805,12 +4769,11 @@ static int stl_sc26198datastate(stlport_t *portp)
         if (test_bit(ASYI_TXBUSY, &portp->istate))
                 return 1;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         BRDENABLE(portp->brdnr, portp->pagenr);
         sr = stl_sc26198getreg(portp, SR);
         BRDDISABLE(portp->brdnr);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 
         return (sr & SR_TXEMPTY) ? 0 : 1;
 }
@@ -4868,6 +4831,8 @@ static void stl_sc26198intr(stlpanel_t *panelp, unsigned int iobase)
         stlport_t       *portp;
         unsigned int    iack;
 
+        spin_lock(&brd_lock);
+
 /* 
  *      Work around bug in sc26198 chip... Cannot have A6 address
  *      line of UART high, else iack will be returned as 0.
@@ -4883,6 +4848,8 @@ static void stl_sc26198intr(stlpanel_t *panelp, unsigned int iobase)
                 stl_sc26198txisr(portp);
         else
                 stl_sc26198otherisr(portp, iack);
+
+        spin_unlock(&brd_lock);
 }
 
 /*****************************************************************************/