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