]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/char/ip2/i2lib.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Linux-2.6.12-rc2
[mirror_ubuntu-artful-kernel.git] / drivers / char / ip2 / i2lib.c
1 /*******************************************************************************
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 //***********************
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);
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.
83 static void iiSendPendingMail(i2eBordStrPtr);
84 static void serviceOutgoingFifo(i2eBordStrPtr);
85
86 // Functions defined in ip2.c as part of interrupt handling
87 static void do_input(void *);
88 static void do_status(void *);
89
90 //***************
91 //* Debug Data *
92 //***************
93 #ifdef DEBUG_FIFO
94
95 unsigned char DBGBuf[0x4000];
96 unsigned short I = 0;
97
98 static void
99 WriteDBGBuf(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
115 static void
116 fatality(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
144 static inline int
145 i2Validate ( 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 //******************************************************************************
162 static inline void
163 iiSendPendingMail(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 //******************************************************************************
219 static int
220 i2InitChannels ( 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 //******************************************************************************
361 static i2ChanStrPtr
362 i2DeQueueNeeds(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 //******************************************************************************
439 static void
440 i2QueueNeeds(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 //******************************************************************************
526 static int
527 i2QueueCommands(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()) {
658 current->state = TASK_INTERRUPTIBLE;
659 schedule_timeout(1); // short nap
660 } else {
661 // we cannot sched/sleep in interrrupt silly
662 return 0;
663 }
664 if (signal_pending(current)) {
665 return 0; // Wake up! Time to die!!!
666 }
667
668 ip2trace (CHANN, ITRC_QUEUE, 4, 0 );
669
670 } // end of for(;;)
671
672 // At this point we have room and the lock - stick them in.
673 channel = pCh->infl.hd.i2sChannel;
674 pInsert = &pBuf[stuffIndex]; // Pointer to start of packet
675 pDest = CMD_OF(pInsert); // Pointer to start of command
676
677 // When we start counting, the block is the size of the header
678 for (blocksize = sizeof(i2CmdHeader), count = nCommands,
679 lastended = 0, ppCs = &pCs0;
680 count;
681 count--, ppCs++)
682 {
683 pCs = *ppCs; // Points to command protocol structure
684
685 // If this is a bookmark request command, post the fact that a bookmark
686 // request is pending. NOTE THIS TRICK ONLY WORKS BECAUSE CMD_BMARK_REQ
687 // has no parameters! The more general solution would be to reference
688 // pCs->cmd[0].
689 if (pCs == CMD_BMARK_REQ) {
690 pCh->bookMarks++;
691
692 ip2trace (CHANN, ITRC_DRAIN, 30, 1, pCh->bookMarks );
693
694 }
695 cnt = pCs->length;
696
697 // If this command would put us over the maximum block size or
698 // if the last command had to be at the end of a block, we end
699 // the existing block here and start a new one.
700 if ((blocksize + cnt > maxBlock) || lastended) {
701
702 ip2trace (CHANN, ITRC_QUEUE, 5, 0 );
703
704 PTYPE_OF(pInsert) = type;
705 CHANNEL_OF(pInsert) = channel;
706 // count here does not include the header
707 CMD_COUNT_OF(pInsert) = blocksize - sizeof(i2CmdHeader);
708 stuffIndex += blocksize;
709 if(stuffIndex >= maxBuff) {
710 stuffIndex = 0;
711 pInsert = pBuf;
712 }
713 pInsert = &pBuf[stuffIndex]; // Pointer to start of next pkt
714 pDest = CMD_OF(pInsert);
715 blocksize = sizeof(i2CmdHeader);
716 }
717 // Now we know there is room for this one in the current block
718
719 blocksize += cnt; // Total bytes in this command
720 pSource = pCs->cmd; // Copy the command into the buffer
721 while (cnt--) {
722 *pDest++ = *pSource++;
723 }
724 // If this command had to end a block, then we will make sure to account
725 // for it should there be any more blocks.
726 lastended = pCs->flags & END;
727 } // end for
728 // Clean up the final block by writing header, etc
729
730 PTYPE_OF(pInsert) = type;
731 CHANNEL_OF(pInsert) = channel;
732 // count here does not include the header
733 CMD_COUNT_OF(pInsert) = blocksize - sizeof(i2CmdHeader);
734 stuffIndex += blocksize;
735 if(stuffIndex >= maxBuff) {
736 stuffIndex = 0;
737 pInsert = pBuf;
738 }
739 // Updates the index, and post the need for service. When adding these to
740 // the queue of channels, we turn off the interrupt while doing so,
741 // because at interrupt level we might want to push a channel back to the
742 // end of the queue.
743 switch(type)
744 {
745 case PTYPE_INLINE:
746 pCh->Obuf_stuff = stuffIndex; // Store buffer pointer
747 WRITE_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
748
749 pB->debugInlineQueued++;
750 // Add the channel pointer to list of channels needing service (first
751 // come...), if it's not already there.
752 i2QueueNeeds(pB, pCh, NEED_INLINE);
753 break;
754
755 case PTYPE_BYPASS:
756 pCh->Cbuf_stuff = stuffIndex; // Store buffer pointer
757 WRITE_UNLOCK_IRQRESTORE(&pCh->Cbuf_spinlock,flags);
758
759 pB->debugBypassQueued++;
760 // Add the channel pointer to list of channels needing service (first
761 // come...), if it's not already there.
762 i2QueueNeeds(pB, pCh, NEED_BYPASS);
763 break;
764 }
765
766 ip2trace (CHANN, ITRC_QUEUE, ITRC_RETURN, 1, nCommands );
767
768 return nCommands; // Good status: number of commands sent
769 }
770
771 //******************************************************************************
772 // Function: i2GetStatus(pCh,resetBits)
773 // Parameters: Pointer to a channel structure
774 // Bit map of status bits to clear
775 // Returns: Bit map of current status bits
776 //
777 // Description:
778 // Returns the state of data set signals, and whether a break has been received,
779 // (see i2lib.h for bit-mapped result). resetBits is a bit-map of any status
780 // bits to be cleared: I2_BRK, I2_PAR, I2_FRA, I2_OVR,... These are cleared
781 // AFTER the condition is passed. If pCh does not point to a valid channel,
782 // returns -1 (which would be impossible otherwise.
783 //******************************************************************************
784 static int
785 i2GetStatus(i2ChanStrPtr pCh, int resetBits)
786 {
787 unsigned short status;
788 i2eBordStrPtr pB;
789
790 ip2trace (CHANN, ITRC_STATUS, ITRC_ENTER, 2, pCh->dataSetIn, resetBits );
791
792 // Make sure the channel exists, otherwise do nothing */
793 if ( !i2Validate ( pCh ) )
794 return -1;
795
796 pB = pCh->pMyBord;
797
798 status = pCh->dataSetIn;
799
800 // Clear any specified error bits: but note that only actual error bits can
801 // be cleared, regardless of the value passed.
802 if (resetBits)
803 {
804 pCh->dataSetIn &= ~(resetBits & (I2_BRK | I2_PAR | I2_FRA | I2_OVR));
805 pCh->dataSetIn &= ~(I2_DDCD | I2_DCTS | I2_DDSR | I2_DRI);
806 }
807
808 ip2trace (CHANN, ITRC_STATUS, ITRC_RETURN, 1, pCh->dataSetIn );
809
810 return status;
811 }
812
813 //******************************************************************************
814 // Function: i2Input(pChpDest,count)
815 // Parameters: Pointer to a channel structure
816 // Pointer to data buffer
817 // Number of bytes to read
818 // Returns: Number of bytes read, or -1 for error
819 //
820 // Description:
821 // Strips data from the input buffer and writes it to pDest. If there is a
822 // collosal blunder, (invalid structure pointers or the like), returns -1.
823 // Otherwise, returns the number of bytes read.
824 //******************************************************************************
825 static int
826 i2Input(i2ChanStrPtr pCh)
827 {
828 int amountToMove;
829 unsigned short stripIndex;
830 int count;
831 unsigned long flags = 0;
832
833 ip2trace (CHANN, ITRC_INPUT, ITRC_ENTER, 0);
834
835 // Ensure channel structure seems real
836 if ( !i2Validate( pCh ) ) {
837 count = -1;
838 goto i2Input_exit;
839 }
840 WRITE_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags);
841
842 // initialize some accelerators and private copies
843 stripIndex = pCh->Ibuf_strip;
844
845 count = pCh->Ibuf_stuff - stripIndex;
846
847 // If buffer is empty or requested data count was 0, (trivial case) return
848 // without any further thought.
849 if ( count == 0 ) {
850 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
851 goto i2Input_exit;
852 }
853 // Adjust for buffer wrap
854 if ( count < 0 ) {
855 count += IBUF_SIZE;
856 }
857 // Don't give more than can be taken by the line discipline
858 amountToMove = pCh->pTTY->ldisc.receive_room( pCh->pTTY );
859 if (count > amountToMove) {
860 count = amountToMove;
861 }
862 // How much could we copy without a wrap?
863 amountToMove = IBUF_SIZE - stripIndex;
864
865 if (amountToMove > count) {
866 amountToMove = count;
867 }
868 // Move the first block
869 pCh->pTTY->ldisc.receive_buf( pCh->pTTY,
870 &(pCh->Ibuf[stripIndex]), NULL, amountToMove );
871 // If we needed to wrap, do the second data move
872 if (count > amountToMove) {
873 pCh->pTTY->ldisc.receive_buf( pCh->pTTY,
874 pCh->Ibuf, NULL, count - amountToMove );
875 }
876 // Bump and wrap the stripIndex all at once by the amount of data read. This
877 // method is good regardless of whether the data was in one or two pieces.
878 stripIndex += count;
879 if (stripIndex >= IBUF_SIZE) {
880 stripIndex -= IBUF_SIZE;
881 }
882 pCh->Ibuf_strip = stripIndex;
883
884 // Update our flow control information and possibly queue ourselves to send
885 // it, depending on how much data has been stripped since the last time a
886 // packet was sent.
887 pCh->infl.asof += count;
888
889 if ((pCh->sinceLastFlow += count) >= pCh->whenSendFlow) {
890 pCh->sinceLastFlow -= pCh->whenSendFlow;
891 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
892 i2QueueNeeds(pCh->pMyBord, pCh, NEED_FLOW);
893 } else {
894 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
895 }
896
897 i2Input_exit:
898
899 ip2trace (CHANN, ITRC_INPUT, ITRC_RETURN, 1, count);
900
901 return count;
902 }
903
904 //******************************************************************************
905 // Function: i2InputFlush(pCh)
906 // Parameters: Pointer to a channel structure
907 // Returns: Number of bytes stripped, or -1 for error
908 //
909 // Description:
910 // Strips any data from the input buffer. If there is a collosal blunder,
911 // (invalid structure pointers or the like), returns -1. Otherwise, returns the
912 // number of bytes stripped.
913 //******************************************************************************
914 static int
915 i2InputFlush(i2ChanStrPtr pCh)
916 {
917 int count;
918 unsigned long flags;
919
920 // Ensure channel structure seems real
921 if ( !i2Validate ( pCh ) )
922 return -1;
923
924 ip2trace (CHANN, ITRC_INPUT, 10, 0);
925
926 WRITE_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags);
927 count = pCh->Ibuf_stuff - pCh->Ibuf_strip;
928
929 // Adjust for buffer wrap
930 if (count < 0) {
931 count += IBUF_SIZE;
932 }
933
934 // Expedient way to zero out the buffer
935 pCh->Ibuf_strip = pCh->Ibuf_stuff;
936
937
938 // Update our flow control information and possibly queue ourselves to send
939 // it, depending on how much data has been stripped since the last time a
940 // packet was sent.
941
942 pCh->infl.asof += count;
943
944 if ( (pCh->sinceLastFlow += count) >= pCh->whenSendFlow )
945 {
946 pCh->sinceLastFlow -= pCh->whenSendFlow;
947 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
948 i2QueueNeeds(pCh->pMyBord, pCh, NEED_FLOW);
949 } else {
950 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
951 }
952
953 ip2trace (CHANN, ITRC_INPUT, 19, 1, count);
954
955 return count;
956 }
957
958 //******************************************************************************
959 // Function: i2InputAvailable(pCh)
960 // Parameters: Pointer to a channel structure
961 // Returns: Number of bytes available, or -1 for error
962 //
963 // Description:
964 // If there is a collosal blunder, (invalid structure pointers or the like),
965 // returns -1. Otherwise, returns the number of bytes stripped. Otherwise,
966 // returns the number of bytes available in the buffer.
967 //******************************************************************************
968 #if 0
969 static int
970 i2InputAvailable(i2ChanStrPtr pCh)
971 {
972 int count;
973
974 // Ensure channel structure seems real
975 if ( !i2Validate ( pCh ) ) return -1;
976
977
978 // initialize some accelerators and private copies
979 READ_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,flags);
980 count = pCh->Ibuf_stuff - pCh->Ibuf_strip;
981 READ_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,flags);
982
983 // Adjust for buffer wrap
984 if (count < 0)
985 {
986 count += IBUF_SIZE;
987 }
988
989 return count;
990 }
991 #endif
992
993 //******************************************************************************
994 // Function: i2Output(pCh, pSource, count)
995 // Parameters: Pointer to channel structure
996 // Pointer to source data
997 // Number of bytes to send
998 // Returns: Number of bytes sent, or -1 for error
999 //
1000 // Description:
1001 // Queues the data at pSource to be sent as data packets to the board. If there
1002 // is a collosal blunder, (invalid structure pointers or the like), returns -1.
1003 // Otherwise, returns the number of bytes written. What if there is not enough
1004 // room for all the data? If pCh->channelOptions & CO_NBLOCK_WRITE is set, then
1005 // we transfer as many characters as we can now, then return. If this bit is
1006 // clear (default), routine will spin along until all the data is buffered.
1007 // Should this occur, the 1-ms delay routine is called while waiting to avoid
1008 // applications that one cannot break out of.
1009 //******************************************************************************
1010 static int
1011 i2Output(i2ChanStrPtr pCh, const char *pSource, int count, int user )
1012 {
1013 i2eBordStrPtr pB;
1014 unsigned char *pInsert;
1015 int amountToMove;
1016 int countOriginal = count;
1017 unsigned short channel;
1018 unsigned short stuffIndex;
1019 unsigned long flags;
1020 int rc = 0;
1021
1022 int bailout = 10;
1023
1024 ip2trace (CHANN, ITRC_OUTPUT, ITRC_ENTER, 2, count, user );
1025
1026 // Ensure channel structure seems real
1027 if ( !i2Validate ( pCh ) )
1028 return -1;
1029
1030 // initialize some accelerators and private copies
1031 pB = pCh->pMyBord;
1032 channel = pCh->infl.hd.i2sChannel;
1033
1034 // If the board has gone fatal, return bad, and also hit the trap routine if
1035 // it exists.
1036 if (pB->i2eFatal) {
1037 if (pB->i2eFatalTrap) {
1038 (*(pB)->i2eFatalTrap)(pB);
1039 }
1040 return -1;
1041 }
1042 // Proceed as though we would do everything
1043 while ( count > 0 ) {
1044
1045 // How much room in output buffer is there?
1046 READ_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
1047 amountToMove = pCh->Obuf_strip - pCh->Obuf_stuff - 1;
1048 READ_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
1049 if (amountToMove < 0) {
1050 amountToMove += OBUF_SIZE;
1051 }
1052 // Subtract off the headers size and see how much room there is for real
1053 // data. If this is negative, we will discover later.
1054 amountToMove -= sizeof (i2DataHeader);
1055
1056 // Don't move more (now) than can go in a single packet
1057 if ( amountToMove > (int)(MAX_OBUF_BLOCK - sizeof(i2DataHeader)) ) {
1058 amountToMove = MAX_OBUF_BLOCK - sizeof(i2DataHeader);
1059 }
1060 // Don't move more than the count we were given
1061 if (amountToMove > count) {
1062 amountToMove = count;
1063 }
1064 // Now we know how much we must move: NB because the ring buffers have
1065 // an overflow area at the end, we needn't worry about wrapping in the
1066 // middle of a packet.
1067
1068 // Small WINDOW here with no LOCK but I can't call Flush with LOCK
1069 // We would be flushing (or ending flush) anyway
1070
1071 ip2trace (CHANN, ITRC_OUTPUT, 10, 1, amountToMove );
1072
1073 if ( !(pCh->flush_flags && i2RetryFlushOutput(pCh) )
1074 && amountToMove > 0 )
1075 {
1076 WRITE_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
1077 stuffIndex = pCh->Obuf_stuff;
1078
1079 // Had room to move some data: don't know whether the block size,
1080 // buffer space, or what was the limiting factor...
1081 pInsert = &(pCh->Obuf[stuffIndex]);
1082
1083 // Set up the header
1084 CHANNEL_OF(pInsert) = channel;
1085 PTYPE_OF(pInsert) = PTYPE_DATA;
1086 TAG_OF(pInsert) = 0;
1087 ID_OF(pInsert) = ID_ORDINARY_DATA;
1088 DATA_COUNT_OF(pInsert) = amountToMove;
1089
1090 // Move the data
1091 if ( user ) {
1092 rc = copy_from_user((char*)(DATA_OF(pInsert)), pSource,
1093 amountToMove );
1094 } else {
1095 memcpy( (char*)(DATA_OF(pInsert)), pSource, amountToMove );
1096 }
1097 // Adjust pointers and indices
1098 pSource += amountToMove;
1099 pCh->Obuf_char_count += amountToMove;
1100 stuffIndex += amountToMove + sizeof(i2DataHeader);
1101 count -= amountToMove;
1102
1103 if (stuffIndex >= OBUF_SIZE) {
1104 stuffIndex = 0;
1105 }
1106 pCh->Obuf_stuff = stuffIndex;
1107
1108 WRITE_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
1109
1110 ip2trace (CHANN, ITRC_OUTPUT, 13, 1, stuffIndex );
1111
1112 } else {
1113
1114 // Cannot move data
1115 // becuz we need to stuff a flush
1116 // or amount to move is <= 0
1117
1118 ip2trace(CHANN, ITRC_OUTPUT, 14, 3,
1119 amountToMove, pB->i2eFifoRemains,
1120 pB->i2eWaitingForEmptyFifo );
1121
1122 // Put this channel back on queue
1123 // this ultimatly gets more data or wakes write output
1124 i2QueueNeeds(pB, pCh, NEED_INLINE);
1125
1126 if ( pB->i2eWaitingForEmptyFifo ) {
1127
1128 ip2trace (CHANN, ITRC_OUTPUT, 16, 0 );
1129
1130 // or schedule
1131 if (!in_interrupt()) {
1132
1133 ip2trace (CHANN, ITRC_OUTPUT, 61, 0 );
1134
1135 current->state = TASK_INTERRUPTIBLE;
1136 schedule_timeout(2);
1137 if (signal_pending(current)) {
1138 break;
1139 }
1140 continue;
1141 } else {
1142
1143 ip2trace (CHANN, ITRC_OUTPUT, 62, 0 );
1144
1145 // let interrupt in = WAS restore_flags()
1146 // We hold no lock nor is irq off anymore???
1147
1148 break;
1149 }
1150 break; // from while(count)
1151 }
1152 else if ( pB->i2eFifoRemains < 32 && !pB->i2eTxMailEmpty ( pB ) )
1153 {
1154 ip2trace (CHANN, ITRC_OUTPUT, 19, 2,
1155 pB->i2eFifoRemains,
1156 pB->i2eTxMailEmpty );
1157
1158 break; // from while(count)
1159 } else if ( pCh->channelNeeds & NEED_CREDIT ) {
1160
1161 ip2trace (CHANN, ITRC_OUTPUT, 22, 0 );
1162
1163 break; // from while(count)
1164 } else if ( --bailout) {
1165
1166 // Try to throw more things (maybe not us) in the fifo if we're
1167 // not already waiting for it.
1168
1169 ip2trace (CHANN, ITRC_OUTPUT, 20, 0 );
1170
1171 serviceOutgoingFifo(pB);
1172 //break; CONTINUE;
1173 } else {
1174 ip2trace (CHANN, ITRC_OUTPUT, 21, 3,
1175 pB->i2eFifoRemains,
1176 pB->i2eOutMailWaiting,
1177 pB->i2eWaitingForEmptyFifo );
1178
1179 break; // from while(count)
1180 }
1181 }
1182 } // End of while(count)
1183
1184 i2QueueNeeds(pB, pCh, NEED_INLINE);
1185
1186 // We drop through either when the count expires, or when there is some
1187 // count left, but there was a non-blocking write.
1188 if (countOriginal > count) {
1189
1190 ip2trace (CHANN, ITRC_OUTPUT, 17, 2, countOriginal, count );
1191
1192 serviceOutgoingFifo( pB );
1193 }
1194
1195 ip2trace (CHANN, ITRC_OUTPUT, ITRC_RETURN, 2, countOriginal, count );
1196
1197 return countOriginal - count;
1198 }
1199
1200 //******************************************************************************
1201 // Function: i2FlushOutput(pCh)
1202 // Parameters: Pointer to a channel structure
1203 // Returns: Nothing
1204 //
1205 // Description:
1206 // Sends bypass command to start flushing (waiting possibly forever until there
1207 // is room), then sends inline command to stop flushing output, (again waiting
1208 // possibly forever).
1209 //******************************************************************************
1210 static inline void
1211 i2FlushOutput(i2ChanStrPtr pCh)
1212 {
1213
1214 ip2trace (CHANN, ITRC_FLUSH, 1, 1, pCh->flush_flags );
1215
1216 if (pCh->flush_flags)
1217 return;
1218
1219 if ( 1 != i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_STARTFL) ) {
1220 pCh->flush_flags = STARTFL_FLAG; // Failed - flag for later
1221
1222 ip2trace (CHANN, ITRC_FLUSH, 2, 0 );
1223
1224 } else if ( 1 != i2QueueCommands(PTYPE_INLINE, pCh, 0, 1, CMD_STOPFL) ) {
1225 pCh->flush_flags = STOPFL_FLAG; // Failed - flag for later
1226
1227 ip2trace (CHANN, ITRC_FLUSH, 3, 0 );
1228 }
1229 }
1230
1231 static int
1232 i2RetryFlushOutput(i2ChanStrPtr pCh)
1233 {
1234 int old_flags = pCh->flush_flags;
1235
1236 ip2trace (CHANN, ITRC_FLUSH, 14, 1, old_flags );
1237
1238 pCh->flush_flags = 0; // Clear flag so we can avoid recursion
1239 // and queue the commands
1240
1241 if ( old_flags & STARTFL_FLAG ) {
1242 if ( 1 == i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_STARTFL) ) {
1243 old_flags = STOPFL_FLAG; //Success - send stop flush
1244 } else {
1245 old_flags = STARTFL_FLAG; //Failure - Flag for retry later
1246 }
1247
1248 ip2trace (CHANN, ITRC_FLUSH, 15, 1, old_flags );
1249
1250 }
1251 if ( old_flags & STOPFL_FLAG ) {
1252 if (1 == i2QueueCommands(PTYPE_INLINE, pCh, 0, 1, CMD_STOPFL)) {
1253 old_flags = 0; // Success - clear flags
1254 }
1255
1256 ip2trace (CHANN, ITRC_FLUSH, 16, 1, old_flags );
1257 }
1258 pCh->flush_flags = old_flags;
1259
1260 ip2trace (CHANN, ITRC_FLUSH, 17, 1, old_flags );
1261
1262 return old_flags;
1263 }
1264
1265 //******************************************************************************
1266 // Function: i2DrainOutput(pCh,timeout)
1267 // Parameters: Pointer to a channel structure
1268 // Maximum period to wait
1269 // Returns: ?
1270 //
1271 // Description:
1272 // Uses the bookmark request command to ask the board to send a bookmark back as
1273 // soon as all the data is completely sent.
1274 //******************************************************************************
1275 static void
1276 i2DrainWakeup(i2ChanStrPtr pCh)
1277 {
1278 ip2trace (CHANN, ITRC_DRAIN, 10, 1, pCh->BookmarkTimer.expires );
1279
1280 pCh->BookmarkTimer.expires = 0;
1281 wake_up_interruptible( &pCh->pBookmarkWait );
1282 }
1283
1284 static void
1285 i2DrainOutput(i2ChanStrPtr pCh, int timeout)
1286 {
1287 wait_queue_t wait;
1288 i2eBordStrPtr pB;
1289
1290 ip2trace (CHANN, ITRC_DRAIN, ITRC_ENTER, 1, pCh->BookmarkTimer.expires);
1291
1292 pB = pCh->pMyBord;
1293 // If the board has gone fatal, return bad,
1294 // and also hit the trap routine if it exists.
1295 if (pB->i2eFatal) {
1296 if (pB->i2eFatalTrap) {
1297 (*(pB)->i2eFatalTrap)(pB);
1298 }
1299 return;
1300 }
1301 if ((timeout > 0) && (pCh->BookmarkTimer.expires == 0 )) {
1302 // One per customer (channel)
1303 init_timer( &(pCh->BookmarkTimer) );
1304 pCh->BookmarkTimer.expires = jiffies + timeout;
1305 pCh->BookmarkTimer.function = (void*)(unsigned long)i2DrainWakeup;
1306 pCh->BookmarkTimer.data = (unsigned long)pCh;
1307
1308 ip2trace (CHANN, ITRC_DRAIN, 1, 1, pCh->BookmarkTimer.expires );
1309
1310 add_timer( &(pCh->BookmarkTimer) );
1311 }
1312
1313 i2QueueCommands( PTYPE_INLINE, pCh, -1, 1, CMD_BMARK_REQ );
1314
1315 init_waitqueue_entry(&wait, current);
1316 add_wait_queue(&(pCh->pBookmarkWait), &wait);
1317 set_current_state( TASK_INTERRUPTIBLE );
1318
1319 serviceOutgoingFifo( pB );
1320
1321 schedule(); // Now we take our interruptible sleep on
1322
1323 // Clean up the queue
1324 set_current_state( TASK_RUNNING );
1325 remove_wait_queue(&(pCh->pBookmarkWait), &wait);
1326
1327 // if expires == 0 then timer poped, then do not need to del_timer
1328 if ((timeout > 0) && pCh->BookmarkTimer.expires &&
1329 time_before(jiffies, pCh->BookmarkTimer.expires)) {
1330 del_timer( &(pCh->BookmarkTimer) );
1331 pCh->BookmarkTimer.expires = 0;
1332
1333 ip2trace (CHANN, ITRC_DRAIN, 3, 1, pCh->BookmarkTimer.expires );
1334
1335 }
1336 ip2trace (CHANN, ITRC_DRAIN, ITRC_RETURN, 1, pCh->BookmarkTimer.expires );
1337 return;
1338 }
1339
1340 //******************************************************************************
1341 // Function: i2OutputFree(pCh)
1342 // Parameters: Pointer to a channel structure
1343 // Returns: Space in output buffer
1344 //
1345 // Description:
1346 // Returns -1 if very gross error. Otherwise returns the amount of bytes still
1347 // free in the output buffer.
1348 //******************************************************************************
1349 static int
1350 i2OutputFree(i2ChanStrPtr pCh)
1351 {
1352 int amountToMove;
1353 unsigned long flags;
1354
1355 // Ensure channel structure seems real
1356 if ( !i2Validate ( pCh ) ) {
1357 return -1;
1358 }
1359 READ_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
1360 amountToMove = pCh->Obuf_strip - pCh->Obuf_stuff - 1;
1361 READ_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
1362
1363 if (amountToMove < 0) {
1364 amountToMove += OBUF_SIZE;
1365 }
1366 // If this is negative, we will discover later
1367 amountToMove -= sizeof(i2DataHeader);
1368
1369 return (amountToMove < 0) ? 0 : amountToMove;
1370 }
1371 static void
1372
1373 ip2_owake( PTTY tp)
1374 {
1375 i2ChanStrPtr pCh;
1376
1377 if (tp == NULL) return;
1378
1379 pCh = tp->driver_data;
1380
1381 ip2trace (CHANN, ITRC_SICMD, 10, 2, tp->flags,
1382 (1 << TTY_DO_WRITE_WAKEUP) );
1383
1384 wake_up_interruptible ( &tp->write_wait );
1385 if ( ( tp->flags & (1 << TTY_DO_WRITE_WAKEUP) )
1386 && tp->ldisc.write_wakeup )
1387 {
1388 (tp->ldisc.write_wakeup) ( tp );
1389
1390 ip2trace (CHANN, ITRC_SICMD, 11, 0 );
1391
1392 }
1393 }
1394
1395 static inline void
1396 set_baud_params(i2eBordStrPtr pB)
1397 {
1398 int i,j;
1399 i2ChanStrPtr *pCh;
1400
1401 pCh = (i2ChanStrPtr *) pB->i2eChannelPtr;
1402
1403 for (i = 0; i < ABS_MAX_BOXES; i++) {
1404 if (pB->channelBtypes.bid_value[i]) {
1405 if (BID_HAS_654(pB->channelBtypes.bid_value[i])) {
1406 for (j = 0; j < ABS_BIGGEST_BOX; j++) {
1407 if (pCh[i*16+j] == NULL)
1408 break;
1409 (pCh[i*16+j])->BaudBase = 921600; // MAX for ST654
1410 (pCh[i*16+j])->BaudDivisor = 96;
1411 }
1412 } else { // has cirrus cd1400
1413 for (j = 0; j < ABS_BIGGEST_BOX; j++) {
1414 if (pCh[i*16+j] == NULL)
1415 break;
1416 (pCh[i*16+j])->BaudBase = 115200; // MAX for CD1400
1417 (pCh[i*16+j])->BaudDivisor = 12;
1418 }
1419 }
1420 }
1421 }
1422 }
1423
1424 //******************************************************************************
1425 // Function: i2StripFifo(pB)
1426 // Parameters: Pointer to a board structure
1427 // Returns: ?
1428 //
1429 // Description:
1430 // Strips all the available data from the incoming FIFO, identifies the type of
1431 // packet, and either buffers the data or does what needs to be done.
1432 //
1433 // Note there is no overflow checking here: if the board sends more data than it
1434 // ought to, we will not detect it here, but blindly overflow...
1435 //******************************************************************************
1436
1437 // A buffer for reading in blocks for unknown channels
1438 static unsigned char junkBuffer[IBUF_SIZE];
1439
1440 // A buffer to read in a status packet. Because of the size of the count field
1441 // for these things, the maximum packet size must be less than MAX_CMD_PACK_SIZE
1442 static unsigned char cmdBuffer[MAX_CMD_PACK_SIZE + 4];
1443
1444 // This table changes the bit order from MSR order given by STAT_MODEM packet to
1445 // status bits used in our library.
1446 static char xlatDss[16] = {
1447 0 | 0 | 0 | 0 ,
1448 0 | 0 | 0 | I2_CTS ,
1449 0 | 0 | I2_DSR | 0 ,
1450 0 | 0 | I2_DSR | I2_CTS ,
1451 0 | I2_RI | 0 | 0 ,
1452 0 | I2_RI | 0 | I2_CTS ,
1453 0 | I2_RI | I2_DSR | 0 ,
1454 0 | I2_RI | I2_DSR | I2_CTS ,
1455 I2_DCD | 0 | 0 | 0 ,
1456 I2_DCD | 0 | 0 | I2_CTS ,
1457 I2_DCD | 0 | I2_DSR | 0 ,
1458 I2_DCD | 0 | I2_DSR | I2_CTS ,
1459 I2_DCD | I2_RI | 0 | 0 ,
1460 I2_DCD | I2_RI | 0 | I2_CTS ,
1461 I2_DCD | I2_RI | I2_DSR | 0 ,
1462 I2_DCD | I2_RI | I2_DSR | I2_CTS };
1463
1464 static inline void
1465 i2StripFifo(i2eBordStrPtr pB)
1466 {
1467 i2ChanStrPtr pCh;
1468 int channel;
1469 int count;
1470 unsigned short stuffIndex;
1471 int amountToRead;
1472 unsigned char *pc, *pcLimit;
1473 unsigned char uc;
1474 unsigned char dss_change;
1475 unsigned long bflags,cflags;
1476
1477 // ip2trace (ITRC_NO_PORT, ITRC_SFIFO, ITRC_ENTER, 0 );
1478
1479 while (HAS_INPUT(pB)) {
1480 // ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 2, 0 );
1481
1482 // Process packet from fifo a one atomic unit
1483 WRITE_LOCK_IRQSAVE(&pB->read_fifo_spinlock,bflags);
1484
1485 // The first word (or two bytes) will have channel number and type of
1486 // packet, possibly other information
1487 pB->i2eLeadoffWord[0] = iiReadWord(pB);
1488
1489 switch(PTYPE_OF(pB->i2eLeadoffWord))
1490 {
1491 case PTYPE_DATA:
1492 pB->got_input = 1;
1493
1494 // ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 3, 0 );
1495
1496 channel = CHANNEL_OF(pB->i2eLeadoffWord); /* Store channel */
1497 count = iiReadWord(pB); /* Count is in the next word */
1498
1499 // NEW: Check the count for sanity! Should the hardware fail, our death
1500 // is more pleasant. While an oversize channel is acceptable (just more
1501 // than the driver supports), an over-length count clearly means we are
1502 // sick!
1503 if ( ((unsigned int)count) > IBUF_SIZE ) {
1504 pB->i2eFatal = 2;
1505 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock,bflags);
1506 return; /* Bail out ASAP */
1507 }
1508 // Channel is illegally big ?
1509 if ((channel >= pB->i2eChannelCnt) ||
1510 (NULL==(pCh = ((i2ChanStrPtr*)pB->i2eChannelPtr)[channel])))
1511 {
1512 iiReadBuf(pB, junkBuffer, count);
1513 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock,bflags);
1514 break; /* From switch: ready for next packet */
1515 }
1516
1517 // Channel should be valid, then
1518
1519 // If this is a hot-key, merely post its receipt for now. These are
1520 // always supposed to be 1-byte packets, so we won't even check the
1521 // count. Also we will post an acknowledgement to the board so that
1522 // more data can be forthcoming. Note that we are not trying to use
1523 // these sequences in this driver, merely to robustly ignore them.
1524 if(ID_OF(pB->i2eLeadoffWord) == ID_HOT_KEY)
1525 {
1526 pCh->hotKeyIn = iiReadWord(pB) & 0xff;
1527 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock,bflags);
1528 i2QueueCommands(PTYPE_BYPASS, pCh, 0, 1, CMD_HOTACK);
1529 break; /* From the switch: ready for next packet */
1530 }
1531
1532 // Normal data! We crudely assume there is room for the data in our
1533 // buffer because the board wouldn't have exceeded his credit limit.
1534 WRITE_LOCK_IRQSAVE(&pCh->Ibuf_spinlock,cflags);
1535 // We have 2 locks now
1536 stuffIndex = pCh->Ibuf_stuff;
1537 amountToRead = IBUF_SIZE - stuffIndex;
1538 if (amountToRead > count)
1539 amountToRead = count;
1540
1541 // stuffIndex would have been already adjusted so there would
1542 // always be room for at least one, and count is always at least
1543 // one.
1544
1545 iiReadBuf(pB, &(pCh->Ibuf[stuffIndex]), amountToRead);
1546 pCh->icount.rx += amountToRead;
1547
1548 // Update the stuffIndex by the amount of data moved. Note we could
1549 // never ask for more data than would just fit. However, we might
1550 // have read in one more byte than we wanted because the read
1551 // rounds up to even bytes. If this byte is on the end of the
1552 // packet, and is padding, we ignore it. If the byte is part of
1553 // the actual data, we need to move it.
1554
1555 stuffIndex += amountToRead;
1556
1557 if (stuffIndex >= IBUF_SIZE) {
1558 if ((amountToRead & 1) && (count > amountToRead)) {
1559 pCh->Ibuf[0] = pCh->Ibuf[IBUF_SIZE];
1560 amountToRead++;
1561 stuffIndex = 1;
1562 } else {
1563 stuffIndex = 0;
1564 }
1565 }
1566
1567 // If there is anything left over, read it as well
1568 if (count > amountToRead) {
1569 amountToRead = count - amountToRead;
1570 iiReadBuf(pB, &(pCh->Ibuf[stuffIndex]), amountToRead);
1571 pCh->icount.rx += amountToRead;
1572 stuffIndex += amountToRead;
1573 }
1574
1575 // Update stuff index
1576 pCh->Ibuf_stuff = stuffIndex;
1577 WRITE_UNLOCK_IRQRESTORE(&pCh->Ibuf_spinlock,cflags);
1578 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock,bflags);
1579
1580 #ifdef USE_IQ
1581 schedule_work(&pCh->tqueue_input);
1582 #else
1583 do_input(pCh);
1584 #endif
1585
1586 // Note we do not need to maintain any flow-control credits at this
1587 // time: if we were to increment .asof and decrement .room, there
1588 // would be no net effect. Instead, when we strip data, we will
1589 // increment .asof and leave .room unchanged.
1590
1591 break; // From switch: ready for next packet
1592
1593 case PTYPE_STATUS:
1594 ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 4, 0 );
1595
1596 count = CMD_COUNT_OF(pB->i2eLeadoffWord);
1597
1598 iiReadBuf(pB, cmdBuffer, count);
1599 // We can release early with buffer grab
1600 WRITE_UNLOCK_IRQRESTORE(&pB->read_fifo_spinlock,bflags);
1601
1602 pc = cmdBuffer;
1603 pcLimit = &(cmdBuffer[count]);
1604
1605 while (pc < pcLimit) {
1606 channel = *pc++;
1607
1608 ip2trace (channel, ITRC_SFIFO, 7, 2, channel, *pc );
1609
1610 /* check for valid channel */
1611 if (channel < pB->i2eChannelCnt
1612 &&
1613 (pCh = (((i2ChanStrPtr*)pB->i2eChannelPtr)[channel])) != NULL
1614 )
1615 {
1616 dss_change = 0;
1617
1618 switch (uc = *pc++)
1619 {
1620 /* Breaks and modem signals are easy: just update status */
1621 case STAT_CTS_UP:
1622 if ( !(pCh->dataSetIn & I2_CTS) )
1623 {
1624 pCh->dataSetIn |= I2_DCTS;
1625 pCh->icount.cts++;
1626 dss_change = 1;
1627 }
1628 pCh->dataSetIn |= I2_CTS;
1629 break;
1630
1631 case STAT_CTS_DN:
1632 if ( pCh->dataSetIn & I2_CTS )
1633 {
1634 pCh->dataSetIn |= I2_DCTS;
1635 pCh->icount.cts++;
1636 dss_change = 1;
1637 }
1638 pCh->dataSetIn &= ~I2_CTS;
1639 break;
1640
1641 case STAT_DCD_UP:
1642 ip2trace (channel, ITRC_MODEM, 1, 1, pCh->dataSetIn );
1643
1644 if ( !(pCh->dataSetIn & I2_DCD) )
1645 {
1646 ip2trace (CHANN, ITRC_MODEM, 2, 0 );
1647 pCh->dataSetIn |= I2_DDCD;
1648 pCh->icount.dcd++;
1649 dss_change = 1;
1650 }
1651 pCh->dataSetIn |= I2_DCD;
1652
1653 ip2trace (channel, ITRC_MODEM, 3, 1, pCh->dataSetIn );
1654 break;
1655
1656 case STAT_DCD_DN:
1657 ip2trace (channel, ITRC_MODEM, 4, 1, pCh->dataSetIn );
1658 if ( pCh->dataSetIn & I2_DCD )
1659 {
1660 ip2trace (channel, ITRC_MODEM, 5, 0 );
1661 pCh->dataSetIn |= I2_DDCD;
1662 pCh->icount.dcd++;
1663 dss_change = 1;
1664 }
1665 pCh->dataSetIn &= ~I2_DCD;
1666
1667 ip2trace (channel, ITRC_MODEM, 6, 1, pCh->dataSetIn );
1668 break;
1669
1670 case STAT_DSR_UP:
1671 if ( !(pCh->dataSetIn & I2_DSR) )
1672 {
1673 pCh->dataSetIn |= I2_DDSR;
1674 pCh->icount.dsr++;
1675 dss_change = 1;
1676 }
1677 pCh->dataSetIn |= I2_DSR;
1678 break;
1679
1680 case STAT_DSR_DN:
1681 if ( pCh->dataSetIn & I2_DSR )
1682 {
1683 pCh->dataSetIn |= I2_DDSR;
1684 pCh->icount.dsr++;
1685 dss_change = 1;
1686 }
1687 pCh->dataSetIn &= ~I2_DSR;
1688 break;
1689
1690 case STAT_RI_UP:
1691 if ( !(pCh->dataSetIn & I2_RI) )
1692 {
1693 pCh->dataSetIn |= I2_DRI;
1694 pCh->icount.rng++;
1695 dss_change = 1;
1696 }
1697 pCh->dataSetIn |= I2_RI ;
1698 break;
1699
1700 case STAT_RI_DN:
1701 // to be compat with serial.c
1702 //if ( pCh->dataSetIn & I2_RI )
1703 //{
1704 // pCh->dataSetIn |= I2_DRI;
1705 // pCh->icount.rng++;
1706 // dss_change = 1;
1707 //}
1708 pCh->dataSetIn &= ~I2_RI ;
1709 break;
1710
1711 case STAT_BRK_DET:
1712 pCh->dataSetIn |= I2_BRK;
1713 pCh->icount.brk++;
1714 dss_change = 1;
1715 break;
1716
1717 // Bookmarks? one less request we're waiting for
1718 case STAT_BMARK:
1719 pCh->bookMarks--;
1720 if (pCh->bookMarks <= 0 ) {
1721 pCh->bookMarks = 0;
1722 wake_up_interruptible( &pCh->pBookmarkWait );
1723
1724 ip2trace (channel, ITRC_DRAIN, 20, 1, pCh->BookmarkTimer.expires );
1725 }
1726 break;
1727
1728 // Flow control packets? Update the new credits, and if
1729 // someone was waiting for output, queue him up again.
1730 case STAT_FLOW:
1731 pCh->outfl.room =
1732 ((flowStatPtr)pc)->room -
1733 (pCh->outfl.asof - ((flowStatPtr)pc)->asof);
1734
1735 ip2trace (channel, ITRC_STFLW, 1, 1, pCh->outfl.room );
1736
1737 if (pCh->channelNeeds & NEED_CREDIT)
1738 {
1739 ip2trace (channel, ITRC_STFLW, 2, 1, pCh->channelNeeds);
1740
1741 pCh->channelNeeds &= ~NEED_CREDIT;
1742 i2QueueNeeds(pB, pCh, NEED_INLINE);
1743 if ( pCh->pTTY )
1744 ip2_owake(pCh->pTTY);
1745 }
1746
1747 ip2trace (channel, ITRC_STFLW, 3, 1, pCh->channelNeeds);
1748
1749 pc += sizeof(flowStat);
1750 break;
1751
1752 /* Special packets: */
1753 /* Just copy the information into the channel structure */
1754
1755 case STAT_STATUS:
1756
1757 pCh->channelStatus = *((debugStatPtr)pc);
1758 pc += sizeof(debugStat);
1759 break;
1760
1761 case STAT_TXCNT:
1762
1763 pCh->channelTcount = *((cntStatPtr)pc);
1764 pc += sizeof(cntStat);
1765 break;
1766
1767 case STAT_RXCNT:
1768
1769 pCh->channelRcount = *((cntStatPtr)pc);
1770 pc += sizeof(cntStat);
1771 break;
1772
1773 case STAT_BOXIDS:
1774 pB->channelBtypes = *((bidStatPtr)pc);
1775 pc += sizeof(bidStat);
1776 set_baud_params(pB);
1777 break;
1778
1779 case STAT_HWFAIL:
1780 i2QueueCommands (PTYPE_INLINE, pCh, 0, 1, CMD_HW_TEST);
1781 pCh->channelFail = *((failStatPtr)pc);
1782 pc += sizeof(failStat);
1783 break;
1784
1785 /* No explicit match? then
1786 * Might be an error packet...
1787 */
1788 default:
1789 switch (uc & STAT_MOD_ERROR)
1790 {
1791 case STAT_ERROR:
1792 if (uc & STAT_E_PARITY) {
1793 pCh->dataSetIn |= I2_PAR;
1794 pCh->icount.parity++;
1795 }
1796 if (uc & STAT_E_FRAMING){
1797 pCh->dataSetIn |= I2_FRA;
1798 pCh->icount.frame++;
1799 }
1800 if (uc & STAT_E_OVERRUN){
1801 pCh->dataSetIn |= I2_OVR;
1802 pCh->icount.overrun++;
1803 }
1804 break;
1805
1806 case STAT_MODEM:
1807 // the answer to DSS_NOW request (not change)
1808 pCh->dataSetIn = (pCh->dataSetIn
1809 & ~(I2_RI | I2_CTS | I2_DCD | I2_DSR) )
1810 | xlatDss[uc & 0xf];
1811 wake_up_interruptible ( &pCh->dss_now_wait );
1812 default:
1813 break;
1814 }
1815 } /* End of switch on status type */
1816 if (dss_change) {
1817 #ifdef USE_IQ
1818 schedule_work(&pCh->tqueue_status);
1819 #else
1820 do_status(pCh);
1821 #endif
1822 }
1823 }
1824 else /* Or else, channel is invalid */
1825 {
1826 // Even though the channel is invalid, we must test the
1827 // status to see how much additional data it has (to be
1828 // skipped)
1829 switch (*pc++)
1830 {
1831 case STAT_FLOW:
1832 pc += 4; /* Skip the data */
1833 break;
1834
1835 default:
1836 break;
1837 }
1838 }
1839 } // End of while (there is still some status packet left)
1840 break;
1841
1842 default: // Neither packet? should be impossible
1843 ip2trace (ITRC_NO_PORT, ITRC_SFIFO, 5, 1,
1844 PTYPE_OF(pB->i2eLeadoffWord) );
1845
1846 break;
1847 } // End of switch on type of packets
1848 } //while(board HAS_INPUT)
1849
1850 ip2trace (ITRC_NO_PORT, ITRC_SFIFO, ITRC_RETURN, 0 );
1851
1852 // Send acknowledgement to the board even if there was no data!
1853 pB->i2eOutMailWaiting |= MB_IN_STRIPPED;
1854 return;
1855 }
1856
1857 //******************************************************************************
1858 // Function: i2Write2Fifo(pB,address,count)
1859 // Parameters: Pointer to a board structure, source address, byte count
1860 // Returns: bytes written
1861 //
1862 // Description:
1863 // Writes count bytes to board io address(implied) from source
1864 // Adjusts count, leaves reserve for next time around bypass cmds
1865 //******************************************************************************
1866 static int
1867 i2Write2Fifo(i2eBordStrPtr pB, unsigned char *source, int count,int reserve)
1868 {
1869 int rc = 0;
1870 unsigned long flags;
1871 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
1872 if (!pB->i2eWaitingForEmptyFifo) {
1873 if (pB->i2eFifoRemains > (count+reserve)) {
1874 pB->i2eFifoRemains -= count;
1875 iiWriteBuf(pB, source, count);
1876 pB->i2eOutMailWaiting |= MB_OUT_STUFFED;
1877 rc = count;
1878 }
1879 }
1880 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
1881 return rc;
1882 }
1883 //******************************************************************************
1884 // Function: i2StuffFifoBypass(pB)
1885 // Parameters: Pointer to a board structure
1886 // Returns: Nothing
1887 //
1888 // Description:
1889 // Stuffs as many bypass commands into the fifo as possible. This is simpler
1890 // than stuffing data or inline commands to fifo, since we do not have
1891 // flow-control to deal with.
1892 //******************************************************************************
1893 static inline void
1894 i2StuffFifoBypass(i2eBordStrPtr pB)
1895 {
1896 i2ChanStrPtr pCh;
1897 unsigned char *pRemove;
1898 unsigned short stripIndex;
1899 unsigned short packetSize;
1900 unsigned short paddedSize;
1901 unsigned short notClogged = 1;
1902 unsigned long flags;
1903
1904 int bailout = 1000;
1905
1906 // Continue processing so long as there are entries, or there is room in the
1907 // fifo. Each entry represents a channel with something to do.
1908 while ( --bailout && notClogged &&
1909 (NULL != (pCh = i2DeQueueNeeds(pB,NEED_BYPASS))))
1910 {
1911 WRITE_LOCK_IRQSAVE(&pCh->Cbuf_spinlock,flags);
1912 stripIndex = pCh->Cbuf_strip;
1913
1914 // as long as there are packets for this channel...
1915
1916 while (stripIndex != pCh->Cbuf_stuff) {
1917 pRemove = &(pCh->Cbuf[stripIndex]);
1918 packetSize = CMD_COUNT_OF(pRemove) + sizeof(i2CmdHeader);
1919 paddedSize = ROUNDUP(packetSize);
1920
1921 if (paddedSize > 0) {
1922 if ( 0 == i2Write2Fifo(pB, pRemove, paddedSize,0)) {
1923 notClogged = 0; /* fifo full */
1924 i2QueueNeeds(pB, pCh, NEED_BYPASS); // Put back on queue
1925 break; // Break from the channel
1926 }
1927 }
1928 #ifdef DEBUG_FIFO
1929 WriteDBGBuf("BYPS", pRemove, paddedSize);
1930 #endif /* DEBUG_FIFO */
1931 pB->debugBypassCount++;
1932
1933 pRemove += packetSize;
1934 stripIndex += packetSize;
1935 if (stripIndex >= CBUF_SIZE) {
1936 stripIndex = 0;
1937 pRemove = pCh->Cbuf;
1938 }
1939 }
1940 // Done with this channel. Move to next, removing this one from
1941 // the queue of channels if we cleaned it out (i.e., didn't get clogged.
1942 pCh->Cbuf_strip = stripIndex;
1943 WRITE_UNLOCK_IRQRESTORE(&pCh->Cbuf_spinlock,flags);
1944 } // Either clogged or finished all the work
1945
1946 #ifdef IP2DEBUG_TRACE
1947 if ( !bailout ) {
1948 ip2trace (ITRC_NO_PORT, ITRC_ERROR, 1, 0 );
1949 }
1950 #endif
1951 }
1952
1953 //******************************************************************************
1954 // Function: i2StuffFifoFlow(pB)
1955 // Parameters: Pointer to a board structure
1956 // Returns: Nothing
1957 //
1958 // Description:
1959 // Stuffs as many flow control packets into the fifo as possible. This is easier
1960 // even than doing normal bypass commands, because there is always at most one
1961 // packet, already assembled, for each channel.
1962 //******************************************************************************
1963 static inline void
1964 i2StuffFifoFlow(i2eBordStrPtr pB)
1965 {
1966 i2ChanStrPtr pCh;
1967 unsigned short paddedSize = ROUNDUP(sizeof(flowIn));
1968
1969 ip2trace (ITRC_NO_PORT, ITRC_SFLOW, ITRC_ENTER, 2,
1970 pB->i2eFifoRemains, paddedSize );
1971
1972 // Continue processing so long as there are entries, or there is room in the
1973 // fifo. Each entry represents a channel with something to do.
1974 while ( (NULL != (pCh = i2DeQueueNeeds(pB,NEED_FLOW)))) {
1975 pB->debugFlowCount++;
1976
1977 // NO Chan LOCK needed ???
1978 if ( 0 == i2Write2Fifo(pB,(unsigned char *)&(pCh->infl),paddedSize,0)) {
1979 break;
1980 }
1981 #ifdef DEBUG_FIFO
1982 WriteDBGBuf("FLOW",(unsigned char *) &(pCh->infl), paddedSize);
1983 #endif /* DEBUG_FIFO */
1984
1985 } // Either clogged or finished all the work
1986
1987 ip2trace (ITRC_NO_PORT, ITRC_SFLOW, ITRC_RETURN, 0 );
1988 }
1989
1990 //******************************************************************************
1991 // Function: i2StuffFifoInline(pB)
1992 // Parameters: Pointer to a board structure
1993 // Returns: Nothing
1994 //
1995 // Description:
1996 // Stuffs as much data and inline commands into the fifo as possible. This is
1997 // the most complex fifo-stuffing operation, since there if now the channel
1998 // flow-control issue to deal with.
1999 //******************************************************************************
2000 static inline void
2001 i2StuffFifoInline(i2eBordStrPtr pB)
2002 {
2003 i2ChanStrPtr pCh;
2004 unsigned char *pRemove;
2005 unsigned short stripIndex;
2006 unsigned short packetSize;
2007 unsigned short paddedSize;
2008 unsigned short notClogged = 1;
2009 unsigned short flowsize;
2010 unsigned long flags;
2011
2012 int bailout = 1000;
2013 int bailout2;
2014
2015 ip2trace (ITRC_NO_PORT, ITRC_SICMD, ITRC_ENTER, 3, pB->i2eFifoRemains,
2016 pB->i2Dbuf_strip, pB->i2Dbuf_stuff );
2017
2018 // Continue processing so long as there are entries, or there is room in the
2019 // fifo. Each entry represents a channel with something to do.
2020 while ( --bailout && notClogged &&
2021 (NULL != (pCh = i2DeQueueNeeds(pB,NEED_INLINE))) )
2022 {
2023 WRITE_LOCK_IRQSAVE(&pCh->Obuf_spinlock,flags);
2024 stripIndex = pCh->Obuf_strip;
2025
2026 ip2trace (CHANN, ITRC_SICMD, 3, 2, stripIndex, pCh->Obuf_stuff );
2027
2028 // as long as there are packets for this channel...
2029 bailout2 = 1000;
2030 while ( --bailout2 && stripIndex != pCh->Obuf_stuff) {
2031 pRemove = &(pCh->Obuf[stripIndex]);
2032
2033 // Must determine whether this be a data or command packet to
2034 // calculate correctly the header size and the amount of
2035 // flow-control credit this type of packet will use.
2036 if (PTYPE_OF(pRemove) == PTYPE_DATA) {
2037 flowsize = DATA_COUNT_OF(pRemove);
2038 packetSize = flowsize + sizeof(i2DataHeader);
2039 } else {
2040 flowsize = CMD_COUNT_OF(pRemove);
2041 packetSize = flowsize + sizeof(i2CmdHeader);
2042 }
2043 flowsize = CREDIT_USAGE(flowsize);
2044 paddedSize = ROUNDUP(packetSize);
2045
2046 ip2trace (CHANN, ITRC_SICMD, 4, 2, pB->i2eFifoRemains, paddedSize );
2047
2048 // If we don't have enough credits from the board to send the data,
2049 // flag the channel that we are waiting for flow control credit, and
2050 // break out. This will clean up this channel and remove us from the
2051 // queue of hot things to do.
2052
2053 ip2trace (CHANN, ITRC_SICMD, 5, 2, pCh->outfl.room, flowsize );
2054
2055 if (pCh->outfl.room <= flowsize) {
2056 // Do Not have the credits to send this packet.
2057 i2QueueNeeds(pB, pCh, NEED_CREDIT);
2058 notClogged = 0;
2059 break; // So to do next channel
2060 }
2061 if ( (paddedSize > 0)
2062 && ( 0 == i2Write2Fifo(pB, pRemove, paddedSize, 128))) {
2063 // Do Not have room in fifo to send this packet.
2064 notClogged = 0;
2065 i2QueueNeeds(pB, pCh, NEED_INLINE);
2066 break; // Break from the channel
2067 }
2068 #ifdef DEBUG_FIFO
2069 WriteDBGBuf("DATA", pRemove, paddedSize);
2070 #endif /* DEBUG_FIFO */
2071 pB->debugInlineCount++;
2072
2073 pCh->icount.tx += flowsize;
2074 // Update current credits
2075 pCh->outfl.room -= flowsize;
2076 pCh->outfl.asof += flowsize;
2077 if (PTYPE_OF(pRemove) == PTYPE_DATA) {
2078 pCh->Obuf_char_count -= DATA_COUNT_OF(pRemove);
2079 }
2080 pRemove += packetSize;
2081 stripIndex += packetSize;
2082
2083 ip2trace (CHANN, ITRC_SICMD, 6, 2, stripIndex, pCh->Obuf_strip);
2084
2085 if (stripIndex >= OBUF_SIZE) {
2086 stripIndex = 0;
2087 pRemove = pCh->Obuf;
2088
2089 ip2trace (CHANN, ITRC_SICMD, 7, 1, stripIndex );
2090
2091 }
2092 } /* while */
2093 if ( !bailout2 ) {
2094 ip2trace (CHANN, ITRC_ERROR, 3, 0 );
2095 }
2096 // Done with this channel. Move to next, removing this one from the
2097 // queue of channels if we cleaned it out (i.e., didn't get clogged.
2098 pCh->Obuf_strip = stripIndex;
2099 WRITE_UNLOCK_IRQRESTORE(&pCh->Obuf_spinlock,flags);
2100 if ( notClogged )
2101 {
2102
2103 ip2trace (CHANN, ITRC_SICMD, 8, 0 );
2104
2105 if ( pCh->pTTY ) {
2106 ip2_owake(pCh->pTTY);
2107 }
2108 }
2109 } // Either clogged or finished all the work
2110
2111 if ( !bailout ) {
2112 ip2trace (ITRC_NO_PORT, ITRC_ERROR, 4, 0 );
2113 }
2114
2115 ip2trace (ITRC_NO_PORT, ITRC_SICMD, ITRC_RETURN, 1,pB->i2Dbuf_strip);
2116 }
2117
2118 //******************************************************************************
2119 // Function: serviceOutgoingFifo(pB)
2120 // Parameters: Pointer to a board structure
2121 // Returns: Nothing
2122 //
2123 // Description:
2124 // Helper routine to put data in the outgoing fifo, if we aren't already waiting
2125 // for something to be there. If the fifo has only room for a very little data,
2126 // go head and hit the board with a mailbox hit immediately. Otherwise, it will
2127 // have to happen later in the interrupt processing. Since this routine may be
2128 // called both at interrupt and foreground time, we must turn off interrupts
2129 // during the entire process.
2130 //******************************************************************************
2131 static void
2132 serviceOutgoingFifo(i2eBordStrPtr pB)
2133 {
2134 // If we aren't currently waiting for the board to empty our fifo, service
2135 // everything that is pending, in priority order (especially, Bypass before
2136 // Inline).
2137 if ( ! pB->i2eWaitingForEmptyFifo )
2138 {
2139 i2StuffFifoFlow(pB);
2140 i2StuffFifoBypass(pB);
2141 i2StuffFifoInline(pB);
2142
2143 iiSendPendingMail(pB);
2144 }
2145 }
2146
2147 //******************************************************************************
2148 // Function: i2ServiceBoard(pB)
2149 // Parameters: Pointer to a board structure
2150 // Returns: Nothing
2151 //
2152 // Description:
2153 // Normally this is called from interrupt level, but there is deliberately
2154 // nothing in here specific to being called from interrupt level. All the
2155 // hardware-specific, interrupt-specific things happen at the outer levels.
2156 //
2157 // For example, a timer interrupt could drive this routine for some sort of
2158 // polled operation. The only requirement is that the programmer deal with any
2159 // atomiticity/concurrency issues that result.
2160 //
2161 // This routine responds to the board's having sent mailbox information to the
2162 // host (which would normally cause an interrupt). This routine reads the
2163 // incoming mailbox. If there is no data in it, this board did not create the
2164 // interrupt and/or has nothing to be done to it. (Except, if we have been
2165 // waiting to write mailbox data to it, we may do so.
2166 //
2167 // Based on the value in the mailbox, we may take various actions.
2168 //
2169 // No checking here of pB validity: after all, it shouldn't have been called by
2170 // the handler unless pB were on the list.
2171 //******************************************************************************
2172 static inline int
2173 i2ServiceBoard ( i2eBordStrPtr pB )
2174 {
2175 unsigned inmail;
2176 unsigned long flags;
2177
2178
2179 /* This should be atomic because of the way we are called... */
2180 if (NO_MAIL_HERE == ( inmail = pB->i2eStartMail ) ) {
2181 inmail = iiGetMail(pB);
2182 }
2183 pB->i2eStartMail = NO_MAIL_HERE;
2184
2185 ip2trace (ITRC_NO_PORT, ITRC_INTR, 2, 1, inmail );
2186
2187 if (inmail != NO_MAIL_HERE) {
2188 // If the board has gone fatal, nothing to do but hit a bit that will
2189 // alert foreground tasks to protest!
2190 if ( inmail & MB_FATAL_ERROR ) {
2191 pB->i2eFatal = 1;
2192 goto exit_i2ServiceBoard;
2193 }
2194
2195 /* Assuming no fatal condition, we proceed to do work */
2196 if ( inmail & MB_IN_STUFFED ) {
2197 pB->i2eFifoInInts++;
2198 i2StripFifo(pB); /* There might be incoming packets */
2199 }
2200
2201 if (inmail & MB_OUT_STRIPPED) {
2202 pB->i2eFifoOutInts++;
2203 WRITE_LOCK_IRQSAVE(&pB->write_fifo_spinlock,flags);
2204 pB->i2eFifoRemains = pB->i2eFifoSize;
2205 pB->i2eWaitingForEmptyFifo = 0;
2206 WRITE_UNLOCK_IRQRESTORE(&pB->write_fifo_spinlock,flags);
2207
2208 ip2trace (ITRC_NO_PORT, ITRC_INTR, 30, 1, pB->i2eFifoRemains );
2209
2210 }
2211 serviceOutgoingFifo(pB);
2212 }
2213
2214 ip2trace (ITRC_NO_PORT, ITRC_INTR, 8, 0 );
2215
2216 exit_i2ServiceBoard:
2217
2218 return 0;
2219 }
Ubuntu Artful kernel mirror