1 files changed, 35 insertions, 276 deletions

diff --git a/drivers/char/rio/riointr.c b/drivers/char/rio/riointr.c
index 34d8787557a1..ec415ccbc4f0 100644
--- a/drivers/char/rio/riointr.c
+++ b/drivers/char/rio/riointr.c
@@ -101,8 +101,7 @@ static char *firstchars(char *p, int nch)
 
 #define INCR( P, I )    ((P) = (((P)+(I)) & p->RIOBufferMask))
 /* Enable and start the transmission of packets */
-void RIOTxEnable(en)
-char *en;
+void RIOTxEnable(char *en)
 {
         struct Port *PortP;
         struct rio_info *p;
@@ -186,10 +185,8 @@ char *en;
 static int RupIntr;
 static int RxIntr;
 static int TxIntr;
-void RIOServiceHost(p, HostP, From)
-struct rio_info *p;
-struct Host *HostP;
-int From;
+
+void RIOServiceHost(struct rio_info *p, struct Host *HostP, int From)
 {
         rio_spin_lock(&HostP->HostLock);
         if ((HostP->Flags & RUN_STATE) != RC_RUNNING) {
@@ -201,22 +198,22 @@ int From;
         }
         rio_spin_unlock(&HostP->HostLock);
 
-        if (RWORD(HostP->ParmMapP->rup_intr)) {
-                WWORD(HostP->ParmMapP->rup_intr, 0);
+        if (readw(&HostP->ParmMapP->rup_intr)) {
+                writew(0, &HostP->ParmMapP->rup_intr);
                 p->RIORupCount++;
                 RupIntr++;
-                rio_dprintk(RIO_DEBUG_INTR, "rio: RUP interrupt on host %d\n", HostP - p->RIOHosts);
+                rio_dprintk(RIO_DEBUG_INTR, "rio: RUP interrupt on host %Zd\n", HostP - p->RIOHosts);
                 RIOPollHostCommands(p, HostP);
         }
 
-        if (RWORD(HostP->ParmMapP->rx_intr)) {
+        if (readw(&HostP->ParmMapP->rx_intr)) {
                 int port;
 
-                WWORD(HostP->ParmMapP->rx_intr, 0);
+                writew(0, &HostP->ParmMapP->rx_intr);
                 p->RIORxCount++;
                 RxIntr++;
 
-                rio_dprintk(RIO_DEBUG_INTR, "rio: RX interrupt on host %d\n", HostP - p->RIOHosts);
+                rio_dprintk(RIO_DEBUG_INTR, "rio: RX interrupt on host %Zd\n", HostP - p->RIOHosts);
                 /*
                  ** Loop through every port. If the port is mapped into
                  ** the system ( i.e. has /dev/ttyXXXX associated ) then it is
@@ -277,26 +274,26 @@ int From;
                          ** it's handshake bit is set, then we must clear the handshake,
                          ** so that that downstream RTA is re-enabled.
                          */
-                        if (!can_remove_receive(&PacketP, PortP) && (RWORD(PortP->PhbP->handshake) == PHB_HANDSHAKE_SET)) {
+                        if (!can_remove_receive(&PacketP, PortP) && (readw(&PortP->PhbP->handshake) == PHB_HANDSHAKE_SET)) {
                                 /*
                                  ** MAGIC! ( Basically, handshake the RX buffer, so that
                                  ** the RTAs upstream can be re-enabled. )
                                  */
                                 rio_dprintk(RIO_DEBUG_INTR, "Set RX handshake bit\n");
-                                WWORD(PortP->PhbP->handshake, PHB_HANDSHAKE_SET | PHB_HANDSHAKE_RESET);
+                                writew(PHB_HANDSHAKE_SET | PHB_HANDSHAKE_RESET, &PortP->PhbP->handshake);
                         }
                         rio_spin_unlock(&PortP->portSem);
                 }
         }
 
-        if (RWORD(HostP->ParmMapP->tx_intr)) {
+        if (readw(&HostP->ParmMapP->tx_intr)) {
                 int port;
 
-                WWORD(HostP->ParmMapP->tx_intr, 0);
+                writew(0, &HostP->ParmMapP->tx_intr);
 
                 p->RIOTxCount++;
                 TxIntr++;
-                rio_dprintk(RIO_DEBUG_INTR, "rio: TX interrupt on host %d\n", HostP - p->RIOHosts);
+                rio_dprintk(RIO_DEBUG_INTR, "rio: TX interrupt on host %Zd\n", HostP - p->RIOHosts);
 
                 /*
                  ** Loop through every port.
@@ -445,9 +442,9 @@ int From;
                                          */
                                         PktCmdP = (struct PktCmd *) &PacketP->data[0];
 
-                                        WBYTE(PktCmdP->Command, WFLUSH);
+                                        writeb(WFLUSH, &PktCmdP->Command);
 
-                                        p = PortP->HostPort % (ushort) PORTS_PER_RTA;
+                                        p = PortP->HostPort % (u16) PORTS_PER_RTA;
 
                                         /*
                                          ** If second block of ports for 16 port RTA, add 8
@@ -456,27 +453,27 @@ int From;
                                         if (PortP->SecondBlock)
                                                 p += PORTS_PER_RTA;
 
-                                        WBYTE(PktCmdP->PhbNum, p);
+                                        writeb(p, &PktCmdP->PhbNum);
 
                                         /*
                                          ** to make debuggery easier
                                          */
-                                        WBYTE(PacketP->data[2], 'W');
-                                        WBYTE(PacketP->data[3], 'F');
-                                        WBYTE(PacketP->data[4], 'L');
-                                        WBYTE(PacketP->data[5], 'U');
-                                        WBYTE(PacketP->data[6], 'S');
-                                        WBYTE(PacketP->data[7], 'H');
-                                        WBYTE(PacketP->data[8], ' ');
-                                        WBYTE(PacketP->data[9], '0' + PortP->WflushFlag);
-                                        WBYTE(PacketP->data[10], ' ');
-                                        WBYTE(PacketP->data[11], ' ');
-                                        WBYTE(PacketP->data[12], '\0');
+                                        writeb('W', &PacketP->data[2]);
+                                        writeb('F', &PacketP->data[3]);
+                                        writeb('L', &PacketP->data[4]);
+                                        writeb('U', &PacketP->data[5]);
+                                        writeb('S', &PacketP->data[6]);
+                                        writeb('H', &PacketP->data[7]);
+                                        writeb(' ', &PacketP->data[8]);
+                                        writeb('0' + PortP->WflushFlag, &PacketP->data[9]);
+                                        writeb(' ', &PacketP->data[10]);
+                                        writeb(' ', &PacketP->data[11]);
+                                        writeb('\0', &PacketP->data[12]);
 
                                         /*
                                          ** its two bytes long!
                                          */
-                                        WBYTE(PacketP->len, PKT_CMD_BIT | 2);
+                                        writeb(PKT_CMD_BIT | 2, &PacketP->len);
 
                                         /*
                                          ** queue it!
@@ -529,19 +526,15 @@ int From;
 }
 
 /*
-** Routine for handling received data for clist drivers.
-** NB: Called with the tty locked. The spl from the lockb( ) is passed.
-** we return the ttySpl level that we re-locked at.
+** Routine for handling received data for tty drivers
 */
-static void RIOReceive(p, PortP)
-struct rio_info *p;
-struct Port *PortP;
+static void RIOReceive(struct rio_info *p, struct Port *PortP)
 {
         struct tty_struct *TtyP;
-        register ushort transCount;
+        unsigned short transCount;
         struct PKT *PacketP;
-        register uint DataCnt;
-        uchar *ptr;
+        register unsigned int DataCnt;
+        unsigned char *ptr;
         unsigned char *buf;
         int copied = 0;
 
@@ -594,9 +587,6 @@ struct Port *PortP;
                 transCount = 1;
                 while (can_remove_receive(&PacketP, PortP)
                        && transCount) {
-#ifdef STATS
-                        PortP->Stat.RxIntCnt++;
-#endif                          /* STATS */
                         RxIntCnt++;
 
                         /*
@@ -642,28 +632,15 @@ struct Port *PortP;
                          ** to '#define', (this is the only place ___DEBUG_IT___ occurs in the
                          ** driver).
                          */
-#undef ___DEBUG_IT___
-#ifdef ___DEBUG_IT___
-                        kkprintf("I:%d R:%d P:%d Q:%d C:%d F:%x ", intCount, RxIntCnt, PortP->PortNum, TtyP->rxqueue.count, transCount, TtyP->flags);
-#endif
-                        ptr = (uchar *) PacketP->data + PortP->RxDataStart;
+                        ptr = (unsigned char *) PacketP->data + PortP->RxDataStart;
 
                         tty_prepare_flip_string(TtyP, &buf, transCount);
                         rio_memcpy_fromio(buf, ptr, transCount);
-#ifdef STATS
-                        /*
-                         ** keep a count for statistical purposes
-                         */
-                        PortP->Stat.RxCharCnt += transCount;
-#endif
                         PortP->RxDataStart += transCount;
                         PacketP->len -= transCount;
                         copied += transCount;
 
 
-#ifdef ___DEBUG_IT___
-                        kkprintf("T:%d L:%d\n", DataCnt, PacketP->len);
-#endif
 
                         if (PacketP->len == 0) {
                                 /*
@@ -674,12 +651,6 @@ struct Port *PortP;
                                 remove_receive(PortP);
                                 put_free_end(PortP->HostP, PacketP);
                                 PortP->RxDataStart = 0;
-#ifdef STATS
-                                /*
-                                 ** more lies ( oops, I mean statistics )
-                                 */
-                                PortP->Stat.RxPktCnt++;
-#endif                          /* STATS */
                         }
                 }
         }
@@ -691,215 +662,3 @@ struct Port *PortP;
         return;
 }
 
-#ifdef FUTURE_RELEASE
-/*
-** The proc routine called by the line discipline to do the work for it.
-** The proc routine works hand in hand with the interrupt routine.
-*/
-int riotproc(p, tp, cmd, port)
-struct rio_info *p;
-register struct ttystatics *tp;
-int cmd;
-int port;
-{
-        register struct Port *PortP;
-        int SysPort;
-        struct PKT *PacketP;
-
-        SysPort = port;         /* Believe me, it works. */
-
-        if (SysPort < 0 || SysPort >= RIO_PORTS) {
-                rio_dprintk(RIO_DEBUG_INTR, "Illegal port %d derived from TTY in riotproc()\n", SysPort);
-                return 0;
-        }
-        PortP = p->RIOPortp[SysPort];
-
-        if ((uint) PortP->PhbP < (uint) PortP->Caddr || (uint) PortP->PhbP >= (uint) PortP->Caddr + SIXTY_FOUR_K) {
-                rio_dprintk(RIO_DEBUG_INTR, "RIO: NULL or BAD PhbP on sys port %d in proc routine\n", SysPort);
-                rio_dprintk(RIO_DEBUG_INTR, "    PortP = 0x%x\n", PortP);
-                rio_dprintk(RIO_DEBUG_INTR, "    PortP->PhbP = 0x%x\n", PortP->PhbP);
-                rio_dprintk(RIO_DEBUG_INTR, "    PortP->Caddr = 0x%x\n", PortP->PhbP);
-                rio_dprintk(RIO_DEBUG_INTR, "    PortP->HostPort = 0x%x\n", PortP->HostPort);
-                return 0;
-        }
-
-        switch (cmd) {
-        case T_WFLUSH:
-                rio_dprintk(RIO_DEBUG_INTR, "T_WFLUSH\n");
-                /*
-                 ** Because of the spooky way the RIO works, we don't need
-                 ** to issue a flush command on any of the SET*F commands,
-                 ** as that causes trouble with getty and login, which issue
-                 ** these commands to incur a READ flush, and rely on the fact
-                 ** that the line discipline does a wait for drain for them.
-                 ** As the rio doesn't wait for drain, the write flush would
-                 ** destroy the Password: prompt. This isn't very friendly, so
-                 ** here we only issue a WFLUSH command if we are in the interrupt
-                 ** routine, or we aren't executing a SET*F command.
-                 */
-                if (PortP->HostP->InIntr || !PortP->FlushCmdBodge) {
-                        /*
-                         ** form a wflush packet - 1 byte long, no data
-                         */
-                        if (PortP->State & RIO_DELETED) {
-                                rio_dprintk(RIO_DEBUG_INTR, "WFLUSH on deleted RTA\n");
-                        } else {
-                                if (RIOPreemptiveCmd(p, PortP, WFLUSH) == RIO_FAIL) {
-                                        rio_dprintk(RIO_DEBUG_INTR, "T_WFLUSH Command failed\n");
-                                } else
-                                        rio_dprintk(RIO_DEBUG_INTR, "T_WFLUSH Command\n");
-                        }
-                        /*
-                         ** WFLUSH operation - flush the data!
-                         */
-                        PortP->TxBufferIn = PortP->TxBufferOut = 0;
-                } else {
-                        rio_dprintk(RIO_DEBUG_INTR, "T_WFLUSH Command ignored\n");
-                }
-                /*
-                 ** sort out the line discipline
-                 */
-                if (PortP->CookMode == COOK_WELL)
-                        goto start;
-                break;
-
-        case T_RESUME:
-                rio_dprintk(RIO_DEBUG_INTR, "T_RESUME\n");
-                /*
-                 ** send pre-emptive resume packet
-                 */
-                if (PortP->State & RIO_DELETED) {
-                        rio_dprintk(RIO_DEBUG_INTR, "RESUME on deleted RTA\n");
-                } else {
-                        if (RIOPreemptiveCmd(p, PortP, RESUME) == RIO_FAIL) {
-                                rio_dprintk(RIO_DEBUG_INTR, "T_RESUME Command failed\n");
-                        }
-                }
-                /*
-                 ** and re-start the sender software!
-                 */
-                if (PortP->CookMode == COOK_WELL)
-                        goto start;
-                break;
-
-        case T_TIME:
-                rio_dprintk(RIO_DEBUG_INTR, "T_TIME\n");
-                /*
-                 ** T_TIME is called when xDLY is set in oflags and
-                 ** the line discipline timeout has expired. It's
-                 ** function in life is to clear the TIMEOUT flag
-                 ** and to re-start output to the port.
-                 */
-                /*
-                 ** Fall through and re-start output
-                 */
-        case T_OUTPUT:
-              start:
-                if (PortP->MagicFlags & MAGIC_FLUSH) {
-                        PortP->MagicFlags |= MORE_OUTPUT_EYGOR;
-                        return 0;
-                }
-                RIOTxEnable((char *) PortP);
-                PortP->MagicFlags &= ~MORE_OUTPUT_EYGOR;
-                /*rio_dprint(RIO_DEBUG_INTR, PortP,DBG_PROC,"T_OUTPUT finished\n"); */
-                break;
-
-        case T_SUSPEND:
-                rio_dprintk(RIO_DEBUG_INTR, "T_SUSPEND\n");
-                /*
-                 ** send a suspend pre-emptive packet.
-                 */
-                if (PortP->State & RIO_DELETED) {
-                        rio_dprintk(RIO_DEBUG_INTR, "SUSPEND deleted RTA\n");
-                } else {
-                        if (RIOPreemptiveCmd(p, PortP, SUSPEND) == RIO_FAIL) {
-                                rio_dprintk(RIO_DEBUG_INTR, "T_SUSPEND Command failed\n");
-                        }
-                }
-                /*
-                 ** done!
-                 */
-                break;
-
-        case T_BLOCK:
-                rio_dprintk(RIO_DEBUG_INTR, "T_BLOCK\n");
-                break;
-
-        case T_RFLUSH:
-                rio_dprintk(RIO_DEBUG_INTR, "T_RFLUSH\n");
-                if (PortP->State & RIO_DELETED) {
-                        rio_dprintk(RIO_DEBUG_INTR, "RFLUSH on deleted RTA\n");
-                        PortP->RxDataStart = 0;
-                } else {
-                        if (RIOPreemptiveCmd(p, PortP, RFLUSH) == RIO_FAIL) {
-                                rio_dprintk(RIO_DEBUG_INTR, "T_RFLUSH Command failed\n");
-                                return 0;
-                        }
-                        PortP->RxDataStart = 0;
-                        while (can_remove_receive(&PacketP, PortP)) {
-                                remove_receive(PortP);
-                                ShowPacket(DBG_PROC, PacketP);
-                                put_free_end(PortP->HostP, PacketP);
-                        }
-                        if (PortP->PhbP->handshake == PHB_HANDSHAKE_SET) {
-                                /*
-                                 ** MAGIC!
-                                 */
-                                rio_dprintk(RIO_DEBUG_INTR, "Set receive handshake bit\n");
-                                PortP->PhbP->handshake |= PHB_HANDSHAKE_RESET;
-                        }
-                }
-                break;
-                /* FALLTHROUGH */
-        case T_UNBLOCK:
-                rio_dprintk(RIO_DEBUG_INTR, "T_UNBLOCK\n");
-                /*
-                 ** If there is any data to receive set a timeout to service it.
-                 */
-                RIOReceive(p, PortP);
-                break;
-
-        case T_BREAK:
-                rio_dprintk(RIO_DEBUG_INTR, "T_BREAK\n");
-                /*
-                 ** Send a break command. For Sys V
-                 ** this is a timed break, so we
-                 ** send a SBREAK[time] packet
-                 */
-                /*
-                 ** Build a BREAK command
-                 */
-                if (PortP->State & RIO_DELETED) {
-                        rio_dprintk(RIO_DEBUG_INTR, "BREAK on deleted RTA\n");
-                } else {
-                        if (RIOShortCommand(PortP, SBREAK, 2, p->RIOConf.BreakInterval) == RIO_FAIL) {
-                                rio_dprintk(RIO_DEBUG_INTR, "SBREAK RIOShortCommand failed\n");
-                        }
-                }
-
-                /*
-                 ** done!
-                 */
-                break;
-
-        case T_INPUT:
-                rio_dprintk(RIO_DEBUG_INTR, "Proc T_INPUT called - I don't know what to do!\n");
-                break;
-        case T_PARM:
-                rio_dprintk(RIO_DEBUG_INTR, "Proc T_PARM called - I don't know what to do!\n");
-                break;
-
-        case T_SWTCH:
-                rio_dprintk(RIO_DEBUG_INTR, "Proc T_SWTCH called - I don't know what to do!\n");
-                break;
-
-        default:
-                rio_dprintk(RIO_DEBUG_INTR, "Proc UNKNOWN command %d\n", cmd);
-        }
-        /*
-         ** T_OUTPUT returns without passing through this point!
-         */
-        /*rio_dprint(RIO_DEBUG_INTR, PortP,DBG_PROC,"riotproc done\n"); */
-        return (0);
-}
-#endif