[PATCH] Char: tty_wakeup cleanup
[linux-2.6.git] / drivers / char / cyclades.c
1 #undef  BLOCKMOVE
2 #define Z_WAKE
3 #undef  Z_EXT_CHARS_IN_BUFFER
4
5 /*
6  *  linux/drivers/char/cyclades.c
7  *
8  * This file contains the driver for the Cyclades async multiport
9  * serial boards.
10  *
11  * Initially written by Randolph Bentson <bentson@grieg.seaslug.org>.
12  * Modified and maintained by Marcio Saito <marcio@cyclades.com>.
13  * Currently maintained by Cyclades team <async@cyclades.com>.
14  *
15  * For Technical support and installation problems, please send e-mail
16  * to support@cyclades.com.
17  *
18  * Much of the design and some of the code came from serial.c
19  * which was copyright (C) 1991, 1992  Linus Torvalds.  It was
20  * extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92,
21  * and then fixed as suggested by Michael K. Johnson 12/12/92.
22  *
23  * This version supports shared IRQ's (only for PCI boards).
24  *
25  * $Log: cyclades.c,v $
26  * Prevent users from opening non-existing Z ports.
27  *
28  * Revision 2.3.2.8   2000/07/06 18:14:16 ivan
29  * Fixed the PCI detection function to work properly on Alpha systems.
30  * Implemented support for TIOCSERGETLSR ioctl.
31  * Implemented full support for non-standard baud rates.
32  *
33  * Revision 2.3.2.7   2000/06/01 18:26:34 ivan
34  * Request PLX I/O region, although driver doesn't use it, to avoid
35  * problems with other drivers accessing it.
36  * Removed count for on-board buffer characters in cy_chars_in_buffer
37  * (Cyclades-Z only).
38  *
39  * Revision 2.3.2.6   2000/05/05 13:56:05 ivan
40  * Driver now reports physical instead of virtual memory addresses.
41  * Masks were added to some Cyclades-Z read accesses.
42  * Implemented workaround for PLX9050 bug that would cause a system lockup
43  * in certain systems, depending on the MMIO addresses allocated to the
44  * board.
45  * Changed the Tx interrupt programming in the CD1400 chips to boost up
46  * performance (Cyclom-Y only).
47  * Code is now compliant with the new module interface (module_[init|exit]).
48  * Make use of the PCI helper functions to access PCI resources.
49  * Did some code "housekeeping".
50  *
51  * Revision 2.3.2.5   2000/01/19 14:35:33 ivan
52  * Fixed bug in cy_set_termios on CRTSCTS flag turnoff.
53  *
54  * Revision 2.3.2.4   2000/01/17 09:19:40 ivan
55  * Fixed SMP locking in Cyclom-Y interrupt handler.
56  *
57  * Revision 2.3.2.3   1999/12/28 12:11:39 ivan
58  * Added a new cyclades_card field called nports to allow the driver to
59  * know the exact number of ports found by the Z firmware after its load;
60  * RX buffer contention prevention logic on interrupt op mode revisited
61  * (Cyclades-Z only);
62  * Revisited printk's for Z debug;
63  * Driver now makes sure that the constant SERIAL_XMIT_SIZE is defined;
64  *
65  * Revision 2.3.2.2   1999/10/01 11:27:43 ivan
66  * Fixed bug in cyz_poll that would make all ports but port 0 
67  * unable to transmit/receive data (Cyclades-Z only);
68  * Implemented logic to prevent the RX buffer from being stuck with data
69  * due to a driver / firmware race condition in interrupt op mode
70  * (Cyclades-Z only);
71  * Fixed bug in block_til_ready logic that would lead to a system crash;
72  * Revisited cy_close spinlock usage;
73  *
74  * Revision 2.3.2.1   1999/09/28 11:01:22 ivan
75  * Revisited CONFIG_PCI conditional compilation for PCI board support;
76  * Implemented TIOCGICOUNT and TIOCMIWAIT ioctl support;
77  * _Major_ cleanup on the Cyclades-Z interrupt support code / logic;
78  * Removed CTS handling from the driver -- this is now completely handled
79  * by the firmware (Cyclades-Z only);
80  * Flush RX on-board buffers on a port open (Cyclades-Z only);
81  * Fixed handling of ASYNC_SPD_* TTY flags;
82  * Module unload now unmaps all memory area allocated by ioremap;
83  *
84  * Revision 2.3.1.1   1999/07/15 16:45:53 ivan
85  * Removed CY_PROC conditional compilation;
86  * Implemented SMP-awareness for the driver;
87  * Implemented a new ISA IRQ autoprobe that uses the irq_probe_[on|off] 
88  * functions;
89  * The driver now accepts memory addresses (maddr=0xMMMMM) and IRQs
90  * (irq=NN) as parameters (only for ISA boards);
91  * Fixed bug in set_line_char that would prevent the Cyclades-Z 
92  * ports from being configured at speeds above 115.2Kbps;
93  * Fixed bug in cy_set_termios that would prevent XON/XOFF flow control
94  * switching from working properly;
95  * The driver now only prints IRQ info for the Cyclades-Z if it's 
96  * configured to work in interrupt mode;
97  *
98  * Revision 2.2.2.3   1999/06/28 11:13:29 ivan
99  * Added support for interrupt mode operation for the Z cards;
100  * Removed the driver inactivity control for the Z;
101  * Added a missing MOD_DEC_USE_COUNT in the cy_open function for when 
102  * the Z firmware is not loaded yet;
103  * Replaced the "manual" Z Tx flush buffer by a call to a FW command of 
104  * same functionality;
105  * Implemented workaround for IRQ setting loss on the PCI configuration 
106  * registers after a PCI bridge EEPROM reload (affects PLX9060 only);
107  *
108  * Revision 2.2.2.2  1999/05/14 17:18:15 ivan
109  * /proc entry location changed to /proc/tty/driver/cyclades;
110  * Added support to shared IRQ's (only for PCI boards);
111  * Added support for Cobalt Qube2 systems;
112  * IRQ [de]allocation scheme revisited;
113  * BREAK implementation changed in order to make use of the 'break_ctl'
114  * TTY facility;
115  * Fixed typo in TTY structure field 'driver_name';
116  * Included a PCI bridge reset and EEPROM reload in the board 
117  * initialization code (for both Y and Z series).
118  *
119  * Revision 2.2.2.1  1999/04/08 16:17:43 ivan
120  * Fixed a bug in cy_wait_until_sent that was preventing the port to be 
121  * closed properly after a SIGINT;
122  * Module usage counter scheme revisited;
123  * Added support to the upcoming Y PCI boards (i.e., support to additional
124  * PCI Device ID's).
125  * 
126  * Revision 2.2.1.10 1999/01/20 16:14:29 ivan
127  * Removed all unnecessary page-alignement operations in ioremap calls
128  * (ioremap is currently safe for these operations).
129  *
130  * Revision 2.2.1.9  1998/12/30 18:18:30 ivan
131  * Changed access to PLX PCI bridge registers from I/O to MMIO, in 
132  * order to make PLX9050-based boards work with certain motherboards.
133  *
134  * Revision 2.2.1.8  1998/11/13 12:46:20 ivan
135  * cy_close function now resets (correctly) the tty->closing flag;
136  * JIFFIES_DIFF macro fixed.
137  *
138  * Revision 2.2.1.7  1998/09/03 12:07:28 ivan
139  * Fixed bug in cy_close function, which was not informing HW of
140  * which port should have the reception disabled before doing so;
141  * fixed Cyclom-8YoP hardware detection bug.
142  *
143  * Revision 2.2.1.6  1998/08/20 17:15:39 ivan
144  * Fixed bug in cy_close function, which causes malfunction
145  * of one of the first 4 ports when a higher port is closed
146  * (Cyclom-Y only).
147  *
148  * Revision 2.2.1.5  1998/08/10 18:10:28 ivan
149  * Fixed Cyclom-4Yo hardware detection bug.
150  *
151  * Revision 2.2.1.4  1998/08/04 11:02:50 ivan
152  * /proc/cyclades implementation with great collaboration of 
153  * Marc Lewis <marc@blarg.net>;
154  * cyy_interrupt was changed to avoid occurrence of kernel oopses
155  * during PPP operation.
156  *
157  * Revision 2.2.1.3  1998/06/01 12:09:10 ivan
158  * General code review in order to comply with 2.1 kernel standards;
159  * data loss prevention for slow devices revisited (cy_wait_until_sent
160  * was created);
161  * removed conditional compilation for new/old PCI structure support 
162  * (now the driver only supports the new PCI structure).
163  *
164  * Revision 2.2.1.1  1998/03/19 16:43:12 ivan
165  * added conditional compilation for new/old PCI structure support;
166  * removed kernel series (2.0.x / 2.1.x) conditional compilation.
167  *
168  * Revision 2.1.1.3  1998/03/16 18:01:12 ivan
169  * cleaned up the data loss fix;
170  * fixed XON/XOFF handling once more (Cyclades-Z);
171  * general review of the driver routines;
172  * introduction of a mechanism to prevent data loss with slow 
173  * printers, by forcing a delay before closing the port.
174  *
175  * Revision 2.1.1.2  1998/02/17 16:50:00 ivan
176  * fixed detection/handling of new CD1400 in Ye boards;
177  * fixed XON/XOFF handling (Cyclades-Z);
178  * fixed data loss caused by a premature port close;
179  * introduction of a flag that holds the CD1400 version ID per port
180  * (used by the CYGETCD1400VER new ioctl).
181  *
182  * Revision 2.1.1.1  1997/12/03 17:31:19 ivan
183  * Code review for the module cleanup routine;
184  * fixed RTS and DTR status report for new CD1400's in get_modem_info;
185  * includes anonymous changes regarding signal_pending.
186  * 
187  * Revision 2.1  1997/11/01 17:42:41 ivan
188  * Changes in the driver to support Alpha systems (except 8Zo V_1);
189  * BREAK fix for the Cyclades-Z boards;
190  * driver inactivity control by FW implemented;
191  * introduction of flag that allows driver to take advantage of 
192  * a special CD1400 feature related to HW flow control;
193  * added support for the CD1400  rev. J (Cyclom-Y boards);
194  * introduction of ioctls to:
195  *  - control the rtsdtr_inv flag (Cyclom-Y);
196  *  - control the rflow flag (Cyclom-Y);
197  *  - adjust the polling interval (Cyclades-Z);
198  *
199  * Revision 1.36.4.33  1997/06/27 19:00:00  ivan
200  * Fixes related to kernel version conditional 
201  * compilation.
202  *  
203  * Revision 1.36.4.32  1997/06/14 19:30:00  ivan
204  * Compatibility issues between kernels 2.0.x and 
205  * 2.1.x (mainly related to clear_bit function).
206  *  
207  * Revision 1.36.4.31  1997/06/03 15:30:00  ivan
208  * Changes to define the memory window according to the 
209  * board type.
210  *  
211  * Revision 1.36.4.30  1997/05/16 15:30:00  daniel
212  * Changes to support new cycladesZ boards.
213  *
214  * Revision 1.36.4.29  1997/05/12 11:30:00  daniel
215  * Merge of Bentson's and Daniel's version 1.36.4.28.
216  * Corrects bug in cy_detect_pci: check if there are more
217  * ports than the number of static structs allocated.
218  * Warning message during initialization if this driver is
219  * used with the new generation of cycladesZ boards.  Those
220  * will be supported only in next release of the driver.
221  * Corrects bug in cy_detect_pci and cy_detect_isa that
222  * returned wrong number of VALID boards, when a cyclomY
223  * was found with no serial modules connected.
224  * Changes to use current (2.1.x) kernel subroutine names
225  * and created macros for compilation with 2.0.x kernel,
226  * instead of the other way around.
227  *
228  * Revision 1.36.4.28  1997/05/?? ??:00:00  bentson
229  * Change queue_task_irq_off to queue_task_irq.
230  * The inline function queue_task_irq_off (tqueue.h)
231  * was removed from latest releases of 2.1.x kernel.
232  * Use of macro __init to mark the initialization
233  * routines, so memory can be reused.
234  * Also incorporate implementation of critical region
235  * in function cleanup_module() created by anonymous
236  * linuxer.
237  *
238  * Revision 1.36.4.28  1997/04/25 16:00:00  daniel
239  * Change to support new firmware that solves DCD problem:
240  * application could fail to receive SIGHUP signal when DCD
241  * varying too fast.
242  *
243  * Revision 1.36.4.27  1997/03/26 10:30:00  daniel
244  * Changed for support linux versions 2.1.X.
245  * Backward compatible with linux versions 2.0.X.
246  * Corrected illegal use of filler field in
247  * CH_CTRL struct.
248  * Deleted some debug messages.
249  *
250  * Revision 1.36.4.26  1997/02/27 12:00:00  daniel
251  * Included check for NULL tty pointer in cyz_poll.
252  *
253  * Revision 1.36.4.25  1997/02/26 16:28:30  bentson
254  * Bill Foster at Blarg! Online services noticed that
255  * some of the switch elements of -Z modem control
256  * lacked a closing "break;"
257  *
258  * Revision 1.36.4.24  1997/02/24 11:00:00  daniel
259  * Changed low water threshold for buffer xmit_buf
260  *
261  * Revision 1.36.4.23  1996/12/02 21:50:16  bentson
262  * Marcio provided fix to modem status fetch for -Z
263  *
264  * Revision 1.36.4.22  1996/10/28 22:41:17  bentson
265  * improve mapping of -Z control page (thanks to Steve
266  * Price <stevep@fa.tdktca.com> for help on this)
267  *
268  * Revision 1.36.4.21  1996/09/10 17:00:10  bentson
269  * shift from CPU-bound to memcopy in cyz_polling operation
270  *
271  * Revision 1.36.4.20  1996/09/09 18:30:32  Bentson
272  * Added support to set and report higher speeds.
273  *
274  * Revision 1.36.4.19c  1996/08/09 10:00:00  Marcio Saito
275  * Some fixes in the HW flow control for the BETA release.
276  * Don't try to register the IRQ.
277  *
278  * Revision 1.36.4.19  1996/08/08 16:23:18  Bentson
279  * make sure "cyc" appears in all kernel messages; all soft interrupts
280  * handled by same routine; recognize out-of-band reception; comment
281  * out some diagnostic messages; leave RTS/CTS flow control to hardware;
282  * fix race condition in -Z buffer management; only -Y needs to explicitly
283  * flush chars; tidy up some startup messages;
284  *
285  * Revision 1.36.4.18  1996/07/25 18:57:31  bentson
286  * shift MOD_INC_USE_COUNT location to match
287  * serial.c; purge some diagnostic messages;
288  *
289  * Revision 1.36.4.17  1996/07/25 18:01:08  bentson
290  * enable modem status messages and fetch & process them; note
291  * time of last activity type for each port; set_line_char now
292  * supports more than line 0 and treats 0 baud correctly;
293  * get_modem_info senses rs_status;
294  *
295  * Revision 1.36.4.16  1996/07/20 08:43:15  bentson
296  * barely works--now's time to turn on
297  * more features 'til it breaks
298  *
299  * Revision 1.36.4.15  1996/07/19 22:30:06  bentson
300  * check more -Z board status; shorten boot message
301  *
302  * Revision 1.36.4.14  1996/07/19 22:20:37  bentson
303  * fix reference to ch_ctrl in startup; verify return
304  * values from cyz_issue_cmd and cyz_update_channel;
305  * more stuff to get modem control correct;
306  *
307  * Revision 1.36.4.13  1996/07/11 19:53:33  bentson
308  * more -Z stuff folded in; re-order changes to put -Z stuff
309  * after -Y stuff (to make changes clearer)
310  *
311  * Revision 1.36.4.12  1996/07/11 15:40:55  bentson
312  * Add code to poll Cyclades-Z.  Add code to get & set RS-232 control.
313  * Add code to send break.  Clear firmware ID word at startup (so
314  * that other code won't talk to inactive board).
315  *
316  * Revision 1.36.4.11  1996/07/09 05:28:29  bentson
317  * add code for -Z in set_line_char
318  *
319  * Revision 1.36.4.10  1996/07/08 19:28:37  bentson
320  * fold more -Z stuff (or in some cases, error messages)
321  * into driver; add text to "don't know what to do" messages.
322  *
323  * Revision 1.36.4.9  1996/07/08 18:38:38  bentson
324  * moved compile-time flags near top of file; cosmetic changes
325  * to narrow text (to allow 2-up printing); changed many declarations
326  * to "static" to limit external symbols; shuffled code order to
327  * coalesce -Y and -Z specific code, also to put internal functions
328  * in order of tty_driver structure; added code to recognize -Z
329  * ports (and for moment, do nothing or report error); add cy_startup
330  * to parse boot command line for extra base addresses for ISA probes;
331  *
332  * Revision 1.36.4.8  1996/06/25 17:40:19  bentson
333  * reorder some code, fix types of some vars (int vs. long),
334  * add cy_setup to support user declared ISA addresses
335  *
336  * Revision 1.36.4.7  1996/06/21 23:06:18  bentson
337  * dump ioctl based firmware load (it's now a user level
338  * program); ensure uninitialzed ports cannot be used
339  *
340  * Revision 1.36.4.6  1996/06/20 23:17:19  bentson
341  * rename vars and restructure some code
342  *
343  * Revision 1.36.4.5  1996/06/14 15:09:44  bentson
344  * get right status back after boot load
345  *
346  * Revision 1.36.4.4  1996/06/13 19:51:44  bentson
347  * successfully loads firmware
348  *
349  * Revision 1.36.4.3  1996/06/13 06:08:33  bentson
350  * add more of the code for the boot/load ioctls
351  *
352  * Revision 1.36.4.2  1996/06/11 21:00:51  bentson
353  * start to add Z functionality--starting with ioctl
354  * for loading firmware
355  *
356  * Revision 1.36.4.1  1996/06/10 18:03:02  bentson
357  * added code to recognize Z/PCI card at initialization; report
358  * presence, but card is not initialized (because firmware needs
359  * to be loaded)
360  *
361  * Revision 1.36.3.8  1996/06/07 16:29:00  bentson
362  * starting minor number at zero; added missing verify_area
363  * as noted by Heiko Eissfeldt <heiko@colossus.escape.de>
364  *
365  * Revision 1.36.3.7  1996/04/19 21:06:18  bentson
366  * remove unneeded boot message & fix CLOCAL hardware flow
367  * control (Miquel van Smoorenburg <miquels@Q.cistron.nl>);
368  * remove unused diagnostic statements; minor 0 is first;
369  *
370  * Revision 1.36.3.6  1996/03/13 13:21:17  marcio
371  * The kernel function vremap (available only in later 1.3.xx kernels)
372  * allows the access to memory addresses above the RAM. This revision
373  * of the driver supports PCI boards below 1Mb (device id 0x100) and
374  * above 1Mb (device id 0x101).
375  *
376  * Revision 1.36.3.5  1996/03/07 15:20:17  bentson
377  * Some global changes to interrupt handling spilled into
378  * this driver--mostly unused arguments in system function
379  * calls.  Also added change by Marcio Saito which should
380  * reduce lost interrupts at startup by fast processors.
381  *
382  * Revision 1.36.3.4  1995/11/13  20:45:10  bentson
383  * Changes by Corey Minyard <minyard@wf-rch.cirr.com> distributed
384  * in 1.3.41 kernel to remove a possible race condition, extend
385  * some error messages, and let the driver run as a loadable module
386  * Change by Alan Wendt <alan@ez0.ezlink.com> to remove a
387  * possible race condition.
388  * Change by Marcio Saito <marcio@cyclades.com> to fix PCI addressing.
389  *
390  * Revision 1.36.3.3  1995/11/13  19:44:48  bentson
391  * Changes by Linus Torvalds in 1.3.33 kernel distribution
392  * required due to reordering of driver initialization.
393  * Drivers are now initialized *after* memory management.
394  *
395  * Revision 1.36.3.2  1995/09/08  22:07:14  bentson
396  * remove printk from ISR; fix typo
397  *
398  * Revision 1.36.3.1  1995/09/01  12:00:42  marcio
399  * Minor fixes in the PCI board support. PCI function calls in
400  * conditional compilation (CONFIG_PCI). Thanks to Jim Duncan
401  * <duncan@okay.com>. "bad serial count" message removed.
402  *
403  * Revision 1.36.3  1995/08/22  09:19:42  marcio
404  * Cyclom-Y/PCI support added. Changes in the cy_init routine and
405  * board initialization. Changes in the boot messages. The driver
406  * supports up to 4 boards and 64 ports by default.
407  *
408  * Revision 1.36.1.4  1995/03/29  06:14:14  bentson
409  * disambiguate between Cyclom-16Y and Cyclom-32Ye;
410  *
411  * Revision 1.36.1.3  1995/03/23  22:15:35  bentson
412  * add missing break in modem control block in ioctl switch statement
413  * (discovered by Michael Edward Chastain <mec@jobe.shell.portal.com>);
414  *
415  * Revision 1.36.1.2  1995/03/22  19:16:22  bentson
416  * make sure CTS flow control is set as soon as possible (thanks
417  * to note from David Lambert <lambert@chesapeake.rps.slb.com>);
418  *
419  * Revision 1.36.1.1  1995/03/13  15:44:43  bentson
420  * initialize defaults for receive threshold and stale data timeout;
421  * cosmetic changes;
422  *
423  * Revision 1.36  1995/03/10  23:33:53  bentson
424  * added support of chips 4-7 in 32 port Cyclom-Ye;
425  * fix cy_interrupt pointer dereference problem
426  * (Joe Portman <baron@aa.net>);
427  * give better error response if open is attempted on non-existent port
428  * (Zachariah Vaum <jchryslr@netcom.com>);
429  * correct command timeout (Kenneth Lerman <lerman@@seltd.newnet.com>);
430  * conditional compilation for -16Y on systems with fast, noisy bus;
431  * comment out diagnostic print function;
432  * cleaned up table of base addresses;
433  * set receiver time-out period register to correct value,
434  * set receive threshold to better default values,
435  * set chip timer to more accurate 200 Hz ticking,
436  * add code to monitor and modify receive parameters
437  * (Rik Faith <faith@cs.unc.edu> Nick Simicich
438  * <njs@scifi.emi.net>);
439  *
440  * Revision 1.35  1994/12/16  13:54:18  steffen
441  * additional patch by Marcio Saito for board detection
442  * Accidently left out in 1.34
443  *
444  * Revision 1.34  1994/12/10  12:37:12  steffen
445  * This is the corrected version as suggested by Marcio Saito
446  *
447  * Revision 1.33  1994/12/01  22:41:18  bentson
448  * add hooks to support more high speeds directly; add tytso
449  * patch regarding CLOCAL wakeups
450  *
451  * Revision 1.32  1994/11/23  19:50:04  bentson
452  * allow direct kernel control of higher signalling rates;
453  * look for cards at additional locations
454  *
455  * Revision 1.31  1994/11/16  04:33:28  bentson
456  * ANOTHER fix from Corey Minyard, minyard@wf-rch.cirr.com--
457  * a problem in chars_in_buffer has been resolved by some
458  * small changes;  this should yield smoother output
459  *
460  * Revision 1.30  1994/11/16  04:28:05  bentson
461  * Fix from Corey Minyard, Internet: minyard@metronet.com,
462  * UUCP: minyard@wf-rch.cirr.com, WORK: minyardbnr.ca, to
463  * cy_hangup that appears to clear up much (all?) of the
464  * DTR glitches; also he's added/cleaned-up diagnostic messages
465  *
466  * Revision 1.29  1994/11/16  04:16:07  bentson
467  * add change proposed by Ralph Sims, ralphs@halcyon.com, to
468  * operate higher speeds in same way as other serial ports;
469  * add more serial ports (for up to two 16-port muxes).
470  *
471  * Revision 1.28  1994/11/04  00:13:16  root
472  * turn off diagnostic messages
473  *
474  * Revision 1.27  1994/11/03  23:46:37  root
475  * bunch of changes to bring driver into greater conformance
476  * with the serial.c driver (looking for missed fixes)
477  *
478  * Revision 1.26  1994/11/03  22:40:36  root
479  * automatic interrupt probing fixed.
480  *
481  * Revision 1.25  1994/11/03  20:17:02  root
482  * start to implement auto-irq
483  *
484  * Revision 1.24  1994/11/03  18:01:55  root
485  * still working on modem signals--trying not to drop DTR
486  * during the getty/login processes
487  *
488  * Revision 1.23  1994/11/03  17:51:36  root
489  * extend baud rate support; set receive threshold as function
490  * of baud rate; fix some problems with RTS/CTS;
491  *
492  * Revision 1.22  1994/11/02  18:05:35  root
493  * changed arguments to udelay to type long to get
494  * delays to be of correct duration
495  *
496  * Revision 1.21  1994/11/02  17:37:30  root
497  * employ udelay (after calibrating loops_per_second earlier
498  * in init/main.c) instead of using home-grown delay routines
499  *
500  * Revision 1.20  1994/11/02  03:11:38  root
501  * cy_chars_in_buffer forces a return value of 0 to let
502  * login work (don't know why it does); some functions
503  * that were returning EFAULT, now executes the code;
504  * more work on deciding when to disable xmit interrupts;
505  *
506  * Revision 1.19  1994/11/01  20:10:14  root
507  * define routine to start transmission interrupts (by enabling
508  * transmit interrupts); directly enable/disable modem interrupts;
509  *
510  * Revision 1.18  1994/11/01  18:40:45  bentson
511  * Don't always enable transmit interrupts in startup; interrupt on
512  * TxMpty instead of TxRdy to help characters get out before shutdown;
513  * restructure xmit interrupt to check for chars first and quit if
514  * none are ready to go; modem status (MXVRx) is upright, _not_ inverted
515  * (to my view);
516  *
517  * Revision 1.17  1994/10/30  04:39:45  bentson
518  * rename serial_driver and callout_driver to cy_serial_driver and
519  * cy_callout_driver to avoid linkage interference; initialize
520  * info->type to PORT_CIRRUS; ruggedize paranoia test; elide ->port
521  * from cyclades_port structure; add paranoia check to cy_close;
522  *
523  * Revision 1.16  1994/10/30  01:14:33  bentson
524  * change major numbers; add some _early_ return statements;
525  *
526  * Revision 1.15  1994/10/29  06:43:15  bentson
527  * final tidying up for clean compile;  enable some error reporting
528  *
529  * Revision 1.14  1994/10/28  20:30:22  Bentson
530  * lots of changes to drag the driver towards the new tty_io
531  * structures and operation.  not expected to work, but may
532  * compile cleanly.
533  *
534  * Revision 1.13  1994/07/21  23:08:57  Bentson
535  * add some diagnostic cruft; support 24 lines (for testing
536  * both -8Y and -16Y cards; be more thorough in servicing all
537  * chips during interrupt; add "volatile" a few places to
538  * circumvent compiler optimizations; fix base & offset
539  * computations in block_til_ready (was causing chip 0 to
540  * stop operation)
541  *
542  * Revision 1.12  1994/07/19  16:42:11  Bentson
543  * add some hackery for kernel version 1.1.8; expand
544  * error messages; refine timing for delay loops and
545  * declare loop params volatile
546  *
547  * Revision 1.11  1994/06/11  21:53:10  bentson
548  * get use of save_car right in transmit interrupt service
549  *
550  * Revision 1.10.1.1  1994/06/11  21:31:18  bentson
551  * add some diagnostic printing; try to fix save_car stuff
552  *
553  * Revision 1.10  1994/06/11  20:36:08  bentson
554  * clean up compiler warnings
555  *
556  * Revision 1.9  1994/06/11  19:42:46  bentson
557  * added a bunch of code to support modem signalling
558  *
559  * Revision 1.8  1994/06/11  17:57:07  bentson
560  * recognize break & parity error
561  *
562  * Revision 1.7  1994/06/05  05:51:34  bentson
563  * Reorder baud table to be monotonic; add cli to CP; discard
564  * incoming characters and status if the line isn't open; start to
565  * fold code into cy_throttle; start to port get_serial_info,
566  * set_serial_info, get_modem_info, set_modem_info, and send_break
567  * from serial.c; expand cy_ioctl; relocate and expand config_setup;
568  * get flow control characters from tty struct; invalidate ports w/o
569  * hardware;
570  *
571  * Revision 1.6  1994/05/31  18:42:21  bentson
572  * add a loop-breaker in the interrupt service routine;
573  * note when port is initialized so that it can be shut
574  * down under the right conditions; receive works without
575  * any obvious errors
576  *
577  * Revision 1.5  1994/05/30  00:55:02  bentson
578  * transmit works without obvious errors
579  *
580  * Revision 1.4  1994/05/27  18:46:27  bentson
581  * incorporated more code from lib_y.c; can now print short
582  * strings under interrupt control to port zero; seems to
583  * select ports/channels/lines correctly
584  *
585  * Revision 1.3  1994/05/25  22:12:44  bentson
586  * shifting from multi-port on a card to proper multiplexor
587  * data structures;  added skeletons of most routines
588  *
589  * Revision 1.2  1994/05/19  13:21:43  bentson
590  * start to crib from other sources
591  *
592  */
593
594 #define CY_VERSION      "2.4"
595
596 /* If you need to install more boards than NR_CARDS, change the constant
597    in the definition below. No other change is necessary to support up to
598    eight boards. Beyond that you'll have to extend cy_isa_addresses. */
599
600 #define NR_CARDS        4
601
602 /*
603    If the total number of ports is larger than NR_PORTS, change this
604    constant in the definition below. No other change is necessary to
605    support more boards/ports. */
606
607 #define NR_PORTS        256
608
609 #define ZE_V1_NPORTS    64
610 #define ZO_V1   0
611 #define ZO_V2   1
612 #define ZE_V1   2
613
614 #define SERIAL_PARANOIA_CHECK
615 #undef  CY_DEBUG_OPEN
616 #undef  CY_DEBUG_THROTTLE
617 #undef  CY_DEBUG_OTHER
618 #undef  CY_DEBUG_IO
619 #undef  CY_DEBUG_COUNT
620 #undef  CY_DEBUG_DTR
621 #undef  CY_DEBUG_WAIT_UNTIL_SENT
622 #undef  CY_DEBUG_INTERRUPTS
623 #undef  CY_16Y_HACK
624 #undef  CY_ENABLE_MONITORING
625 #undef  CY_PCI_DEBUG
626
627 #if 0
628 #define PAUSE __asm__("nop")
629 #else
630 #define PAUSE do {} while (0)
631 #endif
632
633 /*
634  * Include section 
635  */
636 #include <linux/module.h>
637 #include <linux/errno.h>
638 #include <linux/signal.h>
639 #include <linux/sched.h>
640 #include <linux/timer.h>
641 #include <linux/interrupt.h>
642 #include <linux/tty.h>
643 #include <linux/tty_flip.h>
644 #include <linux/serial.h>
645 #include <linux/major.h>
646 #include <linux/string.h>
647 #include <linux/fcntl.h>
648 #include <linux/ptrace.h>
649 #include <linux/cyclades.h>
650 #include <linux/mm.h>
651 #include <linux/ioport.h>
652 #include <linux/init.h>
653 #include <linux/delay.h>
654 #include <linux/spinlock.h>
655 #include <linux/bitops.h>
656
657 #include <asm/system.h>
658 #include <asm/io.h>
659 #include <asm/irq.h>
660 #include <asm/uaccess.h>
661
662 #define CY_LOCK(info,flags)                                     \
663                 do {                                            \
664                 spin_lock_irqsave(&cy_card[info->card].card_lock, flags); \
665                 } while (0)
666
667 #define CY_UNLOCK(info,flags)                                   \
668                 do {                                            \
669                 spin_unlock_irqrestore(&cy_card[info->card].card_lock, flags); \
670                 } while (0)
671
672 #include <linux/types.h>
673 #include <linux/kernel.h>
674 #include <linux/pci.h>
675
676 #include <linux/stat.h>
677 #include <linux/proc_fs.h>
678
679 static void cy_throttle(struct tty_struct *tty);
680 static void cy_send_xchar(struct tty_struct *tty, char ch);
681
682 #define IS_CYC_Z(card) ((card).num_chips == -1)
683
684 #define Z_FPGA_CHECK(card) \
685         ((cy_readl(&((struct RUNTIME_9060 __iomem *) \
686                 ((card).ctl_addr))->init_ctrl) & (1<<17)) != 0)
687
688 #define ISZLOADED(card) (((ZO_V1==cy_readl(&((struct RUNTIME_9060 __iomem *) \
689                         ((card).ctl_addr))->mail_box_0)) || \
690                         Z_FPGA_CHECK(card)) && \
691                         (ZFIRM_ID==cy_readl(&((struct FIRM_ID __iomem *) \
692                         ((card).base_addr+ID_ADDRESS))->signature)))
693
694 #ifndef SERIAL_XMIT_SIZE
695 #define SERIAL_XMIT_SIZE        (min(PAGE_SIZE, 4096))
696 #endif
697 #define WAKEUP_CHARS            256
698
699 #define STD_COM_FLAGS (0)
700
701 static struct tty_driver *cy_serial_driver;
702
703 #ifdef CONFIG_ISA
704 /* This is the address lookup table. The driver will probe for
705    Cyclom-Y/ISA boards at all addresses in here. If you want the
706    driver to probe addresses at a different address, add it to
707    this table.  If the driver is probing some other board and
708    causing problems, remove the offending address from this table.
709    The cy_setup function extracts additional addresses from the
710    boot options line.  The form is "cyclades=address,address..."
711 */
712
713 static unsigned int cy_isa_addresses[] = {
714         0xD0000,
715         0xD2000,
716         0xD4000,
717         0xD6000,
718         0xD8000,
719         0xDA000,
720         0xDC000,
721         0xDE000,
722         0, 0, 0, 0, 0, 0, 0, 0
723 };
724
725 #define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
726
727 #ifdef MODULE
728 static long maddr[NR_CARDS] = { 0, };
729 static int irq[NR_CARDS] = { 0, };
730
731 module_param_array(maddr, long, NULL, 0);
732 module_param_array(irq, int, NULL, 0);
733 #endif
734
735 #endif                          /* CONFIG_ISA */
736
737 /* This is the per-card data structure containing address, irq, number of
738    channels, etc. This driver supports a maximum of NR_CARDS cards.
739 */
740 static struct cyclades_card cy_card[NR_CARDS];
741
742 /* This is the per-channel data structure containing pointers, flags
743  and variables for the port. This driver supports a maximum of NR_PORTS.
744 */
745 static struct cyclades_port cy_port[NR_PORTS];
746
747 static int cy_next_channel;     /* next minor available */
748
749 /*
750  * This is used to look up the divisor speeds and the timeouts
751  * We're normally limited to 15 distinct baud rates.  The extra
752  * are accessed via settings in info->flags.
753  *      0,     1,     2,     3,     4,     5,     6,     7,     8,     9,
754  *     10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
755  *                                               HI            VHI
756  *     20
757  */
758 static int baud_table[] = {
759         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
760         1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
761         230400, 0
762 };
763
764 static char baud_co_25[] = {    /* 25 MHz clock option table */
765         /* value =>    00    01   02    03    04 */
766         /* divide by    8    32   128   512  2048 */
767         0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
768         0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
769 };
770
771 static char baud_bpr_25[] = {   /* 25 MHz baud rate period table */
772         0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
773         0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
774 };
775
776 static char baud_co_60[] = {    /* 60 MHz clock option table (CD1400 J) */
777         /* value =>    00    01   02    03    04 */
778         /* divide by    8    32   128   512  2048 */
779         0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
780         0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
781         0x00
782 };
783
784 static char baud_bpr_60[] = {   /* 60 MHz baud rate period table (CD1400 J) */
785         0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62,
786         0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32,
787         0x21
788 };
789
790 static char baud_cor3[] = {     /* receive threshold */
791         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
792         0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07,
793         0x07
794 };
795
796 /*
797  * The Cyclades driver implements HW flow control as any serial driver.
798  * The cyclades_port structure member rflow and the vector rflow_thr 
799  * allows us to take advantage of a special feature in the CD1400 to avoid 
800  * data loss even when the system interrupt latency is too high. These flags 
801  * are to be used only with very special applications. Setting these flags 
802  * requires the use of a special cable (DTR and RTS reversed). In the new 
803  * CD1400-based boards (rev. 6.00 or later), there is no need for special 
804  * cables.
805  */
806
807 static char rflow_thr[] = {     /* rflow threshold */
808         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
809         0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
810         0x0a
811 };
812
813 /*  The Cyclom-Ye has placed the sequential chips in non-sequential
814  *  address order.  This look-up table overcomes that problem.
815  */
816 static int cy_chip_offset[] = { 0x0000,
817         0x0400,
818         0x0800,
819         0x0C00,
820         0x0200,
821         0x0600,
822         0x0A00,
823         0x0E00
824 };
825
826 /* PCI related definitions */
827
828 static unsigned short cy_pci_nboard;
829 static unsigned short cy_isa_nboard;
830 static unsigned short cy_nboard;
831 #ifdef CONFIG_PCI
832 static unsigned short cy_pci_dev_id[] = {
833         PCI_DEVICE_ID_CYCLOM_Y_Lo,      /* PCI < 1Mb */
834         PCI_DEVICE_ID_CYCLOM_Y_Hi,      /* PCI > 1Mb */
835         PCI_DEVICE_ID_CYCLOM_4Y_Lo,     /* 4Y PCI < 1Mb */
836         PCI_DEVICE_ID_CYCLOM_4Y_Hi,     /* 4Y PCI > 1Mb */
837         PCI_DEVICE_ID_CYCLOM_8Y_Lo,     /* 8Y PCI < 1Mb */
838         PCI_DEVICE_ID_CYCLOM_8Y_Hi,     /* 8Y PCI > 1Mb */
839         PCI_DEVICE_ID_CYCLOM_Z_Lo,      /* Z PCI < 1Mb */
840         PCI_DEVICE_ID_CYCLOM_Z_Hi,      /* Z PCI > 1Mb */
841         0                       /* end of table */
842 };
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 *, uclong, ucchar, uclong);
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                 uclong * channel, ucchar * cmd, uclong * 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 = (uclong) 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                 uclong channel, ucchar cmd, uclong param)
1531 {
1532         struct FIRM_ID __iomem *firm_id;
1533         struct ZFW_CTRL __iomem *zfw_ctrl;
1534         struct BOARD_CTRL __iomem *board_ctrl;
1535         unsigned long __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 uclong 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 uclong 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         uclong channel;
1758         ucchar cmd;
1759         uclong param;
1760         uclong 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         uclong 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                                 (uclong)(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 uclong 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, uclong baud)
3058 {
3059         int co, co_val, bpr;
3060         uclong 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                 uclong 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.baud_base = info->baud;
3504         tmp.custom_divisor = info->custom_divisor;
3505         tmp.hub6 = 0;           /*!!! */
3506         return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
3507 }                               /* get_serial_info */
3508
3509 static int
3510 set_serial_info(struct cyclades_port *info,
3511                 struct serial_struct __user * new_info)
3512 {
3513         struct serial_struct new_serial;
3514         struct cyclades_port old_info;
3515
3516         if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
3517                 return -EFAULT;
3518         old_info = *info;
3519
3520         if (!capable(CAP_SYS_ADMIN)) {
3521                 if (new_serial.close_delay != info->close_delay ||
3522                                 new_serial.baud_base != info->baud ||
3523                                 (new_serial.flags & ASYNC_FLAGS &
3524                                         ~ASYNC_USR_MASK) !=
3525                                 (info->flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
3526                         return -EPERM;
3527                 info->flags = (info->flags & ~ASYNC_USR_MASK) |
3528                                 (new_serial.flags & ASYNC_USR_MASK);
3529                 info->baud = new_serial.baud_base;
3530                 info->custom_divisor = new_serial.custom_divisor;
3531                 goto check_and_exit;
3532         }
3533
3534         /*
3535          * OK, past this point, all the error checking has been done.
3536          * At this point, we start making changes.....
3537          */
3538
3539         info->baud = new_serial.baud_base;
3540         info->custom_divisor = new_serial.custom_divisor;
3541         info->flags = (info->flags & ~ASYNC_FLAGS) |
3542                         (new_serial.flags & ASYNC_FLAGS);
3543         info->close_delay = new_serial.close_delay * HZ / 100;
3544         info->closing_wait = new_serial.closing_wait * HZ / 100;
3545
3546 check_and_exit:
3547         if (info->flags & ASYNC_INITIALIZED) {
3548                 set_line_char(info);
3549                 return 0;
3550         } else {
3551                 return startup(info);
3552         }
3553 }                               /* set_serial_info */
3554
3555 /*
3556  * get_lsr_info - get line status register info
3557  *
3558  * Purpose: Let user call ioctl() to get info when the UART physically
3559  *          is emptied.  On bus types like RS485, the transmitter must
3560  *          release the bus after transmitting. This must be done when
3561  *          the transmit shift register is empty, not be done when the
3562  *          transmit holding register is empty.  This functionality
3563  *          allows an RS485 driver to be written in user space.
3564  */
3565 static int get_lsr_info(struct cyclades_port *info, unsigned int __user * value)
3566 {
3567         int card, chip, channel, index;
3568         unsigned char status;
3569         unsigned int result;
3570         unsigned long flags;
3571         void __iomem *base_addr;
3572
3573         card = info->card;
3574         channel = (info->line) - (cy_card[card].first_line);
3575         if (!IS_CYC_Z(cy_card[card])) {
3576                 chip = channel >> 2;
3577                 channel &= 0x03;
3578                 index = cy_card[card].bus_index;
3579                 base_addr =
3580                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3581
3582                 CY_LOCK(info, flags);
3583                 status = cy_readb(base_addr + (CySRER << index)) &
3584                                 (CyTxRdy | CyTxMpty);
3585                 CY_UNLOCK(info, flags);
3586                 result = (status ? 0 : TIOCSER_TEMT);
3587         } else {
3588                 /* Not supported yet */
3589                 return -EINVAL;
3590         }
3591         return put_user(result, (unsigned long __user *)value);
3592 }
3593
3594 static int cy_tiocmget(struct tty_struct *tty, struct file *file)
3595 {
3596         struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
3597         int card, chip, channel, index;
3598         void __iomem *base_addr;
3599         unsigned long flags;
3600         unsigned char status;
3601         unsigned long lstatus;
3602         unsigned int result;
3603         struct FIRM_ID __iomem *firm_id;
3604         struct ZFW_CTRL __iomem *zfw_ctrl;
3605         struct BOARD_CTRL __iomem *board_ctrl;
3606         struct CH_CTRL __iomem *ch_ctrl;
3607
3608         if (serial_paranoia_check(info, tty->name, __FUNCTION__))
3609                 return -ENODEV;
3610
3611         card = info->card;
3612         channel = (info->line) - (cy_card[card].first_line);
3613         if (!IS_CYC_Z(cy_card[card])) {
3614                 chip = channel >> 2;
3615                 channel &= 0x03;
3616                 index = cy_card[card].bus_index;
3617                 base_addr =
3618                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3619
3620                 CY_LOCK(info, flags);
3621                 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
3622                 status = cy_readb(base_addr + (CyMSVR1 << index));
3623                 status |= cy_readb(base_addr + (CyMSVR2 << index));
3624                 CY_UNLOCK(info, flags);
3625
3626                 if (info->rtsdtr_inv) {
3627                         result = ((status & CyRTS) ? TIOCM_DTR : 0) |
3628                                 ((status & CyDTR) ? TIOCM_RTS : 0);
3629                 } else {
3630                         result = ((status & CyRTS) ? TIOCM_RTS : 0) |
3631                                 ((status & CyDTR) ? TIOCM_DTR : 0);
3632                 }
3633                 result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
3634                         ((status & CyRI) ? TIOCM_RNG : 0) |
3635                         ((status & CyDSR) ? TIOCM_DSR : 0) |
3636                         ((status & CyCTS) ? TIOCM_CTS : 0);
3637         } else {
3638                 base_addr = cy_card[card].base_addr;
3639
3640                 if (cy_card[card].num_chips != -1) {
3641                         return -EINVAL;
3642                 }
3643
3644                 firm_id = cy_card[card].base_addr + ID_ADDRESS;
3645                 if (ISZLOADED(cy_card[card])) {
3646                         zfw_ctrl = cy_card[card].base_addr +
3647                                 (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
3648                         board_ctrl = &zfw_ctrl->board_ctrl;
3649                         ch_ctrl = zfw_ctrl->ch_ctrl;
3650                         lstatus = cy_readl(&ch_ctrl[channel].rs_status);
3651                         result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
3652                                 ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
3653                                 ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
3654                                 ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
3655                                 ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
3656                                 ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
3657                 } else {
3658                         result = 0;
3659                         return -ENODEV;
3660                 }
3661
3662         }
3663         return result;
3664 }                               /* cy_tiomget */
3665
3666 static int
3667 cy_tiocmset(struct tty_struct *tty, struct file *file,
3668                 unsigned int set, unsigned int clear)
3669 {
3670         struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
3671         int card, chip, channel, index;
3672         void __iomem *base_addr;
3673         unsigned long flags;
3674         struct FIRM_ID __iomem *firm_id;
3675         struct ZFW_CTRL __iomem *zfw_ctrl;
3676         struct BOARD_CTRL __iomem *board_ctrl;
3677         struct CH_CTRL __iomem *ch_ctrl;
3678         int retval;
3679
3680         if (serial_paranoia_check(info, tty->name, __FUNCTION__))
3681                 return -ENODEV;
3682
3683         card = info->card;
3684         channel = (info->line) - (cy_card[card].first_line);
3685         if (!IS_CYC_Z(cy_card[card])) {
3686                 chip = channel >> 2;
3687                 channel &= 0x03;
3688                 index = cy_card[card].bus_index;
3689                 base_addr =
3690                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3691
3692                 if (set & TIOCM_RTS) {
3693                         CY_LOCK(info, flags);
3694                         cy_writeb(base_addr + (CyCAR << index),
3695                                   (u_char) channel);
3696                         if (info->rtsdtr_inv) {
3697                                 cy_writeb(base_addr + (CyMSVR2 << index),
3698                                           CyDTR);
3699                         } else {
3700                                 cy_writeb(base_addr + (CyMSVR1 << index),
3701                                           CyRTS);
3702                         }
3703                         CY_UNLOCK(info, flags);
3704                 }
3705                 if (clear & TIOCM_RTS) {
3706                         CY_LOCK(info, flags);
3707                         cy_writeb(base_addr + (CyCAR << index),
3708                                   (u_char) channel);
3709                         if (info->rtsdtr_inv) {
3710                                 cy_writeb(base_addr + (CyMSVR2 << index),
3711                                           ~CyDTR);
3712                         } else {
3713                                 cy_writeb(base_addr + (CyMSVR1 << index),
3714                                           ~CyRTS);
3715                         }
3716                         CY_UNLOCK(info, flags);
3717                 }
3718                 if (set & TIOCM_DTR) {
3719                         CY_LOCK(info, flags);
3720                         cy_writeb(base_addr + (CyCAR << index),
3721                                   (u_char) channel);
3722                         if (info->rtsdtr_inv) {
3723                                 cy_writeb(base_addr + (CyMSVR1 << index),
3724                                           CyRTS);
3725                         } else {
3726                                 cy_writeb(base_addr + (CyMSVR2 << index),
3727                                           CyDTR);
3728                         }
3729 #ifdef CY_DEBUG_DTR
3730                         printk("cyc:set_modem_info raising DTR\n");
3731                         printk("     status: 0x%x, 0x%x\n",
3732                                 cy_readb(base_addr + (CyMSVR1 << index)),
3733                                 cy_readb(base_addr + (CyMSVR2 << index)));
3734 #endif
3735                         CY_UNLOCK(info, flags);
3736                 }
3737                 if (clear & TIOCM_DTR) {
3738                         CY_LOCK(info, flags);
3739                         cy_writeb(base_addr + (CyCAR << index),
3740                                   (u_char) channel);
3741                         if (info->rtsdtr_inv) {
3742                                 cy_writeb(base_addr + (CyMSVR1 << index),
3743                                           ~CyRTS);
3744                         } else {
3745                                 cy_writeb(base_addr + (CyMSVR2 << index),
3746                                           ~CyDTR);
3747                         }
3748
3749 #ifdef CY_DEBUG_DTR
3750                         printk("cyc:set_modem_info dropping DTR\n");
3751                         printk("     status: 0x%x, 0x%x\n",
3752                                 cy_readb(base_addr + (CyMSVR1 << index)),
3753                                 cy_readb(base_addr + (CyMSVR2 << index)));
3754 #endif
3755                         CY_UNLOCK(info, flags);
3756                 }
3757         } else {
3758                 base_addr = cy_card[card].base_addr;
3759
3760                 firm_id = cy_card[card].base_addr + ID_ADDRESS;
3761                 if (ISZLOADED(cy_card[card])) {
3762                         zfw_ctrl = cy_card[card].base_addr +
3763                                 (cy_readl(&firm_id->zfwctrl_addr) & 0xfffff);
3764                         board_ctrl = &zfw_ctrl->board_ctrl;
3765                         ch_ctrl = zfw_ctrl->ch_ctrl;
3766
3767                         if (set & TIOCM_RTS) {
3768                                 CY_LOCK(info, flags);
3769                                 cy_writel(&ch_ctrl[channel].rs_control,
3770                                           cy_readl(&ch_ctrl[channel].
3771                                                    rs_control) | C_RS_RTS);
3772                                 CY_UNLOCK(info, flags);
3773                         }
3774                         if (clear & TIOCM_RTS) {
3775                                 CY_LOCK(info, flags);
3776                                 cy_writel(&ch_ctrl[channel].rs_control,
3777                                           cy_readl(&ch_ctrl[channel].
3778                                                    rs_control) & ~C_RS_RTS);
3779                                 CY_UNLOCK(info, flags);
3780                         }
3781                         if (set & TIOCM_DTR) {
3782                                 CY_LOCK(info, flags);
3783                                 cy_writel(&ch_ctrl[channel].rs_control,
3784                                           cy_readl(&ch_ctrl[channel].
3785                                                    rs_control) | C_RS_DTR);
3786 #ifdef CY_DEBUG_DTR
3787                                 printk("cyc:set_modem_info raising Z DTR\n");
3788 #endif
3789                                 CY_UNLOCK(info, flags);
3790                         }
3791                         if (clear & TIOCM_DTR) {
3792                                 CY_LOCK(info, flags);
3793                                 cy_writel(&ch_ctrl[channel].rs_control,
3794                                           cy_readl(&ch_ctrl[channel].
3795                                                    rs_control) & ~C_RS_DTR);
3796 #ifdef CY_DEBUG_DTR
3797                                 printk("cyc:set_modem_info clearing Z DTR\n");
3798 #endif
3799                                 CY_UNLOCK(info, flags);
3800                         }
3801                 } else {
3802                         return -ENODEV;
3803                 }
3804                 CY_LOCK(info, flags);
3805                 retval = cyz_issue_cmd(&cy_card[info->card],
3806                                         channel, C_CM_IOCTLM, 0L);
3807                 if (retval != 0) {
3808                         printk("cyc:set_modem_info retval on ttyC%d was %x\n",
3809                                 info->line, retval);
3810                 }
3811                 CY_UNLOCK(info, flags);
3812         }
3813         return 0;
3814 }                               /* cy_tiocmset */
3815
3816 /*
3817  * cy_break() --- routine which turns the break handling on or off
3818  */
3819 static void cy_break(struct tty_struct *tty, int break_state)
3820 {
3821         struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
3822         unsigned long flags;
3823
3824         if (serial_paranoia_check(info, tty->name, "cy_break"))
3825                 return;
3826
3827         CY_LOCK(info, flags);
3828         if (!IS_CYC_Z(cy_card[info->card])) {
3829                 /* Let the transmit ISR take care of this (since it
3830                    requires stuffing characters into the output stream).
3831                  */
3832                 if (break_state == -1) {
3833                         if (!info->breakon) {
3834                                 info->breakon = 1;
3835                                 if (!info->xmit_cnt) {
3836                                         CY_UNLOCK(info, flags);
3837                                         start_xmit(info);
3838                                         CY_LOCK(info, flags);
3839                                 }
3840                         }
3841                 } else {
3842                         if (!info->breakoff) {
3843                                 info->breakoff = 1;
3844                                 if (!info->xmit_cnt) {
3845                                         CY_UNLOCK(info, flags);
3846                                         start_xmit(info);
3847                                         CY_LOCK(info, flags);
3848                                 }
3849                         }
3850                 }
3851         } else {
3852                 int retval;
3853
3854                 if (break_state == -1) {
3855                         retval = cyz_issue_cmd(&cy_card[info->card],
3856                                 info->line - cy_card[info->card].first_line,
3857                                 C_CM_SET_BREAK, 0L);
3858                         if (retval != 0) {
3859                                 printk("cyc:cy_break (set) retval on ttyC%d "
3860                                         "was %x\n", info->line, retval);
3861                         }
3862                 } else {
3863                         retval = cyz_issue_cmd(&cy_card[info->card],
3864                                 info->line - cy_card[info->card].first_line,
3865                                 C_CM_CLR_BREAK, 0L);
3866                         if (retval != 0) {
3867                                 printk("cyc:cy_break (clr) retval on ttyC%d "
3868                                         "was %x\n", info->line, retval);
3869                         }
3870                 }
3871         }
3872         CY_UNLOCK(info, flags);
3873 }                               /* cy_break */
3874
3875 static int
3876 get_mon_info(struct cyclades_port *info, struct cyclades_monitor __user * mon)
3877 {
3878
3879         if (copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
3880                 return -EFAULT;
3881         info->mon.int_count = 0;
3882         info->mon.char_count = 0;
3883         info->mon.char_max = 0;
3884         info->mon.char_last = 0;
3885         return 0;
3886 }                               /* get_mon_info */
3887
3888 static int set_threshold(struct cyclades_port *info, unsigned long value)
3889 {
3890         void __iomem *base_addr;
3891         int card, channel, chip, index;
3892         unsigned long flags;
3893
3894         card = info->card;
3895         channel = info->line - cy_card[card].first_line;
3896         if (!IS_CYC_Z(cy_card[card])) {
3897                 chip = channel >> 2;
3898                 channel &= 0x03;
3899                 index = cy_card[card].bus_index;
3900                 base_addr =
3901                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3902
3903                 info->cor3 &= ~CyREC_FIFO;
3904                 info->cor3 |= value & CyREC_FIFO;
3905
3906                 CY_LOCK(info, flags);
3907                 cy_writeb(base_addr + (CyCOR3 << index), info->cor3);
3908                 cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR3ch, index);
3909                 CY_UNLOCK(info, flags);
3910         } else {
3911                 /* Nothing to do! */
3912         }
3913         return 0;
3914 }                               /* set_threshold */
3915
3916 static int
3917 get_threshold(struct cyclades_port *info, unsigned long __user * value)
3918 {
3919         void __iomem *base_addr;
3920         int card, channel, chip, index;
3921         unsigned long tmp;
3922
3923         card = info->card;
3924         channel = info->line - cy_card[card].first_line;
3925         if (!IS_CYC_Z(cy_card[card])) {
3926                 chip = channel >> 2;
3927                 channel &= 0x03;
3928                 index = cy_card[card].bus_index;
3929                 base_addr =
3930                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3931
3932                 tmp = cy_readb(base_addr + (CyCOR3 << index)) & CyREC_FIFO;
3933                 return put_user(tmp, value);
3934         } else {
3935                 /* Nothing to do! */
3936                 return 0;
3937         }
3938 }                               /* get_threshold */
3939
3940 static int
3941 set_default_threshold(struct cyclades_port *info, unsigned long value)
3942 {
3943         info->default_threshold = value & 0x0f;
3944         return 0;
3945 }                               /* set_default_threshold */
3946
3947 static int
3948 get_default_threshold(struct cyclades_port *info, unsigned long __user * value)
3949 {
3950         return put_user(info->default_threshold, value);
3951 }                               /* get_default_threshold */
3952
3953 static int set_timeout(struct cyclades_port *info, unsigned long value)
3954 {
3955         void __iomem *base_addr;
3956         int card, channel, chip, index;
3957         unsigned long flags;
3958
3959         card = info->card;
3960         channel = info->line - cy_card[card].first_line;
3961         if (!IS_CYC_Z(cy_card[card])) {
3962                 chip = channel >> 2;
3963                 channel &= 0x03;
3964                 index = cy_card[card].bus_index;
3965                 base_addr =
3966                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3967
3968                 CY_LOCK(info, flags);
3969                 cy_writeb(base_addr + (CyRTPR << index), value & 0xff);
3970                 CY_UNLOCK(info, flags);
3971         } else {
3972                 /* Nothing to do! */
3973         }
3974         return 0;
3975 }                               /* set_timeout */
3976
3977 static int get_timeout(struct cyclades_port *info, unsigned long __user * value)
3978 {
3979         void __iomem *base_addr;
3980         int card, channel, chip, index;
3981         unsigned long tmp;
3982
3983         card = info->card;
3984         channel = info->line - cy_card[card].first_line;
3985         if (!IS_CYC_Z(cy_card[card])) {
3986                 chip = channel >> 2;
3987                 channel &= 0x03;
3988                 index = cy_card[card].bus_index;
3989                 base_addr =
3990                     cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3991
3992                 tmp = cy_readb(base_addr + (CyRTPR << index));
3993                 return put_user(tmp, value);
3994         } else {
3995                 /* Nothing to do! */
3996                 return 0;
3997         }
3998 }                               /* get_timeout */
3999
4000 static int set_default_timeout(struct cyclades_port *info, unsigned long value)
4001 {
4002         info->default_timeout = value & 0xff;
4003         return 0;
4004 }                               /* set_default_timeout */
4005
4006 static int
4007 get_default_timeout(struct cyclades_port *info, unsigned long __user * value)
4008 {
4009         return put_user(info->default_timeout, value);
4010 }                               /* get_default_timeout */
4011
4012 /*
4013  * This routine allows the tty driver to implement device-
4014  * specific ioctl's.  If the ioctl number passed in cmd is
4015  * not recognized by the driver, it should return ENOIOCTLCMD.
4016  */
4017 static int
4018 cy_ioctl(struct tty_struct *tty, struct file *file,
4019          unsigned int cmd, unsigned long arg)
4020 {
4021         struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4022         struct cyclades_icount cprev, cnow;     /* kernel counter temps */
4023         struct serial_icounter_struct __user *p_cuser;  /* user space */
4024         int ret_val = 0;
4025         unsigned long flags;
4026         void __user *argp = (void __user *)arg;
4027
4028         if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
4029                 return -ENODEV;
4030
4031 #ifdef CY_DEBUG_OTHER
4032         printk("cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n", info->line, cmd, arg);      /* */
4033 #endif
4034
4035         switch (cmd) {
4036         case CYGETMON:
4037                 ret_val = get_mon_info(info, argp);
4038                 break;
4039         case CYGETTHRESH:
4040                 ret_val = get_threshold(info, argp);
4041                 break;
4042         case CYSETTHRESH:
4043                 ret_val = set_threshold(info, arg);
4044                 break;
4045         case CYGETDEFTHRESH:
4046                 ret_val = get_default_threshold(info, argp);
4047                 break;
4048         case CYSETDEFTHRESH:
4049                 ret_val = set_default_threshold(info, arg);
4050                 break;
4051         case CYGETTIMEOUT:
4052                 ret_val = get_timeout(info, argp);
4053                 break;
4054         case CYSETTIMEOUT:
4055                 ret_val = set_timeout(info, arg);
4056                 break;
4057         case CYGETDEFTIMEOUT:
4058                 ret_val = get_default_timeout(info, argp);
4059                 break;
4060         case CYSETDEFTIMEOUT:
4061                 ret_val = set_default_timeout(info, arg);
4062                 break;
4063         case CYSETRFLOW:
4064                 info->rflow = (int)arg;
4065                 ret_val = 0;
4066                 break;
4067         case CYGETRFLOW:
4068                 ret_val = info->rflow;
4069                 break;
4070         case CYSETRTSDTR_INV:
4071                 info->rtsdtr_inv = (int)arg;
4072                 ret_val = 0;
4073                 break;
4074         case CYGETRTSDTR_INV:
4075                 ret_val = info->rtsdtr_inv;
4076                 break;
4077         case CYGETCARDINFO:
4078                 if (copy_to_user(argp, &cy_card[info->card],
4079                                  sizeof(struct cyclades_card))) {
4080                         ret_val = -EFAULT;
4081                         break;
4082                 }
4083                 ret_val = 0;
4084                 break;
4085         case CYGETCD1400VER:
4086                 ret_val = info->chip_rev;
4087                 break;
4088 #ifndef CONFIG_CYZ_INTR
4089         case CYZSETPOLLCYCLE:
4090                 cyz_polling_cycle = (arg * HZ) / 1000;
4091                 ret_val = 0;
4092                 break;
4093         case CYZGETPOLLCYCLE:
4094                 ret_val = (cyz_polling_cycle * 1000) / HZ;
4095                 break;
4096 #endif                          /* CONFIG_CYZ_INTR */
4097         case CYSETWAIT:
4098                 info->closing_wait = (unsigned short)arg *HZ / 100;
4099                 ret_val = 0;
4100                 break;
4101         case CYGETWAIT:
4102                 ret_val = info->closing_wait / (HZ / 100);
4103                 break;
4104         case TIOCGSERIAL:
4105                 ret_val = get_serial_info(info, argp);
4106                 break;
4107         case TIOCSSERIAL:
4108                 ret_val = set_serial_info(info, argp);
4109                 break;
4110         case TIOCSERGETLSR:     /* Get line status register */
4111                 ret_val = get_lsr_info(info, argp);
4112                 break;
4113                 /*
4114                  * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
4115                  * - mask passed in arg for lines of interest
4116                  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
4117                  * Caller should use TIOCGICOUNT to see which one it was
4118                  */
4119         case TIOCMIWAIT:
4120                 CY_LOCK(info, flags);
4121                 /* note the counters on entry */
4122                 cprev = info->icount;
4123                 CY_UNLOCK(info, flags);
4124                 while (1) {
4125                         interruptible_sleep_on(&info->delta_msr_wait);
4126                         /* see if a signal did it */
4127                         if (signal_pending(current)) {
4128                                 return -ERESTARTSYS;
4129                         }
4130
4131                         CY_LOCK(info, flags);
4132                         cnow = info->icount;    /* atomic copy */
4133                         CY_UNLOCK(info, flags);
4134
4135                         if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
4136                             cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
4137                                 return -EIO;    /* no change => error */
4138                         }
4139                         if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
4140                             ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
4141                             ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
4142                             ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
4143                                 return 0;
4144                         }
4145                         cprev = cnow;
4146                 }
4147                 /* NOTREACHED */
4148
4149                 /*
4150                  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
4151                  * Return: write counters to the user passed counter struct
4152                  * NB: both 1->0 and 0->1 transitions are counted except for
4153                  *     RI where only 0->1 is counted.
4154                  */
4155         case TIOCGICOUNT:
4156                 CY_LOCK(info, flags);
4157                 cnow = info->icount;
4158                 CY_UNLOCK(info, flags);
4159                 p_cuser = argp;
4160                 ret_val = put_user(cnow.cts, &p_cuser->cts);
4161                 if (ret_val)
4162                         return ret_val;
4163                 ret_val = put_user(cnow.dsr, &p_cuser->dsr);
4164                 if (ret_val)
4165                         return ret_val;
4166                 ret_val = put_user(cnow.rng, &p_cuser->rng);
4167                 if (ret_val)
4168                         return ret_val;
4169                 ret_val = put_user(cnow.dcd, &p_cuser->dcd);
4170                 if (ret_val)
4171                         return ret_val;
4172                 ret_val = put_user(cnow.rx, &p_cuser->rx);
4173                 if (ret_val)
4174                         return ret_val;
4175                 ret_val = put_user(cnow.tx, &p_cuser->tx);
4176                 if (ret_val)
4177                         return ret_val;
4178                 ret_val = put_user(cnow.frame, &p_cuser->frame);
4179                 if (ret_val)
4180                         return ret_val;
4181                 ret_val = put_user(cnow.overrun, &p_cuser->overrun);
4182                 if (ret_val)
4183                         return ret_val;
4184                 ret_val = put_user(cnow.parity, &p_cuser->parity);
4185                 if (ret_val)
4186                         return ret_val;
4187                 ret_val = put_user(cnow.brk, &p_cuser->brk);
4188                 if (ret_val)
4189                         return ret_val;
4190                 ret_val = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
4191                 if (ret_val)
4192                         return ret_val;
4193                 ret_val = 0;
4194                 break;
4195         default:
4196                 ret_val = -ENOIOCTLCMD;
4197         }
4198
4199 #ifdef CY_DEBUG_OTHER
4200         printk(" cyc:cy_ioctl done\n");
4201 #endif
4202
4203         return ret_val;
4204 }                               /* cy_ioctl */
4205
4206 /*
4207  * This routine allows the tty driver to be notified when
4208  * device's termios settings have changed.  Note that a
4209  * well-designed tty driver should be prepared to accept the case
4210  * where old == NULL, and try to do something rational.
4211  */
4212 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
4213 {
4214         struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4215
4216 #ifdef CY_DEBUG_OTHER
4217         printk("cyc:cy_set_termios ttyC%d\n", info->line);
4218 #endif
4219
4220         if (tty->termios->c_cflag == old_termios->c_cflag &&
4221                         (tty->termios->c_iflag & (IXON | IXANY)) ==
4222                         (old_termios->c_iflag & (IXON | IXANY)))
4223                 return;
4224         set_line_char(info);
4225
4226         if ((old_termios->c_cflag & CRTSCTS) &&
4227                         !(tty->termios->c_cflag & CRTSCTS)) {
4228                 tty->hw_stopped = 0;
4229                 cy_start(tty);
4230         }
4231 #if 0
4232         /*
4233          * No need to wake up processes in open wait, since they
4234          * sample the CLOCAL flag once, and don't recheck it.
4235          * XXX  It's not clear whether the current behavior is correct
4236          * or not.  Hence, this may change.....
4237          */
4238         if (!(old_termios->c_cflag & CLOCAL) &&
4239             (tty->termios->c_cflag & CLOCAL))
4240                 wake_up_interruptible(&info->open_wait);
4241 #endif
4242 }                               /* cy_set_termios */
4243
4244 /* This function is used to send a high-priority XON/XOFF character to
4245    the device.
4246 */
4247 static void cy_send_xchar(struct tty_struct *tty, char ch)
4248 {
4249         struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4250         int card, channel;
4251
4252         if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
4253                 return;
4254
4255         info->x_char = ch;
4256
4257         if (ch)
4258                 cy_start(tty);
4259
4260         card = info->card;
4261         channel = info->line - cy_card[card].first_line;
4262
4263         if (IS_CYC_Z(cy_card[card])) {
4264                 if (ch == STOP_CHAR(tty))
4265                         cyz_issue_cmd(&cy_card[card], channel, C_CM_SENDXOFF,
4266                                         0L);
4267                 else if (ch == START_CHAR(tty))
4268                         cyz_issue_cmd(&cy_card[card], channel, C_CM_SENDXON,
4269                                         0L);
4270         }
4271 }
4272
4273 /* This routine is called by the upper-layer tty layer to signal
4274    that incoming characters should be throttled because the input
4275    buffers are close to full.
4276  */
4277 static void cy_throttle(struct tty_struct *tty)
4278 {
4279         struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4280         unsigned long flags;
4281         void __iomem *base_addr;
4282         int card, chip, channel, index;
4283
4284 #ifdef CY_DEBUG_THROTTLE
4285         char buf[64];
4286
4287         printk("cyc:throttle %s: %d....ttyC%d\n", tty_name(tty, buf),
4288                         tty->ldisc.chars_in_buffer(tty), info->line);
4289 #endif
4290
4291         if (serial_paranoia_check(info, tty->name, "cy_throttle")) {
4292                 return;
4293         }
4294
4295         card = info->card;
4296
4297         if (I_IXOFF(tty)) {
4298                 if (!IS_CYC_Z(cy_card[card]))
4299                         cy_send_xchar(tty, STOP_CHAR(tty));
4300                 else
4301                         info->throttle = 1;
4302         }
4303
4304         if (tty->termios->c_cflag & CRTSCTS) {
4305                 channel = info->line - cy_card[card].first_line;
4306                 if (!IS_CYC_Z(cy_card[card])) {
4307                         chip = channel >> 2;
4308                         channel &= 0x03;
4309                         index = cy_card[card].bus_index;
4310                         base_addr = cy_card[card].base_addr +
4311                                 (cy_chip_offset[chip] << index);
4312
4313                         CY_LOCK(info, flags);
4314                         cy_writeb(base_addr + (CyCAR << index),
4315                                   (u_char) channel);
4316                         if (info->rtsdtr_inv) {
4317                                 cy_writeb(base_addr + (CyMSVR2 << index),
4318                                           ~CyDTR);
4319                         } else {
4320                                 cy_writeb(base_addr + (CyMSVR1 << index),
4321                                           ~CyRTS);
4322                         }
4323                         CY_UNLOCK(info, flags);
4324                 } else {
4325                         info->throttle = 1;
4326                 }
4327         }
4328 }                               /* cy_throttle */
4329
4330 /*
4331  * This routine notifies the tty driver that it should signal
4332  * that characters can now be sent to the tty without fear of
4333  * overrunning the input buffers of the line disciplines.
4334  */
4335 static void cy_unthrottle(struct tty_struct *tty)
4336 {
4337         struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4338         unsigned long flags;
4339         void __iomem *base_addr;
4340         int card, chip, channel, index;
4341
4342 #ifdef CY_DEBUG_THROTTLE
4343         char buf[64];
4344
4345         printk("cyc:unthrottle %s: %d....ttyC%d\n", tty_name(tty, buf),
4346                 tty->ldisc.chars_in_buffer(tty), info->line);
4347 #endif
4348
4349         if (serial_paranoia_check(info, tty->name, "cy_unthrottle")) {
4350                 return;
4351         }
4352
4353         if (I_IXOFF(tty)) {
4354                 if (info->x_char)
4355                         info->x_char = 0;
4356                 else
4357                         cy_send_xchar(tty, START_CHAR(tty));
4358         }
4359
4360         if (tty->termios->c_cflag & CRTSCTS) {
4361                 card = info->card;
4362                 channel = info->line - cy_card[card].first_line;
4363                 if (!IS_CYC_Z(cy_card[card])) {
4364                         chip = channel >> 2;
4365                         channel &= 0x03;
4366                         index = cy_card[card].bus_index;
4367                         base_addr = cy_card[card].base_addr +
4368                                 (cy_chip_offset[chip] << index);
4369
4370                         CY_LOCK(info, flags);
4371                         cy_writeb(base_addr + (CyCAR << index),
4372                                   (u_char) channel);
4373                         if (info->rtsdtr_inv) {
4374                                 cy_writeb(base_addr + (CyMSVR2 << index),
4375                                           CyDTR);
4376                         } else {
4377                                 cy_writeb(base_addr + (CyMSVR1 << index),
4378                                           CyRTS);
4379                         }
4380                         CY_UNLOCK(info, flags);
4381                 } else {
4382                         info->throttle = 0;
4383                 }
4384         }
4385 }                               /* cy_unthrottle */
4386
4387 /* cy_start and cy_stop provide software output flow control as a
4388    function of XON/XOFF, software CTS, and other such stuff.
4389 */
4390 static void cy_stop(struct tty_struct *tty)
4391 {
4392         struct cyclades_card *cinfo;
4393         struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4394         void __iomem *base_addr;
4395         int chip, channel, index;
4396         unsigned long flags;
4397
4398 #ifdef CY_DEBUG_OTHER
4399         printk("cyc:cy_stop ttyC%d\n", info->line);     /* */
4400 #endif
4401
4402         if (serial_paranoia_check(info, tty->name, "cy_stop"))
4403                 return;
4404
4405         cinfo = &cy_card[info->card];
4406         channel = info->line - cinfo->first_line;
4407         if (!IS_CYC_Z(*cinfo)) {
4408                 index = cinfo->bus_index;
4409                 chip = channel >> 2;
4410                 channel &= 0x03;
4411                 base_addr = cy_card[info->card].base_addr +
4412                         (cy_chip_offset[chip] << index);
4413
4414                 CY_LOCK(info, flags);
4415                 cy_writeb(base_addr + (CyCAR << index),
4416                         (u_char)(channel & 0x0003)); /* index channel */
4417                 cy_writeb(base_addr + (CySRER << index),
4418                           cy_readb(base_addr + (CySRER << index)) & ~CyTxRdy);
4419                 CY_UNLOCK(info, flags);
4420         } else {
4421                 /* Nothing to do! */
4422         }
4423 }                               /* cy_stop */
4424
4425 static void cy_start(struct tty_struct *tty)
4426 {
4427         struct cyclades_card *cinfo;
4428         struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4429         void __iomem *base_addr;
4430         int chip, channel, index;
4431         unsigned long flags;
4432
4433 #ifdef CY_DEBUG_OTHER
4434         printk("cyc:cy_start ttyC%d\n", info->line);    /* */
4435 #endif
4436
4437         if (serial_paranoia_check(info, tty->name, "cy_start"))
4438                 return;
4439
4440         cinfo = &cy_card[info->card];
4441         channel = info->line - cinfo->first_line;
4442         index = cinfo->bus_index;
4443         if (!IS_CYC_Z(*cinfo)) {
4444                 chip = channel >> 2;
4445                 channel &= 0x03;
4446                 base_addr = cy_card[info->card].base_addr +
4447                         (cy_chip_offset[chip] << index);
4448
4449                 CY_LOCK(info, flags);
4450                 cy_writeb(base_addr + (CyCAR << index), (u_char) (channel & 0x0003));   /* index channel */
4451                 cy_writeb(base_addr + (CySRER << index),
4452                           cy_readb(base_addr + (CySRER << index)) | CyTxRdy);
4453                 CY_UNLOCK(info, flags);
4454         } else {
4455                 /* Nothing to do! */
4456         }
4457 }                               /* cy_start */
4458
4459 static void cy_flush_buffer(struct tty_struct *tty)
4460 {
4461         struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4462         int card, channel, retval;
4463         unsigned long flags;
4464
4465 #ifdef CY_DEBUG_IO
4466         printk("cyc:cy_flush_buffer ttyC%d\n", info->line);     /* */
4467 #endif
4468
4469         if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
4470                 return;
4471
4472         card = info->card;
4473         channel = (info->line) - (cy_card[card].first_line);
4474
4475         CY_LOCK(info, flags);
4476         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
4477         CY_UNLOCK(info, flags);
4478
4479         if (IS_CYC_Z(cy_card[card])) {  /* If it is a Z card, flush the on-board
4480                                            buffers as well */
4481                 CY_LOCK(info, flags);
4482                 retval =
4483                     cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_TX, 0L);
4484                 if (retval != 0) {
4485                         printk("cyc: flush_buffer retval on ttyC%d was %x\n",
4486                                 info->line, retval);
4487                 }
4488                 CY_UNLOCK(info, flags);
4489         }
4490         tty_wakeup(tty);
4491 }                               /* cy_flush_buffer */
4492
4493 /*
4494  * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
4495  */
4496 static void cy_hangup(struct tty_struct *tty)
4497 {
4498         struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4499
4500 #ifdef CY_DEBUG_OTHER
4501         printk("cyc:cy_hangup ttyC%d\n", info->line);   /* */
4502 #endif
4503
4504         if (serial_paranoia_check(info, tty->name, "cy_hangup"))
4505                 return;
4506
4507         cy_flush_buffer(tty);
4508         shutdown(info);
4509         info->event = 0;
4510         info->count = 0;
4511 #ifdef CY_DEBUG_COUNT
4512         printk("cyc:cy_hangup (%d): setting count to 0\n", current->pid);
4513 #endif
4514         info->tty = NULL;
4515         info->flags &= ~ASYNC_NORMAL_ACTIVE;
4516         wake_up_interruptible(&info->open_wait);
4517 }                               /* cy_hangup */
4518
4519 /*
4520  * ---------------------------------------------------------------------
4521  * cy_init() and friends
4522  *
4523  * cy_init() is called at boot-time to initialize the serial driver.
4524  * ---------------------------------------------------------------------
4525  */
4526
4527 /* initialize chips on Cyclom-Y card -- return number of valid
4528    chips (which is number of ports/4) */
4529 static unsigned short __init
4530 cyy_init_card(void __iomem * true_base_addr, int index)
4531 {
4532         unsigned int chip_number;
4533         void __iomem *base_addr;
4534
4535         cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
4536         /* Cy_HwReset is 0x1400 */
4537         cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
4538         /* Cy_ClrIntr is 0x1800 */
4539         udelay(500L);
4540
4541         for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD; chip_number++) {
4542                 base_addr =
4543                     true_base_addr + (cy_chip_offset[chip_number] << index);
4544                 mdelay(1);
4545                 if (cy_readb(base_addr + (CyCCR << index)) != 0x00) {
4546                         /*************
4547                         printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
4548                         chip_number, (unsigned long)base_addr);
4549                         *************/
4550                         return chip_number;
4551                 }
4552
4553                 cy_writeb(base_addr + (CyGFRCR << index), 0);
4554                 udelay(10L);
4555
4556                 /* The Cyclom-16Y does not decode address bit 9 and therefore
4557                    cannot distinguish between references to chip 0 and a non-
4558                    existent chip 4.  If the preceding clearing of the supposed
4559                    chip 4 GFRCR register appears at chip 0, there is no chip 4
4560                    and this must be a Cyclom-16Y, not a Cyclom-32Ye.
4561                  */
4562                 if (chip_number == 4 && cy_readb(true_base_addr +
4563                                 (cy_chip_offset[0] << index) +
4564                                 (CyGFRCR << index)) == 0) {
4565                         return chip_number;
4566                 }
4567
4568                 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
4569                 mdelay(1);
4570
4571                 if (cy_readb(base_addr + (CyGFRCR << index)) == 0x00) {
4572                         /*
4573                            printk(" chip #%d at %#6lx is not responding ",
4574                            chip_number, (unsigned long)base_addr);
4575                            printk("(GFRCR stayed 0)\n",
4576                          */
4577                         return chip_number;
4578                 }
4579                 if ((0xf0 & (cy_readb(base_addr + (CyGFRCR << index)))) !=
4580                                 0x40) {
4581                         /*
4582                         printk(" chip #%d at %#6lx is not valid (GFRCR == "
4583                                         "%#2x)\n",
4584                                         chip_number, (unsigned long)base_addr,
4585                                         base_addr[CyGFRCR<<index]);
4586                          */
4587                         return chip_number;
4588                 }
4589                 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
4590                 if (cy_readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
4591                         /* It is a CD1400 rev. J or later */
4592                         /* Impossible to reach 5ms with this chip.
4593                            Changed to 2ms instead (f = 500 Hz). */
4594                         cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
4595                 } else {
4596                         /* f = 200 Hz */
4597                         cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
4598                 }
4599
4600                 /*
4601                    printk(" chip #%d at %#6lx is rev 0x%2x\n",
4602                    chip_number, (unsigned long)base_addr,
4603                    cy_readb(base_addr+(CyGFRCR<<index)));
4604                  */
4605         }
4606         return chip_number;
4607 }                               /* cyy_init_card */
4608
4609 /*
4610  * ---------------------------------------------------------------------
4611  * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
4612  * sets global variables and return the number of ISA boards found.
4613  * ---------------------------------------------------------------------
4614  */
4615 static int __init cy_detect_isa(void)
4616 {
4617 #ifdef CONFIG_ISA
4618         unsigned short cy_isa_irq, nboard;
4619         void __iomem *cy_isa_address;
4620         unsigned short i, j, cy_isa_nchan;
4621 #ifdef MODULE
4622         int isparam = 0;
4623 #endif
4624
4625         nboard = 0;
4626
4627 #ifdef MODULE
4628         /* Check for module parameters */
4629         for (i = 0; i < NR_CARDS; i++) {
4630                 if (maddr[i] || i) {
4631                         isparam = 1;
4632                         cy_isa_addresses[i] = maddr[i];
4633                 }
4634                 if (!maddr[i])
4635                         break;
4636         }
4637 #endif
4638
4639         /* scan the address table probing for Cyclom-Y/ISA boards */
4640         for (i = 0; i < NR_ISA_ADDRS; i++) {
4641                 unsigned int isa_address = cy_isa_addresses[i];
4642                 if (isa_address == 0x0000) {
4643                         return nboard;
4644                 }
4645
4646                 /* probe for CD1400... */
4647                 cy_isa_address = ioremap(isa_address, CyISA_Ywin);
4648                 cy_isa_nchan = CyPORTS_PER_CHIP *
4649                         cyy_init_card(cy_isa_address, 0);
4650                 if (cy_isa_nchan == 0) {
4651                         continue;
4652                 }
4653 #ifdef MODULE
4654                 if (isparam && irq[i])
4655                         cy_isa_irq = irq[i];
4656                 else
4657 #endif
4658                         /* find out the board's irq by probing */
4659                         cy_isa_irq = detect_isa_irq(cy_isa_address);
4660                 if (cy_isa_irq == 0) {
4661                         printk("Cyclom-Y/ISA found at 0x%lx ",
4662                                 (unsigned long)cy_isa_address);
4663                         printk("but the IRQ could not be detected.\n");
4664                         continue;
4665                 }
4666
4667                 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
4668                         printk("Cyclom-Y/ISA found at 0x%lx ",
4669                                 (unsigned long)cy_isa_address);
4670                         printk("but no more channels are available.\n");
4671                         printk("Change NR_PORTS in cyclades.c and recompile "
4672                                         "kernel.\n");
4673                         return nboard;
4674                 }
4675                 /* fill the next cy_card structure available */
4676                 for (j = 0; j < NR_CARDS; j++) {
4677                         if (cy_card[j].base_addr == 0)
4678                                 break;
4679                 }
4680                 if (j == NR_CARDS) {    /* no more cy_cards available */
4681                         printk("Cyclom-Y/ISA found at 0x%lx ",
4682                                 (unsigned long)cy_isa_address);
4683                         printk("but no more cards can be used .\n");
4684                         printk("Change NR_CARDS in cyclades.c and recompile "
4685                                         "kernel.\n");
4686                         return nboard;
4687                 }
4688
4689                 /* allocate IRQ */
4690                 if (request_irq(cy_isa_irq, cyy_interrupt,
4691                                 IRQF_DISABLED, "Cyclom-Y", &cy_card[j])) {
4692                         printk("Cyclom-Y/ISA found at 0x%lx ",
4693                                 (unsigned long)cy_isa_address);
4694                         printk("but could not allocate IRQ#%d.\n", cy_isa_irq);
4695                         return nboard;
4696                 }
4697
4698                 /* set cy_card */
4699                 cy_card[j].base_addr = cy_isa_address;
4700                 cy_card[j].ctl_addr = NULL;
4701                 cy_card[j].irq = (int)cy_isa_irq;
4702                 cy_card[j].bus_index = 0;
4703                 cy_card[j].first_line = cy_next_channel;
4704                 cy_card[j].num_chips = cy_isa_nchan / 4;
4705                 nboard++;
4706
4707                 /* print message */
4708                 printk("Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d, ",
4709                         j + 1, (unsigned long)cy_isa_address,
4710                         (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
4711                         cy_isa_irq);
4712                 printk("%d channels starting from port %d.\n",
4713                         cy_isa_nchan, cy_next_channel);
4714                 cy_next_channel += cy_isa_nchan;
4715         }
4716         return nboard;
4717 #else
4718         return 0;
4719 #endif                          /* CONFIG_ISA */
4720 }                               /* cy_detect_isa */
4721
4722 static void plx_init(void __iomem * addr, uclong initctl)
4723 {
4724         /* Reset PLX */
4725         cy_writel(addr + initctl, cy_readl(addr + initctl) | 0x40000000);
4726         udelay(100L);
4727         cy_writel(addr + initctl, cy_readl(addr + initctl) & ~0x40000000);
4728
4729         /* Reload Config. Registers from EEPROM */
4730         cy_writel(addr + initctl, cy_readl(addr + initctl) | 0x20000000);
4731         udelay(100L);
4732         cy_writel(addr + initctl, cy_readl(addr + initctl) & ~0x20000000);
4733 }
4734
4735 /*
4736  * ---------------------------------------------------------------------
4737  * cy_detect_pci() - Test PCI bus presence and Cyclom-Ye/PCI.
4738  * sets global variables and return the number of PCI boards found.
4739  * ---------------------------------------------------------------------
4740  */
4741 static int __init cy_detect_pci(void)
4742 {
4743 #ifdef CONFIG_PCI
4744
4745         struct pci_dev *pdev = NULL;
4746         unsigned char cyy_rev_id;
4747         unsigned char cy_pci_irq = 0;
4748         uclong cy_pci_phys0, cy_pci_phys2;
4749         void __iomem *cy_pci_addr0, *cy_pci_addr2;
4750         unsigned short i, j, cy_pci_nchan, plx_ver;
4751         unsigned short device_id, dev_index = 0;
4752         uclong mailbox;
4753         uclong ZeIndex = 0;
4754         void __iomem *Ze_addr0[NR_CARDS], *Ze_addr2[NR_CARDS];
4755         uclong Ze_phys0[NR_CARDS], Ze_phys2[NR_CARDS];
4756         unsigned char Ze_irq[NR_CARDS];
4757         struct pci_dev *Ze_pdev[NR_CARDS];
4758
4759         for (i = 0; i < NR_CARDS; i++) {
4760                 /* look for a Cyclades card by vendor and device id */
4761                 while ((device_id = cy_pci_dev_id[dev_index]) != 0) {
4762                         if ((pdev = pci_get_device(PCI_VENDOR_ID_CYCLADES,
4763                                                    device_id, pdev)) == NULL) {
4764                                 dev_index++;    /* try next device id */
4765                         } else {
4766                                 break;  /* found a board */
4767                         }
4768                 }
4769
4770                 if (device_id == 0)
4771                         break;
4772
4773                 if (pci_enable_device(pdev))
4774                         continue;
4775
4776                 /* read PCI configuration area */
4777                 cy_pci_irq = pdev->irq;
4778                 cy_pci_phys0 = pci_resource_start(pdev, 0);
4779                 cy_pci_phys2 = pci_resource_start(pdev, 2);
4780                 pci_read_config_byte(pdev, PCI_REVISION_ID, &cyy_rev_id);
4781
4782                 device_id &= ~PCI_DEVICE_ID_MASK;
4783
4784                 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
4785                                 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
4786 #ifdef CY_PCI_DEBUG
4787                         printk("Cyclom-Y/PCI (bus=0x0%x, pci_id=0x%x, ",
4788                                 pdev->bus->number, pdev->devfn);
4789                         printk("rev_id=%d) IRQ%d\n",
4790                                 cyy_rev_id, (int)cy_pci_irq);
4791                         printk("Cyclom-Y/PCI:found  winaddr=0x%lx "
4792                                 "ctladdr=0x%lx\n",
4793                                 (ulong)cy_pci_phys2, (ulong)cy_pci_phys0);
4794 #endif
4795
4796                         if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
4797                                 printk("  Warning: PCI I/O bit incorrectly "
4798                                         "set. Ignoring it...\n");
4799                                 pdev->resource[2].flags &= ~IORESOURCE_IO;
4800                         }
4801
4802                         /* Although we don't use this I/O region, we should
4803                            request it from the kernel anyway, to avoid problems
4804                            with other drivers accessing it. */
4805                         if (pci_request_regions(pdev, "Cyclom-Y") != 0) {
4806                                 printk(KERN_ERR "cyclades: failed to reserve "
4807                                                 "PCI resources\n");
4808                                 continue;
4809                         }
4810 #if defined(__alpha__)
4811                         if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) {   /* below 1M? */
4812                                 printk("Cyclom-Y/PCI (bus=0x0%x, pci_id=0x%x, ",
4813                                         pdev->bus->number, pdev->devfn);
4814                                 printk("rev_id=%d) IRQ%d\n",
4815                                         cyy_rev_id, (int)cy_pci_irq);
4816                                 printk("Cyclom-Y/PCI:found  winaddr=0x%lx "
4817                                         "ctladdr=0x%lx\n",
4818                                         (ulong)cy_pci_phys2,
4819                                         (ulong)cy_pci_phys0);
4820                                 printk("Cyclom-Y/PCI not supported for low "
4821                                         "addresses in Alpha systems.\n");
4822                                 i--;
4823                                 continue;
4824                         }
4825 #endif
4826                         cy_pci_addr0 = ioremap(cy_pci_phys0, CyPCI_Yctl);
4827                         cy_pci_addr2 = ioremap(cy_pci_phys2, CyPCI_Ywin);
4828
4829 #ifdef CY_PCI_DEBUG
4830                         printk("Cyclom-Y/PCI: relocate winaddr=0x%lx "
4831                                 "ctladdr=0x%lx\n",
4832                                 (u_long)cy_pci_addr2, (u_long)cy_pci_addr0);
4833 #endif
4834                         cy_pci_nchan = (unsigned short)(CyPORTS_PER_CHIP *
4835                                         cyy_init_card(cy_pci_addr2, 1));
4836                         if (cy_pci_nchan == 0) {
4837                                 printk("Cyclom-Y PCI host card with ");
4838                                 printk("no Serial-Modules at 0x%lx.\n",
4839                                         (ulong) cy_pci_phys2);
4840                                 i--;
4841                                 continue;
4842                         }
4843                         if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
4844                                 printk("Cyclom-Y/PCI found at 0x%lx ",
4845                                         (ulong) cy_pci_phys2);
4846                                 printk("but no channels are available.\n");
4847                                 printk("Change NR_PORTS in cyclades.c and "
4848                                                 "recompile kernel.\n");
4849                                 return i;
4850                         }
4851                         /* fill the next cy_card structure available */
4852                         for (j = 0; j < NR_CARDS; j++) {
4853                                 if (cy_card[j].base_addr == 0)
4854                                         break;
4855                         }
4856                         if (j == NR_CARDS) {    /* no more cy_cards available */
4857                                 printk("Cyclom-Y/PCI found at 0x%lx ",
4858                                         (ulong) cy_pci_phys2);
4859                                 printk("but no more cards can be used.\n");
4860                                 printk("Change NR_CARDS in cyclades.c and "
4861                                                 "recompile kernel.\n");
4862                                 return i;
4863                         }
4864
4865                         /* allocate IRQ */
4866                         if (request_irq(cy_pci_irq, cyy_interrupt,
4867                                         IRQF_SHARED, "Cyclom-Y", &cy_card[j])) {
4868                                 printk("Cyclom-Y/PCI found at 0x%lx ",
4869                                         (ulong) cy_pci_phys2);
4870                                 printk("but could not allocate IRQ%d.\n",
4871                                         cy_pci_irq);
4872                                 return i;
4873                         }
4874
4875                         /* set cy_card */
4876                         cy_card[j].base_phys = (ulong) cy_pci_phys2;
4877                         cy_card[j].ctl_phys = (ulong) cy_pci_phys0;
4878                         cy_card[j].base_addr = cy_pci_addr2;
4879                         cy_card[j].ctl_addr = cy_pci_addr0;
4880                         cy_card[j].irq = (int)cy_pci_irq;
4881                         cy_card[j].bus_index = 1;
4882                         cy_card[j].first_line = cy_next_channel;
4883                         cy_card[j].num_chips = cy_pci_nchan / 4;
4884                         cy_card[j].pdev = pdev;
4885
4886                         /* enable interrupts in the PCI interface */
4887                         plx_ver = cy_readb(cy_pci_addr2 + CyPLX_VER) & 0x0f;
4888                         switch (plx_ver) {
4889                         case PLX_9050:
4890
4891                                 cy_writeb(cy_pci_addr0 + 0x4c, 0x43);
4892                                 break;
4893
4894                         case PLX_9060:
4895                         case PLX_9080:
4896                         default:        /* Old boards, use PLX_9060 */
4897
4898                                 plx_init(cy_pci_addr0, 0x6c);
4899                         /* For some yet unknown reason, once the PLX9060 reloads
4900                            the EEPROM, the IRQ is lost and, thus, we have to
4901                            re-write it to the PCI config. registers.
4902                            This will remain here until we find a permanent
4903                            fix. */
4904                                 pci_write_config_byte(pdev, PCI_INTERRUPT_LINE,
4905                                                 cy_pci_irq);
4906
4907                                 cy_writew(cy_pci_addr0 + 0x68,
4908                                           cy_readw(cy_pci_addr0 +
4909                                                    0x68) | 0x0900);
4910                                 break;
4911                         }
4912
4913                         /* print message */
4914                         printk("Cyclom-Y/PCI #%d: 0x%lx-0x%lx, IRQ%d, ",
4915                                 j + 1, (ulong)cy_pci_phys2,
4916                                 (ulong) (cy_pci_phys2 + CyPCI_Ywin - 1),
4917                                 (int)cy_pci_irq);
4918                         printk("%d channels starting from port %d.\n",
4919                                 cy_pci_nchan, cy_next_channel);
4920
4921                         cy_next_channel += cy_pci_nchan;
4922                 } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
4923                         /* print message */
4924                         printk("Cyclades-Z/PCI (bus=0x0%x, pci_id=0x%x, ",
4925                                 pdev->bus->number, pdev->devfn);
4926                         printk("rev_id=%d) IRQ%d\n",
4927                                 cyy_rev_id, (int)cy_pci_irq);
4928                         printk("Cyclades-Z/PCI: found winaddr=0x%lx "
4929                                 "ctladdr=0x%lx\n",
4930                                 (ulong)cy_pci_phys2, (ulong)cy_pci_phys0);
4931                         printk("Cyclades-Z/PCI not supported for low "
4932                                 "addresses\n");
4933                         break;
4934                 } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
4935 #ifdef CY_PCI_DEBUG
4936                         printk("Cyclades-Z/PCI (bus=0x0%x, pci_id=0x%x, ",
4937                                 pdev->bus->number, pdev->devfn);
4938                         printk("rev_id=%d) IRQ%d\n",
4939                                 cyy_rev_id, (int)cy_pci_irq);
4940                         printk("Cyclades-Z/PCI: found winaddr=0x%lx "
4941                                 "ctladdr=0x%lx\n",
4942                                 (ulong) cy_pci_phys2, (ulong) cy_pci_phys0);
4943 #endif
4944                         cy_pci_addr0 = ioremap(cy_pci_phys0, CyPCI_Zctl);
4945
4946                         /* Disable interrupts on the PLX before resetting it */
4947                         cy_writew(cy_pci_addr0 + 0x68,
4948                                 cy_readw(cy_pci_addr0 + 0x68) & ~0x0900);
4949
4950                         plx_init(cy_pci_addr0, 0x6c);
4951                         /* For some yet unknown reason, once the PLX9060 reloads
4952                            the EEPROM, the IRQ is lost and, thus, we have to
4953                            re-write it to the PCI config. registers.
4954                            This will remain here until we find a permanent
4955                            fix. */
4956                         pci_write_config_byte(pdev, PCI_INTERRUPT_LINE,
4957                                                 cy_pci_irq);
4958
4959                         mailbox =
4960                             (uclong)cy_readl(&((struct RUNTIME_9060 __iomem *)
4961                                                 cy_pci_addr0)->mail_box_0);
4962
4963                         if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
4964                                 printk("  Warning: PCI I/O bit incorrectly "
4965                                         "set. Ignoring it...\n");
4966                                 pdev->resource[2].flags &= ~IORESOURCE_IO;
4967                         }
4968
4969                         /* Although we don't use this I/O region, we should
4970                            request it from the kernel anyway, to avoid problems
4971                            with other drivers accessing it. */
4972                         if (pci_request_regions(pdev, "Cyclades-Z") != 0) {
4973                                 printk(KERN_ERR "cyclades: failed to reserve "
4974                                         "PCI resources\n");
4975                                 continue;
4976                         }
4977
4978                         if (mailbox == ZE_V1) {
4979                                 cy_pci_addr2 = ioremap(cy_pci_phys2,
4980                                                 CyPCI_Ze_win);
4981                                 if (ZeIndex == NR_CARDS) {
4982                                         printk("Cyclades-Ze/PCI found at "
4983                                                 "0x%lx but no more cards can "
4984                                                 "be used.\nChange NR_CARDS in "
4985                                                 "cyclades.c and recompile "
4986                                                 "kernel.\n",
4987                                                 (ulong)cy_pci_phys2);
4988                                 } else {
4989                                         Ze_phys0[ZeIndex] = cy_pci_phys0;
4990                                         Ze_phys2[ZeIndex] = cy_pci_phys2;
4991                                         Ze_addr0[ZeIndex] = cy_pci_addr0;
4992                                         Ze_addr2[ZeIndex] = cy_pci_addr2;
4993                                         Ze_irq[ZeIndex] = cy_pci_irq;
4994                                         Ze_pdev[ZeIndex] = pdev;
4995                                         ZeIndex++;
4996                                 }
4997                                 i--;
4998                                 continue;
4999                         } else {
5000                                 cy_pci_addr2 = ioremap(cy_pci_phys2,CyPCI_Zwin);
5001                         }
5002
5003 #ifdef CY_PCI_DEBUG
5004                         printk("Cyclades-Z/PCI: relocate winaddr=0x%lx "
5005                                 "ctladdr=0x%lx\n",
5006                                 (ulong) cy_pci_addr2, (ulong) cy_pci_addr0);
5007                         if (mailbox == ZO_V1) {
5008                                 cy_writel(&((struct RUNTIME_9060 *)
5009                                         (cy_pci_addr0))->loc_addr_base,
5010                                         WIN_CREG);
5011                                 PAUSE;
5012                                 printk("Cyclades-8Zo/PCI: FPGA id %lx, ver "
5013                                         "%lx\n", (ulong) (0xff &
5014                                         cy_readl(&((struct CUSTOM_REG *)
5015                                                 (cy_pci_addr2))->fpga_id)),
5016                                         (ulong)(0xff &
5017                                         cy_readl(&((struct CUSTOM_REG *)
5018                                                 (cy_pci_addr2))->
5019                                                         fpga_version)));
5020                                 cy_writel(&((struct RUNTIME_9060 *)
5021                                         (cy_pci_addr0))->loc_addr_base,
5022                                         WIN_RAM);
5023                         } else {
5024                                 printk("Cyclades-Z/PCI: New Cyclades-Z board.  "
5025                                                 "FPGA not loaded\n");
5026                         }
5027 #endif
5028                         /* The following clears the firmware id word.  This
5029                            ensures that the driver will not attempt to talk to
5030                            the board until it has been properly initialized.
5031                          */
5032                         PAUSE;
5033                         if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
5034                                 cy_writel(cy_pci_addr2 + ID_ADDRESS, 0L);
5035
5036                         /* This must be a Cyclades-8Zo/PCI.  The extendable
5037                            version will have a different device_id and will
5038                            be allocated its maximum number of ports. */
5039                         cy_pci_nchan = 8;
5040
5041                         if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
5042                                 printk("Cyclades-8Zo/PCI found at 0x%lx but"
5043                                         "no channels are available.\nChange "
5044                                         "NR_PORTS in cyclades.c and recompile "
5045                                         "kernel.\n", (ulong)cy_pci_phys2);
5046                                 return i;
5047                         }
5048
5049                         /* fill the next cy_card structure available */
5050                         for (j = 0; j < NR_CARDS; j++) {
5051                                 if (cy_card[j].base_addr == 0)
5052                                         break;
5053                         }
5054                         if (j == NR_CARDS) {    /* no more cy_cards available */
5055                                 printk("Cyclades-8Zo/PCI found at 0x%lx but"
5056                                         "no more cards can be used.\nChange "
5057                                         "NR_CARDS in cyclades.c and recompile "
5058                                         "kernel.\n", (ulong)cy_pci_phys2);
5059                                 return i;
5060                         }
5061 #ifdef CONFIG_CYZ_INTR
5062                         /* allocate IRQ only if board has an IRQ */
5063                         if ((cy_pci_irq != 0) && (cy_pci_irq != 255)) {
5064                                 if (request_irq(cy_pci_irq, cyz_interrupt,
5065                                                 IRQF_SHARED, "Cyclades-Z",
5066                                                 &cy_card[j])) {
5067                                         printk("Cyclom-8Zo/PCI found at 0x%lx "
5068                                                 "but could not allocate "
5069                                                 "IRQ%d.\n", (ulong)cy_pci_phys2,
5070                                                 cy_pci_irq);
5071                                         return i;
5072                                 }
5073                         }
5074 #endif                          /* CONFIG_CYZ_INTR */
5075
5076                         /* set cy_card */
5077                         cy_card[j].base_phys = cy_pci_phys2;
5078                         cy_card[j].ctl_phys = cy_pci_phys0;
5079                         cy_card[j].base_addr = cy_pci_addr2;
5080                         cy_card[j].ctl_addr = cy_pci_addr0;
5081                         cy_card[j].irq = (int)cy_pci_irq;
5082                         cy_card[j].bus_index = 1;
5083                         cy_card[j].first_line = cy_next_channel;
5084                         cy_card[j].num_chips = -1;
5085                         cy_card[j].pdev = pdev;
5086
5087                         /* print message */
5088 #ifdef CONFIG_CYZ_INTR
5089                         /* don't report IRQ if board is no IRQ */
5090                         if ((cy_pci_irq != 0) && (cy_pci_irq != 255))
5091                                 printk("Cyclades-8Zo/PCI #%d: 0x%lx-0x%lx, "
5092                                         "IRQ%d, ", j + 1, (ulong)cy_pci_phys2,
5093                                         (ulong) (cy_pci_phys2 + CyPCI_Zwin - 1),
5094                                         (int)cy_pci_irq);
5095                         else
5096 #endif                          /* CONFIG_CYZ_INTR */
5097                                 printk("Cyclades-8Zo/PCI #%d: 0x%lx-0x%lx, ",
5098                                         j + 1, (ulong)cy_pci_phys2,
5099                                         (ulong)(cy_pci_phys2 + CyPCI_Zwin - 1));
5100
5101                         printk("%d channels starting from port %d.\n",
5102                                         cy_pci_nchan, cy_next_channel);
5103                         cy_next_channel += cy_pci_nchan;
5104                 }
5105         }
5106
5107         for (; ZeIndex != 0 && i < NR_CARDS; i++) {
5108                 cy_pci_phys0 = Ze_phys0[0];
5109                 cy_pci_phys2 = Ze_phys2[0];
5110                 cy_pci_addr0 = Ze_addr0[0];
5111                 cy_pci_addr2 = Ze_addr2[0];
5112                 cy_pci_irq = Ze_irq[0];
5113                 pdev = Ze_pdev[0];
5114                 for (j = 0; j < ZeIndex - 1; j++) {
5115                         Ze_phys0[j] = Ze_phys0[j + 1];
5116                         Ze_phys2[j] = Ze_phys2[j + 1];
5117                         Ze_addr0[j] = Ze_addr0[j + 1];
5118                         Ze_addr2[j] = Ze_addr2[j + 1];
5119                         Ze_irq[j] = Ze_irq[j + 1];
5120                         Ze_pdev[j] = Ze_pdev[j + 1];
5121                 }
5122                 ZeIndex--;
5123                 mailbox = (uclong)cy_readl(&((struct RUNTIME_9060 __iomem *)
5124                                                 cy_pci_addr0)->mail_box_0);
5125 #ifdef CY_PCI_DEBUG
5126                 printk("Cyclades-Z/PCI: relocate winaddr=0x%lx ctladdr=0x%lx\n",
5127                         (ulong)cy_pci_addr2, (ulong)cy_pci_addr0);
5128                 printk("Cyclades-Z/PCI: New Cyclades-Z board.  FPGA not "
5129                                 "loaded\n");
5130 #endif
5131                 PAUSE;
5132                 /* This must be the new Cyclades-Ze/PCI. */
5133                 cy_pci_nchan = ZE_V1_NPORTS;
5134
5135                 if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
5136                         printk("Cyclades-Ze/PCI found at 0x%lx but no channels "
5137                                 "are available.\nChange NR_PORTS in cyclades.c "
5138                                 "and recompile kernel.\n",
5139                                 (ulong) cy_pci_phys2);
5140                         return i;
5141                 }
5142
5143                 /* fill the next cy_card structure available */
5144                 for