Linux 2.6.21.1
[linux/fpc-iii.git] / drivers / char / ip2 / i2lib.c
blobe46120d05b689af32f855e68a1656fd1d9794fd0
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 //------------------------------------------------------------------------------
19 // Note on Strategy:
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 //------------------------------------------------------------------------------
32 // Revision History:
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
48 // argument.
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
55 // some incoming.
57 // 1.1 - 12/25/96 AKM Linux version.
58 // - 10/09/98 DMC Revised Linux version.
59 //------------------------------------------------------------------------------
61 //************
62 //* Includes *
63 //************
65 #include <linux/sched.h>
66 #include "i2lib.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 *);
90 //***************
91 //* Debug Data *
92 //***************
93 #ifdef DEBUG_FIFO
95 unsigned char DBGBuf[0x4000];
96 unsigned short I = 0;
98 static void
99 WriteDBGBuf(char *s, unsigned char *src, unsigned short n )
101 char *p = src;
103 // XXX: We need a spin lock here if we ever use this again
105 while (*s) { // copy label
106 DBGBuf[I] = *s++;
107 I = I++ & 0x3fff;
109 while (n--) { // copy data
110 DBGBuf[I] = *p++;
111 I = I++ & 0x3fff;
115 static void
116 fatality(i2eBordStrPtr pB )
118 int i;
120 for (i=0;i<sizeof(DBGBuf);i++) {
121 if ((i%16) == 0)
122 printk("\n%4x:",i);
123 printk("%02x ",DBGBuf[i]);
125 printk("\n");
126 for (i=0;i<sizeof(DBGBuf);i++) {
127 if ((i%16) == 0)
128 printk("\n%4x:",i);
129 if (DBGBuf[i] >= ' ' && DBGBuf[i] <= '~') {
130 printk(" %c ",DBGBuf[i]);
131 } else {
132 printk(" . ");
135 printk("\n");
136 printk("Last index %x\n",I);
138 #endif /* DEBUG_FIFO */
140 //********
141 //* Code *
142 //********
144 static inline int
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 static void iiSendPendingMail_t(unsigned long data)
155 i2eBordStrPtr pB = (i2eBordStrPtr)data;
157 iiSendPendingMail(pB);
160 //******************************************************************************
161 // Function: iiSendPendingMail(pB)
162 // Parameters: Pointer to a board structure
163 // Returns: Nothing
165 // Description:
166 // If any outgoing mail bits are set and there is outgoing mailbox is empty,
167 // send the mail and clear the bits.
168 //******************************************************************************
169 static void
170 iiSendPendingMail(i2eBordStrPtr pB)
172 if (pB->i2eOutMailWaiting && (!pB->i2eWaitingForEmptyFifo) )
174 if (iiTrySendMail(pB, pB->i2eOutMailWaiting))
176 /* If we were already waiting for fifo to empty,
177 * or just sent MB_OUT_STUFFED, then we are
178 * still waiting for it to empty, until we should
179 * receive an MB_IN_STRIPPED from the board.
181 pB->i2eWaitingForEmptyFifo |=
182 (pB->i2eOutMailWaiting & MB_OUT_STUFFED);
183 pB->i2eOutMailWaiting = 0;
184 pB->SendPendingRetry = 0;
185 } else {
186 /* The only time we hit this area is when "iiTrySendMail" has
187 failed. That only occurs when the outbound mailbox is
188 still busy with the last message. We take a short breather
189 to let the board catch up with itself and then try again.
190 16 Retries is the limit - then we got a borked board.
191 /\/\|=mhw=|\/\/ */
193 if( ++pB->SendPendingRetry < 16 ) {
194 setup_timer(&pB->SendPendingTimer,
195 iiSendPendingMail_t, (unsigned long)pB);
196 mod_timer(&pB->SendPendingTimer, jiffies + 1);
197 } else {
198 printk( KERN_ERR "IP2: iiSendPendingMail unable to queue outbound mail\n" );
204 //******************************************************************************
205 // Function: i2InitChannels(pB, nChannels, pCh)
206 // Parameters: Pointer to Ellis Board structure
207 // Number of channels to initialize
208 // Pointer to first element in an array of channel structures
209 // Returns: Success or failure
211 // Description:
213 // This function patches pointers, back-pointers, and initializes all the
214 // elements in the channel structure array.
216 // This should be run after the board structure is initialized, through having
217 // loaded the standard loadware (otherwise it complains).
219 // In any case, it must be done before any serious work begins initializing the
220 // irq's or sending commands...
222 //******************************************************************************
223 static int
224 i2InitChannels ( i2eBordStrPtr pB, int nChannels, i2ChanStrPtr pCh)
226 int index, stuffIndex;
227 i2ChanStrPtr *ppCh;
229 if (pB->i2eValid != I2E_MAGIC) {
230 COMPLETE(pB, I2EE_BADMAGIC);
232 if (pB->i2eState != II_STATE_STDLOADED) {
233 COMPLETE(pB, I2EE_BADSTATE);
236 LOCK_INIT(&pB->read_fifo_spinlock);
237 LOCK_INIT(&pB->write_fifo_spinlock);
238 LOCK_INIT(&pB->Dbuf_spinlock);
239 LOCK_INIT(&pB->Bbuf_spinlock);
240 LOCK_INIT(&pB->Fbuf_spinlock);
242 // NO LOCK needed yet - this is init
244 pB->i2eChannelPtr = pCh;
245 pB->i2eChannelCnt = nChannels;
247 pB->i2Fbuf_strip = pB->i2Fbuf_stuff = 0;
248 pB->i2Dbuf_strip = pB->i2Dbuf_stuff = 0;
249 pB->i2Bbuf_strip = pB->i2Bbuf_stuff = 0;
251 pB->SendPendingRetry = 0;
253 memset ( pCh, 0, sizeof (i2ChanStr) * nChannels );
255 for (index = stuffIndex = 0, ppCh = (i2ChanStrPtr *)(pB->i2Fbuf);
256 nChannels && index < ABS_MOST_PORTS;
257 index++)
259 if ( !(pB->i2eChannelMap[index >> 4] & (1 << (index & 0xf)) ) ) {
260 continue;
262 LOCK_INIT(&pCh->Ibuf_spinlock);
263 LOCK_INIT(&pCh->Obuf_spinlock);
264 LOCK_INIT(&pCh->Cbuf_spinlock);
265 LOCK_INIT(&pCh->Pbuf_spinlock);
266 // NO LOCK needed yet - this is init
267 // Set up validity flag according to support level
268 if (pB->i2eGoodMap[index >> 4] & (1 << (index & 0xf)) ) {
269 pCh->validity = CHANNEL_MAGIC | CHANNEL_SUPPORT;
270 } else {
271 pCh->validity = CHANNEL_MAGIC;
273 pCh->pMyBord = pB; /* Back-pointer */
275 // Prepare an outgoing flow-control packet to send as soon as the chance
276 // occurs.
277 if ( pCh->validity & CHANNEL_SUPPORT ) {
278 pCh->infl.hd.i2sChannel = index;
279 pCh->infl.hd.i2sCount = 5;
280 pCh->infl.hd.i2sType = PTYPE_BYPASS;
281 pCh->infl.fcmd = 37;
282 pCh->infl.asof = 0;
283 pCh->infl.room = IBUF_SIZE - 1;
285 pCh->whenSendFlow = (IBUF_SIZE/5)*4; // when 80% full
287 // The following is similar to calling i2QueueNeeds, except that this
288 // is done in longhand, since we are setting up initial conditions on
289 // many channels at once.
290 pCh->channelNeeds = NEED_FLOW; // Since starting from scratch
291 pCh->sinceLastFlow = 0; // No bytes received since last flow
292 // control packet was queued
293 stuffIndex++;
294 *ppCh++ = pCh; // List this channel as needing
295 // initial flow control packet sent
298 // Don't allow anything to be sent until the status packets come in from
299 // the board.
301 pCh->outfl.asof = 0;
302 pCh->outfl.room = 0;
304 // Initialize all the ring buffers
306 pCh->Ibuf_stuff = pCh->Ibuf_strip = 0;
307 pCh->Obuf_stuff = pCh->Obuf_strip = 0;
308 pCh->Cbuf_stuff = pCh->Cbuf_strip = 0;
310 memset( &pCh->icount, 0, sizeof (struct async_icount) );
311 pCh->hotKeyIn = HOT_CLEAR;
312 pCh->channelOptions = 0;
313 pCh->bookMarks = 0;
314 init_waitqueue_head(&pCh->pBookmarkWait);
316 init_waitqueue_head(&pCh->open_wait);
317 init_waitqueue_head(&pCh->close_wait);
318 init_waitqueue_head(&pCh->delta_msr_wait);
320 // Set base and divisor so default custom rate is 9600
321 pCh->BaudBase = 921600; // MAX for ST654, changed after we get
322 pCh->BaudDivisor = 96; // the boxids (UART types) later
324 pCh->dataSetIn = 0;
325 pCh->dataSetOut = 0;
327 pCh->wopen = 0;
328 pCh->throttled = 0;
330 pCh->speed = CBR_9600;
332 pCh->flags = 0;
334 pCh->ClosingDelay = 5*HZ/10;
335 pCh->ClosingWaitTime = 30*HZ;
337 // Initialize task queue objects
338 INIT_WORK(&pCh->tqueue_input, do_input);
339 INIT_WORK(&pCh->tqueue_status, do_status);
341 #ifdef IP2DEBUG_TRACE
342 pCh->trace = ip2trace;
343 #endif
345 ++pCh;
346 --nChannels;
348 // No need to check for wrap here; this is initialization.
349 pB->i2Fbuf_stuff = stuffIndex;
350 COMPLETE(pB, I2EE_GOOD);
354 //******************************************************************************
355 // Function: i2DeQueueNeeds(pB, type)
356 // Parameters: Pointer to a board structure
357 // type bit map: may include NEED_INLINE, NEED_BYPASS, or NEED_FLOW
358 // Returns:
359 // Pointer to a channel structure
361 // Description: Returns pointer struct of next channel that needs service of
362 // the type specified. Otherwise returns a NULL reference.
364 //******************************************************************************
365 static i2ChanStrPtr
366 i2DeQueueNeeds(i2eBordStrPtr pB, int type)
368 unsigned short queueIndex;
369 unsigned long flags;
371 i2ChanStrPtr pCh = NULL;
373 switch(type) {
375 case NEED_INLINE:
377 WRITE_LOCK_IRQSAVE(&pB->Dbuf_spinlock,flags);
378 if ( pB->i2Dbuf_stuff != pB->i2Dbuf_strip)
380 queueIndex = pB->i2Dbuf_strip;
381 pCh = pB->i2Dbuf[queueIndex];
382 queueIndex++;
383 if (queueIndex >= CH_QUEUE_SIZE) {
384 queueIndex = 0;
386 pB->i2Dbuf_strip = queueIndex;
387 pCh->channelNeeds &= ~NEED_INLINE;
389 WRITE_UNLOCK_IRQRESTORE(&pB->Dbuf_spinlock,flags);
390 break;
392 case NEED_BYPASS:
394 WRITE_LOCK_IRQSAVE(&pB->Bbuf_spinlock,flags);
395 if (pB->i2Bbuf_stuff != pB->i2Bbuf_strip)
397 queueIndex = pB->i2Bbuf_strip;
398 pCh = pB->i2Bbuf[queueIndex];
399 queueIndex++;
400 if (queueIndex >= CH_QUEUE_SIZE) {
401 queueIndex = 0;
403 pB->i2Bbuf_strip = queueIndex;
404 pCh->channelNeeds &= ~NEED_BYPASS;
406 WRITE_UNLOCK_IRQRESTORE(&pB->Bbuf_spinlock,flags);
407 break;
409 case NEED_FLOW:
411 WRITE_LOCK_IRQSAVE(&pB->Fbuf_spinlock,flags);
412 if (pB->i2Fbuf_stuff != pB->i2Fbuf_strip)
414 queueIndex = pB->i2Fbuf_strip;
415 pCh = pB->i2Fbuf[queueIndex];
416 queueIndex++;
417 if (queueIndex >= CH_QUEUE_SIZE) {
418 queueIndex = 0;
420 pB->i2Fbuf_strip = queueIndex;
421 pCh->channelNeeds &= ~NEED_FLOW;
423 WRITE_UNLOCK_IRQRESTORE(&pB->Fbuf_spinlock,flags);
424 break;
425 default:
426 printk(KERN_ERR "i2DeQueueNeeds called with bad type:%x\n",type);
427 break;
429 return pCh;
432 //******************************************************************************
433 // Function: i2QueueNeeds(pB, pCh, type)
434 // Parameters: Pointer to a board structure
435 // Pointer to a channel structure
436 // type bit map: may include NEED_INLINE, NEED_BYPASS, or NEED_FLOW
437 // Returns: Nothing
439 // Description:
440 // For each type of need selected, if the given channel is not already in the
441 // queue, adds it, and sets the flag indicating it is in the queue.
442 //******************************************************************************
443 static void
444 i2QueueNeeds(i2eBordStrPtr pB, i2ChanStrPtr pCh, int type)
446 unsigned short queueIndex;
447 unsigned long flags;
449 // We turn off all the interrupts during this brief process, since the
450 // interrupt-level code might want to put things on the queue as well.
452 switch (type) {
454 case NEED_INLINE:
456 WRITE_LOCK_IRQSAVE(&pB->Dbuf_spinlock,flags);
457 if ( !(pCh->channelNeeds & NEED_INLINE) )
459 pCh->channelNeeds |= NEED_INLINE;
460 queueIndex = pB->i2Dbuf_stuff;
461 pB->i2Dbuf[queueIndex++] = pCh;
462 if (queueIndex >= CH_QUEUE_SIZE)
463 queueIndex = 0;
464 pB->i2Dbuf_stuff = queueIndex;
466 WRITE_UNLOCK_IRQRESTORE(&pB->Dbuf_spinlock,flags);
467 break;
469 case NEED_BYPASS:
471 WRITE_LOCK_IRQSAVE(&pB->Bbuf_spinlock,flags);
472 if ((type & NEED_BYPASS) && !(pCh->channelNeeds & NEED_BYPASS))
474 pCh->channelNeeds |= NEED_BYPASS;
475 queueIndex = pB->i2Bbuf_stuff;
476 pB->i2Bbuf[queueIndex++] = pCh;
477 if (queueIndex >= CH_QUEUE_SIZE)
478 queueIndex = 0;
479 pB->i2Bbuf_stuff = queueIndex;
481 WRITE_UNLOCK_IRQRESTORE(&pB->Bbuf_spinlock,flags);
482 break;
484 case NEED_FLOW:
486 WRITE_LOCK_IRQSAVE(&pB->Fbuf_spinlock,flags);
487 if ((type & NEED_FLOW) && !(pCh->channelNeeds & NEED_FLOW))
489 pCh->channelNeeds |= NEED_FLOW;
490 queueIndex = pB->i2Fbuf_stuff;
491 pB->i2Fbuf[queueIndex++] = pCh;
492 if (queueIndex >= CH_QUEUE_SIZE)
493 queueIndex = 0;
494 pB->i2Fbuf_stuff = queueIndex;
496 WRITE_UNLOCK_IRQRESTORE(&pB->Fbuf_spinlock,flags);
497 break;
499 case NEED_CREDIT:
500 pCh->channelNeeds |= NEED_CREDIT;
501 break;
502 default:
503 printk(KERN_ERR "i2QueueNeeds called with bad type:%x\n",type);
504 break;
506 return;
509 //******************************************************************************
510 // Function: i2QueueCommands(type, pCh, timeout, nCommands, pCs,...)
511 // Parameters: type - PTYPE_BYPASS or PTYPE_INLINE
512 // pointer to the channel structure
513 // maximum period to wait
514 // number of commands (n)
515 // n commands
516 // Returns: Number of commands sent, or -1 for error
518 // get board lock before calling
520 // Description:
521 // Queues up some commands to be sent to a channel. To send possibly several
522 // bypass or inline commands to the given channel. The timeout parameter
523 // indicates how many HUNDREDTHS OF SECONDS to wait until there is room:
524 // 0 = return immediately if no room, -ive = wait forever, +ive = number of
525 // 1/100 seconds to wait. Return values:
526 // -1 Some kind of nasty error: bad channel structure or invalid arguments.
527 // 0 No room to send all the commands
528 // (+) Number of commands sent
529 //******************************************************************************
530 static int
531 i2QueueCommands(int type, i2ChanStrPtr pCh, int timeout, int nCommands,
532 cmdSyntaxPtr pCs0,...)
534 int totalsize = 0;
535 int blocksize;
536 int lastended;
537 cmdSyntaxPtr *ppCs;
538 cmdSyntaxPtr pCs;
539 int count;
540 int flag;
541 i2eBordStrPtr pB;
543 unsigned short maxBlock;
544 unsigned short maxBuff;
545 short bufroom;
546 unsigned short stuffIndex;
547 unsigned char *pBuf;
548 unsigned char *pInsert;
549 unsigned char *pDest, *pSource;
550 unsigned short channel;
551 int cnt;
552 unsigned long flags = 0;
553 rwlock_t *lock_var_p = NULL;
555 // Make sure the channel exists, otherwise do nothing
556 if ( !i2Validate ( pCh ) ) {
557 return -1;
560 ip2trace (CHANN, ITRC_QUEUE, ITRC_ENTER, 0 );
562 pB = pCh->pMyBord;
564 // Board must also exist, and THE INTERRUPT COMMAND ALREADY SENT
565 if (pB->i2eValid != I2E_MAGIC || pB->i2eUsingIrq == IRQ_UNDEFINED) {
566 return -2;
568 // If the board has gone fatal, return bad, and also hit the trap routine if
569 // it exists.
570 if (pB->i2eFatal) {
571 if ( pB->i2eFatalTrap ) {
572 (*(pB)->i2eFatalTrap)(pB);
574 return -3;
576 // Set up some variables, Which buffers are we using? How big are they?
577 switch(type)
579 case PTYPE_INLINE:
580 flag = INL;
581 maxBlock = MAX_OBUF_BLOCK;
582 maxBuff = OBUF_SIZE;
583 pBuf = pCh->Obuf;
584 break;
585 case PTYPE_BYPASS:
586 flag = BYP;
587 maxBlock = MAX_CBUF_BLOCK;
588 maxBuff = CBUF_SIZE;
589 pBuf = pCh->Cbuf;
590 break;
591 default:
592 return -4;
594 // Determine the total size required for all the commands
595 totalsize = blocksize = sizeof(i2CmdHeader);
596 lastended = 0;
597 ppCs = &pCs0;
598 for ( count = nCommands; count; count--, ppCs++)
600 pCs = *ppCs;
601 cnt = pCs->length;
602 // Will a new block be needed for this one?
603 // Two possible reasons: too
604 // big or previous command has to be at the end of a packet.
605 if ((blocksize + cnt > maxBlock) || lastended) {
606 blocksize = sizeof(i2CmdHeader);
607 totalsize += sizeof(i2CmdHeader);
609 totalsize += cnt;
610 blocksize += cnt;
612 // If this command had to end a block, then we will make sure to
613 // account for it should there be any more blocks.
614 lastended = pCs->flags & END;
616 for (;;) {
617 // Make sure any pending flush commands go out before we add more data.
618 if ( !( pCh->flush_flags && i2RetryFlushOutput( pCh ) ) ) {
619 // How much room (this time through) ?
620 switch(type) {
621 case PTYPE_INLINE:
622 lock_var_p = &pCh->Obuf_spinlock;
623 WRITE_LOCK_IRQSAVE(lock_var_p,flags);
624 stuffIndex = pCh->Obuf_stuff;
625 bufroom = pCh->Obuf_strip - stuffIndex;
626 break;
627 case PTYPE_BYPASS:
628 lock_var_p = &pCh->Cbuf_spinlock;
629 WRITE_LOCK_IRQSAVE(lock_var_p,flags);
630 stuffIndex = pCh->Cbuf_stuff;
631 bufroom = pCh->Cbuf_strip - stuffIndex;
632 break;
633 default:
634 return -5;
636 if (--bufroom < 0) {
637 bufroom += maxBuff;
640 ip2trace (CHANN, ITRC_QUEUE, 2, 1, bufroom );
642 // Check for overflow
643 if (totalsize <= bufroom) {
644 // Normal Expected path - We still hold LOCK
645 break; /* from for()- Enough room: goto proceed */
649 ip2trace (CHANN, ITRC_QUEUE, 3, 1, totalsize );
651 // Prepare to wait for buffers to empty
652 WRITE_UNLOCK_IRQRESTORE(lock_var_p,flags);
653 serviceOutgoingFifo(pB); // Dump what we got
655 if (timeout == 0) {
656 return 0; // Tired of waiting
658 if (timeout > 0)
659 timeout--; // So negative values == forever
661 if (!in_interrupt()) {
662 schedule_timeout_interruptible(1); // short nap
663 } else {
664 // we cannot sched/sleep in interrrupt silly
665 return 0;
667 if (signal_pending(current)) {
668 return 0; // Wake up! Time to die!!!
671 ip2trace (CHANN, ITRC_QUEUE, 4, 0 );
673 } // end of for(;;)
675 // At this point we have room and the lock - stick them in.
676 channel = pCh->infl.hd.i2sChannel;
677 pInsert = &pBuf[stuffIndex]; // Pointer to start of packet
678 pDest = CMD_OF(pInsert); // Pointer to start of command
680 // When we start counting, the block is the size of the header
681 for (blocksize = sizeof(i2CmdHeader), count = nCommands,
682 lastended = 0, ppCs = &pCs0;
683 count;
684 count--, ppCs++)
686 pCs = *ppCs; // Points to command protocol structure
688 // If this is a bookmark request command, post the fact that a bookmark
689 // request is pending. NOTE THIS TRICK ONLY WORKS BECAUSE CMD_BMARK_REQ
690 // has no parameters! The more general solution would be to reference
691 // pCs->cmd[0].
692 if (pCs == CMD_BMARK_REQ) {
693 pCh->bookMarks++;
695 ip2trace (CHANN, ITRC_DRAIN, 30, 1, pCh->bookMarks );
698 cnt = pCs->length;
700 // If this command would put us over the maximum block size or
701 // if the last command had to be at the end of a block, we end
702 // the existing block here and start a new one.
703 if ((blocksize + cnt > maxBlock) || lastended) {
705 ip2trace (CHANN, ITRC_QUEUE, 5, 0 );
707 PTYPE_OF(pInsert) = type;
708 CHANNEL_OF(pInsert) = channel;
709 // count here does not include the header
710 CMD_COUNT_OF(pInsert) = blocksize - sizeof(i2CmdHeader);
711 stuffIndex += blocksize;
712 if(stuffIndex >= maxBuff) {
713 stuffIndex = 0;
714 pInsert = pBuf;
716 pInsert = &pBuf[stuffIndex]; // Pointer to start of next pkt
717 pDest = CMD_OF(pInsert);
718 blocksize = sizeof(i2CmdHeader);
720 // Now we know there is room for this one in the current block
722 blocksize += cnt; // Total bytes in this command
723 pSource = pCs->cmd; // Copy the command into the buffer
724 while (cnt--) {
725 *pDest++ = *pSource++;
727 // If this command had to end a block, then we will make sure to account
728 // for it should there be any more blocks.
729 lastended = pCs->flags & END;
730 } // end for
731 // Clean up the final block by writing header, etc
733 PTYPE_OF(pInsert) = type;
734 CHANNEL_OF(pInsert) = channel;
735 // count here does not include the header
736 CMD_COUNT_OF(pInsert) = blocksize - sizeof(i2CmdHeader);
737 stuffIndex += blocksize;
738 if(stuffIndex >= maxBuff) {
739 stuffIndex = 0;
740 pInsert = pBuf;
742 // Updates the index, and post the need for service. When adding these to
743 // the queue of channels, we turn off the interrupt while doing so,
744 // because at interrupt level we might want to push a channel back to the
745 // end of the queue.
746 switch(type)
748 case PTYPE_INLINE:
749 pCh->Obuf_stuff = stuffIndex; // Store buffer pointer
750 WRITE_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
752 pB->debugInlineQueued++;
753 // Add the channel pointer to list of channels needing service (first
754 // come...), if it's not already there.
755 i2QueueNeeds(pB, pCh, NEED_INLINE);
756 break;
758 case PTYPE_BYPASS:
759 pCh->Cbuf_stuff = stuffIndex; // Store buffer pointer
760 WRITE_UNLOCK_IRQRESTORE(&pCh->Cbuf_spinlock,flags);
762 pB->debugBypassQueued++;
763 // Add the channel pointer to list of channels needing service (first
764 // come...), if it's not already there.
765 i2QueueNeeds(pB, pCh, NEED_BYPASS);
766 break;
769 ip2trace (CHANN, ITRC_QUEUE, ITRC_RETURN, 1, nCommands );
771 return nCommands; // Good status: number of commands sent
774 //******************************************************************************
775 // Function: i2GetStatus(pCh,resetBits)
776 // Parameters: Pointer to a channel structure
777 // Bit map of status bits to clear
778 // Returns: Bit map of current status bits
780 // Description:
781 // Returns the state of data set signals, and whether a break has been received,
782 // (see i2lib.h for bit-mapped result). resetBits is a bit-map of any status
783 // bits to be cleared: I2_BRK, I2_PAR, I2_FRA, I2_OVR,... These are cleared
784 // AFTER the condition is passed. If pCh does not point to a valid channel,
785 // returns -1 (which would be impossible otherwise.
786 //******************************************************************************
787 static int
788 i2GetStatus(i2ChanStrPtr pCh, int resetBits)
790 unsigned short status;
791 i2eBordStrPtr pB;
793 ip2trace (CHANN, ITRC_STATUS, ITRC_ENTER, 2, pCh->dataSetIn, resetBits );
795 // Make sure the channel exists, otherwise do nothing */
796 if ( !i2Validate ( pCh ) )
797 return -1;
799 pB = pCh->pMyBord;
801 status = pCh->dataSetIn;
803 // Clear any specified error bits: but note that only actual error bits can
804 // be cleared, regardless of the value passed.
805 if (resetBits)
807 pCh->dataSetIn &= ~(resetBits & (I2_BRK | I2_PAR | I2_FRA | I2_OVR));
808 pCh->dataSetIn &= ~(I2_DDCD | I2_DCTS | I2_DDSR | I2_DRI);
811 ip2trace (CHANN, ITRC_STATUS, ITRC_RETURN, 1, pCh->dataSetIn );
813 return status;
816 //******************************************************************************
817 // Function: i2Input(pChpDest,count)
818 // Parameters: Pointer to a channel structure
819 // Pointer to data buffer
820 // Number of bytes to read
821 // Returns: Number of bytes read, or -1 for error
823 // Description:
824 // Strips data from the input buffer and writes it to pDest. If there is a
825 // collosal blunder, (invalid structure pointers or the like), returns -1.
826 // Otherwise, returns the number of bytes read.
827 //******************************************************************************
828 static int
829 i2Input(i2ChanStrPtr pCh)
831 int amountToMove;
832 unsigned short stripIndex;
833 int count;
834 unsigned long flags = 0;
836 ip2trace (CHANN, ITRC_INPUT, ITRC_ENTER, 0);
838 // Ensure channel structure seems real
839 if ( !i2Validate( pCh ) ) {
840 count = -1;
841 goto i2Input_exit;
843 WRITE_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags);
845 // initialize some accelerators and private copies
846 stripIndex = pCh->Ibuf_strip;
848 count = pCh->Ibuf_stuff - stripIndex;
850 // If buffer is empty or requested data count was 0, (trivial case) return
851 // without any further thought.
852 if ( count == 0 ) {
853 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
854 goto i2Input_exit;
856 // Adjust for buffer wrap
857 if ( count < 0 ) {
858 count += IBUF_SIZE;
860 // Don't give more than can be taken by the line discipline
861 amountToMove = pCh->pTTY->receive_room;
862 if (count > amountToMove) {
863 count = amountToMove;
865 // How much could we copy without a wrap?
866 amountToMove = IBUF_SIZE - stripIndex;
868 if (amountToMove > count) {
869 amountToMove = count;
871 // Move the first block
872 pCh->pTTY->ldisc.receive_buf( pCh->pTTY,
873 &(pCh->Ibuf[stripIndex]), NULL, amountToMove );
874 // If we needed to wrap, do the second data move
875 if (count > amountToMove) {
876 pCh->pTTY->ldisc.receive_buf( pCh->pTTY,
877 pCh->Ibuf, NULL, count - amountToMove );
879 // Bump and wrap the stripIndex all at once by the amount of data read. This
880 // method is good regardless of whether the data was in one or two pieces.
881 stripIndex += count;
882 if (stripIndex >= IBUF_SIZE) {
883 stripIndex -= IBUF_SIZE;
885 pCh->Ibuf_strip = stripIndex;
887 // Update our flow control information and possibly queue ourselves to send
888 // it, depending on how much data has been stripped since the last time a
889 // packet was sent.
890 pCh->infl.asof += count;
892 if ((pCh->sinceLastFlow += count) >= pCh->whenSendFlow) {
893 pCh->sinceLastFlow -= pCh->whenSendFlow;
894 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
895 i2QueueNeeds(pCh->pMyBord, pCh, NEED_FLOW);
896 } else {
897 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
900 i2Input_exit:
902 ip2trace (CHANN, ITRC_INPUT, ITRC_RETURN, 1, count);
904 return count;
907 //******************************************************************************
908 // Function: i2InputFlush(pCh)
909 // Parameters: Pointer to a channel structure
910 // Returns: Number of bytes stripped, or -1 for error
912 // Description:
913 // Strips any data from the input buffer. If there is a collosal blunder,
914 // (invalid structure pointers or the like), returns -1. Otherwise, returns the
915 // number of bytes stripped.
916 //******************************************************************************
917 static int
918 i2InputFlush(i2ChanStrPtr pCh)
920 int count;
921 unsigned long flags;
923 // Ensure channel structure seems real
924 if ( !i2Validate ( pCh ) )
925 return -1;
927 ip2trace (CHANN, ITRC_INPUT, 10, 0);
929 WRITE_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags);
930 count = pCh->Ibuf_stuff - pCh->Ibuf_strip;
932 // Adjust for buffer wrap
933 if (count < 0) {
934 count += IBUF_SIZE;
937 // Expedient way to zero out the buffer
938 pCh->Ibuf_strip = pCh->Ibuf_stuff;
941 // Update our flow control information and possibly queue ourselves to send
942 // it, depending on how much data has been stripped since the last time a
943 // packet was sent.
945 pCh->infl.asof += count;
947 if ( (pCh->sinceLastFlow += count) >= pCh->whenSendFlow )
949 pCh->sinceLastFlow -= pCh->whenSendFlow;
950 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
951 i2QueueNeeds(pCh->pMyBord, pCh, NEED_FLOW);
952 } else {
953 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
956 ip2trace (CHANN, ITRC_INPUT, 19, 1, count);
958 return count;
961 //******************************************************************************
962 // Function: i2InputAvailable(pCh)
963 // Parameters: Pointer to a channel structure
964 // Returns: Number of bytes available, or -1 for error
966 // Description:
967 // If there is a collosal blunder, (invalid structure pointers or the like),
968 // returns -1. Otherwise, returns the number of bytes stripped. Otherwise,
969 // returns the number of bytes available in the buffer.
970 //******************************************************************************
971 #if 0
972 static int
973 i2InputAvailable(i2ChanStrPtr pCh)
975 int count;
977 // Ensure channel structure seems real
978 if ( !i2Validate ( pCh ) ) return -1;
981 // initialize some accelerators and private copies
982 READ_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags);
983 count = pCh->Ibuf_stuff - pCh->Ibuf_strip;
984 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
986 // Adjust for buffer wrap
987 if (count < 0)
989 count += IBUF_SIZE;
992 return count;
994 #endif
996 //******************************************************************************
997 // Function: i2Output(pCh, pSource, count)
998 // Parameters: Pointer to channel structure
999 // Pointer to source data
1000 // Number of bytes to send
1001 // Returns: Number of bytes sent, or -1 for error
1003 // Description:
1004 // Queues the data at pSource to be sent as data packets to the board. If there
1005 // is a collosal blunder, (invalid structure pointers or the like), returns -1.
1006 // Otherwise, returns the number of bytes written. What if there is not enough
1007 // room for all the data? If pCh->channelOptions & CO_NBLOCK_WRITE is set, then
1008 // we transfer as many characters as we can now, then return. If this bit is
1009 // clear (default), routine will spin along until all the data is buffered.
1010 // Should this occur, the 1-ms delay routine is called while waiting to avoid
1011 // applications that one cannot break out of.
1012 //******************************************************************************
1013 static int
1014 i2Output(i2ChanStrPtr pCh, const char *pSource, int count)
1016 i2eBordStrPtr pB;
1017 unsigned char *pInsert;
1018 int amountToMove;
1019 int countOriginal = count;
1020 unsigned short channel;
1021 unsigned short stuffIndex;
1022 unsigned long flags;
1024 int bailout = 10;
1026 ip2trace (CHANN, ITRC_OUTPUT, ITRC_ENTER, 2, count, 0 );
1028 // Ensure channel structure seems real
1029 if ( !i2Validate ( pCh ) )
1030 return -1;
1032 // initialize some accelerators and private copies
1033 pB = pCh->pMyBord;
1034 channel = pCh->infl.hd.i2sChannel;
1036 // If the board has gone fatal, return bad, and also hit the trap routine if
1037 // it exists.
1038 if (pB->i2eFatal) {
1039 if (pB->i2eFatalTrap) {
1040 (*(pB)->i2eFatalTrap)(pB);
1042 return -1;
1044 // Proceed as though we would do everything
1045 while ( count > 0 ) {
1047 // How much room in output buffer is there?
1048 READ_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
1049 amountToMove = pCh->Obuf_strip - pCh->Obuf_stuff - 1;
1050 READ_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
1051 if (amountToMove < 0) {
1052 amountToMove += OBUF_SIZE;
1054 // Subtract off the headers size and see how much room there is for real
1055 // data. If this is negative, we will discover later.
1056 amountToMove -= sizeof (i2DataHeader);
1058 // Don't move more (now) than can go in a single packet
1059 if ( amountToMove > (int)(MAX_OBUF_BLOCK - sizeof(i2DataHeader)) ) {
1060 amountToMove = MAX_OBUF_BLOCK - sizeof(i2DataHeader);
1062 // Don't move more than the count we were given
1063 if (amountToMove > count) {
1064 amountToMove = count;
1066 // Now we know how much we must move: NB because the ring buffers have
1067 // an overflow area at the end, we needn't worry about wrapping in the
1068 // middle of a packet.
1070 // Small WINDOW here with no LOCK but I can't call Flush with LOCK
1071 // We would be flushing (or ending flush) anyway
1073 ip2trace (CHANN, ITRC_OUTPUT, 10, 1, amountToMove );
1075 if ( !(pCh->flush_flags && i2RetryFlushOutput(pCh) )
1076 && amountToMove > 0 )
1078 WRITE_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
1079 stuffIndex = pCh->Obuf_stuff;
1081 // Had room to move some data: don't know whether the block size,
1082 // buffer space, or what was the limiting factor...
1083 pInsert = &(pCh->Obuf[stuffIndex]);
1085 // Set up the header
1086 CHANNEL_OF(pInsert) = channel;
1087 PTYPE_OF(pInsert) = PTYPE_DATA;
1088 TAG_OF(pInsert) = 0;
1089 ID_OF(pInsert) = ID_ORDINARY_DATA;
1090 DATA_COUNT_OF(pInsert) = amountToMove;
1092 // Move the data
1093 memcpy( (char*)(DATA_OF(pInsert)), pSource, amountToMove );
1094 // Adjust pointers and indices
1095 pSource += amountToMove;
1096 pCh->Obuf_char_count += amountToMove;
1097 stuffIndex += amountToMove + sizeof(i2DataHeader);
1098 count -= amountToMove;
1100 if (stuffIndex >= OBUF_SIZE) {
1101 stuffIndex = 0;
1103 pCh->Obuf_stuff = stuffIndex;
1105 WRITE_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
1107 ip2trace (CHANN, ITRC_OUTPUT, 13, 1, stuffIndex );
1109 } else {
1111 // Cannot move data
1112 // becuz we need to stuff a flush
1113 // or amount to move is <= 0
1115 ip2trace(CHANN, ITRC_OUTPUT, 14, 3,
1116 amountToMove, pB->i2eFifoRemains,
1117 pB->i2eWaitingForEmptyFifo );
1119 // Put this channel back on queue
1120 // this ultimatly gets more data or wakes write output
1121 i2QueueNeeds(pB, pCh, NEED_INLINE);
1123 if ( pB->i2eWaitingForEmptyFifo ) {
1125 ip2trace (CHANN, ITRC_OUTPUT, 16, 0 );
1127 // or schedule
1128 if (!in_interrupt()) {
1130 ip2trace (CHANN, ITRC_OUTPUT, 61, 0 );
1132 schedule_timeout_interruptible(2);
1133 if (signal_pending(current)) {
1134 break;
1136 continue;
1137 } else {
1139 ip2trace (CHANN, ITRC_OUTPUT, 62, 0 );
1141 // let interrupt in = WAS restore_flags()
1142 // We hold no lock nor is irq off anymore???
1144 break;
1146 break; // from while(count)
1148 else if ( pB->i2eFifoRemains < 32 && !pB->i2eTxMailEmpty ( pB ) )
1150 ip2trace (CHANN, ITRC_OUTPUT, 19, 2,
1151 pB->i2eFifoRemains,
1152 pB->i2eTxMailEmpty );
1154 break; // from while(count)
1155 } else if ( pCh->channelNeeds & NEED_CREDIT ) {
1157 ip2trace (CHANN, ITRC_OUTPUT, 22, 0 );
1159 break; // from while(count)
1160 } else if ( --bailout) {
1162 // Try to throw more things (maybe not us) in the fifo if we're
1163 // not already waiting for it.
1165 ip2trace (CHANN, ITRC_OUTPUT, 20, 0 );
1167 serviceOutgoingFifo(pB);
1168 //break; CONTINUE;
1169 } else {
1170 ip2trace (CHANN, ITRC_OUTPUT, 21, 3,
1171 pB->i2eFifoRemains,
1172 pB->i2eOutMailWaiting,
1173 pB->i2eWaitingForEmptyFifo );
1175 break; // from while(count)
1178 } // End of while(count)
1180 i2QueueNeeds(pB, pCh, NEED_INLINE);
1182 // We drop through either when the count expires, or when there is some
1183 // count left, but there was a non-blocking write.
1184 if (countOriginal > count) {
1186 ip2trace (CHANN, ITRC_OUTPUT, 17, 2, countOriginal, count );
1188 serviceOutgoingFifo( pB );
1191 ip2trace (CHANN, ITRC_OUTPUT, ITRC_RETURN, 2, countOriginal, count );
1193 return countOriginal - count;
1196 //******************************************************************************
1197 // Function: i2FlushOutput(pCh)
1198 // Parameters: Pointer to a channel structure
1199 // Returns: Nothing
1201 // Description:
1202 // Sends bypass command to start flushing (waiting possibly forever until there
1203 // is room), then sends inline command to stop flushing output, (again waiting
1204 // possibly forever).
1205 //******************************************************************************
1206 static inline void
1207 i2FlushOutput(i2ChanStrPtr pCh)
1210 ip2trace (CHANN, ITRC_FLUSH, 1, 1, pCh->flush_flags );
1212 if (pCh->flush_flags)
1213 return;
1215 if ( 1 != i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_STARTFL) ) {
1216 pCh->flush_flags = STARTFL_FLAG; // Failed - flag for later
1218 ip2trace (CHANN, ITRC_FLUSH, 2, 0 );
1220 } else if ( 1 != i2QueueCommands(PTYPE_INLINE, pCh, 0, 1, CMD_STOPFL) ) {
1221 pCh->flush_flags = STOPFL_FLAG; // Failed - flag for later
1223 ip2trace (CHANN, ITRC_FLUSH, 3, 0 );
1227 static int
1228 i2RetryFlushOutput(i2ChanStrPtr pCh)
1230 int old_flags = pCh->flush_flags;
1232 ip2trace (CHANN, ITRC_FLUSH, 14, 1, old_flags );
1234 pCh->flush_flags = 0; // Clear flag so we can avoid recursion
1235 // and queue the commands
1237 if ( old_flags & STARTFL_FLAG ) {
1238 if ( 1 == i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_STARTFL) ) {
1239 old_flags = STOPFL_FLAG; //Success - send stop flush
1240 } else {
1241 old_flags = STARTFL_FLAG; //Failure - Flag for retry later
1244 ip2trace (CHANN, ITRC_FLUSH, 15, 1, old_flags );
1247 if ( old_flags & STOPFL_FLAG ) {
1248 if (1 == i2QueueCommands(PTYPE_INLINE, pCh, 0, 1, CMD_STOPFL)) {
1249 old_flags = 0; // Success - clear flags
1252 ip2trace (CHANN, ITRC_FLUSH, 16, 1, old_flags );
1254 pCh->flush_flags = old_flags;
1256 ip2trace (CHANN, ITRC_FLUSH, 17, 1, old_flags );
1258 return old_flags;
1261 //******************************************************************************
1262 // Function: i2DrainOutput(pCh,timeout)
1263 // Parameters: Pointer to a channel structure
1264 // Maximum period to wait
1265 // Returns: ?
1267 // Description:
1268 // Uses the bookmark request command to ask the board to send a bookmark back as
1269 // soon as all the data is completely sent.
1270 //******************************************************************************
1271 static void
1272 i2DrainWakeup(unsigned long d)
1274 i2ChanStrPtr pCh = (i2ChanStrPtr)d;
1276 ip2trace (CHANN, ITRC_DRAIN, 10, 1, pCh->BookmarkTimer.expires );
1278 pCh->BookmarkTimer.expires = 0;
1279 wake_up_interruptible( &pCh->pBookmarkWait );
1282 static void
1283 i2DrainOutput(i2ChanStrPtr pCh, int timeout)
1285 wait_queue_t wait;
1286 i2eBordStrPtr pB;
1288 ip2trace (CHANN, ITRC_DRAIN, ITRC_ENTER, 1, pCh->BookmarkTimer.expires);
1290 pB = pCh->pMyBord;
1291 // If the board has gone fatal, return bad,
1292 // and also hit the trap routine if it exists.
1293 if (pB->i2eFatal) {
1294 if (pB->i2eFatalTrap) {
1295 (*(pB)->i2eFatalTrap)(pB);
1297 return;
1299 if ((timeout > 0) && (pCh->BookmarkTimer.expires == 0 )) {
1300 // One per customer (channel)
1301 setup_timer(&pCh->BookmarkTimer, i2DrainWakeup,
1302 (unsigned long)pCh);
1304 ip2trace (CHANN, ITRC_DRAIN, 1, 1, pCh->BookmarkTimer.expires );
1306 mod_timer(&pCh->BookmarkTimer, jiffies + timeout);
1309 i2QueueCommands( PTYPE_INLINE, pCh, -1, 1, CMD_BMARK_REQ );
1311 init_waitqueue_entry(&wait, current);
1312 add_wait_queue(&(pCh->pBookmarkWait), &wait);
1313 set_current_state( TASK_INTERRUPTIBLE );
1315 serviceOutgoingFifo( pB );
1317 schedule(); // Now we take our interruptible sleep on
1319 // Clean up the queue
1320 set_current_state( TASK_RUNNING );
1321 remove_wait_queue(&(pCh->pBookmarkWait), &wait);
1323 // if expires == 0 then timer poped, then do not need to del_timer
1324 if ((timeout > 0) && pCh->BookmarkTimer.expires &&
1325 time_before(jiffies, pCh->BookmarkTimer.expires)) {
1326 del_timer( &(pCh->BookmarkTimer) );
1327 pCh->BookmarkTimer.expires = 0;
1329 ip2trace (CHANN, ITRC_DRAIN, 3, 1, pCh->BookmarkTimer.expires );
1332 ip2trace (CHANN, ITRC_DRAIN, ITRC_RETURN, 1, pCh->BookmarkTimer.expires );
1333 return;
1336 //******************************************************************************
1337 // Function: i2OutputFree(pCh)
1338 // Parameters: Pointer to a channel structure
1339 // Returns: Space in output buffer
1341 // Description:
1342 // Returns -1 if very gross error. Otherwise returns the amount of bytes still
1343 // free in the output buffer.
1344 //******************************************************************************
1345 static int
1346 i2OutputFree(i2ChanStrPtr pCh)
1348 int amountToMove;
1349 unsigned long flags;
1351 // Ensure channel structure seems real
1352 if ( !i2Validate ( pCh ) ) {
1353 return -1;
1355 READ_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
1356 amountToMove = pCh->Obuf_strip - pCh->Obuf_stuff - 1;
1357 READ_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
1359 if (amountToMove < 0) {
1360 amountToMove += OBUF_SIZE;
1362 // If this is negative, we will discover later
1363 amountToMove -= sizeof(i2DataHeader);
1365 return (amountToMove < 0) ? 0 : amountToMove;
1367 static void
1369 ip2_owake( PTTY tp)
1371 i2ChanStrPtr pCh;
1373 if (tp == NULL) return;
1375 pCh = tp->driver_data;
1377 ip2trace (CHANN, ITRC_SICMD, 10, 2, tp->flags,
1378 (1 << TTY_DO_WRITE_WAKEUP) );
1380 tty_wakeup(tp);
1383 static inline void
1384 set_baud_params(i2eBordStrPtr pB)
1386 int i,j;
1387 i2ChanStrPtr *pCh;
1389 pCh = (i2ChanStrPtr *) pB->i2eChannelPtr;
1391 for (i = 0; i < ABS_MAX_BOXES; i++) {
1392 if (pB->channelBtypes.bid_value[i]) {
1393 if (BID_HAS_654(pB->channelBtypes.bid_value[i])) {
1394 for (j = 0; j < ABS_BIGGEST_BOX; j++) {
1395 if (pCh[i*16+j] == NULL)
1396 break;
1397 (pCh[i*16+j])->BaudBase = 921600; // MAX for ST654
1398 (pCh[i*16+j])->BaudDivisor = 96;
1400 } else { // has cirrus cd1400
1401 for (j = 0; j < ABS_BIGGEST_BOX; j++) {
1402 if (pCh[i*16+j] == NULL)
1403 break;
1404 (pCh[i*16+j])->BaudBase = 115200; // MAX for CD1400
1405 (pCh[i*16+j])->BaudDivisor = 12;
1412 //******************************************************************************
1413 // Function: i2StripFifo(pB)
1414 // Parameters: Pointer to a board structure
1415 // Returns: ?
1417 // Description:
1418 // Strips all the available data from the incoming FIFO, identifies the type of
1419 // packet, and either buffers the data or does what needs to be done.
1421 // Note there is no overflow checking here: if the board sends more data than it
1422 // ought to, we will not detect it here, but blindly overflow...
1423 //******************************************************************************
1425 // A buffer for reading in blocks for unknown channels
1426 static unsigned char junkBuffer[IBUF_SIZE];
1428 // A buffer to read in a status packet. Because of the size of the count field
1429 // for these things, the maximum packet size must be less than MAX_CMD_PACK_SIZE
1430 static unsigned char cmdBuffer[MAX_CMD_PACK_SIZE + 4];
1432 // This table changes the bit order from MSR order given by STAT_MODEM packet to
1433 // status bits used in our library.
1434 static char xlatDss[16] = {
1435 0 | 0 | 0 | 0 ,
1436 0 | 0 | 0 | I2_CTS ,
1437 0 | 0 | I2_DSR | 0 ,
1438 0 | 0 | I2_DSR | I2_CTS ,
1439 0 | I2_RI | 0 | 0 ,
1440 0 | I2_RI | 0 | I2_CTS ,
1441 0 | I2_RI | I2_DSR | 0 ,
1442 0 | I2_RI | I2_DSR | I2_CTS ,
1443 I2_DCD | 0 | 0 | 0 ,
1444 I2_DCD | 0 | 0 | I2_CTS ,
1445 I2_DCD | 0 | I2_DSR | 0 ,
1446 I2_DCD | 0 | I2_DSR | I2_CTS ,
1447 I2_DCD | I2_RI | 0 | 0 ,
1448 I2_DCD | I2_RI | 0 | I2_CTS ,
1449 I2_DCD | I2_RI | I2_DSR | 0 ,
1450 I2_DCD | I2_RI | I2_DSR | I2_CTS };
1452 static inline void
1453 i2StripFifo(i2eBordStrPtr pB)
1455 i2ChanStrPtr pCh;
1456 int channel;
1457 int count;
1458 unsigned short stuffIndex;
1459 int amountToRead;
1460 unsigned char *pc, *pcLimit;
1461 unsigned char uc;
1462 unsigned char dss_change;
1463 unsigned long bflags,cflags;
1465 // ip2trace (ITRC_NO_PORT, ITRC_SFIFO, ITRC_ENTER, 0 );
1467 while (HAS_INPUT(pB)) {
1468 // ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 2, 0 );
1470 // Process packet from fifo a one atomic unit
1471 WRITE_LOCK_IRQSAVE(&pB->read_fifo_spinlock,bflags);
1473 // The first word (or two bytes) will have channel number and type of
1474 // packet, possibly other information
1475 pB->i2eLeadoffWord[0] = iiReadWord(pB);
1477 switch(PTYPE_OF(pB->i2eLeadoffWord))
1479 case PTYPE_DATA:
1480 pB->got_input = 1;
1482 // ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 3, 0 );
1484 channel = CHANNEL_OF(pB->i2eLeadoffWord); /* Store channel */
1485 count = iiReadWord(pB); /* Count is in the next word */
1487 // NEW: Check the count for sanity! Should the hardware fail, our death
1488 // is more pleasant. While an oversize channel is acceptable (just more
1489 // than the driver supports), an over-length count clearly means we are
1490 // sick!
1491 if ( ((unsigned int)count) > IBUF_SIZE ) {
1492 pB->i2eFatal = 2;
1493 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock,bflags);
1494 return; /* Bail out ASAP */
1496 // Channel is illegally big ?
1497 if ((channel >= pB->i2eChannelCnt) ||
1498 (NULL==(pCh = ((i2ChanStrPtr*)pB->i2eChannelPtr)[channel])))
1500 iiReadBuf(pB, junkBuffer, count);
1501 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock,bflags);
1502 break; /* From switch: ready for next packet */
1505 // Channel should be valid, then
1507 // If this is a hot-key, merely post its receipt for now. These are
1508 // always supposed to be 1-byte packets, so we won't even check the
1509 // count. Also we will post an acknowledgement to the board so that
1510 // more data can be forthcoming. Note that we are not trying to use
1511 // these sequences in this driver, merely to robustly ignore them.
1512 if(ID_OF(pB->i2eLeadoffWord) == ID_HOT_KEY)
1514 pCh->hotKeyIn = iiReadWord(pB) & 0xff;
1515 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock,bflags);
1516 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_HOTACK);
1517 break; /* From the switch: ready for next packet */
1520 // Normal data! We crudely assume there is room for the data in our
1521 // buffer because the board wouldn't have exceeded his credit limit.
1522 WRITE_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,cflags);
1523 // We have 2 locks now
1524 stuffIndex = pCh->Ibuf_stuff;
1525 amountToRead = IBUF_SIZE - stuffIndex;
1526 if (amountToRead > count)
1527 amountToRead = count;
1529 // stuffIndex would have been already adjusted so there would
1530 // always be room for at least one, and count is always at least
1531 // one.
1533 iiReadBuf(pB, &(pCh->Ibuf[stuffIndex]), amountToRead);
1534 pCh->icount.rx += amountToRead;
1536 // Update the stuffIndex by the amount of data moved. Note we could
1537 // never ask for more data than would just fit. However, we might
1538 // have read in one more byte than we wanted because the read
1539 // rounds up to even bytes. If this byte is on the end of the
1540 // packet, and is padding, we ignore it. If the byte is part of
1541 // the actual data, we need to move it.
1543 stuffIndex += amountToRead;
1545 if (stuffIndex >= IBUF_SIZE) {
1546 if ((amountToRead & 1) && (count > amountToRead)) {
1547 pCh->Ibuf[0] = pCh->Ibuf[IBUF_SIZE];
1548 amountToRead++;
1549 stuffIndex = 1;
1550 } else {
1551 stuffIndex = 0;
1555 // If there is anything left over, read it as well
1556 if (count > amountToRead) {
1557 amountToRead = count - amountToRead;
1558 iiReadBuf(pB, &(pCh->Ibuf[stuffIndex]), amountToRead);
1559 pCh->icount.rx += amountToRead;
1560 stuffIndex += amountToRead;
1563 // Update stuff index
1564 pCh->Ibuf_stuff = stuffIndex;
1565 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,cflags);
1566 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock,bflags);
1568 #ifdef USE_IQ
1569 schedule_work(&pCh->tqueue_input);
1570 #else
1571 do_input(&pCh->tqueue_input);
1572 #endif
1574 // Note we do not need to maintain any flow-control credits at this
1575 // time: if we were to increment .asof and decrement .room, there
1576 // would be no net effect. Instead, when we strip data, we will
1577 // increment .asof and leave .room unchanged.
1579 break; // From switch: ready for next packet
1581 case PTYPE_STATUS:
1582 ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 4, 0 );
1584 count = CMD_COUNT_OF(pB->i2eLeadoffWord);
1586 iiReadBuf(pB, cmdBuffer, count);
1587 // We can release early with buffer grab
1588 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock,bflags);
1590 pc = cmdBuffer;
1591 pcLimit = &(cmdBuffer[count]);
1593 while (pc < pcLimit) {
1594 channel = *pc++;
1596 ip2trace (channel, ITRC_SFIFO, 7, 2, channel, *pc );
1598 /* check for valid channel */
1599 if (channel < pB->i2eChannelCnt
1601 (pCh = (((i2ChanStrPtr*)pB->i2eChannelPtr)[channel])) != NULL
1604 dss_change = 0;
1606 switch (uc = *pc++)
1608 /* Breaks and modem signals are easy: just update status */
1609 case STAT_CTS_UP:
1610 if ( !(pCh->dataSetIn & I2_CTS) )
1612 pCh->dataSetIn |= I2_DCTS;
1613 pCh->icount.cts++;
1614 dss_change = 1;
1616 pCh->dataSetIn |= I2_CTS;
1617 break;
1619 case STAT_CTS_DN:
1620 if ( pCh->dataSetIn & I2_CTS )
1622 pCh->dataSetIn |= I2_DCTS;
1623 pCh->icount.cts++;
1624 dss_change = 1;
1626 pCh->dataSetIn &= ~I2_CTS;
1627 break;
1629 case STAT_DCD_UP:
1630 ip2trace (channel, ITRC_MODEM, 1, 1, pCh->dataSetIn );
1632 if ( !(pCh->dataSetIn & I2_DCD) )
1634 ip2trace (CHANN, ITRC_MODEM, 2, 0 );
1635 pCh->dataSetIn |= I2_DDCD;
1636 pCh->icount.dcd++;
1637 dss_change = 1;
1639 pCh->dataSetIn |= I2_DCD;
1641 ip2trace (channel, ITRC_MODEM, 3, 1, pCh->dataSetIn );
1642 break;
1644 case STAT_DCD_DN:
1645 ip2trace (channel, ITRC_MODEM, 4, 1, pCh->dataSetIn );
1646 if ( pCh->dataSetIn & I2_DCD )
1648 ip2trace (channel, ITRC_MODEM, 5, 0 );
1649 pCh->dataSetIn |= I2_DDCD;
1650 pCh->icount.dcd++;
1651 dss_change = 1;
1653 pCh->dataSetIn &= ~I2_DCD;
1655 ip2trace (channel, ITRC_MODEM, 6, 1, pCh->dataSetIn );
1656 break;
1658 case STAT_DSR_UP:
1659 if ( !(pCh->dataSetIn & I2_DSR) )
1661 pCh->dataSetIn |= I2_DDSR;
1662 pCh->icount.dsr++;
1663 dss_change = 1;
1665 pCh->dataSetIn |= I2_DSR;
1666 break;
1668 case STAT_DSR_DN:
1669 if ( pCh->dataSetIn & I2_DSR )
1671 pCh->dataSetIn |= I2_DDSR;
1672 pCh->icount.dsr++;
1673 dss_change = 1;
1675 pCh->dataSetIn &= ~I2_DSR;
1676 break;
1678 case STAT_RI_UP:
1679 if ( !(pCh->dataSetIn & I2_RI) )
1681 pCh->dataSetIn |= I2_DRI;
1682 pCh->icount.rng++;
1683 dss_change = 1;
1685 pCh->dataSetIn |= I2_RI ;
1686 break;
1688 case STAT_RI_DN:
1689 // to be compat with serial.c
1690 //if ( pCh->dataSetIn & I2_RI )
1692 // pCh->dataSetIn |= I2_DRI;
1693 // pCh->icount.rng++;
1694 // dss_change = 1;
1696 pCh->dataSetIn &= ~I2_RI ;
1697 break;
1699 case STAT_BRK_DET:
1700 pCh->dataSetIn |= I2_BRK;
1701 pCh->icount.brk++;
1702 dss_change = 1;
1703 break;
1705 // Bookmarks? one less request we're waiting for
1706 case STAT_BMARK:
1707 pCh->bookMarks--;
1708 if (pCh->bookMarks <= 0 ) {
1709 pCh->bookMarks = 0;
1710 wake_up_interruptible( &pCh->pBookmarkWait );
1712 ip2trace (channel, ITRC_DRAIN, 20, 1, pCh->BookmarkTimer.expires );
1714 break;
1716 // Flow control packets? Update the new credits, and if
1717 // someone was waiting for output, queue him up again.
1718 case STAT_FLOW:
1719 pCh->outfl.room =
1720 ((flowStatPtr)pc)->room -
1721 (pCh->outfl.asof - ((flowStatPtr)pc)->asof);
1723 ip2trace (channel, ITRC_STFLW, 1, 1, pCh->outfl.room );
1725 if (pCh->channelNeeds & NEED_CREDIT)
1727 ip2trace (channel, ITRC_STFLW, 2, 1, pCh->channelNeeds);
1729 pCh->channelNeeds &= ~NEED_CREDIT;
1730 i2QueueNeeds(pB, pCh, NEED_INLINE);
1731 if ( pCh->pTTY )
1732 ip2_owake(pCh->pTTY);
1735 ip2trace (channel, ITRC_STFLW, 3, 1, pCh->channelNeeds);
1737 pc += sizeof(flowStat);
1738 break;
1740 /* Special packets: */
1741 /* Just copy the information into the channel structure */
1743 case STAT_STATUS:
1745 pCh->channelStatus = *((debugStatPtr)pc);
1746 pc += sizeof(debugStat);
1747 break;
1749 case STAT_TXCNT:
1751 pCh->channelTcount = *((cntStatPtr)pc);
1752 pc += sizeof(cntStat);
1753 break;
1755 case STAT_RXCNT:
1757 pCh->channelRcount = *((cntStatPtr)pc);
1758 pc += sizeof(cntStat);
1759 break;
1761 case STAT_BOXIDS:
1762 pB->channelBtypes = *((bidStatPtr)pc);
1763 pc += sizeof(bidStat);
1764 set_baud_params(pB);
1765 break;
1767 case STAT_HWFAIL:
1768 i2QueueCommands (PTYPE_INLINE, pCh, 0, 1, CMD_HW_TEST);
1769 pCh->channelFail = *((failStatPtr)pc);
1770 pc += sizeof(failStat);
1771 break;
1773 /* No explicit match? then
1774 * Might be an error packet...
1776 default:
1777 switch (uc & STAT_MOD_ERROR)
1779 case STAT_ERROR:
1780 if (uc & STAT_E_PARITY) {
1781 pCh->dataSetIn |= I2_PAR;
1782 pCh->icount.parity++;
1784 if (uc & STAT_E_FRAMING){
1785 pCh->dataSetIn |= I2_FRA;
1786 pCh->icount.frame++;
1788 if (uc & STAT_E_OVERRUN){
1789 pCh->dataSetIn |= I2_OVR;
1790 pCh->icount.overrun++;
1792 break;
1794 case STAT_MODEM:
1795 // the answer to DSS_NOW request (not change)
1796 pCh->dataSetIn = (pCh->dataSetIn
1797 & ~(I2_RI | I2_CTS | I2_DCD | I2_DSR) )
1798 | xlatDss[uc & 0xf];
1799 wake_up_interruptible ( &pCh->dss_now_wait );
1800 default:
1801 break;
1803 } /* End of switch on status type */
1804 if (dss_change) {
1805 #ifdef USE_IQ
1806 schedule_work(&pCh->tqueue_status);
1807 #else
1808 do_status(&pCh->tqueue_status);
1809 #endif
1812 else /* Or else, channel is invalid */
1814 // Even though the channel is invalid, we must test the
1815 // status to see how much additional data it has (to be
1816 // skipped)
1817 switch (*pc++)
1819 case STAT_FLOW:
1820 pc += 4; /* Skip the data */
1821 break;
1823 default:
1824 break;
1827 } // End of while (there is still some status packet left)
1828 break;
1830 default: // Neither packet? should be impossible
1831 ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 5, 1,
1832 PTYPE_OF(pB->i2eLeadoffWord) );
1834 break;
1835 } // End of switch on type of packets
1836 } //while(board HAS_INPUT)
1838 ip2trace (ITRC_NO_PORT, ITRC_SFIFO, ITRC_RETURN, 0 );
1840 // Send acknowledgement to the board even if there was no data!
1841 pB->i2eOutMailWaiting |= MB_IN_STRIPPED;
1842 return;
1845 //******************************************************************************
1846 // Function: i2Write2Fifo(pB,address,count)
1847 // Parameters: Pointer to a board structure, source address, byte count
1848 // Returns: bytes written
1850 // Description:
1851 // Writes count bytes to board io address(implied) from source
1852 // Adjusts count, leaves reserve for next time around bypass cmds
1853 //******************************************************************************
1854 static int
1855 i2Write2Fifo(i2eBordStrPtr pB, unsigned char *source, int count,int reserve)
1857 int rc = 0;
1858 unsigned long flags;
1859 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
1860 if (!pB->i2eWaitingForEmptyFifo) {
1861 if (pB->i2eFifoRemains > (count+reserve)) {
1862 pB->i2eFifoRemains -= count;
1863 iiWriteBuf(pB, source, count);
1864 pB->i2eOutMailWaiting |= MB_OUT_STUFFED;
1865 rc = count;
1868 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1869 return rc;
1871 //******************************************************************************
1872 // Function: i2StuffFifoBypass(pB)
1873 // Parameters: Pointer to a board structure
1874 // Returns: Nothing
1876 // Description:
1877 // Stuffs as many bypass commands into the fifo as possible. This is simpler
1878 // than stuffing data or inline commands to fifo, since we do not have
1879 // flow-control to deal with.
1880 //******************************************************************************
1881 static inline void
1882 i2StuffFifoBypass(i2eBordStrPtr pB)
1884 i2ChanStrPtr pCh;
1885 unsigned char *pRemove;
1886 unsigned short stripIndex;
1887 unsigned short packetSize;
1888 unsigned short paddedSize;
1889 unsigned short notClogged = 1;
1890 unsigned long flags;
1892 int bailout = 1000;
1894 // Continue processing so long as there are entries, or there is room in the
1895 // fifo. Each entry represents a channel with something to do.
1896 while ( --bailout && notClogged &&
1897 (NULL != (pCh = i2DeQueueNeeds(pB,NEED_BYPASS))))
1899 WRITE_LOCK_IRQSAVE(&pCh->Cbuf_spinlock,flags);
1900 stripIndex = pCh->Cbuf_strip;
1902 // as long as there are packets for this channel...
1904 while (stripIndex != pCh->Cbuf_stuff) {
1905 pRemove = &(pCh->Cbuf[stripIndex]);
1906 packetSize = CMD_COUNT_OF(pRemove) + sizeof(i2CmdHeader);
1907 paddedSize = ROUNDUP(packetSize);
1909 if (paddedSize > 0) {
1910 if ( 0 == i2Write2Fifo(pB, pRemove, paddedSize,0)) {
1911 notClogged = 0; /* fifo full */
1912 i2QueueNeeds(pB, pCh, NEED_BYPASS); // Put back on queue
1913 break; // Break from the channel
1916 #ifdef DEBUG_FIFO
1917 WriteDBGBuf("BYPS", pRemove, paddedSize);
1918 #endif /* DEBUG_FIFO */
1919 pB->debugBypassCount++;
1921 pRemove += packetSize;
1922 stripIndex += packetSize;
1923 if (stripIndex >= CBUF_SIZE) {
1924 stripIndex = 0;
1925 pRemove = pCh->Cbuf;
1928 // Done with this channel. Move to next, removing this one from
1929 // the queue of channels if we cleaned it out (i.e., didn't get clogged.
1930 pCh->Cbuf_strip = stripIndex;
1931 WRITE_UNLOCK_IRQRESTORE(&pCh->Cbuf_spinlock,flags);
1932 } // Either clogged or finished all the work
1934 #ifdef IP2DEBUG_TRACE
1935 if ( !bailout ) {
1936 ip2trace (ITRC_NO_PORT, ITRC_ERROR, 1, 0 );
1938 #endif
1941 //******************************************************************************
1942 // Function: i2StuffFifoFlow(pB)
1943 // Parameters: Pointer to a board structure
1944 // Returns: Nothing
1946 // Description:
1947 // Stuffs as many flow control packets into the fifo as possible. This is easier
1948 // even than doing normal bypass commands, because there is always at most one
1949 // packet, already assembled, for each channel.
1950 //******************************************************************************
1951 static inline void
1952 i2StuffFifoFlow(i2eBordStrPtr pB)
1954 i2ChanStrPtr pCh;
1955 unsigned short paddedSize = ROUNDUP(sizeof(flowIn));
1957 ip2trace (ITRC_NO_PORT, ITRC_SFLOW, ITRC_ENTER, 2,
1958 pB->i2eFifoRemains, paddedSize );
1960 // Continue processing so long as there are entries, or there is room in the
1961 // fifo. Each entry represents a channel with something to do.
1962 while ( (NULL != (pCh = i2DeQueueNeeds(pB,NEED_FLOW)))) {
1963 pB->debugFlowCount++;
1965 // NO Chan LOCK needed ???
1966 if ( 0 == i2Write2Fifo(pB,(unsigned char *)&(pCh->infl),paddedSize,0)) {
1967 break;
1969 #ifdef DEBUG_FIFO
1970 WriteDBGBuf("FLOW",(unsigned char *) &(pCh->infl), paddedSize);
1971 #endif /* DEBUG_FIFO */
1973 } // Either clogged or finished all the work
1975 ip2trace (ITRC_NO_PORT, ITRC_SFLOW, ITRC_RETURN, 0 );
1978 //******************************************************************************
1979 // Function: i2StuffFifoInline(pB)
1980 // Parameters: Pointer to a board structure
1981 // Returns: Nothing
1983 // Description:
1984 // Stuffs as much data and inline commands into the fifo as possible. This is
1985 // the most complex fifo-stuffing operation, since there if now the channel
1986 // flow-control issue to deal with.
1987 //******************************************************************************
1988 static inline void
1989 i2StuffFifoInline(i2eBordStrPtr pB)
1991 i2ChanStrPtr pCh;
1992 unsigned char *pRemove;
1993 unsigned short stripIndex;
1994 unsigned short packetSize;
1995 unsigned short paddedSize;
1996 unsigned short notClogged = 1;
1997 unsigned short flowsize;
1998 unsigned long flags;
2000 int bailout = 1000;
2001 int bailout2;
2003 ip2trace (ITRC_NO_PORT, ITRC_SICMD, ITRC_ENTER, 3, pB->i2eFifoRemains,
2004 pB->i2Dbuf_strip, pB->i2Dbuf_stuff );
2006 // Continue processing so long as there are entries, or there is room in the
2007 // fifo. Each entry represents a channel with something to do.
2008 while ( --bailout && notClogged &&
2009 (NULL != (pCh = i2DeQueueNeeds(pB,NEED_INLINE))) )
2011 WRITE_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
2012 stripIndex = pCh->Obuf_strip;
2014 ip2trace (CHANN, ITRC_SICMD, 3, 2, stripIndex, pCh->Obuf_stuff );
2016 // as long as there are packets for this channel...
2017 bailout2 = 1000;
2018 while ( --bailout2 && stripIndex != pCh->Obuf_stuff) {
2019 pRemove = &(pCh->Obuf[stripIndex]);
2021 // Must determine whether this be a data or command packet to
2022 // calculate correctly the header size and the amount of
2023 // flow-control credit this type of packet will use.
2024 if (PTYPE_OF(pRemove) == PTYPE_DATA) {
2025 flowsize = DATA_COUNT_OF(pRemove);
2026 packetSize = flowsize + sizeof(i2DataHeader);
2027 } else {
2028 flowsize = CMD_COUNT_OF(pRemove);
2029 packetSize = flowsize + sizeof(i2CmdHeader);
2031 flowsize = CREDIT_USAGE(flowsize);
2032 paddedSize = ROUNDUP(packetSize);
2034 ip2trace (CHANN, ITRC_SICMD, 4, 2, pB->i2eFifoRemains, paddedSize );
2036 // If we don't have enough credits from the board to send the data,
2037 // flag the channel that we are waiting for flow control credit, and
2038 // break out. This will clean up this channel and remove us from the
2039 // queue of hot things to do.
2041 ip2trace (CHANN, ITRC_SICMD, 5, 2, pCh->outfl.room, flowsize );
2043 if (pCh->outfl.room <= flowsize) {
2044 // Do Not have the credits to send this packet.
2045 i2QueueNeeds(pB, pCh, NEED_CREDIT);
2046 notClogged = 0;
2047 break; // So to do next channel
2049 if ( (paddedSize > 0)
2050 && ( 0 == i2Write2Fifo(pB, pRemove, paddedSize, 128))) {
2051 // Do Not have room in fifo to send this packet.
2052 notClogged = 0;
2053 i2QueueNeeds(pB, pCh, NEED_INLINE);
2054 break; // Break from the channel
2056 #ifdef DEBUG_FIFO
2057 WriteDBGBuf("DATA", pRemove, paddedSize);
2058 #endif /* DEBUG_FIFO */
2059 pB->debugInlineCount++;
2061 pCh->icount.tx += flowsize;
2062 // Update current credits
2063 pCh->outfl.room -= flowsize;
2064 pCh->outfl.asof += flowsize;
2065 if (PTYPE_OF(pRemove) == PTYPE_DATA) {
2066 pCh->Obuf_char_count -= DATA_COUNT_OF(pRemove);
2068 pRemove += packetSize;
2069 stripIndex += packetSize;
2071 ip2trace (CHANN, ITRC_SICMD, 6, 2, stripIndex, pCh->Obuf_strip);
2073 if (stripIndex >= OBUF_SIZE) {
2074 stripIndex = 0;
2075 pRemove = pCh->Obuf;
2077 ip2trace (CHANN, ITRC_SICMD, 7, 1, stripIndex );
2080 } /* while */
2081 if ( !bailout2 ) {
2082 ip2trace (CHANN, ITRC_ERROR, 3, 0 );
2084 // Done with this channel. Move to next, removing this one from the
2085 // queue of channels if we cleaned it out (i.e., didn't get clogged.
2086 pCh->Obuf_strip = stripIndex;
2087 WRITE_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
2088 if ( notClogged )
2091 ip2trace (CHANN, ITRC_SICMD, 8, 0 );
2093 if ( pCh->pTTY ) {
2094 ip2_owake(pCh->pTTY);
2097 } // Either clogged or finished all the work
2099 if ( !bailout ) {
2100 ip2trace (ITRC_NO_PORT, ITRC_ERROR, 4, 0 );
2103 ip2trace (ITRC_NO_PORT, ITRC_SICMD, ITRC_RETURN, 1,pB->i2Dbuf_strip);
2106 //******************************************************************************
2107 // Function: serviceOutgoingFifo(pB)
2108 // Parameters: Pointer to a board structure
2109 // Returns: Nothing
2111 // Description:
2112 // Helper routine to put data in the outgoing fifo, if we aren't already waiting
2113 // for something to be there. If the fifo has only room for a very little data,
2114 // go head and hit the board with a mailbox hit immediately. Otherwise, it will
2115 // have to happen later in the interrupt processing. Since this routine may be
2116 // called both at interrupt and foreground time, we must turn off interrupts
2117 // during the entire process.
2118 //******************************************************************************
2119 static void
2120 serviceOutgoingFifo(i2eBordStrPtr pB)
2122 // If we aren't currently waiting for the board to empty our fifo, service
2123 // everything that is pending, in priority order (especially, Bypass before
2124 // Inline).
2125 if ( ! pB->i2eWaitingForEmptyFifo )
2127 i2StuffFifoFlow(pB);
2128 i2StuffFifoBypass(pB);
2129 i2StuffFifoInline(pB);
2131 iiSendPendingMail(pB);
2135 //******************************************************************************
2136 // Function: i2ServiceBoard(pB)
2137 // Parameters: Pointer to a board structure
2138 // Returns: Nothing
2140 // Description:
2141 // Normally this is called from interrupt level, but there is deliberately
2142 // nothing in here specific to being called from interrupt level. All the
2143 // hardware-specific, interrupt-specific things happen at the outer levels.
2145 // For example, a timer interrupt could drive this routine for some sort of
2146 // polled operation. The only requirement is that the programmer deal with any
2147 // atomiticity/concurrency issues that result.
2149 // This routine responds to the board's having sent mailbox information to the
2150 // host (which would normally cause an interrupt). This routine reads the
2151 // incoming mailbox. If there is no data in it, this board did not create the
2152 // interrupt and/or has nothing to be done to it. (Except, if we have been
2153 // waiting to write mailbox data to it, we may do so.
2155 // Based on the value in the mailbox, we may take various actions.
2157 // No checking here of pB validity: after all, it shouldn't have been called by
2158 // the handler unless pB were on the list.
2159 //******************************************************************************
2160 static inline int
2161 i2ServiceBoard ( i2eBordStrPtr pB )
2163 unsigned inmail;
2164 unsigned long flags;
2167 /* This should be atomic because of the way we are called... */
2168 if (NO_MAIL_HERE == ( inmail = pB->i2eStartMail ) ) {
2169 inmail = iiGetMail(pB);
2171 pB->i2eStartMail = NO_MAIL_HERE;
2173 ip2trace (ITRC_NO_PORT, ITRC_INTR, 2, 1, inmail );
2175 if (inmail != NO_MAIL_HERE) {
2176 // If the board has gone fatal, nothing to do but hit a bit that will
2177 // alert foreground tasks to protest!
2178 if ( inmail & MB_FATAL_ERROR ) {
2179 pB->i2eFatal = 1;
2180 goto exit_i2ServiceBoard;
2183 /* Assuming no fatal condition, we proceed to do work */
2184 if ( inmail & MB_IN_STUFFED ) {
2185 pB->i2eFifoInInts++;
2186 i2StripFifo(pB); /* There might be incoming packets */
2189 if (inmail & MB_OUT_STRIPPED) {
2190 pB->i2eFifoOutInts++;
2191 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
2192 pB->i2eFifoRemains = pB->i2eFifoSize;
2193 pB->i2eWaitingForEmptyFifo = 0;
2194 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
2196 ip2trace (ITRC_NO_PORT, ITRC_INTR, 30, 1, pB->i2eFifoRemains );
2199 serviceOutgoingFifo(pB);
2202 ip2trace (ITRC_NO_PORT, ITRC_INTR, 8, 0 );
2204 exit_i2ServiceBoard:
2206 return 0;