2 ** -----------------------------------------------------------------------------
4 ** Perle Specialix driver for Linux
5 ** Ported from existing RIO Driver for SCO sources.
7 * (C) 1990 - 2000 Specialix International Ltd., Byfleet, Surrey, UK.
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.
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.
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.
25 ** Last Modified : 11/6/98 10:33:44
26 ** Retrieved : 11/6/98 10:33:49
28 ** ident @(#)riointr.c 1.2
30 ** -----------------------------------------------------------------------------
33 static char *_riointr_c_sccs_ = "@(#)riointr.c 1.2";
37 #include <linux/module.h>
38 #include <linux/slab.h>
39 #include <linux/errno.h>
40 #include <linux/tty.h>
41 #include <linux/tty_flip.h>
43 #include <asm/system.h>
44 #include <asm/string.h>
45 #include <asm/semaphore.h>
46 #include <asm/uaccess.h>
48 #include <linux/termios.h>
49 #include <linux/serial.h>
51 #include <linux/generic_serial.h>
53 #include <linux/delay.h>
55 #include "linux_compat.h"
56 #include "rio_linux.h"
88 static void RIOReceive(struct rio_info *, struct Port *);
91 static char *firstchars(char *p, int nch)
93 static char buf[2][128];
96 memcpy(buf[t], p, nch);
102 #define INCR( P, I ) ((P) = (((P)+(I)) & p->RIOBufferMask))
103 /* Enable and start the transmission of packets */
104 void RIOTxEnable(char *en)
108 struct tty_struct *tty;
113 PortP = (struct Port *) en;
114 p = (struct rio_info *) PortP->p;
118 rio_dprintk(RIO_DEBUG_INTR, "tx port %d: %d chars queued.\n", PortP->PortNum, PortP->gs.xmit_cnt);
120 if (!PortP->gs.xmit_cnt)
124 /* This routine is an order of magnitude simpler than the specialix
125 version. One of the disadvantages is that this version will send
126 an incomplete packet (usually 64 bytes instead of 72) once for
127 every 4k worth of data. Let's just say that this won't influence
128 performance significantly..... */
130 rio_spin_lock_irqsave(&PortP->portSem, flags);
132 while (can_add_transmit(&PacketP, PortP)) {
133 c = PortP->gs.xmit_cnt;
134 if (c > PKT_MAX_DATA_LEN)
135 c = PKT_MAX_DATA_LEN;
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;
143 t = (c > 10) ? 10 : c;
145 rio_dprintk(RIO_DEBUG_INTR, "rio: tx port %d: copying %d chars: %s - %s\n", PortP->PortNum, c, firstchars(PortP->gs.xmit_buf + PortP->gs.xmit_tail, t), firstchars(PortP->gs.xmit_buf + PortP->gs.xmit_tail + c - t, t));
147 /* If for one reason or another, we can't copy more data,
152 rio_memcpy_toio(PortP->HostP->Caddr, (caddr_t) PacketP->data, PortP->gs.xmit_buf + PortP->gs.xmit_tail, c);
155 writeb(c, &(PacketP->len));
156 if (!(PortP->State & RIO_DELETED)) {
159 ** Count chars tx'd for port statistics reporting
161 if (PortP->statsGather)
164 PortP->gs.xmit_tail = (PortP->gs.xmit_tail + c) & (SERIAL_XMIT_SIZE - 1);
165 PortP->gs.xmit_cnt -= c;
168 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
170 if (PortP->gs.xmit_cnt <= (PortP->gs.wakeup_chars + 2 * PKT_MAX_DATA_LEN)) {
171 rio_dprintk(RIO_DEBUG_INTR, "Waking up.... ldisc:%d (%d/%d)....", (int) (PortP->gs.tty->flags & (1 << TTY_DO_WRITE_WAKEUP)), PortP->gs.wakeup_chars, PortP->gs.xmit_cnt);
172 if ((PortP->gs.tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && PortP->gs.tty->ldisc.write_wakeup)
173 (PortP->gs.tty->ldisc.write_wakeup) (PortP->gs.tty);
174 rio_dprintk(RIO_DEBUG_INTR, "(%d/%d)\n", PortP->gs.wakeup_chars, PortP->gs.xmit_cnt);
175 wake_up_interruptible(&PortP->gs.tty->write_wait);
182 ** RIO Host Service routine. Does all the work traditionally associated with an
189 void RIOServiceHost(struct rio_info *p, struct Host *HostP, int From)
191 rio_spin_lock(&HostP->HostLock);
192 if ((HostP->Flags & RUN_STATE) != RC_RUNNING) {
194 rio_spin_unlock(&HostP->HostLock);
195 if ((t++ % 200) == 0)
196 rio_dprintk(RIO_DEBUG_INTR, "Interrupt but host not running. flags=%x.\n", (int) HostP->Flags);
199 rio_spin_unlock(&HostP->HostLock);
201 if (readw(&HostP->ParmMapP->rup_intr)) {
202 writew(0, &HostP->ParmMapP->rup_intr);
205 rio_dprintk(RIO_DEBUG_INTR, "rio: RUP interrupt on host %Zd\n", HostP - p->RIOHosts);
206 RIOPollHostCommands(p, HostP);
209 if (readw(&HostP->ParmMapP->rx_intr)) {
212 writew(0, &HostP->ParmMapP->rx_intr);
216 rio_dprintk(RIO_DEBUG_INTR, "rio: RX interrupt on host %Zd\n", HostP - p->RIOHosts);
218 ** Loop through every port. If the port is mapped into
219 ** the system ( i.e. has /dev/ttyXXXX associated ) then it is
220 ** worth checking. If the port isn't open, grab any packets
221 ** hanging on its receive queue and stuff them on the free
222 ** list; check for commands on the way.
224 for (port = p->RIOFirstPortsBooted; port < p->RIOLastPortsBooted + PORTS_PER_RTA; port++) {
225 struct Port *PortP = p->RIOPortp[port];
226 struct tty_struct *ttyP;
230 ** not mapped in - most of the RIOPortp[] information
231 ** has not been set up!
232 ** Optimise: ports come in bundles of eight.
234 if (!PortP->Mapped) {
236 continue; /* with the next port */
240 ** If the host board isn't THIS host board, check the next one.
241 ** optimise: ports come in bundles of eight.
243 if (PortP->HostP != HostP) {
249 ** Let us see - is the port open? If not, then don't service it.
251 if (!(PortP->PortState & PORT_ISOPEN)) {
256 ** find corresponding tty structure. The process of mapping
257 ** the ports puts these here.
259 ttyP = PortP->gs.tty;
262 ** Lock the port before we begin working on it.
264 rio_spin_lock(&PortP->portSem);
267 ** Process received data if there is any.
269 if (can_remove_receive(&PacketP, PortP))
270 RIOReceive(p, PortP);
273 ** If there is no data left to be read from the port, and
274 ** it's handshake bit is set, then we must clear the handshake,
275 ** so that that downstream RTA is re-enabled.
277 if (!can_remove_receive(&PacketP, PortP) && (readw(&PortP->PhbP->handshake) == PHB_HANDSHAKE_SET)) {
279 ** MAGIC! ( Basically, handshake the RX buffer, so that
280 ** the RTAs upstream can be re-enabled. )
282 rio_dprintk(RIO_DEBUG_INTR, "Set RX handshake bit\n");
283 writew(PHB_HANDSHAKE_SET | PHB_HANDSHAKE_RESET, &PortP->PhbP->handshake);
285 rio_spin_unlock(&PortP->portSem);
289 if (readw(&HostP->ParmMapP->tx_intr)) {
292 writew(0, &HostP->ParmMapP->tx_intr);
296 rio_dprintk(RIO_DEBUG_INTR, "rio: TX interrupt on host %Zd\n", HostP - p->RIOHosts);
299 ** Loop through every port.
300 ** If the port is mapped into the system ( i.e. has /dev/ttyXXXX
301 ** associated ) then it is worth checking.
303 for (port = p->RIOFirstPortsBooted; port < p->RIOLastPortsBooted + PORTS_PER_RTA; port++) {
304 struct Port *PortP = p->RIOPortp[port];
305 struct tty_struct *ttyP;
309 ** not mapped in - most of the RIOPortp[] information
310 ** has not been set up!
312 if (!PortP->Mapped) {
314 continue; /* with the next port */
318 ** If the host board isn't running, then its data structures
319 ** are no use to us - continue quietly.
321 if (PortP->HostP != HostP) {
323 continue; /* with the next port */
327 ** Let us see - is the port open? If not, then don't service it.
329 if (!(PortP->PortState & PORT_ISOPEN)) {
333 rio_dprintk(RIO_DEBUG_INTR, "rio: Looking into port %d.\n", port);
335 ** Lock the port before we begin working on it.
337 rio_spin_lock(&PortP->portSem);
340 ** If we can't add anything to the transmit queue, then
341 ** we need do none of this processing.
343 if (!can_add_transmit(&PacketP, PortP)) {
344 rio_dprintk(RIO_DEBUG_INTR, "Can't add to port, so skipping.\n");
345 rio_spin_unlock(&PortP->portSem);
350 ** find corresponding tty structure. The process of mapping
351 ** the ports puts these here.
353 ttyP = PortP->gs.tty;
354 /* If ttyP is NULL, the port is getting closed. Forget about it. */
356 rio_dprintk(RIO_DEBUG_INTR, "no tty, so skipping.\n");
357 rio_spin_unlock(&PortP->portSem);
361 ** If there is more room available we start up the transmit
362 ** data process again. This can be direct I/O, if the cookmode
363 ** is set to COOK_RAW or COOK_MEDIUM, or will be a call to the
364 ** riotproc( T_OUTPUT ) if we are in COOK_WELL mode, to fetch
365 ** characters via the line discipline. We must always call
366 ** the line discipline,
367 ** so that user input characters can be echoed correctly.
370 ** With the advent of double buffering, we now see if
371 ** TxBufferOut-In is non-zero. If so, then we copy a packet
372 ** to the output place, and set it going. If this empties
373 ** the buffer, then we must issue a wakeup( ) on OUT.
374 ** If it frees space in the buffer then we must issue
375 ** a wakeup( ) on IN.
377 ** ++++ Extra! Extra! If PortP->WflushFlag is set, then we
378 ** have to send a WFLUSH command down the PHB, to mark the
379 ** end point of a WFLUSH. We also need to clear out any
380 ** data from the double buffer! ( note that WflushFlag is a
381 ** *count* of the number of WFLUSH commands outstanding! )
383 ** ++++ And there's more!
384 ** If an RTA is powered off, then on again, and rebooted,
385 ** whilst it has ports open, then we need to re-open the ports.
386 ** ( reasonable enough ). We can't do this when we spot the
387 ** re-boot, in interrupt time, because the queue is probably
388 ** full. So, when we come in here, we need to test if any
389 ** ports are in this condition, and re-open the port before
390 ** we try to send any more data to it. Now, the re-booted
391 ** RTA will be discarding packets from the PHB until it
392 ** receives this open packet, but don't worry tooo much
393 ** about that. The one thing that is interesting is the
394 ** combination of this effect and the WFLUSH effect!
396 /* For now don't handle RTA reboots. -- REW.
397 Reenabled. Otherwise RTA reboots didn't work. Duh. -- REW */
398 if (PortP->MagicFlags) {
400 if (PortP->MagicFlags & MAGIC_REBOOT) {
402 ** well, the RTA has been rebooted, and there is room
403 ** on its queue to add the open packet that is required.
405 ** The messy part of this line is trying to decide if
406 ** we need to call the Param function as a tty or as
408 ** DONT USE CLOCAL AS A TEST FOR THIS!
410 ** If we can't param the port, then move on to the
413 PortP->InUse = NOT_INUSE;
415 rio_spin_unlock(&PortP->portSem);
416 if (RIOParam(PortP, OPEN, ((PortP->Cor2Copy & (COR2_RTSFLOW | COR2_CTSFLOW)) == (COR2_RTSFLOW | COR2_CTSFLOW)) ? TRUE : FALSE, DONT_SLEEP) == RIO_FAIL) {
417 continue; /* with next port */
419 rio_spin_lock(&PortP->portSem);
420 PortP->MagicFlags &= ~MAGIC_REBOOT;
425 ** As mentioned above, this is a tacky hack to cope
428 if (PortP->WflushFlag) {
429 rio_dprintk(RIO_DEBUG_INTR, "Want to WFLUSH mark this port\n");
432 rio_dprintk(RIO_DEBUG_INTR, "FAILS - PORT IS IN USE\n");
435 while (PortP->WflushFlag && can_add_transmit(&PacketP, PortP) && (PortP->InUse == NOT_INUSE)) {
437 struct PktCmd *PktCmdP;
439 rio_dprintk(RIO_DEBUG_INTR, "Add WFLUSH marker to data queue\n");
441 ** make it look just like a WFLUSH command
443 PktCmdP = (struct PktCmd *) &PacketP->data[0];
445 writeb(WFLUSH, &PktCmdP->Command);
447 p = PortP->HostPort % (u16) PORTS_PER_RTA;
450 ** If second block of ports for 16 port RTA, add 8
453 if (PortP->SecondBlock)
456 writeb(p, &PktCmdP->PhbNum);
459 ** to make debuggery easier
461 writeb('W', &PacketP->data[2]);
462 writeb('F', &PacketP->data[3]);
463 writeb('L', &PacketP->data[4]);
464 writeb('U', &PacketP->data[5]);
465 writeb('S', &PacketP->data[6]);
466 writeb('H', &PacketP->data[7]);
467 writeb(' ', &PacketP->data[8]);
468 writeb('0' + PortP->WflushFlag, &PacketP->data[9]);
469 writeb(' ', &PacketP->data[10]);
470 writeb(' ', &PacketP->data[11]);
471 writeb('\0', &PacketP->data[12]);
474 ** its two bytes long!
476 writeb(PKT_CMD_BIT | 2, &PacketP->len);
481 if (!(PortP->State & RIO_DELETED)) {
484 ** Count chars tx'd for port statistics reporting
486 if (PortP->statsGather)
490 if (--(PortP->WflushFlag) == 0) {
491 PortP->MagicFlags &= ~MAGIC_FLUSH;
494 rio_dprintk(RIO_DEBUG_INTR, "Wflush count now stands at %d\n", PortP->WflushFlag);
496 if (PortP->MagicFlags & MORE_OUTPUT_EYGOR) {
497 if (PortP->MagicFlags & MAGIC_FLUSH) {
498 PortP->MagicFlags |= MORE_OUTPUT_EYGOR;
500 if (!can_add_transmit(&PacketP, PortP)) {
501 rio_spin_unlock(&PortP->portSem);
504 rio_spin_unlock(&PortP->portSem);
505 RIOTxEnable((char *) PortP);
506 rio_spin_lock(&PortP->portSem);
507 PortP->MagicFlags &= ~MORE_OUTPUT_EYGOR;
514 ** If we can't add anything to the transmit queue, then
515 ** we need do none of the remaining processing.
517 if (!can_add_transmit(&PacketP, PortP)) {
518 rio_spin_unlock(&PortP->portSem);
522 rio_spin_unlock(&PortP->portSem);
523 RIOTxEnable((char *) PortP);
529 ** Routine for handling received data for tty drivers
531 static void RIOReceive(struct rio_info *p, struct Port *PortP)
533 struct tty_struct *TtyP;
534 unsigned short transCount;
536 register unsigned int DataCnt;
541 static int intCount, RxIntCnt;
544 ** The receive data process is to remove packets from the
545 ** PHB until there aren't any more or the current cblock
546 ** is full. When this occurs, there will be some left over
547 ** data in the packet, that we must do something with.
548 ** As we haven't unhooked the packet from the read list
549 ** yet, we can just leave the packet there, having first
550 ** made a note of how far we got. This means that we need
551 ** a pointer per port saying where we start taking the
552 ** data from - this will normally be zero, but when we
553 ** run out of space it will be set to the offset of the
554 ** next byte to copy from the packet data area. The packet
555 ** length field is decremented by the number of bytes that
556 ** we succesfully removed from the packet. When this reaches
557 ** zero, we reset the offset pointer to be zero, and free
558 ** the packet from the front of the queue.
563 TtyP = PortP->gs.tty;
565 rio_dprintk(RIO_DEBUG_INTR, "RIOReceive: tty is null. \n");
569 if (PortP->State & RIO_THROTTLE_RX) {
570 rio_dprintk(RIO_DEBUG_INTR, "RIOReceive: Throttled. Can't handle more input.\n");
574 if (PortP->State & RIO_DELETED) {
575 while (can_remove_receive(&PacketP, PortP)) {
576 remove_receive(PortP);
577 put_free_end(PortP->HostP, PacketP);
581 ** loop, just so long as:
582 ** i ) there's some data ( i.e. can_remove_receive )
583 ** ii ) we haven't been blocked
584 ** iii ) there's somewhere to put the data
585 ** iv ) we haven't outstayed our welcome
588 while (can_remove_receive(&PacketP, PortP)
593 ** check that it is not a command!
595 if (PacketP->len & PKT_CMD_BIT) {
596 rio_dprintk(RIO_DEBUG_INTR, "RIO: unexpected command packet received on PHB\n");
597 /* rio_dprint(RIO_DEBUG_INTR, (" sysport = %d\n", p->RIOPortp->PortNum)); */
598 rio_dprintk(RIO_DEBUG_INTR, " dest_unit = %d\n", PacketP->dest_unit);
599 rio_dprintk(RIO_DEBUG_INTR, " dest_port = %d\n", PacketP->dest_port);
600 rio_dprintk(RIO_DEBUG_INTR, " src_unit = %d\n", PacketP->src_unit);
601 rio_dprintk(RIO_DEBUG_INTR, " src_port = %d\n", PacketP->src_port);
602 rio_dprintk(RIO_DEBUG_INTR, " len = %d\n", PacketP->len);
603 rio_dprintk(RIO_DEBUG_INTR, " control = %d\n", PacketP->control);
604 rio_dprintk(RIO_DEBUG_INTR, " csum = %d\n", PacketP->csum);
605 rio_dprintk(RIO_DEBUG_INTR, " data bytes: ");
606 for (DataCnt = 0; DataCnt < PKT_MAX_DATA_LEN; DataCnt++)
607 rio_dprintk(RIO_DEBUG_INTR, "%d\n", PacketP->data[DataCnt]);
608 remove_receive(PortP);
609 put_free_end(PortP->HostP, PacketP);
610 continue; /* with next packet */
614 ** How many characters can we move 'upstream' ?
616 ** Determine the minimum of the amount of data
617 ** available and the amount of space in which to
620 ** 1. Get the packet length by masking 'len'
621 ** for only the length bits.
622 ** 2. Available space is [buffer size] - [space used]
624 ** Transfer count is the minimum of packet length
625 ** and available space.
628 transCount = tty_buffer_request_room(TtyP, PacketP->len & PKT_LEN_MASK);
629 rio_dprintk(RIO_DEBUG_REC, "port %d: Copy %d bytes\n", PortP->PortNum, transCount);
631 ** To use the following 'kkprintfs' for debugging - change the '#undef'
632 ** to '#define', (this is the only place ___DEBUG_IT___ occurs in the
635 ptr = (unsigned char *) PacketP->data + PortP->RxDataStart;
637 tty_prepare_flip_string(TtyP, &buf, transCount);
638 rio_memcpy_fromio(buf, ptr, transCount);
639 PortP->RxDataStart += transCount;
640 PacketP->len -= transCount;
641 copied += transCount;
645 if (PacketP->len == 0) {
647 ** If we have emptied the packet, then we can
648 ** free it, and reset the start pointer for
651 remove_receive(PortP);
652 put_free_end(PortP->HostP, PacketP);
653 PortP->RxDataStart = 0;
658 rio_dprintk(RIO_DEBUG_REC, "port %d: pushing tty flip buffer: %d total bytes copied.\n", PortP->PortNum, copied);
659 tty_flip_buffer_push(TtyP);