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