You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2214 lines
65 KiB
2214 lines
65 KiB
/*******************************************************************************
|
|
*
|
|
* (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.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.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;
|
|
}
|
|
|