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