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"
83 static void RIOReceive(struct rio_info
*, struct Port
*);
86 static char *firstchars(char *p
, int nch
)
88 static char buf
[2][128];
91 memcpy(buf
[t
], p
, nch
);
97 #define INCR( P, I ) ((P) = (((P)+(I)) & p->RIOBufferMask))
98 /* Enable and start the transmission of packets */
99 void RIOTxEnable(char *en
)
103 struct tty_struct
*tty
;
105 struct PKT __iomem
*PacketP
;
108 PortP
= (struct Port
*) en
;
109 p
= (struct rio_info
*) PortP
->p
;
113 rio_dprintk(RIO_DEBUG_INTR
, "tx port %d: %d chars queued.\n", PortP
->PortNum
, PortP
->gs
.xmit_cnt
);
115 if (!PortP
->gs
.xmit_cnt
)
119 /* This routine is an order of magnitude simpler than the specialix
120 version. One of the disadvantages is that this version will send
121 an incomplete packet (usually 64 bytes instead of 72) once for
122 every 4k worth of data. Let's just say that this won't influence
123 performance significantly..... */
125 rio_spin_lock_irqsave(&PortP
->portSem
, flags
);
127 while (can_add_transmit(&PacketP
, PortP
)) {
128 c
= PortP
->gs
.xmit_cnt
;
129 if (c
> PKT_MAX_DATA_LEN
)
130 c
= PKT_MAX_DATA_LEN
;
132 /* Don't copy past the end of the source buffer */
133 if (c
> SERIAL_XMIT_SIZE
- PortP
->gs
.xmit_tail
)
134 c
= SERIAL_XMIT_SIZE
- PortP
->gs
.xmit_tail
;
138 t
= (c
> 10) ? 10 : c
;
140 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
));
142 /* If for one reason or another, we can't copy more data,
147 rio_memcpy_toio(PortP
->HostP
->Caddr
, PacketP
->data
, PortP
->gs
.xmit_buf
+ PortP
->gs
.xmit_tail
, c
);
150 writeb(c
, &(PacketP
->len
));
151 if (!(PortP
->State
& RIO_DELETED
)) {
154 ** Count chars tx'd for port statistics reporting
156 if (PortP
->statsGather
)
159 PortP
->gs
.xmit_tail
= (PortP
->gs
.xmit_tail
+ c
) & (SERIAL_XMIT_SIZE
- 1);
160 PortP
->gs
.xmit_cnt
-= c
;
163 rio_spin_unlock_irqrestore(&PortP
->portSem
, flags
);
165 if (PortP
->gs
.xmit_cnt
<= (PortP
->gs
.wakeup_chars
+ 2 * PKT_MAX_DATA_LEN
)) {
166 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
);
167 if ((PortP
->gs
.tty
->flags
& (1 << TTY_DO_WRITE_WAKEUP
)) && PortP
->gs
.tty
->ldisc
.write_wakeup
)
168 (PortP
->gs
.tty
->ldisc
.write_wakeup
) (PortP
->gs
.tty
);
169 rio_dprintk(RIO_DEBUG_INTR
, "(%d/%d)\n", PortP
->gs
.wakeup_chars
, PortP
->gs
.xmit_cnt
);
170 wake_up_interruptible(&PortP
->gs
.tty
->write_wait
);
177 ** RIO Host Service routine. Does all the work traditionally associated with an
184 void RIOServiceHost(struct rio_info
*p
, struct Host
*HostP
)
186 rio_spin_lock(&HostP
->HostLock
);
187 if ((HostP
->Flags
& RUN_STATE
) != RC_RUNNING
) {
189 rio_spin_unlock(&HostP
->HostLock
);
190 if ((t
++ % 200) == 0)
191 rio_dprintk(RIO_DEBUG_INTR
, "Interrupt but host not running. flags=%x.\n", (int) HostP
->Flags
);
194 rio_spin_unlock(&HostP
->HostLock
);
196 if (readw(&HostP
->ParmMapP
->rup_intr
)) {
197 writew(0, &HostP
->ParmMapP
->rup_intr
);
200 rio_dprintk(RIO_DEBUG_INTR
, "rio: RUP interrupt on host %Zd\n", HostP
- p
->RIOHosts
);
201 RIOPollHostCommands(p
, HostP
);
204 if (readw(&HostP
->ParmMapP
->rx_intr
)) {
207 writew(0, &HostP
->ParmMapP
->rx_intr
);
211 rio_dprintk(RIO_DEBUG_INTR
, "rio: RX interrupt on host %Zd\n", HostP
- p
->RIOHosts
);
213 ** Loop through every port. If the port is mapped into
214 ** the system ( i.e. has /dev/ttyXXXX associated ) then it is
215 ** worth checking. If the port isn't open, grab any packets
216 ** hanging on its receive queue and stuff them on the free
217 ** list; check for commands on the way.
219 for (port
= p
->RIOFirstPortsBooted
; port
< p
->RIOLastPortsBooted
+ PORTS_PER_RTA
; port
++) {
220 struct Port
*PortP
= p
->RIOPortp
[port
];
221 struct tty_struct
*ttyP
;
222 struct PKT __iomem
*PacketP
;
225 ** not mapped in - most of the RIOPortp[] information
226 ** has not been set up!
227 ** Optimise: ports come in bundles of eight.
229 if (!PortP
->Mapped
) {
231 continue; /* with the next port */
235 ** If the host board isn't THIS host board, check the next one.
236 ** optimise: ports come in bundles of eight.
238 if (PortP
->HostP
!= HostP
) {
244 ** Let us see - is the port open? If not, then don't service it.
246 if (!(PortP
->PortState
& PORT_ISOPEN
)) {
251 ** find corresponding tty structure. The process of mapping
252 ** the ports puts these here.
254 ttyP
= PortP
->gs
.tty
;
257 ** Lock the port before we begin working on it.
259 rio_spin_lock(&PortP
->portSem
);
262 ** Process received data if there is any.
264 if (can_remove_receive(&PacketP
, PortP
))
265 RIOReceive(p
, PortP
);
268 ** If there is no data left to be read from the port, and
269 ** it's handshake bit is set, then we must clear the handshake,
270 ** so that that downstream RTA is re-enabled.
272 if (!can_remove_receive(&PacketP
, PortP
) && (readw(&PortP
->PhbP
->handshake
) == PHB_HANDSHAKE_SET
)) {
274 ** MAGIC! ( Basically, handshake the RX buffer, so that
275 ** the RTAs upstream can be re-enabled. )
277 rio_dprintk(RIO_DEBUG_INTR
, "Set RX handshake bit\n");
278 writew(PHB_HANDSHAKE_SET
| PHB_HANDSHAKE_RESET
, &PortP
->PhbP
->handshake
);
280 rio_spin_unlock(&PortP
->portSem
);
284 if (readw(&HostP
->ParmMapP
->tx_intr
)) {
287 writew(0, &HostP
->ParmMapP
->tx_intr
);
291 rio_dprintk(RIO_DEBUG_INTR
, "rio: TX interrupt on host %Zd\n", HostP
- p
->RIOHosts
);
294 ** Loop through every port.
295 ** If the port is mapped into the system ( i.e. has /dev/ttyXXXX
296 ** associated ) then it is worth checking.
298 for (port
= p
->RIOFirstPortsBooted
; port
< p
->RIOLastPortsBooted
+ PORTS_PER_RTA
; port
++) {
299 struct Port
*PortP
= p
->RIOPortp
[port
];
300 struct tty_struct
*ttyP
;
301 struct PKT __iomem
*PacketP
;
304 ** not mapped in - most of the RIOPortp[] information
305 ** has not been set up!
307 if (!PortP
->Mapped
) {
309 continue; /* with the next port */
313 ** If the host board isn't running, then its data structures
314 ** are no use to us - continue quietly.
316 if (PortP
->HostP
!= HostP
) {
318 continue; /* with the next port */
322 ** Let us see - is the port open? If not, then don't service it.
324 if (!(PortP
->PortState
& PORT_ISOPEN
)) {
328 rio_dprintk(RIO_DEBUG_INTR
, "rio: Looking into port %d.\n", port
);
330 ** Lock the port before we begin working on it.
332 rio_spin_lock(&PortP
->portSem
);
335 ** If we can't add anything to the transmit queue, then
336 ** we need do none of this processing.
338 if (!can_add_transmit(&PacketP
, PortP
)) {
339 rio_dprintk(RIO_DEBUG_INTR
, "Can't add to port, so skipping.\n");
340 rio_spin_unlock(&PortP
->portSem
);
345 ** find corresponding tty structure. The process of mapping
346 ** the ports puts these here.
348 ttyP
= PortP
->gs
.tty
;
349 /* If ttyP is NULL, the port is getting closed. Forget about it. */
351 rio_dprintk(RIO_DEBUG_INTR
, "no tty, so skipping.\n");
352 rio_spin_unlock(&PortP
->portSem
);
356 ** If there is more room available we start up the transmit
357 ** data process again. This can be direct I/O, if the cookmode
358 ** is set to COOK_RAW or COOK_MEDIUM, or will be a call to the
359 ** riotproc( T_OUTPUT ) if we are in COOK_WELL mode, to fetch
360 ** characters via the line discipline. We must always call
361 ** the line discipline,
362 ** so that user input characters can be echoed correctly.
365 ** With the advent of double buffering, we now see if
366 ** TxBufferOut-In is non-zero. If so, then we copy a packet
367 ** to the output place, and set it going. If this empties
368 ** the buffer, then we must issue a wakeup( ) on OUT.
369 ** If it frees space in the buffer then we must issue
370 ** a wakeup( ) on IN.
372 ** ++++ Extra! Extra! If PortP->WflushFlag is set, then we
373 ** have to send a WFLUSH command down the PHB, to mark the
374 ** end point of a WFLUSH. We also need to clear out any
375 ** data from the double buffer! ( note that WflushFlag is a
376 ** *count* of the number of WFLUSH commands outstanding! )
378 ** ++++ And there's more!
379 ** If an RTA is powered off, then on again, and rebooted,
380 ** whilst it has ports open, then we need to re-open the ports.
381 ** ( reasonable enough ). We can't do this when we spot the
382 ** re-boot, in interrupt time, because the queue is probably
383 ** full. So, when we come in here, we need to test if any
384 ** ports are in this condition, and re-open the port before
385 ** we try to send any more data to it. Now, the re-booted
386 ** RTA will be discarding packets from the PHB until it
387 ** receives this open packet, but don't worry tooo much
388 ** about that. The one thing that is interesting is the
389 ** combination of this effect and the WFLUSH effect!
391 /* For now don't handle RTA reboots. -- REW.
392 Reenabled. Otherwise RTA reboots didn't work. Duh. -- REW */
393 if (PortP
->MagicFlags
) {
394 if (PortP
->MagicFlags
& MAGIC_REBOOT
) {
396 ** well, the RTA has been rebooted, and there is room
397 ** on its queue to add the open packet that is required.
399 ** The messy part of this line is trying to decide if
400 ** we need to call the Param function as a tty or as
402 ** DONT USE CLOCAL AS A TEST FOR THIS!
404 ** If we can't param the port, then move on to the
407 PortP
->InUse
= NOT_INUSE
;
409 rio_spin_unlock(&PortP
->portSem
);
410 if (RIOParam(PortP
, OPEN
, ((PortP
->Cor2Copy
& (COR2_RTSFLOW
| COR2_CTSFLOW
)) == (COR2_RTSFLOW
| COR2_CTSFLOW
)) ? 1 : 0, DONT_SLEEP
) == RIO_FAIL
) {
411 continue; /* with next port */
413 rio_spin_lock(&PortP
->portSem
);
414 PortP
->MagicFlags
&= ~MAGIC_REBOOT
;
418 ** As mentioned above, this is a tacky hack to cope
421 if (PortP
->WflushFlag
) {
422 rio_dprintk(RIO_DEBUG_INTR
, "Want to WFLUSH mark this port\n");
425 rio_dprintk(RIO_DEBUG_INTR
, "FAILS - PORT IS IN USE\n");
428 while (PortP
->WflushFlag
&& can_add_transmit(&PacketP
, PortP
) && (PortP
->InUse
== NOT_INUSE
)) {
430 struct PktCmd __iomem
*PktCmdP
;
432 rio_dprintk(RIO_DEBUG_INTR
, "Add WFLUSH marker to data queue\n");
434 ** make it look just like a WFLUSH command
436 PktCmdP
= (struct PktCmd __iomem
*) &PacketP
->data
[0];
438 writeb(WFLUSH
, &PktCmdP
->Command
);
440 p
= PortP
->HostPort
% (u16
) PORTS_PER_RTA
;
443 ** If second block of ports for 16 port RTA, add 8
446 if (PortP
->SecondBlock
)
449 writeb(p
, &PktCmdP
->PhbNum
);
452 ** to make debuggery easier
454 writeb('W', &PacketP
->data
[2]);
455 writeb('F', &PacketP
->data
[3]);
456 writeb('L', &PacketP
->data
[4]);
457 writeb('U', &PacketP
->data
[5]);
458 writeb('S', &PacketP
->data
[6]);
459 writeb('H', &PacketP
->data
[7]);
460 writeb(' ', &PacketP
->data
[8]);
461 writeb('0' + PortP
->WflushFlag
, &PacketP
->data
[9]);
462 writeb(' ', &PacketP
->data
[10]);
463 writeb(' ', &PacketP
->data
[11]);
464 writeb('\0', &PacketP
->data
[12]);
467 ** its two bytes long!
469 writeb(PKT_CMD_BIT
| 2, &PacketP
->len
);
474 if (!(PortP
->State
& RIO_DELETED
)) {
477 ** Count chars tx'd for port statistics reporting
479 if (PortP
->statsGather
)
483 if (--(PortP
->WflushFlag
) == 0) {
484 PortP
->MagicFlags
&= ~MAGIC_FLUSH
;
487 rio_dprintk(RIO_DEBUG_INTR
, "Wflush count now stands at %d\n", PortP
->WflushFlag
);
489 if (PortP
->MagicFlags
& MORE_OUTPUT_EYGOR
) {
490 if (PortP
->MagicFlags
& MAGIC_FLUSH
) {
491 PortP
->MagicFlags
|= MORE_OUTPUT_EYGOR
;
493 if (!can_add_transmit(&PacketP
, PortP
)) {
494 rio_spin_unlock(&PortP
->portSem
);
497 rio_spin_unlock(&PortP
->portSem
);
498 RIOTxEnable((char *) PortP
);
499 rio_spin_lock(&PortP
->portSem
);
500 PortP
->MagicFlags
&= ~MORE_OUTPUT_EYGOR
;
507 ** If we can't add anything to the transmit queue, then
508 ** we need do none of the remaining processing.
510 if (!can_add_transmit(&PacketP
, PortP
)) {
511 rio_spin_unlock(&PortP
->portSem
);
515 rio_spin_unlock(&PortP
->portSem
);
516 RIOTxEnable((char *) PortP
);
522 ** Routine for handling received data for tty drivers
524 static void RIOReceive(struct rio_info
*p
, struct Port
*PortP
)
526 struct tty_struct
*TtyP
;
527 unsigned short transCount
;
528 struct PKT __iomem
*PacketP
;
529 register unsigned int DataCnt
;
530 unsigned char __iomem
*ptr
;
534 static int intCount
, RxIntCnt
;
537 ** The receive data process is to remove packets from the
538 ** PHB until there aren't any more or the current cblock
539 ** is full. When this occurs, there will be some left over
540 ** data in the packet, that we must do something with.
541 ** As we haven't unhooked the packet from the read list
542 ** yet, we can just leave the packet there, having first
543 ** made a note of how far we got. This means that we need
544 ** a pointer per port saying where we start taking the
545 ** data from - this will normally be zero, but when we
546 ** run out of space it will be set to the offset of the
547 ** next byte to copy from the packet data area. The packet
548 ** length field is decremented by the number of bytes that
549 ** we successfully removed from the packet. When this reaches
550 ** zero, we reset the offset pointer to be zero, and free
551 ** the packet from the front of the queue.
556 TtyP
= PortP
->gs
.tty
;
558 rio_dprintk(RIO_DEBUG_INTR
, "RIOReceive: tty is null. \n");
562 if (PortP
->State
& RIO_THROTTLE_RX
) {
563 rio_dprintk(RIO_DEBUG_INTR
, "RIOReceive: Throttled. Can't handle more input.\n");
567 if (PortP
->State
& RIO_DELETED
) {
568 while (can_remove_receive(&PacketP
, PortP
)) {
569 remove_receive(PortP
);
570 put_free_end(PortP
->HostP
, PacketP
);
574 ** loop, just so long as:
575 ** i ) there's some data ( i.e. can_remove_receive )
576 ** ii ) we haven't been blocked
577 ** iii ) there's somewhere to put the data
578 ** iv ) we haven't outstayed our welcome
581 while (can_remove_receive(&PacketP
, PortP
)
586 ** check that it is not a command!
588 if (readb(&PacketP
->len
) & PKT_CMD_BIT
) {
589 rio_dprintk(RIO_DEBUG_INTR
, "RIO: unexpected command packet received on PHB\n");
590 /* rio_dprint(RIO_DEBUG_INTR, (" sysport = %d\n", p->RIOPortp->PortNum)); */
591 rio_dprintk(RIO_DEBUG_INTR
, " dest_unit = %d\n", readb(&PacketP
->dest_unit
));
592 rio_dprintk(RIO_DEBUG_INTR
, " dest_port = %d\n", readb(&PacketP
->dest_port
));
593 rio_dprintk(RIO_DEBUG_INTR
, " src_unit = %d\n", readb(&PacketP
->src_unit
));
594 rio_dprintk(RIO_DEBUG_INTR
, " src_port = %d\n", readb(&PacketP
->src_port
));
595 rio_dprintk(RIO_DEBUG_INTR
, " len = %d\n", readb(&PacketP
->len
));
596 rio_dprintk(RIO_DEBUG_INTR
, " control = %d\n", readb(&PacketP
->control
));
597 rio_dprintk(RIO_DEBUG_INTR
, " csum = %d\n", readw(&PacketP
->csum
));
598 rio_dprintk(RIO_DEBUG_INTR
, " data bytes: ");
599 for (DataCnt
= 0; DataCnt
< PKT_MAX_DATA_LEN
; DataCnt
++)
600 rio_dprintk(RIO_DEBUG_INTR
, "%d\n", readb(&PacketP
->data
[DataCnt
]));
601 remove_receive(PortP
);
602 put_free_end(PortP
->HostP
, PacketP
);
603 continue; /* with next packet */
607 ** How many characters can we move 'upstream' ?
609 ** Determine the minimum of the amount of data
610 ** available and the amount of space in which to
613 ** 1. Get the packet length by masking 'len'
614 ** for only the length bits.
615 ** 2. Available space is [buffer size] - [space used]
617 ** Transfer count is the minimum of packet length
618 ** and available space.
621 transCount
= tty_buffer_request_room(TtyP
, readb(&PacketP
->len
) & PKT_LEN_MASK
);
622 rio_dprintk(RIO_DEBUG_REC
, "port %d: Copy %d bytes\n", PortP
->PortNum
, transCount
);
624 ** To use the following 'kkprintfs' for debugging - change the '#undef'
625 ** to '#define', (this is the only place ___DEBUG_IT___ occurs in the
628 ptr
= (unsigned char __iomem
*) PacketP
->data
+ PortP
->RxDataStart
;
630 tty_prepare_flip_string(TtyP
, &buf
, transCount
);
631 rio_memcpy_fromio(buf
, ptr
, transCount
);
632 PortP
->RxDataStart
+= transCount
;
633 writeb(readb(&PacketP
->len
)-transCount
, &PacketP
->len
);
634 copied
+= transCount
;
638 if (readb(&PacketP
->len
) == 0) {
640 ** If we have emptied the packet, then we can
641 ** free it, and reset the start pointer for
644 remove_receive(PortP
);
645 put_free_end(PortP
->HostP
, PacketP
);
646 PortP
->RxDataStart
= 0;
651 rio_dprintk(RIO_DEBUG_REC
, "port %d: pushing tty flip buffer: %d total bytes copied.\n", PortP
->PortNum
, copied
);
652 tty_flip_buffer_push(TtyP
);