drivers/char/rio/riotty.c

   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          : riotty.c
  24 **      SID             : 1.3
  25 **      Last Modified   : 11/6/98 10:33:47
  26 **      Retrieved       : 11/6/98 10:33:50
  27 **
  28 **  ident @(#)riotty.c  1.3
  29 **
  30 ** -----------------------------------------------------------------------------
  31 */
  32 #ifdef SCCS_LABELS
  33 static char *_riotty_c_sccs_ = "@(#)riotty.c    1.3";
  34 #endif
  35
  36
  37 #define __EXPLICIT_DEF_H__
  38
  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>
  44 #include <asm/io.h>
  45 #include <asm/system.h>
  46 #include <asm/string.h>
  47 #include <asm/semaphore.h>
  48 #include <asm/uaccess.h>
  49
  50 #include <linux/termios.h>
  51
  52 #include <linux/serial.h>
  53
  54 #include <linux/generic_serial.h>
  55
  56
  57 #include "linux_compat.h"
  58 #include "rio_linux.h"
  59 #include "typdef.h"
  60 #include "pkt.h"
  61 #include "daemon.h"
  62 #include "rio.h"
  63 #include "riospace.h"
  64 #include "top.h"
  65 #include "cmdpkt.h"
  66 #include "map.h"
  67 #include "riotypes.h"
  68 #include "rup.h"
  69 #include "port.h"
  70 #include "riodrvr.h"
  71 #include "rioinfo.h"
  72 #include "func.h"
  73 #include "errors.h"
  74 #include "pci.h"
  75
  76 #include "parmmap.h"
  77 #include "unixrup.h"
  78 #include "board.h"
  79 #include "host.h"
  80 #include "error.h"
  81 #include "phb.h"
  82 #include "link.h"
  83 #include "cmdblk.h"
  84 #include "route.h"
  85 #include "control.h"
  86 #include "cirrus.h"
  87 #include "rioioctl.h"
  88 #include "param.h"
  89 #include "list.h"
  90 #include "sam.h"
  91
  92 static void RIOClearUp(struct Port *PortP);
  93 int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg);
  94
  95
  96 extern int conv_vb[];           /* now defined in ttymgr.c */
  97 extern int conv_bv[];           /* now defined in ttymgr.c */
  98
  99 /*
 100 ** 16.09.1998 ARG - Fix to build riotty.k.o for Modular Kernel Support
 101 **
 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
 105 */
 106 #ifdef uLYNX
 107 #include <ep.def.h>
 108 #endif
 109
 110 #ifdef NEED_THIS2
 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 */
 121         'D' - '@',              /* EOF */
 122         -1,                     /* brk */
 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 */
 130 };
 131 #endif
 132
 133
 134 extern struct rio_info *p;
 135
 136
 137 int riotopen(struct tty_struct *tty, struct file *filp)
 138 {
 139         register uint SysPort;
 140         int Modem;
 141         int repeat_this = 250;
 142         struct Port *PortP;     /* pointer to the port structure */
 143         unsigned long flags;
 144         int retval = 0;
 145
 146         func_enter();
 147
 148         /* Make sure driver_data is NULL in case the rio isn't booted jet. Else gs_close
 149            is going to oops.
 150          */
 151         tty->driver_data = NULL;
 152
 153         SysPort = rio_minor(tty);
 154         Modem = rio_ismodem(tty);
 155
 156         if (p->RIOFailed) {
 157                 rio_dprintk(RIO_DEBUG_TTY, "System initialisation failed\n");
 158                 pseterr(ENXIO);
 159                 func_exit();
 160                 return -ENXIO;
 161         }
 162
 163         rio_dprintk(RIO_DEBUG_TTY, "port open SysPort %d (%s) (mapped:%d)\n", SysPort, Modem ? "Modem" : "tty", p->RIOPortp[SysPort]->Mapped);
 164
 165         /*
 166          ** Validate that we have received a legitimate request.
 167          ** Currently, just check that we are opening a port on
 168          ** a host card that actually exists, and that the port
 169          ** has been mapped onto a host.
 170          */
 171         if (SysPort >= RIO_PORTS) {     /* out of range ? */
 172                 rio_dprintk(RIO_DEBUG_TTY, "Illegal port number %d\n", SysPort);
 173                 pseterr(ENXIO);
 174                 func_exit();
 175                 return -ENXIO;
 176         }
 177
 178         /*
 179          ** Grab pointer to the port stucture
 180          */
 181         PortP = p->RIOPortp[SysPort];   /* Get control struc */
 182         rio_dprintk(RIO_DEBUG_TTY, "PortP: %p\n", PortP);
 183         if (!PortP->Mapped) {   /* we aren't mapped yet! */
 184                 /*
 185                  ** The system doesn't know which RTA this port
 186                  ** corresponds to.
 187                  */
 188                 rio_dprintk(RIO_DEBUG_TTY, "port not mapped into system\n");
 189                 func_exit();
 190                 pseterr(ENXIO);
 191                 return -ENXIO;
 192         }
 193
 194         tty->driver_data = PortP;
 195
 196         PortP->gs.tty = tty;
 197         PortP->gs.count++;
 198
 199         rio_dprintk(RIO_DEBUG_TTY, "%d bytes in tx buffer\n", PortP->gs.xmit_cnt);
 200
 201         retval = gs_init_port(&PortP->gs);
 202         if (retval) {
 203                 PortP->gs.count--;
 204                 return -ENXIO;
 205         }
 206         /*
 207          ** If the host hasn't been booted yet, then
 208          ** fail
 209          */
 210         if ((PortP->HostP->Flags & RUN_STATE) != RC_RUNNING) {
 211                 rio_dprintk(RIO_DEBUG_TTY, "Host not running\n");
 212                 pseterr(ENXIO);
 213                 func_exit();
 214                 return -ENXIO;
 215         }
 216
 217         /*
 218          ** If the RTA has not booted yet and the user has choosen to block
 219          ** until the RTA is present then we must spin here waiting for
 220          ** the RTA to boot.
 221          */
 222         /* I find the above code a bit hairy. I find the below code
 223            easier to read and shorter. Now, if it works too that would
 224            be great... -- REW
 225          */
 226         rio_dprintk(RIO_DEBUG_TTY, "Checking if RTA has booted... \n");
 227         while (!(PortP->HostP->Mapping[PortP->RupNum].Flags & RTA_BOOTED)) {
 228                 if (!PortP->WaitUntilBooted) {
 229                         rio_dprintk(RIO_DEBUG_TTY, "RTA never booted\n");
 230                         func_exit();
 231                         return -ENXIO;
 232                 }
 233
 234                 /* Under Linux you'd normally use a wait instead of this
 235                    busy-waiting. I'll stick with the old implementation for
 236                    now. --REW
 237                  */
 238                 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
 239                         rio_dprintk(RIO_DEBUG_TTY, "RTA_wait_for_boot: EINTR in delay \n");
 240                         func_exit();
 241                         return -EINTR;
 242                 }
 243                 if (repeat_this-- <= 0) {
 244                         rio_dprintk(RIO_DEBUG_TTY, "Waiting for RTA to boot timeout\n");
 245                         func_exit();
 246                         return -EIO;
 247                 }
 248         }
 249         rio_dprintk(RIO_DEBUG_TTY, "RTA has been booted\n");
 250         rio_spin_lock_irqsave(&PortP->portSem, flags);
 251         if (p->RIOHalted) {
 252                 goto bombout;
 253         }
 254
 255         /*
 256          ** If the port is in the final throws of being closed,
 257          ** we should wait here (politely), waiting
 258          ** for it to finish, so that it doesn't close us!
 259          */
 260         while ((PortP->State & RIO_CLOSING) && !p->RIOHalted) {
 261                 rio_dprintk(RIO_DEBUG_TTY, "Waiting for RIO_CLOSING to go away\n");
 262                 if (repeat_this-- <= 0) {
 263                         rio_dprintk(RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
 264                         RIOPreemptiveCmd(p, PortP, FCLOSE);
 265                         retval = -EINTR;
 266                         goto bombout;
 267                 }
 268                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 269                 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
 270                         rio_spin_lock_irqsave(&PortP->portSem, flags);
 271                         retval = -EINTR;
 272                         goto bombout;
 273                 }
 274                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 275         }
 276
 277         if (!PortP->Mapped) {
 278                 rio_dprintk(RIO_DEBUG_TTY, "Port unmapped while closing!\n");
 279                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 280                 retval = -ENXIO;
 281                 func_exit();
 282                 return retval;
 283         }
 284
 285         if (p->RIOHalted) {
 286                 goto bombout;
 287         }
 288
 289 /*
 290 ** 15.10.1998 ARG - ESIL 0761 part fix
 291 ** RIO has it's own CTSFLOW and RTSFLOW flags in 'Config' in the port structure,
 292 ** we need to make sure that the flags are clear when the port is opened.
 293 */
 294         /* Uh? Suppose I turn these on and then another process opens
 295            the port again? The flags get cleared! Not good. -- REW */
 296         if (!(PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
 297                 PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW);
 298         }
 299
 300         if (!(PortP->firstOpen)) {      /* First time ? */
 301                 rio_dprintk(RIO_DEBUG_TTY, "First open for this port\n");
 302
 303
 304                 PortP->firstOpen++;
 305                 PortP->CookMode = 0;    /* XXX RIOCookMode(tp); */
 306                 PortP->InUse = NOT_INUSE;
 307
 308                 /* Tentative fix for bug PR27. Didn't work. */
 309                 /* PortP->gs.xmit_cnt = 0; */
 310
 311                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 312 #ifdef NEED_THIS
 313                 ttyseth(PortP, tp, (struct old_sgttyb *) &default_sg);
 314 #endif
 315
 316                 /* Someone explain to me why this delay/config is
 317                    here. If I read the docs correctly the "open"
 318                    command piggybacks the parameters immediately.
 319                    -- REW */
 320                 RIOParam(PortP, OPEN, Modem, OK_TO_SLEEP);      /* Open the port */
 321                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 322
 323                 /*
 324                  ** wait for the port to be not closed.
 325                  */
 326                 while (!(PortP->PortState & PORT_ISOPEN) && !p->RIOHalted) {
 327                         rio_dprintk(RIO_DEBUG_TTY, "Waiting for PORT_ISOPEN-currently %x\n", PortP->PortState);
 328 /*
 329 ** 15.10.1998 ARG - ESIL 0759
 330 ** (Part) fix for port being trashed when opened whilst RTA "disconnected"
 331 ** Take out the limited wait - now wait for ever or until user
 332 ** bangs us out.
 333 **
 334                         if (repeat_this -- <= 0) {
 335                                 rio_dprint(RIO_DEBUG_TTY, ("Waiting for open to finish timed out.\n"));
 336                                 RIOPreemptiveCmd(p, PortP, FCLOSE );
 337                                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 338                                 return -EINTR;
 339                         }
 340 **
 341 */
 342                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 343                         if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
 344                                 rio_dprintk(RIO_DEBUG_TTY, "Waiting for open to finish broken by signal\n");
 345                                 RIOPreemptiveCmd(p, PortP, FCLOSE);
 346                                 func_exit();
 347                                 return -EINTR;
 348                         }
 349                         rio_spin_lock_irqsave(&PortP->portSem, flags);
 350                 }
 351
 352                 if (p->RIOHalted) {
 353                         retval = -EIO;
 354                       bombout:
 355                         /*                    RIOClearUp( PortP ); */
 356                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 357                         return retval;
 358                 }
 359                 rio_dprintk(RIO_DEBUG_TTY, "PORT_ISOPEN found\n");
 360         }
 361 #ifdef MODEM_SUPPORT
 362         if (Modem) {
 363                 rio_dprintk(RIO_DEBUG_TTY, "Modem - test for carrier\n");
 364                 /*
 365                  ** ACTION
 366                  ** insert test for carrier here. -- ???
 367                  ** I already see that test here. What's the deal? -- REW
 368                  */
 369                 if ((PortP->gs.tty->termios->c_cflag & CLOCAL) || (PortP->ModemState & MSVR1_CD)) {
 370                         rio_dprintk(RIO_DEBUG_TTY, "open(%d) Modem carr on\n", SysPort);
 371                         /*
 372                            tp->tm.c_state |= CARR_ON;
 373                            wakeup((caddr_t) &tp->tm.c_canq);
 374                          */
 375                         PortP->State |= RIO_CARR_ON;
 376                         wake_up_interruptible(&PortP->gs.open_wait);
 377                 } else {        /* no carrier - wait for DCD */
 378
 379                         /*
 380                            while (!(PortP->gs.tty->termios->c_state & CARR_ON) &&
 381                            !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted )
 382                          */
 383                         while (!(PortP->State & RIO_CARR_ON) && !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted) {
 384
 385                                 rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr on\n", SysPort);
 386                                 /*
 387                                    PortP->gs.tty->termios->c_state |= WOPEN;
 388                                  */
 389                                 PortP->State |= RIO_WOPEN;
 390                                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 391                                 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL)
 392                                         {
 393                                                 /*
 394                                                  ** ACTION: verify that this is a good thing
 395                                                  ** to do here. -- ???
 396                                                  ** I think it's OK. -- REW
 397                                                  */
 398                                                 rio_dprintk(RIO_DEBUG_TTY, "open(%d) sleeping for carr broken by signal\n", SysPort);
 399                                                 RIOPreemptiveCmd(p, PortP, FCLOSE);
 400                                                 /*
 401                                                    tp->tm.c_state &= ~WOPEN;
 402                                                  */
 403                                                 PortP->State &= ~RIO_WOPEN;
 404                                                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 405                                                 func_exit();
 406                                                 return -EINTR;
 407                                         }
 408                         }
 409                         PortP->State &= ~RIO_WOPEN;
 410                 }
 411                 if (p->RIOHalted)
 412                         goto bombout;
 413                 rio_dprintk(RIO_DEBUG_TTY, "Setting RIO_MOPEN\n");
 414                 PortP->State |= RIO_MOPEN;
 415         } else
 416 #endif
 417         {
 418                 /*
 419                  ** ACTION
 420                  ** Direct line open - force carrier (will probably mean
 421                  ** that sleeping Modem line fubar)
 422                  */
 423                 PortP->State |= RIO_LOPEN;
 424         }
 425
 426         if (p->RIOHalted) {
 427                 goto bombout;
 428         }
 429
 430         rio_dprintk(RIO_DEBUG_TTY, "high level open done\n");
 431
 432 #ifdef STATS
 433         PortP->Stat.OpenCnt++;
 434 #endif
 435         /*
 436          ** Count opens for port statistics reporting
 437          */
 438         if (PortP->statsGather)
 439                 PortP->opens++;
 440
 441         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 442         rio_dprintk(RIO_DEBUG_TTY, "Returning from open\n");
 443         func_exit();
 444         return 0;
 445 }
 446
 447 /*
 448 ** RIOClose the port.
 449 ** The operating system thinks that this is last close for the device.
 450 ** As there are two interfaces to the port (Modem and tty), we need to
 451 ** check that both are closed before we close the device.
 452 */
 453 int riotclose(void *ptr)
 454 {
 455         struct Port *PortP = ptr;       /* pointer to the port structure */
 456         int deleted = 0;
 457         int try = -1;           /* Disable the timeouts by setting them to -1 */
 458         int repeat_this = -1;   /* Congrats to those having 15 years of
 459                                    uptime! (You get to break the driver.) */
 460         unsigned long end_time;
 461         struct tty_struct *tty;
 462         unsigned long flags;
 463         int Modem;
 464         int rv = 0;
 465
 466         rio_dprintk(RIO_DEBUG_TTY, "port close SysPort %d\n", PortP->PortNum);
 467
 468         /* PortP = p->RIOPortp[SysPort]; */
 469         rio_dprintk(RIO_DEBUG_TTY, "Port is at address 0x%x\n", (int) PortP);
 470         /* tp = PortP->TtyP; *//* Get tty */
 471         tty = PortP->gs.tty;
 472         rio_dprintk(RIO_DEBUG_TTY, "TTY is at address 0x%x\n", (int) tty);
 473
 474         if (PortP->gs.closing_wait)
 475                 end_time = jiffies + PortP->gs.closing_wait;
 476         else
 477                 end_time = jiffies + MAX_SCHEDULE_TIMEOUT;
 478
 479         Modem = rio_ismodem(tty);
 480         rio_spin_lock_irqsave(&PortP->portSem, flags);
 481
 482         /*
 483          ** Setting this flag will make any process trying to open
 484          ** this port block until we are complete closing it.
 485          */
 486         PortP->State |= RIO_CLOSING;
 487
 488         if ((PortP->State & RIO_DELETED)) {
 489                 rio_dprintk(RIO_DEBUG_TTY, "Close on deleted RTA\n");
 490                 deleted = 1;
 491         }
 492
 493         if (p->RIOHalted) {
 494                 RIOClearUp(PortP);
 495                 rv = -EIO;
 496                 goto close_end;
 497         }
 498
 499         rio_dprintk(RIO_DEBUG_TTY, "Clear bits\n");
 500         /*
 501          ** clear the open bits for this device
 502          */
 503         PortP->State &= (Modem ? ~RIO_MOPEN : ~RIO_LOPEN);
 504         PortP->State &= ~RIO_CARR_ON;
 505         PortP->ModemState &= ~MSVR1_CD;
 506         /*
 507          ** If the device was open as both a Modem and a tty line
 508          ** then we need to wimp out here, as the port has not really
 509          ** been finally closed (gee, whizz!) The test here uses the
 510          ** bit for the OTHER mode of operation, to see if THAT is
 511          ** still active!
 512          */
 513         if ((PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
 514                 /*
 515                  ** The port is still open for the other task -
 516                  ** return, pretending that we are still active.
 517                  */
 518                 rio_dprintk(RIO_DEBUG_TTY, "Channel %d still open !\n", PortP->PortNum);
 519                 PortP->State &= ~RIO_CLOSING;
 520                 if (PortP->firstOpen)
 521                         PortP->firstOpen--;
 522                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 523                 return -EIO;
 524         }
 525
 526         rio_dprintk(RIO_DEBUG_TTY, "Closing down - everything must go!\n");
 527
 528         PortP->State &= ~RIO_DYNOROD;
 529
 530         /*
 531          ** This is where we wait for the port
 532          ** to drain down before closing. Bye-bye....
 533          ** (We never meant to do this)
 534          */
 535         rio_dprintk(RIO_DEBUG_TTY, "Timeout 1 starts\n");
 536
 537         if (!deleted)
 538                 while ((PortP->InUse != NOT_INUSE) && !p->RIOHalted && (PortP->TxBufferIn != PortP->TxBufferOut)) {
 539                         cprintf("Need to flush the ttyport\n");
 540                         if (repeat_this-- <= 0) {
 541                                 rv = -EINTR;
 542                                 rio_dprintk(RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
 543                                 RIOPreemptiveCmd(p, PortP, FCLOSE);
 544                                 goto close_end;
 545                         }
 546                         rio_dprintk(RIO_DEBUG_TTY, "Calling timeout to flush in closing\n");
 547                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 548                         if (RIODelay_ni(PortP, HUNDRED_MS * 10) == RIO_FAIL) {
 549                                 rio_dprintk(RIO_DEBUG_TTY, "RTA EINTR in delay \n");
 550                                 rv = -EINTR;
 551                                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 552                                 goto close_end;
 553                         }
 554                         rio_spin_lock_irqsave(&PortP->portSem, flags);
 555                 }
 556
 557         PortP->TxBufferIn = PortP->TxBufferOut = 0;
 558         repeat_this = 0xff;
 559
 560         PortP->InUse = 0;
 561         if ((PortP->State & (RIO_LOPEN | RIO_MOPEN))) {
 562                 /*
 563                  ** The port has been re-opened for the other task -
 564                  ** return, pretending that we are still active.
 565                  */
 566                 rio_dprintk(RIO_DEBUG_TTY, "Channel %d re-open!\n", PortP->PortNum);
 567                 PortP->State &= ~RIO_CLOSING;
 568                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 569                 if (PortP->firstOpen)
 570                         PortP->firstOpen--;
 571                 return -EIO;
 572         }
 573
 574         if (p->RIOHalted) {
 575                 RIOClearUp(PortP);
 576                 goto close_end;
 577         }
 578
 579         /* Can't call RIOShortCommand with the port locked. */
 580         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 581
 582         if (RIOShortCommand(p, PortP, CLOSE, 1, 0) == RIO_FAIL) {
 583                 RIOPreemptiveCmd(p, PortP, FCLOSE);
 584                 goto close_end;
 585         }
 586
 587         if (!deleted)
 588                 while (try && (PortP->PortState & PORT_ISOPEN)) {
 589                         try--;
 590                         if (time_after(jiffies, end_time)) {
 591                                 rio_dprintk(RIO_DEBUG_TTY, "Run out of tries - force the bugger shut!\n");
 592                                 RIOPreemptiveCmd(p, PortP, FCLOSE);
 593                                 break;
 594                         }
 595                         rio_dprintk(RIO_DEBUG_TTY, "Close: PortState:ISOPEN is %d\n", PortP->PortState & PORT_ISOPEN);
 596
 597                         if (p->RIOHalted) {
 598                                 RIOClearUp(PortP);
 599                                 goto close_end;
 600                         }
 601                         if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
 602                                 rio_dprintk(RIO_DEBUG_TTY, "RTA EINTR in delay \n");
 603                                 RIOPreemptiveCmd(p, PortP, FCLOSE);
 604                                 break;
 605                         }
 606                 }
 607         rio_spin_lock_irqsave(&PortP->portSem, flags);
 608         rio_dprintk(RIO_DEBUG_TTY, "Close: try was %d on completion\n", try);
 609
 610         /* RIOPreemptiveCmd(p, PortP, FCLOSE); */
 611
 612 /*
 613 ** 15.10.1998 ARG - ESIL 0761 part fix
 614 ** 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.
 615 */
 616         PortP->Config &= ~(RIO_CTSFLOW | RIO_RTSFLOW);
 617
 618 #ifdef STATS
 619         PortP->Stat.CloseCnt++;
 620 #endif
 621         /*
 622          ** Count opens for port statistics reporting
 623          */
 624         if (PortP->statsGather)
 625                 PortP->closes++;
 626
 627       close_end:
 628         /* XXX: Why would a "DELETED" flag be reset here? I'd have
 629            thought that a "deleted" flag means that the port was
 630            permanently gone, but here we can make it reappear by it
 631            being in close during the "deletion".
 632          */
 633         PortP->State &= ~(RIO_CLOSING | RIO_DELETED);
 634         if (PortP->firstOpen)
 635                 PortP->firstOpen--;
 636         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 637         rio_dprintk(RIO_DEBUG_TTY, "Return from close\n");
 638         return rv;
 639 }
 640
 641
 642
 643 static void RIOClearUp(PortP)
 644 struct Port *PortP;
 645 {
 646         rio_dprintk(RIO_DEBUG_TTY, "RIOHalted set\n");
 647         PortP->Config = 0;      /* Direct semaphore */
 648         PortP->PortState = 0;
 649         PortP->firstOpen = 0;
 650         PortP->FlushCmdBodge = 0;
 651         PortP->ModemState = PortP->CookMode = 0;
 652         PortP->Mapped = 0;
 653         PortP->WflushFlag = 0;
 654         PortP->MagicFlags = 0;
 655         PortP->RxDataStart = 0;
 656         PortP->TxBufferIn = 0;
 657         PortP->TxBufferOut = 0;
 658 }
 659
 660 /*
 661 ** Put a command onto a port.
 662 ** The PortPointer, command, length and arg are passed.
 663 ** The len is the length *inclusive* of the command byte,
 664 ** and so for a command that takes no data, len==1.
 665 ** The arg is a single byte, and is only used if len==2.
 666 ** Other values of len aren't allowed, and will cause
 667 ** a panic.
 668 */
 669 int RIOShortCommand(struct rio_info *p, struct Port *PortP, int command, int len, int arg)
 670 {
 671         PKT *PacketP;
 672         int retries = 20;       /* at 10 per second -> 2 seconds */
 673         unsigned long flags;
 674
 675         rio_dprintk(RIO_DEBUG_TTY, "entering shortcommand.\n");
 676
 677         if (PortP->State & RIO_DELETED) {
 678                 rio_dprintk(RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n");
 679                 return RIO_FAIL;
 680         }
 681         rio_spin_lock_irqsave(&PortP->portSem, flags);
 682
 683         /*
 684          ** If the port is in use for pre-emptive command, then wait for it to
 685          ** be free again.
 686          */
 687         while ((PortP->InUse != NOT_INUSE) && !p->RIOHalted) {
 688                 rio_dprintk(RIO_DEBUG_TTY, "Waiting for not in use (%d)\n", retries);
 689                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 690                 if (retries-- <= 0) {
 691                         return RIO_FAIL;
 692                 }
 693                 if (RIODelay_ni(PortP, HUNDRED_MS) == RIO_FAIL) {
 694                         return RIO_FAIL;
 695                 }
 696                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 697         }
 698         if (PortP->State & RIO_DELETED) {
 699                 rio_dprintk(RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n");
 700                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 701                 return RIO_FAIL;
 702         }
 703
 704         while (!can_add_transmit(&PacketP, PortP) && !p->RIOHalted) {
 705                 rio_dprintk(RIO_DEBUG_TTY, "Waiting to add short command to queue (%d)\n", retries);
 706                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 707                 if (retries-- <= 0) {
 708                         rio_dprintk(RIO_DEBUG_TTY, "out of tries. Failing\n");
 709                         return RIO_FAIL;
 710                 }
 711                 if (RIODelay_ni(PortP, HUNDRED_MS) == RIO_FAIL) {
 712                         return RIO_FAIL;
 713                 }
 714                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 715         }
 716
 717         if (p->RIOHalted) {
 718                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 719                 return RIO_FAIL;
 720         }
 721
 722         /*
 723          ** set the command byte and the argument byte
 724          */
 725         WBYTE(PacketP->data[0], command);
 726
 727         if (len == 2)
 728                 WBYTE(PacketP->data[1], arg);
 729
 730         /*
 731          ** set the length of the packet and set the command bit.
 732          */
 733         WBYTE(PacketP->len, PKT_CMD_BIT | len);
 734
 735         add_transmit(PortP);
 736         /*
 737          ** Count characters transmitted for port statistics reporting
 738          */
 739         if (PortP->statsGather)
 740                 PortP->txchars += len;
 741
 742         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 743         return p->RIOHalted ? RIO_FAIL : ~RIO_FAIL;
 744 }
 745
 746