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:47
26 ** Retrieved : 11/6/98 10:33:50
28 ** ident @(#)riotty.c 1.3
30 ** -----------------------------------------------------------------------------
33 static char *_riotty_c_sccs_ = "@(#)riotty.c 1.3";
37 #define __EXPLICIT_DEF_H__
39 #include <linux/module.h>
40 #include <linux/slab.h>
41 #include <linux/errno.h>
42 #include <linux/tty.h>
43 #include <linux/string.h>
45 #include <asm/system.h>
46 #include <asm/string.h>
47 #include <asm/semaphore.h>
48 #include <asm/uaccess.h>
50 #include <linux/termios.h>
52 #include <linux/serial.h>
54 #include <linux/generic_serial.h>
57 #include "linux_compat.h"
58 #include "rio_linux.h"
92 static void RIOClearUp(struct Port *PortP);
93 int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg);
96 extern int conv_vb[]; /* now defined in ttymgr.c */
97 extern int conv_bv[]; /* now defined in ttymgr.c */
100 ** 16.09.1998 ARG - Fix to build riotty.k.o for Modular Kernel Support
102 ** ep.def.h is necessary for Modular Kernel Support
103 ** DO NOT place any kernel 'extern's after this line
104 ** or this source file will not build riotty.k.o
111 static struct old_sgttyb default_sg = {
112 B19200, B19200, /* input and output speed */
113 'H' - '@', /* erase char */
114 -1, /* 2nd erase char */
115 'U' - '@', /* kill char */
116 ECHO | CRMOD, /* mode */
117 'C' - '@', /* interrupt character */
118 '\\' - '@', /* quit char */
119 'Q' - '@', /* start char */
120 'S' - '@', /* stop char */
123 (LCRTBS | LCRTERA | LCRTKIL | LCTLECH), /* local mode word */
124 'Z' - '@', /* process stop */
125 'Y' - '@', /* delayed stop */
126 'R' - '@', /* reprint line */
127 'O' - '@', /* flush output */
128 'W' - '@', /* word erase */
129 'V' - '@' /* literal next char */
134 extern struct rio_info *p;
137 int riotopen(struct tty_struct *tty, struct file *filp)
139 unsigned int SysPort;
141 int repeat_this = 250;
142 struct Port *PortP; /* pointer to the port structure */
148 /* Make sure driver_data is NULL in case the rio isn't booted jet. Else gs_close
151 tty->driver_data = NULL;
153 SysPort = rio_minor(tty);
154 Modem = rio_ismodem(tty);
157 rio_dprintk(RIO_DEBUG_TTY, "System initialisation failed\n");
162 rio_dprintk(RIO_DEBUG_TTY, "port open SysPort %d (%s) (mapped:%d)\n", SysPort, Modem ? "Modem" : "tty", p->RIOPortp[SysPort]->Mapped);
165 ** Validate that we have received a legitimate request.
166 ** Currently, just check that we are opening a port on
167 ** a host card that actually exists, and that the port
168 ** has been mapped onto a host.
170 if (SysPort >= RIO_PORTS) { /* out of range ? */
171 rio_dprintk(RIO_DEBUG_TTY, "Illegal port number %d\n", SysPort);
177 ** Grab pointer to the port stucture
179 PortP = p->RIOPortp[SysPort]; /* Get control struc */
180 rio_dprintk(RIO_DEBUG_TTY, "PortP: %p\n", PortP);
181 if (!PortP->Mapped) { /* we aren't mapped yet! */
183 ** The system doesn't know which RTA this port
186 rio_dprintk(RIO_DEBUG_TTY, "port not mapped into system\n");
191 tty->driver_data = PortP;
196 rio_dprintk(RIO_DEBUG_TTY, "%d bytes in tx buffer\n", PortP->gs.xmit_cnt);
198 retval = gs_init_port(&PortP->gs);
204 ** If the host hasn't been booted yet, then
207 if ((PortP->HostP->Flags & RUN_STATE) != RC_RUNNING) {
208 rio_dprintk(RIO_DEBUG_TTY, "Host not running\n");
214 ** If the RTA has not booted yet and the user has choosen to block
215 ** until the RTA is present then we must spin here waiting for
218 /* I find the above code a bit hairy. I find the below code
219 easier to read and shorter. Now, if it works too that would
222 rio_dprintk(RIO_DEBUG_TTY, "Checking if RTA has booted... \n");
223 while (!(PortP->HostP->Mapping[PortP->RupNum].Flags & RTA_BOOTED)) {
224 if (!PortP->WaitUntilBooted) {
225 rio_dprintk(RIO_DEBUG_TTY, "RTA never booted\n");
230 /* Under Linux you'd normally use a wait instead of this
231 busy-waiting. I'll stick with the old implementation for
234 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
235 rio_dprintk(RIO_DEBUG_TTY, "RTA_wait_for_boot: EINTR in delay \n");
239 if (repeat_this-- <= 0) {
240 rio_dprintk(RIO_DEBUG_TTY, "Waiting for RTA to boot timeout\n");
245 rio_dprintk(RIO_DEBUG_TTY, "RTA has been booted\n");
246 rio_spin_lock_irqsave(&PortP->portSem, flags);
252 ** If the port is in the final throws of being closed,
253 ** we should wait here (politely), waiting
254 ** for it to finish, so that it doesn't close us!
256 while ((PortP->State & RIO_CLOSING) && !p->RIOHalted) {
257 rio_dprintk(RIO_DEBUG_TTY, "Waiting for RIO_CLOSING to go away\n");
258 if (repeat_this-- <= 0) {
259 rio_dprintk(RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
260 RIOPreemptiveCmd(p, PortP, FCLOSE);
264 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
265 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
266 rio_spin_lock_irqsave(&PortP->portSem, flags);
270 rio_spin_lock_irqsave(&PortP->portSem, flags);
273 if (!PortP->Mapped) {
274 rio_dprintk(RIO_DEBUG_TTY, "Port unmapped while closing!\n");
275 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
286 ** 15.10.1998 ARG - ESIL 0761 part fix
287 ** RIO has it's own CTSFLOW and RTSFLOW flags in 'Config' in the port structure,
288 ** we need to make sure that the flags are clear when the port is opened.
290 /* Uh? Suppose I turn these on and then another process opens
291 the port again? The flags get cleared! Not good. -- REW */
292 if (!(PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
293 PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW);
296 if (!(PortP->firstOpen)) { /* First time ? */
297 rio_dprintk(RIO_DEBUG_TTY, "First open for this port\n");
301 PortP->CookMode = 0; /* XXX RIOCookMode(tp); */
302 PortP->InUse = NOT_INUSE;
304 /* Tentative fix for bug PR27. Didn't work. */
305 /* PortP->gs.xmit_cnt = 0; */
307 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
309 ttyseth(PortP, tp, (struct old_sgttyb *) &default_sg);
312 /* Someone explain to me why this delay/config is
313 here. If I read the docs correctly the "open"
314 command piggybacks the parameters immediately.
316 RIOParam(PortP, OPEN, Modem, OK_TO_SLEEP); /* Open the port */
317 rio_spin_lock_irqsave(&PortP->portSem, flags);
320 ** wait for the port to be not closed.
322 while (!(PortP->PortState & PORT_ISOPEN) && !p->RIOHalted) {
323 rio_dprintk(RIO_DEBUG_TTY, "Waiting for PORT_ISOPEN-currently %x\n", PortP->PortState);
325 ** 15.10.1998 ARG - ESIL 0759
326 ** (Part) fix for port being trashed when opened whilst RTA "disconnected"
327 ** Take out the limited wait - now wait for ever or until user
330 if (repeat_this -- <= 0) {
331 rio_dprint(RIO_DEBUG_TTY, ("Waiting for open to finish timed out.\n"));
332 RIOPreemptiveCmd(p, PortP, FCLOSE );
333 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
338 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
339 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
340 rio_dprintk(RIO_DEBUG_TTY, "Waiting for open to finish broken by signal\n");
341 RIOPreemptiveCmd(p, PortP, FCLOSE);
345 rio_spin_lock_irqsave(&PortP->portSem, flags);
351 /* RIOClearUp( PortP ); */
352 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
355 rio_dprintk(RIO_DEBUG_TTY, "PORT_ISOPEN found\n");
359 rio_dprintk(RIO_DEBUG_TTY, "Modem - test for carrier\n");
362 ** insert test for carrier here. -- ???
363 ** I already see that test here. What's the deal? -- REW
365 if ((PortP->gs.tty->termios->c_cflag & CLOCAL) || (PortP->ModemState & MSVR1_CD)) {
366 rio_dprintk(RIO_DEBUG_TTY, "open(%d) Modem carr on\n", SysPort);
368 tp->tm.c_state |= CARR_ON;
369 wakeup((caddr_t) &tp->tm.c_canq);
371 PortP->State |= RIO_CARR_ON;
372 wake_up_interruptible(&PortP->gs.open_wait);
373 } else { /* no carrier - wait for DCD */
376 while (!(PortP->gs.tty->termios->c_state & CARR_ON) &&
377 !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted )
379 while (!(PortP->State & RIO_CARR_ON) && !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted) {
381 rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr on\n", SysPort);
383 PortP->gs.tty->termios->c_state |= WOPEN;
385 PortP->State |= RIO_WOPEN;
386 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
387 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL)
390 ** ACTION: verify that this is a good thing
391 ** to do here. -- ???
392 ** I think it's OK. -- REW
394 rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr broken by signal\n", SysPort);
395 RIOPreemptiveCmd(p, PortP, FCLOSE);
397 tp->tm.c_state &= ~WOPEN;
399 PortP->State &= ~RIO_WOPEN;
400 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
405 PortP->State &= ~RIO_WOPEN;
409 rio_dprintk(RIO_DEBUG_TTY, "Setting RIO_MOPEN\n");
410 PortP->State |= RIO_MOPEN;
416 ** Direct line open - force carrier (will probably mean
417 ** that sleeping Modem line fubar)
419 PortP->State |= RIO_LOPEN;
426 rio_dprintk(RIO_DEBUG_TTY, "high level open done\n");
429 ** Count opens for port statistics reporting
431 if (PortP->statsGather)
434 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
435 rio_dprintk(RIO_DEBUG_TTY, "Returning from open\n");
441 ** RIOClose the port.
442 ** The operating system thinks that this is last close for the device.
443 ** As there are two interfaces to the port (Modem and tty), we need to
444 ** check that both are closed before we close the device.
446 int riotclose(void *ptr)
448 struct Port *PortP = ptr; /* pointer to the port structure */
450 int try = -1; /* Disable the timeouts by setting them to -1 */
451 int repeat_this = -1; /* Congrats to those having 15 years of
452 uptime! (You get to break the driver.) */
453 unsigned long end_time;
454 struct tty_struct *tty;
459 rio_dprintk(RIO_DEBUG_TTY, "port close SysPort %d\n", PortP->PortNum);
461 /* PortP = p->RIOPortp[SysPort]; */
462 rio_dprintk(RIO_DEBUG_TTY, "Port is at address 0x%p\n", PortP);
463 /* tp = PortP->TtyP; *//* Get tty */
465 rio_dprintk(RIO_DEBUG_TTY, "TTY is at address 0x%p\n", tty);
467 if (PortP->gs.closing_wait)
468 end_time = jiffies + PortP->gs.closing_wait;
470 end_time = jiffies + MAX_SCHEDULE_TIMEOUT;
472 Modem = rio_ismodem(tty);
473 rio_spin_lock_irqsave(&PortP->portSem, flags);
476 ** Setting this flag will make any process trying to open
477 ** this port block until we are complete closing it.
479 PortP->State |= RIO_CLOSING;
481 if ((PortP->State & RIO_DELETED)) {
482 rio_dprintk(RIO_DEBUG_TTY, "Close on deleted RTA\n");
492 rio_dprintk(RIO_DEBUG_TTY, "Clear bits\n");
494 ** clear the open bits for this device
496 PortP->State &= (Modem ? ~RIO_MOPEN : ~RIO_LOPEN);
497 PortP->State &= ~RIO_CARR_ON;
498 PortP->ModemState &= ~MSVR1_CD;
500 ** If the device was open as both a Modem and a tty line
501 ** then we need to wimp out here, as the port has not really
502 ** been finally closed (gee, whizz!) The test here uses the
503 ** bit for the OTHER mode of operation, to see if THAT is
506 if ((PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
508 ** The port is still open for the other task -
509 ** return, pretending that we are still active.
511 rio_dprintk(RIO_DEBUG_TTY, "Channel %d still open !\n", PortP->PortNum);
512 PortP->State &= ~RIO_CLOSING;
513 if (PortP->firstOpen)
515 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
519 rio_dprintk(RIO_DEBUG_TTY, "Closing down - everything must go!\n");
521 PortP->State &= ~RIO_DYNOROD;
524 ** This is where we wait for the port
525 ** to drain down before closing. Bye-bye....
526 ** (We never meant to do this)
528 rio_dprintk(RIO_DEBUG_TTY, "Timeout 1 starts\n");
531 while ((PortP->InUse != NOT_INUSE) && !p->RIOHalted && (PortP->TxBufferIn != PortP->TxBufferOut)) {
532 if (repeat_this-- <= 0) {
534 rio_dprintk(RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
535 RIOPreemptiveCmd(p, PortP, FCLOSE);
538 rio_dprintk(RIO_DEBUG_TTY, "Calling timeout to flush in closing\n");
539 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
540 if (RIODelay_ni(PortP, HUNDRED_MS * 10) == RIO_FAIL) {
541 rio_dprintk(RIO_DEBUG_TTY, "RTA EINTR in delay \n");
543 rio_spin_lock_irqsave(&PortP->portSem, flags);
546 rio_spin_lock_irqsave(&PortP->portSem, flags);
549 PortP->TxBufferIn = PortP->TxBufferOut = 0;
553 if ((PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
555 ** The port has been re-opened for the other task -
556 ** return, pretending that we are still active.
558 rio_dprintk(RIO_DEBUG_TTY, "Channel %d re-open!\n", PortP->PortNum);
559 PortP->State &= ~RIO_CLOSING;
560 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
561 if (PortP->firstOpen)
571 /* Can't call RIOShortCommand with the port locked. */
572 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
574 if (RIOShortCommand(p, PortP, CLOSE, 1, 0) == RIO_FAIL) {
575 RIOPreemptiveCmd(p, PortP, FCLOSE);
580 while (try && (PortP->PortState & PORT_ISOPEN)) {
582 if (time_after(jiffies, end_time)) {
583 rio_dprintk(RIO_DEBUG_TTY, "Run out of tries - force the bugger shut!\n");
584 RIOPreemptiveCmd(p, PortP, FCLOSE);
587 rio_dprintk(RIO_DEBUG_TTY, "Close: PortState:ISOPEN is %d\n", PortP->PortState & PORT_ISOPEN);
593 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
594 rio_dprintk(RIO_DEBUG_TTY, "RTA EINTR in delay \n");
595 RIOPreemptiveCmd(p, PortP, FCLOSE);
599 rio_spin_lock_irqsave(&PortP->portSem, flags);
600 rio_dprintk(RIO_DEBUG_TTY, "Close: try was %d on completion\n", try);
602 /* RIOPreemptiveCmd(p, PortP, FCLOSE); */
605 ** 15.10.1998 ARG - ESIL 0761 part fix
606 ** RIO has it's own CTSFLOW and RTSFLOW flags in 'Config' in the port structure,** we need to make sure that the flags are clear when the port is opened.
608 PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW);
611 ** Count opens for port statistics reporting
613 if (PortP->statsGather)
617 /* XXX: Why would a "DELETED" flag be reset here? I'd have
618 thought that a "deleted" flag means that the port was
619 permanently gone, but here we can make it reappear by it
620 being in close during the "deletion".
622 PortP->State &= ~(RIO_CLOSING | RIO_DELETED);
623 if (PortP->firstOpen)
625 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
626 rio_dprintk(RIO_DEBUG_TTY, "Return from close\n");
632 static void RIOClearUp(PortP)
635 rio_dprintk(RIO_DEBUG_TTY, "RIOHalted set\n");
636 PortP->Config = 0; /* Direct semaphore */
637 PortP->PortState = 0;
638 PortP->firstOpen = 0;
639 PortP->FlushCmdBodge = 0;
640 PortP->ModemState = PortP->CookMode = 0;
642 PortP->WflushFlag = 0;
643 PortP->MagicFlags = 0;
644 PortP->RxDataStart = 0;
645 PortP->TxBufferIn = 0;
646 PortP->TxBufferOut = 0;
650 ** Put a command onto a port.
651 ** The PortPointer, command, length and arg are passed.
652 ** The len is the length *inclusive* of the command byte,
653 ** and so for a command that takes no data, len==1.
654 ** The arg is a single byte, and is only used if len==2.
655 ** Other values of len aren't allowed, and will cause
658 int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg)
661 int retries = 20; /* at 10 per second -> 2 seconds */
664 rio_dprintk(RIO_DEBUG_TTY, "entering shortcommand.\n");
666 if (PortP->State & RIO_DELETED) {
667 rio_dprintk(RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n");
670 rio_spin_lock_irqsave(&PortP->portSem, flags);
673 ** If the port is in use for pre-emptive command, then wait for it to
676 while ((PortP->InUse != NOT_INUSE) && !p->RIOHalted) {
677 rio_dprintk(RIO_DEBUG_TTY, "Waiting for not in use (%d)\n", retries);
678 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
679 if (retries-- <= 0) {
682 if (RIODelay_ni(PortP, HUNDRED_MS) == RIO_FAIL) {
685 rio_spin_lock_irqsave(&PortP->portSem, flags);
687 if (PortP->State & RIO_DELETED) {
688 rio_dprintk(RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n");
689 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
693 while (!can_add_transmit(&PacketP, PortP) && !p->RIOHalted) {
694 rio_dprintk(RIO_DEBUG_TTY, "Waiting to add short command to queue (%d)\n", retries);
695 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
696 if (retries-- <= 0) {
697 rio_dprintk(RIO_DEBUG_TTY, "out of tries. Failing\n");
700 if (RIODelay_ni(PortP, HUNDRED_MS) == RIO_FAIL) {
703 rio_spin_lock_irqsave(&PortP->portSem, flags);
707 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
712 ** set the command byte and the argument byte
714 writeb(command, &PacketP->data[0]);
717 writeb(arg, &PacketP->data[1]);
720 ** set the length of the packet and set the command bit.
722 writeb(PKT_CMD_BIT | len, &PacketP->len);
726 ** Count characters transmitted for port statistics reporting
728 if (PortP->statsGather)
729 PortP->txchars += len;
731 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
732 return p->RIOHalted ? RIO_FAIL : ~RIO_FAIL;