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