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