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 #if 0
  93 static void ttyseth_pv(struct Port *, struct ttystatics *,
  94                                 struct termios *sg, int);
  95 #endif
  96
  97 static void RIOClearUp(struct Port *PortP);
  98 int RIOShortCommand(struct rio_info *p, struct Port *PortP,
  99                            int command, int len, int arg);
 100
 101 #if 0
 102 static int RIOCookMode(struct ttystatics *);
 103 #endif
 104
 105 extern int      conv_vb[];      /* now defined in ttymgr.c */
 106 extern int      conv_bv[];      /* now defined in ttymgr.c */
 107
 108 /*
 109 ** 16.09.1998 ARG - Fix to build riotty.k.o for Modular Kernel Support
 110 **
 111 ** ep.def.h is necessary for Modular Kernel Support
 112 ** DO NOT place any kernel 'extern's after this line
 113 ** or this source file will not build riotty.k.o
 114 */
 115 #ifdef uLYNX
 116 #include <ep.def.h>
 117 #endif
 118
 119 #ifdef NEED_THIS2
 120 static struct old_sgttyb
 121 default_sg =
 122 {
 123         B19200, B19200,                         /* input and output speed */
 124         'H' - '@',                                      /* erase char */
 125         -1,                                                     /* 2nd erase char */
 126         'U' - '@',                                      /* kill char */
 127         ECHO | CRMOD,                           /* mode */
 128         'C' - '@',                                      /* interrupt character */
 129         '\\' - '@',                                     /* quit char */
 130         'Q' - '@',                                      /* start char */
 131         'S' - '@',                                      /* stop char */
 132         'D' - '@',                                      /* EOF */
 133         -1,                                                     /* brk */
 134         (LCRTBS | LCRTERA | LCRTKIL | LCTLECH), /* local mode word */
 135         'Z' - '@',                                      /* process stop */
 136         'Y' - '@',                                      /* delayed stop */
 137         'R' - '@',                                      /* reprint line */
 138         'O' - '@',                                      /* flush output */
 139         'W' - '@',                                      /* word erase */
 140         'V' - '@'                                       /* literal next char */
 141 };
 142 #endif
 143
 144
 145 extern struct rio_info *p;
 146
 147
 148 int
 149 riotopen(struct tty_struct * tty, struct file * filp)
 150 {
 151         register uint SysPort;
 152         int Modem;
 153         int repeat_this = 250;
 154         struct Port *PortP;              /* pointer to the port structure */
 155         unsigned long flags;
 156         int retval = 0;
 157
 158         func_enter ();
 159
 160         /* Make sure driver_data is NULL in case the rio isn't booted jet. Else gs_close
 161            is going to oops.
 162         */
 163         tty->driver_data = NULL;
 164
 165         SysPort = rio_minor(tty);
 166         Modem   = rio_ismodem(tty);
 167
 168         if ( p->RIOFailed ) {
 169                 rio_dprintk (RIO_DEBUG_TTY, "System initialisation failed\n");
 170                 pseterr(ENXIO);
 171                 func_exit ();
 172                 return -ENXIO;
 173         }
 174
 175         rio_dprintk (RIO_DEBUG_TTY, "port open SysPort %d (%s) (mapped:%d)\n",
 176                SysPort,  Modem ? "Modem" : "tty",
 177                                    p->RIOPortp[SysPort]->Mapped);
 178
 179         /*
 180         ** Validate that we have received a legitimate request.
 181         ** Currently, just check that we are opening a port on
 182         ** a host card that actually exists, and that the port
 183         ** has been mapped onto a host.
 184         */
 185         if (SysPort >= RIO_PORTS) {     /* out of range ? */
 186                 rio_dprintk (RIO_DEBUG_TTY, "Illegal port number %d\n",SysPort);
 187                 pseterr(ENXIO);
 188                 func_exit();
 189                 return -ENXIO;
 190         }
 191
 192         /*
 193         ** Grab pointer to the port stucture
 194         */
 195         PortP = p->RIOPortp[SysPort];   /* Get control struc */
 196         rio_dprintk (RIO_DEBUG_TTY, "PortP: %p\n", PortP);
 197         if ( !PortP->Mapped ) { /* we aren't mapped yet! */
 198                 /*
 199                 ** The system doesn't know which RTA this port
 200                 ** corresponds to.
 201                 */
 202                 rio_dprintk (RIO_DEBUG_TTY, "port not mapped into system\n");
 203                 func_exit ();
 204                 pseterr(ENXIO);
 205                 return -ENXIO;
 206         }
 207
 208         tty->driver_data = PortP;
 209
 210         PortP->gs.tty = tty;
 211         PortP->gs.count++;
 212
 213         rio_dprintk (RIO_DEBUG_TTY, "%d bytes in tx buffer\n",
 214                                    PortP->gs.xmit_cnt);
 215
 216         retval = gs_init_port (&PortP->gs);
 217         if (retval) {
 218                 PortP->gs.count--;
 219                 return -ENXIO;
 220         }
 221         /*
 222         ** If the host hasn't been booted yet, then
 223         ** fail
 224         */
 225         if ( (PortP->HostP->Flags & RUN_STATE) != RC_RUNNING ) {
 226                 rio_dprintk (RIO_DEBUG_TTY, "Host not running\n");
 227                 pseterr(ENXIO);
 228                 func_exit ();
 229                 return -ENXIO;
 230         }
 231
 232         /*
 233         ** If the RTA has not booted yet and the user has choosen to block
 234         ** until the RTA is present then we must spin here waiting for
 235         ** the RTA to boot.
 236         */
 237 #if 0
 238         if (!(PortP->HostP->Mapping[PortP->RupNum].Flags & RTA_BOOTED)) {
 239                 if (PortP->WaitUntilBooted) {
 240                         rio_dprintk (RIO_DEBUG_TTY, "Waiting for RTA to boot\n");
 241                         do {
 242                                 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
 243                                         rio_dprintk (RIO_DEBUG_TTY, "RTA EINTR in delay \n");
 244                                         func_exit ();
 245                                         return -EINTR;
 246                                 }
 247                                 if (repeat_this -- <= 0) {
 248                                         rio_dprintk (RIO_DEBUG_TTY, "Waiting for RTA to boot timeout\n");
 249                                         RIOPreemptiveCmd(p, PortP, FCLOSE );
 250                                         pseterr(EINTR);
 251                                         func_exit ();
 252                                         return -EIO;
 253                                 }
 254                         } while(!(PortP->HostP->Mapping[PortP->RupNum].Flags & RTA_BOOTED));
 255                         rio_dprintk (RIO_DEBUG_TTY, "RTA has been booted\n");
 256                 } else {
 257                         rio_dprintk (RIO_DEBUG_TTY, "RTA never booted\n");
 258                         pseterr(ENXIO);
 259                         func_exit ();
 260                         return 0;
 261                 }
 262         }
 263 #else
 264         /* I find the above code a bit hairy. I find the below code
 265            easier to read and shorter. Now, if it works too that would
 266            be great... -- REW
 267         */
 268         rio_dprintk (RIO_DEBUG_TTY, "Checking if RTA has booted... \n");
 269         while (!(PortP->HostP->Mapping[PortP->RupNum].Flags & RTA_BOOTED)) {
 270           if (!PortP->WaitUntilBooted) {
 271             rio_dprintk (RIO_DEBUG_TTY, "RTA never booted\n");
 272             func_exit ();
 273             return -ENXIO;
 274           }
 275
 276           /* Under Linux you'd normally use a wait instead of this
 277              busy-waiting. I'll stick with the old implementation for
 278              now. --REW
 279           */
 280           if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
 281             rio_dprintk (RIO_DEBUG_TTY, "RTA_wait_for_boot: EINTR in delay \n");
 282             func_exit ();
 283             return -EINTR;
 284           }
 285           if (repeat_this -- <= 0) {
 286             rio_dprintk (RIO_DEBUG_TTY, "Waiting for RTA to boot timeout\n");
 287             func_exit ();
 288             return -EIO;
 289           }
 290         }
 291         rio_dprintk (RIO_DEBUG_TTY, "RTA has been booted\n");
 292 #endif
 293 #if 0
 294         tp =  PortP->TtyP;              /* get tty struct */
 295 #endif
 296         rio_spin_lock_irqsave(&PortP->portSem, flags);
 297         if ( p->RIOHalted ) {
 298                 goto bombout;
 299         }
 300 #if 0
 301         retval = gs_init_port(&PortP->gs);
 302         if (retval){
 303                 func_exit ();
 304                 return retval;
 305         }
 306 #endif
 307
 308         /*
 309         ** If the port is in the final throws of being closed,
 310         ** we should wait here (politely), waiting
 311         ** for it to finish, so that it doesn't close us!
 312         */
 313         while ( (PortP->State & RIO_CLOSING) && !p->RIOHalted ) {
 314                 rio_dprintk (RIO_DEBUG_TTY, "Waiting for RIO_CLOSING to go away\n");
 315                 if (repeat_this -- <= 0) {
 316                         rio_dprintk (RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
 317                         RIOPreemptiveCmd(p, PortP, FCLOSE );
 318                         retval = -EINTR;
 319                         goto bombout;
 320                 }
 321                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 322                 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
 323                         rio_spin_lock_irqsave(&PortP->portSem, flags);
 324                         retval = -EINTR;
 325                         goto bombout;
 326                 }
 327                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 328         }
 329
 330         if ( !PortP->Mapped ) {
 331                 rio_dprintk (RIO_DEBUG_TTY, "Port unmapped while closing!\n");
 332                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 333                 retval = -ENXIO;
 334                 func_exit ();
 335                 return retval;
 336         }
 337
 338         if ( p->RIOHalted ) {
 339                 goto bombout;
 340         }
 341
 342 /*
 343 ** 15.10.1998 ARG - ESIL 0761 part fix
 344 ** RIO has it's own CTSFLOW and RTSFLOW flags in 'Config' in the port structure,
 345 ** we need to make sure that the flags are clear when the port is opened.
 346 */
 347         /* Uh? Suppose I turn these on and then another process opens
 348            the port again? The flags get cleared! Not good. -- REW */
 349         if ( !(PortP->State & (RIO_LOPEN | RIO_MOPEN)) ) {
 350                 PortP->Config &= ~(RIO_CTSFLOW|RIO_RTSFLOW);
 351         }
 352
 353         if (!(PortP->firstOpen)) {      /* First time ? */
 354                 rio_dprintk (RIO_DEBUG_TTY, "First open for this port\n");
 355
 356
 357                 PortP->firstOpen++;
 358                 PortP->CookMode = 0; /* XXX RIOCookMode(tp); */
 359                 PortP->InUse = NOT_INUSE;
 360
 361                 /* Tentative fix for bug PR27. Didn't work. */
 362                 /* PortP->gs.xmit_cnt = 0; */
 363
 364                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 365 #ifdef NEED_THIS
 366                 ttyseth(PortP, tp, (struct old_sgttyb *)&default_sg);
 367 #endif
 368
 369                 /* Someone explain to me why this delay/config is
 370                    here. If I read the docs correctly the "open"
 371                    command piggybacks the parameters immediately.
 372                    -- REW */
 373                 RIOParam(PortP,OPEN,Modem,OK_TO_SLEEP);         /* Open the port */
 374 #if 0
 375                 /* This delay of 1 second was annoying. I removed it. -- REW */
 376                 RIODelay(PortP, HUNDRED_MS*10);
 377                 RIOParam(PortP,CONFIG,Modem,OK_TO_SLEEP);       /* Config the port */
 378 #endif
 379                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 380
 381                 /*
 382                 ** wait for the port to be not closed.
 383                 */
 384                 while ( !(PortP->PortState & PORT_ISOPEN) && !p->RIOHalted ) {
 385                         rio_dprintk (RIO_DEBUG_TTY, "Waiting for PORT_ISOPEN-currently %x\n",PortP->PortState);
 386 /*
 387 ** 15.10.1998 ARG - ESIL 0759
 388 ** (Part) fix for port being trashed when opened whilst RTA "disconnected"
 389 ** Take out the limited wait - now wait for ever or until user
 390 ** bangs us out.
 391 **
 392                         if (repeat_this -- <= 0) {
 393                                 rio_dprint(RIO_DEBUG_TTY, ("Waiting for open to finish timed out.\n"));
 394                                 RIOPreemptiveCmd(p, PortP, FCLOSE );
 395                                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 396                                 return -EINTR;
 397                         }
 398 **
 399 */
 400                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 401                         if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
 402                                 rio_dprintk (RIO_DEBUG_TTY, "Waiting for open to finish broken by signal\n");
 403                                 RIOPreemptiveCmd(p, PortP, FCLOSE );
 404                                 func_exit ();
 405                                 return -EINTR;
 406                         }
 407                         rio_spin_lock_irqsave(&PortP->portSem, flags);
 408                 }
 409
 410                 if ( p->RIOHalted ) {
 411                   retval = -EIO;
 412 bombout:
 413                   /*                    RIOClearUp( PortP ); */
 414                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 415                         return retval;
 416                 }
 417                 rio_dprintk (RIO_DEBUG_TTY, "PORT_ISOPEN found\n");
 418         }
 419
 420 #ifdef MODEM_SUPPORT
 421         if (Modem) {
 422                 rio_dprintk (RIO_DEBUG_TTY, "Modem - test for carrier\n");
 423                 /*
 424                 ** ACTION
 425                 ** insert test for carrier here. -- ???
 426                 ** I already see that test here. What's the deal? -- REW
 427                 */
 428                 if ((PortP->gs.tty->termios->c_cflag & CLOCAL) || (PortP->ModemState & MSVR1_CD))
 429                 {
 430                         rio_dprintk (RIO_DEBUG_TTY, "open(%d) Modem carr on\n", SysPort);
 431                         /*
 432                         tp->tm.c_state |= CARR_ON;
 433                         wakeup((caddr_t) &tp->tm.c_canq);
 434                         */
 435                         PortP->State |= RIO_CARR_ON;
 436                         wake_up_interruptible (&PortP->gs.open_wait);
 437                 }
 438                 else /* no carrier - wait for DCD */
 439                 {
 440                   /*
 441                         while (!(PortP->gs.tty->termios->c_state & CARR_ON) &&
 442                                !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted )
 443                   */
 444                         while (!(PortP->State & RIO_CARR_ON) &&
 445                                !(filp->f_flags & O_NONBLOCK) && !p->RIOHalted ) {
 446
 447                                 rio_dprintk (RIO_DEBUG_TTY, "open(%d) sleeping for carr on\n",SysPort);
 448                                 /*
 449                                 PortP->gs.tty->termios->c_state |= WOPEN;
 450                                 */
 451                                 PortP->State |= RIO_WOPEN;
 452                                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 453                                 if (RIODelay (PortP, HUNDRED_MS) == RIO_FAIL)
 454 #if 0
 455                                 if ( sleep((caddr_t)&tp->tm.c_canqo, TTIPRI|PCATCH))
 456 #endif
 457                                 {
 458                                         /*
 459                                         ** ACTION: verify that this is a good thing
 460                                         ** to do here. -- ???
 461                                         ** I think it's OK. -- REW
 462                                         */
 463                                         rio_dprintk (RIO_DEBUG_TTY, "open(%d) sleeping for carr broken by signal\n",
 464                                                SysPort);
 465                                         RIOPreemptiveCmd( p, PortP, FCLOSE );
 466                                         /*
 467                                         tp->tm.c_state &= ~WOPEN;
 468                                         */
 469                                         PortP->State &= ~RIO_WOPEN;
 470                                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 471                                         func_exit ();
 472                                         return -EINTR;
 473                                 }
 474                         }
 475                         PortP->State &= ~RIO_WOPEN;
 476                 }
 477                 if ( p->RIOHalted )
 478                         goto bombout;
 479                 rio_dprintk (RIO_DEBUG_TTY, "Setting RIO_MOPEN\n");
 480                 PortP->State |= RIO_MOPEN;
 481         }
 482         else
 483 #endif
 484         {
 485                 /*
 486                 ** ACTION
 487                 ** Direct line open - force carrier (will probably mean
 488                 ** that sleeping Modem line fubar)
 489                 */
 490                 PortP->State |= RIO_LOPEN;
 491         }
 492
 493         if ( p->RIOHalted ) {
 494                 goto bombout;
 495         }
 496
 497         rio_dprintk (RIO_DEBUG_TTY, "high level open done\n");
 498
 499 #ifdef STATS
 500         PortP->Stat.OpenCnt++;
 501 #endif
 502         /*
 503         ** Count opens for port statistics reporting
 504         */
 505         if (PortP->statsGather)
 506                 PortP->opens++;
 507
 508         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 509         rio_dprintk (RIO_DEBUG_TTY, "Returning from open\n");
 510         func_exit ();
 511         return 0;
 512 }
 513
 514 /*
 515 ** RIOClose the port.
 516 ** The operating system thinks that this is last close for the device.
 517 ** As there are two interfaces to the port (Modem and tty), we need to
 518 ** check that both are closed before we close the device.
 519 */
 520 int
 521 riotclose(void  *ptr)
 522 {
 523 #if 0
 524         register uint SysPort = dev;
 525         struct ttystatics *tp;          /* pointer to our ttystruct */
 526 #endif
 527         struct Port *PortP =ptr;        /* pointer to the port structure */
 528         int deleted = 0;
 529         int     try = -1; /* Disable the timeouts by setting them to -1 */
 530         int     repeat_this = -1; /* Congrats to those having 15 years of
 531                                      uptime! (You get to break the driver.) */
 532         long end_time;
 533         struct tty_struct * tty;
 534         unsigned long flags;
 535         int Modem;
 536         int rv =0;
 537
 538         rio_dprintk (RIO_DEBUG_TTY, "port close SysPort %d\n",PortP->PortNum);
 539
 540         /* PortP = p->RIOPortp[SysPort]; */
 541         rio_dprintk (RIO_DEBUG_TTY, "Port is at address 0x%x\n",(int)PortP);
 542         /* tp = PortP->TtyP;*/                  /* Get tty */
 543         tty = PortP->gs.tty;
 544         rio_dprintk (RIO_DEBUG_TTY, "TTY is at address 0x%x\n",(int)tty);
 545
 546         if (PortP->gs.closing_wait)
 547                 end_time = jiffies + PortP->gs.closing_wait;
 548         else
 549                 end_time = jiffies + MAX_SCHEDULE_TIMEOUT;
 550
 551         Modem = rio_ismodem(tty);
 552 #if 0
 553         /* What F.CKING cache? Even then, a higly idle multiprocessor,
 554            system with large caches this won't work . Better find out when
 555            this doesn't work asap, and fix the cause.  -- REW */
 556
 557         RIODelay(PortP, HUNDRED_MS*10); /* To flush the cache */
 558 #endif
 559         rio_spin_lock_irqsave(&PortP->portSem, flags);
 560
 561         /*
 562         ** Setting this flag will make any process trying to open
 563         ** this port block until we are complete closing it.
 564         */
 565         PortP->State |= RIO_CLOSING;
 566
 567         if ( (PortP->State & RIO_DELETED) ) {
 568                 rio_dprintk (RIO_DEBUG_TTY, "Close on deleted RTA\n");
 569                 deleted = 1;
 570         }
 571
 572         if ( p->RIOHalted ) {
 573                 RIOClearUp( PortP );
 574                 rv = -EIO;
 575                 goto close_end;
 576         }
 577
 578         rio_dprintk (RIO_DEBUG_TTY, "Clear bits\n");
 579         /*
 580         ** clear the open bits for this device
 581         */
 582         PortP->State &= (Modem ? ~RIO_MOPEN : ~RIO_LOPEN);
 583         PortP->State &= ~RIO_CARR_ON;
 584         PortP->ModemState &= ~MSVR1_CD;
 585         /*
 586         ** If the device was open as both a Modem and a tty line
 587         ** then we need to wimp out here, as the port has not really
 588         ** been finally closed (gee, whizz!) The test here uses the
 589         ** bit for the OTHER mode of operation, to see if THAT is
 590         ** still active!
 591         */
 592         if ( (PortP->State & (RIO_LOPEN|RIO_MOPEN)) ) {
 593                 /*
 594                 ** The port is still open for the other task -
 595                 ** return, pretending that we are still active.
 596                 */
 597                 rio_dprintk (RIO_DEBUG_TTY, "Channel %d still open !\n",PortP->PortNum);
 598                 PortP->State &= ~RIO_CLOSING;
 599                 if (PortP->firstOpen)
 600                         PortP->firstOpen--;
 601                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 602                 return -EIO;
 603         }
 604
 605         rio_dprintk (RIO_DEBUG_TTY, "Closing down - everything must go!\n");
 606
 607         PortP->State &= ~RIO_DYNOROD;
 608
 609         /*
 610         ** This is where we wait for the port
 611         ** to drain down before closing. Bye-bye....
 612         ** (We never meant to do this)
 613         */
 614         rio_dprintk (RIO_DEBUG_TTY, "Timeout 1 starts\n");
 615
 616         if (!deleted)
 617         while ( (PortP->InUse != NOT_INUSE) && !p->RIOHalted &&
 618                 (PortP->TxBufferIn != PortP->TxBufferOut) ) {
 619                 cprintf("Need to flush the ttyport\n");
 620                 if (repeat_this -- <= 0) {
 621                         rv = -EINTR;
 622                         rio_dprintk (RIO_DEBUG_TTY, "Waiting for not idle closed broken by signal\n");
 623                         RIOPreemptiveCmd(p, PortP, FCLOSE );
 624                         goto close_end;
 625                 }
 626                 rio_dprintk (RIO_DEBUG_TTY, "Calling timeout to flush in closing\n");
 627                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 628                 if (RIODelay_ni(PortP, HUNDRED_MS*10) == RIO_FAIL) {
 629                         rio_dprintk (RIO_DEBUG_TTY, "RTA EINTR in delay \n");
 630                         rv = -EINTR;
 631                         rio_spin_lock_irqsave(&PortP->portSem, flags);
 632                         goto close_end;
 633                 }
 634                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 635         }
 636
 637         PortP->TxBufferIn = PortP->TxBufferOut = 0;
 638         repeat_this = 0xff;
 639
 640         PortP->InUse = 0;
 641         if ( (PortP->State & (RIO_LOPEN|RIO_MOPEN)) ) {
 642                 /*
 643                 ** The port has been re-opened for the other task -
 644                 ** return, pretending that we are still active.
 645                 */
 646                 rio_dprintk (RIO_DEBUG_TTY, "Channel %d re-open!\n", PortP->PortNum);
 647                 PortP->State &= ~RIO_CLOSING;
 648                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 649                 if (PortP->firstOpen)
 650                         PortP->firstOpen--;
 651                 return -EIO;
 652         }
 653
 654         if ( p->RIOHalted ) {
 655                 RIOClearUp( PortP );
 656                 goto close_end;
 657         }
 658
 659
 660
 661         /* Can't call RIOShortCommand with the port locked. */
 662         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 663
 664         if (RIOShortCommand(p, PortP, CLOSE, 1, 0) == RIO_FAIL) {
 665           RIOPreemptiveCmd(p, PortP,FCLOSE);
 666           goto close_end;
 667         }
 668
 669         if (!deleted)
 670           while (try && (PortP->PortState & PORT_ISOPEN)) {
 671                 try--;
 672                 if (time_after (jiffies, end_time)) {
 673                   rio_dprintk (RIO_DEBUG_TTY, "Run out of tries - force the bugger shut!\n" );
 674                   RIOPreemptiveCmd(p, PortP,FCLOSE);
 675                   break;
 676                 }
 677                 rio_dprintk (RIO_DEBUG_TTY, "Close: PortState:ISOPEN is %d\n",
 678                                            PortP->PortState & PORT_ISOPEN);
 679
 680                 if ( p->RIOHalted ) {
 681                         RIOClearUp( PortP );
 682                         goto close_end;
 683                 }
 684                 if (RIODelay(PortP, HUNDRED_MS) == RIO_FAIL) {
 685                         rio_dprintk (RIO_DEBUG_TTY, "RTA EINTR in delay \n");
 686                         RIOPreemptiveCmd(p, PortP,FCLOSE);
 687                         break;
 688                 }
 689         }
 690         rio_spin_lock_irqsave(&PortP->portSem, flags);
 691         rio_dprintk (RIO_DEBUG_TTY, "Close: try was %d on completion\n", try );
 692
 693         /* RIOPreemptiveCmd(p, PortP, FCLOSE); */
 694
 695 /*
 696 ** 15.10.1998 ARG - ESIL 0761 part fix
 697 ** 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.
 698 */
 699         PortP->Config &= ~(RIO_CTSFLOW|RIO_RTSFLOW);
 700
 701
 702 #ifdef STATS
 703         PortP->Stat.CloseCnt++;
 704 #endif
 705         /*
 706         ** Count opens for port statistics reporting
 707         */
 708         if (PortP->statsGather)
 709                 PortP->closes++;
 710
 711 close_end:
 712         /* XXX: Why would a "DELETED" flag be reset here? I'd have
 713            thought that a "deleted" flag means that the port was
 714            permanently gone, but here we can make it reappear by it
 715            being in close during the "deletion".
 716         */
 717         PortP->State &= ~(RIO_CLOSING|RIO_DELETED);
 718         if (PortP->firstOpen)
 719                 PortP->firstOpen--;
 720         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 721         rio_dprintk (RIO_DEBUG_TTY, "Return from close\n");
 722         return rv;
 723 }
 724
 725
 726 /*
 727 ** decide if we need to use the line discipline.
 728 ** This routine can return one of three values:
 729 ** COOK_RAW if no processing has to be done by the line discipline or the card
 730 ** COOK_WELL if the line discipline must be used to do the processing
 731 ** COOK_MEDIUM if the card can do all the processing necessary.
 732 */
 733 #if 0
 734 static int
 735 RIOCookMode(struct ttystatics *tp)
 736 {
 737         /*
 738         ** We can't handle tm.c_mstate != 0 on SCO
 739         ** We can't handle mapping
 740         ** We can't handle non-ttwrite line disc.
 741         ** We can't handle lflag XCASE
 742         ** We can handle oflag OPOST & (OCRNL, ONLCR, TAB3)
 743         */
 744
 745 #ifdef CHECK
 746         CheckTtyP( tp );
 747 #endif
 748         if (!(tp->tm.c_oflag & OPOST))  /* No post processing */
 749                 return COOK_RAW;        /* Raw mode o/p */
 750
 751         if ( tp->tm.c_lflag & XCASE )
 752                 return COOK_WELL;       /* Use line disc */
 753
 754         if (tp->tm.c_oflag & ~(OPOST | ONLCR | OCRNL | TAB3 ) )
 755                 return COOK_WELL;       /* Use line disc for strange modes */
 756
 757         if ( tp->tm.c_oflag == OPOST )  /* If only OPOST is set, do RAW */
 758                 return COOK_RAW;
 759
 760         /*
 761         ** So, we need to output process!
 762         */
 763         return COOK_MEDIUM;
 764 }
 765 #endif
 766
 767 static void
 768 RIOClearUp(PortP)
 769 struct Port *PortP;
 770 {
 771         rio_dprintk (RIO_DEBUG_TTY, "RIOHalted set\n");
 772         PortP->Config = 0;        /* Direct semaphore */
 773         PortP->PortState = 0;
 774         PortP->firstOpen = 0;
 775         PortP->FlushCmdBodge = 0;
 776         PortP->ModemState = PortP->CookMode = 0;
 777         PortP->Mapped = 0;
 778         PortP->WflushFlag = 0;
 779         PortP->MagicFlags       = 0;
 780         PortP->RxDataStart = 0;
 781         PortP->TxBufferIn = 0;
 782         PortP->TxBufferOut = 0;
 783 }
 784
 785 /*
 786 ** Put a command onto a port.
 787 ** The PortPointer, command, length and arg are passed.
 788 ** The len is the length *inclusive* of the command byte,
 789 ** and so for a command that takes no data, len==1.
 790 ** The arg is a single byte, and is only used if len==2.
 791 ** Other values of len aren't allowed, and will cause
 792 ** a panic.
 793 */
 794 int RIOShortCommand(struct rio_info *p, struct Port *PortP,
 795                 int command, int len, int arg)
 796 {
 797         PKT *PacketP;
 798         int             retries = 20; /* at 10 per second -> 2 seconds */
 799         unsigned long flags;
 800
 801         rio_dprintk (RIO_DEBUG_TTY, "entering shortcommand.\n");
 802 #ifdef CHECK
 803         CheckPortP( PortP );
 804         if ( len < 1 || len > 2 )
 805                 cprintf(("STUPID LENGTH %d\n",len));
 806 #endif
 807
 808         if ( PortP->State & RIO_DELETED ) {
 809                 rio_dprintk (RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n");
 810                 return RIO_FAIL;
 811         }
 812         rio_spin_lock_irqsave(&PortP->portSem, flags);
 813
 814         /*
 815         ** If the port is in use for pre-emptive command, then wait for it to
 816         ** be free again.
 817         */
 818         while ( (PortP->InUse != NOT_INUSE) && !p->RIOHalted ) {
 819                 rio_dprintk (RIO_DEBUG_TTY, "Waiting for not in use (%d)\n",
 820                                            retries);
 821                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 822                 if (retries-- <= 0) {
 823                         return RIO_FAIL;
 824                 }
 825                 if (RIODelay_ni(PortP, HUNDRED_MS) == RIO_FAIL) {
 826                         return RIO_FAIL;
 827                 }
 828                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 829         }
 830         if ( PortP->State & RIO_DELETED ) {
 831                 rio_dprintk (RIO_DEBUG_TTY, "Short command to deleted RTA ignored\n");
 832                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 833                 return RIO_FAIL;
 834         }
 835
 836         while ( !can_add_transmit(&PacketP,PortP) && !p->RIOHalted ) {
 837                 rio_dprintk (RIO_DEBUG_TTY, "Waiting to add short command to queue (%d)\n", retries);
 838                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 839                 if (retries-- <= 0) {
 840                   rio_dprintk (RIO_DEBUG_TTY, "out of tries. Failing\n");
 841                         return RIO_FAIL;
 842                 }
 843                 if ( RIODelay_ni(PortP, HUNDRED_MS)==RIO_FAIL ) {
 844                         return RIO_FAIL;
 845                 }
 846                 rio_spin_lock_irqsave(&PortP->portSem, flags);
 847         }
 848
 849         if ( p->RIOHalted ) {
 850                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 851                 return RIO_FAIL;
 852         }
 853
 854         /*
 855         ** set the command byte and the argument byte
 856         */
 857         WBYTE(PacketP->data[0] , command);
 858
 859         if ( len==2 )
 860                 WBYTE(PacketP->data[1] , arg);
 861
 862         /*
 863         ** set the length of the packet and set the command bit.
 864         */
 865         WBYTE(PacketP->len , PKT_CMD_BIT | len);
 866
 867         add_transmit(PortP);
 868         /*
 869         ** Count characters transmitted for port statistics reporting
 870         */
 871         if (PortP->statsGather)
 872                 PortP->txchars += len;
 873
 874         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 875         return p->RIOHalted ? RIO_FAIL : ~RIO_FAIL;
 876 }
 877
 878
 879 #if 0
 880 /*
 881 ** This is an ioctl interface. This is the twentieth century. You know what
 882 ** its all about.
 883 */
 884 int
 885 riotioctl(struct rio_info *p, struct tty_struct *tty, int cmd, caddr_t arg)
 886 {
 887         register struct         Port *PortP;
 888         register struct         ttystatics *tp;
 889         int                                     current;
 890         int                                     ParamSemIncremented = 0;
 891         int                                     old_oflag, old_cflag, old_iflag, changed, oldcook;
 892         int                                     i;
 893         unsigned char           sio_regs[5];            /* Here be magic */
 894         short                           vpix_cflag;
 895         short                           divisor;
 896         int                                     baud;
 897         uint                            SysPort = rio_minor(tty);
 898         int                             Modem = rio_ismodem(tty);
 899         int                                     ioctl_processed;
 900
 901         rio_dprintk (RIO_DEBUG_TTY, "port ioctl SysPort %d command 0x%x argument 0x%x %s\n",
 902                         SysPort, cmd, arg, Modem?"Modem":"tty") ;
 903
 904         if ( SysPort >= RIO_PORTS ) {
 905                 rio_dprintk (RIO_DEBUG_TTY, "Bad port number %d\n", SysPort);
 906                 return -ENXIO;
 907         }
 908
 909         PortP = p->RIOPortp[SysPort];
 910         tp = PortP->TtyP;
 911
 912         rio_spin_lock_irqsave(&PortP->portSem, flags);
 913
 914 #ifdef STATS
 915         PortP->Stat.IoctlCnt++;
 916 #endif
 917
 918         if ( PortP->State & RIO_DELETED ) {
 919                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 920                 return -EIO;
 921         }
 922
 923
 924         if ( p->RIOHalted ) {
 925                 RIOClearUp( PortP );
 926                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 927                 return -EIO;
 928         }
 929
 930         /*
 931         ** Count ioctls for port statistics reporting
 932         */
 933         if (PortP->statsGather)
 934                 PortP->ioctls++;
 935
 936         /*
 937         ** Specialix RIO Ioctl calls
 938         */
 939         switch (cmd) {
 940
 941                 case TCRIOTRIAD:
 942                         if ( arg )
 943                                 PortP->State |= RIO_TRIAD_MODE;
 944                         else
 945                                 PortP->State &= ~RIO_TRIAD_MODE;
 946                         /*
 947                         ** Normally, when istrip is set on a port, a config is
 948                         ** sent to the RTA instructing the CD1400 to do the
 949                         ** stripping. In TRIAD mode, the interrupt receive routine
 950                         ** must do the stripping instead, since it has to detect
 951                         ** an 8 bit function key sequence. If istrip is set with
 952                         ** TRIAD mode on(off), and 8 bit data is being read by
 953                         ** the port, the user then turns TRIAD mode off(on), the RTA
 954                         ** must be reconfigured (not) to do the stripping.
 955                         ** Hence we call RIOParam here.
 956                         */
 957                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 958                         RIOParam(PortP,CONFIG,Modem,OK_TO_SLEEP);
 959                         return 0;
 960
 961                 case TCRIOTSTATE:
 962                         rio_dprintk (RIO_DEBUG_TTY, "tbusy/tstop monitoring %sabled\n",
 963                                 arg ? "en" : "dis");
 964                         /* MonitorTstate = 0 ;*/
 965                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 966                         RIOParam(PortP, CONFIG, Modem, OK_TO_SLEEP);
 967                         return 0;
 968
 969                 case TCRIOSTATE: /* current state of Modem input pins */
 970                         rio_dprintk (RIO_DEBUG_TTY, "TCRIOSTATE\n");
 971                         if (RIOPreemptiveCmd(p, PortP, MGET) == RIO_FAIL)
 972                                 rio_dprintk (RIO_DEBUG_TTY, "TCRIOSTATE command failed\n");
 973                         PortP->State |= RIO_BUSY;
 974                         current = PortP->ModemState;
 975                         if ( copyout((caddr_t)&current, (int)arg,
 976                                                         sizeof(current))==COPYFAIL ) {
 977                                 rio_dprintk (RIO_DEBUG_TTY, "Copyout failed\n");
 978                                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 979                                 pseterr(EFAULT);
 980                         }
 981                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
 982                         return 0;
 983
 984                 case TCRIOMBIS:         /* Set modem lines */
 985                 case TCRIOMBIC:         /* Clear modem lines */
 986                         rio_dprintk (RIO_DEBUG_TTY, "TCRIOMBIS/TCRIOMBIC\n");
 987                         if (cmd == TCRIOMBIS) {
 988                                 uint            state;
 989                                 state = (uint)arg;
 990                                 PortP->ModemState |= (ushort)state;
 991                                 PortP->ModemLines = (ulong) arg;
 992                                 if (RIOPreemptiveCmd(p, PortP, MBIS) == RIO_FAIL)
 993                                         rio_dprintk (RIO_DEBUG_TTY,
 994                                          "TCRIOMBIS command failed\n");
 995                         }
 996                         else {
 997                                 uint            state;
 998
 999                                 state = (uint)arg;
1000                                 PortP->ModemState &= ~(ushort)state;
1001                                 PortP->ModemLines = (ulong) arg;
1002                                 if (RIOPreemptiveCmd(p, PortP, MBIC) == RIO_FAIL)
1003                                         rio_dprintk (RIO_DEBUG_TTY, "TCRIOMBIC command failed\n");
1004                         }
1005                         PortP->State |= RIO_BUSY;
1006                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1007                         return 0;
1008
1009                 case TCRIOXPON: /* set Xprint ON string */
1010                         rio_dprintk (RIO_DEBUG_TTY, "TCRIOXPON\n");
1011                         if ( copyin((int)arg, (caddr_t)PortP->Xprint.XpOn,
1012                                                 MAX_XP_CTRL_LEN)==COPYFAIL ) {
1013                                 rio_dprintk (RIO_DEBUG_TTY, "Copyin failed\n");
1014                                 PortP->Xprint.XpOn[0] = '\0';
1015                                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1016                                 pseterr(EFAULT);
1017                         }
1018                         PortP->Xprint.XpOn[MAX_XP_CTRL_LEN-1] = '\0';
1019                         PortP->Xprint.XpLen = strlen(PortP->Xprint.XpOn)+
1020                                                                                                 strlen(PortP->Xprint.XpOff);
1021                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1022                         return 0;
1023
1024                 case TCRIOXPOFF: /* set Xprint OFF string */
1025                         rio_dprintk (RIO_DEBUG_TTY, "TCRIOXPOFF\n");
1026                         if ( copyin( (int)arg, (caddr_t)PortP->Xprint.XpOff,
1027                                                 MAX_XP_CTRL_LEN)==COPYFAIL ) {
1028                                 rio_dprintk (RIO_DEBUG_TTY, "Copyin failed\n");
1029                                 PortP->Xprint.XpOff[0] = '\0';
1030                                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1031                                 pseterr(EFAULT);
1032                         }
1033                         PortP->Xprint.XpOff[MAX_XP_CTRL_LEN-1] = '\0';
1034                         PortP->Xprint.XpLen = strlen(PortP->Xprint.XpOn)+
1035                                                                                 strlen(PortP->Xprint.XpOff);
1036                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1037                         return 0;
1038
1039                 case TCRIOXPCPS: /* set Xprint CPS string */
1040                         rio_dprintk (RIO_DEBUG_TTY, "TCRIOXPCPS\n");
1041                         if ( (uint)arg > p->RIOConf.MaxXpCps ||
1042                                         (uint)arg < p->RIOConf.MinXpCps ) {
1043                                 rio_dprintk (RIO_DEBUG_TTY, "%d CPS out of range\n",arg);
1044                                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1045                                 pseterr(EINVAL);
1046                                 return 0;
1047                         }
1048                         PortP->Xprint.XpCps = (uint)arg;
1049                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1050                         return 0;
1051
1052                 case TCRIOXPRINT:
1053                         rio_dprintk (RIO_DEBUG_TTY, "TCRIOXPRINT\n");
1054                         if ( copyout((caddr_t)&PortP->Xprint, (int)arg,
1055                                         sizeof(struct Xprint))==COPYFAIL ) {
1056                                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1057                                 pseterr(EFAULT);
1058                         }
1059                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1060                         return 0;
1061
1062                 case TCRIOIXANYON:
1063                         rio_dprintk (RIO_DEBUG_TTY, "TCRIOIXANYON\n");
1064                         PortP->Config |= RIO_IXANY;
1065                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1066                         return 0;
1067
1068                 case TCRIOIXANYOFF:
1069                         rio_dprintk (RIO_DEBUG_TTY, "TCRIOIXANYOFF\n");
1070                         PortP->Config &= ~RIO_IXANY;
1071                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1072                         return 0;
1073
1074                 case TCRIOIXONON:
1075                         rio_dprintk (RIO_DEBUG_TTY, "TCRIOIXONON\n");
1076                         PortP->Config |= RIO_IXON;
1077                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1078                         return 0;
1079
1080                 case TCRIOIXONOFF:
1081                         rio_dprintk (RIO_DEBUG_TTY, "TCRIOIXONOFF\n");
1082                         PortP->Config &= ~RIO_IXON;
1083                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1084                         return 0;
1085
1086 /*
1087 ** 15.10.1998 ARG - ESIL 0761 part fix
1088 ** Added support for CTS and RTS flow control ioctls :
1089 */
1090                 case TCRIOCTSFLOWEN:
1091                         rio_dprintk (RIO_DEBUG_TTY, "TCRIOCTSFLOWEN\n");
1092                         PortP->Config |= RIO_CTSFLOW;
1093                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1094                         RIOParam(PortP,CONFIG,Modem,OK_TO_SLEEP);
1095                         return 0;
1096
1097                 case TCRIOCTSFLOWDIS:
1098                         rio_dprintk (RIO_DEBUG_TTY, "TCRIOCTSFLOWDIS\n");
1099                         PortP->Config &= ~RIO_CTSFLOW;
1100                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1101                         RIOParam(PortP,CONFIG,Modem,OK_TO_SLEEP);
1102                         return 0;
1103
1104                 case TCRIORTSFLOWEN:
1105                         rio_dprintk (RIO_DEBUG_TTY, "TCRIORTSFLOWEN\n");
1106                         PortP->Config |= RIO_RTSFLOW;
1107                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1108                         RIOParam(PortP,CONFIG,Modem,OK_TO_SLEEP);
1109                         return 0;
1110
1111                 case TCRIORTSFLOWDIS:
1112                         rio_dprintk (RIO_DEBUG_TTY, "TCRIORTSFLOWDIS\n");
1113                         PortP->Config &= ~RIO_RTSFLOW;
1114                         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1115                         RIOParam(PortP,CONFIG,Modem,OK_TO_SLEEP);
1116                         return 0;
1117
1118 /* end ESIL 0761 part fix */
1119
1120         }
1121
1122
1123         /* Lynx IOCTLS */
1124         switch (cmd) {
1125                 case TIOCSETP:
1126                 case TIOCSETN:
1127                 case OTIOCSETP:
1128                 case OTIOCSETN:
1129                         ioctl_processed++;
1130                         ttyseth(PortP, tp, (struct old_sgttyb *)arg);
1131                         break;
1132                 case TCSETA:
1133                 case TCSETAW:
1134                 case TCSETAF:
1135                         ioctl_processed++;
1136                         rio_dprintk (RIO_DEBUG_TTY, "NON POSIX ioctl\n");
1137                         ttyseth_pv(PortP, tp, (struct termios *)arg, 0);
1138                         break;
1139                 case TCSETAP:   /* posix tcsetattr() */
1140                 case TCSETAWP:  /* posix tcsetattr() */
1141                 case TCSETAFP:  /* posix tcsetattr() */
1142                         rio_dprintk (RIO_DEBUG_TTY, "NON POSIX SYSV ioctl\n");
1143                         ttyseth_pv(PortP, tp, (struct termios *)arg, 1);
1144                         ioctl_processed++;
1145                         break;
1146         }
1147
1148         /*
1149         ** If its any of the commands that require the port to be in the
1150         ** non-busy state wait until all output has drained
1151         */
1152         if (!ioctl_processed)
1153         switch(cmd) {
1154                 case TCSETAW:
1155                 case TCSETAF:
1156                 case TCSETA:
1157                 case TCSBRK:
1158 #define OLD_POSIX ('x' << 8)
1159 #define OLD_POSIX_SETA (OLD_POSIX | 2)
1160 #define OLD_POSIX_SETAW (OLD_POSIX | 3)
1161 #define OLD_POSIX_SETAF (OLD_POSIX | 4)
1162 #define NEW_POSIX (('i' << 24) | ('X' << 16))
1163 #define NEW_POSIX_SETA (NEW_POSIX | 2)
1164 #define NEW_POSIX_SETAW (NEW_POSIX | 3)
1165 #define NEW_POSIX_SETAF (NEW_POSIX | 4)
1166                 case OLD_POSIX_SETA:
1167                 case OLD_POSIX_SETAW:
1168                 case OLD_POSIX_SETAF:
1169                 case NEW_POSIX_SETA:
1170                 case NEW_POSIX_SETAW:
1171                 case NEW_POSIX_SETAF:
1172 #ifdef TIOCSETP
1173                 case TIOCSETP:
1174 #endif
1175                 case TIOCSETD:
1176                 case TIOCSETN:
1177                         rio_dprintk (RIO_DEBUG_TTY, "wait for non-BUSY, semaphore set\n");
1178                         /*
1179                         ** Wait for drain here, at least as far as the double buffer
1180                         ** being empty.
1181                         */
1182                         /* XXX Does the above comment mean that this has
1183                            still to be implemented? -- REW */
1184                         /* XXX Is the locking OK together with locking
1185                            in txenable? (Deadlock?) -- REW */
1186
1187                         RIOTxEnable((char *)PortP);
1188                         break;
1189                 default:
1190                         break;
1191         }
1192
1193         old_cflag = tp->tm.c_cflag;
1194         old_iflag = tp->tm.c_iflag;
1195         old_oflag = tp->tm.c_oflag;
1196         oldcook = PortP->CookMode;
1197
1198         if ( p->RIOHalted ) {
1199                 RIOClearUp( PortP );
1200                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1201                 pseterr(EIO);
1202                 return 0;
1203         }
1204
1205         PortP->FlushCmdBodge = 0;
1206
1207         /*
1208         ** If the port is locked, and it is reconfigured, we want
1209         ** to restore the state of the tty structure so the change is NOT
1210         ** made.
1211         */
1212         if (PortP->Lock) {
1213                 tp->tm.c_iflag = PortP->StoredTty.iflag;
1214                 tp->tm.c_oflag = PortP->StoredTty.oflag;
1215                 tp->tm.c_cflag = PortP->StoredTty.cflag;
1216                 tp->tm.c_lflag = PortP->StoredTty.lflag;
1217                 tp->tm.c_line = PortP->StoredTty.line;
1218                 for (i = 0; i < NCC + 1; i++)
1219                         tp->tm.c_cc[i] = PortP->StoredTty.cc[i];
1220         }
1221         else {
1222                 /*
1223                 ** If the port is set to store the parameters, and it is
1224                 ** reconfigured, we want to save the current tty struct so it
1225                 ** may be restored on the next open.
1226                 */
1227                 if (PortP->Store) {
1228                         PortP->StoredTty.iflag = tp->tm.c_iflag;
1229                         PortP->StoredTty.oflag = tp->tm.c_oflag;
1230                         PortP->StoredTty.cflag = tp->tm.c_cflag;
1231                         PortP->StoredTty.lflag = tp->tm.c_lflag;
1232                         PortP->StoredTty.line = tp->tm.c_line;
1233                         for (i = 0; i < NCC + 1; i++)
1234                                 PortP->StoredTty.cc[i] = tp->tm.c_cc[i];
1235                 }
1236         }
1237
1238         changed = (tp->tm.c_cflag != old_cflag) ||
1239                                 (tp->tm.c_iflag != old_iflag) ||
1240                                 (tp->tm.c_oflag != old_oflag);
1241
1242         PortP->CookMode = RIOCookMode(tp);      /* Set new cooking mode */
1243
1244         rio_dprintk (RIO_DEBUG_TTY, "RIOIoctl changed %d newcook %d oldcook %d\n",
1245                         changed,PortP->CookMode,oldcook);
1246
1247 #ifdef MODEM_SUPPORT
1248         /*
1249         ** kludge to force CARR_ON if CLOCAL set
1250         */
1251         if ((tp->tm.c_cflag & CLOCAL) || (PortP->ModemState & MSVR1_CD))        {
1252                 tp->tm.c_state |= CARR_ON;
1253                 wakeup ((caddr_t)&tp->tm.c_canq);
1254         }
1255 #endif
1256
1257         if ( p->RIOHalted ) {
1258                 RIOClearUp( PortP );
1259                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1260                 pseterr(EIO);
1261                 return 0;
1262         }
1263         /*
1264         ** Re-configure if modes or cooking have changed
1265         */
1266         if (changed || oldcook != PortP->CookMode || (ioctl_processed)) {
1267                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1268                 rio_dprintk (RIO_DEBUG_TTY, "Ioctl changing the PORT settings\n");
1269                 RIOParam(PortP,CONFIG,Modem,OK_TO_SLEEP);
1270                 rio_spin_lock_irqsave(&PortP->portSem, flags);
1271         }
1272
1273         if (p->RIOHalted) {
1274                 rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1275                 RIOClearUp( PortP );
1276                 pseterr(EIO);
1277                 return 0;
1278         }
1279         rio_spin_unlock_irqrestore(&PortP->portSem, flags);
1280         return 0;
1281 }
1282
1283 /*
1284         ttyseth -- set hardware dependent tty settings
1285 */
1286 void
1287 ttyseth(PortP, s, sg)
1288 struct Port *           PortP;
1289 struct ttystatics *             s;
1290 struct old_sgttyb *sg;
1291 {
1292         struct old_sgttyb *     tsg;
1293         struct termios *tp = &s->tm;
1294
1295         tsg = &s->sg;
1296
1297         if (sg->sg_flags & (EVENP|ODDP))  {
1298                 tp->c_cflag &= PARENB;
1299                 if (sg->sg_flags & EVENP) {
1300                         if (sg->sg_flags & ODDP) {
1301                                 tp->c_cflag &= V_CS7;
1302                                 tp->c_cflag &= ~PARENB;
1303                         }
1304                         else {
1305                                 tp->c_cflag &= V_CS7;
1306                                 tp->c_cflag &= PARENB;
1307                                 tp->c_cflag &= PARODD;
1308                         }
1309                 }
1310                 else if (sg->sg_flags & ODDP) {
1311                         tp->c_cflag &= V_CS7;
1312                         tp->c_cflag &= PARENB;
1313                         tp->c_cflag &= PARODD;
1314                 }
1315                 else {
1316                         tp->c_cflag &= V_CS7;
1317                         tp->c_cflag &= PARENB;
1318                 }
1319         }
1320 /*
1321  * Use ispeed as the desired speed.  Most implementations don't handle
1322  * separate input and output speeds very well. If the RIO handles this,
1323  * I will have to use separate sets of flags to store them in the
1324  * Port structure.
1325  */
1326         if ( !sg->sg_ospeed )
1327                 sg->sg_ospeed = sg->sg_ispeed;
1328         else
1329                 sg->sg_ispeed = sg->sg_ospeed;
1330         if (sg->sg_ispeed > V_EXTB )
1331                 sg->sg_ispeed = V_EXTB;
1332         if (sg->sg_ispeed < V_B0)
1333                 sg->sg_ispeed = V_B0;
1334         *tsg = *sg;
1335    tp->c_cflag = (tp->c_cflag & ~V_CBAUD) | conv_bv[(int)sg->sg_ispeed];
1336 }
1337
1338 /*
1339         ttyseth_pv -- set hardware dependent tty settings using either the
1340                         POSIX termios structure or the System V termio structure.
1341                                 sysv = 0 => (POSIX):     struct termios *sg
1342                                 sysv != 0 => (System V): struct termio *sg
1343 */
1344 static void
1345 ttyseth_pv(PortP, s, sg, sysv)
1346 struct Port *PortP;
1347 struct ttystatics *s;
1348 struct termios *sg;
1349 int sysv;
1350 {
1351     int speed;
1352     unsigned char csize;
1353     unsigned char cread;
1354     unsigned int lcr_flags;
1355     int ps;
1356
1357     if (sysv) {
1358         /* sg points to a System V termio structure */
1359         csize = ((struct termio *)sg)->c_cflag & CSIZE;
1360         cread = ((struct termio *)sg)->c_cflag & CREAD;
1361         speed = conv_vb[((struct termio *)sg)->c_cflag & V_CBAUD];
1362     }
1363     else {
1364         /* sg points to a POSIX termios structure */
1365         csize = sg->c_cflag & CSIZE;
1366         cread = sg->c_cflag & CREAD;
1367         speed = conv_vb[sg->c_cflag & V_CBAUD];
1368     }
1369     if (s->sg.sg_ispeed != speed || s->sg.sg_ospeed != speed) {
1370         s->sg.sg_ispeed = speed;
1371         s->sg.sg_ospeed = speed;
1372         s->tm.c_cflag = (s->tm.c_cflag & ~V_CBAUD) |
1373                          conv_bv[(int)s->sg.sg_ispeed];
1374     }
1375 }
1376 #endif