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