drivers/char/stallion.c

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