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