git.oblomov.eu Git - linux-2.6/blob - drivers/char/cyclades.c

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