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