Commit | Line | Data |
---|---|---|
1da177e4 LT |
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()) { | |
da4cd8df | 658 | schedule_timeout_interruptible(1); // short nap |
1da177e4 LT |
659 | } 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 | //****************************************************************************** | |
783 | static int | |
784 | i2GetStatus(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 | //****************************************************************************** | |
824 | static int | |
825 | i2Input(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 | |
d9e39538 | 857 | amountToMove = pCh->pTTY->receive_room; |
1da177e4 LT |
858 | 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 | ||
896 | i2Input_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 | //****************************************************************************** | |
913 | static int | |
914 | i2InputFlush(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 | |
968 | static int | |
969 | i2InputAvailable(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 | //****************************************************************************** | |
1009 | static int | |
f061c584 | 1010 | i2Output(i2ChanStrPtr pCh, const char *pSource, int count) |
1da177e4 LT |
1011 | { |
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 | ||
f061c584 | 1023 | ip2trace (CHANN, ITRC_OUTPUT, ITRC_ENTER, 2, count, 0 ); |
1da177e4 LT |
1024 | |
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 | |
f061c584 | 1090 | memcpy( (char*)(DATA_OF(pInsert)), pSource, amountToMove ); |
1da177e4 LT |
1091 | // 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 | ||
da4cd8df | 1129 | schedule_timeout_interruptible(2); |
1da177e4 LT |
1130 | 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 | //****************************************************************************** | |
1203 | static inline void | |
1204 | i2FlushOutput(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 | ||
1224 | static int | |
1225 | i2RetryFlushOutput(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 | //****************************************************************************** | |
1268 | static void | |
1269 | i2DrainWakeup(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 | ||
1277 | static void | |
1278 | i2DrainOutput(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 | //****************************************************************************** | |
1342 | static int | |
1343 | i2OutputFree(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 | } | |
1364 | static void | |
1365 | ||
1366 | ip2_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 | ||
1388 | static inline void | |
1389 | set_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 | |
1431 | static 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 | |
1435 | static 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. | |
1439 | static char xlatDss[16] = { | |
1440 | 0 | 0 | 0 | 0 , | |
1441 | 0 | 0 | 0 | I2_CTS , | |
1442 | 0 | 0 | I2_DSR | 0 , | |
1443 | 0 | 0 | I2_DSR | I2_CTS , | |
1444 | 0 | I2_RI | 0 | 0 , | |
1445 | 0 | I2_RI | 0 | I2_CTS , | |
1446 | 0 | I2_RI | I2_DSR | 0 , | |
1447 | 0 | I2_RI | I2_DSR | I2_CTS , | |
1448 | I2_DCD | 0 | 0 | 0 , | |
1449 | I2_DCD | 0 | 0 | I2_CTS , | |
1450 | I2_DCD | 0 | I2_DSR | 0 , | |
1451 | I2_DCD | 0 | I2_DSR | I2_CTS , | |
1452 | I2_DCD | I2_RI | 0 | 0 , | |
1453 | I2_DCD | I2_RI | 0 | I2_CTS , | |
1454 | I2_DCD | I2_RI | I2_DSR | 0 , | |
1455 | I2_DCD | I2_RI | I2_DSR | I2_CTS }; | |
1456 | ||
1457 | static inline void | |
1458 | i2StripFifo(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 | //****************************************************************************** | |
1859 | static int | |
1860 | i2Write2Fifo(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 | //****************************************************************************** | |
1886 | static inline void | |
1887 | i2StuffFifoBypass(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 | |
1922 | WriteDBGBuf("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 | //****************************************************************************** | |
1956 | static inline void | |
1957 | i2StuffFifoFlow(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 | //****************************************************************************** | |
1993 | static inline void | |
1994 | i2StuffFifoInline(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 | |
2062 | WriteDBGBuf("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 | //****************************************************************************** | |
2124 | static void | |
2125 | serviceOutgoingFifo(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 | //****************************************************************************** | |
2165 | static inline int | |
2166 | i2ServiceBoard ( 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 | ||
2209 | exit_i2ServiceBoard: | |
2210 | ||
2211 | return 0; | |
2212 | } |