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