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