ClabureDB: Classified Bug-Reports Database

   /*******************************************************************************
   *
   *   (c) 1999 by Computone Corporation
   *
   ********************************************************************************
   *
   *
   *   PACKAGE:     Linux tty Device Driver for IntelliPort family of multiport
   *                serial I/O controllers.
  *
  *   DESCRIPTION: High-level interface code for the device driver. Uses the
  *                Extremely Low Level Interface Support (i2ellis.c). Provides an
  *                interface to the standard loadware, to support drivers or
  *                application code. (This is included source code, not a separate
  *                compilation module.)
  *
  *******************************************************************************/
  //------------------------------------------------------------------------------
  // Note on Strategy:
  // Once the board has been initialized, it will interrupt us when:
  // 1) It has something in the fifo for us to read (incoming data, flow control
  // packets, or whatever).
  // 2) It has stripped whatever we have sent last time in the FIFO (and
  // consequently is ready for more).
  //
  // Note also that the buffer sizes declared in i2lib.h are VERY SMALL. This
  // worsens performance considerably, but is done so that a great many channels
  // might use only a little memory.
  //------------------------------------------------------------------------------
  
  //------------------------------------------------------------------------------
  // Revision History:
  //
  // 0.00 -  4/16/91 --- First Draft
  // 0.01 -  4/29/91 --- 1st beta release
  // 0.02 -  6/14/91 --- Changes to allow small model compilation
  // 0.03 -  6/17/91 MAG Break reporting protected from interrupts routines with
  //                     in-line asm added for moving data to/from ring buffers,
  //                     replacing a variety of methods used previously.
  // 0.04 -  6/21/91 MAG Initial flow-control packets not queued until
  //                     i2_enable_interrupts time. Former versions would enqueue
  //                     them at i2_init_channel time, before we knew how many
  //                     channels were supposed to exist!
  // 0.05 - 10/12/91 MAG Major changes: works through the ellis.c routines now;
  //                     supports new 16-bit protocol and expandable boards.
  //      - 10/24/91 MAG Most changes in place and stable.
  // 0.06 -  2/20/92 MAG Format of CMD_HOTACK corrected: the command takes no
  //                     argument.
  // 0.07 -- 3/11/92 MAG Support added to store special packet types at interrupt
  //                     level (mostly responses to specific commands.)
  // 0.08 -- 3/30/92 MAG Support added for STAT_MODEM packet
  // 0.09 -- 6/24/93 MAG i2Link... needed to update number of boards BEFORE
  //                     turning on the interrupt.
  // 0.10 -- 6/25/93 MAG To avoid gruesome death from a bad board, we sanity check
  //                     some incoming.
  //
  // 1.1  - 12/25/96 AKM Linux version.
  //      - 10/09/98 DMC Revised Linux version.
  //------------------------------------------------------------------------------
  
  //************
  //* Includes *
  //************
  
  #include <linux/sched.h>
  #include "i2lib.h"
  
  
  //***********************
  //* Function Prototypes *
  //***********************
  static void i2QueueNeeds(i2eBordStrPtr, i2ChanStrPtr, int);
  static i2ChanStrPtr i2DeQueueNeeds(i2eBordStrPtr, int );
  static void i2StripFifo(i2eBordStrPtr);
  static void i2StuffFifoBypass(i2eBordStrPtr);
  static void i2StuffFifoFlow(i2eBordStrPtr);
  static void i2StuffFifoInline(i2eBordStrPtr);
  static int i2RetryFlushOutput(i2ChanStrPtr);
  
  // Not a documented part of the library routines (careful...) but the Diagnostic
  // i2diag.c finds them useful to help the throughput in certain limited
  // single-threaded operations.
  static void iiSendPendingMail(i2eBordStrPtr);
  static void serviceOutgoingFifo(i2eBordStrPtr);
  
  // Functions defined in ip2.c as part of interrupt handling
  static void do_input(struct work_struct *);
  static void do_status(struct work_struct *);
  
  //***************
  //* Debug  Data *
  //***************
  #ifdef DEBUG_FIFO
  
  unsigned char DBGBuf[0x4000];
  unsigned short I = 0;
  
  static void
  WriteDBGBuf(char *s, unsigned char *src, unsigned short n ) 
 {
         char *p = src;
 
         // XXX: We need a spin lock here if we ever use this again
 
         while (*s) {        // copy label
                 DBGBuf[I] = *s++;
                 I = I++ & 0x3fff;
         }
         while (n--) {        // copy data
                 DBGBuf[I] = *p++;
                 I = I++ & 0x3fff;
         }
 }
 
 static void
 fatality(i2eBordStrPtr pB )
 {
         int i;
 
         for (i=0;i<sizeof(DBGBuf);i++) {
                 if ((i%16) == 0)
                         printk("\n%4x:",i);
                 printk("%02x ",DBGBuf[i]);
         }
         printk("\n");
         for (i=0;i<sizeof(DBGBuf);i++) {
                 if ((i%16) == 0)
                         printk("\n%4x:",i);
                 if (DBGBuf[i] >= ' ' && DBGBuf[i] <= '~') {
                         printk(" %c ",DBGBuf[i]);
                 } else {
                         printk(" . ");
                 }
         }
         printk("\n");
         printk("Last index %x\n",I);
 }
 #endif /* DEBUG_FIFO */
 
 //********
 //* Code *
 //********
 
 static inline int
 i2Validate ( i2ChanStrPtr pCh )
 {
         //ip2trace(pCh->port_index, ITRC_VERIFY,ITRC_ENTER,2,pCh->validity,
         //        (CHANNEL_MAGIC | CHANNEL_SUPPORT));
         return ((pCh->validity & (CHANNEL_MAGIC_BITS | CHANNEL_SUPPORT)) 
                           == (CHANNEL_MAGIC | CHANNEL_SUPPORT));
 }
 
 static void iiSendPendingMail_t(unsigned long data)
 {
         i2eBordStrPtr pB = (i2eBordStrPtr)data;
 
         iiSendPendingMail(pB);
 }
 
 //******************************************************************************
 // Function:   iiSendPendingMail(pB)
 // Parameters: Pointer to a board structure
 // Returns:    Nothing
 //
 // Description:
 // If any outgoing mail bits are set and there is outgoing mailbox is empty,
 // send the mail and clear the bits.
 //******************************************************************************
 static void
 iiSendPendingMail(i2eBordStrPtr pB)
 {
         if (pB->i2eOutMailWaiting && (!pB->i2eWaitingForEmptyFifo) )
         {
                 if (iiTrySendMail(pB, pB->i2eOutMailWaiting))
                 {
                         /* If we were already waiting for fifo to empty,
                          * or just sent MB_OUT_STUFFED, then we are
                          * still waiting for it to empty, until we should
                          * receive an MB_IN_STRIPPED from the board.
                          */
                         pB->i2eWaitingForEmptyFifo |=
                                 (pB->i2eOutMailWaiting & MB_OUT_STUFFED);
                         pB->i2eOutMailWaiting = 0;
                         pB->SendPendingRetry = 0;
                 } else {
 /*                The only time we hit this area is when "iiTrySendMail" has
                 failed.  That only occurs when the outbound mailbox is
                 still busy with the last message.  We take a short breather
                 to let the board catch up with itself and then try again.
                 16 Retries is the limit - then we got a borked board.
                         /\/\|=mhw=|\/\/                                */
 
                         if( ++pB->SendPendingRetry < 16 ) {
                                 setup_timer(&pB->SendPendingTimer,
                                         iiSendPendingMail_t, (unsigned long)pB);
                                 mod_timer(&pB->SendPendingTimer, jiffies + 1);
                         } else {
                                 printk( KERN_ERR "IP2: iiSendPendingMail unable to queue outbound mail\n" );
                         }
                 }
         }
 }
 
 //******************************************************************************
 // Function:   i2InitChannels(pB, nChannels, pCh)
 // Parameters: Pointer to Ellis Board structure
 //             Number of channels to initialize
 //             Pointer to first element in an array of channel structures
 // Returns:    Success or failure
 //
 // Description:
 //
 // This function patches pointers, back-pointers, and initializes all the
 // elements in the channel structure array.
 //
 // This should be run after the board structure is initialized, through having
 // loaded the standard loadware (otherwise it complains).
 //
 // In any case, it must be done before any serious work begins initializing the
 // irq's or sending commands...
 //
 //******************************************************************************
 static int
 i2InitChannels ( i2eBordStrPtr pB, int nChannels, i2ChanStrPtr pCh)
 {
         int index, stuffIndex;
         i2ChanStrPtr *ppCh;
         
         if (pB->i2eValid != I2E_MAGIC) {
                 I2_COMPLETE(pB, I2EE_BADMAGIC);
         }
         if (pB->i2eState != II_STATE_STDLOADED) {
                 I2_COMPLETE(pB, I2EE_BADSTATE);
         }
 
         rwlock_init(&pB->read_fifo_spinlock);
         rwlock_init(&pB->write_fifo_spinlock);
         rwlock_init(&pB->Dbuf_spinlock);
         rwlock_init(&pB->Bbuf_spinlock);
         rwlock_init(&pB->Fbuf_spinlock);
         
         // NO LOCK needed yet - this is init
 
         pB->i2eChannelPtr = pCh;
         pB->i2eChannelCnt = nChannels;
 
         pB->i2Fbuf_strip = pB->i2Fbuf_stuff = 0;
         pB->i2Dbuf_strip = pB->i2Dbuf_stuff = 0;
         pB->i2Bbuf_strip = pB->i2Bbuf_stuff = 0;
 
         pB->SendPendingRetry = 0;
 
         memset ( pCh, 0, sizeof (i2ChanStr) * nChannels );
 
         for (index = stuffIndex = 0, ppCh = (i2ChanStrPtr *)(pB->i2Fbuf);
                   nChannels && index < ABS_MOST_PORTS;
                   index++)
         {
                 if ( !(pB->i2eChannelMap[index >> 4] & (1 << (index & 0xf)) ) ) {
                         continue;
                 }
                 rwlock_init(&pCh->Ibuf_spinlock);
                 rwlock_init(&pCh->Obuf_spinlock);
                 rwlock_init(&pCh->Cbuf_spinlock);
                 rwlock_init(&pCh->Pbuf_spinlock);
                 // NO LOCK needed yet - this is init
                 // Set up validity flag according to support level
                 if (pB->i2eGoodMap[index >> 4] & (1 << (index & 0xf)) ) {
                         pCh->validity = CHANNEL_MAGIC | CHANNEL_SUPPORT;
                 } else {
                         pCh->validity = CHANNEL_MAGIC;
                 }
                 pCh->pMyBord = pB;      /* Back-pointer */
 
                 // Prepare an outgoing flow-control packet to send as soon as the chance
                 // occurs.
                 if ( pCh->validity & CHANNEL_SUPPORT ) {
                         pCh->infl.hd.i2sChannel = index;
                         pCh->infl.hd.i2sCount = 5;
                         pCh->infl.hd.i2sType = PTYPE_BYPASS;
                         pCh->infl.fcmd = 37;
                         pCh->infl.asof = 0;
                         pCh->infl.room = IBUF_SIZE - 1;
 
                         pCh->whenSendFlow = (IBUF_SIZE/5)*4; // when 80% full
 
                 // The following is similar to calling i2QueueNeeds, except that this
                 // is done in longhand, since we are setting up initial conditions on
                 // many channels at once.
                         pCh->channelNeeds = NEED_FLOW;  // Since starting from scratch
                         pCh->sinceLastFlow = 0;         // No bytes received since last flow
                                                                                         // control packet was queued
                         stuffIndex++;
                         *ppCh++ = pCh;      // List this channel as needing
                                                                 // initial flow control packet sent
                 }
 
                 // Don't allow anything to be sent until the status packets come in from
                 // the board.
 
                 pCh->outfl.asof = 0;
                 pCh->outfl.room = 0;
 
                 // Initialize all the ring buffers
 
                 pCh->Ibuf_stuff = pCh->Ibuf_strip = 0;
                 pCh->Obuf_stuff = pCh->Obuf_strip = 0;
                 pCh->Cbuf_stuff = pCh->Cbuf_strip = 0;
 
                 memset( &pCh->icount, 0, sizeof (struct async_icount) );
                 pCh->hotKeyIn       = HOT_CLEAR;
                 pCh->channelOptions = 0;
                 pCh->bookMarks      = 0;
                 init_waitqueue_head(&pCh->pBookmarkWait);
 
                 init_waitqueue_head(&pCh->open_wait);
                 init_waitqueue_head(&pCh->close_wait);
                 init_waitqueue_head(&pCh->delta_msr_wait);
 
                 // Set base and divisor so default custom rate is 9600
                 pCh->BaudBase    = 921600;        // MAX for ST654, changed after we get
                 pCh->BaudDivisor = 96;                // the boxids (UART types) later
 
                 pCh->dataSetIn   = 0;
                 pCh->dataSetOut  = 0;
 
                 pCh->wopen       = 0;
                 pCh->throttled   = 0;
 
                 pCh->speed       = CBR_9600;
 
                 pCh->flags    = 0;
 
                 pCh->ClosingDelay     = 5*HZ/10;
                 pCh->ClosingWaitTime  = 30*HZ;
 
                 // Initialize task queue objects
                 INIT_WORK(&pCh->tqueue_input, do_input);
                 INIT_WORK(&pCh->tqueue_status, do_status);
 
 #ifdef IP2DEBUG_TRACE
                 pCh->trace = ip2trace;
 #endif
 
                 ++pCh;
              --nChannels;
         }
         // No need to check for wrap here; this is initialization.
         pB->i2Fbuf_stuff = stuffIndex;
         I2_COMPLETE(pB, I2EE_GOOD);
 
 }
 
 //******************************************************************************
 // Function:   i2DeQueueNeeds(pB, type)
 // Parameters: Pointer to a board structure
 //             type bit map: may include NEED_INLINE, NEED_BYPASS, or NEED_FLOW
 // Returns:   
 //             Pointer to a channel structure
 //
 // Description: Returns pointer struct of next channel that needs service of
 //  the type specified. Otherwise returns a NULL reference.
 //
 //******************************************************************************
 static i2ChanStrPtr 
 i2DeQueueNeeds(i2eBordStrPtr pB, int type)
 {
         unsigned short queueIndex;
         unsigned long flags;
 
         i2ChanStrPtr pCh = NULL;
 
         switch(type) {
 
         case  NEED_INLINE:
 
                 write_lock_irqsave(&pB->Dbuf_spinlock, flags);
                 if ( pB->i2Dbuf_stuff != pB->i2Dbuf_strip)
                 {
                         queueIndex = pB->i2Dbuf_strip;
                         pCh = pB->i2Dbuf[queueIndex];
                         queueIndex++;
                         if (queueIndex >= CH_QUEUE_SIZE) {
                                 queueIndex = 0;
                         }
                         pB->i2Dbuf_strip = queueIndex;
                         pCh->channelNeeds &= ~NEED_INLINE;
                 }
                 write_unlock_irqrestore(&pB->Dbuf_spinlock, flags);
                 break;
 
         case NEED_BYPASS:
 
                 write_lock_irqsave(&pB->Bbuf_spinlock, flags);
                 if (pB->i2Bbuf_stuff != pB->i2Bbuf_strip)
                 {
                         queueIndex = pB->i2Bbuf_strip;
                         pCh = pB->i2Bbuf[queueIndex];
                         queueIndex++;
                         if (queueIndex >= CH_QUEUE_SIZE) {
                                 queueIndex = 0;
                         }
                         pB->i2Bbuf_strip = queueIndex;
                         pCh->channelNeeds &= ~NEED_BYPASS;
                 }
                 write_unlock_irqrestore(&pB->Bbuf_spinlock, flags);
                 break;
         
         case NEED_FLOW:
 
                 write_lock_irqsave(&pB->Fbuf_spinlock, flags);
                 if (pB->i2Fbuf_stuff != pB->i2Fbuf_strip)
                 {
                         queueIndex = pB->i2Fbuf_strip;
                         pCh = pB->i2Fbuf[queueIndex];
                         queueIndex++;
                         if (queueIndex >= CH_QUEUE_SIZE) {
                                 queueIndex = 0;
                         }
                         pB->i2Fbuf_strip = queueIndex;
                         pCh->channelNeeds &= ~NEED_FLOW;
                 }
                 write_unlock_irqrestore(&pB->Fbuf_spinlock, flags);
                 break;
         default:
                 printk(KERN_ERR "i2DeQueueNeeds called with bad type:%x\n",type);
                 break;
         }
         return pCh;
 }
 
 //******************************************************************************
 // Function:   i2QueueNeeds(pB, pCh, type)
 // Parameters: Pointer to a board structure
 //             Pointer to a channel structure
 //             type bit map: may include NEED_INLINE, NEED_BYPASS, or NEED_FLOW
 // Returns:    Nothing
 //
 // Description:
 // For each type of need selected, if the given channel is not already in the
 // queue, adds it, and sets the flag indicating it is in the queue.
 //******************************************************************************
 static void
 i2QueueNeeds(i2eBordStrPtr pB, i2ChanStrPtr pCh, int type)
 {
         unsigned short queueIndex;
         unsigned long flags;
 
         // We turn off all the interrupts during this brief process, since the
         // interrupt-level code might want to put things on the queue as well.
 
         switch (type) {
 
         case NEED_INLINE:
 
                 write_lock_irqsave(&pB->Dbuf_spinlock, flags);
                 if ( !(pCh->channelNeeds & NEED_INLINE) )
                 {
                         pCh->channelNeeds |= NEED_INLINE;
                         queueIndex = pB->i2Dbuf_stuff;
                         pB->i2Dbuf[queueIndex++] = pCh;
                         if (queueIndex >= CH_QUEUE_SIZE)
                                 queueIndex = 0;
                         pB->i2Dbuf_stuff = queueIndex;
                 }
                 write_unlock_irqrestore(&pB->Dbuf_spinlock, flags);
                 break;
 
         case NEED_BYPASS:
 
                 write_lock_irqsave(&pB->Bbuf_spinlock, flags);
                 if ((type & NEED_BYPASS) && !(pCh->channelNeeds & NEED_BYPASS))
                 {
                         pCh->channelNeeds |= NEED_BYPASS;
                         queueIndex = pB->i2Bbuf_stuff;
                         pB->i2Bbuf[queueIndex++] = pCh;
                         if (queueIndex >= CH_QUEUE_SIZE)
                                 queueIndex = 0;
                         pB->i2Bbuf_stuff = queueIndex;
                 } 
                 write_unlock_irqrestore(&pB->Bbuf_spinlock, flags);
                 break;
 
         case NEED_FLOW:
 
                 write_lock_irqsave(&pB->Fbuf_spinlock, flags);
                 if ((type & NEED_FLOW) && !(pCh->channelNeeds & NEED_FLOW))
                 {
                         pCh->channelNeeds |= NEED_FLOW;
                         queueIndex = pB->i2Fbuf_stuff;
                         pB->i2Fbuf[queueIndex++] = pCh;
                         if (queueIndex >= CH_QUEUE_SIZE)
                                 queueIndex = 0;
                         pB->i2Fbuf_stuff = queueIndex;
                 }
                 write_unlock_irqrestore(&pB->Fbuf_spinlock, flags);
                 break;
 
         case NEED_CREDIT:
                 pCh->channelNeeds |= NEED_CREDIT;
                 break;
         default:
                 printk(KERN_ERR "i2QueueNeeds called with bad type:%x\n",type);
                 break;
         }
         return;
 }
 
 //******************************************************************************
 // Function:   i2QueueCommands(type, pCh, timeout, nCommands, pCs,...)
 // Parameters: type - PTYPE_BYPASS or PTYPE_INLINE
 //             pointer to the channel structure
 //             maximum period to wait
 //             number of commands (n)
 //             n commands
 // Returns:    Number of commands sent, or -1 for error
 //
 // get board lock before calling
 //
 // Description:
 // Queues up some commands to be sent to a channel. To send possibly several
 // bypass or inline commands to the given channel. The timeout parameter
 // indicates how many HUNDREDTHS OF SECONDS to wait until there is room:
 // 0 = return immediately if no room, -ive  = wait forever, +ive = number of
 // 1/100 seconds to wait. Return values:
 // -1 Some kind of nasty error: bad channel structure or invalid arguments.
 //  0 No room to send all the commands
 // (+)   Number of commands sent
 //******************************************************************************
 static int
 i2QueueCommands(int type, i2ChanStrPtr pCh, int timeout, int nCommands,
                                          cmdSyntaxPtr pCs0,...)
 {
         int totalsize = 0;
         int blocksize;
         int lastended;
         cmdSyntaxPtr *ppCs;
         cmdSyntaxPtr pCs;
         int count;
         int flag;
         i2eBordStrPtr pB;
 
         unsigned short maxBlock;
         unsigned short maxBuff;
         short bufroom;
         unsigned short stuffIndex;
         unsigned char *pBuf;
         unsigned char *pInsert;
         unsigned char *pDest, *pSource;
         unsigned short channel;
         int cnt;
         unsigned long flags = 0;
         rwlock_t *lock_var_p = NULL;
 
         // Make sure the channel exists, otherwise do nothing
         if ( !i2Validate ( pCh ) ) {
                 return -1;
         }
 
         ip2trace (CHANN, ITRC_QUEUE, ITRC_ENTER, 0 );
 
         pB = pCh->pMyBord;
 
         // Board must also exist, and THE INTERRUPT COMMAND ALREADY SENT
         if (pB->i2eValid != I2E_MAGIC || pB->i2eUsingIrq == I2_IRQ_UNDEFINED)
                 return -2;
         // If the board has gone fatal, return bad, and also hit the trap routine if
         // it exists.
         if (pB->i2eFatal) {
                 if ( pB->i2eFatalTrap ) {
                         (*(pB)->i2eFatalTrap)(pB);
                 }
                 return -3;
         }
         // Set up some variables, Which buffers are we using?  How big are they?
         switch(type)
         {
         case PTYPE_INLINE:
                 flag = INL;
                 maxBlock = MAX_OBUF_BLOCK;
                 maxBuff = OBUF_SIZE;
                 pBuf = pCh->Obuf;
                 break;
         case PTYPE_BYPASS:
                 flag = BYP;
                 maxBlock = MAX_CBUF_BLOCK;
                 maxBuff = CBUF_SIZE;
                 pBuf = pCh->Cbuf;
                 break;
         default:
                 return -4;
         }
         // Determine the total size required for all the commands
         totalsize = blocksize = sizeof(i2CmdHeader);
         lastended = 0;
         ppCs = &pCs0;
         for ( count = nCommands; count; count--, ppCs++)
         {
                 pCs = *ppCs;
                 cnt = pCs->length;
                 // Will a new block be needed for this one? 
                 // Two possible reasons: too
                 // big or previous command has to be at the end of a packet.
                 if ((blocksize + cnt > maxBlock) || lastended) {
                         blocksize = sizeof(i2CmdHeader);
                         totalsize += sizeof(i2CmdHeader);
                 }
                 totalsize += cnt;
                 blocksize += cnt;
 
                 // If this command had to end a block, then we will make sure to
                 // account for it should there be any more blocks.
                 lastended = pCs->flags & END;
         }
         for (;;) {
                 // Make sure any pending flush commands go out before we add more data.
                 if ( !( pCh->flush_flags && i2RetryFlushOutput( pCh ) ) ) {
                         // How much room (this time through) ?
                         switch(type) {
                         case PTYPE_INLINE:
                                 lock_var_p = &pCh->Obuf_spinlock;
                                 write_lock_irqsave(lock_var_p, flags);
                                 stuffIndex = pCh->Obuf_stuff;
                                 bufroom = pCh->Obuf_strip - stuffIndex;
                                 break;
                         case PTYPE_BYPASS:
                                 lock_var_p = &pCh->Cbuf_spinlock;
                                 write_lock_irqsave(lock_var_p, flags);
                                 stuffIndex = pCh->Cbuf_stuff;
                                 bufroom = pCh->Cbuf_strip - stuffIndex;
                                 break;
                         default:
                                 return -5;
                         }
                         if (--bufroom < 0) {
                                 bufroom += maxBuff;
                         }
 
                         ip2trace (CHANN, ITRC_QUEUE, 2, 1, bufroom );
 
                         // Check for overflow
                         if (totalsize <= bufroom) {
                                 // Normal Expected path - We still hold LOCK
                                 break; /* from for()- Enough room: goto proceed */
                         }
                         ip2trace(CHANN, ITRC_QUEUE, 3, 1, totalsize);
                         write_unlock_irqrestore(lock_var_p, flags);
                 } else
                         ip2trace(CHANN, ITRC_QUEUE, 3, 1, totalsize);
 
                 /* Prepare to wait for buffers to empty */
                 serviceOutgoingFifo(pB);        // Dump what we got
 
                 if (timeout == 0) {
                         return 0;   // Tired of waiting
                 }
                 if (timeout > 0)
                         timeout--;   // So negative values == forever
                 
                 if (!in_interrupt()) {
                         schedule_timeout_interruptible(1);        // short nap
                 } else {
                         // we cannot sched/sleep in interrupt silly
                         return 0;   
                 }
                 if (signal_pending(current)) {
                         return 0;   // Wake up! Time to die!!!
                 }
 
                 ip2trace (CHANN, ITRC_QUEUE, 4, 0 );
 
         }        // end of for(;;)
 
         // At this point we have room and the lock - stick them in.
         channel = pCh->infl.hd.i2sChannel;
         pInsert = &pBuf[stuffIndex];     // Pointer to start of packet
         pDest = CMD_OF(pInsert);         // Pointer to start of command
 
         // When we start counting, the block is the size of the header
         for (blocksize = sizeof(i2CmdHeader), count = nCommands,
                         lastended = 0, ppCs = &pCs0;
                 count;
                 count--, ppCs++)
         {
                 pCs = *ppCs;         // Points to command protocol structure
 
                 // If this is a bookmark request command, post the fact that a bookmark
                 // request is pending. NOTE THIS TRICK ONLY WORKS BECAUSE CMD_BMARK_REQ
                 // has no parameters!  The more general solution would be to reference
                 // pCs->cmd[0].
                 if (pCs == CMD_BMARK_REQ) {
                         pCh->bookMarks++;
 
                         ip2trace (CHANN, ITRC_DRAIN, 30, 1, pCh->bookMarks );
 
                 }
                 cnt = pCs->length;
 
                 // If this command would put us over the maximum block size or 
                 // if the last command had to be at the end of a block, we end
                 // the existing block here and start a new one.
                 if ((blocksize + cnt > maxBlock) || lastended) {
 
                         ip2trace (CHANN, ITRC_QUEUE, 5, 0 );
 
                         PTYPE_OF(pInsert) = type;
                         CHANNEL_OF(pInsert) = channel;
                         // count here does not include the header
                         CMD_COUNT_OF(pInsert) = blocksize - sizeof(i2CmdHeader);
                         stuffIndex += blocksize;
                         if(stuffIndex >= maxBuff) {
                                 stuffIndex = 0;
                                 pInsert = pBuf;
                         }
                         pInsert = &pBuf[stuffIndex];  // Pointer to start of next pkt
                         pDest = CMD_OF(pInsert);
                         blocksize = sizeof(i2CmdHeader);
                 }
                 // Now we know there is room for this one in the current block
 
                 blocksize += cnt;       // Total bytes in this command
                 pSource = pCs->cmd;     // Copy the command into the buffer
                 while (cnt--) {
                         *pDest++ = *pSource++;
                 }
                 // If this command had to end a block, then we will make sure to account
                 // for it should there be any more blocks.
                 lastended = pCs->flags & END;
         }        // end for
         // Clean up the final block by writing header, etc
 
         PTYPE_OF(pInsert) = type;
         CHANNEL_OF(pInsert) = channel;
         // count here does not include the header
         CMD_COUNT_OF(pInsert) = blocksize - sizeof(i2CmdHeader);
         stuffIndex += blocksize;
         if(stuffIndex >= maxBuff) {
                 stuffIndex = 0;
                 pInsert = pBuf;
         }
         // Updates the index, and post the need for service. When adding these to
         // the queue of channels, we turn off the interrupt while doing so,
         // because at interrupt level we might want to push a channel back to the
         // end of the queue.
         switch(type)
         {
         case PTYPE_INLINE:
                 pCh->Obuf_stuff = stuffIndex;  // Store buffer pointer
                 write_unlock_irqrestore(&pCh->Obuf_spinlock, flags);
 
                 pB->debugInlineQueued++;
                 // Add the channel pointer to list of channels needing service (first
                 // come...), if it's not already there.
                 i2QueueNeeds(pB, pCh, NEED_INLINE);
                 break;
 
         case PTYPE_BYPASS:
                 pCh->Cbuf_stuff = stuffIndex;  // Store buffer pointer
                 write_unlock_irqrestore(&pCh->Cbuf_spinlock, flags);
 
                 pB->debugBypassQueued++;
                 // Add the channel pointer to list of channels needing service (first
                 // come...), if it's not already there.
                 i2QueueNeeds(pB, pCh, NEED_BYPASS);
                 break;
         }
 
         ip2trace (CHANN, ITRC_QUEUE, ITRC_RETURN, 1, nCommands );
 
         return nCommands; // Good status: number of commands sent
 }
 
 //******************************************************************************
 // Function:   i2GetStatus(pCh,resetBits)
 // Parameters: Pointer to a channel structure
 //             Bit map of status bits to clear
 // Returns:    Bit map of current status bits
 //
 // Description:
 // Returns the state of data set signals, and whether a break has been received,
 // (see i2lib.h for bit-mapped result). resetBits is a bit-map of any status
 // bits to be cleared: I2_BRK, I2_PAR, I2_FRA, I2_OVR,... These are cleared
 // AFTER the condition is passed. If pCh does not point to a valid channel,
 // returns -1 (which would be impossible otherwise.
 //******************************************************************************
 static int
 i2GetStatus(i2ChanStrPtr pCh, int resetBits)
 {
         unsigned short status;
         i2eBordStrPtr pB;
 
         ip2trace (CHANN, ITRC_STATUS, ITRC_ENTER, 2, pCh->dataSetIn, resetBits );
 
         // Make sure the channel exists, otherwise do nothing */
         if ( !i2Validate ( pCh ) )
                 return -1;
 
         pB = pCh->pMyBord;
 
         status = pCh->dataSetIn;
 
         // Clear any specified error bits: but note that only actual error bits can
         // be cleared, regardless of the value passed.
         if (resetBits)
         {
                 pCh->dataSetIn &= ~(resetBits & (I2_BRK | I2_PAR | I2_FRA | I2_OVR));
                 pCh->dataSetIn &= ~(I2_DDCD | I2_DCTS | I2_DDSR | I2_DRI);
         }
 
         ip2trace (CHANN, ITRC_STATUS, ITRC_RETURN, 1, pCh->dataSetIn );
 
         return status;
 }
 
 //******************************************************************************
 // Function:   i2Input(pChpDest,count)
 // Parameters: Pointer to a channel structure
 //             Pointer to data buffer
 //             Number of bytes to read
 // Returns:    Number of bytes read, or -1 for error
 //
 // Description:
 // Strips data from the input buffer and writes it to pDest. If there is a
 // collosal blunder, (invalid structure pointers or the like), returns -1.
 // Otherwise, returns the number of bytes read.
 //******************************************************************************
 static int
 i2Input(i2ChanStrPtr pCh)
 {
         int amountToMove;
         unsigned short stripIndex;
         int count;
         unsigned long flags = 0;
 
         ip2trace (CHANN, ITRC_INPUT, ITRC_ENTER, 0);
 
         // Ensure channel structure seems real
         if ( !i2Validate( pCh ) ) {
                 count = -1;
                 goto i2Input_exit;
         }
         write_lock_irqsave(&pCh->Ibuf_spinlock, flags);
 
         // initialize some accelerators and private copies
         stripIndex = pCh->Ibuf_strip;
 
         count = pCh->Ibuf_stuff - stripIndex;
 
         // If buffer is empty or requested data count was 0, (trivial case) return
         // without any further thought.
         if ( count == 0 ) {
                 write_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
                 goto i2Input_exit;
         }
         // Adjust for buffer wrap
         if ( count < 0 ) {
                 count += IBUF_SIZE;
         }
         // Don't give more than can be taken by the line discipline
         amountToMove = pCh->pTTY->receive_room;
         if (count > amountToMove) {
                 count = amountToMove;
         }
         // How much could we copy without a wrap?
         amountToMove = IBUF_SIZE - stripIndex;
 
         if (amountToMove > count) {
                 amountToMove = count;
         }
         // Move the first block
         pCh->pTTY->ldisc.ops->receive_buf( pCh->pTTY,
                  &(pCh->Ibuf[stripIndex]), NULL, amountToMove );
         // If we needed to wrap, do the second data move
         if (count > amountToMove) {
                 pCh->pTTY->ldisc.ops->receive_buf( pCh->pTTY,
                  pCh->Ibuf, NULL, count - amountToMove );
         }
         // Bump and wrap the stripIndex all at once by the amount of data read. This
         // method is good regardless of whether the data was in one or two pieces.
         stripIndex += count;
         if (stripIndex >= IBUF_SIZE) {
                 stripIndex -= IBUF_SIZE;
         }
         pCh->Ibuf_strip = stripIndex;
 
         // Update our flow control information and possibly queue ourselves to send
         // it, depending on how much data has been stripped since the last time a
         // packet was sent.
         pCh->infl.asof += count;
 
         if ((pCh->sinceLastFlow += count) >= pCh->whenSendFlow) {
                 pCh->sinceLastFlow -= pCh->whenSendFlow;
                 write_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
                 i2QueueNeeds(pCh->pMyBord, pCh, NEED_FLOW);
         } else {
                 write_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
         }
 
 i2Input_exit:
 
         ip2trace (CHANN, ITRC_INPUT, ITRC_RETURN, 1, count);
 
         return count;
 }
 
 //******************************************************************************
 // Function:   i2InputFlush(pCh)
 // Parameters: Pointer to a channel structure
 // Returns:    Number of bytes stripped, or -1 for error
 //
 // Description:
 // Strips any data from the input buffer. If there is a collosal blunder,
 // (invalid structure pointers or the like), returns -1. Otherwise, returns the
 // number of bytes stripped.
 //******************************************************************************
 static int
 i2InputFlush(i2ChanStrPtr pCh)
 {
         int count;
         unsigned long flags;
 
         // Ensure channel structure seems real
         if ( !i2Validate ( pCh ) )
                 return -1;
 
         ip2trace (CHANN, ITRC_INPUT, 10, 0);
 
         write_lock_irqsave(&pCh->Ibuf_spinlock, flags);
         count = pCh->Ibuf_stuff - pCh->Ibuf_strip;
 
         // Adjust for buffer wrap
         if (count < 0) {
                 count += IBUF_SIZE;
         }
 
         // Expedient way to zero out the buffer
         pCh->Ibuf_strip = pCh->Ibuf_stuff;
 
 
         // Update our flow control information and possibly queue ourselves to send
         // it, depending on how much data has been stripped since the last time a
         // packet was sent.
 
         pCh->infl.asof += count;
 
         if ( (pCh->sinceLastFlow += count) >= pCh->whenSendFlow )
         {
                 pCh->sinceLastFlow -= pCh->whenSendFlow;
                 write_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
                 i2QueueNeeds(pCh->pMyBord, pCh, NEED_FLOW);
         } else {
                 write_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
         }
 
         ip2trace (CHANN, ITRC_INPUT, 19, 1, count);
 
         return count;
 }
 
 //******************************************************************************
 // Function:   i2InputAvailable(pCh)
 // Parameters: Pointer to a channel structure
 // Returns:    Number of bytes available, or -1 for error
 //
 // Description:
 // If there is a collosal blunder, (invalid structure pointers or the like),
 // returns -1. Otherwise, returns the number of bytes stripped. Otherwise,
 // returns the number of bytes available in the buffer.
 //******************************************************************************
 #if 0
 static int
 i2InputAvailable(i2ChanStrPtr pCh)
 {
         int count;
 
         // Ensure channel structure seems real
         if ( !i2Validate ( pCh ) ) return -1;
 
 
         // initialize some accelerators and private copies
         read_lock_irqsave(&pCh->Ibuf_spinlock, flags);
         count = pCh->Ibuf_stuff - pCh->Ibuf_strip;
         read_unlock_irqrestore(&pCh->Ibuf_spinlock, flags);
 
         // Adjust for buffer wrap
         if (count < 0)
         {
                 count += IBUF_SIZE;
         }
 
         return count;
 }
 #endif 
 
 //******************************************************************************
 // Function:   i2Output(pCh, pSource, count)
 // Parameters: Pointer to channel structure
 //             Pointer to source data
 //             Number of bytes to send
// Returns:    Number of bytes sent, or -1 for error
//
// Description:
// Queues the data at pSource to be sent as data packets to the board. If there
// is a collosal blunder, (invalid structure pointers or the like), returns -1.
// Otherwise, returns the number of bytes written. What if there is not enough
// room for all the data? If pCh->channelOptions & CO_NBLOCK_WRITE is set, then
// we transfer as many characters as we can now, then return. If this bit is
// clear (default), routine will spin along until all the data is buffered.
// Should this occur, the 1-ms delay routine is called while waiting to avoid
// applications that one cannot break out of.
//******************************************************************************
static int
i2Output(i2ChanStrPtr pCh, const char *pSource, int count)
{
        i2eBordStrPtr pB;
        unsigned char *pInsert;
        int amountToMove;
        int countOriginal = count;
        unsigned short channel;
        unsigned short stuffIndex;
        unsigned long flags;

        int bailout = 10;

        ip2trace (CHANN, ITRC_OUTPUT, ITRC_ENTER, 2, count, 0 );

        // Ensure channel structure seems real
        if ( !i2Validate ( pCh ) ) 
                return -1;

        // initialize some accelerators and private copies
        pB = pCh->pMyBord;
        channel = pCh->infl.hd.i2sChannel;

        // If the board has gone fatal, return bad, and also hit the trap routine if
        // it exists.
        if (pB->i2eFatal) {
                if (pB->i2eFatalTrap) {
                        (*(pB)->i2eFatalTrap)(pB);
                }
                return -1;
        }
        // Proceed as though we would do everything
        while ( count > 0 ) {

                // How much room in output buffer is there?
                read_lock_irqsave(&pCh->Obuf_spinlock, flags);
                amountToMove = pCh->Obuf_strip - pCh->Obuf_stuff - 1;
                read_unlock_irqrestore(&pCh->Obuf_spinlock, flags);
                if (amountToMove < 0) {
                        amountToMove += OBUF_SIZE;
                }
                // Subtract off the headers size and see how much room there is for real
                // data. If this is negative, we will discover later.
                amountToMove -= sizeof (i2DataHeader);

                // Don't move more (now) than can go in a single packet
                if ( amountToMove > (int)(MAX_OBUF_BLOCK - sizeof(i2DataHeader)) ) {
                        amountToMove = MAX_OBUF_BLOCK - sizeof(i2DataHeader);
                }
                // Don't move more than the count we were given
                if (amountToMove > count) {
                        amountToMove = count;
                }
                // Now we know how much we must move: NB because the ring buffers have
                // an overflow area at the end, we needn't worry about wrapping in the
                // middle of a packet.

// Small WINDOW here with no LOCK but I can't call Flush with LOCK
// We would be flushing (or ending flush) anyway

                ip2trace (CHANN, ITRC_OUTPUT, 10, 1, amountToMove );

                if ( !(pCh->flush_flags && i2RetryFlushOutput(pCh) ) 
                                && amountToMove > 0 )
                {
                        write_lock_irqsave(&pCh->Obuf_spinlock, flags);
                        stuffIndex = pCh->Obuf_stuff;
      
                        // Had room to move some data: don't know whether the block size,
                        // buffer space, or what was the limiting factor...
                        pInsert = &(pCh->Obuf[stuffIndex]);

                        // Set up the header
                        CHANNEL_OF(pInsert)     = channel;
                        PTYPE_OF(pInsert)       = PTYPE_DATA;
                        TAG_OF(pInsert)         = 0;
                        ID_OF(pInsert)          = ID_ORDINARY_DATA;
                        DATA_COUNT_OF(pInsert)  = amountToMove;

                        // Move the data
                        memcpy( (char*)(DATA_OF(pInsert)), pSource, amountToMove );
                        // Adjust pointers and indices
                        pSource                                        += amountToMove;
                        pCh->Obuf_char_count        += amountToMove;
                        stuffIndex                                 += amountToMove + sizeof(i2DataHeader);
                        count                                         -= amountToMove;

                        if (stuffIndex >= OBUF_SIZE) {
                                stuffIndex = 0;
                        }
                        pCh->Obuf_stuff = stuffIndex;

                        write_unlock_irqrestore(&pCh->Obuf_spinlock, flags);

                        ip2trace (CHANN, ITRC_OUTPUT, 13, 1, stuffIndex );

                } else {

                        // Cannot move data
                        // becuz we need to stuff a flush 
                        // or amount to move is <= 0

                        ip2trace(CHANN, ITRC_OUTPUT, 14, 3,
                                amountToMove,  pB->i2eFifoRemains,
                                pB->i2eWaitingForEmptyFifo );

                        // Put this channel back on queue
                        // this ultimatly gets more data or wakes write output
                        i2QueueNeeds(pB, pCh, NEED_INLINE);

                        if ( pB->i2eWaitingForEmptyFifo ) {

                                ip2trace (CHANN, ITRC_OUTPUT, 16, 0 );

                                // or schedule
                                if (!in_interrupt()) {

                                        ip2trace (CHANN, ITRC_OUTPUT, 61, 0 );

                                        schedule_timeout_interruptible(2);
                                        if (signal_pending(current)) {
                                                break;
                                        }
                                        continue;
                                } else {

                                        ip2trace (CHANN, ITRC_OUTPUT, 62, 0 );

                                        // let interrupt in = WAS restore_flags()
                                        // We hold no lock nor is irq off anymore???
                                        
                                        break;
                                }
                                break;   // from while(count)
                        }
                        else if ( pB->i2eFifoRemains < 32 && !pB->i2eTxMailEmpty ( pB ) )
                        {
                                ip2trace (CHANN, ITRC_OUTPUT, 19, 2,
                                        pB->i2eFifoRemains,
                                        pB->i2eTxMailEmpty );

                                break;   // from while(count)
                        } else if ( pCh->channelNeeds & NEED_CREDIT ) {

                                ip2trace (CHANN, ITRC_OUTPUT, 22, 0 );

                                break;   // from while(count)
                        } else if ( --bailout) {

                                // Try to throw more things (maybe not us) in the fifo if we're
                                // not already waiting for it.
        
                                ip2trace (CHANN, ITRC_OUTPUT, 20, 0 );

                                serviceOutgoingFifo(pB);
                                //break;  CONTINUE;
                        } else {
                                ip2trace (CHANN, ITRC_OUTPUT, 21, 3,
                                        pB->i2eFifoRemains,
                                        pB->i2eOutMailWaiting,
                                        pB->i2eWaitingForEmptyFifo );

                                break;   // from while(count)
                        }
                }
        } // End of while(count)

        i2QueueNeeds(pB, pCh, NEED_INLINE);

        // We drop through either when the count expires, or when there is some
        // count left, but there was a non-blocking write.
        if (countOriginal > count) {

                ip2trace (CHANN, ITRC_OUTPUT, 17, 2, countOriginal, count );

                serviceOutgoingFifo( pB );
        }

        ip2trace (CHANN, ITRC_OUTPUT, ITRC_RETURN, 2, countOriginal, count );

        return countOriginal - count;
}

//******************************************************************************
// Function:   i2FlushOutput(pCh)
// Parameters: Pointer to a channel structure
// Returns:    Nothing
//
// Description:
// Sends bypass command to start flushing (waiting possibly forever until there
// is room), then sends inline command to stop flushing output, (again waiting
// possibly forever).
//******************************************************************************
static inline void
i2FlushOutput(i2ChanStrPtr pCh)
{

        ip2trace (CHANN, ITRC_FLUSH, 1, 1, pCh->flush_flags );

        if (pCh->flush_flags)
                return;

        if ( 1 != i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_STARTFL) ) {
                pCh->flush_flags = STARTFL_FLAG;                // Failed - flag for later

                ip2trace (CHANN, ITRC_FLUSH, 2, 0 );

        } else if ( 1 != i2QueueCommands(PTYPE_INLINE, pCh, 0, 1, CMD_STOPFL) ) {
                pCh->flush_flags = STOPFL_FLAG;                // Failed - flag for later

                ip2trace (CHANN, ITRC_FLUSH, 3, 0 );
        }
}

static int 
i2RetryFlushOutput(i2ChanStrPtr pCh)
{
        int old_flags = pCh->flush_flags;

        ip2trace (CHANN, ITRC_FLUSH, 14, 1, old_flags );

        pCh->flush_flags = 0;        // Clear flag so we can avoid recursion
                                                                        // and queue the commands

        if ( old_flags & STARTFL_FLAG ) {
                if ( 1 == i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_STARTFL) ) {
                        old_flags = STOPFL_FLAG;        //Success - send stop flush
                } else {
                        old_flags = STARTFL_FLAG;        //Failure - Flag for retry later
                }

                ip2trace (CHANN, ITRC_FLUSH, 15, 1, old_flags );

        }
        if ( old_flags & STOPFL_FLAG ) {
                if (1 == i2QueueCommands(PTYPE_INLINE, pCh, 0, 1, CMD_STOPFL)) {
                        old_flags = 0;        // Success - clear flags
                }

                ip2trace (CHANN, ITRC_FLUSH, 16, 1, old_flags );
        }
        pCh->flush_flags = old_flags;

        ip2trace (CHANN, ITRC_FLUSH, 17, 1, old_flags );

        return old_flags;
}

//******************************************************************************
// Function:   i2DrainOutput(pCh,timeout)
// Parameters: Pointer to a channel structure
//             Maximum period to wait
// Returns:    ?
//
// Description:
// Uses the bookmark request command to ask the board to send a bookmark back as
// soon as all the data is completely sent.
//******************************************************************************
static void
i2DrainWakeup(unsigned long d)
{
        i2ChanStrPtr pCh = (i2ChanStrPtr)d;

        ip2trace (CHANN, ITRC_DRAIN, 10, 1, pCh->BookmarkTimer.expires );

        pCh->BookmarkTimer.expires = 0;
        wake_up_interruptible( &pCh->pBookmarkWait );
}

static void
i2DrainOutput(i2ChanStrPtr pCh, int timeout)
{
        wait_queue_t wait;
        i2eBordStrPtr pB;

        ip2trace (CHANN, ITRC_DRAIN, ITRC_ENTER, 1, pCh->BookmarkTimer.expires);

        pB = pCh->pMyBord;
        // If the board has gone fatal, return bad, 
        // and also hit the trap routine if it exists.
        if (pB->i2eFatal) {
                if (pB->i2eFatalTrap) {
                        (*(pB)->i2eFatalTrap)(pB);
                }
                return;
        }
        if ((timeout > 0) && (pCh->BookmarkTimer.expires == 0 )) {
                // One per customer (channel)
                setup_timer(&pCh->BookmarkTimer, i2DrainWakeup,
                                (unsigned long)pCh);

                ip2trace (CHANN, ITRC_DRAIN, 1, 1, pCh->BookmarkTimer.expires );

                mod_timer(&pCh->BookmarkTimer, jiffies + timeout);
        }
        
        i2QueueCommands( PTYPE_INLINE, pCh, -1, 1, CMD_BMARK_REQ );

        init_waitqueue_entry(&wait, current);
        add_wait_queue(&(pCh->pBookmarkWait), &wait);
        set_current_state( TASK_INTERRUPTIBLE );

        serviceOutgoingFifo( pB );
        
        schedule();        // Now we take our interruptible sleep on

        // Clean up the queue
        set_current_state( TASK_RUNNING );
        remove_wait_queue(&(pCh->pBookmarkWait), &wait);

        // if expires == 0 then timer poped, then do not need to del_timer
        if ((timeout > 0) && pCh->BookmarkTimer.expires && 
                             time_before(jiffies, pCh->BookmarkTimer.expires)) {
                del_timer( &(pCh->BookmarkTimer) );
                pCh->BookmarkTimer.expires = 0;

                ip2trace (CHANN, ITRC_DRAIN, 3, 1, pCh->BookmarkTimer.expires );

        }
        ip2trace (CHANN, ITRC_DRAIN, ITRC_RETURN, 1, pCh->BookmarkTimer.expires );
        return;
}

//******************************************************************************
// Function:   i2OutputFree(pCh)
// Parameters: Pointer to a channel structure
// Returns:    Space in output buffer
//
// Description:
// Returns -1 if very gross error. Otherwise returns the amount of bytes still
// free in the output buffer.
//******************************************************************************
static int
i2OutputFree(i2ChanStrPtr pCh)
{
        int amountToMove;
        unsigned long flags;

        // Ensure channel structure seems real
        if ( !i2Validate ( pCh ) ) {
                return -1;
        }
        read_lock_irqsave(&pCh->Obuf_spinlock, flags);
        amountToMove = pCh->Obuf_strip - pCh->Obuf_stuff - 1;
        read_unlock_irqrestore(&pCh->Obuf_spinlock, flags);

        if (amountToMove < 0) {
                amountToMove += OBUF_SIZE;
        }
        // If this is negative, we will discover later
        amountToMove -= sizeof(i2DataHeader);

        return (amountToMove < 0) ? 0 : amountToMove;
}
static void

ip2_owake( PTTY tp)
{
        i2ChanStrPtr  pCh;

        if (tp == NULL) return;

        pCh = tp->driver_data;

        ip2trace (CHANN, ITRC_SICMD, 10, 2, tp->flags,
                        (1 << TTY_DO_WRITE_WAKEUP) );

        tty_wakeup(tp);
}

static inline void
set_baud_params(i2eBordStrPtr pB) 
{
        int i,j;
        i2ChanStrPtr  *pCh;

        pCh = (i2ChanStrPtr *) pB->i2eChannelPtr;

        for (i = 0; i < ABS_MAX_BOXES; i++) {
                if (pB->channelBtypes.bid_value[i]) {
                        if (BID_HAS_654(pB->channelBtypes.bid_value[i])) {
                                for (j = 0; j < ABS_BIGGEST_BOX; j++) {
                                        if (pCh[i*16+j] == NULL)
                                                break;
                                        (pCh[i*16+j])->BaudBase    = 921600;        // MAX for ST654
                                        (pCh[i*16+j])->BaudDivisor = 96;
                                }
                        } else {        // has cirrus cd1400
                                for (j = 0; j < ABS_BIGGEST_BOX; j++) {
                                        if (pCh[i*16+j] == NULL)
                                                break;
                                        (pCh[i*16+j])->BaudBase    = 115200;        // MAX for CD1400
                                        (pCh[i*16+j])->BaudDivisor = 12;
                                }
                        }
                }
        }
}

//******************************************************************************
// Function:   i2StripFifo(pB)
// Parameters: Pointer to a board structure
// Returns:    ?
//
// Description:
// Strips all the available data from the incoming FIFO, identifies the type of
// packet, and either buffers the data or does what needs to be done.
//
// Note there is no overflow checking here: if the board sends more data than it
// ought to, we will not detect it here, but blindly overflow...
//******************************************************************************

// A buffer for reading in blocks for unknown channels
static unsigned char junkBuffer[IBUF_SIZE];

// A buffer to read in a status packet. Because of the size of the count field
// for these things, the maximum packet size must be less than MAX_CMD_PACK_SIZE
static unsigned char cmdBuffer[MAX_CMD_PACK_SIZE + 4];

// This table changes the bit order from MSR order given by STAT_MODEM packet to
// status bits used in our library.
static char xlatDss[16] = {
0      | 0     | 0      | 0      ,
0      | 0     | 0      | I2_CTS ,
0      | 0     | I2_DSR | 0      ,
0      | 0     | I2_DSR | I2_CTS ,
0      | I2_RI | 0      | 0      ,
0      | I2_RI | 0      | I2_CTS ,
0      | I2_RI | I2_DSR | 0      ,
0      | I2_RI | I2_DSR | I2_CTS ,
I2_DCD | 0     | 0      | 0      ,
I2_DCD | 0     | 0      | I2_CTS ,
I2_DCD | 0     | I2_DSR | 0      ,
I2_DCD | 0     | I2_DSR | I2_CTS ,
I2_DCD | I2_RI | 0      | 0      ,
I2_DCD | I2_RI | 0      | I2_CTS ,
I2_DCD | I2_RI | I2_DSR | 0      ,
I2_DCD | I2_RI | I2_DSR | I2_CTS };

static inline void
i2StripFifo(i2eBordStrPtr pB)
{
        i2ChanStrPtr pCh;
        int channel;
        int count;
        unsigned short stuffIndex;
        int amountToRead;
        unsigned char *pc, *pcLimit;
        unsigned char uc;
        unsigned char dss_change;
        unsigned long bflags,cflags;

//        ip2trace (ITRC_NO_PORT, ITRC_SFIFO, ITRC_ENTER, 0 );

        while (I2_HAS_INPUT(pB)) {
//                ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 2, 0 );

                // Process packet from fifo a one atomic unit
                write_lock_irqsave(&pB->read_fifo_spinlock, bflags);
   
                // The first word (or two bytes) will have channel number and type of
                // packet, possibly other information
                pB->i2eLeadoffWord[0] = iiReadWord(pB);

                switch(PTYPE_OF(pB->i2eLeadoffWord))
                {
                case PTYPE_DATA:
                        pB->got_input = 1;

//                        ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 3, 0 );

                        channel = CHANNEL_OF(pB->i2eLeadoffWord); /* Store channel */
                        count = iiReadWord(pB);          /* Count is in the next word */

// NEW: Check the count for sanity! Should the hardware fail, our death
// is more pleasant. While an oversize channel is acceptable (just more
// than the driver supports), an over-length count clearly means we are
// sick!
                        if ( ((unsigned int)count) > IBUF_SIZE ) {
                                pB->i2eFatal = 2;
                                write_unlock_irqrestore(&pB->read_fifo_spinlock,
                                                bflags);
                                return;     /* Bail out ASAP */
                        }
                        // Channel is illegally big ?
                        if ((channel >= pB->i2eChannelCnt) ||
                                (NULL==(pCh = ((i2ChanStrPtr*)pB->i2eChannelPtr)[channel])))
                        {
                                iiReadBuf(pB, junkBuffer, count);
                                write_unlock_irqrestore(&pB->read_fifo_spinlock,
                                                bflags);
                                break;         /* From switch: ready for next packet */
                        }

                        // Channel should be valid, then

                        // If this is a hot-key, merely post its receipt for now. These are
                        // always supposed to be 1-byte packets, so we won't even check the
                        // count. Also we will post an acknowledgement to the board so that
                        // more data can be forthcoming. Note that we are not trying to use
                        // these sequences in this driver, merely to robustly ignore them.
                        if(ID_OF(pB->i2eLeadoffWord) == ID_HOT_KEY)
                        {
                                pCh->hotKeyIn = iiReadWord(pB) & 0xff;
                                write_unlock_irqrestore(&pB->read_fifo_spinlock,
                                                bflags);
                                i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_HOTACK);
                                break;   /* From the switch: ready for next packet */
                        }

                        // Normal data! We crudely assume there is room for the data in our
                        // buffer because the board wouldn't have exceeded his credit limit.
                        write_lock_irqsave(&pCh->Ibuf_spinlock, cflags);
                                                                                                        // We have 2 locks now
                        stuffIndex = pCh->Ibuf_stuff;
                        amountToRead = IBUF_SIZE - stuffIndex;
                        if (amountToRead > count)
                                amountToRead = count;

                        // stuffIndex would have been already adjusted so there would 
                        // always be room for at least one, and count is always at least
                        // one.

                        iiReadBuf(pB, &(pCh->Ibuf[stuffIndex]), amountToRead);
                        pCh->icount.rx += amountToRead;

                        // Update the stuffIndex by the amount of data moved. Note we could
                        // never ask for more data than would just fit. However, we might
                        // have read in one more byte than we wanted because the read
                        // rounds up to even bytes. If this byte is on the end of the
                        // packet, and is padding, we ignore it. If the byte is part of
                        // the actual data, we need to move it.

                        stuffIndex += amountToRead;

                        if (stuffIndex >= IBUF_SIZE) {
                                if ((amountToRead & 1) && (count > amountToRead)) {
                                        pCh->Ibuf[0] = pCh->Ibuf[IBUF_SIZE];
                                        amountToRead++;
                                        stuffIndex = 1;
                                } else {
                                        stuffIndex = 0;
                                }
                        }

                        // If there is anything left over, read it as well
                        if (count > amountToRead) {
                                amountToRead = count - amountToRead;
                                iiReadBuf(pB, &(pCh->Ibuf[stuffIndex]), amountToRead);
                                pCh->icount.rx += amountToRead;
                                stuffIndex += amountToRead;
                        }

                        // Update stuff index
                        pCh->Ibuf_stuff = stuffIndex;
                        write_unlock_irqrestore(&pCh->Ibuf_spinlock, cflags);
                        write_unlock_irqrestore(&pB->read_fifo_spinlock,
                                        bflags);

#ifdef USE_IQ
                        schedule_work(&pCh->tqueue_input);
#else
                        do_input(&pCh->tqueue_input);
#endif

                        // Note we do not need to maintain any flow-control credits at this
                        // time:  if we were to increment .asof and decrement .room, there
                        // would be no net effect. Instead, when we strip data, we will
                        // increment .asof and leave .room unchanged.

                        break;   // From switch: ready for next packet

                case PTYPE_STATUS:
                        ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 4, 0 );
      
                        count = CMD_COUNT_OF(pB->i2eLeadoffWord);

                        iiReadBuf(pB, cmdBuffer, count);
                        // We can release early with buffer grab
                        write_unlock_irqrestore(&pB->read_fifo_spinlock,
                                        bflags);

                        pc = cmdBuffer;
                        pcLimit = &(cmdBuffer[count]);

                        while (pc < pcLimit) {
                                channel = *pc++;

                                ip2trace (channel, ITRC_SFIFO, 7, 2, channel, *pc );

                                /* check for valid channel */
                                if (channel < pB->i2eChannelCnt
                                         && 
                                         (pCh = (((i2ChanStrPtr*)pB->i2eChannelPtr)[channel])) != NULL
                                        )
                                {
                                        dss_change = 0;

                                        switch (uc = *pc++)
                                        {
                                        /* Breaks and modem signals are easy: just update status */
                                        case STAT_CTS_UP:
                                                if ( !(pCh->dataSetIn & I2_CTS) )
                                                {
                                                        pCh->dataSetIn |= I2_DCTS;
                                                        pCh->icount.cts++;
                                                        dss_change = 1;
                                                }
                                                pCh->dataSetIn |= I2_CTS;
                                                break;

                                        case STAT_CTS_DN:
                                                if ( pCh->dataSetIn & I2_CTS )
                                                {
                                                        pCh->dataSetIn |= I2_DCTS;
                                                        pCh->icount.cts++;
                                                        dss_change = 1;
                                                }
                                                pCh->dataSetIn &= ~I2_CTS;
                                                break;

                                        case STAT_DCD_UP:
                                                ip2trace (channel, ITRC_MODEM, 1, 1, pCh->dataSetIn );

                                                if ( !(pCh->dataSetIn & I2_DCD) )
                                                {
                                                        ip2trace (CHANN, ITRC_MODEM, 2, 0 );
                                                        pCh->dataSetIn |= I2_DDCD;
                                                        pCh->icount.dcd++;
                                                        dss_change = 1;
                                                }
                                                pCh->dataSetIn |= I2_DCD;

                                                ip2trace (channel, ITRC_MODEM, 3, 1, pCh->dataSetIn );
                                                break;

                                        case STAT_DCD_DN:
                                                ip2trace (channel, ITRC_MODEM, 4, 1, pCh->dataSetIn );
                                                if ( pCh->dataSetIn & I2_DCD )
                                                {
                                                        ip2trace (channel, ITRC_MODEM, 5, 0 );
                                                        pCh->dataSetIn |= I2_DDCD;
                                                        pCh->icount.dcd++;
                                                        dss_change = 1;
                                                }
                                                pCh->dataSetIn &= ~I2_DCD;

                                                ip2trace (channel, ITRC_MODEM, 6, 1, pCh->dataSetIn );
                                                break;

                                        case STAT_DSR_UP:
                                                if ( !(pCh->dataSetIn & I2_DSR) )
                                                {
                                                        pCh->dataSetIn |= I2_DDSR;
                                                        pCh->icount.dsr++;
                                                        dss_change = 1;
                                                }
                                                pCh->dataSetIn |= I2_DSR;
                                                break;

                                        case STAT_DSR_DN:
                                                if ( pCh->dataSetIn & I2_DSR )
                                                {
                                                        pCh->dataSetIn |= I2_DDSR;
                                                        pCh->icount.dsr++;
                                                        dss_change = 1;
                                                }
                                                pCh->dataSetIn &= ~I2_DSR;
                                                break;

                                        case STAT_RI_UP:
                                                if ( !(pCh->dataSetIn & I2_RI) )
                                                {
                                                        pCh->dataSetIn |= I2_DRI;
                                                        pCh->icount.rng++;
                                                        dss_change = 1;
                                                }
                                                pCh->dataSetIn |= I2_RI ;
                                                break;

                                        case STAT_RI_DN:
                                                // to be compat with serial.c
                                                //if ( pCh->dataSetIn & I2_RI )
                                                //{
                                                //        pCh->dataSetIn |= I2_DRI;
                                                //        pCh->icount.rng++; 
                                                //        dss_change = 1;
                                                //}
                                                pCh->dataSetIn &= ~I2_RI ;
                                                break;

                                        case STAT_BRK_DET:
                                                pCh->dataSetIn |= I2_BRK;
                                                pCh->icount.brk++;
                                                dss_change = 1;
                                                break;

                                        // Bookmarks? one less request we're waiting for
                                        case STAT_BMARK:
                                                pCh->bookMarks--;
                                                if (pCh->bookMarks <= 0 ) {
                                                        pCh->bookMarks = 0;
                                                        wake_up_interruptible( &pCh->pBookmarkWait );

                                                ip2trace (channel, ITRC_DRAIN, 20, 1, pCh->BookmarkTimer.expires );
                                                }
                                                break;

                                        // Flow control packets? Update the new credits, and if
                                        // someone was waiting for output, queue him up again.
                                        case STAT_FLOW:
                                                pCh->outfl.room =
                                                        ((flowStatPtr)pc)->room -
                                                        (pCh->outfl.asof - ((flowStatPtr)pc)->asof);

                                                ip2trace (channel, ITRC_STFLW, 1, 1, pCh->outfl.room );

                                                if (pCh->channelNeeds & NEED_CREDIT)
                                                {
                                                        ip2trace (channel, ITRC_STFLW, 2, 1, pCh->channelNeeds);

                                                        pCh->channelNeeds &= ~NEED_CREDIT;
                                                        i2QueueNeeds(pB, pCh, NEED_INLINE);
                                                        if ( pCh->pTTY )
                                                                ip2_owake(pCh->pTTY);
                                                }

                                                ip2trace (channel, ITRC_STFLW, 3, 1, pCh->channelNeeds);

                                                pc += sizeof(flowStat);
                                                break;

                                        /* Special packets: */
                                        /* Just copy the information into the channel structure */

                                        case STAT_STATUS:

                                                pCh->channelStatus = *((debugStatPtr)pc);
                                                pc += sizeof(debugStat);
                                                break;

                                        case STAT_TXCNT:

                                                pCh->channelTcount = *((cntStatPtr)pc);
                                                pc += sizeof(cntStat);
                                                break;

                                        case STAT_RXCNT:

                                                pCh->channelRcount = *((cntStatPtr)pc);
                                                pc += sizeof(cntStat);
                                                break;

                                        case STAT_BOXIDS:
                                                pB->channelBtypes = *((bidStatPtr)pc);
                                                pc += sizeof(bidStat);
                                                set_baud_params(pB);
                                                break;

                                        case STAT_HWFAIL:
                                                i2QueueCommands (PTYPE_INLINE, pCh, 0, 1, CMD_HW_TEST);
                                                pCh->channelFail = *((failStatPtr)pc);
                                                pc += sizeof(failStat);
                                                break;

                                        /* No explicit match? then
                                         * Might be an error packet...
                                         */
                                        default:
                                                switch (uc & STAT_MOD_ERROR)
                                                {
                                                case STAT_ERROR:
                                                        if (uc & STAT_E_PARITY) {
                                                                pCh->dataSetIn |= I2_PAR;
                                                                pCh->icount.parity++;
                                                        }
                                                        if (uc & STAT_E_FRAMING){
                                                                pCh->dataSetIn |= I2_FRA;
                                                                pCh->icount.frame++;
                                                        }
                                                        if (uc & STAT_E_OVERRUN){
                                                                pCh->dataSetIn |= I2_OVR;
                                                                pCh->icount.overrun++;
                                                        }
                                                        break;

                                                case STAT_MODEM:
                                                        // the answer to DSS_NOW request (not change)
                                                        pCh->dataSetIn = (pCh->dataSetIn
                                                                & ~(I2_RI | I2_CTS | I2_DCD | I2_DSR) )
                                                                | xlatDss[uc & 0xf];
                                                        wake_up_interruptible ( &pCh->dss_now_wait );
                                                default:
                                                        break;
                                                }
                                        }  /* End of switch on status type */
                                        if (dss_change) {
#ifdef USE_IQ
                                                schedule_work(&pCh->tqueue_status);
#else
                                                do_status(&pCh->tqueue_status);
#endif
                                        }
                                }
                                else  /* Or else, channel is invalid */
                                {
                                        // Even though the channel is invalid, we must test the
                                        // status to see how much additional data it has (to be
                                        // skipped)
                                        switch (*pc++)
                                        {
                                        case STAT_FLOW:
                                                pc += 4;    /* Skip the data */
                                                break;

                                        default:
                                                break;
                                        }
                                }
                        }  // End of while (there is still some status packet left)
                        break;

                default: // Neither packet? should be impossible
                        ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 5, 1,
                                PTYPE_OF(pB->i2eLeadoffWord) );
                        write_unlock_irqrestore(&pB->read_fifo_spinlock,
                                        bflags);

                        break;
                }  // End of switch on type of packets
        }        /*while(board I2_HAS_INPUT)*/

        ip2trace (ITRC_NO_PORT, ITRC_SFIFO, ITRC_RETURN, 0 );

        // Send acknowledgement to the board even if there was no data!
        pB->i2eOutMailWaiting |= MB_IN_STRIPPED;
        return;
}

//******************************************************************************
// Function:   i2Write2Fifo(pB,address,count)
// Parameters: Pointer to a board structure, source address, byte count
// Returns:    bytes written
//
// Description:
//  Writes count bytes to board io address(implied) from source
//  Adjusts count, leaves reserve for next time around bypass cmds
//******************************************************************************
static int
i2Write2Fifo(i2eBordStrPtr pB, unsigned char *source, int count,int reserve)
{
        int rc = 0;
        unsigned long flags;
        write_lock_irqsave(&pB->write_fifo_spinlock, flags);
        if (!pB->i2eWaitingForEmptyFifo) {
                if (pB->i2eFifoRemains > (count+reserve)) {
                        pB->i2eFifoRemains -= count;
                        iiWriteBuf(pB, source, count);
                        pB->i2eOutMailWaiting |= MB_OUT_STUFFED;
                        rc =  count;
                }
        }
        write_unlock_irqrestore(&pB->write_fifo_spinlock, flags);
        return rc;
}
//******************************************************************************
// Function:   i2StuffFifoBypass(pB)
// Parameters: Pointer to a board structure
// Returns:    Nothing
//
// Description:
// Stuffs as many bypass commands into the fifo as possible. This is simpler
// than stuffing data or inline commands to fifo, since we do not have
// flow-control to deal with.
//******************************************************************************
static inline void
i2StuffFifoBypass(i2eBordStrPtr pB)
{
        i2ChanStrPtr pCh;
        unsigned char *pRemove;
        unsigned short stripIndex;
        unsigned short packetSize;
        unsigned short paddedSize;
        unsigned short notClogged = 1;
        unsigned long flags;

        int bailout = 1000;

        // Continue processing so long as there are entries, or there is room in the
        // fifo. Each entry represents a channel with something to do.
        while ( --bailout && notClogged && 
                        (NULL != (pCh = i2DeQueueNeeds(pB,NEED_BYPASS))))
        {
                write_lock_irqsave(&pCh->Cbuf_spinlock, flags);
                stripIndex = pCh->Cbuf_strip;

                // as long as there are packets for this channel...

                while (stripIndex != pCh->Cbuf_stuff) {
                        pRemove = &(pCh->Cbuf[stripIndex]);
                        packetSize = CMD_COUNT_OF(pRemove) + sizeof(i2CmdHeader);
                        paddedSize = roundup(packetSize, 2);

                        if (paddedSize > 0) {
                                if ( 0 == i2Write2Fifo(pB, pRemove, paddedSize,0)) {
                                        notClogged = 0;        /* fifo full */
                                        i2QueueNeeds(pB, pCh, NEED_BYPASS);        // Put back on queue
                                        break;   // Break from the channel
                                } 
                        }
#ifdef DEBUG_FIFO
WriteDBGBuf("BYPS", pRemove, paddedSize);
#endif        /* DEBUG_FIFO */
                        pB->debugBypassCount++;

                        pRemove += packetSize;
                        stripIndex += packetSize;
                        if (stripIndex >= CBUF_SIZE) {
                                stripIndex = 0;
                                pRemove = pCh->Cbuf;
                        }
                }
                // Done with this channel. Move to next, removing this one from 
                // the queue of channels if we cleaned it out (i.e., didn't get clogged.
                pCh->Cbuf_strip = stripIndex;
                write_unlock_irqrestore(&pCh->Cbuf_spinlock, flags);
        }  // Either clogged or finished all the work

#ifdef IP2DEBUG_TRACE
        if ( !bailout ) {
                ip2trace (ITRC_NO_PORT, ITRC_ERROR, 1, 0 );
        }
#endif
}

//******************************************************************************
// Function:   i2StuffFifoFlow(pB)
// Parameters: Pointer to a board structure
// Returns:    Nothing
//
// Description:
// Stuffs as many flow control packets into the fifo as possible. This is easier
// even than doing normal bypass commands, because there is always at most one
// packet, already assembled, for each channel.
//******************************************************************************
static inline void
i2StuffFifoFlow(i2eBordStrPtr pB)
{
        i2ChanStrPtr pCh;
        unsigned short paddedSize = roundup(sizeof(flowIn), 2);

        ip2trace (ITRC_NO_PORT, ITRC_SFLOW, ITRC_ENTER, 2,
                pB->i2eFifoRemains, paddedSize );

        // Continue processing so long as there are entries, or there is room in the
        // fifo. Each entry represents a channel with something to do.
        while ( (NULL != (pCh = i2DeQueueNeeds(pB,NEED_FLOW)))) {
                pB->debugFlowCount++;

                // NO Chan LOCK needed ???
                if ( 0 == i2Write2Fifo(pB,(unsigned char *)&(pCh->infl),paddedSize,0)) {
                        break;
                }
#ifdef DEBUG_FIFO
                WriteDBGBuf("FLOW",(unsigned char *) &(pCh->infl), paddedSize);
#endif /* DEBUG_FIFO */

        }  // Either clogged or finished all the work

        ip2trace (ITRC_NO_PORT, ITRC_SFLOW, ITRC_RETURN, 0 );
}

//******************************************************************************
// Function:   i2StuffFifoInline(pB)
// Parameters: Pointer to a board structure
// Returns:    Nothing
//
// Description:
// Stuffs as much data and inline commands into the fifo as possible. This is
// the most complex fifo-stuffing operation, since there if now the channel
// flow-control issue to deal with.
//******************************************************************************
static inline void
i2StuffFifoInline(i2eBordStrPtr pB)
{
        i2ChanStrPtr pCh;
        unsigned char *pRemove;
        unsigned short stripIndex;
        unsigned short packetSize;
        unsigned short paddedSize;
        unsigned short notClogged = 1;
        unsigned short flowsize;
        unsigned long flags;

        int bailout  = 1000;
        int bailout2;

        ip2trace (ITRC_NO_PORT, ITRC_SICMD, ITRC_ENTER, 3, pB->i2eFifoRemains, 
                        pB->i2Dbuf_strip, pB->i2Dbuf_stuff );

        // Continue processing so long as there are entries, or there is room in the
        // fifo. Each entry represents a channel with something to do.
        while ( --bailout && notClogged && 
                        (NULL != (pCh = i2DeQueueNeeds(pB,NEED_INLINE))) )
        {
                write_lock_irqsave(&pCh->Obuf_spinlock, flags);
                stripIndex = pCh->Obuf_strip;

                ip2trace (CHANN, ITRC_SICMD, 3, 2, stripIndex, pCh->Obuf_stuff );

                // as long as there are packets for this channel...
                bailout2 = 1000;
                while ( --bailout2 && stripIndex != pCh->Obuf_stuff) {
                        pRemove = &(pCh->Obuf[stripIndex]);

                        // Must determine whether this be a data or command packet to
                        // calculate correctly the header size and the amount of
                        // flow-control credit this type of packet will use.
                        if (PTYPE_OF(pRemove) == PTYPE_DATA) {
                                flowsize = DATA_COUNT_OF(pRemove);
                                packetSize = flowsize + sizeof(i2DataHeader);
                        } else {
                                flowsize = CMD_COUNT_OF(pRemove);
                                packetSize = flowsize + sizeof(i2CmdHeader);
                        }
                        flowsize = CREDIT_USAGE(flowsize);
                        paddedSize = roundup(packetSize, 2);

                        ip2trace (CHANN, ITRC_SICMD, 4, 2, pB->i2eFifoRemains, paddedSize );

                        // If we don't have enough credits from the board to send the data,
                        // flag the channel that we are waiting for flow control credit, and
                        // break out. This will clean up this channel and remove us from the
                        // queue of hot things to do.

                                ip2trace (CHANN, ITRC_SICMD, 5, 2, pCh->outfl.room, flowsize );

                        if (pCh->outfl.room <= flowsize)        {
                                // Do Not have the credits to send this packet.
                                i2QueueNeeds(pB, pCh, NEED_CREDIT);
                                notClogged = 0;
                                break;   // So to do next channel
                        }
                        if ( (paddedSize > 0) 
                                && ( 0 == i2Write2Fifo(pB, pRemove, paddedSize, 128))) {
                                // Do Not have room in fifo to send this packet.
                                notClogged = 0;
                                i2QueueNeeds(pB, pCh, NEED_INLINE);        
                                break;   // Break from the channel
                        }
#ifdef DEBUG_FIFO
WriteDBGBuf("DATA", pRemove, paddedSize);
#endif /* DEBUG_FIFO */
                        pB->debugInlineCount++;

                        pCh->icount.tx += flowsize;
                        // Update current credits
                        pCh->outfl.room -= flowsize;
                        pCh->outfl.asof += flowsize;
                        if (PTYPE_OF(pRemove) == PTYPE_DATA) {
                                pCh->Obuf_char_count -= DATA_COUNT_OF(pRemove);
                        }
                        pRemove += packetSize;
                        stripIndex += packetSize;

                        ip2trace (CHANN, ITRC_SICMD, 6, 2, stripIndex, pCh->Obuf_strip);

                        if (stripIndex >= OBUF_SIZE) {
                                stripIndex = 0;
                                pRemove = pCh->Obuf;

                                ip2trace (CHANN, ITRC_SICMD, 7, 1, stripIndex );

                        }
                }        /* while */
                if ( !bailout2 ) {
                        ip2trace (CHANN, ITRC_ERROR, 3, 0 );
                }
                // Done with this channel. Move to next, removing this one from the
                // queue of channels if we cleaned it out (i.e., didn't get clogged.
                pCh->Obuf_strip = stripIndex;
                write_unlock_irqrestore(&pCh->Obuf_spinlock, flags);
                if ( notClogged )
                {

                        ip2trace (CHANN, ITRC_SICMD, 8, 0 );

                        if ( pCh->pTTY ) {
                                ip2_owake(pCh->pTTY);
                        }
                }
        }  // Either clogged or finished all the work

        if ( !bailout ) {
                ip2trace (ITRC_NO_PORT, ITRC_ERROR, 4, 0 );
        }

        ip2trace (ITRC_NO_PORT, ITRC_SICMD, ITRC_RETURN, 1,pB->i2Dbuf_strip);
}

//******************************************************************************
// Function:   serviceOutgoingFifo(pB)
// Parameters: Pointer to a board structure
// Returns:    Nothing
//
// Description:
// Helper routine to put data in the outgoing fifo, if we aren't already waiting
// for something to be there. If the fifo has only room for a very little data,
// go head and hit the board with a mailbox hit immediately. Otherwise, it will
// have to happen later in the interrupt processing. Since this routine may be
// called both at interrupt and foreground time, we must turn off interrupts
// during the entire process.
//******************************************************************************
static void
serviceOutgoingFifo(i2eBordStrPtr pB)
{
        // If we aren't currently waiting for the board to empty our fifo, service
        // everything that is pending, in priority order (especially, Bypass before
        // Inline).
        if ( ! pB->i2eWaitingForEmptyFifo )
        {
                i2StuffFifoFlow(pB);
                i2StuffFifoBypass(pB);
                i2StuffFifoInline(pB);

                iiSendPendingMail(pB);
        } 
}

//******************************************************************************
// Function:   i2ServiceBoard(pB)
// Parameters: Pointer to a board structure
// Returns:    Nothing
//
// Description:
// Normally this is called from interrupt level, but there is deliberately
// nothing in here specific to being called from interrupt level. All the
// hardware-specific, interrupt-specific things happen at the outer levels.
//
// For example, a timer interrupt could drive this routine for some sort of
// polled operation. The only requirement is that the programmer deal with any
// atomiticity/concurrency issues that result.
//
// This routine responds to the board's having sent mailbox information to the
// host (which would normally cause an interrupt). This routine reads the
// incoming mailbox. If there is no data in it, this board did not create the
// interrupt and/or has nothing to be done to it. (Except, if we have been
// waiting to write mailbox data to it, we may do so.
//
// Based on the value in the mailbox, we may take various actions.
//
// No checking here of pB validity: after all, it shouldn't have been called by
// the handler unless pB were on the list.
//******************************************************************************
static inline int
i2ServiceBoard ( i2eBordStrPtr pB )
{
        unsigned inmail;
        unsigned long flags;


        /* This should be atomic because of the way we are called... */
        if (NO_MAIL_HERE == ( inmail = pB->i2eStartMail ) ) {
                inmail = iiGetMail(pB);
        }
        pB->i2eStartMail = NO_MAIL_HERE;

        ip2trace (ITRC_NO_PORT, ITRC_INTR, 2, 1, inmail );

        if (inmail != NO_MAIL_HERE) {
                // If the board has gone fatal, nothing to do but hit a bit that will
                // alert foreground tasks to protest!
                if ( inmail & MB_FATAL_ERROR ) {
                        pB->i2eFatal = 1;
                        goto exit_i2ServiceBoard;
                }

                /* Assuming no fatal condition, we proceed to do work */
                if ( inmail & MB_IN_STUFFED ) {
                        pB->i2eFifoInInts++;
                        i2StripFifo(pB);     /* There might be incoming packets */
                }

                if (inmail & MB_OUT_STRIPPED) {
                        pB->i2eFifoOutInts++;
                        write_lock_irqsave(&pB->write_fifo_spinlock, flags);
                        pB->i2eFifoRemains = pB->i2eFifoSize;
                        pB->i2eWaitingForEmptyFifo = 0;
                        write_unlock_irqrestore(&pB->write_fifo_spinlock,
                                        flags);

                        ip2trace (ITRC_NO_PORT, ITRC_INTR, 30, 1, pB->i2eFifoRemains );

                }
                serviceOutgoingFifo(pB);
        }

        ip2trace (ITRC_NO_PORT, ITRC_INTR, 8, 0 );

exit_i2ServiceBoard:

        return 0;
}