projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Char: cyclades, timer cleanup
[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
02f1175c
JS		 821static unsigned short cy_pci_nboard;
822static unsigned short cy_isa_nboard;
823static unsigned short cy_nboard;
1da177e4 824#ifdef CONFIG_PCI
893de2df
JS		 825static struct pci_device_id cy_pci_dev_id[] __devinitdata = {
826 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo) }, /* PCI < 1Mb */
827 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Hi) }, /* PCI > 1Mb */
828 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Lo) }, /* 4Y PCI < 1Mb */
829 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_4Y_Hi) }, /* 4Y PCI > 1Mb */
830 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Lo) }, /* 8Y PCI < 1Mb */
831 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_8Y_Hi) }, /* 8Y PCI > 1Mb */
832 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Lo) }, /* Z PCI < 1Mb */
833 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Z_Hi) }, /* Z PCI > 1Mb */
834 { } /* end of table */
02f1175c 835};
893de2df 836MODULE_DEVICE_TABLE(pci, cy_pci_dev_id);
1da177e4
LT		 837#endif
838
839static void cy_start(struct tty_struct *);
840static void set_line_char(struct cyclades_port *);
1a86b5e3 841static int cyz_issue_cmd(struct cyclades_card *, __u32, __u8, __u32);
1da177e4
LT		 842#ifdef CONFIG_ISA
843static unsigned detect_isa_irq(void __iomem *);
02f1175c 844#endif /* CONFIG_ISA */
1da177e4 845
02f1175c 846static int cyclades_get_proc_info(char *, char **, off_t, int, int *, void *);
1da177e4
LT		 847
848#ifndef CONFIG_CYZ_INTR
849static void cyz_poll(unsigned long);
850
851/* The Cyclades-Z polling cycle is defined by this variable */
852static long cyz_polling_cycle = CZ_DEF_POLL;
853
8d06afab 854static DEFINE_TIMER(cyz_timerlist, cyz_poll, 0, 0);
1da177e4 855
02f1175c 856#else /* CONFIG_CYZ_INTR */
1da177e4
LT		 857static void cyz_rx_restart(unsigned long);
858static struct timer_list cyz_rx_full_timer[NR_PORTS];
02f1175c 859#endif /* CONFIG_CYZ_INTR */
1da177e4 860
02f1175c
JS		 861static inline int serial_paranoia_check(struct cyclades_port *info,
862 char *name, const char *routine)
1da177e4
LT		 863{
864#ifdef SERIAL_PARANOIA_CHECK
02f1175c 865 if (!info) {
096dcfce
JS		 866 printk("cyc Warning: null cyclades_port for (%s) in %s\n",
867 name, routine);
02f1175c
JS		 868 return 1;
869 }
870
871 if ((long)info < (long)(&cy_port[0]) ||
872 (long)(&cy_port[NR_PORTS]) < (long)info) {
096dcfce
JS		 873 printk("cyc Warning: cyclades_port out of range for (%s) in "
874 "%s\n", name, routine);
02f1175c
JS		 875 return 1;
876 }
877
878 if (info->magic != CYCLADES_MAGIC) {
096dcfce
JS		 879 printk("cyc Warning: bad magic number for serial struct (%s) "
880 "in %s\n", name, routine);
02f1175c
JS		 881 return 1;
882 }
1da177e4 883#endif
02f1175c
JS		 884 return 0;
885} /* serial_paranoia_check */
1da177e4
LT		 886
887/*
888 * This routine is used by the interrupt handler to schedule
889 * processing in the software interrupt portion of the driver
890 * (also known as the "bottom half"). This can be called any
891 * number of times for any channel without harm.
892 */
02f1175c 893static inline void cy_sched_event(struct cyclades_port *info, int event)
1da177e4 894{
02f1175c
JS		 895 info->event |= 1 << event; /* remember what kind of event and who */
896 schedule_work(&info->tqueue);
897} /* cy_sched_event */
1da177e4
LT		 898
899/*
900 * This routine is used to handle the "bottom half" processing for the
901 * serial driver, known also the "software interrupt" processing.
902 * This processing is done at the kernel interrupt level, after the
903 * cy#/_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON. This
904 * is where time-consuming activities which can not be done in the
905 * interrupt driver proper are done; the interrupt driver schedules
906 * them using cy_sched_event(), and they get done here.
907 *
908 * This is done through one level of indirection--the task queue.
909 * When a hardware interrupt service routine wants service by the
910 * driver's bottom half, it enqueues the appropriate tq_struct (one
911 * per port) to the keventd work queue and sets a request flag
912 * that the work queue be processed.
913 *
914 * Although this may seem unwieldy, it gives the system a way to
915 * pass an argument (in this case the pointer to the cyclades_port
916 * structure) to the bottom half of the driver. Previous kernels
917 * had to poll every port to see if that port needed servicing.
918 */
919static void
c4028958 920do_softint(struct work_struct *work)
1da177e4 921{
c4028958
DH		 922 struct cyclades_port *info =
923 container_of(work, struct cyclades_port, tqueue);
02f1175c
JS		 924 struct tty_struct *tty;
925
926 tty = info->tty;
927 if (!tty)
928 return;
929
930 if (test_and_clear_bit(Cy_EVENT_HANGUP, &info->event)) {
931 tty_hangup(info->tty);
932 wake_up_interruptible(&info->open_wait);
933 info->flags &= ~ASYNC_NORMAL_ACTIVE;
934 }
935 if (test_and_clear_bit(Cy_EVENT_OPEN_WAKEUP, &info->event))
936 wake_up_interruptible(&info->open_wait);
1da177e4 937#ifdef CONFIG_CYZ_INTR
02f1175c
JS		 938 if (test_and_clear_bit(Cy_EVENT_Z_RX_FULL, &info->event)) {
939 if (cyz_rx_full_timer[info->line].function == NULL) {
940 cyz_rx_full_timer[info->line].expires = jiffies + 1;
941 cyz_rx_full_timer[info->line].function = cyz_rx_restart;
942 cyz_rx_full_timer[info->line].data =
943 (unsigned long)info;
944 add_timer(&cyz_rx_full_timer[info->line]);
945 }
1da177e4 946 }
1da177e4 947#endif
02f1175c
JS		 948 if (test_and_clear_bit(Cy_EVENT_DELTA_WAKEUP, &info->event))
949 wake_up_interruptible(&info->delta_msr_wait);
950 tty_wakeup(tty);
1da177e4 951#ifdef Z_WAKE
02f1175c
JS		 952 if (test_and_clear_bit(Cy_EVENT_SHUTDOWN_WAKEUP, &info->event))
953 wake_up_interruptible(&info->shutdown_wait);
1da177e4
LT		 954#endif
955} /* do_softint */
956
957
958/***********************************************************/
959/********* Start of block of Cyclom-Y specific code ********/
960
961/* This routine waits up to 1000 micro-seconds for the previous
962 command to the Cirrus chip to complete and then issues the
963 new command. An error is returned if the previous command
964 didn't finish within the time limit.
965
966 This function is only called from inside spinlock-protected code.
967 */
02f1175c 968static int cyy_issue_cmd(void __iomem * base_addr, u_char cmd, int index)
1da177e4 969{
02f1175c 970 volatile int i;
1da177e4 971
02f1175c
JS		 972 /* Check to see that the previous command has completed */
973 for (i = 0; i < 100; i++) {
db05c3b1 974 if (readb(base_addr + (CyCCR << index)) == 0) {
02f1175c
JS		 975 break;
976 }
977 udelay(10L);
1da177e4 978 }
02f1175c
JS		 979 /* if the CCR never cleared, the previous command
980 didn't finish within the "reasonable time" */
981 if (i == 100)
096dcfce 982 return -1;
1da177e4 983
02f1175c
JS		 984 /* Issue the new command */
985 cy_writeb(base_addr + (CyCCR << index), cmd);
1da177e4 986
096dcfce 987 return 0;
02f1175c 988} /* cyy_issue_cmd */
1da177e4
LT		 989
990#ifdef CONFIG_ISA
991/* ISA interrupt detection code */
02f1175c 992static unsigned detect_isa_irq(void __iomem * address)
1da177e4 993{
02f1175c
JS		 994 int irq;
995 unsigned long irqs, flags;
996 int save_xir, save_car;
997 int index = 0; /* IRQ probing is only for ISA */
998
999 /* forget possible initially masked and pending IRQ */
1000 irq = probe_irq_off(probe_irq_on());
1001
1002 /* Clear interrupts on the board first */
1003 cy_writeb(address + (Cy_ClrIntr << index), 0);
1004 /* Cy_ClrIntr is 0x1800 */
1005
1006 irqs = probe_irq_on();
1007 /* Wait ... */
1008 udelay(5000L);
1009
1010 /* Enable the Tx interrupts on the CD1400 */
1011 local_irq_save(flags);
1012 cy_writeb(address + (CyCAR << index), 0);
1013 cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
1014
1015 cy_writeb(address + (CyCAR << index), 0);
1016 cy_writeb(address + (CySRER << index),
db05c3b1 1017 readb(address + (CySRER << index)) | CyTxRdy);
02f1175c
JS		 1018 local_irq_restore(flags);
1019
1020 /* Wait ... */
1021 udelay(5000L);
1022
1023 /* Check which interrupt is in use */
1024 irq = probe_irq_off(irqs);
1025
1026 /* Clean up */
db05c3b1
JS		 1027 save_xir = (u_char) readb(address + (CyTIR << index));
1028 save_car = readb(address + (CyCAR << index));
02f1175c
JS		 1029 cy_writeb(address + (CyCAR << index), (save_xir & 0x3));
1030 cy_writeb(address + (CySRER << index),
db05c3b1 1031 readb(address + (CySRER << index)) & ~CyTxRdy);
02f1175c
JS		 1032 cy_writeb(address + (CyTIR << index), (save_xir & 0x3f));
1033 cy_writeb(address + (CyCAR << index), (save_car));
1034 cy_writeb(address + (Cy_ClrIntr << index), 0);
1035 /* Cy_ClrIntr is 0x1800 */
1036
1037 return (irq > 0) ? irq : 0;
1da177e4 1038}
02f1175c 1039#endif /* CONFIG_ISA */
1da177e4 1040
e941027f 1041static void cyy_intr_chip(struct cyclades_card *cinfo, int chip,
02f1175c 1042 void __iomem * base_addr, int status, int index)
e941027f
JS		 1043{
1044 struct cyclades_port *info;
1045 struct tty_struct *tty;
1046 volatile int char_count;
1047 int i, j, len, mdm_change, mdm_status, outch;
1048 int save_xir, channel, save_car;
1049 char data;
1050
02f1175c 1051 if (status & CySRReceive) { /* reception interrupt */
e941027f 1052#ifdef CY_DEBUG_INTERRUPTS
02f1175c 1053 printk("cyy_interrupt: rcvd intr, chip %d\n\r", chip);
e941027f 1054#endif
02f1175c
JS		 1055 /* determine the channel & change to that context */
1056 spin_lock(&cinfo->card_lock);
db05c3b1 1057 save_xir = (u_char) readb(base_addr + (CyRIR << index));
02f1175c
JS		 1058 channel = (u_short) (save_xir & CyIRChannel);
1059 i = channel + chip * 4 + cinfo->first_line;
1060 info = &cy_port[i];
1061 info->last_active = jiffies;
db05c3b1 1062 save_car = readb(base_addr + (CyCAR << index));
02f1175c
JS		 1063 cy_writeb(base_addr + (CyCAR << index), save_xir);
1064
1065 /* if there is nowhere to put the data, discard it */
1066 if (info->tty == 0) {
db05c3b1 1067 j = (readb(base_addr + (CyRIVR << index)) &
02f1175c
JS		 1068 CyIVRMask);
1069 if (j == CyIVRRxEx) { /* exception */
db05c3b1 1070 data = readb(base_addr + (CyRDSR << index));
02f1175c 1071 } else { /* normal character reception */
db05c3b1 1072 char_count = readb(base_addr +
02f1175c
JS		 1073 (CyRDCR << index));
1074 while (char_count--) {
db05c3b1 1075 data = readb(base_addr +
02f1175c 1076 (CyRDSR << index));
e941027f 1077 }
e941027f 1078 }
02f1175c
JS		 1079 } else { /* there is an open port for this data */
1080 tty = info->tty;
db05c3b1 1081 j = (readb(base_addr + (CyRIVR << index)) &
02f1175c
JS		 1082 CyIVRMask);
1083 if (j == CyIVRRxEx) { /* exception */
db05c3b1 1084 data = readb(base_addr + (CyRDSR << index));
02f1175c
JS		 1085
1086 /* For statistics only */
1087 if (data & CyBREAK)
1088 info->icount.brk++;
1089 else if (data & CyFRAME)
1090 info->icount.frame++;
1091 else if (data & CyPARITY)
1092 info->icount.parity++;
1093 else if (data & CyOVERRUN)
1094 info->icount.overrun++;
1095
1096 if (data & info->ignore_status_mask) {
1097 info->icount.rx++;
1098 return;
1099 }
1100 if (tty_buffer_request_room(tty, 1)) {
1101 if (data & info->read_status_mask) {
1102 if (data & CyBREAK) {
1103 tty_insert_flip_char(
1104 tty,
db05c3b1 1105 readb(
02f1175c
JS		 1106 base_addr +
1107 (CyRDSR <<
1108 index)),
1109 TTY_BREAK);
1110 info->icount.rx++;
1111 if (info->flags &
1112 ASYNC_SAK) {
1113 do_SAK(tty);
1114 }
1115 } else if (data & CyFRAME) {
1116 tty_insert_flip_char(
1117 tty,
db05c3b1 1118 readb(
02f1175c
JS		 1119 base_addr +
1120 (CyRDSR <<
1121 index)),
1122 TTY_FRAME);
1123 info->icount.rx++;
1124 info->idle_stats.
1125 frame_errs++;
1126 } else if (data & CyPARITY) {
1127 /* Pieces of seven... */
1128 tty_insert_flip_char(
1129 tty,
db05c3b1 1130 readb(
02f1175c
JS		 1131 base_addr +
1132 (CyRDSR <<
1133 index)),
1134 TTY_PARITY);
1135 info->icount.rx++;
1136 info->idle_stats.
1137 parity_errs++;
1138 } else if (data & CyOVERRUN) {
1139 tty_insert_flip_char(
1140 tty, 0,
1141 TTY_OVERRUN);
1142 info->icount.rx++;
1143 /* If the flip buffer itself is
1144 overflowing, we still lose
1145 the next incoming character.
1146 */
1147 tty_insert_flip_char(
1148 tty,
db05c3b1 1149 readb(
02f1175c
JS		 1150 base_addr +
1151 (CyRDSR <<
1152 index)),
1153 TTY_FRAME);
1154 info->icount.rx++;
1155 info->idle_stats.
1156 overruns++;
1157 /* These two conditions may imply */
1158 /* a normal read should be done. */
1159 /* }else if(data & CyTIMEOUT){ */
1160 /* }else if(data & CySPECHAR){ */
1161 } else {
1162 tty_insert_flip_char(
1163 tty, 0,
1164 TTY_NORMAL);
1165 info->icount.rx++;
1166 }
1167 } else {
1168 tty_insert_flip_char(tty, 0,
1169 TTY_NORMAL);
1170 info->icount.rx++;
1171 }
1172 } else {
1173 /* there was a software buffer
1174 overrun and nothing could be
1175 done about it!!! */
1176 info->icount.buf_overrun++;
1177 info->idle_stats.overruns++;
1178 }
1179 } else { /* normal character reception */
1180 /* load # chars available from the chip */
db05c3b1 1181 char_count = readb(base_addr +
02f1175c 1182 (CyRDCR << index));
e941027f
JS		 1183
1184#ifdef CY_ENABLE_MONITORING
02f1175c
JS		 1185 ++info->mon.int_count;
1186 info->mon.char_count += char_count;
1187 if (char_count > info->mon.char_max)
1188 info->mon.char_max = char_count;
1189 info->mon.char_last = char_count;
e941027f 1190#endif
02f1175c
JS		 1191 len = tty_buffer_request_room(tty, char_count);
1192 while (len--) {
db05c3b1 1193 data = readb(base_addr +
02f1175c
JS		 1194 (CyRDSR << index));
1195 tty_insert_flip_char(tty, data,
1196 TTY_NORMAL);
1197 info->idle_stats.recv_bytes++;
1198 info->icount.rx++;
e941027f 1199#ifdef CY_16Y_HACK
02f1175c 1200 udelay(10L);
e941027f 1201#endif
02f1175c
JS		 1202 }
1203 info->idle_stats.recv_idle = jiffies;
1204 }
1205 tty_schedule_flip(tty);
e941027f 1206 }
02f1175c
JS		 1207 /* end of service */
1208 cy_writeb(base_addr + (CyRIR << index), (save_xir & 0x3f));
1209 cy_writeb(base_addr + (CyCAR << index), (save_car));
1210 spin_unlock(&cinfo->card_lock);
e941027f
JS		 1211 }
1212
02f1175c
JS		 1213 if (status & CySRTransmit) { /* transmission interrupt */
1214 /* Since we only get here when the transmit buffer
1215 is empty, we know we can always stuff a dozen
1216 characters. */
e941027f 1217#ifdef CY_DEBUG_INTERRUPTS
02f1175c 1218 printk("cyy_interrupt: xmit intr, chip %d\n\r", chip);
e941027f
JS		 1219#endif
1220
02f1175c
JS		 1221 /* determine the channel & change to that context */
1222 spin_lock(&cinfo->card_lock);
db05c3b1 1223 save_xir = (u_char) readb(base_addr + (CyTIR << index));
02f1175c
JS		 1224 channel = (u_short) (save_xir & CyIRChannel);
1225 i = channel + chip * 4 + cinfo->first_line;
db05c3b1 1226 save_car = readb(base_addr + (CyCAR << index));
02f1175c
JS		 1227 cy_writeb(base_addr + (CyCAR << index), save_xir);
1228
1229 /* validate the port# (as configured and open) */
1230 if ((i < 0) || (NR_PORTS <= i)) {
1231 cy_writeb(base_addr + (CySRER << index),
db05c3b1 1232 readb(base_addr + (CySRER << index)) &
02f1175c
JS		 1233 ~CyTxRdy);
1234 goto txend;
e941027f 1235 }
02f1175c
JS		 1236 info = &cy_port[i];
1237 info->last_active = jiffies;
1238 if (info->tty == 0) {
1239 cy_writeb(base_addr + (CySRER << index),
db05c3b1 1240 readb(base_addr + (CySRER << index)) &
02f1175c
JS		 1241 ~CyTxRdy);
1242 goto txdone;
e941027f 1243 }
02f1175c
JS		 1244
1245 /* load the on-chip space for outbound data */
1246 char_count = info->xmit_fifo_size;
1247
1248 if (info->x_char) { /* send special char */
1249 outch = info->x_char;
1250 cy_writeb(base_addr + (CyTDR << index), outch);
1251 char_count--;
1252 info->icount.tx++;
1253 info->x_char = 0;
e941027f 1254 }
02f1175c
JS		 1255
1256 if (info->breakon || info->breakoff) {
1257 if (info->breakon) {
1258 cy_writeb(base_addr + (CyTDR << index), 0);
1259 cy_writeb(base_addr + (CyTDR << index), 0x81);
1260 info->breakon = 0;
1261 char_count -= 2;
1262 }
1263 if (info->breakoff) {
1264 cy_writeb(base_addr + (CyTDR << index), 0);
1265 cy_writeb(base_addr + (CyTDR << index), 0x83);
1266 info->breakoff = 0;
1267 char_count -= 2;
1268 }
e941027f 1269 }
02f1175c
JS		 1270
1271 while (char_count-- > 0) {
1272 if (!info->xmit_cnt) {
db05c3b1 1273 if (readb(base_addr + (CySRER << index)) &
02f1175c
JS		 1274 CyTxMpty) {
1275 cy_writeb(base_addr + (CySRER << index),
db05c3b1 1276 readb(base_addr +
02f1175c
JS		 1277 (CySRER << index)) &
1278 ~CyTxMpty);
1279 } else {
1280 cy_writeb(base_addr + (CySRER << index),
db05c3b1 1281 (readb(base_addr +
02f1175c
JS		 1282 (CySRER << index)) &
1283 ~CyTxRdy) | CyTxMpty);
1284 }
1285 goto txdone;
1286 }
1287 if (info->xmit_buf == 0) {
1288 cy_writeb(base_addr + (CySRER << index),
db05c3b1 1289 readb(base_addr + (CySRER << index)) &
02f1175c
JS		 1290 ~CyTxRdy);
1291 goto txdone;
1292 }
1293 if (info->tty->stopped || info->tty->hw_stopped) {
1294 cy_writeb(base_addr + (CySRER << index),
db05c3b1 1295 readb(base_addr + (CySRER << index)) &
02f1175c
JS		 1296 ~CyTxRdy);
1297 goto txdone;
1298 }
1299 /* Because the Embedded Transmit Commands have
1300 been enabled, we must check to see if the
1301 escape character, NULL, is being sent. If it
1302 is, we must ensure that there is room for it
1303 to be doubled in the output stream. Therefore
1304 we no longer advance the pointer when the
1305 character is fetched, but rather wait until
1306 after the check for a NULL output character.
1307 This is necessary because there may not be
1308 room for the two chars needed to send a NULL.)
1309 */
1310 outch = info->xmit_buf[info->xmit_tail];
1311 if (outch) {
1312 info->xmit_cnt--;
1313 info->xmit_tail = (info->xmit_tail + 1) &
1314 (SERIAL_XMIT_SIZE - 1);
1315 cy_writeb(base_addr + (CyTDR << index), outch);
1316 info->icount.tx++;
1317 } else {
1318 if (char_count > 1) {
1319 info->xmit_cnt--;
1320 info->xmit_tail = (info->xmit_tail + 1)&
1321 (SERIAL_XMIT_SIZE - 1);
1322 cy_writeb(base_addr + (CyTDR << index),
1323 outch);
1324 cy_writeb(base_addr + (CyTDR << index),
1325 0);
1326 info->icount.tx++;
1327 char_count--;
1328 } else {
1329 }
1330 }
e941027f 1331 }
e941027f
JS		 1332
1333txdone:
02f1175c
JS		 1334 if (info->xmit_cnt < WAKEUP_CHARS) {
1335 cy_sched_event(info, Cy_EVENT_WRITE_WAKEUP);
1336 }
e941027f 1337txend:
02f1175c
JS		 1338 /* end of service */
1339 cy_writeb(base_addr + (CyTIR << index), (save_xir & 0x3f));
1340 cy_writeb(base_addr + (CyCAR << index), (save_car));
1341 spin_unlock(&cinfo->card_lock);
e941027f
JS		 1342 }
1343
02f1175c 1344 if (status & CySRModem) { /* modem interrupt */
e941027f 1345
02f1175c
JS		 1346 /* determine the channel & change to that context */
1347 spin_lock(&cinfo->card_lock);
db05c3b1 1348 save_xir = (u_char) readb(base_addr + (CyMIR << index));
02f1175c
JS		 1349 channel = (u_short) (save_xir & CyIRChannel);
1350 info = &cy_port[channel + chip * 4 + cinfo->first_line];
1351 info->last_active = jiffies;
db05c3b1 1352 save_car = readb(base_addr + (CyCAR << index));
02f1175c
JS		 1353 cy_writeb(base_addr + (CyCAR << index), save_xir);
1354
db05c3b1
JS		 1355 mdm_change = readb(base_addr + (CyMISR << index));
1356 mdm_status = readb(base_addr + (CyMSVR1 << index));
02f1175c
JS		 1357
1358 if (info->tty == 0) { /* no place for data, ignore it */
1359 ;
1360 } else {
1361 if (mdm_change & CyANY_DELTA) {
1362 /* For statistics only */
1363 if (mdm_change & CyDCD)
1364 info->icount.dcd++;
1365 if (mdm_change & CyCTS)
1366 info->icount.cts++;
1367 if (mdm_change & CyDSR)
1368 info->icount.dsr++;
1369 if (mdm_change & CyRI)
1370 info->icount.rng++;
1371
1372 cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
e941027f 1373 }
02f1175c
JS		 1374
1375 if ((mdm_change & CyDCD) &&
1376 (info->flags & ASYNC_CHECK_CD)) {
1377 if (mdm_status & CyDCD) {
1378 cy_sched_event(info,
1379 Cy_EVENT_OPEN_WAKEUP);
1380 } else {
1381 cy_sched_event(info, Cy_EVENT_HANGUP);
1382 }
1383 }
1384 if ((mdm_change & CyCTS) &&
1385 (info->flags & ASYNC_CTS_FLOW)) {
1386 if (info->tty->hw_stopped) {
1387 if (mdm_status & CyCTS) {
1388 /* cy_start isn't used
1389 because... !!! */
1390 info->tty->hw_stopped = 0;
1391 cy_writeb(base_addr +
1392 (CySRER << index),
db05c3b1 1393 readb(base_addr +
02f1175c
JS		 1394 (CySRER <<
1395 index))|
1396 CyTxRdy);
1397 cy_sched_event(info,
1398 Cy_EVENT_WRITE_WAKEUP);
1399 }
1400 } else {
1401 if (!(mdm_status & CyCTS)) {
1402 /* cy_stop isn't used
1403 because ... !!! */
1404 info->tty->hw_stopped = 1;
1405 cy_writeb(base_addr +
1406 (CySRER << index),
db05c3b1 1407 readb(base_addr +
02f1175c
JS		 1408 (CySRER <<
1409 index)) &
1410 ~CyTxRdy);
1411 }
1412 }
1413 }
1414 if (mdm_change & CyDSR) {
1415 }
1416 if (mdm_change & CyRI) {
e941027f 1417 }
e941027f 1418 }
02f1175c
JS		 1419 /* end of service */
1420 cy_writeb(base_addr + (CyMIR << index), (save_xir & 0x3f));
1421 cy_writeb(base_addr + (CyCAR << index), save_car);
1422 spin_unlock(&cinfo->card_lock);
e941027f
JS		 1423 }
1424}
1425
1da177e4
LT		 1426/* The real interrupt service routine is called
1427 whenever the card wants its hand held--chars
1428 received, out buffer empty, modem change, etc.
1429 */
02f1175c 1430static irqreturn_t cyy_interrupt(int irq, void *dev_id)
1da177e4 1431{
02f1175c
JS		 1432 int status;
1433 struct cyclades_card *cinfo;
1434 void __iomem *base_addr, *card_base_addr;
1435 int chip;
1436 int index;
1437 int too_many;
1438 int had_work;
1439
1440 if ((cinfo = (struct cyclades_card *)dev_id) == 0) {
1da177e4 1441#ifdef CY_DEBUG_INTERRUPTS
02f1175c 1442 printk("cyy_interrupt: spurious interrupt %d\n\r", irq);
1da177e4 1443#endif
02f1175c
JS		 1444 return IRQ_NONE; /* spurious interrupt */
1445 }
1446
1447 card_base_addr = cinfo->base_addr;
1448 index = cinfo->bus_index;
1449
1450 /* This loop checks all chips in the card. Make a note whenever
1451 _any_ chip had some work to do, as this is considered an
1452 indication that there will be more to do. Only when no chip
1453 has any work does this outermost loop exit.
1454 */
1455 do {
1456 had_work = 0;
1457 for (chip = 0; chip < cinfo->num_chips; chip++) {
1458 base_addr = cinfo->base_addr +
1459 (cy_chip_offset[chip] << index);
1460 too_many = 0;
db05c3b1 1461 while ((status = readb(base_addr +
02f1175c
JS		 1462 (CySVRR << index))) != 0x00) {
1463 had_work++;
1464 /* The purpose of the following test is to ensure that
1465 no chip can monopolize the driver. This forces the
1466 chips to be checked in a round-robin fashion (after
1467 draining each of a bunch (1000) of characters).
1468 */
1469 if (1000 < too_many++) {
1470 break;
1471 }
1472 cyy_intr_chip(cinfo, chip, base_addr, status,
1473 index);
1474 }
1475 }
1476 } while (had_work);
1477
1478 /* clear interrupts */
1479 spin_lock(&cinfo->card_lock);
1480 cy_writeb(card_base_addr + (Cy_ClrIntr << index), 0);
1481 /* Cy_ClrIntr is 0x1800 */
1482 spin_unlock(&cinfo->card_lock);
1483 return IRQ_HANDLED;
1484} /* cyy_interrupt */
1da177e4
LT		 1485
1486/***********************************************************/
1487/********* End of block of Cyclom-Y specific code **********/
1488/******** Start of block of Cyclades-Z specific code *********/
1489/***********************************************************/
1490
1491static int
02f1175c 1492cyz_fetch_msg(struct cyclades_card *cinfo,
1a86b5e3 1493 __u32 * channel, __u8 * cmd, __u32 * param)
1da177e4 1494{
02f1175c
JS		 1495 struct FIRM_ID __iomem *firm_id;
1496 struct ZFW_CTRL __iomem *zfw_ctrl;
1497 struct BOARD_CTRL __iomem *board_ctrl;
1498 unsigned long loc_doorbell;
1499
1500 firm_id = cinfo->base_addr + ID_ADDRESS;
1501 if (!ISZLOADED(*cinfo)) {
096dcfce 1502 return -1;
02f1175c 1503 }
db05c3b1 1504 zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
02f1175c
JS		 1505 board_ctrl = &zfw_ctrl->board_ctrl;
1506
db05c3b1 1507 loc_doorbell = readl(&((struct RUNTIME_9060 __iomem *)
02f1175c
JS		 1508 (cinfo->ctl_addr))->loc_doorbell);
1509 if (loc_doorbell) {
1510 *cmd = (char)(0xff & loc_doorbell);
db05c3b1
JS		 1511 *channel = readl(&board_ctrl->fwcmd_channel);
1512 *param = (__u32) readl(&board_ctrl->fwcmd_param);
02f1175c
JS		 1513 cy_writel(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->
1514 loc_doorbell, 0xffffffff);
1515 return 1;
1516 }
1517 return 0;
1518} /* cyz_fetch_msg */
1da177e4
LT		 1519
1520static int
02f1175c 1521cyz_issue_cmd(struct cyclades_card *cinfo,
1a86b5e3 1522 __u32 channel, __u8 cmd, __u32 param)
1da177e4 1523{
02f1175c
JS		 1524 struct FIRM_ID __iomem *firm_id;
1525 struct ZFW_CTRL __iomem *zfw_ctrl;
1526 struct BOARD_CTRL __iomem *board_ctrl;
1a86b5e3 1527 __u32 __iomem *pci_doorbell;
02f1175c
JS		 1528 int index;
1529
1530 firm_id = cinfo->base_addr + ID_ADDRESS;
1531 if (!ISZLOADED(*cinfo)) {
096dcfce 1532 return -1;
02f1175c 1533 }
db05c3b1 1534 zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
02f1175c
JS		 1535 board_ctrl = &zfw_ctrl->board_ctrl;
1536
1537 index = 0;
1538 pci_doorbell =
1539 &((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->pci_doorbell;
db05c3b1 1540 while ((readl(pci_doorbell) & 0xff) != 0) {
02f1175c 1541 if (index++ == 1000) {
db05c3b1 1542 return (int)(readl(pci_doorbell) & 0xff);
02f1175c
JS		 1543 }
1544 udelay(50L);
1545 }
1546 cy_writel(&board_ctrl->hcmd_channel, channel);
1547 cy_writel(&board_ctrl->hcmd_param, param);
1548 cy_writel(pci_doorbell, (long)cmd);
1549
096dcfce 1550 return 0;
02f1175c 1551} /* cyz_issue_cmd */
1da177e4
LT		 1552
1553static void
1554cyz_handle_rx(struct cyclades_port *info,
02f1175c
JS		 1555 volatile struct CH_CTRL __iomem * ch_ctrl,
1556 volatile 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;
1560 volatile int char_count;
1561 int len;
1da177e4 1562#ifdef BLOCKMOVE
02f1175c 1563 int small_count;
1da177e4 1564#else
02f1175c 1565 char data;
1da177e4 1566#endif
1a86b5e3 1567 volatile __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
1651cyz_handle_tx(struct cyclades_port *info,
02f1175c
JS		 1652 volatile struct CH_CTRL __iomem * ch_ctrl,
1653 volatile struct BUF_CTRL __iomem * buf_ctrl)
1da177e4 1654{
02f1175c
JS		 1655 struct cyclades_card *cinfo = &cy_card[info->card];
1656 struct tty_struct *tty = info->tty;
1657 char data;
1658 volatile int char_count;
1da177e4 1659#ifdef BLOCKMOVE
02f1175c 1660 int small_count;
1da177e4 1661#endif
1a86b5e3 1662 volatile __u32 tx_put, tx_get, tx_bufsize, tx_bufaddr;
1da177e4 1663
02f1175c
JS		 1664 if (info->xmit_cnt <= 0) /* Nothing to transmit */
1665 return;
1da177e4 1666
db05c3b1
JS		 1667 tx_get = readl(&buf_ctrl->tx_get);
1668 tx_put = readl(&buf_ctrl->tx_put);
1669 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
1670 tx_bufaddr = readl(&buf_ctrl->tx_bufaddr);
02f1175c
JS		 1671 if (tx_put >= tx_get)
1672 char_count = tx_get - tx_put - 1 + tx_bufsize;
1673 else
1674 char_count = tx_get - tx_put - 1;
1da177e4 1675
02f1175c 1676 if (char_count) {
1da177e4 1677
02f1175c
JS		 1678 if (tty == 0) {
1679 goto ztxdone;
1680 }
1da177e4 1681
02f1175c
JS		 1682 if (info->x_char) { /* send special char */
1683 data = info->x_char;
1da177e4 1684
02f1175c
JS		 1685 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1686 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1687 info->x_char = 0;
1688 char_count--;
1689 info->icount.tx++;
1690 info->last_active = jiffies;
1691 info->jiffies[2] = jiffies;
1692 }
1da177e4 1693#ifdef BLOCKMOVE
02f1175c
JS		 1694 while (0 < (small_count = min_t(unsigned int,
1695 tx_bufsize - tx_put, min_t(unsigned int,
1696 (SERIAL_XMIT_SIZE - info->xmit_tail),
1697 min_t(unsigned int, info->xmit_cnt,
1698 char_count))))) {
1699
1700 memcpy_toio((char *)(cinfo->base_addr + tx_bufaddr +
1701 tx_put),
1702 &info->xmit_buf[info->xmit_tail],
1703 small_count);
1704
1705 tx_put = (tx_put + small_count) & (tx_bufsize - 1);
1706 char_count -= small_count;
1707 info->icount.tx += small_count;
1708 info->xmit_cnt -= small_count;
1709 info->xmit_tail = (info->xmit_tail + small_count) &
1710 (SERIAL_XMIT_SIZE - 1);
1711 info->last_active = jiffies;
1712 info->jiffies[2] = jiffies;
1713 }
1da177e4 1714#else
02f1175c
JS		 1715 while (info->xmit_cnt && char_count) {
1716 data = info->xmit_buf[info->xmit_tail];
1717 info->xmit_cnt--;
1718 info->xmit_tail = (info->xmit_tail + 1) &
1719 (SERIAL_XMIT_SIZE - 1);
1720
1721 cy_writeb(cinfo->base_addr + tx_bufaddr + tx_put, data);
1722 tx_put = (tx_put + 1) & (tx_bufsize - 1);
1723 char_count--;
1724 info->icount.tx++;
1725 info->last_active = jiffies;
1726 info->jiffies[2] = jiffies;
1727 }
1da177e4 1728#endif
02f1175c
JS		 1729ztxdone:
1730 if (info->xmit_cnt < WAKEUP_CHARS) {
1731 cy_sched_event(info, Cy_EVENT_WRITE_WAKEUP);
1732 }
1733 /* Update tx_put */
1734 cy_writel(&buf_ctrl->tx_put, tx_put);
1da177e4 1735 }
1da177e4
LT		 1736}
1737
02f1175c 1738static void cyz_handle_cmd(struct cyclades_card *cinfo)
1da177e4 1739{
02f1175c
JS		 1740 struct tty_struct *tty;
1741 struct cyclades_port *info;
1742 static volatile struct FIRM_ID __iomem *firm_id;
1743 static volatile struct ZFW_CTRL __iomem *zfw_ctrl;
1744 static volatile struct BOARD_CTRL __iomem *board_ctrl;
1745 static volatile struct CH_CTRL __iomem *ch_ctrl;
1746 static volatile struct BUF_CTRL __iomem *buf_ctrl;
1a86b5e3
KK		 1747 __u32 channel;
1748 __u8 cmd;
1749 __u32 param;
1750 __u32 hw_ver, fw_ver;
02f1175c
JS		 1751 int special_count;
1752 int delta_count;
1753
1754 firm_id = cinfo->base_addr + ID_ADDRESS;
db05c3b1 1755 zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
02f1175c 1756 board_ctrl = &zfw_ctrl->board_ctrl;
db05c3b1
JS		 1757 fw_ver = readl(&board_ctrl->fw_version);
1758 hw_ver = readl(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->
02f1175c
JS		 1759 mail_box_0);
1760
1761 while (cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) {
1762 special_count = 0;
1763 delta_count = 0;
1764 info = &cy_port[channel + cinfo->first_line];
1765 if ((tty = info->tty) == 0) {
1766 continue;
1da177e4 1767 }
02f1175c
JS		 1768 ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
1769 buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
1770
1771 switch (cmd) {
1772 case C_CM_PR_ERROR:
1773 tty_insert_flip_char(tty, 0, TTY_PARITY);
1774 info->icount.rx++;
1775 special_count++;
1776 break;
1777 case C_CM_FR_ERROR:
1778 tty_insert_flip_char(tty, 0, TTY_FRAME);
1779 info->icount.rx++;
1780 special_count++;
1781 break;
1782 case C_CM_RXBRK:
1783 tty_insert_flip_char(tty, 0, TTY_BREAK);
1784 info->icount.rx++;
1785 special_count++;
1786 break;
1787 case C_CM_MDCD:
1788 info->icount.dcd++;
1789 delta_count++;
1790 if (info->flags & ASYNC_CHECK_CD) {
1791 if ((fw_ver > 241 ? ((u_long) param) :
db05c3b1 1792 readl(&ch_ctrl->rs_status)) &
02f1175c
JS		 1793 C_RS_DCD) {
1794 cy_sched_event(info,
1795 Cy_EVENT_OPEN_WAKEUP);
1796 } else {
1797 cy_sched_event(info, Cy_EVENT_HANGUP);
1798 }
1799 }
1800 break;
1801 case C_CM_MCTS:
1802 info->icount.cts++;
1803 delta_count++;
1804 break;
1805 case C_CM_MRI:
1806 info->icount.rng++;
1807 delta_count++;
1808 break;
1809 case C_CM_MDSR:
1810 info->icount.dsr++;
1811 delta_count++;
1812 break;
1da177e4 1813#ifdef Z_WAKE
02f1175c
JS		 1814 case C_CM_IOCTLW:
1815 cy_sched_event(info, Cy_EVENT_SHUTDOWN_WAKEUP);
1816 break;
1da177e4
LT		 1817#endif
1818#ifdef CONFIG_CYZ_INTR
02f1175c
JS		 1819 case C_CM_RXHIWM:
1820 case C_CM_RXNNDT:
1821 case C_CM_INTBACK2:
1822 /* Reception Interrupt */
1da177e4 1823#ifdef CY_DEBUG_INTERRUPTS
02f1175c
JS		 1824 printk("cyz_interrupt: rcvd intr, card %d, "
1825 "port %ld\n\r", info->card, channel);
1da177e4 1826#endif
02f1175c
JS		 1827 cyz_handle_rx(info, ch_ctrl, buf_ctrl);
1828 break;
1829 case C_CM_TXBEMPTY:
1830 case C_CM_TXLOWWM:
1831 case C_CM_INTBACK:
1832 /* Transmission Interrupt */
1da177e4 1833#ifdef CY_DEBUG_INTERRUPTS
02f1175c
JS		 1834 printk("cyz_interrupt: xmit intr, card %d, "
1835 "port %ld\n\r", info->card, channel);
1da177e4 1836#endif
02f1175c
JS		 1837 cyz_handle_tx(info, ch_ctrl, buf_ctrl);
1838 break;
1839#endif /* CONFIG_CYZ_INTR */
1840 case C_CM_FATAL:
1841 /* should do something with this !!! */
1842 break;
1843 default:
1844 break;
1845 }
1846 if (delta_count)
1847 cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
1848 if (special_count)
1849 tty_schedule_flip(tty);
1da177e4 1850 }
1da177e4
LT		 1851}
1852
1853#ifdef CONFIG_CYZ_INTR
02f1175c 1854static irqreturn_t cyz_interrupt(int irq, void *dev_id)
1da177e4 1855{
02f1175c 1856 struct cyclades_card *cinfo;
1da177e4 1857
02f1175c 1858 if ((cinfo = (struct cyclades_card *)dev_id) == 0) {
1da177e4 1859#ifdef CY_DEBUG_INTERRUPTS
02f1175c 1860 printk("cyz_interrupt: spurious interrupt %d\n\r", irq);
1da177e4 1861#endif
02f1175c
JS		 1862 return IRQ_NONE; /* spurious interrupt */
1863 }
1da177e4 1864
02f1175c 1865 if (!ISZLOADED(*cinfo)) {
1da177e4 1866#ifdef CY_DEBUG_INTERRUPTS
02f1175c 1867 printk("cyz_interrupt: board not yet loaded (IRQ%d).\n\r", irq);
1da177e4 1868#endif
02f1175c
JS		 1869 return IRQ_NONE;
1870 }
1da177e4 1871
02f1175c
JS		 1872 /* Handle the interrupts */
1873 cyz_handle_cmd(cinfo);
1da177e4 1874
02f1175c
JS		 1875 return IRQ_HANDLED;
1876} /* cyz_interrupt */
1da177e4 1877
02f1175c 1878static void cyz_rx_restart(unsigned long arg)
1da177e4 1879{
02f1175c
JS		 1880 struct cyclades_port *info = (struct cyclades_port *)arg;
1881 int retval;
1882 int card = info->card;
1a86b5e3 1883 __u32 channel = (info->line) - (cy_card[card].first_line);
02f1175c
JS		 1884 unsigned long flags;
1885
1886 CY_LOCK(info, flags);
1887 retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_INTBACK2, 0L);
1888 if (retval != 0) {
1889 printk("cyc:cyz_rx_restart retval on ttyC%d was %x\n",
1890 info->line, retval);
1891 }
1892 cyz_rx_full_timer[info->line].function = NULL;
1893 CY_UNLOCK(info, flags);
1da177e4
LT		 1894}
1895
02f1175c 1896#else /* CONFIG_CYZ_INTR */
1da177e4 1897
02f1175c 1898static void cyz_poll(unsigned long arg)
1da177e4 1899{
02f1175c
JS		 1900 struct cyclades_card *cinfo;
1901 struct cyclades_port *info;
1902 struct tty_struct *tty;
1903 static volatile struct FIRM_ID *firm_id;
1904 static volatile struct ZFW_CTRL *zfw_ctrl;
1905 static volatile struct BOARD_CTRL *board_ctrl;
1906 static volatile struct CH_CTRL *ch_ctrl;
1907 static volatile struct BUF_CTRL *buf_ctrl;
b7050906 1908 unsigned long expires = jiffies + HZ;
02f1175c 1909 int card, port;
1da177e4 1910
02f1175c
JS		 1911 for (card = 0; card < NR_CARDS; card++) {
1912 cinfo = &cy_card[card];
1913
1914 if (!IS_CYC_Z(*cinfo))
1915 continue;
1916 if (!ISZLOADED(*cinfo))
1917 continue;
1918
1919 firm_id = cinfo->base_addr + ID_ADDRESS;
1920 zfw_ctrl = cinfo->base_addr +
db05c3b1 1921 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
02f1175c 1922 board_ctrl = &(zfw_ctrl->board_ctrl);
1da177e4
LT		 1923
1924 /* Skip first polling cycle to avoid racing conditions with the FW */
02f1175c 1925 if (!cinfo->intr_enabled) {
db05c3b1 1926 cinfo->nports = (int)readl(&board_ctrl->n_channel);
02f1175c
JS		 1927 cinfo->intr_enabled = 1;
1928 continue;
1929 }
1da177e4 1930
02f1175c 1931 cyz_handle_cmd(cinfo);
1da177e4 1932
02f1175c
JS		 1933 for (port = 0; port < cinfo->nports; port++) {
1934 info = &cy_port[port + cinfo->first_line];
1935 tty = info->tty;
1936 ch_ctrl = &(zfw_ctrl->ch_ctrl[port]);
1937 buf_ctrl = &(zfw_ctrl->buf_ctrl[port]);
1da177e4 1938
02f1175c
JS		 1939 if (!info->throttle)
1940 cyz_handle_rx(info, ch_ctrl, buf_ctrl);
1941 cyz_handle_tx(info, ch_ctrl, buf_ctrl);
1942 }
1943 /* poll every 'cyz_polling_cycle' period */
b7050906 1944 expires = jiffies + cyz_polling_cycle;
1da177e4 1945 }
b7050906 1946 mod_timer(&cyz_timerlist, expires);
02f1175c 1947} /* cyz_poll */
1da177e4 1948
02f1175c 1949#endif /* CONFIG_CYZ_INTR */
1da177e4
LT		 1950
1951/********** End of block of Cyclades-Z specific code *********/
1952/***********************************************************/
1953
1da177e4
LT		 1954/* This is called whenever a port becomes active;
1955 interrupts are enabled and DTR & RTS are turned on.
1956 */
02f1175c 1957static int startup(struct cyclades_port *info)
1da177e4 1958{
02f1175c
JS		 1959 unsigned long flags;
1960 int retval = 0;
1961 void __iomem *base_addr;
1962 int card, chip, channel, index;
1963 unsigned long page;
1da177e4 1964
02f1175c
JS		 1965 card = info->card;
1966 channel = (info->line) - (cy_card[card].first_line);
1da177e4 1967
02f1175c
JS		 1968 page = get_zeroed_page(GFP_KERNEL);
1969 if (!page)
1970 return -ENOMEM;
1da177e4 1971
02f1175c 1972 CY_LOCK(info, flags);
1da177e4 1973
02f1175c
JS		 1974 if (info->flags & ASYNC_INITIALIZED) {
1975 free_page(page);
1976 goto errout;
1977 }
1da177e4 1978
02f1175c
JS		 1979 if (!info->type) {
1980 if (info->tty) {
1981 set_bit(TTY_IO_ERROR, &info->tty->flags);
1982 }
1983 free_page(page);
1984 goto errout;
1985 }
1da177e4 1986
02f1175c
JS		 1987 if (info->xmit_buf)
1988 free_page(page);
1989 else
1990 info->xmit_buf = (unsigned char *)page;
1da177e4 1991
02f1175c 1992 CY_UNLOCK(info, flags);
1da177e4 1993
02f1175c 1994 set_line_char(info);
1da177e4 1995
02f1175c
JS		 1996 if (!IS_CYC_Z(cy_card[card])) {
1997 chip = channel >> 2;
1998 channel &= 0x03;
1999 index = cy_card[card].bus_index;
2000 base_addr = cy_card[card].base_addr +
2001 (cy_chip_offset[chip] << index);
1da177e4
LT		 2002
2003#ifdef CY_DEBUG_OPEN
02f1175c
JS		 2004 printk("cyc startup card %d, chip %d, channel %d, "
2005 "base_addr %lx\n",
2006 card, chip, channel, (long)base_addr);
2007 /**/
1da177e4 2008#endif
02f1175c 2009 CY_LOCK(info, flags);
1da177e4 2010
02f1175c 2011 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
1da177e4 2012
02f1175c
JS		 2013 cy_writeb(base_addr + (CyRTPR << index),
2014 (info->default_timeout ? info->default_timeout : 0x02));
2015 /* 10ms rx timeout */
1da177e4 2016
02f1175c
JS		 2017 cyy_issue_cmd(base_addr, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR,
2018 index);
1da177e4 2019
02f1175c
JS		 2020 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
2021 cy_writeb(base_addr + (CyMSVR1 << index), CyRTS);
2022 cy_writeb(base_addr + (CyMSVR2 << index), CyDTR);
1da177e4
LT		 2023
2024#ifdef CY_DEBUG_DTR
02f1175c
JS		 2025 printk("cyc:startup raising DTR\n");
2026 printk(" status: 0x%x, 0x%x\n",
db05c3b1
JS		 2027 readb(base_addr + (CyMSVR1 << index)),
2028 readb(base_addr + (CyMSVR2 << index)));
1da177e4
LT		 2029#endif
2030
02f1175c 2031 cy_writeb(base_addr + (CySRER << index),
db05c3b1 2032 readb(base_addr + (CySRER << index)) | CyRxData);
02f1175c 2033 info->flags |= ASYNC_INITIALIZED;
1da177e4 2034
02f1175c
JS		 2035 if (info->tty) {
2036 clear_bit(TTY_IO_ERROR, &info->tty->flags);
2037 }
2038 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
2039 info->breakon = info->breakoff = 0;
2040 memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
2041 info->idle_stats.in_use =
2042 info->idle_stats.recv_idle =
2043 info->idle_stats.xmit_idle = jiffies;
1da177e4 2044
02f1175c 2045 CY_UNLOCK(info, flags);
1da177e4 2046
02f1175c
JS		 2047 } else {
2048 struct FIRM_ID __iomem *firm_id;
2049 struct ZFW_CTRL __iomem *zfw_ctrl;
2050 struct BOARD_CTRL __iomem *board_ctrl;
2051 struct CH_CTRL __iomem *ch_ctrl;
2052 int retval;
1da177e4 2053
02f1175c 2054 base_addr = cy_card[card].base_addr;
1da177e4 2055
02f1175c
JS		 2056 firm_id = base_addr + ID_ADDRESS;
2057 if (!ISZLOADED(cy_card[card])) {
2058 return -ENODEV;
2059 }
1da177e4 2060
02f1175c 2061 zfw_ctrl = cy_card[card].base_addr +
db05c3b1 2062 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
02f1175c
JS		 2063 board_ctrl = &zfw_ctrl->board_ctrl;
2064 ch_ctrl = zfw_ctrl->ch_ctrl;
1da177e4
LT		 2065
2066#ifdef CY_DEBUG_OPEN
02f1175c
JS		 2067 printk("cyc startup Z card %d, channel %d, base_addr %lx\n",
2068 card, channel, (long)base_addr);
2069 /**/
1da177e4 2070#endif
02f1175c 2071 CY_LOCK(info, flags);
1da177e4 2072
02f1175c 2073 cy_writel(&ch_ctrl[channel].op_mode, C_CH_ENABLE);
1da177e4
LT		 2074#ifdef Z_WAKE
2075#ifdef CONFIG_CYZ_INTR
02f1175c
JS		 2076 cy_writel(&ch_ctrl[channel].intr_enable,
2077 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
2078 C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
1da177e4 2079#else
02f1175c
JS		 2080 cy_writel(&ch_ctrl[channel].intr_enable,
2081 C_IN_IOCTLW | C_IN_MDCD);
2082#endif /* CONFIG_CYZ_INTR */
1da177e4
LT		 2083#else
2084#ifdef CONFIG_CYZ_INTR
02f1175c
JS		 2085 cy_writel(&ch_ctrl[channel].intr_enable,
2086 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
2087 C_IN_RXNNDT | C_IN_MDCD);
1da177e4 2088#else
02f1175c
JS		 2089 cy_writel(&ch_ctrl[channel].intr_enable, C_IN_MDCD);
2090#endif /* CONFIG_CYZ_INTR */
2091#endif /* Z_WAKE */
2092
2093 retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTL, 0L);
2094 if (retval != 0) {
2095 printk("cyc:startup(1) retval on ttyC%d was %x\n",
2096 info->line, retval);
2097 }
1da177e4 2098
02f1175c
JS		 2099 /* Flush RX buffers before raising DTR and RTS */
2100 retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_RX,
2101 0L);
2102 if (retval != 0) {
2103 printk("cyc:startup(2) retval on ttyC%d was %x\n",
2104 info->line, retval);
2105 }
1da177e4 2106
02f1175c
JS		 2107 /* set timeout !!! */
2108 /* set RTS and DTR !!! */
2109 cy_writel(&ch_ctrl[channel].rs_control,
db05c3b1 2110 readl(&ch_ctrl[channel].rs_control) | C_RS_RTS |
02f1175c
JS		 2111 C_RS_DTR);
2112 retval = cyz_issue_cmd(&cy_card[info->card], channel,
2113 C_CM_IOCTLM, 0L);
2114 if (retval != 0) {
2115 printk("cyc:startup(3) retval on ttyC%d was %x\n",
2116 info->line, retval);
2117 }
1da177e4 2118#ifdef CY_DEBUG_DTR
02f1175c 2119 printk("cyc:startup raising Z DTR\n");
1da177e4
LT		 2120#endif
2121
02f1175c
JS		 2122 /* enable send, recv, modem !!! */
2123
2124 info->flags |= ASYNC_INITIALIZED;
2125 if (info->tty) {
2126 clear_bit(TTY_IO_ERROR, &info->tty->flags);
2127 }
2128 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
2129 info->breakon = info->breakoff = 0;
2130 memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
2131 info->idle_stats.in_use =
2132 info->idle_stats.recv_idle =
2133 info->idle_stats.xmit_idle = jiffies;
1da177e4 2134
02f1175c 2135 CY_UNLOCK(info, flags);
1da177e4 2136 }
1da177e4
LT		 2137
2138#ifdef CY_DEBUG_OPEN
2139 printk(" cyc startup done\n");
2140#endif
2141 return 0;
2142
2143errout:
2144 CY_UNLOCK(info, flags);
2145 return retval;
02f1175c 2146} /* startup */
1da177e4 2147
02f1175c 2148static void start_xmit(struct cyclades_port *info)
1da177e4 2149{
02f1175c
JS		 2150 unsigned long flags;
2151 void __iomem *base_addr;
2152 int card, chip, channel, index;
1da177e4 2153
02f1175c
JS		 2154 card = info->card;
2155 channel = (info->line) - (cy_card[card].first_line);
2156 if (!IS_CYC_Z(cy_card[card])) {
2157 chip = channel >> 2;
2158 channel &= 0x03;
2159 index = cy_card[card].bus_index;
2160 base_addr = cy_card[card].base_addr +
2161 (cy_chip_offset[chip] << index);
2162
2163 CY_LOCK(info, flags);
2164 cy_writeb(base_addr + (CyCAR << index), channel);
2165 cy_writeb(base_addr + (CySRER << index),
db05c3b1 2166 readb(base_addr + (CySRER << index)) | CyTxRdy);
02f1175c
JS		 2167 CY_UNLOCK(info, flags);
2168 } else {
1da177e4 2169#ifdef CONFIG_CYZ_INTR
02f1175c 2170 int retval;
1da177e4 2171
02f1175c
JS		 2172 CY_LOCK(info, flags);
2173 retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_INTBACK,
2174 0L);
2175 if (retval != 0) {
2176 printk("cyc:start_xmit retval on ttyC%d was %x\n",
2177 info->line, retval);
2178 }
2179 CY_UNLOCK(info, flags);
2180#else /* CONFIG_CYZ_INTR */
2181 /* Don't have to do anything at this time */
2182#endif /* CONFIG_CYZ_INTR */
2183 }
2184} /* start_xmit */
1da177e4
LT		 2185
2186/*
2187 * This routine shuts down a serial port; interrupts are disabled,
2188 * and DTR is dropped if the hangup on close termio flag is on.
2189 */
02f1175c 2190static void shutdown(struct cyclades_port *info)
1da177e4 2191{
02f1175c
JS		 2192 unsigned long flags;
2193 void __iomem *base_addr;
2194 int card, chip, channel, index;
2195
2196 if (!(info->flags & ASYNC_INITIALIZED)) {
2197 return;
2198 }
2199
2200 card = info->card;
2201 channel = info->line - cy_card[card].first_line;
2202 if (!IS_CYC_Z(cy_card[card])) {
2203 chip = channel >> 2;
2204 channel &= 0x03;
2205 index = cy_card[card].bus_index;
2206 base_addr = cy_card[card].base_addr +
2207 (cy_chip_offset[chip] << index);
1da177e4
LT		 2208
2209#ifdef CY_DEBUG_OPEN
02f1175c
JS		 2210 printk("cyc shutdown Y card %d, chip %d, channel %d, "
2211 "base_addr %lx\n",
2212 card, chip, channel, (long)base_addr);
1da177e4
LT		 2213#endif
2214
02f1175c
JS		 2215 CY_LOCK(info, flags);
2216
2217 /* Clear delta_msr_wait queue to avoid mem leaks. */
2218 wake_up_interruptible(&info->delta_msr_wait);
1da177e4 2219
02f1175c
JS		 2220 if (info->xmit_buf) {
2221 unsigned char *temp;
2222 temp = info->xmit_buf;
2223 info->xmit_buf = NULL;
2224 free_page((unsigned long)temp);
2225 }
2226 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
2227 if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
2228 cy_writeb(base_addr + (CyMSVR1 << index), ~CyRTS);
2229 cy_writeb(base_addr + (CyMSVR2 << index), ~CyDTR);
1da177e4 2230#ifdef CY_DEBUG_DTR
02f1175c
JS		 2231 printk("cyc shutdown dropping DTR\n");
2232 printk(" status: 0x%x, 0x%x\n",
db05c3b1
JS		 2233 readb(base_addr + (CyMSVR1 << index)),
2234 readb(base_addr + (CyMSVR2 << index)));
1da177e4 2235#endif
02f1175c
JS		 2236 }
2237 cyy_issue_cmd(base_addr, CyCHAN_CTL | CyDIS_RCVR, index);
2238 /* it may be appropriate to clear _XMIT at
2239 some later date (after testing)!!! */
2240
2241 if (info->tty) {
2242 set_bit(TTY_IO_ERROR, &info->tty->flags);
2243 }
2244 info->flags &= ~ASYNC_INITIALIZED;
2245 CY_UNLOCK(info, flags);
2246 } else {
2247 struct FIRM_ID __iomem *firm_id;
2248 struct ZFW_CTRL __iomem *zfw_ctrl;
2249 struct BOARD_CTRL __iomem *board_ctrl;
2250 struct CH_CTRL __iomem *ch_ctrl;
2251 int retval;
2252
2253 base_addr = cy_card[card].base_addr;
1da177e4 2254#ifdef CY_DEBUG_OPEN
02f1175c
JS		 2255 printk("cyc shutdown Z card %d, channel %d, base_addr %lx\n",
2256 card, channel, (long)base_addr);
1da177e4
LT		 2257#endif
2258
02f1175c
JS		 2259 firm_id = base_addr + ID_ADDRESS;
2260 if (!ISZLOADED(cy_card[card])) {
2261 return;
2262 }
1da177e4 2263
02f1175c 2264 zfw_ctrl = cy_card[card].base_addr +
db05c3b1 2265 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
02f1175c
JS		 2266 board_ctrl = &zfw_ctrl->board_ctrl;
2267 ch_ctrl = zfw_ctrl->ch_ctrl;
1da177e4 2268
02f1175c 2269 CY_LOCK(info, flags);
1da177e4 2270
02f1175c
JS		 2271 if (info->xmit_buf) {
2272 unsigned char *temp;
2273 temp = info->xmit_buf;
2274 info->xmit_buf = NULL;
2275 free_page((unsigned long)temp);
1da177e4 2276 }
02f1175c
JS		 2277
2278 if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) {
2279 cy_writel(&ch_ctrl[channel].rs_control,
db05c3b1 2280 (__u32)(readl(&ch_ctrl[channel].rs_control) &
02f1175c
JS		 2281 ~(C_RS_RTS | C_RS_DTR)));
2282 retval = cyz_issue_cmd(&cy_card[info->card], channel,
2283 C_CM_IOCTLM, 0L);
2284 if (retval != 0) {
2285 printk("cyc:shutdown retval on ttyC%d was %x\n",
2286 info->line, retval);
2287 }
1da177e4 2288#ifdef CY_DEBUG_DTR
02f1175c 2289 printk("cyc:shutdown dropping Z DTR\n");
1da177e4 2290#endif
02f1175c 2291 }
1da177e4 2292
02f1175c
JS		 2293 if (info->tty) {
2294 set_bit(TTY_IO_ERROR, &info->tty->flags);
2295 }
2296 info->flags &= ~ASYNC_INITIALIZED;
2297
2298 CY_UNLOCK(info, flags);
2299 }
1da177e4
LT		 2300
2301#ifdef CY_DEBUG_OPEN
02f1175c 2302 printk(" cyc shutdown done\n");
1da177e4 2303#endif
02f1175c 2304} /* shutdown */
1da177e4
LT		 2305
2306/*
2307 * ------------------------------------------------------------
2308 * cy_open() and friends
2309 * ------------------------------------------------------------
2310 */
2311
2312static int
02f1175c
JS		 2313block_til_ready(struct tty_struct *tty, struct file *filp,
2314 struct cyclades_port *info)
1da177e4 2315{
02f1175c
JS		 2316 DECLARE_WAITQUEUE(wait, current);
2317 struct cyclades_card *cinfo;
2318 unsigned long flags;
2319 int chip, channel, index;
2320 int retval;
2321 void __iomem *base_addr;
2322
2323 cinfo = &cy_card[info->card];
2324 channel = info->line - cinfo->first_line;
2325
2326 /*
2327 * If the device is in the middle of being closed, then block
2328 * until it's done, and then try again.
2329 */
2330 if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
2331 if (info->flags & ASYNC_CLOSING) {
2332 interruptible_sleep_on(&info->close_wait);
2333 }
096dcfce 2334 return (info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
1da177e4 2335 }
02f1175c
JS		 2336
2337 /*
2338 * If non-blocking mode is set, then make the check up front
2339 * and then exit.
2340 */
2341 if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) {
2342 info->flags |= ASYNC_NORMAL_ACTIVE;
2343 return 0;
2344 }
2345
2346 /*
2347 * Block waiting for the carrier detect and the line to become
2348 * free (i.e., not in use by the callout). While we are in
2349 * this loop, info->count is dropped by one, so that
2350 * cy_close() knows when to free things. We restore it upon
2351 * exit, either normal or abnormal.
2352 */
2353 retval = 0;
2354 add_wait_queue(&info->open_wait, &wait);
1da177e4 2355#ifdef CY_DEBUG_OPEN
02f1175c
JS		 2356 printk("cyc block_til_ready before block: ttyC%d, count = %d\n",
2357 info->line, info->count);
2358 /**/
1da177e4 2359#endif
02f1175c
JS		 2360 CY_LOCK(info, flags);
2361 if (!tty_hung_up_p(filp))
2362 info->count--;
2363 CY_UNLOCK(info, flags);
1da177e4 2364#ifdef CY_DEBUG_COUNT
02f1175c
JS		 2365 printk("cyc block_til_ready: (%d): decrementing count to %d\n",
2366 current->pid, info->count);
1da177e4 2367#endif
02f1175c
JS		 2368 info->blocked_open++;
2369
2370 if (!IS_CYC_Z(*cinfo)) {
2371 chip = channel >> 2;
2372 channel &= 0x03;
2373 index = cinfo->bus_index;
2374 base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
2375
2376 while (1) {
2377 CY_LOCK(info, flags);
2378 if ((tty->termios->c_cflag & CBAUD)) {
2379 cy_writeb(base_addr + (CyCAR << index),
2380 (u_char) channel);
2381 cy_writeb(base_addr + (CyMSVR1 << index),
2382 CyRTS);
2383 cy_writeb(base_addr + (CyMSVR2 << index),
2384 CyDTR);
1da177e4 2385#ifdef CY_DEBUG_DTR
02f1175c
JS		 2386 printk("cyc:block_til_ready raising DTR\n");
2387 printk(" status: 0x%x, 0x%x\n",
db05c3b1
JS		 2388 readb(base_addr + (CyMSVR1 << index)),
2389 readb(base_addr + (CyMSVR2 << index)));
1da177e4 2390#endif
02f1175c
JS		 2391 }
2392 CY_UNLOCK(info, flags);
1da177e4 2393
02f1175c
JS		 2394 set_current_state(TASK_INTERRUPTIBLE);
2395 if (tty_hung_up_p(filp) ||
2396 !(info->flags & ASYNC_INITIALIZED)) {
2397 retval = ((info->flags & ASYNC_HUP_NOTIFY) ?
2398 -EAGAIN : -ERESTARTSYS);
2399 break;
2400 }
1da177e4 2401
02f1175c
JS		 2402 CY_LOCK(info, flags);
2403 cy_writeb(base_addr + (CyCAR << index),
2404 (u_char) channel);
2405 if (!(info->flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
db05c3b1 2406 (readb(base_addr +
02f1175c
JS		 2407 (CyMSVR1 << index)) & CyDCD))) {
2408 CY_UNLOCK(info, flags);
2409 break;
2410 }
1da177e4 2411 CY_UNLOCK(info, flags);
1da177e4 2412
02f1175c
JS		 2413 if (signal_pending(current)) {
2414 retval = -ERESTARTSYS;
2415 break;
2416 }
1da177e4 2417#ifdef CY_DEBUG_OPEN
02f1175c
JS		 2418 printk("cyc block_til_ready blocking: ttyC%d, "
2419 "count = %d\n",
2420 info->line, info->count);
2421 /**/
1da177e4 2422#endif
02f1175c 2423 schedule();
1da177e4 2424 }
02f1175c
JS		 2425 } else {
2426 struct FIRM_ID __iomem *firm_id;
2427 struct ZFW_CTRL __iomem *zfw_ctrl;
2428 struct BOARD_CTRL __iomem *board_ctrl;
2429 struct CH_CTRL __iomem *ch_ctrl;
2430 int retval;
2431
2432 base_addr = cinfo->base_addr;
2433 firm_id = base_addr + ID_ADDRESS;
2434 if (!ISZLOADED(*cinfo)) {
cc0a8fbb 2435 __set_current_state(TASK_RUNNING);
02f1175c
JS		 2436 remove_wait_queue(&info->open_wait, &wait);
2437 return -EINVAL;
2438 }
2439
db05c3b1 2440 zfw_ctrl = base_addr + (readl(&firm_id->zfwctrl_addr)& 0xfffff);
02f1175c
JS		 2441 board_ctrl = &zfw_ctrl->board_ctrl;
2442 ch_ctrl = zfw_ctrl->ch_ctrl;
2443
2444 while (1) {
2445 if ((tty->termios->c_cflag & CBAUD)) {
2446 cy_writel(&ch_ctrl[channel].rs_control,
db05c3b1
JS		 2447 readl(&ch_ctrl[channel].rs_control) |
2448 C_RS_RTS | C_RS_DTR);
02f1175c 2449 retval = cyz_issue_cmd(&cy_card[info->card],
db05c3b1 2450 channel, C_CM_IOCTLM, 0L);
02f1175c
JS		 2451 if (retval != 0) {
2452 printk("cyc:block_til_ready retval on "
2453 "ttyC%d was %x\n",
2454 info->line, retval);
2455 }
1da177e4 2456#ifdef CY_DEBUG_DTR
02f1175c 2457 printk("cyc:block_til_ready raising Z DTR\n");
1da177e4 2458#endif
02f1175c 2459 }
1da177e4 2460
02f1175c
JS		 2461 set_current_state(TASK_INTERRUPTIBLE);
2462 if (tty_hung_up_p(filp) ||
2463 !(info->flags & ASYNC_INITIALIZED)) {
2464 retval = ((info->flags & ASYNC_HUP_NOTIFY) ?
2465 -EAGAIN : -ERESTARTSYS);
2466 break;
2467 }
2468 if (!(info->flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
db05c3b1 2469 (readl(&ch_ctrl[channel].rs_status) &
02f1175c
JS		 2470 C_RS_DCD))) {
2471 break;
2472 }
2473 if (signal_pending(current)) {
2474 retval = -ERESTARTSYS;
2475 break;
2476 }
1da177e4 2477#ifdef CY_DEBUG_OPEN
02f1175c
JS		 2478 printk("cyc block_til_ready blocking: ttyC%d, "
2479 "count = %d\n",
2480 info->line, info->count);
2481 /**/
1da177e4 2482#endif
02f1175c
JS		 2483 schedule();
2484 }
1da177e4 2485 }
cc0a8fbb 2486 __set_current_state(TASK_RUNNING);
02f1175c
JS		 2487 remove_wait_queue(&info->open_wait, &wait);
2488 if (!tty_hung_up_p(filp)) {
2489 info->count++;
1da177e4 2490#ifdef CY_DEBUG_COUNT
02f1175c
JS		 2491 printk("cyc:block_til_ready (%d): incrementing count to %d\n",
2492 current->pid, info->count);
1da177e4 2493#endif
02f1175c
JS		 2494 }
2495 info->blocked_open--;
1da177e4 2496#ifdef CY_DEBUG_OPEN
02f1175c
JS		 2497 printk("cyc:block_til_ready after blocking: ttyC%d, count = %d\n",
2498 info->line, info->count);
2499 /**/
1da177e4 2500#endif
02f1175c
JS		 2501 if (retval)
2502 return retval;
2503 info->flags |= ASYNC_NORMAL_ACTIVE;
2504 return 0;
2505} /* block_til_ready */
1da177e4
LT		 2506
2507/*
2508 * This routine is called whenever a serial port is opened. It
2509 * performs the serial-specific initialization for the tty structure.
2510 */
02f1175c 2511static int cy_open(struct tty_struct *tty, struct file *filp)
1da177e4 2512{
02f1175c
JS		 2513 struct cyclades_port *info;
2514 int retval, line;
1da177e4 2515
02f1175c
JS		 2516 line = tty->index;
2517 if ((line < 0) || (NR_PORTS <= line)) {
2518 return -ENODEV;
2519 }
2520 info = &cy_port[line];
2521 if (info->line < 0) {
2522 return -ENODEV;
2523 }
1da177e4 2524
02f1175c
JS		 2525 /* If the card's firmware hasn't been loaded,
2526 treat it as absent from the system. This
2527 will make the user pay attention.
2528 */
2529 if (IS_CYC_Z(cy_card[info->card])) {
2530 struct cyclades_card *cinfo = &cy_card[info->card];
2531 struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
2532
2533 if (!ISZLOADED(*cinfo)) {
db05c3b1 2534 if (((ZE_V1 == readl(&((struct RUNTIME_9060 __iomem *)
02f1175c
JS		 2535 (cinfo->ctl_addr))->mail_box_0)) &&
2536 Z_FPGA_CHECK(*cinfo)) &&
db05c3b1 2537 (ZFIRM_HLT == readl(
02f1175c
JS		 2538 &firm_id->signature))) {
2539 printk("cyc:Cyclades-Z Error: you need an "
2540 "external power supply for this number "
2541 "of ports.\n\rFirmware halted.\r\n");
2542 } else {
2543 printk("cyc:Cyclades-Z firmware not yet "
2544 "loaded\n");
2545 }
2546 return -ENODEV;
2547 }
2548#ifdef CONFIG_CYZ_INTR
2549 else {
2550 /* In case this Z board is operating in interrupt mode, its
2551 interrupts should be enabled as soon as the first open
2552 happens to one of its ports. */
2553 if (!cinfo->intr_enabled) {
2554 struct ZFW_CTRL __iomem *zfw_ctrl;
2555 struct BOARD_CTRL __iomem *board_ctrl;
2556
2557 zfw_ctrl = cinfo->base_addr +
db05c3b1
JS		 2558 (readl(&firm_id->zfwctrl_addr) &
2559 0xfffff);
02f1175c
JS		 2560
2561 board_ctrl = &zfw_ctrl->board_ctrl;
2562
2563 /* Enable interrupts on the PLX chip */
2564 cy_writew(cinfo->ctl_addr + 0x68,
db05c3b1 2565 readw(cinfo->ctl_addr + 0x68) | 0x0900);
02f1175c
JS		 2566 /* Enable interrupts on the FW */
2567 retval = cyz_issue_cmd(cinfo, 0,
2568 C_CM_IRQ_ENBL, 0L);
2569 if (retval != 0) {
2570 printk("cyc:IRQ enable retval was %x\n",
2571 retval);
2572 }
2573 cinfo->nports =
db05c3b1 2574 (int)readl(&board_ctrl->n_channel);
02f1175c
JS		 2575 cinfo->intr_enabled = 1;
2576 }
1da177e4 2577 }
02f1175c
JS		 2578#endif /* CONFIG_CYZ_INTR */
2579 /* Make sure this Z port really exists in hardware */
2580 if (info->line > (cinfo->first_line + cinfo->nports - 1))
2581 return -ENODEV;
1da177e4 2582 }
1da177e4 2583#ifdef CY_DEBUG_OTHER
02f1175c 2584 printk("cyc:cy_open ttyC%d\n", info->line); /* */
1da177e4 2585#endif
02f1175c
JS		 2586 tty->driver_data = info;
2587 info->tty = tty;
2588 if (serial_paranoia_check(info, tty->name, "cy_open")) {
2589 return -ENODEV;
2590 }
1da177e4 2591#ifdef CY_DEBUG_OPEN
02f1175c
JS		 2592 printk("cyc:cy_open ttyC%d, count = %d\n", info->line, info->count);
2593 /**/
1da177e4 2594#endif
02f1175c 2595 info->count++;
1da177e4 2596#ifdef CY_DEBUG_COUNT
02f1175c
JS		 2597 printk("cyc:cy_open (%d): incrementing count to %d\n",
2598 current->pid, info->count);
1da177e4 2599#endif
1da177e4 2600
02f1175c
JS		 2601 /*
2602 * If the port is the middle of closing, bail out now
2603 */
2604 if (tty_hung_up_p(filp) || (info->flags & ASYNC_CLOSING)) {
2605 if (info->flags & ASYNC_CLOSING)
2606 interruptible_sleep_on(&info->close_wait);
096dcfce 2607 return (info->flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
02f1175c 2608 }
1da177e4 2609
02f1175c
JS		 2610 /*
2611 * Start up serial port
2612 */
2613 retval = startup(info);
2614 if (retval) {
2615 return retval;
2616 }
1da177e4 2617
02f1175c
JS		 2618 retval = block_til_ready(tty, filp, info);
2619 if (retval) {
1da177e4 2620#ifdef CY_DEBUG_OPEN
02f1175c
JS		 2621 printk("cyc:cy_open returning after block_til_ready with %d\n",
2622 retval);
1da177e4 2623#endif
02f1175c
JS		 2624 return retval;
2625 }
1da177e4 2626
02f1175c 2627 info->throttle = 0;
1da177e4 2628
02f1175c
JS		 2629#ifdef CY_DEBUG_OPEN
2630 printk(" cyc:cy_open done\n");
2631 /**/
2632#endif
2633 return 0;
2634} /* cy_open */
1da177e4
LT		 2635
2636/*
2637 * cy_wait_until_sent() --- wait until the transmitter is empty
2638 */
02f1175c 2639static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
1da177e4 2640{
02f1175c
JS		 2641 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
2642 void __iomem *base_addr;
2643 int card, chip, channel, index;
2644 unsigned long orig_jiffies;
2645 int char_time;
2646
2647 if (serial_paranoia_check(info, tty->name, "cy_wait_until_sent"))
2648 return;
2649
2650 if (info->xmit_fifo_size == 0)
2651 return; /* Just in case.... */
1da177e4 2652
02f1175c
JS		 2653 orig_jiffies = jiffies;
2654 /*
2655 * Set the check interval to be 1/5 of the estimated time to
2656 * send a single character, and make it at least 1. The check
2657 * interval should also be less than the timeout.
2658 *
2659 * Note: we have to use pretty tight timings here to satisfy
2660 * the NIST-PCTS.
2661 */
2662 char_time = (info->timeout - HZ / 50) / info->xmit_fifo_size;
2663 char_time = char_time / 5;
2664 if (char_time <= 0)
2665 char_time = 1;
2666 if (timeout < 0)
2667 timeout = 0;
2668 if (timeout)
2669 char_time = min(char_time, timeout);
2670 /*
2671 * If the transmitter hasn't cleared in twice the approximate
2672 * amount of time to send the entire FIFO, it probably won't
2673 * ever clear. This assumes the UART isn't doing flow
2674 * control, which is currently the case. Hence, if it ever
2675 * takes longer than info->timeout, this is probably due to a
2676 * UART bug of some kind. So, we clamp the timeout parameter at
2677 * 2*info->timeout.
2678 */
2679 if (!timeout || timeout > 2 * info->timeout)
2680 timeout = 2 * info->timeout;
1da177e4 2681#ifdef CY_DEBUG_WAIT_UNTIL_SENT
02f1175c
JS		 2682 printk("In cy_wait_until_sent(%d) check=%lu...", timeout, char_time);
2683 printk("jiff=%lu...", jiffies);
1da177e4 2684#endif
02f1175c
JS		 2685 card = info->card;
2686 channel = (info->line) - (cy_card[card].first_line);
2687 if (!IS_CYC_Z(cy_card[card])) {
2688 chip = channel >> 2;
2689 channel &= 0x03;
2690 index = cy_card[card].bus_index;
2691 base_addr =
2692 cy_card[card].base_addr + (cy_chip_offset[chip] << index);
db05c3b1 2693 while (readb(base_addr + (CySRER << index)) & CyTxRdy) {
1da177e4 2694#ifdef CY_DEBUG_WAIT_UNTIL_SENT
02f1175c 2695 printk("Not clean (jiff=%lu)...", jiffies);
1da177e4 2696#endif
02f1175c
JS		 2697 if (msleep_interruptible(jiffies_to_msecs(char_time)))
2698 break;
2699 if (timeout && time_after(jiffies, orig_jiffies +
2700 timeout))
2701 break;
2702 }
2703 } else {
096dcfce 2704 /* Nothing to do! */
1da177e4 2705 }
02f1175c
JS		 2706 /* Run one more char cycle */
2707 msleep_interruptible(jiffies_to_msecs(char_time * 5));
1da177e4 2708#ifdef CY_DEBUG_WAIT_UNTIL_SENT
02f1175c 2709 printk("Clean (jiff=%lu)...done\n", jiffies);
1da177e4
LT		 2710#endif
2711}
2712
2713/*
2714 * This routine is called when a particular tty device is closed.
2715 */
02f1175c 2716static void cy_close(struct tty_struct *tty, struct file *filp)
1da177e4 2717{
02f1175c
JS		 2718 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
2719 unsigned long flags;
1da177e4
LT		 2720
2721#ifdef CY_DEBUG_OTHER
02f1175c 2722 printk("cyc:cy_close ttyC%d\n", info->line);
1da177e4
LT		 2723#endif
2724
02f1175c
JS		 2725 if (!info || serial_paranoia_check(info, tty->name, "cy_close")) {
2726 return;
2727 }
1da177e4 2728
02f1175c
JS		 2729 CY_LOCK(info, flags);
2730 /* If the TTY is being hung up, nothing to do */
2731 if (tty_hung_up_p(filp)) {
2732 CY_UNLOCK(info, flags);
2733 return;
2734 }
1da177e4 2735#ifdef CY_DEBUG_OPEN
02f1175c 2736 printk("cyc:cy_close ttyC%d, count = %d\n", info->line, info->count);
1da177e4 2737#endif
02f1175c
JS		 2738 if ((tty->count == 1) && (info->count != 1)) {
2739 /*
2740 * Uh, oh. tty->count is 1, which means that the tty
2741 * structure will be freed. Info->count should always
2742 * be one in these conditions. If it's greater than
2743 * one, we've got real problems, since it means the
2744 * serial port won't be shutdown.
2745 */
2746 printk("cyc:cy_close: bad serial port count; tty->count is 1, "
2747 "info->count is %d\n", info->count);
2748 info->count = 1;
2749 }
1da177e4 2750#ifdef CY_DEBUG_COUNT
02f1175c
JS		 2751 printk("cyc:cy_close at (%d): decrementing count to %d\n",
2752 current->pid, info->count - 1);
1da177e4 2753#endif
02f1175c 2754 if (--info->count < 0) {
1da177e4 2755#ifdef CY_DEBUG_COUNT
02f1175c 2756 printk("cyc:cyc_close setting count to 0\n");
1da177e4 2757#endif
02f1175c 2758 info->count = 0;
1da177e4 2759 }
02f1175c
JS		 2760 if (info->count) {
2761 CY_UNLOCK(info, flags);
2762 return;
2763 }
2764 info->flags |= ASYNC_CLOSING;
1da177e4 2765
02f1175c
JS		 2766 /*
2767 * Now we wait for the transmit buffer to clear; and we notify
2768 * the line discipline to only process XON/XOFF characters.
2769 */
2770 tty->closing = 1;
2771 CY_UNLOCK(info, flags);
2772 if (info->closing_wait != CY_CLOSING_WAIT_NONE) {
2773 tty_wait_until_sent(tty, info->closing_wait);
1da177e4 2774 }
02f1175c
JS		 2775 CY_LOCK(info, flags);
2776
2777 if (!IS_CYC_Z(cy_card[info->card])) {
2778 int channel = info->line - cy_card[info->card].first_line;
2779 int index = cy_card[info->card].bus_index;
2780 void __iomem *base_addr = cy_card[info->card].base_addr +
2781 (cy_chip_offset[channel >> 2] << index);
2782 /* Stop accepting input */
2783 channel &= 0x03;
2784 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
2785 cy_writeb(base_addr + (CySRER << index),
db05c3b1 2786 readb(base_addr + (CySRER << index)) & ~CyRxData);
02f1175c
JS		 2787 if (info->flags & ASYNC_INITIALIZED) {
2788 /* Waiting for on-board buffers to be empty before closing
2789 the port */
2790 CY_UNLOCK(info, flags);
2791 cy_wait_until_sent(tty, info->timeout);
2792 CY_LOCK(info, flags);
2793 }
2794 } else {
2795#ifdef Z_WAKE
2796 /* Waiting for on-board buffers to be empty before closing the port */
2797 void __iomem *base_addr = cy_card[info->card].base_addr;
2798 struct FIRM_ID __iomem *firm_id = base_addr + ID_ADDRESS;
2799 struct ZFW_CTRL __iomem *zfw_ctrl =
db05c3b1 2800 base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
02f1175c
JS		 2801 struct CH_CTRL __iomem *ch_ctrl = zfw_ctrl->ch_ctrl;
2802 int channel = info->line - cy_card[info->card].first_line;
2803 int retval;
2804
db05c3b1 2805 if (readl(&ch_ctrl[channel].flow_status) != C_FS_TXIDLE) {
02f1175c
JS		 2806 retval = cyz_issue_cmd(&cy_card[info->card], channel,
2807 C_CM_IOCTLW, 0L);
2808 if (retval != 0) {
2809 printk("cyc:cy_close retval on ttyC%d was %x\n",
2810 info->line, retval);
2811 }
2812 CY_UNLOCK(info, flags);
2813 interruptible_sleep_on(&info->shutdown_wait);
2814 CY_LOCK(info, flags);
2815 }
1da177e4 2816#endif
02f1175c
JS		 2817 }
2818
1da177e4 2819 CY_UNLOCK(info, flags);
02f1175c
JS		 2820 shutdown(info);
2821 if (tty->driver->flush_buffer)
2822 tty->driver->flush_buffer(tty);
2823 tty_ldisc_flush(tty);
1da177e4 2824 CY_LOCK(info, flags);
02f1175c
JS		 2825
2826 tty->closing = 0;
2827 info->event = 0;
2828 info->tty = NULL;
2829 if (info->blocked_open) {
2830 CY_UNLOCK(info, flags);
2831 if (info->close_delay) {
2832 msleep_interruptible(jiffies_to_msecs
2833 (info->close_delay));
2834 }
2835 wake_up_interruptible(&info->open_wait);
2836 CY_LOCK(info, flags);
2837 }
2838 info->flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
2839 wake_up_interruptible(&info->close_wait);
1da177e4
LT		 2840
2841#ifdef CY_DEBUG_OTHER
02f1175c 2842 printk(" cyc:cy_close done\n");
1da177e4
LT		 2843#endif
2844
02f1175c 2845 CY_UNLOCK(info, flags);
02f1175c 2846} /* cy_close */
1da177e4
LT		 2847
2848/* This routine gets called when tty_write has put something into
2849 * the write_queue. The characters may come from user space or
2850 * kernel space.
2851 *
2852 * This routine will return the number of characters actually
2853 * accepted for writing.
2854 *
2855 * If the port is not already transmitting stuff, start it off by
2856 * enabling interrupts. The interrupt service routine will then
2857 * ensure that the characters are sent.
2858 * If the port is already active, there is no need to kick it.
2859 *
2860 */
02f1175c 2861static int cy_write(struct tty_struct *tty, const unsigned char *buf, int count)
1da177e4 2862{
02f1175c
JS		 2863 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
2864 unsigned long flags;
2865 int c, ret = 0;
1da177e4
LT		 2866
2867#ifdef CY_DEBUG_IO
02f1175c 2868 printk("cyc:cy_write ttyC%d\n", info->line); /* */
1da177e4
LT		 2869#endif
2870
02f1175c
JS		 2871 if (serial_paranoia_check(info, tty->name, "cy_write")) {
2872 return 0;
2873 }
1da177e4 2874
02f1175c
JS		 2875 if (!info->xmit_buf)
2876 return 0;
1da177e4 2877
02f1175c
JS		 2878 CY_LOCK(info, flags);
2879 while (1) {
2880 c = min(count, min((int)(SERIAL_XMIT_SIZE - info->xmit_cnt - 1),
2881 (int)(SERIAL_XMIT_SIZE - info->xmit_head)));
2882
2883 if (c <= 0)
2884 break;
2885
2886 memcpy(info->xmit_buf + info->xmit_head, buf, c);
2887 info->xmit_head = (info->xmit_head + c) &
2888 (SERIAL_XMIT_SIZE - 1);
2889 info->xmit_cnt += c;
2890 buf += c;
2891 count -= c;
2892 ret += c;
2893 }
2894 CY_UNLOCK(info, flags);
2895
2896 info->idle_stats.xmit_bytes += ret;
2897 info->idle_stats.xmit_idle = jiffies;
2898
2899 if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
2900 start_xmit(info);
2901 }
2902 return ret;
2903} /* cy_write */
1da177e4
LT		 2904
2905/*
2906 * This routine is called by the kernel to write a single
2907 * character to the tty device. If the kernel uses this routine,
2908 * it must call the flush_chars() routine (if defined) when it is
2909 * done stuffing characters into the driver. If there is no room
2910 * in the queue, the character is ignored.
2911 */
02f1175c 2912static void cy_put_char(struct tty_struct *tty, unsigned char ch)
1da177e4 2913{
02f1175c
JS		 2914 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
2915 unsigned long flags;
1da177e4
LT		 2916
2917#ifdef CY_DEBUG_IO
02f1175c 2918 printk("cyc:cy_put_char ttyC%d\n", info->line);
1da177e4
LT		 2919#endif
2920
02f1175c
JS		 2921 if (serial_paranoia_check(info, tty->name, "cy_put_char"))
2922 return;
1da177e4 2923
02f1175c
JS		 2924 if (!info->xmit_buf)
2925 return;
1da177e4 2926
02f1175c 2927 CY_LOCK(info, flags);
90cc3018 2928 if (info->xmit_cnt >= (int)(SERIAL_XMIT_SIZE - 1)) {
02f1175c
JS		 2929 CY_UNLOCK(info, flags);
2930 return;
2931 }
1da177e4 2932
02f1175c
JS		 2933 info->xmit_buf[info->xmit_head++] = ch;
2934 info->xmit_head &= SERIAL_XMIT_SIZE - 1;
2935 info->xmit_cnt++;
1da177e4
LT		 2936 info->idle_stats.xmit_bytes++;
2937 info->idle_stats.xmit_idle = jiffies;
02f1175c
JS		 2938 CY_UNLOCK(info, flags);
2939} /* cy_put_char */
1da177e4
LT		 2940
2941/*
2942 * This routine is called by the kernel after it has written a
2943 * series of characters to the tty device using put_char().
2944 */
02f1175c 2945static void cy_flush_chars(struct tty_struct *tty)
1da177e4 2946{
02f1175c
JS		 2947 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
2948
1da177e4 2949#ifdef CY_DEBUG_IO
02f1175c 2950 printk("cyc:cy_flush_chars ttyC%d\n", info->line); /* */
1da177e4
LT		 2951#endif
2952
02f1175c
JS		 2953 if (serial_paranoia_check(info, tty->name, "cy_flush_chars"))
2954 return;
1da177e4 2955
02f1175c
JS		 2956 if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
2957 !info->xmit_buf)
2958 return;
1da177e4 2959
02f1175c
JS		 2960 start_xmit(info);
2961} /* cy_flush_chars */
1da177e4
LT		 2962
2963/*
2964 * This routine returns the numbers of characters the tty driver
2965 * will accept for queuing to be written. This number is subject
2966 * to change as output buffers get emptied, or if the output flow
2967 * control is activated.
2968 */
02f1175c 2969static int cy_write_room(struct tty_struct *tty)
1da177e4 2970{
02f1175c
JS		 2971 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
2972 int ret;
2973
1da177e4 2974#ifdef CY_DEBUG_IO
02f1175c 2975 printk("cyc:cy_write_room ttyC%d\n", info->line); /* */
1da177e4
LT		 2976#endif
2977
02f1175c
JS		 2978 if (serial_paranoia_check(info, tty->name, "cy_write_room"))
2979 return 0;
2980 ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
2981 if (ret < 0)
2982 ret = 0;
2983 return ret;
2984} /* cy_write_room */
1da177e4 2985
02f1175c 2986static int cy_chars_in_buffer(struct tty_struct *tty)
1da177e4 2987{
02f1175c
JS		 2988 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
2989 int card, channel;
1da177e4 2990
02f1175c
JS		 2991 if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
2992 return 0;
2993
2994 card = info->card;
2995 channel = (info->line) - (cy_card[card].first_line);
1da177e4
LT		 2996
2997#ifdef Z_EXT_CHARS_IN_BUFFER
02f1175c
JS		 2998 if (!IS_CYC_Z(cy_card[card])) {
2999#endif /* Z_EXT_CHARS_IN_BUFFER */
1da177e4 3000#ifdef CY_DEBUG_IO
02f1175c 3001 printk("cyc:cy_chars_in_buffer ttyC%d %d\n", info->line, info->xmit_cnt); /* */
1da177e4 3002#endif
02f1175c 3003 return info->xmit_cnt;
1da177e4 3004#ifdef Z_EXT_CHARS_IN_BUFFER
02f1175c
JS		 3005 } else {
3006 static volatile struct FIRM_ID *firm_id;
3007 static volatile struct ZFW_CTRL *zfw_ctrl;
3008 static volatile struct CH_CTRL *ch_ctrl;
3009 static volatile struct BUF_CTRL *buf_ctrl;
3010 int char_count;
1a86b5e3 3011 volatile __u32 tx_put, tx_get, tx_bufsize;
02f1175c
JS		 3012
3013 firm_id = cy_card[card].base_addr + ID_ADDRESS;
3014 zfw_ctrl = cy_card[card].base_addr +
db05c3b1 3015 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
02f1175c
JS		 3016 ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
3017 buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
3018
db05c3b1
JS		 3019 tx_get = readl(&buf_ctrl->tx_get);
3020 tx_put = readl(&buf_ctrl->tx_put);
3021 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
02f1175c
JS		 3022 if (tx_put >= tx_get)
3023 char_count = tx_put - tx_get;
3024 else
3025 char_count = tx_put - tx_get + tx_bufsize;
1da177e4 3026#ifdef CY_DEBUG_IO
02f1175c 3027 printk("cyc:cy_chars_in_buffer ttyC%d %d\n", info->line, info->xmit_cnt + char_count); /* */
1da177e4 3028#endif
096dcfce 3029 return info->xmit_cnt + char_count;
02f1175c
JS		 3030 }
3031#endif /* Z_EXT_CHARS_IN_BUFFER */
3032} /* cy_chars_in_buffer */
1da177e4
LT		 3033
3034/*
3035 * ------------------------------------------------------------
3036 * cy_ioctl() and friends
3037 * ------------------------------------------------------------
3038 */
3039
1a86b5e3 3040static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
1da177e4 3041{
02f1175c 3042 int co, co_val, bpr;
1a86b5e3 3043 __u32 cy_clock = ((info->chip_rev >= CD1400_REV_J) ? 60000000 :
02f1175c 3044 25000000);
1da177e4 3045
02f1175c
JS		 3046 if (baud == 0) {
3047 info->tbpr = info->tco = info->rbpr = info->rco = 0;
3048 return;
3049 }
1da177e4 3050
02f1175c
JS		 3051 /* determine which prescaler to use */
3052 for (co = 4, co_val = 2048; co; co--, co_val >>= 2) {
3053 if (cy_clock / co_val / baud > 63)
3054 break;
3055 }
1da177e4 3056
02f1175c
JS		 3057 bpr = (cy_clock / co_val * 2 / baud + 1) / 2;
3058 if (bpr > 255)
3059 bpr = 255;
1da177e4 3060
02f1175c
JS		 3061 info->tbpr = info->rbpr = bpr;
3062 info->tco = info->rco = co;
1da177e4
LT		 3063}
3064
3065/*
3066 * This routine finds or computes the various line characteristics.
3067 * It used to be called config_setup
3068 */
02f1175c 3069static void set_line_char(struct cyclades_port *info)
1da177e4 3070{
02f1175c
JS		 3071 unsigned long flags;
3072 void __iomem *base_addr;
3073 int card, chip, channel, index;
3074 unsigned cflag, iflag;
3075 unsigned short chip_number;
3076 int baud, baud_rate = 0;
3077 int i;
3078
3079 if (!info->tty || !info->tty->termios) {
3080 return;
1da177e4 3081 }
02f1175c
JS		 3082 if (info->line == -1) {
3083 return;
1da177e4 3084 }
02f1175c
JS		 3085 cflag = info->tty->termios->c_cflag;
3086 iflag = info->tty->termios->c_iflag;
1da177e4 3087
02f1175c
JS		 3088 /*
3089 * Set up the tty->alt_speed kludge
3090 */
3091 if (info->tty) {
3092 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
3093 info->tty->alt_speed = 57600;
3094 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
3095 info->tty->alt_speed = 115200;
3096 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
3097 info->tty->alt_speed = 230400;
3098 if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
3099 info->tty->alt_speed = 460800;
1da177e4 3100 }
02f1175c
JS		 3101
3102 card = info->card;
3103 channel = (info->line) - (cy_card[card].first_line);
3104 chip_number = channel / 4;
3105
3106 if (!IS_CYC_Z(cy_card[card])) {
3107
3108 index = cy_card[card].bus_index;
3109
3110 /* baud rate */
3111 baud = tty_get_baud_rate(info->tty);
3112 if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3113 ASYNC_SPD_CUST) {
3114 if (info->custom_divisor)
3115 baud_rate = info->baud / info->custom_divisor;
3116 else
3117 baud_rate = info->baud;
3118 } else if (baud > CD1400_MAX_SPEED) {
3119 baud = CD1400_MAX_SPEED;
3120 }
3121 /* find the baud index */
3122 for (i = 0; i < 20; i++) {
3123 if (baud == baud_table[i]) {
3124 break;
3125 }
3126 }
3127 if (i == 20) {
3128 i = 19; /* CD1400_MAX_SPEED */
3129 }
3130
3131 if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3132 ASYNC_SPD_CUST) {
3133 cyy_baud_calc(info, baud_rate);
3134 } else {
3135 if (info->chip_rev >= CD1400_REV_J) {
3136 /* It is a CD1400 rev. J or later */
3137 info->tbpr = baud_bpr_60[i]; /* Tx BPR */
3138 info->tco = baud_co_60[i]; /* Tx CO */
3139 info->rbpr = baud_bpr_60[i]; /* Rx BPR */
3140 info->rco = baud_co_60[i]; /* Rx CO */
3141 } else {
3142 info->tbpr = baud_bpr_25[i]; /* Tx BPR */
3143 info->tco = baud_co_25[i]; /* Tx CO */
3144 info->rbpr = baud_bpr_25[i]; /* Rx BPR */
3145 info->rco = baud_co_25[i]; /* Rx CO */
3146 }
3147 }
3148 if (baud_table[i] == 134) {
3149 /* get it right for 134.5 baud */
3150 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
3151 2;
3152 } else if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3153 ASYNC_SPD_CUST) {
3154 info->timeout = (info->xmit_fifo_size * HZ * 15 /
3155 baud_rate) + 2;
3156 } else if (baud_table[i]) {
3157 info->timeout = (info->xmit_fifo_size * HZ * 15 /
3158 baud_table[i]) + 2;
3159 /* this needs to be propagated into the card info */
3160 } else {
3161 info->timeout = 0;
3162 }
3163 /* By tradition (is it a standard?) a baud rate of zero
3164 implies the line should be/has been closed. A bit
3165 later in this routine such a test is performed. */
3166
3167 /* byte size and parity */
3168 info->cor5 = 0;
3169 info->cor4 = 0;
3170 /* receive threshold */
3171 info->cor3 = (info->default_threshold ?
3172 info->default_threshold : baud_cor3[i]);
3173 info->cor2 = CyETC;
3174 switch (cflag & CSIZE) {
3175 case CS5:
3176 info->cor1 = Cy_5_BITS;
3177 break;
3178 case CS6:
3179 info->cor1 = Cy_6_BITS;
3180 break;
3181 case CS7:
3182 info->cor1 = Cy_7_BITS;
3183 break;
3184 case CS8:
3185 info->cor1 = Cy_8_BITS;
3186 break;
3187 }
3188 if (cflag & CSTOPB) {
3189 info->cor1 |= Cy_2_STOP;
3190 }
3191 if (cflag & PARENB) {
3192 if (cflag & PARODD) {
3193 info->cor1 |= CyPARITY_O;
3194 } else {
3195 info->cor1 |= CyPARITY_E;
3196 }
3197 } else {
3198 info->cor1 |= CyPARITY_NONE;
3199 }
3200
3201 /* CTS flow control flag */
3202 if (cflag & CRTSCTS) {
3203 info->flags |= ASYNC_CTS_FLOW;
3204 info->cor2 |= CyCtsAE;
3205 } else {
3206 info->flags &= ~ASYNC_CTS_FLOW;
3207 info->cor2 &= ~CyCtsAE;
3208 }
3209 if (cflag & CLOCAL)
3210 info->flags &= ~ASYNC_CHECK_CD;
3211 else
3212 info->flags |= ASYNC_CHECK_CD;
1da177e4
LT		 3213
3214 /***********************************************
3215 The hardware option, CyRtsAO, presents RTS when
3216 the chip has characters to send. Since most modems
3217 use RTS as reverse (inbound) flow control, this
3218 option is not used. If inbound flow control is
3219 necessary, DTR can be programmed to provide the
3220 appropriate signals for use with a non-standard
3221 cable. Contact Marcio Saito for details.
3222 ***********************************************/
3223
02f1175c
JS		 3224 chip = channel >> 2;
3225 channel &= 0x03;
3226 base_addr = cy_card[card].base_addr +
3227 (cy_chip_offset[chip] << index);
1da177e4 3228
02f1175c
JS		 3229 CY_LOCK(info, flags);
3230 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
3231
3232 /* tx and rx baud rate */
3233
3234 cy_writeb(base_addr + (CyTCOR << index), info->tco);
3235 cy_writeb(base_addr + (CyTBPR << index), info->tbpr);
3236 cy_writeb(base_addr + (CyRCOR << index), info->rco);
3237 cy_writeb(base_addr + (CyRBPR << index), info->rbpr);
3238
3239 /* set line characteristics according configuration */
3240
3241 cy_writeb(base_addr + (CySCHR1 << index),
3242 START_CHAR(info->tty));
3243 cy_writeb(base_addr + (CySCHR2 << index), STOP_CHAR(info->tty));
3244 cy_writeb(base_addr + (CyCOR1 << index), info->cor1);
3245 cy_writeb(base_addr + (CyCOR2 << index), info->cor2);
3246 cy_writeb(base_addr + (CyCOR3 << index), info->cor3);
3247 cy_writeb(base_addr + (CyCOR4 << index), info->cor4);
3248 cy_writeb(base_addr + (CyCOR5 << index), info->cor5);
3249
3250 cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
3251 CyCOR3ch, index);
3252
3253 cy_writeb(base_addr + (CyCAR << index), (u_char) channel); /* !!! Is this needed? */
3254 cy_writeb(base_addr + (CyRTPR << index),
3255 (info->default_timeout ? info->default_timeout : 0x02));
3256 /* 10ms rx timeout */
3257
3258 if (C_CLOCAL(info->tty)) {
3259 /* without modem intr */
3260 cy_writeb(base_addr + (CySRER << index),
db05c3b1 3261 readb(base_addr + (CySRER << index)) | CyMdmCh);
02f1175c
JS		 3262 /* act on 1->0 modem transitions */
3263 if ((cflag & CRTSCTS) && info->rflow) {
3264 cy_writeb(base_addr + (CyMCOR1 << index),
3265 (CyCTS | rflow_thr[i]));
3266 } else {
3267 cy_writeb(base_addr + (CyMCOR1 << index),
3268 CyCTS);
3269 }
3270 /* act on 0->1 modem transitions */
3271 cy_writeb(base_addr + (CyMCOR2 << index), CyCTS);
1da177e4 3272 } else {
02f1175c
JS		 3273 /* without modem intr */
3274 cy_writeb(base_addr + (CySRER << index),
db05c3b1 3275 readb(base_addr +
02f1175c
JS		 3276 (CySRER << index)) | CyMdmCh);
3277 /* act on 1->0 modem transitions */
3278 if ((cflag & CRTSCTS) && info->rflow) {
3279 cy_writeb(base_addr + (CyMCOR1 << index),
3280 (CyDSR | CyCTS | CyRI | CyDCD |
3281 rflow_thr[i]));
3282 } else {
3283 cy_writeb(base_addr + (CyMCOR1 << index),
3284 CyDSR | CyCTS | CyRI | CyDCD);
3285 }
3286 /* act on 0->1 modem transitions */
3287 cy_writeb(base_addr + (CyMCOR2 << index),
3288 CyDSR | CyCTS | CyRI | CyDCD);
1da177e4 3289 }
02f1175c
JS		 3290
3291 if (i == 0) { /* baud rate is zero, turn off line */
3292 if (info->rtsdtr_inv) {
3293 cy_writeb(base_addr + (CyMSVR1 << index),
3294 ~CyRTS);
3295 } else {
3296 cy_writeb(base_addr + (CyMSVR2 << index),
3297 ~CyDTR);
3298 }
1da177e4 3299#ifdef CY_DEBUG_DTR
02f1175c
JS		 3300 printk("cyc:set_line_char dropping DTR\n");
3301 printk(" status: 0x%x, 0x%x\n",
db05c3b1
JS		 3302 readb(base_addr + (CyMSVR1 << index)),
3303 readb(base_addr + (CyMSVR2 << index)));
1da177e4 3304#endif
02f1175c
JS		 3305 } else {
3306 if (info->rtsdtr_inv) {
3307 cy_writeb(base_addr + (CyMSVR1 << index),
3308 CyRTS);
3309 } else {
3310 cy_writeb(base_addr + (CyMSVR2 << index),
3311 CyDTR);
3312 }
1da177e4 3313#ifdef CY_DEBUG_DTR
02f1175c
JS		 3314 printk("cyc:set_line_char raising DTR\n");
3315 printk(" status: 0x%x, 0x%x\n",
db05c3b1
JS		 3316 readb(base_addr + (CyMSVR1 << index)),
3317 readb(base_addr + (CyMSVR2 << index)));
1da177e4 3318#endif
02f1175c 3319 }
1da177e4 3320
02f1175c
JS		 3321 if (info->tty) {
3322 clear_bit(TTY_IO_ERROR, &info->tty->flags);
3323 }
3324 CY_UNLOCK(info, flags);
1da177e4 3325
1da177e4 3326 } else {
02f1175c
JS		 3327 struct FIRM_ID __iomem *firm_id;
3328 struct ZFW_CTRL __iomem *zfw_ctrl;
3329 struct BOARD_CTRL __iomem *board_ctrl;
3330 struct CH_CTRL __iomem *ch_ctrl;
3331 struct BUF_CTRL __iomem *buf_ctrl;
1a86b5e3 3332 __u32 sw_flow;
02f1175c 3333 int retval;
1da177e4 3334
02f1175c
JS		 3335 firm_id = cy_card[card].base_addr + ID_ADDRESS;
3336 if (!ISZLOADED(cy_card[card])) {
3337 return;
3338 }
1da177e4 3339
02f1175c 3340 zfw_ctrl = cy_card[card].base_addr +
db05c3b1 3341 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
02f1175c
JS		 3342 board_ctrl = &zfw_ctrl->board_ctrl;
3343 ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
3344 buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3345
3346 /* baud rate */
3347 baud = tty_get_baud_rate(info->tty);
3348 if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3349 ASYNC_SPD_CUST) {
3350 if (info->custom_divisor)
3351 baud_rate = info->baud / info->custom_divisor;
3352 else
3353 baud_rate = info->baud;
3354 } else if (baud > CYZ_MAX_SPEED) {
3355 baud = CYZ_MAX_SPEED;
3356 }
3357 cy_writel(&ch_ctrl->comm_baud, baud);
3358
3359 if (baud == 134) {
3360 /* get it right for 134.5 baud */
3361 info->timeout = (info->xmit_fifo_size * HZ * 30 / 269) +
3362 2;
3363 } else if (baud == 38400 && (info->flags & ASYNC_SPD_MASK) ==
3364 ASYNC_SPD_CUST) {
3365 info->timeout = (info->xmit_fifo_size * HZ * 15 /
3366 baud_rate) + 2;
3367 } else if (baud) {
3368 info->timeout = (info->xmit_fifo_size * HZ * 15 /
3369 baud) + 2;
3370 /* this needs to be propagated into the card info */
3371 } else {
3372 info->timeout = 0;
3373 }
1da177e4 3374
02f1175c
JS		 3375 /* byte size and parity */
3376 switch (cflag & CSIZE) {
3377 case CS5:
3378 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS5);
3379 break;
3380 case CS6:
3381 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS6);
3382 break;
3383 case CS7:
3384 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS7);
3385 break;
3386 case CS8:
3387 cy_writel(&ch_ctrl->comm_data_l, C_DL_CS8);
3388 break;
3389 }
3390 if (cflag & CSTOPB) {
3391 cy_writel(&ch_ctrl->comm_data_l,
db05c3b1 3392 readl(&ch_ctrl->comm_data_l) | C_DL_2STOP);
02f1175c
JS		 3393 } else {
3394 cy_writel(&ch_ctrl->comm_data_l,
db05c3b1 3395 readl(&ch_ctrl->comm_data_l) | C_DL_1STOP);
02f1175c
JS		 3396 }
3397 if (cflag & PARENB) {
3398 if (cflag & PARODD) {
3399 cy_writel(&ch_ctrl->comm_parity, C_PR_ODD);
3400 } else {
3401 cy_writel(&ch_ctrl->comm_parity, C_PR_EVEN);
3402 }
3403 } else {
3404 cy_writel(&ch_ctrl->comm_parity, C_PR_NONE);
3405 }
1da177e4 3406
02f1175c
JS		 3407 /* CTS flow control flag */
3408 if (cflag & CRTSCTS) {
3409 cy_writel(&ch_ctrl->hw_flow,
db05c3b1 3410 readl(&ch_ctrl->hw_flow) | C_RS_CTS | C_RS_RTS);
02f1175c 3411 } else {
db05c3b1
JS		 3412 cy_writel(&ch_ctrl->hw_flow, readl(&ch_ctrl->hw_flow) &
3413 ~(C_RS_CTS | C_RS_RTS));
02f1175c
JS		 3414 }
3415 /* As the HW flow control is done in firmware, the driver
3416 doesn't need to care about it */
3417 info->flags &= ~ASYNC_CTS_FLOW;
3418
3419 /* XON/XOFF/XANY flow control flags */
3420 sw_flow = 0;
3421 if (iflag & IXON) {
3422 sw_flow |= C_FL_OXX;
3423 if (iflag & IXANY)
3424 sw_flow |= C_FL_OIXANY;
3425 }
3426 cy_writel(&ch_ctrl->sw_flow, sw_flow);
3427
3428 retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTL, 0L);
3429 if (retval != 0) {
3430 printk("cyc:set_line_char retval on ttyC%d was %x\n",
3431 info->line, retval);
3432 }
3433
3434 /* CD sensitivity */
3435 if (cflag & CLOCAL) {
3436 info->flags &= ~ASYNC_CHECK_CD;
3437 } else {
3438 info->flags |= ASYNC_CHECK_CD;
3439 }
1da177e4 3440
02f1175c
JS		 3441 if (baud == 0) { /* baud rate is zero, turn off line */
3442 cy_writel(&ch_ctrl->rs_control,
db05c3b1 3443 readl(&ch_ctrl->rs_control) & ~C_RS_DTR);
1da177e4 3444#ifdef CY_DEBUG_DTR
02f1175c 3445 printk("cyc:set_line_char dropping Z DTR\n");
1da177e4 3446#endif
02f1175c
JS		 3447 } else {
3448 cy_writel(&ch_ctrl->rs_control,
db05c3b1 3449 readl(&ch_ctrl->rs_control) | C_RS_DTR);
1da177e4 3450#ifdef CY_DEBUG_DTR
02f1175c 3451 printk("cyc:set_line_char raising Z DTR\n");
1da177e4 3452#endif
02f1175c 3453 }
1da177e4 3454
02f1175c
JS		 3455 retval = cyz_issue_cmd(&cy_card[card], channel, C_CM_IOCTLM,0L);
3456 if (retval != 0) {
3457 printk("cyc:set_line_char(2) retval on ttyC%d was %x\n",
3458 info->line, retval);
3459 }
1da177e4 3460
02f1175c
JS		 3461 if (info->tty) {
3462 clear_bit(TTY_IO_ERROR, &info->tty->flags);
3463 }
1da177e4 3464 }
02f1175c 3465} /* set_line_char */
1da177e4
LT		 3466
3467static int
02f1175c
JS		 3468get_serial_info(struct cyclades_port *info,
3469 struct serial_struct __user * retinfo)
1da177e4 3470{
02f1175c
JS		 3471 struct serial_struct tmp;
3472 struct cyclades_card *cinfo = &cy_card[info->card];
1da177e4 3473
02f1175c
JS		 3474 if (!retinfo)
3475 return -EFAULT;
3476 memset(&tmp, 0, sizeof(tmp));
3477 tmp.type = info->type;
3478 tmp.line = info->line;
3479 tmp.port = info->card * 0x100 + info->line - cinfo->first_line;
3480 tmp.irq = cinfo->irq;
3481 tmp.flags = info->flags;
3482 tmp.close_delay = info->close_delay;
d5dedf99 3483 tmp.closing_wait = info->closing_wait;
02f1175c
JS		 3484 tmp.baud_base = info->baud;
3485 tmp.custom_divisor = info->custom_divisor;
3486 tmp.hub6 = 0; /*!!! */
3487 return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
3488} /* get_serial_info */
1da177e4
LT		 3489
3490static int
02f1175c
JS		 3491set_serial_info(struct cyclades_port *info,
3492 struct serial_struct __user * new_info)
1da177e4 3493{
02f1175c
JS		 3494 struct serial_struct new_serial;
3495 struct cyclades_port old_info;
3496
3497 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
3498 return -EFAULT;
3499 old_info = *info;
3500
3501 if (!capable(CAP_SYS_ADMIN)) {
3502 if (new_serial.close_delay != info->close_delay ||
3503 new_serial.baud_base != info->baud ||
3504 (new_serial.flags & ASYNC_FLAGS &
3505 ~ASYNC_USR_MASK) !=
3506 (info->flags & ASYNC_FLAGS & ~ASYNC_USR_MASK))
3507 return -EPERM;
3508 info->flags = (info->flags & ~ASYNC_USR_MASK) |
3509 (new_serial.flags & ASYNC_USR_MASK);
3510 info->baud = new_serial.baud_base;
3511 info->custom_divisor = new_serial.custom_divisor;
3512 goto check_and_exit;
3513 }
3514
3515 /*
3516 * OK, past this point, all the error checking has been done.
3517 * At this point, we start making changes.....
3518 */
3519
3520 info->baud = new_serial.baud_base;
3521 info->custom_divisor = new_serial.custom_divisor;
3522 info->flags = (info->flags & ~ASYNC_FLAGS) |
3523 (new_serial.flags & ASYNC_FLAGS);
3524 info->close_delay = new_serial.close_delay * HZ / 100;
3525 info->closing_wait = new_serial.closing_wait * HZ / 100;
1da177e4
LT		 3526
3527check_and_exit:
02f1175c
JS		 3528 if (info->flags & ASYNC_INITIALIZED) {
3529 set_line_char(info);
3530 return 0;
3531 } else {
3532 return startup(info);
3533 }
3534} /* set_serial_info */
1da177e4
LT		 3535
3536/*
3537 * get_lsr_info - get line status register info
3538 *
3539 * Purpose: Let user call ioctl() to get info when the UART physically
3540 * is emptied. On bus types like RS485, the transmitter must
3541 * release the bus after transmitting. This must be done when
3542 * the transmit shift register is empty, not be done when the
3543 * transmit holding register is empty. This functionality
3544 * allows an RS485 driver to be written in user space.
3545 */
02f1175c 3546static int get_lsr_info(struct cyclades_port *info, unsigned int __user * value)
1da177e4 3547{
02f1175c
JS		 3548 int card, chip, channel, index;
3549 unsigned char status;
3550 unsigned int result;
3551 unsigned long flags;
3552 void __iomem *base_addr;
1da177e4 3553
02f1175c
JS		 3554 card = info->card;
3555 channel = (info->line) - (cy_card[card].first_line);
3556 if (!IS_CYC_Z(cy_card[card])) {
3557 chip = channel >> 2;
3558 channel &= 0x03;
3559 index = cy_card[card].bus_index;
3560 base_addr =
3561 cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3562
3563 CY_LOCK(info, flags);
db05c3b1 3564 status = readb(base_addr + (CySRER << index)) &
02f1175c
JS		 3565 (CyTxRdy | CyTxMpty);
3566 CY_UNLOCK(info, flags);
3567 result = (status ? 0 : TIOCSER_TEMT);
3568 } else {
3569 /* Not supported yet */
3570 return -EINVAL;
3571 }
3572 return put_user(result, (unsigned long __user *)value);
1da177e4
LT		 3573}
3574
02f1175c 3575static int cy_tiocmget(struct tty_struct *tty, struct file *file)
1da177e4 3576{
02f1175c
JS		 3577 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
3578 int card, chip, channel, index;
3579 void __iomem *base_addr;
3580 unsigned long flags;
3581 unsigned char status;
3582 unsigned long lstatus;
3583 unsigned int result;
3584 struct FIRM_ID __iomem *firm_id;
3585 struct ZFW_CTRL __iomem *zfw_ctrl;
3586 struct BOARD_CTRL __iomem *board_ctrl;
3587 struct CH_CTRL __iomem *ch_ctrl;
3588
3589 if (serial_paranoia_check(info, tty->name, __FUNCTION__))
3590 return -ENODEV;
1da177e4 3591
02f1175c
JS		 3592 card = info->card;
3593 channel = (info->line) - (cy_card[card].first_line);
3594 if (!IS_CYC_Z(cy_card[card])) {
3595 chip = channel >> 2;
3596 channel &= 0x03;
3597 index = cy_card[card].bus_index;
3598 base_addr =
3599 cy_card[card].base_addr + (cy_chip_offset[chip] << index);
1da177e4 3600
02f1175c
JS		 3601 CY_LOCK(info, flags);
3602 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
db05c3b1
JS		 3603 status = readb(base_addr + (CyMSVR1 << index));
3604 status |= readb(base_addr + (CyMSVR2 << index));
02f1175c
JS		 3605 CY_UNLOCK(info, flags);
3606
3607 if (info->rtsdtr_inv) {
3608 result = ((status & CyRTS) ? TIOCM_DTR : 0) |
3609 ((status & CyDTR) ? TIOCM_RTS : 0);
3610 } else {
3611 result = ((status & CyRTS) ? TIOCM_RTS : 0) |
3612 ((status & CyDTR) ? TIOCM_DTR : 0);
3613 }
3614 result |= ((status & CyDCD) ? TIOCM_CAR : 0) |
3615 ((status & CyRI) ? TIOCM_RNG : 0) |
3616 ((status & CyDSR) ? TIOCM_DSR : 0) |
3617 ((status & CyCTS) ? TIOCM_CTS : 0);
1da177e4 3618 } else {
02f1175c 3619 base_addr = cy_card[card].base_addr;
1da177e4 3620
02f1175c
JS		 3621 if (cy_card[card].num_chips != -1) {
3622 return -EINVAL;
3623 }
1da177e4 3624
02f1175c
JS		 3625 firm_id = cy_card[card].base_addr + ID_ADDRESS;
3626 if (ISZLOADED(cy_card[card])) {
3627 zfw_ctrl = cy_card[card].base_addr +
db05c3b1 3628 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
02f1175c
JS		 3629 board_ctrl = &zfw_ctrl->board_ctrl;
3630 ch_ctrl = zfw_ctrl->ch_ctrl;
db05c3b1 3631 lstatus = readl(&ch_ctrl[channel].rs_status);
02f1175c
JS		 3632 result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
3633 ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
3634 ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
3635 ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
3636 ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
3637 ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
3638 } else {
3639 result = 0;
3640 return -ENODEV;
3641 }
1da177e4 3642
02f1175c
JS		 3643 }
3644 return result;
3645} /* cy_tiomget */
1da177e4
LT		 3646
3647static int
3648cy_tiocmset(struct tty_struct *tty, struct file *file,
02f1175c 3649 unsigned int set, unsigned int clear)
1da177e4 3650{
02f1175c
JS		 3651 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
3652 int card, chip, channel, index;
3653 void __iomem *base_addr;
3654 unsigned long flags;
3655 struct FIRM_ID __iomem *firm_id;
3656 struct ZFW_CTRL __iomem *zfw_ctrl;
3657 struct BOARD_CTRL __iomem *board_ctrl;
3658 struct CH_CTRL __iomem *ch_ctrl;
3659 int retval;
3660
3661 if (serial_paranoia_check(info, tty->name, __FUNCTION__))
3662 return -ENODEV;
3663
3664 card = info->card;
3665 channel = (info->line) - (cy_card[card].first_line);
3666 if (!IS_CYC_Z(cy_card[card])) {
3667 chip = channel >> 2;
3668 channel &= 0x03;
3669 index = cy_card[card].bus_index;
3670 base_addr =
3671 cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3672
3673 if (set & TIOCM_RTS) {
3674 CY_LOCK(info, flags);
3675 cy_writeb(base_addr + (CyCAR << index),
3676 (u_char) channel);
3677 if (info->rtsdtr_inv) {
3678 cy_writeb(base_addr + (CyMSVR2 << index),
3679 CyDTR);
3680 } else {
3681 cy_writeb(base_addr + (CyMSVR1 << index),
3682 CyRTS);
3683 }
3684 CY_UNLOCK(info, flags);
3685 }
3686 if (clear & TIOCM_RTS) {
3687 CY_LOCK(info, flags);
3688 cy_writeb(base_addr + (CyCAR << index),
3689 (u_char) channel);
3690 if (info->rtsdtr_inv) {
3691 cy_writeb(base_addr + (CyMSVR2 << index),
3692 ~CyDTR);
3693 } else {
3694 cy_writeb(base_addr + (CyMSVR1 << index),
3695 ~CyRTS);
3696 }
3697 CY_UNLOCK(info, flags);
3698 }
3699 if (set & TIOCM_DTR) {
3700 CY_LOCK(info, flags);
3701 cy_writeb(base_addr + (CyCAR << index),
3702 (u_char) channel);
3703 if (info->rtsdtr_inv) {
3704 cy_writeb(base_addr + (CyMSVR1 << index),
3705 CyRTS);
3706 } else {
3707 cy_writeb(base_addr + (CyMSVR2 << index),
3708 CyDTR);
3709 }
1da177e4 3710#ifdef CY_DEBUG_DTR
02f1175c
JS		 3711 printk("cyc:set_modem_info raising DTR\n");
3712 printk(" status: 0x%x, 0x%x\n",
db05c3b1
JS		 3713 readb(base_addr + (CyMSVR1 << index)),
3714 readb(base_addr + (CyMSVR2 << index)));
1da177e4 3715#endif
02f1175c
JS		 3716 CY_UNLOCK(info, flags);
3717 }
3718 if (clear & TIOCM_DTR) {
3719 CY_LOCK(info, flags);
3720 cy_writeb(base_addr + (CyCAR << index),
3721 (u_char) channel);
3722 if (info->rtsdtr_inv) {
3723 cy_writeb(base_addr + (CyMSVR1 << index),
3724 ~CyRTS);
3725 } else {
3726 cy_writeb(base_addr + (CyMSVR2 << index),
3727 ~CyDTR);
3728 }
1da177e4
LT		 3729
3730#ifdef CY_DEBUG_DTR
02f1175c
JS		 3731 printk("cyc:set_modem_info dropping DTR\n");
3732 printk(" status: 0x%x, 0x%x\n",
db05c3b1
JS		 3733 readb(base_addr + (CyMSVR1 << index)),
3734 readb(base_addr + (CyMSVR2 << index)));
1da177e4 3735#endif
02f1175c
JS		 3736 CY_UNLOCK(info, flags);
3737 }
3738 } else {
3739 base_addr = cy_card[card].base_addr;
3740
3741 firm_id = cy_card[card].base_addr + ID_ADDRESS;
3742 if (ISZLOADED(cy_card[card])) {
3743 zfw_ctrl = cy_card[card].base_addr +
db05c3b1 3744 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
02f1175c
JS		 3745 board_ctrl = &zfw_ctrl->board_ctrl;
3746 ch_ctrl = zfw_ctrl->ch_ctrl;
3747
3748 if (set & TIOCM_RTS) {
3749 CY_LOCK(info, flags);
3750 cy_writel(&ch_ctrl[channel].rs_control,
db05c3b1
JS		 3751 readl(&ch_ctrl[channel].rs_control) |
3752 C_RS_RTS);
02f1175c
JS		 3753 CY_UNLOCK(info, flags);
3754 }
3755 if (clear & TIOCM_RTS) {
3756 CY_LOCK(info, flags);
3757 cy_writel(&ch_ctrl[channel].rs_control,
db05c3b1
JS		 3758 readl(&ch_ctrl[channel].rs_control) &
3759 ~C_RS_RTS);
02f1175c
JS		 3760 CY_UNLOCK(info, flags);
3761 }
3762 if (set & TIOCM_DTR) {
3763 CY_LOCK(info, flags);
3764 cy_writel(&ch_ctrl[channel].rs_control,
db05c3b1
JS		 3765 readl(&ch_ctrl[channel].rs_control) |
3766 C_RS_DTR);
1da177e4 3767#ifdef CY_DEBUG_DTR
02f1175c 3768 printk("cyc:set_modem_info raising Z DTR\n");
1da177e4 3769#endif
02f1175c
JS		 3770 CY_UNLOCK(info, flags);
3771 }
3772 if (clear & TIOCM_DTR) {
3773 CY_LOCK(info, flags);
3774 cy_writel(&ch_ctrl[channel].rs_control,
db05c3b1
JS		 3775 readl(&ch_ctrl[channel].rs_control) &
3776 ~C_RS_DTR);
1da177e4 3777#ifdef CY_DEBUG_DTR
02f1175c 3778 printk("cyc:set_modem_info clearing Z DTR\n");
1da177e4 3779#endif
02f1175c
JS		 3780 CY_UNLOCK(info, flags);
3781 }
3782 } else {
3783 return -ENODEV;
3784 }
3785 CY_LOCK(info, flags);
3786 retval = cyz_issue_cmd(&cy_card[info->card],
3787 channel, C_CM_IOCTLM, 0L);
3788 if (retval != 0) {
3789 printk("cyc:set_modem_info retval on ttyC%d was %x\n",
3790 info->line, retval);
3791 }
3792 CY_UNLOCK(info, flags);
1da177e4 3793 }
02f1175c
JS		 3794 return 0;
3795} /* cy_tiocmset */
1da177e4
LT		 3796
3797/*
3798 * cy_break() --- routine which turns the break handling on or off
3799 */
02f1175c 3800static void cy_break(struct tty_struct *tty, int break_state)
1da177e4 3801{
02f1175c
JS		 3802 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
3803 unsigned long flags;
1da177e4 3804
02f1175c
JS		 3805 if (serial_paranoia_check(info, tty->name, "cy_break"))
3806 return;
1da177e4 3807
02f1175c
JS		 3808 CY_LOCK(info, flags);
3809 if (!IS_CYC_Z(cy_card[info->card])) {
3810 /* Let the transmit ISR take care of this (since it
3811 requires stuffing characters into the output stream).
3812 */
3813 if (break_state == -1) {
3814 if (!info->breakon) {
3815 info->breakon = 1;
3816 if (!info->xmit_cnt) {
3817 CY_UNLOCK(info, flags);
3818 start_xmit(info);
3819 CY_LOCK(info, flags);
3820 }
3821 }
3822 } else {
3823 if (!info->breakoff) {
3824 info->breakoff = 1;
3825 if (!info->xmit_cnt) {
3826 CY_UNLOCK(info, flags);
3827 start_xmit(info);
3828 CY_LOCK(info, flags);
3829 }
3830 }
1da177e4 3831 }
1da177e4 3832 } else {
02f1175c
JS		 3833 int retval;
3834
3835 if (break_state == -1) {
3836 retval = cyz_issue_cmd(&cy_card[info->card],
3837 info->line - cy_card[info->card].first_line,
3838 C_CM_SET_BREAK, 0L);
3839 if (retval != 0) {
3840 printk("cyc:cy_break (set) retval on ttyC%d "
3841 "was %x\n", info->line, retval);
3842 }
3843 } else {
3844 retval = cyz_issue_cmd(&cy_card[info->card],
3845 info->line - cy_card[info->card].first_line,
3846 C_CM_CLR_BREAK, 0L);
3847 if (retval != 0) {
3848 printk("cyc:cy_break (clr) retval on ttyC%d "
3849 "was %x\n", info->line, retval);
3850 }
1da177e4 3851 }
1da177e4 3852 }
02f1175c
JS		 3853 CY_UNLOCK(info, flags);
3854} /* cy_break */
1da177e4
LT		 3855
3856static int
02f1175c 3857get_mon_info(struct cyclades_port *info, struct cyclades_monitor __user * mon)
1da177e4
LT		 3858{
3859
02f1175c
JS		 3860 if (copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
3861 return -EFAULT;
3862 info->mon.int_count = 0;
3863 info->mon.char_count = 0;
3864 info->mon.char_max = 0;
3865 info->mon.char_last = 0;
3866 return 0;
3867} /* get_mon_info */
1da177e4 3868
02f1175c 3869static int set_threshold(struct cyclades_port *info, unsigned long value)
1da177e4 3870{
02f1175c
JS		 3871 void __iomem *base_addr;
3872 int card, channel, chip, index;
3873 unsigned long flags;
1da177e4 3874
02f1175c
JS		 3875 card = info->card;
3876 channel = info->line - cy_card[card].first_line;
3877 if (!IS_CYC_Z(cy_card[card])) {
3878 chip = channel >> 2;
3879 channel &= 0x03;
3880 index = cy_card[card].bus_index;
3881 base_addr =
3882 cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3883
3884 info->cor3 &= ~CyREC_FIFO;
3885 info->cor3 |= value & CyREC_FIFO;
1da177e4 3886
02f1175c
JS		 3887 CY_LOCK(info, flags);
3888 cy_writeb(base_addr + (CyCOR3 << index), info->cor3);
3889 cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR3ch, index);
3890 CY_UNLOCK(info, flags);
3891 } else {
096dcfce 3892 /* Nothing to do! */
02f1175c
JS		 3893 }
3894 return 0;
3895} /* set_threshold */
1da177e4
LT		 3896
3897static int
02f1175c 3898get_threshold(struct cyclades_port *info, unsigned long __user * value)
1da177e4 3899{
02f1175c
JS		 3900 void __iomem *base_addr;
3901 int card, channel, chip, index;
3902 unsigned long tmp;
1da177e4 3903
02f1175c
JS		 3904 card = info->card;
3905 channel = info->line - cy_card[card].first_line;
3906 if (!IS_CYC_Z(cy_card[card])) {
3907 chip = channel >> 2;
3908 channel &= 0x03;
3909 index = cy_card[card].bus_index;
3910 base_addr =
3911 cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3912
db05c3b1 3913 tmp = readb(base_addr + (CyCOR3 << index)) & CyREC_FIFO;
02f1175c
JS		 3914 return put_user(tmp, value);
3915 } else {
096dcfce 3916 /* Nothing to do! */
02f1175c
JS		 3917 return 0;
3918 }
3919} /* get_threshold */
1da177e4
LT		 3920
3921static int
02f1175c 3922set_default_threshold(struct cyclades_port *info, unsigned long value)
1da177e4 3923{
02f1175c
JS		 3924 info->default_threshold = value & 0x0f;
3925 return 0;
3926} /* set_default_threshold */
1da177e4
LT		 3927
3928static int
02f1175c 3929get_default_threshold(struct cyclades_port *info, unsigned long __user * value)
1da177e4 3930{
02f1175c
JS		 3931 return put_user(info->default_threshold, value);
3932} /* get_default_threshold */
1da177e4 3933
02f1175c 3934static int set_timeout(struct cyclades_port *info, unsigned long value)
1da177e4 3935{
02f1175c
JS		 3936 void __iomem *base_addr;
3937 int card, channel, chip, index;
3938 unsigned long flags;
1da177e4 3939
02f1175c
JS		 3940 card = info->card;
3941 channel = info->line - cy_card[card].first_line;
3942 if (!IS_CYC_Z(cy_card[card])) {
3943 chip = channel >> 2;
3944 channel &= 0x03;
3945 index = cy_card[card].bus_index;
3946 base_addr =
3947 cy_card[card].base_addr + (cy_chip_offset[chip] << index);
1da177e4 3948
02f1175c
JS		 3949 CY_LOCK(info, flags);
3950 cy_writeb(base_addr + (CyRTPR << index), value & 0xff);
3951 CY_UNLOCK(info, flags);
3952 } else {
096dcfce 3953 /* Nothing to do! */
02f1175c
JS		 3954 }
3955 return 0;
3956} /* set_timeout */
1da177e4 3957
02f1175c 3958static int get_timeout(struct cyclades_port *info, unsigned long __user * value)
1da177e4 3959{
02f1175c
JS		 3960 void __iomem *base_addr;
3961 int card, channel, chip, index;
3962 unsigned long tmp;
1da177e4 3963
02f1175c
JS		 3964 card = info->card;
3965 channel = info->line - cy_card[card].first_line;
3966 if (!IS_CYC_Z(cy_card[card])) {
3967 chip = channel >> 2;
3968 channel &= 0x03;
3969 index = cy_card[card].bus_index;
3970 base_addr =
3971 cy_card[card].base_addr + (cy_chip_offset[chip] << index);
3972
db05c3b1 3973 tmp = readb(base_addr + (CyRTPR << index));
02f1175c
JS		 3974 return put_user(tmp, value);
3975 } else {
096dcfce 3976 /* Nothing to do! */
02f1175c
JS		 3977 return 0;
3978 }
3979} /* get_timeout */
1da177e4 3980
02f1175c 3981static int set_default_timeout(struct cyclades_port *info, unsigned long value)
1da177e4 3982{
02f1175c
JS		 3983 info->default_timeout = value & 0xff;
3984 return 0;
3985} /* set_default_timeout */
1da177e4
LT		 3986
3987static int
02f1175c 3988get_default_timeout(struct cyclades_port *info, unsigned long __user * value)
1da177e4 3989{
02f1175c
JS		 3990 return put_user(info->default_timeout, value);
3991} /* get_default_timeout */
1da177e4
LT		 3992
3993/*
3994 * This routine allows the tty driver to implement device-
3995 * specific ioctl's. If the ioctl number passed in cmd is
3996 * not recognized by the driver, it should return ENOIOCTLCMD.
3997 */
3998static int
02f1175c
JS		 3999cy_ioctl(struct tty_struct *tty, struct file *file,
4000 unsigned int cmd, unsigned long arg)
1da177e4 4001{
02f1175c
JS		 4002 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4003 struct cyclades_icount cprev, cnow; /* kernel counter temps */
4004 struct serial_icounter_struct __user *p_cuser; /* user space */
4005 int ret_val = 0;
4006 unsigned long flags;
4007 void __user *argp = (void __user *)arg;
4008
4009 if (serial_paranoia_check(info, tty->name, "cy_ioctl"))
4010 return -ENODEV;
1da177e4
LT		 4011
4012#ifdef CY_DEBUG_OTHER
02f1175c 4013 printk("cyc:cy_ioctl ttyC%d, cmd = %x arg = %lx\n", info->line, cmd, arg); /* */
1da177e4
LT		 4014#endif
4015
02f1175c
JS		 4016 switch (cmd) {
4017 case CYGETMON:
4018 ret_val = get_mon_info(info, argp);
4019 break;
4020 case CYGETTHRESH:
4021 ret_val = get_threshold(info, argp);
4022 break;
4023 case CYSETTHRESH:
4024 ret_val = set_threshold(info, arg);
4025 break;
4026 case CYGETDEFTHRESH:
4027 ret_val = get_default_threshold(info, argp);
4028 break;
4029 case CYSETDEFTHRESH:
4030 ret_val = set_default_threshold(info, arg);
4031 break;
4032 case CYGETTIMEOUT:
4033 ret_val = get_timeout(info, argp);
4034 break;
4035 case CYSETTIMEOUT:
4036 ret_val = set_timeout(info, arg);
4037 break;
4038 case CYGETDEFTIMEOUT:
4039 ret_val = get_default_timeout(info, argp);
4040 break;
4041 case CYSETDEFTIMEOUT:
4042 ret_val = set_default_timeout(info, arg);
4043 break;
1da177e4 4044 case CYSETRFLOW:
02f1175c
JS		 4045 info->rflow = (int)arg;
4046 ret_val = 0;
4047 break;
1da177e4 4048 case CYGETRFLOW:
02f1175c
JS		 4049 ret_val = info->rflow;
4050 break;
1da177e4 4051 case CYSETRTSDTR_INV:
02f1175c
JS		 4052 info->rtsdtr_inv = (int)arg;
4053 ret_val = 0;
4054 break;
1da177e4 4055 case CYGETRTSDTR_INV:
02f1175c
JS		 4056 ret_val = info->rtsdtr_inv;
4057 break;
1da177e4 4058 case CYGETCARDINFO:
02f1175c
JS		 4059 if (copy_to_user(argp, &cy_card[info->card],
4060 sizeof(struct cyclades_card))) {
4061 ret_val = -EFAULT;
4062 break;
4063 }
4064 ret_val = 0;
1da177e4 4065 break;
1da177e4 4066 case CYGETCD1400VER:
02f1175c
JS		 4067 ret_val = info->chip_rev;
4068 break;
1da177e4
LT		 4069#ifndef CONFIG_CYZ_INTR
4070 case CYZSETPOLLCYCLE:
02f1175c
JS		 4071 cyz_polling_cycle = (arg * HZ) / 1000;
4072 ret_val = 0;
4073 break;
1da177e4 4074 case CYZGETPOLLCYCLE:
02f1175c
JS		 4075 ret_val = (cyz_polling_cycle * 1000) / HZ;
4076 break;
4077#endif /* CONFIG_CYZ_INTR */
1da177e4 4078 case CYSETWAIT:
02f1175c
JS		 4079 info->closing_wait = (unsigned short)arg *HZ / 100;
4080 ret_val = 0;
4081 break;
1da177e4 4082 case CYGETWAIT:
02f1175c
JS		 4083 ret_val = info->closing_wait / (HZ / 100);
4084 break;
4085 case TIOCGSERIAL:
4086 ret_val = get_serial_info(info, argp);
4087 break;
4088 case TIOCSSERIAL:
4089 ret_val = set_serial_info(info, argp);
4090 break;
4091 case TIOCSERGETLSR: /* Get line status register */
4092 ret_val = get_lsr_info(info, argp);
4093 break;
4094 /*
4095 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
4096 * - mask passed in arg for lines of interest
4097 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
4098 * Caller should use TIOCGICOUNT to see which one it was
4099 */
1da177e4 4100 case TIOCMIWAIT:
1da177e4 4101 CY_LOCK(info, flags);
02f1175c
JS		 4102 /* note the counters on entry */
4103 cprev = info->icount;
1da177e4 4104 CY_UNLOCK(info, flags);
02f1175c
JS		 4105 while (1) {
4106 interruptible_sleep_on(&info->delta_msr_wait);
4107 /* see if a signal did it */
4108 if (signal_pending(current)) {
4109 return -ERESTARTSYS;
4110 }
1da177e4 4111
02f1175c
JS		 4112 CY_LOCK(info, flags);
4113 cnow = info->icount; /* atomic copy */
4114 CY_UNLOCK(info, flags);
4115
4116 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
4117 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
4118 return -EIO; /* no change => error */
4119 }
4120 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
4121 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
4122 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
4123 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
4124 return 0;
4125 }
4126 cprev = cnow;
1da177e4 4127 }
02f1175c 4128 /* NOTREACHED */
1da177e4 4129
02f1175c
JS		 4130 /*
4131 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
4132 * Return: write counters to the user passed counter struct
4133 * NB: both 1->0 and 0->1 transitions are counted except for
4134 * RI where only 0->1 is counted.
4135 */
1da177e4 4136 case TIOCGICOUNT:
02f1175c
JS		 4137 CY_LOCK(info, flags);
4138 cnow = info->icount;
4139 CY_UNLOCK(info, flags);
4140 p_cuser = argp;
4141 ret_val = put_user(cnow.cts, &p_cuser->cts);
4142 if (ret_val)
4143 return ret_val;
4144 ret_val = put_user(cnow.dsr, &p_cuser->dsr);
4145 if (ret_val)
4146 return ret_val;
4147 ret_val = put_user(cnow.rng, &p_cuser->rng);
4148 if (ret_val)
4149 return ret_val;
4150 ret_val = put_user(cnow.dcd, &p_cuser->dcd);
4151 if (ret_val)
4152 return ret_val;
4153 ret_val = put_user(cnow.rx, &p_cuser->rx);
4154 if (ret_val)
4155 return ret_val;
4156 ret_val = put_user(cnow.tx, &p_cuser->tx);
4157 if (ret_val)
4158 return ret_val;
4159 ret_val = put_user(cnow.frame, &p_cuser->frame);
4160 if (ret_val)
4161 return ret_val;
4162 ret_val = put_user(cnow.overrun, &p_cuser->overrun);
4163 if (ret_val)
4164 return ret_val;
4165 ret_val = put_user(cnow.parity, &p_cuser->parity);
4166 if (ret_val)
4167 return ret_val;
4168 ret_val = put_user(cnow.brk, &p_cuser->brk);
4169 if (ret_val)
4170 return ret_val;
4171 ret_val = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
4172 if (ret_val)
4173 return ret_val;
4174 ret_val = 0;
4175 break;
4176 default:
4177 ret_val = -ENOIOCTLCMD;
4178 }
1da177e4
LT		 4179
4180#ifdef CY_DEBUG_OTHER
02f1175c 4181 printk(" cyc:cy_ioctl done\n");
1da177e4
LT		 4182#endif
4183
02f1175c
JS		 4184 return ret_val;
4185} /* cy_ioctl */
1da177e4
LT		 4186
4187/*
4188 * This routine allows the tty driver to be notified when
4189 * device's termios settings have changed. Note that a
4190 * well-designed tty driver should be prepared to accept the case
4191 * where old == NULL, and try to do something rational.
4192 */
02f1175c 4193static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
1da177e4 4194{
02f1175c 4195 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
1da177e4
LT		 4196
4197#ifdef CY_DEBUG_OTHER
02f1175c 4198 printk("cyc:cy_set_termios ttyC%d\n", info->line);
1da177e4
LT		 4199#endif
4200
02f1175c
JS		 4201 if (tty->termios->c_cflag == old_termios->c_cflag &&
4202 (tty->termios->c_iflag & (IXON | IXANY)) ==
4203 (old_termios->c_iflag & (IXON | IXANY)))
4204 return;
4205 set_line_char(info);
4206
4207 if ((old_termios->c_cflag & CRTSCTS) &&
4208 !(tty->termios->c_cflag & CRTSCTS)) {
4209 tty->hw_stopped = 0;
4210 cy_start(tty);
4211 }
1da177e4 4212#if 0
02f1175c
JS		 4213 /*
4214 * No need to wake up processes in open wait, since they
4215 * sample the CLOCAL flag once, and don't recheck it.
4216 * XXX It's not clear whether the current behavior is correct
4217 * or not. Hence, this may change.....
4218 */
4219 if (!(old_termios->c_cflag & CLOCAL) &&
4220 (tty->termios->c_cflag & CLOCAL))
4221 wake_up_interruptible(&info->open_wait);
1da177e4 4222#endif
02f1175c 4223} /* cy_set_termios */
1da177e4
LT		 4224
4225/* This function is used to send a high-priority XON/XOFF character to
4226 the device.
4227*/
02f1175c 4228static void cy_send_xchar(struct tty_struct *tty, char ch)
1da177e4 4229{
02f1175c 4230 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
1da177e4
LT		 4231 int card, channel;
4232
02f1175c 4233 if (serial_paranoia_check(info, tty->name, "cy_send_xchar"))
1da177e4
LT		 4234 return;
4235
02f1175c 4236 info->x_char = ch;
1da177e4
LT		 4237
4238 if (ch)
02f1175c 4239 cy_start(tty);
1da177e4
LT		 4240
4241 card = info->card;
4242 channel = info->line - cy_card[card].first_line;
4243
02f1175c
JS		 4244 if (IS_CYC_Z(cy_card[card])) {
4245 if (ch == STOP_CHAR(tty))
4246 cyz_issue_cmd(&cy_card[card], channel, C_CM_SENDXOFF,
4247 0L);
4248 else if (ch == START_CHAR(tty))
4249 cyz_issue_cmd(&cy_card[card], channel, C_CM_SENDXON,
4250 0L);
1da177e4
LT		 4251 }
4252}
4253
4254/* This routine is called by the upper-layer tty layer to signal
4255 that incoming characters should be throttled because the input
4256 buffers are close to full.
4257 */
02f1175c 4258static void cy_throttle(struct tty_struct *tty)
1da177e4 4259{
02f1175c
JS		 4260 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4261 unsigned long flags;
4262 void __iomem *base_addr;
4263 int card, chip, channel, index;
1da177e4
LT		 4264
4265#ifdef CY_DEBUG_THROTTLE
02f1175c 4266 char buf[64];
1da177e4 4267
02f1175c
JS		 4268 printk("cyc:throttle %s: %d....ttyC%d\n", tty_name(tty, buf),
4269 tty->ldisc.chars_in_buffer(tty), info->line);
1da177e4
LT		 4270#endif
4271
02f1175c
JS		 4272 if (serial_paranoia_check(info, tty->name, "cy_throttle")) {
4273 return;
4274 }
4275
4276 card = info->card;
4277
4278 if (I_IXOFF(tty)) {
4279 if (!IS_CYC_Z(cy_card[card]))
4280 cy_send_xchar(tty, STOP_CHAR(tty));
4281 else
4282 info->throttle = 1;
4283 }
1da177e4 4284
02f1175c
JS		 4285 if (tty->termios->c_cflag & CRTSCTS) {
4286 channel = info->line - cy_card[card].first_line;
4287 if (!IS_CYC_Z(cy_card[card])) {
4288 chip = channel >> 2;
4289 channel &= 0x03;
4290 index = cy_card[card].bus_index;
4291 base_addr = cy_card[card].base_addr +
4292 (cy_chip_offset[chip] << index);
4293
4294 CY_LOCK(info, flags);
4295 cy_writeb(base_addr + (CyCAR << index),
4296 (u_char) channel);
4297 if (info->rtsdtr_inv) {
4298 cy_writeb(base_addr + (CyMSVR2 << index),
4299 ~CyDTR);
4300 } else {
4301 cy_writeb(base_addr + (CyMSVR1 << index),
4302 ~CyRTS);
4303 }
4304 CY_UNLOCK(info, flags);
4305 } else {
4306 info->throttle = 1;
4307 }
4308 }
02f1175c 4309} /* cy_throttle */
1da177e4
LT		 4310
4311/*
4312 * This routine notifies the tty driver that it should signal
4313 * that characters can now be sent to the tty without fear of
4314 * overrunning the input buffers of the line disciplines.
4315 */
02f1175c 4316static void cy_unthrottle(struct tty_struct *tty)
1da177e4 4317{
02f1175c
JS		 4318 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4319 unsigned long flags;
4320 void __iomem *base_addr;
4321 int card, chip, channel, index;
1da177e4
LT		 4322
4323#ifdef CY_DEBUG_THROTTLE
02f1175c
JS		 4324 char buf[64];
4325
4326 printk("cyc:unthrottle %s: %d....ttyC%d\n", tty_name(tty, buf),
4327 tty->ldisc.chars_in_buffer(tty), info->line);
1da177e4
LT		 4328#endif
4329
02f1175c
JS		 4330 if (serial_paranoia_check(info, tty->name, "cy_unthrottle")) {
4331 return;
4332 }
1da177e4 4333
02f1175c
JS		 4334 if (I_IXOFF(tty)) {
4335 if (info->x_char)
4336 info->x_char = 0;
4337 else
4338 cy_send_xchar(tty, START_CHAR(tty));
1da177e4 4339 }
1da177e4 4340
02f1175c
JS		 4341 if (tty->termios->c_cflag & CRTSCTS) {
4342 card = info->card;
4343 channel = info->line - cy_card[card].first_line;
4344 if (!IS_CYC_Z(cy_card[card])) {
4345 chip = channel >> 2;
4346 channel &= 0x03;
4347 index = cy_card[card].bus_index;
4348 base_addr = cy_card[card].base_addr +
4349 (cy_chip_offset[chip] << index);
4350
4351 CY_LOCK(info, flags);
4352 cy_writeb(base_addr + (CyCAR << index),
4353 (u_char) channel);
4354 if (info->rtsdtr_inv) {
4355 cy_writeb(base_addr + (CyMSVR2 << index),
4356 CyDTR);
4357 } else {
4358 cy_writeb(base_addr + (CyMSVR1 << index),
4359 CyRTS);
4360 }
4361 CY_UNLOCK(info, flags);
4362 } else {
4363 info->throttle = 0;
4364 }
4365 }
02f1175c 4366} /* cy_unthrottle */
1da177e4
LT		 4367
4368/* cy_start and cy_stop provide software output flow control as a
4369 function of XON/XOFF, software CTS, and other such stuff.
4370*/
02f1175c 4371static void cy_stop(struct tty_struct *tty)
1da177e4 4372{
02f1175c
JS		 4373 struct cyclades_card *cinfo;
4374 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4375 void __iomem *base_addr;
4376 int chip, channel, index;
4377 unsigned long flags;
1da177e4
LT		 4378
4379#ifdef CY_DEBUG_OTHER
02f1175c 4380 printk("cyc:cy_stop ttyC%d\n", info->line); /* */
1da177e4
LT		 4381#endif
4382
02f1175c
JS		 4383 if (serial_paranoia_check(info, tty->name, "cy_stop"))
4384 return;
1da177e4 4385
02f1175c
JS		 4386 cinfo = &cy_card[info->card];
4387 channel = info->line - cinfo->first_line;
4388 if (!IS_CYC_Z(*cinfo)) {
4389 index = cinfo->bus_index;
4390 chip = channel >> 2;
4391 channel &= 0x03;
4392 base_addr = cy_card[info->card].base_addr +
4393 (cy_chip_offset[chip] << index);
1da177e4 4394
02f1175c
JS		 4395 CY_LOCK(info, flags);
4396 cy_writeb(base_addr + (CyCAR << index),
4397 (u_char)(channel & 0x0003)); /* index channel */
4398 cy_writeb(base_addr + (CySRER << index),
db05c3b1 4399 readb(base_addr + (CySRER << index)) & ~CyTxRdy);
02f1175c
JS		 4400 CY_UNLOCK(info, flags);
4401 } else {
096dcfce 4402 /* Nothing to do! */
02f1175c 4403 }
02f1175c 4404} /* cy_stop */
1da177e4 4405
02f1175c 4406static void cy_start(struct tty_struct *tty)
1da177e4 4407{
02f1175c
JS		 4408 struct cyclades_card *cinfo;
4409 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4410 void __iomem *base_addr;
4411 int chip, channel, index;
4412 unsigned long flags;
1da177e4
LT		 4413
4414#ifdef CY_DEBUG_OTHER
02f1175c 4415 printk("cyc:cy_start ttyC%d\n", info->line); /* */
1da177e4
LT		 4416#endif
4417
02f1175c
JS		 4418 if (serial_paranoia_check(info, tty->name, "cy_start"))
4419 return;
1da177e4 4420
02f1175c
JS		 4421 cinfo = &cy_card[info->card];
4422 channel = info->line - cinfo->first_line;
4423 index = cinfo->bus_index;
4424 if (!IS_CYC_Z(*cinfo)) {
4425 chip = channel >> 2;
4426 channel &= 0x03;
4427 base_addr = cy_card[info->card].base_addr +
4428 (cy_chip_offset[chip] << index);
1da177e4 4429
02f1175c
JS		 4430 CY_LOCK(info, flags);
4431 cy_writeb(base_addr + (CyCAR << index), (u_char) (channel & 0x0003)); /* index channel */
4432 cy_writeb(base_addr + (CySRER << index),
db05c3b1 4433 readb(base_addr + (CySRER << index)) | CyTxRdy);
02f1175c
JS		 4434 CY_UNLOCK(info, flags);
4435 } else {
096dcfce 4436 /* Nothing to do! */
02f1175c 4437 }
02f1175c 4438} /* cy_start */
1da177e4 4439
02f1175c 4440static void cy_flush_buffer(struct tty_struct *tty)
1da177e4 4441{
02f1175c
JS		 4442 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4443 int card, channel, retval;
4444 unsigned long flags;
4445
1da177e4 4446#ifdef CY_DEBUG_IO
02f1175c 4447 printk("cyc:cy_flush_buffer ttyC%d\n", info->line); /* */
1da177e4
LT		 4448#endif
4449
02f1175c
JS		 4450 if (serial_paranoia_check(info, tty->name, "cy_flush_buffer"))
4451 return;
1da177e4 4452
02f1175c
JS		 4453 card = info->card;
4454 channel = (info->line) - (cy_card[card].first_line);
1da177e4 4455
1da177e4 4456 CY_LOCK(info, flags);
02f1175c 4457 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1da177e4 4458 CY_UNLOCK(info, flags);
1da177e4 4459
02f1175c
JS		 4460 if (IS_CYC_Z(cy_card[card])) { /* If it is a Z card, flush the on-board
4461 buffers as well */
4462 CY_LOCK(info, flags);
4463 retval =
4464 cyz_issue_cmd(&cy_card[card], channel, C_CM_FLUSH_TX, 0L);
4465 if (retval != 0) {
4466 printk("cyc: flush_buffer retval on ttyC%d was %x\n",
4467 info->line, retval);
4468 }
4469 CY_UNLOCK(info, flags);
4470 }
4471 tty_wakeup(tty);
02f1175c 4472} /* cy_flush_buffer */
1da177e4
LT		 4473
4474/*
4475 * cy_hangup() --- called by tty_hangup() when a hangup is signaled.
4476 */
02f1175c 4477static void cy_hangup(struct tty_struct *tty)
1da177e4 4478{
02f1175c
JS		 4479 struct cyclades_port *info = (struct cyclades_port *)tty->driver_data;
4480
1da177e4 4481#ifdef CY_DEBUG_OTHER
02f1175c 4482 printk("cyc:cy_hangup ttyC%d\n", info->line); /* */
1da177e4
LT		 4483#endif
4484
02f1175c
JS		 4485 if (serial_paranoia_check(info, tty->name, "cy_hangup"))
4486 return;
1da177e4 4487
02f1175c
JS		 4488 cy_flush_buffer(tty);
4489 shutdown(info);
4490 info->event = 0;
4491 info->count = 0;
1da177e4 4492#ifdef CY_DEBUG_COUNT
02f1175c 4493 printk("cyc:cy_hangup (%d): setting count to 0\n", current->pid);
1da177e4 4494#endif
02f1175c
JS		 4495 info->tty = NULL;
4496 info->flags &= ~ASYNC_NORMAL_ACTIVE;
4497 wake_up_interruptible(&info->open_wait);
4498} /* cy_hangup */
1da177e4
LT		 4499
4500/*
4501 * ---------------------------------------------------------------------
4502 * cy_init() and friends
4503 *
4504 * cy_init() is called at boot-time to initialize the serial driver.
4505 * ---------------------------------------------------------------------
4506 */
4507
4508/* initialize chips on Cyclom-Y card -- return number of valid
4509 chips (which is number of ports/4) */
4510static unsigned short __init
02f1175c 4511cyy_init_card(void __iomem * true_base_addr, int index)
1da177e4 4512{
02f1175c
JS		 4513 unsigned int chip_number;
4514 void __iomem *base_addr;
4515
4516 cy_writeb(true_base_addr + (Cy_HwReset << index), 0);
4517 /* Cy_HwReset is 0x1400 */
4518 cy_writeb(true_base_addr + (Cy_ClrIntr << index), 0);
4519 /* Cy_ClrIntr is 0x1800 */
4520 udelay(500L);
4521
4522 for (chip_number = 0; chip_number < CyMAX_CHIPS_PER_CARD; chip_number++) {
4523 base_addr =
4524 true_base_addr + (cy_chip_offset[chip_number] << index);
4525 mdelay(1);
db05c3b1 4526 if (readb(base_addr + (CyCCR << index)) != 0x00) {
02f1175c
JS		 4527 /*************
4528 printk(" chip #%d at %#6lx is never idle (CCR != 0)\n",
4529 chip_number, (unsigned long)base_addr);
4530 *************/
4531 return chip_number;
4532 }
4533
4534 cy_writeb(base_addr + (CyGFRCR << index), 0);
4535 udelay(10L);
4536
4537 /* The Cyclom-16Y does not decode address bit 9 and therefore
4538 cannot distinguish between references to chip 0 and a non-
4539 existent chip 4. If the preceding clearing of the supposed
4540 chip 4 GFRCR register appears at chip 0, there is no chip 4
4541 and this must be a Cyclom-16Y, not a Cyclom-32Ye.
4542 */
db05c3b1 4543 if (chip_number == 4 && readb(true_base_addr +
02f1175c
JS		 4544 (cy_chip_offset[0] << index) +
4545 (CyGFRCR << index)) == 0) {
4546 return chip_number;
4547 }
4548
4549 cy_writeb(base_addr + (CyCCR << index), CyCHIP_RESET);
4550 mdelay(1);
4551
db05c3b1 4552 if (readb(base_addr + (CyGFRCR << index)) == 0x00) {
02f1175c
JS		 4553 /*
4554 printk(" chip #%d at %#6lx is not responding ",
4555 chip_number, (unsigned long)base_addr);
4556 printk("(GFRCR stayed 0)\n",
4557 */
4558 return chip_number;
4559 }
db05c3b1 4560 if ((0xf0 & (readb(base_addr + (CyGFRCR << index)))) !=
02f1175c
JS		 4561 0x40) {
4562 /*
4563 printk(" chip #%d at %#6lx is not valid (GFRCR == "
4564 "%#2x)\n",
4565 chip_number, (unsigned long)base_addr,
4566 base_addr[CyGFRCR<<index]);
4567 */
4568 return chip_number;
4569 }
4570 cy_writeb(base_addr + (CyGCR << index), CyCH0_SERIAL);
db05c3b1 4571 if (readb(base_addr + (CyGFRCR << index)) >= CD1400_REV_J) {
02f1175c
JS		 4572 /* It is a CD1400 rev. J or later */
4573 /* Impossible to reach 5ms with this chip.
4574 Changed to 2ms instead (f = 500 Hz). */
4575 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_60_2MS);
4576 } else {
4577 /* f = 200 Hz */
4578 cy_writeb(base_addr + (CyPPR << index), CyCLOCK_25_5MS);
4579 }
1da177e4 4580
02f1175c
JS		 4581 /*
4582 printk(" chip #%d at %#6lx is rev 0x%2x\n",
4583 chip_number, (unsigned long)base_addr,
db05c3b1 4584 readb(base_addr+(CyGFRCR<<index)));
02f1175c
JS		 4585 */
4586 }
4587 return chip_number;
4588} /* cyy_init_card */
1da177e4
LT		 4589
4590/*
4591 * ---------------------------------------------------------------------
4592 * cy_detect_isa() - Probe for Cyclom-Y/ISA boards.
4593 * sets global variables and return the number of ISA boards found.
4594 * ---------------------------------------------------------------------
4595 */
02f1175c 4596static int __init cy_detect_isa(void)
1da177e4
LT		 4597{
4598#ifdef CONFIG_ISA
02f1175c
JS		 4599 unsigned short cy_isa_irq, nboard;
4600 void __iomem *cy_isa_address;
4601 unsigned short i, j, cy_isa_nchan;
1da177e4 4602#ifdef MODULE
02f1175c 4603 int isparam = 0;
1da177e4
LT		 4604#endif
4605
02f1175c 4606 nboard = 0;
1da177e4
LT		 4607
4608#ifdef MODULE
4609 /* Check for module parameters */
02f1175c
JS		 4610 for (i = 0; i < NR_CARDS; i++) {
4611 if (maddr[i] || i) {
4612 isparam = 1;
4613 cy_isa_addresses[i] = maddr[i];
4614 }
4615 if (!maddr[i])
4616 break;
1da177e4
LT		 4617 }
4618#endif
4619
02f1175c
JS		 4620 /* scan the address table probing for Cyclom-Y/ISA boards */
4621 for (i = 0; i < NR_ISA_ADDRS; i++) {
4622 unsigned int isa_address = cy_isa_addresses[i];
4623 if (isa_address == 0x0000) {
096dcfce 4624 return nboard;
02f1175c 4625 }
1da177e4 4626
02f1175c 4627 /* probe for CD1400... */
1da177e4 4628 cy_isa_address = ioremap(isa_address, CyISA_Ywin);
02f1175c
JS		 4629 cy_isa_nchan = CyPORTS_PER_CHIP *
4630 cyy_init_card(cy_isa_address, 0);
4631 if (cy_isa_nchan == 0) {
4632 continue;
4633 }
1da177e4
LT		 4634#ifdef MODULE
4635 if (isparam && irq[i])
02f1175c 4636 cy_isa_irq = irq[i];
1da177e4
LT		 4637 else
4638#endif
02f1175c
JS		 4639 /* find out the board's irq by probing */
4640 cy_isa_irq = detect_isa_irq(cy_isa_address);
4641 if (cy_isa_irq == 0) {
4642 printk("Cyclom-Y/ISA found at 0x%lx ",
4643 (unsigned long)cy_isa_address);
4644 printk("but the IRQ could not be detected.\n");
4645 continue;
4646 }
4647
4648 if ((cy_next_channel + cy_isa_nchan) > NR_PORTS) {
4649 printk("Cyclom-Y/ISA found at 0x%lx ",
4650 (unsigned long)cy_isa_address);
4651 printk("but no more channels are available.\n");
4652 printk("Change NR_PORTS in cyclades.c and recompile "
4653 "kernel.\n");
096dcfce 4654 return nboard;
02f1175c
JS		 4655 }
4656 /* fill the next cy_card structure available */
4657 for (j = 0; j < NR_CARDS; j++) {
4658 if (cy_card[j].base_addr == 0)
4659 break;
4660 }
4661 if (j == NR_CARDS) { /* no more cy_cards available */
4662 printk("Cyclom-Y/ISA found at 0x%lx ",
4663 (unsigned long)cy_isa_address);
4664 printk("but no more cards can be used .\n");
4665 printk("Change NR_CARDS in cyclades.c and recompile "
4666 "kernel.\n");
096dcfce 4667 return nboard;
02f1175c
JS		 4668 }
4669
4670 /* allocate IRQ */
4671 if (request_irq(cy_isa_irq, cyy_interrupt,
4672 IRQF_DISABLED, "Cyclom-Y", &cy_card[j])) {
4673 printk("Cyclom-Y/ISA found at 0x%lx ",
4674 (unsigned long)cy_isa_address);
4675 printk("but could not allocate IRQ#%d.\n", cy_isa_irq);
096dcfce 4676 return nboard;
02f1175c
JS		 4677 }
4678
4679 /* set cy_card */
4680 cy_card[j].base_addr = cy_isa_address;
4681 cy_card[j].ctl_addr = NULL;
4682 cy_card[j].irq = (int)cy_isa_irq;
4683 cy_card[j].bus_index = 0;
4684 cy_card[j].first_line = cy_next_channel;
4685 cy_card[j].num_chips = cy_isa_nchan / 4;
4686 nboard++;
4687
4688 /* print message */
4689 printk("Cyclom-Y/ISA #%d: 0x%lx-0x%lx, IRQ%d, ",
4690 j + 1, (unsigned long)cy_isa_address,
4691 (unsigned long)(cy_isa_address + (CyISA_Ywin - 1)),
4692 cy_isa_irq);
4693 printk("%d channels starting from port %d.\n",
4694 cy_isa_nchan, cy_next_channel);
4695 cy_next_channel += cy_isa_nchan;
4696 }
096dcfce 4697 return nboard;
1da177e4 4698#else
096dcfce 4699 return 0;
02f1175c
JS		 4700#endif /* CONFIG_ISA */
4701} /* cy_detect_isa */
1da177e4 4702
1a86b5e3 4703static void plx_init(void __iomem * addr, __u32 initctl)
1da177e4 4704{
02f1175c 4705 /* Reset PLX */
db05c3b1 4706 cy_writel(addr + initctl, readl(addr + initctl) | 0x40000000);
02f1175c 4707 udelay(100L);
db05c3b1 4708 cy_writel(addr + initctl, readl(addr + initctl) & ~0x40000000);
02f1175c
JS		 4709
4710 /* Reload Config. Registers from EEPROM */
db05c3b1 4711 cy_writel(addr + initctl, readl(addr + initctl) | 0x20000000);
02f1175c 4712 udelay(100L);
db05c3b1 4713 cy_writel(addr + initctl, readl(addr + initctl) & ~0x20000000);
1da177e4
LT		 4714}
4715
4716/*
4717 * ---------------------------------------------------------------------
4718 * cy_detect_pci() - Test PCI bus presence and Cyclom-Ye/PCI.
4719 * sets global variables and return the number of PCI boards found.
4720 * ---------------------------------------------------------------------
4721 */
02f1175c 4722static int __init cy_detect_pci(void)
1da177e4
LT		 4723{
4724#ifdef CONFIG_PCI
4725
02f1175c
JS		 4726 struct pci_dev *pdev = NULL;
4727 unsigned char cyy_rev_id;
4728 unsigned char cy_pci_irq = 0;
1a86b5e3 4729 __u32 cy_pci_phys0, cy_pci_phys2;
02f1175c
JS		 4730 void __iomem *cy_pci_addr0, *cy_pci_addr2;
4731 unsigned short i, j, cy_pci_nchan, plx_ver;
4732 unsigned short device_id, dev_index = 0;
1a86b5e3
KK		 4733 __u32 mailbox;
4734 __u32 ZeIndex = 0;
02f1175c 4735 void __iomem *Ze_addr0[NR_CARDS], *Ze_addr2[NR_CARDS];
1a86b5e3 4736 __u32 Ze_phys0[NR_CARDS], Ze_phys2[NR_CARDS];
02f1175c
JS		 4737 unsigned char Ze_irq[NR_CARDS];
4738 struct pci_dev *Ze_pdev[NR_CARDS];
4739
4740 for (i = 0; i < NR_CARDS; i++) {
4741 /* look for a Cyclades card by vendor and device id */
893de2df 4742 while ((device_id = cy_pci_dev_id[dev_index].device) != 0) {
02f1175c
JS		 4743 if ((pdev = pci_get_device(PCI_VENDOR_ID_CYCLADES,
4744 device_id, pdev)) == NULL) {
4745 dev_index++; /* try next device id */
4746 } else {
4747 break; /* found a board */
4748 }
4749 }
1da177e4
LT		 4750
4751 if (device_id == 0)
02f1175c 4752 break;
1da177e4
LT		 4753
4754 if (pci_enable_device(pdev))
02f1175c 4755 continue;
1da177e4 4756
02f1175c 4757 /* read PCI configuration area */
1da177e4
LT		 4758 cy_pci_irq = pdev->irq;
4759 cy_pci_phys0 = pci_resource_start(pdev, 0);
4760 cy_pci_phys2 = pci_resource_start(pdev, 2);
4761 pci_read_config_byte(pdev, PCI_REVISION_ID, &cyy_rev_id);
4762
4763 device_id &= ~PCI_DEVICE_ID_MASK;
4764
02f1175c
JS		 4765 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo ||
4766 device_id == PCI_DEVICE_ID_CYCLOM_Y_Hi) {
1da177e4 4767#ifdef CY_PCI_DEBUG
02f1175c
JS		 4768 printk("Cyclom-Y/PCI (bus=0x0%x, pci_id=0x%x, ",
4769 pdev->bus->number, pdev->devfn);
4770 printk("rev_id=%d) IRQ%d\n",
4771 cyy_rev_id, (int)cy_pci_irq);
4772 printk("Cyclom-Y/PCI:found winaddr=0x%lx "
4773 "ctladdr=0x%lx\n",
4774 (ulong)cy_pci_phys2, (ulong)cy_pci_phys0);
1da177e4
LT		 4775#endif
4776
02f1175c
JS		 4777 if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
4778 printk(" Warning: PCI I/O bit incorrectly "
4779 "set. Ignoring it...\n");
4780 pdev->resource[2].flags &= ~IORESOURCE_IO;
4781 }
1da177e4 4782
02f1175c
JS		 4783 /* Although we don't use this I/O region, we should
4784 request it from the kernel anyway, to avoid problems
4785 with other drivers accessing it. */
4786 if (pci_request_regions(pdev, "Cyclom-Y") != 0) {
4787 printk(KERN_ERR "cyclades: failed to reserve "
4788 "PCI resources\n");
4789 continue;
4790 }
1da177e4 4791#if defined(__alpha__)
02f1175c
JS		 4792 if (device_id == PCI_DEVICE_ID_CYCLOM_Y_Lo) { /* below 1M? */
4793 printk("Cyclom-Y/PCI (bus=0x0%x, pci_id=0x%x, ",
4794 pdev->bus->number, pdev->devfn);
4795 printk("rev_id=%d) IRQ%d\n",
4796 cyy_rev_id, (int)cy_pci_irq);
4797 printk("Cyclom-Y/PCI:found winaddr=0x%lx "
4798 "ctladdr=0x%lx\n",
4799 (ulong)cy_pci_phys2,
4800 (ulong)cy_pci_phys0);
4801 printk("Cyclom-Y/PCI not supported for low "
4802 "addresses in Alpha systems.\n");
4803 i--;
4804 continue;
4805 }
1da177e4 4806#endif
02f1175c
JS		 4807 cy_pci_addr0 = ioremap(cy_pci_phys0, CyPCI_Yctl);
4808 cy_pci_addr2 = ioremap(cy_pci_phys2, CyPCI_Ywin);
1da177e4
LT		 4809
4810#ifdef CY_PCI_DEBUG
02f1175c
JS		 4811 printk("Cyclom-Y/PCI: relocate winaddr=0x%lx "
4812 "ctladdr=0x%lx\n",
4813 (u_long)cy_pci_addr2, (u_long)cy_pci_addr0);
1da177e4 4814#endif
02f1175c
JS		 4815 cy_pci_nchan = (unsigned short)(CyPORTS_PER_CHIP *
4816 cyy_init_card(cy_pci_addr2, 1));
4817 if (cy_pci_nchan == 0) {
4818 printk("Cyclom-Y PCI host card with ");
4819 printk("no Serial-Modules at 0x%lx.\n",
4820 (ulong) cy_pci_phys2);
4821 i--;
4822 continue;
4823 }
4824 if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
4825 printk("Cyclom-Y/PCI found at 0x%lx ",
4826 (ulong) cy_pci_phys2);
4827 printk("but no channels are available.\n");
4828 printk("Change NR_PORTS in cyclades.c and "
4829 "recompile kernel.\n");
096dcfce 4830 return i;
02f1175c
JS		 4831 }
4832 /* fill the next cy_card structure available */
4833 for (j = 0; j < NR_CARDS; j++) {
4834 if (cy_card[j].base_addr == 0)
4835 break;
4836 }
4837 if (j == NR_CARDS) { /* no more cy_cards available */
4838 printk("Cyclom-Y/PCI found at 0x%lx ",
4839 (ulong) cy_pci_phys2);
4840 printk("but no more cards can be used.\n");
4841 printk("Change NR_CARDS in cyclades.c and "
4842 "recompile kernel.\n");
096dcfce 4843 return i;
02f1175c 4844 }
1da177e4 4845
02f1175c
JS		 4846 /* allocate IRQ */
4847 if (request_irq(cy_pci_irq, cyy_interrupt,
4848 IRQF_SHARED, "Cyclom-Y", &cy_card[j])) {
4849 printk("Cyclom-Y/PCI found at 0x%lx ",
4850 (ulong) cy_pci_phys2);
4851 printk("but could not allocate IRQ%d.\n",
4852 cy_pci_irq);
096dcfce 4853 return i;
02f1175c
JS		 4854 }
4855
4856 /* set cy_card */
4857 cy_card[j].base_phys = (ulong) cy_pci_phys2;
4858 cy_card[j].ctl_phys = (ulong) cy_pci_phys0;
4859 cy_card[j].base_addr = cy_pci_addr2;
4860 cy_card[j].ctl_addr = cy_pci_addr0;
4861 cy_card[j].irq = (int)cy_pci_irq;
4862 cy_card[j].bus_index = 1;
4863 cy_card[j].first_line = cy_next_channel;
4864 cy_card[j].num_chips = cy_pci_nchan / 4;
4865 cy_card[j].pdev = pdev;
4866
4867 /* enable interrupts in the PCI interface */
db05c3b1 4868 plx_ver = readb(cy_pci_addr2 + CyPLX_VER) & 0x0f;
02f1175c
JS		 4869 switch (plx_ver) {
4870 case PLX_9050:
4871
4872 cy_writeb(cy_pci_addr0 + 0x4c, 0x43);
4873 break;
4874
4875 case PLX_9060:
4876 case PLX_9080:
4877 default: /* Old boards, use PLX_9060 */
4878
4879 plx_init(cy_pci_addr0, 0x6c);
4880 /* For some yet unknown reason, once the PLX9060 reloads
4881 the EEPROM, the IRQ is lost and, thus, we have to
4882 re-write it to the PCI config. registers.
4883 This will remain here until we find a permanent
4884 fix. */
4885 pci_write_config_byte(pdev, PCI_INTERRUPT_LINE,
4886 cy_pci_irq);
4887
4888 cy_writew(cy_pci_addr0 + 0x68,
db05c3b1 4889 readw(cy_pci_addr0 + 0x68) | 0x0900);
02f1175c
JS		 4890 break;
4891 }
4892
4893 /* print message */
4894 printk("Cyclom-Y/PCI #%d: 0x%lx-0x%lx, IRQ%d, ",
4895 j + 1, (ulong)cy_pci_phys2,
4896 (ulong) (cy_pci_phys2 + CyPCI_Ywin - 1),
4897 (int)cy_pci_irq);
4898 printk("%d channels starting from port %d.\n",
4899 cy_pci_nchan, cy_next_channel);
4900
4901 cy_next_channel += cy_pci_nchan;
4902 } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Lo) {
4903 /* print message */
4904 printk("Cyclades-Z/PCI (bus=0x0%x, pci_id=0x%x, ",
4905 pdev->bus->number, pdev->devfn);
4906 printk("rev_id=%d) IRQ%d\n",
4907 cyy_rev_id, (int)cy_pci_irq);
4908 printk("Cyclades-Z/PCI: found winaddr=0x%lx "
4909 "ctladdr=0x%lx\n",
4910 (ulong)cy_pci_phys2, (ulong)cy_pci_phys0);
4911 printk("Cyclades-Z/PCI not supported for low "
4912 "addresses\n");
4913 break;
4914 } else if (device_id == PCI_DEVICE_ID_CYCLOM_Z_Hi) {
1da177e4 4915#ifdef CY_PCI_DEBUG
02f1175c
JS		 4916 printk("Cyclades-Z/PCI (bus=0x0%x, pci_id=0x%x, ",
4917 pdev->bus->number, pdev->devfn);
4918 printk("rev_id=%d) IRQ%d\n",
4919 cyy_rev_id, (int)cy_pci_irq);
4920 printk("Cyclades-Z/PCI: found winaddr=0x%lx "
4921 "ctladdr=0x%lx\n",
4922 (ulong) cy_pci_phys2, (ulong) cy_pci_phys0);
1da177e4 4923#endif
02f1175c
JS		 4924 cy_pci_addr0 = ioremap(cy_pci_phys0, CyPCI_Zctl);
4925
4926 /* Disable interrupts on the PLX before resetting it */
4927 cy_writew(cy_pci_addr0 + 0x68,
db05c3b1 4928 readw(cy_pci_addr0 + 0x68) & ~0x0900);
02f1175c
JS		 4929
4930 plx_init(cy_pci_addr0, 0x6c);
4931 /* For some yet unknown reason, once the PLX9060 reloads
4932 the EEPROM, the IRQ is lost and, thus, we have to
4933 re-write it to the PCI config. registers.
4934 This will remain here until we find a permanent
4935 fix. */
4936 pci_write_config_byte(pdev, PCI_INTERRUPT_LINE,
4937 cy_pci_irq);
4938
db05c3b1
JS		 4939 mailbox = (__u32)readl(&((struct RUNTIME_9060 __iomem *)
4940 cy_pci_addr0)->mail_box_0);
02f1175c
JS		 4941
4942 if (pci_resource_flags(pdev, 2) & IORESOURCE_IO) {
4943 printk(" Warning: PCI I/O bit incorrectly "
4944 "set. Ignoring it...\n");
4945 pdev->resource[2].flags &= ~IORESOURCE_IO;
4946 }
1da177e4 4947
02f1175c
JS		 4948 /* Although we don't use this I/O region, we should
4949 request it from the kernel anyway, to avoid problems
4950 with other drivers accessing it. */
4951 if (pci_request_regions(pdev, "Cyclades-Z") != 0) {
4952 printk(KERN_ERR "cyclades: failed to reserve "
4953 "PCI resources\n");
4954 continue;
4955 }
4956
4957 if (mailbox == ZE_V1) {
4958 cy_pci_addr2 = ioremap(cy_pci_phys2,
4959 CyPCI_Ze_win);
4960 if (ZeIndex == NR_CARDS) {
4961 printk("Cyclades-Ze/PCI found at "
4962 "0x%lx but no more cards can "
4963 "be used.\nChange NR_CARDS in "
4964 "cyclades.c and recompile "
4965 "kernel.\n",
4966 (ulong)cy_pci_phys2);
4967 } else {
4968 Ze_phys0[ZeIndex] = cy_pci_phys0;
4969 Ze_phys2[ZeIndex] = cy_pci_phys2;
4970 Ze_addr0[ZeIndex] = cy_pci_addr0;
4971 Ze_addr2[ZeIndex] = cy_pci_addr2;
4972 Ze_irq[ZeIndex] = cy_pci_irq;
4973 Ze_pdev[ZeIndex] = pdev;
4974 ZeIndex++;
4975 }
4976 i--;
4977 continue;
4978 } else {
4979 cy_pci_addr2 = ioremap(cy_pci_phys2,CyPCI_Zwin);
4980 }
1da177e4
LT		 4981
4982#ifdef CY_PCI_DEBUG
02f1175c
JS		 4983 printk("Cyclades-Z/PCI: relocate winaddr=0x%lx "
4984 "ctladdr=0x%lx\n",
4985 (ulong) cy_pci_addr2, (ulong) cy_pci_addr0);
4986 if (mailbox == ZO_V1) {
4987 cy_writel(&((struct RUNTIME_9060 *)
4988 (cy_pci_addr0))->loc_addr_base,
4989 WIN_CREG);
02f1175c
JS		 4990 printk("Cyclades-8Zo/PCI: FPGA id %lx, ver "
4991 "%lx\n", (ulong) (0xff &
db05c3b1 4992 readl(&((struct CUSTOM_REG *)
02f1175c
JS		 4993 (cy_pci_addr2))->fpga_id)),
4994 (ulong)(0xff &
db05c3b1 4995 readl(&((struct CUSTOM_REG *)
02f1175c
JS		 4996 (cy_pci_addr2))->
4997 fpga_version)));
4998 cy_writel(&((struct RUNTIME_9060 *)
4999 (cy_pci_addr0))->loc_addr_base,
5000 WIN_RAM);
5001 } else {
5002 printk("Cyclades-Z/PCI: New Cyclades-Z board. "
5003 "FPGA not loaded\n");
5004 }
1da177e4 5005#endif
02f1175c
JS		 5006 /* The following clears the firmware id word. This
5007 ensures that the driver will not attempt to talk to
5008 the board until it has been properly initialized.
5009 */
02f1175c
JS		 5010 if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
5011 cy_writel(cy_pci_addr2 + ID_ADDRESS, 0L);
5012
5013 /* This must be a Cyclades-8Zo/PCI. The extendable
5014 version will have a different device_id and will
5015 be allocated its maximum number of ports. */
5016 cy_pci_nchan = 8;
5017
5018 if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
5019 printk("Cyclades-8Zo/PCI found at 0x%lx but"
5020 "no channels are available.\nChange "
5021 "NR_PORTS in cyclades.c and recompile "
5022 "kernel.\n", (ulong)cy_pci_phys2);
096dcfce 5023 return i;
02f1175c 5024 }
1da177e4 5025
02f1175c
JS		 5026 /* fill the next cy_card structure available */
5027 for (j = 0; j < NR_CARDS; j++) {
5028 if (cy_card[j].base_addr == 0)
5029 break;
5030 }
5031 if (j == NR_CARDS) { /* no more cy_cards available */
5032 printk("Cyclades-8Zo/PCI found at 0x%lx but"
5033 "no more cards can be used.\nChange "
5034 "NR_CARDS in cyclades.c and recompile "
5035 "kernel.\n", (ulong)cy_pci_phys2);
096dcfce 5036 return i;
02f1175c
JS		 5037 }
5038#ifdef CONFIG_CYZ_INTR
5039 /* allocate IRQ only if board has an IRQ */
5040 if ((cy_pci_irq != 0) && (cy_pci_irq != 255)) {
5041 if (request_irq(cy_pci_irq, cyz_interrupt,
5042 IRQF_SHARED, "Cyclades-Z",
5043 &cy_card[j])) {
5044 printk("Cyclom-8Zo/PCI found at 0x%lx "
5045 "but could not allocate "
5046 "IRQ%d.\n", (ulong)cy_pci_phys2,
5047 cy_pci_irq);
096dcfce 5048 return i;
02f1175c
JS		 5049 }
5050 }
5051#endif /* CONFIG_CYZ_INTR */
5052
5053 /* set cy_card */
5054 cy_card[j].base_phys = cy_pci_phys2;
5055 cy_card[j].ctl_phys = cy_pci_phys0;
5056 cy_card[j].base_addr = cy_pci_addr2;
5057 cy_card[j].ctl_addr = cy_pci_addr0;
5058 cy_card[j].irq = (int)cy_pci_irq;
5059 cy_card[j].bus_index = 1;
5060 cy_card[j].first_line = cy_next_channel;
5061 cy_card[j].num_chips = -1;
5062 cy_card[j].pdev = pdev;
5063
5064 /* print message */
1da177e4 5065#ifdef CONFIG_CYZ_INTR
02f1175c
JS		 5066 /* don't report IRQ if board is no IRQ */
5067 if ((cy_pci_irq != 0) && (cy_pci_irq != 255))
5068 printk("Cyclades-8Zo/PCI #%d: 0x%lx-0x%lx, "
5069 "IRQ%d, ", j + 1, (ulong)cy_pci_phys2,
5070 (ulong) (cy_pci_phys2 + CyPCI_Zwin - 1),
5071 (int)cy_pci_irq);
5072 else
5073#endif /* CONFIG_CYZ_INTR */
5074 printk("Cyclades-8Zo/PCI #%d: 0x%lx-0x%lx, ",
5075 j + 1, (ulong)cy_pci_phys2,
5076 (ulong)(cy_pci_phys2 + CyPCI_Zwin - 1));
5077
5078 printk("%d channels starting from port %d.\n",
5079 cy_pci_nchan, cy_next_channel);
5080 cy_next_channel += cy_pci_nchan;
1da177e4 5081 }
02f1175c 5082 }
1da177e4 5083
02f1175c
JS		 5084 for (; ZeIndex != 0 && i < NR_CARDS; i++) {
5085 cy_pci_phys0 = Ze_phys0[0];
5086 cy_pci_phys2 = Ze_phys2[0];
5087 cy_pci_addr0 = Ze_addr0[0];
5088 cy_pci_addr2 = Ze_addr2[0];
5089 cy_pci_irq = Ze_irq[0];
5090 pdev = Ze_pdev[0];
5091 for (j = 0; j < ZeIndex - 1; j++) {
5092 Ze_phys0[j] = Ze_phys0[j + 1];
5093 Ze_phys2[j] = Ze_phys2[j + 1];
5094 Ze_addr0[j] = Ze_addr0[j + 1];
5095 Ze_addr2[j] = Ze_addr2[j + 1];
5096 Ze_irq[j] = Ze_irq[j + 1];
5097 Ze_pdev[j] = Ze_pdev[j + 1];
5098 }
5099 ZeIndex--;
db05c3b1 5100 mailbox = (__u32)readl(&((struct RUNTIME_9060 __iomem *)
02f1175c 5101 cy_pci_addr0)->mail_box_0);
1da177e4 5102#ifdef CY_PCI_DEBUG
02f1175c
JS		 5103 printk("Cyclades-Z/PCI: relocate winaddr=0x%lx ctladdr=0x%lx\n",
5104 (ulong)cy_pci_addr2, (ulong)cy_pci_addr0);
5105 printk("Cyclades-Z/PCI: New Cyclades-Z board. FPGA not "
5106 "loaded\n");
1da177e4 5107#endif
02f1175c
JS		 5108 /* This must be the new Cyclades-Ze/PCI. */
5109 cy_pci_nchan = ZE_V1_NPORTS;
5110
5111 if ((cy_next_channel + cy_pci_nchan) > NR_PORTS) {
5112 printk("Cyclades-Ze/PCI found at 0x%lx but no channels "
5113 "are available.\nChange NR_PORTS in cyclades.c "
5114 "and recompile kernel.\n",
5115 (ulong) cy_pci_phys2);
096dcfce 5116 return i;
02f1175c 5117 }
1da177e4 5118
02f1175c
JS		 5119 /* fill the next cy_card structure available */
5120 for (j = 0; j < NR_CARDS; j++) {
5121 if (cy_card[j].base_addr == 0)
5122 break;
5123 }
5124 if (j == NR_CARDS) { /* no more cy_cards available */
5125 printk("Cyclades-Ze/PCI found at 0x%lx but no more "
5126 "cards can be used.\nChange NR_CARDS in "
5127 "cyclades.c and recompile kernel.\n",
5128 (ulong) cy_pci_phys2);
096dcfce 5129 return i;
02f1175c 5130 }
1da177e4 5131#ifdef CONFIG_CYZ_INTR
02f1175c
JS		 5132 /* allocate IRQ only if board has an IRQ */
5133 if ((cy_pci_irq != 0) && (cy_pci_irq != 255)) {
5134 if (request_irq(cy_pci_irq, cyz_interrupt,
5135 IRQF_SHARED, "Cyclades-Z",
5136 &cy_card[j])) {
5137 printk("Cyclom-Ze/PCI found at 0x%lx ",
5138 (ulong) cy_pci_phys2);
5139 printk("but could not allocate IRQ%d.\n",
5140 cy_pci_irq);
096dcfce 5141 return i;
02f1175c 5142 }
1da177e4 5143 }
02f1175c
JS		 5144#endif /* CONFIG_CYZ_INTR */
5145
5146 /* set cy_card */
5147 cy_card[j].base_phys = cy_pci_phys2;
5148 cy_card[j].ctl_phys = cy_pci_phys0;
5149 cy_card[j].base_addr = cy_pci_addr2;
5150 cy_card[j].ctl_addr = cy_pci_addr0;
5151 cy_card[j].irq = (int)cy_pci_irq;
5152 cy_card[j].bus_index = 1;
5153 cy_card[j].first_line = cy_next_channel;
5154 cy_card[j].num_chips = -1;
1da177e4
LT		 5155 cy_card[j].pdev = pdev;
5156
02f1175c 5157 /* print message */
1da177e4
LT		 5158#ifdef CONFIG_CYZ_INTR
5159 /* don't report IRQ if board is no IRQ */
02f1175c
JS		 5160 if ((cy_pci_irq != 0) && (cy_pci_irq != 255))
5161 printk("Cyclades-Ze/PCI #%d: 0x%lx-0x%lx, IRQ%d, ",
5162 j + 1, (ulong) cy_pci_phys2,
5163 (ulong) (cy_pci_phys2 + CyPCI_Ze_win - 1),
5164 (int)cy_pci_irq);
1da177e4 5165 else
02f1175c
JS		 5166#endif /* CONFIG_CYZ_INTR */
5167 printk("Cyclades-Ze/PCI #%d: 0x%lx-0x%lx, ",
5168 j + 1, (ulong) cy_pci_phys2,
5169 (ulong) (cy_pci_phys2 + CyPCI_Ze_win - 1));
5170
5171 printk("%d channels starting from port %d.\n",
5172 cy_pci_nchan, cy_next_channel);
5173 cy_next_channel += cy_pci_nchan;
5174 }
1da177e4 5175 if (ZeIndex != 0) {
02f1175c
JS		 5176 printk("Cyclades-Ze/PCI found at 0x%x but no more cards can be "
5177 "used.\nChange NR_CARDS in cyclades.c and recompile "
5178 "kernel.\n", (unsigned int)Ze_phys2[0]);
1da177e4 5179 }
096dcfce 5180 return i;
1da177e4 5181#else
096dcfce 5182 return 0;
02f1175c
JS		 5183#endif /* ifdef CONFIG_PCI */
5184} /* cy_detect_pci */
1da177e4
LT		 5185
5186/*
5187 * This routine prints out the appropriate serial driver version number
5188 * and identifies which options were configured into this driver.
5189 */
02f1175c 5190static inline void show_version(void)
1da177e4 5191{
096dcfce 5192 printk("Cyclades driver " CY_VERSION "\n");
02f1175c
JS		 5193 printk(" built %s %s\n", __DATE__, __TIME__);
5194} /* show_version */
5195
5196static int
1da177e4 5197cyclades_get_proc_info(char *buf, char **start, off_t offset, int length,
02f1175c 5198 int *eof, void *data)
1da177e4 5199{
02f1175c
JS		 5200 struct cyclades_port *info;
5201 int i;
5202 int len = 0;
5203 off_t begin = 0;
5204 off_t pos = 0;
5205 int size;
5206 __u32 cur_jifs = jiffies;
5207
5208 size = sprintf(buf, "Dev TimeOpen BytesOut IdleOut BytesIn "
5209 "IdleIn Overruns Ldisc\n");
5210
5211 pos += size;
1da177e4 5212 len += size;
1da177e4 5213
02f1175c
JS		 5214 /* Output one line for each known port */
5215 for (i = 0; i < NR_PORTS && cy_port[i].line >= 0; i++) {
5216 info = &cy_port[i];
5217
5218 if (info->count)
5219 size = sprintf(buf + len, "%3d %8lu %10lu %8lu %10lu "
5220 "%8lu %9lu %6ld\n", info->line,
096dcfce 5221 (cur_jifs - info->idle_stats.in_use) / HZ,
02f1175c 5222 info->idle_stats.xmit_bytes,
096dcfce 5223 (cur_jifs - info->idle_stats.xmit_idle) / HZ,
02f1175c 5224 info->idle_stats.recv_bytes,
096dcfce 5225 (cur_jifs - info->idle_stats.recv_idle) / HZ,
02f1175c
JS		 5226 info->idle_stats.overruns,
5227 (long)info->tty->ldisc.num);
5228 else
5229 size = sprintf(buf + len, "%3d %8lu %10lu %8lu %10lu "
5230 "%8lu %9lu %6ld\n",
5231 info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
5232 len += size;
5233 pos = begin + len;
5234
5235 if (pos < offset) {
5236 len = 0;
5237 begin = pos;
5238 }
5239 if (pos > offset + length)
5240 goto done;
1da177e4 5241 }
02f1175c 5242 *eof = 1;
1da177e4 5243done:
02f1175c
JS		 5244 *start = buf + (offset - begin); /* Start of wanted data */
5245 len -= (offset - begin); /* Start slop */
5246 if (len > length)
5247 len = length; /* Ending slop */
5248 if (len < 0)
5249 len = 0;
5250 return len;
1da177e4
LT		 5251}
5252
5253/* The serial driver boot-time initialization code!
5254 Hardware I/O ports are mapped to character special devices on a
5255 first found, first allocated manner. That is, this code searches
5256 for Cyclom cards in the system. As each is found, it is probed
5257 to discover how many chips (and thus how many ports) are present.
5258 These ports are mapped to the tty ports 32 and upward in monotonic
5259 fashion. If an 8-port card is replaced with a 16-port card, the
5260 port mapping on a following card will shift.
5261
5262 This approach is different from what is used in the other serial
5263 device driver because the Cyclom is more properly a multiplexer,
5264 not just an aggregation of serial ports on one card.
5265
5266 If there are more cards with more ports than have been
5267 statically allocated above, a warning is printed and the
5268 extra ports are ignored.
5269 */
5270
b68e31d0 5271static const struct tty_operations cy_ops = {
02f1175c
JS		 5272 .open = cy_open,
5273 .close = cy_close,
5274 .write = cy_write,
5275 .put_char = cy_put_char,
5276 .flush_chars = cy_flush_chars,
5277 .write_room = cy_write_room,
5278 .chars_in_buffer = cy_chars_in_buffer,
5279 .flush_buffer = cy_flush_buffer,
5280 .ioctl = cy_ioctl,
5281 .throttle = cy_throttle,
5282 .unthrottle = cy_unthrottle,
5283 .set_termios = cy_set_termios,
5284 .stop = cy_stop,
5285 .start = cy_start,
5286 .hangup = cy_hangup,
5287 .break_ctl = cy_break,
5288 .wait_until_sent = cy_wait_until_sent,
5289 .read_proc = cyclades_get_proc_info,
5290 .tiocmget = cy_tiocmget,
5291 .tiocmset = cy_tiocmset,
1da177e4
LT		 5292};
5293
02f1175c 5294static int __init cy_init(void)
1da177e4 5295{
02f1175c
JS		 5296 struct cyclades_port *info;
5297 struct cyclades_card *cinfo;
5298 int number_z_boards = 0;
5299 int board, port, i, index;
5300 unsigned long mailbox;
5301 unsigned short chip_number;
5302 int nports;
5303
5304 cy_serial_driver = alloc_tty_driver(NR_PORTS);
5305 if (!cy_serial_driver)
5306 return -ENOMEM;
5307 show_version();
5308
5309 /* Initialize the tty_driver structure */
5310
5311 cy_serial_driver->owner = THIS_MODULE;
5312 cy_serial_driver->driver_name = "cyclades";
5313 cy_serial_driver->name = "ttyC";
5314 cy_serial_driver->major = CYCLADES_MAJOR;
5315 cy_serial_driver->minor_start = 0;
5316 cy_serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
5317 cy_serial_driver->subtype = SERIAL_TYPE_NORMAL;
5318 cy_serial_driver->init_termios = tty_std_termios;
5319 cy_serial_driver->init_termios.c_cflag =
5320 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
5321 cy_serial_driver->flags = TTY_DRIVER_REAL_RAW;
5322 tty_set_operations(cy_serial_driver, &cy_ops);
5323
5324 if (tty_register_driver(cy_serial_driver))
5325 panic("Couldn't register Cyclades serial driver\n");
5326
5327 for (i = 0; i < NR_CARDS; i++) {
5328 /* base_addr=0 indicates board not found */
5329 cy_card[i].base_addr = NULL;
5330 }
5331
5332 /* the code below is responsible to find the boards. Each different
5333 type of board has its own detection routine. If a board is found,
5334 the next cy_card structure available is set by the detection
5335 routine. These functions are responsible for checking the
5336 availability of cy_card and cy_port data structures and updating
5337 the cy_next_channel. */
5338
5339 /* look for isa boards */
5340 cy_isa_nboard = cy_detect_isa();
5341
5342 /* look for pci boards */
5343 cy_pci_nboard = cy_detect_pci();
5344
5345 cy_nboard = cy_isa_nboard + cy_pci_nboard;
5346
5347 /* invalidate remaining cy_card structures */
5348 for (i = 0; i < NR_CARDS; i++) {
5349 if (cy_card[i].base_addr == 0) {
5350 cy_card[i].first_line = -1;
5351 cy_card[i].ctl_addr = NULL;
5352 cy_card[i].irq = 0;
5353 cy_card[i].bus_index = 0;
5354 cy_card[i].first_line = 0;
5355 cy_card[i].num_chips = 0;
5356 }
5357 }
5358 /* invalidate remaining cy_port structures */
5359 for (i = cy_next_channel; i < NR_PORTS; i++) {
5360 cy_port[i].line = -1;
5361 cy_port[i].magic = -1;
5362 }
5363
5364 /* initialize per-port data structures for each valid board found */
5365 for (board = 0; board < cy_nboard; board++) {
5366 cinfo = &cy_card[board];
5367 if (cinfo->num_chips == -1) { /* Cyclades-Z */
5368 number_z_boards++;
db05c3b1 5369 mailbox = readl(&((struct RUNTIME_9060 __iomem *)
02f1175c
JS		 5370 cy_card[board].ctl_addr)->
5371 mail_box_0);
5372 nports = (mailbox == ZE_V1) ? ZE_V1_NPORTS : 8;
5373 cinfo->intr_enabled = 0;
5374 cinfo->nports = 0; /* Will be correctly set later, after
5375 Z FW is loaded */
5376 spin_lock_init(&cinfo->card_lock);
5377 for (port = cinfo->first_line;
5378 port < cinfo->first_line + nports; port++) {
5379 info = &cy_port[port];
5380 info->magic = CYCLADES_MAGIC;
5381 info->type = PORT_STARTECH;
5382 info->card = board;
5383 info->line = port;
5384 info->chip_rev = 0;
5385 info->flags = STD_COM_FLAGS;
5386 info->tty = NULL;
5387 if (mailbox == ZO_V1)
5388 info->xmit_fifo_size = CYZ_FIFO_SIZE;
5389 else
5390 info->xmit_fifo_size =
5391 4 * CYZ_FIFO_SIZE;
5392 info->cor1 = 0;
5393 info->cor2 = 0;
5394 info->cor3 = 0;
5395 info->cor4 = 0;
5396 info->cor5 = 0;
5397 info->tbpr = 0;
5398 info->tco = 0;
5399 info->rbpr = 0;
5400 info->rco = 0;
5401 info->custom_divisor = 0;
5402 info->close_delay = 5 * HZ / 10;
5403 info->closing_wait = CLOSING_WAIT_DELAY;
5404 info->icount.cts = info->icount.dsr =
5405 info->icount.rng = info->icount.dcd = 0;
5406 info->icount.rx = info->icount.tx = 0;
5407 info->icount.frame = info->icount.parity = 0;
5408 info->icount.overrun = info->icount.brk = 0;
5409 info->x_char = 0;
5410 info->event = 0;
5411 info->count = 0;
5412 info->blocked_open = 0;
5413 info->default_threshold = 0;
5414 info->default_timeout = 0;
5415 INIT_WORK(&info->tqueue, do_softint);
5416 init_waitqueue_head(&info->open_wait);
5417 init_waitqueue_head(&info->close_wait);
5418 init_waitqueue_head(&info->shutdown_wait);
5419 init_waitqueue_head(&info->delta_msr_wait);
5420 /* info->session */
5421 /* info->pgrp */
5422 info->read_status_mask = 0;
5423 /* info->timeout */
5424 /* Bentson's vars */
5425 info->jiffies[0] = 0;
5426 info->jiffies[1] = 0;
5427 info->jiffies[2] = 0;
5428 info->rflush_count = 0;
1da177e4 5429#ifdef CONFIG_CYZ_INTR
02f1175c
JS		 5430 init_timer(&cyz_rx_full_timer[port]);
5431 cyz_rx_full_timer[port].function = NULL;
1da177e4 5432#endif
02f1175c
JS		 5433 }
5434 continue;
5435 } else { /* Cyclom-Y of some kind */
5436 index = cinfo->bus_index;
5437 spin_lock_init(&cinfo->card_lock);
5438 cinfo->nports = CyPORTS_PER_CHIP * cinfo->num_chips;
5439 for (port = cinfo->first_line;
5440 port < cinfo->first_line + cinfo->nports; port++) {
5441 info = &cy_port[port];
5442 info->magic = CYCLADES_MAGIC;
5443 info->type = PORT_CIRRUS;
5444 info->card = board;
5445 info->line = port;
5446 info->flags = STD_COM_FLAGS;
5447 info->tty = NULL;
5448 info->xmit_fifo_size = CyMAX_CHAR_FIFO;
5449 info->cor1 =
5450 CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
5451 info->cor2 = CyETC;
5452 info->cor3 = 0x08; /* _very_ small rcv threshold */
5453 info->cor4 = 0;
5454 info->cor5 = 0;
5455 info->custom_divisor = 0;
5456 info->close_delay = 5 * HZ / 10;
5457 info->closing_wait = CLOSING_WAIT_DELAY;
5458 info->icount.cts = info->icount.dsr =
5459 info->icount.rng = info->icount.dcd = 0;
5460 info->icount.rx = info->icount.tx = 0;
5461 info->icount.frame = info->icount.parity = 0;
5462 info->icount.overrun = info->icount.brk = 0;
5463 chip_number = (port - cinfo->first_line) / 4;
5464 if ((info->chip_rev =
db05c3b1 5465 readb(cinfo->base_addr +
02f1175c
JS		 5466 (cy_chip_offset[chip_number] <<
5467 index) + (CyGFRCR << index))) >=
5468 CD1400_REV_J) {
5469 /* It is a CD1400 rev. J or later */
5470 info->tbpr = baud_bpr_60[13]; /* Tx BPR */
5471 info->tco = baud_co_60[13]; /* Tx CO */
5472 info->rbpr = baud_bpr_60[13]; /* Rx BPR */
5473 info->rco = baud_co_60[13]; /* Rx CO */
5474 info->rflow = 0;
5475 info->rtsdtr_inv = 1;
5476 } else {
5477 info->tbpr = baud_bpr_25[13]; /* Tx BPR */
5478 info->tco = baud_co_25[13]; /* Tx CO */
5479 info->rbpr = baud_bpr_25[13]; /* Rx BPR */
5480 info->rco = baud_co_25[13]; /* Rx CO */
5481 info->rflow = 0;
5482 info->rtsdtr_inv = 0;
5483 }
5484 info->x_char = 0;
5485 info->event = 0;
5486 info->count = 0;
5487 info->blocked_open = 0;
5488 info->default_threshold = 0;
5489 info->default_timeout = 0;
5490 INIT_WORK(&info->tqueue, do_softint);
5491 init_waitqueue_head(&info->open_wait);
5492 init_waitqueue_head(&info->close_wait);
5493 init_waitqueue_head(&info->shutdown_wait);
5494 init_waitqueue_head(&info->delta_msr_wait);
5495 /* info->session */
5496 /* info->pgrp */
5497 info->read_status_mask =
5498 CyTIMEOUT | CySPECHAR | CyBREAK
5499 | CyPARITY | CyFRAME | CyOVERRUN;
5500 /* info->timeout */
5501 }
5502 }
5503 }
1da177e4
LT		 5504
5505#ifndef CONFIG_CYZ_INTR
b7050906
JS		 5506 if (number_z_boards) {
5507 mod_timer(&cyz_timerlist, jiffies + 1);
1da177e4 5508#ifdef CY_PCI_DEBUG
02f1175c 5509 printk("Cyclades-Z polling initialized\n");
1da177e4 5510#endif
02f1175c
JS		 5511 }
5512#endif /* CONFIG_CYZ_INTR */
5513
5514 return 0;
1da177e4 5515
02f1175c 5516} /* cy_init */
1da177e4 5517
02f1175c 5518static void __exit cy_cleanup_module(void)
1da177e4 5519{
02f1175c 5520 int i, e1;
1da177e4
LT		 5521
5522#ifndef CONFIG_CYZ_INTR
b7050906 5523 del_timer_sync(&cyz_timerlist);
1da177e4
LT		 5524#endif /* CONFIG_CYZ_INTR */
5525
02f1175c
JS		 5526 if ((e1 = tty_unregister_driver(cy_serial_driver)))
5527 printk("cyc: failed to unregister Cyclades serial driver(%d)\n",
5528 e1);
1da177e4 5529
02f1175c 5530 put_tty_driver(cy_serial_driver);
1da177e4 5531
02f1175c
JS		 5532 for (i = 0; i < NR_CARDS; i++) {
5533 if (cy_card[i].base_addr) {
5534 iounmap(cy_card[i].base_addr);
5535 if (cy_card[i].ctl_addr)
5536 iounmap(cy_card[i].ctl_addr);
5537 if (cy_card[i].irq
1da177e4 5538#ifndef CONFIG_CYZ_INTR
02f1175c 5539 && cy_card[i].num_chips != -1 /* not a Z card */
1da177e4 5540#endif /* CONFIG_CYZ_INTR */
02f1175c
JS		 5541 )
5542 free_irq(cy_card[i].irq, &cy_card[i]);
1da177e4 5543#ifdef CONFIG_PCI
02f1175c
JS		 5544 if (cy_card[i].pdev)
5545 pci_release_regions(cy_card[i].pdev);
1da177e4 5546#endif
02f1175c
JS		 5547 }
5548 }
1da177e4
LT		 5549} /* cy_cleanup_module */
5550
5551module_init(cy_init);
5552module_exit(cy_cleanup_module);
5553
5554MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)