err.no Git - linux-2.6/blob - drivers/char/cyclades.c

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