err.no Git - linux-2.6/blob - drivers/char/stallion.c

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