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