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