sys/dev/serial/stl/stallion.c

   1 /*****************************************************************************/
   2
   3 /*
   4  * stallion.c  -- stallion multiport serial driver.
   5  *
   6  * Copyright (c) 1995-1996 Greg Ungerer (gerg@stallion.oz.au).
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. All advertising materials mentioning features or use of this software
  18  *    must display the following acknowledgement:
  19  *      This product includes software developed by Greg Ungerer.
  20  * 4. Neither the name of the author nor the names of any co-contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  * $FreeBSD: src/sys/i386/isa/stallion.c,v 1.39.2.2 2001/08/30 12:29:57 murray Exp $
  37  * $DragonFly: src/sys/dev/serial/stl/stallion.c,v 1.14 2005/06/16 21:12:42 dillon Exp $
  38  */
  39
  40 /*****************************************************************************/
  41
  42 #define TTYDEFCHARS     1
  43
  44 #include "use_pci.h"
  45 #include "opt_compat.h"
  46
  47 #include <sys/param.h>
  48 #include <sys/systm.h>
  49 #include <sys/kernel.h>
  50 #include <sys/malloc.h>
  51 #include <sys/tty.h>
  52 #include <sys/proc.h>
  53 #include <sys/conf.h>
  54 #include <sys/fcntl.h>
  55 #include <sys/thread2.h>
  56 #include <bus/isa/i386/isa_device.h>
  57 #include <i386/isa/ic/scd1400.h>
  58 #include <i386/isa/ic/sc26198.h>
  59 #include <machine/comstats.h>
  60
  61 #if NPCI > 0
  62 #include <bus/pci/pcivar.h>
  63 #include <bus/pci/pcireg.h>
  64 #endif
  65
  66 #undef STLDEBUG
  67
  68 /*****************************************************************************/
  69
  70 /*
  71  *      Define the version level of the kernel - so we can compile in the
  72  *      appropriate bits of code. By default this will compile for a 2.1
  73  *      level kernel.
  74  */
  75 #define VFREEBSD        220
  76
  77 #if VFREEBSD >= 220
  78 #define STATIC          static
  79 #else
  80 #define STATIC
  81 #endif
  82
  83 /*****************************************************************************/
  84
  85 /*
  86  *      Define different board types. At the moment I have only declared
  87  *      those boards that this driver supports. But I will use the standard
  88  *      "assigned" board numbers. In the future this driver will support
  89  *      some of the other Stallion boards. Currently supported boards are
  90  *      abbreviated as EIO = EasyIO and ECH = EasyConnection 8/32.
  91  */
  92 #define BRD_EASYIO      20
  93 #define BRD_ECH         21
  94 #define BRD_ECHMC       22
  95 #define BRD_ECHPCI      26
  96 #define BRD_ECH64PCI    27
  97 #define BRD_EASYIOPCI   28
  98
  99 /*
 100  *      When using the BSD "config" stuff there is no easy way to specifiy
 101  *      a secondary IO address region. So it is hard wired here. Also the
 102  *      shared interrupt information is hard wired here...
 103  */
 104 static unsigned int     stl_ioshared = 0x280;
 105 static unsigned int     stl_irqshared = 0;
 106
 107 /*****************************************************************************/
 108
 109 /*
 110  *      Define important driver limitations.
 111  */
 112 #define STL_MAXBRDS             8
 113 #define STL_MAXPANELS           4
 114 #define STL_MAXBANKS            8
 115 #define STL_PORTSPERPANEL       16
 116 #define STL_PORTSPERBRD         64
 117
 118 /*
 119  *      Define the important minor number break down bits. These have been
 120  *      chosen to be "compatible" with the standard sio driver minor numbers.
 121  *      Extra high bits are used to distinguish between boards.
 122  */
 123 #define STL_CALLOUTDEV          0x80
 124 #define STL_CTRLLOCK            0x40
 125 #define STL_CTRLINIT            0x20
 126 #define STL_CTRLDEV             (STL_CTRLLOCK | STL_CTRLINIT)
 127
 128 #define STL_MEMDEV      0x07000000
 129
 130 #define STL_DEFSPEED    TTYDEF_SPEED
 131 #define STL_DEFCFLAG    (CS8 | CREAD | HUPCL)
 132
 133 /*
 134  *      I haven't really decided (or measured) what buffer sizes give
 135  *      a good balance between performance and memory usage. These seem
 136  *      to work pretty well...
 137  */
 138 #define STL_RXBUFSIZE           2048
 139 #define STL_TXBUFSIZE           2048
 140
 141 #define STL_TXBUFLOW            (STL_TXBUFSIZE / 4)
 142 #define STL_RXBUFHIGH           (3 * STL_RXBUFSIZE / 4)
 143
 144 /*****************************************************************************/
 145
 146 /*
 147  *      Define our local driver identity first. Set up stuff to deal with
 148  *      all the local structures required by a serial tty driver.
 149  */
 150 static const char       stl_drvname[] = "stl";
 151 static const char       stl_longdrvname[] = "Stallion Multiport Serial Driver";
 152 static const char       stl_drvversion[] = "2.0.0";
 153 static int              stl_brdprobed[STL_MAXBRDS];
 154
 155 static int              stl_nrbrds = 0;
 156 static int              stl_doingtimeout = 0;
 157 static struct callout   stl_poll_ch;
 158
 159 static const char       __file__[] = /*__FILE__*/ "stallion.c";
 160
 161 /*
 162  *      Define global stats structures. Not used often, and can be
 163  *      re-used for each stats call.
 164  */
 165 static combrd_t         stl_brdstats;
 166 static comstats_t       stl_comstats;
 167
 168 /*****************************************************************************/
 169
 170 /*
 171  *      Define a set of structures to hold all the board/panel/port info
 172  *      for our ports. These will be dynamically allocated as required.
 173  */
 174
 175 /*
 176  *      Define a ring queue structure for each port. This will hold the
 177  *      TX data waiting to be output. Characters are fed into this buffer
 178  *      from the line discipline (or even direct from user space!) and
 179  *      then fed into the UARTs during interrupts. Will use a clasic ring
 180  *      queue here for this. The good thing about this type of ring queue
 181  *      is that the head and tail pointers can be updated without interrupt
 182  *      protection - since "write" code only needs to change the head, and
 183  *      interrupt code only needs to change the tail.
 184  */
 185 typedef struct {
 186         char    *buf;
 187         char    *endbuf;
 188         char    *head;
 189         char    *tail;
 190 } stlrq_t;
 191
 192 /*
 193  *      Port, panel and board structures to hold status info about each.
 194  *      The board structure contains pointers to structures for each panel
 195  *      connected to it, and in turn each panel structure contains pointers
 196  *      for each port structure for each port on that panel. Note that
 197  *      the port structure also contains the board and panel number that it
 198  *      is associated with, this makes it (fairly) easy to get back to the
 199  *      board/panel info for a port. Also note that the tty struct is at
 200  *      the top of the structure, this is important, since the code uses
 201  *      this fact to get the port struct pointer from the tty struct
 202  *      pointer!
 203  */
 204 typedef struct stlport {
 205         struct tty      tty;
 206         int             portnr;
 207         int             panelnr;
 208         int             brdnr;
 209         int             ioaddr;
 210         int             uartaddr;
 211         int             pagenr;
 212         int             callout;
 213         int             brklen;
 214         int             dtrwait;
 215         int             dotimestamp;
 216         int             waitopens;
 217         int             hotchar;
 218         void            *uartp;
 219         unsigned int    state;
 220         unsigned int    hwid;
 221         unsigned int    sigs;
 222         unsigned int    rxignoremsk;
 223         unsigned int    rxmarkmsk;
 224         unsigned int    crenable;
 225         unsigned int    imr;
 226         unsigned long   clk;
 227         struct termios  initintios;
 228         struct termios  initouttios;
 229         struct termios  lockintios;
 230         struct termios  lockouttios;
 231         struct timeval  timestamp;
 232         comstats_t      stats;
 233         stlrq_t         tx;
 234         stlrq_t         rx;
 235         stlrq_t         rxstatus;
 236         struct callout  dtr_ch;
 237 } stlport_t;
 238
 239 typedef struct stlpanel {
 240         int             panelnr;
 241         int             brdnr;
 242         int             pagenr;
 243         int             nrports;
 244         int             iobase;
 245         unsigned int    hwid;
 246         unsigned int    ackmask;
 247         void            (*isr)(struct stlpanel *panelp, unsigned int iobase);
 248         void            *uartp;
 249         stlport_t       *ports[STL_PORTSPERPANEL];
 250 } stlpanel_t;
 251
 252 typedef struct stlbrd {
 253         int             brdnr;
 254         int             brdtype;
 255         int             unitid;
 256         int             state;
 257         int             nrpanels;
 258         int             nrports;
 259         int             nrbnks;
 260         int             irq;
 261         int             irqtype;
 262         unsigned int    ioaddr1;
 263         unsigned int    ioaddr2;
 264         unsigned int    iostatus;
 265         unsigned int    ioctrl;
 266         unsigned int    ioctrlval;
 267         unsigned int    hwid;
 268         unsigned long   clk;
 269         void            (*isr)(struct stlbrd *brdp);
 270         unsigned int    bnkpageaddr[STL_MAXBANKS];
 271         unsigned int    bnkstataddr[STL_MAXBANKS];
 272         stlpanel_t      *bnk2panel[STL_MAXBANKS];
 273         stlpanel_t      *panels[STL_MAXPANELS];
 274         stlport_t       *ports[STL_PORTSPERBRD];
 275 } stlbrd_t;
 276
 277 static stlbrd_t         *stl_brds[STL_MAXBRDS];
 278
 279 /*
 280  *      Per board state flags. Used with the state field of the board struct.
 281  *      Not really much here yet!
 282  */
 283 #define BRD_FOUND       0x1
 284
 285 /*
 286  *      Define the port structure state flags. These set of flags are
 287  *      modified at interrupt time - so setting and reseting them needs
 288  *      to be atomic.
 289  */
 290 #define ASY_TXLOW       0x1
 291 #define ASY_RXDATA      0x2
 292 #define ASY_DCDCHANGE   0x4
 293 #define ASY_DTRWAIT     0x8
 294 #define ASY_RTSFLOW     0x10
 295 #define ASY_RTSFLOWMODE 0x20
 296 #define ASY_CTSFLOWMODE 0x40
 297 #define ASY_TXFLOWED    0x80
 298 #define ASY_TXBUSY      0x100
 299 #define ASY_TXEMPTY     0x200
 300
 301 #define ASY_ACTIVE      (ASY_TXLOW | ASY_RXDATA | ASY_DCDCHANGE)
 302
 303 /*
 304  *      Define an array of board names as printable strings. Handy for
 305  *      referencing boards when printing trace and stuff.
 306  */
 307 static char     *stl_brdnames[] = {
 308         (char *) NULL,
 309         (char *) NULL,
 310         (char *) NULL,
 311         (char *) NULL,
 312         (char *) NULL,
 313         (char *) NULL,
 314         (char *) NULL,
 315         (char *) NULL,
 316         (char *) NULL,
 317         (char *) NULL,
 318         (char *) NULL,
 319         (char *) NULL,
 320         (char *) NULL,
 321         (char *) NULL,
 322         (char *) NULL,
 323         (char *) NULL,
 324         (char *) NULL,
 325         (char *) NULL,
 326         (char *) NULL,
 327         (char *) NULL,
 328         "EasyIO",
 329         "EC8/32-AT",
 330         "EC8/32-MC",
 331         (char *) NULL,
 332         (char *) NULL,
 333         (char *) NULL,
 334         "EC8/32-PCI",
 335         "EC8/64-PCI",
 336         "EasyIO-PCI",
 337 };
 338
 339 /*****************************************************************************/
 340
 341 /*
 342  *      Hardware ID bits for the EasyIO and ECH boards. These defines apply
 343  *      to the directly accessable io ports of these boards (not the cd1400
 344  *      uarts - they are in scd1400.h).
 345  */
 346 #define EIO_8PORTRS     0x04
 347 #define EIO_4PORTRS     0x05
 348 #define EIO_8PORTDI     0x00
 349 #define EIO_8PORTM      0x06
 350 #define EIO_MK3         0x03
 351 #define EIO_IDBITMASK   0x07
 352
 353 #define EIO_BRDMASK     0xf0
 354 #define ID_BRD4         0x10
 355 #define ID_BRD8         0x20
 356 #define ID_BRD16        0x30
 357
 358 #define EIO_INTRPEND    0x08
 359 #define EIO_INTEDGE     0x00
 360 #define EIO_INTLEVEL    0x08
 361
 362 #define ECH_ID          0xa0
 363 #define ECH_IDBITMASK   0xe0
 364 #define ECH_BRDENABLE   0x08
 365 #define ECH_BRDDISABLE  0x00
 366 #define ECH_INTENABLE   0x01
 367 #define ECH_INTDISABLE  0x00
 368 #define ECH_INTLEVEL    0x02
 369 #define ECH_INTEDGE     0x00
 370 #define ECH_INTRPEND    0x01
 371 #define ECH_BRDRESET    0x01
 372
 373 #define ECHMC_INTENABLE 0x01
 374 #define ECHMC_BRDRESET  0x02
 375
 376 #define ECH_PNLSTATUS   2
 377 #define ECH_PNL16PORT   0x20
 378 #define ECH_PNLIDMASK   0x07
 379 #define ECH_PNLXPID     0x40
 380 #define ECH_PNLINTRPEND 0x80
 381 #define ECH_ADDR2MASK   0x1e0
 382
 383 #define EIO_CLK         25000000
 384 #define EIO_CLK8M       20000000
 385 #define ECH_CLK         EIO_CLK
 386
 387 /*
 388  *      Define the PCI vendor and device ID for Stallion PCI boards.
 389  */
 390 #define STL_PCINSVENDID 0x100b
 391 #define STL_PCINSDEVID  0xd001
 392
 393 #define STL_PCIVENDID   0x124d
 394 #define STL_PCI32DEVID  0x0000
 395 #define STL_PCI64DEVID  0x0002
 396 #define STL_PCIEIODEVID 0x0003
 397
 398 #define STL_PCIBADCLASS 0x0101
 399
 400 typedef struct stlpcibrd {
 401         unsigned short          vendid;
 402         unsigned short          devid;
 403         int                     brdtype;
 404 } stlpcibrd_t;
 405
 406 static  stlpcibrd_t     stl_pcibrds[] = {
 407         { STL_PCIVENDID, STL_PCI64DEVID, BRD_ECH64PCI },
 408         { STL_PCIVENDID, STL_PCIEIODEVID, BRD_EASYIOPCI },
 409         { STL_PCIVENDID, STL_PCI32DEVID, BRD_ECHPCI },
 410         { STL_PCINSVENDID, STL_PCINSDEVID, BRD_ECHPCI },
 411 };
 412
 413 static int      stl_nrpcibrds = sizeof(stl_pcibrds) / sizeof(stlpcibrd_t);
 414
 415 /*****************************************************************************/
 416
 417 /*
 418  *      Define the vector mapping bits for the programmable interrupt board
 419  *      hardware. These bits encode the interrupt for the board to use - it
 420  *      is software selectable (except the EIO-8M).
 421  */
 422 static unsigned char    stl_vecmap[] = {
 423         0xff, 0xff, 0xff, 0x04, 0x06, 0x05, 0xff, 0x07,
 424         0xff, 0xff, 0x00, 0x02, 0x01, 0xff, 0xff, 0x03
 425 };
 426
 427 /*
 428  *      Set up enable and disable macros for the ECH boards. They require
 429  *      the secondary io address space to be activated and deactivated.
 430  *      This way all ECH boards can share their secondary io region.
 431  *      If this is an ECH-PCI board then also need to set the page pointer
 432  *      to point to the correct page.
 433  */
 434 #define BRDENABLE(brdnr,pagenr)                                         \
 435         if (stl_brds[(brdnr)]->brdtype == BRD_ECH)                      \
 436                 outb(stl_brds[(brdnr)]->ioctrl,                         \
 437                         (stl_brds[(brdnr)]->ioctrlval | ECH_BRDENABLE));\
 438         else if (stl_brds[(brdnr)]->brdtype == BRD_ECHPCI)              \
 439                 outb(stl_brds[(brdnr)]->ioctrl, (pagenr));
 440
 441 #define BRDDISABLE(brdnr)                                               \
 442         if (stl_brds[(brdnr)]->brdtype == BRD_ECH)                      \
 443                 outb(stl_brds[(brdnr)]->ioctrl,                         \
 444                         (stl_brds[(brdnr)]->ioctrlval | ECH_BRDDISABLE));
 445
 446 /*
 447  *      Define some spare buffer space for un-wanted received characters.
 448  */
 449 static char     stl_unwanted[SC26198_RXFIFOSIZE];
 450
 451 /*****************************************************************************/
 452
 453 /*
 454  *      Define macros to extract a brd and port number from a minor number.
 455  *      This uses the extended minor number range in the upper 2 bytes of
 456  *      the device number. This gives us plenty of minor numbers to play
 457  *      with...
 458  */
 459 #define MKDEV2BRD(m)    ((minor(m) & 0x00700000) >> 20)
 460 #define MKDEV2PORT(m)   ((minor(m) & 0x1f) | ((minor(m) & 0x00010000) >> 11))
 461
 462 /*
 463  *      Define some handy local macros...
 464  */
 465 #ifndef MIN
 466 #define MIN(a,b)        (((a) <= (b)) ? (a) : (b))
 467 #endif
 468
 469 /*****************************************************************************/
 470
 471 /*
 472  *      Declare all those functions in this driver!  First up is the set of
 473  *      externally visible functions.
 474  */
 475
 476 static int      stlprobe(struct isa_device *idp);
 477 static int      stlattach(struct isa_device *idp);
 478
 479 STATIC  d_open_t        stlopen;
 480 STATIC  d_close_t       stlclose;
 481 STATIC  d_ioctl_t       stlioctl;
 482
 483 /*
 484  *      Internal function prototypes.
 485  */
 486 static stlport_t *stl_dev2port(dev_t dev);
 487 static int      stl_findfreeunit(void);
 488 static int      stl_rawopen(stlport_t *portp);
 489 static int      stl_rawclose(stlport_t *portp);
 490 static void     stl_flush(stlport_t *portp, int flag);
 491 static int      stl_param(struct tty *tp, struct termios *tiosp);
 492 static void     stl_start(struct tty *tp);
 493 static void     stl_stop(struct tty *tp, int);
 494 static void     stl_ttyoptim(stlport_t *portp, struct termios *tiosp);
 495 static void     stl_dotimeout(void);
 496 static void     stl_poll(void *arg);
 497 static void     stl_rxprocess(stlport_t *portp);
 498 static void     stl_flowcontrol(stlport_t *portp, int hw, int sw);
 499 static void     stl_dtrwakeup(void *arg);
 500 static int      stl_brdinit(stlbrd_t *brdp);
 501 static int      stl_initeio(stlbrd_t *brdp);
 502 static int      stl_initech(stlbrd_t *brdp);
 503 static int      stl_initports(stlbrd_t *brdp, stlpanel_t *panelp);
 504 static void     stl_eiointr(stlbrd_t *brdp);
 505 static void     stl_echatintr(stlbrd_t *brdp);
 506 static void     stl_echmcaintr(stlbrd_t *brdp);
 507 static void     stl_echpciintr(stlbrd_t *brdp);
 508 static void     stl_echpci64intr(stlbrd_t *brdp);
 509 static int      stl_memioctl(dev_t dev, unsigned long cmd, caddr_t data,
 510                         int flag, struct thread *td);
 511 static int      stl_getbrdstats(caddr_t data);
 512 static int      stl_getportstats(stlport_t *portp, caddr_t data);
 513 static int      stl_clrportstats(stlport_t *portp, caddr_t data);
 514 static stlport_t *stl_getport(int brdnr, int panelnr, int portnr);
 515 static ointhand2_t      stlintr;
 516
 517 #if NPCI > 0
 518 static const char *stlpciprobe(pcici_t tag, pcidi_t type);
 519 static void     stlpciattach(pcici_t tag, int unit);
 520 static void     stlpciintr(void * arg);
 521 #endif
 522
 523 /*
 524  *      CD1400 uart specific handling functions.
 525  */
 526 static void     stl_cd1400setreg(stlport_t *portp, int regnr, int value);
 527 static int      stl_cd1400getreg(stlport_t *portp, int regnr);
 528 static int      stl_cd1400updatereg(stlport_t *portp, int regnr, int value);
 529 static int      stl_cd1400panelinit(stlbrd_t *brdp, stlpanel_t *panelp);
 530 static void     stl_cd1400portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp);
 531 static int      stl_cd1400setport(stlport_t *portp, struct termios *tiosp);
 532 static int      stl_cd1400getsignals(stlport_t *portp);
 533 static void     stl_cd1400setsignals(stlport_t *portp, int dtr, int rts);
 534 static void     stl_cd1400ccrwait(stlport_t *portp);
 535 static void     stl_cd1400enablerxtx(stlport_t *portp, int rx, int tx);
 536 static void     stl_cd1400startrxtx(stlport_t *portp, int rx, int tx);
 537 static void     stl_cd1400disableintrs(stlport_t *portp);
 538 static void     stl_cd1400sendbreak(stlport_t *portp, long len);
 539 static void     stl_cd1400sendflow(stlport_t *portp, int hw, int sw);
 540 static int      stl_cd1400datastate(stlport_t *portp);
 541 static void     stl_cd1400flush(stlport_t *portp, int flag);
 542 static __inline void    stl_cd1400txisr(stlpanel_t *panelp, int ioaddr);
 543 static void     stl_cd1400rxisr(stlpanel_t *panelp, int ioaddr);
 544 static void     stl_cd1400mdmisr(stlpanel_t *panelp, int ioaddr);
 545 static void     stl_cd1400eiointr(stlpanel_t *panelp, unsigned int iobase);
 546 static void     stl_cd1400echintr(stlpanel_t *panelp, unsigned int iobase);
 547
 548 /*
 549  *      SC26198 uart specific handling functions.
 550  */
 551 static void     stl_sc26198setreg(stlport_t *portp, int regnr, int value);
 552 static int      stl_sc26198getreg(stlport_t *portp, int regnr);
 553 static int      stl_sc26198updatereg(stlport_t *portp, int regnr, int value);
 554 static int      stl_sc26198getglobreg(stlport_t *portp, int regnr);
 555 static int      stl_sc26198panelinit(stlbrd_t *brdp, stlpanel_t *panelp);
 556 static void     stl_sc26198portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp);
 557 static int      stl_sc26198setport(stlport_t *portp, struct termios *tiosp);
 558 static int      stl_sc26198getsignals(stlport_t *portp);
 559 static void     stl_sc26198setsignals(stlport_t *portp, int dtr, int rts);
 560 static void     stl_sc26198enablerxtx(stlport_t *portp, int rx, int tx);
 561 static void     stl_sc26198startrxtx(stlport_t *portp, int rx, int tx);
 562 static void     stl_sc26198disableintrs(stlport_t *portp);
 563 static void     stl_sc26198sendbreak(stlport_t *portp, long len);
 564 static void     stl_sc26198sendflow(stlport_t *portp, int hw, int sw);
 565 static int      stl_sc26198datastate(stlport_t *portp);
 566 static void     stl_sc26198flush(stlport_t *portp, int flag);
 567 static void     stl_sc26198txunflow(stlport_t *portp);
 568 static void     stl_sc26198wait(stlport_t *portp);
 569 static void     stl_sc26198intr(stlpanel_t *panelp, unsigned int iobase);
 570 static void     stl_sc26198txisr(stlport_t *port);
 571 static void     stl_sc26198rxisr(stlport_t *port, unsigned int iack);
 572 static void     stl_sc26198rxgoodchars(stlport_t *portp);
 573 static void     stl_sc26198rxbadchars(stlport_t *portp);
 574 static void     stl_sc26198otherisr(stlport_t *port, unsigned int iack);
 575
 576 /*****************************************************************************/
 577
 578 /*
 579  *      Generic UART support structure.
 580  */
 581 typedef struct uart {
 582         int     (*panelinit)(stlbrd_t *brdp, stlpanel_t *panelp);
 583         void    (*portinit)(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp);
 584         int     (*setport)(stlport_t *portp, struct termios *tiosp);
 585         int     (*getsignals)(stlport_t *portp);
 586         void    (*setsignals)(stlport_t *portp, int dtr, int rts);
 587         void    (*enablerxtx)(stlport_t *portp, int rx, int tx);
 588         void    (*startrxtx)(stlport_t *portp, int rx, int tx);
 589         void    (*disableintrs)(stlport_t *portp);
 590         void    (*sendbreak)(stlport_t *portp, long len);
 591         void    (*sendflow)(stlport_t *portp, int hw, int sw);
 592         void    (*flush)(stlport_t *portp, int flag);
 593         int     (*datastate)(stlport_t *portp);
 594         void    (*intr)(stlpanel_t *panelp, unsigned int iobase);
 595 } uart_t;
 596
 597 /*
 598  *      Define some macros to make calling these functions nice and clean.
 599  */
 600 #define stl_panelinit           (* ((uart_t *) panelp->uartp)->panelinit)
 601 #define stl_portinit            (* ((uart_t *) portp->uartp)->portinit)
 602 #define stl_setport             (* ((uart_t *) portp->uartp)->setport)
 603 #define stl_getsignals          (* ((uart_t *) portp->uartp)->getsignals)
 604 #define stl_setsignals          (* ((uart_t *) portp->uartp)->setsignals)
 605 #define stl_enablerxtx          (* ((uart_t *) portp->uartp)->enablerxtx)
 606 #define stl_startrxtx           (* ((uart_t *) portp->uartp)->startrxtx)
 607 #define stl_disableintrs        (* ((uart_t *) portp->uartp)->disableintrs)
 608 #define stl_sendbreak           (* ((uart_t *) portp->uartp)->sendbreak)
 609 #define stl_sendflow            (* ((uart_t *) portp->uartp)->sendflow)
 610 #define stl_uartflush           (* ((uart_t *) portp->uartp)->flush)
 611 #define stl_datastate           (* ((uart_t *) portp->uartp)->datastate)
 612
 613 /*****************************************************************************/
 614
 615 /*
 616  *      CD1400 UART specific data initialization.
 617  */
 618 static uart_t stl_cd1400uart = {
 619         stl_cd1400panelinit,
 620         stl_cd1400portinit,
 621         stl_cd1400setport,
 622         stl_cd1400getsignals,
 623         stl_cd1400setsignals,
 624         stl_cd1400enablerxtx,
 625         stl_cd1400startrxtx,
 626         stl_cd1400disableintrs,
 627         stl_cd1400sendbreak,
 628         stl_cd1400sendflow,
 629         stl_cd1400flush,
 630         stl_cd1400datastate,
 631         stl_cd1400eiointr
 632 };
 633
 634 /*
 635  *      Define the offsets within the register bank of a cd1400 based panel.
 636  *      These io address offsets are common to the EasyIO board as well.
 637  */
 638 #define EREG_ADDR       0
 639 #define EREG_DATA       4
 640 #define EREG_RXACK      5
 641 #define EREG_TXACK      6
 642 #define EREG_MDACK      7
 643
 644 #define EREG_BANKSIZE   8
 645
 646 #define CD1400_CLK      25000000
 647 #define CD1400_CLK8M    20000000
 648
 649 /*
 650  *      Define the cd1400 baud rate clocks. These are used when calculating
 651  *      what clock and divisor to use for the required baud rate. Also
 652  *      define the maximum baud rate allowed, and the default base baud.
 653  */
 654 static int      stl_cd1400clkdivs[] = {
 655         CD1400_CLK0, CD1400_CLK1, CD1400_CLK2, CD1400_CLK3, CD1400_CLK4
 656 };
 657
 658 /*
 659  *      Define the maximum baud rate of the cd1400 devices.
 660  */
 661 #define CD1400_MAXBAUD  230400
 662
 663 /*****************************************************************************/
 664
 665 /*
 666  *      SC26198 UART specific data initization.
 667  */
 668 static uart_t stl_sc26198uart = {
 669         stl_sc26198panelinit,
 670         stl_sc26198portinit,
 671         stl_sc26198setport,
 672         stl_sc26198getsignals,
 673         stl_sc26198setsignals,
 674         stl_sc26198enablerxtx,
 675         stl_sc26198startrxtx,
 676         stl_sc26198disableintrs,
 677         stl_sc26198sendbreak,
 678         stl_sc26198sendflow,
 679         stl_sc26198flush,
 680         stl_sc26198datastate,
 681         stl_sc26198intr
 682 };
 683
 684 /*
 685  *      Define the offsets within the register bank of a sc26198 based panel.
 686  */
 687 #define XP_DATA         0
 688 #define XP_ADDR         1
 689 #define XP_MODID        2
 690 #define XP_STATUS       2
 691 #define XP_IACK         3
 692
 693 #define XP_BANKSIZE     4
 694
 695 /*
 696  *      Define the sc26198 baud rate table. Offsets within the table
 697  *      represent the actual baud rate selector of sc26198 registers.
 698  */
 699 static unsigned int     sc26198_baudtable[] = {
 700         50, 75, 150, 200, 300, 450, 600, 900, 1200, 1800, 2400, 3600,
 701         4800, 7200, 9600, 14400, 19200, 28800, 38400, 57600, 115200,
 702         230400, 460800
 703 };
 704
 705 #define SC26198_NRBAUDS (sizeof(sc26198_baudtable) / sizeof(unsigned int))
 706
 707 /*
 708  *      Define the maximum baud rate of the sc26198 devices.
 709  */
 710 #define SC26198_MAXBAUD 460800
 711
 712 /*****************************************************************************/
 713
 714 /*
 715  *      Declare the driver isa structure.
 716  */
 717 struct isa_driver       stldriver = {
 718         stlprobe, stlattach, "stl"
 719 };
 720
 721 /*****************************************************************************/
 722
 723 #if NPCI > 0
 724
 725 /*
 726  *      Declare the driver pci structure.
 727  */
 728 static unsigned long    stl_count;
 729
 730 static struct pci_device        stlpcidriver = {
 731         "stl",
 732         stlpciprobe,
 733         stlpciattach,
 734         &stl_count,
 735         NULL,
 736 };
 737
 738 COMPAT_PCI_DRIVER (stlpci, stlpcidriver);
 739
 740 #endif
 741
 742 /*****************************************************************************/
 743
 744 #if VFREEBSD >= 220
 745
 746 /*
 747  *      FreeBSD-2.2+ kernel linkage.
 748  */
 749
 750 #define CDEV_MAJOR      72
 751 static struct cdevsw stl_cdevsw = {
 752         /* name */      "stl",
 753         /* maj */       CDEV_MAJOR,
 754         /* flags */     D_TTY | D_KQFILTER,
 755         /* port */      NULL,
 756         /* clone */     NULL,
 757
 758         /* open */      stlopen,
 759         /* close */     stlclose,
 760         /* read */      ttyread,
 761         /* write */     ttywrite,
 762         /* ioctl */     stlioctl,
 763         /* poll */      ttypoll,
 764         /* mmap */      nommap,
 765         /* strategy */  nostrategy,
 766         /* dump */      nodump,
 767         /* psize */     nopsize,
 768         /* kqfilter */  ttykqfilter
 769 };
 770
 771 static void stl_drvinit(void *unused)
 772 {
 773 }
 774
 775 SYSINIT(sidev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,stl_drvinit,NULL)
 776
 777 #endif
 778
 779 /*****************************************************************************/
 780
 781 /*
 782  *      Probe for some type of EasyIO or EasyConnection 8/32 board at
 783  *      the supplied address. All we do is check if we can find the
 784  *      board ID for the board... (Note, PCI boards not checked here,
 785  *      they are done in the stlpciprobe() routine).
 786  */
 787
 788 static int stlprobe(struct isa_device *idp)
 789 {
 790         unsigned int    status;
 791
 792 #if STLDEBUG
 793         printf("stlprobe(idp=%x): unit=%d iobase=%x\n", (int) idp,
 794                 idp->id_unit, idp->id_iobase);
 795 #endif
 796
 797         if (idp->id_unit > STL_MAXBRDS)
 798                 return(0);
 799
 800         status = inb(idp->id_iobase + 1);
 801         if ((status & ECH_IDBITMASK) == ECH_ID) {
 802                 stl_brdprobed[idp->id_unit] = BRD_ECH;
 803                 return(1);
 804         }
 805
 806         status = inb(idp->id_iobase + 2);
 807         switch (status & EIO_IDBITMASK) {
 808         case EIO_8PORTRS:
 809         case EIO_8PORTM:
 810         case EIO_8PORTDI:
 811         case EIO_4PORTRS:
 812         case EIO_MK3:
 813                 stl_brdprobed[idp->id_unit] = BRD_EASYIO;
 814                 return(1);
 815         default:
 816                 break;
 817         }
 818
 819         return(0);
 820 }
 821
 822 /*****************************************************************************/
 823
 824 /*
 825  *      Find an available internal board number (unit number). The problem
 826  *      is that the same unit numbers can be assigned to different boards
 827  *      detected during the ISA and PCI initialization phases.
 828  */
 829
 830 static int stl_findfreeunit()
 831 {
 832         int     i;
 833
 834         for (i = 0; (i < STL_MAXBRDS); i++)
 835                 if (stl_brds[i] == (stlbrd_t *) NULL)
 836                         break;
 837         return((i >= STL_MAXBRDS) ? -1 : i);
 838 }
 839
 840 /*****************************************************************************/
 841
 842 /*
 843  *      Allocate resources for and initialize the specified board.
 844  */
 845
 846 static int stlattach(struct isa_device *idp)
 847 {
 848         stlbrd_t        *brdp;
 849         int             boardnr, portnr, minor_dev;
 850
 851 #if STLDEBUG
 852         printf("stlattach(idp=%p): unit=%d iobase=%x\n", (void *) idp,
 853                 idp->id_unit, idp->id_iobase);
 854 #endif
 855
 856 /*      idp->id_ointr = stlintr; */
 857
 858         brdp = malloc(sizeof(stlbrd_t), M_TTYS, M_WAITOK | M_ZERO);
 859
 860         if ((brdp->brdnr = stl_findfreeunit()) < 0) {
 861                 printf("STALLION: too many boards found, max=%d\n",
 862                         STL_MAXBRDS);
 863                 return(0);
 864         }
 865         if (brdp->brdnr >= stl_nrbrds)
 866                 stl_nrbrds = brdp->brdnr + 1;
 867
 868         brdp->unitid = idp->id_unit;
 869         brdp->brdtype = stl_brdprobed[idp->id_unit];
 870         brdp->ioaddr1 = idp->id_iobase;
 871         brdp->ioaddr2 = stl_ioshared;
 872         brdp->irq = ffs(idp->id_irq) - 1;
 873         brdp->irqtype = stl_irqshared;
 874         stl_brdinit(brdp);
 875
 876         /* register devices for DEVFS */
 877         boardnr = brdp->brdnr;
 878         cdevsw_add(&stl_cdevsw, 31, boardnr);
 879         make_dev(&stl_cdevsw, boardnr + 0x1000000, UID_ROOT, GID_WHEEL,
 880                  0600, "staliomem%d", boardnr);
 881
 882         for (portnr = 0, minor_dev = boardnr * 0x100000;
 883               portnr < 32; portnr++, minor_dev++) {
 884                 /* hw ports */
 885                 make_dev(&stl_cdevsw, minor_dev,
 886                          UID_ROOT, GID_WHEEL, 0600,
 887                          "ttyE%d", portnr + (boardnr * 64));
 888                 make_dev(&stl_cdevsw, minor_dev + 32,
 889                          UID_ROOT, GID_WHEEL, 0600,
 890                          "ttyiE%d", portnr + (boardnr * 64));
 891                 make_dev(&stl_cdevsw, minor_dev + 64,
 892                          UID_ROOT, GID_WHEEL, 0600,
 893                          "ttylE%d", portnr + (boardnr * 64));
 894                 make_dev(&stl_cdevsw, minor_dev + 128,
 895                          UID_ROOT, GID_WHEEL, 0600,
 896                          "cue%d", portnr + (boardnr * 64));
 897                 make_dev(&stl_cdevsw, minor_dev + 160,
 898                          UID_ROOT, GID_WHEEL, 0600,
 899                          "cuie%d", portnr + (boardnr * 64));
 900                 make_dev(&stl_cdevsw, minor_dev + 192,
 901                          UID_ROOT, GID_WHEEL, 0600,
 902                          "cule%d", portnr + (boardnr * 64));
 903
 904                 /* sw ports */
 905                 make_dev(&stl_cdevsw, minor_dev + 0x10000,
 906                          UID_ROOT, GID_WHEEL, 0600,
 907                          "ttyE%d", portnr + (boardnr * 64) + 32);
 908                 make_dev(&stl_cdevsw, minor_dev + 32 + 0x10000,
 909                          UID_ROOT, GID_WHEEL, 0600,
 910                          "ttyiE%d", portnr + (boardnr * 64) + 32);
 911                 make_dev(&stl_cdevsw, minor_dev + 64 + 0x10000,
 912                          UID_ROOT, GID_WHEEL, 0600,
 913                          "ttylE%d", portnr + (boardnr * 64) + 32);
 914                 make_dev(&stl_cdevsw, minor_dev + 128 + 0x10000,
 915                          UID_ROOT, GID_WHEEL, 0600,
 916                          "cue%d", portnr + (boardnr * 64) + 32);
 917                 make_dev(&stl_cdevsw, minor_dev + 160 + 0x10000,
 918                          UID_ROOT, GID_WHEEL, 0600,
 919                          "cuie%d", portnr + (boardnr * 64) + 32);
 920                 make_dev(&stl_cdevsw, minor_dev + 192 + 0x10000,
 921                          UID_ROOT, GID_WHEEL, 0600,
 922                          "cule%d", portnr + (boardnr * 64) + 32);
 923         }
 924         boardnr = brdp->brdnr;
 925         make_dev(&stl_cdevsw, boardnr + 0x1000000, UID_ROOT, GID_WHEEL,
 926                  0600, "staliomem%d", boardnr);
 927
 928         for (portnr = 0, minor_dev = boardnr * 0x100000;
 929               portnr < 32; portnr++, minor_dev++) {
 930                 /* hw ports */
 931                 make_dev(&stl_cdevsw, minor_dev,
 932                          UID_ROOT, GID_WHEEL, 0600,
 933                          "ttyE%d", portnr + (boardnr * 64));
 934                 make_dev(&stl_cdevsw, minor_dev + 32,
 935                          UID_ROOT, GID_WHEEL, 0600,
 936                          "ttyiE%d", portnr + (boardnr * 64));
 937                 make_dev(&stl_cdevsw, minor_dev + 64,
 938                          UID_ROOT, GID_WHEEL, 0600,
 939                          "ttylE%d", portnr + (boardnr * 64));
 940                 make_dev(&stl_cdevsw, minor_dev + 128,
 941                          UID_ROOT, GID_WHEEL, 0600,
 942                          "cue%d", portnr + (boardnr * 64));
 943                 make_dev(&stl_cdevsw, minor_dev + 160,
 944                          UID_ROOT, GID_WHEEL, 0600,
 945                          "cuie%d", portnr + (boardnr * 64));
 946                 make_dev(&stl_cdevsw, minor_dev + 192,
 947                          UID_ROOT, GID_WHEEL, 0600,
 948                          "cule%d", portnr + (boardnr * 64));
 949
 950                 /* sw ports */
 951                 make_dev(&stl_cdevsw, minor_dev + 0x10000,
 952                          UID_ROOT, GID_WHEEL, 0600,
 953                          "ttyE%d", portnr + (boardnr * 64) + 32);
 954                 make_dev(&stl_cdevsw, minor_dev + 32 + 0x10000,
 955                          UID_ROOT, GID_WHEEL, 0600,
 956                          "ttyiE%d", portnr + (boardnr * 64) + 32);
 957                 make_dev(&stl_cdevsw, minor_dev + 64 + 0x10000,
 958                          UID_ROOT, GID_WHEEL, 0600,
 959                          "ttylE%d", portnr + (boardnr * 64) + 32);
 960                 make_dev(&stl_cdevsw, minor_dev + 128 + 0x10000,
 961                          UID_ROOT, GID_WHEEL, 0600,
 962                          "cue%d", portnr + (boardnr * 64) + 32);
 963                 make_dev(&stl_cdevsw, minor_dev + 160 + 0x10000,
 964                          UID_ROOT, GID_WHEEL, 0600,
 965                          "cuie%d", portnr + (boardnr * 64) + 32);
 966                 make_dev(&stl_cdevsw, minor_dev + 192 + 0x10000,
 967                          UID_ROOT, GID_WHEEL, 0600,
 968                          "cule%d", portnr + (boardnr * 64) + 32);
 969         }
 970
 971         return(1);
 972 }
 973
 974 /*****************************************************************************/
 975
 976 #if NPCI > 0
 977
 978 /*
 979  *      Probe specifically for the PCI boards. We need to be a little
 980  *      carefull here, since it looks sort like a Nat Semi IDE chip...
 981  */
 982
 983 static const char *stlpciprobe(pcici_t tag, pcidi_t type)
 984 {
 985         unsigned long   class;
 986         int             i, brdtype;
 987
 988 #if STLDEBUG
 989         printf("stlpciprobe(tag=%x,type=%x)\n", (int) &tag, (int) type);
 990 #endif
 991
 992         brdtype = 0;
 993         for (i = 0; (i < stl_nrpcibrds); i++) {
 994                 if (((type & 0xffff) == stl_pcibrds[i].vendid) &&
 995                     (((type >> 16) & 0xffff) == stl_pcibrds[i].devid)) {
 996                         brdtype = stl_pcibrds[i].brdtype;
 997                         break;
 998                 }
 999         }
1000
1001         if (brdtype == 0)
1002                 return((char *) NULL);
1003
1004         class = pci_conf_read(tag, PCI_CLASS_REG);
1005         if ((class & PCI_CLASS_MASK) == PCI_CLASS_MASS_STORAGE)
1006                 return((char *) NULL);
1007
1008         return(stl_brdnames[brdtype]);
1009 }
1010
1011 /*****************************************************************************/
1012
1013 /*
1014  *      Allocate resources for and initialize the specified PCI board.
1015  */
1016
1017 void stlpciattach(pcici_t tag, int unit)
1018 {
1019         stlbrd_t        *brdp;
1020         unsigned int    bar[4];
1021         unsigned int    id;
1022         int             i;
1023         int             boardnr, portnr, minor_dev;
1024
1025 #if STLDEBUG
1026         printf("stlpciattach(tag=%x,unit=%x)\n", (int) &tag, unit);
1027 #endif
1028
1029         brdp = malloc(sizeof(stlbrd_t), M_TTYS, M_WAITOK | M_ZERO);
1030
1031         if ((unit < 0) || (unit > STL_MAXBRDS)) {
1032                 printf("STALLION: bad PCI board unit number=%d\n", unit);
1033                 return;
1034         }
1035
1036 /*
1037  *      Allocate us a new driver unique unit number.
1038  */
1039         if ((brdp->brdnr = stl_findfreeunit()) < 0) {
1040                 printf("STALLION: too many boards found, max=%d\n",
1041                         STL_MAXBRDS);
1042                 return;
1043         }
1044         if (brdp->brdnr >= stl_nrbrds)
1045                 stl_nrbrds = brdp->brdnr + 1;
1046
1047 /*
1048  *      Determine what type of PCI board this is...
1049  */
1050         id = (unsigned int) pci_conf_read(tag, 0x0);
1051         for (i = 0; (i < stl_nrpcibrds); i++) {
1052                 if (((id & 0xffff) == stl_pcibrds[i].vendid) &&
1053                     (((id >> 16) & 0xffff) == stl_pcibrds[i].devid)) {
1054                         brdp->brdtype = stl_pcibrds[i].brdtype;
1055                         break;
1056                 }
1057         }
1058
1059         if (i >= stl_nrpcibrds) {
1060                 printf("STALLION: probed PCI board unknown type=%x\n", id);
1061                 return;
1062         }
1063
1064         for (i = 0; (i < 4); i++)
1065                 bar[i] = (unsigned int) pci_conf_read(tag, 0x10 + (i * 4)) &
1066                         0xfffc;
1067
1068         switch (brdp->brdtype) {
1069         case BRD_ECH64PCI:
1070                 brdp->ioaddr1 = bar[1];
1071                 brdp->ioaddr2 = bar[2];
1072                 break;
1073         case BRD_EASYIOPCI:
1074                 brdp->ioaddr1 = bar[2];
1075                 brdp->ioaddr2 = bar[1];
1076                 break;
1077         case BRD_ECHPCI:
1078                 brdp->ioaddr1 = bar[1];
1079                 brdp->ioaddr2 = bar[0];
1080                 break;
1081         default:
1082                 printf("STALLION: unknown PCI board type=%d\n", brdp->brdtype);
1083                 return;
1084                 break;
1085         }
1086
1087         brdp->unitid = brdp->brdnr; /* PCI units auto-assigned */
1088         brdp->irq = ((int) pci_conf_read(tag, 0x3c)) & 0xff;
1089         brdp->irqtype = 0;
1090         if (pci_map_int(tag, stlpciintr, (void *) NULL) == 0) {
1091                 printf("STALLION: failed to map interrupt irq=%d for unit=%d\n",
1092                         brdp->irq, brdp->brdnr);
1093                 return;
1094         }
1095
1096         stl_brdinit(brdp);
1097
1098         /* register devices for DEVFS */
1099         boardnr = brdp->brdnr;
1100         make_dev(&stl_cdevsw, boardnr + 0x1000000, UID_ROOT, GID_WHEEL,
1101                  0600, "staliomem%d", boardnr);
1102
1103         for (portnr = 0, minor_dev = boardnr * 0x100000;
1104               portnr < 32; portnr++, minor_dev++) {
1105                 /* hw ports */
1106                 make_dev(&stl_cdevsw, minor_dev,
1107                          UID_ROOT, GID_WHEEL, 0600,
1108                          "ttyE%d", portnr + (boardnr * 64));
1109                 make_dev(&stl_cdevsw, minor_dev + 32,
1110                          UID_ROOT, GID_WHEEL, 0600,
1111                          "ttyiE%d", portnr + (boardnr * 64));
1112                 make_dev(&stl_cdevsw, minor_dev + 64,
1113                          UID_ROOT, GID_WHEEL, 0600,
1114                          "ttylE%d", portnr + (boardnr * 64));
1115                 make_dev(&stl_cdevsw, minor_dev + 128,
1116                          UID_ROOT, GID_WHEEL, 0600,
1117                          "cue%d", portnr + (boardnr * 64));
1118                 make_dev(&stl_cdevsw, minor_dev + 160,
1119                          UID_ROOT, GID_WHEEL, 0600,
1120                          "cuie%d", portnr + (boardnr * 64));
1121                 make_dev(&stl_cdevsw, minor_dev + 192,
1122                          UID_ROOT, GID_WHEEL, 0600,
1123                          "cule%d", portnr + (boardnr * 64));
1124
1125                 /* sw ports */
1126                 make_dev(&stl_cdevsw, minor_dev + 0x10000,
1127                          UID_ROOT, GID_WHEEL, 0600,
1128                          "ttyE%d", portnr + (boardnr * 64) + 32);
1129                 make_dev(&stl_cdevsw, minor_dev + 32 + 0x10000,
1130                          UID_ROOT, GID_WHEEL, 0600,
1131                          "ttyiE%d", portnr + (boardnr * 64) + 32);
1132                 make_dev(&stl_cdevsw, minor_dev + 64 + 0x10000,
1133                          UID_ROOT, GID_WHEEL, 0600,
1134                          "ttylE%d", portnr + (boardnr * 64) + 32);
1135                 make_dev(&stl_cdevsw, minor_dev + 128 + 0x10000,
1136                          UID_ROOT, GID_WHEEL, 0600,
1137                          "cue%d", portnr + (boardnr * 64) + 32);
1138                 make_dev(&stl_cdevsw, minor_dev + 160 + 0x10000,
1139                          UID_ROOT, GID_WHEEL, 0600,
1140                          "cuie%d", portnr + (boardnr * 64) + 32);
1141                 make_dev(&stl_cdevsw, minor_dev + 192 + 0x10000,
1142                          UID_ROOT, GID_WHEEL, 0600,
1143                          "cule%d", portnr + (boardnr * 64) + 32);
1144         }
1145 }
1146
1147 #endif
1148
1149 /*****************************************************************************/
1150
1151 STATIC int stlopen(dev_t dev, int flag, int mode, struct thread *td)
1152 {
1153         struct tty      *tp;
1154         stlport_t       *portp;
1155         int             error, callout;
1156
1157 #if STLDEBUG
1158         printf("stlopen(dev=%x,flag=%x,mode=%x,p=%x)\n", (int) dev, flag,
1159                 mode, (int) p);
1160 #endif
1161
1162 /*
1163  *      Firstly check if the supplied device number is a valid device.
1164  */
1165         if (minor(dev) & STL_MEMDEV)
1166                 return(0);
1167
1168         portp = stl_dev2port(dev);
1169         if (portp == (stlport_t *) NULL)
1170                 return(ENXIO);
1171         if (minor(dev) & STL_CTRLDEV)
1172                 return(0);
1173         tp = &portp->tty;
1174         dev->si_tty = tp;
1175         callout = minor(dev) & STL_CALLOUTDEV;
1176         error = 0;
1177
1178         crit_enter();
1179
1180 stlopen_restart:
1181 /*
1182  *      Wait here for the DTR drop timeout period to expire.
1183  */
1184         while (portp->state & ASY_DTRWAIT) {
1185                 error = tsleep(&portp->dtrwait, PCATCH, "stldtr", 0);
1186                 if (error)
1187                         goto stlopen_end;
1188         }
1189
1190 /*
1191  *      We have a valid device, so now we check if it is already open.
1192  *      If not then initialize the port hardware and set up the tty
1193  *      struct as required.
1194  */
1195         if ((tp->t_state & TS_ISOPEN) == 0) {
1196                 tp->t_oproc = stl_start;
1197                 tp->t_stop = stl_stop;
1198                 tp->t_param = stl_param;
1199                 tp->t_dev = dev;
1200                 tp->t_termios = callout ? portp->initouttios :
1201                         portp->initintios;
1202                 stl_rawopen(portp);
1203                 ttsetwater(tp);
1204                 if ((portp->sigs & TIOCM_CD) || callout)
1205                         (*linesw[tp->t_line].l_modem)(tp, 1);
1206         } else {
1207                 if (callout) {
1208                         if (portp->callout == 0) {
1209                                 error = EBUSY;
1210                                 goto stlopen_end;
1211                         }
1212                 } else {
1213                         if (portp->callout != 0) {
1214                                 if (flag & O_NONBLOCK) {
1215                                         error = EBUSY;
1216                                         goto stlopen_end;
1217                                 }
1218                                 error = tsleep(&portp->callout,
1219                                             PCATCH, "stlcall", 0);
1220                                 if (error)
1221                                         goto stlopen_end;
1222                                 goto stlopen_restart;
1223                         }
1224                 }
1225                 if ((tp->t_state & TS_XCLUDE) && suser(td)) {
1226                         error = EBUSY;
1227                         goto stlopen_end;
1228                 }
1229         }
1230
1231 /*
1232  *      If this port is not the callout device and we do not have carrier
1233  *      then we need to sleep, waiting for it to be asserted.
1234  */
1235         if (((tp->t_state & TS_CARR_ON) == 0) && !callout &&
1236                         ((tp->t_cflag & CLOCAL) == 0) &&
1237                         ((flag & O_NONBLOCK) == 0)) {
1238                 portp->waitopens++;
1239                 error = tsleep(TSA_CARR_ON(tp), PCATCH, "stldcd", 0);
1240                 portp->waitopens--;
1241                 if (error)
1242                         goto stlopen_end;
1243                 goto stlopen_restart;
1244         }
1245
1246 /*
1247  *      Open the line discipline.
1248  */
1249         error = (*linesw[tp->t_line].l_open)(dev, tp);
1250         stl_ttyoptim(portp, &tp->t_termios);
1251         if ((tp->t_state & TS_ISOPEN) && callout)
1252                 portp->callout = 1;
1253
1254 /*
1255  *      If for any reason we get to here and the port is not actually
1256  *      open then close of the physical hardware - no point leaving it
1257  *      active when the open failed...
1258  */
1259 stlopen_end:
1260         crit_exit();
1261         if (((tp->t_state & TS_ISOPEN) == 0) && (portp->waitopens == 0))
1262                 stl_rawclose(portp);
1263
1264         return(error);
1265 }
1266
1267 /*****************************************************************************/
1268
1269 STATIC int stlclose(dev_t dev, int flag, int mode, struct thread *td)
1270 {
1271         struct tty      *tp;
1272         stlport_t       *portp;
1273
1274 #if STLDEBUG
1275         printf("stlclose(dev=%s,flag=%x,mode=%x,p=%p)\n", devtoname(dev),
1276                 flag, mode, (void *) p);
1277 #endif
1278
1279         if (minor(dev) & STL_MEMDEV)
1280                 return(0);
1281         if (minor(dev) & STL_CTRLDEV)
1282                 return(0);
1283
1284         portp = stl_dev2port(dev);
1285         if (portp == (stlport_t *) NULL)
1286                 return(ENXIO);
1287         tp = &portp->tty;
1288
1289         crit_enter();
1290         (*linesw[tp->t_line].l_close)(tp, flag);
1291         stl_ttyoptim(portp, &tp->t_termios);
1292         stl_rawclose(portp);
1293         ttyclose(tp);
1294         crit_exit();
1295         return(0);
1296 }
1297
1298 /*****************************************************************************/
1299
1300 #if VFREEBSD >= 220
1301
1302 STATIC void stl_stop(struct tty *tp, int rw)
1303 {
1304 #if STLDEBUG
1305         printf("stl_stop(tp=%x,rw=%x)\n", (int) tp, rw);
1306 #endif
1307
1308         stl_flush((stlport_t *) tp, rw);
1309 }
1310
1311 #else
1312
1313 STATIC int stlstop(struct tty *tp, int rw)
1314 {
1315 #if STLDEBUG
1316         printf("stlstop(tp=%x,rw=%x)\n", (int) tp, rw);
1317 #endif
1318
1319         stl_flush((stlport_t *) tp, rw);
1320         return(0);
1321 }
1322
1323 #endif
1324
1325 /*****************************************************************************/
1326
1327 STATIC int stlioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag,
1328                     struct thread *td)
1329 {
1330         struct termios  *newtios, *localtios;
1331         struct tty      *tp;
1332         stlport_t       *portp;
1333         int             error, i;
1334
1335 #if STLDEBUG
1336         printf("stlioctl(dev=%s,cmd=%lx,data=%p,flag=%x,p=%p)\n",
1337                 devtoname(dev), cmd, (void *) data, flag, (void *) p);
1338 #endif
1339
1340         if (minor(dev) & STL_MEMDEV)
1341                 return(stl_memioctl(dev, cmd, data, flag, td));
1342
1343         portp = stl_dev2port(dev);
1344         if (portp == (stlport_t *) NULL)
1345                 return(ENODEV);
1346         tp = &portp->tty;
1347         error = 0;
1348
1349 /*
1350  *      First up handle ioctls on the control devices.
1351  */
1352         if (minor(dev) & STL_CTRLDEV) {
1353                 if ((minor(dev) & STL_CTRLDEV) == STL_CTRLINIT)
1354                         localtios = (minor(dev) & STL_CALLOUTDEV) ?
1355                                 &portp->initouttios : &portp->initintios;
1356                 else if ((minor(dev) & STL_CTRLDEV) == STL_CTRLLOCK)
1357                         localtios = (minor(dev) & STL_CALLOUTDEV) ?
1358                                 &portp->lockouttios : &portp->lockintios;
1359                 else
1360                         return(ENODEV);
1361
1362                 switch (cmd) {
1363                 case TIOCSETA:
1364                         if ((error = suser(td)) == 0)
1365                                 *localtios = *((struct termios *) data);
1366                         break;
1367                 case TIOCGETA:
1368                         *((struct termios *) data) = *localtios;
1369                         break;
1370                 case TIOCGETD:
1371                         *((int *) data) = TTYDISC;
1372                         break;
1373                 case TIOCGWINSZ:
1374                         bzero(data, sizeof(struct winsize));
1375                         break;
1376                 default:
1377                         error = ENOTTY;
1378                         break;
1379                 }
1380                 return(error);
1381         }
1382
1383 /*
1384  *      Deal with 4.3 compatibility issues if we have too...
1385  */
1386 #if defined(COMPAT_43) || defined(COMPAT_SUNOS)
1387         if (1) {
1388                 struct termios  tios;
1389                 unsigned long   oldcmd;
1390
1391                 tios = tp->t_termios;
1392                 oldcmd = cmd;
1393                 if ((error = ttsetcompat(tp, &cmd, data, &tios)))
1394                         return(error);
1395                 if (cmd != oldcmd)
1396                         data = (caddr_t) &tios;
1397         }
1398 #endif
1399
1400 /*
1401  *      Carry out some pre-cmd processing work first...
1402  *      Hmmm, not so sure we want this, disable for now...
1403  */
1404         if ((cmd == TIOCSETA) || (cmd == TIOCSETAW) || (cmd == TIOCSETAF)) {
1405                 newtios = (struct termios *) data;
1406                 localtios = (minor(dev) & STL_CALLOUTDEV) ?
1407                         &portp->lockouttios : &portp->lockintios;
1408
1409                 newtios->c_iflag = (tp->t_iflag & localtios->c_iflag) |
1410                         (newtios->c_iflag & ~localtios->c_iflag);
1411                 newtios->c_oflag = (tp->t_oflag & localtios->c_oflag) |
1412                         (newtios->c_oflag & ~localtios->c_oflag);
1413                 newtios->c_cflag = (tp->t_cflag & localtios->c_cflag) |
1414                         (newtios->c_cflag & ~localtios->c_cflag);
1415                 newtios->c_lflag = (tp->t_lflag & localtios->c_lflag) |
1416                         (newtios->c_lflag & ~localtios->c_lflag);
1417                 for (i = 0; (i < NCCS); i++) {
1418                         if (localtios->c_cc[i] != 0)
1419                                 newtios->c_cc[i] = tp->t_cc[i];
1420                 }
1421                 if (localtios->c_ispeed != 0)
1422                         newtios->c_ispeed = tp->t_ispeed;
1423                 if (localtios->c_ospeed != 0)
1424                         newtios->c_ospeed = tp->t_ospeed;
1425         }
1426
1427 /*
1428  *      Call the line discipline and the common command processing to
1429  *      process this command (if they can).
1430  */
1431         error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, td);
1432         if (error != ENOIOCTL)
1433                 return(error);
1434
1435         crit_enter();
1436         error = ttioctl(tp, cmd, data, flag);
1437         stl_ttyoptim(portp, &tp->t_termios);
1438         if (error != ENOIOCTL) {
1439                 crit_exit();
1440                 return(error);
1441         }
1442
1443         error = 0;
1444
1445 /*
1446  *      Process local commands here. These are all commands that only we
1447  *      can take care of (they all rely on actually doing something special
1448  *      to the actual hardware).
1449  */
1450         switch (cmd) {
1451         case TIOCSBRK:
1452                 stl_sendbreak(portp, -1);
1453                 break;
1454         case TIOCCBRK:
1455                 stl_sendbreak(portp, -2);
1456                 break;
1457         case TIOCSDTR:
1458                 stl_setsignals(portp, 1, -1);
1459                 break;
1460         case TIOCCDTR:
1461                 stl_setsignals(portp, 0, -1);
1462                 break;
1463         case TIOCMSET:
1464                 i = *((int *) data);
1465                 stl_setsignals(portp, ((i & TIOCM_DTR) ? 1 : 0),
1466                         ((i & TIOCM_RTS) ? 1 : 0));
1467                 break;
1468         case TIOCMBIS:
1469                 i = *((int *) data);
1470                 stl_setsignals(portp, ((i & TIOCM_DTR) ? 1 : -1),
1471                         ((i & TIOCM_RTS) ? 1 : -1));
1472                 break;
1473         case TIOCMBIC:
1474                 i = *((int *) data);
1475                 stl_setsignals(portp, ((i & TIOCM_DTR) ? 0 : -1),
1476                         ((i & TIOCM_RTS) ? 0 : -1));
1477                 break;
1478         case TIOCMGET:
1479                 *((int *) data) = (stl_getsignals(portp) | TIOCM_LE);
1480                 break;
1481         case TIOCMSDTRWAIT:
1482                 if ((error = suser(td)) == 0)
1483                         portp->dtrwait = *((int *) data) * hz / 100;
1484                 break;
1485         case TIOCMGDTRWAIT:
1486                 *((int *) data) = portp->dtrwait * 100 / hz;
1487                 break;
1488         case TIOCTIMESTAMP:
1489                 portp->dotimestamp = 1;
1490                 *((struct timeval *) data) = portp->timestamp;
1491                 break;
1492         default:
1493                 error = ENOTTY;
1494                 break;
1495         }
1496         crit_exit();
1497
1498         return(error);
1499 }
1500 /*****************************************************************************/
1501
1502 /*
1503  *      Convert the specified minor device number into a port struct
1504  *      pointer. Return NULL if the device number is not a valid port.
1505  */
1506
1507 STATIC stlport_t *stl_dev2port(dev_t dev)
1508 {
1509         stlbrd_t        *brdp;
1510
1511         brdp = stl_brds[MKDEV2BRD(dev)];
1512         if (brdp == (stlbrd_t *) NULL)
1513                 return((stlport_t *) NULL);
1514         return(brdp->ports[MKDEV2PORT(dev)]);
1515 }
1516
1517 /*****************************************************************************/
1518
1519 /*
1520  *      Initialize the port hardware. This involves enabling the transmitter
1521  *      and receiver, setting the port configuration, and setting the initial
1522  *      signal state.
1523  */
1524
1525 static int stl_rawopen(stlport_t *portp)
1526 {
1527 #if STLDEBUG
1528         printf("stl_rawopen(portp=%p): brdnr=%d panelnr=%d portnr=%d\n",
1529                 (void *) portp, portp->brdnr, portp->panelnr, portp->portnr);
1530 #endif
1531
1532         stl_setport(portp, &portp->tty.t_termios);
1533         portp->sigs = stl_getsignals(portp);
1534         stl_setsignals(portp, 1, 1);
1535         stl_enablerxtx(portp, 1, 1);
1536         stl_startrxtx(portp, 1, 0);
1537         return(0);
1538 }
1539
1540 /*****************************************************************************/
1541
1542 /*
1543  *      Shutdown the hardware of a port. Disable its transmitter and
1544  *      receiver, and maybe drop signals if appropriate.
1545  */
1546
1547 static int stl_rawclose(stlport_t *portp)
1548 {
1549         struct tty      *tp;
1550
1551 #if STLDEBUG
1552         printf("stl_rawclose(portp=%p): brdnr=%d panelnr=%d portnr=%d\n",
1553                 (void *) portp, portp->brdnr, portp->panelnr, portp->portnr);
1554 #endif
1555
1556         tp = &portp->tty;
1557         stl_disableintrs(portp);
1558         stl_enablerxtx(portp, 0, 0);
1559         stl_flush(portp, (FWRITE | FREAD));
1560         if (tp->t_cflag & HUPCL) {
1561                 stl_setsignals(portp, 0, 0);
1562                 if (portp->dtrwait != 0) {
1563                         portp->state |= ASY_DTRWAIT;
1564                         callout_reset(&portp->dtr_ch, portp->dtrwait,
1565                                         stl_dtrwakeup, portp);
1566                 }
1567         }
1568         portp->callout = 0;
1569         portp->brklen = 0;
1570         portp->state &= ~(ASY_ACTIVE | ASY_RTSFLOW);
1571         wakeup(&portp->callout);
1572         wakeup(TSA_CARR_ON(tp));
1573         return(0);
1574 }
1575
1576 /*****************************************************************************/
1577
1578 /*
1579  *      Clear the DTR waiting flag, and wake up any sleepers waiting for
1580  *      DTR wait period to finish.
1581  */
1582
1583 static void stl_dtrwakeup(void *arg)
1584 {
1585         stlport_t       *portp;
1586
1587         portp = (stlport_t *) arg;
1588         portp->state &= ~ASY_DTRWAIT;
1589         wakeup(&portp->dtrwait);
1590 }
1591
1592 /*****************************************************************************/
1593
1594 /*
1595  *      Start (or continue) the transfer of TX data on this port. If the
1596  *      port is not currently busy then load up the interrupt ring queue
1597  *      buffer and kick of the transmitter. If the port is running low on
1598  *      TX data then refill the ring queue. This routine is also used to
1599  *      activate input flow control!
1600  */
1601
1602 static void stl_start(struct tty *tp)
1603 {
1604         stlport_t       *portp;
1605         unsigned int    len, stlen;
1606         char            *head, *tail;
1607         int             count;
1608
1609         portp = (stlport_t *) tp;
1610
1611 #if STLDEBUG
1612         printf("stl_start(tp=%x): brdnr=%d portnr=%d\n", (int) tp,
1613                 portp->brdnr, portp->portnr);
1614 #endif
1615
1616         crit_enter();
1617
1618 /*
1619  *      Check if the ports input has been blocked, and take appropriate action.
1620  *      Not very often do we really need to do anything, so make it quick.
1621  */
1622         if (tp->t_state & TS_TBLOCK) {
1623                 if ((portp->state & ASY_RTSFLOWMODE) &&
1624                     ((portp->state & ASY_RTSFLOW) == 0))
1625                         stl_flowcontrol(portp, 0, -1);
1626         } else {
1627                 if (portp->state & ASY_RTSFLOW)
1628                         stl_flowcontrol(portp, 1, -1);
1629         }
1630
1631 #if VFREEBSD == 205
1632 /*
1633  *      Check if the output cooked clist buffers are near empty, wake up
1634  *      the line discipline to fill it up.
1635  */
1636         if (tp->t_outq.c_cc <= tp->t_lowat) {
1637                 if (tp->t_state & TS_ASLEEP) {
1638                         tp->t_state &= ~TS_ASLEEP;
1639                         wakeup(&tp->t_outq);
1640                 }
1641                 selwakeup(&tp->t_wsel);
1642         }
1643 #endif
1644
1645         if (tp->t_state & (TS_TIMEOUT | TS_TTSTOP)) {
1646                 crit_exit();
1647                 return;
1648         }
1649
1650 /*
1651  *      Copy data from the clists into the interrupt ring queue. This will
1652  *      require at most 2 copys... What we do is calculate how many chars
1653  *      can fit into the ring queue, and how many can fit in 1 copy. If after
1654  *      the first copy there is still more room then do the second copy.
1655  *      The beauty of this type of ring queue is that we do not need to
1656  *      spl protect our-selves, since we only ever update the head pointer,
1657  *      and the interrupt routine only ever updates the tail pointer.
1658  */
1659         if (tp->t_outq.c_cc != 0) {
1660                 head = portp->tx.head;
1661                 tail = portp->tx.tail;
1662                 if (head >= tail) {
1663                         len = STL_TXBUFSIZE - (head - tail) - 1;
1664                         stlen = portp->tx.endbuf - head;
1665                 } else {
1666                         len = tail - head - 1;
1667                         stlen = len;
1668                 }
1669
1670                 if (len > 0) {
1671                         stlen = MIN(len, stlen);
1672                         count = q_to_b(&tp->t_outq, head, stlen);
1673                         len -= count;
1674                         head += count;
1675                         if (head >= portp->tx.endbuf) {
1676                                 head = portp->tx.buf;
1677                                 if (len > 0) {
1678                                         stlen = q_to_b(&tp->t_outq, head, len);
1679                                         head += stlen;
1680                                         count += stlen;
1681                                 }
1682                         }
1683                         portp->tx.head = head;
1684                         if (count > 0)
1685                                 stl_startrxtx(portp, -1, 1);
1686                 }
1687
1688 /*
1689  *              If we sent something, make sure we are called again.
1690  */
1691                 tp->t_state |= TS_BUSY;
1692         }
1693
1694 #if VFREEBSD != 205
1695 /*
1696  *      Do any writer wakeups.
1697  */
1698         ttwwakeup(tp);
1699 #endif
1700
1701         crit_exit();
1702 }
1703
1704 /*****************************************************************************/
1705
1706 static void stl_flush(stlport_t *portp, int flag)
1707 {
1708         char    *head, *tail;
1709         int     len;
1710
1711 #if STLDEBUG
1712         printf("stl_flush(portp=%x,flag=%x)\n", (int) portp, flag);
1713 #endif
1714
1715         if (portp == (stlport_t *) NULL)
1716                 return;
1717
1718         crit_enter();
1719
1720         if (flag & FWRITE) {
1721                 stl_uartflush(portp, FWRITE);
1722                 portp->tx.tail = portp->tx.head;
1723         }
1724
1725 /*
1726  *      The only thing to watch out for when flushing the read side is
1727  *      the RX status buffer. The interrupt code relys on the status
1728  *      bytes as being zeroed all the time (it does not bother setting
1729  *      a good char status to 0, it expects that it already will be).
1730  *      We also need to un-flow the RX channel if flow control was
1731  *      active.
1732  */
1733         if (flag & FREAD) {
1734                 head = portp->rx.head;
1735                 tail = portp->rx.tail;
1736                 if (head != tail) {
1737                         if (head >= tail) {
1738                                 len = head - tail;
1739                         } else {
1740                                 len = portp->rx.endbuf - tail;
1741                                 bzero(portp->rxstatus.buf,
1742                                         (head - portp->rx.buf));
1743                         }
1744                         bzero((tail + STL_RXBUFSIZE), len);
1745                         portp->rx.tail = head;
1746                 }
1747
1748                 if ((portp->state & ASY_RTSFLOW) &&
1749                                 ((portp->tty.t_state & TS_TBLOCK) == 0))
1750                         stl_flowcontrol(portp, 1, -1);
1751         }
1752
1753         crit_exit();
1754 }
1755
1756 /*****************************************************************************/
1757
1758 /*
1759  *      Interrupt handler for host based boards. Interrupts for all boards
1760  *      are vectored through here.
1761  */
1762
1763 void stlintr(int unit)
1764 {
1765         stlbrd_t        *brdp;
1766         int             i;
1767
1768 #if STLDEBUG
1769         printf("stlintr(unit=%d)\n", unit);
1770 #endif
1771
1772         for (i = 0; (i < stl_nrbrds); i++) {
1773                 if ((brdp = stl_brds[i]) == (stlbrd_t *) NULL)
1774                         continue;
1775                 if (brdp->state == 0)
1776                         continue;
1777                 (* brdp->isr)(brdp);
1778         }
1779 }
1780
1781 /*****************************************************************************/
1782
1783 #if NPCI > 0
1784
1785 static void stlpciintr(void *arg)
1786 {
1787         stlintr(0);
1788 }
1789
1790 #endif
1791
1792 /*****************************************************************************/
1793
1794 /*
1795  *      Interrupt service routine for EasyIO boards.
1796  */
1797
1798 static void stl_eiointr(stlbrd_t *brdp)
1799 {
1800         stlpanel_t      *panelp;
1801         int             iobase;
1802
1803 #if STLDEBUG
1804         printf("stl_eiointr(brdp=%p)\n", brdp);
1805 #endif
1806
1807         panelp = (stlpanel_t *) brdp->panels[0];
1808         iobase = panelp->iobase;
1809         while (inb(brdp->iostatus) & EIO_INTRPEND)
1810                 (* panelp->isr)(panelp, iobase);
1811 }
1812
1813 /*
1814  *      Interrupt service routine for ECH-AT board types.
1815  */
1816
1817 static void stl_echatintr(stlbrd_t *brdp)
1818 {
1819         stlpanel_t      *panelp;
1820         unsigned int    ioaddr;
1821         int             bnknr;
1822
1823         outb(brdp->ioctrl, (brdp->ioctrlval | ECH_BRDENABLE));
1824
1825         while (inb(brdp->iostatus) & ECH_INTRPEND) {
1826                 for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
1827                         ioaddr = brdp->bnkstataddr[bnknr];
1828                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1829                                 panelp = brdp->bnk2panel[bnknr];
1830                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1831                         }
1832                 }
1833         }
1834
1835         outb(brdp->ioctrl, (brdp->ioctrlval | ECH_BRDDISABLE));
1836 }
1837
1838 /*****************************************************************************/
1839
1840 /*
1841  *      Interrupt service routine for ECH-MCA board types.
1842  */
1843
1844 static void stl_echmcaintr(stlbrd_t *brdp)
1845 {
1846         stlpanel_t      *panelp;
1847         unsigned int    ioaddr;
1848         int             bnknr;
1849
1850         while (inb(brdp->iostatus) & ECH_INTRPEND) {
1851                 for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
1852                         ioaddr = brdp->bnkstataddr[bnknr];
1853                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1854                                 panelp = brdp->bnk2panel[bnknr];
1855                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1856                         }
1857                 }
1858         }
1859 }
1860
1861 /*****************************************************************************/
1862
1863 /*
1864  *      Interrupt service routine for ECH-PCI board types.
1865  */
1866
1867 static void stl_echpciintr(stlbrd_t *brdp)
1868 {
1869         stlpanel_t      *panelp;
1870         unsigned int    ioaddr;
1871         int             bnknr, recheck;
1872
1873 #if STLDEBUG
1874         printf("stl_echpciintr(brdp=%x)\n", (int) brdp);
1875 #endif
1876
1877         for (;;) {
1878                 recheck = 0;
1879                 for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
1880                         outb(brdp->ioctrl, brdp->bnkpageaddr[bnknr]);
1881                         ioaddr = brdp->bnkstataddr[bnknr];
1882                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1883                                 panelp = brdp->bnk2panel[bnknr];
1884                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1885                                 recheck++;
1886                         }
1887                 }
1888                 if (! recheck)
1889                         break;
1890         }
1891 }
1892
1893 /*****************************************************************************/
1894
1895 /*
1896  *      Interrupt service routine for EC8/64-PCI board types.
1897  */
1898
1899 static void stl_echpci64intr(stlbrd_t *brdp)
1900 {
1901         stlpanel_t      *panelp;
1902         unsigned int    ioaddr;
1903         int             bnknr;
1904
1905 #if STLDEBUG
1906         printf("stl_echpci64intr(brdp=%p)\n", brdp);
1907 #endif
1908
1909         while (inb(brdp->ioctrl) & 0x1) {
1910                 for (bnknr = 0; (bnknr < brdp->nrbnks); bnknr++) {
1911                         ioaddr = brdp->bnkstataddr[bnknr];
1912 #if STLDEBUG
1913         printf("    --> ioaddr=%x status=%x(%x)\n", ioaddr, inb(ioaddr) & ECH_PNLINTRPEND, inb(ioaddr));
1914 #endif
1915                         if (inb(ioaddr) & ECH_PNLINTRPEND) {
1916                                 panelp = brdp->bnk2panel[bnknr];
1917                                 (* panelp->isr)(panelp, (ioaddr & 0xfffc));
1918                         }
1919                 }
1920         }
1921 }
1922
1923 /*****************************************************************************/
1924
1925 /*
1926  *      If we haven't scheduled a timeout then do it, some port needs high
1927  *      level processing.
1928  */
1929
1930 static void stl_dotimeout()
1931 {
1932 #if STLDEBUG
1933         printf("stl_dotimeout()\n");
1934 #endif
1935         if (stl_doingtimeout == 0) {
1936                 if ((stl_poll_ch.c_flags & CALLOUT_DID_INIT) == 0)
1937                         callout_init(&stl_poll_ch);
1938                 callout_reset(&stl_poll_ch, 1, stl_poll, NULL);
1939                 stl_doingtimeout++;
1940         }
1941 }
1942
1943 /*****************************************************************************/
1944
1945 /*
1946  *      Service "software" level processing. Too slow or painfull to be done
1947  *      at real hardware interrupt time. This way we might also be able to
1948  *      do some service on other waiting ports as well...
1949  */
1950
1951 static void stl_poll(void *arg)
1952 {
1953         stlbrd_t        *brdp;
1954         stlport_t       *portp;
1955         struct tty      *tp;
1956         int             brdnr, portnr, rearm;
1957
1958 #if STLDEBUG
1959         printf("stl_poll()\n");
1960 #endif
1961
1962         stl_doingtimeout = 0;
1963         rearm = 0;
1964
1965         crit_enter();
1966         for (brdnr = 0; (brdnr < stl_nrbrds); brdnr++) {
1967                 if ((brdp = stl_brds[brdnr]) == (stlbrd_t *) NULL)
1968                         continue;
1969                 for (portnr = 0; (portnr < brdp->nrports); portnr++) {
1970                         if ((portp = brdp->ports[portnr]) == (stlport_t *) NULL)
1971                                 continue;
1972                         if ((portp->state & ASY_ACTIVE) == 0)
1973                                 continue;
1974                         tp = &portp->tty;
1975
1976                         if (portp->state & ASY_RXDATA)
1977                                 stl_rxprocess(portp);
1978                         if (portp->state & ASY_DCDCHANGE) {
1979                                 portp->state &= ~ASY_DCDCHANGE;
1980                                 portp->sigs = stl_getsignals(portp);
1981                                 (*linesw[tp->t_line].l_modem)(tp,
1982                                         (portp->sigs & TIOCM_CD));
1983                         }
1984                         if (portp->state & ASY_TXEMPTY) {
1985                                 if (stl_datastate(portp) == 0) {
1986                                         portp->state &= ~ASY_TXEMPTY;
1987                                         tp->t_state &= ~TS_BUSY;
1988                                         (*linesw[tp->t_line].l_start)(tp);
1989                                 }
1990                         }
1991                         if (portp->state & ASY_TXLOW) {
1992                                 portp->state &= ~ASY_TXLOW;
1993                                 (*linesw[tp->t_line].l_start)(tp);
1994                         }
1995
1996                         if (portp->state & ASY_ACTIVE)
1997                                 rearm++;
1998                 }
1999         }
2000         crit_exit();
2001
2002         if (rearm)
2003                 stl_dotimeout();
2004 }
2005
2006 /*****************************************************************************/
2007
2008 /*
2009  *      Process the RX data that has been buffered up in the RX ring queue.
2010  */
2011
2012 static void stl_rxprocess(stlport_t *portp)
2013 {
2014         struct tty      *tp;
2015         unsigned int    len, stlen, lostlen;
2016         char            *head, *tail;
2017         char            status;
2018         int             ch;
2019
2020 #if STLDEBUG
2021         printf("stl_rxprocess(portp=%x): brdnr=%d portnr=%d\n", (int) portp,
2022                 portp->brdnr, portp->portnr);
2023 #endif
2024
2025         tp = &portp->tty;
2026         portp->state &= ~ASY_RXDATA;
2027
2028         if ((tp->t_state & TS_ISOPEN) == 0) {
2029                 stl_flush(portp, FREAD);
2030                 return;
2031         }
2032
2033 /*
2034  *      Calculate the amount of data in the RX ring queue. Also calculate
2035  *      the largest single copy size...
2036  */
2037         head = portp->rx.head;
2038         tail = portp->rx.tail;
2039         if (head >= tail) {
2040                 len = head - tail;
2041                 stlen = len;
2042         } else {
2043                 len = STL_RXBUFSIZE - (tail - head);
2044                 stlen = portp->rx.endbuf - tail;
2045         }
2046
2047         if (tp->t_state & TS_CAN_BYPASS_L_RINT) {
2048                 if (len > 0) {
2049                         if (((tp->t_rawq.c_cc + len) >= TTYHOG) &&
2050                                         ((portp->state & ASY_RTSFLOWMODE) ||
2051                                         (tp->t_iflag & IXOFF)) &&
2052                                         ((tp->t_state & TS_TBLOCK) == 0)) {
2053                                 ch = TTYHOG - tp->t_rawq.c_cc - 1;
2054                                 len = (ch > 0) ? ch : 0;
2055                                 stlen = MIN(stlen, len);
2056                                 ttyblock(tp);
2057                         }
2058                         lostlen = b_to_q(tail, stlen, &tp->t_rawq);
2059                         tail += stlen;
2060                         len -= stlen;
2061                         if (tail >= portp->rx.endbuf) {
2062                                 tail = portp->rx.buf;
2063                                 lostlen += b_to_q(tail, len, &tp->t_rawq);
2064                                 tail += len;
2065                         }
2066                         portp->stats.rxlost += lostlen;
2067                         ttwakeup(tp);
2068                         portp->rx.tail = tail;
2069                 }
2070         } else {
2071                 while (portp->rx.tail != head) {
2072                         ch = (unsigned char) *(portp->rx.tail);
2073                         status = *(portp->rx.tail + STL_RXBUFSIZE);
2074                         if (status) {
2075                                 *(portp->rx.tail + STL_RXBUFSIZE) = 0;
2076                                 if (status & ST_BREAK)
2077                                         ch |= TTY_BI;
2078                                 if (status & ST_FRAMING)
2079                                         ch |= TTY_FE;
2080                                 if (status & ST_PARITY)
2081                                         ch |= TTY_PE;
2082                                 if (status & ST_OVERRUN)
2083                                         ch |= TTY_OE;
2084                         }
2085                         (*linesw[tp->t_line].l_rint)(ch, tp);
2086                         if (portp->rx.tail == head)
2087                                 break;
2088
2089                         if (++(portp->rx.tail) >= portp->rx.endbuf)
2090                                 portp->rx.tail = portp->rx.buf;
2091                 }
2092         }
2093
2094         if (head != portp->rx.tail)
2095                 portp->state |= ASY_RXDATA;
2096
2097 /*
2098  *      If we were flow controled then maybe the buffer is low enough that
2099  *      we can re-activate it.
2100  */
2101         if ((portp->state & ASY_RTSFLOW) && ((tp->t_state & TS_TBLOCK) == 0))
2102                 stl_flowcontrol(portp, 1, -1);
2103 }
2104
2105 /*****************************************************************************/
2106
2107 static int stl_param(struct tty *tp, struct termios *tiosp)
2108 {
2109         stlport_t       *portp;
2110
2111         portp = (stlport_t *) tp;
2112         if (portp == (stlport_t *) NULL)
2113                 return(ENODEV);
2114
2115         return(stl_setport(portp, tiosp));
2116 }
2117
2118 /*****************************************************************************/
2119
2120 /*
2121  *      Action the flow control as required. The hw and sw args inform the
2122  *      routine what flow control methods it should try.
2123  */
2124
2125 static void stl_flowcontrol(stlport_t *portp, int hw, int sw)
2126 {
2127         unsigned char   *head, *tail;
2128         int             len, hwflow;
2129
2130 #if STLDEBUG
2131         printf("stl_flowcontrol(portp=%x,hw=%d,sw=%d)\n", (int) portp, hw, sw);
2132 #endif
2133
2134         hwflow = -1;
2135
2136         if (portp->state & ASY_RTSFLOWMODE) {
2137                 if (hw == 0) {
2138                         if ((portp->state & ASY_RTSFLOW) == 0)
2139                                 hwflow = 0;
2140                 } else if (hw > 0) {
2141                         if (portp->state & ASY_RTSFLOW) {
2142                                 head = portp->rx.head;
2143                                 tail = portp->rx.tail;
2144                                 len = (head >= tail) ? (head - tail) :
2145                                         (STL_RXBUFSIZE - (tail - head));
2146                                 if (len < STL_RXBUFHIGH)
2147                                         hwflow = 1;
2148                         }
2149                 }
2150         }
2151
2152 /*
2153  *      We have worked out what to do, if anything. So now apply it to the
2154  *      UART port.
2155  */
2156         stl_sendflow(portp, hwflow, sw);
2157 }
2158
2159 /*****************************************************************************/
2160
2161 /*
2162  *      Enable l_rint processing bypass mode if tty modes allow it.
2163  */
2164
2165 static void stl_ttyoptim(stlport_t *portp, struct termios *tiosp)
2166 {
2167         struct tty      *tp;
2168
2169         tp = &portp->tty;
2170         if (((tiosp->c_iflag &
2171               (ICRNL | IGNCR | IMAXBEL | INLCR | ISTRIP)) == 0) &&
2172             (((tiosp->c_iflag & BRKINT) == 0) || (tiosp->c_iflag & IGNBRK)) &&
2173             (((tiosp->c_iflag & PARMRK) == 0) ||
2174                 ((tiosp->c_iflag & (IGNPAR | IGNBRK)) == (IGNPAR | IGNBRK))) &&
2175             ((tiosp->c_lflag & (ECHO | ICANON | IEXTEN | ISIG | PENDIN)) ==0) &&
2176             (linesw[tp->t_line].l_rint == ttyinput))
2177                 tp->t_state |= TS_CAN_BYPASS_L_RINT;
2178         else
2179                 tp->t_state &= ~TS_CAN_BYPASS_L_RINT;
2180         portp->hotchar = linesw[tp->t_line].l_hotchar;
2181 }
2182
2183 /*****************************************************************************/
2184
2185 /*
2186  *      Try and find and initialize all the ports on a panel. We don't care
2187  *      what sort of board these ports are on - since the port io registers
2188  *      are almost identical when dealing with ports.
2189  */
2190
2191 static int stl_initports(stlbrd_t *brdp, stlpanel_t *panelp)
2192 {
2193         stlport_t       *portp;
2194         unsigned int    chipmask;
2195         int             i, j;
2196
2197 #if STLDEBUG
2198         printf("stl_initports(panelp=%x)\n", (int) panelp);
2199 #endif
2200
2201         chipmask = stl_panelinit(brdp, panelp);
2202
2203 /*
2204  *      All UART's are initialized if found. Now go through and setup
2205  *      each ports data structures. Also initialize each individual
2206  *      UART port.
2207  */
2208         for (i = 0; (i < panelp->nrports); i++) {
2209                 portp = malloc(sizeof(stlport_t), M_TTYS, M_WAITOK | M_ZERO);
2210
2211                 portp->portnr = i;
2212                 portp->brdnr = panelp->brdnr;
2213                 portp->panelnr = panelp->panelnr;
2214                 portp->uartp = panelp->uartp;
2215                 portp->clk = brdp->clk;
2216                 panelp->ports[i] = portp;
2217
2218                 j = STL_TXBUFSIZE + (2 * STL_RXBUFSIZE);
2219                 portp->tx.buf = malloc(j, M_TTYS, M_WAITOK);
2220                 portp->tx.endbuf = portp->tx.buf + STL_TXBUFSIZE;
2221                 portp->tx.head = portp->tx.buf;
2222                 portp->tx.tail = portp->tx.buf;
2223                 portp->rx.buf = portp->tx.buf + STL_TXBUFSIZE;
2224                 portp->rx.endbuf = portp->rx.buf + STL_RXBUFSIZE;
2225                 portp->rx.head = portp->rx.buf;
2226                 portp->rx.tail = portp->rx.buf;
2227                 portp->rxstatus.buf = portp->rx.buf + STL_RXBUFSIZE;
2228                 portp->rxstatus.endbuf = portp->rxstatus.buf + STL_RXBUFSIZE;
2229                 portp->rxstatus.head = portp->rxstatus.buf;
2230                 portp->rxstatus.tail = portp->rxstatus.buf;
2231                 bzero(portp->rxstatus.head, STL_RXBUFSIZE);
2232
2233                 portp->initintios.c_ispeed = STL_DEFSPEED;
2234                 portp->initintios.c_ospeed = STL_DEFSPEED;
2235                 portp->initintios.c_cflag = STL_DEFCFLAG;
2236                 portp->initintios.c_iflag = 0;
2237                 portp->initintios.c_oflag = 0;
2238                 portp->initintios.c_lflag = 0;
2239                 bcopy(&ttydefchars[0], &portp->initintios.c_cc[0],
2240                         sizeof(portp->initintios.c_cc));
2241                 portp->initouttios = portp->initintios;
2242                 portp->dtrwait = 3 * hz;
2243                 callout_init(&portp->dtr_ch);
2244
2245                 stl_portinit(brdp, panelp, portp);
2246         }
2247
2248         return(0);
2249 }
2250
2251 /*****************************************************************************/
2252
2253 /*
2254  *      Try to find and initialize an EasyIO board.
2255  */
2256
2257 static int stl_initeio(stlbrd_t *brdp)
2258 {
2259         stlpanel_t      *panelp;
2260         unsigned int    status;
2261
2262 #if STLDEBUG
2263         printf("stl_initeio(brdp=%x)\n", (int) brdp);
2264 #endif
2265
2266         brdp->ioctrl = brdp->ioaddr1 + 1;
2267         brdp->iostatus = brdp->ioaddr1 + 2;
2268         brdp->clk = EIO_CLK;
2269         brdp->isr = stl_eiointr;
2270
2271         status = inb(brdp->iostatus);
2272         switch (status & EIO_IDBITMASK) {
2273         case EIO_8PORTM:
2274                 brdp->clk = EIO_CLK8M;
2275                 /* fall thru */
2276         case EIO_8PORTRS:
2277         case EIO_8PORTDI:
2278                 brdp->nrports = 8;
2279                 break;
2280         case EIO_4PORTRS:
2281                 brdp->nrports = 4;
2282                 break;
2283         case EIO_MK3:
2284                 switch (status & EIO_BRDMASK) {
2285                 case ID_BRD4:
2286                         brdp->nrports = 4;
2287                         break;
2288                 case ID_BRD8:
2289                         brdp->nrports = 8;
2290                         break;
2291                 case ID_BRD16:
2292                         brdp->nrports = 16;
2293                         break;
2294                 default:
2295                         return(ENODEV);
2296                 }
2297                 brdp->ioctrl++;
2298                 break;
2299         default:
2300                 return(ENODEV);
2301         }
2302
2303         if (brdp->brdtype == BRD_EASYIOPCI) {
2304                 outb((brdp->ioaddr2 + 0x4c), 0x41);
2305         } else {
2306 /*
2307  *      Check that the supplied IRQ is good and then use it to setup the
2308  *      programmable interrupt bits on EIO board. Also set the edge/level
2309  *      triggered interrupt bit.
2310  */
2311                 if ((brdp->irq < 0) || (brdp->irq > 15) ||
2312                         (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
2313                         printf("STALLION: invalid irq=%d for brd=%d\n",
2314                                brdp->irq, brdp->brdnr);
2315                         return(EINVAL);
2316                 }
2317                 outb(brdp->ioctrl, (stl_vecmap[brdp->irq] |
2318                         ((brdp->irqtype) ? EIO_INTLEVEL : EIO_INTEDGE)));
2319         }
2320
2321         panelp = malloc(sizeof(stlpanel_t), M_TTYS, M_WAITOK | M_ZERO);
2322         panelp->brdnr = brdp->brdnr;
2323         panelp->panelnr = 0;
2324         panelp->nrports = brdp->nrports;
2325         panelp->iobase = brdp->ioaddr1;
2326         panelp->hwid = status;
2327         if ((status & EIO_IDBITMASK) == EIO_MK3) {
2328                 panelp->uartp = (void *) &stl_sc26198uart;
2329                 panelp->isr = stl_sc26198intr;
2330         } else {
2331                 panelp->uartp = (void *) &stl_cd1400uart;
2332                 panelp->isr = stl_cd1400eiointr;
2333         }
2334         brdp->panels[0] = panelp;
2335         brdp->nrpanels = 1;
2336         brdp->hwid = status;
2337         brdp->state |= BRD_FOUND;
2338         return(0);
2339 }
2340
2341 /*****************************************************************************/
2342
2343 /*
2344  *      Try to find an ECH board and initialize it. This code is capable of
2345  *      dealing with all types of ECH board.
2346  */
2347
2348 static int stl_initech(stlbrd_t *brdp)
2349 {
2350         stlpanel_t      *panelp;
2351         unsigned int    status, nxtid;
2352         int             panelnr, ioaddr, banknr, i;
2353
2354 #if STLDEBUG
2355         printf("stl_initech(brdp=%x)\n", (int) brdp);
2356 #endif
2357
2358 /*
2359  *      Set up the initial board register contents for boards. This varys a
2360  *      bit between the different board types. So we need to handle each
2361  *      separately. Also do a check that the supplied IRQ is good.
2362  */
2363         switch (brdp->brdtype) {
2364
2365         case BRD_ECH:
2366                 brdp->isr = stl_echatintr;
2367                 brdp->ioctrl = brdp->ioaddr1 + 1;
2368                 brdp->iostatus = brdp->ioaddr1 + 1;
2369                 status = inb(brdp->iostatus);
2370                 if ((status & ECH_IDBITMASK) != ECH_ID)
2371                         return(ENODEV);
2372                 brdp->hwid = status;
2373
2374                 if ((brdp->irq < 0) || (brdp->irq > 15) ||
2375                     (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
2376                         printf("STALLION: invalid irq=%d for brd=%d\n",
2377                                 brdp->irq, brdp->brdnr);
2378                         return(EINVAL);
2379                 }
2380                 status = ((brdp->ioaddr2 & ECH_ADDR2MASK) >> 1);
2381                 status |= (stl_vecmap[brdp->irq] << 1);
2382                 outb(brdp->ioaddr1, (status | ECH_BRDRESET));
2383                 brdp->ioctrlval = ECH_INTENABLE |
2384                         ((brdp->irqtype) ? ECH_INTLEVEL : ECH_INTEDGE);
2385                 outb(brdp->ioctrl, (brdp->ioctrlval | ECH_BRDENABLE));
2386                 outb(brdp->ioaddr1, status);
2387                 break;
2388
2389         case BRD_ECHMC:
2390                 brdp->isr = stl_echmcaintr;
2391                 brdp->ioctrl = brdp->ioaddr1 + 0x20;
2392                 brdp->iostatus = brdp->ioctrl;
2393                 status = inb(brdp->iostatus);
2394                 if ((status & ECH_IDBITMASK) != ECH_ID)
2395                         return(ENODEV);
2396                 brdp->hwid = status;
2397
2398                 if ((brdp->irq < 0) || (brdp->irq > 15) ||
2399                     (stl_vecmap[brdp->irq] == (unsigned char) 0xff)) {
2400                         printf("STALLION: invalid irq=%d for brd=%d\n",
2401                                 brdp->irq, brdp->brdnr);
2402                         return(EINVAL);
2403                 }
2404                 outb(brdp->ioctrl, ECHMC_BRDRESET);
2405                 outb(brdp->ioctrl, ECHMC_INTENABLE);
2406                 break;
2407
2408         case BRD_ECHPCI:
2409                 brdp->isr = stl_echpciintr;
2410                 brdp->ioctrl = brdp->ioaddr1 + 2;
2411                 break;
2412
2413         case BRD_ECH64PCI:
2414                 brdp->isr = stl_echpci64intr;
2415                 brdp->ioctrl = brdp->ioaddr2 + 0x40;
2416                 outb((brdp->ioaddr1 + 0x4c), 0x43);
2417                 break;
2418
2419         default:
2420                 printf("STALLION: unknown board type=%d\n", brdp->brdtype);
2421                 break;
2422         }
2423
2424         brdp->clk = ECH_CLK;
2425
2426 /*
2427  *      Scan through the secondary io address space looking for panels.
2428  *      As we find'em allocate and initialize panel structures for each.
2429  */
2430         ioaddr = brdp->ioaddr2;
2431         panelnr = 0;
2432         nxtid = 0;
2433         banknr = 0;
2434
2435         for (i = 0; (i < STL_MAXPANELS); i++) {
2436                 if (brdp->brdtype == BRD_ECHPCI) {
2437                         outb(brdp->ioctrl, nxtid);
2438                         ioaddr = brdp->ioaddr2;
2439                 }
2440                 status = inb(ioaddr + ECH_PNLSTATUS);
2441                 if ((status & ECH_PNLIDMASK) != nxtid)
2442                         break;
2443                 panelp = malloc(sizeof(stlpanel_t), M_TTYS, M_WAITOK | M_ZERO);
2444                 panelp->brdnr = brdp->brdnr;
2445                 panelp->panelnr = panelnr;
2446                 panelp->iobase = ioaddr;
2447                 panelp->pagenr = nxtid;
2448                 panelp->hwid = status;
2449                 brdp->bnk2panel[banknr] = panelp;
2450                 brdp->bnkpageaddr[banknr] = nxtid;
2451                 brdp->bnkstataddr[banknr++] = ioaddr + ECH_PNLSTATUS;
2452
2453                 if (status & ECH_PNLXPID) {
2454                         panelp->uartp = (void *) &stl_sc26198uart;
2455                         panelp->isr = stl_sc26198intr;
2456                         if (status & ECH_PNL16PORT) {
2457                                 panelp->nrports = 16;
2458                                 brdp->bnk2panel[banknr] = panelp;
2459                                 brdp->bnkpageaddr[banknr] = nxtid;
2460                                 brdp->bnkstataddr[banknr++] = ioaddr + 4 +
2461                                         ECH_PNLSTATUS;
2462                         } else {
2463                                 panelp->nrports = 8;
2464                         }
2465                 } else {
2466                         panelp->uartp = (void *) &stl_cd1400uart;
2467                         panelp->isr = stl_cd1400echintr;
2468                         if (status & ECH_PNL16PORT) {
2469                                 panelp->nrports = 16;
2470                                 panelp->ackmask = 0x80;
2471                                 if (brdp->brdtype != BRD_ECHPCI)
2472                                         ioaddr += EREG_BANKSIZE;
2473                                 brdp->bnk2panel[banknr] = panelp;
2474                                 brdp->bnkpageaddr[banknr] = ++nxtid;
2475                                 brdp->bnkstataddr[banknr++] = ioaddr +
2476                                         ECH_PNLSTATUS;
2477                         } else {
2478                                 panelp->nrports = 8;
2479                                 panelp->ackmask = 0xc0;
2480                         }
2481                 }
2482
2483                 nxtid++;
2484                 ioaddr += EREG_BANKSIZE;
2485                 brdp->nrports += panelp->nrports;
2486                 brdp->panels[panelnr++] = panelp;
2487                 if ((brdp->brdtype == BRD_ECH) || (brdp->brdtype == BRD_ECHMC)){
2488                         if (ioaddr >= (brdp->ioaddr2 + 0x20)) {
2489                                 printf("STALLION: too many ports attached "
2490                                         "to board %d, remove last module\n",
2491                                         brdp->brdnr);
2492                                 break;
2493                         }
2494                 }
2495         }
2496
2497         brdp->nrpanels = panelnr;
2498         brdp->nrbnks = banknr;
2499         if (brdp->brdtype == BRD_ECH)
2500                 outb(brdp->ioctrl, (brdp->ioctrlval | ECH_BRDDISABLE));
2501
2502         brdp->state |= BRD_FOUND;
2503         return(0);
2504 }
2505
2506 /*****************************************************************************/
2507
2508 /*
2509  *      Initialize and configure the specified board. This firstly probes
2510  *      for the board, if it is found then the board is initialized and
2511  *      then all its ports are initialized as well.
2512  */
2513
2514 static int stl_brdinit(stlbrd_t *brdp)
2515 {
2516         stlpanel_t      *panelp;
2517         int             i, j, k;
2518
2519 #if STLDEBUG
2520         printf("stl_brdinit(brdp=%x): unit=%d type=%d io1=%x io2=%x irq=%d\n",
2521                 (int) brdp, brdp->brdnr, brdp->brdtype, brdp->ioaddr1,
2522                 brdp->ioaddr2, brdp->irq);
2523 #endif
2524
2525         switch (brdp->brdtype) {
2526         case BRD_EASYIO:
2527         case BRD_EASYIOPCI:
2528                 stl_initeio(brdp);
2529                 break;
2530         case BRD_ECH:
2531         case BRD_ECHMC:
2532         case BRD_ECHPCI:
2533         case BRD_ECH64PCI:
2534                 stl_initech(brdp);
2535                 break;
2536         default:
2537                 printf("STALLION: unit=%d is unknown board type=%d\n",
2538                         brdp->brdnr, brdp->brdtype);
2539                 return(ENODEV);
2540         }
2541
2542         stl_brds[brdp->brdnr] = brdp;
2543         if ((brdp->state & BRD_FOUND) == 0) {
2544 #if 0
2545                 printf("STALLION: %s board not found, unit=%d io=%x irq=%d\n",
2546                         stl_brdnames[brdp->brdtype], brdp->brdnr,
2547                         brdp->ioaddr1, brdp->irq);
2548 #endif
2549                 return(ENODEV);
2550         }
2551
2552         for (i = 0, k = 0; (i < STL_MAXPANELS); i++) {
2553                 panelp = brdp->panels[i];
2554                 if (panelp != (stlpanel_t *) NULL) {
2555                         stl_initports(brdp, panelp);
2556                         for (j = 0; (j < panelp->nrports); j++)
2557                                 brdp->ports[k++] = panelp->ports[j];
2558                 }
2559         }
2560
2561         printf("stl%d: %s (driver version %s) unit=%d nrpanels=%d nrports=%d\n",
2562                 brdp->unitid, stl_brdnames[brdp->brdtype], stl_drvversion,
2563                 brdp->brdnr, brdp->nrpanels, brdp->nrports);
2564         return(0);
2565 }
2566
2567 /*****************************************************************************/
2568
2569 /*
2570  *      Return the board stats structure to user app.
2571  */
2572
2573 static int stl_getbrdstats(caddr_t data)
2574 {
2575         stlbrd_t        *brdp;
2576         stlpanel_t      *panelp;
2577         int             i;
2578
2579         stl_brdstats = *((combrd_t *) data);
2580         if (stl_brdstats.brd >= STL_MAXBRDS)
2581                 return(-ENODEV);
2582         brdp = stl_brds[stl_brdstats.brd];
2583         if (brdp == (stlbrd_t *) NULL)
2584                 return(-ENODEV);
2585
2586         bzero(&stl_brdstats, sizeof(combrd_t));
2587         stl_brdstats.brd = brdp->brdnr;
2588         stl_brdstats.type = brdp->brdtype;
2589         stl_brdstats.hwid = brdp->hwid;
2590         stl_brdstats.state = brdp->state;
2591         stl_brdstats.ioaddr = brdp->ioaddr1;
2592         stl_brdstats.ioaddr2 = brdp->ioaddr2;
2593         stl_brdstats.irq = brdp->irq;
2594         stl_brdstats.nrpanels = brdp->nrpanels;
2595         stl_brdstats.nrports = brdp->nrports;
2596         for (i = 0; (i < brdp->nrpanels); i++) {
2597                 panelp = brdp->panels[i];
2598                 stl_brdstats.panels[i].panel = i;
2599                 stl_brdstats.panels[i].hwid = panelp->hwid;
2600                 stl_brdstats.panels[i].nrports = panelp->nrports;
2601         }
2602
2603         *((combrd_t *) data) = stl_brdstats;;
2604         return(0);
2605 }
2606
2607 /*****************************************************************************/
2608
2609 /*
2610  *      Resolve the referenced port number into a port struct pointer.
2611  */
2612
2613 static stlport_t *stl_getport(int brdnr, int panelnr, int portnr)
2614 {
2615         stlbrd_t        *brdp;
2616         stlpanel_t      *panelp;
2617
2618         if ((brdnr < 0) || (brdnr >= STL_MAXBRDS))
2619                 return((stlport_t *) NULL);
2620         brdp = stl_brds[brdnr];
2621         if (brdp == (stlbrd_t *) NULL)
2622                 return((stlport_t *) NULL);
2623         if ((panelnr < 0) || (panelnr >= brdp->nrpanels))
2624                 return((stlport_t *) NULL);
2625         panelp = brdp->panels[panelnr];
2626         if (panelp == (stlpanel_t *) NULL)
2627                 return((stlport_t *) NULL);
2628         if ((portnr < 0) || (portnr >= panelp->nrports))
2629                 return((stlport_t *) NULL);
2630         return(panelp->ports[portnr]);
2631 }
2632
2633 /*****************************************************************************/
2634
2635 /*
2636  *      Return the port stats structure to user app. A NULL port struct
2637  *      pointer passed in means that we need to find out from the app
2638  *      what port to get stats for (used through board control device).
2639  */
2640
2641 static int stl_getportstats(stlport_t *portp, caddr_t data)
2642 {
2643         unsigned char   *head, *tail;
2644
2645         if (portp == (stlport_t *) NULL) {
2646                 stl_comstats = *((comstats_t *) data);
2647                 portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
2648                         stl_comstats.port);
2649                 if (portp == (stlport_t *) NULL)
2650                         return(-ENODEV);
2651         }
2652
2653         portp->stats.state = portp->state;
2654         /*portp->stats.flags = portp->flags;*/
2655         portp->stats.hwid = portp->hwid;
2656         portp->stats.ttystate = portp->tty.t_state;
2657         portp->stats.cflags = portp->tty.t_cflag;
2658         portp->stats.iflags = portp->tty.t_iflag;
2659         portp->stats.oflags = portp->tty.t_oflag;
2660         portp->stats.lflags = portp->tty.t_lflag;
2661
2662         head = portp->tx.head;
2663         tail = portp->tx.tail;
2664         portp->stats.txbuffered = ((head >= tail) ? (head - tail) :
2665                 (STL_TXBUFSIZE - (tail - head)));
2666
2667         head = portp->rx.head;
2668         tail = portp->rx.tail;
2669         portp->stats.rxbuffered = (head >= tail) ? (head - tail) :
2670                 (STL_RXBUFSIZE - (tail - head));
2671
2672         portp->stats.signals = (unsigned long) stl_getsignals(portp);
2673
2674         *((comstats_t *) data) = portp->stats;
2675         return(0);
2676 }
2677
2678 /*****************************************************************************/
2679
2680 /*
2681  *      Clear the port stats structure. We also return it zeroed out...
2682  */
2683
2684 static int stl_clrportstats(stlport_t *portp, caddr_t data)
2685 {
2686         if (portp == (stlport_t *) NULL) {
2687                 stl_comstats = *((comstats_t *) data);
2688                 portp = stl_getport(stl_comstats.brd, stl_comstats.panel,
2689                         stl_comstats.port);
2690                 if (portp == (stlport_t *) NULL)
2691                         return(ENODEV);
2692         }
2693
2694         bzero(&portp->stats, sizeof(comstats_t));
2695         portp->stats.brd = portp->brdnr;
2696         portp->stats.panel = portp->panelnr;
2697         portp->stats.port = portp->portnr;
2698         *((comstats_t *) data) = stl_comstats;
2699         return(0);
2700 }
2701
2702 /*****************************************************************************/
2703
2704 /*
2705  *      The "staliomem" device is used for stats collection in this driver.
2706  */
2707
2708 static int stl_memioctl(dev_t dev, unsigned long cmd, caddr_t data, int flag,
2709                         struct thread *td)
2710 {
2711         int             rc;
2712
2713 #if STLDEBUG
2714         printf("stl_memioctl(dev=%s,cmd=%lx,data=%p,flag=%x)\n",
2715                 devtoname(dev), cmd, (void *) data, flag);
2716 #endif
2717
2718         rc = 0;
2719
2720         switch (cmd) {
2721         case COM_GETPORTSTATS:
2722                 rc = stl_getportstats((stlport_t *) NULL, data);
2723                 break;
2724         case COM_CLRPORTSTATS:
2725                 rc = stl_clrportstats((stlport_t *) NULL, data);
2726                 break;
2727         case COM_GETBRDSTATS:
2728                 rc = stl_getbrdstats(data);
2729                 break;
2730         default:
2731                 rc = ENOTTY;
2732                 break;
2733         }
2734
2735         return(rc);
2736 }
2737
2738 /*****************************************************************************/
2739
2740 /*****************************************************************************/
2741 /*                         CD1400 UART CODE                                  */
2742 /*****************************************************************************/
2743
2744 /*
2745  *      These functions get/set/update the registers of the cd1400 UARTs.
2746  *      Access to the cd1400 registers is via an address/data io port pair.
2747  */
2748
2749 static int stl_cd1400getreg(stlport_t *portp, int regnr)
2750 {
2751         outb(portp->ioaddr, (regnr + portp->uartaddr));
2752         return(inb(portp->ioaddr + EREG_DATA));
2753 }
2754
2755 /*****************************************************************************/
2756
2757 static void stl_cd1400setreg(stlport_t *portp, int regnr, int value)
2758 {
2759         outb(portp->ioaddr, (regnr + portp->uartaddr));
2760         outb((portp->ioaddr + EREG_DATA), value);
2761 }
2762
2763 /*****************************************************************************/
2764
2765 static int stl_cd1400updatereg(stlport_t *portp, int regnr, int value)
2766 {
2767         outb(portp->ioaddr, (regnr + portp->uartaddr));
2768         if (inb(portp->ioaddr + EREG_DATA) != value) {
2769                 outb((portp->ioaddr + EREG_DATA), value);
2770                 return(1);
2771         }
2772         return(0);
2773 }
2774
2775 /*****************************************************************************/
2776
2777 static void stl_cd1400flush(stlport_t *portp, int flag)
2778 {
2779
2780 #if STLDEBUG
2781         printf("stl_cd1400flush(portp=%x,flag=%x)\n", (int) portp, flag);
2782 #endif
2783
2784         if (portp == (stlport_t *) NULL)
2785                 return;
2786
2787         crit_enter();
2788
2789         if (flag & FWRITE) {
2790                 BRDENABLE(portp->brdnr, portp->pagenr);
2791                 stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
2792                 stl_cd1400ccrwait(portp);
2793                 stl_cd1400setreg(portp, CCR, CCR_TXFLUSHFIFO);
2794                 stl_cd1400ccrwait(portp);
2795                 BRDDISABLE(portp->brdnr);
2796         }
2797
2798         if (flag & FREAD) {
2799                 /* Hmmm */
2800         }
2801
2802         crit_exit();
2803 }
2804
2805 /*****************************************************************************/
2806
2807 static void stl_cd1400ccrwait(stlport_t *portp)
2808 {
2809         int     i;
2810
2811         for (i = 0; (i < CCR_MAXWAIT); i++) {
2812                 if (stl_cd1400getreg(portp, CCR) == 0)
2813                         return;
2814         }
2815
2816         printf("stl%d: cd1400 device not responding, panel=%d port=%d\n",
2817             portp->brdnr, portp->panelnr, portp->portnr);
2818 }
2819
2820 /*****************************************************************************/
2821
2822 /*
2823  *      Transmit interrupt handler. This has gotta be fast!  Handling TX
2824  *      chars is pretty simple, stuff as many as possible from the TX buffer
2825  *      into the cd1400 FIFO. Must also handle TX breaks here, since they
2826  *      are embedded as commands in the data stream. Oh no, had to use a goto!
2827  */
2828
2829 static __inline void stl_cd1400txisr(stlpanel_t *panelp, int ioaddr)
2830 {
2831         struct tty      *tp;
2832         stlport_t       *portp;
2833         unsigned char   ioack, srer;
2834         char            *head, *tail;
2835         int             len, stlen;
2836
2837 #if STLDEBUG
2838         printf("stl_cd1400txisr(panelp=%x,ioaddr=%x)\n", (int) panelp, ioaddr);
2839 #endif
2840
2841         ioack = inb(ioaddr + EREG_TXACK);
2842         if (((ioack & panelp->ackmask) != 0) ||
2843             ((ioack & ACK_TYPMASK) != ACK_TYPTX)) {
2844                 printf("STALLION: bad TX interrupt ack value=%x\n",
2845                         ioack);
2846                 return;
2847         }
2848         portp = panelp->ports[(ioack >> 3)];
2849         tp = &portp->tty;
2850
2851 /*
2852  *      Unfortunately we need to handle breaks in the data stream, since
2853  *      this is the only way to generate them on the cd1400. Do it now if
2854  *      a break is to be sent. Some special cases here: brklen is -1 then
2855  *      start sending an un-timed break, if brklen is -2 then stop sending
2856  *      an un-timed break, if brklen is -3 then we have just sent an
2857  *      un-timed break and do not want any data to go out, if brklen is -4
2858  *      then a break has just completed so clean up the port settings.
2859  */
2860         if (portp->brklen != 0) {
2861                 if (portp->brklen >= -1) {
2862                         outb(ioaddr, (TDR + portp->uartaddr));
2863                         outb((ioaddr + EREG_DATA), ETC_CMD);
2864                         outb((ioaddr + EREG_DATA), ETC_STARTBREAK);
2865                         if (portp->brklen > 0) {
2866                                 outb((ioaddr + EREG_DATA), ETC_CMD);
2867                                 outb((ioaddr + EREG_DATA), ETC_DELAY);
2868                                 outb((ioaddr + EREG_DATA), portp->brklen);
2869                                 outb((ioaddr + EREG_DATA), ETC_CMD);
2870                                 outb((ioaddr + EREG_DATA), ETC_STOPBREAK);
2871                                 portp->brklen = -4;
2872                         } else {
2873                                 portp->brklen = -3;
2874                         }
2875                 } else if (portp->brklen == -2) {
2876                         outb(ioaddr, (TDR + portp->uartaddr));
2877                         outb((ioaddr + EREG_DATA), ETC_CMD);
2878                         outb((ioaddr + EREG_DATA), ETC_STOPBREAK);
2879                         portp->brklen = -4;
2880                 } else if (portp->brklen == -3) {
2881                         outb(ioaddr, (SRER + portp->uartaddr));
2882                         srer = inb(ioaddr + EREG_DATA);
2883                         srer &= ~(SRER_TXDATA | SRER_TXEMPTY);
2884                         outb((ioaddr + EREG_DATA), srer);
2885                 } else {
2886                         outb(ioaddr, (COR2 + portp->uartaddr));
2887                         outb((ioaddr + EREG_DATA),
2888                                 (inb(ioaddr + EREG_DATA) & ~COR2_ETC));
2889                         portp->brklen = 0;
2890                 }
2891                 goto stl_txalldone;
2892         }
2893
2894         head = portp->tx.head;
2895         tail = portp->tx.tail;
2896         len = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
2897         if ((len == 0) || ((len < STL_TXBUFLOW) &&
2898             ((portp->state & ASY_TXLOW) == 0))) {
2899                 portp->state |= ASY_TXLOW;
2900                 stl_dotimeout();
2901         }
2902
2903         if (len == 0) {
2904                 outb(ioaddr, (SRER + portp->uartaddr));
2905                 srer = inb(ioaddr + EREG_DATA);
2906                 if (srer & SRER_TXDATA) {
2907                         srer = (srer & ~SRER_TXDATA) | SRER_TXEMPTY;
2908                 } else {
2909                         srer &= ~(SRER_TXDATA | SRER_TXEMPTY);
2910                         portp->state |= ASY_TXEMPTY;
2911                         portp->state &= ~ASY_TXBUSY;
2912                 }
2913                 outb((ioaddr + EREG_DATA), srer);
2914         } else {
2915                 len = MIN(len, CD1400_TXFIFOSIZE);
2916                 portp->stats.txtotal += len;
2917                 stlen = MIN(len, (portp->tx.endbuf - tail));
2918                 outb(ioaddr, (TDR + portp->uartaddr));
2919                 outsb((ioaddr + EREG_DATA), tail, stlen);
2920                 len -= stlen;
2921                 tail += stlen;
2922                 if (tail >= portp->tx.endbuf)
2923                         tail = portp->tx.buf;
2924                 if (len > 0) {
2925                         outsb((ioaddr + EREG_DATA), tail, len);
2926                         tail += len;
2927                 }
2928                 portp->tx.tail = tail;
2929         }
2930
2931 stl_txalldone:
2932         outb(ioaddr, (EOSRR + portp->uartaddr));
2933         outb((ioaddr + EREG_DATA), 0);
2934 }
2935
2936 /*****************************************************************************/
2937
2938 /*
2939  *      Receive character interrupt handler. Determine if we have good chars
2940  *      or bad chars and then process appropriately.
2941  */
2942
2943 static __inline void stl_cd1400rxisr(stlpanel_t *panelp, int ioaddr)
2944 {
2945         stlport_t       *portp;
2946         struct tty      *tp;
2947         unsigned int    ioack, len, buflen, stlen;
2948         unsigned char   status;
2949         char            ch;
2950         char            *head, *tail;
2951
2952 #if STLDEBUG
2953         printf("stl_cd1400rxisr(panelp=%x,ioaddr=%x)\n", (int) panelp, ioaddr);
2954 #endif
2955
2956         ioack = inb(ioaddr + EREG_RXACK);
2957         if ((ioack & panelp->ackmask) != 0) {
2958                 printf("STALLION: bad RX interrupt ack value=%x\n", ioack);
2959                 return;
2960         }
2961         portp = panelp->ports[(ioack >> 3)];
2962         tp = &portp->tty;
2963
2964 /*
2965  *      First up, calculate how much room there is in the RX ring queue.
2966  *      We also want to keep track of the longest possible copy length,
2967  *      this has to allow for the wrapping of the ring queue.
2968  */
2969         head = portp->rx.head;
2970         tail = portp->rx.tail;
2971         if (head >= tail) {
2972                 buflen = STL_RXBUFSIZE - (head - tail) - 1;
2973                 stlen = portp->rx.endbuf - head;
2974         } else {
2975                 buflen = tail - head - 1;
2976                 stlen = buflen;
2977         }
2978
2979 /*
2980  *      Check if the input buffer is near full. If so then we should take
2981  *      some flow control action... It is very easy to do hardware and
2982  *      software flow control from here since we have the port selected on
2983  *      the UART.
2984  */
2985         if (buflen <= (STL_RXBUFSIZE - STL_RXBUFHIGH)) {
2986                 if (((portp->state & ASY_RTSFLOW) == 0) &&
2987                     (portp->state & ASY_RTSFLOWMODE)) {
2988                         portp->state |= ASY_RTSFLOW;
2989                         stl_cd1400setreg(portp, MCOR1,
2990                                 (stl_cd1400getreg(portp, MCOR1) & 0xf0));
2991                         stl_cd1400setreg(portp, MSVR2, 0);
2992                         portp->stats.rxrtsoff++;
2993                 }
2994         }
2995
2996 /*
2997  *      OK we are set, process good data... If the RX ring queue is full
2998  *      just chuck the chars - don't leave them in the UART.
2999  */
3000         if ((ioack & ACK_TYPMASK) == ACK_TYPRXGOOD) {
3001                 outb(ioaddr, (RDCR + portp->uartaddr));
3002                 len = inb(ioaddr + EREG_DATA);
3003                 if (buflen == 0) {
3004                         outb(ioaddr, (RDSR + portp->uartaddr));
3005                         insb((ioaddr + EREG_DATA), &stl_unwanted[0], len);
3006                         portp->stats.rxlost += len;
3007                         portp->stats.rxtotal += len;
3008                 } else {
3009                         len = MIN(len, buflen);
3010                         portp->stats.rxtotal += len;
3011                         stlen = MIN(len, stlen);
3012                         if (len > 0) {
3013                                 outb(ioaddr, (RDSR + portp->uartaddr));
3014                                 insb((ioaddr + EREG_DATA), head, stlen);
3015                                 head += stlen;
3016                                 if (head >= portp->rx.endbuf) {
3017                                         head = portp->rx.buf;
3018                                         len -= stlen;
3019                                         insb((ioaddr + EREG_DATA), head, len);
3020                                         head += len;
3021                                 }
3022                         }
3023                 }
3024         } else if ((ioack & ACK_TYPMASK) == ACK_TYPRXBAD) {
3025                 outb(ioaddr, (RDSR + portp->uartaddr));
3026                 status = inb(ioaddr + EREG_DATA);
3027                 ch = inb(ioaddr + EREG_DATA);
3028                 if (status & ST_BREAK)
3029                         portp->stats.rxbreaks++;
3030                 if (status & ST_FRAMING)
3031                         portp->stats.rxframing++;
3032                 if (status & ST_PARITY)
3033                         portp->stats.rxparity++;
3034                 if (status & ST_OVERRUN)
3035                         portp->stats.rxoverrun++;
3036                 if (status & ST_SCHARMASK) {
3037                         if ((status & ST_SCHARMASK) == ST_SCHAR1)
3038                                 portp->stats.txxon++;
3039                         if ((status & ST_SCHARMASK) == ST_SCHAR2)
3040                                 portp->stats.txxoff++;
3041                         goto stl_rxalldone;
3042                 }
3043                 if ((portp->rxignoremsk & status) == 0) {
3044                         if ((tp->t_state & TS_CAN_BYPASS_L_RINT) &&
3045                             ((status & ST_FRAMING) ||
3046                             ((status & ST_PARITY) && (tp->t_iflag & INPCK))))
3047                                 ch = 0;
3048                         if ((portp->rxmarkmsk & status) == 0)
3049                                 status = 0;
3050                         *(head + STL_RXBUFSIZE) = status;
3051                         *head++ = ch;
3052                         if (head >= portp->rx.endbuf)
3053                                 head = portp->rx.buf;
3054                 }
3055         } else {
3056                 printf("STALLION: bad RX interrupt ack value=%x\n", ioack);
3057                 return;
3058         }
3059
3060         portp->rx.head = head;
3061         portp->state |= ASY_RXDATA;
3062         stl_dotimeout();
3063
3064 stl_rxalldone:
3065         outb(ioaddr, (EOSRR + portp->uartaddr));
3066         outb((ioaddr + EREG_DATA), 0);
3067 }
3068
3069 /*****************************************************************************/
3070
3071 /*
3072  *      Modem interrupt handler. The is called when the modem signal line
3073  *      (DCD) has changed state.
3074  */
3075
3076 static __inline void stl_cd1400mdmisr(stlpanel_t *panelp, int ioaddr)
3077 {
3078         stlport_t       *portp;
3079         unsigned int    ioack;
3080         unsigned char   misr;
3081
3082 #if STLDEBUG
3083         printf("stl_cd1400mdmisr(panelp=%x,ioaddr=%x)\n", (int) panelp, ioaddr);
3084 #endif
3085
3086         ioack = inb(ioaddr + EREG_MDACK);
3087         if (((ioack & panelp->ackmask) != 0) ||
3088             ((ioack & ACK_TYPMASK) != ACK_TYPMDM)) {
3089                 printf("STALLION: bad MODEM interrupt ack value=%x\n", ioack);
3090                 return;
3091         }
3092         portp = panelp->ports[(ioack >> 3)];
3093
3094         outb(ioaddr, (MISR + portp->uartaddr));
3095         misr = inb(ioaddr + EREG_DATA);
3096         if (misr & MISR_DCD) {
3097                 portp->state |= ASY_DCDCHANGE;
3098                 portp->stats.modem++;
3099                 stl_dotimeout();
3100         }
3101
3102         outb(ioaddr, (EOSRR + portp->uartaddr));
3103         outb((ioaddr + EREG_DATA), 0);
3104 }
3105
3106 /*****************************************************************************/
3107
3108 /*
3109  *      Interrupt service routine for cd1400 EasyIO boards.
3110  */
3111
3112 static void stl_cd1400eiointr(stlpanel_t *panelp, unsigned int iobase)
3113 {
3114         unsigned char   svrtype;
3115
3116 #if STLDEBUG
3117         printf("stl_cd1400eiointr(panelp=%x,iobase=%x)\n", (int) panelp,
3118                 iobase);
3119 #endif
3120
3121         outb(iobase, SVRR);
3122         svrtype = inb(iobase + EREG_DATA);
3123         if (panelp->nrports > 4) {
3124                 outb(iobase, (SVRR + 0x80));
3125                 svrtype |= inb(iobase + EREG_DATA);
3126         }
3127 #if STLDEBUG
3128 printf("stl_cd1400eiointr(panelp=%x,iobase=%x): svrr=%x\n", (int) panelp, iobase, svrtype);
3129 #endif
3130
3131         if (svrtype & SVRR_RX)
3132                 stl_cd1400rxisr(panelp, iobase);
3133         else if (svrtype & SVRR_TX)
3134                 stl_cd1400txisr(panelp, iobase);
3135         else if (svrtype & SVRR_MDM)
3136                 stl_cd1400mdmisr(panelp, iobase);
3137 }
3138
3139 /*****************************************************************************/
3140
3141 /*
3142  *      Interrupt service routine for cd1400 panels.
3143  */
3144
3145 static void stl_cd1400echintr(stlpanel_t *panelp, unsigned int iobase)
3146 {
3147         unsigned char   svrtype;
3148
3149 #if STLDEBUG
3150         printf("stl_cd1400echintr(panelp=%x,iobase=%x)\n", (int) panelp,
3151                 iobase);
3152 #endif
3153
3154         outb(iobase, SVRR);
3155         svrtype = inb(iobase + EREG_DATA);
3156         outb(iobase, (SVRR + 0x80));
3157         svrtype |= inb(iobase + EREG_DATA);
3158         if (svrtype & SVRR_RX)
3159                 stl_cd1400rxisr(panelp, iobase);
3160         else if (svrtype & SVRR_TX)
3161                 stl_cd1400txisr(panelp, iobase);
3162         else if (svrtype & SVRR_MDM)
3163                 stl_cd1400mdmisr(panelp, iobase);
3164 }
3165
3166 /*****************************************************************************/
3167
3168 /*
3169  *      Set up the cd1400 registers for a port based on the termios port
3170  *      settings.
3171  */
3172
3173 static int stl_cd1400setport(stlport_t *portp, struct termios *tiosp)
3174 {
3175         unsigned int    clkdiv;
3176         unsigned char   cor1, cor2, cor3;
3177         unsigned char   cor4, cor5, ccr;
3178         unsigned char   srer, sreron, sreroff;
3179         unsigned char   mcor1, mcor2, rtpr;
3180         unsigned char   clk, div;
3181
3182 #if STLDEBUG
3183         printf("stl_cd1400setport(portp=%x,tiosp=%x): brdnr=%d portnr=%d\n",
3184                 (int) portp, (int) tiosp, portp->brdnr, portp->portnr);
3185 #endif
3186
3187         cor1 = 0;
3188         cor2 = 0;
3189         cor3 = 0;
3190         cor4 = 0;
3191         cor5 = 0;
3192         ccr = 0;
3193         rtpr = 0;
3194         clk = 0;
3195         div = 0;
3196         mcor1 = 0;
3197         mcor2 = 0;
3198         sreron = 0;
3199         sreroff = 0;
3200
3201 /*
3202  *      Set up the RX char ignore mask with those RX error types we
3203  *      can ignore. We could have used some special modes of the cd1400
3204  *      UART to help, but it is better this way because we can keep stats
3205  *      on the number of each type of RX exception event.
3206  */
3207         portp->rxignoremsk = 0;
3208         if (tiosp->c_iflag & IGNPAR)
3209                 portp->rxignoremsk |= (ST_PARITY | ST_FRAMING | ST_OVERRUN);
3210         if (tiosp->c_iflag & IGNBRK)
3211                 portp->rxignoremsk |= ST_BREAK;
3212
3213         portp->rxmarkmsk = ST_OVERRUN;
3214         if (tiosp->c_iflag & (INPCK | PARMRK))
3215                 portp->rxmarkmsk |= (ST_PARITY | ST_FRAMING);
3216         if (tiosp->c_iflag & BRKINT)
3217                 portp->rxmarkmsk |= ST_BREAK;
3218
3219 /*
3220  *      Go through the char size, parity and stop bits and set all the
3221  *      option registers appropriately.
3222  */
3223         switch (tiosp->c_cflag & CSIZE) {
3224         case CS5:
3225                 cor1 |= COR1_CHL5;
3226                 break;
3227         case CS6:
3228                 cor1 |= COR1_CHL6;
3229                 break;
3230         case CS7:
3231                 cor1 |= COR1_CHL7;
3232                 break;
3233         default:
3234                 cor1 |= COR1_CHL8;
3235                 break;
3236         }
3237
3238         if (tiosp->c_cflag & CSTOPB)
3239                 cor1 |= COR1_STOP2;
3240         else
3241                 cor1 |= COR1_STOP1;
3242
3243         if (tiosp->c_cflag & PARENB) {
3244                 if (tiosp->c_cflag & PARODD)
3245                         cor1 |= (COR1_PARENB | COR1_PARODD);
3246                 else
3247                         cor1 |= (COR1_PARENB | COR1_PAREVEN);
3248         } else {
3249                 cor1 |= COR1_PARNONE;
3250         }
3251
3252 /*
3253  *      Set the RX FIFO threshold at 6 chars. This gives a bit of breathing
3254  *      space for hardware flow control and the like. This should be set to
3255  *      VMIN. Also here we will set the RX data timeout to 10ms - this should
3256  *      really be based on VTIME...
3257  */
3258         cor3 |= FIFO_RXTHRESHOLD;
3259         rtpr = 2;
3260
3261 /*
3262  *      Calculate the baud rate timers. For now we will just assume that
3263  *      the input and output baud are the same. Could have used a baud
3264  *      table here, but this way we can generate virtually any baud rate
3265  *      we like!
3266  */
3267         if (tiosp->c_ispeed == 0)
3268                 tiosp->c_ispeed = tiosp->c_ospeed;
3269         if ((tiosp->c_ospeed < 0) || (tiosp->c_ospeed > CD1400_MAXBAUD))
3270                 return(EINVAL);
3271
3272         if (tiosp->c_ospeed > 0) {
3273                 for (clk = 0; (clk < CD1400_NUMCLKS); clk++) {
3274                         clkdiv = ((portp->clk / stl_cd1400clkdivs[clk]) /
3275                                 tiosp->c_ospeed);
3276                         if (clkdiv < 0x100)
3277                                 break;
3278                 }
3279                 div = (unsigned char) clkdiv;
3280         }
3281
3282 /*
3283  *      Check what form of modem signaling is required and set it up.
3284  */
3285         if ((tiosp->c_cflag & CLOCAL) == 0) {
3286                 mcor1 |= MCOR1_DCD;
3287                 mcor2 |= MCOR2_DCD;
3288                 sreron |= SRER_MODEM;
3289         }
3290
3291 /*
3292  *      Setup cd1400 enhanced modes if we can. In particular we want to
3293  *      handle as much of the flow control as possbile automatically. As
3294  *      well as saving a few CPU cycles it will also greatly improve flow
3295  *      control reliablilty.
3296  */
3297         if (tiosp->c_iflag & IXON) {
3298                 cor2 |= COR2_TXIBE;
3299                 cor3 |= COR3_SCD12;
3300                 if (tiosp->c_iflag & IXANY)
3301                         cor2 |= COR2_IXM;
3302         }
3303
3304         if (tiosp->c_cflag & CCTS_OFLOW)
3305                 cor2 |= COR2_CTSAE;
3306         if (tiosp->c_cflag & CRTS_IFLOW)
3307                 mcor1 |= FIFO_RTSTHRESHOLD;
3308
3309 /*
3310  *      All cd1400 register values calculated so go through and set them
3311  *      all up.
3312  */
3313 #if STLDEBUG
3314         printf("SETPORT: portnr=%d panelnr=%d brdnr=%d\n", portp->portnr,
3315                 portp->panelnr, portp->brdnr);
3316         printf("    cor1=%x cor2=%x cor3=%x cor4=%x cor5=%x\n", cor1, cor2,
3317                 cor3, cor4, cor5);
3318         printf("    mcor1=%x mcor2=%x rtpr=%x sreron=%x sreroff=%x\n",
3319                 mcor1, mcor2, rtpr, sreron, sreroff);
3320         printf("    tcor=%x tbpr=%x rcor=%x rbpr=%x\n", clk, div, clk, div);
3321         printf("    schr1=%x schr2=%x schr3=%x schr4=%x\n",
3322                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP], tiosp->c_cc[VSTART],
3323                 tiosp->c_cc[VSTOP]);
3324 #endif
3325
3326         crit_enter();
3327         BRDENABLE(portp->brdnr, portp->pagenr);
3328         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3329         srer = stl_cd1400getreg(portp, SRER);
3330         stl_cd1400setreg(portp, SRER, 0);
3331         ccr += stl_cd1400updatereg(portp, COR1, cor1);
3332         ccr += stl_cd1400updatereg(portp, COR2, cor2);
3333         ccr += stl_cd1400updatereg(portp, COR3, cor3);
3334         if (ccr) {
3335                 stl_cd1400ccrwait(portp);
3336                 stl_cd1400setreg(portp, CCR, CCR_CORCHANGE);
3337         }
3338         stl_cd1400setreg(portp, COR4, cor4);
3339         stl_cd1400setreg(portp, COR5, cor5);
3340         stl_cd1400setreg(portp, MCOR1, mcor1);
3341         stl_cd1400setreg(portp, MCOR2, mcor2);
3342         if (tiosp->c_ospeed == 0) {
3343                 stl_cd1400setreg(portp, MSVR1, 0);
3344         } else {
3345                 stl_cd1400setreg(portp, MSVR1, MSVR1_DTR);
3346                 stl_cd1400setreg(portp, TCOR, clk);
3347                 stl_cd1400setreg(portp, TBPR, div);
3348                 stl_cd1400setreg(portp, RCOR, clk);
3349                 stl_cd1400setreg(portp, RBPR, div);
3350         }
3351         stl_cd1400setreg(portp, SCHR1, tiosp->c_cc[VSTART]);
3352         stl_cd1400setreg(portp, SCHR2, tiosp->c_cc[VSTOP]);
3353         stl_cd1400setreg(portp, SCHR3, tiosp->c_cc[VSTART]);
3354         stl_cd1400setreg(portp, SCHR4, tiosp->c_cc[VSTOP]);
3355         stl_cd1400setreg(portp, RTPR, rtpr);
3356         mcor1 = stl_cd1400getreg(portp, MSVR1);
3357         if (mcor1 & MSVR1_DCD)
3358                 portp->sigs |= TIOCM_CD;
3359         else
3360                 portp->sigs &= ~TIOCM_CD;
3361         stl_cd1400setreg(portp, SRER, ((srer & ~sreroff) | sreron));
3362         BRDDISABLE(portp->brdnr);
3363         portp->state &= ~(ASY_RTSFLOWMODE | ASY_CTSFLOWMODE);
3364         portp->state |= ((tiosp->c_cflag & CRTS_IFLOW) ? ASY_RTSFLOWMODE : 0);
3365         portp->state |= ((tiosp->c_cflag & CCTS_OFLOW) ? ASY_CTSFLOWMODE : 0);
3366         stl_ttyoptim(portp, tiosp);
3367         crit_exit();
3368
3369         return(0);
3370 }
3371
3372 /*****************************************************************************/
3373
3374 /*
3375  *      Action the flow control as required. The hw and sw args inform the
3376  *      routine what flow control methods it should try.
3377  */
3378
3379 static void stl_cd1400sendflow(stlport_t *portp, int hw, int sw)
3380 {
3381
3382 #if STLDEBUG
3383         printf("stl_cd1400sendflow(portp=%x,hw=%d,sw=%d)\n",
3384                 (int) portp, hw, sw);
3385 #endif
3386
3387         crit_enter();
3388         BRDENABLE(portp->brdnr, portp->pagenr);
3389         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3390
3391         if (sw >= 0) {
3392                 stl_cd1400ccrwait(portp);
3393                 if (sw) {
3394                         stl_cd1400setreg(portp, CCR, CCR_SENDSCHR2);
3395                         portp->stats.rxxoff++;
3396                 } else {
3397                         stl_cd1400setreg(portp, CCR, CCR_SENDSCHR1);
3398                         portp->stats.rxxon++;
3399                 }
3400                 stl_cd1400ccrwait(portp);
3401         }
3402
3403         if (hw == 0) {
3404                 portp->state |= ASY_RTSFLOW;
3405                 stl_cd1400setreg(portp, MCOR1,
3406                         (stl_cd1400getreg(portp, MCOR1) & 0xf0));
3407                 stl_cd1400setreg(portp, MSVR2, 0);
3408                 portp->stats.rxrtsoff++;
3409         } else if (hw > 0) {
3410                 portp->state &= ~ASY_RTSFLOW;
3411                 stl_cd1400setreg(portp, MSVR2, MSVR2_RTS);
3412                 stl_cd1400setreg(portp, MCOR1,
3413                         (stl_cd1400getreg(portp, MCOR1) | FIFO_RTSTHRESHOLD));
3414                 portp->stats.rxrtson++;
3415         }
3416
3417         BRDDISABLE(portp->brdnr);
3418         crit_exit();
3419 }
3420
3421 /*****************************************************************************/
3422
3423 /*
3424  *      Return the current state of data flow on this port. This is only
3425  *      really interresting when determining if data has fully completed
3426  *      transmission or not... This is easy for the cd1400, it accurately
3427  *      maintains the busy port flag.
3428  */
3429
3430 static int stl_cd1400datastate(stlport_t *portp)
3431 {
3432 #if STLDEBUG
3433         printf("stl_cd1400datastate(portp=%x)\n", (int) portp);
3434 #endif
3435
3436         if (portp == (stlport_t *) NULL)
3437                 return(0);
3438
3439         return((portp->state & ASY_TXBUSY) ? 1 : 0);
3440 }
3441
3442 /*****************************************************************************/
3443
3444 /*
3445  *      Set the state of the DTR and RTS signals. Got to do some extra
3446  *      work here to deal hardware flow control.
3447  */
3448
3449 static void stl_cd1400setsignals(stlport_t *portp, int dtr, int rts)
3450 {
3451         unsigned char   msvr1, msvr2;
3452
3453 #if STLDEBUG
3454         printf("stl_cd1400setsignals(portp=%x,dtr=%d,rts=%d)\n", (int) portp,
3455                 dtr, rts);
3456 #endif
3457
3458         msvr1 = 0;
3459         msvr2 = 0;
3460         if (dtr > 0)
3461                 msvr1 = MSVR1_DTR;
3462         if (rts > 0)
3463                 msvr2 = MSVR2_RTS;
3464
3465         crit_enter();
3466         BRDENABLE(portp->brdnr, portp->pagenr);
3467         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3468         if (rts >= 0) {
3469                 if (portp->tty.t_cflag & CRTS_IFLOW) {
3470                         if (rts == 0) {
3471                                 stl_cd1400setreg(portp, MCOR1,
3472                                       (stl_cd1400getreg(portp, MCOR1) & 0xf0));
3473                                 portp->stats.rxrtsoff++;
3474                         } else {
3475                                 stl_cd1400setreg(portp, MCOR1,
3476                                         (stl_cd1400getreg(portp, MCOR1) |
3477                                         FIFO_RTSTHRESHOLD));
3478                                 portp->stats.rxrtson++;
3479                         }
3480                 }
3481                 stl_cd1400setreg(portp, MSVR2, msvr2);
3482         }
3483         if (dtr >= 0)
3484                 stl_cd1400setreg(portp, MSVR1, msvr1);
3485         BRDDISABLE(portp->brdnr);
3486         crit_exit();
3487 }
3488
3489 /*****************************************************************************/
3490
3491 /*
3492  *      Get the state of the signals.
3493  */
3494
3495 static int stl_cd1400getsignals(stlport_t *portp)
3496 {
3497         unsigned char   msvr1, msvr2;
3498         int             sigs;
3499
3500 #if STLDEBUG
3501         printf("stl_cd1400getsignals(portp=%x)\n", (int) portp);
3502 #endif
3503
3504         crit_enter();
3505         BRDENABLE(portp->brdnr, portp->pagenr);
3506         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3507         msvr1 = stl_cd1400getreg(portp, MSVR1);
3508         msvr2 = stl_cd1400getreg(portp, MSVR2);
3509         BRDDISABLE(portp->brdnr);
3510         crit_exit();
3511
3512         sigs = 0;
3513         sigs |= (msvr1 & MSVR1_DCD) ? TIOCM_CD : 0;
3514         sigs |= (msvr1 & MSVR1_CTS) ? TIOCM_CTS : 0;
3515         sigs |= (msvr1 & MSVR1_DTR) ? TIOCM_DTR : 0;
3516         sigs |= (msvr2 & MSVR2_RTS) ? TIOCM_RTS : 0;
3517 #if 0
3518         sigs |= (msvr1 & MSVR1_RI) ? TIOCM_RI : 0;
3519         sigs |= (msvr1 & MSVR1_DSR) ? TIOCM_DSR : 0;
3520 #else
3521         sigs |= TIOCM_DSR;
3522 #endif
3523         return(sigs);
3524 }
3525
3526 /*****************************************************************************/
3527
3528 /*
3529  *      Enable or disable the Transmitter and/or Receiver.
3530  */
3531
3532 static void stl_cd1400enablerxtx(stlport_t *portp, int rx, int tx)
3533 {
3534         unsigned char   ccr;
3535
3536 #if STLDEBUG
3537         printf("stl_cd1400enablerxtx(portp=%x,rx=%d,tx=%d)\n",
3538                 (int) portp, rx, tx);
3539 #endif
3540
3541         ccr = 0;
3542         if (tx == 0)
3543                 ccr |= CCR_TXDISABLE;
3544         else if (tx > 0)
3545                 ccr |= CCR_TXENABLE;
3546         if (rx == 0)
3547                 ccr |= CCR_RXDISABLE;
3548         else if (rx > 0)
3549                 ccr |= CCR_RXENABLE;
3550
3551         crit_enter();
3552         BRDENABLE(portp->brdnr, portp->pagenr);
3553         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x03));
3554         stl_cd1400ccrwait(portp);
3555         stl_cd1400setreg(portp, CCR, ccr);
3556         stl_cd1400ccrwait(portp);
3557         BRDDISABLE(portp->brdnr);
3558         crit_exit();
3559 }
3560
3561 /*****************************************************************************/
3562
3563 /*
3564  *      Start or stop the Transmitter and/or Receiver.
3565  */
3566
3567 static void stl_cd1400startrxtx(stlport_t *portp, int rx, int tx)
3568 {
3569         unsigned char   sreron, sreroff;
3570
3571 #if STLDEBUG
3572         printf("stl_cd1400startrxtx(portp=%x,rx=%d,tx=%d)\n",
3573                 (int) portp, rx, tx);
3574 #endif
3575
3576         sreron = 0;
3577         sreroff = 0;
3578         if (tx == 0)
3579                 sreroff |= (SRER_TXDATA | SRER_TXEMPTY);
3580         else if (tx == 1)
3581                 sreron |= SRER_TXDATA;
3582         else if (tx >= 2)
3583                 sreron |= SRER_TXEMPTY;
3584         if (rx == 0)
3585                 sreroff |= SRER_RXDATA;
3586         else if (rx > 0)
3587                 sreron |= SRER_RXDATA;
3588
3589         crit_enter();
3590         BRDENABLE(portp->brdnr, portp->pagenr);
3591         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3592         stl_cd1400setreg(portp, SRER,
3593                 ((stl_cd1400getreg(portp, SRER) & ~sreroff) | sreron));
3594         BRDDISABLE(portp->brdnr);
3595         if (tx > 0) {
3596                 portp->state |= ASY_TXBUSY;
3597                 portp->tty.t_state |= TS_BUSY;
3598         }
3599         crit_exit();
3600 }
3601
3602 /*****************************************************************************/
3603
3604 /*
3605  *      Disable all interrupts from this port.
3606  */
3607
3608 static void stl_cd1400disableintrs(stlport_t *portp)
3609 {
3610
3611 #if STLDEBUG
3612         printf("stl_cd1400disableintrs(portp=%x)\n", (int) portp);
3613 #endif
3614
3615         crit_enter();
3616         BRDENABLE(portp->brdnr, portp->pagenr);
3617         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3618         stl_cd1400setreg(portp, SRER, 0);
3619         BRDDISABLE(portp->brdnr);
3620         crit_exit();
3621 }
3622
3623 /*****************************************************************************/
3624
3625 static void stl_cd1400sendbreak(stlport_t *portp, long len)
3626 {
3627
3628 #if STLDEBUG
3629         printf("stl_cd1400sendbreak(portp=%x,len=%d)\n", (int) portp,
3630                 (int) len);
3631 #endif
3632
3633         crit_enter();
3634         BRDENABLE(portp->brdnr, portp->pagenr);
3635         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3636         stl_cd1400setreg(portp, COR2,
3637                 (stl_cd1400getreg(portp, COR2) | COR2_ETC));
3638         stl_cd1400setreg(portp, SRER,
3639                 ((stl_cd1400getreg(portp, SRER) & ~SRER_TXDATA) |
3640                 SRER_TXEMPTY));
3641         BRDDISABLE(portp->brdnr);
3642         if (len > 0) {
3643                 len = len / 5;
3644                 portp->brklen = (len > 255) ? 255 : len;
3645         } else {
3646                 portp->brklen = len;
3647         }
3648         crit_exit();
3649         portp->stats.txbreaks++;
3650 }
3651
3652 /*****************************************************************************/
3653
3654 /*
3655  *      Try and find and initialize all the ports on a panel. We don't care
3656  *      what sort of board these ports are on - since the port io registers
3657  *      are almost identical when dealing with ports.
3658  */
3659
3660 static void stl_cd1400portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp)
3661 {
3662 #if STLDEBUG
3663         printf("stl_cd1400portinit(brdp=%x,panelp=%x,portp=%x)\n",
3664                 (int) brdp, (int) panelp, (int) portp);
3665 #endif
3666
3667         if ((brdp == (stlbrd_t *) NULL) || (panelp == (stlpanel_t *) NULL) ||
3668             (portp == (stlport_t *) NULL))
3669                 return;
3670
3671         portp->ioaddr = panelp->iobase + (((brdp->brdtype == BRD_ECHPCI) ||
3672                 (portp->portnr < 8)) ? 0 : EREG_BANKSIZE);
3673         portp->uartaddr = (portp->portnr & 0x04) << 5;
3674         portp->pagenr = panelp->pagenr + (portp->portnr >> 3);
3675
3676         BRDENABLE(portp->brdnr, portp->pagenr);
3677         stl_cd1400setreg(portp, CAR, (portp->portnr & 0x3));
3678         stl_cd1400setreg(portp, LIVR, (portp->portnr << 3));
3679         portp->hwid = stl_cd1400getreg(portp, GFRCR);
3680         BRDDISABLE(portp->brdnr);
3681 }
3682
3683 /*****************************************************************************/
3684
3685 /*
3686  *      Inbitialize the UARTs in a panel. We don't care what sort of board
3687  *      these ports are on - since the port io registers are almost
3688  *      identical when dealing with ports.
3689  */
3690
3691 static int stl_cd1400panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
3692 {
3693         unsigned int    gfrcr;
3694         int             chipmask, i, j;
3695         int             nrchips, uartaddr, ioaddr;
3696
3697 #if STLDEBUG
3698         printf("stl_cd1400panelinit(brdp=%x,panelp=%x)\n", (int) brdp,
3699                 (int) panelp);
3700 #endif
3701
3702         BRDENABLE(panelp->brdnr, panelp->pagenr);
3703
3704 /*
3705  *      Check that each chip is present and started up OK.
3706  */
3707         chipmask = 0;
3708         nrchips = panelp->nrports / CD1400_PORTS;
3709         for (i = 0; (i < nrchips); i++) {
3710                 if (brdp->brdtype == BRD_ECHPCI) {
3711                         outb((panelp->pagenr + (i >> 1)), brdp->ioctrl);
3712                         ioaddr = panelp->iobase;
3713                 } else {
3714                         ioaddr = panelp->iobase + (EREG_BANKSIZE * (i >> 1));
3715                 }
3716                 uartaddr = (i & 0x01) ? 0x080 : 0;
3717                 outb(ioaddr, (GFRCR + uartaddr));
3718                 outb((ioaddr + EREG_DATA), 0);
3719                 outb(ioaddr, (CCR + uartaddr));
3720                 outb((ioaddr + EREG_DATA), CCR_RESETFULL);
3721                 outb((ioaddr + EREG_DATA), CCR_RESETFULL);
3722                 outb(ioaddr, (GFRCR + uartaddr));
3723                 for (j = 0; (j < CCR_MAXWAIT); j++) {
3724                         if ((gfrcr = inb(ioaddr + EREG_DATA)) != 0)
3725                                 break;
3726                 }
3727                 if ((j >= CCR_MAXWAIT) || (gfrcr < 0x40) || (gfrcr > 0x60)) {
3728                         printf("STALLION: cd1400 not responding, "
3729                                 "board=%d panel=%d chip=%d\n", panelp->brdnr,
3730                                 panelp->panelnr, i);
3731                         continue;
3732                 }
3733                 chipmask |= (0x1 << i);
3734                 outb(ioaddr, (PPR + uartaddr));
3735                 outb((ioaddr + EREG_DATA), PPR_SCALAR);
3736         }
3737
3738
3739         BRDDISABLE(panelp->brdnr);
3740         return(chipmask);
3741 }
3742
3743 /*****************************************************************************/
3744 /*                      SC26198 HARDWARE FUNCTIONS                           */
3745 /*****************************************************************************/
3746
3747 /*
3748  *      These functions get/set/update the registers of the sc26198 UARTs.
3749  *      Access to the sc26198 registers is via an address/data io port pair.
3750  *      (Maybe should make this inline...)
3751  */
3752
3753 static int stl_sc26198getreg(stlport_t *portp, int regnr)
3754 {
3755         outb((portp->ioaddr + XP_ADDR), (regnr | portp->uartaddr));
3756         return(inb(portp->ioaddr + XP_DATA));
3757 }
3758
3759 static void stl_sc26198setreg(stlport_t *portp, int regnr, int value)
3760 {
3761         outb((portp->ioaddr + XP_ADDR), (regnr | portp->uartaddr));
3762         outb((portp->ioaddr + XP_DATA), value);
3763 }
3764
3765 static int stl_sc26198updatereg(stlport_t *portp, int regnr, int value)
3766 {
3767         outb((portp->ioaddr + XP_ADDR), (regnr | portp->uartaddr));
3768         if (inb(portp->ioaddr + XP_DATA) != value) {
3769                 outb((portp->ioaddr + XP_DATA), value);
3770                 return(1);
3771         }
3772         return(0);
3773 }
3774
3775 /*****************************************************************************/
3776
3777 /*
3778  *      Functions to get and set the sc26198 global registers.
3779  */
3780
3781 static int stl_sc26198getglobreg(stlport_t *portp, int regnr)
3782 {
3783         outb((portp->ioaddr + XP_ADDR), regnr);
3784         return(inb(portp->ioaddr + XP_DATA));
3785 }
3786
3787 #if 0
3788 static void stl_sc26198setglobreg(stlport_t *portp, int regnr, int value)
3789 {
3790         outb((portp->ioaddr + XP_ADDR), regnr);
3791         outb((portp->ioaddr + XP_DATA), value);
3792 }
3793 #endif
3794
3795 /*****************************************************************************/
3796
3797 /*
3798  *      Inbitialize the UARTs in a panel. We don't care what sort of board
3799  *      these ports are on - since the port io registers are almost
3800  *      identical when dealing with ports.
3801  */
3802
3803 static int stl_sc26198panelinit(stlbrd_t *brdp, stlpanel_t *panelp)
3804 {
3805         int     chipmask, i;
3806         int     nrchips, ioaddr;
3807
3808 #if STLDEBUG
3809         printf("stl_sc26198panelinit(brdp=%x,panelp=%x)\n", (int) brdp,
3810                 (int) panelp);
3811 #endif
3812
3813         BRDENABLE(panelp->brdnr, panelp->pagenr);
3814
3815 /*
3816  *      Check that each chip is present and started up OK.
3817  */
3818         chipmask = 0;
3819         nrchips = (panelp->nrports + 4) / SC26198_PORTS;
3820         if (brdp->brdtype == BRD_ECHPCI)
3821                 outb(brdp->ioctrl, panelp->pagenr);
3822
3823         for (i = 0; (i < nrchips); i++) {
3824                 ioaddr = panelp->iobase + (i * 4);
3825                 outb((ioaddr + XP_ADDR), SCCR);
3826                 outb((ioaddr + XP_DATA), CR_RESETALL);
3827                 outb((ioaddr + XP_ADDR), TSTR);
3828                 if (inb(ioaddr + XP_DATA) != 0) {
3829                         printf("STALLION: sc26198 not responding, "
3830                                 "board=%d panel=%d chip=%d\n", panelp->brdnr,
3831                                 panelp->panelnr, i);
3832                         continue;
3833                 }
3834                 chipmask |= (0x1 << i);
3835                 outb((ioaddr + XP_ADDR), GCCR);
3836                 outb((ioaddr + XP_DATA), GCCR_IVRTYPCHANACK);
3837                 outb((ioaddr + XP_ADDR), WDTRCR);
3838                 outb((ioaddr + XP_DATA), 0xff);
3839         }
3840
3841         BRDDISABLE(panelp->brdnr);
3842         return(chipmask);
3843 }
3844
3845 /*****************************************************************************/
3846
3847 /*
3848  *      Initialize hardware specific port registers.
3849  */
3850
3851 static void stl_sc26198portinit(stlbrd_t *brdp, stlpanel_t *panelp, stlport_t *portp)
3852 {
3853 #if STLDEBUG
3854         printf("stl_sc26198portinit(brdp=%x,panelp=%x,portp=%x)\n",
3855                 (int) brdp, (int) panelp, (int) portp);
3856 #endif
3857
3858         if ((brdp == (stlbrd_t *) NULL) || (panelp == (stlpanel_t *) NULL) ||
3859             (portp == (stlport_t *) NULL))
3860                 return;
3861
3862         portp->ioaddr = panelp->iobase + ((portp->portnr < 8) ? 0 : 4);
3863         portp->uartaddr = (portp->portnr & 0x07) << 4;
3864         portp->pagenr = panelp->pagenr;
3865         portp->hwid = 0x1;
3866
3867         BRDENABLE(portp->brdnr, portp->pagenr);
3868         stl_sc26198setreg(portp, IOPCR, IOPCR_SETSIGS);
3869         BRDDISABLE(portp->brdnr);
3870 }
3871
3872 /*****************************************************************************/
3873
3874 /*
3875  *      Set up the sc26198 registers for a port based on the termios port
3876  *      settings.
3877  */
3878
3879 static int stl_sc26198setport(stlport_t *portp, struct termios *tiosp)
3880 {
3881         unsigned char   mr0, mr1, mr2, clk;
3882         unsigned char   imron, imroff, iopr, ipr;
3883
3884 #if STLDEBUG
3885         printf("stl_sc26198setport(portp=%x,tiosp=%x): brdnr=%d portnr=%d\n",
3886                 (int) portp, (int) tiosp, portp->brdnr, portp->portnr);
3887 #endif
3888
3889         mr0 = 0;
3890         mr1 = 0;
3891         mr2 = 0;
3892         clk = 0;
3893         iopr = 0;
3894         imron = 0;
3895         imroff = 0;
3896
3897 /*
3898  *      Set up the RX char ignore mask with those RX error types we
3899  *      can ignore.
3900  */
3901         portp->rxignoremsk = 0;
3902         if (tiosp->c_iflag & IGNPAR)
3903                 portp->rxignoremsk |= (SR_RXPARITY | SR_RXFRAMING |
3904                         SR_RXOVERRUN);
3905         if (tiosp->c_iflag & IGNBRK)
3906                 portp->rxignoremsk |= SR_RXBREAK;
3907
3908         portp->rxmarkmsk = SR_RXOVERRUN;
3909         if (tiosp->c_iflag & (INPCK | PARMRK))
3910                 portp->rxmarkmsk |= (SR_RXPARITY | SR_RXFRAMING);
3911         if (tiosp->c_iflag & BRKINT)
3912                 portp->rxmarkmsk |= SR_RXBREAK;
3913
3914 /*
3915  *      Go through the char size, parity and stop bits and set all the
3916  *      option registers appropriately.
3917  */
3918         switch (tiosp->c_cflag & CSIZE) {
3919         case CS5:
3920                 mr1 |= MR1_CS5;
3921                 break;
3922         case CS6:
3923                 mr1 |= MR1_CS6;
3924                 break;
3925         case CS7:
3926                 mr1 |= MR1_CS7;
3927                 break;
3928         default:
3929                 mr1 |= MR1_CS8;
3930                 break;
3931         }
3932
3933         if (tiosp->c_cflag & CSTOPB)
3934                 mr2 |= MR2_STOP2;
3935         else
3936                 mr2 |= MR2_STOP1;
3937
3938         if (tiosp->c_cflag & PARENB) {
3939                 if (tiosp->c_cflag & PARODD)
3940                         mr1 |= (MR1_PARENB | MR1_PARODD);
3941                 else
3942                         mr1 |= (MR1_PARENB | MR1_PAREVEN);
3943         } else {
3944                 mr1 |= MR1_PARNONE;
3945         }
3946
3947         mr1 |= MR1_ERRBLOCK;
3948
3949 /*
3950  *      Set the RX FIFO threshold at 8 chars. This gives a bit of breathing
3951  *      space for hardware flow control and the like. This should be set to
3952  *      VMIN.
3953  */
3954         mr2 |= MR2_RXFIFOHALF;
3955
3956 /*
3957  *      Calculate the baud rate timers. For now we will just assume that
3958  *      the input and output baud are the same. The sc26198 has a fixed
3959  *      baud rate table, so only discrete baud rates possible.
3960  */
3961         if (tiosp->c_ispeed == 0)
3962                 tiosp->c_ispeed = tiosp->c_ospeed;
3963         if ((tiosp->c_ospeed < 0) || (tiosp->c_ospeed > SC26198_MAXBAUD))
3964                 return(EINVAL);
3965
3966         if (tiosp->c_ospeed > 0) {
3967                 for (clk = 0; (clk < SC26198_NRBAUDS); clk++) {
3968                         if (tiosp->c_ospeed <= sc26198_baudtable[clk])
3969                                 break;
3970                 }
3971         }
3972
3973 /*
3974  *      Check what form of modem signaling is required and set it up.
3975  */
3976         if ((tiosp->c_cflag & CLOCAL) == 0) {
3977                 iopr |= IOPR_DCDCOS;
3978                 imron |= IR_IOPORT;
3979         }
3980
3981 /*
3982  *      Setup sc26198 enhanced modes if we can. In particular we want to
3983  *      handle as much of the flow control as possible automatically. As
3984  *      well as saving a few CPU cycles it will also greatly improve flow
3985  *      control reliability.
3986  */
3987         if (tiosp->c_iflag & IXON) {
3988                 mr0 |= MR0_SWFTX | MR0_SWFT;
3989                 imron |= IR_XONXOFF;
3990         } else {
3991                 imroff |= IR_XONXOFF;
3992         }
3993 #if 0
3994         if (tiosp->c_iflag & IXOFF)
3995                 mr0 |= MR0_SWFRX;
3996 #endif
3997
3998         if (tiosp->c_cflag & CCTS_OFLOW)
3999                 mr2 |= MR2_AUTOCTS;
4000         if (tiosp->c_cflag & CRTS_IFLOW)
4001                 mr1 |= MR1_AUTORTS;
4002
4003 /*
4004  *      All sc26198 register values calculated so go through and set
4005  *      them all up.
4006  */
4007
4008 #if STLDEBUG
4009         printf("SETPORT: portnr=%d panelnr=%d brdnr=%d\n", portp->portnr,
4010                 portp->panelnr, portp->brdnr);
4011         printf("    mr0=%x mr1=%x mr2=%x clk=%x\n", mr0, mr1, mr2, clk);
4012         printf("    iopr=%x imron=%x imroff=%x\n", iopr, imron, imroff);
4013         printf("    schr1=%x schr2=%x schr3=%x schr4=%x\n",
4014                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP],
4015                 tiosp->c_cc[VSTART], tiosp->c_cc[VSTOP]);
4016 #endif
4017
4018         crit_enter();
4019         BRDENABLE(portp->brdnr, portp->pagenr);
4020         stl_sc26198setreg(portp, IMR, 0);
4021         stl_sc26198updatereg(portp, MR0, mr0);
4022         stl_sc26198updatereg(portp, MR1, mr1);
4023         stl_sc26198setreg(portp, SCCR, CR_RXERRBLOCK);
4024         stl_sc26198updatereg(portp, MR2, mr2);
4025         iopr = (stl_sc26198getreg(portp, IOPIOR) & ~IPR_CHANGEMASK) | iopr;
4026         if (tiosp->c_ospeed == 0) {
4027                 iopr &= ~IPR_DTR;
4028         } else {
4029                 iopr |= IPR_DTR;
4030                 stl_sc26198setreg(portp, TXCSR, clk);
4031                 stl_sc26198setreg(portp, RXCSR, clk);
4032         }
4033         stl_sc26198updatereg(portp, IOPIOR, iopr);
4034         stl_sc26198setreg(portp, XONCR, tiosp->c_cc[VSTART]);
4035         stl_sc26198setreg(portp, XOFFCR, tiosp->c_cc[VSTOP]);
4036         ipr = stl_sc26198getreg(portp, IPR);
4037         if (ipr & IPR_DCD)
4038                 portp->sigs &= ~TIOCM_CD;
4039         else
4040                 portp->sigs |= TIOCM_CD;
4041         portp->imr = (portp->imr & ~imroff) | imron;
4042         stl_sc26198setreg(portp, IMR, portp->imr);
4043         BRDDISABLE(portp->brdnr);
4044         portp->state &= ~(ASY_RTSFLOWMODE | ASY_CTSFLOWMODE);
4045         portp->state |= ((tiosp->c_cflag & CRTS_IFLOW) ? ASY_RTSFLOWMODE : 0);
4046         portp->state |= ((tiosp->c_cflag & CCTS_OFLOW) ? ASY_CTSFLOWMODE : 0);
4047         stl_ttyoptim(portp, tiosp);
4048         crit_exit();
4049
4050         return(0);
4051 }
4052
4053 /*****************************************************************************/
4054
4055 /*
4056  *      Set the state of the DTR and RTS signals.
4057  */
4058
4059 static void stl_sc26198setsignals(stlport_t *portp, int dtr, int rts)
4060 {
4061         unsigned char   iopioron, iopioroff;
4062
4063 #if STLDEBUG
4064         printf("stl_sc26198setsignals(portp=%x,dtr=%d,rts=%d)\n",
4065                 (int) portp, dtr, rts);
4066 #endif
4067
4068         iopioron = 0;
4069         iopioroff = 0;
4070         if (dtr == 0)
4071                 iopioroff |= IPR_DTR;
4072         else if (dtr > 0)
4073                 iopioron |= IPR_DTR;
4074         if (rts == 0)
4075                 iopioroff |= IPR_RTS;
4076         else if (rts > 0)
4077                 iopioron |= IPR_RTS;
4078
4079         crit_enter();
4080         BRDENABLE(portp->brdnr, portp->pagenr);
4081         if ((rts >= 0) && (portp->tty.t_cflag & CRTS_IFLOW)) {
4082                 if (rts == 0) {
4083                         stl_sc26198setreg(portp, MR1,
4084                                 (stl_sc26198getreg(portp, MR1) & ~MR1_AUTORTS));
4085                         portp->stats.rxrtsoff++;
4086                 } else {
4087                         stl_sc26198setreg(portp, MR1,
4088                                 (stl_sc26198getreg(portp, MR1) | MR1_AUTORTS));
4089                         portp->stats.rxrtson++;
4090                 }
4091         }
4092         stl_sc26198setreg(portp, IOPIOR,
4093                 ((stl_sc26198getreg(portp, IOPIOR) & ~iopioroff) | iopioron));
4094         BRDDISABLE(portp->brdnr);
4095         crit_exit();
4096 }
4097
4098 /*****************************************************************************/
4099
4100 /*
4101  *      Return the state of the signals.
4102  */
4103
4104 static int stl_sc26198getsignals(stlport_t *portp)
4105 {
4106         unsigned char   ipr;
4107         int             sigs;
4108
4109 #if STLDEBUG
4110         printf("stl_sc26198getsignals(portp=%x)\n", (int) portp);
4111 #endif
4112
4113         crit_enter();
4114         BRDENABLE(portp->brdnr, portp->pagenr);
4115         ipr = stl_sc26198getreg(portp, IPR);
4116         BRDDISABLE(portp->brdnr);
4117         crit_exit();
4118
4119         sigs = TIOCM_DSR;
4120         sigs |= (ipr & IPR_DCD) ? 0 : TIOCM_CD;
4121         sigs |= (ipr & IPR_CTS) ? 0 : TIOCM_CTS;
4122         sigs |= (ipr & IPR_DTR) ? 0: TIOCM_DTR;
4123         sigs |= (ipr & IPR_RTS) ? 0: TIOCM_RTS;
4124         return(sigs);
4125 }
4126
4127 /*****************************************************************************/
4128
4129 /*
4130  *      Enable/Disable the Transmitter and/or Receiver.
4131  */
4132
4133 static void stl_sc26198enablerxtx(stlport_t *portp, int rx, int tx)
4134 {
4135         unsigned char   ccr;
4136
4137 #if STLDEBUG
4138         printf("stl_sc26198enablerxtx(portp=%x,rx=%d,tx=%d)\n",
4139                 (int) portp, rx, tx);
4140 #endif
4141
4142         ccr = portp->crenable;
4143         if (tx == 0)
4144                 ccr &= ~CR_TXENABLE;
4145         else if (tx > 0)
4146                 ccr |= CR_TXENABLE;
4147         if (rx == 0)
4148                 ccr &= ~CR_RXENABLE;
4149         else if (rx > 0)
4150                 ccr |= CR_RXENABLE;
4151
4152         crit_enter();
4153         BRDENABLE(portp->brdnr, portp->pagenr);
4154         stl_sc26198setreg(portp, SCCR, ccr);
4155         BRDDISABLE(portp->brdnr);
4156         portp->crenable = ccr;
4157         crit_exit();
4158 }
4159
4160 /*****************************************************************************/
4161
4162 /*
4163  *      Start/stop the Transmitter and/or Receiver.
4164  */
4165
4166 static void stl_sc26198startrxtx(stlport_t *portp, int rx, int tx)
4167 {
4168         unsigned char   imr;
4169
4170 #if STLDEBUG
4171         printf("stl_sc26198startrxtx(portp=%x,rx=%d,tx=%d)\n",
4172                 (int) portp, rx, tx);
4173 #endif
4174
4175         imr = portp->imr;
4176         if (tx == 0)
4177                 imr &= ~IR_TXRDY;
4178         else if (tx == 1)
4179                 imr |= IR_TXRDY;
4180         if (rx == 0)
4181                 imr &= ~(IR_RXRDY | IR_RXBREAK | IR_RXWATCHDOG);
4182         else if (rx > 0)
4183                 imr |= IR_RXRDY | IR_RXBREAK | IR_RXWATCHDOG;
4184
4185         crit_enter();
4186         BRDENABLE(portp->brdnr, portp->pagenr);
4187         stl_sc26198setreg(portp, IMR, imr);
4188         BRDDISABLE(portp->brdnr);
4189         portp->imr = imr;
4190         if (tx > 0) {
4191                 portp->state |= ASY_TXBUSY;
4192                 portp->tty.t_state |= TS_BUSY;
4193         }
4194         crit_exit();
4195 }
4196
4197 /*****************************************************************************/
4198
4199 /*
4200  *      Disable all interrupts from this port.
4201  */
4202
4203 static void stl_sc26198disableintrs(stlport_t *portp)
4204 {
4205
4206 #if STLDEBUG
4207         printf("stl_sc26198disableintrs(portp=%x)\n", (int) portp);
4208 #endif
4209
4210         crit_enter();
4211         BRDENABLE(portp->brdnr, portp->pagenr);
4212         portp->imr = 0;
4213         stl_sc26198setreg(portp, IMR, 0);
4214         BRDDISABLE(portp->brdnr);
4215         crit_exit();
4216 }
4217
4218 /*****************************************************************************/
4219
4220 static void stl_sc26198sendbreak(stlport_t *portp, long len)
4221 {
4222
4223 #if STLDEBUG
4224         printf("stl_sc26198sendbreak(portp=%x,len=%d)\n",
4225                 (int) portp, (int) len);
4226 #endif
4227
4228         crit_enter();
4229         BRDENABLE(portp->brdnr, portp->pagenr);
4230         if (len == -1) {
4231                 stl_sc26198setreg(portp, SCCR, CR_TXSTARTBREAK);
4232                 portp->stats.txbreaks++;
4233         } else {
4234                 stl_sc26198setreg(portp, SCCR, CR_TXSTOPBREAK);
4235         }
4236         BRDDISABLE(portp->brdnr);
4237         crit_exit();
4238 }
4239
4240 /*****************************************************************************/
4241
4242 /*
4243  *      Take flow control actions...
4244  */
4245
4246 static void stl_sc26198sendflow(stlport_t *portp, int hw, int sw)
4247 {
4248         unsigned char   mr0;
4249
4250 #if STLDEBUG
4251         printf("stl_sc26198sendflow(portp=%x,hw=%d,sw=%d)\n",
4252                 (int) portp, hw, sw);
4253 #endif
4254
4255         if (portp == (stlport_t *) NULL)
4256                 return;
4257
4258         crit_enter();
4259         BRDENABLE(portp->brdnr, portp->pagenr);
4260
4261         if (sw >= 0) {
4262                 mr0 = stl_sc26198getreg(portp, MR0);
4263                 stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4264                 if (sw > 0) {
4265                         stl_sc26198setreg(portp, SCCR, CR_TXSENDXOFF);
4266                         mr0 &= ~MR0_SWFRX;
4267                         portp->stats.rxxoff++;
4268                 } else {
4269                         stl_sc26198setreg(portp, SCCR, CR_TXSENDXON);
4270                         mr0 |= MR0_SWFRX;
4271                         portp->stats.rxxon++;
4272                 }
4273                 stl_sc26198wait(portp);
4274                 stl_sc26198setreg(portp, MR0, mr0);
4275         }
4276
4277         if (hw == 0) {
4278                 portp->state |= ASY_RTSFLOW;
4279                 stl_sc26198setreg(portp, MR1,
4280                         (stl_sc26198getreg(portp, MR1) & ~MR1_AUTORTS));
4281                 stl_sc26198setreg(portp, IOPIOR,
4282                         (stl_sc26198getreg(portp, IOPIOR) & ~IOPR_RTS));
4283                 portp->stats.rxrtsoff++;
4284         } else if (hw > 0) {
4285                 portp->state &= ~ASY_RTSFLOW;
4286                 stl_sc26198setreg(portp, MR1,
4287                         (stl_sc26198getreg(portp, MR1) | MR1_AUTORTS));
4288                 stl_sc26198setreg(portp, IOPIOR,
4289                         (stl_sc26198getreg(portp, IOPIOR) | IOPR_RTS));
4290                 portp->stats.rxrtson++;
4291         }
4292
4293         BRDDISABLE(portp->brdnr);
4294         crit_exit();
4295 }
4296
4297 /*****************************************************************************/
4298
4299 /*
4300  *      Return the current state of data flow on this port. This is only
4301  *      really interresting when determining if data has fully completed
4302  *      transmission or not... The sc26198 interrupt scheme cannot
4303  *      determine when all data has actually drained, so we need to
4304  *      check the port statusy register to be sure.
4305  */
4306
4307 static int stl_sc26198datastate(stlport_t *portp)
4308 {
4309         unsigned char   sr;
4310
4311 #if STLDEBUG
4312         printf("stl_sc26198datastate(portp=%x)\n", (int) portp);
4313 #endif
4314
4315         if (portp == (stlport_t *) NULL)
4316                 return(0);
4317         if (portp->state & ASY_TXBUSY)
4318                 return(1);
4319
4320         crit_enter();
4321         BRDENABLE(portp->brdnr, portp->pagenr);
4322         sr = stl_sc26198getreg(portp, SR);
4323         BRDDISABLE(portp->brdnr);
4324         crit_exit();
4325
4326         return((sr & SR_TXEMPTY) ? 0 : 1);
4327 }
4328
4329 /*****************************************************************************/
4330
4331 static void stl_sc26198flush(stlport_t *portp, int flag)
4332 {
4333
4334 #if STLDEBUG
4335         printf("stl_sc26198flush(portp=%x,flag=%x)\n", (int) portp, flag);
4336 #endif
4337
4338         if (portp == (stlport_t *) NULL)
4339                 return;
4340
4341         crit_enter();
4342         BRDENABLE(portp->brdnr, portp->pagenr);
4343         if (flag & FWRITE) {
4344                 stl_sc26198setreg(portp, SCCR, CR_TXRESET);
4345                 stl_sc26198setreg(portp, SCCR, portp->crenable);
4346         }
4347         if (flag & FREAD) {
4348                 while (stl_sc26198getreg(portp, SR) & SR_RXRDY)
4349                         stl_sc26198getreg(portp, RXFIFO);
4350         }
4351         BRDDISABLE(portp->brdnr);
4352         crit_exit();
4353 }
4354
4355 /*****************************************************************************/
4356
4357 /*
4358  *      If we are TX flow controlled and in IXANY mode then we may
4359  *      need to unflow control here. We gotta do this because of the
4360  *      automatic flow control modes of the sc26198 - which downs't
4361  *      support any concept of an IXANY mode.
4362  */
4363
4364 static void stl_sc26198txunflow(stlport_t *portp)
4365 {
4366         unsigned char   mr0;
4367
4368         mr0 = stl_sc26198getreg(portp, MR0);
4369         stl_sc26198setreg(portp, MR0, (mr0 & ~MR0_SWFRXTX));
4370         stl_sc26198setreg(portp, SCCR, CR_HOSTXON);
4371         stl_sc26198setreg(portp, MR0, mr0);
4372         portp->state &= ~ASY_TXFLOWED;
4373 }
4374
4375 /*****************************************************************************/
4376
4377 /*
4378  *      Delay for a small amount of time, to give the sc26198 a chance
4379  *      to process a command...
4380  */
4381
4382 static void stl_sc26198wait(stlport_t *portp)
4383 {
4384         int     i;
4385
4386 #if STLDEBUG
4387         printf("stl_sc26198wait(portp=%x)\n", (int) portp);
4388 #endif
4389
4390         if (portp == (stlport_t *) NULL)
4391                 return;
4392
4393         for (i = 0; (i < 20); i++)
4394                 stl_sc26198getglobreg(portp, TSTR);
4395 }
4396
4397 /*****************************************************************************/
4398
4399 /*
4400  *      Transmit interrupt handler. This has gotta be fast!  Handling TX
4401  *      chars is pretty simple, stuff as many as possible from the TX buffer
4402  *      into the sc26198 FIFO.
4403  */
4404
4405 static __inline void stl_sc26198txisr(stlport_t *portp)
4406 {
4407         unsigned int    ioaddr;
4408         unsigned char   mr0;
4409         char            *head, *tail;
4410         int             len, stlen;
4411
4412 #if STLDEBUG
4413         printf("stl_sc26198txisr(portp=%x)\n", (int) portp);
4414 #endif
4415
4416         ioaddr = portp->ioaddr;
4417
4418         head = portp->tx.head;
4419         tail = portp->tx.tail;
4420         len = (head >= tail) ? (head - tail) : (STL_TXBUFSIZE - (tail - head));
4421         if ((len == 0) || ((len < STL_TXBUFLOW) &&
4422             ((portp->state & ASY_TXLOW) == 0))) {
4423                 portp->state |= ASY_TXLOW;
4424                 stl_dotimeout();
4425         }
4426
4427         if (len == 0) {
4428                 outb((ioaddr + XP_ADDR), (MR0 | portp->uartaddr));
4429                 mr0 = inb(ioaddr + XP_DATA);
4430                 if ((mr0 & MR0_TXMASK) == MR0_TXEMPTY) {
4431                         portp->imr &= ~IR_TXRDY;
4432                         outb((ioaddr + XP_ADDR), (IMR | portp->uartaddr));
4433                         outb((ioaddr + XP_DATA), portp->imr);
4434                         portp->state |= ASY_TXEMPTY;
4435                         portp->state &= ~ASY_TXBUSY;
4436                 } else {
4437                         mr0 |= ((mr0 & ~MR0_TXMASK) | MR0_TXEMPTY);
4438                         outb((ioaddr + XP_DATA), mr0);
4439                 }
4440         } else {
4441                 len = MIN(len, SC26198_TXFIFOSIZE);
4442                 portp->stats.txtotal += len;
4443                 stlen = MIN(len, (portp->tx.endbuf - tail));
4444                 outb((ioaddr + XP_ADDR), GTXFIFO);
4445                 outsb((ioaddr + XP_DATA), tail, stlen);
4446                 len -= stlen;
4447                 tail += stlen;
4448                 if (tail >= portp->tx.endbuf)
4449                         tail = portp->tx.buf;
4450                 if (len > 0) {
4451                         outsb((ioaddr + XP_DATA), tail, len);
4452                         tail += len;
4453                 }
4454                 portp->tx.tail = tail;
4455         }
4456 }
4457
4458 /*****************************************************************************/
4459
4460 /*
4461  *      Receive character interrupt handler. Determine if we have good chars
4462  *      or bad chars and then process appropriately. Good chars are easy
4463  *      just shove the lot into the RX buffer and set all status byte to 0.
4464  *      If a bad RX char then process as required. This routine needs to be
4465  *      fast!
4466  */
4467
4468 static __inline void stl_sc26198rxisr(stlport_t *portp, unsigned int iack)
4469 {
4470 #if STLDEBUG
4471         printf("stl_sc26198rxisr(portp=%x,iack=%x)\n", (int) portp, iack);
4472 #endif
4473
4474         if ((iack & IVR_TYPEMASK) == IVR_RXDATA)
4475                 stl_sc26198rxgoodchars(portp);
4476         else
4477                 stl_sc26198rxbadchars(portp);
4478
4479 /*
4480  *      If we are TX flow controlled and in IXANY mode then we may need
4481  *      to unflow control here. We gotta do this because of the automatic
4482  *      flow control modes of the sc26198.
4483  */
4484         if ((portp->state & ASY_TXFLOWED) && (portp->tty.t_iflag & IXANY))
4485                 stl_sc26198txunflow(portp);
4486 }
4487
4488 /*****************************************************************************/
4489
4490 /*
4491  *      Process the good received characters from RX FIFO.
4492  */
4493
4494 static void stl_sc26198rxgoodchars(stlport_t *portp)
4495 {
4496         unsigned int    ioaddr, len, buflen, stlen;
4497         char            *head, *tail;
4498
4499 #if STLDEBUG
4500         printf("stl_sc26198rxgoodchars(port=%x)\n", (int) portp);
4501 #endif
4502
4503         ioaddr = portp->ioaddr;
4504
4505 /*
4506  *      First up, calculate how much room there is in the RX ring queue.
4507  *      We also want to keep track of the longest possible copy length,
4508  *      this has to allow for the wrapping of the ring queue.
4509  */
4510         head = portp->rx.head;
4511         tail = portp->rx.tail;
4512         if (head >= tail) {
4513                 buflen = STL_RXBUFSIZE - (head - tail) - 1;
4514                 stlen = portp->rx.endbuf - head;
4515         } else {
4516                 buflen = tail - head - 1;
4517                 stlen = buflen;
4518         }
4519
4520 /*
4521  *      Check if the input buffer is near full. If so then we should take
4522  *      some flow control action... It is very easy to do hardware and
4523  *      software flow control from here since we have the port selected on
4524  *      the UART.
4525  */
4526         if (buflen <= (STL_RXBUFSIZE - STL_RXBUFHIGH)) {
4527                 if (((portp->state & ASY_RTSFLOW) == 0) &&
4528                     (portp->state & ASY_RTSFLOWMODE)) {
4529                         portp->state |= ASY_RTSFLOW;
4530                         stl_sc26198setreg(portp, MR1,
4531                                 (stl_sc26198getreg(portp, MR1) & ~MR1_AUTORTS));
4532                         stl_sc26198setreg(portp, IOPIOR,
4533                                 (stl_sc26198getreg(portp, IOPIOR) & ~IOPR_RTS));
4534                         portp->stats.rxrtsoff++;
4535                 }
4536         }
4537
4538 /*
4539  *      OK we are set, process good data... If the RX ring queue is full
4540  *      just chuck the chars - don't leave them in the UART.
4541  */
4542         outb((ioaddr + XP_ADDR), GIBCR);
4543         len = inb(ioaddr + XP_DATA) + 1;
4544         if (buflen == 0) {
4545                 outb((ioaddr + XP_ADDR), GRXFIFO);
4546                 insb((ioaddr + XP_DATA), &stl_unwanted[0], len);
4547                 portp->stats.rxlost += len;
4548                 portp->stats.rxtotal += len;
4549         } else {
4550                 len = MIN(len, buflen);
4551                 portp->stats.rxtotal += len;
4552                 stlen = MIN(len, stlen);
4553                 if (len > 0) {
4554                         outb((ioaddr + XP_ADDR), GRXFIFO);
4555                         insb((ioaddr + XP_DATA), head, stlen);
4556                         head += stlen;
4557                         if (head >= portp->rx.endbuf) {
4558                                 head = portp->rx.buf;
4559                                 len -= stlen;
4560                                 insb((ioaddr + XP_DATA), head, len);
4561                                 head += len;
4562                         }
4563                 }
4564         }
4565
4566         portp->rx.head = head;
4567         portp->state |= ASY_RXDATA;
4568         stl_dotimeout();
4569 }
4570
4571 /*****************************************************************************/
4572
4573 /*
4574  *      Process all characters in the RX FIFO of the UART. Check all char
4575  *      status bytes as well, and process as required. We need to check
4576  *      all bytes in the FIFO, in case some more enter the FIFO while we
4577  *      are here. To get the exact character error type we need to switch
4578  *      into CHAR error mode (that is why we need to make sure we empty
4579  *      the FIFO).
4580  */
4581
4582 static void stl_sc26198rxbadchars(stlport_t *portp)
4583 {
4584         unsigned char   mr1;
4585         unsigned int    status;
4586         char            *head, *tail;
4587         char            ch;
4588         int             len;
4589
4590 /*
4591  *      First up, calculate how much room there is in the RX ring queue.
4592  *      We also want to keep track of the longest possible copy length,
4593  *      this has to allow for the wrapping of the ring queue.
4594  */
4595         head = portp->rx.head;
4596         tail = portp->rx.tail;
4597         len = (head >= tail) ? (STL_RXBUFSIZE - (head - tail) - 1) :
4598                 (tail - head - 1);
4599
4600 /*
4601  *      To get the precise error type for each character we must switch
4602  *      back into CHAR error mode.
4603  */
4604         mr1 = stl_sc26198getreg(portp, MR1);
4605         stl_sc26198setreg(portp, MR1, (mr1 & ~MR1_ERRBLOCK));
4606
4607         while ((status = stl_sc26198getreg(portp, SR)) & SR_RXRDY) {
4608                 stl_sc26198setreg(portp, SCCR, CR_CLEARRXERR);
4609                 ch = stl_sc26198getreg(portp, RXFIFO);
4610
4611                 if (status & SR_RXBREAK)
4612                         portp->stats.rxbreaks++;
4613                 if (status & SR_RXFRAMING)
4614                         portp->stats.rxframing++;
4615                 if (status & SR_RXPARITY)
4616                         portp->stats.rxparity++;
4617                 if (status & SR_RXOVERRUN)
4618                         portp->stats.rxoverrun++;
4619                 if ((portp->rxignoremsk & status) == 0) {
4620                         if ((portp->tty.t_state & TS_CAN_BYPASS_L_RINT) &&
4621                             ((status & SR_RXFRAMING) ||
4622                             ((status & SR_RXPARITY) &&
4623                             (portp->tty.t_iflag & INPCK))))
4624                                 ch = 0;
4625                         if ((portp->rxmarkmsk & status) == 0)
4626                                 status = 0;
4627                         if (len > 0) {
4628                                 *(head + STL_RXBUFSIZE) = status;
4629                                 *head++ = ch;
4630                                 if (head >= portp->rx.endbuf)
4631                                         head = portp->rx.buf;
4632                                 len--;
4633                         }
4634                 }
4635         }
4636
4637 /*
4638  *      To get correct interrupt class we must switch back into BLOCK
4639  *      error mode.
4640  */
4641         stl_sc26198setreg(portp, MR1, mr1);
4642
4643         portp->rx.head = head;
4644         portp->state |= ASY_RXDATA;
4645         stl_dotimeout();
4646 }
4647
4648 /*****************************************************************************/
4649
4650 /*
4651  *      Other interrupt handler. This includes modem signals, flow
4652  *      control actions, etc.
4653  */
4654
4655 static void stl_sc26198otherisr(stlport_t *portp, unsigned int iack)
4656 {
4657         unsigned char   cir, ipr, xisr;
4658
4659 #if STLDEBUG
4660         printf("stl_sc26198otherisr(portp=%x,iack=%x)\n", (int) portp, iack);
4661 #endif
4662
4663         cir = stl_sc26198getglobreg(portp, CIR);
4664
4665         switch (cir & CIR_SUBTYPEMASK) {
4666         case CIR_SUBCOS:
4667                 ipr = stl_sc26198getreg(portp, IPR);
4668                 if (ipr & IPR_DCDCHANGE) {
4669                         portp->state |= ASY_DCDCHANGE;
4670                         portp->stats.modem++;
4671                         stl_dotimeout();
4672                 }
4673                 break;
4674         case CIR_SUBXONXOFF:
4675                 xisr = stl_sc26198getreg(portp, XISR);
4676                 if (xisr & XISR_RXXONGOT) {
4677                         portp->state |= ASY_TXFLOWED;
4678                         portp->stats.txxoff++;
4679                 }
4680                 if (xisr & XISR_RXXOFFGOT) {
4681                         portp->state &= ~ASY_TXFLOWED;
4682                         portp->stats.txxon++;
4683                 }
4684                 break;
4685         case CIR_SUBBREAK:
4686                 stl_sc26198setreg(portp, SCCR, CR_BREAKRESET);
4687                 stl_sc26198rxbadchars(portp);
4688                 break;
4689         default:
4690                 break;
4691         }
4692 }
4693
4694 /*****************************************************************************/
4695
4696 /*
4697  *      Interrupt service routine for sc26198 panels.
4698  */
4699
4700 static void stl_sc26198intr(stlpanel_t *panelp, unsigned int iobase)
4701 {
4702         stlport_t       *portp;
4703         unsigned int    iack;
4704
4705 /*
4706  *      Work around bug in sc26198 chip... Cannot have A6 address
4707  *      line of UART high, else iack will be returned as 0.
4708  */
4709         outb((iobase + 1), 0);
4710
4711         iack = inb(iobase + XP_IACK);
4712 #if STLDEBUG
4713         printf("stl_sc26198intr(panelp=%p,iobase=%x): iack=%x\n", panelp, iobase, iack);
4714 #endif
4715         portp = panelp->ports[(iack & IVR_CHANMASK) + ((iobase & 0x4) << 1)];
4716
4717         if (iack & IVR_RXDATA)
4718                 stl_sc26198rxisr(portp, iack);
4719         else if (iack & IVR_TXDATA)
4720                 stl_sc26198txisr(portp);
4721         else
4722                 stl_sc26198otherisr(portp, iack);
4723 }
4724
4725 /*****************************************************************************/