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