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