drivers/char/istallion.c

   1 /*****************************************************************************/
   2
   3 /*
   4  *      istallion.c  -- stallion intelligent 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  */
  18
  19 /*****************************************************************************/
  20
  21 #include <linux/module.h>
  22 #include <linux/sched.h>
  23 #include <linux/slab.h>
  24 #include <linux/smp_lock.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/tty.h>
  27 #include <linux/tty_flip.h>
  28 #include <linux/serial.h>
  29 #include <linux/seq_file.h>
  30 #include <linux/cdk.h>
  31 #include <linux/comstats.h>
  32 #include <linux/istallion.h>
  33 #include <linux/ioport.h>
  34 #include <linux/delay.h>
  35 #include <linux/init.h>
  36 #include <linux/device.h>
  37 #include <linux/wait.h>
  38 #include <linux/eisa.h>
  39 #include <linux/ctype.h>
  40
  41 #include <asm/io.h>
  42 #include <asm/uaccess.h>
  43
  44 #include <linux/pci.h>
  45
  46 /*****************************************************************************/
  47
  48 /*
  49  *      Define different board types. Not all of the following board types
  50  *      are supported by this driver. But I will use the standard "assigned"
  51  *      board numbers. Currently supported boards are abbreviated as:
  52  *      ECP = EasyConnection 8/64, ONB = ONboard, BBY = Brumby and
  53  *      STAL = Stallion.
  54  */
  55 #define BRD_UNKNOWN     0
  56 #define BRD_STALLION    1
  57 #define BRD_BRUMBY4     2
  58 #define BRD_ONBOARD2    3
  59 #define BRD_ONBOARD     4
  60 #define BRD_ONBOARDE    7
  61 #define BRD_ECP         23
  62 #define BRD_ECPE        24
  63 #define BRD_ECPMC       25
  64 #define BRD_ECPPCI      29
  65
  66 #define BRD_BRUMBY      BRD_BRUMBY4
  67
  68 /*
  69  *      Define a configuration structure to hold the board configuration.
  70  *      Need to set this up in the code (for now) with the boards that are
  71  *      to be configured into the system. This is what needs to be modified
  72  *      when adding/removing/modifying boards. Each line entry in the
  73  *      stli_brdconf[] array is a board. Each line contains io/irq/memory
  74  *      ranges for that board (as well as what type of board it is).
  75  *      Some examples:
  76  *              { BRD_ECP, 0x2a0, 0, 0xcc000, 0, 0 },
  77  *      This line will configure an EasyConnection 8/64 at io address 2a0,
  78  *      and shared memory address of cc000. Multiple EasyConnection 8/64
  79  *      boards can share the same shared memory address space. No interrupt
  80  *      is required for this board type.
  81  *      Another example:
  82  *              { BRD_ECPE, 0x5000, 0, 0x80000000, 0, 0 },
  83  *      This line will configure an EasyConnection 8/64 EISA in slot 5 and
  84  *      shared memory address of 0x80000000 (2 GByte). Multiple
  85  *      EasyConnection 8/64 EISA boards can share the same shared memory
  86  *      address space. No interrupt is required for this board type.
  87  *      Another example:
  88  *              { BRD_ONBOARD, 0x240, 0, 0xd0000, 0, 0 },
  89  *      This line will configure an ONboard (ISA type) at io address 240,
  90  *      and shared memory address of d0000. Multiple ONboards can share
  91  *      the same shared memory address space. No interrupt required.
  92  *      Another example:
  93  *              { BRD_BRUMBY4, 0x360, 0, 0xc8000, 0, 0 },
  94  *      This line will configure a Brumby board (any number of ports!) at
  95  *      io address 360 and shared memory address of c8000. All Brumby boards
  96  *      configured into a system must have their own separate io and memory
  97  *      addresses. No interrupt is required.
  98  *      Another example:
  99  *              { BRD_STALLION, 0x330, 0, 0xd0000, 0, 0 },
 100  *      This line will configure an original Stallion board at io address 330
 101  *      and shared memory address d0000 (this would only be valid for a "V4.0"
 102  *      or Rev.O Stallion board). All Stallion boards configured into the
 103  *      system must have their own separate io and memory addresses. No
 104  *      interrupt is required.
 105  */
 106
 107 struct stlconf {
 108         int             brdtype;
 109         int             ioaddr1;
 110         int             ioaddr2;
 111         unsigned long   memaddr;
 112         int             irq;
 113         int             irqtype;
 114 };
 115
 116 static unsigned int stli_nrbrds;
 117
 118 /* stli_lock must NOT be taken holding brd_lock */
 119 static spinlock_t stli_lock;    /* TTY logic lock */
 120 static spinlock_t brd_lock;     /* Board logic lock */
 121
 122 /*
 123  *      There is some experimental EISA board detection code in this driver.
 124  *      By default it is disabled, but for those that want to try it out,
 125  *      then set the define below to be 1.
 126  */
 127 #define STLI_EISAPROBE  0
 128
 129 /*****************************************************************************/
 130
 131 /*
 132  *      Define some important driver characteristics. Device major numbers
 133  *      allocated as per Linux Device Registry.
 134  */
 135 #ifndef STL_SIOMEMMAJOR
 136 #define STL_SIOMEMMAJOR         28
 137 #endif
 138 #ifndef STL_SERIALMAJOR
 139 #define STL_SERIALMAJOR         24
 140 #endif
 141 #ifndef STL_CALLOUTMAJOR
 142 #define STL_CALLOUTMAJOR        25
 143 #endif
 144
 145 /*****************************************************************************/
 146
 147 /*
 148  *      Define our local driver identity first. Set up stuff to deal with
 149  *      all the local structures required by a serial tty driver.
 150  */
 151 static char     *stli_drvtitle = "Stallion Intelligent Multiport Serial Driver";
 152 static char     *stli_drvname = "istallion";
 153 static char     *stli_drvversion = "5.6.0";
 154 static char     *stli_serialname = "ttyE";
 155
 156 static struct tty_driver        *stli_serial;
 157 static const struct tty_port_operations stli_port_ops;
 158
 159 #define STLI_TXBUFSIZE          4096
 160
 161 /*
 162  *      Use a fast local buffer for cooked characters. Typically a whole
 163  *      bunch of cooked characters come in for a port, 1 at a time. So we
 164  *      save those up into a local buffer, then write out the whole lot
 165  *      with a large memcpy. Just use 1 buffer for all ports, since its
 166  *      use it is only need for short periods of time by each port.
 167  */
 168 static char                     *stli_txcookbuf;
 169 static int                      stli_txcooksize;
 170 static int                      stli_txcookrealsize;
 171 static struct tty_struct        *stli_txcooktty;
 172
 173 /*
 174  *      Define a local default termios struct. All ports will be created
 175  *      with this termios initially. Basically all it defines is a raw port
 176  *      at 9600 baud, 8 data bits, no parity, 1 stop bit.
 177  */
 178 static struct ktermios          stli_deftermios = {
 179         .c_cflag        = (B9600 | CS8 | CREAD | HUPCL | CLOCAL),
 180         .c_cc           = INIT_C_CC,
 181         .c_ispeed       = 9600,
 182         .c_ospeed       = 9600,
 183 };
 184
 185 /*
 186  *      Define global stats structures. Not used often, and can be
 187  *      re-used for each stats call.
 188  */
 189 static comstats_t       stli_comstats;
 190 static combrd_t         stli_brdstats;
 191 static struct asystats  stli_cdkstats;
 192
 193 /*****************************************************************************/
 194
 195 static DEFINE_MUTEX(stli_brdslock);
 196 static struct stlibrd   *stli_brds[STL_MAXBRDS];
 197
 198 static int              stli_shared;
 199
 200 /*
 201  *      Per board state flags. Used with the state field of the board struct.
 202  *      Not really much here... All we need to do is keep track of whether
 203  *      the board has been detected, and whether it is actually running a slave
 204  *      or not.
 205  */
 206 #define BST_FOUND       0x1
 207 #define BST_STARTED     0x2
 208 #define BST_PROBED      0x4
 209
 210 /*
 211  *      Define the set of port state flags. These are marked for internal
 212  *      state purposes only, usually to do with the state of communications
 213  *      with the slave. Most of them need to be updated atomically, so always
 214  *      use the bit setting operations (unless protected by cli/sti).
 215  */
 216 #define ST_OPENING      2
 217 #define ST_CLOSING      3
 218 #define ST_CMDING       4
 219 #define ST_TXBUSY       5
 220 #define ST_RXING        6
 221 #define ST_DOFLUSHRX    7
 222 #define ST_DOFLUSHTX    8
 223 #define ST_DOSIGS       9
 224 #define ST_RXSTOP       10
 225 #define ST_GETSIGS      11
 226
 227 /*
 228  *      Define an array of board names as printable strings. Handy for
 229  *      referencing boards when printing trace and stuff.
 230  */
 231 static char     *stli_brdnames[] = {
 232         "Unknown",
 233         "Stallion",
 234         "Brumby",
 235         "ONboard-MC",
 236         "ONboard",
 237         "Brumby",
 238         "Brumby",
 239         "ONboard-EI",
 240         NULL,
 241         "ONboard",
 242         "ONboard-MC",
 243         "ONboard-MC",
 244         NULL,
 245         NULL,
 246         NULL,
 247         NULL,
 248         NULL,
 249         NULL,
 250         NULL,
 251         NULL,
 252         "EasyIO",
 253         "EC8/32-AT",
 254         "EC8/32-MC",
 255         "EC8/64-AT",
 256         "EC8/64-EI",
 257         "EC8/64-MC",
 258         "EC8/32-PCI",
 259         "EC8/64-PCI",
 260         "EasyIO-PCI",
 261         "EC/RA-PCI",
 262 };
 263
 264 /*****************************************************************************/
 265
 266 /*
 267  *      Define some string labels for arguments passed from the module
 268  *      load line. These allow for easy board definitions, and easy
 269  *      modification of the io, memory and irq resoucres.
 270  */
 271
 272 static char     *board0[8];
 273 static char     *board1[8];
 274 static char     *board2[8];
 275 static char     *board3[8];
 276
 277 static char     **stli_brdsp[] = {
 278         (char **) &board0,
 279         (char **) &board1,
 280         (char **) &board2,
 281         (char **) &board3
 282 };
 283
 284 /*
 285  *      Define a set of common board names, and types. This is used to
 286  *      parse any module arguments.
 287  */
 288
 289 static struct stlibrdtype {
 290         char    *name;
 291         int     type;
 292 } stli_brdstr[] = {
 293         { "stallion", BRD_STALLION },
 294         { "1", BRD_STALLION },
 295         { "brumby", BRD_BRUMBY },
 296         { "brumby4", BRD_BRUMBY },
 297         { "brumby/4", BRD_BRUMBY },
 298         { "brumby-4", BRD_BRUMBY },
 299         { "brumby8", BRD_BRUMBY },
 300         { "brumby/8", BRD_BRUMBY },
 301         { "brumby-8", BRD_BRUMBY },
 302         { "brumby16", BRD_BRUMBY },
 303         { "brumby/16", BRD_BRUMBY },
 304         { "brumby-16", BRD_BRUMBY },
 305         { "2", BRD_BRUMBY },
 306         { "onboard2", BRD_ONBOARD2 },
 307         { "onboard-2", BRD_ONBOARD2 },
 308         { "onboard/2", BRD_ONBOARD2 },
 309         { "onboard-mc", BRD_ONBOARD2 },
 310         { "onboard/mc", BRD_ONBOARD2 },
 311         { "onboard-mca", BRD_ONBOARD2 },
 312         { "onboard/mca", BRD_ONBOARD2 },
 313         { "3", BRD_ONBOARD2 },
 314         { "onboard", BRD_ONBOARD },
 315         { "onboardat", BRD_ONBOARD },
 316         { "4", BRD_ONBOARD },
 317         { "onboarde", BRD_ONBOARDE },
 318         { "onboard-e", BRD_ONBOARDE },
 319         { "onboard/e", BRD_ONBOARDE },
 320         { "onboard-ei", BRD_ONBOARDE },
 321         { "onboard/ei", BRD_ONBOARDE },
 322         { "7", BRD_ONBOARDE },
 323         { "ecp", BRD_ECP },
 324         { "ecpat", BRD_ECP },
 325         { "ec8/64", BRD_ECP },
 326         { "ec8/64-at", BRD_ECP },
 327         { "ec8/64-isa", BRD_ECP },
 328         { "23", BRD_ECP },
 329         { "ecpe", BRD_ECPE },
 330         { "ecpei", BRD_ECPE },
 331         { "ec8/64-e", BRD_ECPE },
 332         { "ec8/64-ei", BRD_ECPE },
 333         { "24", BRD_ECPE },
 334         { "ecpmc", BRD_ECPMC },
 335         { "ec8/64-mc", BRD_ECPMC },
 336         { "ec8/64-mca", BRD_ECPMC },
 337         { "25", BRD_ECPMC },
 338         { "ecppci", BRD_ECPPCI },
 339         { "ec/ra", BRD_ECPPCI },
 340         { "ec/ra-pc", BRD_ECPPCI },
 341         { "ec/ra-pci", BRD_ECPPCI },
 342         { "29", BRD_ECPPCI },
 343 };
 344
 345 /*
 346  *      Define the module agruments.
 347  */
 348 MODULE_AUTHOR("Greg Ungerer");
 349 MODULE_DESCRIPTION("Stallion Intelligent Multiport Serial Driver");
 350 MODULE_LICENSE("GPL");
 351
 352
 353 module_param_array(board0, charp, NULL, 0);
 354 MODULE_PARM_DESC(board0, "Board 0 config -> name[,ioaddr[,memaddr]");
 355 module_param_array(board1, charp, NULL, 0);
 356 MODULE_PARM_DESC(board1, "Board 1 config -> name[,ioaddr[,memaddr]");
 357 module_param_array(board2, charp, NULL, 0);
 358 MODULE_PARM_DESC(board2, "Board 2 config -> name[,ioaddr[,memaddr]");
 359 module_param_array(board3, charp, NULL, 0);
 360 MODULE_PARM_DESC(board3, "Board 3 config -> name[,ioaddr[,memaddr]");
 361
 362 #if STLI_EISAPROBE != 0
 363 /*
 364  *      Set up a default memory address table for EISA board probing.
 365  *      The default addresses are all bellow 1Mbyte, which has to be the
 366  *      case anyway. They should be safe, since we only read values from
 367  *      them, and interrupts are disabled while we do it. If the higher
 368  *      memory support is compiled in then we also try probing around
 369  *      the 1Gb, 2Gb and 3Gb areas as well...
 370  */
 371 static unsigned long    stli_eisamemprobeaddrs[] = {
 372         0xc0000,    0xd0000,    0xe0000,    0xf0000,
 373         0x80000000, 0x80010000, 0x80020000, 0x80030000,
 374         0x40000000, 0x40010000, 0x40020000, 0x40030000,
 375         0xc0000000, 0xc0010000, 0xc0020000, 0xc0030000,
 376         0xff000000, 0xff010000, 0xff020000, 0xff030000,
 377 };
 378
 379 static int      stli_eisamempsize = ARRAY_SIZE(stli_eisamemprobeaddrs);
 380 #endif
 381
 382 /*
 383  *      Define the Stallion PCI vendor and device IDs.
 384  */
 385 #ifndef PCI_DEVICE_ID_ECRA
 386 #define PCI_DEVICE_ID_ECRA              0x0004
 387 #endif
 388
 389 static struct pci_device_id istallion_pci_tbl[] = {
 390         { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECRA), },
 391         { 0 }
 392 };
 393 MODULE_DEVICE_TABLE(pci, istallion_pci_tbl);
 394
 395 static struct pci_driver stli_pcidriver;
 396
 397 /*****************************************************************************/
 398
 399 /*
 400  *      Hardware configuration info for ECP boards. These defines apply
 401  *      to the directly accessible io ports of the ECP. There is a set of
 402  *      defines for each ECP board type, ISA, EISA, MCA and PCI.
 403  */
 404 #define ECP_IOSIZE      4
 405
 406 #define ECP_MEMSIZE     (128 * 1024)
 407 #define ECP_PCIMEMSIZE  (256 * 1024)
 408
 409 #define ECP_ATPAGESIZE  (4 * 1024)
 410 #define ECP_MCPAGESIZE  (4 * 1024)
 411 #define ECP_EIPAGESIZE  (64 * 1024)
 412 #define ECP_PCIPAGESIZE (64 * 1024)
 413
 414 #define STL_EISAID      0x8c4e
 415
 416 /*
 417  *      Important defines for the ISA class of ECP board.
 418  */
 419 #define ECP_ATIREG      0
 420 #define ECP_ATCONFR     1
 421 #define ECP_ATMEMAR     2
 422 #define ECP_ATMEMPR     3
 423 #define ECP_ATSTOP      0x1
 424 #define ECP_ATINTENAB   0x10
 425 #define ECP_ATENABLE    0x20
 426 #define ECP_ATDISABLE   0x00
 427 #define ECP_ATADDRMASK  0x3f000
 428 #define ECP_ATADDRSHFT  12
 429
 430 /*
 431  *      Important defines for the EISA class of ECP board.
 432  */
 433 #define ECP_EIIREG      0
 434 #define ECP_EIMEMARL    1
 435 #define ECP_EICONFR     2
 436 #define ECP_EIMEMARH    3
 437 #define ECP_EIENABLE    0x1
 438 #define ECP_EIDISABLE   0x0
 439 #define ECP_EISTOP      0x4
 440 #define ECP_EIEDGE      0x00
 441 #define ECP_EILEVEL     0x80
 442 #define ECP_EIADDRMASKL 0x00ff0000
 443 #define ECP_EIADDRSHFTL 16
 444 #define ECP_EIADDRMASKH 0xff000000
 445 #define ECP_EIADDRSHFTH 24
 446 #define ECP_EIBRDENAB   0xc84
 447
 448 #define ECP_EISAID      0x4
 449
 450 /*
 451  *      Important defines for the Micro-channel class of ECP board.
 452  *      (It has a lot in common with the ISA boards.)
 453  */
 454 #define ECP_MCIREG      0
 455 #define ECP_MCCONFR     1
 456 #define ECP_MCSTOP      0x20
 457 #define ECP_MCENABLE    0x80
 458 #define ECP_MCDISABLE   0x00
 459
 460 /*
 461  *      Important defines for the PCI class of ECP board.
 462  *      (It has a lot in common with the other ECP boards.)
 463  */
 464 #define ECP_PCIIREG     0
 465 #define ECP_PCICONFR    1
 466 #define ECP_PCISTOP     0x01
 467
 468 /*
 469  *      Hardware configuration info for ONboard and Brumby boards. These
 470  *      defines apply to the directly accessible io ports of these boards.
 471  */
 472 #define ONB_IOSIZE      16
 473 #define ONB_MEMSIZE     (64 * 1024)
 474 #define ONB_ATPAGESIZE  (64 * 1024)
 475 #define ONB_MCPAGESIZE  (64 * 1024)
 476 #define ONB_EIMEMSIZE   (128 * 1024)
 477 #define ONB_EIPAGESIZE  (64 * 1024)
 478
 479 /*
 480  *      Important defines for the ISA class of ONboard board.
 481  */
 482 #define ONB_ATIREG      0
 483 #define ONB_ATMEMAR     1
 484 #define ONB_ATCONFR     2
 485 #define ONB_ATSTOP      0x4
 486 #define ONB_ATENABLE    0x01
 487 #define ONB_ATDISABLE   0x00
 488 #define ONB_ATADDRMASK  0xff0000
 489 #define ONB_ATADDRSHFT  16
 490
 491 #define ONB_MEMENABLO   0
 492 #define ONB_MEMENABHI   0x02
 493
 494 /*
 495  *      Important defines for the EISA class of ONboard board.
 496  */
 497 #define ONB_EIIREG      0
 498 #define ONB_EIMEMARL    1
 499 #define ONB_EICONFR     2
 500 #define ONB_EIMEMARH    3
 501 #define ONB_EIENABLE    0x1
 502 #define ONB_EIDISABLE   0x0
 503 #define ONB_EISTOP      0x4
 504 #define ONB_EIEDGE      0x00
 505 #define ONB_EILEVEL     0x80
 506 #define ONB_EIADDRMASKL 0x00ff0000
 507 #define ONB_EIADDRSHFTL 16
 508 #define ONB_EIADDRMASKH 0xff000000
 509 #define ONB_EIADDRSHFTH 24
 510 #define ONB_EIBRDENAB   0xc84
 511
 512 #define ONB_EISAID      0x1
 513
 514 /*
 515  *      Important defines for the Brumby boards. They are pretty simple,
 516  *      there is not much that is programmably configurable.
 517  */
 518 #define BBY_IOSIZE      16
 519 #define BBY_MEMSIZE     (64 * 1024)
 520 #define BBY_PAGESIZE    (16 * 1024)
 521
 522 #define BBY_ATIREG      0
 523 #define BBY_ATCONFR     1
 524 #define BBY_ATSTOP      0x4
 525
 526 /*
 527  *      Important defines for the Stallion boards. They are pretty simple,
 528  *      there is not much that is programmably configurable.
 529  */
 530 #define STAL_IOSIZE     16
 531 #define STAL_MEMSIZE    (64 * 1024)
 532 #define STAL_PAGESIZE   (64 * 1024)
 533
 534 /*
 535  *      Define the set of status register values for EasyConnection panels.
 536  *      The signature will return with the status value for each panel. From
 537  *      this we can determine what is attached to the board - before we have
 538  *      actually down loaded any code to it.
 539  */
 540 #define ECH_PNLSTATUS   2
 541 #define ECH_PNL16PORT   0x20
 542 #define ECH_PNLIDMASK   0x07
 543 #define ECH_PNLXPID     0x40
 544 #define ECH_PNLINTRPEND 0x80
 545
 546 /*
 547  *      Define some macros to do things to the board. Even those these boards
 548  *      are somewhat related there is often significantly different ways of
 549  *      doing some operation on it (like enable, paging, reset, etc). So each
 550  *      board class has a set of functions which do the commonly required
 551  *      operations. The macros below basically just call these functions,
 552  *      generally checking for a NULL function - which means that the board
 553  *      needs nothing done to it to achieve this operation!
 554  */
 555 #define EBRDINIT(brdp)                                          \
 556         if (brdp->init != NULL)                                 \
 557                 (* brdp->init)(brdp)
 558
 559 #define EBRDENABLE(brdp)                                        \
 560         if (brdp->enable != NULL)                               \
 561                 (* brdp->enable)(brdp);
 562
 563 #define EBRDDISABLE(brdp)                                       \
 564         if (brdp->disable != NULL)                              \
 565                 (* brdp->disable)(brdp);
 566
 567 #define EBRDINTR(brdp)                                          \
 568         if (brdp->intr != NULL)                                 \
 569                 (* brdp->intr)(brdp);
 570
 571 #define EBRDRESET(brdp)                                         \
 572         if (brdp->reset != NULL)                                \
 573                 (* brdp->reset)(brdp);
 574
 575 #define EBRDGETMEMPTR(brdp,offset)                              \
 576         (* brdp->getmemptr)(brdp, offset, __LINE__)
 577
 578 /*
 579  *      Define the maximal baud rate, and the default baud base for ports.
 580  */
 581 #define STL_MAXBAUD     460800
 582 #define STL_BAUDBASE    115200
 583 #define STL_CLOSEDELAY  (5 * HZ / 10)
 584
 585 /*****************************************************************************/
 586
 587 /*
 588  *      Define macros to extract a brd or port number from a minor number.
 589  */
 590 #define MINOR2BRD(min)          (((min) & 0xc0) >> 6)
 591 #define MINOR2PORT(min)         ((min) & 0x3f)
 592
 593 /*****************************************************************************/
 594
 595 /*
 596  *      Prototype all functions in this driver!
 597  */
 598
 599 static int      stli_parsebrd(struct stlconf *confp, char **argp);
 600 static int      stli_open(struct tty_struct *tty, struct file *filp);
 601 static void     stli_close(struct tty_struct *tty, struct file *filp);
 602 static int      stli_write(struct tty_struct *tty, const unsigned char *buf, int count);
 603 static int      stli_putchar(struct tty_struct *tty, unsigned char ch);
 604 static void     stli_flushchars(struct tty_struct *tty);
 605 static int      stli_writeroom(struct tty_struct *tty);
 606 static int      stli_charsinbuffer(struct tty_struct *tty);
 607 static int      stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
 608 static void     stli_settermios(struct tty_struct *tty, struct ktermios *old);
 609 static void     stli_throttle(struct tty_struct *tty);
 610 static void     stli_unthrottle(struct tty_struct *tty);
 611 static void     stli_stop(struct tty_struct *tty);
 612 static void     stli_start(struct tty_struct *tty);
 613 static void     stli_flushbuffer(struct tty_struct *tty);
 614 static int      stli_breakctl(struct tty_struct *tty, int state);
 615 static void     stli_waituntilsent(struct tty_struct *tty, int timeout);
 616 static void     stli_sendxchar(struct tty_struct *tty, char ch);
 617 static void     stli_hangup(struct tty_struct *tty);
 618
 619 static int      stli_brdinit(struct stlibrd *brdp);
 620 static int      stli_startbrd(struct stlibrd *brdp);
 621 static ssize_t  stli_memread(struct file *fp, char __user *buf, size_t count, loff_t *offp);
 622 static ssize_t  stli_memwrite(struct file *fp, const char __user *buf, size_t count, loff_t *offp);
 623 static long     stli_memioctl(struct file *fp, unsigned int cmd, unsigned long arg);
 624 static void     stli_brdpoll(struct stlibrd *brdp, cdkhdr_t __iomem *hdrp);
 625 static void     stli_poll(unsigned long arg);
 626 static int      stli_hostcmd(struct stlibrd *brdp, struct stliport *portp);
 627 static int      stli_initopen(struct tty_struct *tty, struct stlibrd *brdp, struct stliport *portp);
 628 static int      stli_rawopen(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait);
 629 static int      stli_rawclose(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait);
 630 static int      stli_setport(struct tty_struct *tty);
 631 static int      stli_cmdwait(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback);
 632 static void     stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback);
 633 static void     __stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback);
 634 static void     stli_dodelaycmd(struct stliport *portp, cdkctrl_t __iomem *cp);
 635 static void     stli_mkasyport(struct tty_struct *tty, struct stliport *portp, asyport_t *pp, struct ktermios *tiosp);
 636 static void     stli_mkasysigs(asysigs_t *sp, int dtr, int rts);
 637 static long     stli_mktiocm(unsigned long sigvalue);
 638 static void     stli_read(struct stlibrd *brdp, struct stliport *portp);
 639 static int      stli_getserial(struct stliport *portp, struct serial_struct __user *sp);
 640 static int      stli_setserial(struct tty_struct *tty, struct serial_struct __user *sp);
 641 static int      stli_getbrdstats(combrd_t __user *bp);
 642 static int      stli_getportstats(struct tty_struct *tty, struct stliport *portp, comstats_t __user *cp);
 643 static int      stli_portcmdstats(struct tty_struct *tty, struct stliport *portp);
 644 static int      stli_clrportstats(struct stliport *portp, comstats_t __user *cp);
 645 static int      stli_getportstruct(struct stliport __user *arg);
 646 static int      stli_getbrdstruct(struct stlibrd __user *arg);
 647 static struct stlibrd *stli_allocbrd(void);
 648
 649 static void     stli_ecpinit(struct stlibrd *brdp);
 650 static void     stli_ecpenable(struct stlibrd *brdp);
 651 static void     stli_ecpdisable(struct stlibrd *brdp);
 652 static void __iomem *stli_ecpgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
 653 static void     stli_ecpreset(struct stlibrd *brdp);
 654 static void     stli_ecpintr(struct stlibrd *brdp);
 655 static void     stli_ecpeiinit(struct stlibrd *brdp);
 656 static void     stli_ecpeienable(struct stlibrd *brdp);
 657 static void     stli_ecpeidisable(struct stlibrd *brdp);
 658 static void __iomem *stli_ecpeigetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
 659 static void     stli_ecpeireset(struct stlibrd *brdp);
 660 static void     stli_ecpmcenable(struct stlibrd *brdp);
 661 static void     stli_ecpmcdisable(struct stlibrd *brdp);
 662 static void __iomem *stli_ecpmcgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
 663 static void     stli_ecpmcreset(struct stlibrd *brdp);
 664 static void     stli_ecppciinit(struct stlibrd *brdp);
 665 static void __iomem *stli_ecppcigetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
 666 static void     stli_ecppcireset(struct stlibrd *brdp);
 667
 668 static void     stli_onbinit(struct stlibrd *brdp);
 669 static void     stli_onbenable(struct stlibrd *brdp);
 670 static void     stli_onbdisable(struct stlibrd *brdp);
 671 static void __iomem *stli_onbgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
 672 static void     stli_onbreset(struct stlibrd *brdp);
 673 static void     stli_onbeinit(struct stlibrd *brdp);
 674 static void     stli_onbeenable(struct stlibrd *brdp);
 675 static void     stli_onbedisable(struct stlibrd *brdp);
 676 static void __iomem *stli_onbegetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
 677 static void     stli_onbereset(struct stlibrd *brdp);
 678 static void     stli_bbyinit(struct stlibrd *brdp);
 679 static void __iomem *stli_bbygetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
 680 static void     stli_bbyreset(struct stlibrd *brdp);
 681 static void     stli_stalinit(struct stlibrd *brdp);
 682 static void __iomem *stli_stalgetmemptr(struct stlibrd *brdp, unsigned long offset, int line);
 683 static void     stli_stalreset(struct stlibrd *brdp);
 684
 685 static struct stliport *stli_getport(unsigned int brdnr, unsigned int panelnr, unsigned int portnr);
 686
 687 static int      stli_initecp(struct stlibrd *brdp);
 688 static int      stli_initonb(struct stlibrd *brdp);
 689 #if STLI_EISAPROBE != 0
 690 static int      stli_eisamemprobe(struct stlibrd *brdp);
 691 #endif
 692 static int      stli_initports(struct stlibrd *brdp);
 693
 694 /*****************************************************************************/
 695
 696 /*
 697  *      Define the driver info for a user level shared memory device. This
 698  *      device will work sort of like the /dev/kmem device - except that it
 699  *      will give access to the shared memory on the Stallion intelligent
 700  *      board. This is also a very useful debugging tool.
 701  */
 702 static const struct file_operations     stli_fsiomem = {
 703         .owner          = THIS_MODULE,
 704         .read           = stli_memread,
 705         .write          = stli_memwrite,
 706         .unlocked_ioctl = stli_memioctl,
 707 };
 708
 709 /*****************************************************************************/
 710
 711 /*
 712  *      Define a timer_list entry for our poll routine. The slave board
 713  *      is polled every so often to see if anything needs doing. This is
 714  *      much cheaper on host cpu than using interrupts. It turns out to
 715  *      not increase character latency by much either...
 716  */
 717 static DEFINE_TIMER(stli_timerlist, stli_poll, 0, 0);
 718
 719 static int      stli_timeron;
 720
 721 /*
 722  *      Define the calculation for the timeout routine.
 723  */
 724 #define STLI_TIMEOUT    (jiffies + 1)
 725
 726 /*****************************************************************************/
 727
 728 static struct class *istallion_class;
 729
 730 static void stli_cleanup_ports(struct stlibrd *brdp)
 731 {
 732         struct stliport *portp;
 733         unsigned int j;
 734         struct tty_struct *tty;
 735
 736         for (j = 0; j < STL_MAXPORTS; j++) {
 737                 portp = brdp->ports[j];
 738                 if (portp != NULL) {
 739                         tty = tty_port_tty_get(&portp->port);
 740                         if (tty != NULL) {
 741                                 tty_hangup(tty);
 742                                 tty_kref_put(tty);
 743                         }
 744                         kfree(portp);
 745                 }
 746         }
 747 }
 748
 749 /*****************************************************************************/
 750
 751 /*
 752  *      Parse the supplied argument string, into the board conf struct.
 753  */
 754
 755 static int stli_parsebrd(struct stlconf *confp, char **argp)
 756 {
 757         unsigned int i;
 758         char *sp;
 759
 760         if (argp[0] == NULL || *argp[0] == 0)
 761                 return 0;
 762
 763         for (sp = argp[0], i = 0; ((*sp != 0) && (i < 25)); sp++, i++)
 764                 *sp = tolower(*sp);
 765
 766         for (i = 0; i < ARRAY_SIZE(stli_brdstr); i++) {
 767                 if (strcmp(stli_brdstr[i].name, argp[0]) == 0)
 768                         break;
 769         }
 770         if (i == ARRAY_SIZE(stli_brdstr)) {
 771                 printk(KERN_WARNING "istallion: unknown board name, %s?\n", argp[0]);
 772                 return 0;
 773         }
 774
 775         confp->brdtype = stli_brdstr[i].type;
 776         if (argp[1] != NULL && *argp[1] != 0)
 777                 confp->ioaddr1 = simple_strtoul(argp[1], NULL, 0);
 778         if (argp[2] !=  NULL && *argp[2] != 0)
 779                 confp->memaddr = simple_strtoul(argp[2], NULL, 0);
 780         return(1);
 781 }
 782
 783 /*****************************************************************************/
 784
 785 /*
 786  *      On the first open of the device setup the port hardware, and
 787  *      initialize the per port data structure. Since initializing the port
 788  *      requires several commands to the board we will need to wait for any
 789  *      other open that is already initializing the port.
 790  *
 791  *      Locking: protected by the port mutex.
 792  */
 793
 794 static int stli_activate(struct tty_port *port, struct tty_struct *tty)
 795 {
 796         struct stliport *portp = container_of(port, struct stliport, port);
 797         struct stlibrd *brdp = stli_brds[portp->brdnr];
 798         int rc;
 799
 800         if ((rc = stli_initopen(tty, brdp, portp)) >= 0)
 801                 clear_bit(TTY_IO_ERROR, &tty->flags);
 802         wake_up_interruptible(&portp->raw_wait);
 803         return rc;
 804 }
 805
 806 static int stli_open(struct tty_struct *tty, struct file *filp)
 807 {
 808         struct stlibrd *brdp;
 809         struct stliport *portp;
 810         unsigned int minordev, brdnr, portnr;
 811
 812         minordev = tty->index;
 813         brdnr = MINOR2BRD(minordev);
 814         if (brdnr >= stli_nrbrds)
 815                 return -ENODEV;
 816         brdp = stli_brds[brdnr];
 817         if (brdp == NULL)
 818                 return -ENODEV;
 819         if ((brdp->state & BST_STARTED) == 0)
 820                 return -ENODEV;
 821         portnr = MINOR2PORT(minordev);
 822         if (portnr > brdp->nrports)
 823                 return -ENODEV;
 824
 825         portp = brdp->ports[portnr];
 826         if (portp == NULL)
 827                 return -ENODEV;
 828         if (portp->devnr < 1)
 829                 return -ENODEV;
 830
 831         tty->driver_data = portp;
 832         return tty_port_open(&portp->port, tty, filp);
 833 }
 834
 835
 836 /*****************************************************************************/
 837
 838 static void stli_shutdown(struct tty_port *port)
 839 {
 840         struct stlibrd *brdp;
 841         unsigned long ftype;
 842         unsigned long flags;
 843         struct stliport *portp = container_of(port, struct stliport, port);
 844
 845         if (portp->brdnr >= stli_nrbrds)
 846                 return;
 847         brdp = stli_brds[portp->brdnr];
 848         if (brdp == NULL)
 849                 return;
 850
 851         /*
 852          *      May want to wait for data to drain before closing. The BUSY
 853          *      flag keeps track of whether we are still transmitting or not.
 854          *      It is updated by messages from the slave - indicating when all
 855          *      chars really have drained.
 856          */
 857
 858         if (!test_bit(ST_CLOSING, &portp->state))
 859                 stli_rawclose(brdp, portp, 0, 0);
 860
 861         spin_lock_irqsave(&stli_lock, flags);
 862         clear_bit(ST_TXBUSY, &portp->state);
 863         clear_bit(ST_RXSTOP, &portp->state);
 864         spin_unlock_irqrestore(&stli_lock, flags);
 865
 866         ftype = FLUSHTX | FLUSHRX;
 867         stli_cmdwait(brdp, portp, A_FLUSH, &ftype, sizeof(u32), 0);
 868 }
 869
 870 static void stli_close(struct tty_struct *tty, struct file *filp)
 871 {
 872         struct stliport *portp = tty->driver_data;
 873         unsigned long flags;
 874         if (portp == NULL)
 875                 return;
 876         spin_lock_irqsave(&stli_lock, flags);
 877         /*      Flush any internal buffering out first */
 878         if (tty == stli_txcooktty)
 879                 stli_flushchars(tty);
 880         spin_unlock_irqrestore(&stli_lock, flags);
 881         tty_port_close(&portp->port, tty, filp);
 882 }
 883
 884 /*****************************************************************************/
 885
 886 /*
 887  *      Carry out first open operations on a port. This involves a number of
 888  *      commands to be sent to the slave. We need to open the port, set the
 889  *      notification events, set the initial port settings, get and set the
 890  *      initial signal values. We sleep and wait in between each one. But
 891  *      this still all happens pretty quickly.
 892  */
 893
 894 static int stli_initopen(struct tty_struct *tty,
 895                                 struct stlibrd *brdp, struct stliport *portp)
 896 {
 897         asynotify_t nt;
 898         asyport_t aport;
 899         int rc;
 900
 901         if ((rc = stli_rawopen(brdp, portp, 0, 1)) < 0)
 902                 return rc;
 903
 904         memset(&nt, 0, sizeof(asynotify_t));
 905         nt.data = (DT_TXLOW | DT_TXEMPTY | DT_RXBUSY | DT_RXBREAK);
 906         nt.signal = SG_DCD;
 907         if ((rc = stli_cmdwait(brdp, portp, A_SETNOTIFY, &nt,
 908             sizeof(asynotify_t), 0)) < 0)
 909                 return rc;
 910
 911         stli_mkasyport(tty, portp, &aport, tty->termios);
 912         if ((rc = stli_cmdwait(brdp, portp, A_SETPORT, &aport,
 913             sizeof(asyport_t), 0)) < 0)
 914                 return rc;
 915
 916         set_bit(ST_GETSIGS, &portp->state);
 917         if ((rc = stli_cmdwait(brdp, portp, A_GETSIGNALS, &portp->asig,
 918             sizeof(asysigs_t), 1)) < 0)
 919                 return rc;
 920         if (test_and_clear_bit(ST_GETSIGS, &portp->state))
 921                 portp->sigs = stli_mktiocm(portp->asig.sigvalue);
 922         stli_mkasysigs(&portp->asig, 1, 1);
 923         if ((rc = stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
 924             sizeof(asysigs_t), 0)) < 0)
 925                 return rc;
 926
 927         return 0;
 928 }
 929
 930 /*****************************************************************************/
 931
 932 /*
 933  *      Send an open message to the slave. This will sleep waiting for the
 934  *      acknowledgement, so must have user context. We need to co-ordinate
 935  *      with close events here, since we don't want open and close events
 936  *      to overlap.
 937  */
 938
 939 static int stli_rawopen(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait)
 940 {
 941         cdkhdr_t __iomem *hdrp;
 942         cdkctrl_t __iomem *cp;
 943         unsigned char __iomem *bits;
 944         unsigned long flags;
 945         int rc;
 946
 947 /*
 948  *      Send a message to the slave to open this port.
 949  */
 950
 951 /*
 952  *      Slave is already closing this port. This can happen if a hangup
 953  *      occurs on this port. So we must wait until it is complete. The
 954  *      order of opens and closes may not be preserved across shared
 955  *      memory, so we must wait until it is complete.
 956  */
 957         wait_event_interruptible(portp->raw_wait,
 958                         !test_bit(ST_CLOSING, &portp->state));
 959         if (signal_pending(current)) {
 960                 return -ERESTARTSYS;
 961         }
 962
 963 /*
 964  *      Everything is ready now, so write the open message into shared
 965  *      memory. Once the message is in set the service bits to say that
 966  *      this port wants service.
 967  */
 968         spin_lock_irqsave(&brd_lock, flags);
 969         EBRDENABLE(brdp);
 970         cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
 971         writel(arg, &cp->openarg);
 972         writeb(1, &cp->open);
 973         hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
 974         bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
 975                 portp->portidx;
 976         writeb(readb(bits) | portp->portbit, bits);
 977         EBRDDISABLE(brdp);
 978
 979         if (wait == 0) {
 980                 spin_unlock_irqrestore(&brd_lock, flags);
 981                 return 0;
 982         }
 983
 984 /*
 985  *      Slave is in action, so now we must wait for the open acknowledgment
 986  *      to come back.
 987  */
 988         rc = 0;
 989         set_bit(ST_OPENING, &portp->state);
 990         spin_unlock_irqrestore(&brd_lock, flags);
 991
 992         wait_event_interruptible(portp->raw_wait,
 993                         !test_bit(ST_OPENING, &portp->state));
 994         if (signal_pending(current))
 995                 rc = -ERESTARTSYS;
 996
 997         if ((rc == 0) && (portp->rc != 0))
 998                 rc = -EIO;
 999         return rc;
1000 }
1001
1002 /*****************************************************************************/
1003
1004 /*
1005  *      Send a close message to the slave. Normally this will sleep waiting
1006  *      for the acknowledgement, but if wait parameter is 0 it will not. If
1007  *      wait is true then must have user context (to sleep).
1008  */
1009
1010 static int stli_rawclose(struct stlibrd *brdp, struct stliport *portp, unsigned long arg, int wait)
1011 {
1012         cdkhdr_t __iomem *hdrp;
1013         cdkctrl_t __iomem *cp;
1014         unsigned char __iomem *bits;
1015         unsigned long flags;
1016         int rc;
1017
1018 /*
1019  *      Slave is already closing this port. This can happen if a hangup
1020  *      occurs on this port.
1021  */
1022         if (wait) {
1023                 wait_event_interruptible(portp->raw_wait,
1024                                 !test_bit(ST_CLOSING, &portp->state));
1025                 if (signal_pending(current)) {
1026                         return -ERESTARTSYS;
1027                 }
1028         }
1029
1030 /*
1031  *      Write the close command into shared memory.
1032  */
1033         spin_lock_irqsave(&brd_lock, flags);
1034         EBRDENABLE(brdp);
1035         cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
1036         writel(arg, &cp->closearg);
1037         writeb(1, &cp->close);
1038         hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1039         bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
1040                 portp->portidx;
1041         writeb(readb(bits) |portp->portbit, bits);
1042         EBRDDISABLE(brdp);
1043
1044         set_bit(ST_CLOSING, &portp->state);
1045         spin_unlock_irqrestore(&brd_lock, flags);
1046
1047         if (wait == 0)
1048                 return 0;
1049
1050 /*
1051  *      Slave is in action, so now we must wait for the open acknowledgment
1052  *      to come back.
1053  */
1054         rc = 0;
1055         wait_event_interruptible(portp->raw_wait,
1056                         !test_bit(ST_CLOSING, &portp->state));
1057         if (signal_pending(current))
1058                 rc = -ERESTARTSYS;
1059
1060         if ((rc == 0) && (portp->rc != 0))
1061                 rc = -EIO;
1062         return rc;
1063 }
1064
1065 /*****************************************************************************/
1066
1067 /*
1068  *      Send a command to the slave and wait for the response. This must
1069  *      have user context (it sleeps). This routine is generic in that it
1070  *      can send any type of command. Its purpose is to wait for that command
1071  *      to complete (as opposed to initiating the command then returning).
1072  */
1073
1074 static int stli_cmdwait(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
1075 {
1076         wait_event_interruptible(portp->raw_wait,
1077                         !test_bit(ST_CMDING, &portp->state));
1078         if (signal_pending(current))
1079                 return -ERESTARTSYS;
1080
1081         stli_sendcmd(brdp, portp, cmd, arg, size, copyback);
1082
1083         wait_event_interruptible(portp->raw_wait,
1084                         !test_bit(ST_CMDING, &portp->state));
1085         if (signal_pending(current))
1086                 return -ERESTARTSYS;
1087
1088         if (portp->rc != 0)
1089                 return -EIO;
1090         return 0;
1091 }
1092
1093 /*****************************************************************************/
1094
1095 /*
1096  *      Send the termios settings for this port to the slave. This sleeps
1097  *      waiting for the command to complete - so must have user context.
1098  */
1099
1100 static int stli_setport(struct tty_struct *tty)
1101 {
1102         struct stliport *portp = tty->driver_data;
1103         struct stlibrd *brdp;
1104         asyport_t aport;
1105
1106         if (portp == NULL)
1107                 return -ENODEV;
1108         if (portp->brdnr >= stli_nrbrds)
1109                 return -ENODEV;
1110         brdp = stli_brds[portp->brdnr];
1111         if (brdp == NULL)
1112                 return -ENODEV;
1113
1114         stli_mkasyport(tty, portp, &aport, tty->termios);
1115         return(stli_cmdwait(brdp, portp, A_SETPORT, &aport, sizeof(asyport_t), 0));
1116 }
1117
1118 /*****************************************************************************/
1119
1120 static int stli_carrier_raised(struct tty_port *port)
1121 {
1122         struct stliport *portp = container_of(port, struct stliport, port);
1123         return (portp->sigs & TIOCM_CD) ? 1 : 0;
1124 }
1125
1126 static void stli_dtr_rts(struct tty_port *port, int on)
1127 {
1128         struct stliport *portp = container_of(port, struct stliport, port);
1129         struct stlibrd *brdp = stli_brds[portp->brdnr];
1130         stli_mkasysigs(&portp->asig, on, on);
1131         if (stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
1132                 sizeof(asysigs_t), 0) < 0)
1133                         printk(KERN_WARNING "istallion: dtr set failed.\n");
1134 }
1135
1136
1137 /*****************************************************************************/
1138
1139 /*
1140  *      Write routine. Take the data and put it in the shared memory ring
1141  *      queue. If port is not already sending chars then need to mark the
1142  *      service bits for this port.
1143  */
1144
1145 static int stli_write(struct tty_struct *tty, const unsigned char *buf, int count)
1146 {
1147         cdkasy_t __iomem *ap;
1148         cdkhdr_t __iomem *hdrp;
1149         unsigned char __iomem *bits;
1150         unsigned char __iomem *shbuf;
1151         unsigned char *chbuf;
1152         struct stliport *portp;
1153         struct stlibrd *brdp;
1154         unsigned int len, stlen, head, tail, size;
1155         unsigned long flags;
1156
1157         if (tty == stli_txcooktty)
1158                 stli_flushchars(tty);
1159         portp = tty->driver_data;
1160         if (portp == NULL)
1161                 return 0;
1162         if (portp->brdnr >= stli_nrbrds)
1163                 return 0;
1164         brdp = stli_brds[portp->brdnr];
1165         if (brdp == NULL)
1166                 return 0;
1167         chbuf = (unsigned char *) buf;
1168
1169 /*
1170  *      All data is now local, shove as much as possible into shared memory.
1171  */
1172         spin_lock_irqsave(&brd_lock, flags);
1173         EBRDENABLE(brdp);
1174         ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1175         head = (unsigned int) readw(&ap->txq.head);
1176         tail = (unsigned int) readw(&ap->txq.tail);
1177         if (tail != ((unsigned int) readw(&ap->txq.tail)))
1178                 tail = (unsigned int) readw(&ap->txq.tail);
1179         size = portp->txsize;
1180         if (head >= tail) {
1181                 len = size - (head - tail) - 1;
1182                 stlen = size - head;
1183         } else {
1184                 len = tail - head - 1;
1185                 stlen = len;
1186         }
1187
1188         len = min(len, (unsigned int)count);
1189         count = 0;
1190         shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->txoffset);
1191
1192         while (len > 0) {
1193                 stlen = min(len, stlen);
1194                 memcpy_toio(shbuf + head, chbuf, stlen);
1195                 chbuf += stlen;
1196                 len -= stlen;
1197                 count += stlen;
1198                 head += stlen;
1199                 if (head >= size) {
1200                         head = 0;
1201                         stlen = tail;
1202                 }
1203         }
1204
1205         ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1206         writew(head, &ap->txq.head);
1207         if (test_bit(ST_TXBUSY, &portp->state)) {
1208                 if (readl(&ap->changed.data) & DT_TXEMPTY)
1209                         writel(readl(&ap->changed.data) & ~DT_TXEMPTY, &ap->changed.data);
1210         }
1211         hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1212         bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
1213                 portp->portidx;
1214         writeb(readb(bits) | portp->portbit, bits);
1215         set_bit(ST_TXBUSY, &portp->state);
1216         EBRDDISABLE(brdp);
1217         spin_unlock_irqrestore(&brd_lock, flags);
1218
1219         return(count);
1220 }
1221
1222 /*****************************************************************************/
1223
1224 /*
1225  *      Output a single character. We put it into a temporary local buffer
1226  *      (for speed) then write out that buffer when the flushchars routine
1227  *      is called. There is a safety catch here so that if some other port
1228  *      writes chars before the current buffer has been, then we write them
1229  *      first them do the new ports.
1230  */
1231
1232 static int stli_putchar(struct tty_struct *tty, unsigned char ch)
1233 {
1234         if (tty != stli_txcooktty) {
1235                 if (stli_txcooktty != NULL)
1236                         stli_flushchars(stli_txcooktty);
1237                 stli_txcooktty = tty;
1238         }
1239
1240         stli_txcookbuf[stli_txcooksize++] = ch;
1241         return 0;
1242 }
1243
1244 /*****************************************************************************/
1245
1246 /*
1247  *      Transfer characters from the local TX cooking buffer to the board.
1248  *      We sort of ignore the tty that gets passed in here. We rely on the
1249  *      info stored with the TX cook buffer to tell us which port to flush
1250  *      the data on. In any case we clean out the TX cook buffer, for re-use
1251  *      by someone else.
1252  */
1253
1254 static void stli_flushchars(struct tty_struct *tty)
1255 {
1256         cdkhdr_t __iomem *hdrp;
1257         unsigned char __iomem *bits;
1258         cdkasy_t __iomem *ap;
1259         struct tty_struct *cooktty;
1260         struct stliport *portp;
1261         struct stlibrd *brdp;
1262         unsigned int len, stlen, head, tail, size, count, cooksize;
1263         unsigned char *buf;
1264         unsigned char __iomem *shbuf;
1265         unsigned long flags;
1266
1267         cooksize = stli_txcooksize;
1268         cooktty = stli_txcooktty;
1269         stli_txcooksize = 0;
1270         stli_txcookrealsize = 0;
1271         stli_txcooktty = NULL;
1272
1273         if (cooktty == NULL)
1274                 return;
1275         if (tty != cooktty)
1276                 tty = cooktty;
1277         if (cooksize == 0)
1278                 return;
1279
1280         portp = tty->driver_data;
1281         if (portp == NULL)
1282                 return;
1283         if (portp->brdnr >= stli_nrbrds)
1284                 return;
1285         brdp = stli_brds[portp->brdnr];
1286         if (brdp == NULL)
1287                 return;
1288
1289         spin_lock_irqsave(&brd_lock, flags);
1290         EBRDENABLE(brdp);
1291
1292         ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1293         head = (unsigned int) readw(&ap->txq.head);
1294         tail = (unsigned int) readw(&ap->txq.tail);
1295         if (tail != ((unsigned int) readw(&ap->txq.tail)))
1296                 tail = (unsigned int) readw(&ap->txq.tail);
1297         size = portp->txsize;
1298         if (head >= tail) {
1299                 len = size - (head - tail) - 1;
1300                 stlen = size - head;
1301         } else {
1302                 len = tail - head - 1;
1303                 stlen = len;
1304         }
1305
1306         len = min(len, cooksize);
1307         count = 0;
1308         shbuf = EBRDGETMEMPTR(brdp, portp->txoffset);
1309         buf = stli_txcookbuf;
1310
1311         while (len > 0) {
1312                 stlen = min(len, stlen);
1313                 memcpy_toio(shbuf + head, buf, stlen);
1314                 buf += stlen;
1315                 len -= stlen;
1316                 count += stlen;
1317                 head += stlen;
1318                 if (head >= size) {
1319                         head = 0;
1320                         stlen = tail;
1321                 }
1322         }
1323
1324         ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
1325         writew(head, &ap->txq.head);
1326
1327         if (test_bit(ST_TXBUSY, &portp->state)) {
1328                 if (readl(&ap->changed.data) & DT_TXEMPTY)
1329                         writel(readl(&ap->changed.data) & ~DT_TXEMPTY, &ap->changed.data);
1330         }
1331         hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1332         bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
1333                 portp->portidx;
1334         writeb(readb(bits) | portp->portbit, bits);
1335         set_bit(ST_TXBUSY, &portp->state);
1336
1337         EBRDDISABLE(brdp);
1338         spin_unlock_irqrestore(&brd_lock, flags);
1339 }
1340
1341 /*****************************************************************************/
1342
1343 static int stli_writeroom(struct tty_struct *tty)
1344 {
1345         cdkasyrq_t __iomem *rp;
1346         struct stliport *portp;
1347         struct stlibrd *brdp;
1348         unsigned int head, tail, len;
1349         unsigned long flags;
1350
1351         if (tty == stli_txcooktty) {
1352                 if (stli_txcookrealsize != 0) {
1353                         len = stli_txcookrealsize - stli_txcooksize;
1354                         return len;
1355                 }
1356         }
1357
1358         portp = tty->driver_data;
1359         if (portp == NULL)
1360                 return 0;
1361         if (portp->brdnr >= stli_nrbrds)
1362                 return 0;
1363         brdp = stli_brds[portp->brdnr];
1364         if (brdp == NULL)
1365                 return 0;
1366
1367         spin_lock_irqsave(&brd_lock, flags);
1368         EBRDENABLE(brdp);
1369         rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->txq;
1370         head = (unsigned int) readw(&rp->head);
1371         tail = (unsigned int) readw(&rp->tail);
1372         if (tail != ((unsigned int) readw(&rp->tail)))
1373                 tail = (unsigned int) readw(&rp->tail);
1374         len = (head >= tail) ? (portp->txsize - (head - tail)) : (tail - head);
1375         len--;
1376         EBRDDISABLE(brdp);
1377         spin_unlock_irqrestore(&brd_lock, flags);
1378
1379         if (tty == stli_txcooktty) {
1380                 stli_txcookrealsize = len;
1381                 len -= stli_txcooksize;
1382         }
1383         return len;
1384 }
1385
1386 /*****************************************************************************/
1387
1388 /*
1389  *      Return the number of characters in the transmit buffer. Normally we
1390  *      will return the number of chars in the shared memory ring queue.
1391  *      We need to kludge around the case where the shared memory buffer is
1392  *      empty but not all characters have drained yet, for this case just
1393  *      return that there is 1 character in the buffer!
1394  */
1395
1396 static int stli_charsinbuffer(struct tty_struct *tty)
1397 {
1398         cdkasyrq_t __iomem *rp;
1399         struct stliport *portp;
1400         struct stlibrd *brdp;
1401         unsigned int head, tail, len;
1402         unsigned long flags;
1403
1404         if (tty == stli_txcooktty)
1405                 stli_flushchars(tty);
1406         portp = tty->driver_data;
1407         if (portp == NULL)
1408                 return 0;
1409         if (portp->brdnr >= stli_nrbrds)
1410                 return 0;
1411         brdp = stli_brds[portp->brdnr];
1412         if (brdp == NULL)
1413                 return 0;
1414
1415         spin_lock_irqsave(&brd_lock, flags);
1416         EBRDENABLE(brdp);
1417         rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->txq;
1418         head = (unsigned int) readw(&rp->head);
1419         tail = (unsigned int) readw(&rp->tail);
1420         if (tail != ((unsigned int) readw(&rp->tail)))
1421                 tail = (unsigned int) readw(&rp->tail);
1422         len = (head >= tail) ? (head - tail) : (portp->txsize - (tail - head));
1423         if ((len == 0) && test_bit(ST_TXBUSY, &portp->state))
1424                 len = 1;
1425         EBRDDISABLE(brdp);
1426         spin_unlock_irqrestore(&brd_lock, flags);
1427
1428         return len;
1429 }
1430
1431 /*****************************************************************************/
1432
1433 /*
1434  *      Generate the serial struct info.
1435  */
1436
1437 static int stli_getserial(struct stliport *portp, struct serial_struct __user *sp)
1438 {
1439         struct serial_struct sio;
1440         struct stlibrd *brdp;
1441
1442         memset(&sio, 0, sizeof(struct serial_struct));
1443         sio.type = PORT_UNKNOWN;
1444         sio.line = portp->portnr;
1445         sio.irq = 0;
1446         sio.flags = portp->port.flags;
1447         sio.baud_base = portp->baud_base;
1448         sio.close_delay = portp->port.close_delay;
1449         sio.closing_wait = portp->closing_wait;
1450         sio.custom_divisor = portp->custom_divisor;
1451         sio.xmit_fifo_size = 0;
1452         sio.hub6 = 0;
1453
1454         brdp = stli_brds[portp->brdnr];
1455         if (brdp != NULL)
1456                 sio.port = brdp->iobase;
1457
1458         return copy_to_user(sp, &sio, sizeof(struct serial_struct)) ?
1459                         -EFAULT : 0;
1460 }
1461
1462 /*****************************************************************************/
1463
1464 /*
1465  *      Set port according to the serial struct info.
1466  *      At this point we do not do any auto-configure stuff, so we will
1467  *      just quietly ignore any requests to change irq, etc.
1468  */
1469
1470 static int stli_setserial(struct tty_struct *tty, struct serial_struct __user *sp)
1471 {
1472         struct serial_struct sio;
1473         int rc;
1474         struct stliport *portp = tty->driver_data;
1475
1476         if (copy_from_user(&sio, sp, sizeof(struct serial_struct)))
1477                 return -EFAULT;
1478         if (!capable(CAP_SYS_ADMIN)) {
1479                 if ((sio.baud_base != portp->baud_base) ||
1480                     (sio.close_delay != portp->port.close_delay) ||
1481                     ((sio.flags & ~ASYNC_USR_MASK) !=
1482                     (portp->port.flags & ~ASYNC_USR_MASK)))
1483                         return -EPERM;
1484         }
1485
1486         portp->port.flags = (portp->port.flags & ~ASYNC_USR_MASK) |
1487                 (sio.flags & ASYNC_USR_MASK);
1488         portp->baud_base = sio.baud_base;
1489         portp->port.close_delay = sio.close_delay;
1490         portp->closing_wait = sio.closing_wait;
1491         portp->custom_divisor = sio.custom_divisor;
1492
1493         if ((rc = stli_setport(tty)) < 0)
1494                 return rc;
1495         return 0;
1496 }
1497
1498 /*****************************************************************************/
1499
1500 static int stli_tiocmget(struct tty_struct *tty, struct file *file)
1501 {
1502         struct stliport *portp = tty->driver_data;
1503         struct stlibrd *brdp;
1504         int rc;
1505
1506         if (portp == NULL)
1507                 return -ENODEV;
1508         if (portp->brdnr >= stli_nrbrds)
1509                 return 0;
1510         brdp = stli_brds[portp->brdnr];
1511         if (brdp == NULL)
1512                 return 0;
1513         if (tty->flags & (1 << TTY_IO_ERROR))
1514                 return -EIO;
1515
1516         if ((rc = stli_cmdwait(brdp, portp, A_GETSIGNALS,
1517                                &portp->asig, sizeof(asysigs_t), 1)) < 0)
1518                 return rc;
1519
1520         return stli_mktiocm(portp->asig.sigvalue);
1521 }
1522
1523 static int stli_tiocmset(struct tty_struct *tty, struct file *file,
1524                          unsigned int set, unsigned int clear)
1525 {
1526         struct stliport *portp = tty->driver_data;
1527         struct stlibrd *brdp;
1528         int rts = -1, dtr = -1;
1529
1530         if (portp == NULL)
1531                 return -ENODEV;
1532         if (portp->brdnr >= stli_nrbrds)
1533                 return 0;
1534         brdp = stli_brds[portp->brdnr];
1535         if (brdp == NULL)
1536                 return 0;
1537         if (tty->flags & (1 << TTY_IO_ERROR))
1538                 return -EIO;
1539
1540         if (set & TIOCM_RTS)
1541                 rts = 1;
1542         if (set & TIOCM_DTR)
1543                 dtr = 1;
1544         if (clear & TIOCM_RTS)
1545                 rts = 0;
1546         if (clear & TIOCM_DTR)
1547                 dtr = 0;
1548
1549         stli_mkasysigs(&portp->asig, dtr, rts);
1550
1551         return stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
1552                             sizeof(asysigs_t), 0);
1553 }
1554
1555 static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
1556 {
1557         struct stliport *portp;
1558         struct stlibrd *brdp;
1559         int rc;
1560         void __user *argp = (void __user *)arg;
1561
1562         portp = tty->driver_data;
1563         if (portp == NULL)
1564                 return -ENODEV;
1565         if (portp->brdnr >= stli_nrbrds)
1566                 return 0;
1567         brdp = stli_brds[portp->brdnr];
1568         if (brdp == NULL)
1569                 return 0;
1570
1571         if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
1572             (cmd != COM_GETPORTSTATS) && (cmd != COM_CLRPORTSTATS)) {
1573                 if (tty->flags & (1 << TTY_IO_ERROR))
1574                         return -EIO;
1575         }
1576
1577         rc = 0;
1578
1579         switch (cmd) {
1580         case TIOCGSERIAL:
1581                 rc = stli_getserial(portp, argp);
1582                 break;
1583         case TIOCSSERIAL:
1584                 rc = stli_setserial(tty, argp);
1585                 break;
1586         case STL_GETPFLAG:
1587                 rc = put_user(portp->pflag, (unsigned __user *)argp);
1588                 break;
1589         case STL_SETPFLAG:
1590                 if ((rc = get_user(portp->pflag, (unsigned __user *)argp)) == 0)
1591                         stli_setport(tty);
1592                 break;
1593         case COM_GETPORTSTATS:
1594                 rc = stli_getportstats(tty, portp, argp);
1595                 break;
1596         case COM_CLRPORTSTATS:
1597                 rc = stli_clrportstats(portp, argp);
1598                 break;
1599         case TIOCSERCONFIG:
1600         case TIOCSERGWILD:
1601         case TIOCSERSWILD:
1602         case TIOCSERGETLSR:
1603         case TIOCSERGSTRUCT:
1604         case TIOCSERGETMULTI:
1605         case TIOCSERSETMULTI:
1606         default:
1607                 rc = -ENOIOCTLCMD;
1608                 break;
1609         }
1610
1611         return rc;
1612 }
1613
1614 /*****************************************************************************/
1615
1616 /*
1617  *      This routine assumes that we have user context and can sleep.
1618  *      Looks like it is true for the current ttys implementation..!!
1619  */
1620
1621 static void stli_settermios(struct tty_struct *tty, struct ktermios *old)
1622 {
1623         struct stliport *portp;
1624         struct stlibrd *brdp;
1625         struct ktermios *tiosp;
1626         asyport_t aport;
1627
1628         portp = tty->driver_data;
1629         if (portp == NULL)
1630                 return;
1631         if (portp->brdnr >= stli_nrbrds)
1632                 return;
1633         brdp = stli_brds[portp->brdnr];
1634         if (brdp == NULL)
1635                 return;
1636
1637         tiosp = tty->termios;
1638
1639         stli_mkasyport(tty, portp, &aport, tiosp);
1640         stli_cmdwait(brdp, portp, A_SETPORT, &aport, sizeof(asyport_t), 0);
1641         stli_mkasysigs(&portp->asig, ((tiosp->c_cflag & CBAUD) ? 1 : 0), -1);
1642         stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
1643                 sizeof(asysigs_t), 0);
1644         if ((old->c_cflag & CRTSCTS) && ((tiosp->c_cflag & CRTSCTS) == 0))
1645                 tty->hw_stopped = 0;
1646         if (((old->c_cflag & CLOCAL) == 0) && (tiosp->c_cflag & CLOCAL))
1647                 wake_up_interruptible(&portp->port.open_wait);
1648 }
1649
1650 /*****************************************************************************/
1651
1652 /*
1653  *      Attempt to flow control who ever is sending us data. We won't really
1654  *      do any flow control action here. We can't directly, and even if we
1655  *      wanted to we would have to send a command to the slave. The slave
1656  *      knows how to flow control, and will do so when its buffers reach its
1657  *      internal high water marks. So what we will do is set a local state
1658  *      bit that will stop us sending any RX data up from the poll routine
1659  *      (which is the place where RX data from the slave is handled).
1660  */
1661
1662 static void stli_throttle(struct tty_struct *tty)
1663 {
1664         struct stliport *portp = tty->driver_data;
1665         if (portp == NULL)
1666                 return;
1667         set_bit(ST_RXSTOP, &portp->state);
1668 }
1669
1670 /*****************************************************************************/
1671
1672 /*
1673  *      Unflow control the device sending us data... That means that all
1674  *      we have to do is clear the RXSTOP state bit. The next poll call
1675  *      will then be able to pass the RX data back up.
1676  */
1677
1678 static void stli_unthrottle(struct tty_struct *tty)
1679 {
1680         struct stliport *portp = tty->driver_data;
1681         if (portp == NULL)
1682                 return;
1683         clear_bit(ST_RXSTOP, &portp->state);
1684 }
1685
1686 /*****************************************************************************/
1687
1688 /*
1689  *      Stop the transmitter.
1690  */
1691
1692 static void stli_stop(struct tty_struct *tty)
1693 {
1694 }
1695
1696 /*****************************************************************************/
1697
1698 /*
1699  *      Start the transmitter again.
1700  */
1701
1702 static void stli_start(struct tty_struct *tty)
1703 {
1704 }
1705
1706 /*****************************************************************************/
1707
1708
1709 /*
1710  *      Hangup this port. This is pretty much like closing the port, only
1711  *      a little more brutal. No waiting for data to drain. Shutdown the
1712  *      port and maybe drop signals. This is rather tricky really. We want
1713  *      to close the port as well.
1714  */
1715
1716 static void stli_hangup(struct tty_struct *tty)
1717 {
1718         struct stliport *portp = tty->driver_data;
1719         tty_port_hangup(&portp->port);
1720 }
1721
1722 /*****************************************************************************/
1723
1724 /*
1725  *      Flush characters from the lower buffer. We may not have user context
1726  *      so we cannot sleep waiting for it to complete. Also we need to check
1727  *      if there is chars for this port in the TX cook buffer, and flush them
1728  *      as well.
1729  */
1730
1731 static void stli_flushbuffer(struct tty_struct *tty)
1732 {
1733         struct stliport *portp;
1734         struct stlibrd *brdp;
1735         unsigned long ftype, flags;
1736
1737         portp = tty->driver_data;
1738         if (portp == NULL)
1739                 return;
1740         if (portp->brdnr >= stli_nrbrds)
1741                 return;
1742         brdp = stli_brds[portp->brdnr];
1743         if (brdp == NULL)
1744                 return;
1745
1746         spin_lock_irqsave(&brd_lock, flags);
1747         if (tty == stli_txcooktty) {
1748                 stli_txcooktty = NULL;
1749                 stli_txcooksize = 0;
1750                 stli_txcookrealsize = 0;
1751         }
1752         if (test_bit(ST_CMDING, &portp->state)) {
1753                 set_bit(ST_DOFLUSHTX, &portp->state);
1754         } else {
1755                 ftype = FLUSHTX;
1756                 if (test_bit(ST_DOFLUSHRX, &portp->state)) {
1757                         ftype |= FLUSHRX;
1758                         clear_bit(ST_DOFLUSHRX, &portp->state);
1759                 }
1760                 __stli_sendcmd(brdp, portp, A_FLUSH, &ftype, sizeof(u32), 0);
1761         }
1762         spin_unlock_irqrestore(&brd_lock, flags);
1763         tty_wakeup(tty);
1764 }
1765
1766 /*****************************************************************************/
1767
1768 static int stli_breakctl(struct tty_struct *tty, int state)
1769 {
1770         struct stlibrd  *brdp;
1771         struct stliport *portp;
1772         long            arg;
1773
1774         portp = tty->driver_data;
1775         if (portp == NULL)
1776                 return -EINVAL;
1777         if (portp->brdnr >= stli_nrbrds)
1778                 return -EINVAL;
1779         brdp = stli_brds[portp->brdnr];
1780         if (brdp == NULL)
1781                 return -EINVAL;
1782
1783         arg = (state == -1) ? BREAKON : BREAKOFF;
1784         stli_cmdwait(brdp, portp, A_BREAK, &arg, sizeof(long), 0);
1785         return 0;
1786 }
1787
1788 /*****************************************************************************/
1789
1790 static void stli_waituntilsent(struct tty_struct *tty, int timeout)
1791 {
1792         struct stliport *portp;
1793         unsigned long tend;
1794
1795         portp = tty->driver_data;
1796         if (portp == NULL)
1797                 return;
1798
1799         if (timeout == 0)
1800                 timeout = HZ;
1801         tend = jiffies + timeout;
1802
1803         while (test_bit(ST_TXBUSY, &portp->state)) {
1804                 if (signal_pending(current))
1805                         break;
1806                 msleep_interruptible(20);
1807                 if (time_after_eq(jiffies, tend))
1808                         break;
1809         }
1810 }
1811
1812 /*****************************************************************************/
1813
1814 static void stli_sendxchar(struct tty_struct *tty, char ch)
1815 {
1816         struct stlibrd  *brdp;
1817         struct stliport *portp;
1818         asyctrl_t       actrl;
1819
1820         portp = tty->driver_data;
1821         if (portp == NULL)
1822                 return;
1823         if (portp->brdnr >= stli_nrbrds)
1824                 return;
1825         brdp = stli_brds[portp->brdnr];
1826         if (brdp == NULL)
1827                 return;
1828
1829         memset(&actrl, 0, sizeof(asyctrl_t));
1830         if (ch == STOP_CHAR(tty)) {
1831                 actrl.rxctrl = CT_STOPFLOW;
1832         } else if (ch == START_CHAR(tty)) {
1833                 actrl.rxctrl = CT_STARTFLOW;
1834         } else {
1835                 actrl.txctrl = CT_SENDCHR;
1836                 actrl.tximdch = ch;
1837         }
1838         stli_cmdwait(brdp, portp, A_PORTCTRL, &actrl, sizeof(asyctrl_t), 0);
1839 }
1840
1841 static void stli_portinfo(struct seq_file *m, struct stlibrd *brdp, struct stliport *portp, int portnr)
1842 {
1843         char *uart;
1844         int rc;
1845
1846         rc = stli_portcmdstats(NULL, portp);
1847
1848         uart = "UNKNOWN";
1849         if (brdp->state & BST_STARTED) {
1850                 switch (stli_comstats.hwid) {
1851                 case 0: uart = "2681"; break;
1852                 case 1: uart = "SC26198"; break;
1853                 default:uart = "CD1400"; break;
1854                 }
1855         }
1856         seq_printf(m, "%d: uart:%s ", portnr, uart);
1857
1858         if ((brdp->state & BST_STARTED) && (rc >= 0)) {
1859                 char sep;
1860
1861                 seq_printf(m, "tx:%d rx:%d", (int) stli_comstats.txtotal,
1862                         (int) stli_comstats.rxtotal);
1863
1864                 if (stli_comstats.rxframing)
1865                         seq_printf(m, " fe:%d",
1866                                 (int) stli_comstats.rxframing);
1867                 if (stli_comstats.rxparity)
1868                         seq_printf(m, " pe:%d",
1869                                 (int) stli_comstats.rxparity);
1870                 if (stli_comstats.rxbreaks)
1871                         seq_printf(m, " brk:%d",
1872                                 (int) stli_comstats.rxbreaks);
1873                 if (stli_comstats.rxoverrun)
1874                         seq_printf(m, " oe:%d",
1875                                 (int) stli_comstats.rxoverrun);
1876
1877                 sep = ' ';
1878                 if (stli_comstats.signals & TIOCM_RTS) {
1879                         seq_printf(m, "%c%s", sep, "RTS");
1880                         sep = '|';
1881                 }
1882                 if (stli_comstats.signals & TIOCM_CTS) {
1883                         seq_printf(m, "%c%s", sep, "CTS");
1884                         sep = '|';
1885                 }
1886                 if (stli_comstats.signals & TIOCM_DTR) {
1887                         seq_printf(m, "%c%s", sep, "DTR");
1888                         sep = '|';
1889                 }
1890                 if (stli_comstats.signals & TIOCM_CD) {
1891                         seq_printf(m, "%c%s", sep, "DCD");
1892                         sep = '|';
1893                 }
1894                 if (stli_comstats.signals & TIOCM_DSR) {
1895                         seq_printf(m, "%c%s", sep, "DSR");
1896                         sep = '|';
1897                 }
1898         }
1899         seq_putc(m, '\n');
1900 }
1901
1902 /*****************************************************************************/
1903
1904 /*
1905  *      Port info, read from the /proc file system.
1906  */
1907
1908 static int stli_proc_show(struct seq_file *m, void *v)
1909 {
1910         struct stlibrd *brdp;
1911         struct stliport *portp;
1912         unsigned int brdnr, portnr, totalport;
1913
1914         totalport = 0;
1915
1916         seq_printf(m, "%s: version %s\n", stli_drvtitle, stli_drvversion);
1917
1918 /*
1919  *      We scan through for each board, panel and port. The offset is
1920  *      calculated on the fly, and irrelevant ports are skipped.
1921  */
1922         for (brdnr = 0; (brdnr < stli_nrbrds); brdnr++) {
1923                 brdp = stli_brds[brdnr];
1924                 if (brdp == NULL)
1925                         continue;
1926                 if (brdp->state == 0)
1927                         continue;
1928
1929                 totalport = brdnr * STL_MAXPORTS;
1930                 for (portnr = 0; (portnr < brdp->nrports); portnr++,
1931                     totalport++) {
1932                         portp = brdp->ports[portnr];
1933                         if (portp == NULL)
1934                                 continue;
1935                         stli_portinfo(m, brdp, portp, totalport);
1936                 }
1937         }
1938         return 0;
1939 }
1940
1941 static int stli_proc_open(struct inode *inode, struct file *file)
1942 {
1943         return single_open(file, stli_proc_show, NULL);
1944 }
1945
1946 static const struct file_operations stli_proc_fops = {
1947         .owner          = THIS_MODULE,
1948         .open           = stli_proc_open,
1949         .read           = seq_read,
1950         .llseek         = seq_lseek,
1951         .release        = single_release,
1952 };
1953
1954 /*****************************************************************************/
1955
1956 /*
1957  *      Generic send command routine. This will send a message to the slave,
1958  *      of the specified type with the specified argument. Must be very
1959  *      careful of data that will be copied out from shared memory -
1960  *      containing command results. The command completion is all done from
1961  *      a poll routine that does not have user context. Therefore you cannot
1962  *      copy back directly into user space, or to the kernel stack of a
1963  *      process. This routine does not sleep, so can be called from anywhere.
1964  *
1965  *      The caller must hold the brd_lock (see also stli_sendcmd the usual
1966  *      entry point)
1967  */
1968
1969 static void __stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
1970 {
1971         cdkhdr_t __iomem *hdrp;
1972         cdkctrl_t __iomem *cp;
1973         unsigned char __iomem *bits;
1974
1975         if (test_bit(ST_CMDING, &portp->state)) {
1976                 printk(KERN_ERR "istallion: command already busy, cmd=%x!\n",
1977                                 (int) cmd);
1978                 return;
1979         }
1980
1981         EBRDENABLE(brdp);
1982         cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
1983         if (size > 0) {
1984                 memcpy_toio((void __iomem *) &(cp->args[0]), arg, size);
1985                 if (copyback) {
1986                         portp->argp = arg;
1987                         portp->argsize = size;
1988                 }
1989         }
1990         writel(0, &cp->status);
1991         writel(cmd, &cp->cmd);
1992         hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
1993         bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
1994                 portp->portidx;
1995         writeb(readb(bits) | portp->portbit, bits);
1996         set_bit(ST_CMDING, &portp->state);
1997         EBRDDISABLE(brdp);
1998 }
1999
2000 static void stli_sendcmd(struct stlibrd *brdp, struct stliport *portp, unsigned long cmd, void *arg, int size, int copyback)
2001 {
2002         unsigned long           flags;
2003
2004         spin_lock_irqsave(&brd_lock, flags);
2005         __stli_sendcmd(brdp, portp, cmd, arg, size, copyback);
2006         spin_unlock_irqrestore(&brd_lock, flags);
2007 }
2008
2009 /*****************************************************************************/
2010
2011 /*
2012  *      Read data from shared memory. This assumes that the shared memory
2013  *      is enabled and that interrupts are off. Basically we just empty out
2014  *      the shared memory buffer into the tty buffer. Must be careful to
2015  *      handle the case where we fill up the tty buffer, but still have
2016  *      more chars to unload.
2017  */
2018
2019 static void stli_read(struct stlibrd *brdp, struct stliport *portp)
2020 {
2021         cdkasyrq_t __iomem *rp;
2022         char __iomem *shbuf;
2023         struct tty_struct       *tty;
2024         unsigned int head, tail, size;
2025         unsigned int len, stlen;
2026
2027         if (test_bit(ST_RXSTOP, &portp->state))
2028                 return;
2029         tty = tty_port_tty_get(&portp->port);
2030         if (tty == NULL)
2031                 return;
2032
2033         rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->rxq;
2034         head = (unsigned int) readw(&rp->head);
2035         if (head != ((unsigned int) readw(&rp->head)))
2036                 head = (unsigned int) readw(&rp->head);
2037         tail = (unsigned int) readw(&rp->tail);
2038         size = portp->rxsize;
2039         if (head >= tail) {
2040                 len = head - tail;
2041                 stlen = len;
2042         } else {
2043                 len = size - (tail - head);
2044                 stlen = size - tail;
2045         }
2046
2047         len = tty_buffer_request_room(tty, len);
2048
2049         shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->rxoffset);
2050
2051         while (len > 0) {
2052                 unsigned char *cptr;
2053
2054                 stlen = min(len, stlen);
2055                 tty_prepare_flip_string(tty, &cptr, stlen);
2056                 memcpy_fromio(cptr, shbuf + tail, stlen);
2057                 len -= stlen;
2058                 tail += stlen;
2059                 if (tail >= size) {
2060                         tail = 0;
2061                         stlen = head;
2062                 }
2063         }
2064         rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->rxq;
2065         writew(tail, &rp->tail);
2066
2067         if (head != tail)
2068                 set_bit(ST_RXING, &portp->state);
2069
2070         tty_schedule_flip(tty);
2071         tty_kref_put(tty);
2072 }
2073
2074 /*****************************************************************************/
2075
2076 /*
2077  *      Set up and carry out any delayed commands. There is only a small set
2078  *      of slave commands that can be done "off-level". So it is not too
2079  *      difficult to deal with them here.
2080  */
2081
2082 static void stli_dodelaycmd(struct stliport *portp, cdkctrl_t __iomem *cp)
2083 {
2084         int cmd;
2085
2086         if (test_bit(ST_DOSIGS, &portp->state)) {
2087                 if (test_bit(ST_DOFLUSHTX, &portp->state) &&
2088                     test_bit(ST_DOFLUSHRX, &portp->state))
2089                         cmd = A_SETSIGNALSF;
2090                 else if (test_bit(ST_DOFLUSHTX, &portp->state))
2091                         cmd = A_SETSIGNALSFTX;
2092                 else if (test_bit(ST_DOFLUSHRX, &portp->state))
2093                         cmd = A_SETSIGNALSFRX;
2094                 else
2095                         cmd = A_SETSIGNALS;
2096                 clear_bit(ST_DOFLUSHTX, &portp->state);
2097                 clear_bit(ST_DOFLUSHRX, &portp->state);
2098                 clear_bit(ST_DOSIGS, &portp->state);
2099                 memcpy_toio((void __iomem *) &(cp->args[0]), (void *) &portp->asig,
2100                         sizeof(asysigs_t));
2101                 writel(0, &cp->status);
2102                 writel(cmd, &cp->cmd);
2103                 set_bit(ST_CMDING, &portp->state);
2104         } else if (test_bit(ST_DOFLUSHTX, &portp->state) ||
2105             test_bit(ST_DOFLUSHRX, &portp->state)) {
2106                 cmd = ((test_bit(ST_DOFLUSHTX, &portp->state)) ? FLUSHTX : 0);
2107                 cmd |= ((test_bit(ST_DOFLUSHRX, &portp->state)) ? FLUSHRX : 0);
2108                 clear_bit(ST_DOFLUSHTX, &portp->state);
2109                 clear_bit(ST_DOFLUSHRX, &portp->state);
2110                 memcpy_toio((void __iomem *) &(cp->args[0]), (void *) &cmd, sizeof(int));
2111                 writel(0, &cp->status);
2112                 writel(A_FLUSH, &cp->cmd);
2113                 set_bit(ST_CMDING, &portp->state);
2114         }
2115 }
2116
2117 /*****************************************************************************/
2118
2119 /*
2120  *      Host command service checking. This handles commands or messages
2121  *      coming from the slave to the host. Must have board shared memory
2122  *      enabled and interrupts off when called. Notice that by servicing the
2123  *      read data last we don't need to change the shared memory pointer
2124  *      during processing (which is a slow IO operation).
2125  *      Return value indicates if this port is still awaiting actions from
2126  *      the slave (like open, command, or even TX data being sent). If 0
2127  *      then port is still busy, otherwise no longer busy.
2128  */
2129
2130 static int stli_hostcmd(struct stlibrd *brdp, struct stliport *portp)
2131 {
2132         cdkasy_t __iomem *ap;
2133         cdkctrl_t __iomem *cp;
2134         struct tty_struct *tty;
2135         asynotify_t nt;
2136         unsigned long oldsigs;
2137         int rc, donerx;
2138
2139         ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
2140         cp = &ap->ctrl;
2141
2142 /*
2143  *      Check if we are waiting for an open completion message.
2144  */
2145         if (test_bit(ST_OPENING, &portp->state)) {
2146                 rc = readl(&cp->openarg);
2147                 if (readb(&cp->open) == 0 && rc != 0) {
2148                         if (rc > 0)
2149                                 rc--;
2150                         writel(0, &cp->openarg);
2151                         portp->rc = rc;
2152                         clear_bit(ST_OPENING, &portp->state);
2153                         wake_up_interruptible(&portp->raw_wait);
2154                 }
2155         }
2156
2157 /*
2158  *      Check if we are waiting for a close completion message.
2159  */
2160         if (test_bit(ST_CLOSING, &portp->state)) {
2161                 rc = (int) readl(&cp->closearg);
2162                 if (readb(&cp->close) == 0 && rc != 0) {
2163                         if (rc > 0)
2164                                 rc--;
2165                         writel(0, &cp->closearg);
2166                         portp->rc = rc;
2167                         clear_bit(ST_CLOSING, &portp->state);
2168                         wake_up_interruptible(&portp->raw_wait);
2169                 }
2170         }
2171
2172 /*
2173  *      Check if we are waiting for a command completion message. We may
2174  *      need to copy out the command results associated with this command.
2175  */
2176         if (test_bit(ST_CMDING, &portp->state)) {
2177                 rc = readl(&cp->status);
2178                 if (readl(&cp->cmd) == 0 && rc != 0) {
2179                         if (rc > 0)
2180                                 rc--;
2181                         if (portp->argp != NULL) {
2182                                 memcpy_fromio(portp->argp, (void __iomem *) &(cp->args[0]),
2183                                         portp->argsize);
2184                                 portp->argp = NULL;
2185                         }
2186                         writel(0, &cp->status);
2187                         portp->rc = rc;
2188                         clear_bit(ST_CMDING, &portp->state);
2189                         stli_dodelaycmd(portp, cp);
2190                         wake_up_interruptible(&portp->raw_wait);
2191                 }
2192         }
2193
2194 /*
2195  *      Check for any notification messages ready. This includes lots of
2196  *      different types of events - RX chars ready, RX break received,
2197  *      TX data low or empty in the slave, modem signals changed state.
2198  */
2199         donerx = 0;
2200
2201         if (ap->notify) {
2202                 nt = ap->changed;
2203                 ap->notify = 0;
2204                 tty = tty_port_tty_get(&portp->port);
2205
2206                 if (nt.signal & SG_DCD) {
2207                         oldsigs = portp->sigs;
2208                         portp->sigs = stli_mktiocm(nt.sigvalue);
2209                         clear_bit(ST_GETSIGS, &portp->state);
2210                         if ((portp->sigs & TIOCM_CD) &&
2211                             ((oldsigs & TIOCM_CD) == 0))
2212                                 wake_up_interruptible(&portp->port.open_wait);
2213                         if ((oldsigs & TIOCM_CD) &&
2214                             ((portp->sigs & TIOCM_CD) == 0)) {
2215                                 if (portp->port.flags & ASYNC_CHECK_CD) {
2216                                         if (tty)
2217                                                 tty_hangup(tty);
2218                                 }
2219                         }
2220                 }
2221
2222                 if (nt.data & DT_TXEMPTY)
2223                         clear_bit(ST_TXBUSY, &portp->state);
2224                 if (nt.data & (DT_TXEMPTY | DT_TXLOW)) {
2225                         if (tty != NULL) {
2226                                 tty_wakeup(tty);
2227                                 EBRDENABLE(brdp);
2228                         }
2229                 }
2230
2231                 if ((nt.data & DT_RXBREAK) && (portp->rxmarkmsk & BRKINT)) {
2232                         if (tty != NULL) {
2233                                 tty_insert_flip_char(tty, 0, TTY_BREAK);
2234                                 if (portp->port.flags & ASYNC_SAK) {
2235                                         do_SAK(tty);
2236                                         EBRDENABLE(brdp);
2237                                 }
2238                                 tty_schedule_flip(tty);
2239                         }
2240                 }
2241                 tty_kref_put(tty);
2242
2243                 if (nt.data & DT_RXBUSY) {
2244                         donerx++;
2245                         stli_read(brdp, portp);
2246                 }
2247         }
2248
2249 /*
2250  *      It might seem odd that we are checking for more RX chars here.
2251  *      But, we need to handle the case where the tty buffer was previously
2252  *      filled, but we had more characters to pass up. The slave will not
2253  *      send any more RX notify messages until the RX buffer has been emptied.
2254  *      But it will leave the service bits on (since the buffer is not empty).
2255  *      So from here we can try to process more RX chars.
2256  */
2257         if ((!donerx) && test_bit(ST_RXING, &portp->state)) {
2258                 clear_bit(ST_RXING, &portp->state);
2259                 stli_read(brdp, portp);
2260         }
2261
2262         return((test_bit(ST_OPENING, &portp->state) ||
2263                 test_bit(ST_CLOSING, &portp->state) ||
2264                 test_bit(ST_CMDING, &portp->state) ||
2265                 test_bit(ST_TXBUSY, &portp->state) ||
2266                 test_bit(ST_RXING, &portp->state)) ? 0 : 1);
2267 }
2268
2269 /*****************************************************************************/
2270
2271 /*
2272  *      Service all ports on a particular board. Assumes that the boards
2273  *      shared memory is enabled, and that the page pointer is pointed
2274  *      at the cdk header structure.
2275  */
2276
2277 static void stli_brdpoll(struct stlibrd *brdp, cdkhdr_t __iomem *hdrp)
2278 {
2279         struct stliport *portp;
2280         unsigned char hostbits[(STL_MAXCHANS / 8) + 1];
2281         unsigned char slavebits[(STL_MAXCHANS / 8) + 1];
2282         unsigned char __iomem *slavep;
2283         int bitpos, bitat, bitsize;
2284         int channr, nrdevs, slavebitchange;
2285
2286         bitsize = brdp->bitsize;
2287         nrdevs = brdp->nrdevs;
2288
2289 /*
2290  *      Check if slave wants any service. Basically we try to do as
2291  *      little work as possible here. There are 2 levels of service
2292  *      bits. So if there is nothing to do we bail early. We check
2293  *      8 service bits at a time in the inner loop, so we can bypass
2294  *      the lot if none of them want service.
2295  */
2296         memcpy_fromio(&hostbits[0], (((unsigned char __iomem *) hdrp) + brdp->hostoffset),
2297                 bitsize);
2298
2299         memset(&slavebits[0], 0, bitsize);
2300         slavebitchange = 0;
2301
2302         for (bitpos = 0; (bitpos < bitsize); bitpos++) {
2303                 if (hostbits[bitpos] == 0)
2304                         continue;
2305                 channr = bitpos * 8;
2306                 for (bitat = 0x1; (channr < nrdevs); channr++, bitat <<= 1) {
2307                         if (hostbits[bitpos] & bitat) {
2308                                 portp = brdp->ports[(channr - 1)];
2309                                 if (stli_hostcmd(brdp, portp)) {
2310                                         slavebitchange++;
2311                                         slavebits[bitpos] |= bitat;
2312                                 }
2313                         }
2314                 }
2315         }
2316
2317 /*
2318  *      If any of the ports are no longer busy then update them in the
2319  *      slave request bits. We need to do this after, since a host port
2320  *      service may initiate more slave requests.
2321  */
2322         if (slavebitchange) {
2323                 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
2324                 slavep = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset;
2325                 for (bitpos = 0; (bitpos < bitsize); bitpos++) {
2326                         if (readb(slavebits + bitpos))
2327                                 writeb(readb(slavep + bitpos) & ~slavebits[bitpos], slavebits + bitpos);
2328                 }
2329         }
2330 }
2331
2332 /*****************************************************************************/
2333
2334 /*
2335  *      Driver poll routine. This routine polls the boards in use and passes
2336  *      messages back up to host when necessary. This is actually very
2337  *      CPU efficient, since we will always have the kernel poll clock, it
2338  *      adds only a few cycles when idle (since board service can be
2339  *      determined very easily), but when loaded generates no interrupts
2340  *      (with their expensive associated context change).
2341  */
2342
2343 static void stli_poll(unsigned long arg)
2344 {
2345         cdkhdr_t __iomem *hdrp;
2346         struct stlibrd *brdp;
2347         unsigned int brdnr;
2348
2349         mod_timer(&stli_timerlist, STLI_TIMEOUT);
2350
2351 /*
2352  *      Check each board and do any servicing required.
2353  */
2354         for (brdnr = 0; (brdnr < stli_nrbrds); brdnr++) {
2355                 brdp = stli_brds[brdnr];
2356                 if (brdp == NULL)
2357                         continue;
2358                 if ((brdp->state & BST_STARTED) == 0)
2359                         continue;
2360
2361                 spin_lock(&brd_lock);
2362                 EBRDENABLE(brdp);
2363                 hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
2364                 if (readb(&hdrp->hostreq))
2365                         stli_brdpoll(brdp, hdrp);
2366                 EBRDDISABLE(brdp);
2367                 spin_unlock(&brd_lock);
2368         }
2369 }
2370
2371 /*****************************************************************************/
2372
2373 /*
2374  *      Translate the termios settings into the port setting structure of
2375  *      the slave.
2376  */
2377
2378 static void stli_mkasyport(struct tty_struct *tty, struct stliport *portp,
2379                                 asyport_t *pp, struct ktermios *tiosp)
2380 {
2381         memset(pp, 0, sizeof(asyport_t));
2382
2383 /*
2384  *      Start of by setting the baud, char size, parity and stop bit info.
2385  */
2386         pp->baudout = tty_get_baud_rate(tty);
2387         if ((tiosp->c_cflag & CBAUD) == B38400) {
2388                 if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2389                         pp->baudout = 57600;
2390                 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2391                         pp->baudout = 115200;
2392                 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2393                         pp->baudout = 230400;
2394                 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2395                         pp->baudout = 460800;
2396                 else if ((portp->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
2397                         pp->baudout = (portp->baud_base / portp->custom_divisor);
2398         }
2399         if (pp->baudout > STL_MAXBAUD)
2400                 pp->baudout = STL_MAXBAUD;
2401         pp->baudin = pp->baudout;
2402
2403         switch (tiosp->c_cflag & CSIZE) {
2404         case CS5:
2405                 pp->csize = 5;
2406                 break;
2407         case CS6:
2408                 pp->csize = 6;
2409                 break;
2410         case CS7:
2411                 pp->csize = 7;
2412                 break;
2413         default:
2414                 pp->csize = 8;
2415                 break;
2416         }
2417
2418         if (tiosp->c_cflag & CSTOPB)
2419                 pp->stopbs = PT_STOP2;
2420         else
2421                 pp->stopbs = PT_STOP1;
2422
2423         if (tiosp->c_cflag & PARENB) {
2424                 if (tiosp->c_cflag & PARODD)
2425                         pp->parity = PT_ODDPARITY;
2426                 else
2427                         pp->parity = PT_EVENPARITY;
2428         } else {
2429                 pp->parity = PT_NOPARITY;
2430         }
2431
2432 /*
2433  *      Set up any flow control options enabled.
2434  */
2435         if (tiosp->c_iflag & IXON) {
2436                 pp->flow |= F_IXON;
2437                 if (tiosp->c_iflag & IXANY)
2438                         pp->flow |= F_IXANY;
2439         }
2440         if (tiosp->c_cflag & CRTSCTS)
2441                 pp->flow |= (F_RTSFLOW | F_CTSFLOW);
2442
2443         pp->startin = tiosp->c_cc[VSTART];
2444         pp->stopin = tiosp->c_cc[VSTOP];
2445         pp->startout = tiosp->c_cc[VSTART];
2446         pp->stopout = tiosp->c_cc[VSTOP];
2447
2448 /*
2449  *      Set up the RX char marking mask with those RX error types we must
2450  *      catch. We can get the slave to help us out a little here, it will
2451  *      ignore parity errors and breaks for us, and mark parity errors in
2452  *      the data stream.
2453  */
2454         if (tiosp->c_iflag & IGNPAR)
2455                 pp->iflag |= FI_IGNRXERRS;
2456         if (tiosp->c_iflag & IGNBRK)
2457                 pp->iflag |= FI_IGNBREAK;
2458
2459         portp->rxmarkmsk = 0;
2460         if (tiosp->c_iflag & (INPCK | PARMRK))
2461                 pp->iflag |= FI_1MARKRXERRS;
2462         if (tiosp->c_iflag & BRKINT)
2463                 portp->rxmarkmsk |= BRKINT;
2464
2465 /*
2466  *      Set up clocal processing as required.
2467  */
2468         if (tiosp->c_cflag & CLOCAL)
2469                 portp->port.flags &= ~ASYNC_CHECK_CD;
2470         else
2471                 portp->port.flags |= ASYNC_CHECK_CD;
2472
2473 /*
2474  *      Transfer any persistent flags into the asyport structure.
2475  */
2476         pp->pflag = (portp->pflag & 0xffff);
2477         pp->vmin = (portp->pflag & P_RXIMIN) ? 1 : 0;
2478         pp->vtime = (portp->pflag & P_RXITIME) ? 1 : 0;
2479         pp->cc[1] = (portp->pflag & P_RXTHOLD) ? 1 : 0;
2480 }
2481
2482 /*****************************************************************************/
2483
2484 /*
2485  *      Construct a slave signals structure for setting the DTR and RTS
2486  *      signals as specified.
2487  */
2488
2489 static void stli_mkasysigs(asysigs_t *sp, int dtr, int rts)
2490 {
2491         memset(sp, 0, sizeof(asysigs_t));
2492         if (dtr >= 0) {
2493                 sp->signal |= SG_DTR;
2494                 sp->sigvalue |= ((dtr > 0) ? SG_DTR : 0);
2495         }
2496         if (rts >= 0) {
2497                 sp->signal |= SG_RTS;
2498                 sp->sigvalue |= ((rts > 0) ? SG_RTS : 0);
2499         }
2500 }
2501
2502 /*****************************************************************************/
2503
2504 /*
2505  *      Convert the signals returned from the slave into a local TIOCM type
2506  *      signals value. We keep them locally in TIOCM format.
2507  */
2508
2509 static long stli_mktiocm(unsigned long sigvalue)
2510 {
2511         long    tiocm = 0;
2512         tiocm |= ((sigvalue & SG_DCD) ? TIOCM_CD : 0);
2513         tiocm |= ((sigvalue & SG_CTS) ? TIOCM_CTS : 0);
2514         tiocm |= ((sigvalue & SG_RI) ? TIOCM_RI : 0);
2515         tiocm |= ((sigvalue & SG_DSR) ? TIOCM_DSR : 0);
2516         tiocm |= ((sigvalue & SG_DTR) ? TIOCM_DTR : 0);
2517         tiocm |= ((sigvalue & SG_RTS) ? TIOCM_RTS : 0);
2518         return(tiocm);
2519 }
2520
2521 /*****************************************************************************/
2522
2523 /*
2524  *      All panels and ports actually attached have been worked out. All
2525  *      we need to do here is set up the appropriate per port data structures.
2526  */
2527
2528 static int stli_initports(struct stlibrd *brdp)
2529 {
2530         struct stliport *portp;
2531         unsigned int i, panelnr, panelport;
2532
2533         for (i = 0, panelnr = 0, panelport = 0; (i < brdp->nrports); i++) {
2534                 portp = kzalloc(sizeof(struct stliport), GFP_KERNEL);
2535                 if (!portp) {
2536                         printk(KERN_WARNING "istallion: failed to allocate port structure\n");
2537                         continue;
2538                 }
2539                 tty_port_init(&portp->port);
2540                 portp->port.ops = &stli_port_ops;
2541                 portp->magic = STLI_PORTMAGIC;
2542                 portp->portnr = i;
2543                 portp->brdnr = brdp->brdnr;
2544                 portp->panelnr = panelnr;
2545                 portp->baud_base = STL_BAUDBASE;
2546                 portp->port.close_delay = STL_CLOSEDELAY;
2547                 portp->closing_wait = 30 * HZ;
2548                 init_waitqueue_head(&portp->port.open_wait);
2549                 init_waitqueue_head(&portp->port.close_wait);
2550                 init_waitqueue_head(&portp->raw_wait);
2551                 panelport++;
2552                 if (panelport >= brdp->panels[panelnr]) {
2553                         panelport = 0;
2554                         panelnr++;
2555                 }
2556                 brdp->ports[i] = portp;
2557         }
2558
2559         return 0;
2560 }
2561
2562 /*****************************************************************************/
2563
2564 /*
2565  *      All the following routines are board specific hardware operations.
2566  */
2567
2568 static void stli_ecpinit(struct stlibrd *brdp)
2569 {
2570         unsigned long   memconf;
2571
2572         outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR));
2573         udelay(10);
2574         outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2575         udelay(100);
2576
2577         memconf = (brdp->memaddr & ECP_ATADDRMASK) >> ECP_ATADDRSHFT;
2578         outb(memconf, (brdp->iobase + ECP_ATMEMAR));
2579 }
2580
2581 /*****************************************************************************/
2582
2583 static void stli_ecpenable(struct stlibrd *brdp)
2584 {
2585         outb(ECP_ATENABLE, (brdp->iobase + ECP_ATCONFR));
2586 }
2587
2588 /*****************************************************************************/
2589
2590 static void stli_ecpdisable(struct stlibrd *brdp)
2591 {
2592         outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2593 }
2594
2595 /*****************************************************************************/
2596
2597 static void __iomem *stli_ecpgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2598 {
2599         void __iomem *ptr;
2600         unsigned char val;
2601
2602         if (offset > brdp->memsize) {
2603                 printk(KERN_ERR "istallion: shared memory pointer=%x out of "
2604                                 "range at line=%d(%d), brd=%d\n",
2605                         (int) offset, line, __LINE__, brdp->brdnr);
2606                 ptr = NULL;
2607                 val = 0;
2608         } else {
2609                 ptr = brdp->membase + (offset % ECP_ATPAGESIZE);
2610                 val = (unsigned char) (offset / ECP_ATPAGESIZE);
2611         }
2612         outb(val, (brdp->iobase + ECP_ATMEMPR));
2613         return(ptr);
2614 }
2615
2616 /*****************************************************************************/
2617
2618 static void stli_ecpreset(struct stlibrd *brdp)
2619 {
2620         outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR));
2621         udelay(10);
2622         outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
2623         udelay(500);
2624 }
2625
2626 /*****************************************************************************/
2627
2628 static void stli_ecpintr(struct stlibrd *brdp)
2629 {
2630         outb(0x1, brdp->iobase);
2631 }
2632
2633 /*****************************************************************************/
2634
2635 /*
2636  *      The following set of functions act on ECP EISA boards.
2637  */
2638
2639 static void stli_ecpeiinit(struct stlibrd *brdp)
2640 {
2641         unsigned long   memconf;
2642
2643         outb(0x1, (brdp->iobase + ECP_EIBRDENAB));
2644         outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
2645         udelay(10);
2646         outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2647         udelay(500);
2648
2649         memconf = (brdp->memaddr & ECP_EIADDRMASKL) >> ECP_EIADDRSHFTL;
2650         outb(memconf, (brdp->iobase + ECP_EIMEMARL));
2651         memconf = (brdp->memaddr & ECP_EIADDRMASKH) >> ECP_EIADDRSHFTH;
2652         outb(memconf, (brdp->iobase + ECP_EIMEMARH));
2653 }
2654
2655 /*****************************************************************************/
2656
2657 static void stli_ecpeienable(struct stlibrd *brdp)
2658 {
2659         outb(ECP_EIENABLE, (brdp->iobase + ECP_EICONFR));
2660 }
2661
2662 /*****************************************************************************/
2663
2664 static void stli_ecpeidisable(struct stlibrd *brdp)
2665 {
2666         outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2667 }
2668
2669 /*****************************************************************************/
2670
2671 static void __iomem *stli_ecpeigetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2672 {
2673         void __iomem *ptr;
2674         unsigned char   val;
2675
2676         if (offset > brdp->memsize) {
2677                 printk(KERN_ERR "istallion: shared memory pointer=%x out of "
2678                                 "range at line=%d(%d), brd=%d\n",
2679                         (int) offset, line, __LINE__, brdp->brdnr);
2680                 ptr = NULL;
2681                 val = 0;
2682         } else {
2683                 ptr = brdp->membase + (offset % ECP_EIPAGESIZE);
2684                 if (offset < ECP_EIPAGESIZE)
2685                         val = ECP_EIENABLE;
2686                 else
2687                         val = ECP_EIENABLE | 0x40;
2688         }
2689         outb(val, (brdp->iobase + ECP_EICONFR));
2690         return(ptr);
2691 }
2692
2693 /*****************************************************************************/
2694
2695 static void stli_ecpeireset(struct stlibrd *brdp)
2696 {
2697         outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
2698         udelay(10);
2699         outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
2700         udelay(500);
2701 }
2702
2703 /*****************************************************************************/
2704
2705 /*
2706  *      The following set of functions act on ECP MCA boards.
2707  */
2708
2709 static void stli_ecpmcenable(struct stlibrd *brdp)
2710 {
2711         outb(ECP_MCENABLE, (brdp->iobase + ECP_MCCONFR));
2712 }
2713
2714 /*****************************************************************************/
2715
2716 static void stli_ecpmcdisable(struct stlibrd *brdp)
2717 {
2718         outb(ECP_MCDISABLE, (brdp->iobase + ECP_MCCONFR));
2719 }
2720
2721 /*****************************************************************************/
2722
2723 static void __iomem *stli_ecpmcgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2724 {
2725         void __iomem *ptr;
2726         unsigned char val;
2727
2728         if (offset > brdp->memsize) {
2729                 printk(KERN_ERR "istallion: shared memory pointer=%x out of "
2730                                 "range at line=%d(%d), brd=%d\n",
2731                         (int) offset, line, __LINE__, brdp->brdnr);
2732                 ptr = NULL;
2733                 val = 0;
2734         } else {
2735                 ptr = brdp->membase + (offset % ECP_MCPAGESIZE);
2736                 val = ((unsigned char) (offset / ECP_MCPAGESIZE)) | ECP_MCENABLE;
2737         }
2738         outb(val, (brdp->iobase + ECP_MCCONFR));
2739         return(ptr);
2740 }
2741
2742 /*****************************************************************************/
2743
2744 static void stli_ecpmcreset(struct stlibrd *brdp)
2745 {
2746         outb(ECP_MCSTOP, (brdp->iobase + ECP_MCCONFR));
2747         udelay(10);
2748         outb(ECP_MCDISABLE, (brdp->iobase + ECP_MCCONFR));
2749         udelay(500);
2750 }
2751
2752 /*****************************************************************************/
2753
2754 /*
2755  *      The following set of functions act on ECP PCI boards.
2756  */
2757
2758 static void stli_ecppciinit(struct stlibrd *brdp)
2759 {
2760         outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR));
2761         udelay(10);
2762         outb(0, (brdp->iobase + ECP_PCICONFR));
2763         udelay(500);
2764 }
2765
2766 /*****************************************************************************/
2767
2768 static void __iomem *stli_ecppcigetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2769 {
2770         void __iomem *ptr;
2771         unsigned char   val;
2772
2773         if (offset > brdp->memsize) {
2774                 printk(KERN_ERR "istallion: shared memory pointer=%x out of "
2775                                 "range at line=%d(%d), board=%d\n",
2776                                 (int) offset, line, __LINE__, brdp->brdnr);
2777                 ptr = NULL;
2778                 val = 0;
2779         } else {
2780                 ptr = brdp->membase + (offset % ECP_PCIPAGESIZE);
2781                 val = (offset / ECP_PCIPAGESIZE) << 1;
2782         }
2783         outb(val, (brdp->iobase + ECP_PCICONFR));
2784         return(ptr);
2785 }
2786
2787 /*****************************************************************************/
2788
2789 static void stli_ecppcireset(struct stlibrd *brdp)
2790 {
2791         outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR));
2792         udelay(10);
2793         outb(0, (brdp->iobase + ECP_PCICONFR));
2794         udelay(500);
2795 }
2796
2797 /*****************************************************************************/
2798
2799 /*
2800  *      The following routines act on ONboards.
2801  */
2802
2803 static void stli_onbinit(struct stlibrd *brdp)
2804 {
2805         unsigned long   memconf;
2806
2807         outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR));
2808         udelay(10);
2809         outb(ONB_ATDISABLE, (brdp->iobase + ONB_ATCONFR));
2810         mdelay(1000);
2811
2812         memconf = (brdp->memaddr & ONB_ATADDRMASK) >> ONB_ATADDRSHFT;
2813         outb(memconf, (brdp->iobase + ONB_ATMEMAR));
2814         outb(0x1, brdp->iobase);
2815         mdelay(1);
2816 }
2817
2818 /*****************************************************************************/
2819
2820 static void stli_onbenable(struct stlibrd *brdp)
2821 {
2822         outb((brdp->enabval | ONB_ATENABLE), (brdp->iobase + ONB_ATCONFR));
2823 }
2824
2825 /*****************************************************************************/
2826
2827 static void stli_onbdisable(struct stlibrd *brdp)
2828 {
2829         outb((brdp->enabval | ONB_ATDISABLE), (brdp->iobase + ONB_ATCONFR));
2830 }
2831
2832 /*****************************************************************************/
2833
2834 static void __iomem *stli_onbgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2835 {
2836         void __iomem *ptr;
2837
2838         if (offset > brdp->memsize) {
2839                 printk(KERN_ERR "istallion: shared memory pointer=%x out of "
2840                                 "range at line=%d(%d), brd=%d\n",
2841                                 (int) offset, line, __LINE__, brdp->brdnr);
2842                 ptr = NULL;
2843         } else {
2844                 ptr = brdp->membase + (offset % ONB_ATPAGESIZE);
2845         }
2846         return(ptr);
2847 }
2848
2849 /*****************************************************************************/
2850
2851 static void stli_onbreset(struct stlibrd *brdp)
2852 {
2853         outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR));
2854         udelay(10);
2855         outb(ONB_ATDISABLE, (brdp->iobase + ONB_ATCONFR));
2856         mdelay(1000);
2857 }
2858
2859 /*****************************************************************************/
2860
2861 /*
2862  *      The following routines act on ONboard EISA.
2863  */
2864
2865 static void stli_onbeinit(struct stlibrd *brdp)
2866 {
2867         unsigned long   memconf;
2868
2869         outb(0x1, (brdp->iobase + ONB_EIBRDENAB));
2870         outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
2871         udelay(10);
2872         outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
2873         mdelay(1000);
2874
2875         memconf = (brdp->memaddr & ONB_EIADDRMASKL) >> ONB_EIADDRSHFTL;
2876         outb(memconf, (brdp->iobase + ONB_EIMEMARL));
2877         memconf = (brdp->memaddr & ONB_EIADDRMASKH) >> ONB_EIADDRSHFTH;
2878         outb(memconf, (brdp->iobase + ONB_EIMEMARH));
2879         outb(0x1, brdp->iobase);
2880         mdelay(1);
2881 }
2882
2883 /*****************************************************************************/
2884
2885 static void stli_onbeenable(struct stlibrd *brdp)
2886 {
2887         outb(ONB_EIENABLE, (brdp->iobase + ONB_EICONFR));
2888 }
2889
2890 /*****************************************************************************/
2891
2892 static void stli_onbedisable(struct stlibrd *brdp)
2893 {
2894         outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
2895 }
2896
2897 /*****************************************************************************/
2898
2899 static void __iomem *stli_onbegetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2900 {
2901         void __iomem *ptr;
2902         unsigned char val;
2903
2904         if (offset > brdp->memsize) {
2905                 printk(KERN_ERR "istallion: shared memory pointer=%x out of "
2906                                 "range at line=%d(%d), brd=%d\n",
2907                         (int) offset, line, __LINE__, brdp->brdnr);
2908                 ptr = NULL;
2909                 val = 0;
2910         } else {
2911                 ptr = brdp->membase + (offset % ONB_EIPAGESIZE);
2912                 if (offset < ONB_EIPAGESIZE)
2913                         val = ONB_EIENABLE;
2914                 else
2915                         val = ONB_EIENABLE | 0x40;
2916         }
2917         outb(val, (brdp->iobase + ONB_EICONFR));
2918         return(ptr);
2919 }
2920
2921 /*****************************************************************************/
2922
2923 static void stli_onbereset(struct stlibrd *brdp)
2924 {
2925         outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
2926         udelay(10);
2927         outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
2928         mdelay(1000);
2929 }
2930
2931 /*****************************************************************************/
2932
2933 /*
2934  *      The following routines act on Brumby boards.
2935  */
2936
2937 static void stli_bbyinit(struct stlibrd *brdp)
2938 {
2939         outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR));
2940         udelay(10);
2941         outb(0, (brdp->iobase + BBY_ATCONFR));
2942         mdelay(1000);
2943         outb(0x1, brdp->iobase);
2944         mdelay(1);
2945 }
2946
2947 /*****************************************************************************/
2948
2949 static void __iomem *stli_bbygetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2950 {
2951         void __iomem *ptr;
2952         unsigned char val;
2953
2954         BUG_ON(offset > brdp->memsize);
2955
2956         ptr = brdp->membase + (offset % BBY_PAGESIZE);
2957         val = (unsigned char) (offset / BBY_PAGESIZE);
2958         outb(val, (brdp->iobase + BBY_ATCONFR));
2959         return(ptr);
2960 }
2961
2962 /*****************************************************************************/
2963
2964 static void stli_bbyreset(struct stlibrd *brdp)
2965 {
2966         outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR));
2967         udelay(10);
2968         outb(0, (brdp->iobase + BBY_ATCONFR));
2969         mdelay(1000);
2970 }
2971
2972 /*****************************************************************************/
2973
2974 /*
2975  *      The following routines act on original old Stallion boards.
2976  */
2977
2978 static void stli_stalinit(struct stlibrd *brdp)
2979 {
2980         outb(0x1, brdp->iobase);
2981         mdelay(1000);
2982 }
2983
2984 /*****************************************************************************/
2985
2986 static void __iomem *stli_stalgetmemptr(struct stlibrd *brdp, unsigned long offset, int line)
2987 {
2988         BUG_ON(offset > brdp->memsize);
2989         return brdp->membase + (offset % STAL_PAGESIZE);
2990 }
2991
2992 /*****************************************************************************/
2993
2994 static void stli_stalreset(struct stlibrd *brdp)
2995 {
2996         u32 __iomem *vecp;
2997
2998         vecp = (u32 __iomem *) (brdp->membase + 0x30);
2999         writel(0xffff0000, vecp);
3000         outb(0, brdp->iobase);
3001         mdelay(1000);
3002 }
3003
3004 /*****************************************************************************/
3005
3006 /*
3007  *      Try to find an ECP board and initialize it. This handles only ECP
3008  *      board types.
3009  */
3010
3011 static int stli_initecp(struct stlibrd *brdp)
3012 {
3013         cdkecpsig_t sig;
3014         cdkecpsig_t __iomem *sigsp;
3015         unsigned int status, nxtid;
3016         char *name;
3017         int retval, panelnr, nrports;
3018
3019         if ((brdp->iobase == 0) || (brdp->memaddr == 0)) {
3020                 retval = -ENODEV;
3021                 goto err;
3022         }
3023
3024         brdp->iosize = ECP_IOSIZE;
3025
3026         if (!request_region(brdp->iobase, brdp->iosize, "istallion")) {
3027                 retval = -EIO;
3028                 goto err;
3029         }
3030
3031 /*
3032  *      Based on the specific board type setup the common vars to access
3033  *      and enable shared memory. Set all board specific information now
3034  *      as well.
3035  */
3036         switch (brdp->brdtype) {
3037         case BRD_ECP:
3038                 brdp->memsize = ECP_MEMSIZE;
3039                 brdp->pagesize = ECP_ATPAGESIZE;
3040                 brdp->init = stli_ecpinit;
3041                 brdp->enable = stli_ecpenable;
3042                 brdp->reenable = stli_ecpenable;
3043                 brdp->disable = stli_ecpdisable;
3044                 brdp->getmemptr = stli_ecpgetmemptr;
3045                 brdp->intr = stli_ecpintr;
3046                 brdp->reset = stli_ecpreset;
3047                 name = "serial(EC8/64)";
3048                 break;
3049
3050         case BRD_ECPE:
3051                 brdp->memsize = ECP_MEMSIZE;
3052                 brdp->pagesize = ECP_EIPAGESIZE;
3053                 brdp->init = stli_ecpeiinit;
3054                 brdp->enable = stli_ecpeienable;
3055                 brdp->reenable = stli_ecpeienable;
3056                 brdp->disable = stli_ecpeidisable;
3057                 brdp->getmemptr = stli_ecpeigetmemptr;
3058                 brdp->intr = stli_ecpintr;
3059                 brdp->reset = stli_ecpeireset;
3060                 name = "serial(EC8/64-EI)";
3061                 break;
3062
3063         case BRD_ECPMC:
3064                 brdp->memsize = ECP_MEMSIZE;
3065                 brdp->pagesize = ECP_MCPAGESIZE;
3066                 brdp->init = NULL;
3067                 brdp->enable = stli_ecpmcenable;
3068                 brdp->reenable = stli_ecpmcenable;
3069                 brdp->disable = stli_ecpmcdisable;
3070                 brdp->getmemptr = stli_ecpmcgetmemptr;
3071                 brdp->intr = stli_ecpintr;
3072                 brdp->reset = stli_ecpmcreset;
3073                 name = "serial(EC8/64-MCA)";
3074                 break;
3075
3076         case BRD_ECPPCI:
3077                 brdp->memsize = ECP_PCIMEMSIZE;
3078                 brdp->pagesize = ECP_PCIPAGESIZE;
3079                 brdp->init = stli_ecppciinit;
3080                 brdp->enable = NULL;
3081                 brdp->reenable = NULL;
3082                 brdp->disable = NULL;
3083                 brdp->getmemptr = stli_ecppcigetmemptr;
3084                 brdp->intr = stli_ecpintr;
3085                 brdp->reset = stli_ecppcireset;
3086                 name = "serial(EC/RA-PCI)";
3087                 break;
3088
3089         default:
3090                 retval = -EINVAL;
3091                 goto err_reg;
3092         }
3093
3094 /*
3095  *      The per-board operations structure is all set up, so now let's go
3096  *      and get the board operational. Firstly initialize board configuration
3097  *      registers. Set the memory mapping info so we can get at the boards
3098  *      shared memory.
3099  */
3100         EBRDINIT(brdp);
3101
3102         brdp->membase = ioremap_nocache(brdp->memaddr, brdp->memsize);
3103         if (brdp->membase == NULL) {
3104                 retval = -ENOMEM;
3105                 goto err_reg;
3106         }
3107
3108 /*
3109  *      Now that all specific code is set up, enable the shared memory and
3110  *      look for the a signature area that will tell us exactly what board
3111  *      this is, and what it is connected to it.
3112  */
3113         EBRDENABLE(brdp);
3114         sigsp = (cdkecpsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
3115         memcpy_fromio(&sig, sigsp, sizeof(cdkecpsig_t));
3116         EBRDDISABLE(brdp);
3117
3118         if (sig.magic != cpu_to_le32(ECP_MAGIC)) {
3119                 retval = -ENODEV;
3120                 goto err_unmap;
3121         }
3122
3123 /*
3124  *      Scan through the signature looking at the panels connected to the
3125  *      board. Calculate the total number of ports as we go.
3126  */
3127         for (panelnr = 0, nxtid = 0; (panelnr < STL_MAXPANELS); panelnr++) {
3128                 status = sig.panelid[nxtid];
3129                 if ((status & ECH_PNLIDMASK) != nxtid)
3130                         break;
3131
3132                 brdp->panelids[panelnr] = status;
3133                 nrports = (status & ECH_PNL16PORT) ? 16 : 8;
3134                 if ((nrports == 16) && ((status & ECH_PNLXPID) == 0))
3135                         nxtid++;
3136                 brdp->panels[panelnr] = nrports;
3137                 brdp->nrports += nrports;
3138                 nxtid++;
3139                 brdp->nrpanels++;
3140         }
3141
3142
3143         brdp->state |= BST_FOUND;
3144         return 0;
3145 err_unmap:
3146         iounmap(brdp->membase);
3147         brdp->membase = NULL;
3148 err_reg:
3149         release_region(brdp->iobase, brdp->iosize);
3150 err:
3151         return retval;
3152 }
3153
3154 /*****************************************************************************/
3155
3156 /*
3157  *      Try to find an ONboard, Brumby or Stallion board and initialize it.
3158  *      This handles only these board types.
3159  */
3160
3161 static int stli_initonb(struct stlibrd *brdp)
3162 {
3163         cdkonbsig_t sig;
3164         cdkonbsig_t __iomem *sigsp;
3165         char *name;
3166         int i, retval;
3167
3168 /*
3169  *      Do a basic sanity check on the IO and memory addresses.
3170  */
3171         if (brdp->iobase == 0 || brdp->memaddr == 0) {
3172                 retval = -ENODEV;
3173                 goto err;
3174         }
3175
3176         brdp->iosize = ONB_IOSIZE;
3177
3178         if (!request_region(brdp->iobase, brdp->iosize, "istallion")) {
3179                 retval = -EIO;
3180                 goto err;
3181         }
3182
3183 /*
3184  *      Based on the specific board type setup the common vars to access
3185  *      and enable shared memory. Set all board specific information now
3186  *      as well.
3187  */
3188         switch (brdp->brdtype) {
3189         case BRD_ONBOARD:
3190         case BRD_ONBOARD2:
3191                 brdp->memsize = ONB_MEMSIZE;
3192                 brdp->pagesize = ONB_ATPAGESIZE;
3193                 brdp->init = stli_onbinit;
3194                 brdp->enable = stli_onbenable;
3195                 brdp->reenable = stli_onbenable;
3196                 brdp->disable = stli_onbdisable;
3197                 brdp->getmemptr = stli_onbgetmemptr;
3198                 brdp->intr = stli_ecpintr;
3199                 brdp->reset = stli_onbreset;
3200                 if (brdp->memaddr > 0x100000)
3201                         brdp->enabval = ONB_MEMENABHI;
3202                 else
3203                         brdp->enabval = ONB_MEMENABLO;
3204                 name = "serial(ONBoard)";
3205                 break;
3206
3207         case BRD_ONBOARDE:
3208                 brdp->memsize = ONB_EIMEMSIZE;
3209                 brdp->pagesize = ONB_EIPAGESIZE;
3210                 brdp->init = stli_onbeinit;
3211                 brdp->enable = stli_onbeenable;
3212                 brdp->reenable = stli_onbeenable;
3213                 brdp->disable = stli_onbedisable;
3214                 brdp->getmemptr = stli_onbegetmemptr;
3215                 brdp->intr = stli_ecpintr;
3216                 brdp->reset = stli_onbereset;
3217                 name = "serial(ONBoard/E)";
3218                 break;
3219
3220         case BRD_BRUMBY4:
3221                 brdp->memsize = BBY_MEMSIZE;
3222                 brdp->pagesize = BBY_PAGESIZE;
3223                 brdp->init = stli_bbyinit;
3224                 brdp->enable = NULL;
3225                 brdp->reenable = NULL;
3226                 brdp->disable = NULL;
3227                 brdp->getmemptr = stli_bbygetmemptr;
3228                 brdp->intr = stli_ecpintr;
3229                 brdp->reset = stli_bbyreset;
3230                 name = "serial(Brumby)";
3231                 break;
3232
3233         case BRD_STALLION:
3234                 brdp->memsize = STAL_MEMSIZE;
3235                 brdp->pagesize = STAL_PAGESIZE;
3236                 brdp->init = stli_stalinit;
3237                 brdp->enable = NULL;
3238                 brdp->reenable = NULL;
3239                 brdp->disable = NULL;
3240                 brdp->getmemptr = stli_stalgetmemptr;
3241                 brdp->intr = stli_ecpintr;
3242                 brdp->reset = stli_stalreset;
3243                 name = "serial(Stallion)";
3244                 break;
3245
3246         default:
3247                 retval = -EINVAL;
3248                 goto err_reg;
3249         }
3250
3251 /*
3252  *      The per-board operations structure is all set up, so now let's go
3253  *      and get the board operational. Firstly initialize board configuration
3254  *      registers. Set the memory mapping info so we can get at the boards
3255  *      shared memory.
3256  */
3257         EBRDINIT(brdp);
3258
3259         brdp->membase = ioremap_nocache(brdp->memaddr, brdp->memsize);
3260         if (brdp->membase == NULL) {
3261                 retval = -ENOMEM;
3262                 goto err_reg;
3263         }
3264
3265 /*
3266  *      Now that all specific code is set up, enable the shared memory and
3267  *      look for the a signature area that will tell us exactly what board
3268  *      this is, and how many ports.
3269  */
3270         EBRDENABLE(brdp);
3271         sigsp = (cdkonbsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
3272         memcpy_fromio(&sig, sigsp, sizeof(cdkonbsig_t));
3273         EBRDDISABLE(brdp);
3274
3275         if (sig.magic0 != cpu_to_le16(ONB_MAGIC0) ||
3276             sig.magic1 != cpu_to_le16(ONB_MAGIC1) ||
3277             sig.magic2 != cpu_to_le16(ONB_MAGIC2) ||
3278             sig.magic3 != cpu_to_le16(ONB_MAGIC3)) {
3279                 retval = -ENODEV;
3280                 goto err_unmap;
3281         }
3282
3283 /*
3284  *      Scan through the signature alive mask and calculate how many ports
3285  *      there are on this board.
3286  */
3287         brdp->nrpanels = 1;
3288         if (sig.amask1) {
3289                 brdp->nrports = 32;
3290         } else {
3291                 for (i = 0; (i < 16); i++) {
3292                         if (((sig.amask0 << i) & 0x8000) == 0)
3293                                 break;
3294                 }
3295                 brdp->nrports = i;
3296         }
3297         brdp->panels[0] = brdp->nrports;
3298
3299
3300         brdp->state |= BST_FOUND;
3301         return 0;
3302 err_unmap:
3303         iounmap(brdp->membase);
3304         brdp->membase = NULL;
3305 err_reg:
3306         release_region(brdp->iobase, brdp->iosize);
3307 err:
3308         return retval;
3309 }
3310
3311 /*****************************************************************************/
3312
3313 /*
3314  *      Start up a running board. This routine is only called after the
3315  *      code has been down loaded to the board and is operational. It will
3316  *      read in the memory map, and get the show on the road...
3317  */
3318
3319 static int stli_startbrd(struct stlibrd *brdp)
3320 {
3321         cdkhdr_t __iomem *hdrp;
3322         cdkmem_t __iomem *memp;
3323         cdkasy_t __iomem *ap;
3324         unsigned long flags;
3325         unsigned int portnr, nrdevs, i;
3326         struct stliport *portp;
3327         int rc = 0;
3328         u32 memoff;
3329
3330         spin_lock_irqsave(&brd_lock, flags);
3331         EBRDENABLE(brdp);
3332         hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
3333         nrdevs = hdrp->nrdevs;
3334
3335 #if 0
3336         printk("%s(%d): CDK version %d.%d.%d --> "
3337                 "nrdevs=%d memp=%x hostp=%x slavep=%x\n",
3338                  __FILE__, __LINE__, readb(&hdrp->ver_release), readb(&hdrp->ver_modification),
3339                  readb(&hdrp->ver_fix), nrdevs, (int) readl(&hdrp->memp), readl(&hdrp->hostp),
3340                  readl(&hdrp->slavep));
3341 #endif
3342
3343         if (nrdevs < (brdp->nrports + 1)) {
3344                 printk(KERN_ERR "istallion: slave failed to allocate memory for "
3345                                 "all devices, devices=%d\n", nrdevs);
3346                 brdp->nrports = nrdevs - 1;
3347         }
3348         brdp->nrdevs = nrdevs;
3349         brdp->hostoffset = hdrp->hostp - CDK_CDKADDR;
3350         brdp->slaveoffset = hdrp->slavep - CDK_CDKADDR;
3351         brdp->bitsize = (nrdevs + 7) / 8;
3352         memoff = readl(&hdrp->memp);
3353         if (memoff > brdp->memsize) {
3354                 printk(KERN_ERR "istallion: corrupted shared memory region?\n");
3355                 rc = -EIO;
3356                 goto stli_donestartup;
3357         }
3358         memp = (cdkmem_t __iomem *) EBRDGETMEMPTR(brdp, memoff);
3359         if (readw(&memp->dtype) != TYP_ASYNCTRL) {
3360                 printk(KERN_ERR "istallion: no slave control device found\n");
3361                 goto stli_donestartup;
3362         }
3363         memp++;
3364
3365 /*
3366  *      Cycle through memory allocation of each port. We are guaranteed to
3367  *      have all ports inside the first page of slave window, so no need to
3368  *      change pages while reading memory map.
3369  */
3370         for (i = 1, portnr = 0; (i < nrdevs); i++, portnr++, memp++) {
3371                 if (readw(&memp->dtype) != TYP_ASYNC)
3372                         break;
3373                 portp = brdp->ports[portnr];
3374                 if (portp == NULL)
3375                         break;
3376                 portp->devnr = i;
3377                 portp->addr = readl(&memp->offset);
3378                 portp->reqbit = (unsigned char) (0x1 << (i * 8 / nrdevs));
3379                 portp->portidx = (unsigned char) (i / 8);
3380                 portp->portbit = (unsigned char) (0x1 << (i % 8));
3381         }
3382
3383         writeb(0xff, &hdrp->slavereq);
3384
3385 /*
3386  *      For each port setup a local copy of the RX and TX buffer offsets
3387  *      and sizes. We do this separate from the above, because we need to
3388  *      move the shared memory page...
3389  */
3390         for (i = 1, portnr = 0; (i < nrdevs); i++, portnr++) {
3391                 portp = brdp->ports[portnr];
3392                 if (portp == NULL)
3393                         break;
3394                 if (portp->addr == 0)
3395                         break;
3396                 ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
3397                 if (ap != NULL) {
3398                         portp->rxsize = readw(&ap->rxq.size);
3399                         portp->txsize = readw(&ap->txq.size);
3400                         portp->rxoffset = readl(&ap->rxq.offset);
3401                         portp->txoffset = readl(&ap->txq.offset);
3402                 }
3403         }
3404
3405 stli_donestartup:
3406         EBRDDISABLE(brdp);
3407         spin_unlock_irqrestore(&brd_lock, flags);
3408
3409         if (rc == 0)
3410                 brdp->state |= BST_STARTED;
3411
3412         if (! stli_timeron) {
3413                 stli_timeron++;
3414                 mod_timer(&stli_timerlist, STLI_TIMEOUT);
3415         }
3416
3417         return rc;
3418 }
3419
3420 /*****************************************************************************/
3421
3422 /*
3423  *      Probe and initialize the specified board.
3424  */
3425
3426 static int __devinit stli_brdinit(struct stlibrd *brdp)
3427 {
3428         int retval;
3429
3430         switch (brdp->brdtype) {
3431         case BRD_ECP:
3432         case BRD_ECPE:
3433         case BRD_ECPMC:
3434         case BRD_ECPPCI:
3435                 retval = stli_initecp(brdp);
3436                 break;
3437         case BRD_ONBOARD:
3438         case BRD_ONBOARDE:
3439         case BRD_ONBOARD2:
3440         case BRD_BRUMBY4:
3441         case BRD_STALLION:
3442                 retval = stli_initonb(brdp);
3443                 break;
3444         default:
3445                 printk(KERN_ERR "istallion: board=%d is unknown board "
3446                                 "type=%d\n", brdp->brdnr, brdp->brdtype);
3447                 retval = -ENODEV;
3448         }
3449
3450         if (retval)
3451                 return retval;
3452
3453         stli_initports(brdp);
3454         printk(KERN_INFO "istallion: %s found, board=%d io=%x mem=%x "
3455                 "nrpanels=%d nrports=%d\n", stli_brdnames[brdp->brdtype],
3456                 brdp->brdnr, brdp->iobase, (int) brdp->memaddr,
3457                 brdp->nrpanels, brdp->nrports);
3458         return 0;
3459 }
3460
3461 #if STLI_EISAPROBE != 0
3462 /*****************************************************************************/
3463
3464 /*
3465  *      Probe around trying to find where the EISA boards shared memory
3466  *      might be. This is a bit if hack, but it is the best we can do.
3467  */
3468
3469 static int stli_eisamemprobe(struct stlibrd *brdp)
3470 {
3471         cdkecpsig_t     ecpsig, __iomem *ecpsigp;
3472         cdkonbsig_t     onbsig, __iomem *onbsigp;
3473         int             i, foundit;
3474
3475 /*
3476  *      First up we reset the board, to get it into a known state. There
3477  *      is only 2 board types here we need to worry about. Don;t use the
3478  *      standard board init routine here, it programs up the shared
3479  *      memory address, and we don't know it yet...
3480  */
3481         if (brdp->brdtype == BRD_ECPE) {
3482                 outb(0x1, (brdp->iobase + ECP_EIBRDENAB));
3483                 outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
3484                 udelay(10);
3485                 outb(ECP_EIDISABLE, (brdp->iobase + ECP_EICONFR));
3486                 udelay(500);
3487                 stli_ecpeienable(brdp);
3488         } else if (brdp->brdtype == BRD_ONBOARDE) {
3489                 outb(0x1, (brdp->iobase + ONB_EIBRDENAB));
3490                 outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
3491                 udelay(10);
3492                 outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
3493                 mdelay(100);
3494                 outb(0x1, brdp->iobase);
3495                 mdelay(1);
3496                 stli_onbeenable(brdp);
3497         } else {
3498                 return -ENODEV;
3499         }
3500
3501         foundit = 0;
3502         brdp->memsize = ECP_MEMSIZE;
3503
3504 /*
3505  *      Board shared memory is enabled, so now we have a poke around and
3506  *      see if we can find it.
3507  */
3508         for (i = 0; (i < stli_eisamempsize); i++) {
3509                 brdp->memaddr = stli_eisamemprobeaddrs[i];
3510                 brdp->membase = ioremap_nocache(brdp->memaddr, brdp->memsize);
3511                 if (brdp->membase == NULL)
3512                         continue;
3513
3514                 if (brdp->brdtype == BRD_ECPE) {
3515                         ecpsigp = stli_ecpeigetmemptr(brdp,
3516                                 CDK_SIGADDR, __LINE__);
3517                         memcpy_fromio(&ecpsig, ecpsigp, sizeof(cdkecpsig_t));
3518                         if (ecpsig.magic == cpu_to_le32(ECP_MAGIC))
3519                                 foundit = 1;
3520                 } else {
3521                         onbsigp = (cdkonbsig_t __iomem *) stli_onbegetmemptr(brdp,
3522                                 CDK_SIGADDR, __LINE__);
3523                         memcpy_fromio(&onbsig, onbsigp, sizeof(cdkonbsig_t));
3524                         if ((onbsig.magic0 == cpu_to_le16(ONB_MAGIC0)) &&
3525                             (onbsig.magic1 == cpu_to_le16(ONB_MAGIC1)) &&
3526                             (onbsig.magic2 == cpu_to_le16(ONB_MAGIC2)) &&
3527                             (onbsig.magic3 == cpu_to_le16(ONB_MAGIC3)))
3528                                 foundit = 1;
3529                 }
3530
3531                 iounmap(brdp->membase);
3532                 if (foundit)
3533                         break;
3534         }
3535
3536 /*
3537  *      Regardless of whether we found the shared memory or not we must
3538  *      disable the region. After that return success or failure.
3539  */
3540         if (brdp->brdtype == BRD_ECPE)
3541                 stli_ecpeidisable(brdp);
3542         else
3543                 stli_onbedisable(brdp);
3544
3545         if (! foundit) {
3546                 brdp->memaddr = 0;
3547                 brdp->membase = NULL;
3548                 printk(KERN_ERR "istallion: failed to probe shared memory "
3549                                 "region for %s in EISA slot=%d\n",
3550                         stli_brdnames[brdp->brdtype], (brdp->iobase >> 12));
3551                 return -ENODEV;
3552         }
3553         return 0;
3554 }
3555 #endif
3556
3557 static int stli_getbrdnr(void)
3558 {
3559         unsigned int i;
3560
3561         for (i = 0; i < STL_MAXBRDS; i++) {
3562                 if (!stli_brds[i]) {
3563                         if (i >= stli_nrbrds)
3564                                 stli_nrbrds = i + 1;
3565                         return i;
3566                 }
3567         }
3568         return -1;
3569 }
3570
3571 #if STLI_EISAPROBE != 0
3572 /*****************************************************************************/
3573
3574 /*
3575  *      Probe around and try to find any EISA boards in system. The biggest
3576  *      problem here is finding out what memory address is associated with
3577  *      an EISA board after it is found. The registers of the ECPE and
3578  *      ONboardE are not readable - so we can't read them from there. We
3579  *      don't have access to the EISA CMOS (or EISA BIOS) so we don't
3580  *      actually have any way to find out the real value. The best we can
3581  *      do is go probing around in the usual places hoping we can find it.
3582  */
3583
3584 static int __init stli_findeisabrds(void)
3585 {
3586         struct stlibrd *brdp;
3587         unsigned int iobase, eid, i;
3588         int brdnr, found = 0;
3589
3590 /*
3591  *      Firstly check if this is an EISA system.  If this is not an EISA system then
3592  *      don't bother going any further!
3593  */
3594         if (EISA_bus)
3595                 return 0;
3596
3597 /*
3598  *      Looks like an EISA system, so go searching for EISA boards.
3599  */
3600         for (iobase = 0x1000; (iobase <= 0xc000); iobase += 0x1000) {
3601                 outb(0xff, (iobase + 0xc80));
3602                 eid = inb(iobase + 0xc80);
3603                 eid |= inb(iobase + 0xc81) << 8;
3604                 if (eid != STL_EISAID)
3605                         continue;
3606
3607 /*
3608  *              We have found a board. Need to check if this board was
3609  *              statically configured already (just in case!).
3610  */
3611                 for (i = 0; (i < STL_MAXBRDS); i++) {
3612                         brdp = stli_brds[i];
3613                         if (brdp == NULL)
3614                                 continue;
3615                         if (brdp->iobase == iobase)
3616                                 break;
3617                 }
3618                 if (i < STL_MAXBRDS)
3619                         continue;
3620
3621 /*
3622  *              We have found a Stallion board and it is not configured already.
3623  *              Allocate a board structure and initialize it.
3624  */
3625                 if ((brdp = stli_allocbrd()) == NULL)
3626                         return found ? : -ENOMEM;
3627                 brdnr = stli_getbrdnr();
3628                 if (brdnr < 0)
3629                         return found ? : -ENOMEM;
3630                 brdp->brdnr = (unsigned int)brdnr;
3631                 eid = inb(iobase + 0xc82);
3632                 if (eid == ECP_EISAID)
3633                         brdp->brdtype = BRD_ECPE;
3634                 else if (eid == ONB_EISAID)
3635                         brdp->brdtype = BRD_ONBOARDE;
3636                 else
3637                         brdp->brdtype = BRD_UNKNOWN;
3638                 brdp->iobase = iobase;
3639                 outb(0x1, (iobase + 0xc84));
3640                 if (stli_eisamemprobe(brdp))
3641                         outb(0, (iobase + 0xc84));
3642                 if (stli_brdinit(brdp) < 0) {
3643                         kfree(brdp);
3644                         continue;
3645                 }
3646
3647                 stli_brds[brdp->brdnr] = brdp;
3648                 found++;
3649
3650                 for (i = 0; i < brdp->nrports; i++)
3651                         tty_register_device(stli_serial,
3652                                         brdp->brdnr * STL_MAXPORTS + i, NULL);
3653         }
3654
3655         return found;
3656 }
3657 #else
3658 static inline int stli_findeisabrds(void) { return 0; }
3659 #endif
3660
3661 /*****************************************************************************/
3662
3663 /*
3664  *      Find the next available board number that is free.
3665  */
3666
3667 /*****************************************************************************/
3668
3669 /*
3670  *      We have a Stallion board. Allocate a board structure and
3671  *      initialize it. Read its IO and MEMORY resources from PCI
3672  *      configuration space.
3673  */
3674
3675 static int __devinit stli_pciprobe(struct pci_dev *pdev,
3676                 const struct pci_device_id *ent)
3677 {
3678         struct stlibrd *brdp;
3679         unsigned int i;
3680         int brdnr, retval = -EIO;
3681
3682         retval = pci_enable_device(pdev);
3683         if (retval)
3684                 goto err;
3685         brdp = stli_allocbrd();
3686         if (brdp == NULL) {
3687                 retval = -ENOMEM;
3688                 goto err;
3689         }
3690         mutex_lock(&stli_brdslock);
3691         brdnr = stli_getbrdnr();
3692         if (brdnr < 0) {
3693                 printk(KERN_INFO "istallion: too many boards found, "
3694                         "maximum supported %d\n", STL_MAXBRDS);
3695                 mutex_unlock(&stli_brdslock);
3696                 retval = -EIO;
3697                 goto err_fr;
3698         }
3699         brdp->brdnr = (unsigned int)brdnr;
3700         stli_brds[brdp->brdnr] = brdp;
3701         mutex_unlock(&stli_brdslock);
3702         brdp->brdtype = BRD_ECPPCI;
3703 /*
3704  *      We have all resources from the board, so lets setup the actual
3705  *      board structure now.
3706  */
3707         brdp->iobase = pci_resource_start(pdev, 3);
3708         brdp->memaddr = pci_resource_start(pdev, 2);
3709         retval = stli_brdinit(brdp);
3710         if (retval)
3711                 goto err_null;
3712
3713         brdp->state |= BST_PROBED;
3714         pci_set_drvdata(pdev, brdp);
3715
3716         EBRDENABLE(brdp);
3717         brdp->enable = NULL;
3718         brdp->disable = NULL;
3719
3720         for (i = 0; i < brdp->nrports; i++)
3721                 tty_register_device(stli_serial, brdp->brdnr * STL_MAXPORTS + i,
3722                                 &pdev->dev);
3723
3724         return 0;
3725 err_null:
3726         stli_brds[brdp->brdnr] = NULL;
3727 err_fr:
3728         kfree(brdp);
3729 err:
3730         return retval;
3731 }
3732
3733 static void __devexit stli_pciremove(struct pci_dev *pdev)
3734 {
3735         struct stlibrd *brdp = pci_get_drvdata(pdev);
3736
3737         stli_cleanup_ports(brdp);
3738
3739         iounmap(brdp->membase);
3740         if (brdp->iosize > 0)
3741                 release_region(brdp->iobase, brdp->iosize);
3742
3743         stli_brds[brdp->brdnr] = NULL;
3744         kfree(brdp);
3745 }
3746
3747 static struct pci_driver stli_pcidriver = {
3748         .name = "istallion",
3749         .id_table = istallion_pci_tbl,
3750         .probe = stli_pciprobe,
3751         .remove = __devexit_p(stli_pciremove)
3752 };
3753 /*****************************************************************************/
3754
3755 /*
3756  *      Allocate a new board structure. Fill out the basic info in it.
3757  */
3758
3759 static struct stlibrd *stli_allocbrd(void)
3760 {
3761         struct stlibrd *brdp;
3762
3763         brdp = kzalloc(sizeof(struct stlibrd), GFP_KERNEL);
3764         if (!brdp) {
3765                 printk(KERN_ERR "istallion: failed to allocate memory "
3766                                 "(size=%Zd)\n", sizeof(struct stlibrd));
3767                 return NULL;
3768         }
3769         brdp->magic = STLI_BOARDMAGIC;
3770         return brdp;
3771 }
3772
3773 /*****************************************************************************/
3774
3775 /*
3776  *      Scan through all the boards in the configuration and see what we
3777  *      can find.
3778  */
3779
3780 static int __init stli_initbrds(void)
3781 {
3782         struct stlibrd *brdp, *nxtbrdp;
3783         struct stlconf conf;
3784         unsigned int i, j, found = 0;
3785         int retval;
3786
3787         for (stli_nrbrds = 0; stli_nrbrds < ARRAY_SIZE(stli_brdsp);
3788                         stli_nrbrds++) {
3789                 memset(&conf, 0, sizeof(conf));
3790                 if (stli_parsebrd(&conf, stli_brdsp[stli_nrbrds]) == 0)
3791                         continue;
3792                 if ((brdp = stli_allocbrd()) == NULL)
3793                         continue;
3794                 brdp->brdnr = stli_nrbrds;
3795                 brdp->brdtype = conf.brdtype;
3796                 brdp->iobase = conf.ioaddr1;
3797                 brdp->memaddr = conf.memaddr;
3798                 if (stli_brdinit(brdp) < 0) {
3799                         kfree(brdp);
3800                         continue;
3801                 }
3802                 stli_brds[brdp->brdnr] = brdp;
3803                 found++;
3804
3805                 for (i = 0; i < brdp->nrports; i++)
3806                         tty_register_device(stli_serial,
3807                                         brdp->brdnr * STL_MAXPORTS + i, NULL);
3808         }
3809
3810         retval = stli_findeisabrds();
3811         if (retval > 0)
3812                 found += retval;
3813
3814 /*
3815  *      All found boards are initialized. Now for a little optimization, if
3816  *      no boards are sharing the "shared memory" regions then we can just
3817  *      leave them all enabled. This is in fact the usual case.
3818  */
3819         stli_shared = 0;
3820         if (stli_nrbrds > 1) {
3821                 for (i = 0; (i < stli_nrbrds); i++) {
3822                         brdp = stli_brds[i];
3823                         if (brdp == NULL)
3824                                 continue;
3825                         for (j = i + 1; (j < stli_nrbrds); j++) {
3826                                 nxtbrdp = stli_brds[j];
3827                                 if (nxtbrdp == NULL)
3828                                         continue;
3829                                 if ((brdp->membase >= nxtbrdp->membase) &&
3830                                     (brdp->membase <= (nxtbrdp->membase +
3831                                     nxtbrdp->memsize - 1))) {
3832                                         stli_shared++;
3833                                         break;
3834                                 }
3835                         }
3836                 }
3837         }
3838
3839         if (stli_shared == 0) {
3840                 for (i = 0; (i < stli_nrbrds); i++) {
3841                         brdp = stli_brds[i];
3842                         if (brdp == NULL)
3843                                 continue;
3844                         if (brdp->state & BST_FOUND) {
3845                                 EBRDENABLE(brdp);
3846                                 brdp->enable = NULL;
3847                                 brdp->disable = NULL;
3848                         }
3849                 }
3850         }
3851
3852         retval = pci_register_driver(&stli_pcidriver);
3853         if (retval && found == 0) {
3854                 printk(KERN_ERR "Neither isa nor eisa cards found nor pci "
3855                                 "driver can be registered!\n");
3856                 goto err;
3857         }
3858
3859         return 0;
3860 err:
3861         return retval;
3862 }
3863
3864 /*****************************************************************************/
3865
3866 /*
3867  *      Code to handle an "staliomem" read operation. This device is the
3868  *      contents of the board shared memory. It is used for down loading
3869  *      the slave image (and debugging :-)
3870  */
3871
3872 static ssize_t stli_memread(struct file *fp, char __user *buf, size_t count, loff_t *offp)
3873 {
3874         unsigned long flags;
3875         void __iomem *memptr;
3876         struct stlibrd *brdp;
3877         unsigned int brdnr;
3878         int size, n;
3879         void *p;
3880         loff_t off = *offp;
3881
3882         brdnr = iminor(fp->f_path.dentry->d_inode);
3883         if (brdnr >= stli_nrbrds)
3884                 return -ENODEV;
3885         brdp = stli_brds[brdnr];
3886         if (brdp == NULL)
3887                 return -ENODEV;
3888         if (brdp->state == 0)
3889                 return -ENODEV;
3890         if (off >= brdp->memsize || off + count < off)
3891                 return 0;
3892
3893         size = min(count, (size_t)(brdp->memsize - off));
3894
3895         /*
3896          *      Copy the data a page at a time
3897          */
3898
3899         p = (void *)__get_free_page(GFP_KERNEL);
3900         if(p == NULL)
3901                 return -ENOMEM;
3902
3903         while (size > 0) {
3904                 spin_lock_irqsave(&brd_lock, flags);
3905                 EBRDENABLE(brdp);
3906                 memptr = EBRDGETMEMPTR(brdp, off);
3907                 n = min(size, (int)(brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
3908                 n = min(n, (int)PAGE_SIZE);
3909                 memcpy_fromio(p, memptr, n);
3910                 EBRDDISABLE(brdp);
3911                 spin_unlock_irqrestore(&brd_lock, flags);
3912                 if (copy_to_user(buf, p, n)) {
3913                         count = -EFAULT;
3914                         goto out;
3915                 }
3916                 off += n;
3917                 buf += n;
3918                 size -= n;
3919         }
3920 out:
3921         *offp = off;
3922         free_page((unsigned long)p);
3923         return count;
3924 }
3925
3926 /*****************************************************************************/
3927
3928 /*
3929  *      Code to handle an "staliomem" write operation. This device is the
3930  *      contents of the board shared memory. It is used for down loading
3931  *      the slave image (and debugging :-)
3932  *
3933  *      FIXME: copy under lock
3934  */
3935
3936 static ssize_t stli_memwrite(struct file *fp, const char __user *buf, size_t count, loff_t *offp)
3937 {
3938         unsigned long flags;
3939         void __iomem *memptr;
3940         struct stlibrd *brdp;
3941         char __user *chbuf;
3942         unsigned int brdnr;
3943         int size, n;
3944         void *p;
3945         loff_t off = *offp;
3946
3947         brdnr = iminor(fp->f_path.dentry->d_inode);
3948
3949         if (brdnr >= stli_nrbrds)
3950                 return -ENODEV;
3951         brdp = stli_brds[brdnr];
3952         if (brdp == NULL)
3953                 return -ENODEV;
3954         if (brdp->state == 0)
3955                 return -ENODEV;
3956         if (off >= brdp->memsize || off + count < off)
3957                 return 0;
3958
3959         chbuf = (char __user *) buf;
3960         size = min(count, (size_t)(brdp->memsize - off));
3961
3962         /*
3963          *      Copy the data a page at a time
3964          */
3965
3966         p = (void *)__get_free_page(GFP_KERNEL);
3967         if(p == NULL)
3968                 return -ENOMEM;
3969
3970         while (size > 0) {
3971                 n = min(size, (int)(brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
3972                 n = min(n, (int)PAGE_SIZE);
3973                 if (copy_from_user(p, chbuf, n)) {
3974                         if (count == 0)
3975                                 count = -EFAULT;
3976                         goto out;
3977                 }
3978                 spin_lock_irqsave(&brd_lock, flags);
3979                 EBRDENABLE(brdp);
3980                 memptr = EBRDGETMEMPTR(brdp, off);
3981                 memcpy_toio(memptr, p, n);
3982                 EBRDDISABLE(brdp);
3983                 spin_unlock_irqrestore(&brd_lock, flags);
3984                 off += n;
3985                 chbuf += n;
3986                 size -= n;
3987         }
3988 out:
3989         free_page((unsigned long) p);
3990         *offp = off;
3991         return count;
3992 }
3993
3994 /*****************************************************************************/
3995
3996 /*
3997  *      Return the board stats structure to user app.
3998  */
3999
4000 static int stli_getbrdstats(combrd_t __user *bp)
4001 {
4002         struct stlibrd *brdp;
4003         unsigned int i;
4004
4005         if (copy_from_user(&stli_brdstats, bp, sizeof(combrd_t)))
4006                 return -EFAULT;
4007         if (stli_brdstats.brd >= STL_MAXBRDS)
4008                 return -ENODEV;
4009         brdp = stli_brds[stli_brdstats.brd];
4010         if (brdp == NULL)
4011                 return -ENODEV;
4012
4013         memset(&stli_brdstats, 0, sizeof(combrd_t));
4014         stli_brdstats.brd = brdp->brdnr;
4015         stli_brdstats.type = brdp->brdtype;
4016         stli_brdstats.hwid = 0;
4017         stli_brdstats.state = brdp->state;
4018         stli_brdstats.ioaddr = brdp->iobase;
4019         stli_brdstats.memaddr = brdp->memaddr;
4020         stli_brdstats.nrpanels = brdp->nrpanels;
4021         stli_brdstats.nrports = brdp->nrports;
4022         for (i = 0; (i < brdp->nrpanels); i++) {
4023                 stli_brdstats.panels[i].panel = i;
4024                 stli_brdstats.panels[i].hwid = brdp->panelids[i];
4025                 stli_brdstats.panels[i].nrports = brdp->panels[i];
4026         }
4027
4028         if (copy_to_user(bp, &stli_brdstats, sizeof(combrd_t)))
4029                 return -EFAULT;
4030         return 0;
4031 }
4032
4033 /*****************************************************************************/
4034
4035 /*
4036  *      Resolve the referenced port number into a port struct pointer.
4037  */
4038
4039 static struct stliport *stli_getport(unsigned int brdnr, unsigned int panelnr,
4040                 unsigned int portnr)
4041 {
4042         struct stlibrd *brdp;
4043         unsigned int i;
4044
4045         if (brdnr >= STL_MAXBRDS)
4046                 return NULL;
4047         brdp = stli_brds[brdnr];
4048         if (brdp == NULL)
4049                 return NULL;
4050         for (i = 0; (i < panelnr); i++)
4051                 portnr += brdp->panels[i];
4052         if (portnr >= brdp->nrports)
4053                 return NULL;
4054         return brdp->ports[portnr];
4055 }
4056
4057 /*****************************************************************************/
4058
4059 /*
4060  *      Return the port stats structure to user app. A NULL port struct
4061  *      pointer passed in means that we need to find out from the app
4062  *      what port to get stats for (used through board control device).
4063  */
4064
4065 static int stli_portcmdstats(struct tty_struct *tty, struct stliport *portp)
4066 {
4067         unsigned long   flags;
4068         struct stlibrd  *brdp;
4069         int             rc;
4070
4071         memset(&stli_comstats, 0, sizeof(comstats_t));
4072
4073         if (portp == NULL)
4074                 return -ENODEV;
4075         brdp = stli_brds[portp->brdnr];
4076         if (brdp == NULL)
4077                 return -ENODEV;
4078
4079         if (brdp->state & BST_STARTED) {
4080                 if ((rc = stli_cmdwait(brdp, portp, A_GETSTATS,
4081                     &stli_cdkstats, sizeof(asystats_t), 1)) < 0)
4082                         return rc;
4083         } else {
4084                 memset(&stli_cdkstats, 0, sizeof(asystats_t));
4085         }
4086
4087         stli_comstats.brd = portp->brdnr;
4088         stli_comstats.panel = portp->panelnr;
4089         stli_comstats.port = portp->portnr;
4090         stli_comstats.state = portp->state;
4091         stli_comstats.flags = portp->port.flags;
4092
4093         spin_lock_irqsave(&brd_lock, flags);
4094         if (tty != NULL) {
4095                 if (portp->port.tty == tty) {
4096                         stli_comstats.ttystate = tty->flags;
4097                         stli_comstats.rxbuffered = -1;
4098                         if (tty->termios != NULL) {
4099                                 stli_comstats.cflags = tty->termios->c_cflag;
4100                                 stli_comstats.iflags = tty->termios->c_iflag;
4101                                 stli_comstats.oflags = tty->termios->c_oflag;
4102                                 stli_comstats.lflags = tty->termios->c_lflag;
4103                         }
4104                 }
4105         }
4106         spin_unlock_irqrestore(&brd_lock, flags);
4107
4108         stli_comstats.txtotal = stli_cdkstats.txchars;
4109         stli_comstats.rxtotal = stli_cdkstats.rxchars + stli_cdkstats.ringover;
4110         stli_comstats.txbuffered = stli_cdkstats.txringq;
4111         stli_comstats.rxbuffered += stli_cdkstats.rxringq;
4112         stli_comstats.rxoverrun = stli_cdkstats.overruns;
4113         stli_comstats.rxparity = stli_cdkstats.parity;
4114         stli_comstats.rxframing = stli_cdkstats.framing;
4115         stli_comstats.rxlost = stli_cdkstats.ringover;
4116         stli_comstats.rxbreaks = stli_cdkstats.rxbreaks;
4117         stli_comstats.txbreaks = stli_cdkstats.txbreaks;
4118         stli_comstats.txxon = stli_cdkstats.txstart;
4119         stli_comstats.txxoff = stli_cdkstats.txstop;
4120         stli_comstats.rxxon = stli_cdkstats.rxstart;
4121         stli_comstats.rxxoff = stli_cdkstats.rxstop;
4122         stli_comstats.rxrtsoff = stli_cdkstats.rtscnt / 2;
4123         stli_comstats.rxrtson = stli_cdkstats.rtscnt - stli_comstats.rxrtsoff;
4124         stli_comstats.modem = stli_cdkstats.dcdcnt;
4125         stli_comstats.hwid = stli_cdkstats.hwid;
4126         stli_comstats.signals = stli_mktiocm(stli_cdkstats.signals);
4127
4128         return 0;
4129 }
4130
4131 /*****************************************************************************/
4132
4133 /*
4134  *      Return the port stats structure to user app. A NULL port struct
4135  *      pointer passed in means that we need to find out from the app
4136  *      what port to get stats for (used through board control device).
4137  */
4138
4139 static int stli_getportstats(struct tty_struct *tty, struct stliport *portp,
4140                                                         comstats_t __user *cp)
4141 {
4142         struct stlibrd *brdp;
4143         int rc;
4144
4145         if (!portp) {
4146                 if (copy_from_user(&stli_comstats, cp, sizeof(comstats_t)))
4147                         return -EFAULT;
4148                 portp = stli_getport(stli_comstats.brd, stli_comstats.panel,
4149                         stli_comstats.port);
4150                 if (!portp)
4151                         return -ENODEV;
4152         }
4153
4154         brdp = stli_brds[portp->brdnr];
4155         if (!brdp)
4156                 return -ENODEV;
4157
4158         if ((rc = stli_portcmdstats(tty, portp)) < 0)
4159                 return rc;
4160
4161         return copy_to_user(cp, &stli_comstats, sizeof(comstats_t)) ?
4162                         -EFAULT : 0;
4163 }
4164
4165 /*****************************************************************************/
4166
4167 /*
4168  *      Clear the port stats structure. We also return it zeroed out...
4169  */
4170
4171 static int stli_clrportstats(struct stliport *portp, comstats_t __user *cp)
4172 {
4173         struct stlibrd *brdp;
4174         int rc;
4175
4176         if (!portp) {
4177                 if (copy_from_user(&stli_comstats, cp, sizeof(comstats_t)))
4178                         return -EFAULT;
4179                 portp = stli_getport(stli_comstats.brd, stli_comstats.panel,
4180                         stli_comstats.port);
4181                 if (!portp)
4182                         return -ENODEV;
4183         }
4184
4185         brdp = stli_brds[portp->brdnr];
4186         if (!brdp)
4187                 return -ENODEV;
4188
4189         if (brdp->state & BST_STARTED) {
4190                 if ((rc = stli_cmdwait(brdp, portp, A_CLEARSTATS, NULL, 0, 0)) < 0)
4191                         return rc;
4192         }
4193
4194         memset(&stli_comstats, 0, sizeof(comstats_t));
4195         stli_comstats.brd = portp->brdnr;
4196         stli_comstats.panel = portp->panelnr;
4197         stli_comstats.port = portp->portnr;
4198
4199         if (copy_to_user(cp, &stli_comstats, sizeof(comstats_t)))
4200                 return -EFAULT;
4201         return 0;
4202 }
4203
4204 /*****************************************************************************/
4205
4206 /*
4207  *      Return the entire driver ports structure to a user app.
4208  */
4209
4210 static int stli_getportstruct(struct stliport __user *arg)
4211 {
4212         struct stliport stli_dummyport;
4213         struct stliport *portp;
4214
4215         if (copy_from_user(&stli_dummyport, arg, sizeof(struct stliport)))
4216                 return -EFAULT;
4217         portp = stli_getport(stli_dummyport.brdnr, stli_dummyport.panelnr,
4218                  stli_dummyport.portnr);
4219         if (!portp)
4220                 return -ENODEV;
4221         if (copy_to_user(arg, portp, sizeof(struct stliport)))
4222                 return -EFAULT;
4223         return 0;
4224 }
4225
4226 /*****************************************************************************/
4227
4228 /*
4229  *      Return the entire driver board structure to a user app.
4230  */
4231
4232 static int stli_getbrdstruct(struct stlibrd __user *arg)
4233 {
4234         struct stlibrd stli_dummybrd;
4235         struct stlibrd *brdp;
4236
4237         if (copy_from_user(&stli_dummybrd, arg, sizeof(struct stlibrd)))
4238                 return -EFAULT;
4239         if (stli_dummybrd.brdnr >= STL_MAXBRDS)
4240                 return -ENODEV;
4241         brdp = stli_brds[stli_dummybrd.brdnr];
4242         if (!brdp)
4243                 return -ENODEV;
4244         if (copy_to_user(arg, brdp, sizeof(struct stlibrd)))
4245                 return -EFAULT;
4246         return 0;
4247 }
4248
4249 /*****************************************************************************/
4250
4251 /*
4252  *      The "staliomem" device is also required to do some special operations on
4253  *      the board. We need to be able to send an interrupt to the board,
4254  *      reset it, and start/stop it.
4255  */
4256
4257 static long stli_memioctl(struct file *fp, unsigned int cmd, unsigned long arg)
4258 {
4259         struct stlibrd *brdp;
4260         int brdnr, rc, done;
4261         void __user *argp = (void __user *)arg;
4262
4263 /*
4264  *      First up handle the board independent ioctls.
4265  */
4266         done = 0;
4267         rc = 0;
4268
4269         lock_kernel();
4270
4271         switch (cmd) {
4272         case COM_GETPORTSTATS:
4273                 rc = stli_getportstats(NULL, NULL, argp);
4274                 done++;
4275                 break;
4276         case COM_CLRPORTSTATS:
4277                 rc = stli_clrportstats(NULL, argp);
4278                 done++;
4279                 break;
4280         case COM_GETBRDSTATS:
4281                 rc = stli_getbrdstats(argp);
4282                 done++;
4283                 break;
4284         case COM_READPORT:
4285                 rc = stli_getportstruct(argp);
4286                 done++;
4287                 break;
4288         case COM_READBOARD:
4289                 rc = stli_getbrdstruct(argp);
4290                 done++;
4291                 break;
4292         }
4293         unlock_kernel();
4294
4295         if (done)
4296                 return rc;
4297
4298 /*
4299  *      Now handle the board specific ioctls. These all depend on the
4300  *      minor number of the device they were called from.
4301  */
4302         brdnr = iminor(fp->f_dentry->d_inode);
4303         if (brdnr >= STL_MAXBRDS)
4304                 return -ENODEV;
4305         brdp = stli_brds[brdnr];
4306         if (!brdp)
4307                 return -ENODEV;
4308         if (brdp->state == 0)
4309                 return -ENODEV;
4310
4311         lock_kernel();
4312
4313         switch (cmd) {
4314         case STL_BINTR:
4315                 EBRDINTR(brdp);
4316                 break;
4317         case STL_BSTART:
4318                 rc = stli_startbrd(brdp);
4319                 break;
4320         case STL_BSTOP:
4321                 brdp->state &= ~BST_STARTED;
4322                 break;
4323         case STL_BRESET:
4324                 brdp->state &= ~BST_STARTED;
4325                 EBRDRESET(brdp);
4326                 if (stli_shared == 0) {
4327                         if (brdp->reenable != NULL)
4328                                 (* brdp->reenable)(brdp);
4329                 }
4330                 break;
4331         default:
4332                 rc = -ENOIOCTLCMD;
4333                 break;
4334         }
4335         unlock_kernel();
4336         return rc;
4337 }
4338
4339 static const struct tty_operations stli_ops = {
4340         .open = stli_open,
4341         .close = stli_close,
4342         .write = stli_write,
4343         .put_char = stli_putchar,
4344         .flush_chars = stli_flushchars,
4345         .write_room = stli_writeroom,
4346         .chars_in_buffer = stli_charsinbuffer,
4347         .ioctl = stli_ioctl,
4348         .set_termios = stli_settermios,
4349         .throttle = stli_throttle,
4350         .unthrottle = stli_unthrottle,
4351         .stop = stli_stop,
4352         .start = stli_start,
4353         .hangup = stli_hangup,
4354         .flush_buffer = stli_flushbuffer,
4355         .break_ctl = stli_breakctl,
4356         .wait_until_sent = stli_waituntilsent,
4357         .send_xchar = stli_sendxchar,
4358         .tiocmget = stli_tiocmget,
4359         .tiocmset = stli_tiocmset,
4360         .proc_fops = &stli_proc_fops,
4361 };
4362
4363 static const struct tty_port_operations stli_port_ops = {
4364         .carrier_raised = stli_carrier_raised,
4365         .dtr_rts = stli_dtr_rts,
4366         .activate = stli_activate,
4367         .shutdown = stli_shutdown,
4368 };
4369
4370 /*****************************************************************************/
4371 /*
4372  *      Loadable module initialization stuff.
4373  */
4374
4375 static void istallion_cleanup_isa(void)
4376 {
4377         struct stlibrd  *brdp;
4378         unsigned int j;
4379
4380         for (j = 0; (j < stli_nrbrds); j++) {
4381                 if ((brdp = stli_brds[j]) == NULL || (brdp->state & BST_PROBED))
4382                         continue;
4383
4384                 stli_cleanup_ports(brdp);
4385
4386                 iounmap(brdp->membase);
4387                 if (brdp->iosize > 0)
4388                         release_region(brdp->iobase, brdp->iosize);
4389                 kfree(brdp);
4390                 stli_brds[j] = NULL;
4391         }
4392 }
4393
4394 static int __init istallion_module_init(void)
4395 {
4396         unsigned int i;
4397         int retval;
4398
4399         printk(KERN_INFO "%s: version %s\n", stli_drvtitle, stli_drvversion);
4400
4401         spin_lock_init(&stli_lock);
4402         spin_lock_init(&brd_lock);
4403
4404         stli_txcookbuf = kmalloc(STLI_TXBUFSIZE, GFP_KERNEL);
4405         if (!stli_txcookbuf) {
4406                 printk(KERN_ERR "istallion: failed to allocate memory "
4407                                 "(size=%d)\n", STLI_TXBUFSIZE);
4408                 retval = -ENOMEM;
4409                 goto err;
4410         }
4411
4412         stli_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
4413         if (!stli_serial) {
4414                 retval = -ENOMEM;
4415                 goto err_free;
4416         }
4417
4418         stli_serial->owner = THIS_MODULE;
4419         stli_serial->driver_name = stli_drvname;
4420         stli_serial->name = stli_serialname;
4421         stli_serial->major = STL_SERIALMAJOR;
4422         stli_serial->minor_start = 0;
4423         stli_serial->type = TTY_DRIVER_TYPE_SERIAL;
4424         stli_serial->subtype = SERIAL_TYPE_NORMAL;
4425         stli_serial->init_termios = stli_deftermios;
4426         stli_serial->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
4427         tty_set_operations(stli_serial, &stli_ops);
4428
4429         retval = tty_register_driver(stli_serial);
4430         if (retval) {
4431                 printk(KERN_ERR "istallion: failed to register serial driver\n");
4432                 goto err_ttyput;
4433         }
4434
4435         retval = stli_initbrds();
4436         if (retval)
4437                 goto err_ttyunr;
4438
4439 /*
4440  *      Set up a character driver for the shared memory region. We need this
4441  *      to down load the slave code image. Also it is a useful debugging tool.
4442  */
4443         retval = register_chrdev(STL_SIOMEMMAJOR, "staliomem", &stli_fsiomem);
4444         if (retval) {
4445                 printk(KERN_ERR "istallion: failed to register serial memory "
4446                                 "device\n");
4447                 goto err_deinit;
4448         }
4449
4450         istallion_class = class_create(THIS_MODULE, "staliomem");
4451         for (i = 0; i < 4; i++)
4452                 device_create(istallion_class, NULL, MKDEV(STL_SIOMEMMAJOR, i),
4453                               NULL, "staliomem%d", i);
4454
4455         return 0;
4456 err_deinit:
4457         pci_unregister_driver(&stli_pcidriver);
4458         istallion_cleanup_isa();
4459 err_ttyunr:
4460         tty_unregister_driver(stli_serial);
4461 err_ttyput:
4462         put_tty_driver(stli_serial);
4463 err_free:
4464         kfree(stli_txcookbuf);
4465 err:
4466         return retval;
4467 }
4468
4469 /*****************************************************************************/
4470
4471 static void __exit istallion_module_exit(void)
4472 {
4473         unsigned int j;
4474
4475         printk(KERN_INFO "Unloading %s: version %s\n", stli_drvtitle,
4476                 stli_drvversion);
4477
4478         if (stli_timeron) {
4479                 stli_timeron = 0;
4480                 del_timer_sync(&stli_timerlist);
4481         }
4482
4483         unregister_chrdev(STL_SIOMEMMAJOR, "staliomem");
4484
4485         for (j = 0; j < 4; j++)
4486                 device_destroy(istallion_class, MKDEV(STL_SIOMEMMAJOR, j));
4487         class_destroy(istallion_class);
4488
4489         pci_unregister_driver(&stli_pcidriver);
4490         istallion_cleanup_isa();
4491
4492         tty_unregister_driver(stli_serial);
4493         put_tty_driver(stli_serial);
4494
4495         kfree(stli_txcookbuf);
4496 }
4497
4498 module_init(istallion_module_init);
4499 module_exit(istallion_module_exit);