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