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

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