SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/char/stallion.c

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