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