[PATCH] rio driver rework continued #3

Second large chunk of code cleanup.  The split between this and #3 and #4 is
fairly arbitary and due to the message length limit on the list.  These
patches continue the process of ripping out macros and typedefs while cleaning
up lots of 32bit assumptions.  Several inlines for compatibility also get
removed and that causes a lot of noise.

Signed-off-by: Alan Cox <alan@redhat.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

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