aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/char
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/char')
-rw-r--r--drivers/char/agp/backend.c4
-rw-r--r--drivers/char/agp/uninorth-agp.c2
-rw-r--r--drivers/char/cyclades.c2311
-rw-r--r--drivers/char/epca.c2
-rw-r--r--drivers/char/esp.c7
-rw-r--r--drivers/char/hw_random/core.c2
-rw-r--r--drivers/char/hw_random/virtio-rng.c3
-rw-r--r--drivers/char/ipmi/ipmi_poweroff.c4
-rw-r--r--drivers/char/isicom.c57
-rw-r--r--drivers/char/mem.c29
-rw-r--r--drivers/char/misc.c12
-rw-r--r--drivers/char/mxser.c62
-rw-r--r--drivers/char/n_tty.c79
-rw-r--r--drivers/char/pcmcia/cm4000_cs.c2
-rw-r--r--drivers/char/raw.c4
-rw-r--r--drivers/char/riscom8.c164
-rw-r--r--drivers/char/sysrq.c4
-rw-r--r--drivers/char/tpm/tpm.c4
-rw-r--r--drivers/char/tpm/tpm_bios.c4
-rw-r--r--drivers/char/tty_io.c33
-rw-r--r--drivers/char/tty_ioctl.c4
-rw-r--r--drivers/char/tty_ldisc.c82
-rw-r--r--drivers/char/tty_port.c31
-rw-r--r--drivers/char/virtio_console.c5
-rw-r--r--drivers/char/vt.c14
-rw-r--r--drivers/char/vt_ioctl.c482
26 files changed, 1351 insertions, 2056 deletions
diff --git a/drivers/char/agp/backend.c b/drivers/char/agp/backend.c
index ad87753f6de4..a56ca080e108 100644
--- a/drivers/char/agp/backend.c
+++ b/drivers/char/agp/backend.c
@@ -114,9 +114,9 @@ static int agp_find_max(void)
114 long memory, index, result; 114 long memory, index, result;
115 115
116#if PAGE_SHIFT < 20 116#if PAGE_SHIFT < 20
117 memory = num_physpages >> (20 - PAGE_SHIFT); 117 memory = totalram_pages >> (20 - PAGE_SHIFT);
118#else 118#else
119 memory = num_physpages << (PAGE_SHIFT - 20); 119 memory = totalram_pages << (PAGE_SHIFT - 20);
120#endif 120#endif
121 index = 1; 121 index = 1;
122 122
diff --git a/drivers/char/agp/uninorth-agp.c b/drivers/char/agp/uninorth-agp.c
index 20ef1bf5e726..703959eba45a 100644
--- a/drivers/char/agp/uninorth-agp.c
+++ b/drivers/char/agp/uninorth-agp.c
@@ -270,7 +270,7 @@ static void uninorth_agp_enable(struct agp_bridge_data *bridge, u32 mode)
270 270
271 if ((uninorth_rev >= 0x30) && (uninorth_rev <= 0x33)) { 271 if ((uninorth_rev >= 0x30) && (uninorth_rev <= 0x33)) {
272 /* 272 /*
273 * We need to to set REQ_DEPTH to 7 for U3 versions 1.0, 2.1, 273 * We need to set REQ_DEPTH to 7 for U3 versions 1.0, 2.1,
274 * 2.2 and 2.3, Darwin do so. 274 * 2.2 and 2.3, Darwin do so.
275 */ 275 */
276 if ((command >> AGPSTAT_RQ_DEPTH_SHIFT) > 7) 276 if ((command >> AGPSTAT_RQ_DEPTH_SHIFT) > 7)
diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
index 2dafc2da0648..df5038bbcbc2 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -11,7 +11,7 @@
11 * Initially written by Randolph Bentson <bentson@grieg.seaslug.org>. 11 * Initially written by Randolph Bentson <bentson@grieg.seaslug.org>.
12 * Modified and maintained by Marcio Saito <marcio@cyclades.com>. 12 * Modified and maintained by Marcio Saito <marcio@cyclades.com>.
13 * 13 *
14 * Copyright (C) 2007 Jiri Slaby <jirislaby@gmail.com> 14 * Copyright (C) 2007-2009 Jiri Slaby <jirislaby@gmail.com>
15 * 15 *
16 * Much of the design and some of the code came from serial.c 16 * Much of the design and some of the code came from serial.c
17 * which was copyright (C) 1991, 1992 Linus Torvalds. It was 17 * which was copyright (C) 1991, 1992 Linus Torvalds. It was
@@ -19,577 +19,9 @@
19 * and then fixed as suggested by Michael K. Johnson 12/12/92. 19 * and then fixed as suggested by Michael K. Johnson 12/12/92.
20 * Converted to pci probing and cleaned up by Jiri Slaby. 20 * Converted to pci probing and cleaned up by Jiri Slaby.
21 * 21 *
22 * This version supports shared IRQ's (only for PCI boards).
23 *
24 * Prevent users from opening non-existing Z ports.
25 *
26 * Revision 2.3.2.8 2000/07/06 18:14:16 ivan
27 * Fixed the PCI detection function to work properly on Alpha systems.
28 * Implemented support for TIOCSERGETLSR ioctl.
29 * Implemented full support for non-standard baud rates.
30 *
31 * Revision 2.3.2.7 2000/06/01 18:26:34 ivan
32 * Request PLX I/O region, although driver doesn't use it, to avoid
33 * problems with other drivers accessing it.
34 * Removed count for on-board buffer characters in cy_chars_in_buffer
35 * (Cyclades-Z only).
36 *
37 * Revision 2.3.2.6 2000/05/05 13:56:05 ivan
38 * Driver now reports physical instead of virtual memory addresses.
39 * Masks were added to some Cyclades-Z read accesses.
40 * Implemented workaround for PLX9050 bug that would cause a system lockup
41 * in certain systems, depending on the MMIO addresses allocated to the
42 * board.
43 * Changed the Tx interrupt programming in the CD1400 chips to boost up
44 * performance (Cyclom-Y only).
45 * Code is now compliant with the new module interface (module_[init|exit]).
46 * Make use of the PCI helper functions to access PCI resources.
47 * Did some code "housekeeping".
48 *
49 * Revision 2.3.2.5 2000/01/19 14:35:33 ivan
50 * Fixed bug in cy_set_termios on CRTSCTS flag turnoff.
51 *
52 * Revision 2.3.2.4 2000/01/17 09:19:40 ivan
53 * Fixed SMP locking in Cyclom-Y interrupt handler.
54 *
55 * Revision 2.3.2.3 1999/12/28 12:11:39 ivan
56 * Added a new cyclades_card field called nports to allow the driver to
57 * know the exact number of ports found by the Z firmware after its load;
58 * RX buffer contention prevention logic on interrupt op mode revisited
59 * (Cyclades-Z only);
60 * Revisited printk's for Z debug;
61 * Driver now makes sure that the constant SERIAL_XMIT_SIZE is defined;
62 *
63 * Revision 2.3.2.2 1999/10/01 11:27:43 ivan
64 * Fixed bug in cyz_poll that would make all ports but port 0
65 * unable to transmit/receive data (Cyclades-Z only);
66 * Implemented logic to prevent the RX buffer from being stuck with data
67 * due to a driver / firmware race condition in interrupt op mode
68 * (Cyclades-Z only);
69 * Fixed bug in block_til_ready logic that would lead to a system crash;
70 * Revisited cy_close spinlock usage;
71 *
72 * Revision 2.3.2.1 1999/09/28 11:01:22 ivan
73 * Revisited CONFIG_PCI conditional compilation for PCI board support;
74 * Implemented TIOCGICOUNT and TIOCMIWAIT ioctl support;
75 * _Major_ cleanup on the Cyclades-Z interrupt support code / logic;
76 * Removed CTS handling from the driver -- this is now completely handled
77 * by the firmware (Cyclades-Z only);
78 * Flush RX on-board buffers on a port open (Cyclades-Z only);
79 * Fixed handling of ASYNC_SPD_* TTY flags;
80 * Module unload now unmaps all memory area allocated by ioremap;
81 *
82 * Revision 2.3.1.1 1999/07/15 16:45:53 ivan
83 * Removed CY_PROC conditional compilation;
84 * Implemented SMP-awareness for the driver;
85 * Implemented a new ISA IRQ autoprobe that uses the irq_probe_[on|off]
86 * functions;
87 * The driver now accepts memory addresses (maddr=0xMMMMM) and IRQs
88 * (irq=NN) as parameters (only for ISA boards);
89 * Fixed bug in set_line_char that would prevent the Cyclades-Z
90 * ports from being configured at speeds above 115.2Kbps;
91 * Fixed bug in cy_set_termios that would prevent XON/XOFF flow control
92 * switching from working properly;
93 * The driver now only prints IRQ info for the Cyclades-Z if it's
94 * configured to work in interrupt mode;
95 *
96 * Revision 2.2.2.3 1999/06/28 11:13:29 ivan
97 * Added support for interrupt mode operation for the Z cards;
98 * Removed the driver inactivity control for the Z;
99 * Added a missing MOD_DEC_USE_COUNT in the cy_open function for when
100 * the Z firmware is not loaded yet;
101 * Replaced the "manual" Z Tx flush buffer by a call to a FW command of
102 * same functionality;
103 * Implemented workaround for IRQ setting loss on the PCI configuration
104 * registers after a PCI bridge EEPROM reload (affects PLX9060 only);
105 *
106 * Revision 2.2.2.2 1999/05/14 17:18:15 ivan
107 * /proc entry location changed to /proc/tty/driver/cyclades;
108 * Added support to shared IRQ's (only for PCI boards);
109 * Added support for Cobalt Qube2 systems;
110 * IRQ [de]allocation scheme revisited;
111 * BREAK implementation changed in order to make use of the 'break_ctl'
112 * TTY facility;
113 * Fixed typo in TTY structure field 'driver_name';
114 * Included a PCI bridge reset and EEPROM reload in the board
115 * initialization code (for both Y and Z series).
116 *
117 * Revision 2.2.2.1 1999/04/08 16:17:43 ivan
118 * Fixed a bug in cy_wait_until_sent that was preventing the port to be
119 * closed properly after a SIGINT;
120 * Module usage counter scheme revisited;
121 * Added support to the upcoming Y PCI boards (i.e., support to additional
122 * PCI Device ID's).
123 *
124 * Revision 2.2.1.10 1999/01/20 16:14:29 ivan
125 * Removed all unnecessary page-alignement operations in ioremap calls
126 * (ioremap is currently safe for these operations).
127 *
128 * Revision 2.2.1.9 1998/12/30 18:18:30 ivan
129 * Changed access to PLX PCI bridge registers from I/O to MMIO, in
130 * order to make PLX9050-based boards work with certain motherboards.
131 *
132 * Revision 2.2.1.8 1998/11/13 12:46:20 ivan
133 * cy_close function now resets (correctly) the tty->closing flag;
134 * JIFFIES_DIFF macro fixed.
135 *
136 * Revision 2.2.1.7 1998/09/03 12:07:28 ivan
137 * Fixed bug in cy_close function, which was not informing HW of
138 * which port should have the reception disabled before doing so;
139 * fixed Cyclom-8YoP hardware detection bug.
140 *
141 * Revision 2.2.1.6 1998/08/20 17:15:39 ivan
142 * Fixed bug in cy_close function, which causes malfunction
143 * of one of the first 4 ports when a higher port is closed
144 * (Cyclom-Y only).
145 *
146 * Revision 2.2.1.5 1998/08/10 18:10:28 ivan
147 * Fixed Cyclom-4Yo hardware detection bug.
148 *
149 * Revision 2.2.1.4 1998/08/04 11:02:50 ivan
150 * /proc/cyclades implementation with great collaboration of
151 * Marc Lewis <marc@blarg.net>;
152 * cyy_interrupt was changed to avoid occurrence of kernel oopses
153 * during PPP operation.
154 *
155 * Revision 2.2.1.3 1998/06/01 12:09:10 ivan
156 * General code review in order to comply with 2.1 kernel standards;
157 * data loss prevention for slow devices revisited (cy_wait_until_sent
158 * was created);
159 * removed conditional compilation for new/old PCI structure support
160 * (now the driver only supports the new PCI structure).
161 *
162 * Revision 2.2.1.1 1998/03/19 16:43:12 ivan
163 * added conditional compilation for new/old PCI structure support;
164 * removed kernel series (2.0.x / 2.1.x) conditional compilation.
165 *
166 * Revision 2.1.1.3 1998/03/16 18:01:12 ivan
167 * cleaned up the data loss fix;
168 * fixed XON/XOFF handling once more (Cyclades-Z);
169 * general review of the driver routines;
170 * introduction of a mechanism to prevent data loss with slow
171 * printers, by forcing a delay before closing the port.
172 *
173 * Revision 2.1.1.2 1998/02/17 16:50:00 ivan
174 * fixed detection/handling of new CD1400 in Ye boards;
175 * fixed XON/XOFF handling (Cyclades-Z);
176 * fixed data loss caused by a premature port close;
177 * introduction of a flag that holds the CD1400 version ID per port
178 * (used by the CYGETCD1400VER new ioctl).
179 *
180 * Revision 2.1.1.1 1997/12/03 17:31:19 ivan
181 * Code review for the module cleanup routine;
182 * fixed RTS and DTR status report for new CD1400's in get_modem_info;
183 * includes anonymous changes regarding signal_pending.
184 *
185 * Revision 2.1 1997/11/01 17:42:41 ivan
186 * Changes in the driver to support Alpha systems (except 8Zo V_1);
187 * BREAK fix for the Cyclades-Z boards;
188 * driver inactivity control by FW implemented;
189 * introduction of flag that allows driver to take advantage of
190 * a special CD1400 feature related to HW flow control;
191 * added support for the CD1400 rev. J (Cyclom-Y boards);
192 * introduction of ioctls to:
193 * - control the rtsdtr_inv flag (Cyclom-Y);
194 * - control the rflow flag (Cyclom-Y);
195 * - adjust the polling interval (Cyclades-Z);
196 *
197 * Revision 1.36.4.33 1997/06/27 19:00:00 ivan
198 * Fixes related to kernel version conditional
199 * compilation.
200 *
201 * Revision 1.36.4.32 1997/06/14 19:30:00 ivan
202 * Compatibility issues between kernels 2.0.x and
203 * 2.1.x (mainly related to clear_bit function).
204 *
205 * Revision 1.36.4.31 1997/06/03 15:30:00 ivan
206 * Changes to define the memory window according to the
207 * board type.
208 *
209 * Revision 1.36.4.30 1997/05/16 15:30:00 daniel
210 * Changes to support new cycladesZ boards.
211 *
212 * Revision 1.36.4.29 1997/05/12 11:30:00 daniel
213 * Merge of Bentson's and Daniel's version 1.36.4.28.
214 * Corrects bug in cy_detect_pci: check if there are more
215 * ports than the number of static structs allocated.
216 * Warning message during initialization if this driver is
217 * used with the new generation of cycladesZ boards. Those
218 * will be supported only in next release of the driver.
219 * Corrects bug in cy_detect_pci and cy_detect_isa that
220 * returned wrong number of VALID boards, when a cyclomY
221 * was found with no serial modules connected.
222 * Changes to use current (2.1.x) kernel subroutine names
223 * and created macros for compilation with 2.0.x kernel,
224 * instead of the other way around.
225 *
226 * Revision 1.36.4.28 1997/05/?? ??:00:00 bentson
227 * Change queue_task_irq_off to queue_task_irq.
228 * The inline function queue_task_irq_off (tqueue.h)
229 * was removed from latest releases of 2.1.x kernel.
230 * Use of macro __init to mark the initialization
231 * routines, so memory can be reused.
232 * Also incorporate implementation of critical region
233 * in function cleanup_module() created by anonymous
234 * linuxer.
235 *
236 * Revision 1.36.4.28 1997/04/25 16:00:00 daniel
237 * Change to support new firmware that solves DCD problem:
238 * application could fail to receive SIGHUP signal when DCD
239 * varying too fast.
240 *
241 * Revision 1.36.4.27 1997/03/26 10:30:00 daniel
242 * Changed for support linux versions 2.1.X.
243 * Backward compatible with linux versions 2.0.X.
244 * Corrected illegal use of filler field in
245 * CH_CTRL struct.
246 * Deleted some debug messages.
247 *
248 * Revision 1.36.4.26 1997/02/27 12:00:00 daniel
249 * Included check for NULL tty pointer in cyz_poll.
250 *
251 * Revision 1.36.4.25 1997/02/26 16:28:30 bentson
252 * Bill Foster at Blarg! Online services noticed that
253 * some of the switch elements of -Z modem control
254 * lacked a closing "break;"
255 *
256 * Revision 1.36.4.24 1997/02/24 11:00:00 daniel
257 * Changed low water threshold for buffer xmit_buf
258 *
259 * Revision 1.36.4.23 1996/12/02 21:50:16 bentson
260 * Marcio provided fix to modem status fetch for -Z
261 *
262 * Revision 1.36.4.22 1996/10/28 22:41:17 bentson
263 * improve mapping of -Z control page (thanks to Steve
264 * Price <stevep@fa.tdktca.com> for help on this)
265 *
266 * Revision 1.36.4.21 1996/09/10 17:00:10 bentson
267 * shift from CPU-bound to memcopy in cyz_polling operation
268 *
269 * Revision 1.36.4.20 1996/09/09 18:30:32 Bentson
270 * Added support to set and report higher speeds.
271 *
272 * Revision 1.36.4.19c 1996/08/09 10:00:00 Marcio Saito
273 * Some fixes in the HW flow control for the BETA release.
274 * Don't try to register the IRQ.
275 *
276 * Revision 1.36.4.19 1996/08/08 16:23:18 Bentson
277 * make sure "cyc" appears in all kernel messages; all soft interrupts
278 * handled by same routine; recognize out-of-band reception; comment
279 * out some diagnostic messages; leave RTS/CTS flow control to hardware;
280 * fix race condition in -Z buffer management; only -Y needs to explicitly
281 * flush chars; tidy up some startup messages;
282 *
283 * Revision 1.36.4.18 1996/07/25 18:57:31 bentson
284 * shift MOD_INC_USE_COUNT location to match
285 * serial.c; purge some diagnostic messages;
286 *
287 * Revision 1.36.4.17 1996/07/25 18:01:08 bentson
288 * enable modem status messages and fetch & process them; note
289 * time of last activity type for each port; set_line_char now
290 * supports more than line 0 and treats 0 baud correctly;
291 * get_modem_info senses rs_status;
292 *
293 * Revision 1.36.4.16 1996/07/20 08:43:15 bentson
294 * barely works--now's time to turn on
295 * more features 'til it breaks
296 *
297 * Revision 1.36.4.15 1996/07/19 22:30:06 bentson
298 * check more -Z board status; shorten boot message
299 *
300 * Revision 1.36.4.14 1996/07/19 22:20:37 bentson
301 * fix reference to ch_ctrl in startup; verify return
302 * values from cyz_issue_cmd and cyz_update_channel;
303 * more stuff to get modem control correct;
304 *
305 * Revision 1.36.4.13 1996/07/11 19:53:33 bentson
306 * more -Z stuff folded in; re-order changes to put -Z stuff
307 * after -Y stuff (to make changes clearer)
308 *
309 * Revision 1.36.4.12 1996/07/11 15:40:55 bentson
310 * Add code to poll Cyclades-Z. Add code to get & set RS-232 control.
311 * Add code to send break. Clear firmware ID word at startup (so
312 * that other code won't talk to inactive board).
313 *
314 * Revision 1.36.4.11 1996/07/09 05:28:29 bentson
315 * add code for -Z in set_line_char
316 *
317 * Revision 1.36.4.10 1996/07/08 19:28:37 bentson
318 * fold more -Z stuff (or in some cases, error messages)
319 * into driver; add text to "don't know what to do" messages.
320 *
321 * Revision 1.36.4.9 1996/07/08 18:38:38 bentson
322 * moved compile-time flags near top of file; cosmetic changes
323 * to narrow text (to allow 2-up printing); changed many declarations
324 * to "static" to limit external symbols; shuffled code order to
325 * coalesce -Y and -Z specific code, also to put internal functions
326 * in order of tty_driver structure; added code to recognize -Z
327 * ports (and for moment, do nothing or report error); add cy_startup
328 * to parse boot command line for extra base addresses for ISA probes;
329 *
330 * Revision 1.36.4.8 1996/06/25 17:40:19 bentson
331 * reorder some code, fix types of some vars (int vs. long),
332 * add cy_setup to support user declared ISA addresses
333 *
334 * Revision 1.36.4.7 1996/06/21 23:06:18 bentson
335 * dump ioctl based firmware load (it's now a user level
336 * program); ensure uninitialzed ports cannot be used
337 *
338 * Revision 1.36.4.6 1996/06/20 23:17:19 bentson
339 * rename vars and restructure some code
340 *
341 * Revision 1.36.4.5 1996/06/14 15:09:44 bentson
342 * get right status back after boot load
343 *
344 * Revision 1.36.4.4 1996/06/13 19:51:44 bentson
345 * successfully loads firmware
346 *
347 * Revision 1.36.4.3 1996/06/13 06:08:33 bentson
348 * add more of the code for the boot/load ioctls
349 *
350 * Revision 1.36.4.2 1996/06/11 21:00:51 bentson
351 * start to add Z functionality--starting with ioctl
352 * for loading firmware
353 *
354 * Revision 1.36.4.1 1996/06/10 18:03:02 bentson
355 * added code to recognize Z/PCI card at initialization; report
356 * presence, but card is not initialized (because firmware needs
357 * to be loaded)
358 *
359 * Revision 1.36.3.8 1996/06/07 16:29:00 bentson
360 * starting minor number at zero; added missing verify_area
361 * as noted by Heiko Eißfeldt <heiko@colossus.escape.de>
362 *
363 * Revision 1.36.3.7 1996/04/19 21:06:18 bentson
364 * remove unneeded boot message & fix CLOCAL hardware flow
365 * control (Miquel van Smoorenburg <miquels@Q.cistron.nl>);
366 * remove unused diagnostic statements; minor 0 is first;
367 *
368 * Revision 1.36.3.6 1996/03/13 13:21:17 marcio
369 * The kernel function vremap (available only in later 1.3.xx kernels)
370 * allows the access to memory addresses above the RAM. This revision
371 * of the driver supports PCI boards below 1Mb (device id 0x100) and
372 * above 1Mb (device id 0x101).
373 *
374 * Revision 1.36.3.5 1996/03/07 15:20:17 bentson
375 * Some global changes to interrupt handling spilled into
376 * this driver--mostly unused arguments in system function
377 * calls. Also added change by Marcio Saito which should
378 * reduce lost interrupts at startup by fast processors.
379 *
380 * Revision 1.36.3.4 1995/11/13 20:45:10 bentson
381 * Changes by Corey Minyard <minyard@wf-rch.cirr.com> distributed
382 * in 1.3.41 kernel to remove a possible race condition, extend
383 * some error messages, and let the driver run as a loadable module
384 * Change by Alan Wendt <alan@ez0.ezlink.com> to remove a
385 * possible race condition.
386 * Change by Marcio Saito <marcio@cyclades.com> to fix PCI addressing.
387 *
388 * Revision 1.36.3.3 1995/11/13 19:44:48 bentson
389 * Changes by Linus Torvalds in 1.3.33 kernel distribution
390 * required due to reordering of driver initialization.
391 * Drivers are now initialized *after* memory management.
392 *
393 * Revision 1.36.3.2 1995/09/08 22:07:14 bentson
394 * remove printk from ISR; fix typo
395 *
396 * Revision 1.36.3.1 1995/09/01 12:00:42 marcio
397 * Minor fixes in the PCI board support. PCI function calls in
398 * conditional compilation (CONFIG_PCI). Thanks to Jim Duncan
399 * <duncan@okay.com>. "bad serial count" message removed.
400 *
401 * Revision 1.36.3 1995/08/22 09:19:42 marcio
402 * Cyclom-Y/PCI support added. Changes in the cy_init routine and
403 * board initialization. Changes in the boot messages. The driver
404 * supports up to 4 boards and 64 ports by default.
405 *
406 * Revision 1.36.1.4 1995/03/29 06:14:14 bentson
407 * disambiguate between Cyclom-16Y and Cyclom-32Ye;
408 *
409 * Revision 1.36.1.3 1995/03/23 22:15:35 bentson
410 * add missing break in modem control block in ioctl switch statement
411 * (discovered by Michael Edward Chastain <mec@jobe.shell.portal.com>);
412 *
413 * Revision 1.36.1.2 1995/03/22 19:16:22 bentson
414 * make sure CTS flow control is set as soon as possible (thanks
415 * to note from David Lambert <lambert@chesapeake.rps.slb.com>);
416 *
417 * Revision 1.36.1.1 1995/03/13 15:44:43 bentson
418 * initialize defaults for receive threshold and stale data timeout;
419 * cosmetic changes;
420 *
421 * Revision 1.36 1995/03/10 23:33:53 bentson
422 * added support of chips 4-7 in 32 port Cyclom-Ye;
423 * fix cy_interrupt pointer dereference problem
424 * (Joe Portman <baron@aa.net>);
425 * give better error response if open is attempted on non-existent port
426 * (Zachariah Vaum <jchryslr@netcom.com>);
427 * correct command timeout (Kenneth Lerman <lerman@@seltd.newnet.com>);
428 * conditional compilation for -16Y on systems with fast, noisy bus;
429 * comment out diagnostic print function;
430 * cleaned up table of base addresses;
431 * set receiver time-out period register to correct value,
432 * set receive threshold to better default values,
433 * set chip timer to more accurate 200 Hz ticking,
434 * add code to monitor and modify receive parameters
435 * (Rik Faith <faith@cs.unc.edu> Nick Simicich
436 * <njs@scifi.emi.net>);
437 *
438 * Revision 1.35 1994/12/16 13:54:18 steffen
439 * additional patch by Marcio Saito for board detection
440 * Accidently left out in 1.34
441 *
442 * Revision 1.34 1994/12/10 12:37:12 steffen
443 * This is the corrected version as suggested by Marcio Saito
444 *
445 * Revision 1.33 1994/12/01 22:41:18 bentson
446 * add hooks to support more high speeds directly; add tytso
447 * patch regarding CLOCAL wakeups
448 *
449 * Revision 1.32 1994/11/23 19:50:04 bentson
450 * allow direct kernel control of higher signalling rates;
451 * look for cards at additional locations
452 *
453 * Revision 1.31 1994/11/16 04:33:28 bentson
454 * ANOTHER fix from Corey Minyard, minyard@wf-rch.cirr.com--
455 * a problem in chars_in_buffer has been resolved by some
456 * small changes; this should yield smoother output
457 *
458 * Revision 1.30 1994/11/16 04:28:05 bentson
459 * Fix from Corey Minyard, Internet: minyard@metronet.com,
460 * UUCP: minyard@wf-rch.cirr.com, WORK: minyardbnr.ca, to
461 * cy_hangup that appears to clear up much (all?) of the
462 * DTR glitches; also he's added/cleaned-up diagnostic messages
463 *
464 * Revision 1.29 1994/11/16 04:16:07 bentson
465 * add change proposed by Ralph Sims, ralphs@halcyon.com, to
466 * operate higher speeds in same way as other serial ports;
467 * add more serial ports (for up to two 16-port muxes).
468 *
469 * Revision 1.28 1994/11/04 00:13:16 root
470 * turn off diagnostic messages
471 *
472 * Revision 1.27 1994/11/03 23:46:37 root
473 * bunch of changes to bring driver into greater conformance
474 * with the serial.c driver (looking for missed fixes)
475 *
476 * Revision 1.26 1994/11/03 22:40:36 root
477 * automatic interrupt probing fixed.
478 *
479 * Revision 1.25 1994/11/03 20:17:02 root
480 * start to implement auto-irq
481 *
482 * Revision 1.24 1994/11/03 18:01:55 root
483 * still working on modem signals--trying not to drop DTR
484 * during the getty/login processes
485 *
486 * Revision 1.23 1994/11/03 17:51:36 root
487 * extend baud rate support; set receive threshold as function
488 * of baud rate; fix some problems with RTS/CTS;
489 *
490 * Revision 1.22 1994/11/02 18:05:35 root
491 * changed arguments to udelay to type long to get
492 * delays to be of correct duration
493 *
494 * Revision 1.21 1994/11/02 17:37:30 root
495 * employ udelay (after calibrating loops_per_second earlier
496 * in init/main.c) instead of using home-grown delay routines
497 *
498 * Revision 1.20 1994/11/02 03:11:38 root
499 * cy_chars_in_buffer forces a return value of 0 to let
500 * login work (don't know why it does); some functions
501 * that were returning EFAULT, now executes the code;
502 * more work on deciding when to disable xmit interrupts;
503 *
504 * Revision 1.19 1994/11/01 20:10:14 root
505 * define routine to start transmission interrupts (by enabling
506 * transmit interrupts); directly enable/disable modem interrupts;
507 *
508 * Revision 1.18 1994/11/01 18:40:45 bentson
509 * Don't always enable transmit interrupts in startup; interrupt on
510 * TxMpty instead of TxRdy to help characters get out before shutdown;
511 * restructure xmit interrupt to check for chars first and quit if
512 * none are ready to go; modem status (MXVRx) is upright, _not_ inverted
513 * (to my view);
514 *
515 * Revision 1.17 1994/10/30 04:39:45 bentson
516 * rename serial_driver and callout_driver to cy_serial_driver and
517 * cy_callout_driver to avoid linkage interference; initialize
518 * info->type to PORT_CIRRUS; ruggedize paranoia test; elide ->port
519 * from cyclades_port structure; add paranoia check to cy_close;
520 *
521 * Revision 1.16 1994/10/30 01:14:33 bentson
522 * change major numbers; add some _early_ return statements;
523 *
524 * Revision 1.15 1994/10/29 06:43:15 bentson
525 * final tidying up for clean compile; enable some error reporting
526 *
527 * Revision 1.14 1994/10/28 20:30:22 Bentson
528 * lots of changes to drag the driver towards the new tty_io
529 * structures and operation. not expected to work, but may
530 * compile cleanly.
531 *
532 * Revision 1.13 1994/07/21 23:08:57 Bentson
533 * add some diagnostic cruft; support 24 lines (for testing
534 * both -8Y and -16Y cards; be more thorough in servicing all
535 * chips during interrupt; add "volatile" a few places to
536 * circumvent compiler optimizations; fix base & offset
537 * computations in block_til_ready (was causing chip 0 to
538 * stop operation)
539 *
540 * Revision 1.12 1994/07/19 16:42:11 Bentson
541 * add some hackery for kernel version 1.1.8; expand
542 * error messages; refine timing for delay loops and
543 * declare loop params volatile
544 *
545 * Revision 1.11 1994/06/11 21:53:10 bentson
546 * get use of save_car right in transmit interrupt service
547 *
548 * Revision 1.10.1.1 1994/06/11 21:31:18 bentson
549 * add some diagnostic printing; try to fix save_car stuff
550 *
551 * Revision 1.10 1994/06/11 20:36:08 bentson
552 * clean up compiler warnings
553 *
554 * Revision 1.9 1994/06/11 19:42:46 bentson
555 * added a bunch of code to support modem signalling
556 *
557 * Revision 1.8 1994/06/11 17:57:07 bentson
558 * recognize break & parity error
559 *
560 * Revision 1.7 1994/06/05 05:51:34 bentson
561 * Reorder baud table to be monotonic; add cli to CP; discard
562 * incoming characters and status if the line isn't open; start to
563 * fold code into cy_throttle; start to port get_serial_info,
564 * set_serial_info, get_modem_info, set_modem_info, and send_break
565 * from serial.c; expand cy_ioctl; relocate and expand config_setup;
566 * get flow control characters from tty struct; invalidate ports w/o
567 * hardware;
568 *
569 * Revision 1.6 1994/05/31 18:42:21 bentson
570 * add a loop-breaker in the interrupt service routine;
571 * note when port is initialized so that it can be shut
572 * down under the right conditions; receive works without
573 * any obvious errors
574 *
575 * Revision 1.5 1994/05/30 00:55:02 bentson
576 * transmit works without obvious errors
577 *
578 * Revision 1.4 1994/05/27 18:46:27 bentson
579 * incorporated more code from lib_y.c; can now print short
580 * strings under interrupt control to port zero; seems to
581 * select ports/channels/lines correctly
582 *
583 * Revision 1.3 1994/05/25 22:12:44 bentson
584 * shifting from multi-port on a card to proper multiplexor
585 * data structures; added skeletons of most routines
586 *
587 * Revision 1.2 1994/05/19 13:21:43 bentson
588 * start to crib from other sources
589 *
590 */ 22 */
591 23
592#define CY_VERSION "2.5" 24#define CY_VERSION "2.6"
593 25
594/* If you need to install more boards than NR_CARDS, change the constant 26/* If you need to install more boards than NR_CARDS, change the constant
595 in the definition below. No other change is necessary to support up to 27 in the definition below. No other change is necessary to support up to
@@ -648,9 +80,7 @@
648#include <linux/firmware.h> 80#include <linux/firmware.h>
649#include <linux/device.h> 81#include <linux/device.h>
650 82
651#include <asm/system.h>
652#include <linux/io.h> 83#include <linux/io.h>
653#include <asm/irq.h>
654#include <linux/uaccess.h> 84#include <linux/uaccess.h>
655 85
656#include <linux/kernel.h> 86#include <linux/kernel.h>
@@ -660,13 +90,11 @@
660#include <linux/proc_fs.h> 90#include <linux/proc_fs.h>
661#include <linux/seq_file.h> 91#include <linux/seq_file.h>
662 92
663static void cy_throttle(struct tty_struct *tty);
664static void cy_send_xchar(struct tty_struct *tty, char ch); 93static void cy_send_xchar(struct tty_struct *tty, char ch);
665 94
666#ifndef SERIAL_XMIT_SIZE 95#ifndef SERIAL_XMIT_SIZE
667#define SERIAL_XMIT_SIZE (min(PAGE_SIZE, 4096)) 96#define SERIAL_XMIT_SIZE (min(PAGE_SIZE, 4096))
668#endif 97#endif
669#define WAKEUP_CHARS 256
670 98
671#define STD_COM_FLAGS (0) 99#define STD_COM_FLAGS (0)
672 100
@@ -756,25 +184,25 @@ static int cy_next_channel; /* next minor available */
756 * HI VHI 184 * HI VHI
757 * 20 185 * 20
758 */ 186 */
759static int baud_table[] = { 187static const int baud_table[] = {
760 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 188 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
761 1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000, 189 1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
762 230400, 0 190 230400, 0
763}; 191};
764 192
765static char baud_co_25[] = { /* 25 MHz clock option table */ 193static const char baud_co_25[] = { /* 25 MHz clock option table */
766 /* value => 00 01 02 03 04 */ 194 /* value => 00 01 02 03 04 */
767 /* divide by 8 32 128 512 2048 */ 195 /* divide by 8 32 128 512 2048 */
768 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02, 196 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
769 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 197 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
770}; 198};
771 199
772static char baud_bpr_25[] = { /* 25 MHz baud rate period table */ 200static const char baud_bpr_25[] = { /* 25 MHz baud rate period table */
773 0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3, 201 0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
774 0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15 202 0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
775}; 203};
776 204
777static char baud_co_60[] = { /* 60 MHz clock option table (CD1400 J) */ 205static const char baud_co_60[] = { /* 60 MHz clock option table (CD1400 J) */
778 /* value => 00 01 02 03 04 */ 206 /* value => 00 01 02 03 04 */
779 /* divide by 8 32 128 512 2048 */ 207 /* divide by 8 32 128 512 2048 */
780 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 208 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
@@ -782,13 +210,13 @@ static char baud_co_60[] = { /* 60 MHz clock option table (CD1400 J) */
782 0x00 210 0x00
783}; 211};
784 212
785static char baud_bpr_60[] = { /* 60 MHz baud rate period table (CD1400 J) */ 213static const char baud_bpr_60[] = { /* 60 MHz baud rate period table (CD1400 J) */
786 0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62, 214 0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62,
787 0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32, 215 0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32,
788 0x21 216 0x21
789}; 217};
790 218
791static char baud_cor3[] = { /* receive threshold */ 219static const char baud_cor3[] = { /* receive threshold */
792 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 220 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
793 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07, 221 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07,
794 0x07 222 0x07
@@ -805,7 +233,7 @@ static char baud_cor3[] = { /* receive threshold */
805 * cables. 233 * cables.
806 */ 234 */
807 235
808static char rflow_thr[] = { /* rflow threshold */ 236static const char rflow_thr[] = { /* rflow threshold */
809 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 237 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
810 0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 238 0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
811 0x0a 239 0x0a
@@ -814,7 +242,7 @@ static char rflow_thr[] = { /* rflow threshold */
814/* The Cyclom-Ye has placed the sequential chips in non-sequential 242/* The Cyclom-Ye has placed the sequential chips in non-sequential
815 * address order. This look-up table overcomes that problem. 243 * address order. This look-up table overcomes that problem.
816 */ 244 */
817static int cy_chip_offset[] = { 0x0000, 245static const unsigned int cy_chip_offset[] = { 0x0000,
818 0x0400, 246 0x0400,
819 0x0800, 247 0x0800,
820 0x0C00, 248 0x0C00,
@@ -827,7 +255,7 @@ static int cy_chip_offset[] = { 0x0000,
827/* PCI related definitions */ 255/* PCI related definitions */
828 256
829#ifdef CONFIG_PCI 257#ifdef CONFIG_PCI
830static struct pci_device_id cy_pci_dev_id[] __devinitdata = { 258static const struct pci_device_id cy_pci_dev_id[] = {
831 /* PCI < 1Mb */ 259 /* PCI < 1Mb */
832 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo) }, 260 { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo) },
833 /* PCI > 1Mb */ 261 /* PCI > 1Mb */
@@ -850,7 +278,7 @@ MODULE_DEVICE_TABLE(pci, cy_pci_dev_id);
850#endif 278#endif
851 279
852static void cy_start(struct tty_struct *); 280static void cy_start(struct tty_struct *);
853static void set_line_char(struct cyclades_port *); 281static void cy_set_line_char(struct cyclades_port *, struct tty_struct *);
854static int cyz_issue_cmd(struct cyclades_card *, __u32, __u8, __u32); 282static int cyz_issue_cmd(struct cyclades_card *, __u32, __u8, __u32);
855#ifdef CONFIG_ISA 283#ifdef CONFIG_ISA
856static unsigned detect_isa_irq(void __iomem *); 284static unsigned detect_isa_irq(void __iomem *);
@@ -869,6 +297,20 @@ static void cyz_rx_restart(unsigned long);
869static struct timer_list cyz_rx_full_timer[NR_PORTS]; 297static struct timer_list cyz_rx_full_timer[NR_PORTS];
870#endif /* CONFIG_CYZ_INTR */ 298#endif /* CONFIG_CYZ_INTR */
871 299
300static inline void cyy_writeb(struct cyclades_port *port, u32 reg, u8 val)
301{
302 struct cyclades_card *card = port->card;
303
304 cy_writeb(port->u.cyy.base_addr + (reg << card->bus_index), val);
305}
306
307static inline u8 cyy_readb(struct cyclades_port *port, u32 reg)
308{
309 struct cyclades_card *card = port->card;
310
311 return readb(port->u.cyy.base_addr + (reg << card->bus_index));
312}
313
872static inline bool cy_is_Z(struct cyclades_card *card) 314static inline bool cy_is_Z(struct cyclades_card *card)
873{ 315{
874 return card->num_chips == (unsigned int)-1; 316 return card->num_chips == (unsigned int)-1;
@@ -893,7 +335,7 @@ static inline bool cyz_is_loaded(struct cyclades_card *card)
893} 335}
894 336
895static inline int serial_paranoia_check(struct cyclades_port *info, 337static inline int serial_paranoia_check(struct cyclades_port *info,
896 char *name, const char *routine) 338 const char *name, const char *routine)
897{ 339{
898#ifdef SERIAL_PARANOIA_CHECK 340#ifdef SERIAL_PARANOIA_CHECK
899 if (!info) { 341 if (!info) {
@@ -909,7 +351,7 @@ static inline int serial_paranoia_check(struct cyclades_port *info,
909 } 351 }
910#endif 352#endif
911 return 0; 353 return 0;
912} /* serial_paranoia_check */ 354}
913 355
914/***********************************************************/ 356/***********************************************************/
915/********* Start of block of Cyclom-Y specific code ********/ 357/********* Start of block of Cyclom-Y specific code ********/
@@ -921,13 +363,14 @@ static inline int serial_paranoia_check(struct cyclades_port *info,
921 363
922 This function is only called from inside spinlock-protected code. 364 This function is only called from inside spinlock-protected code.
923 */ 365 */
924static int cyy_issue_cmd(void __iomem *base_addr, u_char cmd, int index) 366static int __cyy_issue_cmd(void __iomem *base_addr, u8 cmd, int index)
925{ 367{
368 void __iomem *ccr = base_addr + (CyCCR << index);
926 unsigned int i; 369 unsigned int i;
927 370
928 /* Check to see that the previous command has completed */ 371 /* Check to see that the previous command has completed */
929 for (i = 0; i < 100; i++) { 372 for (i = 0; i < 100; i++) {
930 if (readb(base_addr + (CyCCR << index)) == 0) 373 if (readb(ccr) == 0)
931 break; 374 break;
932 udelay(10L); 375 udelay(10L);
933 } 376 }
@@ -937,10 +380,16 @@ static int cyy_issue_cmd(void __iomem *base_addr, u_char cmd, int index)
937 return -1; 380 return -1;
938 381
939 /* Issue the new command */ 382 /* Issue the new command */
940 cy_writeb(base_addr + (CyCCR << index), cmd); 383 cy_writeb(ccr, cmd);
941 384
942 return 0; 385 return 0;
943} /* cyy_issue_cmd */ 386}
387
388static inline int cyy_issue_cmd(struct cyclades_port *port, u8 cmd)
389{
390 return __cyy_issue_cmd(port->u.cyy.base_addr, cmd,
391 port->card->bus_index);
392}
944 393
945#ifdef CONFIG_ISA 394#ifdef CONFIG_ISA
946/* ISA interrupt detection code */ 395/* ISA interrupt detection code */
@@ -960,12 +409,12 @@ static unsigned detect_isa_irq(void __iomem *address)
960 409
961 irqs = probe_irq_on(); 410 irqs = probe_irq_on();
962 /* Wait ... */ 411 /* Wait ... */
963 udelay(5000L); 412 msleep(5);
964 413
965 /* Enable the Tx interrupts on the CD1400 */ 414 /* Enable the Tx interrupts on the CD1400 */
966 local_irq_save(flags); 415 local_irq_save(flags);
967 cy_writeb(address + (CyCAR << index), 0); 416 cy_writeb(address + (CyCAR << index), 0);
968 cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index); 417 __cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
969 418
970 cy_writeb(address + (CyCAR << index), 0); 419 cy_writeb(address + (CyCAR << index), 0);
971 cy_writeb(address + (CySRER << index), 420 cy_writeb(address + (CySRER << index),
@@ -973,7 +422,7 @@ static unsigned detect_isa_irq(void __iomem *address)
973 local_irq_restore(flags); 422 local_irq_restore(flags);
974 423
975 /* Wait ... */ 424 /* Wait ... */
976 udelay(5000L); 425 msleep(5);
977 426
978 /* Check which interrupt is in use */ 427 /* Check which interrupt is in use */
979 irq = probe_irq_off(irqs); 428 irq = probe_irq_off(irqs);
@@ -999,7 +448,7 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
999 struct cyclades_port *info; 448 struct cyclades_port *info;
1000 struct tty_struct *tty; 449 struct tty_struct *tty;
1001 int len, index = cinfo->bus_index; 450 int len, index = cinfo->bus_index;
1002 u8 save_xir, channel, save_car, data, char_count; 451 u8 ivr, save_xir, channel, save_car, data, char_count;
1003 452
1004#ifdef CY_DEBUG_INTERRUPTS 453#ifdef CY_DEBUG_INTERRUPTS
1005 printk(KERN_DEBUG "cyy_interrupt: rcvd intr, chip %d\n", chip); 454 printk(KERN_DEBUG "cyy_interrupt: rcvd intr, chip %d\n", chip);
@@ -1008,26 +457,25 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
1008 save_xir = readb(base_addr + (CyRIR << index)); 457 save_xir = readb(base_addr + (CyRIR << index));
1009 channel = save_xir & CyIRChannel; 458 channel = save_xir & CyIRChannel;
1010 info = &cinfo->ports[channel + chip * 4]; 459 info = &cinfo->ports[channel + chip * 4];
1011 save_car = readb(base_addr + (CyCAR << index)); 460 save_car = cyy_readb(info, CyCAR);
1012 cy_writeb(base_addr + (CyCAR << index), save_xir); 461 cyy_writeb(info, CyCAR, save_xir);
462 ivr = cyy_readb(info, CyRIVR) & CyIVRMask;
1013 463
464 tty = tty_port_tty_get(&info->port);
1014 /* if there is nowhere to put the data, discard it */ 465 /* if there is nowhere to put the data, discard it */
1015 if (info->port.tty == NULL) { 466 if (tty == NULL) {
1016 if ((readb(base_addr + (CyRIVR << index)) & CyIVRMask) == 467 if (ivr == CyIVRRxEx) { /* exception */
1017 CyIVRRxEx) { /* exception */ 468 data = cyy_readb(info, CyRDSR);
1018 data = readb(base_addr + (CyRDSR << index));
1019 } else { /* normal character reception */ 469 } else { /* normal character reception */
1020 char_count = readb(base_addr + (CyRDCR << index)); 470 char_count = cyy_readb(info, CyRDCR);
1021 while (char_count--) 471 while (char_count--)
1022 data = readb(base_addr + (CyRDSR << index)); 472 data = cyy_readb(info, CyRDSR);
1023 } 473 }
1024 goto end; 474 goto end;
1025 } 475 }
1026 /* there is an open port for this data */ 476 /* there is an open port for this data */
1027 tty = info->port.tty; 477 if (ivr == CyIVRRxEx) { /* exception */
1028 if ((readb(base_addr + (CyRIVR << index)) & CyIVRMask) == 478 data = cyy_readb(info, CyRDSR);
1029 CyIVRRxEx) { /* exception */
1030 data = readb(base_addr + (CyRDSR << index));
1031 479
1032 /* For statistics only */ 480 /* For statistics only */
1033 if (data & CyBREAK) 481 if (data & CyBREAK)
@@ -1041,28 +489,29 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
1041 489
1042 if (data & info->ignore_status_mask) { 490 if (data & info->ignore_status_mask) {
1043 info->icount.rx++; 491 info->icount.rx++;
492 tty_kref_put(tty);
1044 return; 493 return;
1045 } 494 }
1046 if (tty_buffer_request_room(tty, 1)) { 495 if (tty_buffer_request_room(tty, 1)) {
1047 if (data & info->read_status_mask) { 496 if (data & info->read_status_mask) {
1048 if (data & CyBREAK) { 497 if (data & CyBREAK) {
1049 tty_insert_flip_char(tty, 498 tty_insert_flip_char(tty,
1050 readb(base_addr + (CyRDSR << 499 cyy_readb(info, CyRDSR),
1051 index)), TTY_BREAK); 500 TTY_BREAK);
1052 info->icount.rx++; 501 info->icount.rx++;
1053 if (info->port.flags & ASYNC_SAK) 502 if (info->port.flags & ASYNC_SAK)
1054 do_SAK(tty); 503 do_SAK(tty);
1055 } else if (data & CyFRAME) { 504 } else if (data & CyFRAME) {
1056 tty_insert_flip_char(tty, 505 tty_insert_flip_char(tty,
1057 readb(base_addr + (CyRDSR << 506 cyy_readb(info, CyRDSR),
1058 index)), TTY_FRAME); 507 TTY_FRAME);
1059 info->icount.rx++; 508 info->icount.rx++;
1060 info->idle_stats.frame_errs++; 509 info->idle_stats.frame_errs++;
1061 } else if (data & CyPARITY) { 510 } else if (data & CyPARITY) {
1062 /* Pieces of seven... */ 511 /* Pieces of seven... */
1063 tty_insert_flip_char(tty, 512 tty_insert_flip_char(tty,
1064 readb(base_addr + (CyRDSR << 513 cyy_readb(info, CyRDSR),
1065 index)), TTY_PARITY); 514 TTY_PARITY);
1066 info->icount.rx++; 515 info->icount.rx++;
1067 info->idle_stats.parity_errs++; 516 info->idle_stats.parity_errs++;
1068 } else if (data & CyOVERRUN) { 517 } else if (data & CyOVERRUN) {
@@ -1074,8 +523,8 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
1074 the next incoming character. 523 the next incoming character.
1075 */ 524 */
1076 tty_insert_flip_char(tty, 525 tty_insert_flip_char(tty,
1077 readb(base_addr + (CyRDSR << 526 cyy_readb(info, CyRDSR),
1078 index)), TTY_FRAME); 527 TTY_FRAME);
1079 info->icount.rx++; 528 info->icount.rx++;
1080 info->idle_stats.overruns++; 529 info->idle_stats.overruns++;
1081 /* These two conditions may imply */ 530 /* These two conditions may imply */
@@ -1099,7 +548,7 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
1099 } 548 }
1100 } else { /* normal character reception */ 549 } else { /* normal character reception */
1101 /* load # chars available from the chip */ 550 /* load # chars available from the chip */
1102 char_count = readb(base_addr + (CyRDCR << index)); 551 char_count = cyy_readb(info, CyRDCR);
1103 552
1104#ifdef CY_ENABLE_MONITORING 553#ifdef CY_ENABLE_MONITORING
1105 ++info->mon.int_count; 554 ++info->mon.int_count;
@@ -1110,7 +559,7 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
1110#endif 559#endif
1111 len = tty_buffer_request_room(tty, char_count); 560 len = tty_buffer_request_room(tty, char_count);
1112 while (len--) { 561 while (len--) {
1113 data = readb(base_addr + (CyRDSR << index)); 562 data = cyy_readb(info, CyRDSR);
1114 tty_insert_flip_char(tty, data, TTY_NORMAL); 563 tty_insert_flip_char(tty, data, TTY_NORMAL);
1115 info->idle_stats.recv_bytes++; 564 info->idle_stats.recv_bytes++;
1116 info->icount.rx++; 565 info->icount.rx++;
@@ -1121,16 +570,18 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
1121 info->idle_stats.recv_idle = jiffies; 570 info->idle_stats.recv_idle = jiffies;
1122 } 571 }
1123 tty_schedule_flip(tty); 572 tty_schedule_flip(tty);
573 tty_kref_put(tty);
1124end: 574end:
1125 /* end of service */ 575 /* end of service */
1126 cy_writeb(base_addr + (CyRIR << index), save_xir & 0x3f); 576 cyy_writeb(info, CyRIR, save_xir & 0x3f);
1127 cy_writeb(base_addr + (CyCAR << index), save_car); 577 cyy_writeb(info, CyCAR, save_car);
1128} 578}
1129 579
1130static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip, 580static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
1131 void __iomem *base_addr) 581 void __iomem *base_addr)
1132{ 582{
1133 struct cyclades_port *info; 583 struct cyclades_port *info;
584 struct tty_struct *tty;
1134 int char_count, index = cinfo->bus_index; 585 int char_count, index = cinfo->bus_index;
1135 u8 save_xir, channel, save_car, outch; 586 u8 save_xir, channel, save_car, outch;
1136 587
@@ -1154,9 +605,9 @@ static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
1154 goto end; 605 goto end;
1155 } 606 }
1156 info = &cinfo->ports[channel + chip * 4]; 607 info = &cinfo->ports[channel + chip * 4];
1157 if (info->port.tty == NULL) { 608 tty = tty_port_tty_get(&info->port);
1158 cy_writeb(base_addr + (CySRER << index), 609 if (tty == NULL) {
1159 readb(base_addr + (CySRER << index)) & ~CyTxRdy); 610 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
1160 goto end; 611 goto end;
1161 } 612 }
1162 613
@@ -1165,7 +616,7 @@ static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
1165 616
1166 if (info->x_char) { /* send special char */ 617 if (info->x_char) { /* send special char */
1167 outch = info->x_char; 618 outch = info->x_char;
1168 cy_writeb(base_addr + (CyTDR << index), outch); 619 cyy_writeb(info, CyTDR, outch);
1169 char_count--; 620 char_count--;
1170 info->icount.tx++; 621 info->icount.tx++;
1171 info->x_char = 0; 622 info->x_char = 0;
@@ -1173,14 +624,14 @@ static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
1173 624
1174 if (info->breakon || info->breakoff) { 625 if (info->breakon || info->breakoff) {
1175 if (info->breakon) { 626 if (info->breakon) {
1176 cy_writeb(base_addr + (CyTDR << index), 0); 627 cyy_writeb(info, CyTDR, 0);
1177 cy_writeb(base_addr + (CyTDR << index), 0x81); 628 cyy_writeb(info, CyTDR, 0x81);
1178 info->breakon = 0; 629 info->breakon = 0;
1179 char_count -= 2; 630 char_count -= 2;
1180 } 631 }
1181 if (info->breakoff) { 632 if (info->breakoff) {
1182 cy_writeb(base_addr + (CyTDR << index), 0); 633 cyy_writeb(info, CyTDR, 0);
1183 cy_writeb(base_addr + (CyTDR << index), 0x83); 634 cyy_writeb(info, CyTDR, 0x83);
1184 info->breakoff = 0; 635 info->breakoff = 0;
1185 char_count -= 2; 636 char_count -= 2;
1186 } 637 }
@@ -1188,27 +639,23 @@ static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
1188 639
1189 while (char_count-- > 0) { 640 while (char_count-- > 0) {
1190 if (!info->xmit_cnt) { 641 if (!info->xmit_cnt) {
1191 if (readb(base_addr + (CySRER << index)) & CyTxMpty) { 642 if (cyy_readb(info, CySRER) & CyTxMpty) {
1192 cy_writeb(base_addr + (CySRER << index), 643 cyy_writeb(info, CySRER,
1193 readb(base_addr + (CySRER << index)) & 644 cyy_readb(info, CySRER) & ~CyTxMpty);
1194 ~CyTxMpty);
1195 } else { 645 } else {
1196 cy_writeb(base_addr + (CySRER << index), 646 cyy_writeb(info, CySRER, CyTxMpty |
1197 (readb(base_addr + (CySRER << index)) & 647 (cyy_readb(info, CySRER) & ~CyTxRdy));
1198 ~CyTxRdy) | CyTxMpty);
1199 } 648 }
1200 goto done; 649 goto done;
1201 } 650 }
1202 if (info->port.xmit_buf == NULL) { 651 if (info->port.xmit_buf == NULL) {
1203 cy_writeb(base_addr + (CySRER << index), 652 cyy_writeb(info, CySRER,
1204 readb(base_addr + (CySRER << index)) & 653 cyy_readb(info, CySRER) & ~CyTxRdy);
1205 ~CyTxRdy);
1206 goto done; 654 goto done;
1207 } 655 }
1208 if (info->port.tty->stopped || info->port.tty->hw_stopped) { 656 if (tty->stopped || tty->hw_stopped) {
1209 cy_writeb(base_addr + (CySRER << index), 657 cyy_writeb(info, CySRER,
1210 readb(base_addr + (CySRER << index)) & 658 cyy_readb(info, CySRER) & ~CyTxRdy);
1211 ~CyTxRdy);
1212 goto done; 659 goto done;
1213 } 660 }
1214 /* Because the Embedded Transmit Commands have been enabled, 661 /* Because the Embedded Transmit Commands have been enabled,
@@ -1225,15 +672,15 @@ static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
1225 info->xmit_cnt--; 672 info->xmit_cnt--;
1226 info->xmit_tail = (info->xmit_tail + 1) & 673 info->xmit_tail = (info->xmit_tail + 1) &
1227 (SERIAL_XMIT_SIZE - 1); 674 (SERIAL_XMIT_SIZE - 1);
1228 cy_writeb(base_addr + (CyTDR << index), outch); 675 cyy_writeb(info, CyTDR, outch);
1229 info->icount.tx++; 676 info->icount.tx++;
1230 } else { 677 } else {
1231 if (char_count > 1) { 678 if (char_count > 1) {
1232 info->xmit_cnt--; 679 info->xmit_cnt--;
1233 info->xmit_tail = (info->xmit_tail + 1) & 680 info->xmit_tail = (info->xmit_tail + 1) &
1234 (SERIAL_XMIT_SIZE - 1); 681 (SERIAL_XMIT_SIZE - 1);
1235 cy_writeb(base_addr + (CyTDR << index), outch); 682 cyy_writeb(info, CyTDR, outch);
1236 cy_writeb(base_addr + (CyTDR << index), 0); 683 cyy_writeb(info, CyTDR, 0);
1237 info->icount.tx++; 684 info->icount.tx++;
1238 char_count--; 685 char_count--;
1239 } 686 }
@@ -1241,17 +688,19 @@ static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
1241 } 688 }
1242 689
1243done: 690done:
1244 tty_wakeup(info->port.tty); 691 tty_wakeup(tty);
692 tty_kref_put(tty);
1245end: 693end:
1246 /* end of service */ 694 /* end of service */
1247 cy_writeb(base_addr + (CyTIR << index), save_xir & 0x3f); 695 cyy_writeb(info, CyTIR, save_xir & 0x3f);
1248 cy_writeb(base_addr + (CyCAR << index), save_car); 696 cyy_writeb(info, CyCAR, save_car);
1249} 697}
1250 698
1251static void cyy_chip_modem(struct cyclades_card *cinfo, int chip, 699static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
1252 void __iomem *base_addr) 700 void __iomem *base_addr)
1253{ 701{
1254 struct cyclades_port *info; 702 struct cyclades_port *info;
703 struct tty_struct *tty;
1255 int index = cinfo->bus_index; 704 int index = cinfo->bus_index;
1256 u8 save_xir, channel, save_car, mdm_change, mdm_status; 705 u8 save_xir, channel, save_car, mdm_change, mdm_status;
1257 706
@@ -1259,13 +708,14 @@ static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
1259 save_xir = readb(base_addr + (CyMIR << index)); 708 save_xir = readb(base_addr + (CyMIR << index));
1260 channel = save_xir & CyIRChannel; 709 channel = save_xir & CyIRChannel;
1261 info = &cinfo->ports[channel + chip * 4]; 710 info = &cinfo->ports[channel + chip * 4];
1262 save_car = readb(base_addr + (CyCAR << index)); 711 save_car = cyy_readb(info, CyCAR);
1263 cy_writeb(base_addr + (CyCAR << index), save_xir); 712 cyy_writeb(info, CyCAR, save_xir);
1264 713
1265 mdm_change = readb(base_addr + (CyMISR << index)); 714 mdm_change = cyy_readb(info, CyMISR);
1266 mdm_status = readb(base_addr + (CyMSVR1 << index)); 715 mdm_status = cyy_readb(info, CyMSVR1);
1267 716
1268 if (!info->port.tty) 717 tty = tty_port_tty_get(&info->port);
718 if (!tty)
1269 goto end; 719 goto end;
1270 720
1271 if (mdm_change & CyANY_DELTA) { 721 if (mdm_change & CyANY_DELTA) {
@@ -1279,35 +729,32 @@ static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
1279 if (mdm_change & CyRI) 729 if (mdm_change & CyRI)
1280 info->icount.rng++; 730 info->icount.rng++;
1281 731
1282 wake_up_interruptible(&info->delta_msr_wait); 732 wake_up_interruptible(&info->port.delta_msr_wait);
1283 } 733 }
1284 734
1285 if ((mdm_change & CyDCD) && (info->port.flags & ASYNC_CHECK_CD)) { 735 if ((mdm_change & CyDCD) && (info->port.flags & ASYNC_CHECK_CD)) {
1286 if (!(mdm_status & CyDCD)) { 736 if (mdm_status & CyDCD)
1287 tty_hangup(info->port.tty); 737 wake_up_interruptible(&info->port.open_wait);
1288 info->port.flags &= ~ASYNC_NORMAL_ACTIVE; 738 else
1289 } 739 tty_hangup(tty);
1290 wake_up_interruptible(&info->port.open_wait);
1291 } 740 }
1292 if ((mdm_change & CyCTS) && (info->port.flags & ASYNC_CTS_FLOW)) { 741 if ((mdm_change & CyCTS) && (info->port.flags & ASYNC_CTS_FLOW)) {
1293 if (info->port.tty->hw_stopped) { 742 if (tty->hw_stopped) {
1294 if (mdm_status & CyCTS) { 743 if (mdm_status & CyCTS) {
1295 /* cy_start isn't used 744 /* cy_start isn't used
1296 because... !!! */ 745 because... !!! */
1297 info->port.tty->hw_stopped = 0; 746 tty->hw_stopped = 0;
1298 cy_writeb(base_addr + (CySRER << index), 747 cyy_writeb(info, CySRER,
1299 readb(base_addr + (CySRER << index)) | 748 cyy_readb(info, CySRER) | CyTxRdy);
1300 CyTxRdy); 749 tty_wakeup(tty);
1301 tty_wakeup(info->port.tty);
1302 } 750 }
1303 } else { 751 } else {
1304 if (!(mdm_status & CyCTS)) { 752 if (!(mdm_status & CyCTS)) {
1305 /* cy_stop isn't used 753 /* cy_stop isn't used
1306 because ... !!! */ 754 because ... !!! */
1307 info->port.tty->hw_stopped = 1; 755 tty->hw_stopped = 1;
1308 cy_writeb(base_addr + (CySRER << index), 756 cyy_writeb(info, CySRER,
1309 readb(base_addr + (CySRER << index)) & 757 cyy_readb(info, CySRER) & ~CyTxRdy);
1310 ~CyTxRdy);
1311 } 758 }
1312 } 759 }
1313 } 760 }
@@ -1315,10 +762,11 @@ static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
1315 } 762 }
1316 if (mdm_change & CyRI) { 763 if (mdm_change & CyRI) {
1317 }*/ 764 }*/
765 tty_kref_put(tty);
1318end: 766end:
1319 /* end of service */ 767 /* end of service */
1320 cy_writeb(base_addr + (CyMIR << index), save_xir & 0x3f); 768 cyy_writeb(info, CyMIR, save_xir & 0x3f);
1321 cy_writeb(base_addr + (CyCAR << index), save_car); 769 cyy_writeb(info, CyCAR, save_car);
1322} 770}
1323 771
1324/* The real interrupt service routine is called 772/* The real interrupt service routine is called
@@ -1389,6 +837,56 @@ static irqreturn_t cyy_interrupt(int irq, void *dev_id)
1389 return IRQ_HANDLED; 837 return IRQ_HANDLED;
1390} /* cyy_interrupt */ 838} /* cyy_interrupt */
1391 839
840static void cyy_change_rts_dtr(struct cyclades_port *info, unsigned int set,
841 unsigned int clear)
842{
843 struct cyclades_card *card = info->card;
844 int channel = info->line - card->first_line;
845 u32 rts, dtr, msvrr, msvrd;
846
847 channel &= 0x03;
848
849 if (info->rtsdtr_inv) {
850 msvrr = CyMSVR2;
851 msvrd = CyMSVR1;
852 rts = CyDTR;
853 dtr = CyRTS;
854 } else {
855 msvrr = CyMSVR1;
856 msvrd = CyMSVR2;
857 rts = CyRTS;
858 dtr = CyDTR;
859 }
860 if (set & TIOCM_RTS) {
861 cyy_writeb(info, CyCAR, channel);
862 cyy_writeb(info, msvrr, rts);
863 }
864 if (clear & TIOCM_RTS) {
865 cyy_writeb(info, CyCAR, channel);
866 cyy_writeb(info, msvrr, ~rts);
867 }
868 if (set & TIOCM_DTR) {
869 cyy_writeb(info, CyCAR, channel);
870 cyy_writeb(info, msvrd, dtr);
871#ifdef CY_DEBUG_DTR
872 printk(KERN_DEBUG "cyc:set_modem_info raising DTR\n");
873 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
874 cyy_readb(info, CyMSVR1),
875 cyy_readb(info, CyMSVR2));
876#endif
877 }
878 if (clear & TIOCM_DTR) {
879 cyy_writeb(info, CyCAR, channel);
880 cyy_writeb(info, msvrd, ~dtr);
881#ifdef CY_DEBUG_DTR
882 printk(KERN_DEBUG "cyc:set_modem_info dropping DTR\n");
883 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
884 cyy_readb(info, CyMSVR1),
885 cyy_readb(info, CyMSVR2));
886#endif
887 }
888}
889
1392/***********************************************************/ 890/***********************************************************/
1393/********* End of block of Cyclom-Y specific code **********/ 891/********* End of block of Cyclom-Y specific code **********/
1394/******** Start of block of Cyclades-Z specific code *******/ 892/******** Start of block of Cyclades-Z specific code *******/
@@ -1398,15 +896,9 @@ static int
1398cyz_fetch_msg(struct cyclades_card *cinfo, 896cyz_fetch_msg(struct cyclades_card *cinfo,
1399 __u32 *channel, __u8 *cmd, __u32 *param) 897 __u32 *channel, __u8 *cmd, __u32 *param)
1400{ 898{
1401 struct FIRM_ID __iomem *firm_id; 899 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
1402 struct ZFW_CTRL __iomem *zfw_ctrl;
1403 struct BOARD_CTRL __iomem *board_ctrl;
1404 unsigned long loc_doorbell; 900 unsigned long loc_doorbell;
1405 901
1406 firm_id = cinfo->base_addr + ID_ADDRESS;
1407 zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
1408 board_ctrl = &zfw_ctrl->board_ctrl;
1409
1410 loc_doorbell = readl(&cinfo->ctl_addr.p9060->loc_doorbell); 902 loc_doorbell = readl(&cinfo->ctl_addr.p9060->loc_doorbell);
1411 if (loc_doorbell) { 903 if (loc_doorbell) {
1412 *cmd = (char)(0xff & loc_doorbell); 904 *cmd = (char)(0xff & loc_doorbell);
@@ -1422,19 +914,13 @@ static int
1422cyz_issue_cmd(struct cyclades_card *cinfo, 914cyz_issue_cmd(struct cyclades_card *cinfo,
1423 __u32 channel, __u8 cmd, __u32 param) 915 __u32 channel, __u8 cmd, __u32 param)
1424{ 916{
1425 struct FIRM_ID __iomem *firm_id; 917 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
1426 struct ZFW_CTRL __iomem *zfw_ctrl;
1427 struct BOARD_CTRL __iomem *board_ctrl;
1428 __u32 __iomem *pci_doorbell; 918 __u32 __iomem *pci_doorbell;
1429 unsigned int index; 919 unsigned int index;
1430 920
1431 firm_id = cinfo->base_addr + ID_ADDRESS;
1432 if (!cyz_is_loaded(cinfo)) 921 if (!cyz_is_loaded(cinfo))
1433 return -1; 922 return -1;
1434 923
1435 zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
1436 board_ctrl = &zfw_ctrl->board_ctrl;
1437
1438 index = 0; 924 index = 0;
1439 pci_doorbell = &cinfo->ctl_addr.p9060->pci_doorbell; 925 pci_doorbell = &cinfo->ctl_addr.p9060->pci_doorbell;
1440 while ((readl(pci_doorbell) & 0xff) != 0) { 926 while ((readl(pci_doorbell) & 0xff) != 0) {
@@ -1449,11 +935,10 @@ cyz_issue_cmd(struct cyclades_card *cinfo,
1449 return 0; 935 return 0;
1450} /* cyz_issue_cmd */ 936} /* cyz_issue_cmd */
1451 937
1452static void cyz_handle_rx(struct cyclades_port *info, 938static void cyz_handle_rx(struct cyclades_port *info, struct tty_struct *tty)
1453 struct BUF_CTRL __iomem *buf_ctrl)
1454{ 939{
940 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1455 struct cyclades_card *cinfo = info->card; 941 struct cyclades_card *cinfo = info->card;
1456 struct tty_struct *tty = info->port.tty;
1457 unsigned int char_count; 942 unsigned int char_count;
1458 int len; 943 int len;
1459#ifdef BLOCKMOVE 944#ifdef BLOCKMOVE
@@ -1542,11 +1027,10 @@ static void cyz_handle_rx(struct cyclades_port *info,
1542 } 1027 }
1543} 1028}
1544 1029
1545static void cyz_handle_tx(struct cyclades_port *info, 1030static void cyz_handle_tx(struct cyclades_port *info, struct tty_struct *tty)
1546 struct BUF_CTRL __iomem *buf_ctrl)
1547{ 1031{
1032 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
1548 struct cyclades_card *cinfo = info->card; 1033 struct cyclades_card *cinfo = info->card;
1549 struct tty_struct *tty = info->port.tty;
1550 u8 data; 1034 u8 data;
1551 unsigned int char_count; 1035 unsigned int char_count;
1552#ifdef BLOCKMOVE 1036#ifdef BLOCKMOVE
@@ -1621,34 +1105,24 @@ ztxdone:
1621 1105
1622static void cyz_handle_cmd(struct cyclades_card *cinfo) 1106static void cyz_handle_cmd(struct cyclades_card *cinfo)
1623{ 1107{
1108 struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
1624 struct tty_struct *tty; 1109 struct tty_struct *tty;
1625 struct cyclades_port *info; 1110 struct cyclades_port *info;
1626 static struct FIRM_ID __iomem *firm_id;
1627 static struct ZFW_CTRL __iomem *zfw_ctrl;
1628 static struct BOARD_CTRL __iomem *board_ctrl;
1629 static struct CH_CTRL __iomem *ch_ctrl;
1630 static struct BUF_CTRL __iomem *buf_ctrl;
1631 __u32 channel, param, fw_ver; 1111 __u32 channel, param, fw_ver;
1632 __u8 cmd; 1112 __u8 cmd;
1633 int special_count; 1113 int special_count;
1634 int delta_count; 1114 int delta_count;
1635 1115
1636 firm_id = cinfo->base_addr + ID_ADDRESS;
1637 zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
1638 board_ctrl = &zfw_ctrl->board_ctrl;
1639 fw_ver = readl(&board_ctrl->fw_version); 1116 fw_ver = readl(&board_ctrl->fw_version);
1640 1117
1641 while (cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) { 1118 while (cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) {
1642 special_count = 0; 1119 special_count = 0;
1643 delta_count = 0; 1120 delta_count = 0;
1644 info = &cinfo->ports[channel]; 1121 info = &cinfo->ports[channel];
1645 tty = info->port.tty; 1122 tty = tty_port_tty_get(&info->port);
1646 if (tty == NULL) 1123 if (tty == NULL)
1647 continue; 1124 continue;
1648 1125
1649 ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
1650 buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
1651
1652 switch (cmd) { 1126 switch (cmd) {
1653 case C_CM_PR_ERROR: 1127 case C_CM_PR_ERROR:
1654 tty_insert_flip_char(tty, 0, TTY_PARITY); 1128 tty_insert_flip_char(tty, 0, TTY_PARITY);
@@ -1669,15 +1143,12 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
1669 info->icount.dcd++; 1143 info->icount.dcd++;
1670 delta_count++; 1144 delta_count++;
1671 if (info->port.flags & ASYNC_CHECK_CD) { 1145 if (info->port.flags & ASYNC_CHECK_CD) {
1672 if ((fw_ver > 241 ? ((u_long) param) : 1146 u32 dcd = fw_ver > 241 ? param :
1673 readl(&ch_ctrl->rs_status)) & 1147 readl(&info->u.cyz.ch_ctrl->rs_status);
1674 C_RS_DCD) { 1148 if (dcd & C_RS_DCD)
1675 wake_up_interruptible(&info->port.open_wait); 1149 wake_up_interruptible(&info->port.open_wait);
1676 } else { 1150 else
1677 tty_hangup(info->port.tty); 1151 tty_hangup(tty);
1678 wake_up_interruptible(&info->port.open_wait);
1679 info->port.flags &= ~ASYNC_NORMAL_ACTIVE;
1680 }
1681 } 1152 }
1682 break; 1153 break;
1683 case C_CM_MCTS: 1154 case C_CM_MCTS:
@@ -1706,7 +1177,7 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
1706 printk(KERN_DEBUG "cyz_interrupt: rcvd intr, card %d, " 1177 printk(KERN_DEBUG "cyz_interrupt: rcvd intr, card %d, "
1707 "port %ld\n", info->card, channel); 1178 "port %ld\n", info->card, channel);
1708#endif 1179#endif
1709 cyz_handle_rx(info, buf_ctrl); 1180 cyz_handle_rx(info, tty);
1710 break; 1181 break;
1711 case C_CM_TXBEMPTY: 1182 case C_CM_TXBEMPTY:
1712 case C_CM_TXLOWWM: 1183 case C_CM_TXLOWWM:
@@ -1716,7 +1187,7 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
1716 printk(KERN_DEBUG "cyz_interrupt: xmit intr, card %d, " 1187 printk(KERN_DEBUG "cyz_interrupt: xmit intr, card %d, "
1717 "port %ld\n", info->card, channel); 1188 "port %ld\n", info->card, channel);
1718#endif 1189#endif
1719 cyz_handle_tx(info, buf_ctrl); 1190 cyz_handle_tx(info, tty);
1720 break; 1191 break;
1721#endif /* CONFIG_CYZ_INTR */ 1192#endif /* CONFIG_CYZ_INTR */
1722 case C_CM_FATAL: 1193 case C_CM_FATAL:
@@ -1726,9 +1197,10 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
1726 break; 1197 break;
1727 } 1198 }
1728 if (delta_count) 1199 if (delta_count)
1729 wake_up_interruptible(&info->delta_msr_wait); 1200 wake_up_interruptible(&info->port.delta_msr_wait);
1730 if (special_count) 1201 if (special_count)
1731 tty_schedule_flip(tty); 1202 tty_schedule_flip(tty);
1203 tty_kref_put(tty);
1732 } 1204 }
1733} 1205}
1734 1206
@@ -1774,10 +1246,6 @@ static void cyz_poll(unsigned long arg)
1774{ 1246{
1775 struct cyclades_card *cinfo; 1247 struct cyclades_card *cinfo;
1776 struct cyclades_port *info; 1248 struct cyclades_port *info;
1777 struct tty_struct *tty;
1778 struct FIRM_ID __iomem *firm_id;
1779 struct ZFW_CTRL __iomem *zfw_ctrl;
1780 struct BUF_CTRL __iomem *buf_ctrl;
1781 unsigned long expires = jiffies + HZ; 1249 unsigned long expires = jiffies + HZ;
1782 unsigned int port, card; 1250 unsigned int port, card;
1783 1251
@@ -1789,10 +1257,6 @@ static void cyz_poll(unsigned long arg)
1789 if (!cyz_is_loaded(cinfo)) 1257 if (!cyz_is_loaded(cinfo))
1790 continue; 1258 continue;
1791 1259
1792 firm_id = cinfo->base_addr + ID_ADDRESS;
1793 zfw_ctrl = cinfo->base_addr +
1794 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
1795
1796 /* Skip first polling cycle to avoid racing conditions with the FW */ 1260 /* Skip first polling cycle to avoid racing conditions with the FW */
1797 if (!cinfo->intr_enabled) { 1261 if (!cinfo->intr_enabled) {
1798 cinfo->intr_enabled = 1; 1262 cinfo->intr_enabled = 1;
@@ -1802,13 +1266,17 @@ static void cyz_poll(unsigned long arg)
1802 cyz_handle_cmd(cinfo); 1266 cyz_handle_cmd(cinfo);
1803 1267
1804 for (port = 0; port < cinfo->nports; port++) { 1268 for (port = 0; port < cinfo->nports; port++) {
1269 struct tty_struct *tty;
1270
1805 info = &cinfo->ports[port]; 1271 info = &cinfo->ports[port];
1806 tty = info->port.tty; 1272 tty = tty_port_tty_get(&info->port);
1807 buf_ctrl = &(zfw_ctrl->buf_ctrl[port]); 1273 /* OK to pass NULL to the handle functions below.
1274 They need to drop the data in that case. */
1808 1275
1809 if (!info->throttle) 1276 if (!info->throttle)
1810 cyz_handle_rx(info, buf_ctrl); 1277 cyz_handle_rx(info, tty);
1811 cyz_handle_tx(info, buf_ctrl); 1278 cyz_handle_tx(info, tty);
1279 tty_kref_put(tty);
1812 } 1280 }
1813 /* poll every 'cyz_polling_cycle' period */ 1281 /* poll every 'cyz_polling_cycle' period */
1814 expires = jiffies + cyz_polling_cycle; 1282 expires = jiffies + cyz_polling_cycle;
@@ -1824,13 +1292,12 @@ static void cyz_poll(unsigned long arg)
1824/* This is called whenever a port becomes active; 1292/* This is called whenever a port becomes active;
1825 interrupts are enabled and DTR & RTS are turned on. 1293 interrupts are enabled and DTR & RTS are turned on.
1826 */ 1294 */
1827static int startup(struct cyclades_port *info) 1295static int cy_startup(struct cyclades_port *info, struct tty_struct *tty)
1828{ 1296{
1829 struct cyclades_card *card; 1297 struct cyclades_card *card;
1830 unsigned long flags; 1298 unsigned long flags;
1831 int retval = 0; 1299 int retval = 0;
1832 void __iomem *base_addr; 1300 int channel;
1833 int chip, channel, index;
1834 unsigned long page; 1301 unsigned long page;
1835 1302
1836 card = info->card; 1303 card = info->card;
@@ -1842,15 +1309,11 @@ static int startup(struct cyclades_port *info)
1842 1309
1843 spin_lock_irqsave(&card->card_lock, flags); 1310 spin_lock_irqsave(&card->card_lock, flags);
1844 1311
1845 if (info->port.flags & ASYNC_INITIALIZED) { 1312 if (info->port.flags & ASYNC_INITIALIZED)
1846 free_page(page);
1847 goto errout; 1313 goto errout;
1848 }
1849 1314
1850 if (!info->type) { 1315 if (!info->type) {
1851 if (info->port.tty) 1316 set_bit(TTY_IO_ERROR, &tty->flags);
1852 set_bit(TTY_IO_ERROR, &info->port.tty->flags);
1853 free_page(page);
1854 goto errout; 1317 goto errout;
1855 } 1318 }
1856 1319
@@ -1861,96 +1324,53 @@ static int startup(struct cyclades_port *info)
1861 1324
1862 spin_unlock_irqrestore(&card->card_lock, flags); 1325 spin_unlock_irqrestore(&card->card_lock, flags);
1863 1326
1864 set_line_char(info); 1327 cy_set_line_char(info, tty);
1865 1328
1866 if (!cy_is_Z(card)) { 1329 if (!cy_is_Z(card)) {
1867 chip = channel >> 2;
1868 channel &= 0x03; 1330 channel &= 0x03;
1869 index = card->bus_index;
1870 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
1871 1331
1872#ifdef CY_DEBUG_OPEN
1873 printk(KERN_DEBUG "cyc startup card %d, chip %d, channel %d, "
1874 "base_addr %p\n",
1875 card, chip, channel, base_addr);
1876#endif
1877 spin_lock_irqsave(&card->card_lock, flags); 1332 spin_lock_irqsave(&card->card_lock, flags);
1878 1333
1879 cy_writeb(base_addr + (CyCAR << index), (u_char) channel); 1334 cyy_writeb(info, CyCAR, channel);
1880 1335
1881 cy_writeb(base_addr + (CyRTPR << index), 1336 cyy_writeb(info, CyRTPR,
1882 (info->default_timeout ? info->default_timeout : 0x02)); 1337 (info->default_timeout ? info->default_timeout : 0x02));
1883 /* 10ms rx timeout */ 1338 /* 10ms rx timeout */
1884 1339
1885 cyy_issue_cmd(base_addr, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR, 1340 cyy_issue_cmd(info, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR);
1886 index);
1887
1888 cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
1889 cy_writeb(base_addr + (CyMSVR1 << index), CyRTS);
1890 cy_writeb(base_addr + (CyMSVR2 << index), CyDTR);
1891
1892#ifdef CY_DEBUG_DTR
1893 printk(KERN_DEBUG "cyc:startup raising DTR\n");
1894 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
1895 readb(base_addr + (CyMSVR1 << index)),
1896 readb(base_addr + (CyMSVR2 << index)));
1897#endif
1898
1899 cy_writeb(base_addr + (CySRER << index),
1900 readb(base_addr + (CySRER << index)) | CyRxData);
1901 info->port.flags |= ASYNC_INITIALIZED;
1902
1903 if (info->port.tty)
1904 clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
1905 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1906 info->breakon = info->breakoff = 0;
1907 memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
1908 info->idle_stats.in_use =
1909 info->idle_stats.recv_idle =
1910 info->idle_stats.xmit_idle = jiffies;
1911 1341
1912 spin_unlock_irqrestore(&card->card_lock, flags); 1342 cyy_change_rts_dtr(info, TIOCM_RTS | TIOCM_DTR, 0);
1913 1343
1344 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyRxData);
1914 } else { 1345 } else {
1915 struct FIRM_ID __iomem *firm_id; 1346 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
1916 struct ZFW_CTRL __iomem *zfw_ctrl;
1917 struct BOARD_CTRL __iomem *board_ctrl;
1918 struct CH_CTRL __iomem *ch_ctrl;
1919 1347
1920 base_addr = card->base_addr;
1921
1922 firm_id = base_addr + ID_ADDRESS;
1923 if (!cyz_is_loaded(card)) 1348 if (!cyz_is_loaded(card))
1924 return -ENODEV; 1349 return -ENODEV;
1925 1350
1926 zfw_ctrl = card->base_addr +
1927 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
1928 board_ctrl = &zfw_ctrl->board_ctrl;
1929 ch_ctrl = zfw_ctrl->ch_ctrl;
1930
1931#ifdef CY_DEBUG_OPEN 1351#ifdef CY_DEBUG_OPEN
1932 printk(KERN_DEBUG "cyc startup Z card %d, channel %d, " 1352 printk(KERN_DEBUG "cyc startup Z card %d, channel %d, "
1933 "base_addr %p\n", card, channel, base_addr); 1353 "base_addr %p\n", card, channel, card->base_addr);
1934#endif 1354#endif
1935 spin_lock_irqsave(&card->card_lock, flags); 1355 spin_lock_irqsave(&card->card_lock, flags);
1936 1356
1937 cy_writel(&ch_ctrl[channel].op_mode, C_CH_ENABLE); 1357 cy_writel(&ch_ctrl->op_mode, C_CH_ENABLE);
1938#ifdef Z_WAKE 1358#ifdef Z_WAKE
1939#ifdef CONFIG_CYZ_INTR 1359#ifdef CONFIG_CYZ_INTR
1940 cy_writel(&ch_ctrl[channel].intr_enable, 1360 cy_writel(&ch_ctrl->intr_enable,
1941 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM | 1361 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1942 C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD); 1362 C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
1943#else 1363#else
1944 cy_writel(&ch_ctrl[channel].intr_enable, 1364 cy_writel(&ch_ctrl->intr_enable,
1945 C_IN_IOCTLW | C_IN_MDCD); 1365 C_IN_IOCTLW | C_IN_MDCD);
1946#endif /* CONFIG_CYZ_INTR */ 1366#endif /* CONFIG_CYZ_INTR */
1947#else 1367#else
1948#ifdef CONFIG_CYZ_INTR 1368#ifdef CONFIG_CYZ_INTR
1949 cy_writel(&ch_ctrl[channel].intr_enable, 1369 cy_writel(&ch_ctrl->intr_enable,
1950 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM | 1370 C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
1951 C_IN_RXNNDT | C_IN_MDCD); 1371 C_IN_RXNNDT | C_IN_MDCD);
1952#else 1372#else
1953 cy_writel(&ch_ctrl[channel].intr_enable, C_IN_MDCD); 1373 cy_writel(&ch_ctrl->intr_enable, C_IN_MDCD);
1954#endif /* CONFIG_CYZ_INTR */ 1374#endif /* CONFIG_CYZ_INTR */
1955#endif /* Z_WAKE */ 1375#endif /* Z_WAKE */
1956 1376
@@ -1969,32 +1389,22 @@ static int startup(struct cyclades_port *info)
1969 1389
1970 /* set timeout !!! */ 1390 /* set timeout !!! */
1971 /* set RTS and DTR !!! */ 1391 /* set RTS and DTR !!! */
1972 cy_writel(&ch_ctrl[channel].rs_control, 1392 tty_port_raise_dtr_rts(&info->port);
1973 readl(&ch_ctrl[channel].rs_control) | C_RS_RTS |
1974 C_RS_DTR);
1975 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
1976 if (retval != 0) {
1977 printk(KERN_ERR "cyc:startup(3) retval on ttyC%d was "
1978 "%x\n", info->line, retval);
1979 }
1980#ifdef CY_DEBUG_DTR
1981 printk(KERN_DEBUG "cyc:startup raising Z DTR\n");
1982#endif
1983 1393
1984 /* enable send, recv, modem !!! */ 1394 /* enable send, recv, modem !!! */
1395 }
1985 1396
1986 info->port.flags |= ASYNC_INITIALIZED; 1397 info->port.flags |= ASYNC_INITIALIZED;
1987 if (info->port.tty)
1988 clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
1989 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1990 info->breakon = info->breakoff = 0;
1991 memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
1992 info->idle_stats.in_use =
1993 info->idle_stats.recv_idle =
1994 info->idle_stats.xmit_idle = jiffies;
1995 1398
1996 spin_unlock_irqrestore(&card->card_lock, flags); 1399 clear_bit(TTY_IO_ERROR, &tty->flags);
1997 } 1400 info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1401 info->breakon = info->breakoff = 0;
1402 memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
1403 info->idle_stats.in_use =
1404 info->idle_stats.recv_idle =
1405 info->idle_stats.xmit_idle = jiffies;
1406
1407 spin_unlock_irqrestore(&card->card_lock, flags);
1998 1408
1999#ifdef CY_DEBUG_OPEN 1409#ifdef CY_DEBUG_OPEN
2000 printk(KERN_DEBUG "cyc startup done\n"); 1410 printk(KERN_DEBUG "cyc startup done\n");
@@ -2003,28 +1413,20 @@ static int startup(struct cyclades_port *info)
2003 1413
2004errout: 1414errout:
2005 spin_unlock_irqrestore(&card->card_lock, flags); 1415 spin_unlock_irqrestore(&card->card_lock, flags);
1416 free_page(page);
2006 return retval; 1417 return retval;
2007} /* startup */ 1418} /* startup */
2008 1419
2009static void start_xmit(struct cyclades_port *info) 1420static void start_xmit(struct cyclades_port *info)
2010{ 1421{
2011 struct cyclades_card *card; 1422 struct cyclades_card *card = info->card;
2012 unsigned long flags; 1423 unsigned long flags;
2013 void __iomem *base_addr; 1424 int channel = info->line - card->first_line;
2014 int chip, channel, index;
2015 1425
2016 card = info->card;
2017 channel = info->line - card->first_line;
2018 if (!cy_is_Z(card)) { 1426 if (!cy_is_Z(card)) {
2019 chip = channel >> 2;
2020 channel &= 0x03;
2021 index = card->bus_index;
2022 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
2023
2024 spin_lock_irqsave(&card->card_lock, flags); 1427 spin_lock_irqsave(&card->card_lock, flags);
2025 cy_writeb(base_addr + (CyCAR << index), channel); 1428 cyy_writeb(info, CyCAR, channel & 0x03);
2026 cy_writeb(base_addr + (CySRER << index), 1429 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
2027 readb(base_addr + (CySRER << index)) | CyTxRdy);
2028 spin_unlock_irqrestore(&card->card_lock, flags); 1430 spin_unlock_irqrestore(&card->card_lock, flags);
2029 } else { 1431 } else {
2030#ifdef CONFIG_CYZ_INTR 1432#ifdef CONFIG_CYZ_INTR
@@ -2047,12 +1449,11 @@ static void start_xmit(struct cyclades_port *info)
2047 * This routine shuts down a serial port; interrupts are disabled, 1449 * This routine shuts down a serial port; interrupts are disabled,
2048 * and DTR is dropped if the hangup on close termio flag is on. 1450 * and DTR is dropped if the hangup on close termio flag is on.
2049 */ 1451 */
2050static void shutdown(struct cyclades_port *info) 1452static void cy_shutdown(struct cyclades_port *info, struct tty_struct *tty)
2051{ 1453{
2052 struct cyclades_card *card; 1454 struct cyclades_card *card;
2053 unsigned long flags; 1455 unsigned long flags;
2054 void __iomem *base_addr; 1456 int channel;
2055 int chip, channel, index;
2056 1457
2057 if (!(info->port.flags & ASYNC_INITIALIZED)) 1458 if (!(info->port.flags & ASYNC_INITIALIZED))
2058 return; 1459 return;
@@ -2060,21 +1461,10 @@ static void shutdown(struct cyclades_port *info)
2060 card = info->card; 1461 card = info->card;
2061 channel = info->line - card->first_line; 1462 channel = info->line - card->first_line;
2062 if (!cy_is_Z(card)) { 1463 if (!cy_is_Z(card)) {
2063 chip = channel >> 2;
2064 channel &= 0x03;
2065 index = card->bus_index;
2066 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
2067
2068#ifdef CY_DEBUG_OPEN
2069 printk(KERN_DEBUG "cyc shutdown Y card %d, chip %d, "
2070 "channel %d, base_addr %p\n",
2071 card, chip, channel, base_addr);
2072#endif
2073
2074 spin_lock_irqsave(&card->card_lock, flags); 1464 spin_lock_irqsave(&card->card_lock, flags);
2075 1465
2076 /* Clear delta_msr_wait queue to avoid mem leaks. */ 1466 /* Clear delta_msr_wait queue to avoid mem leaks. */
2077 wake_up_interruptible(&info->delta_msr_wait); 1467 wake_up_interruptible(&info->port.delta_msr_wait);
2078 1468
2079 if (info->port.xmit_buf) { 1469 if (info->port.xmit_buf) {
2080 unsigned char *temp; 1470 unsigned char *temp;
@@ -2082,47 +1472,25 @@ static void shutdown(struct cyclades_port *info)
2082 info->port.xmit_buf = NULL; 1472 info->port.xmit_buf = NULL;
2083 free_page((unsigned long)temp); 1473 free_page((unsigned long)temp);
2084 } 1474 }
2085 cy_writeb(base_addr + (CyCAR << index), (u_char) channel); 1475 if (tty->termios->c_cflag & HUPCL)
2086 if (!info->port.tty || (info->port.tty->termios->c_cflag & HUPCL)) { 1476 cyy_change_rts_dtr(info, 0, TIOCM_RTS | TIOCM_DTR);
2087 cy_writeb(base_addr + (CyMSVR1 << index), ~CyRTS); 1477
2088 cy_writeb(base_addr + (CyMSVR2 << index), ~CyDTR); 1478 cyy_issue_cmd(info, CyCHAN_CTL | CyDIS_RCVR);
2089#ifdef CY_DEBUG_DTR
2090 printk(KERN_DEBUG "cyc shutdown dropping DTR\n");
2091 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
2092 readb(base_addr + (CyMSVR1 << index)),
2093 readb(base_addr + (CyMSVR2 << index)));
2094#endif
2095 }
2096 cyy_issue_cmd(base_addr, CyCHAN_CTL | CyDIS_RCVR, index);
2097 /* it may be appropriate to clear _XMIT at 1479 /* it may be appropriate to clear _XMIT at
2098 some later date (after testing)!!! */ 1480 some later date (after testing)!!! */
2099 1481
2100 if (info->port.tty) 1482 set_bit(TTY_IO_ERROR, &tty->flags);
2101 set_bit(TTY_IO_ERROR, &info->port.tty->flags);
2102 info->port.flags &= ~ASYNC_INITIALIZED; 1483 info->port.flags &= ~ASYNC_INITIALIZED;
2103 spin_unlock_irqrestore(&card->card_lock, flags); 1484 spin_unlock_irqrestore(&card->card_lock, flags);
2104 } else { 1485 } else {
2105 struct FIRM_ID __iomem *firm_id;
2106 struct ZFW_CTRL __iomem *zfw_ctrl;
2107 struct BOARD_CTRL __iomem *board_ctrl;
2108 struct CH_CTRL __iomem *ch_ctrl;
2109 int retval;
2110
2111 base_addr = card->base_addr;
2112#ifdef CY_DEBUG_OPEN 1486#ifdef CY_DEBUG_OPEN
2113 printk(KERN_DEBUG "cyc shutdown Z card %d, channel %d, " 1487 printk(KERN_DEBUG "cyc shutdown Z card %d, channel %d, "
2114 "base_addr %p\n", card, channel, base_addr); 1488 "base_addr %p\n", card, channel, card->base_addr);
2115#endif 1489#endif
2116 1490
2117 firm_id = base_addr + ID_ADDRESS;
2118 if (!cyz_is_loaded(card)) 1491 if (!cyz_is_loaded(card))
2119 return; 1492 return;
2120 1493
2121 zfw_ctrl = card->base_addr +
2122 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
2123 board_ctrl = &zfw_ctrl->board_ctrl;
2124 ch_ctrl = zfw_ctrl->ch_ctrl;
2125
2126 spin_lock_irqsave(&card->card_lock, flags); 1494 spin_lock_irqsave(&card->card_lock, flags);
2127 1495
2128 if (info->port.xmit_buf) { 1496 if (info->port.xmit_buf) {
@@ -2132,23 +1500,10 @@ static void shutdown(struct cyclades_port *info)
2132 free_page((unsigned long)temp); 1500 free_page((unsigned long)temp);
2133 } 1501 }
2134 1502
2135 if (!info->port.tty || (info->port.tty->termios->c_cflag & HUPCL)) { 1503 if (tty->termios->c_cflag & HUPCL)
2136 cy_writel(&ch_ctrl[channel].rs_control, 1504 tty_port_lower_dtr_rts(&info->port);
2137 (__u32)(readl(&ch_ctrl[channel].rs_control) &
2138 ~(C_RS_RTS | C_RS_DTR)));
2139 retval = cyz_issue_cmd(info->card, channel,
2140 C_CM_IOCTLM, 0L);
2141 if (retval != 0) {
2142 printk(KERN_ERR"cyc:shutdown retval on ttyC%d "
2143 "was %x\n", info->line, retval);
2144 }
2145#ifdef CY_DEBUG_DTR
2146 printk(KERN_DEBUG "cyc:shutdown dropping Z DTR\n");
2147#endif
2148 }
2149 1505
2150 if (info->port.tty) 1506 set_bit(TTY_IO_ERROR, &tty->flags);
2151 set_bit(TTY_IO_ERROR, &info->port.tty->flags);
2152 info->port.flags &= ~ASYNC_INITIALIZED; 1507 info->port.flags &= ~ASYNC_INITIALIZED;
2153 1508
2154 spin_unlock_irqrestore(&card->card_lock, flags); 1509 spin_unlock_irqrestore(&card->card_lock, flags);
@@ -2165,199 +1520,6 @@ static void shutdown(struct cyclades_port *info)
2165 * ------------------------------------------------------------ 1520 * ------------------------------------------------------------
2166 */ 1521 */
2167 1522
2168static int
2169block_til_ready(struct tty_struct *tty, struct file *filp,
2170 struct cyclades_port *info)
2171{
2172 DECLARE_WAITQUEUE(wait, current);
2173 struct cyclades_card *cinfo;
2174 unsigned long flags;
2175 int chip, channel, index;
2176 int retval;
2177 void __iomem *base_addr;
2178
2179 cinfo = info->card;
2180 channel = info->line - cinfo->first_line;
2181
2182 /*
2183 * If the device is in the middle of being closed, then block
2184 * until it's done, and then try again.
2185 */
2186 if (tty_hung_up_p(filp) || (info->port.flags & ASYNC_CLOSING)) {
2187 wait_event_interruptible(info->port.close_wait,
2188 !(info->port.flags & ASYNC_CLOSING));
2189 return (info->port.flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
2190 }
2191
2192 /*
2193 * If non-blocking mode is set, then make the check up front
2194 * and then exit.
2195 */
2196 if ((filp->f_flags & O_NONBLOCK) ||
2197 (tty->flags & (1 << TTY_IO_ERROR))) {
2198 info->port.flags |= ASYNC_NORMAL_ACTIVE;
2199 return 0;
2200 }
2201
2202 /*
2203 * Block waiting for the carrier detect and the line to become
2204 * free (i.e., not in use by the callout). While we are in
2205 * this loop, info->port.count is dropped by one, so that
2206 * cy_close() knows when to free things. We restore it upon
2207 * exit, either normal or abnormal.
2208 */
2209 retval = 0;
2210 add_wait_queue(&info->port.open_wait, &wait);
2211#ifdef CY_DEBUG_OPEN
2212 printk(KERN_DEBUG "cyc block_til_ready before block: ttyC%d, "
2213 "count = %d\n", info->line, info->port.count);
2214#endif
2215 spin_lock_irqsave(&cinfo->card_lock, flags);
2216 if (!tty_hung_up_p(filp))
2217 info->port.count--;
2218 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2219#ifdef CY_DEBUG_COUNT
2220 printk(KERN_DEBUG "cyc block_til_ready: (%d): decrementing count to "
2221 "%d\n", current->pid, info->port.count);
2222#endif
2223 info->port.blocked_open++;
2224
2225 if (!cy_is_Z(cinfo)) {
2226 chip = channel >> 2;
2227 channel &= 0x03;
2228 index = cinfo->bus_index;
2229 base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
2230
2231 while (1) {
2232 spin_lock_irqsave(&cinfo->card_lock, flags);
2233 if ((tty->termios->c_cflag & CBAUD)) {
2234 cy_writeb(base_addr + (CyCAR << index),
2235 (u_char) channel);
2236 cy_writeb(base_addr + (CyMSVR1 << index),
2237 CyRTS);
2238 cy_writeb(base_addr + (CyMSVR2 << index),
2239 CyDTR);
2240#ifdef CY_DEBUG_DTR
2241 printk(KERN_DEBUG "cyc:block_til_ready raising "
2242 "DTR\n");
2243 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
2244 readb(base_addr + (CyMSVR1 << index)),
2245 readb(base_addr + (CyMSVR2 << index)));
2246#endif
2247 }
2248 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2249
2250 set_current_state(TASK_INTERRUPTIBLE);
2251 if (tty_hung_up_p(filp) ||
2252 !(info->port.flags & ASYNC_INITIALIZED)) {
2253 retval = ((info->port.flags & ASYNC_HUP_NOTIFY) ?
2254 -EAGAIN : -ERESTARTSYS);
2255 break;
2256 }
2257
2258 spin_lock_irqsave(&cinfo->card_lock, flags);
2259 cy_writeb(base_addr + (CyCAR << index),
2260 (u_char) channel);
2261 if (!(info->port.flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
2262 (readb(base_addr +
2263 (CyMSVR1 << index)) & CyDCD))) {
2264 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2265 break;
2266 }
2267 spin_unlock_irqrestore(&cinfo->card_lock, flags);
2268
2269 if (signal_pending(current)) {
2270 retval = -ERESTARTSYS;
2271 break;
2272 }
2273#ifdef CY_DEBUG_OPEN
2274 printk(KERN_DEBUG "cyc block_til_ready blocking: "
2275 "ttyC%d, count = %d\n",
2276 info->line, info->port.count);
2277#endif
2278 schedule();
2279 }
2280 } else {
2281 struct FIRM_ID __iomem *firm_id;
2282 struct ZFW_CTRL __iomem *zfw_ctrl;
2283 struct BOARD_CTRL __iomem *board_ctrl;
2284 struct CH_CTRL __iomem *ch_ctrl;
2285
2286 base_addr = cinfo->base_addr;
2287 firm_id = base_addr + ID_ADDRESS;
2288 if (!cyz_is_loaded(cinfo)) {
2289 __set_current_state(TASK_RUNNING);
2290 remove_wait_queue(&info->port.open_wait, &wait);
2291 return -EINVAL;
2292 }
2293
2294 zfw_ctrl = base_addr + (readl(&firm_id->zfwctrl_addr)
2295 & 0xfffff);
2296 board_ctrl = &zfw_ctrl->board_ctrl;
2297 ch_ctrl = zfw_ctrl->ch_ctrl;
2298
2299 while (1) {
2300 if ((tty->termios->c_cflag & CBAUD)) {
2301 cy_writel(&ch_ctrl[channel].rs_control,
2302 readl(&ch_ctrl[channel].rs_control) |
2303 C_RS_RTS | C_RS_DTR);
2304 retval = cyz_issue_cmd(cinfo,
2305 channel, C_CM_IOCTLM, 0L);
2306 if (retval != 0) {
2307 printk(KERN_ERR "cyc:block_til_ready "
2308 "retval on ttyC%d was %x\n",
2309 info->line, retval);
2310 }
2311#ifdef CY_DEBUG_DTR
2312 printk(KERN_DEBUG "cyc:block_til_ready raising "
2313 "Z DTR\n");
2314#endif
2315 }
2316
2317 set_current_state(TASK_INTERRUPTIBLE);
2318 if (tty_hung_up_p(filp) ||
2319 !(info->port.flags & ASYNC_INITIALIZED)) {
2320 retval = ((info->port.flags & ASYNC_HUP_NOTIFY) ?
2321 -EAGAIN : -ERESTARTSYS);
2322 break;
2323 }
2324 if (!(info->port.flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
2325 (readl(&ch_ctrl[channel].rs_status) &
2326 C_RS_DCD))) {
2327 break;
2328 }
2329 if (signal_pending(current)) {
2330 retval = -ERESTARTSYS;
2331 break;
2332 }
2333#ifdef CY_DEBUG_OPEN
2334 printk(KERN_DEBUG "cyc block_til_ready blocking: "
2335 "ttyC%d, count = %d\n",
2336 info->line, info->port.count);
2337#endif
2338 schedule();
2339 }
2340 }
2341 __set_current_state(TASK_RUNNING);
2342 remove_wait_queue(&info->port.open_wait, &wait);
2343 if (!tty_hung_up_p(filp)) {
2344 info->port.count++;
2345#ifdef CY_DEBUG_COUNT
2346 printk(KERN_DEBUG "cyc:block_til_ready (%d): incrementing "
2347 "count to %d\n", current->pid, info->port.count);
2348#endif
2349 }
2350 info->port.blocked_open--;
2351#ifdef CY_DEBUG_OPEN
2352 printk(KERN_DEBUG "cyc:block_til_ready after blocking: ttyC%d, "
2353 "count = %d\n", info->line, info->port.count);
2354#endif
2355 if (retval)
2356 return retval;
2357 info->port.flags |= ASYNC_NORMAL_ACTIVE;
2358 return 0;
2359} /* block_til_ready */
2360
2361/* 1523/*
2362 * This routine is called whenever a serial port is opened. It 1524 * This routine is called whenever a serial port is opened. It
2363 * performs the serial-specific initialization for the tty structure. 1525 * performs the serial-specific initialization for the tty structure.
@@ -2436,7 +1598,6 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
2436 printk(KERN_DEBUG "cyc:cy_open ttyC%d\n", info->line); 1598 printk(KERN_DEBUG "cyc:cy_open ttyC%d\n", info->line);
2437#endif 1599#endif
2438 tty->driver_data = info; 1600 tty->driver_data = info;
2439 info->port.tty = tty;
2440 if (serial_paranoia_check(info, tty->name, "cy_open")) 1601 if (serial_paranoia_check(info, tty->name, "cy_open"))
2441 return -ENODEV; 1602 return -ENODEV;
2442 1603
@@ -2462,11 +1623,11 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
2462 /* 1623 /*
2463 * Start up serial port 1624 * Start up serial port
2464 */ 1625 */
2465 retval = startup(info); 1626 retval = cy_startup(info, tty);
2466 if (retval) 1627 if (retval)
2467 return retval; 1628 return retval;
2468 1629
2469 retval = block_til_ready(tty, filp, info); 1630 retval = tty_port_block_til_ready(&info->port, tty, filp);
2470 if (retval) { 1631 if (retval) {
2471#ifdef CY_DEBUG_OPEN 1632#ifdef CY_DEBUG_OPEN
2472 printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready " 1633 printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready "
@@ -2476,6 +1637,7 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
2476 } 1637 }
2477 1638
2478 info->throttle = 0; 1639 info->throttle = 0;
1640 tty_port_tty_set(&info->port, tty);
2479 1641
2480#ifdef CY_DEBUG_OPEN 1642#ifdef CY_DEBUG_OPEN
2481 printk(KERN_DEBUG "cyc:cy_open done\n"); 1643 printk(KERN_DEBUG "cyc:cy_open done\n");
@@ -2490,8 +1652,6 @@ static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
2490{ 1652{
2491 struct cyclades_card *card; 1653 struct cyclades_card *card;
2492 struct cyclades_port *info = tty->driver_data; 1654 struct cyclades_port *info = tty->driver_data;
2493 void __iomem *base_addr;
2494 int chip, channel, index;
2495 unsigned long orig_jiffies; 1655 unsigned long orig_jiffies;
2496 int char_time; 1656 int char_time;
2497 1657
@@ -2535,13 +1695,8 @@ static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
2535 timeout, char_time, jiffies); 1695 timeout, char_time, jiffies);
2536#endif 1696#endif
2537 card = info->card; 1697 card = info->card;
2538 channel = (info->line) - (card->first_line);
2539 if (!cy_is_Z(card)) { 1698 if (!cy_is_Z(card)) {
2540 chip = channel >> 2; 1699 while (cyy_readb(info, CySRER) & CyTxRdy) {
2541 channel &= 0x03;
2542 index = card->bus_index;
2543 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
2544 while (readb(base_addr + (CySRER << index)) & CyTxRdy) {
2545#ifdef CY_DEBUG_WAIT_UNTIL_SENT 1700#ifdef CY_DEBUG_WAIT_UNTIL_SENT
2546 printk(KERN_DEBUG "Not clean (jiff=%lu)...", jiffies); 1701 printk(KERN_DEBUG "Not clean (jiff=%lu)...", jiffies);
2547#endif 1702#endif
@@ -2595,103 +1750,37 @@ static void cy_flush_buffer(struct tty_struct *tty)
2595} /* cy_flush_buffer */ 1750} /* cy_flush_buffer */
2596 1751
2597 1752
2598/* 1753static void cy_do_close(struct tty_port *port)
2599 * This routine is called when a particular tty device is closed.
2600 */
2601static void cy_close(struct tty_struct *tty, struct file *filp)
2602{ 1754{
2603 struct cyclades_port *info = tty->driver_data; 1755 struct cyclades_port *info = container_of(port, struct cyclades_port,
1756 port);
2604 struct cyclades_card *card; 1757 struct cyclades_card *card;
2605 unsigned long flags; 1758 unsigned long flags;
2606 1759 int channel;
2607#ifdef CY_DEBUG_OTHER
2608 printk(KERN_DEBUG "cyc:cy_close ttyC%d\n", info->line);
2609#endif
2610
2611 if (!info || serial_paranoia_check(info, tty->name, "cy_close"))
2612 return;
2613 1760
2614 card = info->card; 1761 card = info->card;
2615 1762 channel = info->line - card->first_line;
2616 spin_lock_irqsave(&card->card_lock, flags);
2617 /* If the TTY is being hung up, nothing to do */
2618 if (tty_hung_up_p(filp)) {
2619 spin_unlock_irqrestore(&card->card_lock, flags);
2620 return;
2621 }
2622#ifdef CY_DEBUG_OPEN
2623 printk(KERN_DEBUG "cyc:cy_close ttyC%d, count = %d\n", info->line,
2624 info->port.count);
2625#endif
2626 if ((tty->count == 1) && (info->port.count != 1)) {
2627 /*
2628 * Uh, oh. tty->count is 1, which means that the tty
2629 * structure will be freed. Info->count should always
2630 * be one in these conditions. If it's greater than
2631 * one, we've got real problems, since it means the
2632 * serial port won't be shutdown.
2633 */
2634 printk(KERN_ERR "cyc:cy_close: bad serial port count; "
2635 "tty->count is 1, info->port.count is %d\n", info->port.count);
2636 info->port.count = 1;
2637 }
2638#ifdef CY_DEBUG_COUNT
2639 printk(KERN_DEBUG "cyc:cy_close at (%d): decrementing count to %d\n",
2640 current->pid, info->port.count - 1);
2641#endif
2642 if (--info->port.count < 0) {
2643#ifdef CY_DEBUG_COUNT
2644 printk(KERN_DEBUG "cyc:cyc_close setting count to 0\n");
2645#endif
2646 info->port.count = 0;
2647 }
2648 if (info->port.count) {
2649 spin_unlock_irqrestore(&card->card_lock, flags);
2650 return;
2651 }
2652 info->port.flags |= ASYNC_CLOSING;
2653
2654 /*
2655 * Now we wait for the transmit buffer to clear; and we notify
2656 * the line discipline to only process XON/XOFF characters.
2657 */
2658 tty->closing = 1;
2659 spin_unlock_irqrestore(&card->card_lock, flags);
2660 if (info->port.closing_wait != CY_CLOSING_WAIT_NONE)
2661 tty_wait_until_sent(tty, info->port.closing_wait);
2662
2663 spin_lock_irqsave(&card->card_lock, flags); 1763 spin_lock_irqsave(&card->card_lock, flags);
2664 1764
2665 if (!cy_is_Z(card)) { 1765 if (!cy_is_Z(card)) {
2666 int channel = info->line - card->first_line;
2667 int index = card->bus_index;
2668 void __iomem *base_addr = card->base_addr +
2669 (cy_chip_offset[channel >> 2] << index);
2670 /* Stop accepting input */ 1766 /* Stop accepting input */
2671 channel &= 0x03; 1767 cyy_writeb(info, CyCAR, channel & 0x03);
2672 cy_writeb(base_addr + (CyCAR << index), (u_char) channel); 1768 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyRxData);
2673 cy_writeb(base_addr + (CySRER << index),
2674 readb(base_addr + (CySRER << index)) & ~CyRxData);
2675 if (info->port.flags & ASYNC_INITIALIZED) { 1769 if (info->port.flags & ASYNC_INITIALIZED) {
2676 /* Waiting for on-board buffers to be empty before 1770 /* Waiting for on-board buffers to be empty before
2677 closing the port */ 1771 closing the port */
2678 spin_unlock_irqrestore(&card->card_lock, flags); 1772 spin_unlock_irqrestore(&card->card_lock, flags);
2679 cy_wait_until_sent(tty, info->timeout); 1773 cy_wait_until_sent(port->tty, info->timeout);
2680 spin_lock_irqsave(&card->card_lock, flags); 1774 spin_lock_irqsave(&card->card_lock, flags);
2681 } 1775 }
2682 } else { 1776 } else {
2683#ifdef Z_WAKE 1777#ifdef Z_WAKE
2684 /* Waiting for on-board buffers to be empty before closing 1778 /* Waiting for on-board buffers to be empty before closing
2685 the port */ 1779 the port */
2686 void __iomem *base_addr = card->base_addr; 1780 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2687 struct FIRM_ID __iomem *firm_id = base_addr + ID_ADDRESS;
2688 struct ZFW_CTRL __iomem *zfw_ctrl =
2689 base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
2690 struct CH_CTRL __iomem *ch_ctrl = zfw_ctrl->ch_ctrl;
2691 int channel = info->line - card->first_line;
2692 int retval; 1781 int retval;
2693 1782
2694 if (readl(&ch_ctrl[channel].flow_status) != C_FS_TXIDLE) { 1783 if (readl(&ch_ctrl->flow_status) != C_FS_TXIDLE) {
2695 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L); 1784 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L);
2696 if (retval != 0) { 1785 if (retval != 0) {
2697 printk(KERN_DEBUG "cyc:cy_close retval on " 1786 printk(KERN_DEBUG "cyc:cy_close retval on "
@@ -2703,32 +1792,19 @@ static void cy_close(struct tty_struct *tty, struct file *filp)
2703 } 1792 }
2704#endif 1793#endif
2705 } 1794 }
2706
2707 spin_unlock_irqrestore(&card->card_lock, flags); 1795 spin_unlock_irqrestore(&card->card_lock, flags);
2708 shutdown(info); 1796 cy_shutdown(info, port->tty);
2709 cy_flush_buffer(tty); 1797}
2710 tty_ldisc_flush(tty);
2711 spin_lock_irqsave(&card->card_lock, flags);
2712
2713 tty->closing = 0;
2714 info->port.tty = NULL;
2715 if (info->port.blocked_open) {
2716 spin_unlock_irqrestore(&card->card_lock, flags);
2717 if (info->port.close_delay) {
2718 msleep_interruptible(jiffies_to_msecs
2719 (info->port.close_delay));
2720 }
2721 wake_up_interruptible(&info->port.open_wait);
2722 spin_lock_irqsave(&card->card_lock, flags);
2723 }
2724 info->port.flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
2725 wake_up_interruptible(&info->port.close_wait);
2726
2727#ifdef CY_DEBUG_OTHER
2728 printk(KERN_DEBUG "cyc:cy_close done\n");
2729#endif
2730 1798
2731 spin_unlock_irqrestore(&card->card_lock, flags); 1799/*
1800 * This routine is called when a particular tty device is closed.
1801 */
1802static void cy_close(struct tty_struct *tty, struct file *filp)
1803{
1804 struct cyclades_port *info = tty->driver_data;
1805 if (!info || serial_paranoia_check(info, tty->name, "cy_close"))
1806 return;
1807 tty_port_close(&info->port, tty, filp);
2732} /* cy_close */ 1808} /* cy_close */
2733 1809
2734/* This routine gets called when tty_write has put something into 1810/* This routine gets called when tty_write has put something into
@@ -2871,18 +1947,13 @@ static int cy_write_room(struct tty_struct *tty)
2871 1947
2872static int cy_chars_in_buffer(struct tty_struct *tty) 1948static int cy_chars_in_buffer(struct tty_struct *tty)
2873{ 1949{
2874 struct cyclades_card *card;
2875 struct cyclades_port *info = tty->driver_data; 1950 struct cyclades_port *info = tty->driver_data;
2876 int channel;
2877 1951
2878 if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer")) 1952 if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
2879 return 0; 1953 return 0;
2880 1954
2881 card = info->card;
2882 channel = (info->line) - (card->first_line);
2883
2884#ifdef Z_EXT_CHARS_IN_BUFFER 1955#ifdef Z_EXT_CHARS_IN_BUFFER
2885 if (!cy_is_Z(card)) { 1956 if (!cy_is_Z(info->card)) {
2886#endif /* Z_EXT_CHARS_IN_BUFFER */ 1957#endif /* Z_EXT_CHARS_IN_BUFFER */
2887#ifdef CY_DEBUG_IO 1958#ifdef CY_DEBUG_IO
2888 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n", 1959 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
@@ -2891,20 +1962,11 @@ static int cy_chars_in_buffer(struct tty_struct *tty)
2891 return info->xmit_cnt; 1962 return info->xmit_cnt;
2892#ifdef Z_EXT_CHARS_IN_BUFFER 1963#ifdef Z_EXT_CHARS_IN_BUFFER
2893 } else { 1964 } else {
2894 static struct FIRM_ID *firm_id; 1965 struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
2895 static struct ZFW_CTRL *zfw_ctrl;
2896 static struct CH_CTRL *ch_ctrl;
2897 static struct BUF_CTRL *buf_ctrl;
2898 int char_count; 1966 int char_count;
2899 __u32 tx_put, tx_get, tx_bufsize; 1967 __u32 tx_put, tx_get, tx_bufsize;
2900 1968
2901 lock_kernel(); 1969 lock_kernel();
2902 firm_id = card->base_addr + ID_ADDRESS;
2903 zfw_ctrl = card->base_addr +
2904 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
2905 ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
2906 buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
2907
2908 tx_get = readl(&buf_ctrl->tx_get); 1970 tx_get = readl(&buf_ctrl->tx_get);
2909 tx_put = readl(&buf_ctrl->tx_put); 1971 tx_put = readl(&buf_ctrl->tx_put);
2910 tx_bufsize = readl(&buf_ctrl->tx_bufsize); 1972 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
@@ -2957,48 +2019,44 @@ static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
2957 * This routine finds or computes the various line characteristics. 2019 * This routine finds or computes the various line characteristics.
2958 * It used to be called config_setup 2020 * It used to be called config_setup
2959 */ 2021 */
2960static void set_line_char(struct cyclades_port *info) 2022static void cy_set_line_char(struct cyclades_port *info, struct tty_struct *tty)
2961{ 2023{
2962 struct cyclades_card *card; 2024 struct cyclades_card *card;
2963 unsigned long flags; 2025 unsigned long flags;
2964 void __iomem *base_addr; 2026 int channel;
2965 int chip, channel, index;
2966 unsigned cflag, iflag; 2027 unsigned cflag, iflag;
2967 int baud, baud_rate = 0; 2028 int baud, baud_rate = 0;
2968 int i; 2029 int i;
2969 2030
2970 if (!info->port.tty || !info->port.tty->termios) 2031 if (!tty->termios) /* XXX can this happen at all? */
2971 return; 2032 return;
2972 2033
2973 if (info->line == -1) 2034 if (info->line == -1)
2974 return; 2035 return;
2975 2036
2976 cflag = info->port.tty->termios->c_cflag; 2037 cflag = tty->termios->c_cflag;
2977 iflag = info->port.tty->termios->c_iflag; 2038 iflag = tty->termios->c_iflag;
2978 2039
2979 /* 2040 /*
2980 * Set up the tty->alt_speed kludge 2041 * Set up the tty->alt_speed kludge
2981 */ 2042 */
2982 if (info->port.tty) { 2043 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
2983 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI) 2044 tty->alt_speed = 57600;
2984 info->port.tty->alt_speed = 57600; 2045 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
2985 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI) 2046 tty->alt_speed = 115200;
2986 info->port.tty->alt_speed = 115200; 2047 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
2987 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI) 2048 tty->alt_speed = 230400;
2988 info->port.tty->alt_speed = 230400; 2049 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
2989 if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP) 2050 tty->alt_speed = 460800;
2990 info->port.tty->alt_speed = 460800;
2991 }
2992 2051
2993 card = info->card; 2052 card = info->card;
2994 channel = info->line - card->first_line; 2053 channel = info->line - card->first_line;
2995 2054
2996 if (!cy_is_Z(card)) { 2055 if (!cy_is_Z(card)) {
2997 2056 u32 cflags;
2998 index = card->bus_index;
2999 2057
3000 /* baud rate */ 2058 /* baud rate */
3001 baud = tty_get_baud_rate(info->port.tty); 2059 baud = tty_get_baud_rate(tty);
3002 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) == 2060 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
3003 ASYNC_SPD_CUST) { 2061 ASYNC_SPD_CUST) {
3004 if (info->custom_divisor) 2062 if (info->custom_divisor)
@@ -3107,124 +2165,68 @@ static void set_line_char(struct cyclades_port *info)
3107 cable. Contact Marcio Saito for details. 2165 cable. Contact Marcio Saito for details.
3108 ***********************************************/ 2166 ***********************************************/
3109 2167
3110 chip = channel >> 2;
3111 channel &= 0x03; 2168 channel &= 0x03;
3112 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
3113 2169
3114 spin_lock_irqsave(&card->card_lock, flags); 2170 spin_lock_irqsave(&card->card_lock, flags);
3115 cy_writeb(base_addr + (CyCAR << index), (u_char) channel); 2171 cyy_writeb(info, CyCAR, channel);
3116 2172
3117 /* tx and rx baud rate */ 2173 /* tx and rx baud rate */
3118 2174
3119 cy_writeb(base_addr + (CyTCOR << index), info->tco); 2175 cyy_writeb(info, CyTCOR, info->tco);
3120 cy_writeb(base_addr + (CyTBPR << index), info->tbpr); 2176 cyy_writeb(info, CyTBPR, info->tbpr);
3121 cy_writeb(base_addr + (CyRCOR << index), info->rco); 2177 cyy_writeb(info, CyRCOR, info->rco);
3122 cy_writeb(base_addr + (CyRBPR << index), info->rbpr); 2178 cyy_writeb(info, CyRBPR, info->rbpr);
3123 2179
3124 /* set line characteristics according configuration */ 2180 /* set line characteristics according configuration */
3125 2181
3126 cy_writeb(base_addr + (CySCHR1 << index), 2182 cyy_writeb(info, CySCHR1, START_CHAR(tty));
3127 START_CHAR(info->port.tty)); 2183 cyy_writeb(info, CySCHR2, STOP_CHAR(tty));
3128 cy_writeb(base_addr + (CySCHR2 << index), STOP_CHAR(info->port.tty)); 2184 cyy_writeb(info, CyCOR1, info->cor1);
3129 cy_writeb(base_addr + (CyCOR1 << index), info->cor1); 2185 cyy_writeb(info, CyCOR2, info->cor2);
3130 cy_writeb(base_addr + (CyCOR2 << index), info->cor2); 2186 cyy_writeb(info, CyCOR3, info->cor3);
3131 cy_writeb(base_addr + (CyCOR3 << index), info->cor3); 2187 cyy_writeb(info, CyCOR4, info->cor4);
3132 cy_writeb(base_addr + (CyCOR4 << index), info->cor4); 2188 cyy_writeb(info, CyCOR5, info->cor5);
3133 cy_writeb(base_addr + (CyCOR5 << index), info->cor5);
3134 2189
3135 cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch | 2190 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
3136 CyCOR3ch, index); 2191 CyCOR3ch);
3137 2192
3138 /* !!! Is this needed? */ 2193 /* !!! Is this needed? */
3139 cy_writeb(base_addr + (CyCAR << index), (u_char) channel); 2194 cyy_writeb(info, CyCAR, channel);
3140 cy_writeb(base_addr + (CyRTPR << index), 2195 cyy_writeb(info, CyRTPR,
3141 (info->default_timeout ? info->default_timeout : 0x02)); 2196 (info->default_timeout ? info->default_timeout : 0x02));
3142 /* 10ms rx timeout */ 2197 /* 10ms rx timeout */
3143 2198
3144 if (C_CLOCAL(info->port.tty)) { 2199 cflags = CyCTS;
3145 /* without modem intr */ 2200 if (!C_CLOCAL(tty))
3146 cy_writeb(base_addr + (CySRER << index), 2201 cflags |= CyDSR | CyRI | CyDCD;
3147 readb(base_addr + (CySRER << index)) | CyMdmCh); 2202 /* without modem intr */
3148 /* act on 1->0 modem transitions */ 2203 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyMdmCh);
3149 if ((cflag & CRTSCTS) && info->rflow) { 2204 /* act on 1->0 modem transitions */
3150 cy_writeb(base_addr + (CyMCOR1 << index), 2205 if ((cflag & CRTSCTS) && info->rflow)
3151 (CyCTS | rflow_thr[i])); 2206 cyy_writeb(info, CyMCOR1, cflags | rflow_thr[i]);
3152 } else { 2207 else
3153 cy_writeb(base_addr + (CyMCOR1 << index), 2208 cyy_writeb(info, CyMCOR1, cflags);
3154 CyCTS); 2209 /* act on 0->1 modem transitions */
3155 } 2210 cyy_writeb(info, CyMCOR2, cflags);
3156 /* act on 0->1 modem transitions */
3157 cy_writeb(base_addr + (CyMCOR2 << index), CyCTS);
3158 } else {
3159 /* without modem intr */
3160 cy_writeb(base_addr + (CySRER << index),
3161 readb(base_addr +
3162 (CySRER << index)) | CyMdmCh);
3163 /* act on 1->0 modem transitions */
3164 if ((cflag & CRTSCTS) && info->rflow) {
3165 cy_writeb(base_addr + (CyMCOR1 << index),
3166 (CyDSR | CyCTS | CyRI | CyDCD |
3167 rflow_thr[i]));
3168 } else {
3169 cy_writeb(base_addr + (CyMCOR1 << index),
3170 CyDSR | CyCTS | CyRI | CyDCD);
3171 }
3172 /* act on 0->1 modem transitions */
3173 cy_writeb(base_addr + (CyMCOR2 << index),
3174 CyDSR | CyCTS | CyRI | CyDCD);
3175 }
3176 2211
3177 if (i == 0) { /* baud rate is zero, turn off line */ 2212 if (i == 0) /* baud rate is zero, turn off line */
3178 if (info->rtsdtr_inv) { 2213 cyy_change_rts_dtr(info, 0, TIOCM_DTR);
3179 cy_writeb(base_addr + (CyMSVR1 << index), 2214 else
3180 ~CyRTS); 2215 cyy_change_rts_dtr(info, TIOCM_DTR, 0);
3181 } else {
3182 cy_writeb(base_addr + (CyMSVR2 << index),
3183 ~CyDTR);
3184 }
3185#ifdef CY_DEBUG_DTR
3186 printk(KERN_DEBUG "cyc:set_line_char dropping DTR\n");
3187 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
3188 readb(base_addr + (CyMSVR1 << index)),
3189 readb(base_addr + (CyMSVR2 << index)));
3190#endif
3191 } else {
3192 if (info->rtsdtr_inv) {
3193 cy_writeb(base_addr + (CyMSVR1 << index),
3194 CyRTS);
3195 } else {
3196 cy_writeb(base_addr + (CyMSVR2 << index),
3197 CyDTR);
3198 }
3199#ifdef CY_DEBUG_DTR
3200 printk(KERN_DEBUG "cyc:set_line_char raising DTR\n");
3201 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
3202 readb(base_addr + (CyMSVR1 << index)),
3203 readb(base_addr + (CyMSVR2 << index)));
3204#endif
3205 }
3206 2216
3207 if (info->port.tty) 2217 clear_bit(TTY_IO_ERROR, &tty->flags);
3208 clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
3209 spin_unlock_irqrestore(&card->card_lock, flags); 2218 spin_unlock_irqrestore(&card->card_lock, flags);
3210 2219
3211 } else { 2220 } else {
3212 struct FIRM_ID __iomem *firm_id; 2221 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
3213 struct ZFW_CTRL __iomem *zfw_ctrl;
3214 struct CH_CTRL __iomem *ch_ctrl;
3215 __u32 sw_flow; 2222 __u32 sw_flow;
3216 int retval; 2223 int retval;
3217 2224
3218 firm_id = card->base_addr + ID_ADDRESS;
3219 if (!cyz_is_loaded(card)) 2225 if (!cyz_is_loaded(card))
3220 return; 2226 return;
3221 2227
3222 zfw_ctrl = card->base_addr +
3223 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3224 ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
3225
3226 /* baud rate */ 2228 /* baud rate */
3227 baud = tty_get_baud_rate(info->port.tty); 2229 baud = tty_get_baud_rate(tty);
3228 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) == 2230 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
3229 ASYNC_SPD_CUST) { 2231 ASYNC_SPD_CUST) {
3230 if (info->custom_divisor) 2232 if (info->custom_divisor)
@@ -3335,45 +2337,38 @@ static void set_line_char(struct cyclades_port *info)
3335 "was %x\n", info->line, retval); 2337 "was %x\n", info->line, retval);
3336 } 2338 }
3337 2339
3338 if (info->port.tty) 2340 clear_bit(TTY_IO_ERROR, &tty->flags);
3339 clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
3340 } 2341 }
3341} /* set_line_char */ 2342} /* set_line_char */
3342 2343
3343static int 2344static int cy_get_serial_info(struct cyclades_port *info,
3344get_serial_info(struct cyclades_port *info,
3345 struct serial_struct __user *retinfo) 2345 struct serial_struct __user *retinfo)
3346{ 2346{
3347 struct serial_struct tmp;
3348 struct cyclades_card *cinfo = info->card; 2347 struct cyclades_card *cinfo = info->card;
3349 2348 struct serial_struct tmp = {
3350 if (!retinfo) 2349 .type = info->type,
3351 return -EFAULT; 2350 .line = info->line,
3352 memset(&tmp, 0, sizeof(tmp)); 2351 .port = (info->card - cy_card) * 0x100 + info->line -
3353 tmp.type = info->type; 2352 cinfo->first_line,
3354 tmp.line = info->line; 2353 .irq = cinfo->irq,
3355 tmp.port = (info->card - cy_card) * 0x100 + info->line - 2354 .flags = info->port.flags,
3356 cinfo->first_line; 2355 .close_delay = info->port.close_delay,
3357 tmp.irq = cinfo->irq; 2356 .closing_wait = info->port.closing_wait,
3358 tmp.flags = info->port.flags; 2357 .baud_base = info->baud,
3359 tmp.close_delay = info->port.close_delay; 2358 .custom_divisor = info->custom_divisor,
3360 tmp.closing_wait = info->port.closing_wait; 2359 .hub6 = 0, /*!!! */
3361 tmp.baud_base = info->baud; 2360 };
3362 tmp.custom_divisor = info->custom_divisor;
3363 tmp.hub6 = 0; /*!!! */
3364 return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0; 2361 return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
3365} /* get_serial_info */ 2362}
3366 2363
3367static int 2364static int
3368set_serial_info(struct cyclades_port *info, 2365cy_set_serial_info(struct cyclades_port *info, struct tty_struct *tty,
3369 struct serial_struct __user *new_info) 2366 struct serial_struct __user *new_info)
3370{ 2367{
3371 struct serial_struct new_serial; 2368 struct serial_struct new_serial;
3372 struct cyclades_port old_info;
3373 2369
3374 if (copy_from_user(&new_serial, new_info, sizeof(new_serial))) 2370 if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
3375 return -EFAULT; 2371 return -EFAULT;
3376 old_info = *info;
3377 2372
3378 if (!capable(CAP_SYS_ADMIN)) { 2373 if (!capable(CAP_SYS_ADMIN)) {
3379 if (new_serial.close_delay != info->port.close_delay || 2374 if (new_serial.close_delay != info->port.close_delay ||
@@ -3403,10 +2398,10 @@ set_serial_info(struct cyclades_port *info,
3403 2398
3404check_and_exit: 2399check_and_exit:
3405 if (info->port.flags & ASYNC_INITIALIZED) { 2400 if (info->port.flags & ASYNC_INITIALIZED) {
3406 set_line_char(info); 2401 cy_set_line_char(info, tty);
3407 return 0; 2402 return 0;
3408 } else { 2403 } else {
3409 return startup(info); 2404 return cy_startup(info, tty);
3410 } 2405 }
3411} /* set_serial_info */ 2406} /* set_serial_info */
3412 2407
@@ -3422,24 +2417,14 @@ check_and_exit:
3422 */ 2417 */
3423static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value) 2418static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
3424{ 2419{
3425 struct cyclades_card *card; 2420 struct cyclades_card *card = info->card;
3426 int chip, channel, index;
3427 unsigned char status;
3428 unsigned int result; 2421 unsigned int result;
3429 unsigned long flags; 2422 unsigned long flags;
3430 void __iomem *base_addr; 2423 u8 status;
3431 2424
3432 card = info->card;
3433 channel = (info->line) - (card->first_line);
3434 if (!cy_is_Z(card)) { 2425 if (!cy_is_Z(card)) {
3435 chip = channel >> 2;
3436 channel &= 0x03;
3437 index = card->bus_index;
3438 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
3439
3440 spin_lock_irqsave(&card->card_lock, flags); 2426 spin_lock_irqsave(&card->card_lock, flags);
3441 status = readb(base_addr + (CySRER << index)) & 2427 status = cyy_readb(info, CySRER) & (CyTxRdy | CyTxMpty);
3442 (CyTxRdy | CyTxMpty);
3443 spin_unlock_irqrestore(&card->card_lock, flags); 2428 spin_unlock_irqrestore(&card->card_lock, flags);
3444 result = (status ? 0 : TIOCSER_TEMT); 2429 result = (status ? 0 : TIOCSER_TEMT);
3445 } else { 2430 } else {
@@ -3453,34 +2438,23 @@ static int cy_tiocmget(struct tty_struct *tty, struct file *file)
3453{ 2438{
3454 struct cyclades_port *info = tty->driver_data; 2439 struct cyclades_port *info = tty->driver_data;
3455 struct cyclades_card *card; 2440 struct cyclades_card *card;
3456 int chip, channel, index; 2441 int result;
3457 void __iomem *base_addr;
3458 unsigned long flags;
3459 unsigned char status;
3460 unsigned long lstatus;
3461 unsigned int result;
3462 struct FIRM_ID __iomem *firm_id;
3463 struct ZFW_CTRL __iomem *zfw_ctrl;
3464 struct BOARD_CTRL __iomem *board_ctrl;
3465 struct CH_CTRL __iomem *ch_ctrl;
3466 2442
3467 if (serial_paranoia_check(info, tty->name, __func__)) 2443 if (serial_paranoia_check(info, tty->name, __func__))
3468 return -ENODEV; 2444 return -ENODEV;
3469 2445
3470 lock_kernel();
3471
3472 card = info->card; 2446 card = info->card;
3473 channel = info->line - card->first_line; 2447
2448 lock_kernel();
3474 if (!cy_is_Z(card)) { 2449 if (!cy_is_Z(card)) {
3475 chip = channel >> 2; 2450 unsigned long flags;
3476 channel &= 0x03; 2451 int channel = info->line - card->first_line;
3477 index = card->bus_index; 2452 u8 status;
3478 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
3479 2453
3480 spin_lock_irqsave(&card->card_lock, flags); 2454 spin_lock_irqsave(&card->card_lock, flags);
3481 cy_writeb(base_addr + (CyCAR << index), (u_char) channel); 2455 cyy_writeb(info, CyCAR, channel & 0x03);
3482 status = readb(base_addr + (CyMSVR1 << index)); 2456 status = cyy_readb(info, CyMSVR1);
3483 status |= readb(base_addr + (CyMSVR2 << index)); 2457 status |= cyy_readb(info, CyMSVR2);
3484 spin_unlock_irqrestore(&card->card_lock, flags); 2458 spin_unlock_irqrestore(&card->card_lock, flags);
3485 2459
3486 if (info->rtsdtr_inv) { 2460 if (info->rtsdtr_inv) {
@@ -3495,27 +2469,22 @@ static int cy_tiocmget(struct tty_struct *tty, struct file *file)
3495 ((status & CyDSR) ? TIOCM_DSR : 0) | 2469 ((status & CyDSR) ? TIOCM_DSR : 0) |
3496 ((status & CyCTS) ? TIOCM_CTS : 0); 2470 ((status & CyCTS) ? TIOCM_CTS : 0);
3497 } else { 2471 } else {
3498 base_addr = card->base_addr; 2472 u32 lstatus;
3499 firm_id = card->base_addr + ID_ADDRESS; 2473
3500 if (cyz_is_loaded(card)) { 2474 if (!cyz_is_loaded(card)) {
3501 zfw_ctrl = card->base_addr + 2475 result = -ENODEV;
3502 (readl(&firm_id->zfwctrl_addr) & 0xfffff); 2476 goto end;
3503 board_ctrl = &zfw_ctrl->board_ctrl;
3504 ch_ctrl = zfw_ctrl->ch_ctrl;
3505 lstatus = readl(&ch_ctrl[channel].rs_status);
3506 result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
3507 ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
3508 ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
3509 ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
3510 ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
3511 ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
3512 } else {
3513 result = 0;
3514 unlock_kernel();
3515 return -ENODEV;
3516 } 2477 }
3517 2478
2479 lstatus = readl(&info->u.cyz.ch_ctrl->rs_status);
2480 result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
2481 ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
2482 ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
2483 ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
2484 ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
2485 ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
3518 } 2486 }
2487end:
3519 unlock_kernel(); 2488 unlock_kernel();
3520 return result; 2489 return result;
3521} /* cy_tiomget */ 2490} /* cy_tiomget */
@@ -3526,150 +2495,53 @@ cy_tiocmset(struct tty_struct *tty, struct file *file,
3526{ 2495{
3527 struct cyclades_port *info = tty->driver_data; 2496 struct cyclades_port *info = tty->driver_data;
3528 struct cyclades_card *card; 2497 struct cyclades_card *card;
3529 int chip, channel, index;
3530 void __iomem *base_addr;
3531 unsigned long flags; 2498 unsigned long flags;
3532 struct FIRM_ID __iomem *firm_id;
3533 struct ZFW_CTRL __iomem *zfw_ctrl;
3534 struct BOARD_CTRL __iomem *board_ctrl;
3535 struct CH_CTRL __iomem *ch_ctrl;
3536 int retval;
3537 2499
3538 if (serial_paranoia_check(info, tty->name, __func__)) 2500 if (serial_paranoia_check(info, tty->name, __func__))
3539 return -ENODEV; 2501 return -ENODEV;
3540 2502
3541 card = info->card; 2503 card = info->card;
3542 channel = (info->line) - (card->first_line);
3543 if (!cy_is_Z(card)) { 2504 if (!cy_is_Z(card)) {
3544 chip = channel >> 2; 2505 spin_lock_irqsave(&card->card_lock, flags);
3545 channel &= 0x03; 2506 cyy_change_rts_dtr(info, set, clear);
3546 index = card->bus_index; 2507 spin_unlock_irqrestore(&card->card_lock, flags);
3547 base_addr = card->base_addr + (cy_chip_offset[chip] << index); 2508 } else {
2509 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
2510 int retval, channel = info->line - card->first_line;
2511 u32 rs;
3548 2512
3549 if (set & TIOCM_RTS) { 2513 if (!cyz_is_loaded(card))
3550 spin_lock_irqsave(&card->card_lock, flags); 2514 return -ENODEV;
3551 cy_writeb(base_addr + (CyCAR << index), 2515
3552 (u_char) channel); 2516 spin_lock_irqsave(&card->card_lock, flags);
3553 if (info->rtsdtr_inv) { 2517 rs = readl(&ch_ctrl->rs_control);
3554 cy_writeb(base_addr + (CyMSVR2 << index), 2518 if (set & TIOCM_RTS)
3555 CyDTR); 2519 rs |= C_RS_RTS;
3556 } else { 2520 if (clear & TIOCM_RTS)
3557 cy_writeb(base_addr + (CyMSVR1 << index), 2521 rs &= ~C_RS_RTS;
3558 CyRTS);
3559 }
3560 spin_unlock_irqrestore(&card->card_lock, flags);
3561 }
3562 if (clear & TIOCM_RTS) {
3563 spin_lock_irqsave(&card->card_lock, flags);
3564 cy_writeb(base_addr + (CyCAR << index),
3565 (u_char) channel);
3566 if (info->rtsdtr_inv) {
3567 cy_writeb(base_addr + (CyMSVR2 << index),
3568 ~CyDTR);
3569 } else {
3570 cy_writeb(base_addr + (CyMSVR1 << index),
3571 ~CyRTS);
3572 }
3573 spin_unlock_irqrestore(&card->card_lock, flags);
3574 }
3575 if (set & TIOCM_DTR) { 2522 if (set & TIOCM_DTR) {
3576 spin_lock_irqsave(&card->card_lock, flags); 2523 rs |= C_RS_DTR;
3577 cy_writeb(base_addr + (CyCAR << index),
3578 (u_char) channel);
3579 if (info->rtsdtr_inv) {
3580 cy_writeb(base_addr + (CyMSVR1 << index),
3581 CyRTS);
3582 } else {
3583 cy_writeb(base_addr + (CyMSVR2 << index),
3584 CyDTR);
3585 }
3586#ifdef CY_DEBUG_DTR 2524#ifdef CY_DEBUG_DTR
3587 printk(KERN_DEBUG "cyc:set_modem_info raising DTR\n"); 2525 printk(KERN_DEBUG "cyc:set_modem_info raising Z DTR\n");
3588 printk(KERN_DEBUG " status: 0x%x, 0x%x\n",
3589 readb(base_addr + (CyMSVR1 << index)),
3590 readb(base_addr + (CyMSVR2 << index)));
3591#endif 2526#endif
3592 spin_unlock_irqrestore(&card->card_lock, flags);
3593 } 2527 }
3594 if (clear & TIOCM_DTR) { 2528 if (clear & TIOCM_DTR) {
3595 spin_lock_irqsave(&card->card_lock, flags); 2529 rs &= ~C_RS_DTR;
3596 cy_writeb(base_addr + (CyCAR << index),
3597 (u_char) channel);
3598 if (info->rtsdtr_inv) {
3599 cy_writeb(base_addr + (CyMSVR1 << index),
3600 ~CyRTS);
3601 } else {
3602 cy_writeb(base_addr + (CyMSVR2 << index),
3603 ~CyDTR);
3604 }
3605
3606#ifdef CY_DEBUG_DTR 2530#ifdef CY_DEBUG_DTR
3607 printk(KERN_DEBUG "cyc:set_modem_info dropping DTR\n"); 2531 printk(KERN_DEBUG "cyc:set_modem_info clearing "
3608 printk(KERN_DEBUG " status: 0x%x, 0x%x\n", 2532 "Z DTR\n");
3609 readb(base_addr + (CyMSVR1 << index)),
3610 readb(base_addr + (CyMSVR2 << index)));
3611#endif 2533#endif
3612 spin_unlock_irqrestore(&card->card_lock, flags);
3613 } 2534 }
3614 } else { 2535 cy_writel(&ch_ctrl->rs_control, rs);
3615 base_addr = card->base_addr;
3616
3617 firm_id = card->base_addr + ID_ADDRESS;
3618 if (cyz_is_loaded(card)) {
3619 zfw_ctrl = card->base_addr +
3620 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3621 board_ctrl = &zfw_ctrl->board_ctrl;
3622 ch_ctrl = zfw_ctrl->ch_ctrl;
3623
3624 if (set & TIOCM_RTS) {
3625 spin_lock_irqsave(&card->card_lock, flags);
3626 cy_writel(&ch_ctrl[channel].rs_control,
3627 readl(&ch_ctrl[channel].rs_control) |
3628 C_RS_RTS);
3629 spin_unlock_irqrestore(&card->card_lock, flags);
3630 }
3631 if (clear & TIOCM_RTS) {
3632 spin_lock_irqsave(&card->card_lock, flags);
3633 cy_writel(&ch_ctrl[channel].rs_control,
3634 readl(&ch_ctrl[channel].rs_control) &
3635 ~C_RS_RTS);
3636 spin_unlock_irqrestore(&card->card_lock, flags);
3637 }
3638 if (set & TIOCM_DTR) {
3639 spin_lock_irqsave(&card->card_lock, flags);
3640 cy_writel(&ch_ctrl[channel].rs_control,
3641 readl(&ch_ctrl[channel].rs_control) |
3642 C_RS_DTR);
3643#ifdef CY_DEBUG_DTR
3644 printk(KERN_DEBUG "cyc:set_modem_info raising "
3645 "Z DTR\n");
3646#endif
3647 spin_unlock_irqrestore(&card->card_lock, flags);
3648 }
3649 if (clear & TIOCM_DTR) {
3650 spin_lock_irqsave(&card->card_lock, flags);
3651 cy_writel(&ch_ctrl[channel].rs_control,
3652 readl(&ch_ctrl[channel].rs_control) &
3653 ~C_RS_DTR);
3654#ifdef CY_DEBUG_DTR
3655 printk(KERN_DEBUG "cyc:set_modem_info clearing "
3656 "Z DTR\n");
3657#endif
3658 spin_unlock_irqrestore(&card->card_lock, flags);
3659 }
3660 } else {
3661 return -ENODEV;
3662 }
3663 spin_lock_irqsave(&card->card_lock, flags);
3664 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L); 2536 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
2537 spin_unlock_irqrestore(&card->card_lock, flags);
3665 if (retval != 0) { 2538 if (retval != 0) {
3666 printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d " 2539 printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
3667 "was %x\n", info->line, retval); 2540 "was %x\n", info->line, retval);
3668 } 2541 }
3669 spin_unlock_irqrestore(&card->card_lock, flags);
3670 } 2542 }
3671 return 0; 2543 return 0;
3672} /* cy_tiocmset */ 2544}
3673 2545
3674/* 2546/*
3675 * cy_break() --- routine which turns the break handling on or off 2547 * cy_break() --- routine which turns the break handling on or off
@@ -3734,41 +2606,18 @@ static int cy_break(struct tty_struct *tty, int break_state)
3734 return retval; 2606 return retval;
3735} /* cy_break */ 2607} /* cy_break */
3736 2608
3737static int get_mon_info(struct cyclades_port *info,
3738 struct cyclades_monitor __user *mon)
3739{
3740
3741 if (copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
3742 return -EFAULT;
3743 info->mon.int_count = 0;
3744 info->mon.char_count = 0;
3745 info->mon.char_max = 0;
3746 info->mon.char_last = 0;
3747 return 0;
3748} /* get_mon_info */
3749
3750static int set_threshold(struct cyclades_port *info, unsigned long value) 2609static int set_threshold(struct cyclades_port *info, unsigned long value)
3751{ 2610{
3752 struct cyclades_card *card; 2611 struct cyclades_card *card = info->card;
3753 void __iomem *base_addr;
3754 int channel, chip, index;
3755 unsigned long flags; 2612 unsigned long flags;
3756 2613
3757 card = info->card;
3758 channel = info->line - card->first_line;
3759 if (!cy_is_Z(card)) { 2614 if (!cy_is_Z(card)) {
3760 chip = channel >> 2;
3761 channel &= 0x03;
3762 index = card->bus_index;
3763 base_addr =
3764 card->base_addr + (cy_chip_offset[chip] << index);
3765
3766 info->cor3 &= ~CyREC_FIFO; 2615 info->cor3 &= ~CyREC_FIFO;
3767 info->cor3 |= value & CyREC_FIFO; 2616 info->cor3 |= value & CyREC_FIFO;
3768 2617
3769 spin_lock_irqsave(&card->card_lock, flags); 2618 spin_lock_irqsave(&card->card_lock, flags);
3770 cy_writeb(base_addr + (CyCOR3 << index), info->cor3); 2619 cyy_writeb(info, CyCOR3, info->cor3);
3771 cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR3ch, index); 2620 cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR3ch);
3772 spin_unlock_irqrestore(&card->card_lock, flags); 2621 spin_unlock_irqrestore(&card->card_lock, flags);
3773 } 2622 }
3774 return 0; 2623 return 0;
@@ -3777,55 +2626,23 @@ static int set_threshold(struct cyclades_port *info, unsigned long value)
3777static int get_threshold(struct cyclades_port *info, 2626static int get_threshold(struct cyclades_port *info,
3778 unsigned long __user *value) 2627 unsigned long __user *value)
3779{ 2628{
3780 struct cyclades_card *card; 2629 struct cyclades_card *card = info->card;
3781 void __iomem *base_addr;
3782 int channel, chip, index;
3783 unsigned long tmp;
3784 2630
3785 card = info->card;
3786 channel = info->line - card->first_line;
3787 if (!cy_is_Z(card)) { 2631 if (!cy_is_Z(card)) {
3788 chip = channel >> 2; 2632 u8 tmp = cyy_readb(info, CyCOR3) & CyREC_FIFO;
3789 channel &= 0x03;
3790 index = card->bus_index;
3791 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
3792
3793 tmp = readb(base_addr + (CyCOR3 << index)) & CyREC_FIFO;
3794 return put_user(tmp, value); 2633 return put_user(tmp, value);
3795 } 2634 }
3796 return 0; 2635 return 0;
3797} /* get_threshold */ 2636} /* get_threshold */
3798 2637
3799static int set_default_threshold(struct cyclades_port *info,
3800 unsigned long value)
3801{
3802 info->default_threshold = value & 0x0f;
3803 return 0;
3804} /* set_default_threshold */
3805
3806static int get_default_threshold(struct cyclades_port *info,
3807 unsigned long __user *value)
3808{
3809 return put_user(info->default_threshold, value);
3810} /* get_default_threshold */
3811
3812static int set_timeout(struct cyclades_port *info, unsigned long value) 2638static int set_timeout(struct cyclades_port *info, unsigned long value)
3813{ 2639{
3814 struct cyclades_card *card; 2640 struct cyclades_card *card = info->card;
3815 void __iomem *base_addr;
3816 int channel, chip, index;
3817 unsigned long flags; 2641 unsigned long flags;
3818 2642
3819 card = info->card;
3820 channel = info->line - card->first_line;
3821 if (!cy_is_Z(card)) { 2643 if (!cy_is_Z(card)) {
3822 chip = channel >> 2;
3823 channel &= 0x03;
3824 index = card->bus_index;
3825 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
3826
3827 spin_lock_irqsave(&card->card_lock, flags); 2644 spin_lock_irqsave(&card->card_lock, flags);
3828 cy_writeb(base_addr + (CyRTPR << index), value & 0xff); 2645 cyy_writeb(info, CyRTPR, value & 0xff);
3829 spin_unlock_irqrestore(&card->card_lock, flags); 2646 spin_unlock_irqrestore(&card->card_lock, flags);
3830 } 2647 }
3831 return 0; 2648 return 0;
@@ -3834,36 +2651,35 @@ static int set_timeout(struct cyclades_port *info, unsigned long value)
3834static int get_timeout(struct cyclades_port *info, 2651static int get_timeout(struct cyclades_port *info,
3835 unsigned long __user *value) 2652 unsigned long __user *value)
3836{ 2653{
3837 struct cyclades_card *card; 2654 struct cyclades_card *card = info->card;
3838 void __iomem *base_addr;
3839 int channel, chip, index;
3840 unsigned long tmp;
3841 2655
3842 card = info->card;
3843 channel = info->line - card->first_line;
3844 if (!cy_is_Z(card)) { 2656 if (!cy_is_Z(card)) {
3845 chip = channel >> 2; 2657 u8 tmp = cyy_readb(info, CyRTPR);
3846 channel &= 0x03;
3847 index = card->bus_index;
3848 base_addr = card->base_addr + (cy_chip_offset[chip] << index);
3849
3850 tmp = readb(base_addr + (CyRTPR << index));
3851 return put_user(tmp, value); 2658 return put_user(tmp, value);
3852 } 2659 }
3853 return 0; 2660 return 0;
3854} /* get_timeout */ 2661} /* get_timeout */
3855 2662
3856static int set_default_timeout(struct cyclades_port *info, unsigned long value) 2663static int cy_cflags_changed(struct cyclades_port *info, unsigned long arg,
2664 struct cyclades_icount *cprev)
3857{ 2665{
3858 info->default_timeout = value & 0xff; 2666 struct cyclades_icount cnow;
3859 return 0; 2667 unsigned long flags;
3860} /* set_default_timeout */ 2668 int ret;
3861 2669
3862static int get_default_timeout(struct cyclades_port *info, 2670 spin_lock_irqsave(&info->card->card_lock, flags);
3863 unsigned long __user *value) 2671 cnow = info->icount; /* atomic copy */
3864{ 2672 spin_unlock_irqrestore(&info->card->card_lock, flags);
3865 return put_user(info->default_timeout, value); 2673
3866} /* get_default_timeout */ 2674 ret = ((arg & TIOCM_RNG) && (cnow.rng != cprev->rng)) ||
2675 ((arg & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) ||
2676 ((arg & TIOCM_CD) && (cnow.dcd != cprev->dcd)) ||
2677 ((arg & TIOCM_CTS) && (cnow.cts != cprev->cts));
2678
2679 *cprev = cnow;
2680
2681 return ret;
2682}
3867 2683
3868/* 2684/*
3869 * This routine allows the tty driver to implement device- 2685 * This routine allows the tty driver to implement device-
@@ -3875,8 +2691,7 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
3875 unsigned int cmd, unsigned long arg) 2691 unsigned int cmd, unsigned long arg)
3876{ 2692{
3877 struct cyclades_port *info = tty->driver_data; 2693 struct cyclades_port *info = tty->driver_data;
3878 struct cyclades_icount cprev, cnow; /* kernel counter temps */ 2694 struct cyclades_icount cnow; /* kernel counter temps */
3879 struct serial_icounter_struct __user *p_cuser; /* user space */
3880 int ret_val = 0; 2695 int ret_val = 0;
3881 unsigned long flags; 2696 unsigned long flags;
3882 void __user *argp = (void __user *)arg; 2697 void __user *argp = (void __user *)arg;
@@ -3892,7 +2707,11 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
3892 2707
3893 switch (cmd) { 2708 switch (cmd) {
3894 case CYGETMON: 2709 case CYGETMON:
3895 ret_val = get_mon_info(info, argp); 2710 if (copy_to_user(argp, &info->mon, sizeof(info->mon))) {
2711 ret_val = -EFAULT;
2712 break;
2713 }
2714 memset(&info->mon, 0, sizeof(info->mon));
3896 break; 2715 break;
3897 case CYGETTHRESH: 2716 case CYGETTHRESH:
3898 ret_val = get_threshold(info, argp); 2717 ret_val = get_threshold(info, argp);
@@ -3901,10 +2720,11 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
3901 ret_val = set_threshold(info, arg); 2720 ret_val = set_threshold(info, arg);
3902 break; 2721 break;
3903 case CYGETDEFTHRESH: 2722 case CYGETDEFTHRESH:
3904 ret_val = get_default_threshold(info, argp); 2723 ret_val = put_user(info->default_threshold,
2724 (unsigned long __user *)argp);
3905 break; 2725 break;
3906 case CYSETDEFTHRESH: 2726 case CYSETDEFTHRESH:
3907 ret_val = set_default_threshold(info, arg); 2727 info->default_threshold = arg & 0x0f;
3908 break; 2728 break;
3909 case CYGETTIMEOUT: 2729 case CYGETTIMEOUT:
3910 ret_val = get_timeout(info, argp); 2730 ret_val = get_timeout(info, argp);
@@ -3913,21 +2733,20 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
3913 ret_val = set_timeout(info, arg); 2733 ret_val = set_timeout(info, arg);
3914 break; 2734 break;
3915 case CYGETDEFTIMEOUT: 2735 case CYGETDEFTIMEOUT:
3916 ret_val = get_default_timeout(info, argp); 2736 ret_val = put_user(info->default_timeout,
2737 (unsigned long __user *)argp);
3917 break; 2738 break;
3918 case CYSETDEFTIMEOUT: 2739 case CYSETDEFTIMEOUT:
3919 ret_val = set_default_timeout(info, arg); 2740 info->default_timeout = arg & 0xff;
3920 break; 2741 break;
3921 case CYSETRFLOW: 2742 case CYSETRFLOW:
3922 info->rflow = (int)arg; 2743 info->rflow = (int)arg;
3923 ret_val = 0;
3924 break; 2744 break;
3925 case CYGETRFLOW: 2745 case CYGETRFLOW:
3926 ret_val = info->rflow; 2746 ret_val = info->rflow;
3927 break; 2747 break;
3928 case CYSETRTSDTR_INV: 2748 case CYSETRTSDTR_INV:
3929 info->rtsdtr_inv = (int)arg; 2749 info->rtsdtr_inv = (int)arg;
3930 ret_val = 0;
3931 break; 2750 break;
3932 case CYGETRTSDTR_INV: 2751 case CYGETRTSDTR_INV:
3933 ret_val = info->rtsdtr_inv; 2752 ret_val = info->rtsdtr_inv;
@@ -3938,7 +2757,6 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
3938#ifndef CONFIG_CYZ_INTR 2757#ifndef CONFIG_CYZ_INTR
3939 case CYZSETPOLLCYCLE: 2758 case CYZSETPOLLCYCLE:
3940 cyz_polling_cycle = (arg * HZ) / 1000; 2759 cyz_polling_cycle = (arg * HZ) / 1000;
3941 ret_val = 0;
3942 break; 2760 break;
3943 case CYZGETPOLLCYCLE: 2761 case CYZGETPOLLCYCLE:
3944 ret_val = (cyz_polling_cycle * 1000) / HZ; 2762 ret_val = (cyz_polling_cycle * 1000) / HZ;
@@ -3946,16 +2764,15 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
3946#endif /* CONFIG_CYZ_INTR */ 2764#endif /* CONFIG_CYZ_INTR */
3947 case CYSETWAIT: 2765 case CYSETWAIT:
3948 info->port.closing_wait = (unsigned short)arg * HZ / 100; 2766 info->port.closing_wait = (unsigned short)arg * HZ / 100;
3949 ret_val = 0;
3950 break; 2767 break;
3951 case CYGETWAIT: 2768 case CYGETWAIT:
3952 ret_val = info->port.closing_wait / (HZ / 100); 2769 ret_val = info->port.closing_wait / (HZ / 100);
3953 break; 2770 break;
3954 case TIOCGSERIAL: 2771 case TIOCGSERIAL:
3955 ret_val = get_serial_info(info, argp); 2772 ret_val = cy_get_serial_info(info, argp);
3956 break; 2773 break;
3957 case TIOCSSERIAL: 2774 case TIOCSSERIAL:
3958 ret_val = set_serial_info(info, argp); 2775 ret_val = cy_set_serial_info(info, tty, argp);
3959 break; 2776 break;
3960 case TIOCSERGETLSR: /* Get line status register */ 2777 case TIOCSERGETLSR: /* Get line status register */
3961 ret_val = get_lsr_info(info, argp); 2778 ret_val = get_lsr_info(info, argp);
@@ -3971,17 +2788,8 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
3971 /* note the counters on entry */ 2788 /* note the counters on entry */
3972 cnow = info->icount; 2789 cnow = info->icount;
3973 spin_unlock_irqrestore(&info->card->card_lock, flags); 2790 spin_unlock_irqrestore(&info->card->card_lock, flags);
3974 ret_val = wait_event_interruptible(info->delta_msr_wait, ({ 2791 ret_val = wait_event_interruptible(info->port.delta_msr_wait,
3975 cprev = cnow; 2792 cy_cflags_changed(info, arg, &cnow));
3976 spin_lock_irqsave(&info->card->card_lock, flags);
3977 cnow = info->icount; /* atomic copy */
3978 spin_unlock_irqrestore(&info->card->card_lock, flags);
3979
3980 ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
3981 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
3982 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
3983 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts));
3984 }));
3985 break; 2793 break;
3986 2794
3987 /* 2795 /*
@@ -3990,46 +2798,29 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
3990 * NB: both 1->0 and 0->1 transitions are counted except for 2798 * NB: both 1->0 and 0->1 transitions are counted except for
3991 * RI where only 0->1 is counted. 2799 * RI where only 0->1 is counted.
3992 */ 2800 */
3993 case TIOCGICOUNT: 2801 case TIOCGICOUNT: {
2802 struct serial_icounter_struct sic = { };
2803
3994 spin_lock_irqsave(&info->card->card_lock, flags); 2804 spin_lock_irqsave(&info->card->card_lock, flags);
3995 cnow = info->icount; 2805 cnow = info->icount;
3996 spin_unlock_irqrestore(&info->card->card_lock, flags); 2806 spin_unlock_irqrestore(&info->card->card_lock, flags);
3997 p_cuser = argp; 2807
3998 ret_val = put_user(cnow.cts, &p_cuser->cts); 2808 sic.cts = cnow.cts;
3999 if (ret_val) 2809 sic.dsr = cnow.dsr;
4000 break; 2810 sic.rng = cnow.rng;
4001 ret_val = put_user(cnow.dsr, &p_cuser->dsr); 2811 sic.dcd = cnow.dcd;
4002 if (ret_val) 2812 sic.rx = cnow.rx;
4003 break; 2813 sic.tx = cnow.tx;
4004 ret_val = put_user(cnow.rng, &p_cuser->rng); 2814 sic.frame = cnow.frame;
4005 if (ret_val) 2815 sic.overrun = cnow.overrun;
4006 break; 2816 sic.parity = cnow.parity;
4007 ret_val = put_user(cnow.dcd, &p_cuser->dcd); 2817 sic.brk = cnow.brk;
4008 if (ret_val) 2818 sic.buf_overrun = cnow.buf_overrun;
4009 break; 2819
4010 ret_val = put_user(cnow.rx, &p_cuser->rx); 2820 if (copy_to_user(argp, &sic, sizeof(sic)))
4011 if (ret_val) 2821 ret_val = -EFAULT;
4012 break;
4013 ret_val = put_user(cnow.tx, &p_cuser->tx);
4014 if (ret_val)
4015 break;
4016 ret_val = put_user(cnow.frame, &p_cuser->frame);
4017 if (ret_val)
4018 break;
4019 ret_val = put_user(cnow.overrun, &p_cuser->overrun);
4020 if (ret_val)
4021 break;
4022 ret_val = put_user(cnow.parity, &p_cuser->parity);
4023 if (ret_val)
4024 break;
4025 ret_val = put_user(cnow.brk, &p_cuser->brk);
4026 if (ret_val)
4027 break;
4028 ret_val = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
4029 if (ret_val)
4030 break;
4031 ret_val = 0;
4032 break; 2822 break;
2823 }
4033 default: 2824 default:
4034 ret_val = -ENOIOCTLCMD; 2825 ret_val = -ENOIOCTLCMD;
4035 } 2826 }
@@ -4055,7 +2846,7 @@ static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
4055 printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line); 2846 printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
4056#endif 2847#endif
4057 2848
4058 set_line_char(info); 2849 cy_set_line_char(info, tty);
4059 2850
4060 if ((old_termios->c_cflag & CRTSCTS) && 2851 if ((old_termios->c_cflag & CRTSCTS) &&
4061 !(tty->termios->c_cflag & CRTSCTS)) { 2852 !(tty->termios->c_cflag & CRTSCTS)) {
@@ -4112,8 +2903,6 @@ static void cy_throttle(struct tty_struct *tty)
4112 struct cyclades_port *info = tty->driver_data; 2903 struct cyclades_port *info = tty->driver_data;
4113 struct cyclades_card *card; 2904 struct cyclades_card *card;
4114 unsigned long flags; 2905 unsigned long flags;
4115 void __iomem *base_addr;
4116 int chip, channel, index;
4117 2906
4118#ifdef CY_DEBUG_THROTTLE 2907#ifdef CY_DEBUG_THROTTLE
4119 char buf[64]; 2908 char buf[64];
@@ -4135,24 +2924,9 @@ static void cy_throttle(struct tty_struct *tty)
4135 } 2924 }
4136 2925
4137 if (tty->termios->c_cflag & CRTSCTS) { 2926 if (tty->termios->c_cflag & CRTSCTS) {
4138 channel = info->line - card->first_line;
4139 if (!cy_is_Z(card)) { 2927 if (!cy_is_Z(card)) {
4140 chip = channel >> 2;
4141 channel &= 0x03;
4142 index = card->bus_index;
4143 base_addr = card->base_addr +
4144 (cy_chip_offset[chip] << index);
4145
4146 spin_lock_irqsave(&card->card_lock, flags); 2928 spin_lock_irqsave(&card->card_lock, flags);
4147 cy_writeb(base_addr + (CyCAR << index), 2929 cyy_change_rts_dtr(info, 0, TIOCM_RTS);
4148 (u_char) channel);
4149 if (info->rtsdtr_inv) {
4150 cy_writeb(base_addr + (CyMSVR2 << index),
4151 ~CyDTR);
4152 } else {
4153 cy_writeb(base_addr + (CyMSVR1 << index),
4154 ~CyRTS);
4155 }
4156 spin_unlock_irqrestore(&card->card_lock, flags); 2930 spin_unlock_irqrestore(&card->card_lock, flags);
4157 } else { 2931 } else {
4158 info->throttle = 1; 2932 info->throttle = 1;
@@ -4170,8 +2944,6 @@ static void cy_unthrottle(struct tty_struct *tty)
4170 struct cyclades_port *info = tty->driver_data; 2944 struct cyclades_port *info = tty->driver_data;
4171 struct cyclades_card *card; 2945 struct cyclades_card *card;
4172 unsigned long flags; 2946 unsigned long flags;
4173 void __iomem *base_addr;
4174 int chip, channel, index;
4175 2947
4176#ifdef CY_DEBUG_THROTTLE 2948#ifdef CY_DEBUG_THROTTLE
4177 char buf[64]; 2949 char buf[64];
@@ -4192,24 +2964,9 @@ static void cy_unthrottle(struct tty_struct *tty)
4192 2964
4193 if (tty->termios->c_cflag & CRTSCTS) { 2965 if (tty->termios->c_cflag & CRTSCTS) {
4194 card = info->card; 2966 card = info->card;
4195 channel = info->line - card->first_line;
4196 if (!cy_is_Z(card)) { 2967 if (!cy_is_Z(card)) {
4197 chip = channel >> 2;
4198 channel &= 0x03;
4199 index = card->bus_index;
4200 base_addr = card->base_addr +
4201 (cy_chip_offset[chip] << index);
4202
4203 spin_lock_irqsave(&card->card_lock, flags); 2968 spin_lock_irqsave(&card->card_lock, flags);
4204 cy_writeb(base_addr + (CyCAR << index), 2969 cyy_change_rts_dtr(info, TIOCM_RTS, 0);
4205 (u_char) channel);
4206 if (info->rtsdtr_inv) {
4207 cy_writeb(base_addr + (CyMSVR2 << index),
4208 CyDTR);
4209 } else {
4210 cy_writeb(base_addr + (CyMSVR1 << index),
4211 CyRTS);
4212 }
4213 spin_unlock_irqrestore(&card->card_lock, flags); 2970 spin_unlock_irqrestore(&card->card_lock, flags);
4214 } else { 2971 } else {
4215 info->throttle = 0; 2972 info->throttle = 0;
@@ -4224,8 +2981,7 @@ static void cy_stop(struct tty_struct *tty)
4224{ 2981{
4225 struct cyclades_card *cinfo; 2982 struct cyclades_card *cinfo;
4226 struct cyclades_port *info = tty->driver_data; 2983 struct cyclades_port *info = tty->driver_data;
4227 void __iomem *base_addr; 2984 int channel;
4228 int chip, channel, index;
4229 unsigned long flags; 2985 unsigned long flags;
4230 2986
4231#ifdef CY_DEBUG_OTHER 2987#ifdef CY_DEBUG_OTHER
@@ -4238,16 +2994,9 @@ static void cy_stop(struct tty_struct *tty)
4238 cinfo = info->card; 2994 cinfo = info->card;
4239 channel = info->line - cinfo->first_line; 2995 channel = info->line - cinfo->first_line;
4240 if (!cy_is_Z(cinfo)) { 2996 if (!cy_is_Z(cinfo)) {
4241 index = cinfo->bus_index;
4242 chip = channel >> 2;
4243 channel &= 0x03;
4244 base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
4245
4246 spin_lock_irqsave(&cinfo->card_lock, flags); 2997 spin_lock_irqsave(&cinfo->card_lock, flags);
4247 cy_writeb(base_addr + (CyCAR << index), 2998 cyy_writeb(info, CyCAR, channel & 0x03);
4248 (u_char)(channel & 0x0003)); /* index channel */ 2999 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
4249 cy_writeb(base_addr + (CySRER << index),
4250 readb(base_addr + (CySRER << index)) & ~CyTxRdy);
4251 spin_unlock_irqrestore(&cinfo->card_lock, flags); 3000 spin_unlock_irqrestore(&cinfo->card_lock, flags);
4252 } 3001 }
4253} /* cy_stop */ 3002} /* cy_stop */
@@ -4256,8 +3005,7 @@ static void cy_start(struct tty_struct *tty)
4256{ 3005{
4257 struct cyclades_card *cinfo; 3006 struct cyclades_card *cinfo;
4258 struct cyclades_port *info = tty->driver_data; 3007 struct cyclades_port *info = tty->driver_data;
4259 void __iomem *base_addr; 3008 int channel;
4260 int chip, channel, index;
4261 unsigned long flags; 3009 unsigned long flags;
4262 3010
4263#ifdef CY_DEBUG_OTHER 3011#ifdef CY_DEBUG_OTHER
@@ -4269,17 +3017,10 @@ static void cy_start(struct tty_struct *tty)
4269 3017
4270 cinfo = info->card; 3018 cinfo = info->card;
4271 channel = info->line - cinfo->first_line; 3019 channel = info->line - cinfo->first_line;
4272 index = cinfo->bus_index;
4273 if (!cy_is_Z(cinfo)) { 3020 if (!cy_is_Z(cinfo)) {
4274 chip = channel >> 2;
4275 channel &= 0x03;
4276 base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
4277
4278 spin_lock_irqsave(&cinfo->card_lock, flags); 3021 spin_lock_irqsave(&cinfo->card_lock, flags);
4279 cy_writeb(base_addr + (CyCAR << index), 3022 cyy_writeb(info, CyCAR, channel & 0x03);
4280 (u_char) (channel & 0x0003)); /* index channel */ 3023 cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
4281 cy_writeb(base_addr + (CySRER << index),
4282 readb(base_addr + (CySRER << index)) | CyTxRdy);
4283 spin_unlock_irqrestore(&cinfo->card_lock, flags); 3024 spin_unlock_irqrestore(&cinfo->card_lock, flags);
4284 } 3025 }
4285} /* cy_start */ 3026} /* cy_start */
@@ -4299,17 +3040,84 @@ static void cy_hangup(struct tty_struct *tty)
4299 return; 3040 return;
4300 3041
4301 cy_flush_buffer(tty); 3042 cy_flush_buffer(tty);
4302 shutdown(info); 3043 cy_shutdown(info, tty);
4303 info->port.count = 0; 3044 tty_port_hangup(&info->port);
4304#ifdef CY_DEBUG_COUNT
4305 printk(KERN_DEBUG "cyc:cy_hangup (%d): setting count to 0\n",
4306 current->pid);
4307#endif
4308 info->port.tty = NULL;
4309 info->port.flags &= ~ASYNC_NORMAL_ACTIVE;
4310 wake_up_interruptible(&info->port.open_wait);
4311} /* cy_hangup */ 3045} /* cy_hangup */
4312 3046
3047static int cyy_carrier_raised(struct tty_port *port)
3048{
3049 struct cyclades_port *info = container_of(port, struct cyclades_port,
3050 port);
3051 struct cyclades_card *cinfo = info->card;
3052 unsigned long flags;
3053 int channel = info->line - cinfo->first_line;
3054 u32 cd;
3055
3056 spin_lock_irqsave(&cinfo->card_lock, flags);
3057 cyy_writeb(info, CyCAR, channel & 0x03);
3058 cd = cyy_readb(info, CyMSVR1) & CyDCD;
3059 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3060
3061 return cd;
3062}
3063
3064static void cyy_dtr_rts(struct tty_port *port, int raise)
3065{
3066 struct cyclades_port *info = container_of(port, struct cyclades_port,
3067 port);
3068 struct cyclades_card *cinfo = info->card;
3069 unsigned long flags;
3070
3071 spin_lock_irqsave(&cinfo->card_lock, flags);
3072 cyy_change_rts_dtr(info, raise ? TIOCM_RTS | TIOCM_DTR : 0,
3073 raise ? 0 : TIOCM_RTS | TIOCM_DTR);
3074 spin_unlock_irqrestore(&cinfo->card_lock, flags);
3075}
3076
3077static int cyz_carrier_raised(struct tty_port *port)
3078{
3079 struct cyclades_port *info = container_of(port, struct cyclades_port,
3080 port);
3081
3082 return readl(&info->u.cyz.ch_ctrl->rs_status) & C_RS_DCD;
3083}
3084
3085static void cyz_dtr_rts(struct tty_port *port, int raise)
3086{
3087 struct cyclades_port *info = container_of(port, struct cyclades_port,
3088 port);
3089 struct cyclades_card *cinfo = info->card;
3090 struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
3091 int ret, channel = info->line - cinfo->first_line;
3092 u32 rs;
3093
3094 rs = readl(&ch_ctrl->rs_control);
3095 if (raise)
3096 rs |= C_RS_RTS | C_RS_DTR;
3097 else
3098 rs &= ~(C_RS_RTS | C_RS_DTR);
3099 cy_writel(&ch_ctrl->rs_control, rs);
3100 ret = cyz_issue_cmd(cinfo, channel, C_CM_IOCTLM, 0L);
3101 if (ret != 0)
3102 printk(KERN_ERR "%s: retval on ttyC%d was %x\n",
3103 __func__, info->line, ret);
3104#ifdef CY_DEBUG_DTR
3105 printk(KERN_DEBUG "%s: raising Z DTR\n", __func__);
3106#endif
3107}
3108
3109static const struct tty_port_operations cyy_port_ops = {
3110 .carrier_raised = cyy_carrier_raised,
3111 .dtr_rts = cyy_dtr_rts,
3112 .shutdown = cy_do_close,
3113};
3114
3115static const struct tty_port_operations cyz_port_ops = {
3116 .carrier_raised = cyz_carrier_raised,
3117 .dtr_rts = cyz_dtr_rts,
3118 .shutdown = cy_do_close,
3119};
3120
4313/* 3121/*
4314 * --------------------------------------------------------------------- 3122 * ---------------------------------------------------------------------
4315 * cy_init() and friends 3123 * cy_init() and friends
@@ -4321,8 +3129,7 @@ static void cy_hangup(struct tty_struct *tty)
4321static int __devinit cy_init_card(struct cyclades_card *cinfo) 3129static int __devinit cy_init_card(struct cyclades_card *cinfo)
4322{ 3130{
4323 struct cyclades_port *info; 3131 struct cyclades_port *info;
4324 unsigned int port; 3132 unsigned int channel, port;
4325 unsigned short chip_number;
4326 3133
4327 spin_lock_init(&cinfo->card_lock); 3134 spin_lock_init(&cinfo->card_lock);
4328 cinfo->intr_enabled = 0; 3135 cinfo->intr_enabled = 0;
@@ -4334,9 +3141,9 @@ static int __devinit cy_init_card(struct cyclades_card *cinfo)
4334 return -ENOMEM; 3141 return -ENOMEM;
4335 } 3142 }
4336 3143
4337 for (port = cinfo->first_line; port < cinfo->first_line + cinfo->nports; 3144 for (channel = 0, port = cinfo->first_line; channel < cinfo->nports;
4338 port++) { 3145 channel++, port++) {
4339 info = &cinfo->ports[port - cinfo->first_line]; 3146 info = &cinfo->ports[channel];
4340 tty_port_init(&info->port); 3147 tty_port_init(&info->port);
4341 info->magic = CYCLADES_MAGIC; 3148 info->magic = CYCLADES_MAGIC;
4342 info->card = cinfo; 3149 info->card = cinfo;
@@ -4346,10 +3153,19 @@ static int __devinit cy_init_card(struct cyclades_card *cinfo)
4346 info->port.close_delay = 5 * HZ / 10; 3153 info->port.close_delay = 5 * HZ / 10;
4347 info->port.flags = STD_COM_FLAGS; 3154 info->port.flags = STD_COM_FLAGS;
4348 init_completion(&info->shutdown_wait); 3155 init_completion(&info->shutdown_wait);
4349 init_waitqueue_head(&info->delta_msr_wait);
4350 3156
4351 if (cy_is_Z(cinfo)) { 3157 if (cy_is_Z(cinfo)) {
3158 struct FIRM_ID *firm_id = cinfo->base_addr + ID_ADDRESS;
3159 struct ZFW_CTRL *zfw_ctrl;
3160
3161 info->port.ops = &cyz_port_ops;
4352 info->type = PORT_STARTECH; 3162 info->type = PORT_STARTECH;
3163
3164 zfw_ctrl = cinfo->base_addr +
3165 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3166 info->u.cyz.ch_ctrl = &zfw_ctrl->ch_ctrl[channel];
3167 info->u.cyz.buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
3168
4353 if (cinfo->hw_ver == ZO_V1) 3169 if (cinfo->hw_ver == ZO_V1)
4354 info->xmit_fifo_size = CYZ_FIFO_SIZE; 3170 info->xmit_fifo_size = CYZ_FIFO_SIZE;
4355 else 3171 else
@@ -4359,17 +3175,20 @@ static int __devinit cy_init_card(struct cyclades_card *cinfo)
4359 cyz_rx_restart, (unsigned long)info); 3175 cyz_rx_restart, (unsigned long)info);
4360#endif 3176#endif
4361 } else { 3177 } else {
3178 unsigned short chip_number;
4362 int index = cinfo->bus_index; 3179 int index = cinfo->bus_index;
3180
3181 info->port.ops = &cyy_port_ops;
4363 info->type = PORT_CIRRUS; 3182 info->type = PORT_CIRRUS;
4364 info->xmit_fifo_size = CyMAX_CHAR_FIFO; 3183 info->xmit_fifo_size = CyMAX_CHAR_FIFO;
4365 info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS; 3184 info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
4366 info->cor2 = CyETC; 3185 info->cor2 = CyETC;
4367 info->cor3 = 0x08; /* _very_ small rcv threshold */ 3186 info->cor3 = 0x08; /* _very_ small rcv threshold */
4368 3187
4369 chip_number = (port - cinfo->first_line) / 4; 3188 chip_number = channel / CyPORTS_PER_CHIP;
4370 info->chip_rev = readb(cinfo->base_addr + 3189 info->u.cyy.base_addr = cinfo->base_addr +
4371 (cy_chip_offset[chip_number] << index) + 3190 (cy_chip_offset[chip_number] << index);
4372 (CyGFRCR << index)); 3191 info->chip_rev = cyy_readb(info, CyGFRCR);
4373 3192
4374 if (info->chip_rev >= CD1400_REV_J) { 3193 if (info->chip_rev >= CD1400_REV_J) {
4375 /* It is a CD1400 rev. J or later */ 3194 /* It is a CD1400 rev. J or later */
@@ -5060,8 +3879,14 @@ static int __devinit cy_pci_probe(struct pci_dev *pdev,
5060 } 3879 }
5061 cy_card[card_no].num_chips = nchan / CyPORTS_PER_CHIP; 3880 cy_card[card_no].num_chips = nchan / CyPORTS_PER_CHIP;
5062 } else { 3881 } else {
3882 struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
3883 struct ZFW_CTRL __iomem *zfw_ctrl;
3884
3885 zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
3886
5063 cy_card[card_no].hw_ver = mailbox; 3887 cy_card[card_no].hw_ver = mailbox;
5064 cy_card[card_no].num_chips = (unsigned int)-1; 3888 cy_card[card_no].num_chips = (unsigned int)-1;
3889 cy_card[card_no].board_ctrl = &zfw_ctrl->board_ctrl;
5065#ifdef CONFIG_CYZ_INTR 3890#ifdef CONFIG_CYZ_INTR
5066 /* allocate IRQ only if board has an IRQ */ 3891 /* allocate IRQ only if board has an IRQ */
5067 if (irq != 0 && irq != 255) { 3892 if (irq != 0 && irq != 255) {
@@ -5191,18 +4016,30 @@ static int cyclades_proc_show(struct seq_file *m, void *v)
5191 for (j = 0; j < cy_card[i].nports; j++) { 4016 for (j = 0; j < cy_card[i].nports; j++) {
5192 info = &cy_card[i].ports[j]; 4017 info = &cy_card[i].ports[j];
5193 4018
5194 if (info->port.count) 4019 if (info->port.count) {
4020 /* XXX is the ldisc num worth this? */
4021 struct tty_struct *tty;
4022 struct tty_ldisc *ld;
4023 int num = 0;
4024 tty = tty_port_tty_get(&info->port);
4025 if (tty) {
4026 ld = tty_ldisc_ref(tty);
4027 if (ld) {
4028 num = ld->ops->num;
4029 tty_ldisc_deref(ld);
4030 }
4031 tty_kref_put(tty);
4032 }
5195 seq_printf(m, "%3d %8lu %10lu %8lu " 4033 seq_printf(m, "%3d %8lu %10lu %8lu "
5196 "%10lu %8lu %9lu %6ld\n", info->line, 4034 "%10lu %8lu %9lu %6d\n", info->line,
5197 (cur_jifs - info->idle_stats.in_use) / 4035 (cur_jifs - info->idle_stats.in_use) /
5198 HZ, info->idle_stats.xmit_bytes, 4036 HZ, info->idle_stats.xmit_bytes,
5199 (cur_jifs - info->idle_stats.xmit_idle)/ 4037 (cur_jifs - info->idle_stats.xmit_idle)/
5200 HZ, info->idle_stats.recv_bytes, 4038 HZ, info->idle_stats.recv_bytes,
5201 (cur_jifs - info->idle_stats.recv_idle)/ 4039 (cur_jifs - info->idle_stats.recv_idle)/
5202 HZ, info->idle_stats.overruns, 4040 HZ, info->idle_stats.overruns,
5203 /* FIXME: double check locking */ 4041 num);
5204 (long)info->port.tty->ldisc->ops->num); 4042 } else
5205 else
5206 seq_printf(m, "%3d %8lu %10lu %8lu " 4043 seq_printf(m, "%3d %8lu %10lu %8lu "
5207 "%10lu %8lu %9lu %6ld\n", 4044 "%10lu %8lu %9lu %6ld\n",
5208 info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L); 4045 info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
diff --git a/drivers/char/epca.c b/drivers/char/epca.c
index ff647ca1c489..9d589e3144de 100644
--- a/drivers/char/epca.c
+++ b/drivers/char/epca.c
@@ -2239,7 +2239,7 @@ static void do_softint(struct work_struct *work)
2239 struct channel *ch = container_of(work, struct channel, tqueue); 2239 struct channel *ch = container_of(work, struct channel, tqueue);
2240 /* Called in response to a modem change event */ 2240 /* Called in response to a modem change event */
2241 if (ch && ch->magic == EPCA_MAGIC) { 2241 if (ch && ch->magic == EPCA_MAGIC) {
2242 struct tty_struct *tty = tty_port_tty_get(&ch->port);; 2242 struct tty_struct *tty = tty_port_tty_get(&ch->port);
2243 2243
2244 if (tty && tty->driver_data) { 2244 if (tty && tty->driver_data) {
2245 if (test_and_clear_bit(EPCA_EVENT_HANGUP, &ch->event)) { 2245 if (test_and_clear_bit(EPCA_EVENT_HANGUP, &ch->event)) {
diff --git a/drivers/char/esp.c b/drivers/char/esp.c
index a5c59fc2b0ff..b19d43cd9542 100644
--- a/drivers/char/esp.c
+++ b/drivers/char/esp.c
@@ -572,7 +572,7 @@ static void check_modem_status(struct esp_struct *info)
572 info->icount.dcd++; 572 info->icount.dcd++;
573 if (status & UART_MSR_DCTS) 573 if (status & UART_MSR_DCTS)
574 info->icount.cts++; 574 info->icount.cts++;
575 wake_up_interruptible(&info->delta_msr_wait); 575 wake_up_interruptible(&info->port.delta_msr_wait);
576 } 576 }
577 577
578 if ((info->port.flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) { 578 if ((info->port.flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) {
@@ -927,7 +927,7 @@ static void shutdown(struct esp_struct *info)
927 * clear delta_msr_wait queue to avoid mem leaks: we may free the irq 927 * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
928 * here so the queue might never be waken up 928 * here so the queue might never be waken up
929 */ 929 */
930 wake_up_interruptible(&info->delta_msr_wait); 930 wake_up_interruptible(&info->port.delta_msr_wait);
931 wake_up_interruptible(&info->break_wait); 931 wake_up_interruptible(&info->break_wait);
932 932
933 /* stop a DMA transfer on the port being closed */ 933 /* stop a DMA transfer on the port being closed */
@@ -1800,7 +1800,7 @@ static int rs_ioctl(struct tty_struct *tty, struct file *file,
1800 spin_unlock_irqrestore(&info->lock, flags); 1800 spin_unlock_irqrestore(&info->lock, flags);
1801 while (1) { 1801 while (1) {
1802 /* FIXME: convert to new style wakeup */ 1802 /* FIXME: convert to new style wakeup */
1803 interruptible_sleep_on(&info->delta_msr_wait); 1803 interruptible_sleep_on(&info->port.delta_msr_wait);
1804 /* see if a signal did it */ 1804 /* see if a signal did it */
1805 if (signal_pending(current)) 1805 if (signal_pending(current))
1806 return -ERESTARTSYS; 1806 return -ERESTARTSYS;
@@ -2452,7 +2452,6 @@ static int __init espserial_init(void)
2452 info->config.flow_off = flow_off; 2452 info->config.flow_off = flow_off;
2453 info->config.pio_threshold = pio_threshold; 2453 info->config.pio_threshold = pio_threshold;
2454 info->next_port = ports; 2454 info->next_port = ports;
2455 init_waitqueue_head(&info->delta_msr_wait);
2456 init_waitqueue_head(&info->break_wait); 2455 init_waitqueue_head(&info->break_wait);
2457 ports = info; 2456 ports = info;
2458 printk(KERN_INFO "ttyP%d at 0x%04x (irq = %d) is an ESP ", 2457 printk(KERN_INFO "ttyP%d at 0x%04x (irq = %d) is an ESP ",
diff --git a/drivers/char/hw_random/core.c b/drivers/char/hw_random/core.c
index fc93e2fc7c71..1573aebd54b5 100644
--- a/drivers/char/hw_random/core.c
+++ b/drivers/char/hw_random/core.c
@@ -153,7 +153,7 @@ static const struct file_operations rng_chrdev_ops = {
153static struct miscdevice rng_miscdev = { 153static struct miscdevice rng_miscdev = {
154 .minor = RNG_MISCDEV_MINOR, 154 .minor = RNG_MISCDEV_MINOR,
155 .name = RNG_MODULE_NAME, 155 .name = RNG_MODULE_NAME,
156 .devnode = "hwrng", 156 .nodename = "hwrng",
157 .fops = &rng_chrdev_ops, 157 .fops = &rng_chrdev_ops,
158}; 158};
159 159
diff --git a/drivers/char/hw_random/virtio-rng.c b/drivers/char/hw_random/virtio-rng.c
index 32216b623248..962968f05b94 100644
--- a/drivers/char/hw_random/virtio-rng.c
+++ b/drivers/char/hw_random/virtio-rng.c
@@ -21,6 +21,7 @@
21#include <linux/scatterlist.h> 21#include <linux/scatterlist.h>
22#include <linux/spinlock.h> 22#include <linux/spinlock.h>
23#include <linux/virtio.h> 23#include <linux/virtio.h>
24#include <linux/virtio_ids.h>
24#include <linux/virtio_rng.h> 25#include <linux/virtio_rng.h>
25 26
26/* The host will fill any buffer we give it with sweet, sweet randomness. We 27/* The host will fill any buffer we give it with sweet, sweet randomness. We
@@ -51,7 +52,7 @@ static void register_buffer(void)
51 52
52 sg_init_one(&sg, random_data+data_left, RANDOM_DATA_SIZE-data_left); 53 sg_init_one(&sg, random_data+data_left, RANDOM_DATA_SIZE-data_left);
53 /* There should always be room for one buffer. */ 54 /* There should always be room for one buffer. */
54 if (vq->vq_ops->add_buf(vq, &sg, 0, 1, random_data) != 0) 55 if (vq->vq_ops->add_buf(vq, &sg, 0, 1, random_data) < 0)
55 BUG(); 56 BUG();
56 vq->vq_ops->kick(vq); 57 vq->vq_ops->kick(vq);
57} 58}
diff --git a/drivers/char/ipmi/ipmi_poweroff.c b/drivers/char/ipmi/ipmi_poweroff.c
index a261bd735dfb..2e66b5f773dd 100644
--- a/drivers/char/ipmi/ipmi_poweroff.c
+++ b/drivers/char/ipmi/ipmi_poweroff.c
@@ -691,7 +691,7 @@ static struct ctl_table_header *ipmi_table_header;
691/* 691/*
692 * Startup and shutdown functions. 692 * Startup and shutdown functions.
693 */ 693 */
694static int ipmi_poweroff_init(void) 694static int __init ipmi_poweroff_init(void)
695{ 695{
696 int rv; 696 int rv;
697 697
@@ -725,7 +725,7 @@ static int ipmi_poweroff_init(void)
725} 725}
726 726
727#ifdef MODULE 727#ifdef MODULE
728static __exit void ipmi_poweroff_cleanup(void) 728static void __exit ipmi_poweroff_cleanup(void)
729{ 729{
730 int rv; 730 int rv;
731 731
diff --git a/drivers/char/isicom.c b/drivers/char/isicom.c
index 4f1f4cd670da..426bfdd7f3e0 100644
--- a/drivers/char/isicom.c
+++ b/drivers/char/isicom.c
@@ -846,37 +846,53 @@ static int isicom_carrier_raised(struct tty_port *port)
846 return (ip->status & ISI_DCD)?1 : 0; 846 return (ip->status & ISI_DCD)?1 : 0;
847} 847}
848 848
849static int isicom_open(struct tty_struct *tty, struct file *filp) 849static struct tty_port *isicom_find_port(struct tty_struct *tty)
850{ 850{
851 struct isi_port *port; 851 struct isi_port *port;
852 struct isi_board *card; 852 struct isi_board *card;
853 unsigned int board; 853 unsigned int board;
854 int error, line; 854 int line = tty->index;
855 855
856 line = tty->index;
857 if (line < 0 || line > PORT_COUNT-1) 856 if (line < 0 || line > PORT_COUNT-1)
858 return -ENODEV; 857 return NULL;
859 board = BOARD(line); 858 board = BOARD(line);
860 card = &isi_card[board]; 859 card = &isi_card[board];
861 860
862 if (!(card->status & FIRMWARE_LOADED)) 861 if (!(card->status & FIRMWARE_LOADED))
863 return -ENODEV; 862 return NULL;
864 863
865 /* open on a port greater than the port count for the card !!! */ 864 /* open on a port greater than the port count for the card !!! */
866 if (line > ((board * 16) + card->port_count - 1)) 865 if (line > ((board * 16) + card->port_count - 1))
867 return -ENODEV; 866 return NULL;
868 867
869 port = &isi_ports[line]; 868 port = &isi_ports[line];
870 if (isicom_paranoia_check(port, tty->name, "isicom_open")) 869 if (isicom_paranoia_check(port, tty->name, "isicom_open"))
871 return -ENODEV; 870 return NULL;
872 871
872 return &port->port;
873}
874
875static int isicom_open(struct tty_struct *tty, struct file *filp)
876{
877 struct isi_port *port;
878 struct isi_board *card;
879 struct tty_port *tport;
880 int error = 0;
881
882 tport = isicom_find_port(tty);
883 if (tport == NULL)
884 return -ENODEV;
885 port = container_of(tport, struct isi_port, port);
886 card = &isi_card[BOARD(tty->index)];
873 isicom_setup_board(card); 887 isicom_setup_board(card);
874 888
875 /* FIXME: locking on port.count etc */ 889 /* FIXME: locking on port.count etc */
876 port->port.count++; 890 port->port.count++;
877 tty->driver_data = port; 891 tty->driver_data = port;
878 tty_port_tty_set(&port->port, tty); 892 tty_port_tty_set(&port->port, tty);
879 error = isicom_setup_port(tty); 893 /* FIXME: Locking on Initialized flag */
894 if (!test_bit(ASYNCB_INITIALIZED, &tport->flags))
895 error = isicom_setup_port(tty);
880 if (error == 0) 896 if (error == 0)
881 error = tty_port_block_til_ready(&port->port, tty, filp); 897 error = tty_port_block_til_ready(&port->port, tty, filp);
882 return error; 898 return error;
@@ -952,19 +968,12 @@ static void isicom_flush_buffer(struct tty_struct *tty)
952 tty_wakeup(tty); 968 tty_wakeup(tty);
953} 969}
954 970
955static void isicom_close(struct tty_struct *tty, struct file *filp) 971static void isicom_close_port(struct tty_port *port)
956{ 972{
957 struct isi_port *ip = tty->driver_data; 973 struct isi_port *ip = container_of(port, struct isi_port, port);
958 struct tty_port *port = &ip->port; 974 struct isi_board *card = ip->card;
959 struct isi_board *card;
960 unsigned long flags; 975 unsigned long flags;
961 976
962 BUG_ON(!ip);
963
964 card = ip->card;
965 if (isicom_paranoia_check(ip, tty->name, "isicom_close"))
966 return;
967
968 /* indicate to the card that no more data can be received 977 /* indicate to the card that no more data can be received
969 on this port */ 978 on this port */
970 spin_lock_irqsave(&card->card_lock, flags); 979 spin_lock_irqsave(&card->card_lock, flags);
@@ -974,9 +983,19 @@ static void isicom_close(struct tty_struct *tty, struct file *filp)
974 } 983 }
975 isicom_shutdown_port(ip); 984 isicom_shutdown_port(ip);
976 spin_unlock_irqrestore(&card->card_lock, flags); 985 spin_unlock_irqrestore(&card->card_lock, flags);
986}
987
988static void isicom_close(struct tty_struct *tty, struct file *filp)
989{
990 struct isi_port *ip = tty->driver_data;
991 struct tty_port *port = &ip->port;
992 if (isicom_paranoia_check(ip, tty->name, "isicom_close"))
993 return;
977 994
995 if (tty_port_close_start(port, tty, filp) == 0)
996 return;
997 isicom_close_port(port);
978 isicom_flush_buffer(tty); 998 isicom_flush_buffer(tty);
979
980 tty_port_close_end(port, tty); 999 tty_port_close_end(port, tty);
981} 1000}
982 1001
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 0491cdf63f2a..0aede1d6a9ea 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -866,24 +866,25 @@ static const struct file_operations kmsg_fops = {
866 866
867static const struct memdev { 867static const struct memdev {
868 const char *name; 868 const char *name;
869 mode_t mode;
869 const struct file_operations *fops; 870 const struct file_operations *fops;
870 struct backing_dev_info *dev_info; 871 struct backing_dev_info *dev_info;
871} devlist[] = { 872} devlist[] = {
872 [ 1] = { "mem", &mem_fops, &directly_mappable_cdev_bdi }, 873 [1] = { "mem", 0, &mem_fops, &directly_mappable_cdev_bdi },
873#ifdef CONFIG_DEVKMEM 874#ifdef CONFIG_DEVKMEM
874 [ 2] = { "kmem", &kmem_fops, &directly_mappable_cdev_bdi }, 875 [2] = { "kmem", 0, &kmem_fops, &directly_mappable_cdev_bdi },
875#endif 876#endif
876 [ 3] = {"null", &null_fops, NULL }, 877 [3] = { "null", 0666, &null_fops, NULL },
877#ifdef CONFIG_DEVPORT 878#ifdef CONFIG_DEVPORT
878 [ 4] = { "port", &port_fops, NULL }, 879 [4] = { "port", 0, &port_fops, NULL },
879#endif 880#endif
880 [ 5] = { "zero", &zero_fops, &zero_bdi }, 881 [5] = { "zero", 0666, &zero_fops, &zero_bdi },
881 [ 7] = { "full", &full_fops, NULL }, 882 [7] = { "full", 0666, &full_fops, NULL },
882 [ 8] = { "random", &random_fops, NULL }, 883 [8] = { "random", 0666, &random_fops, NULL },
883 [ 9] = { "urandom", &urandom_fops, NULL }, 884 [9] = { "urandom", 0666, &urandom_fops, NULL },
884 [11] = { "kmsg", &kmsg_fops, NULL }, 885 [11] = { "kmsg", 0, &kmsg_fops, NULL },
885#ifdef CONFIG_CRASH_DUMP 886#ifdef CONFIG_CRASH_DUMP
886 [12] = { "oldmem", &oldmem_fops, NULL }, 887 [12] = { "oldmem", 0, &oldmem_fops, NULL },
887#endif 888#endif
888}; 889};
889 890
@@ -920,6 +921,13 @@ static const struct file_operations memory_fops = {
920 .open = memory_open, 921 .open = memory_open,
921}; 922};
922 923
924static char *mem_devnode(struct device *dev, mode_t *mode)
925{
926 if (mode && devlist[MINOR(dev->devt)].mode)
927 *mode = devlist[MINOR(dev->devt)].mode;
928 return NULL;
929}
930
923static struct class *mem_class; 931static struct class *mem_class;
924 932
925static int __init chr_dev_init(void) 933static int __init chr_dev_init(void)
@@ -935,6 +943,7 @@ static int __init chr_dev_init(void)
935 printk("unable to get major %d for memory devs\n", MEM_MAJOR); 943 printk("unable to get major %d for memory devs\n", MEM_MAJOR);
936 944
937 mem_class = class_create(THIS_MODULE, "mem"); 945 mem_class = class_create(THIS_MODULE, "mem");
946 mem_class->devnode = mem_devnode;
938 for (minor = 1; minor < ARRAY_SIZE(devlist); minor++) { 947 for (minor = 1; minor < ARRAY_SIZE(devlist); minor++) {
939 if (!devlist[minor].name) 948 if (!devlist[minor].name)
940 continue; 949 continue;
diff --git a/drivers/char/misc.c b/drivers/char/misc.c
index 62c99fa59e2b..07fa612a58d5 100644
--- a/drivers/char/misc.c
+++ b/drivers/char/misc.c
@@ -91,7 +91,7 @@ static int misc_seq_show(struct seq_file *seq, void *v)
91} 91}
92 92
93 93
94static struct seq_operations misc_seq_ops = { 94static const struct seq_operations misc_seq_ops = {
95 .start = misc_seq_start, 95 .start = misc_seq_start,
96 .next = misc_seq_next, 96 .next = misc_seq_next,
97 .stop = misc_seq_stop, 97 .stop = misc_seq_stop,
@@ -263,12 +263,14 @@ int misc_deregister(struct miscdevice *misc)
263EXPORT_SYMBOL(misc_register); 263EXPORT_SYMBOL(misc_register);
264EXPORT_SYMBOL(misc_deregister); 264EXPORT_SYMBOL(misc_deregister);
265 265
266static char *misc_nodename(struct device *dev) 266static char *misc_devnode(struct device *dev, mode_t *mode)
267{ 267{
268 struct miscdevice *c = dev_get_drvdata(dev); 268 struct miscdevice *c = dev_get_drvdata(dev);
269 269
270 if (c->devnode) 270 if (mode && c->mode)
271 return kstrdup(c->devnode, GFP_KERNEL); 271 *mode = c->mode;
272 if (c->nodename)
273 return kstrdup(c->nodename, GFP_KERNEL);
272 return NULL; 274 return NULL;
273} 275}
274 276
@@ -287,7 +289,7 @@ static int __init misc_init(void)
287 err = -EIO; 289 err = -EIO;
288 if (register_chrdev(MISC_MAJOR,"misc",&misc_fops)) 290 if (register_chrdev(MISC_MAJOR,"misc",&misc_fops))
289 goto fail_printk; 291 goto fail_printk;
290 misc_class->nodename = misc_nodename; 292 misc_class->devnode = misc_devnode;
291 return 0; 293 return 0;
292 294
293fail_printk: 295fail_printk:
diff --git a/drivers/char/mxser.c b/drivers/char/mxser.c
index dbf8d52f31d0..5e28d39b9e81 100644
--- a/drivers/char/mxser.c
+++ b/drivers/char/mxser.c
@@ -48,7 +48,7 @@
48 48
49#include "mxser.h" 49#include "mxser.h"
50 50
51#define MXSER_VERSION "2.0.4" /* 1.12 */ 51#define MXSER_VERSION "2.0.5" /* 1.14 */
52#define MXSERMAJOR 174 52#define MXSERMAJOR 174
53 53
54#define MXSER_BOARDS 4 /* Max. boards */ 54#define MXSER_BOARDS 4 /* Max. boards */
@@ -69,6 +69,7 @@
69#define PCI_DEVICE_ID_POS104UL 0x1044 69#define PCI_DEVICE_ID_POS104UL 0x1044
70#define PCI_DEVICE_ID_CB108 0x1080 70#define PCI_DEVICE_ID_CB108 0x1080
71#define PCI_DEVICE_ID_CP102UF 0x1023 71#define PCI_DEVICE_ID_CP102UF 0x1023
72#define PCI_DEVICE_ID_CP112UL 0x1120
72#define PCI_DEVICE_ID_CB114 0x1142 73#define PCI_DEVICE_ID_CB114 0x1142
73#define PCI_DEVICE_ID_CP114UL 0x1143 74#define PCI_DEVICE_ID_CP114UL 0x1143
74#define PCI_DEVICE_ID_CB134I 0x1341 75#define PCI_DEVICE_ID_CB134I 0x1341
@@ -139,7 +140,8 @@ static const struct mxser_cardinfo mxser_cards[] = {
139 { "CP-138U series", 8, }, 140 { "CP-138U series", 8, },
140 { "POS-104UL series", 4, }, 141 { "POS-104UL series", 4, },
141 { "CP-114UL series", 4, }, 142 { "CP-114UL series", 4, },
142/*30*/ { "CP-102UF series", 2, } 143/*30*/ { "CP-102UF series", 2, },
144 { "CP-112UL series", 2, },
143}; 145};
144 146
145/* driver_data correspond to the lines in the structure above 147/* driver_data correspond to the lines in the structure above
@@ -170,6 +172,7 @@ static struct pci_device_id mxser_pcibrds[] = {
170 { PCI_VDEVICE(MOXA, PCI_DEVICE_ID_POS104UL), .driver_data = 28 }, 172 { PCI_VDEVICE(MOXA, PCI_DEVICE_ID_POS104UL), .driver_data = 28 },
171 { PCI_VDEVICE(MOXA, PCI_DEVICE_ID_CP114UL), .driver_data = 29 }, 173 { PCI_VDEVICE(MOXA, PCI_DEVICE_ID_CP114UL), .driver_data = 29 },
172 { PCI_VDEVICE(MOXA, PCI_DEVICE_ID_CP102UF), .driver_data = 30 }, 174 { PCI_VDEVICE(MOXA, PCI_DEVICE_ID_CP102UF), .driver_data = 30 },
175 { PCI_VDEVICE(MOXA, PCI_DEVICE_ID_CP112UL), .driver_data = 31 },
173 { } 176 { }
174}; 177};
175MODULE_DEVICE_TABLE(pci, mxser_pcibrds); 178MODULE_DEVICE_TABLE(pci, mxser_pcibrds);
@@ -258,7 +261,6 @@ struct mxser_port {
258 struct mxser_mon mon_data; 261 struct mxser_mon mon_data;
259 262
260 spinlock_t slock; 263 spinlock_t slock;
261 wait_queue_head_t delta_msr_wait;
262}; 264};
263 265
264struct mxser_board { 266struct mxser_board {
@@ -818,7 +820,7 @@ static void mxser_check_modem_status(struct tty_struct *tty,
818 if (status & UART_MSR_DCTS) 820 if (status & UART_MSR_DCTS)
819 port->icount.cts++; 821 port->icount.cts++;
820 port->mon_data.modem_status = status; 822 port->mon_data.modem_status = status;
821 wake_up_interruptible(&port->delta_msr_wait); 823 wake_up_interruptible(&port->port.delta_msr_wait);
822 824
823 if ((port->port.flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) { 825 if ((port->port.flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) {
824 if (status & UART_MSR_DCD) 826 if (status & UART_MSR_DCD)
@@ -973,7 +975,7 @@ static void mxser_shutdown(struct tty_struct *tty)
973 * clear delta_msr_wait queue to avoid mem leaks: we may free the irq 975 * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
974 * here so the queue might never be waken up 976 * here so the queue might never be waken up
975 */ 977 */
976 wake_up_interruptible(&info->delta_msr_wait); 978 wake_up_interruptible(&info->port.delta_msr_wait);
977 979
978 /* 980 /*
979 * Free the IRQ, if necessary 981 * Free the IRQ, if necessary
@@ -1073,34 +1075,17 @@ static void mxser_flush_buffer(struct tty_struct *tty)
1073} 1075}
1074 1076
1075 1077
1076/* 1078static void mxser_close_port(struct tty_struct *tty, struct tty_port *port)
1077 * This routine is called when the serial port gets closed. First, we
1078 * wait for the last remaining data to be sent. Then, we unlink its
1079 * async structure from the interrupt chain if necessary, and we free
1080 * that IRQ if nothing is left in the chain.
1081 */
1082static void mxser_close(struct tty_struct *tty, struct file *filp)
1083{ 1079{
1084 struct mxser_port *info = tty->driver_data; 1080 struct mxser_port *info = container_of(port, struct mxser_port, port);
1085 struct tty_port *port = &info->port;
1086
1087 unsigned long timeout; 1081 unsigned long timeout;
1088
1089 if (tty->index == MXSER_PORTS)
1090 return;
1091 if (!info)
1092 return;
1093
1094 if (tty_port_close_start(port, tty, filp) == 0)
1095 return;
1096
1097 /* 1082 /*
1098 * Save the termios structure, since this port may have 1083 * Save the termios structure, since this port may have
1099 * separate termios for callout and dialin. 1084 * separate termios for callout and dialin.
1100 * 1085 *
1101 * FIXME: Can this go ? 1086 * FIXME: Can this go ?
1102 */ 1087 */
1103 if (info->port.flags & ASYNC_NORMAL_ACTIVE) 1088 if (port->flags & ASYNC_NORMAL_ACTIVE)
1104 info->normal_termios = *tty->termios; 1089 info->normal_termios = *tty->termios;
1105 /* 1090 /*
1106 * At this point we stop accepting input. To do this, we 1091 * At this point we stop accepting input. To do this, we
@@ -1112,7 +1097,7 @@ static void mxser_close(struct tty_struct *tty, struct file *filp)
1112 if (info->board->chip_flag) 1097 if (info->board->chip_flag)
1113 info->IER &= ~MOXA_MUST_RECV_ISR; 1098 info->IER &= ~MOXA_MUST_RECV_ISR;
1114 1099
1115 if (info->port.flags & ASYNC_INITIALIZED) { 1100 if (port->flags & ASYNC_INITIALIZED) {
1116 outb(info->IER, info->ioaddr + UART_IER); 1101 outb(info->IER, info->ioaddr + UART_IER);
1117 /* 1102 /*
1118 * Before we drop DTR, make sure the UART transmitter 1103 * Before we drop DTR, make sure the UART transmitter
@@ -1127,8 +1112,26 @@ static void mxser_close(struct tty_struct *tty, struct file *filp)
1127 } 1112 }
1128 } 1113 }
1129 mxser_shutdown(tty); 1114 mxser_shutdown(tty);
1130 mxser_flush_buffer(tty);
1131 1115
1116}
1117
1118/*
1119 * This routine is called when the serial port gets closed. First, we
1120 * wait for the last remaining data to be sent. Then, we unlink its
1121 * async structure from the interrupt chain if necessary, and we free
1122 * that IRQ if nothing is left in the chain.
1123 */
1124static void mxser_close(struct tty_struct *tty, struct file *filp)
1125{
1126 struct mxser_port *info = tty->driver_data;
1127 struct tty_port *port = &info->port;
1128
1129 if (tty->index == MXSER_PORTS)
1130 return;
1131 if (tty_port_close_start(port, tty, filp) == 0)
1132 return;
1133 mxser_close_port(tty, port);
1134 mxser_flush_buffer(tty);
1132 /* Right now the tty_port set is done outside of the close_end helper 1135 /* Right now the tty_port set is done outside of the close_end helper
1133 as we don't yet have everyone using refcounts */ 1136 as we don't yet have everyone using refcounts */
1134 tty_port_close_end(port, tty); 1137 tty_port_close_end(port, tty);
@@ -1761,7 +1764,7 @@ static int mxser_ioctl(struct tty_struct *tty, struct file *file,
1761 cnow = info->icount; /* note the counters on entry */ 1764 cnow = info->icount; /* note the counters on entry */
1762 spin_unlock_irqrestore(&info->slock, flags); 1765 spin_unlock_irqrestore(&info->slock, flags);
1763 1766
1764 return wait_event_interruptible(info->delta_msr_wait, 1767 return wait_event_interruptible(info->port.delta_msr_wait,
1765 mxser_cflags_changed(info, arg, &cnow)); 1768 mxser_cflags_changed(info, arg, &cnow));
1766 /* 1769 /*
1767 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS) 1770 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
@@ -1803,7 +1806,7 @@ static int mxser_ioctl(struct tty_struct *tty, struct file *file,
1803 1806
1804 lock_kernel(); 1807 lock_kernel();
1805 len = mxser_chars_in_buffer(tty); 1808 len = mxser_chars_in_buffer(tty);
1806 lsr = inb(info->ioaddr + UART_LSR) & UART_LSR_TEMT; 1809 lsr = inb(info->ioaddr + UART_LSR) & UART_LSR_THRE;
1807 len += (lsr ? 0 : 1); 1810 len += (lsr ? 0 : 1);
1808 unlock_kernel(); 1811 unlock_kernel();
1809 1812
@@ -2413,7 +2416,6 @@ static int __devinit mxser_initbrd(struct mxser_board *brd,
2413 info->port.close_delay = 5 * HZ / 10; 2416 info->port.close_delay = 5 * HZ / 10;
2414 info->port.closing_wait = 30 * HZ; 2417 info->port.closing_wait = 30 * HZ;
2415 info->normal_termios = mxvar_sdriver->init_termios; 2418 info->normal_termios = mxvar_sdriver->init_termios;
2416 init_waitqueue_head(&info->delta_msr_wait);
2417 memset(&info->mon_data, 0, sizeof(struct mxser_mon)); 2419 memset(&info->mon_data, 0, sizeof(struct mxser_mon));
2418 info->err_shadow = 0; 2420 info->err_shadow = 0;
2419 spin_lock_init(&info->slock); 2421 spin_lock_init(&info->slock);
diff --git a/drivers/char/n_tty.c b/drivers/char/n_tty.c
index 4e28b35024ec..2e50f4dfc79c 100644
--- a/drivers/char/n_tty.c
+++ b/drivers/char/n_tty.c
@@ -272,7 +272,8 @@ static inline int is_continuation(unsigned char c, struct tty_struct *tty)
272 * 272 *
273 * This is a helper function that handles one output character 273 * This is a helper function that handles one output character
274 * (including special characters like TAB, CR, LF, etc.), 274 * (including special characters like TAB, CR, LF, etc.),
275 * putting the results in the tty driver's write buffer. 275 * doing OPOST processing and putting the results in the
276 * tty driver's write buffer.
276 * 277 *
277 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY 278 * Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
278 * and NLDLY. They simply aren't relevant in the world today. 279 * and NLDLY. They simply aren't relevant in the world today.
@@ -350,8 +351,9 @@ static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
350 * @c: character (or partial unicode symbol) 351 * @c: character (or partial unicode symbol)
351 * @tty: terminal device 352 * @tty: terminal device
352 * 353 *
353 * Perform OPOST processing. Returns -1 when the output device is 354 * Output one character with OPOST processing.
354 * full and the character must be retried. 355 * Returns -1 when the output device is full and the character
356 * must be retried.
355 * 357 *
356 * Locking: output_lock to protect column state and space left 358 * Locking: output_lock to protect column state and space left
357 * (also, this is called from n_tty_write under the 359 * (also, this is called from n_tty_write under the
@@ -377,8 +379,11 @@ static int process_output(unsigned char c, struct tty_struct *tty)
377/** 379/**
378 * process_output_block - block post processor 380 * process_output_block - block post processor
379 * @tty: terminal device 381 * @tty: terminal device
380 * @inbuf: user buffer 382 * @buf: character buffer
381 * @nr: number of bytes 383 * @nr: number of bytes to output
384 *
385 * Output a block of characters with OPOST processing.
386 * Returns the number of characters output.
382 * 387 *
383 * This path is used to speed up block console writes, among other 388 * This path is used to speed up block console writes, among other
384 * things when processing blocks of output data. It handles only 389 * things when processing blocks of output data. It handles only
@@ -571,33 +576,23 @@ static void process_echoes(struct tty_struct *tty)
571 break; 576 break;
572 577
573 default: 578 default:
574 if (iscntrl(op)) {
575 if (L_ECHOCTL(tty)) {
576 /*
577 * Ensure there is enough space
578 * for the whole ctrl pair.
579 */
580 if (space < 2) {
581 no_space_left = 1;
582 break;
583 }
584 tty_put_char(tty, '^');
585 tty_put_char(tty, op ^ 0100);
586 tty->column += 2;
587 space -= 2;
588 } else {
589 if (!space) {
590 no_space_left = 1;
591 break;
592 }
593 tty_put_char(tty, op);
594 space--;
595 }
596 }
597 /* 579 /*
598 * If above falls through, this was an 580 * If the op is not a special byte code,
599 * undefined op. 581 * it is a ctrl char tagged to be echoed
582 * as "^X" (where X is the letter
583 * representing the control char).
584 * Note that we must ensure there is
585 * enough space for the whole ctrl pair.
586 *
600 */ 587 */
588 if (space < 2) {
589 no_space_left = 1;
590 break;
591 }
592 tty_put_char(tty, '^');
593 tty_put_char(tty, op ^ 0100);
594 tty->column += 2;
595 space -= 2;
601 cp += 2; 596 cp += 2;
602 nr -= 2; 597 nr -= 2;
603 } 598 }
@@ -605,12 +600,18 @@ static void process_echoes(struct tty_struct *tty)
605 if (no_space_left) 600 if (no_space_left)
606 break; 601 break;
607 } else { 602 } else {
608 int retval; 603 if (O_OPOST(tty) &&
609 604 !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
610 retval = do_output_char(c, tty, space); 605 int retval = do_output_char(c, tty, space);
611 if (retval < 0) 606 if (retval < 0)
612 break; 607 break;
613 space -= retval; 608 space -= retval;
609 } else {
610 if (!space)
611 break;
612 tty_put_char(tty, c);
613 space -= 1;
614 }
614 cp += 1; 615 cp += 1;
615 nr -= 1; 616 nr -= 1;
616 } 617 }
@@ -798,8 +799,8 @@ static void echo_char_raw(unsigned char c, struct tty_struct *tty)
798 * Echo user input back onto the screen. This must be called only when 799 * Echo user input back onto the screen. This must be called only when
799 * L_ECHO(tty) is true. Called from the driver receive_buf path. 800 * L_ECHO(tty) is true. Called from the driver receive_buf path.
800 * 801 *
801 * This variant tags control characters to be possibly echoed as 802 * This variant tags control characters to be echoed as "^X"
802 * as "^X" (where X is the letter representing the control char). 803 * (where X is the letter representing the control char).
803 * 804 *
804 * Locking: echo_lock to protect the echo buffer 805 * Locking: echo_lock to protect the echo buffer
805 */ 806 */
@@ -812,7 +813,7 @@ static void echo_char(unsigned char c, struct tty_struct *tty)
812 add_echo_byte(ECHO_OP_START, tty); 813 add_echo_byte(ECHO_OP_START, tty);
813 add_echo_byte(ECHO_OP_START, tty); 814 add_echo_byte(ECHO_OP_START, tty);
814 } else { 815 } else {
815 if (iscntrl(c) && c != '\t') 816 if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
816 add_echo_byte(ECHO_OP_START, tty); 817 add_echo_byte(ECHO_OP_START, tty);
817 add_echo_byte(c, tty); 818 add_echo_byte(c, tty);
818 } 819 }
diff --git a/drivers/char/pcmcia/cm4000_cs.c b/drivers/char/pcmcia/cm4000_cs.c
index 881934c068c8..c250a31efa53 100644
--- a/drivers/char/pcmcia/cm4000_cs.c
+++ b/drivers/char/pcmcia/cm4000_cs.c
@@ -1017,7 +1017,7 @@ static ssize_t cmm_read(struct file *filp, __user char *buf, size_t count,
1017 } 1017 }
1018 } 1018 }
1019 1019
1020 if (dev->proto == 0 && count > dev->rlen - dev->rpos) { 1020 if (dev->proto == 0 && count > dev->rlen - dev->rpos && i) {
1021 DEBUGP(4, dev, "T=0 and count > buffer\n"); 1021 DEBUGP(4, dev, "T=0 and count > buffer\n");
1022 dev->rbuf[i] = dev->rbuf[i - 1]; 1022 dev->rbuf[i] = dev->rbuf[i - 1];
1023 dev->rbuf[i - 1] = dev->procbyte; 1023 dev->rbuf[i - 1] = dev->procbyte;
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index 40268db02e22..64acd05f71c8 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -261,7 +261,7 @@ static const struct file_operations raw_ctl_fops = {
261 261
262static struct cdev raw_cdev; 262static struct cdev raw_cdev;
263 263
264static char *raw_nodename(struct device *dev) 264static char *raw_devnode(struct device *dev, mode_t *mode)
265{ 265{
266 return kasprintf(GFP_KERNEL, "raw/%s", dev_name(dev)); 266 return kasprintf(GFP_KERNEL, "raw/%s", dev_name(dev));
267} 267}
@@ -289,7 +289,7 @@ static int __init raw_init(void)
289 ret = PTR_ERR(raw_class); 289 ret = PTR_ERR(raw_class);
290 goto error_region; 290 goto error_region;
291 } 291 }
292 raw_class->nodename = raw_nodename; 292 raw_class->devnode = raw_devnode;
293 device_create(raw_class, NULL, MKDEV(RAW_MAJOR, 0), NULL, "rawctl"); 293 device_create(raw_class, NULL, MKDEV(RAW_MAJOR, 0), NULL, "rawctl");
294 294
295 return 0; 295 return 0;
diff --git a/drivers/char/riscom8.c b/drivers/char/riscom8.c
index 171711acf5cd..3cfa22d469e0 100644
--- a/drivers/char/riscom8.c
+++ b/drivers/char/riscom8.c
@@ -343,7 +343,7 @@ static void rc_receive_exc(struct riscom_board const *bp)
343 if (port == NULL) 343 if (port == NULL)
344 return; 344 return;
345 345
346 tty = port->port.tty; 346 tty = tty_port_tty_get(&port->port);
347 347
348#ifdef RC_REPORT_OVERRUN 348#ifdef RC_REPORT_OVERRUN
349 status = rc_in(bp, CD180_RCSR); 349 status = rc_in(bp, CD180_RCSR);
@@ -355,18 +355,18 @@ static void rc_receive_exc(struct riscom_board const *bp)
355#endif 355#endif
356 ch = rc_in(bp, CD180_RDR); 356 ch = rc_in(bp, CD180_RDR);
357 if (!status) 357 if (!status)
358 return; 358 goto out;
359 if (status & RCSR_TOUT) { 359 if (status & RCSR_TOUT) {
360 printk(KERN_WARNING "rc%d: port %d: Receiver timeout. " 360 printk(KERN_WARNING "rc%d: port %d: Receiver timeout. "
361 "Hardware problems ?\n", 361 "Hardware problems ?\n",
362 board_No(bp), port_No(port)); 362 board_No(bp), port_No(port));
363 return; 363 goto out;
364 364
365 } else if (status & RCSR_BREAK) { 365 } else if (status & RCSR_BREAK) {
366 printk(KERN_INFO "rc%d: port %d: Handling break...\n", 366 printk(KERN_INFO "rc%d: port %d: Handling break...\n",
367 board_No(bp), port_No(port)); 367 board_No(bp), port_No(port));
368 flag = TTY_BREAK; 368 flag = TTY_BREAK;
369 if (port->port.flags & ASYNC_SAK) 369 if (tty && (port->port.flags & ASYNC_SAK))
370 do_SAK(tty); 370 do_SAK(tty);
371 371
372 } else if (status & RCSR_PE) 372 } else if (status & RCSR_PE)
@@ -380,8 +380,12 @@ static void rc_receive_exc(struct riscom_board const *bp)
380 else 380 else
381 flag = TTY_NORMAL; 381 flag = TTY_NORMAL;
382 382
383 tty_insert_flip_char(tty, ch, flag); 383 if (tty) {
384 tty_flip_buffer_push(tty); 384 tty_insert_flip_char(tty, ch, flag);
385 tty_flip_buffer_push(tty);
386 }
387out:
388 tty_kref_put(tty);
385} 389}
386 390
387static void rc_receive(struct riscom_board const *bp) 391static void rc_receive(struct riscom_board const *bp)
@@ -394,7 +398,7 @@ static void rc_receive(struct riscom_board const *bp)
394 if (port == NULL) 398 if (port == NULL)
395 return; 399 return;
396 400
397 tty = port->port.tty; 401 tty = tty_port_tty_get(&port->port);
398 402
399 count = rc_in(bp, CD180_RDCR); 403 count = rc_in(bp, CD180_RDCR);
400 404
@@ -403,15 +407,14 @@ static void rc_receive(struct riscom_board const *bp)
403#endif 407#endif
404 408
405 while (count--) { 409 while (count--) {
406 if (tty_buffer_request_room(tty, 1) == 0) { 410 u8 ch = rc_in(bp, CD180_RDR);
407 printk(KERN_WARNING "rc%d: port %d: Working around " 411 if (tty)
408 "flip buffer overflow.\n", 412 tty_insert_flip_char(tty, ch, TTY_NORMAL);
409 board_No(bp), port_No(port)); 413 }
410 break; 414 if (tty) {
411 } 415 tty_flip_buffer_push(tty);
412 tty_insert_flip_char(tty, rc_in(bp, CD180_RDR), TTY_NORMAL); 416 tty_kref_put(tty);
413 } 417 }
414 tty_flip_buffer_push(tty);
415} 418}
416 419
417static void rc_transmit(struct riscom_board const *bp) 420static void rc_transmit(struct riscom_board const *bp)
@@ -424,22 +427,22 @@ static void rc_transmit(struct riscom_board const *bp)
424 if (port == NULL) 427 if (port == NULL)
425 return; 428 return;
426 429
427 tty = port->port.tty; 430 tty = tty_port_tty_get(&port->port);
428 431
429 if (port->IER & IER_TXEMPTY) { 432 if (port->IER & IER_TXEMPTY) {
430 /* FIFO drained */ 433 /* FIFO drained */
431 rc_out(bp, CD180_CAR, port_No(port)); 434 rc_out(bp, CD180_CAR, port_No(port));
432 port->IER &= ~IER_TXEMPTY; 435 port->IER &= ~IER_TXEMPTY;
433 rc_out(bp, CD180_IER, port->IER); 436 rc_out(bp, CD180_IER, port->IER);
434 return; 437 goto out;
435 } 438 }
436 439
437 if ((port->xmit_cnt <= 0 && !port->break_length) 440 if ((port->xmit_cnt <= 0 && !port->break_length)
438 || tty->stopped || tty->hw_stopped) { 441 || (tty && (tty->stopped || tty->hw_stopped))) {
439 rc_out(bp, CD180_CAR, port_No(port)); 442 rc_out(bp, CD180_CAR, port_No(port));
440 port->IER &= ~IER_TXRDY; 443 port->IER &= ~IER_TXRDY;
441 rc_out(bp, CD180_IER, port->IER); 444 rc_out(bp, CD180_IER, port->IER);
442 return; 445 goto out;
443 } 446 }
444 447
445 if (port->break_length) { 448 if (port->break_length) {
@@ -464,7 +467,7 @@ static void rc_transmit(struct riscom_board const *bp)
464 rc_out(bp, CD180_CCR, CCR_CORCHG2); 467 rc_out(bp, CD180_CCR, CCR_CORCHG2);
465 port->break_length = 0; 468 port->break_length = 0;
466 } 469 }
467 return; 470 goto out;
468 } 471 }
469 472
470 count = CD180_NFIFO; 473 count = CD180_NFIFO;
@@ -480,8 +483,10 @@ static void rc_transmit(struct riscom_board const *bp)
480 port->IER &= ~IER_TXRDY; 483 port->IER &= ~IER_TXRDY;
481 rc_out(bp, CD180_IER, port->IER); 484 rc_out(bp, CD180_IER, port->IER);
482 } 485 }
483 if (port->xmit_cnt <= port->wakeup_chars) 486 if (tty && port->xmit_cnt <= port->wakeup_chars)
484 tty_wakeup(tty); 487 tty_wakeup(tty);
488out:
489 tty_kref_put(tty);
485} 490}
486 491
487static void rc_check_modem(struct riscom_board const *bp) 492static void rc_check_modem(struct riscom_board const *bp)
@@ -494,37 +499,43 @@ static void rc_check_modem(struct riscom_board const *bp)
494 if (port == NULL) 499 if (port == NULL)
495 return; 500 return;
496 501
497 tty = port->port.tty; 502 tty = tty_port_tty_get(&port->port);
498 503
499 mcr = rc_in(bp, CD180_MCR); 504 mcr = rc_in(bp, CD180_MCR);
500 if (mcr & MCR_CDCHG) { 505 if (mcr & MCR_CDCHG) {
501 if (rc_in(bp, CD180_MSVR) & MSVR_CD) 506 if (rc_in(bp, CD180_MSVR) & MSVR_CD)
502 wake_up_interruptible(&port->port.open_wait); 507 wake_up_interruptible(&port->port.open_wait);
503 else 508 else if (tty)
504 tty_hangup(tty); 509 tty_hangup(tty);
505 } 510 }
506 511
507#ifdef RISCOM_BRAIN_DAMAGED_CTS 512#ifdef RISCOM_BRAIN_DAMAGED_CTS
508 if (mcr & MCR_CTSCHG) { 513 if (mcr & MCR_CTSCHG) {
509 if (rc_in(bp, CD180_MSVR) & MSVR_CTS) { 514 if (rc_in(bp, CD180_MSVR) & MSVR_CTS) {
510 tty->hw_stopped = 0;
511 port->IER |= IER_TXRDY; 515 port->IER |= IER_TXRDY;
512 if (port->xmit_cnt <= port->wakeup_chars) 516 if (tty) {
513 tty_wakeup(tty); 517 tty->hw_stopped = 0;
518 if (port->xmit_cnt <= port->wakeup_chars)
519 tty_wakeup(tty);
520 }
514 } else { 521 } else {
515 tty->hw_stopped = 1; 522 if (tty)
523 tty->hw_stopped = 1;
516 port->IER &= ~IER_TXRDY; 524 port->IER &= ~IER_TXRDY;
517 } 525 }
518 rc_out(bp, CD180_IER, port->IER); 526 rc_out(bp, CD180_IER, port->IER);
519 } 527 }
520 if (mcr & MCR_DSRCHG) { 528 if (mcr & MCR_DSRCHG) {
521 if (rc_in(bp, CD180_MSVR) & MSVR_DSR) { 529 if (rc_in(bp, CD180_MSVR) & MSVR_DSR) {
522 tty->hw_stopped = 0;
523 port->IER |= IER_TXRDY; 530 port->IER |= IER_TXRDY;
524 if (port->xmit_cnt <= port->wakeup_chars) 531 if (tty) {
525 tty_wakeup(tty); 532 tty->hw_stopped = 0;
533 if (port->xmit_cnt <= port->wakeup_chars)
534 tty_wakeup(tty);
535 }
526 } else { 536 } else {
527 tty->hw_stopped = 1; 537 if (tty)
538 tty->hw_stopped = 1;
528 port->IER &= ~IER_TXRDY; 539 port->IER &= ~IER_TXRDY;
529 } 540 }
530 rc_out(bp, CD180_IER, port->IER); 541 rc_out(bp, CD180_IER, port->IER);
@@ -533,6 +544,7 @@ static void rc_check_modem(struct riscom_board const *bp)
533 544
534 /* Clear change bits */ 545 /* Clear change bits */
535 rc_out(bp, CD180_MCR, 0); 546 rc_out(bp, CD180_MCR, 0);
547 tty_kref_put(tty);
536} 548}
537 549
538/* The main interrupt processing routine */ 550/* The main interrupt processing routine */
@@ -632,9 +644,9 @@ static void rc_shutdown_board(struct riscom_board *bp)
632 * Setting up port characteristics. 644 * Setting up port characteristics.
633 * Must be called with disabled interrupts 645 * Must be called with disabled interrupts
634 */ 646 */
635static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port) 647static void rc_change_speed(struct tty_struct *tty, struct riscom_board *bp,
648 struct riscom_port *port)
636{ 649{
637 struct tty_struct *tty = port->port.tty;
638 unsigned long baud; 650 unsigned long baud;
639 long tmp; 651 long tmp;
640 unsigned char cor1 = 0, cor3 = 0; 652 unsigned char cor1 = 0, cor3 = 0;
@@ -781,7 +793,8 @@ static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port)
781} 793}
782 794
783/* Must be called with interrupts enabled */ 795/* Must be called with interrupts enabled */
784static int rc_setup_port(struct riscom_board *bp, struct riscom_port *port) 796static int rc_setup_port(struct tty_struct *tty, struct riscom_board *bp,
797 struct riscom_port *port)
785{ 798{
786 unsigned long flags; 799 unsigned long flags;
787 800
@@ -793,11 +806,11 @@ static int rc_setup_port(struct riscom_board *bp, struct riscom_port *port)
793 806
794 spin_lock_irqsave(&riscom_lock, flags); 807 spin_lock_irqsave(&riscom_lock, flags);
795 808
796 clear_bit(TTY_IO_ERROR, &port->port.tty->flags); 809 clear_bit(TTY_IO_ERROR, &tty->flags);
797 if (port->port.count == 1) 810 if (port->port.count == 1)
798 bp->count++; 811 bp->count++;
799 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0; 812 port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
800 rc_change_speed(bp, port); 813 rc_change_speed(tty, bp, port);
801 port->port.flags |= ASYNC_INITIALIZED; 814 port->port.flags |= ASYNC_INITIALIZED;
802 815
803 spin_unlock_irqrestore(&riscom_lock, flags); 816 spin_unlock_irqrestore(&riscom_lock, flags);
@@ -898,9 +911,9 @@ static int rc_open(struct tty_struct *tty, struct file *filp)
898 911
899 port->port.count++; 912 port->port.count++;
900 tty->driver_data = port; 913 tty->driver_data = port;
901 port->port.tty = tty; 914 tty_port_tty_set(&port->port, tty);
902 915
903 error = rc_setup_port(bp, port); 916 error = rc_setup_port(tty, bp, port);
904 if (error == 0) 917 if (error == 0)
905 error = tty_port_block_til_ready(&port->port, tty, filp); 918 error = tty_port_block_til_ready(&port->port, tty, filp);
906 return error; 919 return error;
@@ -921,20 +934,12 @@ static void rc_flush_buffer(struct tty_struct *tty)
921 tty_wakeup(tty); 934 tty_wakeup(tty);
922} 935}
923 936
924static void rc_close(struct tty_struct *tty, struct file *filp) 937static void rc_close_port(struct tty_port *port)
925{ 938{
926 struct riscom_port *port = tty->driver_data;
927 struct riscom_board *bp;
928 unsigned long flags; 939 unsigned long flags;
940 struct riscom_port *rp = container_of(port, struct riscom_port, port);
941 struct riscom_board *bp = port_Board(rp);
929 unsigned long timeout; 942 unsigned long timeout;
930
931 if (!port || rc_paranoia_check(port, tty->name, "close"))
932 return;
933
934 bp = port_Board(port);
935
936 if (tty_port_close_start(&port->port, tty, filp) == 0)
937 return;
938 943
939 /* 944 /*
940 * At this point we stop accepting input. To do this, we 945 * At this point we stop accepting input. To do this, we
@@ -944,31 +949,37 @@ static void rc_close(struct tty_struct *tty, struct file *filp)
944 */ 949 */
945 950
946 spin_lock_irqsave(&riscom_lock, flags); 951 spin_lock_irqsave(&riscom_lock, flags);
947 port->IER &= ~IER_RXD; 952 rp->IER &= ~IER_RXD;
948 if (port->port.flags & ASYNC_INITIALIZED) { 953 if (port->flags & ASYNC_INITIALIZED) {
949 port->IER &= ~IER_TXRDY; 954 rp->IER &= ~IER_TXRDY;
950 port->IER |= IER_TXEMPTY; 955 rp->IER |= IER_TXEMPTY;
951 rc_out(bp, CD180_CAR, port_No(port)); 956 rc_out(bp, CD180_CAR, port_No(rp));
952 rc_out(bp, CD180_IER, port->IER); 957 rc_out(bp, CD180_IER, rp->IER);
953 /* 958 /*
954 * Before we drop DTR, make sure the UART transmitter 959 * Before we drop DTR, make sure the UART transmitter
955 * has completely drained; this is especially 960 * has completely drained; this is especially
956 * important if there is a transmit FIFO! 961 * important if there is a transmit FIFO!
957 */ 962 */
958 timeout = jiffies + HZ; 963 timeout = jiffies + HZ;
959 while (port->IER & IER_TXEMPTY) { 964 while (rp->IER & IER_TXEMPTY) {
960 spin_unlock_irqrestore(&riscom_lock, flags); 965 spin_unlock_irqrestore(&riscom_lock, flags);
961 msleep_interruptible(jiffies_to_msecs(port->timeout)); 966 msleep_interruptible(jiffies_to_msecs(rp->timeout));
962 spin_lock_irqsave(&riscom_lock, flags); 967 spin_lock_irqsave(&riscom_lock, flags);
963 if (time_after(jiffies, timeout)) 968 if (time_after(jiffies, timeout))
964 break; 969 break;
965 } 970 }
966 } 971 }
967 rc_shutdown_port(tty, bp, port); 972 rc_shutdown_port(port->tty, bp, rp);
968 rc_flush_buffer(tty);
969 spin_unlock_irqrestore(&riscom_lock, flags); 973 spin_unlock_irqrestore(&riscom_lock, flags);
974}
975
976static void rc_close(struct tty_struct *tty, struct file *filp)
977{
978 struct riscom_port *port = tty->driver_data;
970 979
971 tty_port_close_end(&port->port, tty); 980 if (!port || rc_paranoia_check(port, tty->name, "close"))
981 return;
982 tty_port_close(&port->port, tty, filp);
972} 983}
973 984
974static int rc_write(struct tty_struct *tty, 985static int rc_write(struct tty_struct *tty,
@@ -1170,7 +1181,7 @@ static int rc_send_break(struct tty_struct *tty, int length)
1170 return 0; 1181 return 0;
1171} 1182}
1172 1183
1173static int rc_set_serial_info(struct riscom_port *port, 1184static int rc_set_serial_info(struct tty_struct *tty, struct riscom_port *port,
1174 struct serial_struct __user *newinfo) 1185 struct serial_struct __user *newinfo)
1175{ 1186{
1176 struct serial_struct tmp; 1187 struct serial_struct tmp;
@@ -1180,17 +1191,6 @@ static int rc_set_serial_info(struct riscom_port *port,
1180 if (copy_from_user(&tmp, newinfo, sizeof(tmp))) 1191 if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
1181 return -EFAULT; 1192 return -EFAULT;
1182 1193
1183#if 0
1184 if ((tmp.irq != bp->irq) ||
1185 (tmp.port != bp->base) ||
1186 (tmp.type != PORT_CIRRUS) ||
1187 (tmp.baud_base != (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC) ||
1188 (tmp.custom_divisor != 0) ||
1189 (tmp.xmit_fifo_size != CD180_NFIFO) ||
1190 (tmp.flags & ~RISCOM_LEGAL_FLAGS))
1191 return -EINVAL;
1192#endif
1193
1194 change_speed = ((port->port.flags & ASYNC_SPD_MASK) != 1194 change_speed = ((port->port.flags & ASYNC_SPD_MASK) !=
1195 (tmp.flags & ASYNC_SPD_MASK)); 1195 (tmp.flags & ASYNC_SPD_MASK));
1196 1196
@@ -1212,7 +1212,7 @@ static int rc_set_serial_info(struct riscom_port *port,
1212 unsigned long flags; 1212 unsigned long flags;
1213 1213
1214 spin_lock_irqsave(&riscom_lock, flags); 1214 spin_lock_irqsave(&riscom_lock, flags);
1215 rc_change_speed(bp, port); 1215 rc_change_speed(tty, bp, port);
1216 spin_unlock_irqrestore(&riscom_lock, flags); 1216 spin_unlock_irqrestore(&riscom_lock, flags);
1217 } 1217 }
1218 return 0; 1218 return 0;
@@ -1255,7 +1255,7 @@ static int rc_ioctl(struct tty_struct *tty, struct file *filp,
1255 break; 1255 break;
1256 case TIOCSSERIAL: 1256 case TIOCSSERIAL:
1257 lock_kernel(); 1257 lock_kernel();
1258 retval = rc_set_serial_info(port, argp); 1258 retval = rc_set_serial_info(tty, port, argp);
1259 unlock_kernel(); 1259 unlock_kernel();
1260 break; 1260 break;
1261 default: 1261 default:
@@ -1350,21 +1350,12 @@ static void rc_start(struct tty_struct *tty)
1350static void rc_hangup(struct tty_struct *tty) 1350static void rc_hangup(struct tty_struct *tty)
1351{ 1351{
1352 struct riscom_port *port = tty->driver_data; 1352 struct riscom_port *port = tty->driver_data;
1353 struct riscom_board *bp;
1354 unsigned long flags;
1355 1353
1356 if (rc_paranoia_check(port, tty->name, "rc_hangup")) 1354 if (rc_paranoia_check(port, tty->name, "rc_hangup"))
1357 return; 1355 return;
1358 1356
1359 bp = port_Board(port); 1357 rc_shutdown_port(tty, port_Board(port), port);
1360 1358 tty_port_hangup(&port->port);
1361 rc_shutdown_port(tty, bp, port);
1362 spin_lock_irqsave(&port->port.lock, flags);
1363 port->port.count = 0;
1364 port->port.flags &= ~ASYNC_NORMAL_ACTIVE;
1365 port->port.tty = NULL;
1366 wake_up_interruptible(&port->port.open_wait);
1367 spin_unlock_irqrestore(&port->port.lock, flags);
1368} 1359}
1369 1360
1370static void rc_set_termios(struct tty_struct *tty, 1361static void rc_set_termios(struct tty_struct *tty,
@@ -1377,7 +1368,7 @@ static void rc_set_termios(struct tty_struct *tty,
1377 return; 1368 return;
1378 1369
1379 spin_lock_irqsave(&riscom_lock, flags); 1370 spin_lock_irqsave(&riscom_lock, flags);
1380 rc_change_speed(port_Board(port), port); 1371 rc_change_speed(tty, port_Board(port), port);
1381 spin_unlock_irqrestore(&riscom_lock, flags); 1372 spin_unlock_irqrestore(&riscom_lock, flags);
1382 1373
1383 if ((old_termios->c_cflag & CRTSCTS) && 1374 if ((old_termios->c_cflag & CRTSCTS) &&
@@ -1410,6 +1401,7 @@ static const struct tty_operations riscom_ops = {
1410 1401
1411static const struct tty_port_operations riscom_port_ops = { 1402static const struct tty_port_operations riscom_port_ops = {
1412 .carrier_raised = carrier_raised, 1403 .carrier_raised = carrier_raised,
1404 .shutdown = rc_close_port,
1413}; 1405};
1414 1406
1415 1407
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index 50eecfe1d724..44203ff599da 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -26,7 +26,7 @@
26#include <linux/proc_fs.h> 26#include <linux/proc_fs.h>
27#include <linux/nmi.h> 27#include <linux/nmi.h>
28#include <linux/quotaops.h> 28#include <linux/quotaops.h>
29#include <linux/perf_counter.h> 29#include <linux/perf_event.h>
30#include <linux/kernel.h> 30#include <linux/kernel.h>
31#include <linux/module.h> 31#include <linux/module.h>
32#include <linux/suspend.h> 32#include <linux/suspend.h>
@@ -252,7 +252,7 @@ static void sysrq_handle_showregs(int key, struct tty_struct *tty)
252 struct pt_regs *regs = get_irq_regs(); 252 struct pt_regs *regs = get_irq_regs();
253 if (regs) 253 if (regs)
254 show_regs(regs); 254 show_regs(regs);
255 perf_counter_print_debug(); 255 perf_event_print_debug();
256} 256}
257static struct sysrq_key_op sysrq_showregs_op = { 257static struct sysrq_key_op sysrq_showregs_op = {
258 .handler = sysrq_handle_showregs, 258 .handler = sysrq_handle_showregs,
diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index b0603b2e5684..32b957efa420 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -696,7 +696,7 @@ int __tpm_pcr_read(struct tpm_chip *chip, int pcr_idx, u8 *res_buf)
696 696
697 cmd.header.in = pcrread_header; 697 cmd.header.in = pcrread_header;
698 cmd.params.pcrread_in.pcr_idx = cpu_to_be32(pcr_idx); 698 cmd.params.pcrread_in.pcr_idx = cpu_to_be32(pcr_idx);
699 BUILD_BUG_ON(cmd.header.in.length > READ_PCR_RESULT_SIZE); 699 BUG_ON(cmd.header.in.length > READ_PCR_RESULT_SIZE);
700 rc = transmit_cmd(chip, &cmd, cmd.header.in.length, 700 rc = transmit_cmd(chip, &cmd, cmd.header.in.length,
701 "attempting to read a pcr value"); 701 "attempting to read a pcr value");
702 702
@@ -760,7 +760,7 @@ int tpm_pcr_extend(u32 chip_num, int pcr_idx, const u8 *hash)
760 return -ENODEV; 760 return -ENODEV;
761 761
762 cmd.header.in = pcrextend_header; 762 cmd.header.in = pcrextend_header;
763 BUILD_BUG_ON(be32_to_cpu(cmd.header.in.length) > EXTEND_PCR_SIZE); 763 BUG_ON(be32_to_cpu(cmd.header.in.length) > EXTEND_PCR_SIZE);
764 cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(pcr_idx); 764 cmd.params.pcrextend_in.pcr_idx = cpu_to_be32(pcr_idx);
765 memcpy(cmd.params.pcrextend_in.hash, hash, TPM_DIGEST_SIZE); 765 memcpy(cmd.params.pcrextend_in.hash, hash, TPM_DIGEST_SIZE);
766 rc = transmit_cmd(chip, &cmd, cmd.header.in.length, 766 rc = transmit_cmd(chip, &cmd, cmd.header.in.length,
diff --git a/drivers/char/tpm/tpm_bios.c b/drivers/char/tpm/tpm_bios.c
index 0c2f55a38b95..bf2170fb1cdd 100644
--- a/drivers/char/tpm/tpm_bios.c
+++ b/drivers/char/tpm/tpm_bios.c
@@ -343,14 +343,14 @@ static int tpm_ascii_bios_measurements_show(struct seq_file *m, void *v)
343 return 0; 343 return 0;
344} 344}
345 345
346static struct seq_operations tpm_ascii_b_measurments_seqops = { 346static const struct seq_operations tpm_ascii_b_measurments_seqops = {
347 .start = tpm_bios_measurements_start, 347 .start = tpm_bios_measurements_start,
348 .next = tpm_bios_measurements_next, 348 .next = tpm_bios_measurements_next,
349 .stop = tpm_bios_measurements_stop, 349 .stop = tpm_bios_measurements_stop,
350 .show = tpm_ascii_bios_measurements_show, 350 .show = tpm_ascii_bios_measurements_show,
351}; 351};
352 352
353static struct seq_operations tpm_binary_b_measurments_seqops = { 353static const struct seq_operations tpm_binary_b_measurments_seqops = {
354 .start = tpm_bios_measurements_start, 354 .start = tpm_bios_measurements_start,
355 .next = tpm_bios_measurements_next, 355 .next = tpm_bios_measurements_next,
356 .stop = tpm_bios_measurements_stop, 356 .stop = tpm_bios_measurements_stop,
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index a3afa0c387cd..ea18a129b0b5 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -1184,6 +1184,7 @@ int tty_init_termios(struct tty_struct *tty)
1184 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios); 1184 tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
1185 return 0; 1185 return 0;
1186} 1186}
1187EXPORT_SYMBOL_GPL(tty_init_termios);
1187 1188
1188/** 1189/**
1189 * tty_driver_install_tty() - install a tty entry in the driver 1190 * tty_driver_install_tty() - install a tty entry in the driver
@@ -1386,10 +1387,14 @@ EXPORT_SYMBOL(tty_shutdown);
1386 * tty_mutex - sometimes only 1387 * tty_mutex - sometimes only
1387 * takes the file list lock internally when working on the list 1388 * takes the file list lock internally when working on the list
1388 * of ttys that the driver keeps. 1389 * of ttys that the driver keeps.
1390 *
1391 * This method gets called from a work queue so that the driver private
1392 * shutdown ops can sleep (needed for USB at least)
1389 */ 1393 */
1390static void release_one_tty(struct kref *kref) 1394static void release_one_tty(struct work_struct *work)
1391{ 1395{
1392 struct tty_struct *tty = container_of(kref, struct tty_struct, kref); 1396 struct tty_struct *tty =
1397 container_of(work, struct tty_struct, hangup_work);
1393 struct tty_driver *driver = tty->driver; 1398 struct tty_driver *driver = tty->driver;
1394 1399
1395 if (tty->ops->shutdown) 1400 if (tty->ops->shutdown)
@@ -1407,6 +1412,15 @@ static void release_one_tty(struct kref *kref)
1407 free_tty_struct(tty); 1412 free_tty_struct(tty);
1408} 1413}
1409 1414
1415static void queue_release_one_tty(struct kref *kref)
1416{
1417 struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
1418 /* The hangup queue is now free so we can reuse it rather than
1419 waste a chunk of memory for each port */
1420 INIT_WORK(&tty->hangup_work, release_one_tty);
1421 schedule_work(&tty->hangup_work);
1422}
1423
1410/** 1424/**
1411 * tty_kref_put - release a tty kref 1425 * tty_kref_put - release a tty kref
1412 * @tty: tty device 1426 * @tty: tty device
@@ -1418,7 +1432,7 @@ static void release_one_tty(struct kref *kref)
1418void tty_kref_put(struct tty_struct *tty) 1432void tty_kref_put(struct tty_struct *tty)
1419{ 1433{
1420 if (tty) 1434 if (tty)
1421 kref_put(&tty->kref, release_one_tty); 1435 kref_put(&tty->kref, queue_release_one_tty);
1422} 1436}
1423EXPORT_SYMBOL(tty_kref_put); 1437EXPORT_SYMBOL(tty_kref_put);
1424 1438
@@ -2085,7 +2099,7 @@ static int tioccons(struct file *file)
2085 * the generic functionality existed. This piece of history is preserved 2099 * the generic functionality existed. This piece of history is preserved
2086 * in the expected tty API of posix OS's. 2100 * in the expected tty API of posix OS's.
2087 * 2101 *
2088 * Locking: none, the open fle handle ensures it won't go away. 2102 * Locking: none, the open file handle ensures it won't go away.
2089 */ 2103 */
2090 2104
2091static int fionbio(struct file *file, int __user *p) 2105static int fionbio(struct file *file, int __user *p)
@@ -3056,11 +3070,22 @@ void __init console_init(void)
3056 } 3070 }
3057} 3071}
3058 3072
3073static char *tty_devnode(struct device *dev, mode_t *mode)
3074{
3075 if (!mode)
3076 return NULL;
3077 if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3078 dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3079 *mode = 0666;
3080 return NULL;
3081}
3082
3059static int __init tty_class_init(void) 3083static int __init tty_class_init(void)
3060{ 3084{
3061 tty_class = class_create(THIS_MODULE, "tty"); 3085 tty_class = class_create(THIS_MODULE, "tty");
3062 if (IS_ERR(tty_class)) 3086 if (IS_ERR(tty_class))
3063 return PTR_ERR(tty_class); 3087 return PTR_ERR(tty_class);
3088 tty_class->devnode = tty_devnode;
3064 return 0; 3089 return 0;
3065} 3090}
3066 3091
diff --git a/drivers/char/tty_ioctl.c b/drivers/char/tty_ioctl.c
index ad6ba4ed2808..8e67d5c642a4 100644
--- a/drivers/char/tty_ioctl.c
+++ b/drivers/char/tty_ioctl.c
@@ -393,9 +393,7 @@ void tty_termios_encode_baud_rate(struct ktermios *termios,
393 termios->c_cflag |= (BOTHER << IBSHIFT); 393 termios->c_cflag |= (BOTHER << IBSHIFT);
394#else 394#else
395 if (ifound == -1 || ofound == -1) { 395 if (ifound == -1 || ofound == -1) {
396 static int warned; 396 printk_once(KERN_WARNING "tty: Unable to return correct "
397 if (!warned++)
398 printk(KERN_WARNING "tty: Unable to return correct "
399 "speed data as your architecture needs updating.\n"); 397 "speed data as your architecture needs updating.\n");
400 } 398 }
401#endif 399#endif
diff --git a/drivers/char/tty_ldisc.c b/drivers/char/tty_ldisc.c
index e48af9f79219..aafdbaebc16a 100644
--- a/drivers/char/tty_ldisc.c
+++ b/drivers/char/tty_ldisc.c
@@ -145,48 +145,33 @@ int tty_unregister_ldisc(int disc)
145} 145}
146EXPORT_SYMBOL(tty_unregister_ldisc); 146EXPORT_SYMBOL(tty_unregister_ldisc);
147 147
148 148static struct tty_ldisc_ops *get_ldops(int disc)
149/**
150 * tty_ldisc_try_get - try and reference an ldisc
151 * @disc: ldisc number
152 *
153 * Attempt to open and lock a line discipline into place. Return
154 * the line discipline refcounted or an error.
155 */
156
157static struct tty_ldisc *tty_ldisc_try_get(int disc)
158{ 149{
159 unsigned long flags; 150 unsigned long flags;
160 struct tty_ldisc *ld; 151 struct tty_ldisc_ops *ldops, *ret;
161 struct tty_ldisc_ops *ldops;
162 int err = -EINVAL;
163
164 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
165 if (ld == NULL)
166 return ERR_PTR(-ENOMEM);
167 152
168 spin_lock_irqsave(&tty_ldisc_lock, flags); 153 spin_lock_irqsave(&tty_ldisc_lock, flags);
169 ld->ops = NULL; 154 ret = ERR_PTR(-EINVAL);
170 ldops = tty_ldiscs[disc]; 155 ldops = tty_ldiscs[disc];
171 /* Check the entry is defined */
172 if (ldops) { 156 if (ldops) {
173 /* If the module is being unloaded we can't use it */ 157 ret = ERR_PTR(-EAGAIN);
174 if (!try_module_get(ldops->owner)) 158 if (try_module_get(ldops->owner)) {
175 err = -EAGAIN;
176 else {
177 /* lock it */
178 ldops->refcount++; 159 ldops->refcount++;
179 ld->ops = ldops; 160 ret = ldops;
180 atomic_set(&ld->users, 1);
181 err = 0;
182 } 161 }
183 } 162 }
184 spin_unlock_irqrestore(&tty_ldisc_lock, flags); 163 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
185 if (err) { 164 return ret;
186 kfree(ld); 165}
187 return ERR_PTR(err); 166
188 } 167static void put_ldops(struct tty_ldisc_ops *ldops)
189 return ld; 168{
169 unsigned long flags;
170
171 spin_lock_irqsave(&tty_ldisc_lock, flags);
172 ldops->refcount--;
173 module_put(ldops->owner);
174 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
190} 175}
191 176
192/** 177/**
@@ -205,14 +190,31 @@ static struct tty_ldisc *tty_ldisc_try_get(int disc)
205static struct tty_ldisc *tty_ldisc_get(int disc) 190static struct tty_ldisc *tty_ldisc_get(int disc)
206{ 191{
207 struct tty_ldisc *ld; 192 struct tty_ldisc *ld;
193 struct tty_ldisc_ops *ldops;
208 194
209 if (disc < N_TTY || disc >= NR_LDISCS) 195 if (disc < N_TTY || disc >= NR_LDISCS)
210 return ERR_PTR(-EINVAL); 196 return ERR_PTR(-EINVAL);
211 ld = tty_ldisc_try_get(disc); 197
212 if (IS_ERR(ld)) { 198 /*
199 * Get the ldisc ops - we may need to request them to be loaded
200 * dynamically and try again.
201 */
202 ldops = get_ldops(disc);
203 if (IS_ERR(ldops)) {
213 request_module("tty-ldisc-%d", disc); 204 request_module("tty-ldisc-%d", disc);
214 ld = tty_ldisc_try_get(disc); 205 ldops = get_ldops(disc);
206 if (IS_ERR(ldops))
207 return ERR_CAST(ldops);
215 } 208 }
209
210 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
211 if (ld == NULL) {
212 put_ldops(ldops);
213 return ERR_PTR(-ENOMEM);
214 }
215
216 ld->ops = ldops;
217 atomic_set(&ld->users, 1);
216 return ld; 218 return ld;
217} 219}
218 220
@@ -234,13 +236,13 @@ static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
234static int tty_ldiscs_seq_show(struct seq_file *m, void *v) 236static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
235{ 237{
236 int i = *(loff_t *)v; 238 int i = *(loff_t *)v;
237 struct tty_ldisc *ld; 239 struct tty_ldisc_ops *ldops;
238 240
239 ld = tty_ldisc_try_get(i); 241 ldops = get_ldops(i);
240 if (IS_ERR(ld)) 242 if (IS_ERR(ldops))
241 return 0; 243 return 0;
242 seq_printf(m, "%-10s %2d\n", ld->ops->name ? ld->ops->name : "???", i); 244 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
243 put_ldisc(ld); 245 put_ldops(ldops);
244 return 0; 246 return 0;
245} 247}
246 248
diff --git a/drivers/char/tty_port.c b/drivers/char/tty_port.c
index 9769b1149f76..a4bbb28f10be 100644
--- a/drivers/char/tty_port.c
+++ b/drivers/char/tty_port.c
@@ -23,6 +23,7 @@ void tty_port_init(struct tty_port *port)
23 memset(port, 0, sizeof(*port)); 23 memset(port, 0, sizeof(*port));
24 init_waitqueue_head(&port->open_wait); 24 init_waitqueue_head(&port->open_wait);
25 init_waitqueue_head(&port->close_wait); 25 init_waitqueue_head(&port->close_wait);
26 init_waitqueue_head(&port->delta_msr_wait);
26 mutex_init(&port->mutex); 27 mutex_init(&port->mutex);
27 spin_lock_init(&port->lock); 28 spin_lock_init(&port->lock);
28 port->close_delay = (50 * HZ) / 100; 29 port->close_delay = (50 * HZ) / 100;
@@ -96,6 +97,14 @@ void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
96} 97}
97EXPORT_SYMBOL(tty_port_tty_set); 98EXPORT_SYMBOL(tty_port_tty_set);
98 99
100static void tty_port_shutdown(struct tty_port *port)
101{
102 if (port->ops->shutdown &&
103 test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags))
104 port->ops->shutdown(port);
105
106}
107
99/** 108/**
100 * tty_port_hangup - hangup helper 109 * tty_port_hangup - hangup helper
101 * @port: tty port 110 * @port: tty port
@@ -116,6 +125,8 @@ void tty_port_hangup(struct tty_port *port)
116 port->tty = NULL; 125 port->tty = NULL;
117 spin_unlock_irqrestore(&port->lock, flags); 126 spin_unlock_irqrestore(&port->lock, flags);
118 wake_up_interruptible(&port->open_wait); 127 wake_up_interruptible(&port->open_wait);
128 wake_up_interruptible(&port->delta_msr_wait);
129 tty_port_shutdown(port);
119} 130}
120EXPORT_SYMBOL(tty_port_hangup); 131EXPORT_SYMBOL(tty_port_hangup);
121 132
@@ -296,15 +307,17 @@ int tty_port_close_start(struct tty_port *port, struct tty_struct *tty, struct f
296 307
297 if (port->count) { 308 if (port->count) {
298 spin_unlock_irqrestore(&port->lock, flags); 309 spin_unlock_irqrestore(&port->lock, flags);
310 if (port->ops->drop)
311 port->ops->drop(port);
299 return 0; 312 return 0;
300 } 313 }
301 port->flags |= ASYNC_CLOSING; 314 set_bit(ASYNCB_CLOSING, &port->flags);
302 tty->closing = 1; 315 tty->closing = 1;
303 spin_unlock_irqrestore(&port->lock, flags); 316 spin_unlock_irqrestore(&port->lock, flags);
304 /* Don't block on a stalled port, just pull the chain */ 317 /* Don't block on a stalled port, just pull the chain */
305 if (tty->flow_stopped) 318 if (tty->flow_stopped)
306 tty_driver_flush_buffer(tty); 319 tty_driver_flush_buffer(tty);
307 if (port->flags & ASYNC_INITIALIZED && 320 if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
308 port->closing_wait != ASYNC_CLOSING_WAIT_NONE) 321 port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
309 tty_wait_until_sent(tty, port->closing_wait); 322 tty_wait_until_sent(tty, port->closing_wait);
310 if (port->drain_delay) { 323 if (port->drain_delay) {
@@ -318,6 +331,9 @@ int tty_port_close_start(struct tty_port *port, struct tty_struct *tty, struct f
318 timeout = 2 * HZ; 331 timeout = 2 * HZ;
319 schedule_timeout_interruptible(timeout); 332 schedule_timeout_interruptible(timeout);
320 } 333 }
334 /* Don't call port->drop for the last reference. Callers will want
335 to drop the last active reference in ->shutdown() or the tty
336 shutdown path */
321 return 1; 337 return 1;
322} 338}
323EXPORT_SYMBOL(tty_port_close_start); 339EXPORT_SYMBOL(tty_port_close_start);
@@ -348,3 +364,14 @@ void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
348 spin_unlock_irqrestore(&port->lock, flags); 364 spin_unlock_irqrestore(&port->lock, flags);
349} 365}
350EXPORT_SYMBOL(tty_port_close_end); 366EXPORT_SYMBOL(tty_port_close_end);
367
368void tty_port_close(struct tty_port *port, struct tty_struct *tty,
369 struct file *filp)
370{
371 if (tty_port_close_start(port, tty, filp) == 0)
372 return;
373 tty_port_shutdown(port);
374 tty_port_close_end(port, tty);
375 tty_port_tty_set(port, NULL);
376}
377EXPORT_SYMBOL(tty_port_close);
diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index c74dacfa6795..0d328b59568d 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
@@ -31,6 +31,7 @@
31#include <linux/err.h> 31#include <linux/err.h>
32#include <linux/init.h> 32#include <linux/init.h>
33#include <linux/virtio.h> 33#include <linux/virtio.h>
34#include <linux/virtio_ids.h>
34#include <linux/virtio_console.h> 35#include <linux/virtio_console.h>
35#include "hvc_console.h" 36#include "hvc_console.h"
36 37
@@ -65,7 +66,7 @@ static int put_chars(u32 vtermno, const char *buf, int count)
65 66
66 /* add_buf wants a token to identify this buffer: we hand it any 67 /* add_buf wants a token to identify this buffer: we hand it any
67 * non-NULL pointer, since there's only ever one buffer. */ 68 * non-NULL pointer, since there's only ever one buffer. */
68 if (out_vq->vq_ops->add_buf(out_vq, sg, 1, 0, (void *)1) == 0) { 69 if (out_vq->vq_ops->add_buf(out_vq, sg, 1, 0, (void *)1) >= 0) {
69 /* Tell Host to go! */ 70 /* Tell Host to go! */
70 out_vq->vq_ops->kick(out_vq); 71 out_vq->vq_ops->kick(out_vq);
71 /* Chill out until it's done with the buffer. */ 72 /* Chill out until it's done with the buffer. */
@@ -85,7 +86,7 @@ static void add_inbuf(void)
85 sg_init_one(sg, inbuf, PAGE_SIZE); 86 sg_init_one(sg, inbuf, PAGE_SIZE);
86 87
87 /* We should always be able to add one buffer to an empty queue. */ 88 /* We should always be able to add one buffer to an empty queue. */
88 if (in_vq->vq_ops->add_buf(in_vq, sg, 0, 1, inbuf) != 0) 89 if (in_vq->vq_ops->add_buf(in_vq, sg, 0, 1, inbuf) < 0)
89 BUG(); 90 BUG();
90 in_vq->vq_ops->kick(in_vq); 91 in_vq->vq_ops->kick(in_vq);
91} 92}
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index 6aa88f50b039..0c80c68cd047 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -252,7 +252,6 @@ static void notify_update(struct vc_data *vc)
252 struct vt_notifier_param param = { .vc = vc }; 252 struct vt_notifier_param param = { .vc = vc };
253 atomic_notifier_call_chain(&vt_notifier_list, VT_UPDATE, &param); 253 atomic_notifier_call_chain(&vt_notifier_list, VT_UPDATE, &param);
254} 254}
255
256/* 255/*
257 * Low-Level Functions 256 * Low-Level Functions
258 */ 257 */
@@ -935,6 +934,7 @@ static int vc_do_resize(struct tty_struct *tty, struct vc_data *vc,
935 934
936 if (CON_IS_VISIBLE(vc)) 935 if (CON_IS_VISIBLE(vc))
937 update_screen(vc); 936 update_screen(vc);
937 vt_event_post(VT_EVENT_RESIZE, vc->vc_num, vc->vc_num);
938 return err; 938 return err;
939} 939}
940 940
@@ -2129,11 +2129,7 @@ static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int co
2129 currcons = vc->vc_num; 2129 currcons = vc->vc_num;
2130 if (!vc_cons_allocated(currcons)) { 2130 if (!vc_cons_allocated(currcons)) {
2131 /* could this happen? */ 2131 /* could this happen? */
2132 static int error = 0; 2132 printk_once("con_write: tty %d not allocated\n", currcons+1);
2133 if (!error) {
2134 error = 1;
2135 printk("con_write: tty %d not allocated\n", currcons+1);
2136 }
2137 release_console_sem(); 2133 release_console_sem();
2138 return 0; 2134 return 0;
2139 } 2135 }
@@ -2910,6 +2906,9 @@ static const struct tty_operations con_ops = {
2910 .flush_chars = con_flush_chars, 2906 .flush_chars = con_flush_chars,
2911 .chars_in_buffer = con_chars_in_buffer, 2907 .chars_in_buffer = con_chars_in_buffer,
2912 .ioctl = vt_ioctl, 2908 .ioctl = vt_ioctl,
2909#ifdef CONFIG_COMPAT
2910 .compat_ioctl = vt_compat_ioctl,
2911#endif
2913 .stop = con_stop, 2912 .stop = con_stop,
2914 .start = con_start, 2913 .start = con_start,
2915 .throttle = con_throttle, 2914 .throttle = con_throttle,
@@ -2955,7 +2954,6 @@ int __init vty_init(const struct file_operations *console_fops)
2955} 2954}
2956 2955
2957#ifndef VT_SINGLE_DRIVER 2956#ifndef VT_SINGLE_DRIVER
2958#include <linux/device.h>
2959 2957
2960static struct class *vtconsole_class; 2958static struct class *vtconsole_class;
2961 2959
@@ -3638,6 +3636,7 @@ void do_blank_screen(int entering_gfx)
3638 blank_state = blank_vesa_wait; 3636 blank_state = blank_vesa_wait;
3639 mod_timer(&console_timer, jiffies + vesa_off_interval); 3637 mod_timer(&console_timer, jiffies + vesa_off_interval);
3640 } 3638 }
3639 vt_event_post(VT_EVENT_BLANK, vc->vc_num, vc->vc_num);
3641} 3640}
3642EXPORT_SYMBOL(do_blank_screen); 3641EXPORT_SYMBOL(do_blank_screen);
3643 3642
@@ -3682,6 +3681,7 @@ void do_unblank_screen(int leaving_gfx)
3682 console_blank_hook(0); 3681 console_blank_hook(0);
3683 set_palette(vc); 3682 set_palette(vc);
3684 set_cursor(vc); 3683 set_cursor(vc);
3684 vt_event_post(VT_EVENT_UNBLANK, vc->vc_num, vc->vc_num);
3685} 3685}
3686EXPORT_SYMBOL(do_unblank_screen); 3686EXPORT_SYMBOL(do_unblank_screen);
3687 3687
diff --git a/drivers/char/vt_ioctl.c b/drivers/char/vt_ioctl.c
index 95189f288f8c..29c651ab0d78 100644
--- a/drivers/char/vt_ioctl.c
+++ b/drivers/char/vt_ioctl.c
@@ -16,6 +16,8 @@
16#include <linux/tty.h> 16#include <linux/tty.h>
17#include <linux/timer.h> 17#include <linux/timer.h>
18#include <linux/kernel.h> 18#include <linux/kernel.h>
19#include <linux/compat.h>
20#include <linux/module.h>
19#include <linux/kd.h> 21#include <linux/kd.h>
20#include <linux/vt.h> 22#include <linux/vt.h>
21#include <linux/string.h> 23#include <linux/string.h>
@@ -62,6 +64,133 @@ extern struct tty_driver *console_driver;
62static void complete_change_console(struct vc_data *vc); 64static void complete_change_console(struct vc_data *vc);
63 65
64/* 66/*
67 * User space VT_EVENT handlers
68 */
69
70struct vt_event_wait {
71 struct list_head list;
72 struct vt_event event;
73 int done;
74};
75
76static LIST_HEAD(vt_events);
77static DEFINE_SPINLOCK(vt_event_lock);
78static DECLARE_WAIT_QUEUE_HEAD(vt_event_waitqueue);
79
80/**
81 * vt_event_post
82 * @event: the event that occurred
83 * @old: old console
84 * @new: new console
85 *
86 * Post an VT event to interested VT handlers
87 */
88
89void vt_event_post(unsigned int event, unsigned int old, unsigned int new)
90{
91 struct list_head *pos, *head;
92 unsigned long flags;
93 int wake = 0;
94
95 spin_lock_irqsave(&vt_event_lock, flags);
96 head = &vt_events;
97
98 list_for_each(pos, head) {
99 struct vt_event_wait *ve = list_entry(pos,
100 struct vt_event_wait, list);
101 if (!(ve->event.event & event))
102 continue;
103 ve->event.event = event;
104 /* kernel view is consoles 0..n-1, user space view is
105 console 1..n with 0 meaning current, so we must bias */
106 ve->event.old = old + 1;
107 ve->event.new = new + 1;
108 wake = 1;
109 ve->done = 1;
110 }
111 spin_unlock_irqrestore(&vt_event_lock, flags);
112 if (wake)
113 wake_up_interruptible(&vt_event_waitqueue);
114}
115
116/**
117 * vt_event_wait - wait for an event
118 * @vw: our event
119 *
120 * Waits for an event to occur which completes our vt_event_wait
121 * structure. On return the structure has wv->done set to 1 for success
122 * or 0 if some event such as a signal ended the wait.
123 */
124
125static void vt_event_wait(struct vt_event_wait *vw)
126{
127 unsigned long flags;
128 /* Prepare the event */
129 INIT_LIST_HEAD(&vw->list);
130 vw->done = 0;
131 /* Queue our event */
132 spin_lock_irqsave(&vt_event_lock, flags);
133 list_add(&vw->list, &vt_events);
134 spin_unlock_irqrestore(&vt_event_lock, flags);
135 /* Wait for it to pass */
136 wait_event_interruptible(vt_event_waitqueue, vw->done);
137 /* Dequeue it */
138 spin_lock_irqsave(&vt_event_lock, flags);
139 list_del(&vw->list);
140 spin_unlock_irqrestore(&vt_event_lock, flags);
141}
142
143/**
144 * vt_event_wait_ioctl - event ioctl handler
145 * @arg: argument to ioctl
146 *
147 * Implement the VT_WAITEVENT ioctl using the VT event interface
148 */
149
150static int vt_event_wait_ioctl(struct vt_event __user *event)
151{
152 struct vt_event_wait vw;
153
154 if (copy_from_user(&vw.event, event, sizeof(struct vt_event)))
155 return -EFAULT;
156 /* Highest supported event for now */
157 if (vw.event.event & ~VT_MAX_EVENT)
158 return -EINVAL;
159
160 vt_event_wait(&vw);
161 /* If it occurred report it */
162 if (vw.done) {
163 if (copy_to_user(event, &vw.event, sizeof(struct vt_event)))
164 return -EFAULT;
165 return 0;
166 }
167 return -EINTR;
168}
169
170/**
171 * vt_waitactive - active console wait
172 * @event: event code
173 * @n: new console
174 *
175 * Helper for event waits. Used to implement the legacy
176 * event waiting ioctls in terms of events
177 */
178
179int vt_waitactive(int n)
180{
181 struct vt_event_wait vw;
182 do {
183 if (n == fg_console + 1)
184 break;
185 vw.event.event = VT_EVENT_SWITCH;
186 vt_event_wait(&vw);
187 if (vw.done == 0)
188 return -EINTR;
189 } while (vw.event.new != n);
190 return 0;
191}
192
193/*
65 * these are the valid i/o ports we're allowed to change. they map all the 194 * these are the valid i/o ports we're allowed to change. they map all the
66 * video ports 195 * video ports
67 */ 196 */
@@ -360,6 +489,8 @@ do_unimap_ioctl(int cmd, struct unimapdesc __user *user_ud, int perm, struct vc_
360 return 0; 489 return 0;
361} 490}
362 491
492
493
363/* 494/*
364 * We handle the console-specific ioctl's here. We allow the 495 * We handle the console-specific ioctl's here. We allow the
365 * capability to modify any console, not just the fg_console. 496 * capability to modify any console, not just the fg_console.
@@ -842,6 +973,41 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
842 } 973 }
843 break; 974 break;
844 975
976 case VT_SETACTIVATE:
977 {
978 struct vt_setactivate vsa;
979
980 if (!perm)
981 goto eperm;
982
983 if (copy_from_user(&vsa, (struct vt_setactivate __user *)arg,
984 sizeof(struct vt_setactivate)))
985 return -EFAULT;
986 if (vsa.console == 0 || vsa.console > MAX_NR_CONSOLES)
987 ret = -ENXIO;
988 else {
989 vsa.console--;
990 acquire_console_sem();
991 ret = vc_allocate(vsa.console);
992 if (ret == 0) {
993 struct vc_data *nvc;
994 /* This is safe providing we don't drop the
995 console sem between vc_allocate and
996 finishing referencing nvc */
997 nvc = vc_cons[vsa.console].d;
998 nvc->vt_mode = vsa.mode;
999 nvc->vt_mode.frsig = 0;
1000 put_pid(nvc->vt_pid);
1001 nvc->vt_pid = get_pid(task_pid(current));
1002 }
1003 release_console_sem();
1004 if (ret)
1005 break;
1006 /* Commence switch and lock */
1007 set_console(arg);
1008 }
1009 }
1010
845 /* 1011 /*
846 * wait until the specified VT has been activated 1012 * wait until the specified VT has been activated
847 */ 1013 */
@@ -851,7 +1017,7 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
851 if (arg == 0 || arg > MAX_NR_CONSOLES) 1017 if (arg == 0 || arg > MAX_NR_CONSOLES)
852 ret = -ENXIO; 1018 ret = -ENXIO;
853 else 1019 else
854 ret = vt_waitactive(arg - 1); 1020 ret = vt_waitactive(arg);
855 break; 1021 break;
856 1022
857 /* 1023 /*
@@ -1159,6 +1325,9 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
1159 ret = put_user(vc->vc_hi_font_mask, 1325 ret = put_user(vc->vc_hi_font_mask,
1160 (unsigned short __user *)arg); 1326 (unsigned short __user *)arg);
1161 break; 1327 break;
1328 case VT_WAITEVENT:
1329 ret = vt_event_wait_ioctl((struct vt_event __user *)arg);
1330 break;
1162 default: 1331 default:
1163 ret = -ENOIOCTLCMD; 1332 ret = -ENOIOCTLCMD;
1164 } 1333 }
@@ -1170,54 +1339,6 @@ eperm:
1170 goto out; 1339 goto out;
1171} 1340}
1172 1341
1173/*
1174 * Sometimes we want to wait until a particular VT has been activated. We
1175 * do it in a very simple manner. Everybody waits on a single queue and
1176 * get woken up at once. Those that are satisfied go on with their business,
1177 * while those not ready go back to sleep. Seems overkill to add a wait
1178 * to each vt just for this - usually this does nothing!
1179 */
1180static DECLARE_WAIT_QUEUE_HEAD(vt_activate_queue);
1181
1182/*
1183 * Sleeps until a vt is activated, or the task is interrupted. Returns
1184 * 0 if activation, -EINTR if interrupted by a signal handler.
1185 */
1186int vt_waitactive(int vt)
1187{
1188 int retval;
1189 DECLARE_WAITQUEUE(wait, current);
1190
1191 add_wait_queue(&vt_activate_queue, &wait);
1192 for (;;) {
1193 retval = 0;
1194
1195 /*
1196 * Synchronize with redraw_screen(). By acquiring the console
1197 * semaphore we make sure that the console switch is completed
1198 * before we return. If we didn't wait for the semaphore, we
1199 * could return at a point where fg_console has already been
1200 * updated, but the console switch hasn't been completed.
1201 */
1202 acquire_console_sem();
1203 set_current_state(TASK_INTERRUPTIBLE);
1204 if (vt == fg_console) {
1205 release_console_sem();
1206 break;
1207 }
1208 release_console_sem();
1209 retval = -ERESTARTNOHAND;
1210 if (signal_pending(current))
1211 break;
1212 schedule();
1213 }
1214 remove_wait_queue(&vt_activate_queue, &wait);
1215 __set_current_state(TASK_RUNNING);
1216 return retval;
1217}
1218
1219#define vt_wake_waitactive() wake_up(&vt_activate_queue)
1220
1221void reset_vc(struct vc_data *vc) 1342void reset_vc(struct vc_data *vc)
1222{ 1343{
1223 vc->vc_mode = KD_TEXT; 1344 vc->vc_mode = KD_TEXT;
@@ -1256,12 +1377,216 @@ void vc_SAK(struct work_struct *work)
1256 release_console_sem(); 1377 release_console_sem();
1257} 1378}
1258 1379
1380#ifdef CONFIG_COMPAT
1381
1382struct compat_consolefontdesc {
1383 unsigned short charcount; /* characters in font (256 or 512) */
1384 unsigned short charheight; /* scan lines per character (1-32) */
1385 compat_caddr_t chardata; /* font data in expanded form */
1386};
1387
1388static inline int
1389compat_fontx_ioctl(int cmd, struct compat_consolefontdesc __user *user_cfd,
1390 int perm, struct console_font_op *op)
1391{
1392 struct compat_consolefontdesc cfdarg;
1393 int i;
1394
1395 if (copy_from_user(&cfdarg, user_cfd, sizeof(struct compat_consolefontdesc)))
1396 return -EFAULT;
1397
1398 switch (cmd) {
1399 case PIO_FONTX:
1400 if (!perm)
1401 return -EPERM;
1402 op->op = KD_FONT_OP_SET;
1403 op->flags = KD_FONT_FLAG_OLD;
1404 op->width = 8;
1405 op->height = cfdarg.charheight;
1406 op->charcount = cfdarg.charcount;
1407 op->data = compat_ptr(cfdarg.chardata);
1408 return con_font_op(vc_cons[fg_console].d, op);
1409 case GIO_FONTX:
1410 op->op = KD_FONT_OP_GET;
1411 op->flags = KD_FONT_FLAG_OLD;
1412 op->width = 8;
1413 op->height = cfdarg.charheight;
1414 op->charcount = cfdarg.charcount;
1415 op->data = compat_ptr(cfdarg.chardata);
1416 i = con_font_op(vc_cons[fg_console].d, op);
1417 if (i)
1418 return i;
1419 cfdarg.charheight = op->height;
1420 cfdarg.charcount = op->charcount;
1421 if (copy_to_user(user_cfd, &cfdarg, sizeof(struct compat_consolefontdesc)))
1422 return -EFAULT;
1423 return 0;
1424 }
1425 return -EINVAL;
1426}
1427
1428struct compat_console_font_op {
1429 compat_uint_t op; /* operation code KD_FONT_OP_* */
1430 compat_uint_t flags; /* KD_FONT_FLAG_* */
1431 compat_uint_t width, height; /* font size */
1432 compat_uint_t charcount;
1433 compat_caddr_t data; /* font data with height fixed to 32 */
1434};
1435
1436static inline int
1437compat_kdfontop_ioctl(struct compat_console_font_op __user *fontop,
1438 int perm, struct console_font_op *op, struct vc_data *vc)
1439{
1440 int i;
1441
1442 if (copy_from_user(op, fontop, sizeof(struct compat_console_font_op)))
1443 return -EFAULT;
1444 if (!perm && op->op != KD_FONT_OP_GET)
1445 return -EPERM;
1446 op->data = compat_ptr(((struct compat_console_font_op *)op)->data);
1447 op->flags |= KD_FONT_FLAG_OLD;
1448 i = con_font_op(vc, op);
1449 if (i)
1450 return i;
1451 ((struct compat_console_font_op *)op)->data = (unsigned long)op->data;
1452 if (copy_to_user(fontop, op, sizeof(struct compat_console_font_op)))
1453 return -EFAULT;
1454 return 0;
1455}
1456
1457struct compat_unimapdesc {
1458 unsigned short entry_ct;
1459 compat_caddr_t entries;
1460};
1461
1462static inline int
1463compat_unimap_ioctl(unsigned int cmd, struct compat_unimapdesc __user *user_ud,
1464 int perm, struct vc_data *vc)
1465{
1466 struct compat_unimapdesc tmp;
1467 struct unipair __user *tmp_entries;
1468
1469 if (copy_from_user(&tmp, user_ud, sizeof tmp))
1470 return -EFAULT;
1471 tmp_entries = compat_ptr(tmp.entries);
1472 if (tmp_entries)
1473 if (!access_ok(VERIFY_WRITE, tmp_entries,
1474 tmp.entry_ct*sizeof(struct unipair)))
1475 return -EFAULT;
1476 switch (cmd) {
1477 case PIO_UNIMAP:
1478 if (!perm)
1479 return -EPERM;
1480 return con_set_unimap(vc, tmp.entry_ct, tmp_entries);
1481 case GIO_UNIMAP:
1482 if (!perm && fg_console != vc->vc_num)
1483 return -EPERM;
1484 return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp_entries);
1485 }
1486 return 0;
1487}
1488
1489long vt_compat_ioctl(struct tty_struct *tty, struct file * file,
1490 unsigned int cmd, unsigned long arg)
1491{
1492 struct vc_data *vc = tty->driver_data;
1493 struct console_font_op op; /* used in multiple places here */
1494 struct kbd_struct *kbd;
1495 unsigned int console;
1496 void __user *up = (void __user *)arg;
1497 int perm;
1498 int ret = 0;
1499
1500 console = vc->vc_num;
1501
1502 lock_kernel();
1503
1504 if (!vc_cons_allocated(console)) { /* impossible? */
1505 ret = -ENOIOCTLCMD;
1506 goto out;
1507 }
1508
1509 /*
1510 * To have permissions to do most of the vt ioctls, we either have
1511 * to be the owner of the tty, or have CAP_SYS_TTY_CONFIG.
1512 */
1513 perm = 0;
1514 if (current->signal->tty == tty || capable(CAP_SYS_TTY_CONFIG))
1515 perm = 1;
1516
1517 kbd = kbd_table + console;
1518 switch (cmd) {
1519 /*
1520 * these need special handlers for incompatible data structures
1521 */
1522 case PIO_FONTX:
1523 case GIO_FONTX:
1524 ret = compat_fontx_ioctl(cmd, up, perm, &op);
1525 break;
1526
1527 case KDFONTOP:
1528 ret = compat_kdfontop_ioctl(up, perm, &op, vc);
1529 break;
1530
1531 case PIO_UNIMAP:
1532 case GIO_UNIMAP:
1533 ret = do_unimap_ioctl(cmd, up, perm, vc);
1534 break;
1535
1536 /*
1537 * all these treat 'arg' as an integer
1538 */
1539 case KIOCSOUND:
1540 case KDMKTONE:
1541#ifdef CONFIG_X86
1542 case KDADDIO:
1543 case KDDELIO:
1544#endif
1545 case KDSETMODE:
1546 case KDMAPDISP:
1547 case KDUNMAPDISP:
1548 case KDSKBMODE:
1549 case KDSKBMETA:
1550 case KDSKBLED:
1551 case KDSETLED:
1552 case KDSIGACCEPT:
1553 case VT_ACTIVATE:
1554 case VT_WAITACTIVE:
1555 case VT_RELDISP:
1556 case VT_DISALLOCATE:
1557 case VT_RESIZE:
1558 case VT_RESIZEX:
1559 goto fallback;
1560
1561 /*
1562 * the rest has a compatible data structure behind arg,
1563 * but we have to convert it to a proper 64 bit pointer.
1564 */
1565 default:
1566 arg = (unsigned long)compat_ptr(arg);
1567 goto fallback;
1568 }
1569out:
1570 unlock_kernel();
1571 return ret;
1572
1573fallback:
1574 unlock_kernel();
1575 return vt_ioctl(tty, file, cmd, arg);
1576}
1577
1578
1579#endif /* CONFIG_COMPAT */
1580
1581
1259/* 1582/*
1260 * Performs the back end of a vt switch 1583 * Performs the back end of a vt switch. Called under the console
1584 * semaphore.
1261 */ 1585 */
1262static void complete_change_console(struct vc_data *vc) 1586static void complete_change_console(struct vc_data *vc)
1263{ 1587{
1264 unsigned char old_vc_mode; 1588 unsigned char old_vc_mode;
1589 int old = fg_console;
1265 1590
1266 last_console = fg_console; 1591 last_console = fg_console;
1267 1592
@@ -1325,7 +1650,7 @@ static void complete_change_console(struct vc_data *vc)
1325 /* 1650 /*
1326 * Wake anyone waiting for their VT to activate 1651 * Wake anyone waiting for their VT to activate
1327 */ 1652 */
1328 vt_wake_waitactive(); 1653 vt_event_post(VT_EVENT_SWITCH, old, vc->vc_num);
1329 return; 1654 return;
1330} 1655}
1331 1656
@@ -1398,3 +1723,58 @@ void change_console(struct vc_data *new_vc)
1398 1723
1399 complete_change_console(new_vc); 1724 complete_change_console(new_vc);
1400} 1725}
1726
1727/* Perform a kernel triggered VT switch for suspend/resume */
1728
1729static int disable_vt_switch;
1730
1731int vt_move_to_console(unsigned int vt, int alloc)
1732{
1733 int prev;
1734
1735 acquire_console_sem();
1736 /* Graphics mode - up to X */
1737 if (disable_vt_switch) {
1738 release_console_sem();
1739 return 0;
1740 }
1741 prev = fg_console;
1742
1743 if (alloc && vc_allocate(vt)) {
1744 /* we can't have a free VC for now. Too bad,
1745 * we don't want to mess the screen for now. */
1746 release_console_sem();
1747 return -ENOSPC;
1748 }
1749
1750 if (set_console(vt)) {
1751 /*
1752 * We're unable to switch to the SUSPEND_CONSOLE.
1753 * Let the calling function know so it can decide
1754 * what to do.
1755 */
1756 release_console_sem();
1757 return -EIO;
1758 }
1759 release_console_sem();
1760 if (vt_waitactive(vt + 1)) {
1761 pr_debug("Suspend: Can't switch VCs.");
1762 return -EINTR;
1763 }
1764 return prev;
1765}
1766
1767/*
1768 * Normally during a suspend, we allocate a new console and switch to it.
1769 * When we resume, we switch back to the original console. This switch
1770 * can be slow, so on systems where the framebuffer can handle restoration
1771 * of video registers anyways, there's little point in doing the console
1772 * switch. This function allows you to disable it by passing it '0'.
1773 */
1774void pm_set_vt_switch(int do_switch)
1775{
1776 acquire_console_sem();
1777 disable_vt_switch = !do_switch;
1778 release_console_sem();
1779}
1780EXPORT_SYMBOL(pm_set_vt_switch);
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-23 06:08:28 -0500