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