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