git.oblomov.eu Git - linux-2.6/blob - drivers/char/stallion.c

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