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