drivers/char/cyclades.c

   1 #undef  BLOCKMOVE
   2 #define Z_WAKE
   3 #undef  Z_EXT_CHARS_IN_BUFFER
   4
   5 /*
   6  *  linux/drivers/char/cyclades.c
   7  *
   8  * This file contains the driver for the Cyclades async multiport
   9  * serial boards.
  10  *
  11  * Initially written by Randolph Bentson <[email protected]>.
  12  * Modified and maintained by Marcio Saito <[email protected]>.
  13  * Currently maintained by Cyclades team <[email protected]>.
  14  *
  15  * For Technical support and installation problems, please send e-mail
  16  * to [email protected].
  17  *
  18  * Much of the design and some of the code came from serial.c
  19  * which was copyright (C) 1991, 1992  Linus Torvalds.  It was
  20  * extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92,
  21  * and then fixed as suggested by Michael K. Johnson 12/12/92.
  22  *
  23  * This version supports shared IRQ's (only for PCI boards).
  24  *
  25  * $Log: cyclades.c,v $
  26  * Prevent users from opening non-existing Z ports.
  27  *
  28  * Revision 2.3.2.8   2000/07/06 18:14:16 ivan
  29  * Fixed the PCI detection function to work properly on Alpha systems.
  30  * Implemented support for TIOCSERGETLSR ioctl.
  31  * Implemented full support for non-standard baud rates.
  32  *
  33  * Revision 2.3.2.7   2000/06/01 18:26:34 ivan
  34  * Request PLX I/O region, although driver doesn't use it, to avoid
  35  * problems with other drivers accessing it.
  36  * Removed count for on-board buffer characters in cy_chars_in_buffer
  37  * (Cyclades-Z only).
  38  *
  39  * Revision 2.3.2.6   2000/05/05 13:56:05 ivan
  40  * Driver now reports physical instead of virtual memory addresses.
  41  * Masks were added to some Cyclades-Z read accesses.
  42  * Implemented workaround for PLX9050 bug that would cause a system lockup
  43  * in certain systems, depending on the MMIO addresses allocated to the
  44  * board.
  45  * Changed the Tx interrupt programming in the CD1400 chips to boost up
  46  * performance (Cyclom-Y only).
  47  * Code is now compliant with the new module interface (module_[init|exit]).
  48  * Make use of the PCI helper functions to access PCI resources.
  49  * Did some code "housekeeping".
  50  *
  51  * Revision 2.3.2.5   2000/01/19 14:35:33 ivan
  52  * Fixed bug in cy_set_termios on CRTSCTS flag turnoff.
  53  *
  54  * Revision 2.3.2.4   2000/01/17 09:19:40 ivan
  55  * Fixed SMP locking in Cyclom-Y interrupt handler.
  56  *
  57  * Revision 2.3.2.3   1999/12/28 12:11:39 ivan
  58  * Added a new cyclades_card field called nports to allow the driver to
  59  * know the exact number of ports found by the Z firmware after its load;
  60  * RX buffer contention prevention logic on interrupt op mode revisited
  61  * (Cyclades-Z only);
  62  * Revisited printk's for Z debug;
  63  * Driver now makes sure that the constant SERIAL_XMIT_SIZE is defined;
  64  *
  65  * Revision 2.3.2.2   1999/10/01 11:27:43 ivan
  66  * Fixed bug in cyz_poll that would make all ports but port 0
  67  * unable to transmit/receive data (Cyclades-Z only);
  68  * Implemented logic to prevent the RX buffer from being stuck with data
  69  * due to a driver / firmware race condition in interrupt op mode
  70  * (Cyclades-Z only);
  71  * Fixed bug in block_til_ready logic that would lead to a system crash;
  72  * Revisited cy_close spinlock usage;
  73  *
  74  * Revision 2.3.2.1   1999/09/28 11:01:22 ivan
  75  * Revisited CONFIG_PCI conditional compilation for PCI board support;
  76  * Implemented TIOCGICOUNT and TIOCMIWAIT ioctl support;
  77  * _Major_ cleanup on the Cyclades-Z interrupt support code / logic;
  78  * Removed CTS handling from the driver -- this is now completely handled
  79  * by the firmware (Cyclades-Z only);
  80  * Flush RX on-board buffers on a port open (Cyclades-Z only);
  81  * Fixed handling of ASYNC_SPD_* TTY flags;
  82  * Module unload now unmaps all memory area allocated by ioremap;
  83  *
  84  * Revision 2.3.1.1   1999/07/15 16:45:53 ivan
  85  * Removed CY_PROC conditional compilation;
  86  * Implemented SMP-awareness for the driver;
  87  * Implemented a new ISA IRQ autoprobe that uses the irq_probe_[on|off]
  88  * functions;
  89  * The driver now accepts memory addresses (maddr=0xMMMMM) and IRQs
  90  * (irq=NN) as parameters (only for ISA boards);
  91  * Fixed bug in set_line_char that would prevent the Cyclades-Z
  92  * ports from being configured at speeds above 115.2Kbps;
  93  * Fixed bug in cy_set_termios that would prevent XON/XOFF flow control
  94  * switching from working properly;
  95  * The driver now only prints IRQ info for the Cyclades-Z if it's
  96  * configured to work in interrupt mode;
  97  *
  98  * Revision 2.2.2.3   1999/06/28 11:13:29 ivan
  99  * Added support for interrupt mode operation for the Z cards;
 100  * Removed the driver inactivity control for the Z;
 101  * Added a missing MOD_DEC_USE_COUNT in the cy_open function for when
 102  * the Z firmware is not loaded yet;
 103  * Replaced the "manual" Z Tx flush buffer by a call to a FW command of
 104  * same functionality;
 105  * Implemented workaround for IRQ setting loss on the PCI configuration
 106  * registers after a PCI bridge EEPROM reload (affects PLX9060 only);
 107  *
 108  * Revision 2.2.2.2  1999/05/14 17:18:15 ivan
 109  * /proc entry location changed to /proc/tty/driver/cyclades;
 110  * Added support to shared IRQ's (only for PCI boards);
 111  * Added support for Cobalt Qube2 systems;
 112  * IRQ [de]allocation scheme revisited;
 113  * BREAK implementation changed in order to make use of the 'break_ctl'
 114  * TTY facility;
 115  * Fixed typo in TTY structure field 'driver_name';
 116  * Included a PCI bridge reset and EEPROM reload in the board
 117  * initialization code (for both Y and Z series).
 118  *
 119  * Revision 2.2.2.1  1999/04/08 16:17:43 ivan
 120  * Fixed a bug in cy_wait_until_sent that was preventing the port to be
 121  * closed properly after a SIGINT;
 122  * Module usage counter scheme revisited;
 123  * Added support to the upcoming Y PCI boards (i.e., support to additional
 124  * PCI Device ID's).
 125  *
 126  * Revision 2.2.1.10 1999/01/20 16:14:29 ivan
 127  * Removed all unnecessary page-alignement operations in ioremap calls
 128  * (ioremap is currently safe for these operations).
 129  *
 130  * Revision 2.2.1.9  1998/12/30 18:18:30 ivan
 131  * Changed access to PLX PCI bridge registers from I/O to MMIO, in
 132  * order to make PLX9050-based boards work with certain motherboards.
 133  *
 134  * Revision 2.2.1.8  1998/11/13 12:46:20 ivan
 135  * cy_close function now resets (correctly) the tty->closing flag;
 136  * JIFFIES_DIFF macro fixed.
 137  *
 138  * Revision 2.2.1.7  1998/09/03 12:07:28 ivan
 139  * Fixed bug in cy_close function, which was not informing HW of
 140  * which port should have the reception disabled before doing so;
 141  * fixed Cyclom-8YoP hardware detection bug.
 142  *
 143  * Revision 2.2.1.6  1998/08/20 17:15:39 ivan
 144  * Fixed bug in cy_close function, which causes malfunction
 145  * of one of the first 4 ports when a higher port is closed
 146  * (Cyclom-Y only).
 147  *
 148  * Revision 2.2.1.5  1998/08/10 18:10:28 ivan
 149  * Fixed Cyclom-4Yo hardware detection bug.
 150  *
 151  * Revision 2.2.1.4  1998/08/04 11:02:50 ivan
 152  * /proc/cyclades implementation with great collaboration of
 153  * Marc Lewis <[email protected]>;
 154  * cyy_interrupt was changed to avoid occurrence of kernel oopses
 155  * during PPP operation.
 156  *
 157  * Revision 2.2.1.3  1998/06/01 12:09:10 ivan
 158  * General code review in order to comply with 2.1 kernel standards;
 159  * data loss prevention for slow devices revisited (cy_wait_until_sent
 160  * was created);
 161  * removed conditional compilation for new/old PCI structure support
 162  * (now the driver only supports the new PCI structure).
 163  *
 164  * Revision 2.2.1.1  1998/03/19 16:43:12 ivan
 165  * added conditional compilation for new/old PCI structure support;
 166  * removed kernel series (2.0.x / 2.1.x) conditional compilation.
 167  *
 168  * Revision 2.1.1.3  1998/03/16 18:01:12 ivan
 169  * cleaned up the data loss fix;
 170  * fixed XON/XOFF handling once more (Cyclades-Z);
 171  * general review of the driver routines;
 172  * introduction of a mechanism to prevent data loss with slow
 173  * printers, by forcing a delay before closing the port.
 174  *
 175  * Revision 2.1.1.2  1998/02/17 16:50:00 ivan
 176  * fixed detection/handling of new CD1400 in Ye boards;
 177  * fixed XON/XOFF handling (Cyclades-Z);
 178  * fixed data loss caused by a premature port close;
 179  * introduction of a flag that holds the CD1400 version ID per port
 180  * (used by the CYGETCD1400VER new ioctl).
 181  *
 182  * Revision 2.1.1.1  1997/12/03 17:31:19 ivan
 183  * Code review for the module cleanup routine;
 184  * fixed RTS and DTR status report for new CD1400's in get_modem_info;
 185  * includes anonymous changes regarding signal_pending.
 186  *
 187  * Revision 2.1  1997/11/01 17:42:41 ivan
 188  * Changes in the driver to support Alpha systems (except 8Zo V_1);
 189  * BREAK fix for the Cyclades-Z boards;
 190  * driver inactivity control by FW implemented;
 191  * introduction of flag that allows driver to take advantage of
 192  * a special CD1400 feature related to HW flow control;
 193  * added support for the CD1400  rev. J (Cyclom-Y boards);
 194  * introduction of ioctls to:
 195  *  - control the rtsdtr_inv flag (Cyclom-Y);
 196  *  - control the rflow flag (Cyclom-Y);
 197  *  - adjust the polling interval (Cyclades-Z);
 198  *
 199  * Revision 1.36.4.33  1997/06/27 19:00:00  ivan
 200  * Fixes related to kernel version conditional
 201  * compilation.
 202  *
 203  * Revision 1.36.4.32  1997/06/14 19:30:00  ivan
 204  * Compatibility issues between kernels 2.0.x and
 205  * 2.1.x (mainly related to clear_bit function).
 206  *
 207  * Revision 1.36.4.31  1997/06/03 15:30:00  ivan
 208  * Changes to define the memory window according to the
 209  * board type.
 210  *
 211  * Revision 1.36.4.30  1997/05/16 15:30:00  daniel
 212  * Changes to support new cycladesZ boards.
 213  *
 214  * Revision 1.36.4.29  1997/05/12 11:30:00  daniel
 215  * Merge of Bentson's and Daniel's version 1.36.4.28.
 216  * Corrects bug in cy_detect_pci: check if there are more
 217  * ports than the number of static structs allocated.
 218  * Warning message during initialization if this driver is
 219  * used with the new generation of cycladesZ boards.  Those
 220  * will be supported only in next release of the driver.
 221  * Corrects bug in cy_detect_pci and cy_detect_isa that
 222  * returned wrong number of VALID boards, when a cyclomY
 223  * was found with no serial modules connected.
 224  * Changes to use current (2.1.x) kernel subroutine names
 225  * and created macros for compilation with 2.0.x kernel,
 226  * instead of the other way around.
 227  *
 228  * Revision 1.36.4.28  1997/05/?? ??:00:00  bentson
 229  * Change queue_task_irq_off to queue_task_irq.
 230  * The inline function queue_task_irq_off (tqueue.h)
 231  * was removed from latest releases of 2.1.x kernel.
 232  * Use of macro __init to mark the initialization
 233  * routines, so memory can be reused.
 234  * Also incorporate implementation of critical region
 235  * in function cleanup_module() created by anonymous
 236  * linuxer.
 237  *
 238  * Revision 1.36.4.28  1997/04/25 16:00:00  daniel
 239  * Change to support new firmware that solves DCD problem:
 240  * application could fail to receive SIGHUP signal when DCD
 241  * varying too fast.
 242  *
 243  * Revision 1.36.4.27  1997/03/26 10:30:00  daniel
 244  * Changed for support linux versions 2.1.X.
 245  * Backward compatible with linux versions 2.0.X.
 246  * Corrected illegal use of filler field in
 247  * CH_CTRL struct.
 248  * Deleted some debug messages.
 249  *
 250  * Revision 1.36.4.26  1997/02/27 12:00:00  daniel
 251  * Included check for NULL tty pointer in cyz_poll.
 252  *
 253  * Revision 1.36.4.25  1997/02/26 16:28:30  bentson
 254  * Bill Foster at Blarg! Online services noticed that
 255  * some of the switch elements of -Z modem control
 256  * lacked a closing "break;"
 257  *
 258  * Revision 1.36.4.24  1997/02/24 11:00:00  daniel
 259  * Changed low water threshold for buffer xmit_buf
 260  *
 261  * Revision 1.36.4.23  1996/12/02 21:50:16  bentson
 262  * Marcio provided fix to modem status fetch for -Z
 263  *
 264  * Revision 1.36.4.22  1996/10/28 22:41:17  bentson
 265  * improve mapping of -Z control page (thanks to Steve
 266  * Price <[email protected]> for help on this)
 267  *
 268  * Revision 1.36.4.21  1996/09/10 17:00:10  bentson
 269  * shift from CPU-bound to memcopy in cyz_polling operation
 270  *
 271  * Revision 1.36.4.20  1996/09/09 18:30:32  Bentson
 272  * Added support to set and report higher speeds.
 273  *
 274  * Revision 1.36.4.19c  1996/08/09 10:00:00  Marcio Saito
 275  * Some fixes in the HW flow control for the BETA release.
 276  * Don't try to register the IRQ.
 277  *
 278  * Revision 1.36.4.19  1996/08/08 16:23:18  Bentson
 279  * make sure "cyc" appears in all kernel messages; all soft interrupts
 280  * handled by same routine; recognize out-of-band reception; comment
 281  * out some diagnostic messages; leave RTS/CTS flow control to hardware;
 282  * fix race condition in -Z buffer management; only -Y needs to explicitly
 283  * flush chars; tidy up some startup messages;
 284  *
 285  * Revision 1.36.4.18  1996/07/25 18:57:31  bentson
 286  * shift MOD_INC_USE_COUNT location to match
 287  * serial.c; purge some diagnostic messages;
 288  *
 289  * Revision 1.36.4.17  1996/07/25 18:01:08  bentson
 290  * enable modem status messages and fetch & process them; note
 291  * time of last activity type for each port; set_line_char now
 292  * supports more than line 0 and treats 0 baud correctly;
 293  * get_modem_info senses rs_status;
 294  *
 295  * Revision 1.36.4.16  1996/07/20 08:43:15  bentson
 296  * barely works--now's time to turn on
 297  * more features 'til it breaks
 298  *
 299  * Revision 1.36.4.15  1996/07/19 22:30:06  bentson
 300  * check more -Z board status; shorten boot message
 301  *
 302  * Revision 1.36.4.14  1996/07/19 22:20:37  bentson
 303  * fix reference to ch_ctrl in startup; verify return
 304  * values from cyz_issue_cmd and cyz_update_channel;
 305  * more stuff to get modem control correct;
 306  *
 307  * Revision 1.36.4.13  1996/07/11 19:53:33  bentson
 308  * more -Z stuff folded in; re-order changes to put -Z stuff
 309  * after -Y stuff (to make changes clearer)
 310  *
 311  * Revision 1.36.4.12  1996/07/11 15:40:55  bentson
 312  * Add code to poll Cyclades-Z.  Add code to get & set RS-232 control.
 313  * Add code to send break.  Clear firmware ID word at startup (so
 314  * that other code won't talk to inactive board).
 315  *
 316  * Revision 1.36.4.11  1996/07/09 05:28:29  bentson
 317  * add code for -Z in set_line_char
 318  *
 319  * Revision 1.36.4.10  1996/07/08 19:28:37  bentson
 320  * fold more -Z stuff (or in some cases, error messages)
 321  * into driver; add text to "don't know what to do" messages.
 322  *
 323  * Revision 1.36.4.9  1996/07/08 18:38:38  bentson
 324  * moved compile-time flags near top of file; cosmetic changes
 325  * to narrow text (to allow 2-up printing); changed many declarations
 326  * to "static" to limit external symbols; shuffled code order to
 327  * coalesce -Y and -Z specific code, also to put internal functions
 328  * in order of tty_driver structure; added code to recognize -Z
 329  * ports (and for moment, do nothing or report error); add cy_startup
 330  * to parse boot command line for extra base addresses for ISA probes;
 331  *
 332  * Revision 1.36.4.8  1996/06/25 17:40:19  bentson
 333  * reorder some code, fix types of some vars (int vs. long),
 334  * add cy_setup to support user declared ISA addresses
 335  *
 336  * Revision 1.36.4.7  1996/06/21 23:06:18  bentson
 337  * dump ioctl based firmware load (it's now a user level
 338  * program); ensure uninitialzed ports cannot be used
 339  *
 340  * Revision 1.36.4.6  1996/06/20 23:17:19  bentson
 341  * rename vars and restructure some code
 342  *
 343  * Revision 1.36.4.5  1996/06/14 15:09:44  bentson
 344  * get right status back after boot load
 345  *
 346  * Revision 1.36.4.4  1996/06/13 19:51:44  bentson
 347  * successfully loads firmware
 348  *
 349  * Revision 1.36.4.3  1996/06/13 06:08:33  bentson
 350  * add more of the code for the boot/load ioctls
 351  *
 352  * Revision 1.36.4.2  1996/06/11 21:00:51  bentson
 353  * start to add Z functionality--starting with ioctl
 354  * for loading firmware
 355  *
 356  * Revision 1.36.4.1  1996/06/10 18:03:02  bentson
 357  * added code to recognize Z/PCI card at initialization; report
 358  * presence, but card is not initialized (because firmware needs
 359  * to be loaded)
 360  *
 361  * Revision 1.36.3.8  1996/06/07 16:29:00  bentson
 362  * starting minor number at zero; added missing verify_area
 363  * as noted by Heiko Eissfeldt <[email protected]>
 364  *
 365  * Revision 1.36.3.7  1996/04/19 21:06:18  bentson
 366  * remove unneeded boot message & fix CLOCAL hardware flow
 367  * control (Miquel van Smoorenburg <[email protected]>);
 368  * remove unused diagnostic statements; minor 0 is first;
 369  *
 370  * Revision 1.36.3.6  1996/03/13 13:21:17  marcio
 371  * The kernel function vremap (available only in later 1.3.xx kernels)
 372  * allows the access to memory addresses above the RAM. This revision
 373  * of the driver supports PCI boards below 1Mb (device id 0x100) and
 374  * above 1Mb (device id 0x101).
 375  *
 376  * Revision 1.36.3.5  1996/03/07 15:20:17  bentson
 377  * Some global changes to interrupt handling spilled into
 378  * this driver--mostly unused arguments in system function
 379  * calls.  Also added change by Marcio Saito which should
 380  * reduce lost interrupts at startup by fast processors.
 381  *
 382  * Revision 1.36.3.4  1995/11/13  20:45:10  bentson
 383  * Changes by Corey Minyard <[email protected]> distributed
 384  * in 1.3.41 kernel to remove a possible race condition, extend
 385  * some error messages, and let the driver run as a loadable module
 386  * Change by Alan Wendt <[email protected]> to remove a
 387  * possible race condition.
 388  * Change by Marcio Saito <[email protected]> to fix PCI addressing.
 389  *
 390  * Revision 1.36.3.3  1995/11/13  19:44:48  bentson
 391  * Changes by Linus Torvalds in 1.3.33 kernel distribution
 392  * required due to reordering of driver initialization.
 393  * Drivers are now initialized *after* memory management.
 394  *
 395  * Revision 1.36.3.2  1995/09/08  22:07:14  bentson
 396  * remove printk from ISR; fix typo
 397  *
 398  * Revision 1.36.3.1  1995/09/01  12:00:42  marcio
 399  * Minor fixes in the PCI board support. PCI function calls in
 400  * conditional compilation (CONFIG_PCI). Thanks to Jim Duncan
 401  * <[email protected]>. "bad serial count" message removed.
 402  *
 403  * Revision 1.36.3  1995/08/22  09:19:42  marcio
 404  * Cyclom-Y/PCI support added. Changes in the cy_init routine and
 405  * board initialization. Changes in the boot messages. The driver
 406  * supports up to 4 boards and 64 ports by default.
 407  *
 408  * Revision 1.36.1.4  1995/03/29  06:14:14  bentson
 409  * disambiguate between Cyclom-16Y and Cyclom-32Ye;
 410  *
 411  * Revision 1.36.1.3  1995/03/23  22:15:35  bentson
 412  * add missing break in modem control block in ioctl switch statement
 413  * (discovered by Michael Edward Chastain <[email protected]>);
 414  *
 415  * Revision 1.36.1.2  1995/03/22  19:16:22  bentson
 416  * make sure CTS flow control is set as soon as possible (thanks
 417  * to note from David Lambert <[email protected]>);
 418  *
 419  * Revision 1.36.1.1  1995/03/13  15:44:43  bentson
 420  * initialize defaults for receive threshold and stale data timeout;
 421  * cosmetic changes;
 422  *
 423  * Revision 1.36  1995/03/10  23:33:53  bentson
 424  * added support of chips 4-7 in 32 port Cyclom-Ye;
 425  * fix cy_interrupt pointer dereference problem
 426  * (Joe Portman <[email protected]>);
 427  * give better error response if open is attempted on non-existent port
 428  * (Zachariah Vaum <[email protected]>);
 429  * correct command timeout (Kenneth Lerman <lerman@@seltd.newnet.com>);
 430  * conditional compilation for -16Y on systems with fast, noisy bus;
 431  * comment out diagnostic print function;
 432  * cleaned up table of base addresses;
 433  * set receiver time-out period register to correct value,
 434  * set receive threshold to better default values,
 435  * set chip timer to more accurate 200 Hz ticking,
 436  * add code to monitor and modify receive parameters
 437  * (Rik Faith <[email protected]> Nick Simicich
 438  * <[email protected]>);
 439  *
 440  * Revision 1.35  1994/12/16  13:54:18  steffen
 441  * additional patch by Marcio Saito for board detection
 442  * Accidently left out in 1.34
 443  *
 444  * Revision 1.34  1994/12/10  12:37:12  steffen
 445  * This is the corrected version as suggested by Marcio Saito
 446  *
 447  * Revision 1.33  1994/12/01  22:41:18  bentson
 448  * add hooks to support more high speeds directly; add tytso
 449  * patch regarding CLOCAL wakeups
 450  *
 451  * Revision 1.32  1994/11/23  19:50:04  bentson
 452  * allow direct kernel control of higher signalling rates;
 453  * look for cards at additional locations
 454  *
 455  * Revision 1.31  1994/11/16  04:33:28  bentson
 456  * ANOTHER fix from Corey Minyard, [email protected]
 457  * a problem in chars_in_buffer has been resolved by some
 458  * small changes;  this should yield smoother output
 459  *
 460  * Revision 1.30  1994/11/16  04:28:05  bentson
 461  * Fix from Corey Minyard, Internet: [email protected],
 462  * UUCP: [email protected], WORK: minyardbnr.ca, to
 463  * cy_hangup that appears to clear up much (all?) of the
 464  * DTR glitches; also he's added/cleaned-up diagnostic messages
 465  *
 466  * Revision 1.29  1994/11/16  04:16:07  bentson
 467  * add change proposed by Ralph Sims, [email protected], to
 468  * operate higher speeds in same way as other serial ports;
 469  * add more serial ports (for up to two 16-port muxes).
 470  *
 471  * Revision 1.28  1994/11/04  00:13:16  root
 472  * turn off diagnostic messages
 473  *
 474  * Revision 1.27  1994/11/03  23:46:37  root
 475  * bunch of changes to bring driver into greater conformance
 476  * with the serial.c driver (looking for missed fixes)
 477  *
 478  * Revision 1.26  1994/11/03  22:40:36  root
 479  * automatic interrupt probing fixed.
 480  *
 481  * Revision 1.25  1994/11/03  20:17:02  root
 482  * start to implement auto-irq
 483  *
 484  * Revision 1.24  1994/11/03  18:01:55  root
 485  * still working on modem signals--trying not to drop DTR
 486  * during the getty/login processes
 487  *
 488  * Revision 1.23  1994/11/03  17:51:36  root
 489  * extend baud rate support; set receive threshold as function
 490  * of baud rate; fix some problems with RTS/CTS;
 491  *
 492  * Revision 1.22  1994/11/02  18:05:35  root
 493  * changed arguments to udelay to type long to get
 494  * delays to be of correct duration
 495  *
 496  * Revision 1.21  1994/11/02  17:37:30  root
 497  * employ udelay (after calibrating loops_per_second earlier
 498  * in init/main.c) instead of using home-grown delay routines
 499  *
 500  * Revision 1.20  1994/11/02  03:11:38  root
 501  * cy_chars_in_buffer forces a return value of 0 to let
 502  * login work (don't know why it does); some functions
 503  * that were returning EFAULT, now executes the code;
 504  * more work on deciding when to disable xmit interrupts;
 505  *
 506  * Revision 1.19  1994/11/01  20:10:14  root
 507  * define routine to start transmission interrupts (by enabling
 508  * transmit interrupts); directly enable/disable modem interrupts;
 509  *
 510  * Revision 1.18  1994/11/01  18:40:45  bentson
 511  * Don't always enable transmit interrupts in startup; interrupt on
 512  * TxMpty instead of TxRdy to help characters get out before shutdown;
 513  * restructure xmit interrupt to check for chars first and quit if
 514  * none are ready to go; modem status (MXVRx) is upright, _not_ inverted
 515  * (to my view);
 516  *
 517  * Revision 1.17  1994/10/30  04:39:45  bentson
 518  * rename serial_driver and callout_driver to cy_serial_driver and
 519  * cy_callout_driver to avoid linkage interference; initialize
 520  * info->type to PORT_CIRRUS; ruggedize paranoia test; elide ->port
 521  * from cyclades_port structure; add paranoia check to cy_close;
 522  *
 523  * Revision 1.16  1994/10/30  01:14:33  bentson
 524  * change major numbers; add some _early_ return statements;
 525  *
 526  * Revision 1.15  1994/10/29  06:43:15  bentson
 527  * final tidying up for clean compile;  enable some error reporting
 528  *
 529  * Revision 1.14  1994/10/28  20:30:22  Bentson
 530  * lots of changes to drag the driver towards the new tty_io
 531  * structures and operation.  not expected to work, but may
 532  * compile cleanly.
 533  *
 534  * Revision 1.13  1994/07/21  23:08:57  Bentson
 535  * add some diagnostic cruft; support 24 lines (for testing
 536  * both -8Y and -16Y cards; be more thorough in servicing all
 537  * chips during interrupt; add "volatile" a few places to
 538  * circumvent compiler optimizations; fix base & offset
 539  * computations in block_til_ready (was causing chip 0 to
 540  * stop operation)
 541  *
 542  * Revision 1.12  1994/07/19  16:42:11  Bentson
 543  * add some hackery for kernel version 1.1.8; expand
 544  * error messages; refine timing for delay loops and
 545  * declare loop params volatile
 546  *
 547  * Revision 1.11  1994/06/11  21:53:10  bentson
 548  * get use of save_car right in transmit interrupt service
 549  *
 550  * Revision 1.10.1.1  1994/06/11  21:31:18  bentson
 551  * add some diagnostic printing; try to fix save_car stuff
 552  *
 553  * Revision 1.10  1994/06/11  20:36:08  bentson
 554  * clean up compiler warnings
 555  *
 556  * Revision 1.9  1994/06/11  19:42:46  bentson
 557  * added a bunch of code to support modem signalling
 558  *
 559  * Revision 1.8  1994/06/11  17:57:07  bentson
 560  * recognize break & parity error
 561  *
 562  * Revision 1.7  1994/06/05  05:51:34  bentson
 563  * Reorder baud table to be monotonic; add cli to CP; discard
 564  * incoming characters and status if the line isn't open; start to
 565  * fold code into cy_throttle; start to port get_serial_info,
 566  * set_serial_info, get_modem_info, set_modem_info, and send_break
 567  * from serial.c; expand cy_ioctl; relocate and expand config_setup;
 568  * get flow control characters from tty struct; invalidate ports w/o
 569  * hardware;
 570  *
 571  * Revision 1.6  1994/05/31  18:42:21  bentson
 572  * add a loop-breaker in the interrupt service routine;
 573  * note when port is initialized so that it can be shut
 574  * down under the right conditions; receive works without
 575  * any obvious errors
 576  *
 577  * Revision 1.5  1994/05/30  00:55:02  bentson
 578  * transmit works without obvious errors
 579  *
 580  * Revision 1.4  1994/05/27  18:46:27  bentson
 581  * incorporated more code from lib_y.c; can now print short
 582  * strings under interrupt control to port zero; seems to
 583  * select ports/channels/lines correctly
 584  *
 585  * Revision 1.3  1994/05/25  22:12:44  bentson
 586  * shifting from multi-port on a card to proper multiplexor
 587  * data structures;  added skeletons of most routines
 588  *
 589  * Revision 1.2  1994/05/19  13:21:43  bentson
 590  * start to crib from other sources
 591  *
 592  */
 593
 594 #define CY_VERSION      "2.4"
 595
 596 /* If you need to install more boards than NR_CARDS, change the constant
 597    in the definition below. No other change is necessary to support up to
 598    eight boards. Beyond that you'll have to extend cy_isa_addresses. */
 599
 600 #define NR_CARDS        4
 601
 602 /*
 603    If the total number of ports is larger than NR_PORTS, change this
 604    constant in the definition below. No other change is necessary to
 605    support more boards/ports. */
 606
 607 #define NR_PORTS        256
 608
 609 #define ZE_V1_NPORTS    64
 610 #define ZO_V1   0
 611 #define ZO_V2   1
 612 #define ZE_V1   2
 613
 614 #define SERIAL_PARANOIA_CHECK
 615 #undef  CY_DEBUG_OPEN
 616 #undef  CY_DEBUG_THROTTLE
 617 #undef  CY_DEBUG_OTHER
 618 #undef  CY_DEBUG_IO
 619 #undef  CY_DEBUG_COUNT
 620 #undef  CY_DEBUG_DTR
 621 #undef  CY_DEBUG_WAIT_UNTIL_SENT
 622 #undef  CY_DEBUG_INTERRUPTS
 623 #undef  CY_16Y_HACK
 624 #undef  CY_ENABLE_MONITORING
 625 #undef  CY_PCI_DEBUG
 626
 627 /*
 628  * Include section
 629  */
 630 #include <linux/module.h>
 631 #include <linux/errno.h>
 632 #include <linux/signal.h>
 633 #include <linux/sched.h>
 634 #include <linux/timer.h>
 635 #include <linux/interrupt.h>
 636 #include <linux/tty.h>
 637 #include <linux/tty_flip.h>
 638 #include <linux/serial.h>
 639 #include <linux/major.h>
 640 #include <linux/string.h>
 641 #include <linux/fcntl.h>
 642 #include <linux/ptrace.h>
 643 #include <linux/cyclades.h>
 644 #include <linux/mm.h>
 645 #include <linux/ioport.h>
 646 #include <linux/init.h>
 647 #include <linux/delay.h>
 648 #include <linux/spinlock.h>
 649 #include <linux/bitops.h>
 650
 651 #include <asm/system.h>
 652 #include <asm/io.h>
 653 #include <asm/irq.h>
 654 #include <asm/uaccess.h>
 655
 656 #define CY_LOCK(info,flags)                                     \
 657                 do {                                            \
 658                 spin_lock_irqsave(&cy_card[info->card].card_lock, flags); \
 659                 } while (0)
 660
 661 #define CY_UNLOCK(info,flags)                                   \
 662                 do {                                            \
 663                 spin_unlock_irqrestore(&cy_card[info->card].card_lock, flags); \
 664                 } while (0)
 665
 666 #include <linux/kernel.h>
 667 #include <linux/pci.h>
 668
 669 #include <linux/stat.h>
 670 #include <linux/proc_fs.h>
 671
 672 static void cy_throttle(struct tty_struct *tty);
 673 static void cy_send_xchar(struct tty_struct *tty, char ch);
 674
 675 #define IS_CYC_Z(card) ((card).num_chips == -1)
 676
 677 #define Z_FPGA_CHECK(card) \
 678         ((readl(&((struct RUNTIME_9060 __iomem *) \
 679                 ((card).ctl_addr))->init_ctrl) & (1<<17)) != 0)
 680
 681 #define ISZLOADED(card) (((ZO_V1==readl(&((struct RUNTIME_9060 __iomem *) \
 682                         ((card).ctl_addr))->mail_box_0)) || \
 683                         Z_FPGA_CHECK(card)) && \
 684                         (ZFIRM_ID==readl(&((struct FIRM_ID __iomem *) \
 685                         ((card).base_addr+ID_ADDRESS))->signature)))
 686
 687 #ifndef SERIAL_XMIT_SIZE
 688 #define SERIAL_XMIT_SIZE        (min(PAGE_SIZE, 4096))
 689 #endif
 690 #define WAKEUP_CHARS            256
 691
 692 #define STD_COM_FLAGS (0)
 693
 694 static struct tty_driver *cy_serial_driver;
 695
 696 #ifdef CONFIG_ISA
 697 /* This is the address lookup table. The driver will probe for
 698    Cyclom-Y/ISA boards at all addresses in here. If you want the
 699    driver to probe addresses at a different address, add it to
 700    this table.  If the driver is probing some other board and
 701    causing problems, remove the offending address from this table.
 702    The cy_setup function extracts additional addresses from the
 703    boot options line.  The form is "cyclades=address,address..."
 704 */
 705
 706 static unsigned int cy_isa_addresses[] = {
 707         0xD0000,
 708         0xD2000,
 709         0xD4000,
 710         0xD6000,
 711         0xD8000,
 712         0xDA000,
 713         0xDC000,
 714         0xDE000,
 715         0, 0, 0, 0, 0, 0, 0, 0
 716 };
 717
 718 #define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
 719
 720 #ifdef MODULE
 721 static long maddr[NR_CARDS] = { 0, };
 722 static int irq[NR_CARDS] = { 0, };
 723
 724 module_param_array(maddr, long, NULL, 0);
 725 module_param_array(irq, int, NULL, 0);
 726 #endif
 727
 728 #endif                          /* CONFIG_ISA */
 729
 730 /* This is the per-card data structure containing address, irq, number of
 731    channels, etc. This driver supports a maximum of NR_CARDS cards.
 732 */
 733 static struct cyclades_card cy_card[NR_CARDS];
 734
 735 /* This is the per-channel data structure containing pointers, flags
 736  and variables for the port. This driver supports a maximum of NR_PORTS.
 737 */
 738 static struct cyclades_port cy_port[NR_PORTS];
 739
 740 static int cy_next_channel;     /* next minor available */
 741
 742 /*
 743  * This is used to look up the divisor speeds and the timeouts
 744  * We're normally limited to 15 distinct baud rates.  The extra
 745  * are accessed via settings in info->flags.
 746  *      0,     1,     2,     3,     4,     5,     6,     7,     8,     9,
 747  *     10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
 748  *                                               HI            VHI
 749  *     20
 750  */
 751 static int baud_table[] = {
 752         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
 753         1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
 754         230400, 0
 755 };
 756
 757 static char baud_co_25[] = {    /* 25 MHz clock option table */
 758         /* value =>    00    01   02    03    04 */
 759         /* divide by    8    32   128   512  2048 */
 760         0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
 761         0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 762 };
 763
 764 static char baud_bpr_25[] = {   /* 25 MHz baud rate period table */
 765         0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
 766         0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
 767 };
 768
 769 static char baud_co_60[] = {    /* 60 MHz clock option table (CD1400 J) */
 770         /* value =>    00    01   02    03    04 */
 771         /* divide by    8    32   128   512  2048 */
 772         0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
 773         0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
 774         0x00
 775 };
 776
 777 static char baud_bpr_60[] = {   /* 60 MHz baud rate period table (CD1400 J) */
 778         0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62,
 779         0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32,
 780         0x21
 781 };
 782
 783 static char baud_cor3[] = {     /* receive threshold */
 784         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
 785         0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07,
 786         0x07
 787 };
 788
 789 /*
 790  * The Cyclades driver implements HW flow control as any serial driver.
 791  * The cyclades_port structure member rflow and the vector rflow_thr
 792  * allows us to take advantage of a special feature in the CD1400 to avoid
 793  * data loss even when the system interrupt latency is too high. These flags
 794  * are to be used only with very special applications. Setting these flags
 795  * requires the use of a special cable (DTR and RTS reversed). In the new
 796  * CD1400-based boards (rev. 6.00 or later), there is no need for special
 797  * cables.
 798  */
 799
 800 static char rflow_thr[] = {     /* rflow threshold */
 801         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 802         0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
 803         0x0a
 804 };
 805
 806 /*  The Cyclom-Ye has placed the sequential chips in non-sequential
 807  *  address order.  This look-up table overcomes that problem.
 808  */
 809 static int cy_chip_offset[] = { 0x0000,
 810         0x0400,
 811         0x0800,
 812         0x0C00,
 813         0x0200,
 814         0x0600,
 815         0x0A00,
 816         0x0E00
 817 };
 818
 819 /* PCI related definitions */
 820
 821 #ifdef CONFIG_PCI
 822 static struct pci_device_id cy_pci_dev_id[] __devinitdata = {
 823         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo) },      /* PCI < 1Mb */
 824         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Hi) },      /* PCI > 1Mb */
 825         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Lo) },     /* 4Y PCI < 1Mb */
 826         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Hi) },     /* 4Y PCI > 1Mb */
 827         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Lo) },     /* 8Y PCI < 1Mb */
 828         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Hi) },     /* 8Y PCI > 1Mb */
 829         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Lo) },      /* Z PCI < 1Mb */
 830         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Hi) },      /* Z PCI > 1Mb */
 831         { }                     /* end of table */
 832 };
 833 MODULE_DEVICE_TABLE(pci, cy_pci_dev_id);
 834 #endif
 835
 836 static void cy_start(struct tty_struct *);
 837 static void set_line_char(struct cyclades_port *);
 838 static int cyz_issue_cmd(struct cyclades_card *, __u32, __u8, __u32);
 839 #ifdef CONFIG_ISA
 840 static unsigned detect_isa_irq(void __iomem *);
 841 #endif                          /* CONFIG_ISA */
 842
 843 static int cyclades_get_proc_info(char *, char **, off_t, int, int *, void *);
 844
 845 #ifndef CONFIG_CYZ_INTR
 846 static void cyz_poll(unsigned long);
 847
 848 /* The Cyclades-Z polling cycle is defined by this variable */
 849 static long cyz_polling_cycle = CZ_DEF_POLL;
 850
 851 static DEFINE_TIMER(cyz_timerlist, cyz_poll, 0, 0);
 852
 853 #else                           /* CONFIG_CYZ_INTR */
 854 static void cyz_rx_restart(unsigned long);
 855 static struct timer_list cyz_rx_full_timer[NR_PORTS];
 856 #endif                          /* CONFIG_CYZ_INTR */
 857
 858 static inline int serial_paranoia_check(struct cyclades_port *info,
 859                 char *name, const char *routine)
 860 {
 861 #ifdef SERIAL_PARANOIA_CHECK
 862         if (!info) {
 863                 printk("cyc Warning: null cyclades_port for (%s) in %s\n",
 864                                 name, routine);
 865                 return 1;
 866         }
 867
 868         if ((long)info < (long)(&cy_port[0]) ||
 869                         (long)(&cy_port[NR_PORTS]) < (long)info) {
 870                 printk("cyc Warning: cyclades_port out of range for (%s) in "
 871                                 "%s\n", name, routine);
 872                 return 1;
 873         }
 874
 875         if (info->magic != CYCLADES_MAGIC) {
 876                 printk("cyc Warning: bad magic number for serial struct (%s) "
 877                                 "in %s\n", name, routine);
 878                 return 1;
 879         }
 880 #endif
 881         return 0;
 882 }                               /* serial_paranoia_check */
 883
 884 /*
 885  * This routine is used by the interrupt handler to schedule
 886  * processing in the software interrupt portion of the driver
 887  * (also known as the "bottom half").  This can be called any
 888  * number of times for any channel without harm.
 889  */
 890 static inline void cy_sched_event(struct cyclades_port *info, int event)
 891 {
 892         info->event |= 1 << event; /* remember what kind of event and who */
 893         schedule_work(&info->tqueue);
 894 }                               /* cy_sched_event */
 895
 896 /*
 897  * This routine is used to handle the "bottom half" processing for the
 898  * serial driver, known also the "software interrupt" processing.
 899  * This processing is done at the kernel interrupt level, after the
 900  * cy#/_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON.  This
 901  * is where time-consuming activities which can not be done in the
 902  * interrupt driver proper are done; the interrupt driver schedules
 903  * them using cy_sched_event(), and they get done here.
 904  *
 905  * This is done through one level of indirection--the task queue.
 906  * When a hardware interrupt service routine wants service by the
 907  * driver's bottom half, it enqueues the appropriate tq_struct (one
 908  * per port) to the keventd work queue and sets a request flag
 909  * that the work queue be processed.
 910  *
 911  * Although this may seem unwieldy, it gives the system a way to
 912  * pass an argument (in this case the pointer to the cyclades_port
 913  * structure) to the bottom half of the driver.  Previous kernels
 914  * had to poll every port to see if that port needed servicing.
 915  */
 916 static void
 917 do_softint(struct work_struct *work)
 918 {
 919         struct cyclades_port *info =
 920                 container_of(work, struct cyclades_port, tqueue);
 921         struct tty_struct    *tty;
 922
 923         tty = info->tty;
 924         if (!tty)
 925                 return;
 926
 927         if (test_and_clear_bit(Cy_EVENT_HANGUP, &info->event)) {
 928                 tty_hangup(info->tty);
 929                 wake_up_interruptible(&info->open_wait);
 930                         info->flags &= ~ASYNC_NORMAL_ACTIVE;
 931         }
 932         if (test_and_clear_bit(Cy_EVENT_OPEN_WAKEUP, &info->event))
 933                 wake_up_interruptible(&info->open_wait);
 934 #ifdef CONFIG_CYZ_INTR
 935         if (test_and_clear_bit(Cy_EVENT_Z_RX_FULL, &info->event)) {
 936                 if (cyz_rx_full_timer[info->line].function == NULL) {
 937                         cyz_rx_full_timer[info->line].expires = jiffies + 1;
 938                         cyz_rx_full_timer[info->line].function = cyz_rx_restart;
 939                         cyz_rx_full_timer[info->line].data =
 940                                                 (unsigned long)info;
 941                         add_timer(&cyz_rx_full_timer[info->line]);
 942                 }
 943         }
 944 #endif
 945         if (test_and_clear_bit(Cy_EVENT_DELTA_WAKEUP, &info->event))
 946                 wake_up_interruptible(&info->delta_msr_wait);
 947         tty_wakeup(tty);
 948 #ifdef Z_WAKE
 949         if (test_and_clear_bit(Cy_EVENT_SHUTDOWN_WAKEUP, &info->event))
 950                 wake_up_interruptible(&info->shutdown_wait);
 951 #endif
 952 } /* do_softint */
 953
 954
 955 /***********************************************************/
 956 /********* Start of block of Cyclom-Y specific code ********/
 957
 958 /* This routine waits up to 1000 micro-seconds for the previous
 959    command to the Cirrus chip to complete and then issues the
 960    new command.  An error is returned if the previous command
 961    didn't finish within the time limit.
 962
 963    This function is only called from inside spinlock-protected code.
 964  */
 965 static int cyy_issue_cmd(void __iomem * base_addr, u_char cmd, int index)
 966 {
 967         unsigned int i;
 968
 969         /* Check to see that the previous command has completed */
 970         for (i = 0; i < 100; i++) {
 971                 if (readb(base_addr + (CyCCR << index)) == 0) {
 972                         break;
 973                 }
 974                 udelay(10L);
 975         }
 976         /* if the CCR never cleared, the previous command
 977            didn't finish within the "reasonable time" */
 978         if (i == 100)
 979                 return -1;
 980
 981         /* Issue the new command */
 982         cy_writeb(base_addr + (CyCCR << index), cmd);
 983
 984         return 0;
 985 }                               /* cyy_issue_cmd */
 986
 987 #ifdef CONFIG_ISA
 988 /* ISA interrupt detection code */
 989 static unsigned detect_isa_irq(void __iomem * address)
 990 {
 991         int irq;
 992         unsigned long irqs, flags;
 993         int save_xir, save_car;
 994         int index = 0;          /* IRQ probing is only for ISA */
 995
 996         /* forget possible initially masked and pending IRQ */
 997         irq = probe_irq_off(probe_irq_on());
 998
 999         /* Clear interrupts on the board first */
1000         cy_writeb(address + (Cy_ClrIntr << index), 0);
1001         /* Cy_ClrIntr is 0x1800 */
1002
1003         irqs = probe_irq_on();
1004         /* Wait ... */
1005         udelay(5000L);
1006
1007         /* Enable the Tx interrupts on the CD1400 */
1008         local_irq_save(flags);
1009         cy_writeb(address + (CyCAR << index), 0);
1010         cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
1011
1012         cy_writeb(address + (CyCAR << index), 0);
1013         cy_writeb(address + (CySRER << index),
1014                   readb(address + (CySRER << index)) | CyTxRdy);
1015         local_irq_restore(flags);
1016
1017         /* Wait ... */
1018         udelay(5000L);
1019
1020         /* Check which interrupt is in use */
1021         irq = probe_irq_off(irqs);
1022
1023         /* Clean up */
1024         save_xir = (u_char) readb(address + (CyTIR << index));
1025         save_car = readb(address + (CyCAR << index));
1026         cy_writeb(address + (CyCAR << index), (save_xir & 0x3));
1027         cy_writeb(address + (CySRER << index),
1028                   readb(address + (CySRER << index)) & ~CyTxRdy);
1029         cy_writeb(address + (CyTIR << index), (save_xir & 0x3f));
1030         cy_writeb(address + (CyCAR << index), (save_car));
1031         cy_writeb(address + (Cy_ClrIntr << index), 0);
1032         /* Cy_ClrIntr is 0x1800 */
1033
1034         return (irq > 0) ? irq : 0;
1035 }
1036 #endif                          /* CONFIG_ISA */
1037
1038 static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
1039                         void __iomem * base_addr, int status, int index)
1040 {
1041         struct cyclades_port *info;
1042         struct tty_struct *tty;
1043         int char_count;
1044         int i, j, len, mdm_change, mdm_status, outch;
1045         int save_xir, channel, save_car;
1046         char data;
1047
1048         if (status & CySRReceive) {     /* reception interrupt */
1049 #ifdef CY_DEBUG_INTERRUPTS
1050                 printk("cyy_interrupt: rcvd intr, chip %d\n\r", chip);
1051 #endif
1052                 /* determine the channel & change to that context */
1053                 spin_lock(&cinfo->card_lock);
1054                 save_xir = (u_char) readb(base_addr + (CyRIR << index));
1055                 channel = (u_short) (save_xir & CyIRChannel);
1056                 i = channel + chip * 4 + cinfo->first_line;
1057                 info = &cy_port[i];
1058                 info->last_active = jiffies;
1059                 save_car = readb(base_addr + (CyCAR << index));
1060                 cy_writeb(base_addr + (CyCAR << index), save_xir);
1061
1062                 /* if there is nowhere to put the data, discard it */
1063                 if (info->tty == 0) {
1064                         j = (readb(base_addr + (CyRIVR << index)) &
1065                                 CyIVRMask);
1066                         if (j == CyIVRRxEx) {   /* exception */
1067                                 data = readb(base_addr + (CyRDSR << index));
1068                         } else {        /* normal character reception */
1069                                 char_count = readb(base_addr +
1070                                                 (CyRDCR << index));
1071                                 while (char_count--) {
1072                                         data = readb(base_addr +
1073                                                 (CyRDSR << index));
1074                                 }
1075                         }
1076                 } else {        /* there is an open port for this data */
1077                         tty = info->tty;
1078                         j = (readb(base_addr + (CyRIVR << index)) &
1079                                         CyIVRMask);
1080                         if (j == CyIVRRxEx) {   /* exception */
1081                                 data = readb(base_addr + (CyRDSR << index));
1082
1083                                 /* For statistics only */
1084                                 if (data & CyBREAK)
1085                                         info->icount.brk++;
1086                                 else if (data & CyFRAME)
1087                                         info->icount.frame++;
1088                                 else if (data & CyPARITY)
1089                                         info->icount.parity++;
1090                                 else if (data & CyOVERRUN)
1091                                         info->icount.overrun++;
1092
1093                                 if (data & info->ignore_status_mask) {
1094                                         info->icount.rx++;
1095                                         return;
1096                                 }
1097                                 if (tty_buffer_request_room(tty, 1)) {
1098                                         if (data & info->read_status_mask) {
1099                                                 if (data & CyBREAK) {
1100                                                         tty_insert_flip_char(
1101                                                                 tty,
1102                                                                 readb(
1103                                                                 base_addr +
1104                                                                 (CyRDSR <<
1105                                                                         index)),
1106                                                                 TTY_BREAK);
1107                                                         info->icount.rx++;
1108                                                         if (info->flags &
1109                                                             ASYNC_SAK) {
1110                                                                 do_SAK(tty);
1111                                                         }
1112                                                 } else if (data & CyFRAME) {
1113                                                         tty_insert_flip_char(
1114                                                                 tty,
1115                                                                 readb(
1116                                                                 base_addr +
1117                                                                 (CyRDSR <<
1118                                                                         index)),
1119                                                                 TTY_FRAME);
1120                                                         info->icount.rx++;
1121                                                         info->idle_stats.
1122                                                                 frame_errs++;
1123                                                 } else if (data & CyPARITY) {
1124                                                         /* Pieces of seven... */
1125                                                         tty_insert_flip_char(
1126                                                                 tty,
1127                                                                 readb(
1128                                                                 base_addr +
1129                                                                 (CyRDSR <<
1130                                                                         index)),
1131                                                                 TTY_PARITY);
1132                                                         info->icount.rx++;
1133                                                         info->idle_stats.
1134                                                                 parity_errs++;
1135                                                 } else if (data & CyOVERRUN) {
1136                                                         tty_insert_flip_char(
1137                                                                 tty, 0,
1138                                                                 TTY_OVERRUN);
1139                                                         info->icount.rx++;
1140                                                 /* If the flip buffer itself is
1141                                                    overflowing, we still lose
1142                                                    the next incoming character.
1143                                                  */
1144                                                         tty_insert_flip_char(
1145                                                                 tty,
1146                                                                 readb(
1147                                                                 base_addr +
1148                                                                 (CyRDSR <<
1149                                                                         index)),
1150                                                                 TTY_FRAME);
1151                                                         info->icount.rx++;
1152                                                         info->idle_stats.
1153                                                                 overruns++;
1154                                         /* These two conditions may imply */
1155                                         /* a normal read should be done. */
1156                                         /* }else if(data & CyTIMEOUT){ */
1157                                         /* }else if(data & CySPECHAR){ */
1158                                                 } else {
1159                                                         tty_insert_flip_char(
1160                                                                 tty, 0,
1161                                                                 TTY_NORMAL);
1162                                                         info->icount.rx++;
1163                                                 }
1164                                         } else {
1165                                                 tty_insert_flip_char(tty, 0,
1166                                                                 TTY_NORMAL);
1167                                                 info->icount.rx++;
1168                                         }
1169                                 } else {
1170                                         /* there was a software buffer
1171                                            overrun and nothing could be
1172                                            done about it!!! */
1173                                         info->icount.buf_overrun++;
1174                                         info->idle_stats.overruns++;
1175                                 }
1176                         } else {        /* normal character reception */
1177                                 /* load # chars available from the chip */
1178                                 char_count = readb(base_addr +
1179                                                 (CyRDCR << index));
1180
1181 #ifdef CY_ENABLE_MONITORING
1182                                 ++info->mon.int_count;
1183                                 info->mon.char_count += char_count;
1184                                 if (char_count > info->mon.char_max)
1185                                         info->mon.char_max = char_count;
1186                                 info->mon.char_last = char_count;
1187 #endif
1188                                 len = tty_buffer_request_room(tty, char_count);
1189                                 while (len--) {
1190                                         data = readb(base_addr +
1191                                                         (CyRDSR << index));
1192                                         tty_insert_flip_char(tty, data,
1193                                                         TTY_NORMAL);
1194                                         info->idle_stats.recv_bytes++;
1195                                         info->icount.rx++;
1196 #ifdef CY_16Y_HACK
1197                                         udelay(10L);
1198 #endif
1199                                 }
1200                                 info->idle_stats.recv_idle = jiffies;
1201                         }
1202                         tty_schedule_flip(tty);
1203                 }
1204                 /* end of service */
1205                 cy_writeb(base_addr + (CyRIR << index), (save_xir & 0x3f));
1206                 cy_writeb(base_addr + (CyCAR << index), (save_car));
1207                 spin_unlock(&cinfo->card_lock);
1208         }
1209
1210         if (status & CySRTransmit) {    /* transmission interrupt */
1211                 /* Since we only get here when the transmit buffer
1212                    is empty, we know we can always stuff a dozen
1213                    characters. */
1214 #ifdef CY_DEBUG_INTERRUPTS
1215                 printk("cyy_interrupt: xmit intr, chip %d\n\r", chip);
1216 #endif
1217
1218                 /* determine the channel & change to that context */
1219                 spin_lock(&cinfo->card_lock);
1220                 save_xir = (u_char) readb(base_addr + (CyTIR << index));
1221                 channel = (u_short) (save_xir & CyIRChannel);
1222                 i = channel + chip * 4 + cinfo->first_line;
1223                 save_car = readb(base_addr + (CyCAR << index));
1224                 cy_writeb(base_addr + (CyCAR << index), save_xir);
1225
1226                 /* validate the port# (as configured and open) */
1227                 if ((i < 0) || (NR_PORTS <= i)) {
1228                         cy_writeb(base_addr + (CySRER << index),
1229                                   readb(base_addr + (CySRER << index)) &
1230                                   ~CyTxRdy);
1231                         goto txend;
1232                 }
1233                 info = &cy_port[i];
1234                 info->last_active = jiffies;
1235                 if (info->tty == 0) {
1236                         cy_writeb(base_addr + (CySRER << index),
1237                                   readb(base_addr + (CySRER << index)) &
1238                                   ~CyTxRdy);
1239                         goto txdone;
1240                 }
1241
1242                 /* load the on-chip space for outbound data */
1243                 char_count = info->xmit_fifo_size;
1244
1245                 if (info->x_char) {     /* send special char */
1246                         outch = info->x_char;
1247                         cy_writeb(base_addr + (CyTDR << index), outch);
1248                         char_count--;
1249                         info->icount.tx++;
1250                         info->x_char = 0;
1251                 }
1252
1253                 if (info->breakon || info->breakoff) {
1254                         if (info->breakon) {
1255                                 cy_writeb(base_addr + (CyTDR << index), 0);
1256                                 cy_writeb(base_addr + (CyTDR << index), 0x81);
1257                                 info->breakon = 0;
1258                                 char_count -= 2;
1259                         }
1260                         if (info->breakoff) {
1261                                 cy_writeb(base_addr + (CyTDR << index), 0);
1262                                 cy_writeb(base_addr + (CyTDR << index), 0x83);
1263                                 info->breakoff = 0;
1264                                 char_count -= 2;
1265                         }
1266                 }
1267
1268                 while (char_count-- > 0) {
1269                         if (!info->xmit_cnt) {
1270                                 if (readb(base_addr + (CySRER << index)) &
1271                                                 CyTxMpty) {
1272                                         cy_writeb(base_addr + (CySRER << index),
1273                                                 readb(base_addr +
1274                                                         (CySRER << index)) &
1275                                                 ~CyTxMpty);
1276                                 } else {
1277                                         cy_writeb(base_addr + (CySRER << index),
1278                                                 (readb(base_addr +
1279                                                         (CySRER << index)) &
1280                                                 ~CyTxRdy) | CyTxMpty);
1281                                 }
1282                                 goto txdone;
1283                         }
1284                         if (info->xmit_buf == 0) {
1285                                 cy_writeb(base_addr + (CySRER << index),
1286                                         readb(base_addr + (CySRER << index)) &
1287                                         ~CyTxRdy);
1288                                 goto txdone;
1289                         }
1290                         if (info->tty->stopped || info->tty->hw_stopped) {
1291                                 cy_writeb(base_addr + (CySRER << index),
1292                                         readb(base_addr + (CySRER << index)) &
1293                                         ~CyTxRdy);
1294                                 goto txdone;
1295                         }
1296                         /* Because the Embedded Transmit Commands have
1297                            been enabled, we must check to see if the
1298                            escape character, NULL, is being sent.  If it
1299                            is, we must ensure that there is room for it
1300                            to be doubled in the output stream.  Therefore
1301                            we no longer advance the pointer when the
1302                            character is fetched, but rather wait until
1303                            after the check for a NULL output character.
1304                            This is necessary because there may not be
1305                            room for the two chars needed to send a NULL.)
1306                          */
1307                         outch = info->xmit_buf[info->xmit_tail];
1308                         if (outch) {
1309                                 info->xmit_cnt--;
1310                                 info->xmit_tail = (info->xmit_tail + 1) &
1311                                                 (SERIAL_XMIT_SIZE - 1);
1312                                 cy_writeb(base_addr + (CyTDR << index), outch);
1313                                 info->icount.tx++;
1314                         } else {
1315                                 if (char_count > 1) {
1316                                         info->xmit_cnt--;
1317                                         info->xmit_tail = (info->xmit_tail + 1)&
1318                                                 (SERIAL_XMIT_SIZE - 1);
1319                                         cy_writeb(base_addr + (CyTDR << index),
1320                                                 outch);
1321                                         cy_writeb(base_addr + (CyTDR << index),
1322                                                 0);
1323                                         info->icount.tx++;
1324                                         char_count--;
1325                                 } else {
1326                                 }
1327                         }
1328                 }
1329
1330 txdone:
1331                 if (info->xmit_cnt < WAKEUP_CHARS) {
1332                         cy_sched_event(info, Cy_EVENT_WRITE_WAKEUP);
1333                 }
1334 txend:
1335                 /* end of service */
1336                 cy_writeb(base_addr + (CyTIR << index), (save_xir & 0x3f));
1337                 cy_writeb(base_addr + (CyCAR << index), (save_car));
1338                 spin_unlock(&cinfo->card_lock);
1339         }
1340
1341         if (status & CySRModem) {       /* modem interrupt */
1342
1343                 /* determine the channel & change to that context */
1344                 spin_lock(&cinfo->card_lock);
1345                 save_xir = (u_char) readb(base_addr + (CyMIR << index));
1346                 channel = (u_short) (save_xir & CyIRChannel);
1347                 info = &cy_port[channel + chip * 4 + cinfo->first_line];
1348                 info->last_active = jiffies;
1349                 save_car = readb(base_addr + (CyCAR << index));
1350                 cy_writeb(base_addr + (CyCAR << index), save_xir);
1351
1352                 mdm_change = readb(base_addr + (CyMISR << index));
1353                 mdm_status = readb(base_addr + (CyMSVR1 << index));
1354
1355                 if (info->tty == 0) {   /* no place for data, ignore it */
1356                         ;
1357                 } else {
1358                         if (mdm_change & CyANY_DELTA) {
1359                                 /* For statistics only */
1360                                 if (mdm_change & CyDCD)
1361                                         info->icount.dcd++;
1362                                 if (mdm_change & CyCTS)
1363                                         info->icount.cts++;
1364                                 if (mdm_change & CyDSR)
1365                                         info->icount.dsr++;
1366                                 if (mdm_change & CyRI)
1367                                         info->icount.rng++;
1368
1369                                 cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
1370                         }
1371
1372                         if ((mdm_change & CyDCD) &&
1373                                         (info->flags & ASYNC_CHECK_CD)) {
1374                                 if (mdm_status & CyDCD) {
1375                                         cy_sched_event(info,
1376                                                         Cy_EVENT_OPEN_WAKEUP);
1377                                 } else {
1378                                         cy_sched_event(info, Cy_EVENT_HANGUP);
1379                                 }
1380                         }
1381                         if ((mdm_change & CyCTS) &&
1382                                         (info->flags & ASYNC_CTS_FLOW)) {
1383                                 if (info->tty->hw_stopped) {
1384                                         if (mdm_status & CyCTS) {
1385                                                 /* cy_start isn't used
1386                                                    because... !!! */
1387                                                 info->tty->hw_stopped = 0;
1388                                                 cy_writeb(base_addr +
1389                                                         (CySRER << index),
1390                                                         readb(base_addr +
1391                                                                 (CySRER <<
1392                                                                         index))|
1393                                                         CyTxRdy);
1394                                                 cy_sched_event(info,
1395                                                         Cy_EVENT_WRITE_WAKEUP);
1396                                         }
1397                                 } else {
1398                                         if (!(mdm_status & CyCTS)) {
1399                                                 /* cy_stop isn't used
1400                                                    because ... !!! */
1401                                                 info->tty->hw_stopped = 1;
1402                                                 cy_writeb(base_addr +
1403                                                         (CySRER << index),
1404                                                         readb(base_addr +
1405                                                                 (CySRER <<
1406                                                                 index)) &
1407                                                         ~CyTxRdy);
1408                                         }
1409                                 }
1410                         }
1411                         if (mdm_change & CyDSR) {
1412                         }
1413                         if (mdm_change & CyRI) {
1414                         }
1415                 }
1416                 /* end of service */
1417                 cy_writeb(base_addr + (CyMIR << index), (save_xir & 0x3f));
1418                 cy_writeb(base_addr + (CyCAR << index), save_car);
1419                 spin_unlock(&cinfo->card_lock);
1420         }
1421 }
1422
1423 /* The real interrupt service routine is called
1424    whenever the card wants its hand held--chars
1425    received, out buffer empty, modem change, etc.
1426  */
1427 static irqreturn_t cyy_interrupt(int irq, void *dev_id)
1428 {
1429         int status;
1430         struct cyclades_card *cinfo;
1431         void __iomem *base_addr, *card_base_addr;
1432         int chip;
1433         int index;
1434         int too_many;
1435         int had_work;
1436
1437         if ((cinfo = (struct cyclades_card *)dev_id) == 0) {
1438 #ifdef CY_DEBUG_INTERRUPTS
1439                 printk("cyy_interrupt: spurious interrupt %d\n\r", irq);
1440 #endif
1441                 return IRQ_NONE;        /* spurious interrupt */
1442         }
1443
1444         card_base_addr = cinfo->base_addr;
1445         index = cinfo->bus_index;
1446
1447         /* card was not initialized yet (e.g. DEBUG_SHIRQ) */
1448         if (unlikely(card_base_addr == NULL))
1449                 return IRQ_HANDLED;
1450
1451         /* This loop checks all chips in the card.  Make a note whenever
1452            _any_ chip had some work to do, as this is considered an
1453            indication that there will be more to do.  Only when no chip
1454            has any work does this outermost loop exit.
1455          */
1456         do {
1457                 had_work = 0;
1458                 for (chip = 0; chip < cinfo->num_chips; chip++) {
1459                         base_addr = cinfo->base_addr +
1460                                         (cy_chip_offset[chip] << index);
1461                         too_many = 0;
1462                         while ((status = readb(base_addr +
1463                                                 (CySVRR << index))) != 0x00) {
1464                                 had_work++;
1465                         /* The purpose of the following test is to ensure that
1466                            no chip can monopolize the driver.  This forces the
1467                            chips to be checked in a round-robin fashion (after
1468                            draining each of a bunch (1000) of characters).
1469                          */
1470                                 if (1000 < too_many++) {
1471                                         break;
1472                                 }
1473                                 cyy_intr_chip(cinfo, chip, base_addr, status,
1474                                                 index);
1475                         }
1476                 }
1477         } while (had_work);
1478
1479         /* clear interrupts */
1480         spin_lock(&cinfo->card_lock);
1481         cy_writeb(card_base_addr + (Cy_ClrIntr << index), 0);
1482         /* Cy_ClrIntr is 0x1800 */
1483         spin_unlock(&cinfo->card_lock);
1484         return IRQ_HANDLED;
1485 }                               /* cyy_interrupt */
1486
1487 /***********************************************************/
1488 /********* End of block of Cyclom-Y specific code **********/
1489 /******** Start of block of Cyclades-Z specific code *********/
1490 /***********************************************************/
1491
1492 static int
1493 cyz_fetch_msg(struct cyclades_card *cinfo,
1494                 __u32 * channel, __u8 * cmd, __u32 * param)
1495 {
1496         struct FIRM_ID __iomem *firm_id;
1497         struct ZFW_CTRL __iomem *zfw_ctrl;
1498         struct BOARD_CTRL __iomem *board_ctrl;
1499         unsigned long loc_doorbell;
1500
1501         firm_id = cinfo->base_addr + ID_ADDRESS;
1502         if (!ISZLOADED(*cinfo)) {
1503                 return -1;
1504         }
1505         zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
1506         board_ctrl = &zfw_ctrl->board_ctrl;
1507
1508         loc_doorbell = readl(&((struct RUNTIME_9060 __iomem *)
1509                                   (cinfo->ctl_addr))->loc_doorbell);
1510         if (loc_doorbell) {
1511                 *cmd = (char)(0xff & loc_doorbell);
1512                 *channel = readl(&board_ctrl->fwcmd_channel);
1513                 *param = (__u32) readl(&board_ctrl->fwcmd_param);
1514                 cy_writel(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->
1515                           loc_doorbell, 0xffffffff);
1516                 return 1;
1517         }
1518         return 0;
1519 }                               /* cyz_fetch_msg */
1520
1521 static int
1522 cyz_issue_cmd(struct cyclades_card *cinfo,
1523                 __u32 channel, __u8 cmd, __u32 param)
1524 {
1525         struct FIRM_ID __iomem *firm_id;
1526         struct ZFW_CTRL __iomem *zfw_ctrl;
1527         struct BOARD_CTRL __iomem *board_ctrl;
1528         __u32 __iomem *pci_doorbell;
1529         int index;
1530
1531         firm_id = cinfo->base_addr + ID_ADDRESS;
1532         if (!ISZLOADED(*cinfo)) {
1533                 return -1;
1534         }
1535         zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
1536         board_ctrl = &zfw_ctrl->board_ctrl;
1537
1538         index = 0;
1539         pci_doorbell =
1540             &((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->pci_doorbell;
1541         while ((readl(pci_doorbell) & 0xff) != 0) {
1542                 if (index++ == 1000) {
1543                         return (int)(readl(pci_doorbell) & 0xff);
1544                 }
1545                 udelay(50L);
1546         }
1547         cy_writel(&board_ctrl->hcmd_channel, channel);
1548         cy_writel(&board_ctrl->hcmd_param, param);
1549         cy_writel(pci_doorbell, (long)cmd);
1550
1551         return 0;
1552 }                               /* cyz_issue_cmd */
1553
1554 static void
1555 cyz_handle_rx(struct cyclades_port *info, struct CH_CTRL __iomem *ch_ctrl,
1556                 struct BUF_CTRL __iomem *buf_ctrl)
1557 {
1558         struct cyclades_card *cinfo = &cy_card[info->card];
1559         struct tty_struct *tty = info->tty;
1560         int char_count;
1561         int len;
1562 #ifdef BLOCKMOVE
1563         int small_count;
1564 #else
1565         char data;
1566 #endif
1567         __u32 rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
1568
1569         rx_get = new_rx_get = readl(&buf_ctrl->rx_get);
1570         rx_put = readl(&buf_ctrl->rx_put);
1571         rx_bufsize = readl(&buf_ctrl->rx_bufsize);
1572         rx_bufaddr = readl(&buf_ctrl->rx_bufaddr);
1573         if (rx_put >= rx_get)
1574                 char_count = rx_put - rx_get;
1575         else
1576                 char_count = rx_put - rx_get + rx_bufsize;
1577
1578         if (char_count) {
1579                 info->last_active = jiffies;
1580                 info->jiffies[1] = jiffies;
1581
1582 #ifdef CY_ENABLE_MONITORING
1583                 info->mon.int_count++;
1584                 info->mon.char_count += char_count;
1585                 if (char_count > info->mon.char_max)
1586                         info->mon.char_max = char_count;
1587                 info->mon.char_last = char_count;
1588 #endif
1589                 if (tty == 0) {
1590                         /* flush received characters */
1591                         new_rx_get = (new_rx_get + char_count) &
1592                                         (rx_bufsize - 1);
1593                         info->rflush_count++;
1594                 } else {
1595 #ifdef BLOCKMOVE
1596                 /* we'd like to use memcpy(t, f, n) and memset(s, c, count)
1597                    for performance, but because of buffer boundaries, there
1598                    may be several steps to the operation */
1599                         while (0 < (small_count = min_t(unsigned int,
1600                                         rx_bufsize - new_rx_get,
1601                                         min_t(unsigned int, TTY_FLIPBUF_SIZE -
1602                                                 tty->flip.count, char_count)))){
1603                                 memcpy_fromio(tty->flip.char_buf_ptr,
1604                                         (char *)(cinfo->base_addr + rx_bufaddr +
1605                                                 new_rx_get),
1606                                         small_count);
1607
1608                                 tty->flip.char_buf_ptr += small_count;
1609                                 memset(tty->flip.flag_buf_ptr, TTY_NORMAL,
1610                                         small_count);
1611                                 tty->flip.flag_buf_ptr += small_count;
1612                                 new_rx_get = (new_rx_get + small_count) &
1613                                                 (rx_bufsize - 1);
1614                                 char_count -= small_count;
1615                                 info->icount.rx += small_count;
1616                                 info->idle_stats.recv_bytes += small_count;
1617                                 tty->flip.count += small_count;
1618                         }
1619 #else
1620                         len = tty_buffer_request_room(tty, char_count);
1621                         while (len--) {
1622                                 data = readb(cinfo->base_addr + rx_bufaddr +
1623                                                 new_rx_get);
1624                                 new_rx_get = (new_rx_get + 1)& (rx_bufsize - 1);
1625                                 tty_insert_flip_char(tty, data, TTY_NORMAL);
1626                                 info->idle_stats.recv_bytes++;
1627                                 info->icount.rx++;
1628                         }
1629 #endif
1630 #ifdef CONFIG_CYZ_INTR
1631                 /* Recalculate the number of chars in the RX buffer and issue
1632                    a cmd in case it's higher than the RX high water mark */
1633                         rx_put = readl(&buf_ctrl->rx_put);
1634                         if (rx_put >= rx_get)
1635                                 char_count = rx_put - rx_get;
1636                         else
1637                                 char_count = rx_put - rx_get + rx_bufsize;
1638                         if (char_count >= (int)readl(&buf_ctrl->rx_threshold)) {
1639                                 cy_sched_event(info, Cy_EVENT_Z_RX_FULL);
1640                         }
1641 #endif
1642                         info->idle_stats.recv_idle = jiffies;
1643                         tty_schedule_flip(tty);
1644                 }
1645                 /* Update rx_get */
1646                 cy_writel(&buf_ctrl->rx_get, new_rx_get);
1647         }
1648 }
1649
1650 static void
1651 cyz_handle_tx(struct cyclades_port *info, struct CH_CTRL __iomem *ch_ctrl,
1652                 struct BUF_CTRL __iomem *buf_ctrl)
1653 {
1654         struct cyclades_card *cinfo = &cy_card[info->card];
1655         struct tty_struct *tty = info->tty;
1656         char data;
1657         int char_count;
1658 #ifdef BLOCKMOVE
1659         int small_count;
1660 #endif
1661         __u32 tx_put, tx_get, tx_bufsize, tx_bufaddr;
1662
1663         if (info->xmit_cnt <= 0)        /* Nothing to transmit */
1664                 return;
1665
1666         tx_get = readl(&buf_ctrl->tx_get);
1667         tx_put = readl(&buf_ctrl->tx_put);
1668         tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1669         tx_bufaddr = readl(&buf_ctrl->tx_bufaddr);
1670         if (tx_put >= tx_get)
1671                 char_count = tx_get - tx_put - 1 + tx_bufsize;
1672         else
1673                 char_count = tx_get - tx_put - 1;
1674
1675         if (char_count) {
1676
1677                 if (tty == 0) {
1678                         goto ztxdone;
1679                 }
1680
1681                 if (info->x_char) {     /* send special char */
1682                         data = info->x_char;
1683
1684                         cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1685                         tx_put = (tx_put + 1) & (tx_bufsize - 1);
1686                         info->x_char = 0;
1687                         char_count--;
1688                         info->icount.tx++;
1689                         info->last_active = jiffies;
1690                         info->jiffies[2] = jiffies;
1691                 }
1692 #ifdef BLOCKMOVE
1693                 while (0 < (small_count = min_t(unsigned int,
1694                                 tx_bufsize - tx_put, min_t(unsigned int,
1695                                         (SERIAL_XMIT_SIZE - info->xmit_tail),
1696                                         min_t(unsigned int, info->xmit_cnt,
1697                                                 char_count))))) {
1698
1699                         memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr +
1700                                         tx_put),
1701                                         &info->xmit_buf[info->xmit_tail],
1702                                         small_count);
1703
1704                         tx_put = (tx_put + small_count) & (tx_bufsize - 1);
1705                         char_count -= small_count;
1706                         info->icount.tx += small_count;
1707                         info->xmit_cnt -= small_count;
1708                         info->xmit_tail = (info->xmit_tail + small_count) &
1709                                         (SERIAL_XMIT_SIZE - 1);
1710                         info->last_active = jiffies;
1711                         info->jiffies[2] = jiffies;
1712                 }
1713 #else
1714                 while (info->xmit_cnt && char_count) {
1715                         data = info->xmit_buf[info->xmit_tail];
1716                         info->xmit_cnt--;
1717                         info->xmit_tail = (info->xmit_tail + 1) &
1718                                         (SERIAL_XMIT_SIZE - 1);
1719
1720                         cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1721                         tx_put = (tx_put + 1) & (tx_bufsize - 1);
1722                         char_count--;
1723                         info->icount.tx++;
1724                         info->last_active = jiffies;
1725                         info->jiffies[2] = jiffies;
1726                 }
1727 #endif
1728 ztxdone:
1729                 if (info->xmit_cnt < WAKEUP_CHARS) {
1730                         cy_sched_event(info, Cy_EVENT_WRITE_WAKEUP);
1731                 }
1732                 /* Update tx_put */
1733                 cy_writel(&buf_ctrl->tx_put, tx_put);
1734         }
1735 }
1736
1737 static void cyz_handle_cmd(struct cyclades_card *cinfo)
1738 {
1739         struct tty_struct *tty;
1740         struct cyclades_port *info;
1741         static struct FIRM_ID __iomem *firm_id;
1742         static struct ZFW_CTRL __iomem *zfw_ctrl;
1743         static struct BOARD_CTRL __iomem *board_ctrl;
1744         static struct CH_CTRL __iomem *ch_ctrl;
1745         static struct BUF_CTRL __iomem *buf_ctrl;
1746         __u32 channel;
1747         __u8 cmd;
1748         __u32 param;
1749         __u32 hw_ver, fw_ver;
1750         int special_count;
1751         int delta_count;
1752
1753         firm_id = cinfo->base_addr + ID_ADDRESS;
1754         zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
1755         board_ctrl = &zfw_ctrl->board_ctrl;
1756         fw_ver = readl(&board_ctrl->fw_version);
1757         hw_ver = readl(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->
1758                         mail_box_0);
1759
1760         while (cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) {
1761                 special_count = 0;
1762                 delta_count = 0;
1763                 info = &cy_port[channel + cinfo->first_line];
1764                 if ((tty = info->tty) == 0) {
1765                         continue;
1766                 }
1767                 ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
1768                 buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
1769
1770                 switch (cmd) {
1771                 case C_CM_PR_ERROR:
1772                         tty_insert_flip_char(tty, 0, TTY_PARITY);
1773                         info->icount.rx++;
1774                         special_count++;
1775                         break;
1776                 case C_CM_FR_ERROR:
1777                         tty_insert_flip_char(tty, 0, TTY_FRAME);
1778                         info->icount.rx++;
1779                         special_count++;
1780                         break;
1781                 case C_CM_RXBRK:
1782                         tty_insert_flip_char(tty, 0, TTY_BREAK);
1783                         info->icount.rx++;
1784                         special_count++;
1785                         break;
1786                 case C_CM_MDCD:
1787                         info->icount.dcd++;
1788                         delta_count++;
1789                         if (info->flags & ASYNC_CHECK_CD) {
1790                                 if ((fw_ver > 241 ? ((u_long) param) :
1791                                                 readl(&ch_ctrl->rs_status)) &
1792                                                 C_RS_DCD) {
1793                                         cy_sched_event(info,
1794                                                         Cy_EVENT_OPEN_WAKEUP);
1795                                 } else {
1796                                         cy_sched_event(info, Cy_EVENT_HANGUP);
1797                                 }
1798                         }
1799                         break;
1800                 case C_CM_MCTS:
1801                         info->icount.cts++;
1802                         delta_count++;
1803                         break;
1804                 case C_CM_MRI:
1805                         info->icount.rng++;
1806                         delta_count++;
1807                         break;
1808                 case C_CM_MDSR:
1809                         info->icount.dsr++;
1810                         delta_count++;
1811                         break;
1812 #ifdef Z_WAKE
1813                 case C_CM_IOCTLW:
1814                         cy_sched_event(info, Cy_EVENT_SHUTDOWN_WAKEUP);
1815                         break;
1816 #endif
1817 #ifdef CONFIG_CYZ_INTR
1818                 case C_CM_RXHIWM:
1819                 case C_CM_RXNNDT:
1820                 case C_CM_INTBACK2:
1821                         /* Reception Interrupt */
1822 #ifdef CY_DEBUG_INTERRUPTS
1823                         printk("cyz_interrupt: rcvd intr, card %d, "
1824                                         "port %ld\n\r", info->card, channel);
1825 #endif
1826                         cyz_handle_rx(info, ch_ctrl, buf_ctrl);
1827                         break;
1828                 case C_CM_TXBEMPTY:
1829                 case C_CM_TXLOWWM:
1830                 case C_CM_INTBACK:
1831                         /* Transmission Interrupt */
1832 #ifdef CY_DEBUG_INTERRUPTS
1833                         printk("cyz_interrupt: xmit intr, card %d, "
1834                                         "port %ld\n\r", info->card, channel);
1835 #endif
1836                         cyz_handle_tx(info, ch_ctrl, buf_ctrl);
1837                         break;
1838 #endif                          /* CONFIG_CYZ_INTR */
1839                 case C_CM_FATAL:
1840                         /* should do something with this !!! */
1841                         break;
1842                 default:
1843                         break;
1844                 }
1845                 if (delta_count)
1846                         cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
1847                 if (special_count)
1848                         tty_schedule_flip(tty);
1849         }
1850 }
1851
1852 #ifdef CONFIG_CYZ_INTR
1853 static irqreturn_t cyz_interrupt(int irq, void *dev_id)
1854 {
1855         struct cyclades_card *cinfo;
1856
1857         if ((cinfo = (struct cyclades_card *)dev_id) == 0) {
1858 #ifdef CY_DEBUG_INTERRUPTS
1859                 printk("cyz_interrupt: spurious interrupt %d\n\r", irq);
1860 #endif
1861                 return IRQ_NONE;        /* spurious interrupt */
1862         }
1863
1864         if (!ISZLOADED(*cinfo)) {
1865 #ifdef CY_DEBUG_INTERRUPTS
1866                 printk("cyz_interrupt: board not yet loaded (IRQ%d).\n\r", irq);
1867 #endif
1868                 return IRQ_NONE;
1869         }
1870
1871         /* Handle the interrupts */
1872         cyz_handle_cmd(cinfo);
1873
1874         return IRQ_HANDLED;
1875 }                               /* cyz_interrupt */
1876
1877 static void cyz_rx_restart(unsigned long arg)
1878 {
1879         struct cyclades_port *info = (struct cyclades_port *)arg;
1880         int retval;
1881         int card = info->card;
1882         __u32 channel = (info->line) - (cy_card[card].first_line);
1883         unsigned long flags;
1884
1885         CY_LOCK(info, flags);
1886         retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_INTBACK2, 0L);
1887         if (retval != 0) {
1888                 printk("cyc:cyz_rx_restart retval on ttyC%d was %x\n",
1889                         info->line, retval);
1890         }
1891         cyz_rx_full_timer[info->line].function = NULL;
1892         CY_UNLOCK(info, flags);
1893 }
1894
1895 #else                           /* CONFIG_CYZ_INTR */
1896
1897 static void cyz_poll(unsigned long arg)
1898 {
1899         struct cyclades_card *cinfo;
1900         struct cyclades_port *info;
1901         struct tty_struct *tty;
1902         static struct FIRM_ID *firm_id;
1903         static struct ZFW_CTRL *zfw_ctrl;
1904         static struct BOARD_CTRL *board_ctrl;
1905         static struct CH_CTRL *ch_ctrl;
1906         static struct BUF_CTRL *buf_ctrl;
1907         unsigned long expires = jiffies + HZ;
1908         int card, port;
1909
1910         for (card = 0; card < NR_CARDS; card++) {
1911                 cinfo = &cy_card[card];
1912
1913                 if (!IS_CYC_Z(*cinfo))
1914                         continue;
1915                 if (!ISZLOADED(*cinfo))
1916                         continue;
1917
1918                 firm_id = cinfo->base_addr + ID_ADDRESS;
1919                 zfw_ctrl = cinfo->base_addr +
1920                                 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
1921                 board_ctrl = &(zfw_ctrl->board_ctrl);
1922
1923         /* Skip first polling cycle to avoid racing conditions with the FW */
1924                 if (!cinfo->intr_enabled) {
1925                         cinfo->nports = (int)readl(&board_ctrl->n_channel);
1926                         cinfo->intr_enabled = 1;
1927                         continue;
1928                 }
1929
1930                 cyz_handle_cmd(cinfo);
1931
1932                 for (port = 0; port < cinfo->nports; port++) {
1933                         info = &cy_port[port + cinfo->first_line];
1934                         tty = info->tty;
1935                         ch_ctrl = &(zfw_ctrl->ch_ctrl[port]);
1936                         buf_ctrl = &(zfw_ctrl->buf_ctrl[port]);
1937
1938                         if (!info->throttle)
1939                                 cyz_handle_rx(info, ch_ctrl, buf_ctrl);
1940                         cyz_handle_tx(info, ch_ctrl, buf_ctrl);
1941                 }
1942                 /* poll every 'cyz_polling_cycle' period */
1943                 expires = jiffies + cyz_polling_cycle;
1944         }
1945         mod_timer(&cyz_timerlist, expires);
1946 }                               /* cyz_poll */
1947
1948 #endif                          /* CONFIG_CYZ_INTR */
1949
1950 /********** End of block of Cyclades-Z specific code *********/
1951 /***********************************************************/
1952
1953 /* This is called whenever a port becomes active;
1954    interrupts are enabled and DTR & RTS are turned on.
1955  */
1956 static int startup(struct cyclades_port *info)
1957 {
1958         unsigned long flags;
1959         int retval = 0;
1960         void __iomem *base_addr;
1961         int card, chip, channel, index;
1962         unsigned long page;
1963
1964         card = info->card;
1965         channel = (info->line) - (cy_card[card].first_line);
1966
1967         page = get_zeroed_page(GFP_KERNEL);
1968         if (!page)
1969                 return -ENOMEM;
1970
1971         CY_LOCK(info, flags);
1972
1973         if (info->flags & ASYNC_INITIALIZED) {
1974                 free_page(page);
1975                 goto errout;
1976         }
1977
1978         if (!info->type) {
1979                 if (info->tty) {
1980                         set_bit(TTY_IO_ERROR, &info->tty->flags);
1981                 }
1982                 free_page(page);
1983                 goto errout;
1984         }
1985
1986         if (info->xmit_buf)
1987                 free_page(page);
1988         else
1989                 info->xmit_buf = (unsigned char *)page;
1990
1991         CY_UNLOCK(info, flags);
1992
1993         set_line_char(info);
1994
1995         if (!IS_CYC_Z(cy_card[card])) {
1996                 chip = channel >> 2;
1997                 channel &= 0x03;
1998                 index = cy_card[card].bus_index;
1999                 base_addr = cy_card[card].base_addr +
2000                                 (cy_chip_offset[chip] << index);
2001
2002 #ifdef CY_DEBUG_OPEN
2003                 printk("cyc startup card %d, chip %d, channel %d, "
2004                                 "base_addr %lx\n",
2005                                 card, chip, channel, (long)base_addr);
2006                 /**/
2007 #endif
2008                 CY_LOCK(info, flags);
2009
2010                 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
2011
2012                 cy_writeb(base_addr + (CyRTPR << index),
2013                         (info->default_timeout ? info->default_timeout : 0x02));
2014                 /* 10ms rx timeout */
2015
2016                 cyy_issue_cmd(base_addr, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR,
2017                                 index);
2018
2019                 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
2020                 cy_writeb(base_addr + (CyMSVR1 << index), CyRTS);
2021                 cy_writeb(base_addr + (CyMSVR2 << index), CyDTR);
2022
2023 #ifdef CY_DEBUG_DTR
2024                 printk("cyc:startup raising DTR\n");
2025                 printk("     status: 0x%x, 0x%x\n",
2026                         readb(base_addr + (CyMSVR1 << index)),
2027                         readb(base_addr + (CyMSVR2 << index)));
2028 #endif
2029
2030                 cy_writeb(base_addr + (CySRER << index),
2031                         readb(base_addr + (CySRER << index)) | CyRxData);
2032                 info->flags |= ASYNC_INITIALIZED;
2033
2034                 if (info->tty) {
2035                         clear_bit(TTY_IO_ERROR, &info->tty->flags);
2036                 }
2037                 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
2038                 info->breakon = info->breakoff = 0;
2039                 memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
2040                 info->idle_stats.in_use =
2041                 info->idle_stats.recv_idle =
2042                 info->idle_stats.xmit_idle = jiffies;
2043
2044                 CY_UNLOCK(info, flags);
2045
2046         } else {
2047                 struct FIRM_ID __iomem *firm_id;
2048                 struct ZFW_CTRL __iomem *zfw_ctrl;
2049                 struct BOARD_CTRL __iomem *board_ctrl;
2050                 struct CH_CTRL __iomem *ch_ctrl;
2051                 int retval;
2052
2053                 base_addr = cy_card[card].base_addr;
2054
2055                 firm_id = base_addr + ID_ADDRESS;
2056                 if (!ISZLOADED(cy_card[card])) {
2057                         return -ENODEV;
2058                 }
2059
2060                 zfw_ctrl = cy_card[card].base_addr +
2061                                 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
2062                 board_ctrl = &zfw_ctrl->board_ctrl;
2063                 ch_ctrl = zfw_ctrl->ch_ctrl;
2064
2065 #ifdef CY_DEBUG_OPEN
2066                 printk("cyc startup Z card %d, channel %d, base_addr %lx\n",
2067                         card, channel, (long)base_addr);
2068                 /**/
2069 #endif
2070                 CY_LOCK(info, flags);
2071
2072                 cy_writel(&ch_ctrl[channel].op_mode, C_CH_ENABLE);
2073 #ifdef Z_WAKE
2074 #ifdef CONFIG_CYZ_INTR
2075                 cy_writel(&ch_ctrl[channel].intr_enable,
2076                           C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
2077                           C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
2078 #else
2079                 cy_writel(&ch_ctrl[channel].intr_enable,
2080                           C_IN_IOCTLW | C_IN_MDCD);
2081 #endif                          /* CONFIG_CYZ_INTR */
2082 #else
2083 #ifdef CONFIG_CYZ_INTR
2084                 cy_writel(&ch_ctrl[channel].intr_enable,
2085                           C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
2086                           C_IN_RXNNDT | C_IN_MDCD);
2087 #else
2088                 cy_writel(&ch_ctrl[channel].intr_enable, C_IN_MDCD);
2089 #endif                          /* CONFIG_CYZ_INTR */
2090 #endif                          /* Z_WAKE */
2091
2092                 retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTL, 0L);
2093                 if (retval != 0) {
2094                         printk("cyc:startup(1) retval on ttyC%d was %x\n",
2095                                 info->line, retval);
2096                 }
2097
2098                 /* Flush RX buffers before raising DTR and RTS */
2099                 retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_RX,
2100                                 0L);
2101                 if (retval != 0) {
2102                         printk("cyc:startup(2) retval on ttyC%d was %x\n",
2103                                 info->line, retval);
2104                 }
2105
2106                 /* set timeout !!! */
2107                 /* set RTS and DTR !!! */
2108                 cy_writel(&ch_ctrl[channel].rs_control,
2109                         readl(&ch_ctrl[channel].rs_control) | C_RS_RTS |
2110                         C_RS_DTR);
2111                 retval = cyz_issue_cmd(&cy_card[info->card], channel,
2112                                 C_CM_IOCTLM, 0L);
2113                 if (retval != 0) {
2114                         printk("cyc:startup(3) retval on ttyC%d was %x\n",
2115                                 info->line, retval);
2116                 }
2117 #ifdef CY_DEBUG_DTR
2118                 printk("cyc:startup raising Z DTR\n");
2119 #endif
2120
2121                 /* enable send, recv, modem !!! */
2122
2123                 info->flags |= ASYNC_INITIALIZED;
2124                 if (info->tty) {
2125                         clear_bit(TTY_IO_ERROR, &info->tty->flags);
2126                 }
2127                 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
2128                 info->breakon = info->breakoff = 0;
2129                 memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
2130                 info->idle_stats.in_use =
2131                 info->idle_stats.recv_idle =
2132                 info->idle_stats.xmit_idle = jiffies;
2133
2134                 CY_UNLOCK(info, flags);
2135         }
2136
2137 #ifdef CY_DEBUG_OPEN
2138         printk(" cyc startup done\n");
2139 #endif
2140         return 0;
2141
2142 errout:
2143         CY_UNLOCK(info, flags);
2144         return retval;
2145 }                               /* startup */
2146
2147 static void start_xmit(struct cyclades_port *info)
2148 {
2149         unsigned long flags;
2150         void __iomem *base_addr;
2151         int card, chip, channel, index;
2152
2153         card = info->card;
2154         channel = (info->line) - (cy_card[card].first_line);
2155         if (!IS_CYC_Z(cy_card[card])) {
2156                 chip = channel >> 2;
2157                 channel &= 0x03;
2158                 index = cy_card[card].bus_index;
2159                 base_addr = cy_card[card].base_addr +
2160                                 (cy_chip_offset[chip] << index);
2161
2162                 CY_LOCK(info, flags);
2163                 cy_writeb(base_addr + (CyCAR << index), channel);
2164                 cy_writeb(base_addr + (CySRER << index),
2165                         readb(base_addr + (CySRER << index)) | CyTxRdy);
2166                 CY_UNLOCK(info, flags);
2167         } else {
2168 #ifdef CONFIG_CYZ_INTR
2169                 int retval;
2170
2171                 CY_LOCK(info, flags);
2172                 retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_INTBACK,
2173                                 0L);
2174                 if (retval != 0) {
2175                         printk("cyc:start_xmit retval on ttyC%d was %x\n",
2176                                 info->line, retval);
2177                 }
2178                 CY_UNLOCK(info, flags);
2179 #else                           /* CONFIG_CYZ_INTR */
2180                 /* Don't have to do anything at this time */
2181 #endif                          /* CONFIG_CYZ_INTR */
2182         }
2183 }                               /* start_xmit */
2184
2185 /*
2186  * This routine shuts down a serial port; interrupts are disabled,
2187  * and DTR is dropped if the hangup on close termio flag is on.
2188  */
2189 static void shutdown(struct cyclades_port *info)
2190 {
2191         unsigned long flags;
2192         void __iomem *base_addr;
2193         int card, chip, channel, index;
2194
2195         if (!(info->flags & ASYNC_INITIALIZED)) {
2196                 return;
2197         }
2198
2199         card = info->card;
2200         channel = info->line - cy_card[card].first_line;
2201         if (!IS_CYC_Z(cy_card[card])) {
2202                 chip = channel >> 2;
2203                 channel &= 0x03;
2204                 index = cy_card[card].bus_index;
2205                 base_addr = cy_card[card].base_addr +
2206                                 (cy_chip_offset[chip] << index);
2207
2208 #ifdef CY_DEBUG_OPEN
2209                 printk("cyc shutdown Y card %d, chip %d, channel %d, "
2210                                 "base_addr %lx\n",
2211                                 card, chip, channel, (long)base_addr);
2212 #endif
2213
2214                 CY_LOCK(info, flags);
2215
2216                 /* Clear delta_msr_wait queue to avoid mem leaks. */
2217                 wake_up_interruptible(&info->delta_msr_wait);
2218
2219                 if (info->xmit_buf) {
2220                         unsigned char *temp;
2221                         temp = info->xmit_buf;
2222                         info->xmit_buf = NULL;
2223                         free_page((unsigned long)temp);
2224                 }
2225                 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
2226                 if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
2227                         cy_writeb(base_addr + (CyMSVR1 << index), ~CyRTS);
2228                         cy_writeb(base_addr + (CyMSVR2 << index), ~CyDTR);
2229 #ifdef CY_DEBUG_DTR
2230                         printk("cyc shutdown dropping DTR\n");
2231                         printk("     status: 0x%x, 0x%x\n",
2232                                 readb(base_addr + (CyMSVR1 << index)),
2233                                 readb(base_addr + (CyMSVR2 << index)));
2234 #endif
2235                 }
2236                 cyy_issue_cmd(base_addr, CyCHAN_CTL | CyDIS_RCVR, index);
2237                 /* it may be appropriate to clear _XMIT at
2238                    some later date (after testing)!!! */
2239
2240                 if (info->tty) {
2241                         set_bit(TTY_IO_ERROR, &info->tty->flags);
2242                 }
2243                 info->flags &= ~ASYNC_INITIALIZED;
2244                 CY_UNLOCK(info, flags);
2245         } else {
2246                 struct FIRM_ID __iomem *firm_id;
2247                 struct ZFW_CTRL __iomem *zfw_ctrl;
2248                 struct BOARD_CTRL __iomem *board_ctrl;
2249                 struct CH_CTRL __iomem *ch_ctrl;
2250                 int retval;
2251
2252                 base_addr = cy_card[card].base_addr;
2253 #ifdef CY_DEBUG_OPEN
2254                 printk("cyc shutdown Z card %d, channel %d, base_addr %lx\n",
2255                         card, channel, (long)base_addr);
2256 #endif
2257
2258                 firm_id = base_addr + ID_ADDRESS;
2259                 if (!ISZLOADED(cy_card[card])) {
2260                         return;
2261                 }
2262
2263                 zfw_ctrl = cy_card[card].base_addr +
2264                                 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
2265                 board_ctrl = &zfw_ctrl->board_ctrl;
2266                 ch_ctrl = zfw_ctrl->ch_ctrl;
2267
2268                 CY_LOCK(info, flags);
2269
2270                 if (info->xmit_buf) {
2271                         unsigned char *temp;
2272                         temp = info->xmit_buf;
2273                         info->xmit_buf = NULL;
2274                         free_page((unsigned long)temp);
2275                 }
2276
2277                 if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
2278                         cy_writel(&ch_ctrl[channel].rs_control,
2279                                 (__u32)(readl(&ch_ctrl[channel].rs_control) &
2280                                         ~(C_RS_RTS | C_RS_DTR)));
2281                         retval = cyz_issue_cmd(&cy_card[info->card], channel,
2282                                         C_CM_IOCTLM, 0L);
2283                         if (retval != 0) {
2284                                 printk("cyc:shutdown retval on ttyC%d was %x\n",
2285                                         info->line, retval);
2286                         }
2287 #ifdef CY_DEBUG_DTR
2288                         printk("cyc:shutdown dropping Z DTR\n");
2289 #endif
2290                 }
2291
2292                 if (info->tty) {
2293                         set_bit(TTY_IO_ERROR, &info->tty->flags);
2294                 }
2295                 info->flags &= ~ASYNC_INITIALIZED;
2296
2297                 CY_UNLOCK(info, flags);
2298         }
2299
2300 #ifdef CY_DEBUG_OPEN
2301         printk(" cyc shutdown done\n");
2302 #endif
2303 }                               /* shutdown */
2304
2305 /*
2306  * ------------------------------------------------------------
2307  * cy_open() and friends
2308  * ------------------------------------------------------------
2309  */
2310
2311 static int
2312 block_til_ready(struct tty_struct *tty, struct file *filp,
2313                 struct cyclades_port *info)
2314 {
2315         DECLARE_WAITQUEUE(wait, current);
2316         struct cyclades_card *cinfo;
2317         unsigned long flags;
2318         int chip, channel, index;
2319         int retval;
2320         void __iomem *base_addr;
2321
2322         cinfo = &cy_card[info->card];
2323         channel = info->line - cinfo->first_line;
2324
2325         /*
2326          * If the device is in the middle of being closed, then block
2327          * until it's done, and then try again.
2328          */
2329         if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
2330                 if (info->flags & ASYNC_CLOSING) {
2331                         interruptible_sleep_on(&info->close_wait);
2332                 }
2333                 return (info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
2334         }
2335
2336         /*
2337          * If non-blocking mode is set, then make the check up front
2338          * and then exit.
2339          */
2340         if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) {
2341                 info->flags |= ASYNC_NORMAL_ACTIVE;
2342                 return 0;
2343         }
2344
2345         /*
2346          * Block waiting for the carrier detect and the line to become
2347          * free (i.e., not in use by the callout).  While we are in
2348          * this loop, info->count is dropped by one, so that
2349          * cy_close() knows when to free things.  We restore it upon
2350          * exit, either normal or abnormal.
2351          */
2352         retval = 0;
2353         add_wait_queue(&info->open_wait, &wait);
2354 #ifdef CY_DEBUG_OPEN
2355         printk("cyc block_til_ready before block: ttyC%d, count = %d\n",
2356                 info->line, info->count);
2357         /**/
2358 #endif
2359         CY_LOCK(info, flags);
2360         if (!tty_hung_up_p(filp))
2361                 info->count--;
2362         CY_UNLOCK(info, flags);
2363 #ifdef CY_DEBUG_COUNT
2364         printk("cyc block_til_ready: (%d): decrementing count to %d\n",
2365                 current->pid, info->count);
2366 #endif
2367         info->blocked_open++;
2368
2369         if (!IS_CYC_Z(*cinfo)) {
2370                 chip = channel >> 2;
2371                 channel &= 0x03;
2372                 index = cinfo->bus_index;
2373                 base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
2374
2375                 while (1) {
2376                         CY_LOCK(info, flags);
2377                         if ((tty->termios->c_cflag & CBAUD)) {
2378                                 cy_writeb(base_addr + (CyCAR << index),
2379                                           (u_char) channel);
2380                                 cy_writeb(base_addr + (CyMSVR1 << index),
2381                                           CyRTS);
2382                                 cy_writeb(base_addr + (CyMSVR2 << index),
2383                                           CyDTR);
2384 #ifdef CY_DEBUG_DTR
2385                                 printk("cyc:block_til_ready raising DTR\n");
2386                                 printk("     status: 0x%x, 0x%x\n",
2387                                         readb(base_addr + (CyMSVR1 << index)),
2388                                         readb(base_addr + (CyMSVR2 << index)));
2389 #endif
2390                         }
2391                         CY_UNLOCK(info, flags);
2392
2393                         set_current_state(TASK_INTERRUPTIBLE);
2394                         if (tty_hung_up_p(filp) ||
2395                                         !(info->flags & ASYNC_INITIALIZED)) {
2396                                 retval = ((info->flags & ASYNC_HUP_NOTIFY) ?
2397                                           -EAGAIN : -ERESTARTSYS);
2398                                 break;
2399                         }
2400
2401                         CY_LOCK(info, flags);
2402                         cy_writeb(base_addr + (CyCAR << index),
2403                                   (u_char) channel);
2404                         if (!(info->flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
2405                                         (readb(base_addr +
2406                                                 (CyMSVR1 << index)) & CyDCD))) {
2407                                 CY_UNLOCK(info, flags);
2408                                 break;
2409                         }
2410                         CY_UNLOCK(info, flags);
2411
2412                         if (signal_pending(current)) {
2413                                 retval = -ERESTARTSYS;
2414                                 break;
2415                         }
2416 #ifdef CY_DEBUG_OPEN
2417                         printk("cyc block_til_ready blocking: ttyC%d, "
2418                                         "count = %d\n",
2419                                         info->line, info->count);
2420                         /**/
2421 #endif
2422                         schedule();
2423                 }
2424         } else {
2425                 struct FIRM_ID __iomem *firm_id;
2426                 struct ZFW_CTRL __iomem *zfw_ctrl;
2427                 struct BOARD_CTRL __iomem *board_ctrl;
2428                 struct CH_CTRL __iomem *ch_ctrl;
2429                 int retval;
2430
2431                 base_addr = cinfo->base_addr;
2432                 firm_id = base_addr + ID_ADDRESS;
2433                 if (!ISZLOADED(*cinfo)) {
2434                         __set_current_state(TASK_RUNNING);
2435                         remove_wait_queue(&info->open_wait, &wait);
2436                         return -EINVAL;
2437                 }
2438
2439                 zfw_ctrl = base_addr + (readl(&firm_id->zfwctrl_addr)& 0xfffff);
2440                 board_ctrl = &zfw_ctrl->board_ctrl;
2441                 ch_ctrl = zfw_ctrl->ch_ctrl;
2442
2443                 while (1) {
2444                         if ((tty->termios->c_cflag & CBAUD)) {
2445                                 cy_writel(&ch_ctrl[channel].rs_control,
2446                                         readl(&ch_ctrl[channel].rs_control) |
2447                                         C_RS_RTS | C_RS_DTR);
2448                                 retval = cyz_issue_cmd(&cy_card[info->card],
2449                                         channel, C_CM_IOCTLM, 0L);
2450                                 if (retval != 0) {
2451                                         printk("cyc:block_til_ready retval on "
2452                                                 "ttyC%d was %x\n",
2453                                                 info->line, retval);
2454                                 }
2455 #ifdef CY_DEBUG_DTR
2456                                 printk("cyc:block_til_ready raising Z DTR\n");
2457 #endif
2458                         }
2459
2460                         set_current_state(TASK_INTERRUPTIBLE);
2461                         if (tty_hung_up_p(filp) ||
2462                                         !(info->flags & ASYNC_INITIALIZED)) {
2463                                 retval = ((info->flags & ASYNC_HUP_NOTIFY) ?
2464                                           -EAGAIN : -ERESTARTSYS);
2465                                 break;
2466                         }
2467                         if (!(info->flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
2468                                         (readl(&ch_ctrl[channel].rs_status) &
2469                                                 C_RS_DCD))) {
2470                                 break;
2471                         }
2472                         if (signal_pending(current)) {
2473                                 retval = -ERESTARTSYS;
2474                                 break;
2475                         }
2476 #ifdef CY_DEBUG_OPEN
2477                         printk("cyc block_til_ready blocking: ttyC%d, "
2478                                         "count = %d\n",
2479                                         info->line, info->count);
2480                         /**/
2481 #endif
2482                         schedule();
2483                 }
2484         }
2485         __set_current_state(TASK_RUNNING);
2486         remove_wait_queue(&info->open_wait, &wait);
2487         if (!tty_hung_up_p(filp)) {
2488                 info->count++;
2489 #ifdef CY_DEBUG_COUNT
2490                 printk("cyc:block_til_ready (%d): incrementing count to %d\n",
2491                         current->pid, info->count);
2492 #endif
2493         }
2494         info->blocked_open--;
2495 #ifdef CY_DEBUG_OPEN
2496         printk("cyc:block_til_ready after blocking: ttyC%d, count = %d\n",
2497                 info->line, info->count);
2498         /**/
2499 #endif
2500         if (retval)
2501                 return retval;
2502         info->flags |= ASYNC_NORMAL_ACTIVE;
2503         return 0;
2504 }                               /* block_til_ready */
2505
2506 /*
2507  * This routine is called whenever a serial port is opened.  It
2508  * performs the serial-specific initialization for the tty structure.
2509  */
2510 static int cy_open(struct tty_struct *tty, struct file *filp)
2511 {
2512         struct cyclades_port *info;
2513         int retval, line;
2514
2515         line = tty->index;
2516         if ((line < 0) || (NR_PORTS <= line)) {
2517                 return -ENODEV;
2518         }
2519         info = &cy_port[line];
2520         if (info->line < 0) {
2521                 return -ENODEV;
2522         }
2523
2524         /* If the card's firmware hasn't been loaded,
2525            treat it as absent from the system.  This
2526            will make the user pay attention.
2527          */
2528         if (IS_CYC_Z(cy_card[info->card])) {
2529                 struct cyclades_card *cinfo = &cy_card[info->card];
2530                 struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
2531
2532                 if (!ISZLOADED(*cinfo)) {
2533                         if (((ZE_V1 == readl(&((struct RUNTIME_9060 __iomem *)
2534                                          (cinfo->ctl_addr))->mail_box_0)) &&
2535                                         Z_FPGA_CHECK(*cinfo)) &&
2536                                         (ZFIRM_HLT == readl(
2537                                                 &firm_id->signature))) {
2538                                 printk("cyc:Cyclades-Z Error: you need an "
2539                                         "external power supply for this number "
2540                                         "of ports.\n\rFirmware halted.\r\n");
2541                         } else {
2542                                 printk("cyc:Cyclades-Z firmware not yet "
2543                                         "loaded\n");
2544                         }
2545                         return -ENODEV;
2546                 }
2547 #ifdef CONFIG_CYZ_INTR
2548                 else {
2549                 /* In case this Z board is operating in interrupt mode, its
2550                    interrupts should be enabled as soon as the first open
2551                    happens to one of its ports. */
2552                         if (!cinfo->intr_enabled) {
2553                                 struct ZFW_CTRL __iomem *zfw_ctrl;
2554                                 struct BOARD_CTRL __iomem *board_ctrl;
2555
2556                                 zfw_ctrl = cinfo->base_addr +
2557                                         (readl(&firm_id->zfwctrl_addr) &
2558                                          0xfffff);
2559
2560                                 board_ctrl = &zfw_ctrl->board_ctrl;
2561
2562                                 /* Enable interrupts on the PLX chip */
2563                                 cy_writew(cinfo->ctl_addr + 0x68,
2564                                         readw(cinfo->ctl_addr + 0x68) | 0x0900);
2565                                 /* Enable interrupts on the FW */
2566                                 retval = cyz_issue_cmd(cinfo, 0,
2567                                                 C_CM_IRQ_ENBL, 0L);
2568                                 if (retval != 0) {
2569                                         printk("cyc:IRQ enable retval was %x\n",
2570                                                 retval);
2571                                 }
2572                                 cinfo->nports =
2573                                         (int)readl(&board_ctrl->n_channel);
2574                                 cinfo->intr_enabled = 1;
2575                         }
2576                 }
2577 #endif                          /* CONFIG_CYZ_INTR */
2578                 /* Make sure this Z port really exists in hardware */
2579                 if (info->line > (cinfo->first_line + cinfo->nports - 1))
2580                         return -ENODEV;
2581         }
2582 #ifdef CY_DEBUG_OTHER
2583         printk("cyc:cy_open ttyC%d\n", info->line);     /* */
2584 #endif
2585         tty->driver_data = info;
2586         info->tty = tty;
2587         if (serial_paranoia_check(info, tty->name, "cy_open")) {
2588                 return -ENODEV;
2589         }
2590 #ifdef CY_DEBUG_OPEN
2591         printk("cyc:cy_open ttyC%d, count = %d\n", info->line, info->count);
2592         /**/
2593 #endif
2594         info->count++;
2595 #ifdef CY_DEBUG_COUNT
2596         printk("cyc:cy_open (%d): incrementing count to %d\n",
2597                 current->pid, info->count);
2598 #endif
2599
2600         /*
2601          * If the port is the middle of closing, bail out now
2602          */
2603         if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
2604                 if (info->flags & ASYNC_CLOSING)
2605                         interruptible_sleep_on(&info->close_wait);
2606                 return (info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
2607         }
2608
2609         /*
2610          * Start up serial port
2611          */
2612         retval = startup(info);
2613         if (retval) {
2614                 return retval;
2615         }
2616
2617         retval = block_til_ready(tty, filp, info);
2618         if (retval) {
2619 #ifdef CY_DEBUG_OPEN
2620                 printk("cyc:cy_open returning after block_til_ready with %d\n",
2621                         retval);
2622 #endif
2623                 return retval;
2624         }
2625
2626         info->throttle = 0;
2627
2628 #ifdef CY_DEBUG_OPEN
2629         printk(" cyc:cy_open done\n");
2630         /**/
2631 #endif
2632         return 0;
2633 }                               /* cy_open */
2634
2635 /*
2636  * cy_wait_until_sent() --- wait until the transmitter is empty
2637  */
2638 static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
2639 {
2640         struct cyclades_port *info = tty->driver_data;
2641         void __iomem *base_addr;
2642         int card, chip, channel, index;
2643         unsigned long orig_jiffies;
2644         int char_time;
2645
2646         if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
2647                 return;
2648
2649         if (info->xmit_fifo_size == 0)
2650                 return;         /* Just in case.... */
2651
2652         orig_jiffies = jiffies;
2653         /*
2654          * Set the check interval to be 1/5 of the estimated time to
2655          * send a single character, and make it at least 1.  The check
2656          * interval should also be less than the timeout.
2657          *
2658          * Note: we have to use pretty tight timings here to satisfy
2659          * the NIST-PCTS.
2660          */
2661         char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
2662         char_time = char_time / 5;
2663         if (char_time <= 0)
2664                 char_time = 1;
2665         if (timeout < 0)
2666                 timeout = 0;
2667         if (timeout)
2668                 char_time = min(char_time, timeout);
2669         /*
2670          * If the transmitter hasn't cleared in twice the approximate
2671          * amount of time to send the entire FIFO, it probably won't
2672          * ever clear.  This assumes the UART isn't doing flow
2673          * control, which is currently the case.  Hence, if it ever
2674          * takes longer than info->timeout, this is probably due to a
2675          * UART bug of some kind.  So, we clamp the timeout parameter at
2676          * 2*info->timeout.
2677          */
2678         if (!timeout || timeout > 2 * info->timeout)
2679                 timeout = 2 * info->timeout;
2680 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
2681         printk("In cy_wait_until_sent(%d) check=%lu...", timeout, char_time);
2682         printk("jiff=%lu...", jiffies);
2683 #endif
2684         card = info->card;
2685         channel = (info->line) - (cy_card[card].first_line);
2686         if (!IS_CYC_Z(cy_card[card])) {
2687                 chip = channel >> 2;
2688                 channel &= 0x03;
2689                 index = cy_card[card].bus_index;
2690                 base_addr =
2691                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
2692                 while (readb(base_addr + (CySRER << index)) & CyTxRdy) {
2693 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
2694                         printk("Not clean (jiff=%lu)...", jiffies);
2695 #endif
2696                         if (msleep_interruptible(jiffies_to_msecs(char_time)))
2697                                 break;
2698                         if (timeout && time_after(jiffies, orig_jiffies +
2699                                         timeout))
2700                                 break;
2701                 }
2702         } else {
2703                 /* Nothing to do! */
2704         }
2705         /* Run one more char cycle */
2706         msleep_interruptible(jiffies_to_msecs(char_time * 5));
2707 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
2708         printk("Clean (jiff=%lu)...done\n", jiffies);
2709 #endif
2710 }
2711
2712 /*
2713  * This routine is called when a particular tty device is closed.
2714  */
2715 static void cy_close(struct tty_struct *tty, struct file *filp)
2716 {
2717         struct cyclades_port *info = tty->driver_data;
2718         unsigned long flags;
2719
2720 #ifdef CY_DEBUG_OTHER
2721         printk("cyc:cy_close ttyC%d\n", info->line);
2722 #endif
2723
2724         if (!info || serial_paranoia_check(info, tty->name, "cy_close")) {
2725                 return;
2726         }
2727
2728         CY_LOCK(info, flags);
2729         /* If the TTY is being hung up, nothing to do */
2730         if (tty_hung_up_p(filp)) {
2731                 CY_UNLOCK(info, flags);
2732                 return;
2733         }
2734 #ifdef CY_DEBUG_OPEN
2735         printk("cyc:cy_close ttyC%d, count = %d\n", info->line, info->count);
2736 #endif
2737         if ((tty->count == 1) && (info->count != 1)) {
2738                 /*
2739                  * Uh, oh.  tty->count is 1, which means that the tty
2740                  * structure will be freed.  Info->count should always
2741                  * be one in these conditions.  If it's greater than
2742                  * one, we've got real problems, since it means the
2743                  * serial port won't be shutdown.
2744                  */
2745                 printk("cyc:cy_close: bad serial port count; tty->count is 1, "
2746                         "info->count is %d\n", info->count);
2747                 info->count = 1;
2748         }
2749 #ifdef CY_DEBUG_COUNT
2750         printk("cyc:cy_close at (%d): decrementing count to %d\n",
2751                 current->pid, info->count - 1);
2752 #endif
2753         if (--info->count < 0) {
2754 #ifdef CY_DEBUG_COUNT
2755                 printk("cyc:cyc_close setting count to 0\n");
2756 #endif
2757                 info->count = 0;
2758         }
2759         if (info->count) {
2760                 CY_UNLOCK(info, flags);
2761                 return;
2762         }
2763         info->flags |= ASYNC_CLOSING;
2764
2765         /*
2766          * Now we wait for the transmit buffer to clear; and we notify
2767          * the line discipline to only process XON/XOFF characters.
2768          */
2769         tty->closing = 1;
2770         CY_UNLOCK(info, flags);
2771         if (info->closing_wait != CY_CLOSING_WAIT_NONE) {
2772                 tty_wait_until_sent(tty, info->closing_wait);
2773         }
2774         CY_LOCK(info, flags);
2775
2776         if (!IS_CYC_Z(cy_card[info->card])) {
2777                 int channel = info->line - cy_card[info->card].first_line;
2778                 int index = cy_card[info->card].bus_index;
2779                 void __iomem *base_addr = cy_card[info->card].base_addr +
2780                         (cy_chip_offset[channel >> 2] << index);
2781                 /* Stop accepting input */
2782                 channel &= 0x03;
2783                 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
2784                 cy_writeb(base_addr + (CySRER << index),
2785                           readb(base_addr + (CySRER << index)) & ~CyRxData);
2786                 if (info->flags & ASYNC_INITIALIZED) {
2787                         /* Waiting for on-board buffers to be empty before closing
2788                            the port */
2789                         CY_UNLOCK(info, flags);
2790                         cy_wait_until_sent(tty, info->timeout);
2791                         CY_LOCK(info, flags);
2792                 }
2793         } else {
2794 #ifdef Z_WAKE
2795                 /* Waiting for on-board buffers to be empty before closing the port */
2796                 void __iomem *base_addr = cy_card[info->card].base_addr;
2797                 struct FIRM_ID __iomem *firm_id = base_addr + ID_ADDRESS;
2798                 struct ZFW_CTRL __iomem *zfw_ctrl =
2799                     base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
2800                 struct CH_CTRL __iomem *ch_ctrl = zfw_ctrl->ch_ctrl;
2801                 int channel = info->line - cy_card[info->card].first_line;
2802                 int retval;
2803
2804                 if (readl(&ch_ctrl[channel].flow_status) != C_FS_TXIDLE) {
2805                         retval = cyz_issue_cmd(&cy_card[info->card], channel,
2806                                                 C_CM_IOCTLW, 0L);
2807                         if (retval != 0) {
2808                                 printk("cyc:cy_close retval on ttyC%d was %x\n",
2809                                         info->line, retval);
2810                         }
2811                         CY_UNLOCK(info, flags);
2812                         interruptible_sleep_on(&info->shutdown_wait);
2813                         CY_LOCK(info, flags);
2814                 }
2815 #endif
2816         }
2817
2818         CY_UNLOCK(info, flags);
2819         shutdown(info);
2820         if (tty->driver->flush_buffer)
2821                 tty->driver->flush_buffer(tty);
2822         tty_ldisc_flush(tty);
2823         CY_LOCK(info, flags);
2824
2825         tty->closing = 0;
2826         info->event = 0;
2827         info->tty = NULL;
2828         if (info->blocked_open) {
2829                 CY_UNLOCK(info, flags);
2830                 if (info->close_delay) {
2831                         msleep_interruptible(jiffies_to_msecs
2832                                                 (info->close_delay));
2833                 }
2834                 wake_up_interruptible(&info->open_wait);
2835                 CY_LOCK(info, flags);
2836         }
2837         info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
2838         wake_up_interruptible(&info->close_wait);
2839
2840 #ifdef CY_DEBUG_OTHER
2841         printk(" cyc:cy_close done\n");
2842 #endif
2843
2844         CY_UNLOCK(info, flags);
2845 }                               /* cy_close */
2846
2847 /* This routine gets called when tty_write has put something into
2848  * the write_queue.  The characters may come from user space or
2849  * kernel space.
2850  *
2851  * This routine will return the number of characters actually
2852  * accepted for writing.
2853  *
2854  * If the port is not already transmitting stuff, start it off by
2855  * enabling interrupts.  The interrupt service routine will then
2856  * ensure that the characters are sent.
2857  * If the port is already active, there is no need to kick it.
2858  *
2859  */
2860 static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
2861 {
2862         struct cyclades_port *info = tty->driver_data;
2863         unsigned long flags;
2864         int c, ret = 0;
2865
2866 #ifdef CY_DEBUG_IO
2867         printk("cyc:cy_write ttyC%d\n", info->line);    /* */
2868 #endif
2869
2870         if (serial_paranoia_check(info, tty->name, "cy_write")) {
2871                 return 0;
2872         }
2873
2874         if (!info->xmit_buf)
2875                 return 0;
2876
2877         CY_LOCK(info, flags);
2878         while (1) {
2879                 c = min(count, min((int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1),
2880                                    (int)(SERIAL_XMIT_SIZE - info->xmit_head)));
2881
2882                 if (c <= 0)
2883                         break;
2884
2885                 memcpy(info->xmit_buf + info->xmit_head, buf, c);
2886                 info->xmit_head = (info->xmit_head + c) &
2887                         (SERIAL_XMIT_SIZE - 1);
2888                 info->xmit_cnt += c;
2889                 buf += c;
2890                 count -= c;
2891                 ret += c;
2892         }
2893         CY_UNLOCK(info, flags);
2894
2895         info->idle_stats.xmit_bytes += ret;
2896         info->idle_stats.xmit_idle = jiffies;
2897
2898         if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
2899                 start_xmit(info);
2900         }
2901         return ret;
2902 }                               /* cy_write */
2903
2904 /*
2905  * This routine is called by the kernel to write a single
2906  * character to the tty device.  If the kernel uses this routine,
2907  * it must call the flush_chars() routine (if defined) when it is
2908  * done stuffing characters into the driver.  If there is no room
2909  * in the queue, the character is ignored.
2910  */
2911 static void cy_put_char(struct tty_struct *tty, unsigned char ch)
2912 {
2913         struct cyclades_port *info = tty->driver_data;
2914         unsigned long flags;
2915
2916 #ifdef CY_DEBUG_IO
2917         printk("cyc:cy_put_char ttyC%d\n", info->line);
2918 #endif
2919
2920         if (serial_paranoia_check(info, tty->name, "cy_put_char"))
2921                 return;
2922
2923         if (!info->xmit_buf)
2924                 return;
2925
2926         CY_LOCK(info, flags);
2927         if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
2928                 CY_UNLOCK(info, flags);
2929                 return;
2930         }
2931
2932         info->xmit_buf[info->xmit_head++] = ch;
2933         info->xmit_head &= SERIAL_XMIT_SIZE - 1;
2934         info->xmit_cnt++;
2935         info->idle_stats.xmit_bytes++;
2936         info->idle_stats.xmit_idle = jiffies;
2937         CY_UNLOCK(info, flags);
2938 }                               /* cy_put_char */
2939
2940 /*
2941  * This routine is called by the kernel after it has written a
2942  * series of characters to the tty device using put_char().
2943  */
2944 static void cy_flush_chars(struct tty_struct *tty)
2945 {
2946         struct cyclades_port *info = tty->driver_data;
2947
2948 #ifdef CY_DEBUG_IO
2949         printk("cyc:cy_flush_chars ttyC%d\n", info->line);      /* */
2950 #endif
2951
2952         if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
2953                 return;
2954
2955         if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
2956                         !info->xmit_buf)
2957                 return;
2958
2959         start_xmit(info);
2960 }                               /* cy_flush_chars */
2961
2962 /*
2963  * This routine returns the numbers of characters the tty driver
2964  * will accept for queuing to be written.  This number is subject
2965  * to change as output buffers get emptied, or if the output flow
2966  * control is activated.
2967  */
2968 static int cy_write_room(struct tty_struct *tty)
2969 {
2970         struct cyclades_port *info = tty->driver_data;
2971         int ret;
2972
2973 #ifdef CY_DEBUG_IO
2974         printk("cyc:cy_write_room ttyC%d\n", info->line);       /* */
2975 #endif
2976
2977         if (serial_paranoia_check(info, tty->name, "cy_write_room"))
2978                 return 0;
2979         ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
2980         if (ret < 0)
2981                 ret = 0;
2982         return ret;
2983 }                               /* cy_write_room */
2984
2985 static int cy_chars_in_buffer(struct tty_struct *tty)
2986 {
2987         struct cyclades_port *info = tty->driver_data;
2988         int card, channel;
2989
2990         if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
2991                 return 0;
2992
2993         card = info->card;
2994         channel = (info->line) - (cy_card[card].first_line);
2995
2996 #ifdef Z_EXT_CHARS_IN_BUFFER
2997         if (!IS_CYC_Z(cy_card[card])) {
2998 #endif                          /* Z_EXT_CHARS_IN_BUFFER */
2999 #ifdef CY_DEBUG_IO
3000                 printk("cyc:cy_chars_in_buffer ttyC%d %d\n", info->line, info->xmit_cnt);       /* */
3001 #endif
3002                 return info->xmit_cnt;
3003 #ifdef Z_EXT_CHARS_IN_BUFFER
3004         } else {
3005                 static struct FIRM_ID *firm_id;
3006                 static struct ZFW_CTRL *zfw_ctrl;
3007                 static struct CH_CTRL *ch_ctrl;
3008                 static struct BUF_CTRL *buf_ctrl;
3009                 int char_count;
3010                 __u32 tx_put, tx_get, tx_bufsize;
3011
3012                 firm_id = cy_card[card].base_addr + ID_ADDRESS;
3013                 zfw_ctrl = cy_card[card].base_addr +
3014                         (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3015                 ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
3016                 buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
3017
3018                 tx_get = readl(&buf_ctrl->tx_get);
3019                 tx_put = readl(&buf_ctrl->tx_put);
3020                 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
3021                 if (tx_put >= tx_get)
3022                         char_count = tx_put - tx_get;
3023                 else
3024                         char_count = tx_put - tx_get + tx_bufsize;
3025 #ifdef CY_DEBUG_IO
3026                 printk("cyc:cy_chars_in_buffer ttyC%d %d\n", info->line, info->xmit_cnt + char_count);  /* */
3027 #endif
3028                 return info->xmit_cnt + char_count;
3029         }
3030 #endif                          /* Z_EXT_CHARS_IN_BUFFER */
3031 }                               /* cy_chars_in_buffer */
3032
3033 /*
3034  * ------------------------------------------------------------
3035  * cy_ioctl() and friends
3036  * ------------------------------------------------------------
3037  */
3038
3039 static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
3040 {
3041         int co, co_val, bpr;
3042         __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
3043                         25000000);
3044
3045         if (baud == 0) {
3046                 info->tbpr = info->tco = info->rbpr = info->rco = 0;
3047                 return;
3048         }
3049
3050         /* determine which prescaler to use */
3051         for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
3052                 if (cy_clock / co_val / baud > 63)
3053                         break;
3054         }
3055
3056         bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
3057         if (bpr > 255)
3058                 bpr = 255;
3059
3060         info->tbpr = info->rbpr = bpr;
3061         info->tco = info->rco = co;
3062 }
3063
3064 /*
3065  * This routine finds or computes the various line characteristics.
3066  * It used to be called config_setup
3067  */
3068 static void set_line_char(struct cyclades_port *info)
3069 {
3070         unsigned long flags;
3071         void __iomem *base_addr;
3072         int card, chip, channel, index;
3073         unsigned cflag, iflag;
3074         unsigned short chip_number;
3075         int baud, baud_rate = 0;
3076         int i;
3077
3078         if (!info->tty || !info->tty->termios) {
3079                 return;
3080         }
3081         if (info->line == -1) {
3082                 return;
3083         }
3084         cflag = info->tty->termios->c_cflag;
3085         iflag = info->tty->termios->c_iflag;
3086
3087         /*
3088          * Set up the tty->alt_speed kludge
3089          */
3090         if (info->tty) {
3091                 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
3092                         info->tty->alt_speed = 57600;
3093                 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
3094                         info->tty->alt_speed = 115200;
3095                 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
3096                         info->tty->alt_speed = 230400;
3097                 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
3098                         info->tty->alt_speed = 460800;
3099         }
3100
3101         card = info->card;
3102         channel = (info->line) - (cy_card[card].first_line);
3103         chip_number = channel / 4;
3104
3105         if (!IS_CYC_Z(cy_card[card])) {
3106
3107                 index = cy_card[card].bus_index;
3108
3109                 /* baud rate */
3110                 baud = tty_get_baud_rate(info->tty);
3111                 if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3112                                 ASYNC_SPD_CUST) {
3113                         if (info->custom_divisor)
3114                                 baud_rate = info->baud / info->custom_divisor;
3115                         else
3116                                 baud_rate = info->baud;
3117                 } else if (baud > CD1400_MAX_SPEED) {
3118                         baud = CD1400_MAX_SPEED;
3119                 }
3120                 /* find the baud index */
3121                 for (i = 0; i < 20; i++) {
3122                         if (baud == baud_table[i]) {
3123                                 break;
3124                         }
3125                 }
3126                 if (i == 20) {
3127                         i = 19; /* CD1400_MAX_SPEED */
3128                 }
3129
3130                 if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3131                                 ASYNC_SPD_CUST) {
3132                         cyy_baud_calc(info, baud_rate);
3133                 } else {
3134                         if (info->chip_rev >= CD1400_REV_J) {
3135                                 /* It is a CD1400 rev. J or later */
3136                                 info->tbpr = baud_bpr_60[i];    /* Tx BPR */
3137                                 info->tco = baud_co_60[i];      /* Tx CO */
3138                                 info->rbpr = baud_bpr_60[i];    /* Rx BPR */
3139                                 info->rco = baud_co_60[i];      /* Rx CO */
3140                         } else {
3141                                 info->tbpr = baud_bpr_25[i];    /* Tx BPR */
3142                                 info->tco = baud_co_25[i];      /* Tx CO */
3143                                 info->rbpr = baud_bpr_25[i];    /* Rx BPR */
3144                                 info->rco = baud_co_25[i];      /* Rx CO */
3145                         }
3146                 }
3147                 if (baud_table[i] == 134) {
3148                         /* get it right for 134.5 baud */
3149                         info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
3150                                         2;
3151                 } else if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3152                                 ASYNC_SPD_CUST) {
3153                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
3154                                         baud_rate) + 2;
3155                 } else if (baud_table[i]) {
3156                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
3157                                         baud_table[i]) + 2;
3158                         /* this needs to be propagated into the card info */
3159                 } else {
3160                         info->timeout = 0;
3161                 }
3162                 /* By tradition (is it a standard?) a baud rate of zero
3163                    implies the line should be/has been closed.  A bit
3164                    later in this routine such a test is performed. */
3165
3166                 /* byte size and parity */
3167                 info->cor5 = 0;
3168                 info->cor4 = 0;
3169                 /* receive threshold */
3170                 info->cor3 = (info->default_threshold ?
3171                                 info->default_threshold : baud_cor3[i]);
3172                 info->cor2 = CyETC;
3173                 switch (cflag & CSIZE) {
3174                 case CS5:
3175                         info->cor1 = Cy_5_BITS;
3176                         break;
3177                 case CS6:
3178                         info->cor1 = Cy_6_BITS;
3179                         break;
3180                 case CS7:
3181                         info->cor1 = Cy_7_BITS;
3182                         break;
3183                 case CS8:
3184                         info->cor1 = Cy_8_BITS;
3185                         break;
3186                 }
3187                 if (cflag & CSTOPB) {
3188                         info->cor1 |= Cy_2_STOP;
3189                 }
3190                 if (cflag & PARENB) {
3191                         if (cflag & PARODD) {
3192                                 info->cor1 |= CyPARITY_O;
3193                         } else {
3194                                 info->cor1 |= CyPARITY_E;
3195                         }
3196                 } else {
3197                         info->cor1 |= CyPARITY_NONE;
3198                 }
3199
3200                 /* CTS flow control flag */
3201                 if (cflag & CRTSCTS) {
3202                         info->flags |= ASYNC_CTS_FLOW;
3203                         info->cor2 |= CyCtsAE;
3204                 } else {
3205                         info->flags &= ~ASYNC_CTS_FLOW;
3206                         info->cor2 &= ~CyCtsAE;
3207                 }
3208                 if (cflag & CLOCAL)
3209                         info->flags &= ~ASYNC_CHECK_CD;
3210                 else
3211                         info->flags |= ASYNC_CHECK_CD;
3212
3213          /***********************************************
3214             The hardware option, CyRtsAO, presents RTS when
3215             the chip has characters to send.  Since most modems
3216             use RTS as reverse (inbound) flow control, this
3217             option is not used.  If inbound flow control is
3218             necessary, DTR can be programmed to provide the
3219             appropriate signals for use with a non-standard
3220             cable.  Contact Marcio Saito for details.
3221          ***********************************************/
3222
3223                 chip = channel >> 2;
3224                 channel &= 0x03;
3225                 base_addr = cy_card[card].base_addr +
3226                         (cy_chip_offset[chip] << index);
3227
3228                 CY_LOCK(info, flags);
3229                 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
3230
3231                 /* tx and rx baud rate */
3232
3233                 cy_writeb(base_addr + (CyTCOR << index), info->tco);
3234                 cy_writeb(base_addr + (CyTBPR << index), info->tbpr);
3235                 cy_writeb(base_addr + (CyRCOR << index), info->rco);
3236                 cy_writeb(base_addr + (CyRBPR << index), info->rbpr);
3237
3238                 /* set line characteristics  according configuration */
3239
3240                 cy_writeb(base_addr + (CySCHR1 << index),
3241                           START_CHAR(info->tty));
3242                 cy_writeb(base_addr + (CySCHR2 << index), STOP_CHAR(info->tty));
3243                 cy_writeb(base_addr + (CyCOR1 << index), info->cor1);
3244                 cy_writeb(base_addr + (CyCOR2 << index), info->cor2);
3245                 cy_writeb(base_addr + (CyCOR3 << index), info->cor3);
3246                 cy_writeb(base_addr + (CyCOR4 << index), info->cor4);
3247                 cy_writeb(base_addr + (CyCOR5 << index), info->cor5);
3248
3249                 cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
3250                                 CyCOR3ch, index);
3251
3252                 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);      /* !!! Is this needed? */
3253                 cy_writeb(base_addr + (CyRTPR << index),
3254                         (info->default_timeout ? info->default_timeout : 0x02));
3255                 /* 10ms rx timeout */
3256
3257                 if (C_CLOCAL(info->tty)) {
3258                         /* without modem intr */
3259                         cy_writeb(base_addr + (CySRER << index),
3260                                 readb(base_addr + (CySRER << index)) | CyMdmCh);
3261                         /* act on 1->0 modem transitions */
3262                         if ((cflag & CRTSCTS) && info->rflow) {
3263                                 cy_writeb(base_addr + (CyMCOR1 << index),
3264                                           (CyCTS | rflow_thr[i]));
3265                         } else {
3266                                 cy_writeb(base_addr + (CyMCOR1 << index),
3267                                           CyCTS);
3268                         }
3269                         /* act on 0->1 modem transitions */
3270                         cy_writeb(base_addr + (CyMCOR2 << index), CyCTS);
3271                 } else {
3272                         /* without modem intr */
3273                         cy_writeb(base_addr + (CySRER << index),
3274                                   readb(base_addr +
3275                                            (CySRER << index)) | CyMdmCh);
3276                         /* act on 1->0 modem transitions */
3277                         if ((cflag & CRTSCTS) && info->rflow) {
3278                                 cy_writeb(base_addr + (CyMCOR1 << index),
3279                                           (CyDSR | CyCTS | CyRI | CyDCD |
3280                                            rflow_thr[i]));
3281                         } else {
3282                                 cy_writeb(base_addr + (CyMCOR1 << index),
3283                                           CyDSR | CyCTS | CyRI | CyDCD);
3284                         }
3285                         /* act on 0->1 modem transitions */
3286                         cy_writeb(base_addr + (CyMCOR2 << index),
3287                                   CyDSR | CyCTS | CyRI | CyDCD);
3288                 }
3289
3290                 if (i == 0) {   /* baud rate is zero, turn off line */
3291                         if (info->rtsdtr_inv) {
3292                                 cy_writeb(base_addr + (CyMSVR1 << index),
3293                                           ~CyRTS);
3294                         } else {
3295                                 cy_writeb(base_addr + (CyMSVR2 << index),
3296                                           ~CyDTR);
3297                         }
3298 #ifdef CY_DEBUG_DTR
3299                         printk("cyc:set_line_char dropping DTR\n");
3300                         printk("     status: 0x%x, 0x%x\n",
3301                                 readb(base_addr + (CyMSVR1 << index)),
3302                                 readb(base_addr + (CyMSVR2 << index)));
3303 #endif
3304                 } else {
3305                         if (info->rtsdtr_inv) {
3306                                 cy_writeb(base_addr + (CyMSVR1 << index),
3307                                           CyRTS);
3308                         } else {
3309                                 cy_writeb(base_addr + (CyMSVR2 << index),
3310                                           CyDTR);
3311                         }
3312 #ifdef CY_DEBUG_DTR
3313                         printk("cyc:set_line_char raising DTR\n");
3314                         printk("     status: 0x%x, 0x%x\n",
3315                                 readb(base_addr + (CyMSVR1 << index)),
3316                                 readb(base_addr + (CyMSVR2 << index)));
3317 #endif
3318                 }
3319
3320                 if (info->tty) {
3321                         clear_bit(TTY_IO_ERROR, &info->tty->flags);
3322                 }
3323                 CY_UNLOCK(info, flags);
3324
3325         } else {
3326                 struct FIRM_ID __iomem *firm_id;
3327                 struct ZFW_CTRL __iomem *zfw_ctrl;
3328                 struct BOARD_CTRL __iomem *board_ctrl;
3329                 struct CH_CTRL __iomem *ch_ctrl;
3330                 struct BUF_CTRL __iomem *buf_ctrl;
3331                 __u32 sw_flow;
3332                 int retval;
3333
3334                 firm_id = cy_card[card].base_addr + ID_ADDRESS;
3335                 if (!ISZLOADED(cy_card[card])) {
3336                         return;
3337                 }
3338
3339                 zfw_ctrl = cy_card[card].base_addr +
3340                         (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3341                 board_ctrl = &zfw_ctrl->board_ctrl;
3342                 ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
3343                 buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3344
3345                 /* baud rate */
3346                 baud = tty_get_baud_rate(info->tty);
3347                 if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3348                                 ASYNC_SPD_CUST) {
3349                         if (info->custom_divisor)
3350                                 baud_rate = info->baud / info->custom_divisor;
3351                         else
3352                                 baud_rate = info->baud;
3353                 } else if (baud > CYZ_MAX_SPEED) {
3354                         baud = CYZ_MAX_SPEED;
3355                 }
3356                 cy_writel(&ch_ctrl->comm_baud, baud);
3357
3358                 if (baud == 134) {
3359                         /* get it right for 134.5 baud */
3360                         info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
3361                                         2;
3362                 } else if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3363                                 ASYNC_SPD_CUST) {
3364                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
3365                                         baud_rate) + 2;
3366                 } else if (baud) {
3367                         info->timeout = (info->xmit_fifo_size * HZ * 15 /
3368                                         baud) + 2;
3369                         /* this needs to be propagated into the card info */
3370                 } else {
3371                         info->timeout = 0;
3372                 }
3373
3374                 /* byte size and parity */
3375                 switch (cflag & CSIZE) {
3376                 case CS5:
3377                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
3378                         break;
3379                 case CS6:
3380                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
3381                         break;
3382                 case CS7:
3383                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
3384                         break;
3385                 case CS8:
3386                         cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
3387                         break;
3388                 }
3389                 if (cflag & CSTOPB) {
3390                         cy_writel(&ch_ctrl->comm_data_l,
3391                                   readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
3392                 } else {
3393                         cy_writel(&ch_ctrl->comm_data_l,
3394                                   readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
3395                 }
3396                 if (cflag & PARENB) {
3397                         if (cflag & PARODD) {
3398                                 cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
3399                         } else {
3400                                 cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
3401                         }
3402                 } else {
3403                         cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
3404                 }
3405
3406                 /* CTS flow control flag */
3407                 if (cflag & CRTSCTS) {
3408                         cy_writel(&ch_ctrl->hw_flow,
3409                                 readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
3410                 } else {
3411                         cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
3412                                         ~(C_RS_CTS | C_RS_RTS));
3413                 }
3414                 /* As the HW flow control is done in firmware, the driver
3415                    doesn't need to care about it */
3416                 info->flags &= ~ASYNC_CTS_FLOW;
3417
3418                 /* XON/XOFF/XANY flow control flags */
3419                 sw_flow = 0;
3420                 if (iflag & IXON) {
3421                         sw_flow |= C_FL_OXX;
3422                         if (iflag & IXANY)
3423                                 sw_flow |= C_FL_OIXANY;
3424                 }
3425                 cy_writel(&ch_ctrl->sw_flow, sw_flow);
3426
3427                 retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTL, 0L);
3428                 if (retval != 0) {
3429                         printk("cyc:set_line_char retval on ttyC%d was %x\n",
3430                                 info->line, retval);
3431                 }
3432
3433                 /* CD sensitivity */
3434                 if (cflag & CLOCAL) {
3435                         info->flags &= ~ASYNC_CHECK_CD;
3436                 } else {
3437                         info->flags |= ASYNC_CHECK_CD;
3438                 }
3439
3440                 if (baud == 0) {        /* baud rate is zero, turn off line */
3441                         cy_writel(&ch_ctrl->rs_control,
3442                                   readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
3443 #ifdef CY_DEBUG_DTR
3444                         printk("cyc:set_line_char dropping Z DTR\n");
3445 #endif
3446                 } else {
3447                         cy_writel(&ch_ctrl->rs_control,
3448                                   readl(&ch_ctrl->rs_control) | C_RS_DTR);
3449 #ifdef CY_DEBUG_DTR
3450                         printk("cyc:set_line_char raising Z DTR\n");
3451 #endif
3452                 }
3453
3454                 retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTLM,0L);
3455                 if (retval != 0) {
3456                         printk("cyc:set_line_char(2) retval on ttyC%d was %x\n",
3457                                 info->line, retval);
3458                 }
3459
3460                 if (info->tty) {
3461                         clear_bit(TTY_IO_ERROR, &info->tty->flags);
3462                 }
3463         }
3464 }                               /* set_line_char */
3465
3466 static int
3467 get_serial_info(struct cyclades_port *info,
3468                 struct serial_struct __user * retinfo)
3469 {
3470         struct serial_struct tmp;
3471         struct cyclades_card *cinfo = &cy_card[info->card];
3472
3473         if (!retinfo)
3474                 return -EFAULT;
3475         memset(&tmp, 0, sizeof(tmp));
3476         tmp.type = info->type;
3477         tmp.line = info->line;
3478         tmp.port = info->card * 0x100 + info->line - cinfo->first_line;
3479         tmp.irq = cinfo->irq;
3480         tmp.flags = info->flags;
3481         tmp.close_delay = info->close_delay;
3482         tmp.closing_wait = info->closing_wait;
3483         tmp.baud_base = info->baud;
3484         tmp.custom_divisor = info->custom_divisor;
3485         tmp.hub6 = 0;           /*!!! */
3486         return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
3487 }                               /* get_serial_info */
3488
3489 static int
3490 set_serial_info(struct cyclades_port *info,
3491                 struct serial_struct __user * new_info)
3492 {
3493         struct serial_struct new_serial;
3494         struct cyclades_port old_info;
3495
3496         if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
3497                 return -EFAULT;
3498         old_info = *info;
3499
3500         if (!capable(CAP_SYS_ADMIN)) {
3501                 if (new_serial.close_delay != info->close_delay ||
3502                                 new_serial.baud_base != info->baud ||
3503                                 (new_serial.flags & ASYNC_FLAGS &
3504                                         ~ASYNC_USR_MASK) !=
3505                                 (info->flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
3506                         return -EPERM;
3507                 info->flags = (info->flags & ~ASYNC_USR_MASK) |
3508                                 (new_serial.flags & ASYNC_USR_MASK);
3509                 info->baud = new_serial.baud_base;
3510                 info->custom_divisor = new_serial.custom_divisor;
3511                 goto check_and_exit;
3512         }
3513
3514         /*
3515          * OK, past this point, all the error checking has been done.
3516          * At this point, we start making changes.....
3517          */
3518
3519         info->baud = new_serial.baud_base;
3520         info->custom_divisor = new_serial.custom_divisor;
3521         info->flags = (info->flags & ~ASYNC_FLAGS) |
3522                         (new_serial.flags & ASYNC_FLAGS);
3523         info->close_delay = new_serial.close_delay * HZ / 100;
3524         info->closing_wait = new_serial.closing_wait * HZ / 100;
3525
3526 check_and_exit:
3527         if (info->flags & ASYNC_INITIALIZED) {
3528                 set_line_char(info);
3529                 return 0;
3530         } else {
3531                 return startup(info);
3532         }
3533 }                               /* set_serial_info */
3534
3535 /*
3536  * get_lsr_info - get line status register info
3537  *
3538  * Purpose: Let user call ioctl() to get info when the UART physically
3539  *          is emptied.  On bus types like RS485, the transmitter must
3540  *          release the bus after transmitting. This must be done when
3541  *          the transmit shift register is empty, not be done when the
3542  *          transmit holding register is empty.  This functionality
3543  *          allows an RS485 driver to be written in user space.
3544  */
3545 static int get_lsr_info(struct cyclades_port *info, unsigned int __user * value)
3546 {
3547         int card, chip, channel, index;
3548         unsigned char status;
3549         unsigned int result;
3550         unsigned long flags;
3551         void __iomem *base_addr;
3552
3553         card = info->card;
3554         channel = (info->line) - (cy_card[card].first_line);
3555         if (!IS_CYC_Z(cy_card[card])) {
3556                 chip = channel >> 2;
3557                 channel &= 0x03;
3558                 index = cy_card[card].bus_index;
3559                 base_addr =
3560                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3561
3562                 CY_LOCK(info, flags);
3563                 status = readb(base_addr + (CySRER << index)) &
3564                                 (CyTxRdy | CyTxMpty);
3565                 CY_UNLOCK(info, flags);
3566                 result = (status ? 0 : TIOCSER_TEMT);
3567         } else {
3568                 /* Not supported yet */
3569                 return -EINVAL;
3570         }
3571         return put_user(result, (unsigned long __user *)value);
3572 }
3573
3574 static int cy_tiocmget(struct tty_struct *tty, struct file *file)
3575 {
3576         struct cyclades_port *info = tty->driver_data;
3577         int card, chip, channel, index;
3578         void __iomem *base_addr;
3579         unsigned long flags;
3580         unsigned char status;
3581         unsigned long lstatus;
3582         unsigned int result;
3583         struct FIRM_ID __iomem *firm_id;
3584         struct ZFW_CTRL __iomem *zfw_ctrl;
3585         struct BOARD_CTRL __iomem *board_ctrl;
3586         struct CH_CTRL __iomem *ch_ctrl;
3587
3588         if (serial_paranoia_check(info, tty->name, __FUNCTION__))
3589                 return -ENODEV;
3590
3591         card = info->card;
3592         channel = (info->line) - (cy_card[card].first_line);
3593         if (!IS_CYC_Z(cy_card[card])) {
3594                 chip = channel >> 2;
3595                 channel &= 0x03;
3596                 index = cy_card[card].bus_index;
3597                 base_addr =
3598                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3599
3600                 CY_LOCK(info, flags);
3601                 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
3602                 status = readb(base_addr + (CyMSVR1 << index));
3603                 status |= readb(base_addr + (CyMSVR2 << index));
3604                 CY_UNLOCK(info, flags);
3605
3606                 if (info->rtsdtr_inv) {
3607                         result = ((status & CyRTS) ? TIOCM_DTR : 0) |
3608                                 ((status & CyDTR) ? TIOCM_RTS : 0);
3609                 } else {
3610                         result = ((status & CyRTS) ? TIOCM_RTS : 0) |
3611                                 ((status & CyDTR) ? TIOCM_DTR : 0);
3612                 }
3613                 result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
3614                         ((status & CyRI) ? TIOCM_RNG : 0) |
3615                         ((status & CyDSR) ? TIOCM_DSR : 0) |
3616                         ((status & CyCTS) ? TIOCM_CTS : 0);
3617         } else {
3618                 base_addr = cy_card[card].base_addr;
3619                 firm_id = cy_card[card].base_addr + ID_ADDRESS;
3620                 if (ISZLOADED(cy_card[card])) {
3621                         zfw_ctrl = cy_card[card].base_addr +
3622                                 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3623                         board_ctrl = &zfw_ctrl->board_ctrl;
3624                         ch_ctrl = zfw_ctrl->ch_ctrl;
3625                         lstatus = readl(&ch_ctrl[channel].rs_status);
3626                         result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
3627                                 ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
3628                                 ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
3629                                 ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
3630                                 ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
3631                                 ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
3632                 } else {
3633                         result = 0;
3634                         return -ENODEV;
3635                 }
3636
3637         }
3638         return result;
3639 }                               /* cy_tiomget */
3640
3641 static int
3642 cy_tiocmset(struct tty_struct *tty, struct file *file,
3643                 unsigned int set, unsigned int clear)
3644 {
3645         struct cyclades_port *info = tty->driver_data;
3646         int card, chip, channel, index;
3647         void __iomem *base_addr;
3648         unsigned long flags;
3649         struct FIRM_ID __iomem *firm_id;
3650         struct ZFW_CTRL __iomem *zfw_ctrl;
3651         struct BOARD_CTRL __iomem *board_ctrl;
3652         struct CH_CTRL __iomem *ch_ctrl;
3653         int retval;
3654
3655         if (serial_paranoia_check(info, tty->name, __FUNCTION__))
3656                 return -ENODEV;
3657
3658         card = info->card;
3659         channel = (info->line) - (cy_card[card].first_line);
3660         if (!IS_CYC_Z(cy_card[card])) {
3661                 chip = channel >> 2;
3662                 channel &= 0x03;
3663                 index = cy_card[card].bus_index;
3664                 base_addr =
3665                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3666
3667                 if (set & TIOCM_RTS) {
3668                         CY_LOCK(info, flags);
3669                         cy_writeb(base_addr + (CyCAR << index),
3670                                   (u_char) channel);
3671                         if (info->rtsdtr_inv) {
3672                                 cy_writeb(base_addr + (CyMSVR2 << index),
3673                                           CyDTR);
3674                         } else {
3675                                 cy_writeb(base_addr + (CyMSVR1 << index),
3676                                           CyRTS);
3677                         }
3678                         CY_UNLOCK(info, flags);
3679                 }
3680                 if (clear & TIOCM_RTS) {
3681                         CY_LOCK(info, flags);
3682                         cy_writeb(base_addr + (CyCAR << index),
3683                                   (u_char) channel);
3684                         if (info->rtsdtr_inv) {
3685                                 cy_writeb(base_addr + (CyMSVR2 << index),
3686                                           ~CyDTR);
3687                         } else {
3688                                 cy_writeb(base_addr + (CyMSVR1 << index),
3689                                           ~CyRTS);
3690                         }
3691                         CY_UNLOCK(info, flags);
3692                 }
3693                 if (set & TIOCM_DTR) {
3694                         CY_LOCK(info, flags);
3695                         cy_writeb(base_addr + (CyCAR << index),
3696                                   (u_char) channel);
3697                         if (info->rtsdtr_inv) {
3698                                 cy_writeb(base_addr + (CyMSVR1 << index),
3699                                           CyRTS);
3700                         } else {
3701                                 cy_writeb(base_addr + (CyMSVR2 << index),
3702                                           CyDTR);
3703                         }
3704 #ifdef CY_DEBUG_DTR
3705                         printk("cyc:set_modem_info raising DTR\n");
3706                         printk("     status: 0x%x, 0x%x\n",
3707                                 readb(base_addr + (CyMSVR1 << index)),
3708                                 readb(base_addr + (CyMSVR2 << index)));
3709 #endif
3710                         CY_UNLOCK(info, flags);
3711                 }
3712                 if (clear & TIOCM_DTR) {
3713                         CY_LOCK(info, flags);
3714                         cy_writeb(base_addr + (CyCAR << index),
3715                                   (u_char) channel);
3716                         if (info->rtsdtr_inv) {
3717                                 cy_writeb(base_addr + (CyMSVR1 << index),
3718                                           ~CyRTS);
3719                         } else {
3720                                 cy_writeb(base_addr + (CyMSVR2 << index),
3721                                           ~CyDTR);
3722                         }
3723
3724 #ifdef CY_DEBUG_DTR
3725                         printk("cyc:set_modem_info dropping DTR\n");
3726                         printk("     status: 0x%x, 0x%x\n",
3727                                 readb(base_addr + (CyMSVR1 << index)),
3728                                 readb(base_addr + (CyMSVR2 << index)));
3729 #endif
3730                         CY_UNLOCK(info, flags);
3731                 }
3732         } else {
3733                 base_addr = cy_card[card].base_addr;
3734
3735                 firm_id = cy_card[card].base_addr + ID_ADDRESS;
3736                 if (ISZLOADED(cy_card[card])) {
3737                         zfw_ctrl = cy_card[card].base_addr +
3738                                 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3739                         board_ctrl = &zfw_ctrl->board_ctrl;
3740                         ch_ctrl = zfw_ctrl->ch_ctrl;
3741
3742                         if (set & TIOCM_RTS) {
3743                                 CY_LOCK(info, flags);
3744                                 cy_writel(&ch_ctrl[channel].rs_control,
3745                                         readl(&ch_ctrl[channel].rs_control) |
3746                                         C_RS_RTS);
3747                                 CY_UNLOCK(info, flags);
3748                         }
3749                         if (clear & TIOCM_RTS) {
3750                                 CY_LOCK(info, flags);
3751                                 cy_writel(&ch_ctrl[channel].rs_control,
3752                                         readl(&ch_ctrl[channel].rs_control) &
3753                                         ~C_RS_RTS);
3754                                 CY_UNLOCK(info, flags);
3755                         }
3756                         if (set & TIOCM_DTR) {
3757                                 CY_LOCK(info, flags);
3758                                 cy_writel(&ch_ctrl[channel].rs_control,
3759                                         readl(&ch_ctrl[channel].rs_control) |
3760                                         C_RS_DTR);
3761 #ifdef CY_DEBUG_DTR
3762                                 printk("cyc:set_modem_info raising Z DTR\n");
3763 #endif
3764                                 CY_UNLOCK(info, flags);
3765                         }
3766                         if (clear & TIOCM_DTR) {
3767                                 CY_LOCK(info, flags);
3768                                 cy_writel(&ch_ctrl[channel].rs_control,
3769                                         readl(&ch_ctrl[channel].rs_control) &
3770                                         ~C_RS_DTR);
3771 #ifdef CY_DEBUG_DTR
3772                                 printk("cyc:set_modem_info clearing Z DTR\n");
3773 #endif
3774                                 CY_UNLOCK(info, flags);
3775                         }
3776                 } else {
3777                         return -ENODEV;
3778                 }
3779                 CY_LOCK(info, flags);
3780                 retval = cyz_issue_cmd(&cy_card[info->card],
3781                                         channel, C_CM_IOCTLM, 0L);
3782                 if (retval != 0) {
3783                         printk("cyc:set_modem_info retval on ttyC%d was %x\n",
3784                                 info->line, retval);
3785                 }
3786                 CY_UNLOCK(info, flags);
3787         }
3788         return 0;
3789 }                               /* cy_tiocmset */
3790
3791 /*
3792  * cy_break() --- routine which turns the break handling on or off
3793  */
3794 static void cy_break(struct tty_struct *tty, int break_state)
3795 {
3796         struct cyclades_port *info = tty->driver_data;
3797         unsigned long flags;
3798
3799         if (serial_paranoia_check(info, tty->name, "cy_break"))
3800                 return;
3801
3802         CY_LOCK(info, flags);
3803         if (!IS_CYC_Z(cy_card[info->card])) {
3804                 /* Let the transmit ISR take care of this (since it
3805                    requires stuffing characters into the output stream).
3806                  */
3807                 if (break_state == -1) {
3808                         if (!info->breakon) {
3809                                 info->breakon = 1;
3810                                 if (!info->xmit_cnt) {
3811                                         CY_UNLOCK(info, flags);
3812                                         start_xmit(info);
3813                                         CY_LOCK(info, flags);
3814                                 }
3815                         }
3816                 } else {
3817                         if (!info->breakoff) {
3818                                 info->breakoff = 1;
3819                                 if (!info->xmit_cnt) {
3820                                         CY_UNLOCK(info, flags);
3821                                         start_xmit(info);
3822                                         CY_LOCK(info, flags);
3823                                 }
3824                         }
3825                 }
3826         } else {
3827                 int retval;
3828
3829                 if (break_state == -1) {
3830                         retval = cyz_issue_cmd(&cy_card[info->card],
3831                                 info->line - cy_card[info->card].first_line,
3832                                 C_CM_SET_BREAK, 0L);
3833                         if (retval != 0) {
3834                                 printk("cyc:cy_break (set) retval on ttyC%d "
3835                                         "was %x\n", info->line, retval);
3836                         }
3837                 } else {
3838                         retval = cyz_issue_cmd(&cy_card[info->card],
3839                                 info->line - cy_card[info->card].first_line,
3840                                 C_CM_CLR_BREAK, 0L);
3841                         if (retval != 0) {
3842                                 printk("cyc:cy_break (clr) retval on ttyC%d "
3843                                         "was %x\n", info->line, retval);
3844                         }
3845                 }
3846         }
3847         CY_UNLOCK(info, flags);
3848 }                               /* cy_break */
3849
3850 static int
3851 get_mon_info(struct cyclades_port *info, struct cyclades_monitor __user * mon)
3852 {
3853
3854         if (copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
3855                 return -EFAULT;
3856         info->mon.int_count = 0;
3857         info->mon.char_count = 0;
3858         info->mon.char_max = 0;
3859         info->mon.char_last = 0;
3860         return 0;
3861 }                               /* get_mon_info */
3862
3863 static int set_threshold(struct cyclades_port *info, unsigned long value)
3864 {
3865         void __iomem *base_addr;
3866         int card, channel, chip, index;
3867         unsigned long flags;
3868
3869         card = info->card;
3870         channel = info->line - cy_card[card].first_line;
3871         if (!IS_CYC_Z(cy_card[card])) {
3872                 chip = channel >> 2;
3873                 channel &= 0x03;
3874                 index = cy_card[card].bus_index;
3875                 base_addr =
3876                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3877
3878                 info->cor3 &= ~CyREC_FIFO;
3879                 info->cor3 |= value & CyREC_FIFO;
3880
3881                 CY_LOCK(info, flags);
3882                 cy_writeb(base_addr + (CyCOR3 << index), info->cor3);
3883                 cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR3ch, index);
3884                 CY_UNLOCK(info, flags);
3885         } else {
3886                 /* Nothing to do! */
3887         }
3888         return 0;
3889 }                               /* set_threshold */
3890
3891 static int
3892 get_threshold(struct cyclades_port *info, unsigned long __user * value)
3893 {
3894         void __iomem *base_addr;
3895         int card, channel, chip, index;
3896         unsigned long tmp;
3897
3898         card = info->card;
3899         channel = info->line - cy_card[card].first_line;
3900         if (!IS_CYC_Z(cy_card[card])) {
3901                 chip = channel >> 2;
3902                 channel &= 0x03;
3903                 index = cy_card[card].bus_index;
3904                 base_addr =
3905                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3906
3907                 tmp = readb(base_addr + (CyCOR3 << index)) & CyREC_FIFO;
3908                 return put_user(tmp, value);
3909         } else {
3910                 /* Nothing to do! */
3911                 return 0;
3912         }
3913 }                               /* get_threshold */
3914
3915 static int
3916 set_default_threshold(struct cyclades_port *info, unsigned long value)
3917 {
3918         info->default_threshold = value & 0x0f;
3919         return 0;
3920 }                               /* set_default_threshold */
3921
3922 static int
3923 get_default_threshold(struct cyclades_port *info, unsigned long __user * value)
3924 {
3925         return put_user(info->default_threshold, value);
3926 }                               /* get_default_threshold */
3927
3928 static int set_timeout(struct cyclades_port *info, unsigned long value)
3929 {
3930         void __iomem *base_addr;
3931         int card, channel, chip, index;
3932         unsigned long flags;
3933
3934         card = info->card;
3935         channel = info->line - cy_card[card].first_line;
3936         if (!IS_CYC_Z(cy_card[card])) {
3937                 chip = channel >> 2;
3938                 channel &= 0x03;
3939                 index = cy_card[card].bus_index;
3940                 base_addr =
3941                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3942
3943                 CY_LOCK(info, flags);
3944                 cy_writeb(base_addr + (CyRTPR << index), value & 0xff);
3945                 CY_UNLOCK(info, flags);
3946         } else {
3947                 /* Nothing to do! */
3948         }
3949         return 0;
3950 }                               /* set_timeout */
3951
3952 static int get_timeout(struct cyclades_port *info, unsigned long __user * value)
3953 {
3954         void __iomem *base_addr;
3955         int card, channel, chip, index;
3956         unsigned long tmp;
3957
3958         card = info->card;
3959         channel = info->line - cy_card[card].first_line;
3960         if (!IS_CYC_Z(cy_card[card])) {
3961                 chip = channel >> 2;
3962                 channel &= 0x03;
3963                 index = cy_card[card].bus_index;
3964                 base_addr =
3965                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3966
3967                 tmp = readb(base_addr + (CyRTPR << index));
3968                 return put_user(tmp, value);
3969         } else {
3970                 /* Nothing to do! */
3971                 return 0;
3972         }
3973 }                               /* get_timeout */
3974
3975 static int set_default_timeout(struct cyclades_port *info, unsigned long value)
3976 {
3977         info->default_timeout = value & 0xff;
3978         return 0;
3979 }                               /* set_default_timeout */
3980
3981 static int
3982 get_default_timeout(struct cyclades_port *info, unsigned long __user * value)
3983 {
3984         return put_user(info->default_timeout, value);
3985 }                               /* get_default_timeout */
3986
3987 /*
3988  * This routine allows the tty driver to implement device-
3989  * specific ioctl's.  If the ioctl number passed in cmd is
3990  * not recognized by the driver, it should return ENOIOCTLCMD.
3991  */
3992 static int
3993 cy_ioctl(struct tty_struct *tty, struct file *file,
3994          unsigned int cmd, unsigned long arg)
3995 {
3996         struct cyclades_port *info = tty->driver_data;
3997         struct cyclades_icount cprev, cnow;     /* kernel counter temps */
3998         struct serial_icounter_struct __user *p_cuser;  /* user space */
3999         int ret_val = 0;
4000         unsigned long flags;
4001         void __user *argp = (void __user *)arg;
4002
4003         if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
4004                 return -ENODEV;
4005
4006 #ifdef CY_DEBUG_OTHER
4007         printk("cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n", info->line, cmd, arg);      /* */
4008 #endif
4009
4010         switch (cmd) {
4011         case CYGETMON:
4012                 ret_val = get_mon_info(info, argp);
4013                 break;
4014         case CYGETTHRESH:
4015                 ret_val = get_threshold(info, argp);
4016                 break;
4017         case CYSETTHRESH:
4018                 ret_val = set_threshold(info, arg);
4019                 break;
4020         case CYGETDEFTHRESH:
4021                 ret_val = get_default_threshold(info, argp);
4022                 break;
4023         case CYSETDEFTHRESH:
4024                 ret_val = set_default_threshold(info, arg);
4025                 break;
4026         case CYGETTIMEOUT:
4027                 ret_val = get_timeout(info, argp);
4028                 break;
4029         case CYSETTIMEOUT:
4030                 ret_val = set_timeout(info, arg);
4031                 break;
4032         case CYGETDEFTIMEOUT:
4033                 ret_val = get_default_timeout(info, argp);
4034                 break;
4035         case CYSETDEFTIMEOUT:
4036                 ret_val = set_default_timeout(info, arg);
4037                 break;
4038         case CYSETRFLOW:
4039                 info->rflow = (int)arg;
4040                 ret_val = 0;
4041                 break;
4042         case CYGETRFLOW:
4043                 ret_val = info->rflow;
4044                 break;
4045         case CYSETRTSDTR_INV:
4046                 info->rtsdtr_inv = (int)arg;
4047                 ret_val = 0;
4048                 break;
4049         case CYGETRTSDTR_INV:
4050                 ret_val = info->rtsdtr_inv;
4051                 break;
4052         case CYGETCD1400VER:
4053                 ret_val = info->chip_rev;
4054                 break;
4055 #ifndef CONFIG_CYZ_INTR
4056         case CYZSETPOLLCYCLE:
4057                 cyz_polling_cycle = (arg * HZ) / 1000;
4058                 ret_val = 0;
4059                 break;
4060         case CYZGETPOLLCYCLE:
4061                 ret_val = (cyz_polling_cycle * 1000) / HZ;
4062                 break;
4063 #endif                          /* CONFIG_CYZ_INTR */
4064         case CYSETWAIT:
4065                 info->closing_wait = (unsigned short)arg *HZ / 100;
4066                 ret_val = 0;
4067                 break;
4068         case CYGETWAIT:
4069                 ret_val = info->closing_wait / (HZ / 100);
4070                 break;
4071         case TIOCGSERIAL:
4072                 ret_val = get_serial_info(info, argp);
4073                 break;
4074         case TIOCSSERIAL:
4075                 ret_val = set_serial_info(info, argp);
4076                 break;
4077         case TIOCSERGETLSR:     /* Get line status register */
4078                 ret_val = get_lsr_info(info, argp);
4079                 break;
4080                 /*
4081                  * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
4082                  * - mask passed in arg for lines of interest
4083                  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
4084                  * Caller should use TIOCGICOUNT to see which one it was
4085                  */
4086         case TIOCMIWAIT:
4087                 CY_LOCK(info, flags);
4088                 /* note the counters on entry */
4089                 cprev = info->icount;
4090                 CY_UNLOCK(info, flags);
4091                 while (1) {
4092                         interruptible_sleep_on(&info->delta_msr_wait);
4093                         /* see if a signal did it */
4094                         if (signal_pending(current)) {
4095                                 return -ERESTARTSYS;
4096                         }
4097
4098                         CY_LOCK(info, flags);
4099                         cnow = info->icount;    /* atomic copy */
4100                         CY_UNLOCK(info, flags);
4101
4102                         if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
4103                             cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
4104                                 return -EIO;    /* no change => error */
4105                         }
4106                         if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
4107                             ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
4108                             ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
4109                             ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
4110                                 return 0;
4111                         }
4112                         cprev = cnow;
4113                 }
4114                 /* NOTREACHED */
4115
4116                 /*
4117                  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
4118                  * Return: write counters to the user passed counter struct
4119                  * NB: both 1->0 and 0->1 transitions are counted except for
4120                  *     RI where only 0->1 is counted.
4121                  */
4122         case TIOCGICOUNT:
4123                 CY_LOCK(info, flags);
4124                 cnow = info->icount;
4125                 CY_UNLOCK(info, flags);
4126                 p_cuser = argp;
4127                 ret_val = put_user(cnow.cts, &p_cuser->cts);
4128                 if (ret_val)
4129                         return ret_val;
4130                 ret_val = put_user(cnow.dsr, &p_cuser->dsr);
4131                 if (ret_val)
4132                         return ret_val;
4133                 ret_val = put_user(cnow.rng, &p_cuser->rng);
4134                 if (ret_val)
4135                         return ret_val;
4136                 ret_val = put_user(cnow.dcd, &p_cuser->dcd);
4137                 if (ret_val)
4138                         return ret_val;
4139                 ret_val = put_user(cnow.rx, &p_cuser->rx);
4140                 if (ret_val)
4141                         return ret_val;
4142                 ret_val = put_user(cnow.tx, &p_cuser->tx);
4143                 if (ret_val)
4144                         return ret_val;
4145                 ret_val = put_user(cnow.frame, &p_cuser->frame);
4146                 if (ret_val)
4147                         return ret_val;
4148                 ret_val = put_user(cnow.overrun, &p_cuser->overrun);
4149                 if (ret_val)
4150                         return ret_val;
4151                 ret_val = put_user(cnow.parity, &p_cuser->parity);
4152                 if (ret_val)
4153                         return ret_val;
4154                 ret_val = put_user(cnow.brk, &p_cuser->brk);
4155                 if (ret_val)
4156                         return ret_val;
4157                 ret_val = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
4158                 if (ret_val)
4159                         return ret_val;
4160                 ret_val = 0;
4161                 break;
4162         default:
4163                 ret_val = -ENOIOCTLCMD;
4164         }
4165
4166 #ifdef CY_DEBUG_OTHER
4167         printk(" cyc:cy_ioctl done\n");
4168 #endif
4169
4170         return ret_val;
4171 }                               /* cy_ioctl */
4172
4173 /*
4174  * This routine allows the tty driver to be notified when
4175  * device's termios settings have changed.  Note that a
4176  * well-designed tty driver should be prepared to accept the case
4177  * where old == NULL, and try to do something rational.
4178  */
4179 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
4180 {
4181         struct cyclades_port *info = tty->driver_data;
4182
4183 #ifdef CY_DEBUG_OTHER
4184         printk("cyc:cy_set_termios ttyC%d\n", info->line);
4185 #endif
4186
4187         if (tty->termios->c_cflag == old_termios->c_cflag &&
4188                         (tty->termios->c_iflag & (IXON | IXANY)) ==
4189                         (old_termios->c_iflag & (IXON | IXANY)))
4190                 return;
4191         set_line_char(info);
4192
4193         if ((old_termios->c_cflag & CRTSCTS) &&
4194                         !(tty->termios->c_cflag & CRTSCTS)) {
4195                 tty->hw_stopped = 0;
4196                 cy_start(tty);
4197         }
4198 #if 0
4199         /*
4200          * No need to wake up processes in open wait, since they
4201          * sample the CLOCAL flag once, and don't recheck it.
4202          * XXX  It's not clear whether the current behavior is correct
4203          * or not.  Hence, this may change.....
4204          */
4205         if (!(old_termios->c_cflag & CLOCAL) &&
4206             (tty->termios->c_cflag & CLOCAL))
4207                 wake_up_interruptible(&info->open_wait);
4208 #endif
4209 }                               /* cy_set_termios */
4210
4211 /* This function is used to send a high-priority XON/XOFF character to
4212    the device.
4213 */
4214 static void cy_send_xchar(struct tty_struct *tty, char ch)
4215 {
4216         struct cyclades_port *info = tty->driver_data;
4217         int card, channel;
4218
4219         if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
4220                 return;
4221
4222         info->x_char = ch;
4223
4224         if (ch)
4225                 cy_start(tty);
4226
4227         card = info->card;
4228         channel = info->line - cy_card[card].first_line;
4229
4230         if (IS_CYC_Z(cy_card[card])) {
4231                 if (ch == STOP_CHAR(tty))
4232                         cyz_issue_cmd(&cy_card[card], channel, C_CM_SENDXOFF,
4233                                         0L);
4234                 else if (ch == START_CHAR(tty))
4235                         cyz_issue_cmd(&cy_card[card], channel, C_CM_SENDXON,
4236                                         0L);
4237         }
4238 }
4239
4240 /* This routine is called by the upper-layer tty layer to signal
4241    that incoming characters should be throttled because the input
4242    buffers are close to full.
4243  */
4244 static void cy_throttle(struct tty_struct *tty)
4245 {
4246         struct cyclades_port *info = tty->driver_data;
4247         unsigned long flags;
4248         void __iomem *base_addr;
4249         int card, chip, channel, index;
4250
4251 #ifdef CY_DEBUG_THROTTLE
4252         char buf[64];
4253
4254         printk("cyc:throttle %s: %d....ttyC%d\n", tty_name(tty, buf),
4255                         tty->ldisc.chars_in_buffer(tty), info->line);
4256 #endif
4257
4258         if (serial_paranoia_check(info, tty->name, "cy_throttle")) {
4259                 return;
4260         }
4261
4262         card = info->card;
4263
4264         if (I_IXOFF(tty)) {
4265                 if (!IS_CYC_Z(cy_card[card]))
4266                         cy_send_xchar(tty, STOP_CHAR(tty));
4267                 else
4268                         info->throttle = 1;
4269         }
4270
4271         if (tty->termios->c_cflag & CRTSCTS) {
4272                 channel = info->line - cy_card[card].first_line;
4273                 if (!IS_CYC_Z(cy_card[card])) {
4274                         chip = channel >> 2;
4275                         channel &= 0x03;
4276                         index = cy_card[card].bus_index;
4277                         base_addr = cy_card[card].base_addr +
4278                                 (cy_chip_offset[chip] << index);
4279
4280                         CY_LOCK(info, flags);
4281                         cy_writeb(base_addr + (CyCAR << index),
4282                                   (u_char) channel);
4283                         if (info->rtsdtr_inv) {
4284                                 cy_writeb(base_addr + (CyMSVR2 << index),
4285                                           ~CyDTR);
4286                         } else {
4287                                 cy_writeb(base_addr + (CyMSVR1 << index),
4288                                           ~CyRTS);
4289                         }
4290                         CY_UNLOCK(info, flags);
4291                 } else {
4292                         info->throttle = 1;
4293                 }
4294         }
4295 }                               /* cy_throttle */
4296
4297 /*
4298  * This routine notifies the tty driver that it should signal
4299  * that characters can now be sent to the tty without fear of
4300  * overrunning the input buffers of the line disciplines.
4301  */
4302 static void cy_unthrottle(struct tty_struct *tty)
4303 {
4304         struct cyclades_port *info = tty->driver_data;
4305         unsigned long flags;
4306         void __iomem *base_addr;
4307         int card, chip, channel, index;
4308
4309 #ifdef CY_DEBUG_THROTTLE
4310         char buf[64];
4311
4312         printk("cyc:unthrottle %s: %d....ttyC%d\n", tty_name(tty, buf),
4313                 tty->ldisc.chars_in_buffer(tty), info->line);
4314 #endif
4315
4316         if (serial_paranoia_check(info, tty->name, "cy_unthrottle")) {
4317                 return;
4318         }
4319
4320         if (I_IXOFF(tty)) {
4321                 if (info->x_char)
4322                         info->x_char = 0;
4323                 else
4324                         cy_send_xchar(tty, START_CHAR(tty));
4325         }
4326
4327         if (tty->termios->c_cflag & CRTSCTS) {
4328                 card = info->card;
4329                 channel = info->line - cy_card[card].first_line;
4330                 if (!IS_CYC_Z(cy_card[card])) {
4331                         chip = channel >> 2;
4332                         channel &= 0x03;
4333                         index = cy_card[card].bus_index;
4334                         base_addr = cy_card[card].base_addr +
4335                                 (cy_chip_offset[chip] << index);
4336
4337                         CY_LOCK(info, flags);
4338                         cy_writeb(base_addr + (CyCAR << index),
4339                                   (u_char) channel);
4340                         if (info->rtsdtr_inv) {
4341                                 cy_writeb(base_addr + (CyMSVR2 << index),
4342                                           CyDTR);
4343                         } else {
4344                                 cy_writeb(base_addr + (CyMSVR1 << index),
4345                                           CyRTS);
4346                         }
4347                         CY_UNLOCK(info, flags);
4348                 } else {
4349                         info->throttle = 0;
4350                 }
4351         }
4352 }                               /* cy_unthrottle */
4353
4354 /* cy_start and cy_stop provide software output flow control as a
4355    function of XON/XOFF, software CTS, and other such stuff.
4356 */
4357 static void cy_stop(struct tty_struct *tty)
4358 {
4359         struct cyclades_card *cinfo;
4360         struct cyclades_port *info = tty->driver_data;
4361         void __iomem *base_addr;
4362         int chip, channel, index;
4363         unsigned long flags;
4364
4365 #ifdef CY_DEBUG_OTHER
4366         printk("cyc:cy_stop ttyC%d\n", info->line);     /* */
4367 #endif
4368
4369         if (serial_paranoia_check(info, tty->name, "cy_stop"))
4370                 return;
4371
4372         cinfo = &cy_card[info->card];
4373         channel = info->line - cinfo->first_line;
4374         if (!IS_CYC_Z(*cinfo)) {
4375                 index = cinfo->bus_index;
4376                 chip = channel >> 2;
4377                 channel &= 0x03;
4378                 base_addr = cy_card[info->card].base_addr +
4379                         (cy_chip_offset[chip] << index);
4380
4381                 CY_LOCK(info, flags);
4382                 cy_writeb(base_addr + (CyCAR << index),
4383                         (u_char)(channel & 0x0003)); /* index channel */
4384                 cy_writeb(base_addr + (CySRER << index),
4385                           readb(base_addr + (CySRER << index)) & ~CyTxRdy);
4386                 CY_UNLOCK(info, flags);
4387         } else {
4388                 /* Nothing to do! */
4389         }
4390 }                               /* cy_stop */
4391
4392 static void cy_start(struct tty_struct *tty)
4393 {
4394         struct cyclades_card *cinfo;
4395         struct cyclades_port *info = tty->driver_data;
4396         void __iomem *base_addr;
4397         int chip, channel, index;
4398         unsigned long flags;
4399
4400 #ifdef CY_DEBUG_OTHER
4401         printk("cyc:cy_start ttyC%d\n", info->line);    /* */
4402 #endif
4403
4404         if (serial_paranoia_check(info, tty->name, "cy_start"))
4405                 return;
4406
4407         cinfo = &cy_card[info->card];
4408         channel = info->line - cinfo->first_line;
4409         index = cinfo->bus_index;
4410         if (!IS_CYC_Z(*cinfo)) {
4411                 chip = channel >> 2;
4412                 channel &= 0x03;
4413                 base_addr = cy_card[info->card].base_addr +
4414                         (cy_chip_offset[chip] << index);
4415
4416                 CY_LOCK(info, flags);
4417                 cy_writeb(base_addr + (CyCAR << index), (u_char) (channel & 0x0003));   /* index channel */
4418                 cy_writeb(base_addr + (CySRER << index),
4419                           readb(base_addr + (CySRER << index)) | CyTxRdy);
4420                 CY_UNLOCK(info, flags);
4421         } else {
4422                 /* Nothing to do! */
4423         }
4424 }                               /* cy_start */
4425
4426 static void cy_flush_buffer(struct tty_struct *tty)
4427 {
4428         struct cyclades_port *info = tty->driver_data;
4429         int card, channel, retval;
4430         unsigned long flags;
4431
4432 #ifdef CY_DEBUG_IO
4433         printk("cyc:cy_flush_buffer ttyC%d\n", info->line);     /* */
4434 #endif
4435
4436         if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
4437                 return;
4438
4439         card = info->card;
4440         channel = (info->line) - (cy_card[card].first_line);
4441
4442         CY_LOCK(info, flags);
4443         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
4444         CY_UNLOCK(info, flags);
4445
4446         if (IS_CYC_Z(cy_card[card])) {  /* If it is a Z card, flush the on-board
4447                                            buffers as well */
4448                 CY_LOCK(info, flags);
4449                 retval =
4450                     cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_TX, 0L);
4451                 if (retval != 0) {
4452                         printk("cyc: flush_buffer retval on ttyC%d was %x\n",
4453                                 info->line, retval);
4454                 }
4455                 CY_UNLOCK(info, flags);
4456         }
4457         tty_wakeup(tty);
4458 }                               /* cy_flush_buffer */
4459
4460 /*
4461  * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
4462  */
4463 static void cy_hangup(struct tty_struct *tty)
4464 {
4465         struct cyclades_port *info = tty->driver_data;
4466
4467 #ifdef CY_DEBUG_OTHER
4468         printk("cyc:cy_hangup ttyC%d\n", info->line);   /* */
4469 #endif
4470
4471         if (serial_paranoia_check(info, tty->name, "cy_hangup"))
4472                 return;
4473
4474         cy_flush_buffer(tty);
4475         shutdown(info);
4476         info->event = 0;
4477         info->count = 0;
4478 #ifdef CY_DEBUG_COUNT
4479         printk("cyc:cy_hangup (%d): setting count to 0\n", current->pid);
4480 #endif
4481         info->tty = NULL;
4482         info->flags &= ~ASYNC_NORMAL_ACTIVE;
4483         wake_up_interruptible(&info->open_wait);
4484 }                               /* cy_hangup */
4485
4486 /*
4487  * ---------------------------------------------------------------------
4488  * cy_init() and friends
4489  *
4490  * cy_init() is called at boot-time to initialize the serial driver.
4491  * ---------------------------------------------------------------------
4492  */
4493
4494 static void __devinit cy_init_card(struct cyclades_card *cinfo,
4495                 const unsigned int board)
4496 {
4497         struct cyclades_port *info;
4498         u32 mailbox;
4499         unsigned int nports;
4500         unsigned short chip_number;
4501         int index, port;
4502
4503         if (IS_CYC_Z(*cinfo)) { /* Cyclades-Z */
4504                 mailbox = readl(&((struct RUNTIME_9060 __iomem *)
4505                                      cinfo->ctl_addr)->mail_box_0);
4506                 nports = (mailbox == ZE_V1) ? ZE_V1_NPORTS : 8;
4507                 cinfo->intr_enabled = 0;
4508                 cinfo->nports = 0;      /* Will be correctly set later, after
4509                                            Z FW is loaded */
4510                 spin_lock_init(&cinfo->card_lock);
4511                 for (port = cinfo->first_line;
4512                      port < cinfo->first_line + nports; port++) {
4513                         info = &cy_port[port];
4514                         info->magic = CYCLADES_MAGIC;
4515                         info->type = PORT_STARTECH;
4516                         info->card = board;
4517                         info->line = port;
4518                         info->chip_rev = 0;
4519                         info->flags = STD_COM_FLAGS;
4520                         info->tty = NULL;
4521                         if (mailbox == ZO_V1)
4522                                 info->xmit_fifo_size = CYZ_FIFO_SIZE;
4523                         else
4524                                 info->xmit_fifo_size =
4525                                     4 * CYZ_FIFO_SIZE;
4526                         info->cor1 = 0;
4527                         info->cor2 = 0;
4528                         info->cor3 = 0;
4529                         info->cor4 = 0;
4530                         info->cor5 = 0;
4531                         info->tbpr = 0;
4532                         info->tco = 0;
4533                         info->rbpr = 0;
4534                         info->rco = 0;
4535                         info->custom_divisor = 0;
4536                         info->close_delay = 5 * HZ / 10;
4537                         info->closing_wait = CLOSING_WAIT_DELAY;
4538                         info->icount.cts = info->icount.dsr =
4539                             info->icount.rng = info->icount.dcd = 0;
4540                         info->icount.rx = info->icount.tx = 0;
4541                         info->icount.frame = info->icount.parity = 0;
4542                         info->icount.overrun = info->icount.brk = 0;
4543                         info->x_char = 0;
4544                         info->event = 0;
4545                         info->count = 0;
4546                         info->blocked_open = 0;
4547                         info->default_threshold = 0;
4548                         info->default_timeout = 0;
4549                         INIT_WORK(&info->tqueue, do_softint);
4550                         init_waitqueue_head(&info->open_wait);
4551                         init_waitqueue_head(&info->close_wait);
4552                         init_waitqueue_head(&info->shutdown_wait);
4553                         init_waitqueue_head(&info->delta_msr_wait);
4554                         /* info->session */
4555                         /* info->pgrp */
4556                         info->read_status_mask = 0;
4557                         /* info->timeout */
4558                         /* Bentson's vars */
4559                         info->jiffies[0] = 0;
4560                         info->jiffies[1] = 0;
4561                         info->jiffies[2] = 0;
4562                         info->rflush_count = 0;
4563 #ifdef CONFIG_CYZ_INTR
4564                         init_timer(&cyz_rx_full_timer[port]);
4565                         cyz_rx_full_timer[port].function = NULL;
4566 #endif
4567                 }
4568 #ifndef CONFIG_CYZ_INTR
4569                 if (!timer_pending(&cyz_timerlist)) {
4570                         mod_timer(&cyz_timerlist, jiffies + 1);
4571 #ifdef CY_PCI_DEBUG
4572                         printk("Cyclades-Z polling initialized\n");
4573 #endif
4574                 }
4575 #endif                          /* CONFIG_CYZ_INTR */
4576
4577         } else {        /* Cyclom-Y of some kind */
4578                 index = cinfo->bus_index;
4579                 spin_lock_init(&cinfo->card_lock);
4580                 cinfo->nports = CyPORTS_PER_CHIP * cinfo->num_chips;
4581                 for (port = cinfo->first_line;
4582                      port < cinfo->first_line + cinfo->nports; port++) {
4583                         info = &cy_port[port];
4584                         info->magic = CYCLADES_MAGIC;
4585                         info->type = PORT_CIRRUS;
4586                         info->card = board;
4587                         info->line = port;
4588                         info->flags = STD_COM_FLAGS;
4589                         info->tty = NULL;
4590                         info->xmit_fifo_size = CyMAX_CHAR_FIFO;
4591                         info->cor1 =
4592                             CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
4593                         info->cor2 = CyETC;
4594                         info->cor3 = 0x08;      /* _very_ small rcv threshold */
4595                         info->cor4 = 0;
4596                         info->cor5 = 0;
4597                         info->custom_divisor = 0;
4598                         info->close_delay = 5 * HZ / 10;
4599                         info->closing_wait = CLOSING_WAIT_DELAY;
4600                         info->icount.cts = info->icount.dsr =
4601                             info->icount.rng = info->icount.dcd = 0;
4602                         info->icount.rx = info->icount.tx = 0;
4603                         info->icount.frame = info->icount.parity = 0;
4604                         info->icount.overrun = info->icount.brk = 0;
4605                         chip_number = (port - cinfo->first_line) / 4;
4606                         if ((info->chip_rev =
4607                              readb(cinfo->base_addr +
4608                                       (cy_chip_offset[chip_number] <<
4609                                        index) + (CyGFRCR << index))) >=
4610                             CD1400_REV_J) {
4611                                 /* It is a CD1400 rev. J or later */
4612                                 info->tbpr = baud_bpr_60[13];   /* Tx BPR */
4613                                 info->tco = baud_co_60[13];     /* Tx CO */
4614                                 info->rbpr = baud_bpr_60[13];   /* Rx BPR */
4615                                 info->rco = baud_co_60[13];     /* Rx CO */
4616                                 info->rflow = 0;
4617                                 info->rtsdtr_inv = 1;
4618                         } else {
4619                                 info->tbpr = baud_bpr_25[13];   /* Tx BPR */
4620                                 info->tco = baud_co_25[13];     /* Tx CO */
4621                                 info->rbpr = baud_bpr_25[13];   /* Rx BPR */
4622                                 info->rco = baud_co_25[13];     /* Rx CO */
4623                                 info->rflow = 0;
4624                                 info->rtsdtr_inv = 0;
4625                         }
4626                         info->x_char = 0;
4627                         info->event = 0;
4628                         info->count = 0;
4629                         info->blocked_open = 0;
4630                         info->default_threshold = 0;
4631                         info->default_timeout = 0;
4632                         INIT_WORK(&info->tqueue, do_softint);
4633                         init_waitqueue_head(&info->open_wait);
4634                         init_waitqueue_head(&info->close_wait);
4635                         init_waitqueue_head(&info->shutdown_wait);
4636                         init_waitqueue_head(&info->delta_msr_wait);
4637                         /* info->session */
4638                         /* info->pgrp */
4639                         info->read_status_mask =
4640                             CyTIMEOUT | CySPECHAR | CyBREAK
4641                             | CyPARITY | CyFRAME | CyOVERRUN;
4642                         /* info->timeout */
4643                 }
4644         }
4645 }
4646
4647 /* initialize chips on Cyclom-Y card -- return number of valid
4648    chips (which is number of ports/4) */
4649 static unsigned short __init
4650 cyy_init_card(void __iomem * true_base_addr, int index)
4651 {
4652         unsigned int chip_number;
4653         void __iomem *base_addr;
4654
4655         cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
4656         /* Cy_HwReset is 0x1400 */
4657         cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
4658         /* Cy_ClrIntr is 0x1800 */
4659         udelay(500L);
4660
4661         for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD; chip_number++) {
4662                 base_addr =
4663                     true_base_addr + (cy_chip_offset[chip_number] << index);
4664                 mdelay(1);
4665                 if (readb(base_addr + (CyCCR << index)) != 0x00) {
4666                         /*************
4667                         printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
4668                         chip_number, (unsigned long)base_addr);
4669                         *************/
4670                         return chip_number;
4671                 }
4672
4673                 cy_writeb(base_addr + (CyGFRCR << index), 0);
4674                 udelay(10L);
4675
4676                 /* The Cyclom-16Y does not decode address bit 9 and therefore
4677                    cannot distinguish between references to chip 0 and a non-
4678                    existent chip 4.  If the preceding clearing of the supposed
4679                    chip 4 GFRCR register appears at chip 0, there is no chip 4
4680                    and this must be a Cyclom-16Y, not a Cyclom-32Ye.
4681                  */
4682                 if (chip_number == 4 && readb(true_base_addr +
4683                                 (cy_chip_offset[0] << index) +
4684                                 (CyGFRCR << index)) == 0) {
4685                         return chip_number;
4686                 }
4687
4688                 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
4689                 mdelay(1);
4690
4691                 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
4692                         /*
4693                            printk(" chip #%d at %#6lx is not responding ",
4694                            chip_number, (unsigned long)base_addr);
4695                            printk("(GFRCR stayed 0)\n",
4696                          */
4697                         return chip_number;
4698                 }
4699                 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
4700                                 0x40) {
4701                         /*
4702                         printk(" chip #%d at %#6lx is not valid (GFRCR == "
4703                                         "%#2x)\n",
4704                                         chip_number, (unsigned long)base_addr,
4705                                         base_addr[CyGFRCR<<index]);
4706                          */
4707                         return chip_number;
4708                 }
4709                 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
4710                 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
4711                         /* It is a CD1400 rev. J or later */
4712                         /* Impossible to reach 5ms with this chip.
4713                            Changed to 2ms instead (f = 500 Hz). */
4714                         cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
4715                 } else {
4716                         /* f = 200 Hz */
4717                         cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
4718                 }
4719
4720                 /*
4721                    printk(" chip #%d at %#6lx is rev 0x%2x\n",
4722                    chip_number, (unsigned long)base_addr,
4723                    readb(base_addr+(CyGFRCR<<index)));
4724                  */
4725         }
4726         return chip_number;
4727 }                               /* cyy_init_card */
4728
4729 /*
4730  * ---------------------------------------------------------------------
4731  * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
4732  * sets global variables and return the number of ISA boards found.
4733  * ---------------------------------------------------------------------
4734  */
4735 static int __init cy_detect_isa(void)
4736 {
4737 #ifdef CONFIG_ISA
4738         unsigned short cy_isa_irq, nboard;
4739         void __iomem *cy_isa_address;
4740         unsigned short i, j, cy_isa_nchan;
4741 #ifdef MODULE
4742         int isparam = 0;
4743 #endif
4744
4745         nboard = 0;
4746
4747 #ifdef MODULE
4748         /* Check for module parameters */
4749         for (i = 0; i < NR_CARDS; i++) {
4750                 if (maddr[i] || i) {
4751                         isparam = 1;
4752                         cy_isa_addresses[i] = maddr[i];
4753                 }
4754                 if (!maddr[i])
4755                         break;
4756         }
4757 #endif
4758
4759         /* scan the address table probing for Cyclom-Y/ISA boards */
4760         for (i = 0; i < NR_ISA_ADDRS; i++) {
4761                 unsigned int isa_address = cy_isa_addresses[i];
4762                 if (isa_address == 0x0000) {
4763                         return nboard;
4764                 }
4765
4766                 /* probe for CD1400... */
4767                 cy_isa_address = ioremap(isa_address, CyISA_Ywin);
4768                 cy_isa_nchan = CyPORTS_PER_CHIP *
4769                         cyy_init_card(cy_isa_address, 0);
4770                 if (cy_isa_nchan == 0) {
4771                         continue;
4772                 }
4773 #ifdef MODULE
4774                 if (isparam && irq[i])
4775                         cy_isa_irq = irq[i];
4776                 else
4777 #endif
4778                         /* find out the board's irq by probing */
4779                         cy_isa_irq = detect_isa_irq(cy_isa_address);
4780                 if (cy_isa_irq == 0) {
4781                         printk("Cyclom-Y/ISA found at 0x%lx ",
4782                                 (unsigned long)cy_isa_address);
4783                         printk("but the IRQ could not be detected.\n");
4784                         continue;
4785                 }
4786
4787                 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
4788                         printk("Cyclom-Y/ISA found at 0x%lx ",
4789                                 (unsigned long)cy_isa_address);
4790                         printk("but no more channels are available.\n");
4791                         printk("Change NR_PORTS in cyclades.c and recompile "
4792                                         "kernel.\n");
4793                         return nboard;
4794                 }
4795                 /* fill the next cy_card structure available */
4796                 for (j = 0; j < NR_CARDS; j++) {
4797                         if (cy_card[j].base_addr == 0)
4798                                 break;
4799                 }
4800                 if (j == NR_CARDS) {    /* no more cy_cards available */
4801                         printk("Cyclom-Y/ISA found at 0x%lx ",
4802                                 (unsigned long)cy_isa_address);
4803                         printk("but no more cards can be used .\n");
4804                         printk("Change NR_CARDS in cyclades.c and recompile "
4805                                         "kernel.\n");
4806                         return nboard;
4807                 }
4808
4809                 /* allocate IRQ */
4810                 if (request_irq(cy_isa_irq, cyy_interrupt,
4811                                 IRQF_DISABLED, "Cyclom-Y", &cy_card[j])) {
4812                         printk("Cyclom-Y/ISA found at 0x%lx ",
4813                                 (unsigned long)cy_isa_address);
4814                         printk("but could not allocate IRQ#%d.\n", cy_isa_irq);
4815                         return nboard;
4816                 }
4817
4818                 /* set cy_card */
4819                 cy_card[j].base_addr = cy_isa_address;
4820                 cy_card[j].ctl_addr = NULL;
4821                 cy_card[j].irq = (int)cy_isa_irq;
4822                 cy_card[j].bus_index = 0;
4823                 cy_card[j].first_line = cy_next_channel;
4824                 cy_card[j].num_chips = cy_isa_nchan / 4;
4825                 cy_init_card(&cy_card[j], j);
4826                 nboard++;
4827
4828                 /* print message */
4829                 printk("Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d, ",
4830                         j + 1, (unsigned long)cy_isa_address,
4831                         (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
4832                         cy_isa_irq);
4833                 printk("%d channels starting from port %d.\n",
4834                         cy_isa_nchan, cy_next_channel);
4835                 for (j = cy_next_channel;
4836                                 j < cy_next_channel + cy_isa_nchan; j++)
4837                         tty_register_device(cy_serial_driver, j, NULL);
4838                 cy_next_channel += cy_isa_nchan;
4839         }
4840         return nboard;
4841 #else
4842         return 0;
4843 #endif                          /* CONFIG_ISA */
4844 }                               /* cy_detect_isa */
4845
4846 #ifdef CONFIG_PCI
4847 static void __devinit plx_init(void __iomem * addr, __u32 initctl)
4848 {
4849         /* Reset PLX */
4850         cy_writel(addr + initctl, readl(addr + initctl) | 0x40000000);
4851         udelay(100L);
4852         cy_writel(addr + initctl, readl(addr + initctl) & ~0x40000000);
4853
4854         /* Reload Config. Registers from EEPROM */
4855         cy_writel(addr + initctl, readl(addr + initctl) | 0x20000000);
4856         udelay(100L);
4857         cy_writel(addr + initctl, readl(addr + initctl) & ~0x20000000);
4858 }
4859
4860 static int __devinit cy_init_Ze(unsigned long cy_pci_phys0,
4861                 unsigned long cy_pci_phys2,
4862                 struct RUNTIME_9060 __iomem *cy_pci_addr0,
4863                 int cy_pci_irq, struct pci_dev *pdev)
4864 {
4865         void __iomem *cy_pci_addr2;
4866         unsigned int j;
4867         unsigned short cy_pci_nchan;
4868
4869         cy_pci_addr2 = pci_iomap(pdev, 2, CyPCI_Ze_win);
4870
4871         readl(&cy_pci_addr0->mail_box_0);
4872 #ifdef CY_PCI_DEBUG
4873         printk("Cyclades-Z/PCI: relocate winaddr=0x%lx ctladdr=0x%lx\n",
4874                 (ulong)cy_pci_addr2, (ulong)cy_pci_addr0);
4875         printk("Cyclades-Z/PCI: New Cyclades-Z board.  FPGA not "
4876                         "loaded\n");
4877 #endif
4878         /* This must be the new Cyclades-Ze/PCI. */
4879         cy_pci_nchan = ZE_V1_NPORTS;
4880
4881         if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
4882                 printk("Cyclades-Ze/PCI found at 0x%lx but no channels "
4883                         "are available.\nChange NR_PORTS in cyclades.c "
4884                         "and recompile kernel.\n",
4885                         (ulong) cy_pci_phys2);
4886                 return -EIO;
4887         }
4888
4889         /* fill the next cy_card structure available */
4890         for (j = 0; j < NR_CARDS; j++) {
4891                 if (cy_card[j].base_addr == 0)
4892                         break;
4893         }
4894         if (j == NR_CARDS) {    /* no more cy_cards available */
4895                 printk("Cyclades-Ze/PCI found at 0x%lx but no more "
4896                         "cards can be used.\nChange NR_CARDS in "
4897                         "cyclades.c and recompile kernel.\n",
4898                         (ulong) cy_pci_phys2);
4899                 return -EIO;
4900         }
4901 #ifdef CONFIG_CYZ_INTR
4902         /* allocate IRQ only if board has an IRQ */
4903         if ((cy_pci_irq != 0) && (cy_pci_irq != 255)) {
4904                 if (request_irq(cy_pci_irq, cyz_interrupt,
4905                                 IRQF_SHARED, "Cyclades-Z",
4906                                 &cy_card[j])) {
4907                         printk("Cyclom-Ze/PCI found at 0x%lx ",
4908                                 (ulong) cy_pci_phys2);
4909                         printk("but could not allocate IRQ%d.\n",
4910                                 cy_pci_irq);
4911                         return -EIO;
4912                 }
4913         }
4914 #endif                          /* CONFIG_CYZ_INTR */
4915
4916         /* set cy_card */
4917         cy_card[j].base_addr = cy_pci_addr2;
4918         cy_card[j].ctl_addr = cy_pci_addr0;
4919         cy_card[j].irq = cy_pci_irq;
4920         cy_card[j].bus_index = 1;
4921         cy_card[j].first_line = cy_next_channel;
4922         cy_card[j].num_chips = -1;
4923         cy_init_card(&cy_card[j], j);
4924         pci_set_drvdata(pdev, &cy_card[j]);
4925
4926         /* print message */
4927 #ifdef CONFIG_CYZ_INTR
4928         /* don't report IRQ if board is no IRQ */
4929         if ((cy_pci_irq != 0) && (cy_pci_irq != 255))
4930                 printk("Cyclades-Ze/PCI #%d: 0x%lx-0x%lx, IRQ%d, ",
4931                         j + 1, (ulong) cy_pci_phys2,
4932                         (ulong) (cy_pci_phys2 + CyPCI_Ze_win - 1), cy_pci_irq);
4933         else
4934 #endif                          /* CONFIG_CYZ_INTR */
4935                 printk("Cyclades-Ze/PCI #%d: 0x%lx-0x%lx, ",
4936                         j + 1, (ulong) cy_pci_phys2,
4937                         (ulong) (cy_pci_phys2 + CyPCI_Ze_win - 1));
4938
4939         printk("%d channels starting from port %d.\n",
4940                 cy_pci_nchan, cy_next_channel);
4941         for (j = cy_next_channel; j < cy_next_channel + cy_pci_nchan; j++)
4942                 tty_register_device(cy_serial_driver, j, &pdev->dev);
4943         cy_next_channel += cy_pci_nchan;
4944
4945         return 0;
4946 }
4947
4948 static int __devinit cy_pci_probe(struct pci_dev *pdev,
4949                 const struct pci_device_id *ent)
4950 {
4951         unsigned char cyy_rev_id;
4952         int cy_pci_irq;
4953         __u32 cy_pci_phys0, cy_pci_phys2, mailbox;
4954         void __iomem *cy_pci_addr0, *cy_pci_addr2;
4955         unsigned int device_id;
4956         unsigned short j, cy_pci_nchan, plx_ver;
4957         int retval;
4958
4959         retval = pci_enable_device(pdev);
4960         if (retval) {
4961                 dev_err(&pdev->dev, "cannot enable device\n");
4962                 return retval;
4963         }
4964
4965         /* read PCI configuration area */
4966         cy_pci_irq = pdev->irq;
4967         cy_pci_phys0 = pci_resource_start(pdev, 0);
4968         cy_pci_phys2 = pci_resource_start(pdev, 2);
4969         pci_read_config_byte(pdev, PCI_REVISION_ID, &cyy_rev_id);
4970
4971         device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
4972
4973         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
4974                         device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
4975 #ifdef CY_PCI_DEBUG
4976                 printk("Cyclom-Y/PCI (bus=0x0%x, pci_id=0x%x, ",
4977                         pdev->bus->number, pdev->devfn);
4978                 printk("rev_id=%d) IRQ%d\n", cyy_rev_id, cy_pci_irq);
4979                 printk("Cyclom-Y/PCI:found  winaddr=0x%lx "
4980                         "ctladdr=0x%lx\n",
4981                         (ulong)cy_pci_phys2, (ulong)cy_pci_phys0);
4982 #endif
4983
4984                 if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
4985                         printk("  Warning: PCI I/O bit incorrectly "
4986                                 "set. Ignoring it...\n");
4987                         pdev->resource[2].flags &= ~IORESOURCE_IO;
4988                 }
4989
4990                 /* Although we don't use this I/O region, we should
4991                    request it from the kernel anyway, to avoid problems
4992                    with other drivers accessing it. */
4993                 retval = pci_request_regions(pdev, "Cyclom-Y");
4994                 if (retval) {
4995                         printk(KERN_ERR "cyclades: failed to reserve "
4996                                         "PCI resources\n");
4997                         return retval;
4998                 }
4999 #if defined(__alpha__)
5000                 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) {   /* below 1M? */
5001                         printk("Cyclom-Y/PCI (bus=0x0%x, pci_id=0x%x, ",
5002                                 pdev->bus->number, pdev->devfn);
5003                         printk("rev_id=%d) IRQ%d\n",
5004                                 cyy_rev_id, cy_pci_irq);
5005                         printk("Cyclom-Y/PCI:found  winaddr=0x%lx "
5006                                 "ctladdr=0x%lx\n",
5007                                 (ulong)cy_pci_phys2,
5008                                 (ulong)cy_pci_phys0);
5009                         printk("Cyclom-Y/PCI not supported for low "
5010                                 "addresses in Alpha systems.\n");
5011                         return -EIO;
5012                 }
5013 #endif
5014                 cy_pci_addr0 = pci_iomap(pdev, 0, CyPCI_Yctl);
5015                 cy_pci_addr2 = pci_iomap(pdev, 2, CyPCI_Ywin);
5016
5017 #ifdef CY_PCI_DEBUG
5018                 printk("Cyclom-Y/PCI: relocate winaddr=0x%lx "
5019                         "ctladdr=0x%lx\n",
5020                         (u_long)cy_pci_addr2, (u_long)cy_pci_addr0);
5021 #endif
5022                 cy_pci_nchan = (unsigned short)(CyPORTS_PER_CHIP *
5023                                 cyy_init_card(cy_pci_addr2, 1));
5024                 if (cy_pci_nchan == 0) {
5025                         printk("Cyclom-Y PCI host card with ");
5026                         printk("no Serial-Modules at 0x%lx.\n",
5027                                 (ulong) cy_pci_phys2);
5028                         return -EIO;
5029                 }
5030                 if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
5031                         printk("Cyclom-Y/PCI found at 0x%lx ",
5032                                 (ulong) cy_pci_phys2);
5033                         printk("but no channels are available.\n");
5034                         printk("Change NR_PORTS in cyclades.c and "
5035                                         "recompile kernel.\n");
5036                         return -EIO;
5037                 }
5038                 /* fill the next cy_card structure available */
5039                 for (j = 0; j < NR_CARDS; j++) {
5040                         if (cy_card[j].base_addr == 0)
5041                                 break;
5042                 }
5043                 if (j == NR_CARDS) {    /* no more cy_cards available */
5044                         printk("Cyclom-Y/PCI found at 0x%lx ",
5045                                 (ulong) cy_pci_phys2);
5046                         printk("but no more cards can be used.\n");
5047                         printk("Change NR_CARDS in cyclades.c and "
5048                                         "recompile kernel.\n");
5049                         return -EIO;
5050                 }
5051
5052                 /* allocate IRQ */
5053                 retval = request_irq(cy_pci_irq, cyy_interrupt,
5054                                 IRQF_SHARED, "Cyclom-Y", &cy_card[j]);
5055                 if (retval) {
5056                         printk("Cyclom-Y/PCI found at 0x%lx ",
5057                                 (ulong) cy_pci_phys2);
5058                         printk("but could not allocate IRQ%d.\n",
5059                                 cy_pci_irq);
5060                         return retval;
5061                 }
5062
5063                 /* set cy_card */
5064                 cy_card[j].base_addr = cy_pci_addr2;
5065                 cy_card[j].ctl_addr = cy_pci_addr0;
5066                 cy_card[j].irq = cy_pci_irq;
5067                 cy_card[j].bus_index = 1;
5068                 cy_card[j].first_line = cy_next_channel;
5069                 cy_card[j].num_chips = cy_pci_nchan / 4;
5070                 cy_init_card(&cy_card[j], j);
5071                 pci_set_drvdata(pdev, &cy_card[j]);
5072
5073                 /* enable interrupts in the PCI interface */
5074                 plx_ver = readb(cy_pci_addr2 + CyPLX_VER) & 0x0f;
5075                 switch (plx_ver) {
5076                 case PLX_9050:
5077
5078                         cy_writeb(cy_pci_addr0 + 0x4c, 0x43);
5079                         break;
5080
5081                 case PLX_9060:
5082                 case PLX_9080:
5083                 default:        /* Old boards, use PLX_9060 */
5084
5085                         plx_init(cy_pci_addr0, 0x6c);
5086                 /* For some yet unknown reason, once the PLX9060 reloads
5087                    the EEPROM, the IRQ is lost and, thus, we have to
5088                    re-write it to the PCI config. registers.
5089                    This will remain here until we find a permanent
5090                    fix. */
5091                         pci_write_config_byte(pdev, PCI_INTERRUPT_LINE,
5092                                         cy_pci_irq);
5093
5094                         cy_writew(cy_pci_addr0 + 0x68,
5095                                 readw(cy_pci_addr0 + 0x68) | 0x0900);
5096                         break;
5097                 }
5098
5099                 /* print message */
5100                 printk("Cyclom-Y/PCI #%d: 0x%lx-0x%lx, IRQ%d, ",
5101                         j + 1, (ulong)cy_pci_phys2,
5102                         (ulong) (cy_pci_phys2 + CyPCI_Ywin - 1), cy_pci_irq);
5103                 printk("%d channels starting from port %d.\n",
5104                         cy_pci_nchan, cy_next_channel);
5105                 for (j = cy_next_channel;
5106                                 j < cy_next_channel + cy_pci_nchan; j++)
5107                         tty_register_device(cy_serial_driver, j, &pdev->dev);
5108
5109                 cy_next_channel += cy_pci_nchan;
5110         } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
5111                 /* print message */
5112                 printk("Cyclades-Z/PCI (bus=0x0%x, pci_id=0x%x, ",
5113                         pdev->bus->number, pdev->devfn);
5114                 printk("rev_id=%d) IRQ%d\n", cyy_rev_id, cy_pci_irq);
5115                 printk("Cyclades-Z/PCI: found winaddr=0x%lx "
5116                         "ctladdr=0x%lx\n",
5117                         (ulong)cy_pci_phys2, (ulong)cy_pci_phys0);
5118                 printk("Cyclades-Z/PCI not supported for low "
5119                         "addresses\n");
5120                 return -EIO;
5121         } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
5122 #ifdef CY_PCI_DEBUG
5123                 printk("Cyclades-Z/PCI (bus=0x0%x, pci_id=0x%x, ",
5124                         pdev->bus->number, pdev->devfn);
5125                 printk("rev_id=%d) IRQ%d\n", cyy_rev_id, cy_pci_irq);
5126                 printk("Cyclades-Z/PCI: found winaddr=0x%lx "
5127                         "ctladdr=0x%lx\n",
5128                         (ulong) cy_pci_phys2, (ulong) cy_pci_phys0);
5129 #endif
5130                 cy_pci_addr0 = pci_iomap(pdev, 0, CyPCI_Zctl);
5131
5132                 /* Disable interrupts on the PLX before resetting it */
5133                 cy_writew(cy_pci_addr0 + 0x68,
5134                         readw(cy_pci_addr0 + 0x68) & ~0x0900);
5135
5136                 plx_init(cy_pci_addr0, 0x6c);
5137                 /* For some yet unknown reason, once the PLX9060 reloads
5138                    the EEPROM, the IRQ is lost and, thus, we have to
5139                    re-write it to the PCI config. registers.
5140                    This will remain here until we find a permanent
5141                    fix. */
5142                 pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, cy_pci_irq);
5143
5144                 mailbox = (__u32)readl(&((struct RUNTIME_9060 __iomem *)
5145                                 cy_pci_addr0)->mail_box_0);
5146
5147                 if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
5148                         printk("  Warning: PCI I/O bit incorrectly "
5149                                 "set. Ignoring it...\n");
5150                         pdev->resource[2].flags &= ~IORESOURCE_IO;
5151                 }
5152
5153                 /* Although we don't use this I/O region, we should
5154                    request it from the kernel anyway, to avoid problems
5155                    with other drivers accessing it. */
5156                 retval = pci_request_regions(pdev, "Cyclades-Z");
5157                 if (retval) {
5158                         printk(KERN_ERR "cyclades: failed to reserve "
5159                                 "PCI resources\n");
5160                         return retval;
5161                 }
5162
5163                 if (mailbox == ZE_V1) {
5164                         retval = cy_init_Ze(cy_pci_phys0, cy_pci_phys2,
5165                                         cy_pci_addr0, cy_pci_irq, pdev);
5166                         return retval;
5167                 } else {
5168                         cy_pci_addr2 = pci_iomap(pdev, 2, CyPCI_Zwin);
5169                 }
5170
5171 #ifdef CY_PCI_DEBUG
5172                 printk("Cyclades-Z/PCI: relocate winaddr=0x%lx "
5173                         "ctladdr=0x%lx\n",
5174                         (ulong) cy_pci_addr2, (ulong) cy_pci_addr0);
5175                 if (mailbox == ZO_V1) {
5176                         cy_writel(&((struct RUNTIME_9060 *)
5177                                 (cy_pci_addr0))->loc_addr_base,
5178                                 WIN_CREG);
5179                         printk("Cyclades-8Zo/PCI: FPGA id %lx, ver "
5180                                 "%lx\n", (ulong) (0xff &
5181                                 readl(&((struct CUSTOM_REG *)
5182                                         (cy_pci_addr2))->fpga_id)),
5183                                 (ulong)(0xff &
5184                                 readl(&((struct CUSTOM_REG *)
5185                                         (cy_pci_addr2))->
5186                                                 fpga_version)));
5187                         cy_writel(&((struct RUNTIME_9060 *)
5188                                 (cy_pci_addr0))->loc_addr_base,
5189                                 WIN_RAM);
5190                 } else {
5191                         printk("Cyclades-Z/PCI: New Cyclades-Z board.  "
5192                                         "FPGA not loaded\n");
5193                 }
5194 #endif
5195                 /* The following clears the firmware id word.  This
5196                    ensures that the driver will not attempt to talk to
5197                    the board until it has been properly initialized.
5198                  */
5199                 if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
5200                         cy_writel(cy_pci_addr2 + ID_ADDRESS, 0L);
5201
5202                 /* This must be a Cyclades-8Zo/PCI.  The extendable
5203                    version will have a different device_id and will
5204                    be allocated its maximum number of ports. */
5205                 cy_pci_nchan = 8;
5206
5207                 if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
5208                         printk("Cyclades-8Zo/PCI found at 0x%lx but"
5209                                 "no channels are available.\nChange "
5210                                 "NR_PORTS in cyclades.c and recompile "
5211                                 "kernel.\n", (ulong)cy_pci_phys2);
5212                         return -EIO;
5213                 }
5214
5215                 /* fill the next cy_card structure available */
5216                 for (j = 0; j < NR_CARDS; j++) {
5217                         if (cy_card[j].base_addr == 0)
5218                                 break;
5219                 }
5220                 if (j == NR_CARDS) {    /* no more cy_cards available */
5221                         printk("Cyclades-8Zo/PCI found at 0x%lx but"
5222                                 "no more cards can be used.\nChange "
5223                                 "NR_CARDS in cyclades.c and recompile "
5224                                 "kernel.\n", (ulong)cy_pci_phys2);
5225                         return -EIO;
5226                 }
5227 #ifdef CONFIG_CYZ_INTR
5228                 /* allocate IRQ only if board has an IRQ */
5229                 if ((cy_pci_irq != 0) && (cy_pci_irq != 255)) {
5230                         retval = request_irq(cy_pci_irq, cyz_interrupt,
5231                                         IRQF_SHARED, "Cyclades-Z",
5232                                         &cy_card[j]);
5233                         if (retval) {
5234                                 printk("Cyclom-8Zo/PCI found at 0x%lx "
5235                                         "but could not allocate "
5236                                         "IRQ%d.\n", (ulong)cy_pci_phys2,
5237                                         cy_pci_irq);
5238                                 return retval;
5239                         }
5240                 }
5241 #endif                          /* CONFIG_CYZ_INTR */
5242
5243                 /* set cy_card */
5244                 cy_card[j].base_addr = cy_pci_addr2;
5245                 cy_card[j].ctl_addr = cy_pci_addr0;
5246                 cy_card[j].irq = cy_pci_irq;
5247                 cy_card[j].bus_index = 1;
5248                 cy_card[j].first_line = cy_next_channel;
5249                 cy_card[j].num_chips = -1;
5250                 cy_init_card(&cy_card[j], j);
5251                 pci_set_drvdata(pdev, &cy_card[j]);
5252
5253                 /* print message */
5254 #ifdef CONFIG_CYZ_INTR
5255                 /* don't report IRQ if board is no IRQ */
5256                 if ((cy_pci_irq != 0) && (cy_pci_irq != 255))
5257                         printk("Cyclades-8Zo/PCI #%d: 0x%lx-0x%lx, "
5258                                 "IRQ%d, ", j + 1, (ulong)cy_pci_phys2,
5259                                 (ulong) (cy_pci_phys2 + CyPCI_Zwin - 1),
5260                                 cy_pci_irq);
5261                 else
5262 #endif                          /* CONFIG_CYZ_INTR */
5263                         printk("Cyclades-8Zo/PCI #%d: 0x%lx-0x%lx, ",
5264                                 j + 1, (ulong)cy_pci_phys2,
5265                                 (ulong)(cy_pci_phys2 + CyPCI_Zwin - 1));
5266
5267                 printk("%d channels starting from port %d.\n",
5268                                 cy_pci_nchan, cy_next_channel);
5269                 for (j = cy_next_channel;
5270                                 j < cy_next_channel + cy_pci_nchan; j++)
5271                         tty_register_device(cy_serial_driver, j, &pdev->dev);
5272                 cy_next_channel += cy_pci_nchan;
5273         }
5274
5275         return 0;
5276 }
5277
5278 static void __devexit cy_pci_remove(struct pci_dev *pdev)
5279 {
5280         struct cyclades_card *cinfo = pci_get_drvdata(pdev);
5281         unsigned int i;
5282
5283         /* non-Z with old PLX */
5284         if (!IS_CYC_Z(*cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
5285                         PLX_9050)
5286                 cy_writeb(cinfo->ctl_addr + 0x4c, 0);
5287         else
5288 #ifndef CONFIG_CYZ_INTR
5289                 if (!IS_CYC_Z(*cinfo))
5290 #endif
5291                 cy_writew(cinfo->ctl_addr + 0x68,
5292                                 readw(cinfo->ctl_addr + 0x68) & ~0x0900);
5293
5294         pci_iounmap(pdev, cinfo->base_addr);
5295         if (cinfo->ctl_addr)
5296                 pci_iounmap(pdev, cinfo->ctl_addr);
5297         if (cinfo->irq
5298 #ifndef CONFIG_CYZ_INTR
5299                 && !IS_CYC_Z(*cinfo)
5300 #endif /* CONFIG_CYZ_INTR */
5301                 )
5302                 free_irq(cinfo->irq, cinfo);
5303         pci_release_regions(pdev);
5304
5305         cinfo->base_addr = NULL;
5306         for (i = cinfo->first_line; i < cinfo->first_line + cinfo->nports; i++){
5307                 cy_port[i].line = -1;
5308                 cy_port[i].magic = -1;
5309         }
5310         for (i = cinfo->first_line; i < cinfo->first_line +
5311                         cinfo->nports; i++)
5312                 tty_unregister_device(cy_serial_driver, i);
5313 }
5314
5315 static struct pci_driver cy_pci_driver = {
5316         .name = "cyclades",
5317         .id_table = cy_pci_dev_id,
5318         .probe = cy_pci_probe,
5319         .remove = __devexit_p(cy_pci_remove)
5320 };
5321 #endif
5322
5323 /*
5324  * This routine prints out the appropriate serial driver version number
5325  * and identifies which options were configured into this driver.
5326  */
5327 static inline void show_version(void)
5328 {
5329         printk("Cyclades driver " CY_VERSION "\n");
5330         printk("        built %s %s\n", __DATE__, __TIME__);
5331 }                               /* show_version */
5332
5333 static int
5334 cyclades_get_proc_info(char *buf, char **start, off_t offset, int length,
5335                 int *eof, void *data)
5336 {
5337         struct cyclades_port *info;
5338         int i;
5339         int len = 0;
5340         off_t begin = 0;
5341         off_t pos = 0;
5342         int size;
5343         __u32 cur_jifs = jiffies;
5344
5345         size = sprintf(buf, "Dev TimeOpen   BytesOut  IdleOut    BytesIn   "
5346                         "IdleIn  Overruns  Ldisc\n");
5347
5348         pos += size;
5349         len += size;
5350
5351         /* Output one line for each known port */
5352         for (i = 0; i < NR_PORTS && cy_port[i].line >= 0; i++) {
5353                 info = &cy_port[i];
5354
5355                 if (info->count)
5356                         size = sprintf(buf + len, "%3d %8lu %10lu %8lu %10lu "
5357                                 "%8lu %9lu %6ld\n", info->line,
5358                                 (cur_jifs - info->idle_stats.in_use) / HZ,
5359                                 info->idle_stats.xmit_bytes,
5360                                 (cur_jifs - info->idle_stats.xmit_idle) / HZ,
5361                                 info->idle_stats.recv_bytes,
5362                                 (cur_jifs - info->idle_stats.recv_idle) / HZ,
5363                                 info->idle_stats.overruns,
5364                                 (long)info->tty->ldisc.num);
5365                 else
5366                         size = sprintf(buf + len, "%3d %8lu %10lu %8lu %10lu "
5367                                 "%8lu %9lu %6ld\n",
5368                                 info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
5369                 len += size;
5370                 pos = begin + len;
5371
5372                 if (pos < offset) {
5373                         len = 0;
5374                         begin = pos;
5375                 }
5376                 if (pos > offset + length)
5377                         goto done;
5378         }
5379         *eof = 1;
5380 done:
5381         *start = buf + (offset - begin);        /* Start of wanted data */
5382         len -= (offset - begin);        /* Start slop */
5383         if (len > length)
5384                 len = length;   /* Ending slop */
5385         if (len < 0)
5386                 len = 0;
5387         return len;
5388 }
5389
5390 /* The serial driver boot-time initialization code!
5391     Hardware I/O ports are mapped to character special devices on a
5392     first found, first allocated manner.  That is, this code searches
5393     for Cyclom cards in the system.  As each is found, it is probed
5394     to discover how many chips (and thus how many ports) are present.
5395     These ports are mapped to the tty ports 32 and upward in monotonic
5396     fashion.  If an 8-port card is replaced with a 16-port card, the
5397     port mapping on a following card will shift.
5398
5399     This approach is different from what is used in the other serial
5400     device driver because the Cyclom is more properly a multiplexer,
5401     not just an aggregation of serial ports on one card.
5402
5403     If there are more cards with more ports than have been
5404     statically allocated above, a warning is printed and the
5405     extra ports are ignored.
5406  */
5407
5408 static const struct tty_operations cy_ops = {
5409         .open = cy_open,
5410         .close = cy_close,
5411         .write = cy_write,
5412         .put_char = cy_put_char,
5413         .flush_chars = cy_flush_chars,
5414         .write_room = cy_write_room,
5415         .chars_in_buffer = cy_chars_in_buffer,
5416         .flush_buffer = cy_flush_buffer,
5417         .ioctl = cy_ioctl,
5418         .throttle = cy_throttle,
5419         .unthrottle = cy_unthrottle,
5420         .set_termios = cy_set_termios,
5421         .stop = cy_stop,
5422         .start = cy_start,
5423         .hangup = cy_hangup,
5424         .break_ctl = cy_break,
5425         .wait_until_sent = cy_wait_until_sent,
5426         .read_proc = cyclades_get_proc_info,
5427         .tiocmget = cy_tiocmget,
5428         .tiocmset = cy_tiocmset,
5429 };
5430
5431 static int __init cy_init(void)
5432 {
5433         unsigned int i, nboards;
5434         int retval = -ENOMEM;
5435
5436         cy_serial_driver = alloc_tty_driver(NR_PORTS);
5437         if (!cy_serial_driver)
5438                 goto err;
5439         show_version();
5440
5441         /* Initialize the tty_driver structure */
5442
5443         cy_serial_driver->owner = THIS_MODULE;
5444         cy_serial_driver->driver_name = "cyclades";
5445         cy_serial_driver->name = "ttyC";
5446         cy_serial_driver->major = CYCLADES_MAJOR;
5447         cy_serial_driver->minor_start = 0;
5448         cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
5449         cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
5450         cy_serial_driver->init_termios = tty_std_termios;
5451         cy_serial_driver->init_termios.c_cflag =
5452             B9600 | CS8 | CREAD | HUPCL | CLOCAL;
5453         cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
5454         tty_set_operations(cy_serial_driver, &cy_ops);
5455
5456         retval = tty_register_driver(cy_serial_driver);
5457         if (retval) {
5458                 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
5459                 goto err_frtty;
5460         }
5461
5462         for (i = 0; i < NR_CARDS; i++) {
5463                 /* base_addr=0 indicates board not found */
5464                 cy_card[i].base_addr = NULL;
5465         }
5466
5467         /* invalidate remaining cy_port structures */
5468         for (i = 0; i < NR_PORTS; i++) {
5469                 cy_port[i].line = -1;
5470                 cy_port[i].magic = -1;
5471         }
5472
5473         /* the code below is responsible to find the boards. Each different
5474            type of board has its own detection routine. If a board is found,
5475            the next cy_card structure available is set by the detection
5476            routine. These functions are responsible for checking the
5477            availability of cy_card and cy_port data structures and updating
5478            the cy_next_channel. */
5479
5480         /* look for isa boards */
5481         nboards = cy_detect_isa();
5482
5483 #ifdef CONFIG_PCI
5484         /* look for pci boards */
5485         retval = pci_register_driver(&cy_pci_driver);
5486         if (retval && !nboards)
5487                 goto err_unr;
5488 #endif
5489
5490         return 0;
5491 err_unr:
5492         tty_unregister_driver(cy_serial_driver);
5493 err_frtty:
5494         put_tty_driver(cy_serial_driver);
5495 err:
5496         return retval;
5497 }                               /* cy_init */
5498
5499 static void __exit cy_cleanup_module(void)
5500 {
5501         int i, e1;
5502
5503 #ifndef CONFIG_CYZ_INTR
5504         del_timer_sync(&cyz_timerlist);
5505 #endif /* CONFIG_CYZ_INTR */
5506
5507         if ((e1 = tty_unregister_driver(cy_serial_driver)))
5508                 printk("cyc: failed to unregister Cyclades serial driver(%d)\n",
5509                         e1);
5510
5511         put_tty_driver(cy_serial_driver);
5512
5513 #ifdef CONFIG_PCI
5514         pci_unregister_driver(&cy_pci_driver);
5515 #endif
5516
5517         for (i = 0; i < NR_CARDS; i++) {
5518                 if (cy_card[i].base_addr) {
5519                         /* clear interrupt */
5520                         cy_writeb(cy_card[i].base_addr + Cy_ClrIntr, 0);
5521                         iounmap(cy_card[i].base_addr);
5522                         if (cy_card[i].ctl_addr)
5523                                 iounmap(cy_card[i].ctl_addr);
5524                         if (cy_card[i].irq
5525 #ifndef CONFIG_CYZ_INTR
5526                                 && !IS_CYC_Z(cy_card[i])
5527 #endif /* CONFIG_CYZ_INTR */
5528                                 )
5529                                 free_irq(cy_card[i].irq, &cy_card[i]);
5530                         for (e1 = cy_card[i].first_line;
5531                                         e1 < cy_card[i].first_line +
5532                                         cy_card[i].nports; e1++)
5533                                 tty_unregister_device(cy_serial_driver, e1);
5534                 }
5535         }
5536 } /* cy_cleanup_module */
5537
5538 module_init(cy_init);
5539 module_exit(cy_cleanup_module);
5540
5541 MODULE_LICENSE("GPL");