c65c9bc3ef
There are several pretty much unfixable races in the old ldisc code, especially with respect to pty behaviour and also to hangup. It's easier to rewrite the code than simply try and patch it up. This patch - splits the ldisc from the tty (so we will be able to refcount it more cleanly later) - introduces a mutex lock for ldisc changing on an active device - fixes the complete mess that hangup caused - implements hopefully correct setldisc/close/hangup locking There are still some problems around pty pairs that have always been there but at least it is now possible to understand the code and fix further problems. This fixes the following known bugs - hang up can leak ldisc references - hang up may not call open/close on ldisc in a matched way - pty/tty pairs can deadlock during an ldisc change - reading the ldisc proc files can cause every ldisc to be loaded and probably a few other of the mysterious ldisc race reports. I'm sure it also adds the odd new one. Signed-off-by: Alan Cox <alan@linux.intel.com> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2215 lines
65 KiB
C
2215 lines
65 KiB
C
/*******************************************************************************
|
|
*
|
|
* (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;
|
|
}
|