drivers/char/cyclades.c

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