Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | ** ----------------------------------------------------------------------------- | |
3 | ** | |
4 | ** Perle Specialix driver for Linux | |
5 | ** Ported from existing RIO Driver for SCO sources. | |
6 | * | |
7 | * (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK. | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 2 of the License, or | |
12 | * (at your option) any later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | * GNU General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License | |
20 | * along with this program; if not, write to the Free Software | |
21 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
22 | ** | |
23 | ** Module : riointr.c | |
24 | ** SID : 1.2 | |
25 | ** Last Modified : 11/6/98 10:33:44 | |
26 | ** Retrieved : 11/6/98 10:33:49 | |
27 | ** | |
28 | ** ident @(#)riointr.c 1.2 | |
29 | ** | |
30 | ** ----------------------------------------------------------------------------- | |
31 | */ | |
32 | #ifdef SCCS_LABELS | |
33 | static char *_riointr_c_sccs_ = "@(#)riointr.c 1.2"; | |
34 | #endif | |
35 | ||
36 | ||
37 | #include <linux/module.h> | |
38 | #include <linux/slab.h> | |
39 | #include <linux/errno.h> | |
40 | #include <linux/tty.h> | |
41 | #include <asm/io.h> | |
42 | #include <asm/system.h> | |
43 | #include <asm/string.h> | |
44 | #include <asm/semaphore.h> | |
45 | #include <asm/uaccess.h> | |
46 | ||
47 | #include <linux/termios.h> | |
48 | #include <linux/serial.h> | |
49 | ||
50 | #include <linux/generic_serial.h> | |
51 | ||
52 | #include <linux/delay.h> | |
53 | ||
54 | #include "linux_compat.h" | |
55 | #include "rio_linux.h" | |
56 | #include "typdef.h" | |
57 | #include "pkt.h" | |
58 | #include "daemon.h" | |
59 | #include "rio.h" | |
60 | #include "riospace.h" | |
61 | #include "top.h" | |
62 | #include "cmdpkt.h" | |
63 | #include "map.h" | |
64 | #include "riotypes.h" | |
65 | #include "rup.h" | |
66 | #include "port.h" | |
67 | #include "riodrvr.h" | |
68 | #include "rioinfo.h" | |
69 | #include "func.h" | |
70 | #include "errors.h" | |
71 | #include "pci.h" | |
72 | ||
73 | #include "parmmap.h" | |
74 | #include "unixrup.h" | |
75 | #include "board.h" | |
76 | #include "host.h" | |
77 | #include "error.h" | |
78 | #include "phb.h" | |
79 | #include "link.h" | |
80 | #include "cmdblk.h" | |
81 | #include "route.h" | |
82 | #include "control.h" | |
83 | #include "cirrus.h" | |
84 | #include "rioioctl.h" | |
85 | ||
86 | ||
87 | static void RIOReceive(struct rio_info *, struct Port *); | |
88 | ||
89 | ||
90 | static char *firstchars (char *p, int nch) | |
91 | { | |
92 | static char buf[2][128]; | |
93 | static int t=0; | |
94 | t = ! t; | |
95 | memcpy (buf[t], p, nch); | |
96 | buf[t][nch] = 0; | |
97 | return buf[t]; | |
98 | } | |
99 | ||
100 | ||
101 | #define INCR( P, I ) ((P) = (((P)+(I)) & p->RIOBufferMask)) | |
102 | /* Enable and start the transmission of packets */ | |
103 | void | |
104 | RIOTxEnable(en) | |
105 | char * en; | |
106 | { | |
107 | struct Port * PortP; | |
108 | struct rio_info *p; | |
109 | struct tty_struct* tty; | |
110 | int c; | |
111 | struct PKT * PacketP; | |
112 | unsigned long flags; | |
113 | ||
114 | PortP = (struct Port *)en; | |
115 | p = (struct rio_info *)PortP->p; | |
116 | tty = PortP->gs.tty; | |
117 | ||
118 | ||
119 | rio_dprintk (RIO_DEBUG_INTR, "tx port %d: %d chars queued.\n", | |
120 | PortP->PortNum, PortP->gs.xmit_cnt); | |
121 | ||
122 | if (!PortP->gs.xmit_cnt) return; | |
123 | ||
124 | ||
125 | /* This routine is an order of magnitude simpler than the specialix | |
126 | version. One of the disadvantages is that this version will send | |
127 | an incomplete packet (usually 64 bytes instead of 72) once for | |
128 | every 4k worth of data. Let's just say that this won't influence | |
129 | performance significantly..... */ | |
130 | ||
131 | rio_spin_lock_irqsave(&PortP->portSem, flags); | |
132 | ||
133 | while (can_add_transmit( &PacketP, PortP )) { | |
134 | c = PortP->gs.xmit_cnt; | |
135 | if (c > PKT_MAX_DATA_LEN) c = PKT_MAX_DATA_LEN; | |
136 | ||
137 | /* Don't copy past the end of the source buffer */ | |
138 | if (c > SERIAL_XMIT_SIZE - PortP->gs.xmit_tail) | |
139 | c = SERIAL_XMIT_SIZE - PortP->gs.xmit_tail; | |
140 | ||
141 | { int t; | |
142 | t = (c > 10)?10:c; | |
143 | ||
144 | rio_dprintk (RIO_DEBUG_INTR, "rio: tx port %d: copying %d chars: %s - %s\n", | |
145 | PortP->PortNum, c, | |
146 | firstchars (PortP->gs.xmit_buf + PortP->gs.xmit_tail , t), | |
147 | firstchars (PortP->gs.xmit_buf + PortP->gs.xmit_tail + c-t, t)); | |
148 | } | |
149 | /* If for one reason or another, we can't copy more data, | |
150 | we're done! */ | |
151 | if (c == 0) break; | |
152 | ||
153 | rio_memcpy_toio (PortP->HostP->Caddr, (caddr_t)PacketP->data, | |
154 | PortP->gs.xmit_buf + PortP->gs.xmit_tail, c); | |
155 | /* udelay (1); */ | |
156 | ||
157 | writeb (c, &(PacketP->len)); | |
158 | if (!( PortP->State & RIO_DELETED ) ) { | |
159 | add_transmit ( PortP ); | |
160 | /* | |
161 | ** Count chars tx'd for port statistics reporting | |
162 | */ | |
163 | if ( PortP->statsGather ) | |
164 | PortP->txchars += c; | |
165 | } | |
166 | PortP->gs.xmit_tail = (PortP->gs.xmit_tail + c) & (SERIAL_XMIT_SIZE-1); | |
167 | PortP->gs.xmit_cnt -= c; | |
168 | } | |
169 | ||
170 | rio_spin_unlock_irqrestore(&PortP->portSem, flags); | |
171 | ||
172 | if (PortP->gs.xmit_cnt <= (PortP->gs.wakeup_chars + 2*PKT_MAX_DATA_LEN)) { | |
173 | rio_dprintk (RIO_DEBUG_INTR, "Waking up.... ldisc:%d (%d/%d)....", | |
174 | (int)(PortP->gs.tty->flags & (1 << TTY_DO_WRITE_WAKEUP)), | |
175 | PortP->gs.wakeup_chars, PortP->gs.xmit_cnt); | |
176 | if ((PortP->gs.tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && | |
177 | PortP->gs.tty->ldisc.write_wakeup) | |
178 | (PortP->gs.tty->ldisc.write_wakeup)(PortP->gs.tty); | |
179 | rio_dprintk (RIO_DEBUG_INTR, "(%d/%d)\n", | |
180 | PortP->gs.wakeup_chars, PortP->gs.xmit_cnt); | |
181 | wake_up_interruptible(&PortP->gs.tty->write_wait); | |
182 | } | |
183 | ||
184 | } | |
185 | ||
186 | ||
187 | /* | |
188 | ** RIO Host Service routine. Does all the work traditionally associated with an | |
189 | ** interrupt. | |
190 | */ | |
191 | static int RupIntr; | |
192 | static int RxIntr; | |
193 | static int TxIntr; | |
194 | void | |
195 | RIOServiceHost(p, HostP, From) | |
196 | struct rio_info * p; | |
197 | struct Host *HostP; | |
198 | int From; | |
199 | { | |
200 | rio_spin_lock (&HostP->HostLock); | |
201 | if ( (HostP->Flags & RUN_STATE) != RC_RUNNING ) { | |
202 | static int t =0; | |
203 | rio_spin_unlock (&HostP->HostLock); | |
204 | if ((t++ % 200) == 0) | |
205 | rio_dprintk (RIO_DEBUG_INTR, "Interrupt but host not running. flags=%x.\n", (int)HostP->Flags); | |
206 | return; | |
207 | } | |
208 | rio_spin_unlock (&HostP->HostLock); | |
209 | ||
210 | if ( RWORD( HostP->ParmMapP->rup_intr ) ) { | |
211 | WWORD( HostP->ParmMapP->rup_intr , 0 ); | |
212 | p->RIORupCount++; | |
213 | RupIntr++; | |
214 | rio_dprintk (RIO_DEBUG_INTR, "rio: RUP interrupt on host %d\n", HostP-p->RIOHosts); | |
215 | RIOPollHostCommands(p, HostP ); | |
216 | } | |
217 | ||
218 | if ( RWORD( HostP->ParmMapP->rx_intr ) ) { | |
219 | int port; | |
220 | ||
221 | WWORD( HostP->ParmMapP->rx_intr , 0 ); | |
222 | p->RIORxCount++; | |
223 | RxIntr++; | |
224 | ||
225 | rio_dprintk (RIO_DEBUG_INTR, "rio: RX interrupt on host %d\n", HostP-p->RIOHosts); | |
226 | /* | |
227 | ** Loop through every port. If the port is mapped into | |
228 | ** the system ( i.e. has /dev/ttyXXXX associated ) then it is | |
229 | ** worth checking. If the port isn't open, grab any packets | |
230 | ** hanging on its receive queue and stuff them on the free | |
231 | ** list; check for commands on the way. | |
232 | */ | |
233 | for ( port=p->RIOFirstPortsBooted; | |
234 | port<p->RIOLastPortsBooted+PORTS_PER_RTA; port++ ) { | |
235 | struct Port *PortP = p->RIOPortp[port]; | |
236 | struct tty_struct *ttyP; | |
237 | struct PKT *PacketP; | |
238 | ||
239 | /* | |
240 | ** not mapped in - most of the RIOPortp[] information | |
241 | ** has not been set up! | |
242 | ** Optimise: ports come in bundles of eight. | |
243 | */ | |
244 | if ( !PortP->Mapped ) { | |
245 | port += 7; | |
246 | continue; /* with the next port */ | |
247 | } | |
248 | ||
249 | /* | |
250 | ** If the host board isn't THIS host board, check the next one. | |
251 | ** optimise: ports come in bundles of eight. | |
252 | */ | |
253 | if ( PortP->HostP != HostP ) { | |
254 | port += 7; | |
255 | continue; | |
256 | } | |
257 | ||
258 | /* | |
259 | ** Let us see - is the port open? If not, then don't service it. | |
260 | */ | |
261 | if ( !( PortP->PortState & PORT_ISOPEN ) ) { | |
262 | continue; | |
263 | } | |
264 | ||
265 | /* | |
266 | ** find corresponding tty structure. The process of mapping | |
267 | ** the ports puts these here. | |
268 | */ | |
269 | ttyP = PortP->gs.tty; | |
270 | ||
271 | /* | |
272 | ** Lock the port before we begin working on it. | |
273 | */ | |
274 | rio_spin_lock(&PortP->portSem); | |
275 | ||
276 | /* | |
277 | ** Process received data if there is any. | |
278 | */ | |
279 | if ( can_remove_receive( &PacketP, PortP ) ) | |
280 | RIOReceive(p, PortP); | |
281 | ||
282 | /* | |
283 | ** If there is no data left to be read from the port, and | |
284 | ** it's handshake bit is set, then we must clear the handshake, | |
285 | ** so that that downstream RTA is re-enabled. | |
286 | */ | |
287 | if ( !can_remove_receive( &PacketP, PortP ) && | |
288 | ( RWORD( PortP->PhbP->handshake )==PHB_HANDSHAKE_SET ) ) { | |
289 | /* | |
290 | ** MAGIC! ( Basically, handshake the RX buffer, so that | |
291 | ** the RTAs upstream can be re-enabled. ) | |
292 | */ | |
293 | rio_dprintk (RIO_DEBUG_INTR, "Set RX handshake bit\n"); | |
294 | WWORD( PortP->PhbP->handshake, | |
295 | PHB_HANDSHAKE_SET|PHB_HANDSHAKE_RESET ); | |
296 | } | |
297 | rio_spin_unlock(&PortP->portSem); | |
298 | } | |
299 | } | |
300 | ||
301 | if ( RWORD( HostP->ParmMapP->tx_intr ) ) { | |
302 | int port; | |
303 | ||
304 | WWORD( HostP->ParmMapP->tx_intr , 0); | |
305 | ||
306 | p->RIOTxCount++; | |
307 | TxIntr++; | |
308 | rio_dprintk (RIO_DEBUG_INTR, "rio: TX interrupt on host %d\n", HostP-p->RIOHosts); | |
309 | ||
310 | /* | |
311 | ** Loop through every port. | |
312 | ** If the port is mapped into the system ( i.e. has /dev/ttyXXXX | |
313 | ** associated ) then it is worth checking. | |
314 | */ | |
315 | for ( port=p->RIOFirstPortsBooted; | |
316 | port<p->RIOLastPortsBooted+PORTS_PER_RTA; port++ ) { | |
317 | struct Port *PortP = p->RIOPortp[port]; | |
318 | struct tty_struct *ttyP; | |
319 | struct PKT *PacketP; | |
320 | ||
321 | /* | |
322 | ** not mapped in - most of the RIOPortp[] information | |
323 | ** has not been set up! | |
324 | */ | |
325 | if ( !PortP->Mapped ) { | |
326 | port += 7; | |
327 | continue; /* with the next port */ | |
328 | } | |
329 | ||
330 | /* | |
331 | ** If the host board isn't running, then its data structures | |
332 | ** are no use to us - continue quietly. | |
333 | */ | |
334 | if ( PortP->HostP != HostP ) { | |
335 | port += 7; | |
336 | continue; /* with the next port */ | |
337 | } | |
338 | ||
339 | /* | |
340 | ** Let us see - is the port open? If not, then don't service it. | |
341 | */ | |
342 | if ( !( PortP->PortState & PORT_ISOPEN ) ) { | |
343 | continue; | |
344 | } | |
345 | ||
346 | rio_dprintk (RIO_DEBUG_INTR, "rio: Looking into port %d.\n", port); | |
347 | /* | |
348 | ** Lock the port before we begin working on it. | |
349 | */ | |
350 | rio_spin_lock(&PortP->portSem); | |
351 | ||
352 | /* | |
353 | ** If we can't add anything to the transmit queue, then | |
354 | ** we need do none of this processing. | |
355 | */ | |
356 | if ( !can_add_transmit( &PacketP, PortP ) ) { | |
357 | rio_dprintk (RIO_DEBUG_INTR, "Can't add to port, so skipping.\n"); | |
358 | rio_spin_unlock(&PortP->portSem); | |
359 | continue; | |
360 | } | |
361 | ||
362 | /* | |
363 | ** find corresponding tty structure. The process of mapping | |
364 | ** the ports puts these here. | |
365 | */ | |
366 | ttyP = PortP->gs.tty; | |
367 | /* If ttyP is NULL, the port is getting closed. Forget about it. */ | |
368 | if (!ttyP) { | |
369 | rio_dprintk (RIO_DEBUG_INTR, "no tty, so skipping.\n"); | |
370 | rio_spin_unlock(&PortP->portSem); | |
371 | continue; | |
372 | } | |
373 | /* | |
374 | ** If there is more room available we start up the transmit | |
375 | ** data process again. This can be direct I/O, if the cookmode | |
376 | ** is set to COOK_RAW or COOK_MEDIUM, or will be a call to the | |
377 | ** riotproc( T_OUTPUT ) if we are in COOK_WELL mode, to fetch | |
378 | ** characters via the line discipline. We must always call | |
379 | ** the line discipline, | |
380 | ** so that user input characters can be echoed correctly. | |
381 | ** | |
382 | ** ++++ Update +++++ | |
383 | ** With the advent of double buffering, we now see if | |
384 | ** TxBufferOut-In is non-zero. If so, then we copy a packet | |
385 | ** to the output place, and set it going. If this empties | |
386 | ** the buffer, then we must issue a wakeup( ) on OUT. | |
387 | ** If it frees space in the buffer then we must issue | |
388 | ** a wakeup( ) on IN. | |
389 | ** | |
390 | ** ++++ Extra! Extra! If PortP->WflushFlag is set, then we | |
391 | ** have to send a WFLUSH command down the PHB, to mark the | |
392 | ** end point of a WFLUSH. We also need to clear out any | |
393 | ** data from the double buffer! ( note that WflushFlag is a | |
394 | ** *count* of the number of WFLUSH commands outstanding! ) | |
395 | ** | |
396 | ** ++++ And there's more! | |
397 | ** If an RTA is powered off, then on again, and rebooted, | |
398 | ** whilst it has ports open, then we need to re-open the ports. | |
399 | ** ( reasonable enough ). We can't do this when we spot the | |
400 | ** re-boot, in interrupt time, because the queue is probably | |
401 | ** full. So, when we come in here, we need to test if any | |
402 | ** ports are in this condition, and re-open the port before | |
403 | ** we try to send any more data to it. Now, the re-booted | |
404 | ** RTA will be discarding packets from the PHB until it | |
405 | ** receives this open packet, but don't worry tooo much | |
406 | ** about that. The one thing that is interesting is the | |
407 | ** combination of this effect and the WFLUSH effect! | |
408 | */ | |
409 | /* For now don't handle RTA reboots. -- REW. | |
410 | Reenabled. Otherwise RTA reboots didn't work. Duh. -- REW */ | |
411 | if ( PortP->MagicFlags ) { | |
412 | #if 1 | |
413 | if ( PortP->MagicFlags & MAGIC_REBOOT ) { | |
414 | /* | |
415 | ** well, the RTA has been rebooted, and there is room | |
416 | ** on its queue to add the open packet that is required. | |
417 | ** | |
418 | ** The messy part of this line is trying to decide if | |
419 | ** we need to call the Param function as a tty or as | |
420 | ** a modem. | |
421 | ** DONT USE CLOCAL AS A TEST FOR THIS! | |
422 | ** | |
423 | ** If we can't param the port, then move on to the | |
424 | ** next port. | |
425 | */ | |
426 | PortP->InUse = NOT_INUSE; | |
427 | ||
428 | rio_spin_unlock(&PortP->portSem); | |
429 | if ( RIOParam(PortP, OPEN, ((PortP->Cor2Copy & | |
430 | (COR2_RTSFLOW|COR2_CTSFLOW ) )== | |
431 | (COR2_RTSFLOW|COR2_CTSFLOW ) ) ? | |
432 | TRUE : FALSE, DONT_SLEEP ) == RIO_FAIL ) { | |
433 | continue; /* with next port */ | |
434 | } | |
435 | rio_spin_lock(&PortP->portSem); | |
436 | PortP->MagicFlags &= ~MAGIC_REBOOT; | |
437 | } | |
438 | #endif | |
439 | ||
440 | /* | |
441 | ** As mentioned above, this is a tacky hack to cope | |
442 | ** with WFLUSH | |
443 | */ | |
444 | if ( PortP->WflushFlag ) { | |
445 | rio_dprintk (RIO_DEBUG_INTR, "Want to WFLUSH mark this port\n"); | |
446 | ||
447 | if ( PortP->InUse ) | |
448 | rio_dprintk (RIO_DEBUG_INTR, "FAILS - PORT IS IN USE\n"); | |
449 | } | |
450 | ||
451 | while ( PortP->WflushFlag && | |
452 | can_add_transmit( &PacketP, PortP ) && | |
453 | ( PortP->InUse == NOT_INUSE ) ) { | |
454 | int p; | |
455 | struct PktCmd *PktCmdP; | |
456 | ||
457 | rio_dprintk (RIO_DEBUG_INTR, "Add WFLUSH marker to data queue\n"); | |
458 | /* | |
459 | ** make it look just like a WFLUSH command | |
460 | */ | |
461 | PktCmdP = ( struct PktCmd * )&PacketP->data[0]; | |
462 | ||
463 | WBYTE( PktCmdP->Command , WFLUSH ); | |
464 | ||
465 | p = PortP->HostPort % ( ushort )PORTS_PER_RTA; | |
466 | ||
467 | /* | |
468 | ** If second block of ports for 16 port RTA, add 8 | |
469 | ** to index 8-15. | |
470 | */ | |
471 | if ( PortP->SecondBlock ) | |
472 | p += PORTS_PER_RTA; | |
473 | ||
474 | WBYTE( PktCmdP->PhbNum, p ); | |
475 | ||
476 | /* | |
477 | ** to make debuggery easier | |
478 | */ | |
479 | WBYTE( PacketP->data[ 2], 'W' ); | |
480 | WBYTE( PacketP->data[ 3], 'F' ); | |
481 | WBYTE( PacketP->data[ 4], 'L' ); | |
482 | WBYTE( PacketP->data[ 5], 'U' ); | |
483 | WBYTE( PacketP->data[ 6], 'S' ); | |
484 | WBYTE( PacketP->data[ 7], 'H' ); | |
485 | WBYTE( PacketP->data[ 8], ' ' ); | |
486 | WBYTE( PacketP->data[ 9], '0'+PortP->WflushFlag ); | |
487 | WBYTE( PacketP->data[10], ' ' ); | |
488 | WBYTE( PacketP->data[11], ' ' ); | |
489 | WBYTE( PacketP->data[12], '\0' ); | |
490 | ||
491 | /* | |
492 | ** its two bytes long! | |
493 | */ | |
494 | WBYTE( PacketP->len , PKT_CMD_BIT | 2 ); | |
495 | ||
496 | /* | |
497 | ** queue it! | |
498 | */ | |
499 | if ( !( PortP->State & RIO_DELETED ) ) { | |
500 | add_transmit( PortP ); | |
501 | /* | |
502 | ** Count chars tx'd for port statistics reporting | |
503 | */ | |
504 | if ( PortP->statsGather ) | |
505 | PortP->txchars += 2; | |
506 | } | |
507 | ||
508 | if ( --( PortP->WflushFlag ) == 0 ) { | |
509 | PortP->MagicFlags &= ~MAGIC_FLUSH; | |
510 | } | |
511 | ||
512 | rio_dprintk (RIO_DEBUG_INTR, "Wflush count now stands at %d\n", | |
513 | PortP->WflushFlag); | |
514 | } | |
515 | if ( PortP->MagicFlags & MORE_OUTPUT_EYGOR ) { | |
516 | if ( PortP->MagicFlags & MAGIC_FLUSH ) { | |
517 | PortP->MagicFlags |= MORE_OUTPUT_EYGOR; | |
518 | } | |
519 | else { | |
520 | if ( !can_add_transmit( &PacketP, PortP ) ) { | |
521 | rio_spin_unlock(&PortP->portSem); | |
522 | continue; | |
523 | } | |
524 | rio_spin_unlock(&PortP->portSem); | |
525 | RIOTxEnable((char *)PortP); | |
526 | rio_spin_lock(&PortP->portSem); | |
527 | PortP->MagicFlags &= ~MORE_OUTPUT_EYGOR; | |
528 | } | |
529 | } | |
530 | } | |
531 | ||
532 | ||
533 | /* | |
534 | ** If we can't add anything to the transmit queue, then | |
535 | ** we need do none of the remaining processing. | |
536 | */ | |
537 | if (!can_add_transmit( &PacketP, PortP ) ) { | |
538 | rio_spin_unlock(&PortP->portSem); | |
539 | continue; | |
540 | } | |
541 | ||
542 | rio_spin_unlock(&PortP->portSem); | |
543 | RIOTxEnable((char *)PortP); | |
544 | } | |
545 | } | |
546 | } | |
547 | ||
548 | /* | |
549 | ** Routine for handling received data for clist drivers. | |
550 | ** NB: Called with the tty locked. The spl from the lockb( ) is passed. | |
551 | ** we return the ttySpl level that we re-locked at. | |
552 | */ | |
553 | static void | |
554 | RIOReceive(p, PortP) | |
555 | struct rio_info * p; | |
556 | struct Port * PortP; | |
557 | { | |
558 | struct tty_struct *TtyP; | |
559 | register ushort transCount; | |
560 | struct PKT *PacketP; | |
561 | register uint DataCnt; | |
562 | uchar * ptr; | |
563 | int copied =0; | |
564 | ||
565 | static int intCount, RxIntCnt; | |
566 | ||
567 | /* | |
568 | ** The receive data process is to remove packets from the | |
569 | ** PHB until there aren't any more or the current cblock | |
570 | ** is full. When this occurs, there will be some left over | |
571 | ** data in the packet, that we must do something with. | |
572 | ** As we haven't unhooked the packet from the read list | |
573 | ** yet, we can just leave the packet there, having first | |
574 | ** made a note of how far we got. This means that we need | |
575 | ** a pointer per port saying where we start taking the | |
576 | ** data from - this will normally be zero, but when we | |
577 | ** run out of space it will be set to the offset of the | |
578 | ** next byte to copy from the packet data area. The packet | |
579 | ** length field is decremented by the number of bytes that | |
580 | ** we succesfully removed from the packet. When this reaches | |
581 | ** zero, we reset the offset pointer to be zero, and free | |
582 | ** the packet from the front of the queue. | |
583 | */ | |
584 | ||
585 | intCount++; | |
586 | ||
587 | TtyP = PortP->gs.tty; | |
588 | if (!TtyP) { | |
589 | rio_dprintk (RIO_DEBUG_INTR, "RIOReceive: tty is null. \n"); | |
590 | return; | |
591 | } | |
592 | ||
593 | if (PortP->State & RIO_THROTTLE_RX) { | |
594 | rio_dprintk (RIO_DEBUG_INTR, "RIOReceive: Throttled. Can't handle more input.\n"); | |
595 | return; | |
596 | } | |
597 | ||
598 | if ( PortP->State & RIO_DELETED ) | |
599 | { | |
600 | while ( can_remove_receive( &PacketP, PortP ) ) | |
601 | { | |
602 | remove_receive( PortP ); | |
603 | put_free_end( PortP->HostP, PacketP ); | |
604 | } | |
605 | } | |
606 | else | |
607 | { | |
608 | /* | |
609 | ** loop, just so long as: | |
610 | ** i ) there's some data ( i.e. can_remove_receive ) | |
611 | ** ii ) we haven't been blocked | |
612 | ** iii ) there's somewhere to put the data | |
613 | ** iv ) we haven't outstayed our welcome | |
614 | */ | |
615 | transCount = 1; | |
616 | while ( can_remove_receive(&PacketP, PortP) | |
617 | && transCount) | |
618 | { | |
619 | #ifdef STATS | |
620 | PortP->Stat.RxIntCnt++; | |
621 | #endif /* STATS */ | |
622 | RxIntCnt++; | |
623 | ||
624 | /* | |
625 | ** check that it is not a command! | |
626 | */ | |
627 | if ( PacketP->len & PKT_CMD_BIT ) { | |
628 | rio_dprintk (RIO_DEBUG_INTR, "RIO: unexpected command packet received on PHB\n"); | |
629 | /* rio_dprint(RIO_DEBUG_INTR, (" sysport = %d\n", p->RIOPortp->PortNum)); */ | |
630 | rio_dprintk (RIO_DEBUG_INTR, " dest_unit = %d\n", PacketP->dest_unit); | |
631 | rio_dprintk (RIO_DEBUG_INTR, " dest_port = %d\n", PacketP->dest_port); | |
632 | rio_dprintk (RIO_DEBUG_INTR, " src_unit = %d\n", PacketP->src_unit); | |
633 | rio_dprintk (RIO_DEBUG_INTR, " src_port = %d\n", PacketP->src_port); | |
634 | rio_dprintk (RIO_DEBUG_INTR, " len = %d\n", PacketP->len); | |
635 | rio_dprintk (RIO_DEBUG_INTR, " control = %d\n", PacketP->control); | |
636 | rio_dprintk (RIO_DEBUG_INTR, " csum = %d\n", PacketP->csum); | |
637 | rio_dprintk (RIO_DEBUG_INTR, " data bytes: "); | |
638 | for ( DataCnt=0; DataCnt<PKT_MAX_DATA_LEN; DataCnt++ ) | |
639 | rio_dprintk (RIO_DEBUG_INTR, "%d\n", PacketP->data[DataCnt]); | |
640 | remove_receive( PortP ); | |
641 | put_free_end( PortP->HostP, PacketP ); | |
642 | continue; /* with next packet */ | |
643 | } | |
644 | ||
645 | /* | |
646 | ** How many characters can we move 'upstream' ? | |
647 | ** | |
648 | ** Determine the minimum of the amount of data | |
649 | ** available and the amount of space in which to | |
650 | ** put it. | |
651 | ** | |
652 | ** 1. Get the packet length by masking 'len' | |
653 | ** for only the length bits. | |
654 | ** 2. Available space is [buffer size] - [space used] | |
655 | ** | |
656 | ** Transfer count is the minimum of packet length | |
657 | ** and available space. | |
658 | */ | |
659 | ||
660 | transCount = min_t(unsigned int, PacketP->len & PKT_LEN_MASK, | |
661 | TTY_FLIPBUF_SIZE - TtyP->flip.count); | |
662 | rio_dprintk (RIO_DEBUG_REC, "port %d: Copy %d bytes\n", | |
663 | PortP->PortNum, transCount); | |
664 | /* | |
665 | ** To use the following 'kkprintfs' for debugging - change the '#undef' | |
666 | ** to '#define', (this is the only place ___DEBUG_IT___ occurs in the | |
667 | ** driver). | |
668 | */ | |
669 | #undef ___DEBUG_IT___ | |
670 | #ifdef ___DEBUG_IT___ | |
671 | kkprintf("I:%d R:%d P:%d Q:%d C:%d F:%x ", | |
672 | intCount, | |
673 | RxIntCnt, | |
674 | PortP->PortNum, | |
675 | TtyP->rxqueue.count, | |
676 | transCount, | |
677 | TtyP->flags ); | |
678 | #endif | |
679 | ptr = (uchar *) PacketP->data + PortP->RxDataStart; | |
680 | ||
681 | rio_memcpy_fromio (TtyP->flip.char_buf_ptr, ptr, transCount); | |
682 | memset(TtyP->flip.flag_buf_ptr, TTY_NORMAL, transCount); | |
683 | ||
684 | #ifdef STATS | |
685 | /* | |
686 | ** keep a count for statistical purposes | |
687 | */ | |
688 | PortP->Stat.RxCharCnt += transCount; | |
689 | #endif | |
690 | PortP->RxDataStart += transCount; | |
691 | PacketP->len -= transCount; | |
692 | copied += transCount; | |
693 | TtyP->flip.count += transCount; | |
694 | TtyP->flip.char_buf_ptr += transCount; | |
695 | TtyP->flip.flag_buf_ptr += transCount; | |
696 | ||
697 | ||
698 | #ifdef ___DEBUG_IT___ | |
699 | kkprintf("T:%d L:%d\n", DataCnt, PacketP->len ); | |
700 | #endif | |
701 | ||
702 | if ( PacketP->len == 0 ) | |
703 | { | |
704 | /* | |
705 | ** If we have emptied the packet, then we can | |
706 | ** free it, and reset the start pointer for | |
707 | ** the next packet. | |
708 | */ | |
709 | remove_receive( PortP ); | |
710 | put_free_end( PortP->HostP, PacketP ); | |
711 | PortP->RxDataStart = 0; | |
712 | #ifdef STATS | |
713 | /* | |
714 | ** more lies ( oops, I mean statistics ) | |
715 | */ | |
716 | PortP->Stat.RxPktCnt++; | |
717 | #endif /* STATS */ | |
718 | } | |
719 | } | |
720 | } | |
721 | if (copied) { | |
722 | rio_dprintk (RIO_DEBUG_REC, "port %d: pushing tty flip buffer: %d total bytes copied.\n", PortP->PortNum, copied); | |
723 | tty_flip_buffer_push (TtyP); | |
724 | } | |
725 | ||
726 | return; | |
727 | } | |
728 | ||
729 | #ifdef FUTURE_RELEASE | |
730 | /* | |
731 | ** The proc routine called by the line discipline to do the work for it. | |
732 | ** The proc routine works hand in hand with the interrupt routine. | |
733 | */ | |
734 | int | |
735 | riotproc(p, tp, cmd, port) | |
736 | struct rio_info * p; | |
737 | register struct ttystatics *tp; | |
738 | int cmd; | |
739 | int port; | |
740 | { | |
741 | register struct Port *PortP; | |
742 | int SysPort; | |
743 | struct PKT *PacketP; | |
744 | ||
745 | SysPort = port; /* Believe me, it works. */ | |
746 | ||
747 | if ( SysPort < 0 || SysPort >= RIO_PORTS ) { | |
748 | rio_dprintk (RIO_DEBUG_INTR, "Illegal port %d derived from TTY in riotproc()\n",SysPort); | |
749 | return 0; | |
750 | } | |
751 | PortP = p->RIOPortp[SysPort]; | |
752 | ||
753 | if ((uint)PortP->PhbP < (uint)PortP->Caddr || | |
754 | (uint)PortP->PhbP >= (uint)PortP->Caddr+SIXTY_FOUR_K ) { | |
755 | rio_dprintk (RIO_DEBUG_INTR, "RIO: NULL or BAD PhbP on sys port %d in proc routine\n", | |
756 | SysPort); | |
757 | rio_dprintk (RIO_DEBUG_INTR, " PortP = 0x%x\n",PortP); | |
758 | rio_dprintk (RIO_DEBUG_INTR, " PortP->PhbP = 0x%x\n",PortP->PhbP); | |
759 | rio_dprintk (RIO_DEBUG_INTR, " PortP->Caddr = 0x%x\n",PortP->PhbP); | |
760 | rio_dprintk (RIO_DEBUG_INTR, " PortP->HostPort = 0x%x\n",PortP->HostPort); | |
761 | return 0; | |
762 | } | |
763 | ||
764 | switch(cmd) { | |
765 | case T_WFLUSH: | |
766 | rio_dprintk (RIO_DEBUG_INTR, "T_WFLUSH\n"); | |
767 | /* | |
768 | ** Because of the spooky way the RIO works, we don't need | |
769 | ** to issue a flush command on any of the SET*F commands, | |
770 | ** as that causes trouble with getty and login, which issue | |
771 | ** these commands to incur a READ flush, and rely on the fact | |
772 | ** that the line discipline does a wait for drain for them. | |
773 | ** As the rio doesn't wait for drain, the write flush would | |
774 | ** destroy the Password: prompt. This isn't very friendly, so | |
775 | ** here we only issue a WFLUSH command if we are in the interrupt | |
776 | ** routine, or we aren't executing a SET*F command. | |
777 | */ | |
778 | if ( PortP->HostP->InIntr || !PortP->FlushCmdBodge ) { | |
779 | /* | |
780 | ** form a wflush packet - 1 byte long, no data | |
781 | */ | |
782 | if ( PortP->State & RIO_DELETED ) { | |
783 | rio_dprintk (RIO_DEBUG_INTR, "WFLUSH on deleted RTA\n"); | |
784 | } | |
785 | else { | |
786 | if ( RIOPreemptiveCmd(p, PortP, WFLUSH ) == RIO_FAIL ) { | |
787 | rio_dprintk (RIO_DEBUG_INTR, "T_WFLUSH Command failed\n"); | |
788 | } | |
789 | else | |
790 | rio_dprintk (RIO_DEBUG_INTR, "T_WFLUSH Command\n"); | |
791 | } | |
792 | /* | |
793 | ** WFLUSH operation - flush the data! | |
794 | */ | |
795 | PortP->TxBufferIn = PortP->TxBufferOut = 0; | |
796 | } | |
797 | else { | |
798 | rio_dprintk (RIO_DEBUG_INTR, "T_WFLUSH Command ignored\n"); | |
799 | } | |
800 | /* | |
801 | ** sort out the line discipline | |
802 | */ | |
803 | if (PortP->CookMode == COOK_WELL) | |
804 | goto start; | |
805 | break; | |
806 | ||
807 | case T_RESUME: | |
808 | rio_dprintk (RIO_DEBUG_INTR, "T_RESUME\n"); | |
809 | /* | |
810 | ** send pre-emptive resume packet | |
811 | */ | |
812 | if ( PortP->State & RIO_DELETED ) { | |
813 | rio_dprintk (RIO_DEBUG_INTR, "RESUME on deleted RTA\n"); | |
814 | } | |
815 | else { | |
816 | if ( RIOPreemptiveCmd(p, PortP, RESUME ) == RIO_FAIL ) { | |
817 | rio_dprintk (RIO_DEBUG_INTR, "T_RESUME Command failed\n"); | |
818 | } | |
819 | } | |
820 | /* | |
821 | ** and re-start the sender software! | |
822 | */ | |
823 | if (PortP->CookMode == COOK_WELL) | |
824 | goto start; | |
825 | break; | |
826 | ||
827 | case T_TIME: | |
828 | rio_dprintk (RIO_DEBUG_INTR, "T_TIME\n"); | |
829 | /* | |
830 | ** T_TIME is called when xDLY is set in oflags and | |
831 | ** the line discipline timeout has expired. It's | |
832 | ** function in life is to clear the TIMEOUT flag | |
833 | ** and to re-start output to the port. | |
834 | */ | |
835 | /* | |
836 | ** Fall through and re-start output | |
837 | */ | |
838 | case T_OUTPUT: | |
839 | start: | |
840 | if ( PortP->MagicFlags & MAGIC_FLUSH ) { | |
841 | PortP->MagicFlags |= MORE_OUTPUT_EYGOR; | |
842 | return 0; | |
843 | } | |
844 | RIOTxEnable((char *)PortP); | |
845 | PortP->MagicFlags &= ~MORE_OUTPUT_EYGOR; | |
846 | /*rio_dprint(RIO_DEBUG_INTR, PortP,DBG_PROC,"T_OUTPUT finished\n");*/ | |
847 | break; | |
848 | ||
849 | case T_SUSPEND: | |
850 | rio_dprintk (RIO_DEBUG_INTR, "T_SUSPEND\n"); | |
851 | /* | |
852 | ** send a suspend pre-emptive packet. | |
853 | */ | |
854 | if ( PortP->State & RIO_DELETED ) { | |
855 | rio_dprintk (RIO_DEBUG_INTR, "SUSPEND deleted RTA\n"); | |
856 | } | |
857 | else { | |
858 | if ( RIOPreemptiveCmd(p, PortP, SUSPEND ) == RIO_FAIL ) { | |
859 | rio_dprintk (RIO_DEBUG_INTR, "T_SUSPEND Command failed\n"); | |
860 | } | |
861 | } | |
862 | /* | |
863 | ** done! | |
864 | */ | |
865 | break; | |
866 | ||
867 | case T_BLOCK: | |
868 | rio_dprintk (RIO_DEBUG_INTR, "T_BLOCK\n"); | |
869 | break; | |
870 | ||
871 | case T_RFLUSH: | |
872 | rio_dprintk (RIO_DEBUG_INTR, "T_RFLUSH\n"); | |
873 | if ( PortP->State & RIO_DELETED ) { | |
874 | rio_dprintk (RIO_DEBUG_INTR, "RFLUSH on deleted RTA\n"); | |
875 | PortP->RxDataStart = 0; | |
876 | } | |
877 | else { | |
878 | if ( RIOPreemptiveCmd( p, PortP, RFLUSH ) == RIO_FAIL ) { | |
879 | rio_dprintk (RIO_DEBUG_INTR, "T_RFLUSH Command failed\n"); | |
880 | return 0; | |
881 | } | |
882 | PortP->RxDataStart = 0; | |
883 | while ( can_remove_receive(&PacketP, PortP) ) { | |
884 | remove_receive(PortP); | |
885 | ShowPacket(DBG_PROC, PacketP ); | |
886 | put_free_end(PortP->HostP, PacketP ); | |
887 | } | |
888 | if ( PortP->PhbP->handshake == PHB_HANDSHAKE_SET ) { | |
889 | /* | |
890 | ** MAGIC! | |
891 | */ | |
892 | rio_dprintk (RIO_DEBUG_INTR, "Set receive handshake bit\n"); | |
893 | PortP->PhbP->handshake |= PHB_HANDSHAKE_RESET; | |
894 | } | |
895 | } | |
896 | break; | |
897 | /* FALLTHROUGH */ | |
898 | case T_UNBLOCK: | |
899 | rio_dprintk (RIO_DEBUG_INTR, "T_UNBLOCK\n"); | |
900 | /* | |
901 | ** If there is any data to receive set a timeout to service it. | |
902 | */ | |
903 | RIOReceive(p, PortP); | |
904 | break; | |
905 | ||
906 | case T_BREAK: | |
907 | rio_dprintk (RIO_DEBUG_INTR, "T_BREAK\n"); | |
908 | /* | |
909 | ** Send a break command. For Sys V | |
910 | ** this is a timed break, so we | |
911 | ** send a SBREAK[time] packet | |
912 | */ | |
913 | /* | |
914 | ** Build a BREAK command | |
915 | */ | |
916 | if ( PortP->State & RIO_DELETED ) { | |
917 | rio_dprintk (RIO_DEBUG_INTR, "BREAK on deleted RTA\n"); | |
918 | } | |
919 | else { | |
920 | if (RIOShortCommand(PortP,SBREAK,2, | |
921 | p->RIOConf.BreakInterval)==RIO_FAIL) { | |
922 | rio_dprintk (RIO_DEBUG_INTR, "SBREAK RIOShortCommand failed\n"); | |
923 | } | |
924 | } | |
925 | ||
926 | /* | |
927 | ** done! | |
928 | */ | |
929 | break; | |
930 | ||
931 | case T_INPUT: | |
932 | rio_dprintk (RIO_DEBUG_INTR, "Proc T_INPUT called - I don't know what to do!\n"); | |
933 | break; | |
934 | case T_PARM: | |
935 | rio_dprintk (RIO_DEBUG_INTR, "Proc T_PARM called - I don't know what to do!\n"); | |
936 | break; | |
937 | ||
938 | case T_SWTCH: | |
939 | rio_dprintk (RIO_DEBUG_INTR, "Proc T_SWTCH called - I don't know what to do!\n"); | |
940 | break; | |
941 | ||
942 | default: | |
943 | rio_dprintk (RIO_DEBUG_INTR, "Proc UNKNOWN command %d\n",cmd); | |
944 | } | |
945 | /* | |
946 | ** T_OUTPUT returns without passing through this point! | |
947 | */ | |
948 | /*rio_dprint(RIO_DEBUG_INTR, PortP,DBG_PROC,"riotproc done\n");*/ | |
949 | return(0); | |
950 | } | |
951 | #endif |