3 #undef Z_EXT_CHARS_IN_BUFFER
6 * linux/drivers/char/cyclades.c
8 * This file contains the driver for the Cyclades async multiport
11 * Initially written by Randolph Bentson <bentson@grieg.seaslug.org>.
12 * Modified and maintained by Marcio Saito <marcio@cyclades.com>.
13 * Currently maintained by Cyclades team <async@cyclades.com>.
15 * For Technical support and installation problems, please send e-mail
16 * to support@cyclades.com.
18 * Much of the design and some of the code came from serial.c
19 * which was copyright (C) 1991, 1992 Linus Torvalds. It was
20 * extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92,
21 * and then fixed as suggested by Michael K. Johnson 12/12/92.
23 * This version supports shared IRQ's (only for PCI boards).
25 * $Log: cyclades.c,v $
26 * Prevent users from opening non-existing Z ports.
28 * Revision 2.3.2.8 2000/07/06 18:14:16 ivan
29 * Fixed the PCI detection function to work properly on Alpha systems.
30 * Implemented support for TIOCSERGETLSR ioctl.
31 * Implemented full support for non-standard baud rates.
33 * Revision 2.3.2.7 2000/06/01 18:26:34 ivan
34 * Request PLX I/O region, although driver doesn't use it, to avoid
35 * problems with other drivers accessing it.
36 * Removed count for on-board buffer characters in cy_chars_in_buffer
39 * Revision 2.3.2.6 2000/05/05 13:56:05 ivan
40 * Driver now reports physical instead of virtual memory addresses.
41 * Masks were added to some Cyclades-Z read accesses.
42 * Implemented workaround for PLX9050 bug that would cause a system lockup
43 * in certain systems, depending on the MMIO addresses allocated to the
45 * Changed the Tx interrupt programming in the CD1400 chips to boost up
46 * performance (Cyclom-Y only).
47 * Code is now compliant with the new module interface (module_[init|exit]).
48 * Make use of the PCI helper functions to access PCI resources.
49 * Did some code "housekeeping".
51 * Revision 2.3.2.5 2000/01/19 14:35:33 ivan
52 * Fixed bug in cy_set_termios on CRTSCTS flag turnoff.
54 * Revision 2.3.2.4 2000/01/17 09:19:40 ivan
55 * Fixed SMP locking in Cyclom-Y interrupt handler.
57 * Revision 2.3.2.3 1999/12/28 12:11:39 ivan
58 * Added a new cyclades_card field called nports to allow the driver to
59 * know the exact number of ports found by the Z firmware after its load;
60 * RX buffer contention prevention logic on interrupt op mode revisited
62 * Revisited printk's for Z debug;
63 * Driver now makes sure that the constant SERIAL_XMIT_SIZE is defined;
65 * Revision 2.3.2.2 1999/10/01 11:27:43 ivan
66 * Fixed bug in cyz_poll that would make all ports but port 0
67 * unable to transmit/receive data (Cyclades-Z only);
68 * Implemented logic to prevent the RX buffer from being stuck with data
69 * due to a driver / firmware race condition in interrupt op mode
71 * Fixed bug in block_til_ready logic that would lead to a system crash;
72 * Revisited cy_close spinlock usage;
74 * Revision 2.3.2.1 1999/09/28 11:01:22 ivan
75 * Revisited CONFIG_PCI conditional compilation for PCI board support;
76 * Implemented TIOCGICOUNT and TIOCMIWAIT ioctl support;
77 * _Major_ cleanup on the Cyclades-Z interrupt support code / logic;
78 * Removed CTS handling from the driver -- this is now completely handled
79 * by the firmware (Cyclades-Z only);
80 * Flush RX on-board buffers on a port open (Cyclades-Z only);
81 * Fixed handling of ASYNC_SPD_* TTY flags;
82 * Module unload now unmaps all memory area allocated by ioremap;
84 * Revision 2.3.1.1 1999/07/15 16:45:53 ivan
85 * Removed CY_PROC conditional compilation;
86 * Implemented SMP-awareness for the driver;
87 * Implemented a new ISA IRQ autoprobe that uses the irq_probe_[on|off]
89 * The driver now accepts memory addresses (maddr=0xMMMMM) and IRQs
90 * (irq=NN) as parameters (only for ISA boards);
91 * Fixed bug in set_line_char that would prevent the Cyclades-Z
92 * ports from being configured at speeds above 115.2Kbps;
93 * Fixed bug in cy_set_termios that would prevent XON/XOFF flow control
94 * switching from working properly;
95 * The driver now only prints IRQ info for the Cyclades-Z if it's
96 * configured to work in interrupt mode;
98 * Revision 2.2.2.3 1999/06/28 11:13:29 ivan
99 * Added support for interrupt mode operation for the Z cards;
100 * Removed the driver inactivity control for the Z;
101 * Added a missing MOD_DEC_USE_COUNT in the cy_open function for when
102 * the Z firmware is not loaded yet;
103 * Replaced the "manual" Z Tx flush buffer by a call to a FW command of
104 * same functionality;
105 * Implemented workaround for IRQ setting loss on the PCI configuration
106 * registers after a PCI bridge EEPROM reload (affects PLX9060 only);
108 * Revision 2.2.2.2 1999/05/14 17:18:15 ivan
109 * /proc entry location changed to /proc/tty/driver/cyclades;
110 * Added support to shared IRQ's (only for PCI boards);
111 * Added support for Cobalt Qube2 systems;
112 * IRQ [de]allocation scheme revisited;
113 * BREAK implementation changed in order to make use of the 'break_ctl'
115 * Fixed typo in TTY structure field 'driver_name';
116 * Included a PCI bridge reset and EEPROM reload in the board
117 * initialization code (for both Y and Z series).
119 * Revision 2.2.2.1 1999/04/08 16:17:43 ivan
120 * Fixed a bug in cy_wait_until_sent that was preventing the port to be
121 * closed properly after a SIGINT;
122 * Module usage counter scheme revisited;
123 * Added support to the upcoming Y PCI boards (i.e., support to additional
126 * Revision 2.2.1.10 1999/01/20 16:14:29 ivan
127 * Removed all unnecessary page-alignement operations in ioremap calls
128 * (ioremap is currently safe for these operations).
130 * Revision 2.2.1.9 1998/12/30 18:18:30 ivan
131 * Changed access to PLX PCI bridge registers from I/O to MMIO, in
132 * order to make PLX9050-based boards work with certain motherboards.
134 * Revision 2.2.1.8 1998/11/13 12:46:20 ivan
135 * cy_close function now resets (correctly) the tty->closing flag;
136 * JIFFIES_DIFF macro fixed.
138 * Revision 2.2.1.7 1998/09/03 12:07:28 ivan
139 * Fixed bug in cy_close function, which was not informing HW of
140 * which port should have the reception disabled before doing so;
141 * fixed Cyclom-8YoP hardware detection bug.
143 * Revision 2.2.1.6 1998/08/20 17:15:39 ivan
144 * Fixed bug in cy_close function, which causes malfunction
145 * of one of the first 4 ports when a higher port is closed
148 * Revision 2.2.1.5 1998/08/10 18:10:28 ivan
149 * Fixed Cyclom-4Yo hardware detection bug.
151 * Revision 2.2.1.4 1998/08/04 11:02:50 ivan
152 * /proc/cyclades implementation with great collaboration of
153 * Marc Lewis <marc@blarg.net>;
154 * cyy_interrupt was changed to avoid occurrence of kernel oopses
155 * during PPP operation.
157 * Revision 2.2.1.3 1998/06/01 12:09:10 ivan
158 * General code review in order to comply with 2.1 kernel standards;
159 * data loss prevention for slow devices revisited (cy_wait_until_sent
161 * removed conditional compilation for new/old PCI structure support
162 * (now the driver only supports the new PCI structure).
164 * Revision 2.2.1.1 1998/03/19 16:43:12 ivan
165 * added conditional compilation for new/old PCI structure support;
166 * removed kernel series (2.0.x / 2.1.x) conditional compilation.
168 * Revision 2.1.1.3 1998/03/16 18:01:12 ivan
169 * cleaned up the data loss fix;
170 * fixed XON/XOFF handling once more (Cyclades-Z);
171 * general review of the driver routines;
172 * introduction of a mechanism to prevent data loss with slow
173 * printers, by forcing a delay before closing the port.
175 * Revision 2.1.1.2 1998/02/17 16:50:00 ivan
176 * fixed detection/handling of new CD1400 in Ye boards;
177 * fixed XON/XOFF handling (Cyclades-Z);
178 * fixed data loss caused by a premature port close;
179 * introduction of a flag that holds the CD1400 version ID per port
180 * (used by the CYGETCD1400VER new ioctl).
182 * Revision 2.1.1.1 1997/12/03 17:31:19 ivan
183 * Code review for the module cleanup routine;
184 * fixed RTS and DTR status report for new CD1400's in get_modem_info;
185 * includes anonymous changes regarding signal_pending.
187 * Revision 2.1 1997/11/01 17:42:41 ivan
188 * Changes in the driver to support Alpha systems (except 8Zo V_1);
189 * BREAK fix for the Cyclades-Z boards;
190 * driver inactivity control by FW implemented;
191 * introduction of flag that allows driver to take advantage of
192 * a special CD1400 feature related to HW flow control;
193 * added support for the CD1400 rev. J (Cyclom-Y boards);
194 * introduction of ioctls to:
195 * - control the rtsdtr_inv flag (Cyclom-Y);
196 * - control the rflow flag (Cyclom-Y);
197 * - adjust the polling interval (Cyclades-Z);
199 * Revision 1.36.4.33 1997/06/27 19:00:00 ivan
200 * Fixes related to kernel version conditional
203 * Revision 1.36.4.32 1997/06/14 19:30:00 ivan
204 * Compatibility issues between kernels 2.0.x and
205 * 2.1.x (mainly related to clear_bit function).
207 * Revision 1.36.4.31 1997/06/03 15:30:00 ivan
208 * Changes to define the memory window according to the
211 * Revision 1.36.4.30 1997/05/16 15:30:00 daniel
212 * Changes to support new cycladesZ boards.
214 * Revision 1.36.4.29 1997/05/12 11:30:00 daniel
215 * Merge of Bentson's and Daniel's version 1.36.4.28.
216 * Corrects bug in cy_detect_pci: check if there are more
217 * ports than the number of static structs allocated.
218 * Warning message during initialization if this driver is
219 * used with the new generation of cycladesZ boards. Those
220 * will be supported only in next release of the driver.
221 * Corrects bug in cy_detect_pci and cy_detect_isa that
222 * returned wrong number of VALID boards, when a cyclomY
223 * was found with no serial modules connected.
224 * Changes to use current (2.1.x) kernel subroutine names
225 * and created macros for compilation with 2.0.x kernel,
226 * instead of the other way around.
228 * Revision 1.36.4.28 1997/05/?? ??:00:00 bentson
229 * Change queue_task_irq_off to queue_task_irq.
230 * The inline function queue_task_irq_off (tqueue.h)
231 * was removed from latest releases of 2.1.x kernel.
232 * Use of macro __init to mark the initialization
233 * routines, so memory can be reused.
234 * Also incorporate implementation of critical region
235 * in function cleanup_module() created by anonymous
238 * Revision 1.36.4.28 1997/04/25 16:00:00 daniel
239 * Change to support new firmware that solves DCD problem:
240 * application could fail to receive SIGHUP signal when DCD
243 * Revision 1.36.4.27 1997/03/26 10:30:00 daniel
244 * Changed for support linux versions 2.1.X.
245 * Backward compatible with linux versions 2.0.X.
246 * Corrected illegal use of filler field in
248 * Deleted some debug messages.
250 * Revision 1.36.4.26 1997/02/27 12:00:00 daniel
251 * Included check for NULL tty pointer in cyz_poll.
253 * Revision 1.36.4.25 1997/02/26 16:28:30 bentson
254 * Bill Foster at Blarg! Online services noticed that
255 * some of the switch elements of -Z modem control
256 * lacked a closing "break;"
258 * Revision 1.36.4.24 1997/02/24 11:00:00 daniel
259 * Changed low water threshold for buffer xmit_buf
261 * Revision 1.36.4.23 1996/12/02 21:50:16 bentson
262 * Marcio provided fix to modem status fetch for -Z
264 * Revision 1.36.4.22 1996/10/28 22:41:17 bentson
265 * improve mapping of -Z control page (thanks to Steve
266 * Price <stevep@fa.tdktca.com> for help on this)
268 * Revision 1.36.4.21 1996/09/10 17:00:10 bentson
269 * shift from CPU-bound to memcopy in cyz_polling operation
271 * Revision 1.36.4.20 1996/09/09 18:30:32 Bentson
272 * Added support to set and report higher speeds.
274 * Revision 1.36.4.19c 1996/08/09 10:00:00 Marcio Saito
275 * Some fixes in the HW flow control for the BETA release.
276 * Don't try to register the IRQ.
278 * Revision 1.36.4.19 1996/08/08 16:23:18 Bentson
279 * make sure "cyc" appears in all kernel messages; all soft interrupts
280 * handled by same routine; recognize out-of-band reception; comment
281 * out some diagnostic messages; leave RTS/CTS flow control to hardware;
282 * fix race condition in -Z buffer management; only -Y needs to explicitly
283 * flush chars; tidy up some startup messages;
285 * Revision 1.36.4.18 1996/07/25 18:57:31 bentson
286 * shift MOD_INC_USE_COUNT location to match
287 * serial.c; purge some diagnostic messages;
289 * Revision 1.36.4.17 1996/07/25 18:01:08 bentson
290 * enable modem status messages and fetch & process them; note
291 * time of last activity type for each port; set_line_char now
292 * supports more than line 0 and treats 0 baud correctly;
293 * get_modem_info senses rs_status;
295 * Revision 1.36.4.16 1996/07/20 08:43:15 bentson
296 * barely works--now's time to turn on
297 * more features 'til it breaks
299 * Revision 1.36.4.15 1996/07/19 22:30:06 bentson
300 * check more -Z board status; shorten boot message
302 * Revision 1.36.4.14 1996/07/19 22:20:37 bentson
303 * fix reference to ch_ctrl in startup; verify return
304 * values from cyz_issue_cmd and cyz_update_channel;
305 * more stuff to get modem control correct;
307 * Revision 1.36.4.13 1996/07/11 19:53:33 bentson
308 * more -Z stuff folded in; re-order changes to put -Z stuff
309 * after -Y stuff (to make changes clearer)
311 * Revision 1.36.4.12 1996/07/11 15:40:55 bentson
312 * Add code to poll Cyclades-Z. Add code to get & set RS-232 control.
313 * Add code to send break. Clear firmware ID word at startup (so
314 * that other code won't talk to inactive board).
316 * Revision 1.36.4.11 1996/07/09 05:28:29 bentson
317 * add code for -Z in set_line_char
319 * Revision 1.36.4.10 1996/07/08 19:28:37 bentson
320 * fold more -Z stuff (or in some cases, error messages)
321 * into driver; add text to "don't know what to do" messages.
323 * Revision 1.36.4.9 1996/07/08 18:38:38 bentson
324 * moved compile-time flags near top of file; cosmetic changes
325 * to narrow text (to allow 2-up printing); changed many declarations
326 * to "static" to limit external symbols; shuffled code order to
327 * coalesce -Y and -Z specific code, also to put internal functions
328 * in order of tty_driver structure; added code to recognize -Z
329 * ports (and for moment, do nothing or report error); add cy_startup
330 * to parse boot command line for extra base addresses for ISA probes;
332 * Revision 1.36.4.8 1996/06/25 17:40:19 bentson
333 * reorder some code, fix types of some vars (int vs. long),
334 * add cy_setup to support user declared ISA addresses
336 * Revision 1.36.4.7 1996/06/21 23:06:18 bentson
337 * dump ioctl based firmware load (it's now a user level
338 * program); ensure uninitialzed ports cannot be used
340 * Revision 1.36.4.6 1996/06/20 23:17:19 bentson
341 * rename vars and restructure some code
343 * Revision 1.36.4.5 1996/06/14 15:09:44 bentson
344 * get right status back after boot load
346 * Revision 1.36.4.4 1996/06/13 19:51:44 bentson
347 * successfully loads firmware
349 * Revision 1.36.4.3 1996/06/13 06:08:33 bentson
350 * add more of the code for the boot/load ioctls
352 * Revision 1.36.4.2 1996/06/11 21:00:51 bentson
353 * start to add Z functionality--starting with ioctl
354 * for loading firmware
356 * Revision 1.36.4.1 1996/06/10 18:03:02 bentson
357 * added code to recognize Z/PCI card at initialization; report
358 * presence, but card is not initialized (because firmware needs
361 * Revision 1.36.3.8 1996/06/07 16:29:00 bentson
362 * starting minor number at zero; added missing verify_area
363 * as noted by Heiko Eissfeldt <heiko@colossus.escape.de>
365 * Revision 1.36.3.7 1996/04/19 21:06:18 bentson
366 * remove unneeded boot message & fix CLOCAL hardware flow
367 * control (Miquel van Smoorenburg <miquels@Q.cistron.nl>);
368 * remove unused diagnostic statements; minor 0 is first;
370 * Revision 1.36.3.6 1996/03/13 13:21:17 marcio
371 * The kernel function vremap (available only in later 1.3.xx kernels)
372 * allows the access to memory addresses above the RAM. This revision
373 * of the driver supports PCI boards below 1Mb (device id 0x100) and
374 * above 1Mb (device id 0x101).
376 * Revision 1.36.3.5 1996/03/07 15:20:17 bentson
377 * Some global changes to interrupt handling spilled into
378 * this driver--mostly unused arguments in system function
379 * calls. Also added change by Marcio Saito which should
380 * reduce lost interrupts at startup by fast processors.
382 * Revision 1.36.3.4 1995/11/13 20:45:10 bentson
383 * Changes by Corey Minyard <minyard@wf-rch.cirr.com> distributed
384 * in 1.3.41 kernel to remove a possible race condition, extend
385 * some error messages, and let the driver run as a loadable module
386 * Change by Alan Wendt <alan@ez0.ezlink.com> to remove a
387 * possible race condition.
388 * Change by Marcio Saito <marcio@cyclades.com> to fix PCI addressing.
390 * Revision 1.36.3.3 1995/11/13 19:44:48 bentson
391 * Changes by Linus Torvalds in 1.3.33 kernel distribution
392 * required due to reordering of driver initialization.
393 * Drivers are now initialized *after* memory management.
395 * Revision 1.36.3.2 1995/09/08 22:07:14 bentson
396 * remove printk from ISR; fix typo
398 * Revision 1.36.3.1 1995/09/01 12:00:42 marcio
399 * Minor fixes in the PCI board support. PCI function calls in
400 * conditional compilation (CONFIG_PCI). Thanks to Jim Duncan
401 * <duncan@okay.com>. "bad serial count" message removed.
403 * Revision 1.36.3 1995/08/22 09:19:42 marcio
404 * Cyclom-Y/PCI support added. Changes in the cy_init routine and
405 * board initialization. Changes in the boot messages. The driver
406 * supports up to 4 boards and 64 ports by default.
408 * Revision 1.36.1.4 1995/03/29 06:14:14 bentson
409 * disambiguate between Cyclom-16Y and Cyclom-32Ye;
411 * Revision 1.36.1.3 1995/03/23 22:15:35 bentson
412 * add missing break in modem control block in ioctl switch statement
413 * (discovered by Michael Edward Chastain <mec@jobe.shell.portal.com>);
415 * Revision 1.36.1.2 1995/03/22 19:16:22 bentson
416 * make sure CTS flow control is set as soon as possible (thanks
417 * to note from David Lambert <lambert@chesapeake.rps.slb.com>);
419 * Revision 1.36.1.1 1995/03/13 15:44:43 bentson
420 * initialize defaults for receive threshold and stale data timeout;
423 * Revision 1.36 1995/03/10 23:33:53 bentson
424 * added support of chips 4-7 in 32 port Cyclom-Ye;
425 * fix cy_interrupt pointer dereference problem
426 * (Joe Portman <baron@aa.net>);
427 * give better error response if open is attempted on non-existent port
428 * (Zachariah Vaum <jchryslr@netcom.com>);
429 * correct command timeout (Kenneth Lerman <lerman@@seltd.newnet.com>);
430 * conditional compilation for -16Y on systems with fast, noisy bus;
431 * comment out diagnostic print function;
432 * cleaned up table of base addresses;
433 * set receiver time-out period register to correct value,
434 * set receive threshold to better default values,
435 * set chip timer to more accurate 200 Hz ticking,
436 * add code to monitor and modify receive parameters
437 * (Rik Faith <faith@cs.unc.edu> Nick Simicich
438 * <njs@scifi.emi.net>);
440 * Revision 1.35 1994/12/16 13:54:18 steffen
441 * additional patch by Marcio Saito for board detection
442 * Accidently left out in 1.34
444 * Revision 1.34 1994/12/10 12:37:12 steffen
445 * This is the corrected version as suggested by Marcio Saito
447 * Revision 1.33 1994/12/01 22:41:18 bentson
448 * add hooks to support more high speeds directly; add tytso
449 * patch regarding CLOCAL wakeups
451 * Revision 1.32 1994/11/23 19:50:04 bentson
452 * allow direct kernel control of higher signalling rates;
453 * look for cards at additional locations
455 * Revision 1.31 1994/11/16 04:33:28 bentson
456 * ANOTHER fix from Corey Minyard, minyard@wf-rch.cirr.com--
457 * a problem in chars_in_buffer has been resolved by some
458 * small changes; this should yield smoother output
460 * Revision 1.30 1994/11/16 04:28:05 bentson
461 * Fix from Corey Minyard, Internet: minyard@metronet.com,
462 * UUCP: minyard@wf-rch.cirr.com, WORK: minyardbnr.ca, to
463 * cy_hangup that appears to clear up much (all?) of the
464 * DTR glitches; also he's added/cleaned-up diagnostic messages
466 * Revision 1.29 1994/11/16 04:16:07 bentson
467 * add change proposed by Ralph Sims, ralphs@halcyon.com, to
468 * operate higher speeds in same way as other serial ports;
469 * add more serial ports (for up to two 16-port muxes).
471 * Revision 1.28 1994/11/04 00:13:16 root
472 * turn off diagnostic messages
474 * Revision 1.27 1994/11/03 23:46:37 root
475 * bunch of changes to bring driver into greater conformance
476 * with the serial.c driver (looking for missed fixes)
478 * Revision 1.26 1994/11/03 22:40:36 root
479 * automatic interrupt probing fixed.
481 * Revision 1.25 1994/11/03 20:17:02 root
482 * start to implement auto-irq
484 * Revision 1.24 1994/11/03 18:01:55 root
485 * still working on modem signals--trying not to drop DTR
486 * during the getty/login processes
488 * Revision 1.23 1994/11/03 17:51:36 root
489 * extend baud rate support; set receive threshold as function
490 * of baud rate; fix some problems with RTS/CTS;
492 * Revision 1.22 1994/11/02 18:05:35 root
493 * changed arguments to udelay to type long to get
494 * delays to be of correct duration
496 * Revision 1.21 1994/11/02 17:37:30 root
497 * employ udelay (after calibrating loops_per_second earlier
498 * in init/main.c) instead of using home-grown delay routines
500 * Revision 1.20 1994/11/02 03:11:38 root
501 * cy_chars_in_buffer forces a return value of 0 to let
502 * login work (don't know why it does); some functions
503 * that were returning EFAULT, now executes the code;
504 * more work on deciding when to disable xmit interrupts;
506 * Revision 1.19 1994/11/01 20:10:14 root
507 * define routine to start transmission interrupts (by enabling
508 * transmit interrupts); directly enable/disable modem interrupts;
510 * Revision 1.18 1994/11/01 18:40:45 bentson
511 * Don't always enable transmit interrupts in startup; interrupt on
512 * TxMpty instead of TxRdy to help characters get out before shutdown;
513 * restructure xmit interrupt to check for chars first and quit if
514 * none are ready to go; modem status (MXVRx) is upright, _not_ inverted
517 * Revision 1.17 1994/10/30 04:39:45 bentson
518 * rename serial_driver and callout_driver to cy_serial_driver and
519 * cy_callout_driver to avoid linkage interference; initialize
520 * info->type to PORT_CIRRUS; ruggedize paranoia test; elide ->port
521 * from cyclades_port structure; add paranoia check to cy_close;
523 * Revision 1.16 1994/10/30 01:14:33 bentson
524 * change major numbers; add some _early_ return statements;
526 * Revision 1.15 1994/10/29 06:43:15 bentson
527 * final tidying up for clean compile; enable some error reporting
529 * Revision 1.14 1994/10/28 20:30:22 Bentson
530 * lots of changes to drag the driver towards the new tty_io
531 * structures and operation. not expected to work, but may
534 * Revision 1.13 1994/07/21 23:08:57 Bentson
535 * add some diagnostic cruft; support 24 lines (for testing
536 * both -8Y and -16Y cards; be more thorough in servicing all
537 * chips during interrupt; add "volatile" a few places to
538 * circumvent compiler optimizations; fix base & offset
539 * computations in block_til_ready (was causing chip 0 to
542 * Revision 1.12 1994/07/19 16:42:11 Bentson
543 * add some hackery for kernel version 1.1.8; expand
544 * error messages; refine timing for delay loops and
545 * declare loop params volatile
547 * Revision 1.11 1994/06/11 21:53:10 bentson
548 * get use of save_car right in transmit interrupt service
550 * Revision 1.10.1.1 1994/06/11 21:31:18 bentson
551 * add some diagnostic printing; try to fix save_car stuff
553 * Revision 1.10 1994/06/11 20:36:08 bentson
554 * clean up compiler warnings
556 * Revision 1.9 1994/06/11 19:42:46 bentson
557 * added a bunch of code to support modem signalling
559 * Revision 1.8 1994/06/11 17:57:07 bentson
560 * recognize break & parity error
562 * Revision 1.7 1994/06/05 05:51:34 bentson
563 * Reorder baud table to be monotonic; add cli to CP; discard
564 * incoming characters and status if the line isn't open; start to
565 * fold code into cy_throttle; start to port get_serial_info,
566 * set_serial_info, get_modem_info, set_modem_info, and send_break
567 * from serial.c; expand cy_ioctl; relocate and expand config_setup;
568 * get flow control characters from tty struct; invalidate ports w/o
571 * Revision 1.6 1994/05/31 18:42:21 bentson
572 * add a loop-breaker in the interrupt service routine;
573 * note when port is initialized so that it can be shut
574 * down under the right conditions; receive works without
577 * Revision 1.5 1994/05/30 00:55:02 bentson
578 * transmit works without obvious errors
580 * Revision 1.4 1994/05/27 18:46:27 bentson
581 * incorporated more code from lib_y.c; can now print short
582 * strings under interrupt control to port zero; seems to
583 * select ports/channels/lines correctly
585 * Revision 1.3 1994/05/25 22:12:44 bentson
586 * shifting from multi-port on a card to proper multiplexor
587 * data structures; added skeletons of most routines
589 * Revision 1.2 1994/05/19 13:21:43 bentson
590 * start to crib from other sources
594 #define CY_VERSION "2.4"
596 /* If you need to install more boards than NR_CARDS, change the constant
597 in the definition below. No other change is necessary to support up to
598 eight boards. Beyond that you'll have to extend cy_isa_addresses. */
603 If the total number of ports is larger than NR_PORTS, change this
604 constant in the definition below. No other change is necessary to
605 support more boards/ports. */
609 #define ZE_V1_NPORTS 64
614 #define SERIAL_PARANOIA_CHECK
616 #undef CY_DEBUG_THROTTLE
617 #undef CY_DEBUG_OTHER
619 #undef CY_DEBUG_COUNT
621 #undef CY_DEBUG_WAIT_UNTIL_SENT
622 #undef CY_DEBUG_INTERRUPTS
624 #undef CY_ENABLE_MONITORING
630 #include <linux/module.h>
631 #include <linux/errno.h>
632 #include <linux/signal.h>
633 #include <linux/sched.h>
634 #include <linux/timer.h>
635 #include <linux/interrupt.h>
636 #include <linux/tty.h>
637 #include <linux/tty_flip.h>
638 #include <linux/serial.h>
639 #include <linux/major.h>
640 #include <linux/string.h>
641 #include <linux/fcntl.h>
642 #include <linux/ptrace.h>
643 #include <linux/cyclades.h>
644 #include <linux/mm.h>
645 #include <linux/ioport.h>
646 #include <linux/init.h>
647 #include <linux/delay.h>
648 #include <linux/spinlock.h>
649 #include <linux/bitops.h>
651 #include <asm/system.h>
654 #include <asm/uaccess.h>
656 #include <linux/kernel.h>
657 #include <linux/pci.h>
659 #include <linux/stat.h>
660 #include <linux/proc_fs.h>
662 static void cy_throttle(struct tty_struct *tty);
663 static void cy_send_xchar(struct tty_struct *tty, char ch);
665 #define IS_CYC_Z(card) ((card).num_chips == -1)
667 #define Z_FPGA_CHECK(card) \
668 ((readl(&((struct RUNTIME_9060 __iomem *) \
669 ((card).ctl_addr))->init_ctrl) & (1<<17)) != 0)
671 #define ISZLOADED(card) (((ZO_V1==readl(&((struct RUNTIME_9060 __iomem *) \
672 ((card).ctl_addr))->mail_box_0)) || \
673 Z_FPGA_CHECK(card)) && \
674 (ZFIRM_ID==readl(&((struct FIRM_ID __iomem *) \
675 ((card).base_addr+ID_ADDRESS))->signature)))
677 #ifndef SERIAL_XMIT_SIZE
678 #define SERIAL_XMIT_SIZE (min(PAGE_SIZE, 4096))
680 #define WAKEUP_CHARS 256
682 #define STD_COM_FLAGS (0)
684 static struct tty_driver *cy_serial_driver;
687 /* This is the address lookup table. The driver will probe for
688 Cyclom-Y/ISA boards at all addresses in here. If you want the
689 driver to probe addresses at a different address, add it to
690 this table. If the driver is probing some other board and
691 causing problems, remove the offending address from this table.
692 The cy_setup function extracts additional addresses from the
693 boot options line. The form is "cyclades=address,address..."
696 static unsigned int cy_isa_addresses[] = {
705 0, 0, 0, 0, 0, 0, 0, 0
708 #define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
711 static long maddr[NR_CARDS];
712 static int irq[NR_CARDS];
714 module_param_array(maddr, long, NULL, 0);
715 module_param_array(irq, int, NULL, 0);
718 #endif /* CONFIG_ISA */
720 /* This is the per-card data structure containing address, irq, number of
721 channels, etc. This driver supports a maximum of NR_CARDS cards.
723 static struct cyclades_card cy_card[NR_CARDS];
725 static int cy_next_channel; /* next minor available */
728 * This is used to look up the divisor speeds and the timeouts
729 * We're normally limited to 15 distinct baud rates. The extra
730 * are accessed via settings in info->flags.
731 * 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
732 * 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
736 static int baud_table[] = {
737 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
738 1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
742 static char baud_co_25[] = { /* 25 MHz clock option table */
743 /* value => 00 01 02 03 04 */
744 /* divide by 8 32 128 512 2048 */
745 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
746 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
749 static char baud_bpr_25[] = { /* 25 MHz baud rate period table */
750 0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
751 0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
754 static char baud_co_60[] = { /* 60 MHz clock option table (CD1400 J) */
755 /* value => 00 01 02 03 04 */
756 /* divide by 8 32 128 512 2048 */
757 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
758 0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
762 static char baud_bpr_60[] = { /* 60 MHz baud rate period table (CD1400 J) */
763 0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62,
764 0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32,
768 static char baud_cor3[] = { /* receive threshold */
769 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
770 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07,
775 * The Cyclades driver implements HW flow control as any serial driver.
776 * The cyclades_port structure member rflow and the vector rflow_thr
777 * allows us to take advantage of a special feature in the CD1400 to avoid
778 * data loss even when the system interrupt latency is too high. These flags
779 * are to be used only with very special applications. Setting these flags
780 * requires the use of a special cable (DTR and RTS reversed). In the new
781 * CD1400-based boards (rev. 6.00 or later), there is no need for special
785 static char rflow_thr[] = { /* rflow threshold */
786 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
787 0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
791 /* The Cyclom-Ye has placed the sequential chips in non-sequential
792 * address order. This look-up table overcomes that problem.
794 static int cy_chip_offset[] = { 0x0000,
804 /* PCI related definitions */
807 static struct pci_device_id cy_pci_dev_id[] __devinitdata = {
808 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo) }, /* PCI < 1Mb */
809 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Hi) }, /* PCI > 1Mb */
810 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Lo) }, /* 4Y PCI < 1Mb */
811 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Hi) }, /* 4Y PCI > 1Mb */
812 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Lo) }, /* 8Y PCI < 1Mb */
813 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Hi) }, /* 8Y PCI > 1Mb */
814 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Lo) }, /* Z PCI < 1Mb */
815 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Hi) }, /* Z PCI > 1Mb */
816 { } /* end of table */
818 MODULE_DEVICE_TABLE(pci, cy_pci_dev_id);
821 static void cy_start(struct tty_struct *);
822 static void set_line_char(struct cyclades_port *);
823 static int cyz_issue_cmd(struct cyclades_card *, __u32, __u8, __u32);
825 static unsigned detect_isa_irq(void __iomem *);
826 #endif /* CONFIG_ISA */
828 static int cyclades_get_proc_info(char *, char **, off_t, int, int *, void *);
830 #ifndef CONFIG_CYZ_INTR
831 static void cyz_poll(unsigned long);
833 /* The Cyclades-Z polling cycle is defined by this variable */
834 static long cyz_polling_cycle = CZ_DEF_POLL;
836 static DEFINE_TIMER(cyz_timerlist, cyz_poll, 0, 0);
838 #else /* CONFIG_CYZ_INTR */
839 static void cyz_rx_restart(unsigned long);
840 static struct timer_list cyz_rx_full_timer[NR_PORTS];
841 #endif /* CONFIG_CYZ_INTR */
843 static inline int serial_paranoia_check(struct cyclades_port *info,
844 char *name, const char *routine)
846 #ifdef SERIAL_PARANOIA_CHECK
848 printk(KERN_WARNING "cyc Warning: null cyclades_port for (%s) "
849 "in %s\n", name, routine);
853 if (info->magic != CYCLADES_MAGIC) {
854 printk(KERN_WARNING "cyc Warning: bad magic number for serial "
855 "struct (%s) in %s\n", name, routine);
860 } /* serial_paranoia_check */
863 * This routine is used by the interrupt handler to schedule
864 * processing in the software interrupt portion of the driver
865 * (also known as the "bottom half"). This can be called any
866 * number of times for any channel without harm.
868 static inline void cy_sched_event(struct cyclades_port *info, int event)
870 info->event |= 1 << event; /* remember what kind of event and who */
871 schedule_work(&info->tqueue);
872 } /* cy_sched_event */
875 * This routine is used to handle the "bottom half" processing for the
876 * serial driver, known also the "software interrupt" processing.
877 * This processing is done at the kernel interrupt level, after the
878 * cy#/_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON. This
879 * is where time-consuming activities which can not be done in the
880 * interrupt driver proper are done; the interrupt driver schedules
881 * them using cy_sched_event(), and they get done here.
883 * This is done through one level of indirection--the task queue.
884 * When a hardware interrupt service routine wants service by the
885 * driver's bottom half, it enqueues the appropriate tq_struct (one
886 * per port) to the keventd work queue and sets a request flag
887 * that the work queue be processed.
889 * Although this may seem unwieldy, it gives the system a way to
890 * pass an argument (in this case the pointer to the cyclades_port
891 * structure) to the bottom half of the driver. Previous kernels
892 * had to poll every port to see if that port needed servicing.
895 do_softint(struct work_struct *work)
897 struct cyclades_port *info =
898 container_of(work, struct cyclades_port, tqueue);
899 struct tty_struct *tty;
905 if (test_and_clear_bit(Cy_EVENT_HANGUP, &info->event)) {
906 tty_hangup(info->tty);
907 wake_up_interruptible(&info->open_wait);
908 info->flags &= ~ASYNC_NORMAL_ACTIVE;
910 if (test_and_clear_bit(Cy_EVENT_OPEN_WAKEUP, &info->event))
911 wake_up_interruptible(&info->open_wait);
912 #ifdef CONFIG_CYZ_INTR
913 if (test_and_clear_bit(Cy_EVENT_Z_RX_FULL, &info->event) &&
914 !timer_pending(&cyz_rx_full_timer[info->line]))
915 mod_timer(&cyz_rx_full_timer[info->line], jiffies + 1);
917 if (test_and_clear_bit(Cy_EVENT_DELTA_WAKEUP, &info->event))
918 wake_up_interruptible(&info->delta_msr_wait);
921 if (test_and_clear_bit(Cy_EVENT_SHUTDOWN_WAKEUP, &info->event))
922 complete(&info->shutdown_wait);
927 /***********************************************************/
928 /********* Start of block of Cyclom-Y specific code ********/
930 /* This routine waits up to 1000 micro-seconds for the previous
931 command to the Cirrus chip to complete and then issues the
932 new command. An error is returned if the previous command
933 didn't finish within the time limit.
935 This function is only called from inside spinlock-protected code.
937 static int cyy_issue_cmd(void __iomem * base_addr, u_char cmd, int index)
941 /* Check to see that the previous command has completed */
942 for (i = 0; i < 100; i++) {
943 if (readb(base_addr + (CyCCR << index)) == 0) {
948 /* if the CCR never cleared, the previous command
949 didn't finish within the "reasonable time" */
953 /* Issue the new command */
954 cy_writeb(base_addr + (CyCCR << index), cmd);
957 } /* cyy_issue_cmd */
960 /* ISA interrupt detection code */
961 static unsigned detect_isa_irq(void __iomem * address)
964 unsigned long irqs, flags;
965 int save_xir, save_car;
966 int index = 0; /* IRQ probing is only for ISA */
968 /* forget possible initially masked and pending IRQ */
969 irq = probe_irq_off(probe_irq_on());
971 /* Clear interrupts on the board first */
972 cy_writeb(address + (Cy_ClrIntr << index), 0);
973 /* Cy_ClrIntr is 0x1800 */
975 irqs = probe_irq_on();
979 /* Enable the Tx interrupts on the CD1400 */
980 local_irq_save(flags);
981 cy_writeb(address + (CyCAR << index), 0);
982 cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
984 cy_writeb(address + (CyCAR << index), 0);
985 cy_writeb(address + (CySRER << index),
986 readb(address + (CySRER << index)) | CyTxRdy);
987 local_irq_restore(flags);
992 /* Check which interrupt is in use */
993 irq = probe_irq_off(irqs);
996 save_xir = (u_char) readb(address + (CyTIR << index));
997 save_car = readb(address + (CyCAR << index));
998 cy_writeb(address + (CyCAR << index), (save_xir & 0x3));
999 cy_writeb(address + (CySRER << index),
1000 readb(address + (CySRER << index)) & ~CyTxRdy);
1001 cy_writeb(address + (CyTIR << index), (save_xir & 0x3f));
1002 cy_writeb(address + (CyCAR << index), (save_car));
1003 cy_writeb(address + (Cy_ClrIntr << index), 0);
1004 /* Cy_ClrIntr is 0x1800 */
1006 return (irq > 0) ? irq : 0;
1008 #endif /* CONFIG_ISA */
1010 static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
1011 void __iomem * base_addr, int status, int index)
1013 struct cyclades_port *info;
1014 struct tty_struct *tty;
1016 int j, len, mdm_change, mdm_status, outch;
1017 int save_xir, channel, save_car;
1020 if (status & CySRReceive) { /* reception interrupt */
1021 #ifdef CY_DEBUG_INTERRUPTS
1022 printk(KERN_DEBUG "cyy_interrupt: rcvd intr, chip %d\n", chip);
1024 /* determine the channel & change to that context */
1025 spin_lock(&cinfo->card_lock);
1026 save_xir = (u_char) readb(base_addr + (CyRIR << index));
1027 channel = (u_short) (save_xir & CyIRChannel);
1028 info = &cinfo->ports[channel + chip * 4];
1029 save_car = readb(base_addr + (CyCAR << index));
1030 cy_writeb(base_addr + (CyCAR << index), save_xir);
1032 /* if there is nowhere to put the data, discard it */
1033 if (info->tty == NULL) {
1034 j = (readb(base_addr + (CyRIVR << index)) &
1036 if (j == CyIVRRxEx) { /* exception */
1037 data = readb(base_addr + (CyRDSR << index));
1038 } else { /* normal character reception */
1039 char_count = readb(base_addr +
1041 while (char_count--) {
1042 data = readb(base_addr +
1046 } else { /* there is an open port for this data */
1048 j = (readb(base_addr + (CyRIVR << index)) &
1050 if (j == CyIVRRxEx) { /* exception */
1051 data = readb(base_addr + (CyRDSR << index));
1053 /* For statistics only */
1056 else if (data & CyFRAME)
1057 info->icount.frame++;
1058 else if (data & CyPARITY)
1059 info->icount.parity++;
1060 else if (data & CyOVERRUN)
1061 info->icount.overrun++;
1063 if (data & info->ignore_status_mask) {
1067 if (tty_buffer_request_room(tty, 1)) {
1068 if (data & info->read_status_mask) {
1069 if (data & CyBREAK) {
1070 tty_insert_flip_char(
1082 } else if (data & CyFRAME) {
1083 tty_insert_flip_char(
1093 } else if (data & CyPARITY) {
1094 /* Pieces of seven... */
1095 tty_insert_flip_char(
1105 } else if (data & CyOVERRUN) {
1106 tty_insert_flip_char(
1110 /* If the flip buffer itself is
1111 overflowing, we still lose
1112 the next incoming character.
1114 tty_insert_flip_char(
1124 /* These two conditions may imply */
1125 /* a normal read should be done. */
1126 /* }else if(data & CyTIMEOUT){ */
1127 /* }else if(data & CySPECHAR){ */
1129 tty_insert_flip_char(
1135 tty_insert_flip_char(tty, 0,
1140 /* there was a software buffer
1141 overrun and nothing could be
1143 info->icount.buf_overrun++;
1144 info->idle_stats.overruns++;
1146 } else { /* normal character reception */
1147 /* load # chars available from the chip */
1148 char_count = readb(base_addr +
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;
1158 len = tty_buffer_request_room(tty, char_count);
1160 data = readb(base_addr +
1162 tty_insert_flip_char(tty, data,
1164 info->idle_stats.recv_bytes++;
1170 info->idle_stats.recv_idle = jiffies;
1172 tty_schedule_flip(tty);
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);
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
1184 #ifdef CY_DEBUG_INTERRUPTS
1185 printk(KERN_DEBUG "cyy_interrupt: xmit intr, chip %d\n", chip);
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);
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)) &
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)) &
1210 /* load the on-chip space for outbound data */
1211 char_count = info->xmit_fifo_size;
1213 if (info->x_char) { /* send special char */
1214 outch = info->x_char;
1215 cy_writeb(base_addr + (CyTDR << index), outch);
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);
1228 if (info->breakoff) {
1229 cy_writeb(base_addr + (CyTDR << index), 0);
1230 cy_writeb(base_addr + (CyTDR << index), 0x83);
1236 while (char_count-- > 0) {
1237 if (!info->xmit_cnt) {
1238 if (readb(base_addr + (CySRER << index)) &
1240 cy_writeb(base_addr + (CySRER << index),
1242 (CySRER << index)) &
1245 cy_writeb(base_addr + (CySRER << index),
1247 (CySRER << index)) &
1248 ~CyTxRdy) | CyTxMpty);
1252 if (info->xmit_buf == NULL) {
1253 cy_writeb(base_addr + (CySRER << index),
1254 readb(base_addr + (CySRER << index)) &
1258 if (info->tty->stopped || info->tty->hw_stopped) {
1259 cy_writeb(base_addr + (CySRER << index),
1260 readb(base_addr + (CySRER << index)) &
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.)
1275 outch = info->xmit_buf[info->xmit_tail];
1278 info->xmit_tail = (info->xmit_tail + 1) &
1279 (SERIAL_XMIT_SIZE - 1);
1280 cy_writeb(base_addr + (CyTDR << index), outch);
1283 if (char_count > 1) {
1285 info->xmit_tail = (info->xmit_tail + 1)&
1286 (SERIAL_XMIT_SIZE - 1);
1287 cy_writeb(base_addr + (CyTDR << index),
1289 cy_writeb(base_addr + (CyTDR << index),
1298 if (info->xmit_cnt < WAKEUP_CHARS) {
1299 cy_sched_event(info, Cy_EVENT_WRITE_WAKEUP);
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);
1308 if (status & CySRModem) { /* modem interrupt */
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);
1318 mdm_change = readb(base_addr + (CyMISR << index));
1319 mdm_status = readb(base_addr + (CyMSVR1 << index));
1322 if (mdm_change & CyANY_DELTA) {
1323 /* For statistics only */
1324 if (mdm_change & CyDCD)
1326 if (mdm_change & CyCTS)
1328 if (mdm_change & CyDSR)
1330 if (mdm_change & CyRI)
1333 cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
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);
1342 cy_sched_event(info, Cy_EVENT_HANGUP);
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
1351 info->tty->hw_stopped = 0;
1352 cy_writeb(base_addr +
1358 cy_sched_event(info,
1359 Cy_EVENT_WRITE_WAKEUP);
1362 if (!(mdm_status & CyCTS)) {
1363 /* cy_stop isn't used
1365 info->tty->hw_stopped = 1;
1366 cy_writeb(base_addr +
1375 /* if (mdm_change & CyDSR) {
1377 if (mdm_change & CyRI) {
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);
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.
1391 static irqreturn_t cyy_interrupt(int irq, void *dev_id)
1394 struct cyclades_card *cinfo = dev_id;
1395 void __iomem *base_addr, *card_base_addr;
1401 if (unlikely(cinfo == NULL)) {
1402 #ifdef CY_DEBUG_INTERRUPTS
1403 printk(KERN_DEBUG "cyy_interrupt: spurious interrupt %d\n",irq);
1405 return IRQ_NONE; /* spurious interrupt */
1408 card_base_addr = cinfo->base_addr;
1409 index = cinfo->bus_index;
1411 /* card was not initialized yet (e.g. DEBUG_SHIRQ) */
1412 if (unlikely(card_base_addr == NULL))
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.
1422 for (chip = 0; chip < cinfo->num_chips; chip++) {
1423 base_addr = cinfo->base_addr +
1424 (cy_chip_offset[chip] << index);
1426 while ((status = readb(base_addr +
1427 (CySVRR << index))) != 0x00) {
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).
1434 if (1000 < too_many++) {
1437 cyy_intr_chip(cinfo, chip, base_addr, status,
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);
1449 } /* cyy_interrupt */
1451 /***********************************************************/
1452 /********* End of block of Cyclom-Y specific code **********/
1453 /******** Start of block of Cyclades-Z specific code *********/
1454 /***********************************************************/
1457 cyz_fetch_msg(struct cyclades_card *cinfo,
1458 __u32 * channel, __u8 * cmd, __u32 * param)
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;
1465 firm_id = cinfo->base_addr + ID_ADDRESS;
1466 if (!ISZLOADED(*cinfo)) {
1469 zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
1470 board_ctrl = &zfw_ctrl->board_ctrl;
1472 loc_doorbell = readl(&((struct RUNTIME_9060 __iomem *)
1473 (cinfo->ctl_addr))->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);
1483 } /* cyz_fetch_msg */
1486 cyz_issue_cmd(struct cyclades_card *cinfo,
1487 __u32 channel, __u8 cmd, __u32 param)
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;
1495 firm_id = cinfo->base_addr + ID_ADDRESS;
1496 if (!ISZLOADED(*cinfo)) {
1499 zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
1500 board_ctrl = &zfw_ctrl->board_ctrl;
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);
1511 cy_writel(&board_ctrl->hcmd_channel, channel);
1512 cy_writel(&board_ctrl->hcmd_param, param);
1513 cy_writel(pci_doorbell, (long)cmd);
1516 } /* cyz_issue_cmd */
1519 cyz_handle_rx(struct cyclades_port *info, struct CH_CTRL __iomem *ch_ctrl,
1520 struct BUF_CTRL __iomem *buf_ctrl)
1522 struct cyclades_card *cinfo = info->card;
1523 struct tty_struct *tty = info->tty;
1531 __u32 rx_put, rx_get, new_rx_get, rx_bufsize, rx_bufaddr;
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;
1540 char_count = rx_put - rx_get + rx_bufsize;
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;
1551 /* flush received characters */
1552 new_rx_get = (new_rx_get + char_count) &
1554 info->rflush_count++;
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 */
1561 len = tty_prepare_flip_string(tty, &buf,
1566 len = min_t(unsigned int, min(len, char_count),
1567 rx_bufsize - new_rx_get);
1569 memcpy_fromio(buf, cinfo->base_addr +
1570 rx_bufaddr + new_rx_get, len);
1572 new_rx_get = (new_rx_get + len) &
1575 info->icount.rx += len;
1576 info->idle_stats.recv_bytes += len;
1579 len = tty_buffer_request_room(tty, char_count);
1581 data = readb(cinfo->base_addr + rx_bufaddr +
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++;
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;
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);
1601 info->idle_stats.recv_idle = jiffies;
1602 tty_schedule_flip(tty);
1605 cy_writel(&buf_ctrl->rx_get, new_rx_get);
1610 cyz_handle_tx(struct cyclades_port *info, struct CH_CTRL __iomem *ch_ctrl,
1611 struct BUF_CTRL __iomem *buf_ctrl)
1613 struct cyclades_card *cinfo = info->card;
1614 struct tty_struct *tty = info->tty;
1620 __u32 tx_put, tx_get, tx_bufsize, tx_bufaddr;
1622 if (info->xmit_cnt <= 0) /* Nothing to transmit */
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;
1632 char_count = tx_get - tx_put - 1;
1639 if (info->x_char) { /* send special char */
1640 data = info->x_char;
1642 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1643 tx_put = (tx_put + 1) & (tx_bufsize - 1);
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,
1655 memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr +
1657 &info->xmit_buf[info->xmit_tail],
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);
1668 while (info->xmit_cnt && char_count) {
1669 data = info->xmit_buf[info->xmit_tail];
1671 info->xmit_tail = (info->xmit_tail + 1) &
1672 (SERIAL_XMIT_SIZE - 1);
1674 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1675 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1681 if (info->xmit_cnt < WAKEUP_CHARS) {
1682 cy_sched_event(info, Cy_EVENT_WRITE_WAKEUP);
1685 cy_writel(&buf_ctrl->tx_put, tx_put);
1689 static void cyz_handle_cmd(struct cyclades_card *cinfo)
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;
1701 __u32 hw_ver, fw_ver;
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))->
1712 while (cyz_fetch_msg(cinfo, &channel, &cmd, ¶m) == 1) {
1715 info = &cinfo->ports[channel];
1716 if ((tty = info->tty) == NULL)
1719 ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
1720 buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
1724 tty_insert_flip_char(tty, 0, TTY_PARITY);
1729 tty_insert_flip_char(tty, 0, TTY_FRAME);
1734 tty_insert_flip_char(tty, 0, TTY_BREAK);
1741 if (info->flags & ASYNC_CHECK_CD) {
1742 if ((fw_ver > 241 ? ((u_long) param) :
1743 readl(&ch_ctrl->rs_status)) &
1745 cy_sched_event(info,
1746 Cy_EVENT_OPEN_WAKEUP);
1748 cy_sched_event(info, Cy_EVENT_HANGUP);
1766 cy_sched_event(info, Cy_EVENT_SHUTDOWN_WAKEUP);
1769 #ifdef CONFIG_CYZ_INTR
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);
1778 cyz_handle_rx(info, ch_ctrl, buf_ctrl);
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);
1788 cyz_handle_tx(info, ch_ctrl, buf_ctrl);
1790 #endif /* CONFIG_CYZ_INTR */
1792 /* should do something with this !!! */
1798 cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
1800 tty_schedule_flip(tty);
1804 #ifdef CONFIG_CYZ_INTR
1805 static irqreturn_t cyz_interrupt(int irq, void *dev_id)
1807 struct cyclades_card *cinfo = dev_id;
1809 if (unlikely(cinfo == NULL)) {
1810 #ifdef CY_DEBUG_INTERRUPTS
1811 printk(KERN_DEBUG "cyz_interrupt: spurious interrupt %d\n",irq);
1813 return IRQ_NONE; /* spurious interrupt */
1816 if (unlikely(!ISZLOADED(*cinfo))) {
1817 #ifdef CY_DEBUG_INTERRUPTS
1818 printk(KERN_DEBUG "cyz_interrupt: board not yet loaded "
1824 /* Handle the interrupts */
1825 cyz_handle_cmd(cinfo);
1828 } /* cyz_interrupt */
1830 static void cyz_rx_restart(unsigned long arg)
1832 struct cyclades_port *info = (struct cyclades_port *)arg;
1833 struct cyclades_card *card = info->card;
1835 __u32 channel = info->line - card->first_line;
1836 unsigned long flags;
1838 spin_lock_irqsave(&card->card_lock, flags);
1839 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK2, 0L);
1841 printk(KERN_ERR "cyc:cyz_rx_restart retval on ttyC%d was %x\n",
1842 info->line, retval);
1844 spin_unlock_irqrestore(&card->card_lock, flags);
1847 #else /* CONFIG_CYZ_INTR */
1849 static void cyz_poll(unsigned long arg)
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;
1862 for (card = 0; card < NR_CARDS; card++) {
1863 cinfo = &cy_card[card];
1865 if (!IS_CYC_Z(*cinfo))
1867 if (!ISZLOADED(*cinfo))
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);
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;
1882 cyz_handle_cmd(cinfo);
1884 for (port = 0; port < cinfo->nports; port++) {
1885 info = &cinfo->ports[port];
1887 ch_ctrl = &(zfw_ctrl->ch_ctrl[port]);
1888 buf_ctrl = &(zfw_ctrl->buf_ctrl[port]);
1890 if (!info->throttle)
1891 cyz_handle_rx(info, ch_ctrl, buf_ctrl);
1892 cyz_handle_tx(info, ch_ctrl, buf_ctrl);
1894 /* poll every 'cyz_polling_cycle' period */
1895 expires = jiffies + cyz_polling_cycle;
1897 mod_timer(&cyz_timerlist, expires);
1900 #endif /* CONFIG_CYZ_INTR */
1902 /********** End of block of Cyclades-Z specific code *********/
1903 /***********************************************************/
1905 /* This is called whenever a port becomes active;
1906 interrupts are enabled and DTR & RTS are turned on.
1908 static int startup(struct cyclades_port *info)
1910 struct cyclades_card *card;
1911 unsigned long flags;
1913 void __iomem *base_addr;
1914 int chip, channel, index;
1918 channel = info->line - card->first_line;
1920 page = get_zeroed_page(GFP_KERNEL);
1924 spin_lock_irqsave(&card->card_lock, flags);
1926 if (info->flags & ASYNC_INITIALIZED) {
1933 set_bit(TTY_IO_ERROR, &info->tty->flags);
1942 info->xmit_buf = (unsigned char *)page;
1944 spin_unlock_irqrestore(&card->card_lock, flags);
1946 set_line_char(info);
1948 if (!IS_CYC_Z(*card)) {
1949 chip = channel >> 2;
1951 index = card->bus_index;
1952 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
1954 #ifdef CY_DEBUG_OPEN
1955 printk(KERN_DEBUG "cyc startup card %d, chip %d, channel %d, "
1957 card, chip, channel, base_addr);
1959 spin_lock_irqsave(&card->card_lock, flags);
1961 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
1963 cy_writeb(base_addr + (CyRTPR << index),
1964 (info->default_timeout ? info->default_timeout : 0x02));
1965 /* 10ms rx timeout */
1967 cyy_issue_cmd(base_addr, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR,
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);
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)));
1981 cy_writeb(base_addr + (CySRER << index),
1982 readb(base_addr + (CySRER << index)) | CyRxData);
1983 info->flags |= ASYNC_INITIALIZED;
1986 clear_bit(TTY_IO_ERROR, &info->tty->flags);
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;
1995 spin_unlock_irqrestore(&card->card_lock, flags);
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;
2004 base_addr = card->base_addr;
2006 firm_id = base_addr + ID_ADDRESS;
2007 if (!ISZLOADED(*card)) {
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;
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);
2020 spin_lock_irqsave(&card->card_lock, flags);
2022 cy_writel(&ch_ctrl[channel].op_mode, C_CH_ENABLE);
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);
2029 cy_writel(&ch_ctrl[channel].intr_enable,
2030 C_IN_IOCTLW | C_IN_MDCD);
2031 #endif /* CONFIG_CYZ_INTR */
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);
2038 cy_writel(&ch_ctrl[channel].intr_enable, C_IN_MDCD);
2039 #endif /* CONFIG_CYZ_INTR */
2042 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
2044 printk(KERN_ERR "cyc:startup(1) retval on ttyC%d was "
2045 "%x\n", info->line, retval);
2048 /* Flush RX buffers before raising DTR and RTS */
2049 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_RX, 0L);
2051 printk(KERN_ERR "cyc:startup(2) retval on ttyC%d was "
2052 "%x\n", info->line, retval);
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 |
2060 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2062 printk(KERN_ERR "cyc:startup(3) retval on ttyC%d was "
2063 "%x\n", info->line, retval);
2066 printk(KERN_DEBUG "cyc:startup raising Z DTR\n");
2069 /* enable send, recv, modem !!! */
2071 info->flags |= ASYNC_INITIALIZED;
2073 clear_bit(TTY_IO_ERROR, &info->tty->flags);
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;
2082 spin_unlock_irqrestore(&card->card_lock, flags);
2085 #ifdef CY_DEBUG_OPEN
2086 printk(KERN_DEBUG "cyc startup done\n");
2091 spin_unlock_irqrestore(&card->card_lock, flags);
2095 static void start_xmit(struct cyclades_port *info)
2097 struct cyclades_card *card;
2098 unsigned long flags;
2099 void __iomem *base_addr;
2100 int chip, channel, index;
2103 channel = info->line - card->first_line;
2104 if (!IS_CYC_Z(*card)) {
2105 chip = channel >> 2;
2107 index = card->bus_index;
2108 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
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);
2116 #ifdef CONFIG_CYZ_INTR
2119 spin_lock_irqsave(&card->card_lock, flags);
2120 retval = cyz_issue_cmd(card, channel, C_CM_INTBACK, 0L);
2122 printk(KERN_ERR "cyc:start_xmit retval on ttyC%d was "
2123 "%x\n", info->line, retval);
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 */
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.
2136 static void shutdown(struct cyclades_port *info)
2138 struct cyclades_card *card;
2139 unsigned long flags;
2140 void __iomem *base_addr;
2141 int chip, channel, index;
2143 if (!(info->flags & ASYNC_INITIALIZED)) {
2148 channel = info->line - card->first_line;
2149 if (!IS_CYC_Z(*card)) {
2150 chip = channel >> 2;
2152 index = card->bus_index;
2153 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
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);
2161 spin_lock_irqsave(&card->card_lock, flags);
2163 /* Clear delta_msr_wait queue to avoid mem leaks. */
2164 wake_up_interruptible(&info->delta_msr_wait);
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);
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);
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)));
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)!!! */
2188 set_bit(TTY_IO_ERROR, &info->tty->flags);
2190 info->flags &= ~ASYNC_INITIALIZED;
2191 spin_unlock_irqrestore(&card->card_lock, flags);
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;
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);
2205 firm_id = base_addr + ID_ADDRESS;
2206 if (!ISZLOADED(*card)) {
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;
2215 spin_lock_irqsave(&card->card_lock, flags);
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);
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,
2231 printk(KERN_ERR"cyc:shutdown retval on ttyC%d "
2232 "was %x\n", info->line, retval);
2235 printk(KERN_DEBUG "cyc:shutdown dropping Z DTR\n");
2240 set_bit(TTY_IO_ERROR, &info->tty->flags);
2242 info->flags &= ~ASYNC_INITIALIZED;
2244 spin_unlock_irqrestore(&card->card_lock, flags);
2247 #ifdef CY_DEBUG_OPEN
2248 printk(KERN_DEBUG "cyc shutdown done\n");
2253 * ------------------------------------------------------------
2254 * cy_open() and friends
2255 * ------------------------------------------------------------
2259 block_til_ready(struct tty_struct *tty, struct file *filp,
2260 struct cyclades_port *info)
2262 DECLARE_WAITQUEUE(wait, current);
2263 struct cyclades_card *cinfo;
2264 unsigned long flags;
2265 int chip, channel, index;
2267 void __iomem *base_addr;
2270 channel = info->line - cinfo->first_line;
2273 * If the device is in the middle of being closed, then block
2274 * until it's done, and then try again.
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;
2283 * If non-blocking mode is set, then make the check up front
2286 if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) {
2287 info->flags |= ASYNC_NORMAL_ACTIVE;
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.
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);
2304 spin_lock_irqsave(&cinfo->card_lock, flags);
2305 if (!tty_hung_up_p(filp))
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);
2312 info->blocked_open++;
2314 if (!IS_CYC_Z(*cinfo)) {
2315 chip = channel >> 2;
2317 index = cinfo->bus_index;
2318 base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
2321 spin_lock_irqsave(&cinfo->card_lock, flags);
2322 if ((tty->termios->c_cflag & CBAUD)) {
2323 cy_writeb(base_addr + (CyCAR << index),
2325 cy_writeb(base_addr + (CyMSVR1 << index),
2327 cy_writeb(base_addr + (CyMSVR2 << index),
2330 printk(KERN_DEBUG "cyc:block_til_ready raising "
2332 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
2333 readb(base_addr + (CyMSVR1 << index)),
2334 readb(base_addr + (CyMSVR2 << index)));
2337 spin_unlock_irqrestore(&cinfo->card_lock, flags);
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);
2347 spin_lock_irqsave(&cinfo->card_lock, flags);
2348 cy_writeb(base_addr + (CyCAR << index),
2350 if (!(info->flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
2352 (CyMSVR1 << index)) & CyDCD))) {
2353 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2356 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2358 if (signal_pending(current)) {
2359 retval = -ERESTARTSYS;
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);
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;
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);
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;
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);
2396 printk(KERN_ERR "cyc:block_til_ready "
2397 "retval on ttyC%d was %x\n",
2398 info->line, retval);
2401 printk(KERN_DEBUG "cyc:block_til_ready raising "
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);
2413 if (!(info->flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
2414 (readl(&ch_ctrl[channel].rs_status) &
2418 if (signal_pending(current)) {
2419 retval = -ERESTARTSYS;
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);
2430 __set_current_state(TASK_RUNNING);
2431 remove_wait_queue(&info->open_wait, &wait);
2432 if (!tty_hung_up_p(filp)) {
2434 #ifdef CY_DEBUG_COUNT
2435 printk(KERN_DEBUG "cyc:block_til_ready (%d): incrementing "
2436 "count to %d\n", current->pid, info->count);
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);
2446 info->flags |= ASYNC_NORMAL_ACTIVE;
2448 } /* block_til_ready */
2451 * This routine is called whenever a serial port is opened. It
2452 * performs the serial-specific initialization for the tty structure.
2454 static int cy_open(struct tty_struct *tty, struct file *filp)
2456 struct cyclades_port *info;
2461 if ((line < 0) || (NR_PORTS <= line)) {
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)
2470 info = &cy_card[i].ports[line - cy_card[i].first_line];
2471 if (info->line < 0) {
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.
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;
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 "
2494 printk(KERN_ERR "cyc:Cyclades-Z firmware not "
2499 #ifdef CONFIG_CYZ_INTR
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;
2508 zfw_ctrl = cinfo->base_addr +
2509 (readl(&firm_id->zfwctrl_addr) &
2512 board_ctrl = &zfw_ctrl->board_ctrl;
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,
2521 printk(KERN_ERR "cyc:IRQ enable retval "
2522 "was %x\n", retval);
2525 (int)readl(&board_ctrl->n_channel);
2526 cinfo->intr_enabled = 1;
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))
2534 #ifdef CY_DEBUG_OTHER
2535 printk(KERN_DEBUG "cyc:cy_open ttyC%d\n", info->line);
2537 tty->driver_data = info;
2539 if (serial_paranoia_check(info, tty->name, "cy_open")) {
2542 #ifdef CY_DEBUG_OPEN
2543 printk(KERN_DEBUG "cyc:cy_open ttyC%d, count = %d\n", info->line,
2547 #ifdef CY_DEBUG_COUNT
2548 printk(KERN_DEBUG "cyc:cy_open (%d): incrementing count to %d\n",
2549 current->pid, info->count);
2553 * If the port is the middle of closing, bail out now
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;
2562 * Start up serial port
2564 retval = startup(info);
2569 retval = block_til_ready(tty, filp, info);
2571 #ifdef CY_DEBUG_OPEN
2572 printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready "
2573 "with %d\n", retval);
2580 #ifdef CY_DEBUG_OPEN
2581 printk(KERN_DEBUG "cyc:cy_open done\n");
2587 * cy_wait_until_sent() --- wait until the transmitter is empty
2589 static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
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;
2598 if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
2601 if (info->xmit_fifo_size == 0)
2602 return; /* Just in case.... */
2604 orig_jiffies = jiffies;
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.
2610 * Note: we have to use pretty tight timings here to satisfy
2613 char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
2614 char_time = char_time / 5;
2620 char_time = min(char_time, timeout);
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
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);
2637 channel = (info->line) - (card->first_line);
2638 if (!IS_CYC_Z(*card)) {
2639 chip = channel >> 2;
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);
2647 if (msleep_interruptible(jiffies_to_msecs(char_time)))
2649 if (timeout && time_after(jiffies, orig_jiffies +
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);
2662 * This routine is called when a particular tty device is closed.
2664 static void cy_close(struct tty_struct *tty, struct file *filp)
2666 struct cyclades_port *info = tty->driver_data;
2667 struct cyclades_card *card;
2668 unsigned long flags;
2670 #ifdef CY_DEBUG_OTHER
2671 printk(KERN_DEBUG "cyc:cy_close ttyC%d\n", info->line);
2674 if (!info || serial_paranoia_check(info, tty->name, "cy_close")) {
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);
2686 #ifdef CY_DEBUG_OPEN
2687 printk(KERN_DEBUG "cyc:cy_close ttyC%d, count = %d\n", info->line,
2690 if ((tty->count == 1) && (info->count != 1)) {
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.
2698 printk(KERN_ERR "cyc:cy_close: bad serial port count; "
2699 "tty->count is 1, info->count is %d\n", info->count);
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);
2706 if (--info->count < 0) {
2707 #ifdef CY_DEBUG_COUNT
2708 printk(KERN_DEBUG "cyc:cyc_close setting count to 0\n");
2713 spin_unlock_irqrestore(&card->card_lock, flags);
2716 info->flags |= ASYNC_CLOSING;
2719 * Now we wait for the transmit buffer to clear; and we notify
2720 * the line discipline to only process XON/XOFF characters.
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);
2727 spin_lock_irqsave(&card->card_lock, flags);
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 */
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
2742 spin_unlock_irqrestore(&card->card_lock, flags);
2743 cy_wait_until_sent(tty, info->timeout);
2744 spin_lock_irqsave(&card->card_lock, flags);
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;
2757 if (readl(&ch_ctrl[channel].flow_status) != C_FS_TXIDLE) {
2758 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L);
2760 printk(KERN_DEBUG "cyc:cy_close retval on "
2761 "ttyC%d was %x\n", info->line, retval);
2763 spin_unlock_irqrestore(&card->card_lock, flags);
2764 wait_for_completion_interruptible(&info->shutdown_wait);
2765 spin_lock_irqsave(&card->card_lock, flags);
2770 spin_unlock_irqrestore(&card->card_lock, flags);
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);
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));
2786 wake_up_interruptible(&info->open_wait);
2787 spin_lock_irqsave(&card->card_lock, flags);
2789 info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
2790 wake_up_interruptible(&info->close_wait);
2792 #ifdef CY_DEBUG_OTHER
2793 printk(KERN_DEBUG "cyc:cy_close done\n");
2796 spin_unlock_irqrestore(&card->card_lock, flags);
2799 /* This routine gets called when tty_write has put something into
2800 * the write_queue. The characters may come from user space or
2803 * This routine will return the number of characters actually
2804 * accepted for writing.
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.
2812 static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
2814 struct cyclades_port *info = tty->driver_data;
2815 unsigned long flags;
2819 printk(KERN_DEBUG "cyc:cy_write ttyC%d\n", info->line);
2822 if (serial_paranoia_check(info, tty->name, "cy_write")) {
2826 if (!info->xmit_buf)
2829 spin_lock_irqsave(&info->card->card_lock, flags);
2831 c = min(count, min((int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1),
2832 (int)(SERIAL_XMIT_SIZE - info->xmit_head)));
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;
2845 spin_unlock_irqrestore(&info->card->card_lock, flags);
2847 info->idle_stats.xmit_bytes += ret;
2848 info->idle_stats.xmit_idle = jiffies;
2850 if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
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.
2863 static void cy_put_char(struct tty_struct *tty, unsigned char ch)
2865 struct cyclades_port *info = tty->driver_data;
2866 unsigned long flags;
2869 printk(KERN_DEBUG "cyc:cy_put_char ttyC%d\n", info->line);
2872 if (serial_paranoia_check(info, tty->name, "cy_put_char"))
2875 if (!info->xmit_buf)
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);
2884 info->xmit_buf[info->xmit_head++] = ch;
2885 info->xmit_head &= SERIAL_XMIT_SIZE - 1;
2887 info->idle_stats.xmit_bytes++;
2888 info->idle_stats.xmit_idle = jiffies;
2889 spin_unlock_irqrestore(&info->card->card_lock, flags);
2893 * This routine is called by the kernel after it has written a
2894 * series of characters to the tty device using put_char().
2896 static void cy_flush_chars(struct tty_struct *tty)
2898 struct cyclades_port *info = tty->driver_data;
2901 printk(KERN_DEBUG "cyc:cy_flush_chars ttyC%d\n", info->line);
2904 if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
2907 if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
2912 } /* cy_flush_chars */
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.
2920 static int cy_write_room(struct tty_struct *tty)
2922 struct cyclades_port *info = tty->driver_data;
2926 printk(KERN_DEBUG "cyc:cy_write_room ttyC%d\n", info->line);
2929 if (serial_paranoia_check(info, tty->name, "cy_write_room"))
2931 ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
2935 } /* cy_write_room */
2937 static int cy_chars_in_buffer(struct tty_struct *tty)
2939 struct cyclades_card *card;
2940 struct cyclades_port *info = tty->driver_data;
2943 if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
2947 channel = (info->line) - (card->first_line);
2949 #ifdef Z_EXT_CHARS_IN_BUFFER
2950 if (!IS_CYC_Z(cy_card[card])) {
2951 #endif /* Z_EXT_CHARS_IN_BUFFER */
2953 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
2954 info->line, info->xmit_cnt);
2956 return info->xmit_cnt;
2957 #ifdef Z_EXT_CHARS_IN_BUFFER
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;
2964 __u32 tx_put, tx_get, tx_bufsize;
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]);
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;
2978 char_count = tx_put - tx_get + tx_bufsize;
2980 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
2981 info->line, info->xmit_cnt + char_count);
2983 return info->xmit_cnt + char_count;
2985 #endif /* Z_EXT_CHARS_IN_BUFFER */
2986 } /* cy_chars_in_buffer */
2989 * ------------------------------------------------------------
2990 * cy_ioctl() and friends
2991 * ------------------------------------------------------------
2994 static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
2996 int co, co_val, bpr;
2997 __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
3001 info->tbpr = info->tco = info->rbpr = info->rco = 0;
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)
3011 bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
3015 info->tbpr = info->rbpr = bpr;
3016 info->tco = info->rco = co;
3020 * This routine finds or computes the various line characteristics.
3021 * It used to be called config_setup
3023 static void set_line_char(struct cyclades_port *info)
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;
3034 if (!info->tty || !info->tty->termios) {
3037 if (info->line == -1) {
3040 cflag = info->tty->termios->c_cflag;
3041 iflag = info->tty->termios->c_iflag;
3044 * Set up the tty->alt_speed kludge
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;
3058 channel = info->line - card->first_line;
3059 chip_number = channel / 4;
3061 if (!IS_CYC_Z(*card)) {
3063 index = card->bus_index;
3066 baud = tty_get_baud_rate(info->tty);
3067 if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3069 if (info->custom_divisor)
3070 baud_rate = info->baud / info->custom_divisor;
3072 baud_rate = info->baud;
3073 } else if (baud > CD1400_MAX_SPEED) {
3074 baud = CD1400_MAX_SPEED;
3076 /* find the baud index */
3077 for (i = 0; i < 20; i++) {
3078 if (baud == baud_table[i]) {
3083 i = 19; /* CD1400_MAX_SPEED */
3086 if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3088 cyy_baud_calc(info, baud_rate);
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 */
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 */
3103 if (baud_table[i] == 134) {
3104 /* get it right for 134.5 baud */
3105 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
3107 } else if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3109 info->timeout = (info->xmit_fifo_size * HZ * 15 /
3111 } else if (baud_table[i]) {
3112 info->timeout = (info->xmit_fifo_size * HZ * 15 /
3114 /* this needs to be propagated into the card info */
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. */
3122 /* byte size and parity */
3125 /* receive threshold */
3126 info->cor3 = (info->default_threshold ?
3127 info->default_threshold : baud_cor3[i]);
3129 switch (cflag & CSIZE) {
3131 info->cor1 = Cy_5_BITS;
3134 info->cor1 = Cy_6_BITS;
3137 info->cor1 = Cy_7_BITS;
3140 info->cor1 = Cy_8_BITS;
3143 if (cflag & CSTOPB) {
3144 info->cor1 |= Cy_2_STOP;
3146 if (cflag & PARENB) {
3147 if (cflag & PARODD) {
3148 info->cor1 |= CyPARITY_O;
3150 info->cor1 |= CyPARITY_E;
3153 info->cor1 |= CyPARITY_NONE;
3156 /* CTS flow control flag */
3157 if (cflag & CRTSCTS) {
3158 info->flags |= ASYNC_CTS_FLOW;
3159 info->cor2 |= CyCtsAE;
3161 info->flags &= ~ASYNC_CTS_FLOW;
3162 info->cor2 &= ~CyCtsAE;
3165 info->flags &= ~ASYNC_CHECK_CD;
3167 info->flags |= ASYNC_CHECK_CD;
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 ***********************************************/
3179 chip = channel >> 2;
3181 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
3183 spin_lock_irqsave(&card->card_lock, flags);
3184 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
3186 /* tx and rx baud rate */
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);
3193 /* set line characteristics according configuration */
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);
3204 cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
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 */
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]));
3221 cy_writeb(base_addr + (CyMCOR1 << index),
3224 /* act on 0->1 modem transitions */
3225 cy_writeb(base_addr + (CyMCOR2 << index), CyCTS);
3227 /* without modem intr */
3228 cy_writeb(base_addr + (CySRER << index),
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 |
3237 cy_writeb(base_addr + (CyMCOR1 << index),
3238 CyDSR | CyCTS | CyRI | CyDCD);
3240 /* act on 0->1 modem transitions */
3241 cy_writeb(base_addr + (CyMCOR2 << index),
3242 CyDSR | CyCTS | CyRI | CyDCD);
3245 if (i == 0) { /* baud rate is zero, turn off line */
3246 if (info->rtsdtr_inv) {
3247 cy_writeb(base_addr + (CyMSVR1 << index),
3250 cy_writeb(base_addr + (CyMSVR2 << index),
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)));
3260 if (info->rtsdtr_inv) {
3261 cy_writeb(base_addr + (CyMSVR1 << index),
3264 cy_writeb(base_addr + (CyMSVR2 << index),
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)));
3276 clear_bit(TTY_IO_ERROR, &info->tty->flags);
3278 spin_unlock_irqrestore(&card->card_lock, flags);
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;
3289 firm_id = card->base_addr + ID_ADDRESS;
3290 if (!ISZLOADED(*card)) {
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];
3301 baud = tty_get_baud_rate(info->tty);
3302 if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3304 if (info->custom_divisor)
3305 baud_rate = info->baud / info->custom_divisor;
3307 baud_rate = info->baud;
3308 } else if (baud > CYZ_MAX_SPEED) {
3309 baud = CYZ_MAX_SPEED;
3311 cy_writel(&ch_ctrl->comm_baud, baud);
3314 /* get it right for 134.5 baud */
3315 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
3317 } else if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3319 info->timeout = (info->xmit_fifo_size * HZ * 15 /
3322 info->timeout = (info->xmit_fifo_size * HZ * 15 /
3324 /* this needs to be propagated into the card info */
3329 /* byte size and parity */
3330 switch (cflag & CSIZE) {
3332 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
3335 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
3338 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
3341 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
3344 if (cflag & CSTOPB) {
3345 cy_writel(&ch_ctrl->comm_data_l,
3346 readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
3348 cy_writel(&ch_ctrl->comm_data_l,
3349 readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
3351 if (cflag & PARENB) {
3352 if (cflag & PARODD) {
3353 cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
3355 cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
3358 cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
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);
3366 cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
3367 ~(C_RS_CTS | C_RS_RTS));
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;
3373 /* XON/XOFF/XANY flow control flags */
3376 sw_flow |= C_FL_OXX;
3378 sw_flow |= C_FL_OIXANY;
3380 cy_writel(&ch_ctrl->sw_flow, sw_flow);
3382 retval = cyz_issue_cmd(card, channel, C_CM_IOCTL, 0L);
3384 printk(KERN_ERR "cyc:set_line_char retval on ttyC%d "
3385 "was %x\n", info->line, retval);
3388 /* CD sensitivity */
3389 if (cflag & CLOCAL) {
3390 info->flags &= ~ASYNC_CHECK_CD;
3392 info->flags |= ASYNC_CHECK_CD;
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);
3399 printk(KERN_DEBUG "cyc:set_line_char dropping Z DTR\n");
3402 cy_writel(&ch_ctrl->rs_control,
3403 readl(&ch_ctrl->rs_control) | C_RS_DTR);
3405 printk(KERN_DEBUG "cyc:set_line_char raising Z DTR\n");
3409 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM,0L);
3411 printk(KERN_ERR "cyc:set_line_char(2) retval on ttyC%d "
3412 "was %x\n", info->line, retval);
3416 clear_bit(TTY_IO_ERROR, &info->tty->flags);
3419 } /* set_line_char */
3422 get_serial_info(struct cyclades_port *info,
3423 struct serial_struct __user * retinfo)
3425 struct serial_struct tmp;
3426 struct cyclades_card *cinfo = info->card;
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 -
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 */
3446 set_serial_info(struct cyclades_port *info,
3447 struct serial_struct __user * new_info)
3449 struct serial_struct new_serial;
3450 struct cyclades_port old_info;
3452 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
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 &
3461 (info->flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
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;
3471 * OK, past this point, all the error checking has been done.
3472 * At this point, we start making changes.....
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;
3483 if (info->flags & ASYNC_INITIALIZED) {
3484 set_line_char(info);
3487 return startup(info);
3489 } /* set_serial_info */
3492 * get_lsr_info - get line status register info
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.
3501 static int get_lsr_info(struct cyclades_port *info, unsigned int __user * value)
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;
3511 channel = (info->line) - (card->first_line);
3512 if (!IS_CYC_Z(*card)) {
3513 chip = channel >> 2;
3515 index = card->bus_index;
3516 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
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);
3524 /* Not supported yet */
3527 return put_user(result, (unsigned long __user *)value);
3530 static int cy_tiocmget(struct tty_struct *tty, struct file *file)
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;
3545 if (serial_paranoia_check(info, tty->name, __FUNCTION__))
3549 channel = info->line - card->first_line;
3550 if (!IS_CYC_Z(*card)) {
3551 chip = channel >> 2;
3553 index = card->bus_index;
3554 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
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);
3562 if (info->rtsdtr_inv) {
3563 result = ((status & CyRTS) ? TIOCM_DTR : 0) |
3564 ((status & CyDTR) ? TIOCM_RTS : 0);
3566 result = ((status & CyRTS) ? TIOCM_RTS : 0) |
3567 ((status & CyDTR) ? TIOCM_DTR : 0);
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);
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);
3598 cy_tiocmset(struct tty_struct *tty, struct file *file,
3599 unsigned int set, unsigned int clear)
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;
3612 if (serial_paranoia_check(info, tty->name, __FUNCTION__))
3616 channel = (info->line) - (card->first_line);
3617 if (!IS_CYC_Z(*card)) {
3618 chip = channel >> 2;
3620 index = card->bus_index;
3621 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
3623 if (set & TIOCM_RTS) {
3624 spin_lock_irqsave(&card->card_lock, flags);
3625 cy_writeb(base_addr + (CyCAR << index),
3627 if (info->rtsdtr_inv) {
3628 cy_writeb(base_addr + (CyMSVR2 << index),
3631 cy_writeb(base_addr + (CyMSVR1 << index),
3634 spin_unlock_irqrestore(&card->card_lock, flags);
3636 if (clear & TIOCM_RTS) {
3637 spin_lock_irqsave(&card->card_lock, flags);
3638 cy_writeb(base_addr + (CyCAR << index),
3640 if (info->rtsdtr_inv) {
3641 cy_writeb(base_addr + (CyMSVR2 << index),
3644 cy_writeb(base_addr + (CyMSVR1 << index),
3647 spin_unlock_irqrestore(&card->card_lock, flags);
3649 if (set & TIOCM_DTR) {
3650 spin_lock_irqsave(&card->card_lock, flags);
3651 cy_writeb(base_addr + (CyCAR << index),
3653 if (info->rtsdtr_inv) {
3654 cy_writeb(base_addr + (CyMSVR1 << index),
3657 cy_writeb(base_addr + (CyMSVR2 << index),
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)));
3666 spin_unlock_irqrestore(&card->card_lock, flags);
3668 if (clear & TIOCM_DTR) {
3669 spin_lock_irqsave(&card->card_lock, flags);
3670 cy_writeb(base_addr + (CyCAR << index),
3672 if (info->rtsdtr_inv) {
3673 cy_writeb(base_addr + (CyMSVR1 << index),
3676 cy_writeb(base_addr + (CyMSVR2 << index),
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)));
3686 spin_unlock_irqrestore(&card->card_lock, flags);
3689 base_addr = card->base_addr;
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;
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) |
3703 spin_unlock_irqrestore(&card->card_lock, flags);
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) &
3710 spin_unlock_irqrestore(&card->card_lock, flags);
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) |
3718 printk(KERN_DEBUG "cyc:set_modem_info raising "
3721 spin_unlock_irqrestore(&card->card_lock, flags);
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) &
3729 printk(KERN_DEBUG "cyc:set_modem_info clearing "
3732 spin_unlock_irqrestore(&card->card_lock, flags);
3737 spin_lock_irqsave(&card->card_lock, flags);
3738 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
3740 printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
3741 "was %x\n", info->line, retval);
3743 spin_unlock_irqrestore(&card->card_lock, flags);
3749 * cy_break() --- routine which turns the break handling on or off
3751 static void cy_break(struct tty_struct *tty, int break_state)
3753 struct cyclades_port *info = tty->driver_data;
3754 struct cyclades_card *card;
3755 unsigned long flags;
3757 if (serial_paranoia_check(info, tty->name, "cy_break"))
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).
3767 if (break_state == -1) {
3768 if (!info->breakon) {
3770 if (!info->xmit_cnt) {
3771 spin_unlock_irqrestore(&card->card_lock, flags);
3773 spin_lock_irqsave(&card->card_lock, flags);
3777 if (!info->breakoff) {
3779 if (!info->xmit_cnt) {
3780 spin_unlock_irqrestore(&card->card_lock, flags);
3782 spin_lock_irqsave(&card->card_lock, flags);
3789 if (break_state == -1) {
3790 retval = cyz_issue_cmd(card,
3791 info->line - card->first_line,
3792 C_CM_SET_BREAK, 0L);
3794 printk(KERN_ERR "cyc:cy_break (set) retval on "
3795 "ttyC%d was %x\n", info->line, retval);
3798 retval = cyz_issue_cmd(card,
3799 info->line - card->first_line,
3800 C_CM_CLR_BREAK, 0L);
3802 printk(KERN_DEBUG "cyc:cy_break (clr) retval "
3803 "on ttyC%d was %x\n", info->line,
3808 spin_unlock_irqrestore(&card->card_lock, flags);
3812 get_mon_info(struct cyclades_port *info, struct cyclades_monitor __user * mon)
3815 if (copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
3817 info->mon.int_count = 0;
3818 info->mon.char_count = 0;
3819 info->mon.char_max = 0;
3820 info->mon.char_last = 0;
3822 } /* get_mon_info */
3824 static int set_threshold(struct cyclades_port *info, unsigned long value)
3826 struct cyclades_card *card;
3827 void __iomem *base_addr;
3828 int channel, chip, index;
3829 unsigned long flags;
3832 channel = info->line - card->first_line;
3833 if (!IS_CYC_Z(*card)) {
3834 chip = channel >> 2;
3836 index = card->bus_index;
3838 card->base_addr + (cy_chip_offset[chip] << index);
3840 info->cor3 &= ~CyREC_FIFO;
3841 info->cor3 |= value & CyREC_FIFO;
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);
3849 } /* set_threshold */
3852 get_threshold(struct cyclades_port *info, unsigned long __user * value)
3854 struct cyclades_card *card;
3855 void __iomem *base_addr;
3856 int channel, chip, index;
3860 channel = info->line - card->first_line;
3861 if (!IS_CYC_Z(*card)) {
3862 chip = channel >> 2;
3864 index = card->bus_index;
3865 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
3867 tmp = readb(base_addr + (CyCOR3 << index)) & CyREC_FIFO;
3868 return put_user(tmp, value);
3871 } /* get_threshold */
3874 set_default_threshold(struct cyclades_port *info, unsigned long value)
3876 info->default_threshold = value & 0x0f;
3878 } /* set_default_threshold */
3881 get_default_threshold(struct cyclades_port *info, unsigned long __user * value)
3883 return put_user(info->default_threshold, value);
3884 } /* get_default_threshold */
3886 static int set_timeout(struct cyclades_port *info, unsigned long value)
3888 struct cyclades_card *card;
3889 void __iomem *base_addr;
3890 int channel, chip, index;
3891 unsigned long flags;
3894 channel = info->line - card->first_line;
3895 if (!IS_CYC_Z(*card)) {
3896 chip = channel >> 2;
3898 index = card->bus_index;
3899 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
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);
3908 static int get_timeout(struct cyclades_port *info, unsigned long __user * value)
3910 struct cyclades_card *card;
3911 void __iomem *base_addr;
3912 int channel, chip, index;
3916 channel = info->line - card->first_line;
3917 if (!IS_CYC_Z(*card)) {
3918 chip = channel >> 2;
3920 index = card->bus_index;
3921 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
3923 tmp = readb(base_addr + (CyRTPR << index));
3924 return put_user(tmp, value);
3929 static int set_default_timeout(struct cyclades_port *info, unsigned long value)
3931 info->default_timeout = value & 0xff;
3933 } /* set_default_timeout */
3936 get_default_timeout(struct cyclades_port *info, unsigned long __user * value)
3938 return put_user(info->default_timeout, value);
3939 } /* get_default_timeout */
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.
3947 cy_ioctl(struct tty_struct *tty, struct file *file,
3948 unsigned int cmd, unsigned long arg)
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 */
3954 unsigned long flags;
3955 void __user *argp = (void __user *)arg;
3957 if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
3960 #ifdef CY_DEBUG_OTHER
3961 printk(KERN_DEBUG "cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n",
3962 info->line, cmd, arg);
3967 ret_val = get_mon_info(info, argp);
3970 ret_val = get_threshold(info, argp);
3973 ret_val = set_threshold(info, arg);
3975 case CYGETDEFTHRESH:
3976 ret_val = get_default_threshold(info, argp);
3978 case CYSETDEFTHRESH:
3979 ret_val = set_default_threshold(info, arg);
3982 ret_val = get_timeout(info, argp);
3985 ret_val = set_timeout(info, arg);
3987 case CYGETDEFTIMEOUT:
3988 ret_val = get_default_timeout(info, argp);
3990 case CYSETDEFTIMEOUT:
3991 ret_val = set_default_timeout(info, arg);
3994 info->rflow = (int)arg;
3998 ret_val = info->rflow;
4000 case CYSETRTSDTR_INV:
4001 info->rtsdtr_inv = (int)arg;
4004 case CYGETRTSDTR_INV:
4005 ret_val = info->rtsdtr_inv;
4007 case CYGETCD1400VER:
4008 ret_val = info->chip_rev;
4010 #ifndef CONFIG_CYZ_INTR
4011 case CYZSETPOLLCYCLE:
4012 cyz_polling_cycle = (arg * HZ) / 1000;
4015 case CYZGETPOLLCYCLE:
4016 ret_val = (cyz_polling_cycle * 1000) / HZ;
4018 #endif /* CONFIG_CYZ_INTR */
4020 info->closing_wait = (unsigned short)arg *HZ / 100;
4024 ret_val = info->closing_wait / (HZ / 100);
4027 ret_val = get_serial_info(info, argp);
4030 ret_val = set_serial_info(info, argp);
4032 case TIOCSERGETLSR: /* Get line status register */
4033 ret_val = get_lsr_info(info, argp);
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
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, ({
4048 spin_lock_irqsave(&info->card->card_lock, flags);
4049 cnow = info->icount; /* atomic copy */
4050 spin_unlock_irqrestore(&info->card->card_lock, flags);
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));
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.
4066 spin_lock_irqsave(&info->card->card_lock, flags);
4067 cnow = info->icount;
4068 spin_unlock_irqrestore(&info->card->card_lock, flags);
4070 ret_val = put_user(cnow.cts, &p_cuser->cts);
4073 ret_val = put_user(cnow.dsr, &p_cuser->dsr);
4076 ret_val = put_user(cnow.rng, &p_cuser->rng);
4079 ret_val = put_user(cnow.dcd, &p_cuser->dcd);
4082 ret_val = put_user(cnow.rx, &p_cuser->rx);
4085 ret_val = put_user(cnow.tx, &p_cuser->tx);
4088 ret_val = put_user(cnow.frame, &p_cuser->frame);
4091 ret_val = put_user(cnow.overrun, &p_cuser->overrun);
4094 ret_val = put_user(cnow.parity, &p_cuser->parity);
4097 ret_val = put_user(cnow.brk, &p_cuser->brk);
4100 ret_val = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
4106 ret_val = -ENOIOCTLCMD;
4109 #ifdef CY_DEBUG_OTHER
4110 printk(KERN_DEBUG "cyc:cy_ioctl done\n");
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.
4122 static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
4124 struct cyclades_port *info = tty->driver_data;
4126 #ifdef CY_DEBUG_OTHER
4127 printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
4130 if (tty->termios->c_cflag == old_termios->c_cflag &&
4131 (tty->termios->c_iflag & (IXON | IXANY)) ==
4132 (old_termios->c_iflag & (IXON | IXANY)))
4134 set_line_char(info);
4136 if ((old_termios->c_cflag & CRTSCTS) &&
4137 !(tty->termios->c_cflag & CRTSCTS)) {
4138 tty->hw_stopped = 0;
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.....
4148 if (!(old_termios->c_cflag & CLOCAL) &&
4149 (tty->termios->c_cflag & CLOCAL))
4150 wake_up_interruptible(&info->open_wait);
4152 } /* cy_set_termios */
4154 /* This function is used to send a high-priority XON/XOFF character to
4157 static void cy_send_xchar(struct tty_struct *tty, char ch)
4159 struct cyclades_port *info = tty->driver_data;
4160 struct cyclades_card *card;
4163 if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
4172 channel = info->line - card->first_line;
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);
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.
4186 static void cy_throttle(struct tty_struct *tty)
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;
4194 #ifdef CY_DEBUG_THROTTLE
4197 printk(KERN_DEBUG "cyc:throttle %s: %ld...ttyC%d\n", tty_name(tty, buf),
4198 tty->ldisc.chars_in_buffer(tty), info->line);
4201 if (serial_paranoia_check(info, tty->name, "cy_throttle")) {
4208 if (!IS_CYC_Z(*card))
4209 cy_send_xchar(tty, STOP_CHAR(tty));
4214 if (tty->termios->c_cflag & CRTSCTS) {
4215 channel = info->line - card->first_line;
4216 if (!IS_CYC_Z(*card)) {
4217 chip = channel >> 2;
4219 index = card->bus_index;
4220 base_addr = card->base_addr +
4221 (cy_chip_offset[chip] << index);
4223 spin_lock_irqsave(&card->card_lock, flags);
4224 cy_writeb(base_addr + (CyCAR << index),
4226 if (info->rtsdtr_inv) {
4227 cy_writeb(base_addr + (CyMSVR2 << index),
4230 cy_writeb(base_addr + (CyMSVR1 << index),
4233 spin_unlock_irqrestore(&card->card_lock, flags);
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.
4245 static void cy_unthrottle(struct tty_struct *tty)
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;
4253 #ifdef CY_DEBUG_THROTTLE
4256 printk(KERN_DEBUG "cyc:unthrottle %s: %ld...ttyC%d\n",
4257 tty_name(tty, buf), tty->ldisc.chars_in_buffer(tty),info->line);
4260 if (serial_paranoia_check(info, tty->name, "cy_unthrottle")) {
4268 cy_send_xchar(tty, START_CHAR(tty));
4271 if (tty->termios->c_cflag & CRTSCTS) {
4273 channel = info->line - card->first_line;
4274 if (!IS_CYC_Z(*card)) {
4275 chip = channel >> 2;
4277 index = card->bus_index;
4278 base_addr = card->base_addr +
4279 (cy_chip_offset[chip] << index);
4281 spin_lock_irqsave(&card->card_lock, flags);
4282 cy_writeb(base_addr + (CyCAR << index),
4284 if (info->rtsdtr_inv) {
4285 cy_writeb(base_addr + (CyMSVR2 << index),
4288 cy_writeb(base_addr + (CyMSVR1 << index),
4291 spin_unlock_irqrestore(&card->card_lock, flags);
4296 } /* cy_unthrottle */
4298 /* cy_start and cy_stop provide software output flow control as a
4299 function of XON/XOFF, software CTS, and other such stuff.
4301 static void cy_stop(struct tty_struct *tty)
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;
4309 #ifdef CY_DEBUG_OTHER
4310 printk(KERN_DEBUG "cyc:cy_stop ttyC%d\n", info->line);
4313 if (serial_paranoia_check(info, tty->name, "cy_stop"))
4317 channel = info->line - cinfo->first_line;
4318 if (!IS_CYC_Z(*cinfo)) {
4319 index = cinfo->bus_index;
4320 chip = channel >> 2;
4322 base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
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);
4333 static void cy_start(struct tty_struct *tty)
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;
4341 #ifdef CY_DEBUG_OTHER
4342 printk(KERN_DEBUG "cyc:cy_start ttyC%d\n", info->line);
4345 if (serial_paranoia_check(info, tty->name, "cy_start"))
4349 channel = info->line - cinfo->first_line;
4350 index = cinfo->bus_index;
4351 if (!IS_CYC_Z(*cinfo)) {
4352 chip = channel >> 2;
4354 base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
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);
4364 static void cy_flush_buffer(struct tty_struct *tty)
4366 struct cyclades_port *info = tty->driver_data;
4367 struct cyclades_card *card;
4368 int channel, retval;
4369 unsigned long flags;
4372 printk(KERN_DEBUG "cyc:cy_flush_buffer ttyC%d\n", info->line);
4375 if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
4379 channel = info->line - card->first_line;
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);
4385 if (IS_CYC_Z(*card)) { /* If it is a Z card, flush the on-board
4387 spin_lock_irqsave(&card->card_lock, flags);
4388 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_TX, 0L);
4390 printk(KERN_ERR "cyc: flush_buffer retval on ttyC%d "
4391 "was %x\n", info->line, retval);
4393 spin_unlock_irqrestore(&card->card_lock, flags);
4396 } /* cy_flush_buffer */
4399 * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
4401 static void cy_hangup(struct tty_struct *tty)
4403 struct cyclades_port *info = tty->driver_data;
4405 #ifdef CY_DEBUG_OTHER
4406 printk(KERN_DEBUG "cyc:cy_hangup ttyC%d\n", info->line);
4409 if (serial_paranoia_check(info, tty->name, "cy_hangup"))
4412 cy_flush_buffer(tty);
4416 #ifdef CY_DEBUG_COUNT
4417 printk(KERN_DEBUG "cyc:cy_hangup (%d): setting count to 0\n",
4421 info->flags &= ~ASYNC_NORMAL_ACTIVE;
4422 wake_up_interruptible(&info->open_wait);
4426 * ---------------------------------------------------------------------
4427 * cy_init() and friends
4429 * cy_init() is called at boot-time to initialize the serial driver.
4430 * ---------------------------------------------------------------------
4433 static int __devinit cy_init_card(struct cyclades_card *cinfo)
4435 struct cyclades_port *info;
4437 unsigned int nports;
4438 unsigned short chip_number;
4441 spin_lock_init(&cinfo->card_lock);
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
4451 index = cinfo->bus_index;
4452 nports = cinfo->nports = CyPORTS_PER_CHIP * cinfo->num_chips;
4455 cinfo->ports = kzalloc(sizeof(*cinfo->ports) * nports, GFP_KERNEL);
4456 if (cinfo->ports == NULL) {
4457 printk(KERN_ERR "Cyclades: cannot allocate ports\n");
4461 for (port = cinfo->first_line; port < cinfo->first_line + nports;
4463 info = &cinfo->ports[port - cinfo->first_line];
4464 info->magic = CYCLADES_MAGIC;
4467 info->flags = STD_COM_FLAGS;
4468 info->closing_wait = CLOSING_WAIT_DELAY;
4469 info->close_delay = 5 * HZ / 10;
4471 INIT_WORK(&info->tqueue, do_softint);
4472 init_waitqueue_head(&info->open_wait);
4473 init_waitqueue_head(&info->close_wait);
4474 init_completion(&info->shutdown_wait);
4475 init_waitqueue_head(&info->delta_msr_wait);
4477 if (IS_CYC_Z(*cinfo)) {
4478 info->type = PORT_STARTECH;
4479 if (mailbox == ZO_V1)
4480 info->xmit_fifo_size = CYZ_FIFO_SIZE;
4482 info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
4483 #ifdef CONFIG_CYZ_INTR
4484 setup_timer(&cyz_rx_full_timer[port],
4485 cyz_rx_restart, (unsigned long)info);
4488 info->type = PORT_CIRRUS;
4489 info->xmit_fifo_size = CyMAX_CHAR_FIFO;
4490 info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
4492 info->cor3 = 0x08; /* _very_ small rcv threshold */
4494 chip_number = (port - cinfo->first_line) / 4;
4495 if ((info->chip_rev = readb(cinfo->base_addr +
4496 (cy_chip_offset[chip_number] <<
4497 index) + (CyGFRCR << index))) >=
4499 /* It is a CD1400 rev. J or later */
4500 info->tbpr = baud_bpr_60[13]; /* Tx BPR */
4501 info->tco = baud_co_60[13]; /* Tx CO */
4502 info->rbpr = baud_bpr_60[13]; /* Rx BPR */
4503 info->rco = baud_co_60[13]; /* Rx CO */
4504 info->rtsdtr_inv = 1;
4506 info->tbpr = baud_bpr_25[13]; /* Tx BPR */
4507 info->tco = baud_co_25[13]; /* Tx CO */
4508 info->rbpr = baud_bpr_25[13]; /* Rx BPR */
4509 info->rco = baud_co_25[13]; /* Rx CO */
4510 info->rtsdtr_inv = 0;
4512 info->read_status_mask = CyTIMEOUT | CySPECHAR |
4513 CyBREAK | CyPARITY | CyFRAME | CyOVERRUN;
4518 #ifndef CONFIG_CYZ_INTR
4519 if (IS_CYC_Z(*cinfo) && !timer_pending(&cyz_timerlist)) {
4520 mod_timer(&cyz_timerlist, jiffies + 1);
4522 printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
4529 /* initialize chips on Cyclom-Y card -- return number of valid
4530 chips (which is number of ports/4) */
4531 static unsigned short __devinit cyy_init_card(void __iomem *true_base_addr,
4534 unsigned int chip_number;
4535 void __iomem *base_addr;
4537 cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
4538 /* Cy_HwReset is 0x1400 */
4539 cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
4540 /* Cy_ClrIntr is 0x1800 */
4543 for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD; chip_number++) {
4545 true_base_addr + (cy_chip_offset[chip_number] << index);
4547 if (readb(base_addr + (CyCCR << index)) != 0x00) {
4549 printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
4550 chip_number, (unsigned long)base_addr);
4555 cy_writeb(base_addr + (CyGFRCR << index), 0);
4558 /* The Cyclom-16Y does not decode address bit 9 and therefore
4559 cannot distinguish between references to chip 0 and a non-
4560 existent chip 4. If the preceding clearing of the supposed
4561 chip 4 GFRCR register appears at chip 0, there is no chip 4
4562 and this must be a Cyclom-16Y, not a Cyclom-32Ye.
4564 if (chip_number == 4 && readb(true_base_addr +
4565 (cy_chip_offset[0] << index) +
4566 (CyGFRCR << index)) == 0) {
4570 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
4573 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
4575 printk(" chip #%d at %#6lx is not responding ",
4576 chip_number, (unsigned long)base_addr);
4577 printk("(GFRCR stayed 0)\n",
4581 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
4584 printk(" chip #%d at %#6lx is not valid (GFRCR == "
4586 chip_number, (unsigned long)base_addr,
4587 base_addr[CyGFRCR<<index]);
4591 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
4592 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
4593 /* It is a CD1400 rev. J or later */
4594 /* Impossible to reach 5ms with this chip.
4595 Changed to 2ms instead (f = 500 Hz). */
4596 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
4599 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
4603 printk(" chip #%d at %#6lx is rev 0x%2x\n",
4604 chip_number, (unsigned long)base_addr,
4605 readb(base_addr+(CyGFRCR<<index)));
4609 } /* cyy_init_card */
4612 * ---------------------------------------------------------------------
4613 * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
4614 * sets global variables and return the number of ISA boards found.
4615 * ---------------------------------------------------------------------
4617 static int __init cy_detect_isa(void)
4620 unsigned short cy_isa_irq, nboard;
4621 void __iomem *cy_isa_address;
4622 unsigned short i, j, cy_isa_nchan;
4630 /* Check for module parameters */
4631 for (i = 0; i < NR_CARDS; i++) {
4632 if (maddr[i] || i) {
4634 cy_isa_addresses[i] = maddr[i];
4641 /* scan the address table probing for Cyclom-Y/ISA boards */
4642 for (i = 0; i < NR_ISA_ADDRS; i++) {
4643 unsigned int isa_address = cy_isa_addresses[i];
4644 if (isa_address == 0x0000) {
4648 /* probe for CD1400... */
4649 cy_isa_address = ioremap(isa_address, CyISA_Ywin);
4650 cy_isa_nchan = CyPORTS_PER_CHIP *
4651 cyy_init_card(cy_isa_address, 0);
4652 if (cy_isa_nchan == 0) {
4656 if (isparam && irq[i])
4657 cy_isa_irq = irq[i];
4660 /* find out the board's irq by probing */
4661 cy_isa_irq = detect_isa_irq(cy_isa_address);
4662 if (cy_isa_irq == 0) {
4663 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but the "
4664 "IRQ could not be detected.\n",
4665 (unsigned long)cy_isa_address);
4669 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
4670 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
4671 "more channels are available. Change NR_PORTS "
4672 "in cyclades.c and recompile kernel.\n",
4673 (unsigned long)cy_isa_address);
4676 /* fill the next cy_card structure available */
4677 for (j = 0; j < NR_CARDS; j++) {
4678 if (cy_card[j].base_addr == NULL)
4681 if (j == NR_CARDS) { /* no more cy_cards available */
4682 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but no "
4683 "more cards can be used. Change NR_CARDS in "
4684 "cyclades.c and recompile kernel.\n",
4685 (unsigned long)cy_isa_address);
4690 if (request_irq(cy_isa_irq, cyy_interrupt,
4691 IRQF_DISABLED, "Cyclom-Y", &cy_card[j])) {
4692 printk(KERN_ERR "Cyclom-Y/ISA found at 0x%lx, but "
4693 "could not allocate IRQ#%d.\n",
4694 (unsigned long)cy_isa_address, cy_isa_irq);
4699 cy_card[j].base_addr = cy_isa_address;
4700 cy_card[j].ctl_addr = NULL;
4701 cy_card[j].irq = (int)cy_isa_irq;
4702 cy_card[j].bus_index = 0;
4703 cy_card[j].first_line = cy_next_channel;
4704 cy_card[j].num_chips = cy_isa_nchan / 4;
4705 cy_init_card(&cy_card[j]);
4708 printk(KERN_INFO "Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d found: "
4709 "%d channels starting from port %d\n",
4710 j + 1, (unsigned long)cy_isa_address,
4711 (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
4712 cy_isa_irq, cy_isa_nchan, cy_next_channel);
4714 for (j = cy_next_channel;
4715 j < cy_next_channel + cy_isa_nchan; j++)
4716 tty_register_device(cy_serial_driver, j, NULL);
4717 cy_next_channel += cy_isa_nchan;
4722 #endif /* CONFIG_ISA */
4723 } /* cy_detect_isa */
4726 static void __devinit plx_init(void __iomem * addr, __u32 initctl)
4729 cy_writel(addr + initctl, readl(addr + initctl) | 0x40000000);
4731 cy_writel(addr + initctl, readl(addr + initctl) & ~0x40000000);
4733 /* Reload Config. Registers from EEPROM */
4734 cy_writel(addr + initctl, readl(addr + initctl) | 0x20000000);
4736 cy_writel(addr + initctl, readl(addr + initctl) & ~0x20000000);
4739 static int __devinit cy_init_Ze(struct RUNTIME_9060 __iomem *cy_pci_addr0,
4740 int cy_pci_irq, struct pci_dev *pdev)
4742 void __iomem *cy_pci_addr2;
4744 unsigned short cy_pci_nchan;
4746 cy_pci_addr2 = pci_iomap(pdev, 2, CyPCI_Ze_win);
4748 readl(&cy_pci_addr0->mail_box_0);
4749 dev_dbg(&pdev->dev, "new Cyclades-Z board. FPGA not loaded\n");
4751 /* This must be the new Cyclades-Ze/PCI. */
4752 cy_pci_nchan = ZE_V1_NPORTS;
4754 if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
4755 dev_err(&pdev->dev, "Cyclades-Ze/PCI found, but no channels "
4756 "are available.\nChange NR_PORTS in cyclades.c "
4757 "and recompile kernel.\n");
4761 /* fill the next cy_card structure available */
4762 for (j = 0; j < NR_CARDS; j++) {
4763 if (cy_card[j].base_addr == NULL)
4766 if (j == NR_CARDS) { /* no more cy_cards available */
4767 dev_err(&pdev->dev, "Cyclades-Ze/PCI found, but no more "
4768 "cards can be used.\nChange NR_CARDS in "
4769 "cyclades.c and recompile kernel.\n");
4772 #ifdef CONFIG_CYZ_INTR
4773 /* allocate IRQ only if board has an IRQ */
4774 if ((cy_pci_irq != 0) && (cy_pci_irq != 255)) {
4775 if (request_irq(cy_pci_irq, cyz_interrupt,
4776 IRQF_SHARED, "Cyclades-Z",
4778 dev_err(&pdev->dev, "could not allocate IRQ.\n");
4782 #endif /* CONFIG_CYZ_INTR */
4785 cy_card[j].base_addr = cy_pci_addr2;
4786 cy_card[j].ctl_addr = cy_pci_addr0;
4787 cy_card[j].irq = cy_pci_irq;
4788 cy_card[j].bus_index = 1;
4789 cy_card[j].first_line = cy_next_channel;
4790 cy_card[j].num_chips = -1;
4791 cy_init_card(&cy_card[j]);
4792 pci_set_drvdata(pdev, &cy_card[j]);
4794 dev_info(&pdev->dev, "Cyclades-Ze/PCI #%d found: %d channels starting "
4795 "from port %d.\n", j + 1, cy_pci_nchan, cy_next_channel);
4797 for (j = cy_next_channel; j < cy_next_channel + cy_pci_nchan; j++)
4798 tty_register_device(cy_serial_driver, j, &pdev->dev);
4799 cy_next_channel += cy_pci_nchan;
4804 static int __devinit cy_pci_probe(struct pci_dev *pdev,
4805 const struct pci_device_id *ent)
4807 unsigned char cyy_rev_id;
4810 void __iomem *cy_pci_addr0, *cy_pci_addr2;
4811 unsigned int device_id;
4812 unsigned short j, cy_pci_nchan, plx_ver;
4815 retval = pci_enable_device(pdev);
4817 dev_err(&pdev->dev, "cannot enable device\n");
4821 /* read PCI configuration area */
4822 cy_pci_irq = pdev->irq;
4823 pci_read_config_byte(pdev, PCI_REVISION_ID, &cyy_rev_id);
4825 device_id = pdev->device & ~PCI_DEVICE_ID_MASK;
4827 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
4828 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
4829 dev_dbg(&pdev->dev, "Cyclom-Y/PCI found\n");
4831 if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
4832 dev_warn(&pdev->dev, "PCI I/O bit incorrectly "
4833 "set. Ignoring it...\n");
4834 pdev->resource[2].flags &= ~IORESOURCE_IO;
4837 /* Although we don't use this I/O region, we should
4838 request it from the kernel anyway, to avoid problems
4839 with other drivers accessing it. */
4840 retval = pci_request_regions(pdev, "Cyclom-Y");
4842 dev_err(&pdev->dev, "failed to reserve resources\n");
4845 #if defined(__alpha__)
4846 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) { /* below 1M? */
4847 dev_err(&pdev->dev, "Cyclom-Y/PCI not supported for "
4848 "low addresses on Alpha systems.\n");
4852 cy_pci_addr0 = pci_iomap(pdev, 0, CyPCI_Yctl);
4853 cy_pci_addr2 = pci_iomap(pdev, 2, CyPCI_Ywin);
4855 dev_dbg(&pdev->dev, "Cyclom-Y/PCI: relocate winaddr=0x%p "
4856 "ctladdr=0x%p\n", cy_pci_addr2, cy_pci_addr0);
4858 cy_pci_nchan = (unsigned short)(CyPORTS_PER_CHIP *
4859 cyy_init_card(cy_pci_addr2, 1));
4860 if (cy_pci_nchan == 0) {
4861 dev_err(&pdev->dev, "Cyclom-Y PCI host card with no "
4862 "Serial-Modules\n");
4865 if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
4866 dev_err(&pdev->dev, "Cyclom-Y/PCI found, but no "
4867 "channels are available. Change NR_PORTS in "
4868 "cyclades.c and recompile kernel.\n");
4871 /* fill the next cy_card structure available */
4872 for (j = 0; j < NR_CARDS; j++) {
4873 if (cy_card[j].base_addr == NULL)
4876 if (j == NR_CARDS) { /* no more cy_cards available */
4877 dev_err(&pdev->dev, "Cyclom-Y/PCI found, but no more "
4878 "cards can be used. Change NR_CARDS in "
4879 "cyclades.c and recompile kernel.\n");
4884 retval = request_irq(cy_pci_irq, cyy_interrupt,
4885 IRQF_SHARED, "Cyclom-Y", &cy_card[j]);
4887 dev_err(&pdev->dev, "could not allocate IRQ\n");
4892 cy_card[j].base_addr = cy_pci_addr2;
4893 cy_card[j].ctl_addr = cy_pci_addr0;
4894 cy_card[j].irq = cy_pci_irq;
4895 cy_card[j].bus_index = 1;
4896 cy_card[j].first_line = cy_next_channel;
4897 cy_card[j].num_chips = cy_pci_nchan / 4;
4898 cy_init_card(&cy_card[j]);
4899 pci_set_drvdata(pdev, &cy_card[j]);
4901 /* enable interrupts in the PCI interface */
4902 plx_ver = readb(cy_pci_addr2 + CyPLX_VER) & 0x0f;
4906 cy_writeb(cy_pci_addr0 + 0x4c, 0x43);
4911 default: /* Old boards, use PLX_9060 */
4913 plx_init(cy_pci_addr0, 0x6c);
4914 /* For some yet unknown reason, once the PLX9060 reloads
4915 the EEPROM, the IRQ is lost and, thus, we have to
4916 re-write it to the PCI config. registers.
4917 This will remain here until we find a permanent
4919 pci_write_config_byte(pdev, PCI_INTERRUPT_LINE,
4922 cy_writew(cy_pci_addr0 + 0x68,
4923 readw(cy_pci_addr0 + 0x68) | 0x0900);
4927 dev_info(&pdev->dev, "Cyclom-Y/PCI #%d found: %d channels "
4928 "starting from port %d.\n", j + 1, cy_pci_nchan,
4931 for (j = cy_next_channel;
4932 j < cy_next_channel + cy_pci_nchan; j++)
4933 tty_register_device(cy_serial_driver, j, &pdev->dev);
4935 cy_next_channel += cy_pci_nchan;
4936 } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
4937 dev_err(&pdev->dev, "Cyclades-Z/PCI not supported for "
4940 } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
4941 dev_dbg(&pdev->dev, "Cyclades-Z/PCI found\n");
4943 cy_pci_addr0 = pci_iomap(pdev, 0, CyPCI_Zctl);
4945 /* Disable interrupts on the PLX before resetting it */
4946 cy_writew(cy_pci_addr0 + 0x68,
4947 readw(cy_pci_addr0 + 0x68) & ~0x0900);
4949 plx_init(cy_pci_addr0, 0x6c);
4950 /* For some yet unknown reason, once the PLX9060 reloads
4951 the EEPROM, the IRQ is lost and, thus, we have to
4952 re-write it to the PCI config. registers.
4953 This will remain here until we find a permanent
4955 pci_write_config_byte(pdev, PCI_INTERRUPT_LINE, cy_pci_irq);
4957 mailbox = (__u32)readl(&((struct RUNTIME_9060 __iomem *)
4958 cy_pci_addr0)->mail_box_0);
4960 if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
4961 dev_warn(&pdev->dev, "PCI I/O bit incorrectly "
4962 "set. Ignoring it...\n");
4963 pdev->resource[2].flags &= ~IORESOURCE_IO;
4966 /* Although we don't use this I/O region, we should
4967 request it from the kernel anyway, to avoid problems
4968 with other drivers accessing it. */
4969 retval = pci_request_regions(pdev, "Cyclades-Z");
4971 dev_err(&pdev->dev, "failed to reserve resources\n");
4975 if (mailbox == ZE_V1) {
4976 retval = cy_init_Ze(cy_pci_addr0, cy_pci_irq, pdev);
4979 cy_pci_addr2 = pci_iomap(pdev, 2, CyPCI_Zwin);
4982 dev_dbg(&pdev->dev, "Cyclades-Z/PCI: relocate winaddr=0x%p "
4983 "ctladdr=0x%p\n", cy_pci_addr2, cy_pci_addr0);
4985 if (mailbox == ZO_V1) {
4986 cy_writel(&((struct RUNTIME_9060 *)
4987 (cy_pci_addr0))->loc_addr_base,
4989 dev_info(&pdev->dev, "Cyclades-8Zo/PCI: FPGA id %lx, "
4990 "ver %lx\n", (ulong)(0xff &
4991 readl(&((struct CUSTOM_REG *)
4992 cy_pci_addr2)->fpga_id)),
4993 (ulong)(0xff & readl(&((struct CUSTOM_REG *)
4994 cy_pci_addr2)->fpga_version)));
4995 cy_writel(&((struct RUNTIME_9060 *)
4996 cy_pci_addr0)->loc_addr_base, WIN_RAM);
4998 dev_info(&pdev->dev, "Cyclades-Z/PCI: New Cyclades-Z "
4999 "board. FPGA not loaded\n");
5002 /* The following clears the firmware id word. This
5003 ensures that the driver will not attempt to talk to
5004 the board until it has been properly initialized.
5006 if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
5007 cy_writel(cy_pci_addr2 + ID_ADDRESS, 0L);
5009 /* This must be a Cyclades-8Zo/PCI. The extendable
5010 version will have a different device_id and will
5011 be allocated its maximum number of ports. */
5014 if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
5015 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
5016 "channels are available. Change NR_PORTS in "
5017 "cyclades.c and recompile kernel.\n");
5021 /* fill the next cy_card structure available */
5022 for (j = 0; j < NR_CARDS; j++) {
5023 if (cy_card[j].base_addr == NULL)
5026 if (j == NR_CARDS) { /* no more cy_cards available */
5027 dev_err(&pdev->dev, "Cyclades-8Zo/PCI found, but no "
5028 "more cards can be used. Change NR_CARDS in "
5029 "cyclades.c and recompile kernel.\n");
5032 #ifdef CONFIG_CYZ_INTR
5033 /* allocate IRQ only if board has an IRQ */
5034 if ((cy_pci_irq != 0) && (cy_pci_irq != 255)) {
5035 retval = request_irq(cy_pci_irq, cyz_interrupt,
5036 IRQF_SHARED, "Cyclades-Z",
5039 dev_err(&pdev->dev, "could not allocate IRQ\n");
5043 #endif /* CONFIG_CYZ_INTR */
5046 cy_card[j].base_addr = cy_pci_addr2;
5047 cy_card[j].ctl_addr = cy_pci_addr0;
5048 cy_card[j].irq = cy_pci_irq;
5049 cy_card[j].bus_index = 1;
5050 cy_card[j].first_line = cy_next_channel;
5051 cy_card[j].num_chips = -1;
5052 cy_init_card(&cy_card[j]);
5053 pci_set_drvdata(pdev, &cy_card[j]);
5055 dev_info(&pdev->dev, "Cyclades-8Zo/PCI #%d found: %d channels "
5056 "starting from port %d.\n", j + 1, cy_pci_nchan,
5059 for (j = cy_next_channel;
5060 j < cy_next_channel + cy_pci_nchan; j++)
5061 tty_register_device(cy_serial_driver, j, &pdev->dev);
5062 cy_next_channel += cy_pci_nchan;
5068 static void __devexit cy_pci_remove(struct pci_dev *pdev)
5070 struct cyclades_card *cinfo = pci_get_drvdata(pdev);
5073 /* non-Z with old PLX */
5074 if (!IS_CYC_Z(*cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
5076 cy_writeb(cinfo->ctl_addr + 0x4c, 0);
5078 #ifndef CONFIG_CYZ_INTR
5079 if (!IS_CYC_Z(*cinfo))
5081 cy_writew(cinfo->ctl_addr + 0x68,
5082 readw(cinfo->ctl_addr + 0x68) & ~0x0900);
5084 pci_iounmap(pdev, cinfo->base_addr);
5085 if (cinfo->ctl_addr)
5086 pci_iounmap(pdev, cinfo->ctl_addr);
5088 #ifndef CONFIG_CYZ_INTR
5089 && !IS_CYC_Z(*cinfo)
5090 #endif /* CONFIG_CYZ_INTR */
5092 free_irq(cinfo->irq, cinfo);
5093 pci_release_regions(pdev);
5095 cinfo->base_addr = NULL;
5096 for (i = cinfo->first_line; i < cinfo->first_line +
5098 tty_unregister_device(cy_serial_driver, i);
5100 kfree(cinfo->ports);
5103 static struct pci_driver cy_pci_driver = {
5105 .id_table = cy_pci_dev_id,
5106 .probe = cy_pci_probe,
5107 .remove = __devexit_p(cy_pci_remove)
5112 cyclades_get_proc_info(char *buf, char **start, off_t offset, int length,
5113 int *eof, void *data)
5115 struct cyclades_port *info;
5121 __u32 cur_jifs = jiffies;
5123 size = sprintf(buf, "Dev TimeOpen BytesOut IdleOut BytesIn "
5124 "IdleIn Overruns Ldisc\n");
5129 /* Output one line for each known port */
5130 for (i = 0; i < NR_CARDS; i++)
5131 for (j = 0; j < cy_card[i].nports; j++) {
5132 info = &cy_card[i].ports[j];
5135 size = sprintf(buf + len, "%3d %8lu %10lu %8lu "
5136 "%10lu %8lu %9lu %6ld\n", info->line,
5137 (cur_jifs - info->idle_stats.in_use) /
5138 HZ, info->idle_stats.xmit_bytes,
5139 (cur_jifs - info->idle_stats.xmit_idle)/
5140 HZ, info->idle_stats.recv_bytes,
5141 (cur_jifs - info->idle_stats.recv_idle)/
5142 HZ, info->idle_stats.overruns,
5143 (long)info->tty->ldisc.num);
5145 size = sprintf(buf + len, "%3d %8lu %10lu %8lu "
5146 "%10lu %8lu %9lu %6ld\n",
5147 info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
5155 if (pos > offset + length)
5160 *start = buf + (offset - begin); /* Start of wanted data */
5161 len -= (offset - begin); /* Start slop */
5163 len = length; /* Ending slop */
5169 /* The serial driver boot-time initialization code!
5170 Hardware I/O ports are mapped to character special devices on a
5171 first found, first allocated manner. That is, this code searches
5172 for Cyclom cards in the system. As each is found, it is probed
5173 to discover how many chips (and thus how many ports) are present.
5174 These ports are mapped to the tty ports 32 and upward in monotonic
5175 fashion. If an 8-port card is replaced with a 16-port card, the
5176 port mapping on a following card will shift.
5178 This approach is different from what is used in the other serial
5179 device driver because the Cyclom is more properly a multiplexer,
5180 not just an aggregation of serial ports on one card.
5182 If there are more cards with more ports than have been
5183 statically allocated above, a warning is printed and the
5184 extra ports are ignored.
5187 static const struct tty_operations cy_ops = {
5191 .put_char = cy_put_char,
5192 .flush_chars = cy_flush_chars,
5193 .write_room = cy_write_room,
5194 .chars_in_buffer = cy_chars_in_buffer,
5195 .flush_buffer = cy_flush_buffer,
5197 .throttle = cy_throttle,
5198 .unthrottle = cy_unthrottle,
5199 .set_termios = cy_set_termios,
5202 .hangup = cy_hangup,
5203 .break_ctl = cy_break,
5204 .wait_until_sent = cy_wait_until_sent,
5205 .read_proc = cyclades_get_proc_info,
5206 .tiocmget = cy_tiocmget,
5207 .tiocmset = cy_tiocmset,
5210 static int __init cy_init(void)
5212 unsigned int nboards;
5213 int retval = -ENOMEM;
5215 cy_serial_driver = alloc_tty_driver(NR_PORTS);
5216 if (!cy_serial_driver)
5219 printk(KERN_INFO "Cyclades driver " CY_VERSION " (built %s %s)\n",
5220 __DATE__, __TIME__);
5222 /* Initialize the tty_driver structure */
5224 cy_serial_driver->owner = THIS_MODULE;
5225 cy_serial_driver->driver_name = "cyclades";
5226 cy_serial_driver->name = "ttyC";
5227 cy_serial_driver->major = CYCLADES_MAJOR;
5228 cy_serial_driver->minor_start = 0;
5229 cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
5230 cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
5231 cy_serial_driver->init_termios = tty_std_termios;
5232 cy_serial_driver->init_termios.c_cflag =
5233 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
5234 cy_serial_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
5235 tty_set_operations(cy_serial_driver, &cy_ops);
5237 retval = tty_register_driver(cy_serial_driver);
5239 printk(KERN_ERR "Couldn't register Cyclades serial driver\n");
5243 /* the code below is responsible to find the boards. Each different
5244 type of board has its own detection routine. If a board is found,
5245 the next cy_card structure available is set by the detection
5246 routine. These functions are responsible for checking the
5247 availability of cy_card and cy_port data structures and updating
5248 the cy_next_channel. */
5250 /* look for isa boards */
5251 nboards = cy_detect_isa();
5254 /* look for pci boards */
5255 retval = pci_register_driver(&cy_pci_driver);
5256 if (retval && !nboards)
5262 tty_unregister_driver(cy_serial_driver);
5264 put_tty_driver(cy_serial_driver);
5269 static void __exit cy_cleanup_module(void)
5271 struct cyclades_card *card;
5274 #ifndef CONFIG_CYZ_INTR
5275 del_timer_sync(&cyz_timerlist);
5276 #endif /* CONFIG_CYZ_INTR */
5278 if ((e1 = tty_unregister_driver(cy_serial_driver)))
5279 printk(KERN_ERR "failed to unregister Cyclades serial "
5280 "driver(%d)\n", e1);
5283 pci_unregister_driver(&cy_pci_driver);
5286 for (i = 0; i < NR_CARDS; i++) {
5288 if (card->base_addr) {
5289 /* clear interrupt */
5290 cy_writeb(card->base_addr + Cy_ClrIntr, 0);
5291 iounmap(card->base_addr);
5293 iounmap(card->ctl_addr);
5295 #ifndef CONFIG_CYZ_INTR
5297 #endif /* CONFIG_CYZ_INTR */
5299 free_irq(card->irq, card);
5300 for (e1 = card->first_line;
5301 e1 < card->first_line +
5303 tty_unregister_device(cy_serial_driver, e1);
5308 put_tty_driver(cy_serial_driver);
5309 } /* cy_cleanup_module */
5311 module_init(cy_init);
5312 module_exit(cy_cleanup_module);
5314 MODULE_LICENSE("GPL");