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

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