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