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