]> pilppa.com Git - linux-2.6-omap-h63xx.git/commitdiff
[PATCH] Clean up the old digi support and rescue it
authorAlan Cox <alan@lxorguk.ukuu.org.uk>
Tue, 6 Sep 2005 22:16:44 +0000 (15:16 -0700)
committerLinus Torvalds <torvalds@g5.osdl.org>
Wed, 7 Sep 2005 23:57:20 +0000 (16:57 -0700)
Signed-off-by: Alan Cox <alan@redhat.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
drivers/char/Kconfig
drivers/char/digi1.h
drivers/char/digiFep1.h
drivers/char/epca.c
drivers/char/epca.h

index a1de06d76de63e8742558f0f20e587e1fcfa3cf6..2bc9d64db106cc40df4cf709db77405f66258c9d 100644 (file)
@@ -138,7 +138,7 @@ config CYZ_INTR
 
 config DIGIEPCA
        tristate "Digiboard Intelligent Async Support"
-       depends on SERIAL_NONSTANDARD && BROKEN_ON_SMP && (!64BIT || BROKEN)
+       depends on SERIAL_NONSTANDARD
        ---help---
          This is a driver for Digi International's Xx, Xeve, and Xem series
          of cards which provide multiple serial ports. You would need
index 184378d23f8ce1598827da50ca87041d5c21e24f..94d4eab5d3ca30e494e6cf90feab98607725d48b 100644 (file)
@@ -1,46 +1,46 @@
 /*          Definitions for DigiBoard ditty(1) command.                 */
 
 #if !defined(TIOCMODG)
-#define        TIOCMODG        ('d'<<8) | 250          /* get modem ctrl state */
-#define        TIOCMODS        ('d'<<8) | 251          /* set modem ctrl state */
+#define        TIOCMODG        (('d'<<8) | 250)        /* get modem ctrl state */
+#define        TIOCMODS        (('d'<<8) | 251)        /* set modem ctrl state */
 #endif
 
 #if !defined(TIOCMSET)
-#define        TIOCMSET        ('d'<<8) | 252          /* set modem ctrl state */
-#define        TIOCMGET        ('d'<<8) | 253          /* set modem ctrl state */
+#define        TIOCMSET        (('d'<<8) | 252)        /* set modem ctrl state */
+#define        TIOCMGET        (('d'<<8) | 253)        /* set modem ctrl state */
 #endif
 
 #if !defined(TIOCMBIC)
-#define        TIOCMBIC        ('d'<<8) | 254          /* set modem ctrl state */
-#define        TIOCMBIS        ('d'<<8) | 255          /* set modem ctrl state */
+#define        TIOCMBIC        (('d'<<8) | 254)        /* set modem ctrl state */
+#define        TIOCMBIS        (('d'<<8) | 255)        /* set modem ctrl state */
 #endif
 
 #if !defined(TIOCSDTR)
-#define        TIOCSDTR        ('e'<<8) | 0            /* set DTR              */
-#define        TIOCCDTR        ('e'<<8) | 1            /* clear DTR            */
+#define        TIOCSDTR        (('e'<<8) | 0)          /* set DTR              */
+#define        TIOCCDTR        (('e'<<8) | 1)          /* clear DTR            */
 #endif
 
 /************************************************************************
  * Ioctl command arguments for DIGI parameters.
  ************************************************************************/
-#define DIGI_GETA      ('e'<<8) | 94           /* Read params          */
+#define DIGI_GETA      (('e'<<8) | 94)         /* Read params          */
 
-#define DIGI_SETA      ('e'<<8) | 95           /* Set params           */
-#define DIGI_SETAW     ('e'<<8) | 96           /* Drain & set params   */
-#define DIGI_SETAF     ('e'<<8) | 97           /* Drain, flush & set params */
+#define DIGI_SETA      (('e'<<8) | 95)         /* Set params           */
+#define DIGI_SETAW     (('e'<<8) | 96)         /* Drain & set params   */
+#define DIGI_SETAF     (('e'<<8) | 97)         /* Drain, flush & set params */
 
-#define        DIGI_GETFLOW    ('e'<<8) | 99           /* Get startc/stopc flow */
+#define        DIGI_GETFLOW    (('e'<<8) | 99)         /* Get startc/stopc flow */
                                                /* control characters    */
-#define        DIGI_SETFLOW    ('e'<<8) | 100          /* Set startc/stopc flow */
+#define        DIGI_SETFLOW    (('e'<<8) | 100)        /* Set startc/stopc flow */
                                                /* control characters    */
-#define        DIGI_GETAFLOW   ('e'<<8) | 101          /* Get Aux. startc/stopc */
+#define        DIGI_GETAFLOW   (('e'<<8) | 101)        /* Get Aux. startc/stopc */
                                                /* flow control chars    */
-#define        DIGI_SETAFLOW   ('e'<<8) | 102          /* Set Aux. startc/stopc */
+#define        DIGI_SETAFLOW   (('e'<<8) | 102)        /* Set Aux. startc/stopc */
                                                /* flow control chars    */
 
-#define        DIGI_GETINFO    ('e'<<8) | 103          /* Fill in digi_info */
-#define        DIGI_POLLER     ('e'<<8) | 104          /* Turn on/off poller */
-#define        DIGI_INIT       ('e'<<8) | 105          /* Allow things to run. */
+#define        DIGI_GETINFO    (('e'<<8) | 103)        /* Fill in digi_info */
+#define        DIGI_POLLER     (('e'<<8) | 104)        /* Turn on/off poller */
+#define        DIGI_INIT       (('e'<<8) | 105)        /* Allow things to run. */
 
 struct digiflow_struct 
 {
index c47d7fcb840017fe9372f079e0ffec0452cd2280..3c1f1922c798a4cff9dea622efc537bbfd885b40 100644 (file)
 
 struct global_data 
 {
-       volatile ushort cin;
-       volatile ushort cout;
-       volatile ushort cstart;
-       volatile ushort cmax;
-       volatile ushort ein;
-       volatile ushort eout;
-       volatile ushort istart;
-       volatile ushort imax;
+       u16 cin;
+       u16 cout;
+       u16 cstart;
+       u16 cmax;
+       u16 ein;
+       u16 eout;
+       u16 istart;
+       u16 imax;
 };
 
 
 struct board_chan 
 {
-       int filler1; 
-       int filler2;
-       volatile ushort tseg;
-       volatile ushort tin;
-       volatile ushort tout;
-       volatile ushort tmax;
-       
-       volatile ushort rseg;
-       volatile ushort rin;
-       volatile ushort rout;
-       volatile ushort rmax;
-       
-       volatile ushort tlow;
-       volatile ushort rlow;
-       volatile ushort rhigh;
-       volatile ushort incr;
-       
-       volatile ushort etime;
-       volatile ushort edelay;
-       volatile unchar *dev;
-       
-       volatile ushort iflag;
-       volatile ushort oflag;
-       volatile ushort cflag;
-       volatile ushort gmask;
-       
-       volatile ushort col;
-       volatile ushort delay;
-       volatile ushort imask;
-       volatile ushort tflush;
-
-       int filler3;
-       int filler4;
-       int filler5;
-       int filler6;
-       
-       volatile unchar num;
-       volatile unchar ract;
-       volatile unchar bstat;
-       volatile unchar tbusy;
-       volatile unchar iempty;
-       volatile unchar ilow;
-       volatile unchar idata;
-       volatile unchar eflag;
-       
-       volatile unchar tflag;
-       volatile unchar rflag;
-       volatile unchar xmask;
-       volatile unchar xval;
-       volatile unchar mstat;
-       volatile unchar mchange;
-       volatile unchar mint;
-       volatile unchar lstat;
-
-       volatile unchar mtran;
-       volatile unchar orun;
-       volatile unchar startca;
-       volatile unchar stopca;
-       volatile unchar startc;
-       volatile unchar stopc;
-       volatile unchar vnext;
-       volatile unchar hflow;
-
-       volatile unchar fillc;
-       volatile unchar ochar;
-       volatile unchar omask;
-
-       unchar filler7;
-       unchar filler8[28];
+       u32 filler1;
+       u32 filler2;
+       u16 tseg;
+       u16 tin;
+       u16 tout;
+       u16 tmax;
+
+       u16 rseg;
+       u16 rin;
+       u16 rout;
+       u16 rmax;
+
+       u16 tlow;
+       u16 rlow;
+       u16 rhigh;
+       u16 incr;
+
+       u16 etime;
+       u16 edelay;
+       unchar *dev;
+
+       u16 iflag;
+       u16 oflag;
+       u16 cflag;
+       u16 gmask;
+
+       u16 col;
+       u16 delay;
+       u16 imask;
+       u16 tflush;
+
+       u32 filler3;
+       u32 filler4;
+       u32 filler5;
+       u32 filler6;
+
+       u8 num;
+       u8 ract;
+       u8 bstat;
+       u8 tbusy;
+       u8 iempty;
+       u8 ilow;
+       u8 idata;
+       u8 eflag;
+
+       u8 tflag;
+       u8 rflag;
+       u8 xmask;
+       u8 xval;
+       u8 mstat;
+       u8 mchange;
+       u8 mint;
+       u8 lstat;
+
+       u8 mtran;
+       u8 orun;
+       u8 startca;
+       u8 stopca;
+       u8 startc;
+       u8 stopc;
+       u8 vnext;
+       u8 hflow;
+
+       u8 fillc;
+       u8 ochar;
+       u8 omask;
+
+       u8 filler7;
+       u8 filler8[28];
 }; 
 
 
index 6025e1866c7e5e0afeb74dbd74a979b77795da5d..58d3738a2b7fd4eab9d51cd783fba8bf98ceb562 100644 (file)
@@ -6,6 +6,8 @@
        For technical support please email digiLinux@dgii.com or
        call Digi tech support at (612) 912-3456
 
+       ** This driver is no longer supported by Digi **
+
        Much of this design and code came from epca.c which was 
        copyright (C) 1994, 1995 Troy De Jongh, and subsquently 
        modified by David Nugent, Christoph Lameter, Mike McLagan. 
 #include <linux/interrupt.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
-
-#ifdef CONFIG_PCI
-#define ENABLE_PCI
-#endif /* CONFIG_PCI */
-
-#define putUser(arg1, arg2) put_user(arg1, (unsigned long __user *)arg2)
-#define getUser(arg1, arg2) get_user(arg1, (unsigned __user *)arg2)
-
-#ifdef ENABLE_PCI
+#include <linux/spinlock.h>
 #include <linux/pci.h>
 #include "digiPCI.h"
-#endif /* ENABLE_PCI */
+
 
 #include "digi1.h"
 #include "digiFep1.h"
 #include "epca.h"
 #include "epcaconfig.h"
 
-#if BITS_PER_LONG != 32
-#  error FIXME: this driver only works on 32-bit platforms
-#endif
-
 /* ---------------------- Begin defines ------------------------ */
 
-#define VERSION            "1.3.0.1-LK"
+#define VERSION            "1.3.0.1-LK2.6"
 
 /* This major needs to be submitted to Linux to join the majors list */
 
 
 /* ----------------- Begin global definitions ------------------- */
 
-static char mesg[100];
 static int nbdevs, num_cards, liloconfig;
 static int digi_poller_inhibited = 1 ;
 
 static int setup_error_code;
 static int invalid_lilo_config;
 
+/* The ISA boards do window flipping into the same spaces so its only sane
+   with a single lock. It's still pretty efficient */
+
+static spinlock_t epca_lock = SPIN_LOCK_UNLOCKED;
+
 /* -----------------------------------------------------------------------
        MAXBOARDS is typically 12, but ISA and EISA cards are restricted to 
        7 below.
@@ -129,58 +123,58 @@ static struct timer_list epca_timer;
        configured.
 ----------------------------------------------------------------------- */
        
-static inline void memwinon(struct board_info *b, unsigned int win);
-static inline void memwinoff(struct board_info *b, unsigned int win);
-static inline void globalwinon(struct channel *ch);
-static inline void rxwinon(struct channel *ch);
-static inline void txwinon(struct channel *ch);
-static inline void memoff(struct channel *ch);
-static inline void assertgwinon(struct channel *ch);
-static inline void assertmemoff(struct channel *ch);
+static void memwinon(struct board_info *b, unsigned int win);
+static void memwinoff(struct board_info *b, unsigned int win);
+static void globalwinon(struct channel *ch);
+static void rxwinon(struct channel *ch);
+static void txwinon(struct channel *ch);
+static void memoff(struct channel *ch);
+static void assertgwinon(struct channel *ch);
+static void assertmemoff(struct channel *ch);
 
 /* ---- Begin more 'specific' memory functions for cx_like products --- */
 
-static inline void pcxem_memwinon(struct board_info *b, unsigned int win);
-static inline void pcxem_memwinoff(struct board_info *b, unsigned int win);
-static inline void pcxem_globalwinon(struct channel *ch);
-static inline void pcxem_rxwinon(struct channel *ch);
-static inline void pcxem_txwinon(struct channel *ch);
-static inline void pcxem_memoff(struct channel *ch);
+static void pcxem_memwinon(struct board_info *b, unsigned int win);
+static void pcxem_memwinoff(struct board_info *b, unsigned int win);
+static void pcxem_globalwinon(struct channel *ch);
+static void pcxem_rxwinon(struct channel *ch);
+static void pcxem_txwinon(struct channel *ch);
+static void pcxem_memoff(struct channel *ch);
 
 /* ------ Begin more 'specific' memory functions for the pcxe ------- */
 
-static inline void pcxe_memwinon(struct board_info *b, unsigned int win);
-static inline void pcxe_memwinoff(struct board_info *b, unsigned int win);
-static inline void pcxe_globalwinon(struct channel *ch);
-static inline void pcxe_rxwinon(struct channel *ch);
-static inline void pcxe_txwinon(struct channel *ch);
-static inline void pcxe_memoff(struct channel *ch);
+static void pcxe_memwinon(struct board_info *b, unsigned int win);
+static void pcxe_memwinoff(struct board_info *b, unsigned int win);
+static void pcxe_globalwinon(struct channel *ch);
+static void pcxe_rxwinon(struct channel *ch);
+static void pcxe_txwinon(struct channel *ch);
+static void pcxe_memoff(struct channel *ch);
 
 /* ---- Begin more 'specific' memory functions for the pc64xe and pcxi ---- */
 /* Note : pc64xe and pcxi share the same windowing routines */
 
-static inline void pcxi_memwinon(struct board_info *b, unsigned int win);
-static inline void pcxi_memwinoff(struct board_info *b, unsigned int win);
-static inline void pcxi_globalwinon(struct channel *ch);
-static inline void pcxi_rxwinon(struct channel *ch);
-static inline void pcxi_txwinon(struct channel *ch);
-static inline void pcxi_memoff(struct channel *ch);
+static void pcxi_memwinon(struct board_info *b, unsigned int win);
+static void pcxi_memwinoff(struct board_info *b, unsigned int win);
+static void pcxi_globalwinon(struct channel *ch);
+static void pcxi_rxwinon(struct channel *ch);
+static void pcxi_txwinon(struct channel *ch);
+static void pcxi_memoff(struct channel *ch);
 
 /* - Begin 'specific' do nothing memory functions needed for some cards - */
 
-static inline void dummy_memwinon(struct board_info *b, unsigned int win);
-static inline void dummy_memwinoff(struct board_info *b, unsigned int win);
-static inline void dummy_globalwinon(struct channel *ch);
-static inline void dummy_rxwinon(struct channel *ch);
-static inline void dummy_txwinon(struct channel *ch);
-static inline void dummy_memoff(struct channel *ch);
-static inline void dummy_assertgwinon(struct channel *ch);
-static inline void dummy_assertmemoff(struct channel *ch);
+static void dummy_memwinon(struct board_info *b, unsigned int win);
+static void dummy_memwinoff(struct board_info *b, unsigned int win);
+static void dummy_globalwinon(struct channel *ch);
+static void dummy_rxwinon(struct channel *ch);
+static void dummy_txwinon(struct channel *ch);
+static void dummy_memoff(struct channel *ch);
+static void dummy_assertgwinon(struct channel *ch);
+static void dummy_assertmemoff(struct channel *ch);
 
 /* ------------------- Begin declare functions ----------------------- */
 
-static inline struct channel *verifyChannel(register struct tty_struct *);
-static inline void pc_sched_event(struct channel *, int);
+static struct channel *verifyChannel(struct tty_struct *);
+static void pc_sched_event(struct channel *, int);
 static void epca_error(int, char *);
 static void pc_close(struct tty_struct *, struct file *);
 static void shutdown(struct channel *);
@@ -215,15 +209,11 @@ static void pc_unthrottle(struct tty_struct *tty);
 static void digi_send_break(struct channel *ch, int msec);
 static void setup_empty_event(struct tty_struct *tty, struct channel *ch);
 void epca_setup(char *, int *);
-void console_print(const char *);
 
 static int get_termio(struct tty_struct *, struct termio __user *);
 static int pc_write(struct tty_struct *, const unsigned char *, int);
-int pc_init(void);
-
-#ifdef ENABLE_PCI
+static int pc_init(void);
 static int init_PCI(void);
-#endif /* ENABLE_PCI */
 
 
 /* ------------------------------------------------------------------
@@ -237,41 +227,41 @@ static int init_PCI(void);
        making direct calls deserves what they get.
 -------------------------------------------------------------------- */
 
-static inline void memwinon(struct board_info *b, unsigned int win)
+static void memwinon(struct board_info *b, unsigned int win)
 {
        (b->memwinon)(b, win);
 }
 
-static inline void memwinoff(struct board_info *b, unsigned int win)
+static void memwinoff(struct board_info *b, unsigned int win)
 {
        (b->memwinoff)(b, win);
 }
 
-static inline void globalwinon(struct channel *ch)
+static void globalwinon(struct channel *ch)
 {
        (ch->board->globalwinon)(ch);
 }
 
-static inline void rxwinon(struct channel *ch)
+static void rxwinon(struct channel *ch)
 {
        (ch->board->rxwinon)(ch);
 }
 
-static inline void txwinon(struct channel *ch)
+static void txwinon(struct channel *ch)
 {
        (ch->board->txwinon)(ch);
 }
 
-static inline void memoff(struct channel *ch)
+static void memoff(struct channel *ch)
 {
        (ch->board->memoff)(ch);
 }
-static inline void assertgwinon(struct channel *ch)
+static void assertgwinon(struct channel *ch)
 {
        (ch->board->assertgwinon)(ch);
 }
 
-static inline void assertmemoff(struct channel *ch)
+static void assertmemoff(struct channel *ch)
 {
        (ch->board->assertmemoff)(ch);
 }
@@ -281,66 +271,66 @@ static inline void assertmemoff(struct channel *ch)
        and CX series cards.
 ------------------------------------------------------------ */
 
-static inline void pcxem_memwinon(struct board_info *b, unsigned int win)
+static void pcxem_memwinon(struct board_info *b, unsigned int win)
 {
-        outb_p(FEPWIN|win, (int)b->port + 1);
+        outb_p(FEPWIN|win, b->port + 1);
 }
 
-static inline void pcxem_memwinoff(struct board_info *b, unsigned int win)
+static void pcxem_memwinoff(struct board_info *b, unsigned int win)
 {
-       outb_p(0, (int)b->port + 1);
+       outb_p(0, b->port + 1);
 }
 
-static inline void pcxem_globalwinon(struct channel *ch)
+static void pcxem_globalwinon(struct channel *ch)
 {
        outb_p( FEPWIN, (int)ch->board->port + 1);
 }
 
-static inline void pcxem_rxwinon(struct channel *ch)
+static void pcxem_rxwinon(struct channel *ch)
 {
        outb_p(ch->rxwin, (int)ch->board->port + 1);
 }
 
-static inline void pcxem_txwinon(struct channel *ch)
+static void pcxem_txwinon(struct channel *ch)
 {
        outb_p(ch->txwin, (int)ch->board->port + 1);
 }
 
-static inline void pcxem_memoff(struct channel *ch)
+static void pcxem_memoff(struct channel *ch)
 {
        outb_p(0, (int)ch->board->port + 1);
 }
 
 /* ----------------- Begin pcxe memory window stuff ------------------ */
 
-static inline void pcxe_memwinon(struct board_info *b, unsigned int win)
+static void pcxe_memwinon(struct board_info *b, unsigned int win)
 {
-               outb_p(FEPWIN | win, (int)b->port + 1);
+               outb_p(FEPWIN | win, b->port + 1);
 }
 
-static inline void pcxe_memwinoff(struct board_info *b, unsigned int win)
+static void pcxe_memwinoff(struct board_info *b, unsigned int win)
 {
-       outb_p(inb((int)b->port) & ~FEPMEM,
-                  (int)b->port + 1);
-       outb_p(0, (int)b->port + 1);
+       outb_p(inb(b->port) & ~FEPMEM,
+                  b->port + 1);
+       outb_p(0, b->port + 1);
 }
 
-static inline void pcxe_globalwinon(struct channel *ch)
+static void pcxe_globalwinon(struct channel *ch)
 {
        outb_p( FEPWIN, (int)ch->board->port + 1);
 }
 
-static inline void pcxe_rxwinon(struct channel *ch)
+static void pcxe_rxwinon(struct channel *ch)
 {
                outb_p(ch->rxwin, (int)ch->board->port + 1);
 }
 
-static inline void pcxe_txwinon(struct channel *ch)
+static void pcxe_txwinon(struct channel *ch)
 {
                outb_p(ch->txwin, (int)ch->board->port + 1);
 }
 
-static inline void pcxe_memoff(struct channel *ch)
+static void pcxe_memoff(struct channel *ch)
 {
        outb_p(0, (int)ch->board->port);
        outb_p(0, (int)ch->board->port + 1);
@@ -348,44 +338,44 @@ static inline void pcxe_memoff(struct channel *ch)
 
 /* ------------- Begin pc64xe and pcxi memory window stuff -------------- */
 
-static inline void pcxi_memwinon(struct board_info *b, unsigned int win)
+static void pcxi_memwinon(struct board_info *b, unsigned int win)
 {
-               outb_p(inb((int)b->port) | FEPMEM, (int)b->port);
+               outb_p(inb(b->port) | FEPMEM, b->port);
 }
 
-static inline void pcxi_memwinoff(struct board_info *b, unsigned int win)
+static void pcxi_memwinoff(struct board_info *b, unsigned int win)
 {
-       outb_p(inb((int)b->port) & ~FEPMEM, (int)b->port);
+       outb_p(inb(b->port) & ~FEPMEM, b->port);
 }
 
-static inline void pcxi_globalwinon(struct channel *ch)
+static void pcxi_globalwinon(struct channel *ch)
 {
-       outb_p(FEPMEM, (int)ch->board->port);
+       outb_p(FEPMEM, ch->board->port);
 }
 
-static inline void pcxi_rxwinon(struct channel *ch)
+static void pcxi_rxwinon(struct channel *ch)
 {
-               outb_p(FEPMEM, (int)ch->board->port);
+               outb_p(FEPMEM, ch->board->port);
 }
 
-static inline void pcxi_txwinon(struct channel *ch)
+static void pcxi_txwinon(struct channel *ch)
 {
-               outb_p(FEPMEM, (int)ch->board->port);
+               outb_p(FEPMEM, ch->board->port);
 }
 
-static inline void pcxi_memoff(struct channel *ch)
+static void pcxi_memoff(struct channel *ch)
 {
-       outb_p(0, (int)ch->board->port);
+       outb_p(0, ch->board->port);
 }
 
-static inline void pcxi_assertgwinon(struct channel *ch)
+static void pcxi_assertgwinon(struct channel *ch)
 {
-       epcaassert(inb((int)ch->board->port) & FEPMEM, "Global memory off");
+       epcaassert(inb(ch->board->port) & FEPMEM, "Global memory off");
 }
 
-static inline void pcxi_assertmemoff(struct channel *ch)
+static void pcxi_assertmemoff(struct channel *ch)
 {
-       epcaassert(!(inb((int)ch->board->port) & FEPMEM), "Memory on");
+       epcaassert(!(inb(ch->board->port) & FEPMEM), "Memory on");
 }
 
 
@@ -398,185 +388,143 @@ static inline void pcxi_assertmemoff(struct channel *ch)
        may or may not do anything.
 ---------------------------------------------------------------------------*/
 
-static inline void dummy_memwinon(struct board_info *b, unsigned int win)
+static void dummy_memwinon(struct board_info *b, unsigned int win)
 {
 }
 
-static inline void dummy_memwinoff(struct board_info *b, unsigned int win)
+static void dummy_memwinoff(struct board_info *b, unsigned int win)
 {
 }
 
-static inline void dummy_globalwinon(struct channel *ch)
+static void dummy_globalwinon(struct channel *ch)
 {
 }
 
-static inline void dummy_rxwinon(struct channel *ch)
+static void dummy_rxwinon(struct channel *ch)
 {
 }
 
-static inline void dummy_txwinon(struct channel *ch)
+static void dummy_txwinon(struct channel *ch)
 {
 }
 
-static inline void dummy_memoff(struct channel *ch)
+static void dummy_memoff(struct channel *ch)
 {
 }
 
-static inline void dummy_assertgwinon(struct channel *ch)
+static void dummy_assertgwinon(struct channel *ch)
 {
 }
 
-static inline void dummy_assertmemoff(struct channel *ch)
+static void dummy_assertmemoff(struct channel *ch)
 {
 }
 
 /* ----------------- Begin verifyChannel function ----------------------- */
-static inline struct channel *verifyChannel(register struct tty_struct *tty)
+static struct channel *verifyChannel(struct tty_struct *tty)
 { /* Begin verifyChannel */
-
        /* --------------------------------------------------------------------
                This routine basically provides a sanity check.  It insures that
                the channel returned is within the proper range of addresses as
                well as properly initialized.  If some bogus info gets passed in
                through tty->driver_data this should catch it.
-       --------------------------------------------------------------------- */
-
-       if (tty) 
-       { /* Begin if tty */
-
-               register struct channel *ch = (struct channel *)tty->driver_data;
-
-               if ((ch >= &digi_channels[0]) && (ch < &digi_channels[nbdevs])) 
-               {
+               --------------------------------------------------------------------- */
+       if (tty) {
+               struct channel *ch = (struct channel *)tty->driver_data;
+               if ((ch >= &digi_channels[0]) && (ch < &digi_channels[nbdevs])) {
                        if (ch->magic == EPCA_MAGIC)
                                return ch;
                }
-
-       } /* End if tty */
-
-       /* Else return a NULL for invalid */
+       }
        return NULL;
 
 } /* End verifyChannel */
 
 /* ------------------ Begin pc_sched_event ------------------------- */
 
-static inline void pc_sched_event(struct channel *ch, int event)
-{ /* Begin pc_sched_event */
-
-
+static void pc_sched_event(struct channel *ch, int event)
+{
        /* ----------------------------------------------------------------------
                We call this to schedule interrupt processing on some event.  The 
                kernel sees our request and calls the related routine in OUR driver.
        -------------------------------------------------------------------------*/
-
        ch->event |= 1 << event;
        schedule_work(&ch->tqueue);
-
-
 } /* End pc_sched_event */
 
 /* ------------------ Begin epca_error ------------------------- */
 
 static void epca_error(int line, char *msg)
-{ /* Begin epca_error */
-
+{
        printk(KERN_ERR "epca_error (Digi): line = %d %s\n",line,msg);
-       return;
-
-} /* End epca_error */
+}
 
 /* ------------------ Begin pc_close ------------------------- */
 static void pc_close(struct tty_struct * tty, struct file * filp)
-{ /* Begin pc_close */
-
+{
        struct channel *ch;
        unsigned long flags;
-
        /* ---------------------------------------------------------
                verifyChannel returns the channel from the tty struct
                if it is valid.  This serves as a sanity check.
        ------------------------------------------------------------- */
-
-       if ((ch = verifyChannel(tty)) != NULL) 
-       { /* Begin if ch != NULL */
-
-               save_flags(flags);
-               cli();
-
-               if (tty_hung_up_p(filp)) 
-               {
-                       restore_flags(flags);
+       if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if ch != NULL */
+               spin_lock_irqsave(&epca_lock, flags);
+               if (tty_hung_up_p(filp)) {
+                       spin_unlock_irqrestore(&epca_lock, flags);
                        return;
                }
-
                /* Check to see if the channel is open more than once */
-               if (ch->count-- > 1) 
-               { /* Begin channel is open more than once */
-
+               if (ch->count-- > 1)  {
+                       /* Begin channel is open more than once */
                        /* -------------------------------------------------------------
                                Return without doing anything.  Someone might still be using
                                the channel.
                        ---------------------------------------------------------------- */
-
-                       restore_flags(flags);
+                       spin_unlock_irqrestore(&epca_lock, flags);
                        return;
                } /* End channel is open more than once */
 
                /* Port open only once go ahead with shutdown & reset */
-
-               if (ch->count < 0) 
-               {
-                       ch->count = 0;
-               }
+               if (ch->count < 0)
+                       BUG();
 
                /* ---------------------------------------------------------------
                        Let the rest of the driver know the channel is being closed.
                        This becomes important if an open is attempted before close 
                        is finished.
                ------------------------------------------------------------------ */
-
                ch->asyncflags |= ASYNC_CLOSING;
-       
                tty->closing = 1;
 
-               if (ch->asyncflags & ASYNC_INITIALIZED) 
-               {
+               spin_unlock_irqrestore(&epca_lock, flags);
+
+               if (ch->asyncflags & ASYNC_INITIALIZED)  {
                        /* Setup an event to indicate when the transmit buffer empties */
                        setup_empty_event(tty, ch);             
                        tty_wait_until_sent(tty, 3000); /* 30 seconds timeout */
                }
-       
                if (tty->driver->flush_buffer)
                        tty->driver->flush_buffer(tty);
 
                tty_ldisc_flush(tty);
                shutdown(ch);
+
+               spin_lock_irqsave(&epca_lock, flags);
                tty->closing = 0;
                ch->event = 0;
                ch->tty = NULL;
+               spin_unlock_irqrestore(&epca_lock, flags);
 
-               if (ch->blocked_open) 
-               { /* Begin if blocked_open */
-
+               if (ch->blocked_open)  { /* Begin if blocked_open */
                        if (ch->close_delay) 
-                       {
                                msleep_interruptible(jiffies_to_msecs(ch->close_delay));
-                       }
-
                        wake_up_interruptible(&ch->open_wait);
-
                } /* End if blocked_open */
-
                ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_INITIALIZED | 
                                      ASYNC_CLOSING);
                wake_up_interruptible(&ch->close_wait);
-
-
-               restore_flags(flags);
-
        } /* End if ch != NULL */
-
 } /* End pc_close */ 
 
 /* ------------------ Begin shutdown  ------------------------- */
@@ -586,15 +534,14 @@ static void shutdown(struct channel *ch)
 
        unsigned long flags;
        struct tty_struct *tty;
-       volatile struct board_chan *bc;
+       struct board_chan *bc;
 
        if (!(ch->asyncflags & ASYNC_INITIALIZED)) 
                return;
 
-       save_flags(flags);
-       cli();
-       globalwinon(ch);
+       spin_lock_irqsave(&epca_lock, flags);
 
+       globalwinon(ch);
        bc = ch->brdchan;
 
        /* ------------------------------------------------------------------
@@ -604,20 +551,17 @@ static void shutdown(struct channel *ch)
        --------------------------------------------------------------------- */ 
 
        if (bc)
-               bc->idata = 0;
-
+               writeb(0, &bc->idata);
        tty = ch->tty;
 
        /* ----------------------------------------------------------------
           If we're a modem control device and HUPCL is on, drop RTS & DTR.
        ------------------------------------------------------------------ */
 
-       if (tty->termios->c_cflag & HUPCL) 
-       {
+       if (tty->termios->c_cflag & HUPCL)  {
                ch->omodem &= ~(ch->m_rts | ch->m_dtr);
                fepcmd(ch, SETMODEM, 0, ch->m_dtr | ch->m_rts, 10, 1);
        }
-
        memoff(ch);
 
        /* ------------------------------------------------------------------
@@ -628,7 +572,7 @@ static void shutdown(struct channel *ch)
        /* Prevent future Digi programmed interrupts from coming active */
 
        ch->asyncflags &= ~ASYNC_INITIALIZED;
-       restore_flags(flags);
+       spin_unlock_irqrestore(&epca_lock, flags);
 
 } /* End shutdown */
 
@@ -636,7 +580,6 @@ static void shutdown(struct channel *ch)
 
 static void pc_hangup(struct tty_struct *tty)
 { /* Begin pc_hangup */
-
        struct channel *ch;
        
        /* ---------------------------------------------------------
@@ -644,25 +587,21 @@ static void pc_hangup(struct tty_struct *tty)
                if it is valid.  This serves as a sanity check.
        ------------------------------------------------------------- */
 
-       if ((ch = verifyChannel(tty)) != NULL) 
-       { /* Begin if ch != NULL */
-
+       if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if ch != NULL */
                unsigned long flags;
 
-               save_flags(flags);
-               cli();
                if (tty->driver->flush_buffer)
                        tty->driver->flush_buffer(tty);
                tty_ldisc_flush(tty);
                shutdown(ch);
 
+               spin_lock_irqsave(&epca_lock, flags);
                ch->tty   = NULL;
                ch->event = 0;
                ch->count = 0;
-               restore_flags(flags);
                ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_INITIALIZED);
+               spin_unlock_irqrestore(&epca_lock, flags);
                wake_up_interruptible(&ch->open_wait);
-
        } /* End if ch != NULL */
 
 } /* End pc_hangup */
@@ -672,18 +611,14 @@ static void pc_hangup(struct tty_struct *tty)
 static int pc_write(struct tty_struct * tty,
                     const unsigned char *buf, int bytesAvailable)
 { /* Begin pc_write */
-
-       register unsigned int head, tail;
-       register int dataLen;
-       register int size;
-       register int amountCopied;
-
-
+       unsigned int head, tail;
+       int dataLen;
+       int size;
+       int amountCopied;
        struct channel *ch;
        unsigned long flags;
        int remain;
-       volatile struct board_chan *bc;
-
+       struct board_chan *bc;
 
        /* ----------------------------------------------------------------
                pc_write is primarily called directly by the kernel routine
@@ -706,24 +641,20 @@ static int pc_write(struct tty_struct * tty,
 
        bc   = ch->brdchan;
        size = ch->txbufsize;
-
        amountCopied = 0;
-       save_flags(flags);
-       cli();
 
+       spin_lock_irqsave(&epca_lock, flags);
        globalwinon(ch);
 
-       head = bc->tin & (size - 1);
-       tail = bc->tout;
+       head = readw(&bc->tin) & (size - 1);
+       tail = readw(&bc->tout);
 
-       if (tail != bc->tout)
-               tail = bc->tout;
+       if (tail != readw(&bc->tout))
+               tail = readw(&bc->tout);
        tail &= (size - 1);
 
        /*      If head >= tail, head has not wrapped around. */ 
-       if (head >= tail) 
-       { /* Begin head has not wrapped */
-
+       if (head >= tail)  { /* Begin head has not wrapped */
                /* ---------------------------------------------------------------
                        remain (much like dataLen above) represents the total amount of
                        space available on the card for data.  Here dataLen represents
@@ -731,26 +662,19 @@ static int pc_write(struct tty_struct * tty,
                        buffer.  This is important because a memcpy cannot be told to
                        automatically wrap around when it hits the buffer end.
                ------------------------------------------------------------------ */ 
-
                dataLen = size - head;
                remain = size - (head - tail) - 1;
-
-       } /* End head has not wrapped */
-       else 
-       { /* Begin head has wrapped around */
+       } else { /* Begin head has wrapped around */
 
                remain = tail - head - 1;
                dataLen = remain;
 
        } /* End head has wrapped around */
-
        /* -------------------------------------------------------------------
                        Check the space on the card.  If we have more data than 
                        space; reduce the amount of data to fit the space.
        ---------------------------------------------------------------------- */
-
        bytesAvailable = min(remain, bytesAvailable);
-
        txwinon(ch);
        while (bytesAvailable > 0) 
        { /* Begin while there is data to copy onto card */
@@ -767,26 +691,21 @@ static int pc_write(struct tty_struct * tty,
                amountCopied += dataLen;
                bytesAvailable -= dataLen;
 
-               if (head >= size) 
-               {
+               if (head >= size) {
                        head = 0;
                        dataLen = tail;
                }
-
        } /* End while there is data to copy onto card */
-
        ch->statusflags |= TXBUSY;
        globalwinon(ch);
-       bc->tin = head;
+       writew(head, &bc->tin);
 
-       if ((ch->statusflags & LOWWAIT) == 0) 
-       {
+       if ((ch->statusflags & LOWWAIT) == 0)  {
                ch->statusflags |= LOWWAIT;
-               bc->ilow = 1;
+               writeb(1, &bc->ilow);
        }
        memoff(ch);
-       restore_flags(flags);
-
+       spin_unlock_irqrestore(&epca_lock, flags);
        return(amountCopied);
 
 } /* End pc_write */
@@ -795,11 +714,7 @@ static int pc_write(struct tty_struct * tty,
 
 static void pc_put_char(struct tty_struct *tty, unsigned char c)
 { /* Begin pc_put_char */
-
-   
        pc_write(tty, &c, 1);
-       return;
-
 } /* End pc_put_char */
 
 /* ------------------ Begin pc_write_room  ------------------------- */
@@ -811,7 +726,7 @@ static int pc_write_room(struct tty_struct *tty)
        struct channel *ch;
        unsigned long flags;
        unsigned int head, tail;
-       volatile struct board_chan *bc;
+       struct board_chan *bc;
 
        remain = 0;
 
@@ -820,33 +735,29 @@ static int pc_write_room(struct tty_struct *tty)
                if it is valid.  This serves as a sanity check.
        ------------------------------------------------------------- */
 
-       if ((ch = verifyChannel(tty)) != NULL) 
-       {
-               save_flags(flags);
-               cli();
+       if ((ch = verifyChannel(tty)) != NULL)  {
+               spin_lock_irqsave(&epca_lock, flags);
                globalwinon(ch);
 
                bc   = ch->brdchan;
-               head = bc->tin & (ch->txbufsize - 1);
-               tail = bc->tout;
+               head = readw(&bc->tin) & (ch->txbufsize - 1);
+               tail = readw(&bc->tout);
 
-               if (tail != bc->tout)
-                       tail = bc->tout;
+               if (tail != readw(&bc->tout))
+                       tail = readw(&bc->tout);
                /* Wrap tail if necessary */
                tail &= (ch->txbufsize - 1);
 
                if ((remain = tail - head - 1) < 0 )
                        remain += ch->txbufsize;
 
-               if (remain && (ch->statusflags & LOWWAIT) == 0) 
-               {
+               if (remain && (ch->statusflags & LOWWAIT) == 0) {
                        ch->statusflags |= LOWWAIT;
-                       bc->ilow = 1;
+                       writeb(1, &bc->ilow);
                }
                memoff(ch);
-               restore_flags(flags);
+               spin_unlock_irqrestore(&epca_lock, flags);
        }
-
        /* Return how much room is left on card */
        return remain;
 
@@ -862,8 +773,7 @@ static int pc_chars_in_buffer(struct tty_struct *tty)
        int remain;
        unsigned long flags;
        struct channel *ch;
-       volatile struct board_chan *bc;
-
+       struct board_chan *bc;
 
        /* ---------------------------------------------------------
                verifyChannel returns the channel from the tty struct
@@ -873,34 +783,27 @@ static int pc_chars_in_buffer(struct tty_struct *tty)
        if ((ch = verifyChannel(tty)) == NULL)
                return(0);
 
-       save_flags(flags);
-       cli();
+       spin_lock_irqsave(&epca_lock, flags);
        globalwinon(ch);
 
        bc = ch->brdchan;
-       tail = bc->tout;
-       head = bc->tin;
-       ctail = ch->mailbox->cout;
+       tail = readw(&bc->tout);
+       head = readw(&bc->tin);
+       ctail = readw(&ch->mailbox->cout);
 
-       if (tail == head && ch->mailbox->cin == ctail && bc->tbusy == 0)
+       if (tail == head && readw(&ch->mailbox->cin) == ctail && readb(&bc->tbusy) == 0)
                chars = 0;
-       else 
-       { /* Begin if some space on the card has been used */
-
-               head = bc->tin & (ch->txbufsize - 1);
+       else  { /* Begin if some space on the card has been used */
+               head = readw(&bc->tin) & (ch->txbufsize - 1);
                tail &= (ch->txbufsize - 1);
-
                /*  --------------------------------------------------------------
                        The logic here is basically opposite of the above pc_write_room
                        here we are finding the amount of bytes in the buffer filled.
                        Not the amount of bytes empty.
                ------------------------------------------------------------------- */
-
                if ((remain = tail - head - 1) < 0 )
                        remain += ch->txbufsize;
-
                chars = (int)(ch->txbufsize - remain);
-
                /* -------------------------------------------------------------  
                        Make it possible to wakeup anything waiting for output
                        in tty_ioctl.c, etc.
@@ -908,15 +811,12 @@ static int pc_chars_in_buffer(struct tty_struct *tty)
                        If not already set.  Setup an event to indicate when the
                        transmit buffer empties 
                ----------------------------------------------------------------- */
-
                if (!(ch->statusflags & EMPTYWAIT))
                        setup_empty_event(tty,ch);
 
        } /* End if some space on the card has been used */
-
        memoff(ch);
-       restore_flags(flags);
-
+       spin_unlock_irqrestore(&epca_lock, flags);
        /* Return number of characters residing on card. */
        return(chars);
 
@@ -930,67 +830,46 @@ static void pc_flush_buffer(struct tty_struct *tty)
        unsigned int tail;
        unsigned long flags;
        struct channel *ch;
-       volatile struct board_chan *bc;
-
-
+       struct board_chan *bc;
        /* ---------------------------------------------------------
                verifyChannel returns the channel from the tty struct
                if it is valid.  This serves as a sanity check.
        ------------------------------------------------------------- */
-
        if ((ch = verifyChannel(tty)) == NULL)
                return;
 
-       save_flags(flags);
-       cli();
-
+       spin_lock_irqsave(&epca_lock, flags);
        globalwinon(ch);
-
        bc   = ch->brdchan;
-       tail = bc->tout;
-
+       tail = readw(&bc->tout);
        /* Have FEP move tout pointer; effectively flushing transmit buffer */
-
        fepcmd(ch, STOUT, (unsigned) tail, 0, 0, 0);
-
        memoff(ch);
-       restore_flags(flags);
-
+       spin_unlock_irqrestore(&epca_lock, flags);
        wake_up_interruptible(&tty->write_wait);
        tty_wakeup(tty);
-
 } /* End pc_flush_buffer */
 
 /* ------------------ Begin pc_flush_chars  ---------------------- */
 
 static void pc_flush_chars(struct tty_struct *tty)
 { /* Begin pc_flush_chars */
-
        struct channel * ch;
-
        /* ---------------------------------------------------------
                verifyChannel returns the channel from the tty struct
                if it is valid.  This serves as a sanity check.
        ------------------------------------------------------------- */
-
-       if ((ch = verifyChannel(tty)) != NULL) 
-       {
+       if ((ch = verifyChannel(tty)) != NULL) {
                unsigned long flags;
-
-               save_flags(flags);
-               cli();
-
+               spin_lock_irqsave(&epca_lock, flags);
                /* ----------------------------------------------------------------
                        If not already set and the transmitter is busy setup an event
                        to indicate when the transmit empties.
                ------------------------------------------------------------------- */
-
                if ((ch->statusflags & TXBUSY) && !(ch->statusflags & EMPTYWAIT))
                        setup_empty_event(tty,ch);
-
-               restore_flags(flags);
+               spin_unlock_irqrestore(&epca_lock, flags);
        }
-
 } /* End pc_flush_chars */
 
 /* ------------------ Begin block_til_ready  ---------------------- */
@@ -998,14 +877,11 @@ static void pc_flush_chars(struct tty_struct *tty)
 static int block_til_ready(struct tty_struct *tty, 
                            struct file *filp, struct channel *ch)
 { /* Begin block_til_ready */
-
        DECLARE_WAITQUEUE(wait,current);
        int     retval, do_clocal = 0;
        unsigned long flags;
 
-
-       if (tty_hung_up_p(filp))
-       {
+       if (tty_hung_up_p(filp)) {
                if (ch->asyncflags & ASYNC_HUP_NOTIFY)
                        retval = -EAGAIN;
                else
@@ -1017,8 +893,7 @@ static int block_til_ready(struct tty_struct *tty,
                If the device is in the middle of being closed, then block
                until it's done, and then try again.
        -------------------------------------------------------------------- */
-       if (ch->asyncflags & ASYNC_CLOSING) 
-       {
+       if (ch->asyncflags & ASYNC_CLOSING) {
                interruptible_sleep_on(&ch->close_wait);
 
                if (ch->asyncflags & ASYNC_HUP_NOTIFY)
@@ -1027,43 +902,29 @@ static int block_til_ready(struct tty_struct *tty,
                        return -ERESTARTSYS;
        }
 
-       if (filp->f_flags & O_NONBLOCK) 
-       {
+       if (filp->f_flags & O_NONBLOCK)  {
                /* ----------------------------------------------------------------- 
                 If non-blocking mode is set, then make the check up front
                 and then exit.
                -------------------------------------------------------------------- */
-
                ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
-
                return 0;
        }
-
-
        if (tty->termios->c_cflag & CLOCAL)
                do_clocal = 1;
-       
-   /* Block waiting for the carrier detect and the line to become free */
+       /* Block waiting for the carrier detect and the line to become free */
        
        retval = 0;
        add_wait_queue(&ch->open_wait, &wait);
-       save_flags(flags);
-       cli();
-
 
+       spin_lock_irqsave(&epca_lock, flags);
        /* We dec count so that pc_close will know when to free things */
        if (!tty_hung_up_p(filp))
                ch->count--;
-
-       restore_flags(flags);
-
        ch->blocked_open++;
-
        while(1) 
        { /* Begin forever while  */
-
                set_current_state(TASK_INTERRUPTIBLE);
-
                if (tty_hung_up_p(filp) ||
                    !(ch->asyncflags & ASYNC_INITIALIZED)) 
                {
@@ -1073,17 +934,14 @@ static int block_til_ready(struct tty_struct *tty,
                                retval = -ERESTARTSYS;  
                        break;
                }
-
                if (!(ch->asyncflags & ASYNC_CLOSING) && 
                          (do_clocal || (ch->imodem & ch->dcd)))
                        break;
-
-               if (signal_pending(current)) 
-               {
+               if (signal_pending(current)) {
                        retval = -ERESTARTSYS;
                        break;
                }
-
+               spin_unlock_irqrestore(&epca_lock, flags);
                /* ---------------------------------------------------------------
                        Allow someone else to be scheduled.  We will occasionally go
                        through this loop until one of the above conditions change.
@@ -1091,25 +949,23 @@ static int block_til_ready(struct tty_struct *tty,
                        prevent this loop from hogging the cpu.
                ------------------------------------------------------------------ */
                schedule();
+               spin_lock_irqsave(&epca_lock, flags);
 
        } /* End forever while  */
 
        current->state = TASK_RUNNING;
        remove_wait_queue(&ch->open_wait, &wait);
-       cli();
        if (!tty_hung_up_p(filp))
                ch->count++;
-       restore_flags(flags);
-
        ch->blocked_open--;
 
+       spin_unlock_irqrestore(&epca_lock, flags);
+
        if (retval)
                return retval;
 
        ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
-
        return 0;
-
 } /* End block_til_ready */    
 
 /* ------------------ Begin pc_open  ---------------------- */
@@ -1120,17 +976,12 @@ static int pc_open(struct tty_struct *tty, struct file * filp)
        struct channel *ch;
        unsigned long flags;
        int line, retval, boardnum;
-       volatile struct board_chan *bc;
-       volatile unsigned int head;
+       struct board_chan *bc;
+       unsigned int head;
 
        line = tty->index;
-       if (line < 0 || line >= nbdevs) 
-       {
-               printk(KERN_ERR "<Error> - pc_open : line out of range in pc_open\n");
-               tty->driver_data = NULL;
-               return(-ENODEV);
-       }
-
+       if (line < 0 || line >= nbdevs)
+               return -ENODEV;
 
        ch = &digi_channels[line];
        boardnum = ch->boardnum;
@@ -1143,66 +994,49 @@ static int pc_open(struct tty_struct *tty, struct file * filp)
                goes here.
        ---------------------------------------------------------------------- */
 
-       if (invalid_lilo_config)
-       {
+       if (invalid_lilo_config) {
                if (setup_error_code & INVALID_BOARD_TYPE)
-                       printk(KERN_ERR "<Error> - pc_open: Invalid board type specified in LILO command\n");
-
+                       printk(KERN_ERR "epca: pc_open: Invalid board type specified in kernel options.\n");
                if (setup_error_code & INVALID_NUM_PORTS)
-                       printk(KERN_ERR "<Error> - pc_open: Invalid number of ports specified in LILO command\n");
-
+                       printk(KERN_ERR "epca: pc_open: Invalid number of ports specified in kernel options.\n");
                if (setup_error_code & INVALID_MEM_BASE)
-                       printk(KERN_ERR "<Error> - pc_open: Invalid board memory address specified in LILO command\n");
-
+                       printk(KERN_ERR "epca: pc_open: Invalid board memory address specified in kernel options.\n");
                if (setup_error_code & INVALID_PORT_BASE)
-                       printk(KERN_ERR "<Error> - pc_open: Invalid board port address specified in LILO command\n");
-
+                       printk(KERN_ERR "epca; pc_open: Invalid board port address specified in kernel options.\n");
                if (setup_error_code & INVALID_BOARD_STATUS)
-                       printk(KERN_ERR "<Error> - pc_open: Invalid board status specified in LILO command\n");
-
+                       printk(KERN_ERR "epca: pc_open: Invalid board status specified in kernel options.\n");
                if (setup_error_code & INVALID_ALTPIN)
-                       printk(KERN_ERR "<Error> - pc_open: Invalid board altpin specified in LILO command\n");
-
+                       printk(KERN_ERR "epca: pc_open: Invalid board altpin specified in kernel options;\n");
                tty->driver_data = NULL;   /* Mark this device as 'down' */
-               return(-ENODEV);
+               return -ENODEV;
        }
-
-       if ((boardnum >= num_cards) || (boards[boardnum].status == DISABLED)) 
-       {
+       if (boardnum >= num_cards || boards[boardnum].status == DISABLED)  {
                tty->driver_data = NULL;   /* Mark this device as 'down' */
                return(-ENODEV);
        }
        
-       if (( bc = ch->brdchan) == 0) 
-       {
+       if ((bc = ch->brdchan) == 0) {
                tty->driver_data = NULL;
-               return(-ENODEV);
+               return -ENODEV;
        }
 
+       spin_lock_irqsave(&epca_lock, flags);
        /* ------------------------------------------------------------------
                Every time a channel is opened, increment a counter.  This is 
                necessary because we do not wish to flush and shutdown the channel
                until the last app holding the channel open, closes it.         
        --------------------------------------------------------------------- */
-
        ch->count++;
-
        /* ----------------------------------------------------------------
                Set a kernel structures pointer to our local channel 
                structure.  This way we can get to it when passed only
                a tty struct.
        ------------------------------------------------------------------ */
-
        tty->driver_data = ch;
-       
        /* ----------------------------------------------------------------
                If this is the first time the channel has been opened, initialize
                the tty->termios struct otherwise let pc_close handle it.
        -------------------------------------------------------------------- */
-
-       save_flags(flags);
-       cli();
-
        globalwinon(ch);
        ch->statusflags = 0;
 
@@ -1213,8 +1047,8 @@ static int pc_open(struct tty_struct *tty, struct file * filp)
           Set receive head and tail ptrs to each other.  This indicates
           no data available to read.
        ----------------------------------------------------------------- */
-       head = bc->rin;
-       bc->rout = head;
+       head = readw(&bc->rin);
+       writew(head, &bc->rout);
 
        /* Set the channels associated tty structure */
        ch->tty = tty;
@@ -1224,122 +1058,74 @@ static int pc_open(struct tty_struct *tty, struct file * filp)
                issues, etc.... It effect both control flags and input flags.
        -------------------------------------------------------------------- */
        epcaparam(tty,ch);
-
        ch->asyncflags |= ASYNC_INITIALIZED;
        memoff(ch);
-
-       restore_flags(flags);
+       spin_unlock_irqrestore(&epca_lock, flags);
 
        retval = block_til_ready(tty, filp, ch);
        if (retval)
-       {
                return retval;
-       }
-
        /* -------------------------------------------------------------
                Set this again in case a hangup set it to zero while this 
                open() was waiting for the line...
        --------------------------------------------------------------- */
+       spin_lock_irqsave(&epca_lock, flags);
        ch->tty = tty;
-
-       save_flags(flags);
-       cli();
        globalwinon(ch);
-
        /* Enable Digi Data events */
-       bc->idata = 1;
-
+       writeb(1, &bc->idata);
        memoff(ch);
-       restore_flags(flags);
-
+       spin_unlock_irqrestore(&epca_lock, flags);
        return 0;
-
 } /* End pc_open */
 
-#ifdef MODULE
 static int __init epca_module_init(void)
 { /* Begin init_module */
-
-       unsigned long   flags;
-
-       save_flags(flags);
-       cli();
-
-       pc_init();
-
-       restore_flags(flags);
-
-       return(0);
+       return pc_init();
 }
 
 module_init(epca_module_init);
-#endif
 
-#ifdef ENABLE_PCI
 static struct pci_driver epca_driver;
-#endif
-
-#ifdef MODULE
-/* -------------------- Begin cleanup_module  ---------------------- */
 
 static void __exit epca_module_exit(void)
 {
-
        int               count, crd;
        struct board_info *bd;
        struct channel    *ch;
-       unsigned long     flags;
 
        del_timer_sync(&epca_timer);
 
-       save_flags(flags);
-       cli();
-
        if ((tty_unregister_driver(pc_driver)) ||  
            (tty_unregister_driver(pc_info)))
        {
-               printk(KERN_WARNING "<Error> - DIGI : cleanup_module failed to un-register tty driver\n");
-               restore_flags(flags);
+               printk(KERN_WARNING "epca: cleanup_module failed to un-register tty driver\n");
                return;
        }
        put_tty_driver(pc_driver);
        put_tty_driver(pc_info);
 
-       for (crd = 0; crd < num_cards; crd++) 
-       { /* Begin for each card */
-
+       for (crd = 0; crd < num_cards; crd++)  { /* Begin for each card */
                bd = &boards[crd];
-
                if (!bd)
                { /* Begin sanity check */
                        printk(KERN_ERR "<Error> - Digi : cleanup_module failed\n");
                        return;
                } /* End sanity check */
-
-               ch = card_ptr[crd]; 
-
+               ch = card_ptr[crd];
                for (count = 0; count < bd->numports; count++, ch++) 
                { /* Begin for each port */
-
-                       if (ch) 
-                       {
+                       if (ch) {
                                if (ch->tty)
                                        tty_hangup(ch->tty);
                                kfree(ch->tmp_buf);
                        }
-
                } /* End for each port */
        } /* End for each card */
-
-#ifdef ENABLE_PCI
        pci_unregister_driver (&epca_driver);
-#endif
-
-       restore_flags(flags);
-
 }
+
 module_exit(epca_module_exit);
-#endif /* MODULE */
 
 static struct tty_operations pc_ops = {
        .open = pc_open,
@@ -1371,34 +1157,15 @@ static struct tty_operations info_ops = {
 
 /* ------------------ Begin pc_init  ---------------------- */
 
-int __init pc_init(void)
+static int __init pc_init(void)
 { /* Begin pc_init */
-
-       /* ----------------------------------------------------------------
-               pc_init is called by the operating system during boot up prior to
-               any open calls being made.  In the older versions of Linux (Prior
-               to 2.0.0) an entry is made into tty_io.c.  A pointer to the last
-               memory location (from kernel space) used (kmem_start) is passed
-               to pc_init.  It is pc_inits responsibility to modify this value 
-               for any memory that the Digi driver might need and then return
-               this value to the operating system.  For example if the driver
-               wishes to allocate 1K of kernel memory, pc_init would return 
-               (kmem_start + 1024).  This memory (Between kmem_start and kmem_start
-               + 1024) would then be available for use exclusively by the driver.  
-               In this case our driver does not allocate any of this kernel 
-               memory.
-       ------------------------------------------------------------------*/
-
-       ulong flags;
        int crd;
        struct board_info *bd;
        unsigned char board_id = 0;
 
-#ifdef ENABLE_PCI
        int pci_boards_found, pci_count;
 
        pci_count = 0;
-#endif /* ENABLE_PCI */
 
        pc_driver = alloc_tty_driver(MAX_ALLOC);
        if (!pc_driver)
@@ -1416,8 +1183,7 @@ int __init pc_init(void)
                Note : If LILO has ran epca_setup then epca_setup will handle defining
                num_cards as well as copying the data into the board structure.
        -------------------------------------------------------------------------- */
-       if (!liloconfig)
-       { /* Begin driver has been configured via. epcaconfig */
+       if (!liloconfig) { /* Begin driver has been configured via. epcaconfig */
 
                nbdevs = NBDEVS;
                num_cards = NUMCARDS;
@@ -1440,8 +1206,6 @@ int __init pc_init(void)
 
        printk(KERN_INFO "DIGI epca driver version %s loaded.\n",VERSION);
 
-#ifdef ENABLE_PCI
-
        /* ------------------------------------------------------------------
                NOTE : This code assumes that the number of ports found in 
                       the boards array is correct.  This could be wrong if
@@ -1467,8 +1231,6 @@ int __init pc_init(void)
                pci_boards_found += init_PCI();
        num_cards += pci_boards_found;
 
-#endif /* ENABLE_PCI */
-
        pc_driver->owner = THIS_MODULE;
        pc_driver->name = "ttyD"; 
        pc_driver->devfs_name = "tts/D";
@@ -1499,9 +1261,6 @@ int __init pc_init(void)
        tty_set_operations(pc_info, &info_ops);
 
 
-       save_flags(flags);
-       cli();
-
        for (crd = 0; crd < num_cards; crd++) 
        { /* Begin for each card */
 
@@ -1610,11 +1369,7 @@ int __init pc_init(void)
                                        if ((board_id & 0x30) == 0x30) 
                                                bd->memory_seg = 0x8000;
 
-                               } /* End it is an XI card */
-                               else
-                               {
-                                       printk(KERN_ERR "<Error> - Board at 0x%x doesn't appear to be an XI\n",(int)bd->port);
-                               }
+                               } else printk(KERN_ERR "epca: Board at 0x%x doesn't appear to be an XI\n",(int)bd->port);
                        break;
 
                } /* End switch on bd->type */
@@ -1634,9 +1389,6 @@ int __init pc_init(void)
        init_timer(&epca_timer);
        epca_timer.function = epcapoll;
        mod_timer(&epca_timer, jiffies + HZ/25);
-
-       restore_flags(flags);
-
        return 0;
 
 } /* End pc_init */
@@ -1647,10 +1399,10 @@ static void post_fep_init(unsigned int crd)
 { /* Begin post_fep_init */
 
        int i;
-       unchar *memaddr;
-       volatile struct global_data *gd;
+       unsigned char *memaddr;
+       struct global_data *gd;
        struct board_info *bd;
-       volatile struct board_chan *bc;
+       struct board_chan *bc;
        struct channel *ch; 
        int shrinkmem = 0, lowwater ; 
  
@@ -1669,9 +1421,7 @@ static void post_fep_init(unsigned int crd)
                after DIGI_INIT has been called will return the proper values. 
        ------------------------------------------------------------------- */
 
-       if (bd->type >= PCIXEM) /* If the board in question is PCI */
-       { /* Begin get PCI number of ports */
-
+       if (bd->type >= PCIXEM) { /* Begin get PCI number of ports */
                /* --------------------------------------------------------------------
                        Below we use XEMPORTS as a memory offset regardless of which PCI
                        card it is.  This is because all of the supported PCI cards have
@@ -1685,15 +1435,15 @@ static void post_fep_init(unsigned int crd)
                        (FYI - The id should be located at 0x1ac (And may use up to 4 bytes
                        if the box in question is a XEM or CX)).  
                ------------------------------------------------------------------------ */ 
-
-               bd->numports = (unsigned short)*(unsigned char *)bus_to_virt((unsigned long)
-                                                       (bd->re_map_membase + XEMPORTS));
-
-               
+               /* PCI cards are already remapped at this point ISA are not */
+               bd->numports = readw(bd->re_map_membase + XEMPORTS);
                epcaassert(bd->numports <= 64,"PCI returned a invalid number of ports");
                nbdevs += (bd->numports);
-
-       } /* End get PCI number of ports */
+       } else {
+               /* Fix up the mappings for ISA/EISA etc */
+               /* FIXME: 64K - can we be smarter ? */
+               bd->re_map_membase = ioremap(bd->membase, 0x10000);
+       }
 
        if (crd != 0)
                card_ptr[crd] = card_ptr[crd-1] + boards[crd-1].numports;
@@ -1701,19 +1451,9 @@ static void post_fep_init(unsigned int crd)
                card_ptr[crd] = &digi_channels[crd]; /* <- For card 0 only */
 
        ch = card_ptr[crd];
-
-
        epcaassert(ch <= &digi_channels[nbdevs - 1], "ch out of range");
 
-       memaddr = (unchar *)bd->re_map_membase;
-
-       /* 
-          The below command is necessary because newer kernels (2.1.x and
-          up) do not have a 1:1 virtual to physical mapping.  The below
-          call adjust for that.
-       */
-
-       memaddr = (unsigned char *)bus_to_virt((unsigned long)memaddr);
+       memaddr = bd->re_map_membase;
 
        /* -----------------------------------------------------------------
                The below assignment will set bc to point at the BEGINING of
@@ -1721,7 +1461,7 @@ static void post_fep_init(unsigned int crd)
                8 and 64 of these structures.
        -------------------------------------------------------------------- */
 
-       bc = (volatile struct board_chan *)((ulong)memaddr + CHANSTRUCT);
+       bc = (struct board_chan *)(memaddr + CHANSTRUCT);
 
        /* -------------------------------------------------------------------
                The below assignment will set gd to point at the BEGINING of
@@ -1730,20 +1470,18 @@ static void post_fep_init(unsigned int crd)
                pointer begins at 0xd10.
        ---------------------------------------------------------------------- */
 
-       gd = (volatile struct global_data *)((ulong)memaddr + GLOBAL);
+       gd = (struct global_data *)(memaddr + GLOBAL);
 
        /* --------------------------------------------------------------------
                XEPORTS (address 0xc22) points at the number of channels the
                card supports. (For 64XE, XI, XEM, and XR use 0xc02)
        ----------------------------------------------------------------------- */
 
-       if (((bd->type == PCXEVE) | (bd->type == PCXE)) &&
-           (*(ushort *)((ulong)memaddr + XEPORTS) < 3))
+       if ((bd->type == PCXEVE || bd->type == PCXE) && (readw(memaddr + XEPORTS) < 3))
                shrinkmem = 1;
        if (bd->type < PCIXEM)
                if (!request_region((int)bd->port, 4, board_desc[bd->type]))
                        return;         
-
        memwinon(bd, 0);
 
        /*  --------------------------------------------------------------------
@@ -1753,17 +1491,16 @@ static void post_fep_init(unsigned int crd)
 
        /* For every port on the card do ..... */
 
-       for (i = 0; i < bd->numports; i++, ch++, bc++) 
-       { /* Begin for each port */
+       for (i = 0; i < bd->numports; i++, ch++, bc++)  { /* Begin for each port */
+               unsigned long flags;
 
                ch->brdchan        = bc;
                ch->mailbox        = gd; 
                INIT_WORK(&ch->tqueue, do_softint, ch);
                ch->board          = &boards[crd];
 
-               switch (bd->type)
-               { /* Begin switch bd->type */
-
+               spin_lock_irqsave(&epca_lock, flags);
+               switch (bd->type) {
                        /* ----------------------------------------------------------------
                                Since some of the boards use different bitmaps for their
                                control signals we cannot hard code these values and retain
@@ -1796,14 +1533,12 @@ static void post_fep_init(unsigned int crd)
        
                } /* End switch bd->type */
 
-               if (boards[crd].altpin) 
-               {
+               if (boards[crd].altpin) {
                        ch->dsr = ch->m_dcd;
                        ch->dcd = ch->m_dsr;
                        ch->digiext.digi_flags |= DIGI_ALTPIN;
                }
-               else 
-               { 
+               else {
                        ch->dcd = ch->m_dcd;
                        ch->dsr = ch->m_dsr;
                }
@@ -1813,14 +1548,12 @@ static void post_fep_init(unsigned int crd)
                ch->magic      = EPCA_MAGIC;
                ch->tty        = NULL;
 
-               if (shrinkmem) 
-               {
+               if (shrinkmem) {
                        fepcmd(ch, SETBUFFER, 32, 0, 0, 0);
                        shrinkmem = 0;
                }
 
-               switch (bd->type)
-               { /* Begin switch bd->type */
+               switch (bd->type) {
 
                        case PCIXEM:
                        case PCIXRJ:
@@ -1878,13 +1611,13 @@ static void post_fep_init(unsigned int crd)
 
                fepcmd(ch, SRXHWATER, (3 * ch->rxbufsize / 4), 0, 10, 0);
 
-               bc->edelay = 100;
-               bc->idata = 1;
+               writew(100, &bc->edelay);
+               writeb(1, &bc->idata);
        
-               ch->startc  = bc->startc;
-               ch->stopc   = bc->stopc;
-               ch->startca = bc->startca;
-               ch->stopca  = bc->stopca;
+               ch->startc  = readb(&bc->startc);
+               ch->stopc   = readb(&bc->stopc);
+               ch->startca = readb(&bc->startca);
+               ch->stopca  = readb(&bc->stopca);
        
                ch->fepcflag = 0;
                ch->fepiflag = 0;
@@ -1899,27 +1632,23 @@ static void post_fep_init(unsigned int crd)
                ch->blocked_open = 0;
                init_waitqueue_head(&ch->open_wait);
                init_waitqueue_head(&ch->close_wait);
+
+               spin_unlock_irqrestore(&epca_lock, flags);
+
                ch->tmp_buf = kmalloc(ch->txbufsize,GFP_KERNEL);
-               if (!(ch->tmp_buf))
-               {
+               if (!ch->tmp_buf) {
                        printk(KERN_ERR "POST FEP INIT : kmalloc failed for port 0x%x\n",i);
                        release_region((int)bd->port, 4);
                        while(i-- > 0)
                                kfree((ch--)->tmp_buf);
                        return;
-               }
-               else 
+               } else
                        memset((void *)ch->tmp_buf,0,ch->txbufsize);
        } /* End for each port */
 
        printk(KERN_INFO 
                "Digi PC/Xx Driver V%s:  %s I/O = 0x%lx Mem = 0x%lx Ports = %d\n", 
                VERSION, board_desc[bd->type], (long)bd->port, (long)bd->membase, bd->numports);
-       sprintf(mesg, 
-               "Digi PC/Xx Driver V%s:  %s I/O = 0x%lx Mem = 0x%lx Ports = %d\n", 
-               VERSION, board_desc[bd->type], (long)bd->port, (long)bd->membase, bd->numports);
-       console_print(mesg);
-
        memwinoff(bd, 0);
 
 } /* End post_fep_init */
@@ -1943,9 +1672,6 @@ static void epcapoll(unsigned long ignored)
                buffer empty) and acts on those events.
        ----------------------------------------------------------------------- */
        
-       save_flags(flags);
-       cli();
-
        for (crd = 0; crd < num_cards; crd++) 
        { /* Begin for each card */
 
@@ -1961,6 +1687,8 @@ static void epcapoll(unsigned long ignored)
                        some legacy boards.
                ---------------------------------------------------------------- */
 
+               spin_lock_irqsave(&epca_lock, flags);
+
                assertmemoff(ch);
 
                globalwinon(ch);
@@ -1970,21 +1698,19 @@ static void epcapoll(unsigned long ignored)
                        the transmit or receive queue.
                ------------------------------------------------------------------- */
 
-               head = ch->mailbox->ein;
-               tail = ch->mailbox->eout;
+               head = readw(&ch->mailbox->ein);
+               tail = readw(&ch->mailbox->eout);
                
                /* If head isn't equal to tail we have an event */
 
                if (head != tail)
                        doevent(crd);
-
                memoff(ch);
 
-       } /* End for each card */
+               spin_unlock_irqrestore(&epca_lock, flags);
 
+       } /* End for each card */
        mod_timer(&epca_timer, jiffies + (HZ / 25));
-
-       restore_flags(flags);
 } /* End epcapoll */
 
 /* --------------------- Begin doevent  ------------------------ */
@@ -1992,53 +1718,42 @@ static void epcapoll(unsigned long ignored)
 static void doevent(int crd)
 { /* Begin doevent */
 
-       volatile unchar *eventbuf;
+       void *eventbuf;
        struct channel *ch, *chan0;
        static struct tty_struct *tty;
-       volatile struct board_info *bd;
-       volatile struct board_chan *bc;
-       register volatile unsigned int tail, head;
-       register int event, channel;
-       register int mstat, lstat;
+       struct board_info *bd;
+       struct board_chan *bc;
+       unsigned int tail, head;
+       int event, channel;
+       int mstat, lstat;
 
        /* -------------------------------------------------------------------
                This subroutine is called by epcapoll when an event is detected 
                in the event queue.  This routine responds to those events.
        --------------------------------------------------------------------- */
-
        bd = &boards[crd];
 
        chan0 = card_ptr[crd];
        epcaassert(chan0 <= &digi_channels[nbdevs - 1], "ch out of range");
-
        assertgwinon(chan0);
-
-       while ((tail = chan0->mailbox->eout) != (head = chan0->mailbox->ein)) 
+       while ((tail = readw(&chan0->mailbox->eout)) != (head = readw(&chan0->mailbox->ein)))
        { /* Begin while something in event queue */
-
                assertgwinon(chan0);
-
-               eventbuf = (volatile unchar *)bus_to_virt((ulong)(bd->re_map_membase + tail + ISTART));
-
+               eventbuf = bd->re_map_membase + tail + ISTART;
                /* Get the channel the event occurred on */
-               channel = eventbuf[0];
-
+               channel = readb(eventbuf);
                /* Get the actual event code that occurred */
-               event = eventbuf[1];
-
+               event = readb(eventbuf + 1);
                /*  ----------------------------------------------------------------
                        The two assignments below get the current modem status (mstat)
                        and the previous modem status (lstat).  These are useful becuase
                        an event could signal a change in modem signals itself.
                ------------------------------------------------------------------- */
-
-               mstat = eventbuf[2];
-               lstat = eventbuf[3];
+               mstat = readb(eventbuf + 2);
+               lstat = readb(eventbuf + 3);
 
                ch = chan0 + channel;
-
-               if ((unsigned)channel >= bd->numports || !ch) 
-               { 
+               if ((unsigned)channel >= bd->numports || !ch)  {
                        if (channel >= bd->numports)
                                ch = chan0;
                        bc = ch->brdchan;
@@ -2048,97 +1763,53 @@ static void doevent(int crd)
                if ((bc = ch->brdchan) == NULL)
                        goto next;
 
-               if (event & DATA_IND) 
-               { /* Begin DATA_IND */
-
+               if (event & DATA_IND)  { /* Begin DATA_IND */
                        receive_data(ch);
                        assertgwinon(ch);
-
                } /* End DATA_IND */
                /* else *//* Fix for DCD transition missed bug */
-               if (event & MODEMCHG_IND) 
-               { /* Begin MODEMCHG_IND */
-
+               if (event & MODEMCHG_IND)  { /* Begin MODEMCHG_IND */
                        /* A modem signal change has been indicated */
-
                        ch->imodem = mstat;
-
-                       if (ch->asyncflags & ASYNC_CHECK_CD) 
-                       {
+                       if (ch->asyncflags & ASYNC_CHECK_CD)  {
                                if (mstat & ch->dcd)  /* We are now receiving dcd */
                                        wake_up_interruptible(&ch->open_wait);
                                else
                                        pc_sched_event(ch, EPCA_EVENT_HANGUP); /* No dcd; hangup */
                        }
-
                } /* End MODEMCHG_IND */
-
                tty = ch->tty;
-               if (tty) 
-               { /* Begin if valid tty */
-
-                       if (event & BREAK_IND) 
-                       { /* Begin if BREAK_IND */
-
+               if (tty)  { /* Begin if valid tty */
+                       if (event & BREAK_IND)  { /* Begin if BREAK_IND */
                                /* A break has been indicated */
-
                                tty->flip.count++;
                                *tty->flip.flag_buf_ptr++ = TTY_BREAK;
-
                                *tty->flip.char_buf_ptr++ = 0;
-
                                tty_schedule_flip(tty); 
-
-                       } /* End if BREAK_IND */
-                       else
-                       if (event & LOWTX_IND) 
-                       { /* Begin LOWTX_IND */
-
+                       } else if (event & LOWTX_IND)  { /* Begin LOWTX_IND */
                                if (ch->statusflags & LOWWAIT) 
                                { /* Begin if LOWWAIT */
-
                                        ch->statusflags &= ~LOWWAIT;
                                        tty_wakeup(tty);
                                        wake_up_interruptible(&tty->write_wait);
-
                                } /* End if LOWWAIT */
-
-                       } /* End LOWTX_IND */
-                       else
-                       if (event & EMPTYTX_IND) 
-                       { /* Begin EMPTYTX_IND */
-
+                       } else if (event & EMPTYTX_IND)  { /* Begin EMPTYTX_IND */
                                /* This event is generated by setup_empty_event */
-
                                ch->statusflags &= ~TXBUSY;
-                               if (ch->statusflags & EMPTYWAIT) 
-                               { /* Begin if EMPTYWAIT */
-
+                               if (ch->statusflags & EMPTYWAIT)  { /* Begin if EMPTYWAIT */
                                        ch->statusflags &= ~EMPTYWAIT;
                                        tty_wakeup(tty);
-
                                        wake_up_interruptible(&tty->write_wait);
-
                                } /* End if EMPTYWAIT */
-
                        } /* End EMPTYTX_IND */
-
                } /* End if valid tty */
-
-
        next:
                globalwinon(ch);
-
-               if (!bc)
-                       printk(KERN_ERR "<Error> - bc == NULL in doevent!\n");
-               else 
-                       bc->idata = 1;
-
-               chan0->mailbox->eout = (tail + 4) & (IMAX - ISTART - 4);
+               BUG_ON(!bc);
+               writew(1, &bc->idata);
+               writew((tail + 4) & (IMAX - ISTART - 4), &chan0->mailbox->eout);
                globalwinon(chan0);
-
        } /* End while something in event queue */
-
 } /* End doevent */
 
 /* --------------------- Begin fepcmd  ------------------------ */
@@ -2146,7 +1817,6 @@ static void doevent(int crd)
 static void fepcmd(struct channel *ch, int cmd, int word_or_byte,
                    int byte2, int ncmds, int bytecmd)
 { /* Begin fepcmd */
-
        unchar *memaddr;
        unsigned int head, cmdTail, cmdStart, cmdMax;
        long count;
@@ -2155,93 +1825,57 @@ static void fepcmd(struct channel *ch, int cmd, int word_or_byte,
        /* This is the routine in which commands may be passed to the card. */
 
        if (ch->board->status == DISABLED)
-       {
                return;
-       }
-
        assertgwinon(ch);
-
        /* Remember head (As well as max) is just an offset not a base addr */
-       head = ch->mailbox->cin;
-
+       head = readw(&ch->mailbox->cin);
        /* cmdStart is a base address */
-       cmdStart = ch->mailbox->cstart;
-
+       cmdStart = readw(&ch->mailbox->cstart);
        /* ------------------------------------------------------------------
                We do the addition below because we do not want a max pointer 
                relative to cmdStart.  We want a max pointer that points at the 
                physical end of the command queue.
        -------------------------------------------------------------------- */
-
-       cmdMax = (cmdStart + 4 + (ch->mailbox->cmax));
-
+       cmdMax = (cmdStart + 4 + readw(&ch->mailbox->cmax));
        memaddr = ch->board->re_map_membase;
 
-       /* 
-          The below command is necessary because newer kernels (2.1.x and
-          up) do not have a 1:1 virtual to physical mapping.  The below
-          call adjust for that.
-       */
-
-       memaddr = (unsigned char *)bus_to_virt((unsigned long)memaddr);
-
-       if (head >= (cmdMax - cmdStart) || (head & 03)) 
-       {
-               printk(KERN_ERR "line %d: Out of range, cmd = %x, head = %x\n", __LINE__, 
-              cmd, head);
-               printk(KERN_ERR "line %d: Out of range, cmdMax = %x, cmdStart = %x\n", __LINE__, 
-              cmdMax, cmdStart);
+       if (head >= (cmdMax - cmdStart) || (head & 03))  {
+               printk(KERN_ERR "line %d: Out of range, cmd = %x, head = %x\n", __LINE__,  cmd, head);
+               printk(KERN_ERR "line %d: Out of range, cmdMax = %x, cmdStart = %x\n", __LINE__,  cmdMax, cmdStart);
                return;
        }
-
-       if (bytecmd) 
-       {
-               *(volatile unchar *)(memaddr + head + cmdStart + 0) = (unchar)cmd;
-
-               *(volatile unchar *)(memaddr + head + cmdStart + 1) = (unchar)ch->channelnum;
+       if (bytecmd)  {
+               writeb(cmd, memaddr + head + cmdStart + 0);
+               writeb(ch->channelnum,  memaddr + head + cmdStart + 1);
                /* Below word_or_byte is bits to set */
-               *(volatile unchar *)(memaddr + head + cmdStart + 2) = (unchar)word_or_byte;
+               writeb(word_or_byte,  memaddr + head + cmdStart + 2);
                /* Below byte2 is bits to reset */
-               *(volatile unchar *)(memaddr + head + cmdStart + 3) = (unchar)byte2;
-
-       } 
-       else 
-       {
-               *(volatile unchar *)(memaddr + head + cmdStart + 0) = (unchar)cmd;
-               *(volatile unchar *)(memaddr + head + cmdStart + 1) = (unchar)ch->channelnum;
-               *(volatile ushort*)(memaddr + head + cmdStart + 2) = (ushort)word_or_byte;
+               writeb(byte2, memaddr + head + cmdStart + 3);
+       }  else {
+               writeb(cmd, memaddr + head + cmdStart + 0);
+               writeb(ch->channelnum,  memaddr + head + cmdStart + 1);
+               writeb(word_or_byte,  memaddr + head + cmdStart + 2);
        }
-
        head = (head + 4) & (cmdMax - cmdStart - 4);
-       ch->mailbox->cin = head;
-
+       writew(head, &ch->mailbox->cin);
        count = FEPTIMEOUT;
 
-       for (;;) 
-       { /* Begin forever loop */
-
+       for (;;)  { /* Begin forever loop */
                count--;
-               if (count == 0) 
-               {
+               if (count == 0)  {
                        printk(KERN_ERR "<Error> - Fep not responding in fepcmd()\n");
                        return;
                }
-
-               head = ch->mailbox->cin;
-               cmdTail = ch->mailbox->cout;
-
+               head = readw(&ch->mailbox->cin);
+               cmdTail = readw(&ch->mailbox->cout);
                n = (head - cmdTail) & (cmdMax - cmdStart - 4);
-
                /* ----------------------------------------------------------
                        Basically this will break when the FEP acknowledges the 
                        command by incrementing cmdTail (Making it equal to head).
                ------------------------------------------------------------- */
-
                if (n <= ncmds * (sizeof(short) * 4))
                        break; /* Well nearly forever :-) */
-
        } /* End forever loop */
-
 } /* End fepcmd */
 
 /* ---------------------------------------------------------------------
@@ -2255,11 +1889,9 @@ static void fepcmd(struct channel *ch, int cmd, int word_or_byte,
 
 static unsigned termios2digi_h(struct channel *ch, unsigned cflag)
 { /* Begin termios2digi_h */
-
        unsigned res = 0;
 
-       if (cflag & CRTSCTS) 
-       {
+       if (cflag & CRTSCTS) {
                ch->digiext.digi_flags |= (RTSPACE | CTSPACE);
                res |= ((ch->m_cts) | (ch->m_rts));
        }
@@ -2295,7 +1927,6 @@ static unsigned termios2digi_i(struct channel *ch, unsigned iflag)
 
        unsigned res = iflag & (IGNBRK | BRKINT | IGNPAR | PARMRK | 
                                INPCK | ISTRIP|IXON|IXANY|IXOFF);
-       
        if (ch->digiext.digi_flags & DIGI_AIXON)
                res |= IAIXON;
        return res;
@@ -2308,28 +1939,15 @@ static unsigned termios2digi_c(struct channel *ch, unsigned cflag)
 { /* Begin termios2digi_c */
 
        unsigned res = 0;
-
-#ifdef SPEED_HACK
-       /* CL: HACK to force 115200 at 38400 and 57600 at 19200 Baud */
-       if ((cflag & CBAUD)== B38400) cflag=cflag - B38400 + B115200;
-       if ((cflag & CBAUD)== B19200) cflag=cflag - B19200 + B57600;
-#endif /* SPEED_HACK */
-
-       if (cflag & CBAUDEX)
-       { /* Begin detected CBAUDEX */
-
+       if (cflag & CBAUDEX) { /* Begin detected CBAUDEX */
                ch->digiext.digi_flags |= DIGI_FAST;
-
                /* -------------------------------------------------------------
                   HUPCL bit is used by FEP to indicate fast baud
                   table is to be used.
                ----------------------------------------------------------------- */
-
                res |= FEP_HUPCL;
-
        } /* End detected CBAUDEX */
        else ch->digiext.digi_flags &= ~DIGI_FAST; 
-
        /* -------------------------------------------------------------------
                CBAUD has bit position 0x1000 set these days to indicate Linux
                baud rate remap.  Digi hardware can't handle the bit assignment.
@@ -2337,7 +1955,6 @@ static unsigned termios2digi_c(struct channel *ch, unsigned cflag)
                bit out.
        ---------------------------------------------------------------------- */
        res |= cflag & ((CBAUD ^ CBAUDEX) | PARODD | PARENB | CSTOPB | CSIZE);
-
        /* -------------------------------------------------------------
                This gets a little confusing.  The Digi cards have their own
                representation of c_cflags controling baud rate.  For the most
@@ -2357,10 +1974,8 @@ static unsigned termios2digi_c(struct channel *ch, unsigned cflag)
                should be checked for a screened out prior to termios2digi_c 
                returning.  Since CLOCAL isn't used by the board this can be
                ignored as long as the returned value is used only by Digi hardware. 
-       ----------------------------------------------------------------- */
-
-       if (cflag & CBAUDEX)
-       {
+               ----------------------------------------------------------------- */
+       if (cflag & CBAUDEX) {
                /* -------------------------------------------------------------
                        The below code is trying to guarantee that only baud rates
                        115200 and 230400 are remapped.  We use exclusive or because
@@ -2371,138 +1986,96 @@ static unsigned termios2digi_c(struct channel *ch, unsigned cflag)
                                
                if ((!((cflag & 0x7) ^ (B115200 & ~CBAUDEX))) || 
                    (!((cflag & 0x7) ^ (B230400 & ~CBAUDEX))))
-               {
                        res += 1;
-               }
        }
-
        return res;
 
 } /* End termios2digi_c */
 
 /* --------------------- Begin epcaparam  ----------------------- */
 
+/* Caller must hold the locks */
 static void epcaparam(struct tty_struct *tty, struct channel *ch)
 { /* Begin epcaparam */
 
        unsigned int cmdHead;
        struct termios *ts;
-       volatile struct board_chan *bc;
+       struct board_chan *bc;
        unsigned mval, hflow, cflag, iflag;
 
        bc = ch->brdchan;
        epcaassert(bc !=0, "bc out of range");
 
        assertgwinon(ch);
-
        ts = tty->termios;
-
-       if ((ts->c_cflag & CBAUD) == 0) 
-       { /* Begin CBAUD detected */
-
-               cmdHead = bc->rin;
+       if ((ts->c_cflag & CBAUD) == 0)  { /* Begin CBAUD detected */
+               cmdHead = readw(&bc->rin);
                bc->rout = cmdHead;
-               cmdHead = bc->tin;
-
+               cmdHead = readw(&bc->tin);
                /* Changing baud in mid-stream transmission can be wonderful */
                /* ---------------------------------------------------------------
                        Flush current transmit buffer by setting cmdTail pointer (tout)
                        to cmdHead pointer (tin).  Hopefully the transmit buffer is empty.
                ----------------------------------------------------------------- */
-
                fepcmd(ch, STOUT, (unsigned) cmdHead, 0, 0, 0);
                mval = 0;
-
-       } /* End CBAUD detected */
-       else 
-       { /* Begin CBAUD not detected */
-
+       } else  { /* Begin CBAUD not detected */
                /* -------------------------------------------------------------------
                        c_cflags have changed but that change had nothing to do with BAUD.
                        Propagate the change to the card.
                ---------------------------------------------------------------------- */ 
-
                cflag = termios2digi_c(ch, ts->c_cflag);
-
-               if (cflag != ch->fepcflag) 
-               {
+               if (cflag != ch->fepcflag)  {
                        ch->fepcflag = cflag;
                        /* Set baud rate, char size, stop bits, parity */
                        fepcmd(ch, SETCTRLFLAGS, (unsigned) cflag, 0, 0, 0);
                }
-
-
                /* ----------------------------------------------------------------
                        If the user has not forced CLOCAL and if the device is not a 
                        CALLOUT device (Which is always CLOCAL) we set flags such that
                        the driver will wait on carrier detect.
                ------------------------------------------------------------------- */
-
                if (ts->c_cflag & CLOCAL)
-               { /* Begin it is a cud device or a ttyD device with CLOCAL on */
                        ch->asyncflags &= ~ASYNC_CHECK_CD;
-               } /* End it is a cud device or a ttyD device with CLOCAL on */
                else
-               { /* Begin it is a ttyD device */
                        ch->asyncflags |= ASYNC_CHECK_CD;
-               } /* End it is a ttyD device */
-
                mval = ch->m_dtr | ch->m_rts;
-
        } /* End CBAUD not detected */
-
        iflag = termios2digi_i(ch, ts->c_iflag);
-
        /* Check input mode flags */
-
-       if (iflag != ch->fepiflag) 
-       {
+       if (iflag != ch->fepiflag)  {
                ch->fepiflag = iflag;
-
                /* ---------------------------------------------------------------
                        Command sets channels iflag structure on the board. Such things 
                        as input soft flow control, handling of parity errors, and
                        break handling are all set here.
                ------------------------------------------------------------------- */
-
                /* break handling, parity handling, input stripping, flow control chars */
                fepcmd(ch, SETIFLAGS, (unsigned int) ch->fepiflag, 0, 0, 0);
        }
-
        /* ---------------------------------------------------------------
                Set the board mint value for this channel.  This will cause hardware
                events to be generated each time the DCD signal (Described in mint) 
                changes.        
        ------------------------------------------------------------------- */
-       bc->mint = ch->dcd;
-
+       writeb(ch->dcd, &bc->mint);
        if ((ts->c_cflag & CLOCAL) || (ch->digiext.digi_flags & DIGI_FORCEDCD))
                if (ch->digiext.digi_flags & DIGI_FORCEDCD)
-                       bc->mint = 0;
-
-       ch->imodem = bc->mstat;
-
+                       writeb(0, &bc->mint);
+       ch->imodem = readb(&bc->mstat);
        hflow = termios2digi_h(ch, ts->c_cflag);
-
-       if (hflow != ch->hflow) 
-       {
+       if (hflow != ch->hflow)  {
                ch->hflow = hflow;
-
                /* --------------------------------------------------------------
                        Hard flow control has been selected but the board is not
                        using it.  Activate hard flow control now.
                ----------------------------------------------------------------- */
-
                fepcmd(ch, SETHFLOW, hflow, 0xff, 0, 1);
        }
-       
-
        mval ^= ch->modemfake & (mval ^ ch->modem);
 
-       if (ch->omodem ^ mval) 
-       {
+       if (ch->omodem ^ mval)  {
                ch->omodem = mval;
-
                /* --------------------------------------------------------------
                        The below command sets the DTR and RTS mstat structure.  If
                        hard flow control is NOT active these changes will drive the
@@ -2514,87 +2087,65 @@ static void epcaparam(struct tty_struct *tty, struct channel *ch)
                /* First reset DTR & RTS; then set them */
                fepcmd(ch, SETMODEM, 0, ((ch->m_dtr)|(ch->m_rts)), 0, 1);
                fepcmd(ch, SETMODEM, mval, 0, 0, 1);
-
        }
-
-       if (ch->startc != ch->fepstartc || ch->stopc != ch->fepstopc) 
-       {
+       if (ch->startc != ch->fepstartc || ch->stopc != ch->fepstopc)  {
                ch->fepstartc = ch->startc;
                ch->fepstopc = ch->stopc;
-
                /* ------------------------------------------------------------
                        The XON / XOFF characters have changed; propagate these
                        changes to the card.    
                --------------------------------------------------------------- */
-
                fepcmd(ch, SONOFFC, ch->fepstartc, ch->fepstopc, 0, 1);
        }
-
-       if (ch->startca != ch->fepstartca || ch->stopca != ch->fepstopca) 
-       {
+       if (ch->startca != ch->fepstartca || ch->stopca != ch->fepstopca)  {
                ch->fepstartca = ch->startca;
                ch->fepstopca = ch->stopca;
-
                /* ---------------------------------------------------------------
                        Similar to the above, this time the auxilarly XON / XOFF 
                        characters have changed; propagate these changes to the card.
                ------------------------------------------------------------------ */
-
                fepcmd(ch, SAUXONOFFC, ch->fepstartca, ch->fepstopca, 0, 1);
        }
-
 } /* End epcaparam */
 
 /* --------------------- Begin receive_data  ----------------------- */
-
+/* Caller holds lock */
 static void receive_data(struct channel *ch)
 { /* Begin receive_data */
 
        unchar *rptr;
        struct termios *ts = NULL;
        struct tty_struct *tty;
-       volatile struct board_chan *bc;
-       register int dataToRead, wrapgap, bytesAvailable;
-       register unsigned int tail, head;
+       struct board_chan *bc;
+       int dataToRead, wrapgap, bytesAvailable;
+       unsigned int tail, head;
        unsigned int wrapmask;
        int rc;
 
-
        /* ---------------------------------------------------------------
                This routine is called by doint when a receive data event 
                has taken place.
        ------------------------------------------------------------------- */
 
        globalwinon(ch);
-
        if (ch->statusflags & RXSTOPPED)
                return;
-
        tty = ch->tty;
        if (tty)
                ts = tty->termios;
-
        bc = ch->brdchan;
-
-       if (!bc) 
-       {
-               printk(KERN_ERR "<Error> - bc is NULL in receive_data!\n");
-               return;
-       }
-
+       BUG_ON(!bc);
        wrapmask = ch->rxbufsize - 1;
 
        /* --------------------------------------------------------------------- 
                Get the head and tail pointers to the receiver queue.  Wrap the 
                head pointer if it has reached the end of the buffer.
        ------------------------------------------------------------------------ */
-
-       head = bc->rin;
+       head = readw(&bc->rin);
        head &= wrapmask;
-       tail = bc->rout & wrapmask;
+       tail = readw(&bc->rout) & wrapmask;
 
        bytesAvailable = (head - tail) & wrapmask;
-
        if (bytesAvailable == 0)
                return;
 
@@ -2602,8 +2153,7 @@ static void receive_data(struct channel *ch)
           If CREAD bit is off or device not open, set TX tail to head
        --------------------------------------------------------------------- */
 
-       if (!tty || !ts || !(ts->c_cflag & CREAD)) 
-       {
+       if (!tty || !ts || !(ts->c_cflag & CREAD))  {
                bc->rout = head;
                return;
        }
@@ -2611,64 +2161,45 @@ static void receive_data(struct channel *ch)
        if (tty->flip.count == TTY_FLIPBUF_SIZE) 
                return;
 
-       if (bc->orun) 
-       {
-               bc->orun = 0;
-               printk(KERN_WARNING "overrun! DigiBoard device %s\n",tty->name);
+       if (readb(&bc->orun)) {
+               writeb(0, &bc->orun);
+               printk(KERN_WARNING "epca; overrun! DigiBoard device %s\n",tty->name);
        }
-
        rxwinon(ch);
        rptr = tty->flip.char_buf_ptr;
        rc = tty->flip.count;
-
-       while (bytesAvailable > 0) 
-       { /* Begin while there is data on the card */
-
+       while (bytesAvailable > 0)  { /* Begin while there is data on the card */
                wrapgap = (head >= tail) ? head - tail : ch->rxbufsize - tail;
-
                /* ---------------------------------------------------------------
                        Even if head has wrapped around only report the amount of
                        data to be equal to the size - tail.  Remember memcpy can't
                        automaticly wrap around the receive buffer.
                ----------------------------------------------------------------- */
-
                dataToRead = (wrapgap < bytesAvailable) ? wrapgap : bytesAvailable;
-
                /* --------------------------------------------------------------
                   Make sure we don't overflow the buffer
                ----------------------------------------------------------------- */
-
                if ((rc + dataToRead) > TTY_FLIPBUF_SIZE)
                        dataToRead = TTY_FLIPBUF_SIZE - rc;
-
                if (dataToRead == 0)
                        break;
-
                /* ---------------------------------------------------------------
                        Move data read from our card into the line disciplines buffer
                        for translation if necessary.
                ------------------------------------------------------------------ */
-
-               if ((memcpy(rptr, ch->rxptr + tail, dataToRead)) != rptr)
-                       printk(KERN_ERR "<Error> - receive_data : memcpy failed\n");
-                       
+               memcpy_fromio(rptr, ch->rxptr + tail, dataToRead);
                rc   += dataToRead;
                rptr += dataToRead;
                tail = (tail + dataToRead) & wrapmask;
                bytesAvailable -= dataToRead;
-
        } /* End while there is data on the card */
-
-
        tty->flip.count = rc;
        tty->flip.char_buf_ptr = rptr;
        globalwinon(ch);
-       bc->rout = tail;
-
+       writew(tail, &bc->rout);
        /* Must be called with global data */
        tty_schedule_flip(ch->tty); 
        return;
-
 } /* End receive_data */
 
 static int info_ioctl(struct tty_struct *tty, struct file * file,
@@ -2676,17 +2207,15 @@ static int info_ioctl(struct tty_struct *tty, struct file * file,
 {
        switch (cmd) 
        { /* Begin switch cmd */
-
                case DIGI_GETINFO:
                { /* Begin case DIGI_GETINFO */
-
                        struct digi_info di ;
                        int brd;
 
-                       getUser(brd, (unsigned int __user *)arg);
-
-                       if ((brd < 0) || (brd >= num_cards) || (num_cards == 0))
-                               return (-ENODEV);
+                       if(get_user(brd, (unsigned int __user *)arg))
+                               return -EFAULT;
+                       if (brd < 0 || brd >= num_cards || num_cards == 0)
+                               return -ENODEV;
 
                        memset(&di, 0, sizeof(di));
 
@@ -2694,8 +2223,9 @@ static int info_ioctl(struct tty_struct *tty, struct file * file,
                        di.status = boards[brd].status;
                        di.type = boards[brd].type ;
                        di.numports = boards[brd].numports ;
-                       di.port = boards[brd].port ;
-                       di.membase = boards[brd].membase ;
+                       /* Legacy fixups - just move along nothing to see */
+                       di.port = (unsigned char *)boards[brd].port ;
+                       di.membase = (unsigned char *)boards[brd].membase ;
 
                        if (copy_to_user((void __user *)arg, &di, sizeof (di)))
                                return -EFAULT;
@@ -2709,39 +2239,29 @@ static int info_ioctl(struct tty_struct *tty, struct file * file,
                        int brd = arg & 0xff000000 >> 16 ; 
                        unsigned char state = arg & 0xff ; 
 
-                       if ((brd < 0) || (brd >= num_cards))
-                       {
-                               printk(KERN_ERR "<Error> - DIGI POLLER : brd not valid!\n");
+                       if (brd < 0 || brd >= num_cards) {
+                               printk(KERN_ERR "epca: DIGI POLLER : brd not valid!\n");
                                return (-ENODEV);
                        }
-
                        digi_poller_inhibited = state ;
                        break ; 
-
                } /* End case DIGI_POLLER */
 
                case DIGI_INIT:
                { /* Begin case DIGI_INIT */
-
                        /* ------------------------------------------------------------
                                This call is made by the apps to complete the initilization
                                of the board(s).  This routine is responsible for setting
                                the card to its initial state and setting the drivers control
                                fields to the sutianle settings for the card in question.
                        ---------------------------------------------------------------- */
-               
                        int crd ; 
                        for (crd = 0; crd < num_cards; crd++) 
                                post_fep_init (crd);
-
                        break ; 
-
                } /* End case DIGI_INIT */
-
-
                default:
-                       return -ENOIOCTLCMD;
-
+                       return -ENOTTY;
        } /* End switch cmd */
        return (0) ;
 }
@@ -2750,43 +2270,33 @@ static int info_ioctl(struct tty_struct *tty, struct file * file,
 static int pc_tiocmget(struct tty_struct *tty, struct file *file)
 {
        struct channel *ch = (struct channel *) tty->driver_data;
-       volatile struct board_chan *bc;
+       struct board_chan *bc;
        unsigned int mstat, mflag = 0;
        unsigned long flags;
 
        if (ch)
                bc = ch->brdchan;
        else
-       {
-               printk(KERN_ERR "<Error> - ch is NULL in pc_tiocmget!\n");
-               return(-EINVAL);
-       }
+               return -EINVAL;
 
-       save_flags(flags);
-       cli();
+       spin_lock_irqsave(&epca_lock, flags);
        globalwinon(ch);
-       mstat = bc->mstat;
+       mstat = readb(&bc->mstat);
        memoff(ch);
-       restore_flags(flags);
+       spin_unlock_irqrestore(&epca_lock, flags);
 
        if (mstat & ch->m_dtr)
                mflag |= TIOCM_DTR;
-
        if (mstat & ch->m_rts)
                mflag |= TIOCM_RTS;
-
        if (mstat & ch->m_cts)
                mflag |= TIOCM_CTS;
-
        if (mstat & ch->dsr)
                mflag |= TIOCM_DSR;
-
        if (mstat & ch->m_ri)
                mflag |= TIOCM_RI;
-
        if (mstat & ch->dcd)
                mflag |= TIOCM_CD;
-
        return mflag;
 }
 
@@ -2796,13 +2306,10 @@ static int pc_tiocmset(struct tty_struct *tty, struct file *file,
        struct channel *ch = (struct channel *) tty->driver_data;
        unsigned long flags;
 
-       if (!ch) {
-               printk(KERN_ERR "<Error> - ch is NULL in pc_tiocmset!\n");
-               return(-EINVAL);
-       }
+       if (!ch)
+               return -EINVAL;
 
-       save_flags(flags);
-       cli();
+       spin_lock_irqsave(&epca_lock, flags);
        /*
         * I think this modemfake stuff is broken.  It doesn't
         * correctly reflect the behaviour desired by the TIOCM*
@@ -2824,17 +2331,14 @@ static int pc_tiocmset(struct tty_struct *tty, struct file *file,
                ch->modemfake |= ch->m_dtr;
                ch->modem &= ~ch->m_dtr;
        }
-
        globalwinon(ch);
-
        /*  --------------------------------------------------------------
                The below routine generally sets up parity, baud, flow control
                issues, etc.... It effect both control flags and input flags.
        ------------------------------------------------------------------ */
-
        epcaparam(tty,ch);
        memoff(ch);
-       restore_flags(flags);
+       spin_unlock_irqrestore(&epca_lock, flags);
        return 0;
 }
 
@@ -2847,19 +2351,14 @@ static int pc_ioctl(struct tty_struct *tty, struct file * file,
        unsigned long flags;
        unsigned int mflag, mstat;
        unsigned char startc, stopc;
-       volatile struct board_chan *bc;
+       struct board_chan *bc;
        struct channel *ch = (struct channel *) tty->driver_data;
        void __user *argp = (void __user *)arg;
        
        if (ch)
                bc = ch->brdchan;
        else 
-       {
-               printk(KERN_ERR "<Error> - ch is NULL in pc_ioctl!\n");
-               return(-EINVAL);
-       }
-
-       save_flags(flags);
+               return -EINVAL;
 
        /* -------------------------------------------------------------------
                For POSIX compliance we need to add more ioctls.  See tty_ioctl.c
@@ -2871,46 +2370,39 @@ static int pc_ioctl(struct tty_struct *tty, struct file * file,
        { /* Begin switch cmd */
 
                case TCGETS:
-                       if (copy_to_user(argp, 
-                                        tty->termios, sizeof(struct termios)))
+                       if (copy_to_user(argp, tty->termios, sizeof(struct termios)))
                                return -EFAULT;
-                       return(0);
-
+                       return 0;
                case TCGETA:
                        return get_termio(tty, argp);
-
                case TCSBRK:    /* SVID version: non-zero arg --> no break */
-
                        retval = tty_check_change(tty);
                        if (retval)
                                return retval;
-
                        /* Setup an event to indicate when the transmit buffer empties */
-
+                       spin_lock_irqsave(&epca_lock, flags);
                        setup_empty_event(tty,ch);              
+                       spin_unlock_irqrestore(&epca_lock, flags);
                        tty_wait_until_sent(tty, 0);
                        if (!arg)
                                digi_send_break(ch, HZ/4);    /* 1/4 second */
                        return 0;
-
                case TCSBRKP:   /* support for POSIX tcsendbreak() */
-
                        retval = tty_check_change(tty);
                        if (retval)
                                return retval;
 
                        /* Setup an event to indicate when the transmit buffer empties */
-
+                       spin_lock_irqsave(&epca_lock, flags);
                        setup_empty_event(tty,ch);              
+                       spin_unlock_irqrestore(&epca_lock, flags);
                        tty_wait_until_sent(tty, 0);
                        digi_send_break(ch, arg ? arg*(HZ/10) : HZ/4);
                        return 0;
-
                case TIOCGSOFTCAR:
                        if (put_user(C_CLOCAL(tty)?1:0, (unsigned long __user *)arg))
                                return -EFAULT;
                        return 0;
-
                case TIOCSSOFTCAR:
                {
                        unsigned int value;
@@ -2922,75 +2414,63 @@ static int pc_ioctl(struct tty_struct *tty, struct file * file,
                                 (value ? CLOCAL : 0));
                        return 0;
                }
-
                case TIOCMODG:
                        mflag = pc_tiocmget(tty, file);
                        if (put_user(mflag, (unsigned long __user *)argp))
                                return -EFAULT;
                        break;
-
                case TIOCMODS:
                        if (get_user(mstat, (unsigned __user *)argp))
                                return -EFAULT;
                        return pc_tiocmset(tty, file, mstat, ~mstat);
-
                case TIOCSDTR:
+                       spin_lock_irqsave(&epca_lock, flags);
                        ch->omodem |= ch->m_dtr;
-                       cli();
                        globalwinon(ch);
                        fepcmd(ch, SETMODEM, ch->m_dtr, 0, 10, 1);
                        memoff(ch);
-                       restore_flags(flags);
+                       spin_unlock_irqrestore(&epca_lock, flags);
                        break;
 
                case TIOCCDTR:
+                       spin_lock_irqsave(&epca_lock, flags);
                        ch->omodem &= ~ch->m_dtr;
-                       cli();
                        globalwinon(ch);
                        fepcmd(ch, SETMODEM, 0, ch->m_dtr, 10, 1);
                        memoff(ch);
-                       restore_flags(flags);
+                       spin_unlock_irqrestore(&epca_lock, flags);
                        break;
-
                case DIGI_GETA:
                        if (copy_to_user(argp, &ch->digiext, sizeof(digi_t)))
                                return -EFAULT;
                        break;
-
                case DIGI_SETAW:
                case DIGI_SETAF:
-                       if ((cmd) == (DIGI_SETAW)) 
-                       {
+                       if (cmd == DIGI_SETAW) {
                                /* Setup an event to indicate when the transmit buffer empties */
-
+                               spin_lock_irqsave(&epca_lock, flags);
                                setup_empty_event(tty,ch);              
+                               spin_unlock_irqrestore(&epca_lock, flags);
                                tty_wait_until_sent(tty, 0);
-                       }
-                       else 
-                       {
+                       } else  {
                                /* ldisc lock already held in ioctl */
                                if (tty->ldisc.flush_buffer)
                                        tty->ldisc.flush_buffer(tty);
                        }
-
                        /* Fall Thru */
-
                case DIGI_SETA:
                        if (copy_from_user(&ch->digiext, argp, sizeof(digi_t)))
                                return -EFAULT;
                        
-                       if (ch->digiext.digi_flags & DIGI_ALTPIN) 
-                       {
+                       if (ch->digiext.digi_flags & DIGI_ALTPIN)  {
                                ch->dcd = ch->m_dsr;
                                ch->dsr = ch->m_dcd;
-                       } 
-                       else 
-                       {
+                       } else {
                                ch->dcd = ch->m_dcd;
                                ch->dsr = ch->m_dsr;
                        }
                
-                       cli();
+                       spin_lock_irqsave(&epca_lock, flags);
                        globalwinon(ch);
 
                        /* -----------------------------------------------------------------
@@ -3000,25 +2480,22 @@ static int pc_ioctl(struct tty_struct *tty, struct file * file,
 
                        epcaparam(tty,ch);
                        memoff(ch);
-                       restore_flags(flags);
+                       spin_unlock_irqrestore(&epca_lock, flags);
                        break;
 
                case DIGI_GETFLOW:
                case DIGI_GETAFLOW:
-                       cli();  
+                       spin_lock_irqsave(&epca_lock, flags);
                        globalwinon(ch);
-                       if ((cmd) == (DIGI_GETFLOW)) 
-                       {
-                               dflow.startc = bc->startc;
-                               dflow.stopc = bc->stopc;
-                       }
-                       else 
-                       {
-                               dflow.startc = bc->startca;
-                               dflow.stopc = bc->stopca;
+                       if (cmd == DIGI_GETFLOW) {
+                               dflow.startc = readb(&bc->startc);
+                               dflow.stopc = readb(&bc->stopc);
+                       } else {
+                               dflow.startc = readb(&bc->startca);
+                               dflow.stopc = readb(&bc->stopca);
                        }
                        memoff(ch);
-                       restore_flags(flags);
+                       spin_unlock_irqrestore(&epca_lock, flags);
 
                        if (copy_to_user(argp, &dflow, sizeof(dflow)))
                                return -EFAULT;
@@ -3026,13 +2503,10 @@ static int pc_ioctl(struct tty_struct *tty, struct file * file,
 
                case DIGI_SETAFLOW:
                case DIGI_SETFLOW:
-                       if ((cmd) == (DIGI_SETFLOW)) 
-                       {
+                       if (cmd == DIGI_SETFLOW) {
                                startc = ch->startc;
                                stopc = ch->stopc;
-                       } 
-                       else 
-                       {
+                       } else {
                                startc = ch->startca;
                                stopc = ch->stopca;
                        }
@@ -3040,40 +2514,31 @@ static int pc_ioctl(struct tty_struct *tty, struct file * file,
                        if (copy_from_user(&dflow, argp, sizeof(dflow)))
                                return -EFAULT;
 
-                       if (dflow.startc != startc || dflow.stopc != stopc) 
-                       { /* Begin  if setflow toggled */
-                               cli();
+                       if (dflow.startc != startc || dflow.stopc != stopc) { /* Begin  if setflow toggled */
+                               spin_lock_irqsave(&epca_lock, flags);
                                globalwinon(ch);
 
-                               if ((cmd) == (DIGI_SETFLOW)) 
-                               {
+                               if (cmd == DIGI_SETFLOW) {
                                        ch->fepstartc = ch->startc = dflow.startc;
                                        ch->fepstopc = ch->stopc = dflow.stopc;
                                        fepcmd(ch, SONOFFC, ch->fepstartc, ch->fepstopc, 0, 1);
-                               } 
-                               else 
-                               {
+                               } else {
                                        ch->fepstartca = ch->startca = dflow.startc;
                                        ch->fepstopca  = ch->stopca = dflow.stopc;
                                        fepcmd(ch, SAUXONOFFC, ch->fepstartca, ch->fepstopca, 0, 1);
                                }
 
-                               if      (ch->statusflags & TXSTOPPED)
+                               if (ch->statusflags & TXSTOPPED)
                                        pc_start(tty);
 
                                memoff(ch);
-                               restore_flags(flags);
-
+                               spin_unlock_irqrestore(&epca_lock, flags);
                        } /* End if setflow toggled */
                        break;
-
                default:
                        return -ENOIOCTLCMD;
-
        } /* End switch cmd */
-
        return 0;
-
 } /* End pc_ioctl */
 
 /* --------------------- Begin pc_set_termios  ----------------------- */
@@ -3083,20 +2548,16 @@ static void pc_set_termios(struct tty_struct *tty, struct termios *old_termios)
 
        struct channel *ch;
        unsigned long flags;
-
        /* ---------------------------------------------------------
                verifyChannel returns the channel from the tty struct
                if it is valid.  This serves as a sanity check.
        ------------------------------------------------------------- */
-
-       if ((ch = verifyChannel(tty)) != NULL) 
-       { /* Begin if channel valid */
-
-               save_flags(flags);
-               cli();
+       if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if channel valid */
+               spin_lock_irqsave(&epca_lock, flags);
                globalwinon(ch);
                epcaparam(tty, ch);
                memoff(ch);
+               spin_unlock_irqrestore(&epca_lock, flags);
 
                if ((old_termios->c_cflag & CRTSCTS) &&
                         ((tty->termios->c_cflag & CRTSCTS) == 0))
@@ -3106,8 +2567,6 @@ static void pc_set_termios(struct tty_struct *tty, struct termios *old_termios)
                         (tty->termios->c_cflag & CLOCAL))
                        wake_up_interruptible(&ch->open_wait);
 
-               restore_flags(flags);
-
        } /* End if channel valid */
 
 } /* End pc_set_termios */
@@ -3116,29 +2575,18 @@ static void pc_set_termios(struct tty_struct *tty, struct termios *old_termios)
 
 static void do_softint(void *private_)
 { /* Begin do_softint */
-
        struct channel *ch = (struct channel *) private_;
-       
-
        /* Called in response to a modem change event */
-
-       if (ch && ch->magic == EPCA_MAGIC) 
-       { /* Begin EPCA_MAGIC */
-
+       if (ch && ch->magic == EPCA_MAGIC)  { /* Begin EPCA_MAGIC */
                struct tty_struct *tty = ch->tty;
 
-               if (tty && tty->driver_data) 
-               { 
-                       if (test_and_clear_bit(EPCA_EVENT_HANGUP, &ch->event)) 
-                       { /* Begin if clear_bit */
-
+               if (tty && tty->driver_data) {
+                       if (test_and_clear_bit(EPCA_EVENT_HANGUP, &ch->event)) { /* Begin if clear_bit */
                                tty_hangup(tty);        /* FIXME: module removal race here - AKPM */
                                wake_up_interruptible(&ch->open_wait);
                                ch->asyncflags &= ~ASYNC_NORMAL_ACTIVE;
-
                        } /* End if clear_bit */
                }
-
        } /* End EPCA_MAGIC */
 } /* End do_softint */
 
@@ -3154,82 +2602,49 @@ static void pc_stop(struct tty_struct *tty)
 
        struct channel *ch;
        unsigned long flags;
-
        /* ---------------------------------------------------------
                verifyChannel returns the channel from the tty struct
                if it is valid.  This serves as a sanity check.
        ------------------------------------------------------------- */
-
-       if ((ch = verifyChannel(tty)) != NULL) 
-       { /* Begin if valid channel */
-
-               save_flags(flags); 
-               cli();
-
-               if ((ch->statusflags & TXSTOPPED) == 0) 
-               { /* Begin if transmit stop requested */
-
+       if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if valid channel */
+               spin_lock_irqsave(&epca_lock, flags);
+               if ((ch->statusflags & TXSTOPPED) == 0)  { /* Begin if transmit stop requested */
                        globalwinon(ch);
-
                        /* STOP transmitting now !! */
-
                        fepcmd(ch, PAUSETX, 0, 0, 0, 0);
-
                        ch->statusflags |= TXSTOPPED;
                        memoff(ch);
-
                } /* End if transmit stop requested */
-
-               restore_flags(flags);
-
+               spin_unlock_irqrestore(&epca_lock, flags);
        } /* End if valid channel */
-
 } /* End pc_stop */
 
 /* --------------------- Begin pc_start  ----------------------- */
 
 static void pc_start(struct tty_struct *tty)
 { /* Begin pc_start */
-
        struct channel *ch;
-
        /* ---------------------------------------------------------
                verifyChannel returns the channel from the tty struct
                if it is valid.  This serves as a sanity check.
        ------------------------------------------------------------- */
-
-       if ((ch = verifyChannel(tty)) != NULL) 
-       { /* Begin if channel valid */
-
+       if ((ch = verifyChannel(tty)) != NULL) { /* Begin if channel valid */
                unsigned long flags;
-
-               save_flags(flags);
-               cli();
-
+               spin_lock_irqsave(&epca_lock, flags);
                /* Just in case output was resumed because of a change in Digi-flow */
-               if (ch->statusflags & TXSTOPPED) 
-               { /* Begin transmit resume requested */
-
-                       volatile struct board_chan *bc;
-
+               if (ch->statusflags & TXSTOPPED)  { /* Begin transmit resume requested */
+                       struct board_chan *bc;
                        globalwinon(ch);
                        bc = ch->brdchan;
                        if (ch->statusflags & LOWWAIT)
-                               bc->ilow = 1;
-
+                               writeb(1, &bc->ilow);
                        /* Okay, you can start transmitting again... */
-
                        fepcmd(ch, RESUMETX, 0, 0, 0, 0);
-
                        ch->statusflags &= ~TXSTOPPED;
                        memoff(ch);
-
                } /* End transmit resume requested */
-
-               restore_flags(flags);
-
+               spin_unlock_irqrestore(&epca_lock, flags);
        } /* End if channel valid */
-
 } /* End pc_start */
 
 /* ------------------------------------------------------------------
@@ -3244,86 +2659,55 @@ ______________________________________________________________________ */
 
 static void pc_throttle(struct tty_struct * tty)
 { /* Begin pc_throttle */
-
        struct channel *ch;
        unsigned long flags;
-
        /* ---------------------------------------------------------
                verifyChannel returns the channel from the tty struct
                if it is valid.  This serves as a sanity check.
        ------------------------------------------------------------- */
-
-       if ((ch = verifyChannel(tty)) != NULL) 
-       { /* Begin if channel valid */
-
-
-               save_flags(flags);
-               cli();
-
-               if ((ch->statusflags & RXSTOPPED) == 0)
-               {
+       if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if channel valid */
+               spin_lock_irqsave(&epca_lock, flags);
+               if ((ch->statusflags & RXSTOPPED) == 0) {
                        globalwinon(ch);
                        fepcmd(ch, PAUSERX, 0, 0, 0, 0);
-
                        ch->statusflags |= RXSTOPPED;
                        memoff(ch);
                }
-               restore_flags(flags);
-
+               spin_unlock_irqrestore(&epca_lock, flags);
        } /* End if channel valid */
-
 } /* End pc_throttle */
 
 /* --------------------- Begin unthrottle  ----------------------- */
 
 static void pc_unthrottle(struct tty_struct *tty)
 { /* Begin pc_unthrottle */
-
        struct channel *ch;
        unsigned long flags;
-       volatile struct board_chan *bc;
-
-
        /* ---------------------------------------------------------
                verifyChannel returns the channel from the tty struct
                if it is valid.  This serves as a sanity check.
        ------------------------------------------------------------- */
-
-       if ((ch = verifyChannel(tty)) != NULL) 
-       { /* Begin if channel valid */
-
-
+       if ((ch = verifyChannel(tty)) != NULL)  { /* Begin if channel valid */
                /* Just in case output was resumed because of a change in Digi-flow */
-               save_flags(flags);
-               cli();
-
-               if (ch->statusflags & RXSTOPPED) 
-               {
-
+               spin_lock_irqsave(&epca_lock, flags);
+               if (ch->statusflags & RXSTOPPED) {
                        globalwinon(ch);
-                       bc = ch->brdchan;
                        fepcmd(ch, RESUMERX, 0, 0, 0, 0);
-
                        ch->statusflags &= ~RXSTOPPED;
                        memoff(ch);
                }
-               restore_flags(flags);
-
+               spin_unlock_irqrestore(&epca_lock, flags);
        } /* End if channel valid */
-
 } /* End pc_unthrottle */
 
 /* --------------------- Begin digi_send_break  ----------------------- */
 
 void digi_send_break(struct channel *ch, int msec)
 { /* Begin digi_send_break */
-
        unsigned long flags;
 
-       save_flags(flags);
-       cli();
+       spin_lock_irqsave(&epca_lock, flags);
        globalwinon(ch);
-
        /* -------------------------------------------------------------------- 
           Maybe I should send an infinite break here, schedule() for
           msec amount of time, and then stop the break.  This way,
@@ -3331,36 +2715,28 @@ void digi_send_break(struct channel *ch, int msec)
           to be called (i.e. via an ioctl()) more than once in msec amount 
           of time.  Try this for now...
        ------------------------------------------------------------------------ */
-
        fepcmd(ch, SENDBREAK, msec, 0, 10, 0);
        memoff(ch);
-
-       restore_flags(flags);
-
+       spin_unlock_irqrestore(&epca_lock, flags);
 } /* End digi_send_break */
 
 /* --------------------- Begin setup_empty_event  ----------------------- */
 
+/* Caller MUST hold the lock */
+
 static void setup_empty_event(struct tty_struct *tty, struct channel *ch)
 { /* Begin setup_empty_event */
 
-       volatile struct board_chan *bc = ch->brdchan;
-       unsigned long int flags;
+       struct board_chan *bc = ch->brdchan;
 
-       save_flags(flags);
-       cli();
        globalwinon(ch);
        ch->statusflags |= EMPTYWAIT;
-       
        /* ------------------------------------------------------------------
                When set the iempty flag request a event to be generated when the 
                transmit buffer is empty (If there is no BREAK in progress).
        --------------------------------------------------------------------- */
-
-       bc->iempty = 1;
+       writeb(1, &bc->iempty);
        memoff(ch);
-       restore_flags(flags);
-
 } /* End setup_empty_event */
 
 /* --------------------- Begin get_termio ----------------------- */
@@ -3369,10 +2745,10 @@ static int get_termio(struct tty_struct * tty, struct termio __user * termio)
 { /* Begin get_termio */
        return kernel_termios_to_user_termio(termio, tty->termios);
 } /* End get_termio */
+
 /* ---------------------- Begin epca_setup  -------------------------- */
 void epca_setup(char *str, int *ints)
 { /* Begin epca_setup */
-
        struct board_info board;
        int               index, loop, last;
        char              *temp, *t2;
@@ -3394,49 +2770,41 @@ void epca_setup(char *str, int *ints)
        for (last = 0, index = 1; index <= ints[0]; index++)
                switch(index)
                { /* Begin parse switch */
-
                        case 1:
                                board.status = ints[index];
-                               
                                /* ---------------------------------------------------------
                                        We check for 2 (As opposed to 1; because 2 is a flag
                                        instructing the driver to ignore epcaconfig.)  For this
                                        reason we check for 2.
                                ------------------------------------------------------------ */ 
-                               if (board.status == 2)
-                               { /* Begin ignore epcaconfig as well as lilo cmd line */
+                               if (board.status == 2) { /* Begin ignore epcaconfig as well as lilo cmd line */
                                        nbdevs = 0;
                                        num_cards = 0;
                                        return;
                                } /* End ignore epcaconfig as well as lilo cmd line */
        
-                               if (board.status > 2)
-                               {
-                                       printk(KERN_ERR "<Error> - epca_setup: Invalid board status 0x%x\n", board.status);
+                               if (board.status > 2) {
+                                       printk(KERN_ERR "epca_setup: Invalid board status 0x%x\n", board.status);
                                        invalid_lilo_config = 1;
                                        setup_error_code |= INVALID_BOARD_STATUS;
                                        return;
                                }
                                last = index;
                                break;
-
                        case 2:
                                board.type = ints[index];
-                               if (board.type >= PCIXEM) 
-                               {
-                                       printk(KERN_ERR "<Error> - epca_setup: Invalid board type 0x%x\n", board.type);
+                               if (board.type >= PCIXEM)  {
+                                       printk(KERN_ERR "epca_setup: Invalid board type 0x%x\n", board.type);
                                        invalid_lilo_config = 1;
                                        setup_error_code |= INVALID_BOARD_TYPE;
                                        return;
                                }
                                last = index;
                                break;
-
                        case 3:
                                board.altpin = ints[index];
-                               if (board.altpin > 1)
-                               {
-                                       printk(KERN_ERR "<Error> - epca_setup: Invalid board altpin 0x%x\n", board.altpin);
+                               if (board.altpin > 1) {
+                                       printk(KERN_ERR "epca_setup: Invalid board altpin 0x%x\n", board.altpin);
                                        invalid_lilo_config = 1;
                                        setup_error_code |= INVALID_ALTPIN;
                                        return;
@@ -3446,9 +2814,8 @@ void epca_setup(char *str, int *ints)
 
                        case 4:
                                board.numports = ints[index];
-                               if ((board.numports < 2) || (board.numports > 256))
-                               {
-                                       printk(KERN_ERR "<Error> - epca_setup: Invalid board numports 0x%x\n", board.numports);
+                               if (board.numports < 2 || board.numports > 256) {
+                                       printk(KERN_ERR "epca_setup: Invalid board numports 0x%x\n", board.numports);
                                        invalid_lilo_config = 1;
                                        setup_error_code |= INVALID_NUM_PORTS;
                                        return;
@@ -3458,10 +2825,9 @@ void epca_setup(char *str, int *ints)
                                break;
 
                        case 5:
-                               board.port = (unsigned char *)ints[index];
-                               if (ints[index] <= 0)
-                               {
-                                       printk(KERN_ERR "<Error> - epca_setup: Invalid io port 0x%x\n", (unsigned int)board.port);
+                               board.port = ints[index];
+                               if (ints[index] <= 0) {
+                                       printk(KERN_ERR "epca_setup: Invalid io port 0x%x\n", (unsigned int)board.port);
                                        invalid_lilo_config = 1;
                                        setup_error_code |= INVALID_PORT_BASE;
                                        return;
@@ -3470,10 +2836,9 @@ void epca_setup(char *str, int *ints)
                                break;
 
                        case 6:
-                               board.membase = (unsigned char *)ints[index];
-                               if (ints[index] <= 0)
-                               {
-                                       printk(KERN_ERR "<Error> - epca_setup: Invalid memory base 0x%x\n",(unsigned int)board.membase);
+                               board.membase = ints[index];
+                               if (ints[index] <= 0) {
+                                       printk(KERN_ERR "epca_setup: Invalid memory base 0x%x\n",(unsigned int)board.membase);
                                        invalid_lilo_config = 1;
                                        setup_error_code |= INVALID_MEM_BASE;
                                        return;
@@ -3487,21 +2852,16 @@ void epca_setup(char *str, int *ints)
 
                } /* End parse switch */
 
-       while (str && *str) 
-       { /* Begin while there is a string arg */
-
+       while (str && *str)  { /* Begin while there is a string arg */
                /* find the next comma or terminator */
                temp = str;
-
                /* While string is not null, and a comma hasn't been found */
                while (*temp && (*temp != ','))
                        temp++;
-
                if (!*temp)
                        temp = NULL;
                else
                        *temp++ = 0;
-
                /* Set index to the number of args + 1 */
                index = last + 1;
 
@@ -3511,12 +2871,10 @@ void epca_setup(char *str, int *ints)
                                len = strlen(str);
                                if (strncmp("Disable", str, len) == 0) 
                                        board.status = 0;
-                               else
-                               if (strncmp("Enable", str, len) == 0)
+                               else if (strncmp("Enable", str, len) == 0)
                                        board.status = 1;
-                               else
-                               {
-                                       printk(KERN_ERR "<Error> - epca_setup: Invalid status %s\n", str);
+                               else {
+                                       printk(KERN_ERR "epca_setup: Invalid status %s\n", str);
                                        invalid_lilo_config = 1;
                                        setup_error_code |= INVALID_BOARD_STATUS;
                                        return;
@@ -3525,22 +2883,17 @@ void epca_setup(char *str, int *ints)
                                break;
 
                        case 2:
-
                                for(loop = 0; loop < EPCA_NUM_TYPES; loop++)
                                        if (strcmp(board_desc[loop], str) == 0)
                                                break;
-
-
                                /* ---------------------------------------------------------------
                                        If the index incremented above refers to a legitamate board 
                                        type set it here. 
                                ------------------------------------------------------------------*/
-
                                if (index < EPCA_NUM_TYPES) 
                                        board.type = loop;
-                               else
-                               {
-                                       printk(KERN_ERR "<Error> - epca_setup: Invalid board type: %s\n", str);
+                               else {
+                                       printk(KERN_ERR "epca_setup: Invalid board type: %s\n", str);
                                        invalid_lilo_config = 1;
                                        setup_error_code |= INVALID_BOARD_TYPE;
                                        return;
@@ -3552,12 +2905,10 @@ void epca_setup(char *str, int *ints)
                                len = strlen(str);
                                if (strncmp("Disable", str, len) == 0) 
                                        board.altpin = 0;
-                               else
-                               if (strncmp("Enable", str, len) == 0)
+                               else if (strncmp("Enable", str, len) == 0)
                                        board.altpin = 1;
-                               else
-                               {
-                                       printk(KERN_ERR "<Error> - epca_setup: Invalid altpin %s\n", str);
+                               else {
+                                       printk(KERN_ERR "epca_setup: Invalid altpin %s\n", str);
                                        invalid_lilo_config = 1;
                                        setup_error_code |= INVALID_ALTPIN;
                                        return;
@@ -3570,9 +2921,8 @@ void epca_setup(char *str, int *ints)
                                while (isdigit(*t2))
                                        t2++;
 
-                               if (*t2)
-                               {
-                                       printk(KERN_ERR "<Error> - epca_setup: Invalid port count %s\n", str);
+                               if (*t2) {
+                                       printk(KERN_ERR "epca_setup: Invalid port count %s\n", str);
                                        invalid_lilo_config = 1;
                                        setup_error_code |= INVALID_NUM_PORTS;
                                        return;
@@ -3601,15 +2951,14 @@ void epca_setup(char *str, int *ints)
                                while (isxdigit(*t2))
                                        t2++;
 
-                               if (*t2)
-                               {
-                                       printk(KERN_ERR "<Error> - epca_setup: Invalid i/o address %s\n", str);
+                               if (*t2) {
+                                       printk(KERN_ERR "epca_setup: Invalid i/o address %s\n", str);
                                        invalid_lilo_config = 1;
                                        setup_error_code |= INVALID_PORT_BASE;
                                        return;
                                }
 
-                               board.port = (unsigned char *)simple_strtoul(str, NULL, 16);
+                               board.port = simple_strtoul(str, NULL, 16);
                                last = index;
                                break;
 
@@ -3618,52 +2967,38 @@ void epca_setup(char *str, int *ints)
                                while (isxdigit(*t2))
                                        t2++;
 
-                               if (*t2)
-                               {
-                                       printk(KERN_ERR "<Error> - epca_setup: Invalid memory base %s\n",str);
+                               if (*t2) {
+                                       printk(KERN_ERR "epca_setup: Invalid memory base %s\n",str);
                                        invalid_lilo_config = 1;
                                        setup_error_code |= INVALID_MEM_BASE;
                                        return;
                                }
-
-                               board.membase = (unsigned char *)simple_strtoul(str, NULL, 16);
+                               board.membase = simple_strtoul(str, NULL, 16);
                                last = index;
                                break;
-
                        default:
-                               printk(KERN_ERR "PC/Xx: Too many string parms\n");
+                               printk(KERN_ERR "epca: Too many string parms\n");
                                return;
                }
                str = temp;
-
        } /* End while there is a string arg */
 
-
-       if (last < 6)  
-       {
-               printk(KERN_ERR "PC/Xx: Insufficient parms specified\n");
+       if (last < 6) {
+               printk(KERN_ERR "epca: Insufficient parms specified\n");
                return;
        }
  
        /* I should REALLY validate the stuff here */
-
        /* Copies our local copy of board into boards */
        memcpy((void *)&boards[num_cards],(void *)&board, sizeof(board));
-
-
        /* Does this get called once per lilo arg are what ? */
-
        printk(KERN_INFO "PC/Xx: Added board %i, %s %i ports at 0x%4.4X base 0x%6.6X\n", 
                num_cards, board_desc[board.type], 
                board.numports, (int)board.port, (unsigned int) board.membase);
-
        num_cards++;
-
 } /* End epca_setup */
 
 
-
-#ifdef ENABLE_PCI
 /* ------------------------ Begin init_PCI  --------------------------- */
 
 enum epic_board_types {
@@ -3685,7 +3020,6 @@ static struct {
        { PCIXRJ, 2, },
 };
 
-
 static int __devinit epca_init_one (struct pci_dev *pdev,
                                 const struct pci_device_id *ent)
 {
@@ -3711,10 +3045,8 @@ static int __devinit epca_init_one (struct pci_dev *pdev,
        boards[board_idx].status = ENABLED;
        boards[board_idx].type = epca_info_tbl[info_idx].board_type;
        boards[board_idx].numports = 0x0;
-       boards[board_idx].port =
-               (unsigned char *)((char *) addr + PCI_IO_OFFSET);
-       boards[board_idx].membase =
-               (unsigned char *)((char *) addr);
+       boards[board_idx].port = addr + PCI_IO_OFFSET;
+       boards[board_idx].membase = addr;
 
        if (!request_mem_region (addr + PCI_IO_OFFSET, 0x200000, "epca")) {
                printk (KERN_ERR PFX "resource 0x%x @ 0x%lx unavailable\n",
@@ -3775,15 +3107,13 @@ static struct pci_device_id epca_pci_tbl[] = {
 MODULE_DEVICE_TABLE(pci, epca_pci_tbl);
 
 int __init init_PCI (void)
-{ /* Begin init_PCI */
+{      /* Begin init_PCI */
        memset (&epca_driver, 0, sizeof (epca_driver));
        epca_driver.name = "epca";
        epca_driver.id_table = epca_pci_tbl;
        epca_driver.probe = epca_init_one;
 
        return pci_register_driver(&epca_driver);
-} /* End init_PCI */
-
-#endif /* ENABLE_PCI */
+}
 
 MODULE_LICENSE("GPL");
index 52205ef7131483ae59a17a0220c3803fe0939741..20eeb5a70e1ad841c9b73490df25d82d6c7f8786 100644 (file)
@@ -85,73 +85,73 @@ static char *board_desc[] =
 struct channel 
 {
        long   magic;
-       unchar boardnum;
-       unchar channelnum;
-       unchar omodem;         /* FEP output modem status     */
-       unchar imodem;         /* FEP input modem status      */
-       unchar modemfake;      /* Modem values to be forced   */
-       unchar modem;          /* Force values                */
-       unchar hflow;
-       unchar dsr;
-       unchar dcd;
-       unchar m_rts ;          /* The bits used in whatever FEP */
-       unchar m_dcd ;          /* is indiginous to this board to */
-       unchar m_dsr ;          /* represent each of the physical */
-       unchar m_cts ;          /* handshake lines */
-       unchar m_ri ;
-       unchar m_dtr ;
-       unchar stopc;
-       unchar startc;
-       unchar stopca;
-       unchar startca;
-       unchar fepstopc;
-       unchar fepstartc;
-       unchar fepstopca;
-       unchar fepstartca;
-       unchar txwin;
-       unchar rxwin;
-       ushort fepiflag;
-       ushort fepcflag;
-       ushort fepoflag;
-       ushort txbufhead;
-       ushort txbufsize;
-       ushort rxbufhead;
-       ushort rxbufsize;
+       unsigned char boardnum;
+       unsigned char channelnum;
+       unsigned char omodem;         /* FEP output modem status     */
+       unsigned char imodem;         /* FEP input modem status      */
+       unsigned char modemfake;      /* Modem values to be forced   */
+       unsigned char modem;          /* Force values                */
+       unsigned char hflow;
+       unsigned char dsr;
+       unsigned char dcd;
+       unsigned char m_rts ;           /* The bits used in whatever FEP */
+       unsigned char m_dcd ;           /* is indiginous to this board to */
+       unsigned char m_dsr ;           /* represent each of the physical */
+       unsigned char m_cts ;           /* handshake lines */
+       unsigned char m_ri ;
+       unsigned char m_dtr ;
+       unsigned char stopc;
+       unsigned char startc;
+       unsigned char stopca;
+       unsigned char startca;
+       unsigned char fepstopc;
+       unsigned char fepstartc;
+       unsigned char fepstopca;
+       unsigned char fepstartca;
+       unsigned char txwin;
+       unsigned char rxwin;
+       unsigned short fepiflag;
+       unsigned short fepcflag;
+       unsigned short fepoflag;
+       unsigned short txbufhead;
+       unsigned short txbufsize;
+       unsigned short rxbufhead;
+       unsigned short rxbufsize;
        int    close_delay;
        int    count;
        int    blocked_open;
-       ulong  event;
+       unsigned long  event;
        int    asyncflags;
        uint   dev;
-       ulong  statusflags;
-       ulong  c_iflag;
-       ulong  c_cflag;
-       ulong  c_lflag;
-       ulong  c_oflag;
-       unchar *txptr;
-       unchar *rxptr;
-       unchar *tmp_buf;
+       unsigned long  statusflags;
+       unsigned long  c_iflag;
+       unsigned long  c_cflag;
+       unsigned long  c_lflag;
+       unsigned long  c_oflag;
+       unsigned char *txptr;
+       unsigned char *rxptr;
+       unsigned char *tmp_buf;
        struct board_info           *board;
-       volatile struct board_chan  *brdchan;
+       struct board_chan           *brdchan;
        struct digi_struct          digiext;
        struct tty_struct           *tty;
        wait_queue_head_t           open_wait;
        wait_queue_head_t           close_wait;
-       struct work_struct            tqueue;
-       volatile struct global_data *mailbox;
+       struct work_struct          tqueue;
+       struct global_data          *mailbox;
 };
 
 struct board_info      
 {
-       unchar status;
-       unchar type;
-       unchar altpin;
-       ushort numports;
-       unchar *port;
-       unchar *membase;
-       unchar __iomem *re_map_port;
-       unchar *re_map_membase;
-       ulong  memory_seg;
+       unsigned char status;
+       unsigned char type;
+       unsigned char altpin;
+       unsigned short numports;
+       unsigned long port;
+       unsigned long membase;
+       unsigned char __iomem *re_map_port;
+       unsigned char *re_map_membase;
+       unsigned long  memory_seg;
        void ( * memwinon )     (struct board_info *, unsigned int) ;
        void ( * memwinoff )    (struct board_info *, unsigned int) ;
        void ( * globalwinon )  (struct channel *) ;
@@ -160,6 +160,6 @@ struct board_info
        void ( * memoff )       (struct channel *) ;
        void ( * assertgwinon ) (struct channel *) ;
        void ( * assertmemoff ) (struct channel *) ;
-       unchar poller_inhibited ;
+       unsigned char poller_inhibited ;
 };