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