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