blob: 54d93f0345e8565ae2459ce236bd9a8be49cc8f3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*******************************************************************************
2*
3* (c) 1999 by Computone Corporation
4*
5********************************************************************************
6*
7*
8* PACKAGE: Linux tty Device Driver for IntelliPort family of multiport
9* serial I/O controllers.
10*
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.)
16*
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).
25//
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//------------------------------------------------------------------------------
30
31//------------------------------------------------------------------------------
32// Revision History:
33//
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.
56//
57// 1.1 - 12/25/96 AKM Linux version.
58// - 10/09/98 DMC Revised Linux version.
59//------------------------------------------------------------------------------
60
61//************
62//* Includes *
63//************
64
65#include <linux/sched.h>
66#include "i2lib.h"
67
68
69//***********************
70//* Function Prototypes *
71//***********************
72static void i2QueueNeeds(i2eBordStrPtr, i2ChanStrPtr, int);
73static i2ChanStrPtr i2DeQueueNeeds(i2eBordStrPtr, int );
74static void i2StripFifo(i2eBordStrPtr);
75static void i2StuffFifoBypass(i2eBordStrPtr);
76static void i2StuffFifoFlow(i2eBordStrPtr);
77static void i2StuffFifoInline(i2eBordStrPtr);
78static int i2RetryFlushOutput(i2ChanStrPtr);
79
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.
83static void iiSendPendingMail(i2eBordStrPtr);
84static void serviceOutgoingFifo(i2eBordStrPtr);
85
86// Functions defined in ip2.c as part of interrupt handling
87static void do_input(void *);
88static void do_status(void *);
89
90//***************
91//* Debug Data *
92//***************
93#ifdef DEBUG_FIFO
94
95unsigned char DBGBuf[0x4000];
96unsigned short I = 0;
97
98static void
99WriteDBGBuf(char *s, unsigned char *src, unsigned short n )
100{
101 char *p = src;
102
103 // XXX: We need a spin lock here if we ever use this again
104
105 while (*s) { // copy label
106 DBGBuf[I] = *s++;
107 I = I++ & 0x3fff;
108 }
109 while (n--) { // copy data
110 DBGBuf[I] = *p++;
111 I = I++ & 0x3fff;
112 }
113}
114
115static void
116fatality(i2eBordStrPtr pB )
117{
118 int i;
119
120 for (i=0;i<sizeof(DBGBuf);i++) {
121 if ((i%16) == 0)
122 printk("\n%4x:",i);
123 printk("%02x ",DBGBuf[i]);
124 }
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(" . ");
133 }
134 }
135 printk("\n");
136 printk("Last index %x\n",I);
137}
138#endif /* DEBUG_FIFO */
139
140//********
141//* Code *
142//********
143
144static inline int
145i2Validate ( i2ChanStrPtr pCh )
146{
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));
151}
152
153//******************************************************************************
154// Function: iiSendPendingMail(pB)
155// Parameters: Pointer to a board structure
156// Returns: Nothing
157//
158// Description:
159// If any outgoing mail bits are set and there is outgoing mailbox is empty,
160// send the mail and clear the bits.
161//******************************************************************************
162static inline void
163iiSendPendingMail(i2eBordStrPtr pB)
164{
165 if (pB->i2eOutMailWaiting && (!pB->i2eWaitingForEmptyFifo) )
166 {
167 if (iiTrySendMail(pB, pB->i2eOutMailWaiting))
168 {
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.
173 */
174 pB->i2eWaitingForEmptyFifo |=
175 (pB->i2eOutMailWaiting & MB_OUT_STUFFED);
176 pB->i2eOutMailWaiting = 0;
177 pB->SendPendingRetry = 0;
178 } else {
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.
184 /\/\|=mhw=|\/\/ */
185
186 if( ++pB->SendPendingRetry < 16 ) {
187
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) );
193 } else {
194 printk( KERN_ERR "IP2: iiSendPendingMail unable to queue outbound mail\n" );
195 }
196 }
197 }
198}
199
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
206//
207// Description:
208//
209// This function patches pointers, back-pointers, and initializes all the
210// elements in the channel structure array.
211//
212// This should be run after the board structure is initialized, through having
213// loaded the standard loadware (otherwise it complains).
214//
215// In any case, it must be done before any serious work begins initializing the
216// irq's or sending commands...
217//
218//******************************************************************************
219static int
220i2InitChannels ( i2eBordStrPtr pB, int nChannels, i2ChanStrPtr pCh)
221{
222 int index, stuffIndex;
223 i2ChanStrPtr *ppCh;
224
225 if (pB->i2eValid != I2E_MAGIC) {
226 COMPLETE(pB, I2EE_BADMAGIC);
227 }
228 if (pB->i2eState != II_STATE_STDLOADED) {
229 COMPLETE(pB, I2EE_BADSTATE);
230 }
231
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);
237
238 // NO LOCK needed yet - this is init
239
240 pB->i2eChannelPtr = pCh;
241 pB->i2eChannelCnt = nChannels;
242
243 pB->i2Fbuf_strip = pB->i2Fbuf_stuff = 0;
244 pB->i2Dbuf_strip = pB->i2Dbuf_stuff = 0;
245 pB->i2Bbuf_strip = pB->i2Bbuf_stuff = 0;
246
247 pB->SendPendingRetry = 0;
248
249 memset ( pCh, 0, sizeof (i2ChanStr) * nChannels );
250
251 for (index = stuffIndex = 0, ppCh = (i2ChanStrPtr *)(pB->i2Fbuf);
252 nChannels && index < ABS_MOST_PORTS;
253 index++)
254 {
255 if ( !(pB->i2eChannelMap[index >> 4] & (1 << (index & 0xf)) ) ) {
256 continue;
257 }
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;
266 } else {
267 pCh->validity = CHANNEL_MAGIC;
268 }
269 pCh->pMyBord = pB; /* Back-pointer */
270
271 // Prepare an outgoing flow-control packet to send as soon as the chance
272 // occurs.
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;
277 pCh->infl.fcmd = 37;
278 pCh->infl.asof = 0;
279 pCh->infl.room = IBUF_SIZE - 1;
280
281 pCh->whenSendFlow = (IBUF_SIZE/5)*4; // when 80% full
282
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
289 stuffIndex++;
290 *ppCh++ = pCh; // List this channel as needing
291 // initial flow control packet sent
292 }
293
294 // Don't allow anything to be sent until the status packets come in from
295 // the board.
296
297 pCh->outfl.asof = 0;
298 pCh->outfl.room = 0;
299
300 // Initialize all the ring buffers
301
302 pCh->Ibuf_stuff = pCh->Ibuf_strip = 0;
303 pCh->Obuf_stuff = pCh->Obuf_strip = 0;
304 pCh->Cbuf_stuff = pCh->Cbuf_strip = 0;
305
306 memset( &pCh->icount, 0, sizeof (struct async_icount) );
307 pCh->hotKeyIn = HOT_CLEAR;
308 pCh->channelOptions = 0;
309 pCh->bookMarks = 0;
310 init_waitqueue_head(&pCh->pBookmarkWait);
311
312 init_waitqueue_head(&pCh->open_wait);
313 init_waitqueue_head(&pCh->close_wait);
314 init_waitqueue_head(&pCh->delta_msr_wait);
315
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
319
320 pCh->dataSetIn = 0;
321 pCh->dataSetOut = 0;
322
323 pCh->wopen = 0;
324 pCh->throttled = 0;
325
326 pCh->speed = CBR_9600;
327
328 pCh->flags = 0;
329
330 pCh->ClosingDelay = 5*HZ/10;
331 pCh->ClosingWaitTime = 30*HZ;
332
333 // Initialize task queue objects
334 INIT_WORK(&pCh->tqueue_input, do_input, pCh);
335 INIT_WORK(&pCh->tqueue_status, do_status, pCh);
336
337#ifdef IP2DEBUG_TRACE
338 pCh->trace = ip2trace;
339#endif
340
341 ++pCh;
342 --nChannels;
343 }
344 // No need to check for wrap here; this is initialization.
345 pB->i2Fbuf_stuff = stuffIndex;
346 COMPLETE(pB, I2EE_GOOD);
347
348}
349
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
354// Returns:
355// Pointer to a channel structure
356//
357// Description: Returns pointer struct of next channel that needs service of
358// the type specified. Otherwise returns a NULL reference.
359//
360//******************************************************************************
361static i2ChanStrPtr
362i2DeQueueNeeds(i2eBordStrPtr pB, int type)
363{
364 unsigned short queueIndex;
365 unsigned long flags;
366
367 i2ChanStrPtr pCh = NULL;
368
369 switch(type) {
370
371 case NEED_INLINE:
372
373 WRITE_LOCK_IRQSAVE(&pB->Dbuf_spinlock,flags);
374 if ( pB->i2Dbuf_stuff != pB->i2Dbuf_strip)
375 {
376 queueIndex = pB->i2Dbuf_strip;
377 pCh = pB->i2Dbuf[queueIndex];
378 queueIndex++;
379 if (queueIndex >= CH_QUEUE_SIZE) {
380 queueIndex = 0;
381 }
382 pB->i2Dbuf_strip = queueIndex;
383 pCh->channelNeeds &= ~NEED_INLINE;
384 }
385 WRITE_UNLOCK_IRQRESTORE(&pB->Dbuf_spinlock,flags);
386 break;
387
388 case NEED_BYPASS:
389
390 WRITE_LOCK_IRQSAVE(&pB->Bbuf_spinlock,flags);
391 if (pB->i2Bbuf_stuff != pB->i2Bbuf_strip)
392 {
393 queueIndex = pB->i2Bbuf_strip;
394 pCh = pB->i2Bbuf[queueIndex];
395 queueIndex++;
396 if (queueIndex >= CH_QUEUE_SIZE) {
397 queueIndex = 0;
398 }
399 pB->i2Bbuf_strip = queueIndex;
400 pCh->channelNeeds &= ~NEED_BYPASS;
401 }
402 WRITE_UNLOCK_IRQRESTORE(&pB->Bbuf_spinlock,flags);
403 break;
404
405 case NEED_FLOW:
406
407 WRITE_LOCK_IRQSAVE(&pB->Fbuf_spinlock,flags);
408 if (pB->i2Fbuf_stuff != pB->i2Fbuf_strip)
409 {
410 queueIndex = pB->i2Fbuf_strip;
411 pCh = pB->i2Fbuf[queueIndex];
412 queueIndex++;
413 if (queueIndex >= CH_QUEUE_SIZE) {
414 queueIndex = 0;
415 }
416 pB->i2Fbuf_strip = queueIndex;
417 pCh->channelNeeds &= ~NEED_FLOW;
418 }
419 WRITE_UNLOCK_IRQRESTORE(&pB->Fbuf_spinlock,flags);
420 break;
421 default:
422 printk(KERN_ERR "i2DeQueueNeeds called with bad type:%x\n",type);
423 break;
424 }
425 return pCh;
426}
427
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
433// Returns: Nothing
434//
435// Description:
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//******************************************************************************
439static void
440i2QueueNeeds(i2eBordStrPtr pB, i2ChanStrPtr pCh, int type)
441{
442 unsigned short queueIndex;
443 unsigned long flags;
444
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.
447
448 switch (type) {
449
450 case NEED_INLINE:
451
452 WRITE_LOCK_IRQSAVE(&pB->Dbuf_spinlock,flags);
453 if ( !(pCh->channelNeeds & NEED_INLINE) )
454 {
455 pCh->channelNeeds |= NEED_INLINE;
456 queueIndex = pB->i2Dbuf_stuff;
457 pB->i2Dbuf[queueIndex++] = pCh;
458 if (queueIndex >= CH_QUEUE_SIZE)
459 queueIndex = 0;
460 pB->i2Dbuf_stuff = queueIndex;
461 }
462 WRITE_UNLOCK_IRQRESTORE(&pB->Dbuf_spinlock,flags);
463 break;
464
465 case NEED_BYPASS:
466
467 WRITE_LOCK_IRQSAVE(&pB->Bbuf_spinlock,flags);
468 if ((type & NEED_BYPASS) && !(pCh->channelNeeds & NEED_BYPASS))
469 {
470 pCh->channelNeeds |= NEED_BYPASS;
471 queueIndex = pB->i2Bbuf_stuff;
472 pB->i2Bbuf[queueIndex++] = pCh;
473 if (queueIndex >= CH_QUEUE_SIZE)
474 queueIndex = 0;
475 pB->i2Bbuf_stuff = queueIndex;
476 }
477 WRITE_UNLOCK_IRQRESTORE(&pB->Bbuf_spinlock,flags);
478 break;
479
480 case NEED_FLOW:
481
482 WRITE_LOCK_IRQSAVE(&pB->Fbuf_spinlock,flags);
483 if ((type & NEED_FLOW) && !(pCh->channelNeeds & NEED_FLOW))
484 {
485 pCh->channelNeeds |= NEED_FLOW;
486 queueIndex = pB->i2Fbuf_stuff;
487 pB->i2Fbuf[queueIndex++] = pCh;
488 if (queueIndex >= CH_QUEUE_SIZE)
489 queueIndex = 0;
490 pB->i2Fbuf_stuff = queueIndex;
491 }
492 WRITE_UNLOCK_IRQRESTORE(&pB->Fbuf_spinlock,flags);
493 break;
494
495 case NEED_CREDIT:
496 pCh->channelNeeds |= NEED_CREDIT;
497 break;
498 default:
499 printk(KERN_ERR "i2QueueNeeds called with bad type:%x\n",type);
500 break;
501 }
502 return;
503}
504
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)
511// n commands
512// Returns: Number of commands sent, or -1 for error
513//
514// get board lock before calling
515//
516// Description:
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//******************************************************************************
526static int
527i2QueueCommands(int type, i2ChanStrPtr pCh, int timeout, int nCommands,
528 cmdSyntaxPtr pCs0,...)
529{
530 int totalsize = 0;
531 int blocksize;
532 int lastended;
533 cmdSyntaxPtr *ppCs;
534 cmdSyntaxPtr pCs;
535 int count;
536 int flag;
537 i2eBordStrPtr pB;
538
539 unsigned short maxBlock;
540 unsigned short maxBuff;
541 short bufroom;
542 unsigned short stuffIndex;
543 unsigned char *pBuf;
544 unsigned char *pInsert;
545 unsigned char *pDest, *pSource;
546 unsigned short channel;
547 int cnt;
548 unsigned long flags = 0;
549 rwlock_t *lock_var_p = NULL;
550
551 // Make sure the channel exists, otherwise do nothing
552 if ( !i2Validate ( pCh ) ) {
553 return -1;
554 }
555
556 ip2trace (CHANN, ITRC_QUEUE, ITRC_ENTER, 0 );
557
558 pB = pCh->pMyBord;
559
560 // Board must also exist, and THE INTERRUPT COMMAND ALREADY SENT
561 if (pB->i2eValid != I2E_MAGIC || pB->i2eUsingIrq == IRQ_UNDEFINED) {
562 return -2;
563 }
564 // If the board has gone fatal, return bad, and also hit the trap routine if
565 // it exists.
566 if (pB->i2eFatal) {
567 if ( pB->i2eFatalTrap ) {
568 (*(pB)->i2eFatalTrap)(pB);
569 }
570 return -3;
571 }
572 // Set up some variables, Which buffers are we using? How big are they?
573 switch(type)
574 {
575 case PTYPE_INLINE:
576 flag = INL;
577 maxBlock = MAX_OBUF_BLOCK;
578 maxBuff = OBUF_SIZE;
579 pBuf = pCh->Obuf;
580 break;
581 case PTYPE_BYPASS:
582 flag = BYP;
583 maxBlock = MAX_CBUF_BLOCK;
584 maxBuff = CBUF_SIZE;
585 pBuf = pCh->Cbuf;
586 break;
587 default:
588 return -4;
589 }
590 // Determine the total size required for all the commands
591 totalsize = blocksize = sizeof(i2CmdHeader);
592 lastended = 0;
593 ppCs = &pCs0;
594 for ( count = nCommands; count; count--, ppCs++)
595 {
596 pCs = *ppCs;
597 cnt = pCs->length;
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);
604 }
605 totalsize += cnt;
606 blocksize += cnt;
607
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;
611 }
612 for (;;) {
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) ?
616 switch(type) {
617 case PTYPE_INLINE:
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;
622 break;
623 case PTYPE_BYPASS:
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;
628 break;
629 default:
630 return -5;
631 }
632 if (--bufroom < 0) {
633 bufroom += maxBuff;
634 }
635
636 ip2trace (CHANN, ITRC_QUEUE, 2, 1, bufroom );
637
638 // Check for overflow
639 if (totalsize <= bufroom) {
640 // Normal Expected path - We still hold LOCK
641 break; /* from for()- Enough room: goto proceed */
642 }
643 }
644
645 ip2trace (CHANN, ITRC_QUEUE, 3, 1, totalsize );
646
647 // Prepare to wait for buffers to empty
648 WRITE_UNLOCK_IRQRESTORE(lock_var_p,flags);
649 serviceOutgoingFifo(pB); // Dump what we got
650
651 if (timeout == 0) {
652 return 0; // Tired of waiting
653 }
654 if (timeout > 0)
655 timeout--; // So negative values == forever
656
657 if (!in_interrupt()) {
Nishanth Aravamudanda4cd8d2005-09-10 00:27:30 -0700658 schedule_timeout_interruptible(1); // short nap
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 } else {
660 // we cannot sched/sleep in interrrupt silly
661 return 0;
662 }
663 if (signal_pending(current)) {
664 return 0; // Wake up! Time to die!!!
665 }
666
667 ip2trace (CHANN, ITRC_QUEUE, 4, 0 );
668
669 } // end of for(;;)
670
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
675
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;
679 count;
680 count--, ppCs++)
681 {
682 pCs = *ppCs; // Points to command protocol structure
683
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
687 // pCs->cmd[0].
688 if (pCs == CMD_BMARK_REQ) {
689 pCh->bookMarks++;
690
691 ip2trace (CHANN, ITRC_DRAIN, 30, 1, pCh->bookMarks );
692
693 }
694 cnt = pCs->length;
695
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) {
700
701 ip2trace (CHANN, ITRC_QUEUE, 5, 0 );
702
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) {
709 stuffIndex = 0;
710 pInsert = pBuf;
711 }
712 pInsert = &pBuf[stuffIndex]; // Pointer to start of next pkt
713 pDest = CMD_OF(pInsert);
714 blocksize = sizeof(i2CmdHeader);
715 }
716 // Now we know there is room for this one in the current block
717
718 blocksize += cnt; // Total bytes in this command
719 pSource = pCs->cmd; // Copy the command into the buffer
720 while (cnt--) {
721 *pDest++ = *pSource++;
722 }
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;
726 } // end for
727 // Clean up the final block by writing header, etc
728
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) {
735 stuffIndex = 0;
736 pInsert = pBuf;
737 }
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
741 // end of the queue.
742 switch(type)
743 {
744 case PTYPE_INLINE:
745 pCh->Obuf_stuff = stuffIndex; // Store buffer pointer
746 WRITE_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
747
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);
752 break;
753
754 case PTYPE_BYPASS:
755 pCh->Cbuf_stuff = stuffIndex; // Store buffer pointer
756 WRITE_UNLOCK_IRQRESTORE(&pCh->Cbuf_spinlock,flags);
757
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);
762 break;
763 }
764
765 ip2trace (CHANN, ITRC_QUEUE, ITRC_RETURN, 1, nCommands );
766
767 return nCommands; // Good status: number of commands sent
768}
769
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
775//
776// Description:
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//******************************************************************************
783static int
784i2GetStatus(i2ChanStrPtr pCh, int resetBits)
785{
786 unsigned short status;
787 i2eBordStrPtr pB;
788
789 ip2trace (CHANN, ITRC_STATUS, ITRC_ENTER, 2, pCh->dataSetIn, resetBits );
790
791 // Make sure the channel exists, otherwise do nothing */
792 if ( !i2Validate ( pCh ) )
793 return -1;
794
795 pB = pCh->pMyBord;
796
797 status = pCh->dataSetIn;
798
799 // Clear any specified error bits: but note that only actual error bits can
800 // be cleared, regardless of the value passed.
801 if (resetBits)
802 {
803 pCh->dataSetIn &= ~(resetBits & (I2_BRK | I2_PAR | I2_FRA | I2_OVR));
804 pCh->dataSetIn &= ~(I2_DDCD | I2_DCTS | I2_DDSR | I2_DRI);
805 }
806
807 ip2trace (CHANN, ITRC_STATUS, ITRC_RETURN, 1, pCh->dataSetIn );
808
809 return status;
810}
811
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
818//
819// Description:
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//******************************************************************************
824static int
825i2Input(i2ChanStrPtr pCh)
826{
827 int amountToMove;
828 unsigned short stripIndex;
829 int count;
830 unsigned long flags = 0;
831
832 ip2trace (CHANN, ITRC_INPUT, ITRC_ENTER, 0);
833
834 // Ensure channel structure seems real
835 if ( !i2Validate( pCh ) ) {
836 count = -1;
837 goto i2Input_exit;
838 }
839 WRITE_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags);
840
841 // initialize some accelerators and private copies
842 stripIndex = pCh->Ibuf_strip;
843
844 count = pCh->Ibuf_stuff - stripIndex;
845
846 // If buffer is empty or requested data count was 0, (trivial case) return
847 // without any further thought.
848 if ( count == 0 ) {
849 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
850 goto i2Input_exit;
851 }
852 // Adjust for buffer wrap
853 if ( count < 0 ) {
854 count += IBUF_SIZE;
855 }
856 // Don't give more than can be taken by the line discipline
Alan Coxd9e39532006-01-09 20:54:20 -0800857 amountToMove = pCh->pTTY->receive_room;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 if (count > amountToMove) {
859 count = amountToMove;
860 }
861 // How much could we copy without a wrap?
862 amountToMove = IBUF_SIZE - stripIndex;
863
864 if (amountToMove > count) {
865 amountToMove = count;
866 }
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 );
874 }
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.
877 stripIndex += count;
878 if (stripIndex >= IBUF_SIZE) {
879 stripIndex -= IBUF_SIZE;
880 }
881 pCh->Ibuf_strip = stripIndex;
882
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
885 // packet was sent.
886 pCh->infl.asof += count;
887
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);
892 } else {
893 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
894 }
895
896i2Input_exit:
897
898 ip2trace (CHANN, ITRC_INPUT, ITRC_RETURN, 1, count);
899
900 return count;
901}
902
903//******************************************************************************
904// Function: i2InputFlush(pCh)
905// Parameters: Pointer to a channel structure
906// Returns: Number of bytes stripped, or -1 for error
907//
908// Description:
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//******************************************************************************
913static int
914i2InputFlush(i2ChanStrPtr pCh)
915{
916 int count;
917 unsigned long flags;
918
919 // Ensure channel structure seems real
920 if ( !i2Validate ( pCh ) )
921 return -1;
922
923 ip2trace (CHANN, ITRC_INPUT, 10, 0);
924
925 WRITE_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags);
926 count = pCh->Ibuf_stuff - pCh->Ibuf_strip;
927
928 // Adjust for buffer wrap
929 if (count < 0) {
930 count += IBUF_SIZE;
931 }
932
933 // Expedient way to zero out the buffer
934 pCh->Ibuf_strip = pCh->Ibuf_stuff;
935
936
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
939 // packet was sent.
940
941 pCh->infl.asof += count;
942
943 if ( (pCh->sinceLastFlow += count) >= pCh->whenSendFlow )
944 {
945 pCh->sinceLastFlow -= pCh->whenSendFlow;
946 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
947 i2QueueNeeds(pCh->pMyBord, pCh, NEED_FLOW);
948 } else {
949 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
950 }
951
952 ip2trace (CHANN, ITRC_INPUT, 19, 1, count);
953
954 return count;
955}
956
957//******************************************************************************
958// Function: i2InputAvailable(pCh)
959// Parameters: Pointer to a channel structure
960// Returns: Number of bytes available, or -1 for error
961//
962// Description:
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//******************************************************************************
967#if 0
968static int
969i2InputAvailable(i2ChanStrPtr pCh)
970{
971 int count;
972
973 // Ensure channel structure seems real
974 if ( !i2Validate ( pCh ) ) return -1;
975
976
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);
981
982 // Adjust for buffer wrap
983 if (count < 0)
984 {
985 count += IBUF_SIZE;
986 }
987
988 return count;
989}
990#endif
991
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
998//
999// Description:
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//******************************************************************************
1009static int
Al Virof061c582006-10-11 17:45:47 +01001010i2Output(i2ChanStrPtr pCh, const char *pSource, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011{
1012 i2eBordStrPtr pB;
1013 unsigned char *pInsert;
1014 int amountToMove;
1015 int countOriginal = count;
1016 unsigned short channel;
1017 unsigned short stuffIndex;
1018 unsigned long flags;
1019 int rc = 0;
1020
1021 int bailout = 10;
1022
Al Virof061c582006-10-11 17:45:47 +01001023 ip2trace (CHANN, ITRC_OUTPUT, ITRC_ENTER, 2, count, 0 );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024
1025 // Ensure channel structure seems real
1026 if ( !i2Validate ( pCh ) )
1027 return -1;
1028
1029 // initialize some accelerators and private copies
1030 pB = pCh->pMyBord;
1031 channel = pCh->infl.hd.i2sChannel;
1032
1033 // If the board has gone fatal, return bad, and also hit the trap routine if
1034 // it exists.
1035 if (pB->i2eFatal) {
1036 if (pB->i2eFatalTrap) {
1037 (*(pB)->i2eFatalTrap)(pB);
1038 }
1039 return -1;
1040 }
1041 // Proceed as though we would do everything
1042 while ( count > 0 ) {
1043
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;
1050 }
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);
1054
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);
1058 }
1059 // Don't move more than the count we were given
1060 if (amountToMove > count) {
1061 amountToMove = count;
1062 }
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.
1066
1067// Small WINDOW here with no LOCK but I can't call Flush with LOCK
1068// We would be flushing (or ending flush) anyway
1069
1070 ip2trace (CHANN, ITRC_OUTPUT, 10, 1, amountToMove );
1071
1072 if ( !(pCh->flush_flags && i2RetryFlushOutput(pCh) )
1073 && amountToMove > 0 )
1074 {
1075 WRITE_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
1076 stuffIndex = pCh->Obuf_stuff;
1077
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]);
1081
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;
1088
1089 // Move the data
Al Virof061c582006-10-11 17:45:47 +01001090 memcpy( (char*)(DATA_OF(pInsert)), pSource, amountToMove );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 // Adjust pointers and indices
1092 pSource += amountToMove;
1093 pCh->Obuf_char_count += amountToMove;
1094 stuffIndex += amountToMove + sizeof(i2DataHeader);
1095 count -= amountToMove;
1096
1097 if (stuffIndex >= OBUF_SIZE) {
1098 stuffIndex = 0;
1099 }
1100 pCh->Obuf_stuff = stuffIndex;
1101
1102 WRITE_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
1103
1104 ip2trace (CHANN, ITRC_OUTPUT, 13, 1, stuffIndex );
1105
1106 } else {
1107
1108 // Cannot move data
1109 // becuz we need to stuff a flush
1110 // or amount to move is <= 0
1111
1112 ip2trace(CHANN, ITRC_OUTPUT, 14, 3,
1113 amountToMove, pB->i2eFifoRemains,
1114 pB->i2eWaitingForEmptyFifo );
1115
1116 // Put this channel back on queue
1117 // this ultimatly gets more data or wakes write output
1118 i2QueueNeeds(pB, pCh, NEED_INLINE);
1119
1120 if ( pB->i2eWaitingForEmptyFifo ) {
1121
1122 ip2trace (CHANN, ITRC_OUTPUT, 16, 0 );
1123
1124 // or schedule
1125 if (!in_interrupt()) {
1126
1127 ip2trace (CHANN, ITRC_OUTPUT, 61, 0 );
1128
Nishanth Aravamudanda4cd8d2005-09-10 00:27:30 -07001129 schedule_timeout_interruptible(2);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 if (signal_pending(current)) {
1131 break;
1132 }
1133 continue;
1134 } else {
1135
1136 ip2trace (CHANN, ITRC_OUTPUT, 62, 0 );
1137
1138 // let interrupt in = WAS restore_flags()
1139 // We hold no lock nor is irq off anymore???
1140
1141 break;
1142 }
1143 break; // from while(count)
1144 }
1145 else if ( pB->i2eFifoRemains < 32 && !pB->i2eTxMailEmpty ( pB ) )
1146 {
1147 ip2trace (CHANN, ITRC_OUTPUT, 19, 2,
1148 pB->i2eFifoRemains,
1149 pB->i2eTxMailEmpty );
1150
1151 break; // from while(count)
1152 } else if ( pCh->channelNeeds & NEED_CREDIT ) {
1153
1154 ip2trace (CHANN, ITRC_OUTPUT, 22, 0 );
1155
1156 break; // from while(count)
1157 } else if ( --bailout) {
1158
1159 // Try to throw more things (maybe not us) in the fifo if we're
1160 // not already waiting for it.
1161
1162 ip2trace (CHANN, ITRC_OUTPUT, 20, 0 );
1163
1164 serviceOutgoingFifo(pB);
1165 //break; CONTINUE;
1166 } else {
1167 ip2trace (CHANN, ITRC_OUTPUT, 21, 3,
1168 pB->i2eFifoRemains,
1169 pB->i2eOutMailWaiting,
1170 pB->i2eWaitingForEmptyFifo );
1171
1172 break; // from while(count)
1173 }
1174 }
1175 } // End of while(count)
1176
1177 i2QueueNeeds(pB, pCh, NEED_INLINE);
1178
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) {
1182
1183 ip2trace (CHANN, ITRC_OUTPUT, 17, 2, countOriginal, count );
1184
1185 serviceOutgoingFifo( pB );
1186 }
1187
1188 ip2trace (CHANN, ITRC_OUTPUT, ITRC_RETURN, 2, countOriginal, count );
1189
1190 return countOriginal - count;
1191}
1192
1193//******************************************************************************
1194// Function: i2FlushOutput(pCh)
1195// Parameters: Pointer to a channel structure
1196// Returns: Nothing
1197//
1198// Description:
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//******************************************************************************
1203static inline void
1204i2FlushOutput(i2ChanStrPtr pCh)
1205{
1206
1207 ip2trace (CHANN, ITRC_FLUSH, 1, 1, pCh->flush_flags );
1208
1209 if (pCh->flush_flags)
1210 return;
1211
1212 if ( 1 != i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_STARTFL) ) {
1213 pCh->flush_flags = STARTFL_FLAG; // Failed - flag for later
1214
1215 ip2trace (CHANN, ITRC_FLUSH, 2, 0 );
1216
1217 } else if ( 1 != i2QueueCommands(PTYPE_INLINE, pCh, 0, 1, CMD_STOPFL) ) {
1218 pCh->flush_flags = STOPFL_FLAG; // Failed - flag for later
1219
1220 ip2trace (CHANN, ITRC_FLUSH, 3, 0 );
1221 }
1222}
1223
1224static int
1225i2RetryFlushOutput(i2ChanStrPtr pCh)
1226{
1227 int old_flags = pCh->flush_flags;
1228
1229 ip2trace (CHANN, ITRC_FLUSH, 14, 1, old_flags );
1230
1231 pCh->flush_flags = 0; // Clear flag so we can avoid recursion
1232 // and queue the commands
1233
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
1237 } else {
1238 old_flags = STARTFL_FLAG; //Failure - Flag for retry later
1239 }
1240
1241 ip2trace (CHANN, ITRC_FLUSH, 15, 1, old_flags );
1242
1243 }
1244 if ( old_flags & STOPFL_FLAG ) {
1245 if (1 == i2QueueCommands(PTYPE_INLINE, pCh, 0, 1, CMD_STOPFL)) {
1246 old_flags = 0; // Success - clear flags
1247 }
1248
1249 ip2trace (CHANN, ITRC_FLUSH, 16, 1, old_flags );
1250 }
1251 pCh->flush_flags = old_flags;
1252
1253 ip2trace (CHANN, ITRC_FLUSH, 17, 1, old_flags );
1254
1255 return old_flags;
1256}
1257
1258//******************************************************************************
1259// Function: i2DrainOutput(pCh,timeout)
1260// Parameters: Pointer to a channel structure
1261// Maximum period to wait
1262// Returns: ?
1263//
1264// Description:
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//******************************************************************************
1268static void
1269i2DrainWakeup(i2ChanStrPtr pCh)
1270{
1271 ip2trace (CHANN, ITRC_DRAIN, 10, 1, pCh->BookmarkTimer.expires );
1272
1273 pCh->BookmarkTimer.expires = 0;
1274 wake_up_interruptible( &pCh->pBookmarkWait );
1275}
1276
1277static void
1278i2DrainOutput(i2ChanStrPtr pCh, int timeout)
1279{
1280 wait_queue_t wait;
1281 i2eBordStrPtr pB;
1282
1283 ip2trace (CHANN, ITRC_DRAIN, ITRC_ENTER, 1, pCh->BookmarkTimer.expires);
1284
1285 pB = pCh->pMyBord;
1286 // If the board has gone fatal, return bad,
1287 // and also hit the trap routine if it exists.
1288 if (pB->i2eFatal) {
1289 if (pB->i2eFatalTrap) {
1290 (*(pB)->i2eFatalTrap)(pB);
1291 }
1292 return;
1293 }
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;
1300
1301 ip2trace (CHANN, ITRC_DRAIN, 1, 1, pCh->BookmarkTimer.expires );
1302
1303 add_timer( &(pCh->BookmarkTimer) );
1304 }
1305
1306 i2QueueCommands( PTYPE_INLINE, pCh, -1, 1, CMD_BMARK_REQ );
1307
1308 init_waitqueue_entry(&wait, current);
1309 add_wait_queue(&(pCh->pBookmarkWait), &wait);
1310 set_current_state( TASK_INTERRUPTIBLE );
1311
1312 serviceOutgoingFifo( pB );
1313
1314 schedule(); // Now we take our interruptible sleep on
1315
1316 // Clean up the queue
1317 set_current_state( TASK_RUNNING );
1318 remove_wait_queue(&(pCh->pBookmarkWait), &wait);
1319
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;
1325
1326 ip2trace (CHANN, ITRC_DRAIN, 3, 1, pCh->BookmarkTimer.expires );
1327
1328 }
1329 ip2trace (CHANN, ITRC_DRAIN, ITRC_RETURN, 1, pCh->BookmarkTimer.expires );
1330 return;
1331}
1332
1333//******************************************************************************
1334// Function: i2OutputFree(pCh)
1335// Parameters: Pointer to a channel structure
1336// Returns: Space in output buffer
1337//
1338// Description:
1339// Returns -1 if very gross error. Otherwise returns the amount of bytes still
1340// free in the output buffer.
1341//******************************************************************************
1342static int
1343i2OutputFree(i2ChanStrPtr pCh)
1344{
1345 int amountToMove;
1346 unsigned long flags;
1347
1348 // Ensure channel structure seems real
1349 if ( !i2Validate ( pCh ) ) {
1350 return -1;
1351 }
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);
1355
1356 if (amountToMove < 0) {
1357 amountToMove += OBUF_SIZE;
1358 }
1359 // If this is negative, we will discover later
1360 amountToMove -= sizeof(i2DataHeader);
1361
1362 return (amountToMove < 0) ? 0 : amountToMove;
1363}
1364static void
1365
1366ip2_owake( PTTY tp)
1367{
1368 i2ChanStrPtr pCh;
1369
1370 if (tp == NULL) return;
1371
1372 pCh = tp->driver_data;
1373
1374 ip2trace (CHANN, ITRC_SICMD, 10, 2, tp->flags,
1375 (1 << TTY_DO_WRITE_WAKEUP) );
1376
1377 wake_up_interruptible ( &tp->write_wait );
1378 if ( ( tp->flags & (1 << TTY_DO_WRITE_WAKEUP) )
1379 && tp->ldisc.write_wakeup )
1380 {
1381 (tp->ldisc.write_wakeup) ( tp );
1382
1383 ip2trace (CHANN, ITRC_SICMD, 11, 0 );
1384
1385 }
1386}
1387
1388static inline void
1389set_baud_params(i2eBordStrPtr pB)
1390{
1391 int i,j;
1392 i2ChanStrPtr *pCh;
1393
1394 pCh = (i2ChanStrPtr *) pB->i2eChannelPtr;
1395
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)
1401 break;
1402 (pCh[i*16+j])->BaudBase = 921600; // MAX for ST654
1403 (pCh[i*16+j])->BaudDivisor = 96;
1404 }
1405 } else { // has cirrus cd1400
1406 for (j = 0; j < ABS_BIGGEST_BOX; j++) {
1407 if (pCh[i*16+j] == NULL)
1408 break;
1409 (pCh[i*16+j])->BaudBase = 115200; // MAX for CD1400
1410 (pCh[i*16+j])->BaudDivisor = 12;
1411 }
1412 }
1413 }
1414 }
1415}
1416
1417//******************************************************************************
1418// Function: i2StripFifo(pB)
1419// Parameters: Pointer to a board structure
1420// Returns: ?
1421//
1422// Description:
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.
1425//
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//******************************************************************************
1429
1430// A buffer for reading in blocks for unknown channels
1431static unsigned char junkBuffer[IBUF_SIZE];
1432
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
1435static unsigned char cmdBuffer[MAX_CMD_PACK_SIZE + 4];
1436
1437// This table changes the bit order from MSR order given by STAT_MODEM packet to
1438// status bits used in our library.
1439static char xlatDss[16] = {
14400 | 0 | 0 | 0 ,
14410 | 0 | 0 | I2_CTS ,
14420 | 0 | I2_DSR | 0 ,
14430 | 0 | I2_DSR | I2_CTS ,
14440 | I2_RI | 0 | 0 ,
14450 | I2_RI | 0 | I2_CTS ,
14460 | I2_RI | I2_DSR | 0 ,
14470 | I2_RI | I2_DSR | I2_CTS ,
1448I2_DCD | 0 | 0 | 0 ,
1449I2_DCD | 0 | 0 | I2_CTS ,
1450I2_DCD | 0 | I2_DSR | 0 ,
1451I2_DCD | 0 | I2_DSR | I2_CTS ,
1452I2_DCD | I2_RI | 0 | 0 ,
1453I2_DCD | I2_RI | 0 | I2_CTS ,
1454I2_DCD | I2_RI | I2_DSR | 0 ,
1455I2_DCD | I2_RI | I2_DSR | I2_CTS };
1456
1457static inline void
1458i2StripFifo(i2eBordStrPtr pB)
1459{
1460 i2ChanStrPtr pCh;
1461 int channel;
1462 int count;
1463 unsigned short stuffIndex;
1464 int amountToRead;
1465 unsigned char *pc, *pcLimit;
1466 unsigned char uc;
1467 unsigned char dss_change;
1468 unsigned long bflags,cflags;
1469
1470// ip2trace (ITRC_NO_PORT, ITRC_SFIFO, ITRC_ENTER, 0 );
1471
1472 while (HAS_INPUT(pB)) {
1473// ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 2, 0 );
1474
1475 // Process packet from fifo a one atomic unit
1476 WRITE_LOCK_IRQSAVE(&pB->read_fifo_spinlock,bflags);
1477
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);
1481
1482 switch(PTYPE_OF(pB->i2eLeadoffWord))
1483 {
1484 case PTYPE_DATA:
1485 pB->got_input = 1;
1486
1487// ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 3, 0 );
1488
1489 channel = CHANNEL_OF(pB->i2eLeadoffWord); /* Store channel */
1490 count = iiReadWord(pB); /* Count is in the next word */
1491
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
1495// sick!
1496 if ( ((unsigned int)count) > IBUF_SIZE ) {
1497 pB->i2eFatal = 2;
1498 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock,bflags);
1499 return; /* Bail out ASAP */
1500 }
1501 // Channel is illegally big ?
1502 if ((channel >= pB->i2eChannelCnt) ||
1503 (NULL==(pCh = ((i2ChanStrPtr*)pB->i2eChannelPtr)[channel])))
1504 {
1505 iiReadBuf(pB, junkBuffer, count);
1506 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock,bflags);
1507 break; /* From switch: ready for next packet */
1508 }
1509
1510 // Channel should be valid, then
1511
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)
1518 {
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 */
1523 }
1524
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;
1533
1534 // stuffIndex would have been already adjusted so there would
1535 // always be room for at least one, and count is always at least
1536 // one.
1537
1538 iiReadBuf(pB, &(pCh->Ibuf[stuffIndex]), amountToRead);
1539 pCh->icount.rx += amountToRead;
1540
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.
1547
1548 stuffIndex += amountToRead;
1549
1550 if (stuffIndex >= IBUF_SIZE) {
1551 if ((amountToRead & 1) && (count > amountToRead)) {
1552 pCh->Ibuf[0] = pCh->Ibuf[IBUF_SIZE];
1553 amountToRead++;
1554 stuffIndex = 1;
1555 } else {
1556 stuffIndex = 0;
1557 }
1558 }
1559
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;
1566 }
1567
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);
1572
1573#ifdef USE_IQ
1574 schedule_work(&pCh->tqueue_input);
1575#else
1576 do_input(pCh);
1577#endif
1578
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.
1583
1584 break; // From switch: ready for next packet
1585
1586 case PTYPE_STATUS:
1587 ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 4, 0 );
1588
1589 count = CMD_COUNT_OF(pB->i2eLeadoffWord);
1590
1591 iiReadBuf(pB, cmdBuffer, count);
1592 // We can release early with buffer grab
1593 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock,bflags);
1594
1595 pc = cmdBuffer;
1596 pcLimit = &(cmdBuffer[count]);
1597
1598 while (pc < pcLimit) {
1599 channel = *pc++;
1600
1601 ip2trace (channel, ITRC_SFIFO, 7, 2, channel, *pc );
1602
1603 /* check for valid channel */
1604 if (channel < pB->i2eChannelCnt
1605 &&
1606 (pCh = (((i2ChanStrPtr*)pB->i2eChannelPtr)[channel])) != NULL
1607 )
1608 {
1609 dss_change = 0;
1610
1611 switch (uc = *pc++)
1612 {
1613 /* Breaks and modem signals are easy: just update status */
1614 case STAT_CTS_UP:
1615 if ( !(pCh->dataSetIn & I2_CTS) )
1616 {
1617 pCh->dataSetIn |= I2_DCTS;
1618 pCh->icount.cts++;
1619 dss_change = 1;
1620 }
1621 pCh->dataSetIn |= I2_CTS;
1622 break;
1623
1624 case STAT_CTS_DN:
1625 if ( pCh->dataSetIn & I2_CTS )
1626 {
1627 pCh->dataSetIn |= I2_DCTS;
1628 pCh->icount.cts++;
1629 dss_change = 1;
1630 }
1631 pCh->dataSetIn &= ~I2_CTS;
1632 break;
1633
1634 case STAT_DCD_UP:
1635 ip2trace (channel, ITRC_MODEM, 1, 1, pCh->dataSetIn );
1636
1637 if ( !(pCh->dataSetIn & I2_DCD) )
1638 {
1639 ip2trace (CHANN, ITRC_MODEM, 2, 0 );
1640 pCh->dataSetIn |= I2_DDCD;
1641 pCh->icount.dcd++;
1642 dss_change = 1;
1643 }
1644 pCh->dataSetIn |= I2_DCD;
1645
1646 ip2trace (channel, ITRC_MODEM, 3, 1, pCh->dataSetIn );
1647 break;
1648
1649 case STAT_DCD_DN:
1650 ip2trace (channel, ITRC_MODEM, 4, 1, pCh->dataSetIn );
1651 if ( pCh->dataSetIn & I2_DCD )
1652 {
1653 ip2trace (channel, ITRC_MODEM, 5, 0 );
1654 pCh->dataSetIn |= I2_DDCD;
1655 pCh->icount.dcd++;
1656 dss_change = 1;
1657 }
1658 pCh->dataSetIn &= ~I2_DCD;
1659
1660 ip2trace (channel, ITRC_MODEM, 6, 1, pCh->dataSetIn );
1661 break;
1662
1663 case STAT_DSR_UP:
1664 if ( !(pCh->dataSetIn & I2_DSR) )
1665 {
1666 pCh->dataSetIn |= I2_DDSR;
1667 pCh->icount.dsr++;
1668 dss_change = 1;
1669 }
1670 pCh->dataSetIn |= I2_DSR;
1671 break;
1672
1673 case STAT_DSR_DN:
1674 if ( pCh->dataSetIn & I2_DSR )
1675 {
1676 pCh->dataSetIn |= I2_DDSR;
1677 pCh->icount.dsr++;
1678 dss_change = 1;
1679 }
1680 pCh->dataSetIn &= ~I2_DSR;
1681 break;
1682
1683 case STAT_RI_UP:
1684 if ( !(pCh->dataSetIn & I2_RI) )
1685 {
1686 pCh->dataSetIn |= I2_DRI;
1687 pCh->icount.rng++;
1688 dss_change = 1;
1689 }
1690 pCh->dataSetIn |= I2_RI ;
1691 break;
1692
1693 case STAT_RI_DN:
1694 // to be compat with serial.c
1695 //if ( pCh->dataSetIn & I2_RI )
1696 //{
1697 // pCh->dataSetIn |= I2_DRI;
1698 // pCh->icount.rng++;
1699 // dss_change = 1;
1700 //}
1701 pCh->dataSetIn &= ~I2_RI ;
1702 break;
1703
1704 case STAT_BRK_DET:
1705 pCh->dataSetIn |= I2_BRK;
1706 pCh->icount.brk++;
1707 dss_change = 1;
1708 break;
1709
1710 // Bookmarks? one less request we're waiting for
1711 case STAT_BMARK:
1712 pCh->bookMarks--;
1713 if (pCh->bookMarks <= 0 ) {
1714 pCh->bookMarks = 0;
1715 wake_up_interruptible( &pCh->pBookmarkWait );
1716
1717 ip2trace (channel, ITRC_DRAIN, 20, 1, pCh->BookmarkTimer.expires );
1718 }
1719 break;
1720
1721 // Flow control packets? Update the new credits, and if
1722 // someone was waiting for output, queue him up again.
1723 case STAT_FLOW:
1724 pCh->outfl.room =
1725 ((flowStatPtr)pc)->room -
1726 (pCh->outfl.asof - ((flowStatPtr)pc)->asof);
1727
1728 ip2trace (channel, ITRC_STFLW, 1, 1, pCh->outfl.room );
1729
1730 if (pCh->channelNeeds & NEED_CREDIT)
1731 {
1732 ip2trace (channel, ITRC_STFLW, 2, 1, pCh->channelNeeds);
1733
1734 pCh->channelNeeds &= ~NEED_CREDIT;
1735 i2QueueNeeds(pB, pCh, NEED_INLINE);
1736 if ( pCh->pTTY )
1737 ip2_owake(pCh->pTTY);
1738 }
1739
1740 ip2trace (channel, ITRC_STFLW, 3, 1, pCh->channelNeeds);
1741
1742 pc += sizeof(flowStat);
1743 break;
1744
1745 /* Special packets: */
1746 /* Just copy the information into the channel structure */
1747
1748 case STAT_STATUS:
1749
1750 pCh->channelStatus = *((debugStatPtr)pc);
1751 pc += sizeof(debugStat);
1752 break;
1753
1754 case STAT_TXCNT:
1755
1756 pCh->channelTcount = *((cntStatPtr)pc);
1757 pc += sizeof(cntStat);
1758 break;
1759
1760 case STAT_RXCNT:
1761
1762 pCh->channelRcount = *((cntStatPtr)pc);
1763 pc += sizeof(cntStat);
1764 break;
1765
1766 case STAT_BOXIDS:
1767 pB->channelBtypes = *((bidStatPtr)pc);
1768 pc += sizeof(bidStat);
1769 set_baud_params(pB);
1770 break;
1771
1772 case STAT_HWFAIL:
1773 i2QueueCommands (PTYPE_INLINE, pCh, 0, 1, CMD_HW_TEST);
1774 pCh->channelFail = *((failStatPtr)pc);
1775 pc += sizeof(failStat);
1776 break;
1777
1778 /* No explicit match? then
1779 * Might be an error packet...
1780 */
1781 default:
1782 switch (uc & STAT_MOD_ERROR)
1783 {
1784 case STAT_ERROR:
1785 if (uc & STAT_E_PARITY) {
1786 pCh->dataSetIn |= I2_PAR;
1787 pCh->icount.parity++;
1788 }
1789 if (uc & STAT_E_FRAMING){
1790 pCh->dataSetIn |= I2_FRA;
1791 pCh->icount.frame++;
1792 }
1793 if (uc & STAT_E_OVERRUN){
1794 pCh->dataSetIn |= I2_OVR;
1795 pCh->icount.overrun++;
1796 }
1797 break;
1798
1799 case STAT_MODEM:
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 );
1805 default:
1806 break;
1807 }
1808 } /* End of switch on status type */
1809 if (dss_change) {
1810#ifdef USE_IQ
1811 schedule_work(&pCh->tqueue_status);
1812#else
1813 do_status(pCh);
1814#endif
1815 }
1816 }
1817 else /* Or else, channel is invalid */
1818 {
1819 // Even though the channel is invalid, we must test the
1820 // status to see how much additional data it has (to be
1821 // skipped)
1822 switch (*pc++)
1823 {
1824 case STAT_FLOW:
1825 pc += 4; /* Skip the data */
1826 break;
1827
1828 default:
1829 break;
1830 }
1831 }
1832 } // End of while (there is still some status packet left)
1833 break;
1834
1835 default: // Neither packet? should be impossible
1836 ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 5, 1,
1837 PTYPE_OF(pB->i2eLeadoffWord) );
1838
1839 break;
1840 } // End of switch on type of packets
1841 } //while(board HAS_INPUT)
1842
1843 ip2trace (ITRC_NO_PORT, ITRC_SFIFO, ITRC_RETURN, 0 );
1844
1845 // Send acknowledgement to the board even if there was no data!
1846 pB->i2eOutMailWaiting |= MB_IN_STRIPPED;
1847 return;
1848}
1849
1850//******************************************************************************
1851// Function: i2Write2Fifo(pB,address,count)
1852// Parameters: Pointer to a board structure, source address, byte count
1853// Returns: bytes written
1854//
1855// Description:
1856// Writes count bytes to board io address(implied) from source
1857// Adjusts count, leaves reserve for next time around bypass cmds
1858//******************************************************************************
1859static int
1860i2Write2Fifo(i2eBordStrPtr pB, unsigned char *source, int count,int reserve)
1861{
1862 int rc = 0;
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;
1870 rc = count;
1871 }
1872 }
1873 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1874 return rc;
1875}
1876//******************************************************************************
1877// Function: i2StuffFifoBypass(pB)
1878// Parameters: Pointer to a board structure
1879// Returns: Nothing
1880//
1881// Description:
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//******************************************************************************
1886static inline void
1887i2StuffFifoBypass(i2eBordStrPtr pB)
1888{
1889 i2ChanStrPtr pCh;
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;
1896
1897 int bailout = 1000;
1898
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))))
1903 {
1904 WRITE_LOCK_IRQSAVE(&pCh->Cbuf_spinlock,flags);
1905 stripIndex = pCh->Cbuf_strip;
1906
1907 // as long as there are packets for this channel...
1908
1909 while (stripIndex != pCh->Cbuf_stuff) {
1910 pRemove = &(pCh->Cbuf[stripIndex]);
1911 packetSize = CMD_COUNT_OF(pRemove) + sizeof(i2CmdHeader);
1912 paddedSize = ROUNDUP(packetSize);
1913
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
1919 }
1920 }
1921#ifdef DEBUG_FIFO
1922WriteDBGBuf("BYPS", pRemove, paddedSize);
1923#endif /* DEBUG_FIFO */
1924 pB->debugBypassCount++;
1925
1926 pRemove += packetSize;
1927 stripIndex += packetSize;
1928 if (stripIndex >= CBUF_SIZE) {
1929 stripIndex = 0;
1930 pRemove = pCh->Cbuf;
1931 }
1932 }
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
1938
1939#ifdef IP2DEBUG_TRACE
1940 if ( !bailout ) {
1941 ip2trace (ITRC_NO_PORT, ITRC_ERROR, 1, 0 );
1942 }
1943#endif
1944}
1945
1946//******************************************************************************
1947// Function: i2StuffFifoFlow(pB)
1948// Parameters: Pointer to a board structure
1949// Returns: Nothing
1950//
1951// Description:
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//******************************************************************************
1956static inline void
1957i2StuffFifoFlow(i2eBordStrPtr pB)
1958{
1959 i2ChanStrPtr pCh;
1960 unsigned short paddedSize = ROUNDUP(sizeof(flowIn));
1961
1962 ip2trace (ITRC_NO_PORT, ITRC_SFLOW, ITRC_ENTER, 2,
1963 pB->i2eFifoRemains, paddedSize );
1964
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++;
1969
1970 // NO Chan LOCK needed ???
1971 if ( 0 == i2Write2Fifo(pB,(unsigned char *)&(pCh->infl),paddedSize,0)) {
1972 break;
1973 }
1974#ifdef DEBUG_FIFO
1975 WriteDBGBuf("FLOW",(unsigned char *) &(pCh->infl), paddedSize);
1976#endif /* DEBUG_FIFO */
1977
1978 } // Either clogged or finished all the work
1979
1980 ip2trace (ITRC_NO_PORT, ITRC_SFLOW, ITRC_RETURN, 0 );
1981}
1982
1983//******************************************************************************
1984// Function: i2StuffFifoInline(pB)
1985// Parameters: Pointer to a board structure
1986// Returns: Nothing
1987//
1988// Description:
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//******************************************************************************
1993static inline void
1994i2StuffFifoInline(i2eBordStrPtr pB)
1995{
1996 i2ChanStrPtr pCh;
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;
2004
2005 int bailout = 1000;
2006 int bailout2;
2007
2008 ip2trace (ITRC_NO_PORT, ITRC_SICMD, ITRC_ENTER, 3, pB->i2eFifoRemains,
2009 pB->i2Dbuf_strip, pB->i2Dbuf_stuff );
2010
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))) )
2015 {
2016 WRITE_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
2017 stripIndex = pCh->Obuf_strip;
2018
2019 ip2trace (CHANN, ITRC_SICMD, 3, 2, stripIndex, pCh->Obuf_stuff );
2020
2021 // as long as there are packets for this channel...
2022 bailout2 = 1000;
2023 while ( --bailout2 && stripIndex != pCh->Obuf_stuff) {
2024 pRemove = &(pCh->Obuf[stripIndex]);
2025
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);
2032 } else {
2033 flowsize = CMD_COUNT_OF(pRemove);
2034 packetSize = flowsize + sizeof(i2CmdHeader);
2035 }
2036 flowsize = CREDIT_USAGE(flowsize);
2037 paddedSize = ROUNDUP(packetSize);
2038
2039 ip2trace (CHANN, ITRC_SICMD, 4, 2, pB->i2eFifoRemains, paddedSize );
2040
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.
2045
2046 ip2trace (CHANN, ITRC_SICMD, 5, 2, pCh->outfl.room, flowsize );
2047
2048 if (pCh->outfl.room <= flowsize) {
2049 // Do Not have the credits to send this packet.
2050 i2QueueNeeds(pB, pCh, NEED_CREDIT);
2051 notClogged = 0;
2052 break; // So to do next channel
2053 }
2054 if ( (paddedSize > 0)
2055 && ( 0 == i2Write2Fifo(pB, pRemove, paddedSize, 128))) {
2056 // Do Not have room in fifo to send this packet.
2057 notClogged = 0;
2058 i2QueueNeeds(pB, pCh, NEED_INLINE);
2059 break; // Break from the channel
2060 }
2061#ifdef DEBUG_FIFO
2062WriteDBGBuf("DATA", pRemove, paddedSize);
2063#endif /* DEBUG_FIFO */
2064 pB->debugInlineCount++;
2065
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);
2072 }
2073 pRemove += packetSize;
2074 stripIndex += packetSize;
2075
2076 ip2trace (CHANN, ITRC_SICMD, 6, 2, stripIndex, pCh->Obuf_strip);
2077
2078 if (stripIndex >= OBUF_SIZE) {
2079 stripIndex = 0;
2080 pRemove = pCh->Obuf;
2081
2082 ip2trace (CHANN, ITRC_SICMD, 7, 1, stripIndex );
2083
2084 }
2085 } /* while */
2086 if ( !bailout2 ) {
2087 ip2trace (CHANN, ITRC_ERROR, 3, 0 );
2088 }
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);
2093 if ( notClogged )
2094 {
2095
2096 ip2trace (CHANN, ITRC_SICMD, 8, 0 );
2097
2098 if ( pCh->pTTY ) {
2099 ip2_owake(pCh->pTTY);
2100 }
2101 }
2102 } // Either clogged or finished all the work
2103
2104 if ( !bailout ) {
2105 ip2trace (ITRC_NO_PORT, ITRC_ERROR, 4, 0 );
2106 }
2107
2108 ip2trace (ITRC_NO_PORT, ITRC_SICMD, ITRC_RETURN, 1,pB->i2Dbuf_strip);
2109}
2110
2111//******************************************************************************
2112// Function: serviceOutgoingFifo(pB)
2113// Parameters: Pointer to a board structure
2114// Returns: Nothing
2115//
2116// Description:
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//******************************************************************************
2124static void
2125serviceOutgoingFifo(i2eBordStrPtr pB)
2126{
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
2129 // Inline).
2130 if ( ! pB->i2eWaitingForEmptyFifo )
2131 {
2132 i2StuffFifoFlow(pB);
2133 i2StuffFifoBypass(pB);
2134 i2StuffFifoInline(pB);
2135
2136 iiSendPendingMail(pB);
2137 }
2138}
2139
2140//******************************************************************************
2141// Function: i2ServiceBoard(pB)
2142// Parameters: Pointer to a board structure
2143// Returns: Nothing
2144//
2145// Description:
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.
2149//
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.
2153//
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.
2159//
2160// Based on the value in the mailbox, we may take various actions.
2161//
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//******************************************************************************
2165static inline int
2166i2ServiceBoard ( i2eBordStrPtr pB )
2167{
2168 unsigned inmail;
2169 unsigned long flags;
2170
2171
2172 /* This should be atomic because of the way we are called... */
2173 if (NO_MAIL_HERE == ( inmail = pB->i2eStartMail ) ) {
2174 inmail = iiGetMail(pB);
2175 }
2176 pB->i2eStartMail = NO_MAIL_HERE;
2177
2178 ip2trace (ITRC_NO_PORT, ITRC_INTR, 2, 1, inmail );
2179
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 ) {
2184 pB->i2eFatal = 1;
2185 goto exit_i2ServiceBoard;
2186 }
2187
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 */
2192 }
2193
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);
2200
2201 ip2trace (ITRC_NO_PORT, ITRC_INTR, 30, 1, pB->i2eFifoRemains );
2202
2203 }
2204 serviceOutgoingFifo(pB);
2205 }
2206
2207 ip2trace (ITRC_NO_PORT, ITRC_INTR, 8, 0 );
2208
2209exit_i2ServiceBoard:
2210
2211 return 0;
2212}