intel-gtt: switch i81x to the common initialization helpers
[linux-2.6.git] / drivers / char / rio / riotty.c
index db65500..8a90393 100644 (file)
 **
 ** -----------------------------------------------------------------------------
 */
-#ifdef SCCS_LABELS
-static char *_riotty_c_sccs_ = "@(#)riotty.c   1.3";
-#endif
-
 
 #define __EXPLICIT_DEF_H__
 
 #include <linux/module.h>
-#include <linux/slab.h>
+#include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/tty.h>
 #include <linux/string.h>
 #include <asm/io.h>
 #include <asm/system.h>
 #include <asm/string.h>
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 
 #include <linux/termios.h>
@@ -56,15 +51,12 @@ static char *_riotty_c_sccs_ = "@(#)riotty.c        1.3";
 
 #include "linux_compat.h"
 #include "rio_linux.h"
-#include "typdef.h"
 #include "pkt.h"
 #include "daemon.h"
 #include "rio.h"
 #include "riospace.h"
-#include "top.h"
 #include "cmdpkt.h"
 #include "map.h"
-#include "riotypes.h"
 #include "rup.h"
 #include "port.h"
 #include "riodrvr.h"
@@ -77,265 +69,166 @@ static char *_riotty_c_sccs_ = "@(#)riotty.c      1.3";
 #include "unixrup.h"
 #include "board.h"
 #include "host.h"
-#include "error.h"
 #include "phb.h"
 #include "link.h"
 #include "cmdblk.h"
 #include "route.h"
-#include "control.h"
 #include "cirrus.h"
 #include "rioioctl.h"
 #include "param.h"
-#include "list.h"
-#include "sam.h"
-
-#if 0
-static void ttyseth_pv(struct Port *, struct ttystatics *, 
-                               struct termios *sg, int);
-#endif
 
 static void RIOClearUp(struct Port *PortP);
-int RIOShortCommand(struct rio_info *p, struct Port *PortP, 
-                          int command, int len, int arg);
 
-#if 0
-static int RIOCookMode(struct ttystatics *);
-#endif
-
-extern int     conv_vb[];      /* now defined in ttymgr.c */
-extern int     conv_bv[];      /* now defined in ttymgr.c */
-/*
-** 16.09.1998 ARG - Fix to build riotty.k.o for Modular Kernel Support
-**
-** ep.def.h is necessary for Modular Kernel Support
-** DO NOT place any kernel 'extern's after this line
-** or this source file will not build riotty.k.o
-*/
-#ifdef uLYNX
-#include <ep.def.h>
-#endif
-
-#ifdef NEED_THIS2
-static struct old_sgttyb 
-default_sg = 
-{ 
-       B19200, B19200,                         /* input and output speed */ 
-       'H' - '@',                                      /* erase char */ 
-       -1,                                                     /* 2nd erase char */ 
-       'U' - '@',                                      /* kill char */ 
-       ECHO | CRMOD,                           /* mode */ 
-       'C' - '@',                                      /* interrupt character */ 
-       '\\' - '@',                                     /* quit char */ 
-       'Q' - '@',                                      /* start char */
-       'S' - '@',                                      /* stop char */ 
-       'D' - '@',                                      /* EOF */
-       -1,                                                     /* brk */
-       (LCRTBS | LCRTERA | LCRTKIL | LCTLECH), /* local mode word */ 
-       'Z' - '@',                                      /* process stop */
-       'Y' - '@',                                      /* delayed stop */
-       'R' - '@',                                      /* reprint line */ 
-       'O' - '@',                                      /* flush output */
-       'W' - '@',                                      /* word erase */
-       'V' - '@'                                       /* literal next char */
-};
-#endif
+/* Below belongs in func.h */
+int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg);
 
 
 extern struct rio_info *p;
 
 
-int
-riotopen(struct tty_struct * tty, struct file * filp)
+int riotopen(struct tty_struct *tty, struct file *filp)
 {
-       register uint SysPort;
-       int Modem;
+       unsigned int SysPort;
        int repeat_this = 250;
-       struct Port *PortP;              /* pointer to the port structure */
+       struct Port *PortP;     /* pointer to the port structure */
        unsigned long flags;
        int retval = 0;
 
-       func_enter ();
+       func_enter();
 
        /* Make sure driver_data is NULL in case the rio isn't booted jet. Else gs_close
           is going to oops.
-       */
+        */
        tty->driver_data = NULL;
-        
+
        SysPort = rio_minor(tty);
-       Modem   = rio_ismodem(tty);
 
-       if ( p->RIOFailed ) {
-               rio_dprintk (RIO_DEBUG_TTY, "System initialisation failed\n");
-               pseterr(ENXIO);
-               func_exit ();
+       if (p->RIOFailed) {
+               rio_dprintk(RIO_DEBUG_TTY, "System initialisation failed\n");
+               func_exit();
                return -ENXIO;
        }
 
-       rio_dprintk (RIO_DEBUG_TTY, "port open SysPort %d (%s) (mapped:%d)\n",
-              SysPort,  Modem ? "Modem" : "tty",
-                                  p->RIOPortp[SysPort]->Mapped);
+       rio_dprintk(RIO_DEBUG_TTY, "port open SysPort %d (mapped:%d)\n", SysPort, p->RIOPortp[SysPort]->Mapped);
 
        /*
-       ** Validate that we have received a legitimate request.
-       ** Currently, just check that we are opening a port on
-       ** a host card that actually exists, and that the port
-       ** has been mapped onto a host.
-       */
+        ** Validate that we have received a legitimate request.
+        ** Currently, just check that we are opening a port on
+        ** a host card that actually exists, and that the port
+        ** has been mapped onto a host.
+        */
        if (SysPort >= RIO_PORTS) {     /* out of range ? */
-               rio_dprintk (RIO_DEBUG_TTY, "Illegal port number %d\n",SysPort);
-               pseterr(ENXIO);
+               rio_dprintk(RIO_DEBUG_TTY, "Illegal port number %d\n", SysPort);
                func_exit();
                return -ENXIO;
        }
 
        /*
-       ** Grab pointer to the port stucture
-       */
+        ** Grab pointer to the port stucture
+        */
        PortP = p->RIOPortp[SysPort];   /* Get control struc */
-       rio_dprintk (RIO_DEBUG_TTY, "PortP: %p\n", PortP);
-       if ( !PortP->Mapped ) { /* we aren't mapped yet! */
+       rio_dprintk(RIO_DEBUG_TTY, "PortP: %p\n", PortP);
+       if (!PortP->Mapped) {   /* we aren't mapped yet! */
                /*
-               ** The system doesn't know which RTA this port
-               ** corresponds to.
-               */
-               rio_dprintk (RIO_DEBUG_TTY, "port not mapped into system\n");
-               func_exit ();
-               pseterr(ENXIO);
+                ** The system doesn't know which RTA this port
+                ** corresponds to.
+                */
+               rio_dprintk(RIO_DEBUG_TTY, "port not mapped into system\n");
+               func_exit();
                return -ENXIO;
        }
 
        tty->driver_data = PortP;
 
-       PortP->gs.tty = tty;
-       PortP->gs.count++;
+       PortP->gs.port.tty = tty;
+       PortP->gs.port.count++;
 
-       rio_dprintk (RIO_DEBUG_TTY, "%d bytes in tx buffer\n",
-                                  PortP->gs.xmit_cnt);
+       rio_dprintk(RIO_DEBUG_TTY, "%d bytes in tx buffer\n", PortP->gs.xmit_cnt);
 
-       retval = gs_init_port (&PortP->gs);
+       retval = gs_init_port(&PortP->gs);
        if (retval) {
-               PortP->gs.count--;
+               PortP->gs.port.count--;
                return -ENXIO;
        }
        /*
-       ** If the host hasn't been booted yet, then 
-       ** fail
-       */
-       if ( (PortP->HostP->Flags & RUN_STATE) != RC_RUNNING ) {
-               rio_dprintk (RIO_DEBUG_TTY, "Host not running\n");
-               pseterr(ENXIO);
-               func_exit ();
+        ** If the host hasn't been booted yet, then
+        ** fail
+        */
+       if ((PortP->HostP->Flags & RUN_STATE) != RC_RUNNING) {
+               rio_dprintk(RIO_DEBUG_TTY, "Host not running\n");
+               func_exit();
                return -ENXIO;
        }
 
        /*
-       ** If the RTA has not booted yet and the user has choosen to block
-       ** until the RTA is present then we must spin here waiting for
-       ** the RTA to boot.
-       */
-#if 0
-       if (!(PortP->HostP->Mapping[PortP->RupNum].Flags & RTA_BOOTED)) {
-               if (PortP->WaitUntilBooted) {
-                       rio_dprintk (RIO_DEBUG_TTY, "Waiting for RTA to boot\n");
-                       do {
-                               if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
-                                       rio_dprintk (RIO_DEBUG_TTY, "RTA EINTR in delay \n");
-                                       func_exit ();
-                                       return -EINTR;
-                               }
-                               if (repeat_this -- <= 0) {
-                                       rio_dprintk (RIO_DEBUG_TTY, "Waiting for RTA to boot timeout\n");
-                                       RIOPreemptiveCmd(p, PortP, FCLOSE ); 
-                                       pseterr(EINTR);
-                                       func_exit ();
-                                       return -EIO;
-                               }
-                       } while(!(PortP->HostP->Mapping[PortP->RupNum].Flags & RTA_BOOTED));
-                       rio_dprintk (RIO_DEBUG_TTY, "RTA has been booted\n");
-               } else {
-                       rio_dprintk (RIO_DEBUG_TTY, "RTA never booted\n");
-                       pseterr(ENXIO);
-                       func_exit ();
-                       return 0;
-               }
-       }
-#else
+        ** If the RTA has not booted yet and the user has choosen to block
+        ** until the RTA is present then we must spin here waiting for
+        ** the RTA to boot.
+        */
        /* I find the above code a bit hairy. I find the below code
-           easier to read and shorter. Now, if it works too that would
+          easier to read and shorter. Now, if it works too that would
           be great... -- REW 
-       */
-       rio_dprintk (RIO_DEBUG_TTY, "Checking if RTA has booted... \n");
+        */
+       rio_dprintk(RIO_DEBUG_TTY, "Checking if RTA has booted... \n");
        while (!(PortP->HostP->Mapping[PortP->RupNum].Flags & RTA_BOOTED)) {
-         if (!PortP->WaitUntilBooted) {
-           rio_dprintk (RIO_DEBUG_TTY, "RTA never booted\n");
-           func_exit ();
-           return -ENXIO;
-         }
-
-         /* Under Linux you'd normally use a wait instead of this
-            busy-waiting. I'll stick with the old implementation for
-            now. --REW 
-         */
-         if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
-           rio_dprintk (RIO_DEBUG_TTY, "RTA_wait_for_boot: EINTR in delay \n");
-           func_exit ();
-           return -EINTR;
-         }
-         if (repeat_this -- <= 0) {
-           rio_dprintk (RIO_DEBUG_TTY, "Waiting for RTA to boot timeout\n");
-           func_exit ();
-           return -EIO;
-         }
+               if (!PortP->WaitUntilBooted) {
+                       rio_dprintk(RIO_DEBUG_TTY, "RTA never booted\n");
+                       func_exit();
+                       return -ENXIO;
+               }
+
+               /* Under Linux you'd normally use a wait instead of this
+                  busy-waiting. I'll stick with the old implementation for
+                  now. --REW
+                */
+               if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
+                       rio_dprintk(RIO_DEBUG_TTY, "RTA_wait_for_boot: EINTR in delay \n");
+                       func_exit();
+                       return -EINTR;
+               }
+               if (repeat_this-- <= 0) {
+                       rio_dprintk(RIO_DEBUG_TTY, "Waiting for RTA to boot timeout\n");
+                       func_exit();
+                       return -EIO;
+               }
        }
-       rio_dprintk (RIO_DEBUG_TTY, "RTA has been booted\n");
-#endif
-#if 0
-       tp =  PortP->TtyP;              /* get tty struct */
-#endif
+       rio_dprintk(RIO_DEBUG_TTY, "RTA has been booted\n");
        rio_spin_lock_irqsave(&PortP->portSem, flags);
-       if ( p->RIOHalted ) {
+       if (p->RIOHalted) {
                goto bombout;
        }
-#if 0
-       retval = gs_init_port(&PortP->gs);
-       if (retval){
-               func_exit ();
-               return retval;
-       }
-#endif
 
        /*
-       ** If the port is in the final throws of being closed,
-       ** we should wait here (politely), waiting
-       ** for it to finish, so that it doesn't close us!
-       */
-       while ( (PortP->State & RIO_CLOSING) && !p->RIOHalted ) {
-               rio_dprintk (RIO_DEBUG_TTY, "Waiting for RIO_CLOSING to go away\n");
-               if (repeat_this -- <= 0) {
-                       rio_dprintk (RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
-                       RIOPreemptiveCmd(p, PortP, FCLOSE ); 
+        ** If the port is in the final throws of being closed,
+        ** we should wait here (politely), waiting
+        ** for it to finish, so that it doesn't close us!
+        */
+       while ((PortP->State & RIO_CLOSING) && !p->RIOHalted) {
+               rio_dprintk(RIO_DEBUG_TTY, "Waiting for RIO_CLOSING to go away\n");
+               if (repeat_this-- <= 0) {
+                       rio_dprintk(RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
+                       RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE);
                        retval = -EINTR;
                        goto bombout;
                }
                rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
-                       rio_spin_lock_irqsave(&PortP->portSem, flags); 
+                       rio_spin_lock_irqsave(&PortP->portSem, flags);
                        retval = -EINTR;
                        goto bombout;
                }
-               rio_spin_lock_irqsave(&PortP->portSem, flags); 
+               rio_spin_lock_irqsave(&PortP->portSem, flags);
        }
 
-       if ( !PortP->Mapped ) {
-               rio_dprintk (RIO_DEBUG_TTY, "Port unmapped while closing!\n");
+       if (!PortP->Mapped) {
+               rio_dprintk(RIO_DEBUG_TTY, "Port unmapped while closing!\n");
                rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                retval = -ENXIO;
-               func_exit ();
+               func_exit();
                return retval;
        }
 
-       if ( p->RIOHalted ) {
+       if (p->RIOHalted) {
                goto bombout;
        }
 
@@ -346,168 +239,121 @@ riotopen(struct tty_struct * tty, struct file * filp)
 */
        /* Uh? Suppose I turn these on and then another process opens
           the port again? The flags get cleared! Not good. -- REW */
-       if ( !(PortP->State & (RIO_LOPEN | RIO_MOPEN)) ) {
-               PortP->Config &= ~(RIO_CTSFLOW|RIO_RTSFLOW);
+       if (!(PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
+               PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW);
        }
 
        if (!(PortP->firstOpen)) {      /* First time ? */
-               rio_dprintk (RIO_DEBUG_TTY, "First open for this port\n");
-       
+               rio_dprintk(RIO_DEBUG_TTY, "First open for this port\n");
+
 
                PortP->firstOpen++;
-               PortP->CookMode = 0; /* XXX RIOCookMode(tp); */
+               PortP->CookMode = 0;    /* XXX RIOCookMode(tp); */
                PortP->InUse = NOT_INUSE;
 
                /* Tentative fix for bug PR27. Didn't work. */
                /* PortP->gs.xmit_cnt = 0; */
 
                rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-#ifdef NEED_THIS
-               ttyseth(PortP, tp, (struct old_sgttyb *)&default_sg);
-#endif
 
                /* Someone explain to me why this delay/config is
-                   here. If I read the docs correctly the "open"
-                   command piggybacks the parameters immediately. 
+                  here. If I read the docs correctly the "open"
+                  command piggybacks the parameters immediately.
                   -- REW */
-               RIOParam(PortP,OPEN,Modem,OK_TO_SLEEP);         /* Open the port */
-#if 0
-               /* This delay of 1 second was annoying. I removed it. -- REW */
-               RIODelay(PortP, HUNDRED_MS*10);
-               RIOParam(PortP,CONFIG,Modem,OK_TO_SLEEP);       /* Config the port */
-#endif
+               RIOParam(PortP, RIOC_OPEN, 1, OK_TO_SLEEP); /* Open the port */
                rio_spin_lock_irqsave(&PortP->portSem, flags);
 
                /*
-               ** wait for the port to be not closed.
-               */
-               while ( !(PortP->PortState & PORT_ISOPEN) && !p->RIOHalted ) {
-                       rio_dprintk (RIO_DEBUG_TTY, "Waiting for PORT_ISOPEN-currently %x\n",PortP->PortState);
-/*
-** 15.10.1998 ARG - ESIL 0759
-** (Part) fix for port being trashed when opened whilst RTA "disconnected"
-** Take out the limited wait - now wait for ever or until user
-** bangs us out.
-**
-                       if (repeat_this -- <= 0) {
-                               rio_dprint(RIO_DEBUG_TTY, ("Waiting for open to finish timed out.\n"));
-                               RIOPreemptiveCmd(p, PortP, FCLOSE ); 
-                               rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                               return -EINTR;
-                       }
-**
-*/
+                ** wait for the port to be not closed.
+                */
+               while (!(PortP->PortState & PORT_ISOPEN) && !p->RIOHalted) {
+                       rio_dprintk(RIO_DEBUG_TTY, "Waiting for PORT_ISOPEN-currently %x\n", PortP->PortState);
                        rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                        if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
-                               rio_dprintk (RIO_DEBUG_TTY, "Waiting for open to finish broken by signal\n");
-                               RIOPreemptiveCmd(p, PortP, FCLOSE );
-                               func_exit ();
+                               rio_dprintk(RIO_DEBUG_TTY, "Waiting for open to finish broken by signal\n");
+                               RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE);
+                               func_exit();
                                return -EINTR;
                        }
                        rio_spin_lock_irqsave(&PortP->portSem, flags);
                }
 
-               if ( p->RIOHalted ) {
-                 retval = -EIO;
-bombout:
-                 /*                    RIOClearUp( PortP ); */
+               if (p->RIOHalted) {
+                       retval = -EIO;
+                     bombout:
+                       /*                    RIOClearUp( PortP ); */
                        rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                        return retval;
                }
-               rio_dprintk (RIO_DEBUG_TTY, "PORT_ISOPEN found\n");
+               rio_dprintk(RIO_DEBUG_TTY, "PORT_ISOPEN found\n");
        }
-
-#ifdef MODEM_SUPPORT 
-       if (Modem) {
-               rio_dprintk (RIO_DEBUG_TTY, "Modem - test for carrier\n");
+       rio_dprintk(RIO_DEBUG_TTY, "Modem - test for carrier\n");
+       /*
+        ** ACTION
+        ** insert test for carrier here. -- ???
+        ** I already see that test here. What's the deal? -- REW
+        */
+       if ((PortP->gs.port.tty->termios->c_cflag & CLOCAL) ||
+                       (PortP->ModemState & RIOC_MSVR1_CD)) {
+               rio_dprintk(RIO_DEBUG_TTY, "open(%d) Modem carr on\n", SysPort);
                /*
-               ** ACTION
-               ** insert test for carrier here. -- ???
-               ** I already see that test here. What's the deal? -- REW
-               */
-               if ((PortP->gs.tty->termios->c_cflag & CLOCAL) || (PortP->ModemState & MSVR1_CD))
-               {
-                       rio_dprintk (RIO_DEBUG_TTY, "open(%d) Modem carr on\n", SysPort);
+                  tp->tm.c_state |= CARR_ON;
+                  wakeup((caddr_t) &tp->tm.c_canq);
+                */
+               PortP->State |= RIO_CARR_ON;
+               wake_up_interruptible(&PortP->gs.port.open_wait);
+       } else {        /* no carrier - wait for DCD */
                        /*
-                       tp->tm.c_state |= CARR_ON;
-                       wakeup((caddr_t) &tp->tm.c_canq);
-                       */
-                       PortP->State |= RIO_CARR_ON;
-                       wake_up_interruptible (&PortP->gs.open_wait);
-               }
-               else /* no carrier - wait for DCD */
-               {
-                 /*
-                       while (!(PortP->gs.tty->termios->c_state & CARR_ON) && 
-                              !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted )
-                 */
-                       while (!(PortP->State & RIO_CARR_ON) && 
-                              !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted ) {
-
-                               rio_dprintk (RIO_DEBUG_TTY, "open(%d) sleeping for carr on\n",SysPort);
+                  while (!(PortP->gs.port.tty->termios->c_state & CARR_ON) &&
+                  !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted )
+                */
+               while (!(PortP->State & RIO_CARR_ON) && !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted) {
+                               rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr on\n", SysPort);
+                       /*
+                          PortP->gs.port.tty->termios->c_state |= WOPEN;
+                        */
+                       PortP->State |= RIO_WOPEN;
+                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
+                       if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
+                               rio_spin_lock_irqsave(&PortP->portSem, flags);
+                               /*
+                                ** ACTION: verify that this is a good thing
+                                ** to do here. -- ???
+                                ** I think it's OK. -- REW
+                                */
+                               rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr broken by signal\n", SysPort);
+                               RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE);
                                /*
-                               PortP->gs.tty->termios->c_state |= WOPEN;
-                               */
-                               PortP->State |= RIO_WOPEN;
+                                  tp->tm.c_state &= ~WOPEN;
+                                */
+                               PortP->State &= ~RIO_WOPEN;
                                rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                               if (RIODelay (PortP, HUNDRED_MS) == RIO_FAIL)
-#if 0
-                               if ( sleep((caddr_t)&tp->tm.c_canqo, TTIPRI|PCATCH))
-#endif
-                               {
-                                       /*
-                                       ** ACTION: verify that this is a good thing
-                                       ** to do here. -- ???
-                                       ** I think it's OK. -- REW
-                                       */
-                                       rio_dprintk (RIO_DEBUG_TTY, "open(%d) sleeping for carr broken by signal\n",
-                                              SysPort);
-                                       RIOPreemptiveCmd( p, PortP, FCLOSE );
-                                       /*
-                                       tp->tm.c_state &= ~WOPEN;
-                                       */
-                                       PortP->State &= ~RIO_WOPEN;
-                                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                                       func_exit ();
-                                       return -EINTR;
-                               }
+                               func_exit();
+                               return -EINTR;
                        }
-                       PortP->State &= ~RIO_WOPEN;
+                       rio_spin_lock_irqsave(&PortP->portSem, flags);
                }
-               if ( p->RIOHalted )
-                       goto bombout;
-               rio_dprintk (RIO_DEBUG_TTY, "Setting RIO_MOPEN\n");
-               PortP->State |= RIO_MOPEN;
-       }
-       else
-#endif
-       {
-               /*
-               ** ACTION
-               ** Direct line open - force carrier (will probably mean
-               ** that sleeping Modem line fubar)
-               */
-               PortP->State |= RIO_LOPEN;
+               PortP->State &= ~RIO_WOPEN;
        }
+       if (p->RIOHalted)
+               goto bombout;
+       rio_dprintk(RIO_DEBUG_TTY, "Setting RIO_MOPEN\n");
+       PortP->State |= RIO_MOPEN;
 
-       if ( p->RIOHalted ) {
+       if (p->RIOHalted)
                goto bombout;
-       }
 
-       rio_dprintk (RIO_DEBUG_TTY, "high level open done\n");
+       rio_dprintk(RIO_DEBUG_TTY, "high level open done\n");
 
-#ifdef STATS
-       PortP->Stat.OpenCnt++;
-#endif
        /*
-       ** Count opens for port statistics reporting
-       */
+        ** Count opens for port statistics reporting
+        */
        if (PortP->statsGather)
                PortP->opens++;
 
        rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-       rio_dprintk (RIO_DEBUG_TTY, "Returning from open\n");
-       func_exit ();
+       rio_dprintk(RIO_DEBUG_TTY, "Returning from open\n");
+       func_exit();
        return 0;
 }
 
@@ -516,85 +362,71 @@ bombout:
 ** The operating system thinks that this is last close for the device.
 ** As there are two interfaces to the port (Modem and tty), we need to
 ** check that both are closed before we close the device.
-*/ 
-int
-riotclose(void  *ptr)
+*/
+int riotclose(void *ptr)
 {
-#if 0
-       register uint SysPort = dev;
-       struct ttystatics *tp;          /* pointer to our ttystruct */
-#endif
-       struct Port *PortP =ptr;        /* pointer to the port structure */
+       struct Port *PortP = ptr;       /* pointer to the port structure */
        int deleted = 0;
-       int     try = -1; /* Disable the timeouts by setting them to -1 */
-       int     repeat_this = -1; /* Congrats to those having 15 years of 
-                                    uptime! (You get to break the driver.) */
-       long end_time;
-       struct tty_struct * tty;
+       int try = -1;           /* Disable the timeouts by setting them to -1 */
+       int repeat_this = -1;   /* Congrats to those having 15 years of
+                                  uptime! (You get to break the driver.) */
+       unsigned long end_time;
+       struct tty_struct *tty;
        unsigned long flags;
-       int Modem;
-       int rv =0;
-       
-       rio_dprintk (RIO_DEBUG_TTY, "port close SysPort %d\n",PortP->PortNum);
+       int rv = 0;
+
+       rio_dprintk(RIO_DEBUG_TTY, "port close SysPort %d\n", PortP->PortNum);
 
        /* PortP = p->RIOPortp[SysPort]; */
-       rio_dprintk (RIO_DEBUG_TTY, "Port is at address 0x%x\n",(int)PortP);
-       /* tp = PortP->TtyP;*/                  /* Get tty */
-       tty = PortP->gs.tty;
-       rio_dprintk (RIO_DEBUG_TTY, "TTY is at address 0x%x\n",(int)tty);
+       rio_dprintk(RIO_DEBUG_TTY, "Port is at address %p\n", PortP);
+       /* tp = PortP->TtyP; *//* Get tty */
+       tty = PortP->gs.port.tty;
+       rio_dprintk(RIO_DEBUG_TTY, "TTY is at address %p\n", tty);
 
-       if (PortP->gs.closing_wait) 
+       if (PortP->gs.closing_wait)
                end_time = jiffies + PortP->gs.closing_wait;
-       else 
+       else
                end_time = jiffies + MAX_SCHEDULE_TIMEOUT;
 
-       Modem = rio_ismodem(tty);
-#if 0
-       /* What F.CKING cache? Even then, a higly idle multiprocessor,
-          system with large caches this won't work . Better find out when 
-          this doesn't work asap, and fix the cause.  -- REW */
-       
-       RIODelay(PortP, HUNDRED_MS*10); /* To flush the cache */
-#endif
        rio_spin_lock_irqsave(&PortP->portSem, flags);
 
        /*
-       ** Setting this flag will make any process trying to open
-       ** this port block until we are complete closing it.
-       */
+        ** Setting this flag will make any process trying to open
+        ** this port block until we are complete closing it.
+        */
        PortP->State |= RIO_CLOSING;
 
-       if ( (PortP->State & RIO_DELETED) ) {
-               rio_dprintk (RIO_DEBUG_TTY, "Close on deleted RTA\n");
+       if ((PortP->State & RIO_DELETED)) {
+               rio_dprintk(RIO_DEBUG_TTY, "Close on deleted RTA\n");
                deleted = 1;
        }
-       
-       if ( p->RIOHalted ) {
-               RIOClearUp( PortP );
+
+       if (p->RIOHalted) {
+               RIOClearUp(PortP);
                rv = -EIO;
                goto close_end;
        }
 
-       rio_dprintk (RIO_DEBUG_TTY, "Clear bits\n");
+       rio_dprintk(RIO_DEBUG_TTY, "Clear bits\n");
        /*
-       ** clear the open bits for this device
-       */
-       PortP->State &= (Modem ? ~RIO_MOPEN : ~RIO_LOPEN);
+        ** clear the open bits for this device
+        */
+       PortP->State &= ~RIO_MOPEN;
        PortP->State &= ~RIO_CARR_ON;
-       PortP->ModemState &= ~MSVR1_CD;
+       PortP->ModemState &= ~RIOC_MSVR1_CD;
        /*
-       ** If the device was open as both a Modem and a tty line
-       ** then we need to wimp out here, as the port has not really
-       ** been finally closed (gee, whizz!) The test here uses the
-       ** bit for the OTHER mode of operation, to see if THAT is
-       ** still active!
-       */
-       if ( (PortP->State & (RIO_LOPEN|RIO_MOPEN)) ) {
+        ** If the device was open as both a Modem and a tty line
+        ** then we need to wimp out here, as the port has not really
+        ** been finally closed (gee, whizz!) The test here uses the
+        ** bit for the OTHER mode of operation, to see if THAT is
+        ** still active!
+        */
+       if ((PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
                /*
-               ** The port is still open for the other task -
-               ** return, pretending that we are still active.
-               */
-               rio_dprintk (RIO_DEBUG_TTY, "Channel %d still open !\n",PortP->PortNum);
+                ** The port is still open for the other task -
+                ** return, pretending that we are still active.
+                */
+               rio_dprintk(RIO_DEBUG_TTY, "Channel %d still open !\n", PortP->PortNum);
                PortP->State &= ~RIO_CLOSING;
                if (PortP->firstOpen)
                        PortP->firstOpen--;
@@ -602,48 +434,46 @@ riotclose(void  *ptr)
                return -EIO;
        }
 
-       rio_dprintk (RIO_DEBUG_TTY, "Closing down - everything must go!\n");
+       rio_dprintk(RIO_DEBUG_TTY, "Closing down - everything must go!\n");
 
        PortP->State &= ~RIO_DYNOROD;
 
        /*
-       ** This is where we wait for the port
-       ** to drain down before closing. Bye-bye....
-       ** (We never meant to do this)
-       */
-       rio_dprintk (RIO_DEBUG_TTY, "Timeout 1 starts\n");
+        ** This is where we wait for the port
+        ** to drain down before closing. Bye-bye....
+        ** (We never meant to do this)
+        */
+       rio_dprintk(RIO_DEBUG_TTY, "Timeout 1 starts\n");
 
        if (!deleted)
-       while ( (PortP->InUse != NOT_INUSE) && !p->RIOHalted && 
-               (PortP->TxBufferIn != PortP->TxBufferOut) ) {
-               cprintf("Need to flush the ttyport\n");
-               if (repeat_this -- <= 0) {
-                       rv = -EINTR;
-                       rio_dprintk (RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
-                       RIOPreemptiveCmd(p, PortP, FCLOSE ); 
-                       goto close_end;
-               }
-               rio_dprintk (RIO_DEBUG_TTY, "Calling timeout to flush in closing\n");
-               rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-               if (RIODelay_ni(PortP, HUNDRED_MS*10) == RIO_FAIL) {
-                       rio_dprintk (RIO_DEBUG_TTY, "RTA EINTR in delay \n");
-                       rv = -EINTR;
+               while ((PortP->InUse != NOT_INUSE) && !p->RIOHalted && (PortP->TxBufferIn != PortP->TxBufferOut)) {
+                       if (repeat_this-- <= 0) {
+                               rv = -EINTR;
+                               rio_dprintk(RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
+                               RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE);
+                               goto close_end;
+                       }
+                       rio_dprintk(RIO_DEBUG_TTY, "Calling timeout to flush in closing\n");
+                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
+                       if (RIODelay_ni(PortP, HUNDRED_MS * 10) == RIO_FAIL) {
+                               rio_dprintk(RIO_DEBUG_TTY, "RTA EINTR in delay \n");
+                               rv = -EINTR;
+                               rio_spin_lock_irqsave(&PortP->portSem, flags);
+                               goto close_end;
+                       }
                        rio_spin_lock_irqsave(&PortP->portSem, flags);
-                       goto close_end;
                }
-               rio_spin_lock_irqsave(&PortP->portSem, flags);
-       }
 
        PortP->TxBufferIn = PortP->TxBufferOut = 0;
        repeat_this = 0xff;
 
        PortP->InUse = 0;
-       if ( (PortP->State & (RIO_LOPEN|RIO_MOPEN)) ) {
+       if ((PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
                /*
-               ** The port has been re-opened for the other task -
-               ** return, pretending that we are still active.
-               */
-               rio_dprintk (RIO_DEBUG_TTY, "Channel %d re-open!\n", PortP->PortNum);
+                ** The port has been re-opened for the other task -
+                ** return, pretending that we are still active.
+                */
+               rio_dprintk(RIO_DEBUG_TTY, "Channel %d re-open!\n", PortP->PortNum);
                PortP->State &= ~RIO_CLOSING;
                rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                if (PortP->firstOpen)
@@ -651,60 +481,55 @@ riotclose(void  *ptr)
                return -EIO;
        }
 
-       if ( p->RIOHalted ) {
-               RIOClearUp( PortP );
+       if (p->RIOHalted) {
+               RIOClearUp(PortP);
                goto close_end;
        }
 
-       
-
        /* Can't call RIOShortCommand with the port locked. */
        rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 
-       if (RIOShortCommand(p, PortP, CLOSE, 1, 0) == RIO_FAIL) {
-         RIOPreemptiveCmd(p, PortP,FCLOSE);
-         goto close_end;
+       if (RIOShortCommand(p, PortP, RIOC_CLOSE, 1, 0) == RIO_FAIL) {
+               RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE);
+               rio_spin_lock_irqsave(&PortP->portSem, flags);
+               goto close_end;
        }
 
        if (!deleted)
-         while (try && (PortP->PortState & PORT_ISOPEN)) {
-               try--;
-               if (time_after (jiffies, end_time)) {
-                 rio_dprintk (RIO_DEBUG_TTY, "Run out of tries - force the bugger shut!\n" );
-                 RIOPreemptiveCmd(p, PortP,FCLOSE);
-                 break;
-               }
-               rio_dprintk (RIO_DEBUG_TTY, "Close: PortState:ISOPEN is %d\n", 
-                                          PortP->PortState & PORT_ISOPEN);
+               while (try && (PortP->PortState & PORT_ISOPEN)) {
+                       try--;
+                       if (time_after(jiffies, end_time)) {
+                               rio_dprintk(RIO_DEBUG_TTY, "Run out of tries - force the bugger shut!\n");
+                               RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE);
+                               break;
+                       }
+                       rio_dprintk(RIO_DEBUG_TTY, "Close: PortState:ISOPEN is %d\n", PortP->PortState & PORT_ISOPEN);
 
-               if ( p->RIOHalted ) {
-                       RIOClearUp( PortP );
-                       goto close_end;
-               }
-               if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
-                       rio_dprintk (RIO_DEBUG_TTY, "RTA EINTR in delay \n");
-                       RIOPreemptiveCmd(p, PortP,FCLOSE);
-                       break;
+                       if (p->RIOHalted) {
+                               RIOClearUp(PortP);
+                               rio_spin_lock_irqsave(&PortP->portSem, flags);
+                               goto close_end;
+                       }
+                       if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
+                               rio_dprintk(RIO_DEBUG_TTY, "RTA EINTR in delay \n");
+                               RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE);
+                               break;
+                       }
                }
-       }
        rio_spin_lock_irqsave(&PortP->portSem, flags);
-       rio_dprintk (RIO_DEBUG_TTY, "Close: try was %d on completion\n", try );
-       /* RIOPreemptiveCmd(p, PortP, FCLOSE); */
+       rio_dprintk(RIO_DEBUG_TTY, "Close: try was %d on completion\n", try);
+
+       /* RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE); */
 
 /*
 ** 15.10.1998 ARG - ESIL 0761 part fix
 ** RIO has it's own CTSFLOW and RTSFLOW flags in 'Config' in the port structure,** we need to make sure that the flags are clear when the port is opened.
 */
-       PortP->Config &= ~(RIO_CTSFLOW|RIO_RTSFLOW);
-
+       PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW);
 
-#ifdef STATS
-       PortP->Stat.CloseCnt++;
-#endif
        /*
-       ** Count opens for port statistics reporting
-       */
+        ** Count opens for port statistics reporting
+        */
        if (PortP->statsGather)
                PortP->closes++;
 
@@ -713,70 +538,28 @@ close_end:
           thought that a "deleted" flag means that the port was
           permanently gone, but here we can make it reappear by it
           being in close during the "deletion".
-       */
-       PortP->State &= ~(RIO_CLOSING|RIO_DELETED);
+        */
+       PortP->State &= ~(RIO_CLOSING | RIO_DELETED);
        if (PortP->firstOpen)
                PortP->firstOpen--;
        rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-       rio_dprintk (RIO_DEBUG_TTY, "Return from close\n");
+       rio_dprintk(RIO_DEBUG_TTY, "Return from close\n");
        return rv;
 }
 
 
-/*
-** decide if we need to use the line discipline.
-** This routine can return one of three values:
-** COOK_RAW if no processing has to be done by the line discipline or the card
-** COOK_WELL if the line discipline must be used to do the processing
-** COOK_MEDIUM if the card can do all the processing necessary.
-*/
-#if 0
-static int
-RIOCookMode(struct ttystatics *tp)
-{
-       /*
-       ** We can't handle tm.c_mstate != 0 on SCO
-       ** We can't handle mapping
-       ** We can't handle non-ttwrite line disc.
-       ** We can't handle lflag XCASE
-       ** We can handle oflag OPOST & (OCRNL, ONLCR, TAB3)
-       */
-
-#ifdef CHECK
-       CheckTtyP( tp );
-#endif
-       if (!(tp->tm.c_oflag & OPOST))  /* No post processing */
-               return COOK_RAW;        /* Raw mode o/p */
-
-       if ( tp->tm.c_lflag & XCASE )
-               return COOK_WELL;       /* Use line disc */
 
-       if (tp->tm.c_oflag & ~(OPOST | ONLCR | OCRNL | TAB3 ) )
-               return COOK_WELL;       /* Use line disc for strange modes */
-
-       if ( tp->tm.c_oflag == OPOST )  /* If only OPOST is set, do RAW */
-               return COOK_RAW;
-
-       /*
-       ** So, we need to output process!
-       */
-       return COOK_MEDIUM;
-}
-#endif
-
-static void
-RIOClearUp(PortP)
-struct Port *PortP;
+static void RIOClearUp(struct Port *PortP)
 {
-       rio_dprintk (RIO_DEBUG_TTY, "RIOHalted set\n");
-       PortP->Config = 0;        /* Direct semaphore */
+       rio_dprintk(RIO_DEBUG_TTY, "RIOHalted set\n");
+       PortP->Config = 0;      /* Direct semaphore */
        PortP->PortState = 0;
        PortP->firstOpen = 0;
        PortP->FlushCmdBodge = 0;
        PortP->ModemState = PortP->CookMode = 0;
        PortP->Mapped = 0;
        PortP->WflushFlag = 0;
-       PortP->MagicFlags       = 0;
+       PortP->MagicFlags = 0;
        PortP->RxDataStart = 0;
        PortP->TxBufferIn = 0;
        PortP->TxBufferOut = 0;
@@ -791,33 +574,26 @@ struct Port *PortP;
 ** Other values of len aren't allowed, and will cause
 ** a panic.
 */
-int RIOShortCommand(struct rio_info *p, struct Port *PortP,
-               int command, int len, int arg)
+int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg)
 {
-       PKT *PacketP;
-       int             retries = 20; /* at 10 per second -> 2 seconds */
+       struct PKT __iomem *PacketP;
+       int retries = 20;       /* at 10 per second -> 2 seconds */
        unsigned long flags;
 
-       rio_dprintk (RIO_DEBUG_TTY, "entering shortcommand.\n");
-#ifdef CHECK
-       CheckPortP( PortP );
-       if ( len < 1 || len > 2 )
-               cprintf(("STUPID LENGTH %d\n",len));
-#endif
+       rio_dprintk(RIO_DEBUG_TTY, "entering shortcommand.\n");
 
-       if ( PortP->State & RIO_DELETED ) {
-               rio_dprintk (RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n");
+       if (PortP->State & RIO_DELETED) {
+               rio_dprintk(RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n");
                return RIO_FAIL;
        }
        rio_spin_lock_irqsave(&PortP->portSem, flags);
 
        /*
-       ** If the port is in use for pre-emptive command, then wait for it to 
-       ** be free again.
-       */
-       while ( (PortP->InUse != NOT_INUSE) && !p->RIOHalted ) {
-               rio_dprintk (RIO_DEBUG_TTY, "Waiting for not in use (%d)\n", 
-                                          retries);
+        ** If the port is in use for pre-emptive command, then wait for it to
+        ** be free again.
+        */
+       while ((PortP->InUse != NOT_INUSE) && !p->RIOHalted) {
+               rio_dprintk(RIO_DEBUG_TTY, "Waiting for not in use (%d)\n", retries);
                rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                if (retries-- <= 0) {
                        return RIO_FAIL;
@@ -827,47 +603,47 @@ int RIOShortCommand(struct rio_info *p, struct Port *PortP,
                }
                rio_spin_lock_irqsave(&PortP->portSem, flags);
        }
-       if ( PortP->State & RIO_DELETED ) {
-               rio_dprintk (RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n");
+       if (PortP->State & RIO_DELETED) {
+               rio_dprintk(RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n");
                rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                return RIO_FAIL;
        }
 
-       while ( !can_add_transmit(&PacketP,PortP) && !p->RIOHalted ) {
-               rio_dprintk (RIO_DEBUG_TTY, "Waiting to add short command to queue (%d)\n", retries);
+       while (!can_add_transmit(&PacketP, PortP) && !p->RIOHalted) {
+               rio_dprintk(RIO_DEBUG_TTY, "Waiting to add short command to queue (%d)\n", retries);
                rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                if (retries-- <= 0) {
-                 rio_dprintk (RIO_DEBUG_TTY, "out of tries. Failing\n");
+                       rio_dprintk(RIO_DEBUG_TTY, "out of tries. Failing\n");
                        return RIO_FAIL;
                }
-               if ( RIODelay_ni(PortP, HUNDRED_MS)==RIO_FAIL ) {
+               if (RIODelay_ni(PortP, HUNDRED_MS) == RIO_FAIL) {
                        return RIO_FAIL;
                }
                rio_spin_lock_irqsave(&PortP->portSem, flags);
        }
 
-       if ( p->RIOHalted ) {
+       if (p->RIOHalted) {
                rio_spin_unlock_irqrestore(&PortP->portSem, flags);
                return RIO_FAIL;
        }
 
        /*
-       ** set the command byte and the argument byte
-       */
-       WBYTE(PacketP->data[0] , command);
+        ** set the command byte and the argument byte
+        */
+       writeb(command, &PacketP->data[0]);
 
-       if ( len==2 )
-               WBYTE(PacketP->data[1] , arg);
+       if (len == 2)
+               writeb(arg, &PacketP->data[1]);
 
        /*
-       ** set the length of the packet and set the command bit.
-       */
-       WBYTE(PacketP->len , PKT_CMD_BIT | len);
+        ** set the length of the packet and set the command bit.
+        */
+       writeb(PKT_CMD_BIT | len, &PacketP->len);
 
        add_transmit(PortP);
        /*
-       ** Count characters transmitted for port statistics reporting
-       */
+        ** Count characters transmitted for port statistics reporting
+        */
        if (PortP->statsGather)
                PortP->txchars += len;
 
@@ -876,501 +652,3 @@ int RIOShortCommand(struct rio_info *p, struct Port *PortP,
 }
 
 
-#if 0
-/*
-** This is an ioctl interface. This is the twentieth century. You know what
-** its all about.
-*/
-int
-riotioctl(struct rio_info *p, struct tty_struct *tty, int cmd, caddr_t arg)
-{
-       register struct         Port *PortP;
-       register struct         ttystatics *tp;
-       int                                     current;
-       int                                     ParamSemIncremented = 0;
-       int                                     old_oflag, old_cflag, old_iflag, changed, oldcook;
-       int                                     i;
-       unsigned char           sio_regs[5];            /* Here be magic */
-       short                           vpix_cflag;
-       short                           divisor;
-       int                                     baud;
-       uint                            SysPort = rio_minor(tty);
-       int                             Modem = rio_ismodem(tty);
-       int                                     ioctl_processed;
-
-       rio_dprintk (RIO_DEBUG_TTY, "port ioctl SysPort %d command 0x%x argument 0x%x %s\n",
-                       SysPort, cmd, arg, Modem?"Modem":"tty") ;
-
-       if ( SysPort >= RIO_PORTS ) {
-               rio_dprintk (RIO_DEBUG_TTY, "Bad port number %d\n", SysPort);
-               return -ENXIO;
-       }
-
-       PortP = p->RIOPortp[SysPort];
-       tp = PortP->TtyP;
-
-       rio_spin_lock_irqsave(&PortP->portSem, flags);
-
-#ifdef STATS
-       PortP->Stat.IoctlCnt++;
-#endif
-
-       if ( PortP->State & RIO_DELETED ) {
-               rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-               return -EIO;
-       }
-
-
-       if ( p->RIOHalted ) {
-               RIOClearUp( PortP );
-               rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-               return -EIO;
-       }
-
-       /*
-       ** Count ioctls for port statistics reporting
-       */
-       if (PortP->statsGather)
-               PortP->ioctls++;
-
-       /*
-       ** Specialix RIO Ioctl calls
-       */
-       switch (cmd) {
-
-               case TCRIOTRIAD:
-                       if ( arg )
-                               PortP->State |= RIO_TRIAD_MODE;
-                       else
-                               PortP->State &= ~RIO_TRIAD_MODE;
-                       /*
-                       ** Normally, when istrip is set on a port, a config is
-                       ** sent to the RTA instructing the CD1400 to do the
-                       ** stripping. In TRIAD mode, the interrupt receive routine
-                       ** must do the stripping instead, since it has to detect
-                       ** an 8 bit function key sequence. If istrip is set with
-                       ** TRIAD mode on(off), and 8 bit data is being read by
-                       ** the port, the user then turns TRIAD mode off(on), the RTA
-                       ** must be reconfigured (not) to do the stripping.
-                       ** Hence we call RIOParam here.
-                       */
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       RIOParam(PortP,CONFIG,Modem,OK_TO_SLEEP);       
-                       return 0;
-
-               case TCRIOTSTATE:
-                       rio_dprintk (RIO_DEBUG_TTY, "tbusy/tstop monitoring %sabled\n",
-                               arg ? "en" : "dis");
-                       /* MonitorTstate = 0 ;*/
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       RIOParam(PortP, CONFIG, Modem, OK_TO_SLEEP);
-                       return 0;
-
-               case TCRIOSTATE: /* current state of Modem input pins */
-                       rio_dprintk (RIO_DEBUG_TTY, "TCRIOSTATE\n");
-                       if (RIOPreemptiveCmd(p, PortP, MGET) == RIO_FAIL)
-                               rio_dprintk (RIO_DEBUG_TTY, "TCRIOSTATE command failed\n");
-                       PortP->State |= RIO_BUSY;
-                       current = PortP->ModemState;
-                       if ( copyout((caddr_t)&current, (int)arg,
-                                                       sizeof(current))==COPYFAIL ) {
-                               rio_dprintk (RIO_DEBUG_TTY, "Copyout failed\n");
-                               rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                               pseterr(EFAULT);
-                       }
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       return 0;
-
-               case TCRIOMBIS:         /* Set modem lines */
-               case TCRIOMBIC:         /* Clear modem lines */
-                       rio_dprintk (RIO_DEBUG_TTY, "TCRIOMBIS/TCRIOMBIC\n");
-                       if (cmd == TCRIOMBIS) {
-                               uint            state;
-                               state = (uint)arg;
-                               PortP->ModemState |= (ushort)state;
-                               PortP->ModemLines = (ulong) arg;
-                               if (RIOPreemptiveCmd(p, PortP, MBIS) == RIO_FAIL)
-                                       rio_dprintk (RIO_DEBUG_TTY, 
-                                        "TCRIOMBIS command failed\n");
-                       }
-                       else {
-                               uint            state;
-
-                               state = (uint)arg;
-                               PortP->ModemState &= ~(ushort)state;
-                               PortP->ModemLines = (ulong) arg;
-                               if (RIOPreemptiveCmd(p, PortP, MBIC) == RIO_FAIL)
-                                       rio_dprintk (RIO_DEBUG_TTY, "TCRIOMBIC command failed\n");
-                       }
-                       PortP->State |= RIO_BUSY;
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       return 0;
-
-               case TCRIOXPON: /* set Xprint ON string */
-                       rio_dprintk (RIO_DEBUG_TTY, "TCRIOXPON\n");
-                       if ( copyin((int)arg, (caddr_t)PortP->Xprint.XpOn,
-                                               MAX_XP_CTRL_LEN)==COPYFAIL ) {
-                               rio_dprintk (RIO_DEBUG_TTY, "Copyin failed\n");
-                               PortP->Xprint.XpOn[0] = '\0';
-                               rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                               pseterr(EFAULT);
-                       }
-                       PortP->Xprint.XpOn[MAX_XP_CTRL_LEN-1] = '\0';
-                       PortP->Xprint.XpLen = strlen(PortP->Xprint.XpOn)+
-                                                                                               strlen(PortP->Xprint.XpOff);
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       return 0;
-
-               case TCRIOXPOFF: /* set Xprint OFF string */
-                       rio_dprintk (RIO_DEBUG_TTY, "TCRIOXPOFF\n");
-                       if ( copyin( (int)arg, (caddr_t)PortP->Xprint.XpOff,
-                                               MAX_XP_CTRL_LEN)==COPYFAIL ) {
-                               rio_dprintk (RIO_DEBUG_TTY, "Copyin failed\n");
-                               PortP->Xprint.XpOff[0] = '\0';
-                               rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                               pseterr(EFAULT);
-                       }
-                       PortP->Xprint.XpOff[MAX_XP_CTRL_LEN-1] = '\0';
-                       PortP->Xprint.XpLen = strlen(PortP->Xprint.XpOn)+
-                                                                               strlen(PortP->Xprint.XpOff);
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       return 0;
-
-               case TCRIOXPCPS: /* set Xprint CPS string */
-                       rio_dprintk (RIO_DEBUG_TTY, "TCRIOXPCPS\n");
-                       if ( (uint)arg > p->RIOConf.MaxXpCps || 
-                                       (uint)arg < p->RIOConf.MinXpCps ) {
-                               rio_dprintk (RIO_DEBUG_TTY, "%d CPS out of range\n",arg);
-                               rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                               pseterr(EINVAL);
-                               return 0;
-                       }
-                       PortP->Xprint.XpCps = (uint)arg;
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       return 0;
-
-               case TCRIOXPRINT:
-                       rio_dprintk (RIO_DEBUG_TTY, "TCRIOXPRINT\n");
-                       if ( copyout((caddr_t)&PortP->Xprint, (int)arg,
-                                       sizeof(struct Xprint))==COPYFAIL ) {
-                               rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                               pseterr(EFAULT);
-                       }
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       return 0;
-
-               case TCRIOIXANYON:
-                       rio_dprintk (RIO_DEBUG_TTY, "TCRIOIXANYON\n");
-                       PortP->Config |= RIO_IXANY;
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       return 0;
-
-               case TCRIOIXANYOFF:
-                       rio_dprintk (RIO_DEBUG_TTY, "TCRIOIXANYOFF\n");
-                       PortP->Config &= ~RIO_IXANY;
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       return 0;
-
-               case TCRIOIXONON:
-                       rio_dprintk (RIO_DEBUG_TTY, "TCRIOIXONON\n");
-                       PortP->Config |= RIO_IXON;
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       return 0;
-
-               case TCRIOIXONOFF:
-                       rio_dprintk (RIO_DEBUG_TTY, "TCRIOIXONOFF\n");
-                       PortP->Config &= ~RIO_IXON;
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       return 0;
-
-/*
-** 15.10.1998 ARG - ESIL 0761 part fix
-** Added support for CTS and RTS flow control ioctls :
-*/
-               case TCRIOCTSFLOWEN:
-                       rio_dprintk (RIO_DEBUG_TTY, "TCRIOCTSFLOWEN\n");
-                       PortP->Config |= RIO_CTSFLOW;
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       RIOParam(PortP,CONFIG,Modem,OK_TO_SLEEP);       
-                       return 0;
-
-               case TCRIOCTSFLOWDIS:
-                       rio_dprintk (RIO_DEBUG_TTY, "TCRIOCTSFLOWDIS\n");
-                       PortP->Config &= ~RIO_CTSFLOW;
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       RIOParam(PortP,CONFIG,Modem,OK_TO_SLEEP);       
-                       return 0;
-
-               case TCRIORTSFLOWEN:
-                       rio_dprintk (RIO_DEBUG_TTY, "TCRIORTSFLOWEN\n");
-                       PortP->Config |= RIO_RTSFLOW;
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       RIOParam(PortP,CONFIG,Modem,OK_TO_SLEEP);       
-                       return 0;
-
-               case TCRIORTSFLOWDIS:
-                       rio_dprintk (RIO_DEBUG_TTY, "TCRIORTSFLOWDIS\n");
-                       PortP->Config &= ~RIO_RTSFLOW;
-                       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-                       RIOParam(PortP,CONFIG,Modem,OK_TO_SLEEP);       
-                       return 0;
-
-/* end ESIL 0761 part fix */
-
-       }
-
-
-       /* Lynx IOCTLS */
-       switch (cmd) {
-               case TIOCSETP:
-               case TIOCSETN:
-               case OTIOCSETP:
-               case OTIOCSETN:
-                       ioctl_processed++;
-                       ttyseth(PortP, tp, (struct old_sgttyb *)arg);
-                       break;
-               case TCSETA:
-               case TCSETAW:
-               case TCSETAF:
-                       ioctl_processed++;
-                       rio_dprintk (RIO_DEBUG_TTY, "NON POSIX ioctl\n");
-                       ttyseth_pv(PortP, tp, (struct termios *)arg, 0);
-                       break;
-               case TCSETAP:   /* posix tcsetattr() */
-               case TCSETAWP:  /* posix tcsetattr() */
-               case TCSETAFP:  /* posix tcsetattr() */
-                       rio_dprintk (RIO_DEBUG_TTY, "NON POSIX SYSV ioctl\n");
-                       ttyseth_pv(PortP, tp, (struct termios *)arg, 1);
-                       ioctl_processed++;
-                       break;
-       }
-
-       /*
-       ** If its any of the commands that require the port to be in the
-       ** non-busy state wait until all output has drained 
-       */
-       if (!ioctl_processed)
-       switch(cmd) {
-               case TCSETAW:
-               case TCSETAF:
-               case TCSETA:
-               case TCSBRK:
-#define OLD_POSIX ('x' << 8)
-#define OLD_POSIX_SETA (OLD_POSIX | 2)
-#define OLD_POSIX_SETAW (OLD_POSIX | 3)
-#define OLD_POSIX_SETAF (OLD_POSIX | 4)
-#define NEW_POSIX (('i' << 24) | ('X' << 16))
-#define NEW_POSIX_SETA (NEW_POSIX | 2)
-#define NEW_POSIX_SETAW (NEW_POSIX | 3)
-#define NEW_POSIX_SETAF (NEW_POSIX | 4)
-               case OLD_POSIX_SETA:
-               case OLD_POSIX_SETAW:
-               case OLD_POSIX_SETAF:
-               case NEW_POSIX_SETA:
-               case NEW_POSIX_SETAW:
-               case NEW_POSIX_SETAF:
-#ifdef TIOCSETP
-               case TIOCSETP:
-#endif
-               case TIOCSETD:
-               case TIOCSETN:
-                       rio_dprintk (RIO_DEBUG_TTY, "wait for non-BUSY, semaphore set\n");
-                       /*
-                       ** Wait for drain here, at least as far as the double buffer
-                       ** being empty.
-                       */
-                       /* XXX Does the above comment mean that this has
-                          still to be implemented? -- REW */
-                       /* XXX Is the locking OK together with locking
-                           in txenable? (Deadlock?) -- REW */
-                       
-                       RIOTxEnable((char *)PortP);
-                       break;
-               default:
-                       break;
-       }
-
-       old_cflag = tp->tm.c_cflag;
-       old_iflag = tp->tm.c_iflag;
-       old_oflag = tp->tm.c_oflag;
-       oldcook = PortP->CookMode;
-
-       if ( p->RIOHalted ) {
-               RIOClearUp( PortP );
-               rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-               pseterr(EIO);
-               return 0;
-       }
-
-       PortP->FlushCmdBodge = 0;
-
-       /*
-       ** If the port is locked, and it is reconfigured, we want
-       ** to restore the state of the tty structure so the change is NOT
-       ** made.
-       */
-       if (PortP->Lock) {
-               tp->tm.c_iflag = PortP->StoredTty.iflag;
-               tp->tm.c_oflag = PortP->StoredTty.oflag;
-               tp->tm.c_cflag = PortP->StoredTty.cflag;
-               tp->tm.c_lflag = PortP->StoredTty.lflag;
-               tp->tm.c_line = PortP->StoredTty.line;
-               for (i = 0; i < NCC + 1; i++)
-                       tp->tm.c_cc[i] = PortP->StoredTty.cc[i];
-       }
-       else {
-               /*
-               ** If the port is set to store the parameters, and it is
-               ** reconfigured, we want to save the current tty struct so it
-               ** may be restored on the next open.
-               */
-               if (PortP->Store) {
-                       PortP->StoredTty.iflag = tp->tm.c_iflag;
-                       PortP->StoredTty.oflag = tp->tm.c_oflag;
-                       PortP->StoredTty.cflag = tp->tm.c_cflag;
-                       PortP->StoredTty.lflag = tp->tm.c_lflag;
-                       PortP->StoredTty.line = tp->tm.c_line;
-                       for (i = 0; i < NCC + 1; i++)
-                               PortP->StoredTty.cc[i] = tp->tm.c_cc[i];
-               }
-       }
-
-       changed = (tp->tm.c_cflag != old_cflag) ||
-                               (tp->tm.c_iflag != old_iflag) ||
-                               (tp->tm.c_oflag != old_oflag);
-
-       PortP->CookMode = RIOCookMode(tp);      /* Set new cooking mode */
-
-       rio_dprintk (RIO_DEBUG_TTY, "RIOIoctl changed %d newcook %d oldcook %d\n",
-                       changed,PortP->CookMode,oldcook);
-
-#ifdef MODEM_SUPPORT
-       /*
-       ** kludge to force CARR_ON if CLOCAL set
-       */
-       if ((tp->tm.c_cflag & CLOCAL) || (PortP->ModemState & MSVR1_CD))        {
-               tp->tm.c_state |= CARR_ON;
-               wakeup ((caddr_t)&tp->tm.c_canq);
-       }
-#endif
-
-       if ( p->RIOHalted ) {
-               RIOClearUp( PortP );
-               rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-               pseterr(EIO);
-               return 0;
-       }
-       /*
-       ** Re-configure if modes or cooking have changed
-       */
-       if (changed || oldcook != PortP->CookMode || (ioctl_processed)) {
-               rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-               rio_dprintk (RIO_DEBUG_TTY, "Ioctl changing the PORT settings\n");
-               RIOParam(PortP,CONFIG,Modem,OK_TO_SLEEP);       
-               rio_spin_lock_irqsave(&PortP->portSem, flags);
-       }
-
-       if (p->RIOHalted) {
-               rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-               RIOClearUp( PortP );
-               pseterr(EIO);
-               return 0;
-       }
-       rio_spin_unlock_irqrestore(&PortP->portSem, flags);
-       return 0;
-}
-
-/*
-       ttyseth -- set hardware dependent tty settings
-*/
-void
-ttyseth(PortP, s, sg)
-struct Port *          PortP;
-struct ttystatics *            s;
-struct old_sgttyb *sg;
-{
-       struct old_sgttyb *     tsg;
-       struct termios *tp = &s->tm;
-
-       tsg = &s->sg;
-
-       if (sg->sg_flags & (EVENP|ODDP))  {
-               tp->c_cflag &= PARENB;
-               if (sg->sg_flags & EVENP) {
-                       if (sg->sg_flags & ODDP) {
-                               tp->c_cflag &= V_CS7;
-                               tp->c_cflag &= ~PARENB;
-                       }
-                       else {
-                               tp->c_cflag &= V_CS7;
-                               tp->c_cflag &= PARENB;
-                               tp->c_cflag &= PARODD;
-                       }
-               }
-               else if (sg->sg_flags & ODDP) {
-                       tp->c_cflag &= V_CS7;
-                       tp->c_cflag &= PARENB;
-                       tp->c_cflag &= PARODD;
-               }
-               else {
-                       tp->c_cflag &= V_CS7;
-                       tp->c_cflag &= PARENB;
-               }
-       }
-/*
- * Use ispeed as the desired speed.  Most implementations don't handle 
- * separate input and output speeds very well. If the RIO handles this, 
- * I will have to use separate sets of flags to store them in the 
- * Port structure.
- */
-       if ( !sg->sg_ospeed )
-               sg->sg_ospeed = sg->sg_ispeed;
-       else
-               sg->sg_ispeed = sg->sg_ospeed;
-       if (sg->sg_ispeed > V_EXTB ) 
-               sg->sg_ispeed = V_EXTB;
-       if (sg->sg_ispeed < V_B0)
-               sg->sg_ispeed = V_B0;
-       *tsg = *sg;
-   tp->c_cflag = (tp->c_cflag & ~V_CBAUD) | conv_bv[(int)sg->sg_ispeed];
-}
-
-/*
-       ttyseth_pv -- set hardware dependent tty settings using either the
-                       POSIX termios structure or the System V termio structure.
-                               sysv = 0 => (POSIX):     struct termios *sg
-                               sysv != 0 => (System V): struct termio *sg
-*/
-static void
-ttyseth_pv(PortP, s, sg, sysv)
-struct Port *PortP;
-struct ttystatics *s;
-struct termios *sg;
-int sysv;
-{
-    int speed;
-    unsigned char csize;
-    unsigned char cread;
-    unsigned int lcr_flags;
-    int ps;
-    if (sysv) {
-        /* sg points to a System V termio structure */
-        csize = ((struct termio *)sg)->c_cflag & CSIZE;
-        cread = ((struct termio *)sg)->c_cflag & CREAD;
-        speed = conv_vb[((struct termio *)sg)->c_cflag & V_CBAUD];
-    }
-    else {
-        /* sg points to a POSIX termios structure */
-        csize = sg->c_cflag & CSIZE;
-        cread = sg->c_cflag & CREAD;
-        speed = conv_vb[sg->c_cflag & V_CBAUD];
-    }
-    if (s->sg.sg_ispeed != speed || s->sg.sg_ospeed != speed) {
-        s->sg.sg_ispeed = speed;
-        s->sg.sg_ospeed = speed;
-        s->tm.c_cflag = (s->tm.c_cflag & ~V_CBAUD) |
-                         conv_bv[(int)s->sg.sg_ispeed];
-    }
-}
-#endif