1 /*******************************************************************************
3 * (c) 1999 by Computone Corporation
5 ********************************************************************************
8 * PACKAGE: Linux tty Device Driver for IntelliPort family of multiport
9 * serial I/O controllers.
11 * DESCRIPTION: High-level interface code for the device driver. Uses the
12 * Extremely Low Level Interface Support (i2ellis.c). Provides an
13 * interface to the standard loadware, to support drivers or
14 * application code. (This is included source code, not a separate
15 * compilation module.)
17 *******************************************************************************/
18 //------------------------------------------------------------------------------
20 // Once the board has been initialized, it will interrupt us when:
21 // 1) It has something in the fifo for us to read (incoming data, flow control
22 // packets, or whatever).
23 // 2) It has stripped whatever we have sent last time in the FIFO (and
24 // consequently is ready for more).
26 // Note also that the buffer sizes declared in i2lib.h are VERY SMALL. This
27 // worsens performance considerably, but is done so that a great many channels
28 // might use only a little memory.
29 //------------------------------------------------------------------------------
31 //------------------------------------------------------------------------------
34 // 0.00 - 4/16/91 --- First Draft
35 // 0.01 - 4/29/91 --- 1st beta release
36 // 0.02 - 6/14/91 --- Changes to allow small model compilation
37 // 0.03 - 6/17/91 MAG Break reporting protected from interrupts routines with
38 // in-line asm added for moving data to/from ring buffers,
39 // replacing a variety of methods used previously.
40 // 0.04 - 6/21/91 MAG Initial flow-control packets not queued until
41 // i2_enable_interrupts time. Former versions would enqueue
42 // them at i2_init_channel time, before we knew how many
43 // channels were supposed to exist!
44 // 0.05 - 10/12/91 MAG Major changes: works through the ellis.c routines now;
45 // supports new 16-bit protocol and expandable boards.
46 // - 10/24/91 MAG Most changes in place and stable.
47 // 0.06 - 2/20/92 MAG Format of CMD_HOTACK corrected: the command takes no
49 // 0.07 -- 3/11/92 MAG Support added to store special packet types at interrupt
50 // level (mostly responses to specific commands.)
51 // 0.08 -- 3/30/92 MAG Support added for STAT_MODEM packet
52 // 0.09 -- 6/24/93 MAG i2Link... needed to update number of boards BEFORE
53 // turning on the interrupt.
54 // 0.10 -- 6/25/93 MAG To avoid gruesome death from a bad board, we sanity check
57 // 1.1 - 12/25/96 AKM Linux version.
58 // - 10/09/98 DMC Revised Linux version.
59 //------------------------------------------------------------------------------
65 #include <linux/sched.h>
69 //***********************
70 //* Function Prototypes *
71 //***********************
72 static void i2QueueNeeds(i2eBordStrPtr
, i2ChanStrPtr
, int);
73 static i2ChanStrPtr
i2DeQueueNeeds(i2eBordStrPtr
, int );
74 static void i2StripFifo(i2eBordStrPtr
);
75 static void i2StuffFifoBypass(i2eBordStrPtr
);
76 static void i2StuffFifoFlow(i2eBordStrPtr
);
77 static void i2StuffFifoInline(i2eBordStrPtr
);
78 static int i2RetryFlushOutput(i2ChanStrPtr
);
80 // Not a documented part of the library routines (careful...) but the Diagnostic
81 // i2diag.c finds them useful to help the throughput in certain limited
82 // single-threaded operations.
83 static void iiSendPendingMail(i2eBordStrPtr
);
84 static void serviceOutgoingFifo(i2eBordStrPtr
);
86 // Functions defined in ip2.c as part of interrupt handling
87 static void do_input(struct work_struct
*);
88 static void do_status(struct work_struct
*);
95 unsigned char DBGBuf
[0x4000];
99 WriteDBGBuf(char *s
, unsigned char *src
, unsigned short n
)
103 // XXX: We need a spin lock here if we ever use this again
105 while (*s
) { // copy label
109 while (n
--) { // copy data
116 fatality(i2eBordStrPtr pB
)
120 for (i
=0;i
<sizeof(DBGBuf
);i
++) {
123 printk("%02x ",DBGBuf
[i
]);
126 for (i
=0;i
<sizeof(DBGBuf
);i
++) {
129 if (DBGBuf
[i
] >= ' ' && DBGBuf
[i
] <= '~') {
130 printk(" %c ",DBGBuf
[i
]);
136 printk("Last index %x\n",I
);
138 #endif /* DEBUG_FIFO */
145 i2Validate ( i2ChanStrPtr pCh
)
147 //ip2trace(pCh->port_index, ITRC_VERIFY,ITRC_ENTER,2,pCh->validity,
148 // (CHANNEL_MAGIC | CHANNEL_SUPPORT));
149 return ((pCh
->validity
& (CHANNEL_MAGIC_BITS
| CHANNEL_SUPPORT
))
150 == (CHANNEL_MAGIC
| CHANNEL_SUPPORT
));
153 //******************************************************************************
154 // Function: iiSendPendingMail(pB)
155 // Parameters: Pointer to a board structure
159 // If any outgoing mail bits are set and there is outgoing mailbox is empty,
160 // send the mail and clear the bits.
161 //******************************************************************************
163 iiSendPendingMail(i2eBordStrPtr pB
)
165 if (pB
->i2eOutMailWaiting
&& (!pB
->i2eWaitingForEmptyFifo
) )
167 if (iiTrySendMail(pB
, pB
->i2eOutMailWaiting
))
169 /* If we were already waiting for fifo to empty,
170 * or just sent MB_OUT_STUFFED, then we are
171 * still waiting for it to empty, until we should
172 * receive an MB_IN_STRIPPED from the board.
174 pB
->i2eWaitingForEmptyFifo
|=
175 (pB
->i2eOutMailWaiting
& MB_OUT_STUFFED
);
176 pB
->i2eOutMailWaiting
= 0;
177 pB
->SendPendingRetry
= 0;
179 /* The only time we hit this area is when "iiTrySendMail" has
180 failed. That only occurs when the outbound mailbox is
181 still busy with the last message. We take a short breather
182 to let the board catch up with itself and then try again.
183 16 Retries is the limit - then we got a borked board.
186 if( ++pB
->SendPendingRetry
< 16 ) {
188 init_timer( &(pB
->SendPendingTimer
) );
189 pB
->SendPendingTimer
.expires
= jiffies
+ 1;
190 pB
->SendPendingTimer
.function
= (void*)(unsigned long)iiSendPendingMail
;
191 pB
->SendPendingTimer
.data
= (unsigned long)pB
;
192 add_timer( &(pB
->SendPendingTimer
) );
194 printk( KERN_ERR
"IP2: iiSendPendingMail unable to queue outbound mail\n" );
200 //******************************************************************************
201 // Function: i2InitChannels(pB, nChannels, pCh)
202 // Parameters: Pointer to Ellis Board structure
203 // Number of channels to initialize
204 // Pointer to first element in an array of channel structures
205 // Returns: Success or failure
209 // This function patches pointers, back-pointers, and initializes all the
210 // elements in the channel structure array.
212 // This should be run after the board structure is initialized, through having
213 // loaded the standard loadware (otherwise it complains).
215 // In any case, it must be done before any serious work begins initializing the
216 // irq's or sending commands...
218 //******************************************************************************
220 i2InitChannels ( i2eBordStrPtr pB
, int nChannels
, i2ChanStrPtr pCh
)
222 int index
, stuffIndex
;
225 if (pB
->i2eValid
!= I2E_MAGIC
) {
226 COMPLETE(pB
, I2EE_BADMAGIC
);
228 if (pB
->i2eState
!= II_STATE_STDLOADED
) {
229 COMPLETE(pB
, I2EE_BADSTATE
);
232 LOCK_INIT(&pB
->read_fifo_spinlock
);
233 LOCK_INIT(&pB
->write_fifo_spinlock
);
234 LOCK_INIT(&pB
->Dbuf_spinlock
);
235 LOCK_INIT(&pB
->Bbuf_spinlock
);
236 LOCK_INIT(&pB
->Fbuf_spinlock
);
238 // NO LOCK needed yet - this is init
240 pB
->i2eChannelPtr
= pCh
;
241 pB
->i2eChannelCnt
= nChannels
;
243 pB
->i2Fbuf_strip
= pB
->i2Fbuf_stuff
= 0;
244 pB
->i2Dbuf_strip
= pB
->i2Dbuf_stuff
= 0;
245 pB
->i2Bbuf_strip
= pB
->i2Bbuf_stuff
= 0;
247 pB
->SendPendingRetry
= 0;
249 memset ( pCh
, 0, sizeof (i2ChanStr
) * nChannels
);
251 for (index
= stuffIndex
= 0, ppCh
= (i2ChanStrPtr
*)(pB
->i2Fbuf
);
252 nChannels
&& index
< ABS_MOST_PORTS
;
255 if ( !(pB
->i2eChannelMap
[index
>> 4] & (1 << (index
& 0xf)) ) ) {
258 LOCK_INIT(&pCh
->Ibuf_spinlock
);
259 LOCK_INIT(&pCh
->Obuf_spinlock
);
260 LOCK_INIT(&pCh
->Cbuf_spinlock
);
261 LOCK_INIT(&pCh
->Pbuf_spinlock
);
262 // NO LOCK needed yet - this is init
263 // Set up validity flag according to support level
264 if (pB
->i2eGoodMap
[index
>> 4] & (1 << (index
& 0xf)) ) {
265 pCh
->validity
= CHANNEL_MAGIC
| CHANNEL_SUPPORT
;
267 pCh
->validity
= CHANNEL_MAGIC
;
269 pCh
->pMyBord
= pB
; /* Back-pointer */
271 // Prepare an outgoing flow-control packet to send as soon as the chance
273 if ( pCh
->validity
& CHANNEL_SUPPORT
) {
274 pCh
->infl
.hd
.i2sChannel
= index
;
275 pCh
->infl
.hd
.i2sCount
= 5;
276 pCh
->infl
.hd
.i2sType
= PTYPE_BYPASS
;
279 pCh
->infl
.room
= IBUF_SIZE
- 1;
281 pCh
->whenSendFlow
= (IBUF_SIZE
/5)*4; // when 80% full
283 // The following is similar to calling i2QueueNeeds, except that this
284 // is done in longhand, since we are setting up initial conditions on
285 // many channels at once.
286 pCh
->channelNeeds
= NEED_FLOW
; // Since starting from scratch
287 pCh
->sinceLastFlow
= 0; // No bytes received since last flow
288 // control packet was queued
290 *ppCh
++ = pCh
; // List this channel as needing
291 // initial flow control packet sent
294 // Don't allow anything to be sent until the status packets come in from
300 // Initialize all the ring buffers
302 pCh
->Ibuf_stuff
= pCh
->Ibuf_strip
= 0;
303 pCh
->Obuf_stuff
= pCh
->Obuf_strip
= 0;
304 pCh
->Cbuf_stuff
= pCh
->Cbuf_strip
= 0;
306 memset( &pCh
->icount
, 0, sizeof (struct async_icount
) );
307 pCh
->hotKeyIn
= HOT_CLEAR
;
308 pCh
->channelOptions
= 0;
310 init_waitqueue_head(&pCh
->pBookmarkWait
);
312 init_waitqueue_head(&pCh
->open_wait
);
313 init_waitqueue_head(&pCh
->close_wait
);
314 init_waitqueue_head(&pCh
->delta_msr_wait
);
316 // Set base and divisor so default custom rate is 9600
317 pCh
->BaudBase
= 921600; // MAX for ST654, changed after we get
318 pCh
->BaudDivisor
= 96; // the boxids (UART types) later
326 pCh
->speed
= CBR_9600
;
330 pCh
->ClosingDelay
= 5*HZ
/10;
331 pCh
->ClosingWaitTime
= 30*HZ
;
333 // Initialize task queue objects
334 INIT_WORK(&pCh
->tqueue_input
, do_input
);
335 INIT_WORK(&pCh
->tqueue_status
, do_status
);
337 #ifdef IP2DEBUG_TRACE
338 pCh
->trace
= ip2trace
;
344 // No need to check for wrap here; this is initialization.
345 pB
->i2Fbuf_stuff
= stuffIndex
;
346 COMPLETE(pB
, I2EE_GOOD
);
350 //******************************************************************************
351 // Function: i2DeQueueNeeds(pB, type)
352 // Parameters: Pointer to a board structure
353 // type bit map: may include NEED_INLINE, NEED_BYPASS, or NEED_FLOW
355 // Pointer to a channel structure
357 // Description: Returns pointer struct of next channel that needs service of
358 // the type specified. Otherwise returns a NULL reference.
360 //******************************************************************************
362 i2DeQueueNeeds(i2eBordStrPtr pB
, int type
)
364 unsigned short queueIndex
;
367 i2ChanStrPtr pCh
= NULL
;
373 WRITE_LOCK_IRQSAVE(&pB
->Dbuf_spinlock
,flags
);
374 if ( pB
->i2Dbuf_stuff
!= pB
->i2Dbuf_strip
)
376 queueIndex
= pB
->i2Dbuf_strip
;
377 pCh
= pB
->i2Dbuf
[queueIndex
];
379 if (queueIndex
>= CH_QUEUE_SIZE
) {
382 pB
->i2Dbuf_strip
= queueIndex
;
383 pCh
->channelNeeds
&= ~NEED_INLINE
;
385 WRITE_UNLOCK_IRQRESTORE(&pB
->Dbuf_spinlock
,flags
);
390 WRITE_LOCK_IRQSAVE(&pB
->Bbuf_spinlock
,flags
);
391 if (pB
->i2Bbuf_stuff
!= pB
->i2Bbuf_strip
)
393 queueIndex
= pB
->i2Bbuf_strip
;
394 pCh
= pB
->i2Bbuf
[queueIndex
];
396 if (queueIndex
>= CH_QUEUE_SIZE
) {
399 pB
->i2Bbuf_strip
= queueIndex
;
400 pCh
->channelNeeds
&= ~NEED_BYPASS
;
402 WRITE_UNLOCK_IRQRESTORE(&pB
->Bbuf_spinlock
,flags
);
407 WRITE_LOCK_IRQSAVE(&pB
->Fbuf_spinlock
,flags
);
408 if (pB
->i2Fbuf_stuff
!= pB
->i2Fbuf_strip
)
410 queueIndex
= pB
->i2Fbuf_strip
;
411 pCh
= pB
->i2Fbuf
[queueIndex
];
413 if (queueIndex
>= CH_QUEUE_SIZE
) {
416 pB
->i2Fbuf_strip
= queueIndex
;
417 pCh
->channelNeeds
&= ~NEED_FLOW
;
419 WRITE_UNLOCK_IRQRESTORE(&pB
->Fbuf_spinlock
,flags
);
422 printk(KERN_ERR
"i2DeQueueNeeds called with bad type:%x\n",type
);
428 //******************************************************************************
429 // Function: i2QueueNeeds(pB, pCh, type)
430 // Parameters: Pointer to a board structure
431 // Pointer to a channel structure
432 // type bit map: may include NEED_INLINE, NEED_BYPASS, or NEED_FLOW
436 // For each type of need selected, if the given channel is not already in the
437 // queue, adds it, and sets the flag indicating it is in the queue.
438 //******************************************************************************
440 i2QueueNeeds(i2eBordStrPtr pB
, i2ChanStrPtr pCh
, int type
)
442 unsigned short queueIndex
;
445 // We turn off all the interrupts during this brief process, since the
446 // interrupt-level code might want to put things on the queue as well.
452 WRITE_LOCK_IRQSAVE(&pB
->Dbuf_spinlock
,flags
);
453 if ( !(pCh
->channelNeeds
& NEED_INLINE
) )
455 pCh
->channelNeeds
|= NEED_INLINE
;
456 queueIndex
= pB
->i2Dbuf_stuff
;
457 pB
->i2Dbuf
[queueIndex
++] = pCh
;
458 if (queueIndex
>= CH_QUEUE_SIZE
)
460 pB
->i2Dbuf_stuff
= queueIndex
;
462 WRITE_UNLOCK_IRQRESTORE(&pB
->Dbuf_spinlock
,flags
);
467 WRITE_LOCK_IRQSAVE(&pB
->Bbuf_spinlock
,flags
);
468 if ((type
& NEED_BYPASS
) && !(pCh
->channelNeeds
& NEED_BYPASS
))
470 pCh
->channelNeeds
|= NEED_BYPASS
;
471 queueIndex
= pB
->i2Bbuf_stuff
;
472 pB
->i2Bbuf
[queueIndex
++] = pCh
;
473 if (queueIndex
>= CH_QUEUE_SIZE
)
475 pB
->i2Bbuf_stuff
= queueIndex
;
477 WRITE_UNLOCK_IRQRESTORE(&pB
->Bbuf_spinlock
,flags
);
482 WRITE_LOCK_IRQSAVE(&pB
->Fbuf_spinlock
,flags
);
483 if ((type
& NEED_FLOW
) && !(pCh
->channelNeeds
& NEED_FLOW
))
485 pCh
->channelNeeds
|= NEED_FLOW
;
486 queueIndex
= pB
->i2Fbuf_stuff
;
487 pB
->i2Fbuf
[queueIndex
++] = pCh
;
488 if (queueIndex
>= CH_QUEUE_SIZE
)
490 pB
->i2Fbuf_stuff
= queueIndex
;
492 WRITE_UNLOCK_IRQRESTORE(&pB
->Fbuf_spinlock
,flags
);
496 pCh
->channelNeeds
|= NEED_CREDIT
;
499 printk(KERN_ERR
"i2QueueNeeds called with bad type:%x\n",type
);
505 //******************************************************************************
506 // Function: i2QueueCommands(type, pCh, timeout, nCommands, pCs,...)
507 // Parameters: type - PTYPE_BYPASS or PTYPE_INLINE
508 // pointer to the channel structure
509 // maximum period to wait
510 // number of commands (n)
512 // Returns: Number of commands sent, or -1 for error
514 // get board lock before calling
517 // Queues up some commands to be sent to a channel. To send possibly several
518 // bypass or inline commands to the given channel. The timeout parameter
519 // indicates how many HUNDREDTHS OF SECONDS to wait until there is room:
520 // 0 = return immediately if no room, -ive = wait forever, +ive = number of
521 // 1/100 seconds to wait. Return values:
522 // -1 Some kind of nasty error: bad channel structure or invalid arguments.
523 // 0 No room to send all the commands
524 // (+) Number of commands sent
525 //******************************************************************************
527 i2QueueCommands(int type
, i2ChanStrPtr pCh
, int timeout
, int nCommands
,
528 cmdSyntaxPtr pCs0
,...)
539 unsigned short maxBlock
;
540 unsigned short maxBuff
;
542 unsigned short stuffIndex
;
544 unsigned char *pInsert
;
545 unsigned char *pDest
, *pSource
;
546 unsigned short channel
;
548 unsigned long flags
= 0;
549 rwlock_t
*lock_var_p
= NULL
;
551 // Make sure the channel exists, otherwise do nothing
552 if ( !i2Validate ( pCh
) ) {
556 ip2trace (CHANN
, ITRC_QUEUE
, ITRC_ENTER
, 0 );
560 // Board must also exist, and THE INTERRUPT COMMAND ALREADY SENT
561 if (pB
->i2eValid
!= I2E_MAGIC
|| pB
->i2eUsingIrq
== IRQ_UNDEFINED
) {
564 // If the board has gone fatal, return bad, and also hit the trap routine if
567 if ( pB
->i2eFatalTrap
) {
568 (*(pB
)->i2eFatalTrap
)(pB
);
572 // Set up some variables, Which buffers are we using? How big are they?
577 maxBlock
= MAX_OBUF_BLOCK
;
583 maxBlock
= MAX_CBUF_BLOCK
;
590 // Determine the total size required for all the commands
591 totalsize
= blocksize
= sizeof(i2CmdHeader
);
594 for ( count
= nCommands
; count
; count
--, ppCs
++)
598 // Will a new block be needed for this one?
599 // Two possible reasons: too
600 // big or previous command has to be at the end of a packet.
601 if ((blocksize
+ cnt
> maxBlock
) || lastended
) {
602 blocksize
= sizeof(i2CmdHeader
);
603 totalsize
+= sizeof(i2CmdHeader
);
608 // If this command had to end a block, then we will make sure to
609 // account for it should there be any more blocks.
610 lastended
= pCs
->flags
& END
;
613 // Make sure any pending flush commands go out before we add more data.
614 if ( !( pCh
->flush_flags
&& i2RetryFlushOutput( pCh
) ) ) {
615 // How much room (this time through) ?
618 lock_var_p
= &pCh
->Obuf_spinlock
;
619 WRITE_LOCK_IRQSAVE(lock_var_p
,flags
);
620 stuffIndex
= pCh
->Obuf_stuff
;
621 bufroom
= pCh
->Obuf_strip
- stuffIndex
;
624 lock_var_p
= &pCh
->Cbuf_spinlock
;
625 WRITE_LOCK_IRQSAVE(lock_var_p
,flags
);
626 stuffIndex
= pCh
->Cbuf_stuff
;
627 bufroom
= pCh
->Cbuf_strip
- stuffIndex
;
636 ip2trace (CHANN
, ITRC_QUEUE
, 2, 1, bufroom
);
638 // Check for overflow
639 if (totalsize
<= bufroom
) {
640 // Normal Expected path - We still hold LOCK
641 break; /* from for()- Enough room: goto proceed */
645 ip2trace (CHANN
, ITRC_QUEUE
, 3, 1, totalsize
);
647 // Prepare to wait for buffers to empty
648 WRITE_UNLOCK_IRQRESTORE(lock_var_p
,flags
);
649 serviceOutgoingFifo(pB
); // Dump what we got
652 return 0; // Tired of waiting
655 timeout
--; // So negative values == forever
657 if (!in_interrupt()) {
658 schedule_timeout_interruptible(1); // short nap
660 // we cannot sched/sleep in interrrupt silly
663 if (signal_pending(current
)) {
664 return 0; // Wake up! Time to die!!!
667 ip2trace (CHANN
, ITRC_QUEUE
, 4, 0 );
671 // At this point we have room and the lock - stick them in.
672 channel
= pCh
->infl
.hd
.i2sChannel
;
673 pInsert
= &pBuf
[stuffIndex
]; // Pointer to start of packet
674 pDest
= CMD_OF(pInsert
); // Pointer to start of command
676 // When we start counting, the block is the size of the header
677 for (blocksize
= sizeof(i2CmdHeader
), count
= nCommands
,
678 lastended
= 0, ppCs
= &pCs0
;
682 pCs
= *ppCs
; // Points to command protocol structure
684 // If this is a bookmark request command, post the fact that a bookmark
685 // request is pending. NOTE THIS TRICK ONLY WORKS BECAUSE CMD_BMARK_REQ
686 // has no parameters! The more general solution would be to reference
688 if (pCs
== CMD_BMARK_REQ
) {
691 ip2trace (CHANN
, ITRC_DRAIN
, 30, 1, pCh
->bookMarks
);
696 // If this command would put us over the maximum block size or
697 // if the last command had to be at the end of a block, we end
698 // the existing block here and start a new one.
699 if ((blocksize
+ cnt
> maxBlock
) || lastended
) {
701 ip2trace (CHANN
, ITRC_QUEUE
, 5, 0 );
703 PTYPE_OF(pInsert
) = type
;
704 CHANNEL_OF(pInsert
) = channel
;
705 // count here does not include the header
706 CMD_COUNT_OF(pInsert
) = blocksize
- sizeof(i2CmdHeader
);
707 stuffIndex
+= blocksize
;
708 if(stuffIndex
>= maxBuff
) {
712 pInsert
= &pBuf
[stuffIndex
]; // Pointer to start of next pkt
713 pDest
= CMD_OF(pInsert
);
714 blocksize
= sizeof(i2CmdHeader
);
716 // Now we know there is room for this one in the current block
718 blocksize
+= cnt
; // Total bytes in this command
719 pSource
= pCs
->cmd
; // Copy the command into the buffer
721 *pDest
++ = *pSource
++;
723 // If this command had to end a block, then we will make sure to account
724 // for it should there be any more blocks.
725 lastended
= pCs
->flags
& END
;
727 // Clean up the final block by writing header, etc
729 PTYPE_OF(pInsert
) = type
;
730 CHANNEL_OF(pInsert
) = channel
;
731 // count here does not include the header
732 CMD_COUNT_OF(pInsert
) = blocksize
- sizeof(i2CmdHeader
);
733 stuffIndex
+= blocksize
;
734 if(stuffIndex
>= maxBuff
) {
738 // Updates the index, and post the need for service. When adding these to
739 // the queue of channels, we turn off the interrupt while doing so,
740 // because at interrupt level we might want to push a channel back to the
745 pCh
->Obuf_stuff
= stuffIndex
; // Store buffer pointer
746 WRITE_UNLOCK_IRQRESTORE(&pCh
->Obuf_spinlock
,flags
);
748 pB
->debugInlineQueued
++;
749 // Add the channel pointer to list of channels needing service (first
750 // come...), if it's not already there.
751 i2QueueNeeds(pB
, pCh
, NEED_INLINE
);
755 pCh
->Cbuf_stuff
= stuffIndex
; // Store buffer pointer
756 WRITE_UNLOCK_IRQRESTORE(&pCh
->Cbuf_spinlock
,flags
);
758 pB
->debugBypassQueued
++;
759 // Add the channel pointer to list of channels needing service (first
760 // come...), if it's not already there.
761 i2QueueNeeds(pB
, pCh
, NEED_BYPASS
);
765 ip2trace (CHANN
, ITRC_QUEUE
, ITRC_RETURN
, 1, nCommands
);
767 return nCommands
; // Good status: number of commands sent
770 //******************************************************************************
771 // Function: i2GetStatus(pCh,resetBits)
772 // Parameters: Pointer to a channel structure
773 // Bit map of status bits to clear
774 // Returns: Bit map of current status bits
777 // Returns the state of data set signals, and whether a break has been received,
778 // (see i2lib.h for bit-mapped result). resetBits is a bit-map of any status
779 // bits to be cleared: I2_BRK, I2_PAR, I2_FRA, I2_OVR,... These are cleared
780 // AFTER the condition is passed. If pCh does not point to a valid channel,
781 // returns -1 (which would be impossible otherwise.
782 //******************************************************************************
784 i2GetStatus(i2ChanStrPtr pCh
, int resetBits
)
786 unsigned short status
;
789 ip2trace (CHANN
, ITRC_STATUS
, ITRC_ENTER
, 2, pCh
->dataSetIn
, resetBits
);
791 // Make sure the channel exists, otherwise do nothing */
792 if ( !i2Validate ( pCh
) )
797 status
= pCh
->dataSetIn
;
799 // Clear any specified error bits: but note that only actual error bits can
800 // be cleared, regardless of the value passed.
803 pCh
->dataSetIn
&= ~(resetBits
& (I2_BRK
| I2_PAR
| I2_FRA
| I2_OVR
));
804 pCh
->dataSetIn
&= ~(I2_DDCD
| I2_DCTS
| I2_DDSR
| I2_DRI
);
807 ip2trace (CHANN
, ITRC_STATUS
, ITRC_RETURN
, 1, pCh
->dataSetIn
);
812 //******************************************************************************
813 // Function: i2Input(pChpDest,count)
814 // Parameters: Pointer to a channel structure
815 // Pointer to data buffer
816 // Number of bytes to read
817 // Returns: Number of bytes read, or -1 for error
820 // Strips data from the input buffer and writes it to pDest. If there is a
821 // collosal blunder, (invalid structure pointers or the like), returns -1.
822 // Otherwise, returns the number of bytes read.
823 //******************************************************************************
825 i2Input(i2ChanStrPtr pCh
)
828 unsigned short stripIndex
;
830 unsigned long flags
= 0;
832 ip2trace (CHANN
, ITRC_INPUT
, ITRC_ENTER
, 0);
834 // Ensure channel structure seems real
835 if ( !i2Validate( pCh
) ) {
839 WRITE_LOCK_IRQSAVE(&pCh
->Ibuf_spinlock
,flags
);
841 // initialize some accelerators and private copies
842 stripIndex
= pCh
->Ibuf_strip
;
844 count
= pCh
->Ibuf_stuff
- stripIndex
;
846 // If buffer is empty or requested data count was 0, (trivial case) return
847 // without any further thought.
849 WRITE_UNLOCK_IRQRESTORE(&pCh
->Ibuf_spinlock
,flags
);
852 // Adjust for buffer wrap
856 // Don't give more than can be taken by the line discipline
857 amountToMove
= pCh
->pTTY
->receive_room
;
858 if (count
> amountToMove
) {
859 count
= amountToMove
;
861 // How much could we copy without a wrap?
862 amountToMove
= IBUF_SIZE
- stripIndex
;
864 if (amountToMove
> count
) {
865 amountToMove
= count
;
867 // Move the first block
868 pCh
->pTTY
->ldisc
.receive_buf( pCh
->pTTY
,
869 &(pCh
->Ibuf
[stripIndex
]), NULL
, amountToMove
);
870 // If we needed to wrap, do the second data move
871 if (count
> amountToMove
) {
872 pCh
->pTTY
->ldisc
.receive_buf( pCh
->pTTY
,
873 pCh
->Ibuf
, NULL
, count
- amountToMove
);
875 // Bump and wrap the stripIndex all at once by the amount of data read. This
876 // method is good regardless of whether the data was in one or two pieces.
878 if (stripIndex
>= IBUF_SIZE
) {
879 stripIndex
-= IBUF_SIZE
;
881 pCh
->Ibuf_strip
= stripIndex
;
883 // Update our flow control information and possibly queue ourselves to send
884 // it, depending on how much data has been stripped since the last time a
886 pCh
->infl
.asof
+= count
;
888 if ((pCh
->sinceLastFlow
+= count
) >= pCh
->whenSendFlow
) {
889 pCh
->sinceLastFlow
-= pCh
->whenSendFlow
;
890 WRITE_UNLOCK_IRQRESTORE(&pCh
->Ibuf_spinlock
,flags
);
891 i2QueueNeeds(pCh
->pMyBord
, pCh
, NEED_FLOW
);
893 WRITE_UNLOCK_IRQRESTORE(&pCh
->Ibuf_spinlock
,flags
);
898 ip2trace (CHANN
, ITRC_INPUT
, ITRC_RETURN
, 1, count
);
903 //******************************************************************************
904 // Function: i2InputFlush(pCh)
905 // Parameters: Pointer to a channel structure
906 // Returns: Number of bytes stripped, or -1 for error
909 // Strips any data from the input buffer. If there is a collosal blunder,
910 // (invalid structure pointers or the like), returns -1. Otherwise, returns the
911 // number of bytes stripped.
912 //******************************************************************************
914 i2InputFlush(i2ChanStrPtr pCh
)
919 // Ensure channel structure seems real
920 if ( !i2Validate ( pCh
) )
923 ip2trace (CHANN
, ITRC_INPUT
, 10, 0);
925 WRITE_LOCK_IRQSAVE(&pCh
->Ibuf_spinlock
,flags
);
926 count
= pCh
->Ibuf_stuff
- pCh
->Ibuf_strip
;
928 // Adjust for buffer wrap
933 // Expedient way to zero out the buffer
934 pCh
->Ibuf_strip
= pCh
->Ibuf_stuff
;
937 // Update our flow control information and possibly queue ourselves to send
938 // it, depending on how much data has been stripped since the last time a
941 pCh
->infl
.asof
+= count
;
943 if ( (pCh
->sinceLastFlow
+= count
) >= pCh
->whenSendFlow
)
945 pCh
->sinceLastFlow
-= pCh
->whenSendFlow
;
946 WRITE_UNLOCK_IRQRESTORE(&pCh
->Ibuf_spinlock
,flags
);
947 i2QueueNeeds(pCh
->pMyBord
, pCh
, NEED_FLOW
);
949 WRITE_UNLOCK_IRQRESTORE(&pCh
->Ibuf_spinlock
,flags
);
952 ip2trace (CHANN
, ITRC_INPUT
, 19, 1, count
);
957 //******************************************************************************
958 // Function: i2InputAvailable(pCh)
959 // Parameters: Pointer to a channel structure
960 // Returns: Number of bytes available, or -1 for error
963 // If there is a collosal blunder, (invalid structure pointers or the like),
964 // returns -1. Otherwise, returns the number of bytes stripped. Otherwise,
965 // returns the number of bytes available in the buffer.
966 //******************************************************************************
969 i2InputAvailable(i2ChanStrPtr pCh
)
973 // Ensure channel structure seems real
974 if ( !i2Validate ( pCh
) ) return -1;
977 // initialize some accelerators and private copies
978 READ_LOCK_IRQSAVE(&pCh
->Ibuf_spinlock
,flags
);
979 count
= pCh
->Ibuf_stuff
- pCh
->Ibuf_strip
;
980 READ_UNLOCK_IRQRESTORE(&pCh
->Ibuf_spinlock
,flags
);
982 // Adjust for buffer wrap
992 //******************************************************************************
993 // Function: i2Output(pCh, pSource, count)
994 // Parameters: Pointer to channel structure
995 // Pointer to source data
996 // Number of bytes to send
997 // Returns: Number of bytes sent, or -1 for error
1000 // Queues the data at pSource to be sent as data packets to the board. If there
1001 // is a collosal blunder, (invalid structure pointers or the like), returns -1.
1002 // Otherwise, returns the number of bytes written. What if there is not enough
1003 // room for all the data? If pCh->channelOptions & CO_NBLOCK_WRITE is set, then
1004 // we transfer as many characters as we can now, then return. If this bit is
1005 // clear (default), routine will spin along until all the data is buffered.
1006 // Should this occur, the 1-ms delay routine is called while waiting to avoid
1007 // applications that one cannot break out of.
1008 //******************************************************************************
1010 i2Output(i2ChanStrPtr pCh
, const char *pSource
, int count
)
1013 unsigned char *pInsert
;
1015 int countOriginal
= count
;
1016 unsigned short channel
;
1017 unsigned short stuffIndex
;
1018 unsigned long flags
;
1023 ip2trace (CHANN
, ITRC_OUTPUT
, ITRC_ENTER
, 2, count
, 0 );
1025 // Ensure channel structure seems real
1026 if ( !i2Validate ( pCh
) )
1029 // initialize some accelerators and private copies
1031 channel
= pCh
->infl
.hd
.i2sChannel
;
1033 // If the board has gone fatal, return bad, and also hit the trap routine if
1036 if (pB
->i2eFatalTrap
) {
1037 (*(pB
)->i2eFatalTrap
)(pB
);
1041 // Proceed as though we would do everything
1042 while ( count
> 0 ) {
1044 // How much room in output buffer is there?
1045 READ_LOCK_IRQSAVE(&pCh
->Obuf_spinlock
,flags
);
1046 amountToMove
= pCh
->Obuf_strip
- pCh
->Obuf_stuff
- 1;
1047 READ_UNLOCK_IRQRESTORE(&pCh
->Obuf_spinlock
,flags
);
1048 if (amountToMove
< 0) {
1049 amountToMove
+= OBUF_SIZE
;
1051 // Subtract off the headers size and see how much room there is for real
1052 // data. If this is negative, we will discover later.
1053 amountToMove
-= sizeof (i2DataHeader
);
1055 // Don't move more (now) than can go in a single packet
1056 if ( amountToMove
> (int)(MAX_OBUF_BLOCK
- sizeof(i2DataHeader
)) ) {
1057 amountToMove
= MAX_OBUF_BLOCK
- sizeof(i2DataHeader
);
1059 // Don't move more than the count we were given
1060 if (amountToMove
> count
) {
1061 amountToMove
= count
;
1063 // Now we know how much we must move: NB because the ring buffers have
1064 // an overflow area at the end, we needn't worry about wrapping in the
1065 // middle of a packet.
1067 // Small WINDOW here with no LOCK but I can't call Flush with LOCK
1068 // We would be flushing (or ending flush) anyway
1070 ip2trace (CHANN
, ITRC_OUTPUT
, 10, 1, amountToMove
);
1072 if ( !(pCh
->flush_flags
&& i2RetryFlushOutput(pCh
) )
1073 && amountToMove
> 0 )
1075 WRITE_LOCK_IRQSAVE(&pCh
->Obuf_spinlock
,flags
);
1076 stuffIndex
= pCh
->Obuf_stuff
;
1078 // Had room to move some data: don't know whether the block size,
1079 // buffer space, or what was the limiting factor...
1080 pInsert
= &(pCh
->Obuf
[stuffIndex
]);
1082 // Set up the header
1083 CHANNEL_OF(pInsert
) = channel
;
1084 PTYPE_OF(pInsert
) = PTYPE_DATA
;
1085 TAG_OF(pInsert
) = 0;
1086 ID_OF(pInsert
) = ID_ORDINARY_DATA
;
1087 DATA_COUNT_OF(pInsert
) = amountToMove
;
1090 memcpy( (char*)(DATA_OF(pInsert
)), pSource
, amountToMove
);
1091 // Adjust pointers and indices
1092 pSource
+= amountToMove
;
1093 pCh
->Obuf_char_count
+= amountToMove
;
1094 stuffIndex
+= amountToMove
+ sizeof(i2DataHeader
);
1095 count
-= amountToMove
;
1097 if (stuffIndex
>= OBUF_SIZE
) {
1100 pCh
->Obuf_stuff
= stuffIndex
;
1102 WRITE_UNLOCK_IRQRESTORE(&pCh
->Obuf_spinlock
,flags
);
1104 ip2trace (CHANN
, ITRC_OUTPUT
, 13, 1, stuffIndex
);
1109 // becuz we need to stuff a flush
1110 // or amount to move is <= 0
1112 ip2trace(CHANN
, ITRC_OUTPUT
, 14, 3,
1113 amountToMove
, pB
->i2eFifoRemains
,
1114 pB
->i2eWaitingForEmptyFifo
);
1116 // Put this channel back on queue
1117 // this ultimatly gets more data or wakes write output
1118 i2QueueNeeds(pB
, pCh
, NEED_INLINE
);
1120 if ( pB
->i2eWaitingForEmptyFifo
) {
1122 ip2trace (CHANN
, ITRC_OUTPUT
, 16, 0 );
1125 if (!in_interrupt()) {
1127 ip2trace (CHANN
, ITRC_OUTPUT
, 61, 0 );
1129 schedule_timeout_interruptible(2);
1130 if (signal_pending(current
)) {
1136 ip2trace (CHANN
, ITRC_OUTPUT
, 62, 0 );
1138 // let interrupt in = WAS restore_flags()
1139 // We hold no lock nor is irq off anymore???
1143 break; // from while(count)
1145 else if ( pB
->i2eFifoRemains
< 32 && !pB
->i2eTxMailEmpty ( pB
) )
1147 ip2trace (CHANN
, ITRC_OUTPUT
, 19, 2,
1149 pB
->i2eTxMailEmpty
);
1151 break; // from while(count)
1152 } else if ( pCh
->channelNeeds
& NEED_CREDIT
) {
1154 ip2trace (CHANN
, ITRC_OUTPUT
, 22, 0 );
1156 break; // from while(count)
1157 } else if ( --bailout
) {
1159 // Try to throw more things (maybe not us) in the fifo if we're
1160 // not already waiting for it.
1162 ip2trace (CHANN
, ITRC_OUTPUT
, 20, 0 );
1164 serviceOutgoingFifo(pB
);
1167 ip2trace (CHANN
, ITRC_OUTPUT
, 21, 3,
1169 pB
->i2eOutMailWaiting
,
1170 pB
->i2eWaitingForEmptyFifo
);
1172 break; // from while(count)
1175 } // End of while(count)
1177 i2QueueNeeds(pB
, pCh
, NEED_INLINE
);
1179 // We drop through either when the count expires, or when there is some
1180 // count left, but there was a non-blocking write.
1181 if (countOriginal
> count
) {
1183 ip2trace (CHANN
, ITRC_OUTPUT
, 17, 2, countOriginal
, count
);
1185 serviceOutgoingFifo( pB
);
1188 ip2trace (CHANN
, ITRC_OUTPUT
, ITRC_RETURN
, 2, countOriginal
, count
);
1190 return countOriginal
- count
;
1193 //******************************************************************************
1194 // Function: i2FlushOutput(pCh)
1195 // Parameters: Pointer to a channel structure
1199 // Sends bypass command to start flushing (waiting possibly forever until there
1200 // is room), then sends inline command to stop flushing output, (again waiting
1201 // possibly forever).
1202 //******************************************************************************
1204 i2FlushOutput(i2ChanStrPtr pCh
)
1207 ip2trace (CHANN
, ITRC_FLUSH
, 1, 1, pCh
->flush_flags
);
1209 if (pCh
->flush_flags
)
1212 if ( 1 != i2QueueCommands(PTYPE_BYPASS
, pCh
, 0, 1, CMD_STARTFL
) ) {
1213 pCh
->flush_flags
= STARTFL_FLAG
; // Failed - flag for later
1215 ip2trace (CHANN
, ITRC_FLUSH
, 2, 0 );
1217 } else if ( 1 != i2QueueCommands(PTYPE_INLINE
, pCh
, 0, 1, CMD_STOPFL
) ) {
1218 pCh
->flush_flags
= STOPFL_FLAG
; // Failed - flag for later
1220 ip2trace (CHANN
, ITRC_FLUSH
, 3, 0 );
1225 i2RetryFlushOutput(i2ChanStrPtr pCh
)
1227 int old_flags
= pCh
->flush_flags
;
1229 ip2trace (CHANN
, ITRC_FLUSH
, 14, 1, old_flags
);
1231 pCh
->flush_flags
= 0; // Clear flag so we can avoid recursion
1232 // and queue the commands
1234 if ( old_flags
& STARTFL_FLAG
) {
1235 if ( 1 == i2QueueCommands(PTYPE_BYPASS
, pCh
, 0, 1, CMD_STARTFL
) ) {
1236 old_flags
= STOPFL_FLAG
; //Success - send stop flush
1238 old_flags
= STARTFL_FLAG
; //Failure - Flag for retry later
1241 ip2trace (CHANN
, ITRC_FLUSH
, 15, 1, old_flags
);
1244 if ( old_flags
& STOPFL_FLAG
) {
1245 if (1 == i2QueueCommands(PTYPE_INLINE
, pCh
, 0, 1, CMD_STOPFL
)) {
1246 old_flags
= 0; // Success - clear flags
1249 ip2trace (CHANN
, ITRC_FLUSH
, 16, 1, old_flags
);
1251 pCh
->flush_flags
= old_flags
;
1253 ip2trace (CHANN
, ITRC_FLUSH
, 17, 1, old_flags
);
1258 //******************************************************************************
1259 // Function: i2DrainOutput(pCh,timeout)
1260 // Parameters: Pointer to a channel structure
1261 // Maximum period to wait
1265 // Uses the bookmark request command to ask the board to send a bookmark back as
1266 // soon as all the data is completely sent.
1267 //******************************************************************************
1269 i2DrainWakeup(i2ChanStrPtr pCh
)
1271 ip2trace (CHANN
, ITRC_DRAIN
, 10, 1, pCh
->BookmarkTimer
.expires
);
1273 pCh
->BookmarkTimer
.expires
= 0;
1274 wake_up_interruptible( &pCh
->pBookmarkWait
);
1278 i2DrainOutput(i2ChanStrPtr pCh
, int timeout
)
1283 ip2trace (CHANN
, ITRC_DRAIN
, ITRC_ENTER
, 1, pCh
->BookmarkTimer
.expires
);
1286 // If the board has gone fatal, return bad,
1287 // and also hit the trap routine if it exists.
1289 if (pB
->i2eFatalTrap
) {
1290 (*(pB
)->i2eFatalTrap
)(pB
);
1294 if ((timeout
> 0) && (pCh
->BookmarkTimer
.expires
== 0 )) {
1295 // One per customer (channel)
1296 init_timer( &(pCh
->BookmarkTimer
) );
1297 pCh
->BookmarkTimer
.expires
= jiffies
+ timeout
;
1298 pCh
->BookmarkTimer
.function
= (void*)(unsigned long)i2DrainWakeup
;
1299 pCh
->BookmarkTimer
.data
= (unsigned long)pCh
;
1301 ip2trace (CHANN
, ITRC_DRAIN
, 1, 1, pCh
->BookmarkTimer
.expires
);
1303 add_timer( &(pCh
->BookmarkTimer
) );
1306 i2QueueCommands( PTYPE_INLINE
, pCh
, -1, 1, CMD_BMARK_REQ
);
1308 init_waitqueue_entry(&wait
, current
);
1309 add_wait_queue(&(pCh
->pBookmarkWait
), &wait
);
1310 set_current_state( TASK_INTERRUPTIBLE
);
1312 serviceOutgoingFifo( pB
);
1314 schedule(); // Now we take our interruptible sleep on
1316 // Clean up the queue
1317 set_current_state( TASK_RUNNING
);
1318 remove_wait_queue(&(pCh
->pBookmarkWait
), &wait
);
1320 // if expires == 0 then timer poped, then do not need to del_timer
1321 if ((timeout
> 0) && pCh
->BookmarkTimer
.expires
&&
1322 time_before(jiffies
, pCh
->BookmarkTimer
.expires
)) {
1323 del_timer( &(pCh
->BookmarkTimer
) );
1324 pCh
->BookmarkTimer
.expires
= 0;
1326 ip2trace (CHANN
, ITRC_DRAIN
, 3, 1, pCh
->BookmarkTimer
.expires
);
1329 ip2trace (CHANN
, ITRC_DRAIN
, ITRC_RETURN
, 1, pCh
->BookmarkTimer
.expires
);
1333 //******************************************************************************
1334 // Function: i2OutputFree(pCh)
1335 // Parameters: Pointer to a channel structure
1336 // Returns: Space in output buffer
1339 // Returns -1 if very gross error. Otherwise returns the amount of bytes still
1340 // free in the output buffer.
1341 //******************************************************************************
1343 i2OutputFree(i2ChanStrPtr pCh
)
1346 unsigned long flags
;
1348 // Ensure channel structure seems real
1349 if ( !i2Validate ( pCh
) ) {
1352 READ_LOCK_IRQSAVE(&pCh
->Obuf_spinlock
,flags
);
1353 amountToMove
= pCh
->Obuf_strip
- pCh
->Obuf_stuff
- 1;
1354 READ_UNLOCK_IRQRESTORE(&pCh
->Obuf_spinlock
,flags
);
1356 if (amountToMove
< 0) {
1357 amountToMove
+= OBUF_SIZE
;
1359 // If this is negative, we will discover later
1360 amountToMove
-= sizeof(i2DataHeader
);
1362 return (amountToMove
< 0) ? 0 : amountToMove
;
1370 if (tp
== NULL
) return;
1372 pCh
= tp
->driver_data
;
1374 ip2trace (CHANN
, ITRC_SICMD
, 10, 2, tp
->flags
,
1375 (1 << TTY_DO_WRITE_WAKEUP
) );
1377 wake_up_interruptible ( &tp
->write_wait
);
1378 if ( ( tp
->flags
& (1 << TTY_DO_WRITE_WAKEUP
) )
1379 && tp
->ldisc
.write_wakeup
)
1381 (tp
->ldisc
.write_wakeup
) ( tp
);
1383 ip2trace (CHANN
, ITRC_SICMD
, 11, 0 );
1389 set_baud_params(i2eBordStrPtr pB
)
1394 pCh
= (i2ChanStrPtr
*) pB
->i2eChannelPtr
;
1396 for (i
= 0; i
< ABS_MAX_BOXES
; i
++) {
1397 if (pB
->channelBtypes
.bid_value
[i
]) {
1398 if (BID_HAS_654(pB
->channelBtypes
.bid_value
[i
])) {
1399 for (j
= 0; j
< ABS_BIGGEST_BOX
; j
++) {
1400 if (pCh
[i
*16+j
] == NULL
)
1402 (pCh
[i
*16+j
])->BaudBase
= 921600; // MAX for ST654
1403 (pCh
[i
*16+j
])->BaudDivisor
= 96;
1405 } else { // has cirrus cd1400
1406 for (j
= 0; j
< ABS_BIGGEST_BOX
; j
++) {
1407 if (pCh
[i
*16+j
] == NULL
)
1409 (pCh
[i
*16+j
])->BaudBase
= 115200; // MAX for CD1400
1410 (pCh
[i
*16+j
])->BaudDivisor
= 12;
1417 //******************************************************************************
1418 // Function: i2StripFifo(pB)
1419 // Parameters: Pointer to a board structure
1423 // Strips all the available data from the incoming FIFO, identifies the type of
1424 // packet, and either buffers the data or does what needs to be done.
1426 // Note there is no overflow checking here: if the board sends more data than it
1427 // ought to, we will not detect it here, but blindly overflow...
1428 //******************************************************************************
1430 // A buffer for reading in blocks for unknown channels
1431 static unsigned char junkBuffer
[IBUF_SIZE
];
1433 // A buffer to read in a status packet. Because of the size of the count field
1434 // for these things, the maximum packet size must be less than MAX_CMD_PACK_SIZE
1435 static unsigned char cmdBuffer
[MAX_CMD_PACK_SIZE
+ 4];
1437 // This table changes the bit order from MSR order given by STAT_MODEM packet to
1438 // status bits used in our library.
1439 static char xlatDss
[16] = {
1441 0 | 0 | 0 | I2_CTS
,
1442 0 | 0 | I2_DSR
| 0 ,
1443 0 | 0 | I2_DSR
| I2_CTS
,
1445 0 | I2_RI
| 0 | I2_CTS
,
1446 0 | I2_RI
| I2_DSR
| 0 ,
1447 0 | I2_RI
| I2_DSR
| I2_CTS
,
1448 I2_DCD
| 0 | 0 | 0 ,
1449 I2_DCD
| 0 | 0 | I2_CTS
,
1450 I2_DCD
| 0 | I2_DSR
| 0 ,
1451 I2_DCD
| 0 | I2_DSR
| I2_CTS
,
1452 I2_DCD
| I2_RI
| 0 | 0 ,
1453 I2_DCD
| I2_RI
| 0 | I2_CTS
,
1454 I2_DCD
| I2_RI
| I2_DSR
| 0 ,
1455 I2_DCD
| I2_RI
| I2_DSR
| I2_CTS
};
1458 i2StripFifo(i2eBordStrPtr pB
)
1463 unsigned short stuffIndex
;
1465 unsigned char *pc
, *pcLimit
;
1467 unsigned char dss_change
;
1468 unsigned long bflags
,cflags
;
1470 // ip2trace (ITRC_NO_PORT, ITRC_SFIFO, ITRC_ENTER, 0 );
1472 while (HAS_INPUT(pB
)) {
1473 // ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 2, 0 );
1475 // Process packet from fifo a one atomic unit
1476 WRITE_LOCK_IRQSAVE(&pB
->read_fifo_spinlock
,bflags
);
1478 // The first word (or two bytes) will have channel number and type of
1479 // packet, possibly other information
1480 pB
->i2eLeadoffWord
[0] = iiReadWord(pB
);
1482 switch(PTYPE_OF(pB
->i2eLeadoffWord
))
1487 // ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 3, 0 );
1489 channel
= CHANNEL_OF(pB
->i2eLeadoffWord
); /* Store channel */
1490 count
= iiReadWord(pB
); /* Count is in the next word */
1492 // NEW: Check the count for sanity! Should the hardware fail, our death
1493 // is more pleasant. While an oversize channel is acceptable (just more
1494 // than the driver supports), an over-length count clearly means we are
1496 if ( ((unsigned int)count
) > IBUF_SIZE
) {
1498 WRITE_UNLOCK_IRQRESTORE(&pB
->read_fifo_spinlock
,bflags
);
1499 return; /* Bail out ASAP */
1501 // Channel is illegally big ?
1502 if ((channel
>= pB
->i2eChannelCnt
) ||
1503 (NULL
==(pCh
= ((i2ChanStrPtr
*)pB
->i2eChannelPtr
)[channel
])))
1505 iiReadBuf(pB
, junkBuffer
, count
);
1506 WRITE_UNLOCK_IRQRESTORE(&pB
->read_fifo_spinlock
,bflags
);
1507 break; /* From switch: ready for next packet */
1510 // Channel should be valid, then
1512 // If this is a hot-key, merely post its receipt for now. These are
1513 // always supposed to be 1-byte packets, so we won't even check the
1514 // count. Also we will post an acknowledgement to the board so that
1515 // more data can be forthcoming. Note that we are not trying to use
1516 // these sequences in this driver, merely to robustly ignore them.
1517 if(ID_OF(pB
->i2eLeadoffWord
) == ID_HOT_KEY
)
1519 pCh
->hotKeyIn
= iiReadWord(pB
) & 0xff;
1520 WRITE_UNLOCK_IRQRESTORE(&pB
->read_fifo_spinlock
,bflags
);
1521 i2QueueCommands(PTYPE_BYPASS
, pCh
, 0, 1, CMD_HOTACK
);
1522 break; /* From the switch: ready for next packet */
1525 // Normal data! We crudely assume there is room for the data in our
1526 // buffer because the board wouldn't have exceeded his credit limit.
1527 WRITE_LOCK_IRQSAVE(&pCh
->Ibuf_spinlock
,cflags
);
1528 // We have 2 locks now
1529 stuffIndex
= pCh
->Ibuf_stuff
;
1530 amountToRead
= IBUF_SIZE
- stuffIndex
;
1531 if (amountToRead
> count
)
1532 amountToRead
= count
;
1534 // stuffIndex would have been already adjusted so there would
1535 // always be room for at least one, and count is always at least
1538 iiReadBuf(pB
, &(pCh
->Ibuf
[stuffIndex
]), amountToRead
);
1539 pCh
->icount
.rx
+= amountToRead
;
1541 // Update the stuffIndex by the amount of data moved. Note we could
1542 // never ask for more data than would just fit. However, we might
1543 // have read in one more byte than we wanted because the read
1544 // rounds up to even bytes. If this byte is on the end of the
1545 // packet, and is padding, we ignore it. If the byte is part of
1546 // the actual data, we need to move it.
1548 stuffIndex
+= amountToRead
;
1550 if (stuffIndex
>= IBUF_SIZE
) {
1551 if ((amountToRead
& 1) && (count
> amountToRead
)) {
1552 pCh
->Ibuf
[0] = pCh
->Ibuf
[IBUF_SIZE
];
1560 // If there is anything left over, read it as well
1561 if (count
> amountToRead
) {
1562 amountToRead
= count
- amountToRead
;
1563 iiReadBuf(pB
, &(pCh
->Ibuf
[stuffIndex
]), amountToRead
);
1564 pCh
->icount
.rx
+= amountToRead
;
1565 stuffIndex
+= amountToRead
;
1568 // Update stuff index
1569 pCh
->Ibuf_stuff
= stuffIndex
;
1570 WRITE_UNLOCK_IRQRESTORE(&pCh
->Ibuf_spinlock
,cflags
);
1571 WRITE_UNLOCK_IRQRESTORE(&pB
->read_fifo_spinlock
,bflags
);
1574 schedule_work(&pCh
->tqueue_input
);
1576 do_input(&pCh
->tqueue_input
);
1579 // Note we do not need to maintain any flow-control credits at this
1580 // time: if we were to increment .asof and decrement .room, there
1581 // would be no net effect. Instead, when we strip data, we will
1582 // increment .asof and leave .room unchanged.
1584 break; // From switch: ready for next packet
1587 ip2trace (ITRC_NO_PORT
, ITRC_SFIFO
, 4, 0 );
1589 count
= CMD_COUNT_OF(pB
->i2eLeadoffWord
);
1591 iiReadBuf(pB
, cmdBuffer
, count
);
1592 // We can release early with buffer grab
1593 WRITE_UNLOCK_IRQRESTORE(&pB
->read_fifo_spinlock
,bflags
);
1596 pcLimit
= &(cmdBuffer
[count
]);
1598 while (pc
< pcLimit
) {
1601 ip2trace (channel
, ITRC_SFIFO
, 7, 2, channel
, *pc
);
1603 /* check for valid channel */
1604 if (channel
< pB
->i2eChannelCnt
1606 (pCh
= (((i2ChanStrPtr
*)pB
->i2eChannelPtr
)[channel
])) != NULL
1613 /* Breaks and modem signals are easy: just update status */
1615 if ( !(pCh
->dataSetIn
& I2_CTS
) )
1617 pCh
->dataSetIn
|= I2_DCTS
;
1621 pCh
->dataSetIn
|= I2_CTS
;
1625 if ( pCh
->dataSetIn
& I2_CTS
)
1627 pCh
->dataSetIn
|= I2_DCTS
;
1631 pCh
->dataSetIn
&= ~I2_CTS
;
1635 ip2trace (channel
, ITRC_MODEM
, 1, 1, pCh
->dataSetIn
);
1637 if ( !(pCh
->dataSetIn
& I2_DCD
) )
1639 ip2trace (CHANN
, ITRC_MODEM
, 2, 0 );
1640 pCh
->dataSetIn
|= I2_DDCD
;
1644 pCh
->dataSetIn
|= I2_DCD
;
1646 ip2trace (channel
, ITRC_MODEM
, 3, 1, pCh
->dataSetIn
);
1650 ip2trace (channel
, ITRC_MODEM
, 4, 1, pCh
->dataSetIn
);
1651 if ( pCh
->dataSetIn
& I2_DCD
)
1653 ip2trace (channel
, ITRC_MODEM
, 5, 0 );
1654 pCh
->dataSetIn
|= I2_DDCD
;
1658 pCh
->dataSetIn
&= ~I2_DCD
;
1660 ip2trace (channel
, ITRC_MODEM
, 6, 1, pCh
->dataSetIn
);
1664 if ( !(pCh
->dataSetIn
& I2_DSR
) )
1666 pCh
->dataSetIn
|= I2_DDSR
;
1670 pCh
->dataSetIn
|= I2_DSR
;
1674 if ( pCh
->dataSetIn
& I2_DSR
)
1676 pCh
->dataSetIn
|= I2_DDSR
;
1680 pCh
->dataSetIn
&= ~I2_DSR
;
1684 if ( !(pCh
->dataSetIn
& I2_RI
) )
1686 pCh
->dataSetIn
|= I2_DRI
;
1690 pCh
->dataSetIn
|= I2_RI
;
1694 // to be compat with serial.c
1695 //if ( pCh->dataSetIn & I2_RI )
1697 // pCh->dataSetIn |= I2_DRI;
1698 // pCh->icount.rng++;
1701 pCh
->dataSetIn
&= ~I2_RI
;
1705 pCh
->dataSetIn
|= I2_BRK
;
1710 // Bookmarks? one less request we're waiting for
1713 if (pCh
->bookMarks
<= 0 ) {
1715 wake_up_interruptible( &pCh
->pBookmarkWait
);
1717 ip2trace (channel
, ITRC_DRAIN
, 20, 1, pCh
->BookmarkTimer
.expires
);
1721 // Flow control packets? Update the new credits, and if
1722 // someone was waiting for output, queue him up again.
1725 ((flowStatPtr
)pc
)->room
-
1726 (pCh
->outfl
.asof
- ((flowStatPtr
)pc
)->asof
);
1728 ip2trace (channel
, ITRC_STFLW
, 1, 1, pCh
->outfl
.room
);
1730 if (pCh
->channelNeeds
& NEED_CREDIT
)
1732 ip2trace (channel
, ITRC_STFLW
, 2, 1, pCh
->channelNeeds
);
1734 pCh
->channelNeeds
&= ~NEED_CREDIT
;
1735 i2QueueNeeds(pB
, pCh
, NEED_INLINE
);
1737 ip2_owake(pCh
->pTTY
);
1740 ip2trace (channel
, ITRC_STFLW
, 3, 1, pCh
->channelNeeds
);
1742 pc
+= sizeof(flowStat
);
1745 /* Special packets: */
1746 /* Just copy the information into the channel structure */
1750 pCh
->channelStatus
= *((debugStatPtr
)pc
);
1751 pc
+= sizeof(debugStat
);
1756 pCh
->channelTcount
= *((cntStatPtr
)pc
);
1757 pc
+= sizeof(cntStat
);
1762 pCh
->channelRcount
= *((cntStatPtr
)pc
);
1763 pc
+= sizeof(cntStat
);
1767 pB
->channelBtypes
= *((bidStatPtr
)pc
);
1768 pc
+= sizeof(bidStat
);
1769 set_baud_params(pB
);
1773 i2QueueCommands (PTYPE_INLINE
, pCh
, 0, 1, CMD_HW_TEST
);
1774 pCh
->channelFail
= *((failStatPtr
)pc
);
1775 pc
+= sizeof(failStat
);
1778 /* No explicit match? then
1779 * Might be an error packet...
1782 switch (uc
& STAT_MOD_ERROR
)
1785 if (uc
& STAT_E_PARITY
) {
1786 pCh
->dataSetIn
|= I2_PAR
;
1787 pCh
->icount
.parity
++;
1789 if (uc
& STAT_E_FRAMING
){
1790 pCh
->dataSetIn
|= I2_FRA
;
1791 pCh
->icount
.frame
++;
1793 if (uc
& STAT_E_OVERRUN
){
1794 pCh
->dataSetIn
|= I2_OVR
;
1795 pCh
->icount
.overrun
++;
1800 // the answer to DSS_NOW request (not change)
1801 pCh
->dataSetIn
= (pCh
->dataSetIn
1802 & ~(I2_RI
| I2_CTS
| I2_DCD
| I2_DSR
) )
1803 | xlatDss
[uc
& 0xf];
1804 wake_up_interruptible ( &pCh
->dss_now_wait
);
1808 } /* End of switch on status type */
1811 schedule_work(&pCh
->tqueue_status
);
1813 do_status(&pCh
->tqueue_status
);
1817 else /* Or else, channel is invalid */
1819 // Even though the channel is invalid, we must test the
1820 // status to see how much additional data it has (to be
1825 pc
+= 4; /* Skip the data */
1832 } // End of while (there is still some status packet left)
1835 default: // Neither packet? should be impossible
1836 ip2trace (ITRC_NO_PORT
, ITRC_SFIFO
, 5, 1,
1837 PTYPE_OF(pB
->i2eLeadoffWord
) );
1840 } // End of switch on type of packets
1841 } //while(board HAS_INPUT)
1843 ip2trace (ITRC_NO_PORT
, ITRC_SFIFO
, ITRC_RETURN
, 0 );
1845 // Send acknowledgement to the board even if there was no data!
1846 pB
->i2eOutMailWaiting
|= MB_IN_STRIPPED
;
1850 //******************************************************************************
1851 // Function: i2Write2Fifo(pB,address,count)
1852 // Parameters: Pointer to a board structure, source address, byte count
1853 // Returns: bytes written
1856 // Writes count bytes to board io address(implied) from source
1857 // Adjusts count, leaves reserve for next time around bypass cmds
1858 //******************************************************************************
1860 i2Write2Fifo(i2eBordStrPtr pB
, unsigned char *source
, int count
,int reserve
)
1863 unsigned long flags
;
1864 WRITE_LOCK_IRQSAVE(&pB
->write_fifo_spinlock
,flags
);
1865 if (!pB
->i2eWaitingForEmptyFifo
) {
1866 if (pB
->i2eFifoRemains
> (count
+reserve
)) {
1867 pB
->i2eFifoRemains
-= count
;
1868 iiWriteBuf(pB
, source
, count
);
1869 pB
->i2eOutMailWaiting
|= MB_OUT_STUFFED
;
1873 WRITE_UNLOCK_IRQRESTORE(&pB
->write_fifo_spinlock
,flags
);
1876 //******************************************************************************
1877 // Function: i2StuffFifoBypass(pB)
1878 // Parameters: Pointer to a board structure
1882 // Stuffs as many bypass commands into the fifo as possible. This is simpler
1883 // than stuffing data or inline commands to fifo, since we do not have
1884 // flow-control to deal with.
1885 //******************************************************************************
1887 i2StuffFifoBypass(i2eBordStrPtr pB
)
1890 unsigned char *pRemove
;
1891 unsigned short stripIndex
;
1892 unsigned short packetSize
;
1893 unsigned short paddedSize
;
1894 unsigned short notClogged
= 1;
1895 unsigned long flags
;
1899 // Continue processing so long as there are entries, or there is room in the
1900 // fifo. Each entry represents a channel with something to do.
1901 while ( --bailout
&& notClogged
&&
1902 (NULL
!= (pCh
= i2DeQueueNeeds(pB
,NEED_BYPASS
))))
1904 WRITE_LOCK_IRQSAVE(&pCh
->Cbuf_spinlock
,flags
);
1905 stripIndex
= pCh
->Cbuf_strip
;
1907 // as long as there are packets for this channel...
1909 while (stripIndex
!= pCh
->Cbuf_stuff
) {
1910 pRemove
= &(pCh
->Cbuf
[stripIndex
]);
1911 packetSize
= CMD_COUNT_OF(pRemove
) + sizeof(i2CmdHeader
);
1912 paddedSize
= ROUNDUP(packetSize
);
1914 if (paddedSize
> 0) {
1915 if ( 0 == i2Write2Fifo(pB
, pRemove
, paddedSize
,0)) {
1916 notClogged
= 0; /* fifo full */
1917 i2QueueNeeds(pB
, pCh
, NEED_BYPASS
); // Put back on queue
1918 break; // Break from the channel
1922 WriteDBGBuf("BYPS", pRemove
, paddedSize
);
1923 #endif /* DEBUG_FIFO */
1924 pB
->debugBypassCount
++;
1926 pRemove
+= packetSize
;
1927 stripIndex
+= packetSize
;
1928 if (stripIndex
>= CBUF_SIZE
) {
1930 pRemove
= pCh
->Cbuf
;
1933 // Done with this channel. Move to next, removing this one from
1934 // the queue of channels if we cleaned it out (i.e., didn't get clogged.
1935 pCh
->Cbuf_strip
= stripIndex
;
1936 WRITE_UNLOCK_IRQRESTORE(&pCh
->Cbuf_spinlock
,flags
);
1937 } // Either clogged or finished all the work
1939 #ifdef IP2DEBUG_TRACE
1941 ip2trace (ITRC_NO_PORT
, ITRC_ERROR
, 1, 0 );
1946 //******************************************************************************
1947 // Function: i2StuffFifoFlow(pB)
1948 // Parameters: Pointer to a board structure
1952 // Stuffs as many flow control packets into the fifo as possible. This is easier
1953 // even than doing normal bypass commands, because there is always at most one
1954 // packet, already assembled, for each channel.
1955 //******************************************************************************
1957 i2StuffFifoFlow(i2eBordStrPtr pB
)
1960 unsigned short paddedSize
= ROUNDUP(sizeof(flowIn
));
1962 ip2trace (ITRC_NO_PORT
, ITRC_SFLOW
, ITRC_ENTER
, 2,
1963 pB
->i2eFifoRemains
, paddedSize
);
1965 // Continue processing so long as there are entries, or there is room in the
1966 // fifo. Each entry represents a channel with something to do.
1967 while ( (NULL
!= (pCh
= i2DeQueueNeeds(pB
,NEED_FLOW
)))) {
1968 pB
->debugFlowCount
++;
1970 // NO Chan LOCK needed ???
1971 if ( 0 == i2Write2Fifo(pB
,(unsigned char *)&(pCh
->infl
),paddedSize
,0)) {
1975 WriteDBGBuf("FLOW",(unsigned char *) &(pCh
->infl
), paddedSize
);
1976 #endif /* DEBUG_FIFO */
1978 } // Either clogged or finished all the work
1980 ip2trace (ITRC_NO_PORT
, ITRC_SFLOW
, ITRC_RETURN
, 0 );
1983 //******************************************************************************
1984 // Function: i2StuffFifoInline(pB)
1985 // Parameters: Pointer to a board structure
1989 // Stuffs as much data and inline commands into the fifo as possible. This is
1990 // the most complex fifo-stuffing operation, since there if now the channel
1991 // flow-control issue to deal with.
1992 //******************************************************************************
1994 i2StuffFifoInline(i2eBordStrPtr pB
)
1997 unsigned char *pRemove
;
1998 unsigned short stripIndex
;
1999 unsigned short packetSize
;
2000 unsigned short paddedSize
;
2001 unsigned short notClogged
= 1;
2002 unsigned short flowsize
;
2003 unsigned long flags
;
2008 ip2trace (ITRC_NO_PORT
, ITRC_SICMD
, ITRC_ENTER
, 3, pB
->i2eFifoRemains
,
2009 pB
->i2Dbuf_strip
, pB
->i2Dbuf_stuff
);
2011 // Continue processing so long as there are entries, or there is room in the
2012 // fifo. Each entry represents a channel with something to do.
2013 while ( --bailout
&& notClogged
&&
2014 (NULL
!= (pCh
= i2DeQueueNeeds(pB
,NEED_INLINE
))) )
2016 WRITE_LOCK_IRQSAVE(&pCh
->Obuf_spinlock
,flags
);
2017 stripIndex
= pCh
->Obuf_strip
;
2019 ip2trace (CHANN
, ITRC_SICMD
, 3, 2, stripIndex
, pCh
->Obuf_stuff
);
2021 // as long as there are packets for this channel...
2023 while ( --bailout2
&& stripIndex
!= pCh
->Obuf_stuff
) {
2024 pRemove
= &(pCh
->Obuf
[stripIndex
]);
2026 // Must determine whether this be a data or command packet to
2027 // calculate correctly the header size and the amount of
2028 // flow-control credit this type of packet will use.
2029 if (PTYPE_OF(pRemove
) == PTYPE_DATA
) {
2030 flowsize
= DATA_COUNT_OF(pRemove
);
2031 packetSize
= flowsize
+ sizeof(i2DataHeader
);
2033 flowsize
= CMD_COUNT_OF(pRemove
);
2034 packetSize
= flowsize
+ sizeof(i2CmdHeader
);
2036 flowsize
= CREDIT_USAGE(flowsize
);
2037 paddedSize
= ROUNDUP(packetSize
);
2039 ip2trace (CHANN
, ITRC_SICMD
, 4, 2, pB
->i2eFifoRemains
, paddedSize
);
2041 // If we don't have enough credits from the board to send the data,
2042 // flag the channel that we are waiting for flow control credit, and
2043 // break out. This will clean up this channel and remove us from the
2044 // queue of hot things to do.
2046 ip2trace (CHANN
, ITRC_SICMD
, 5, 2, pCh
->outfl
.room
, flowsize
);
2048 if (pCh
->outfl
.room
<= flowsize
) {
2049 // Do Not have the credits to send this packet.
2050 i2QueueNeeds(pB
, pCh
, NEED_CREDIT
);
2052 break; // So to do next channel
2054 if ( (paddedSize
> 0)
2055 && ( 0 == i2Write2Fifo(pB
, pRemove
, paddedSize
, 128))) {
2056 // Do Not have room in fifo to send this packet.
2058 i2QueueNeeds(pB
, pCh
, NEED_INLINE
);
2059 break; // Break from the channel
2062 WriteDBGBuf("DATA", pRemove
, paddedSize
);
2063 #endif /* DEBUG_FIFO */
2064 pB
->debugInlineCount
++;
2066 pCh
->icount
.tx
+= flowsize
;
2067 // Update current credits
2068 pCh
->outfl
.room
-= flowsize
;
2069 pCh
->outfl
.asof
+= flowsize
;
2070 if (PTYPE_OF(pRemove
) == PTYPE_DATA
) {
2071 pCh
->Obuf_char_count
-= DATA_COUNT_OF(pRemove
);
2073 pRemove
+= packetSize
;
2074 stripIndex
+= packetSize
;
2076 ip2trace (CHANN
, ITRC_SICMD
, 6, 2, stripIndex
, pCh
->Obuf_strip
);
2078 if (stripIndex
>= OBUF_SIZE
) {
2080 pRemove
= pCh
->Obuf
;
2082 ip2trace (CHANN
, ITRC_SICMD
, 7, 1, stripIndex
);
2087 ip2trace (CHANN
, ITRC_ERROR
, 3, 0 );
2089 // Done with this channel. Move to next, removing this one from the
2090 // queue of channels if we cleaned it out (i.e., didn't get clogged.
2091 pCh
->Obuf_strip
= stripIndex
;
2092 WRITE_UNLOCK_IRQRESTORE(&pCh
->Obuf_spinlock
,flags
);
2096 ip2trace (CHANN
, ITRC_SICMD
, 8, 0 );
2099 ip2_owake(pCh
->pTTY
);
2102 } // Either clogged or finished all the work
2105 ip2trace (ITRC_NO_PORT
, ITRC_ERROR
, 4, 0 );
2108 ip2trace (ITRC_NO_PORT
, ITRC_SICMD
, ITRC_RETURN
, 1,pB
->i2Dbuf_strip
);
2111 //******************************************************************************
2112 // Function: serviceOutgoingFifo(pB)
2113 // Parameters: Pointer to a board structure
2117 // Helper routine to put data in the outgoing fifo, if we aren't already waiting
2118 // for something to be there. If the fifo has only room for a very little data,
2119 // go head and hit the board with a mailbox hit immediately. Otherwise, it will
2120 // have to happen later in the interrupt processing. Since this routine may be
2121 // called both at interrupt and foreground time, we must turn off interrupts
2122 // during the entire process.
2123 //******************************************************************************
2125 serviceOutgoingFifo(i2eBordStrPtr pB
)
2127 // If we aren't currently waiting for the board to empty our fifo, service
2128 // everything that is pending, in priority order (especially, Bypass before
2130 if ( ! pB
->i2eWaitingForEmptyFifo
)
2132 i2StuffFifoFlow(pB
);
2133 i2StuffFifoBypass(pB
);
2134 i2StuffFifoInline(pB
);
2136 iiSendPendingMail(pB
);
2140 //******************************************************************************
2141 // Function: i2ServiceBoard(pB)
2142 // Parameters: Pointer to a board structure
2146 // Normally this is called from interrupt level, but there is deliberately
2147 // nothing in here specific to being called from interrupt level. All the
2148 // hardware-specific, interrupt-specific things happen at the outer levels.
2150 // For example, a timer interrupt could drive this routine for some sort of
2151 // polled operation. The only requirement is that the programmer deal with any
2152 // atomiticity/concurrency issues that result.
2154 // This routine responds to the board's having sent mailbox information to the
2155 // host (which would normally cause an interrupt). This routine reads the
2156 // incoming mailbox. If there is no data in it, this board did not create the
2157 // interrupt and/or has nothing to be done to it. (Except, if we have been
2158 // waiting to write mailbox data to it, we may do so.
2160 // Based on the value in the mailbox, we may take various actions.
2162 // No checking here of pB validity: after all, it shouldn't have been called by
2163 // the handler unless pB were on the list.
2164 //******************************************************************************
2166 i2ServiceBoard ( i2eBordStrPtr pB
)
2169 unsigned long flags
;
2172 /* This should be atomic because of the way we are called... */
2173 if (NO_MAIL_HERE
== ( inmail
= pB
->i2eStartMail
) ) {
2174 inmail
= iiGetMail(pB
);
2176 pB
->i2eStartMail
= NO_MAIL_HERE
;
2178 ip2trace (ITRC_NO_PORT
, ITRC_INTR
, 2, 1, inmail
);
2180 if (inmail
!= NO_MAIL_HERE
) {
2181 // If the board has gone fatal, nothing to do but hit a bit that will
2182 // alert foreground tasks to protest!
2183 if ( inmail
& MB_FATAL_ERROR
) {
2185 goto exit_i2ServiceBoard
;
2188 /* Assuming no fatal condition, we proceed to do work */
2189 if ( inmail
& MB_IN_STUFFED
) {
2190 pB
->i2eFifoInInts
++;
2191 i2StripFifo(pB
); /* There might be incoming packets */
2194 if (inmail
& MB_OUT_STRIPPED
) {
2195 pB
->i2eFifoOutInts
++;
2196 WRITE_LOCK_IRQSAVE(&pB
->write_fifo_spinlock
,flags
);
2197 pB
->i2eFifoRemains
= pB
->i2eFifoSize
;
2198 pB
->i2eWaitingForEmptyFifo
= 0;
2199 WRITE_UNLOCK_IRQRESTORE(&pB
->write_fifo_spinlock
,flags
);
2201 ip2trace (ITRC_NO_PORT
, ITRC_INTR
, 30, 1, pB
->i2eFifoRemains
);
2204 serviceOutgoingFifo(pB
);
2207 ip2trace (ITRC_NO_PORT
, ITRC_INTR
, 8, 0 );
2209 exit_i2ServiceBoard
: