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