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 #define __EXPLICIT_DEF_H__
35 #include <linux/module.h>
36 #include <linux/sched.h>
37 #include <linux/slab.h>
38 #include <linux/errno.h>
39 #include <linux/tty.h>
40 #include <linux/string.h>
42 #include <asm/system.h>
43 #include <asm/string.h>
44 #include <asm/uaccess.h>
46 #include <linux/termios.h>
48 #include <linux/serial.h>
50 #include <linux/generic_serial.h>
53 #include "linux_compat.h"
54 #include "rio_linux.h"
81 static void RIOClearUp(struct Port *PortP);
83 /* Below belongs in func.h */
84 int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg);
87 extern struct rio_info *p;
90 int riotopen(struct tty_struct *tty, struct file *filp)
93 int repeat_this = 250;
94 struct Port *PortP; /* pointer to the port structure */
100 /* Make sure driver_data is NULL in case the rio isn't booted jet. Else gs_close
103 tty->driver_data = NULL;
105 SysPort = rio_minor(tty);
108 rio_dprintk(RIO_DEBUG_TTY, "System initialisation failed\n");
113 rio_dprintk(RIO_DEBUG_TTY, "port open SysPort %d (mapped:%d)\n", SysPort, p->RIOPortp[SysPort]->Mapped);
116 ** Validate that we have received a legitimate request.
117 ** Currently, just check that we are opening a port on
118 ** a host card that actually exists, and that the port
119 ** has been mapped onto a host.
121 if (SysPort >= RIO_PORTS) { /* out of range ? */
122 rio_dprintk(RIO_DEBUG_TTY, "Illegal port number %d\n", SysPort);
128 ** Grab pointer to the port stucture
130 PortP = p->RIOPortp[SysPort]; /* Get control struc */
131 rio_dprintk(RIO_DEBUG_TTY, "PortP: %p\n", PortP);
132 if (!PortP->Mapped) { /* we aren't mapped yet! */
134 ** The system doesn't know which RTA this port
137 rio_dprintk(RIO_DEBUG_TTY, "port not mapped into system\n");
142 tty->driver_data = PortP;
144 PortP->gs.port.tty = tty;
145 PortP->gs.port.count++;
147 rio_dprintk(RIO_DEBUG_TTY, "%d bytes in tx buffer\n", PortP->gs.xmit_cnt);
149 retval = gs_init_port(&PortP->gs);
151 PortP->gs.port.count--;
155 ** If the host hasn't been booted yet, then
158 if ((PortP->HostP->Flags & RUN_STATE) != RC_RUNNING) {
159 rio_dprintk(RIO_DEBUG_TTY, "Host not running\n");
165 ** If the RTA has not booted yet and the user has choosen to block
166 ** until the RTA is present then we must spin here waiting for
169 /* I find the above code a bit hairy. I find the below code
170 easier to read and shorter. Now, if it works too that would
173 rio_dprintk(RIO_DEBUG_TTY, "Checking if RTA has booted... \n");
174 while (!(PortP->HostP->Mapping[PortP->RupNum].Flags & RTA_BOOTED)) {
175 if (!PortP->WaitUntilBooted) {
176 rio_dprintk(RIO_DEBUG_TTY, "RTA never booted\n");
181 /* Under Linux you'd normally use a wait instead of this
182 busy-waiting. I'll stick with the old implementation for
185 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
186 rio_dprintk(RIO_DEBUG_TTY, "RTA_wait_for_boot: EINTR in delay \n");
190 if (repeat_this-- <= 0) {
191 rio_dprintk(RIO_DEBUG_TTY, "Waiting for RTA to boot timeout\n");
196 rio_dprintk(RIO_DEBUG_TTY, "RTA has been booted\n");
197 rio_spin_lock_irqsave(&PortP->portSem, flags);
203 ** If the port is in the final throws of being closed,
204 ** we should wait here (politely), waiting
205 ** for it to finish, so that it doesn't close us!
207 while ((PortP->State & RIO_CLOSING) && !p->RIOHalted) {
208 rio_dprintk(RIO_DEBUG_TTY, "Waiting for RIO_CLOSING to go away\n");
209 if (repeat_this-- <= 0) {
210 rio_dprintk(RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
211 RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE);
215 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
216 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
217 rio_spin_lock_irqsave(&PortP->portSem, flags);
221 rio_spin_lock_irqsave(&PortP->portSem, flags);
224 if (!PortP->Mapped) {
225 rio_dprintk(RIO_DEBUG_TTY, "Port unmapped while closing!\n");
226 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
237 ** 15.10.1998 ARG - ESIL 0761 part fix
238 ** RIO has it's own CTSFLOW and RTSFLOW flags in 'Config' in the port structure,
239 ** we need to make sure that the flags are clear when the port is opened.
241 /* Uh? Suppose I turn these on and then another process opens
242 the port again? The flags get cleared! Not good. -- REW */
243 if (!(PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
244 PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW);
247 if (!(PortP->firstOpen)) { /* First time ? */
248 rio_dprintk(RIO_DEBUG_TTY, "First open for this port\n");
252 PortP->CookMode = 0; /* XXX RIOCookMode(tp); */
253 PortP->InUse = NOT_INUSE;
255 /* Tentative fix for bug PR27. Didn't work. */
256 /* PortP->gs.xmit_cnt = 0; */
258 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
260 /* Someone explain to me why this delay/config is
261 here. If I read the docs correctly the "open"
262 command piggybacks the parameters immediately.
264 RIOParam(PortP, RIOC_OPEN, 1, OK_TO_SLEEP); /* Open the port */
265 rio_spin_lock_irqsave(&PortP->portSem, flags);
268 ** wait for the port to be not closed.
270 while (!(PortP->PortState & PORT_ISOPEN) && !p->RIOHalted) {
271 rio_dprintk(RIO_DEBUG_TTY, "Waiting for PORT_ISOPEN-currently %x\n", PortP->PortState);
272 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
273 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
274 rio_dprintk(RIO_DEBUG_TTY, "Waiting for open to finish broken by signal\n");
275 RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE);
279 rio_spin_lock_irqsave(&PortP->portSem, flags);
285 /* RIOClearUp( PortP ); */
286 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
289 rio_dprintk(RIO_DEBUG_TTY, "PORT_ISOPEN found\n");
291 rio_dprintk(RIO_DEBUG_TTY, "Modem - test for carrier\n");
294 ** insert test for carrier here. -- ???
295 ** I already see that test here. What's the deal? -- REW
297 if ((PortP->gs.port.tty->termios->c_cflag & CLOCAL) ||
298 (PortP->ModemState & RIOC_MSVR1_CD)) {
299 rio_dprintk(RIO_DEBUG_TTY, "open(%d) Modem carr on\n", SysPort);
301 tp->tm.c_state |= CARR_ON;
302 wakeup((caddr_t) &tp->tm.c_canq);
304 PortP->State |= RIO_CARR_ON;
305 wake_up_interruptible(&PortP->gs.port.open_wait);
306 } else { /* no carrier - wait for DCD */
308 while (!(PortP->gs.port.tty->termios->c_state & CARR_ON) &&
309 !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted )
311 while (!(PortP->State & RIO_CARR_ON) && !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted) {
312 rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr on\n", SysPort);
314 PortP->gs.port.tty->termios->c_state |= WOPEN;
316 PortP->State |= RIO_WOPEN;
317 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
318 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
319 rio_spin_lock_irqsave(&PortP->portSem, flags);
321 ** ACTION: verify that this is a good thing
322 ** to do here. -- ???
323 ** I think it's OK. -- REW
325 rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr broken by signal\n", SysPort);
326 RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE);
328 tp->tm.c_state &= ~WOPEN;
330 PortP->State &= ~RIO_WOPEN;
331 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
335 rio_spin_lock_irqsave(&PortP->portSem, flags);
337 PortP->State &= ~RIO_WOPEN;
341 rio_dprintk(RIO_DEBUG_TTY, "Setting RIO_MOPEN\n");
342 PortP->State |= RIO_MOPEN;
347 rio_dprintk(RIO_DEBUG_TTY, "high level open done\n");
350 ** Count opens for port statistics reporting
352 if (PortP->statsGather)
355 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
356 rio_dprintk(RIO_DEBUG_TTY, "Returning from open\n");
362 ** RIOClose the port.
363 ** The operating system thinks that this is last close for the device.
364 ** As there are two interfaces to the port (Modem and tty), we need to
365 ** check that both are closed before we close the device.
367 int riotclose(void *ptr)
369 struct Port *PortP = ptr; /* pointer to the port structure */
371 int try = -1; /* Disable the timeouts by setting them to -1 */
372 int repeat_this = -1; /* Congrats to those having 15 years of
373 uptime! (You get to break the driver.) */
374 unsigned long end_time;
375 struct tty_struct *tty;
379 rio_dprintk(RIO_DEBUG_TTY, "port close SysPort %d\n", PortP->PortNum);
381 /* PortP = p->RIOPortp[SysPort]; */
382 rio_dprintk(RIO_DEBUG_TTY, "Port is at address %p\n", PortP);
383 /* tp = PortP->TtyP; *//* Get tty */
384 tty = PortP->gs.port.tty;
385 rio_dprintk(RIO_DEBUG_TTY, "TTY is at address %p\n", tty);
387 if (PortP->gs.closing_wait)
388 end_time = jiffies + PortP->gs.closing_wait;
390 end_time = jiffies + MAX_SCHEDULE_TIMEOUT;
392 rio_spin_lock_irqsave(&PortP->portSem, flags);
395 ** Setting this flag will make any process trying to open
396 ** this port block until we are complete closing it.
398 PortP->State |= RIO_CLOSING;
400 if ((PortP->State & RIO_DELETED)) {
401 rio_dprintk(RIO_DEBUG_TTY, "Close on deleted RTA\n");
411 rio_dprintk(RIO_DEBUG_TTY, "Clear bits\n");
413 ** clear the open bits for this device
415 PortP->State &= ~RIO_MOPEN;
416 PortP->State &= ~RIO_CARR_ON;
417 PortP->ModemState &= ~RIOC_MSVR1_CD;
419 ** If the device was open as both a Modem and a tty line
420 ** then we need to wimp out here, as the port has not really
421 ** been finally closed (gee, whizz!) The test here uses the
422 ** bit for the OTHER mode of operation, to see if THAT is
425 if ((PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
427 ** The port is still open for the other task -
428 ** return, pretending that we are still active.
430 rio_dprintk(RIO_DEBUG_TTY, "Channel %d still open !\n", PortP->PortNum);
431 PortP->State &= ~RIO_CLOSING;
432 if (PortP->firstOpen)
434 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
438 rio_dprintk(RIO_DEBUG_TTY, "Closing down - everything must go!\n");
440 PortP->State &= ~RIO_DYNOROD;
443 ** This is where we wait for the port
444 ** to drain down before closing. Bye-bye....
445 ** (We never meant to do this)
447 rio_dprintk(RIO_DEBUG_TTY, "Timeout 1 starts\n");
450 while ((PortP->InUse != NOT_INUSE) && !p->RIOHalted && (PortP->TxBufferIn != PortP->TxBufferOut)) {
451 if (repeat_this-- <= 0) {
453 rio_dprintk(RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
454 RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE);
457 rio_dprintk(RIO_DEBUG_TTY, "Calling timeout to flush in closing\n");
458 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
459 if (RIODelay_ni(PortP, HUNDRED_MS * 10) == RIO_FAIL) {
460 rio_dprintk(RIO_DEBUG_TTY, "RTA EINTR in delay \n");
462 rio_spin_lock_irqsave(&PortP->portSem, flags);
465 rio_spin_lock_irqsave(&PortP->portSem, flags);
468 PortP->TxBufferIn = PortP->TxBufferOut = 0;
472 if ((PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
474 ** The port has been re-opened for the other task -
475 ** return, pretending that we are still active.
477 rio_dprintk(RIO_DEBUG_TTY, "Channel %d re-open!\n", PortP->PortNum);
478 PortP->State &= ~RIO_CLOSING;
479 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
480 if (PortP->firstOpen)
490 /* Can't call RIOShortCommand with the port locked. */
491 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
493 if (RIOShortCommand(p, PortP, RIOC_CLOSE, 1, 0) == RIO_FAIL) {
494 RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE);
495 rio_spin_lock_irqsave(&PortP->portSem, flags);
500 while (try && (PortP->PortState & PORT_ISOPEN)) {
502 if (time_after(jiffies, end_time)) {
503 rio_dprintk(RIO_DEBUG_TTY, "Run out of tries - force the bugger shut!\n");
504 RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE);
507 rio_dprintk(RIO_DEBUG_TTY, "Close: PortState:ISOPEN is %d\n", PortP->PortState & PORT_ISOPEN);
511 rio_spin_lock_irqsave(&PortP->portSem, flags);
514 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
515 rio_dprintk(RIO_DEBUG_TTY, "RTA EINTR in delay \n");
516 RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE);
520 rio_spin_lock_irqsave(&PortP->portSem, flags);
521 rio_dprintk(RIO_DEBUG_TTY, "Close: try was %d on completion\n", try);
523 /* RIOPreemptiveCmd(p, PortP, RIOC_FCLOSE); */
526 ** 15.10.1998 ARG - ESIL 0761 part fix
527 ** 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.
529 PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW);
532 ** Count opens for port statistics reporting
534 if (PortP->statsGather)
538 /* XXX: Why would a "DELETED" flag be reset here? I'd have
539 thought that a "deleted" flag means that the port was
540 permanently gone, but here we can make it reappear by it
541 being in close during the "deletion".
543 PortP->State &= ~(RIO_CLOSING | RIO_DELETED);
544 if (PortP->firstOpen)
546 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
547 rio_dprintk(RIO_DEBUG_TTY, "Return from close\n");
553 static void RIOClearUp(struct Port *PortP)
555 rio_dprintk(RIO_DEBUG_TTY, "RIOHalted set\n");
556 PortP->Config = 0; /* Direct semaphore */
557 PortP->PortState = 0;
558 PortP->firstOpen = 0;
559 PortP->FlushCmdBodge = 0;
560 PortP->ModemState = PortP->CookMode = 0;
562 PortP->WflushFlag = 0;
563 PortP->MagicFlags = 0;
564 PortP->RxDataStart = 0;
565 PortP->TxBufferIn = 0;
566 PortP->TxBufferOut = 0;
570 ** Put a command onto a port.
571 ** The PortPointer, command, length and arg are passed.
572 ** The len is the length *inclusive* of the command byte,
573 ** and so for a command that takes no data, len==1.
574 ** The arg is a single byte, and is only used if len==2.
575 ** Other values of len aren't allowed, and will cause
578 int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg)
580 struct PKT __iomem *PacketP;
581 int retries = 20; /* at 10 per second -> 2 seconds */
584 rio_dprintk(RIO_DEBUG_TTY, "entering shortcommand.\n");
586 if (PortP->State & RIO_DELETED) {
587 rio_dprintk(RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n");
590 rio_spin_lock_irqsave(&PortP->portSem, flags);
593 ** If the port is in use for pre-emptive command, then wait for it to
596 while ((PortP->InUse != NOT_INUSE) && !p->RIOHalted) {
597 rio_dprintk(RIO_DEBUG_TTY, "Waiting for not in use (%d)\n", retries);
598 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
599 if (retries-- <= 0) {
602 if (RIODelay_ni(PortP, HUNDRED_MS) == RIO_FAIL) {
605 rio_spin_lock_irqsave(&PortP->portSem, flags);
607 if (PortP->State & RIO_DELETED) {
608 rio_dprintk(RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n");
609 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
613 while (!can_add_transmit(&PacketP, PortP) && !p->RIOHalted) {
614 rio_dprintk(RIO_DEBUG_TTY, "Waiting to add short command to queue (%d)\n", retries);
615 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
616 if (retries-- <= 0) {
617 rio_dprintk(RIO_DEBUG_TTY, "out of tries. Failing\n");
620 if (RIODelay_ni(PortP, HUNDRED_MS) == RIO_FAIL) {
623 rio_spin_lock_irqsave(&PortP->portSem, flags);
627 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
632 ** set the command byte and the argument byte
634 writeb(command, &PacketP->data[0]);
637 writeb(arg, &PacketP->data[1]);
640 ** set the length of the packet and set the command bit.
642 writeb(PKT_CMD_BIT | len, &PacketP->len);
646 ** Count characters transmitted for port statistics reporting
648 if (PortP->statsGather)
649 PortP->txchars += len;
651 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
652 return p->RIOHalted ? RIO_FAIL : ~RIO_FAIL;