aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--arch/mn10300/kernel/asm-offsets.c6
-rw-r--r--drivers/char/cyclades.c2311
-rw-r--r--drivers/char/esp.c7
-rw-r--r--drivers/char/isicom.c57
-rw-r--r--drivers/char/mxser.c62
-rw-r--r--drivers/char/n_tty.c79
-rw-r--r--drivers/char/riscom8.c164
-rw-r--r--drivers/char/tty_io.c22
-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/vt.c14
-rw-r--r--drivers/char/vt_ioctl.c482
-rw-r--r--drivers/isdn/gigaset/interface.c19
-rw-r--r--drivers/net/slip.c96
-rw-r--r--drivers/serial/21285.c8
-rw-r--r--drivers/serial/8250.c28
-rw-r--r--drivers/serial/8250.h1
-rw-r--r--drivers/serial/amba-pl010.c6
-rw-r--r--drivers/serial/amba-pl011.c6
-rw-r--r--drivers/serial/atmel_serial.c14
-rw-r--r--drivers/serial/bfin_5xx.c24
-rw-r--r--drivers/serial/bfin_sport_uart.c6
-rw-r--r--drivers/serial/clps711x.c4
-rw-r--r--drivers/serial/cpm_uart/cpm_uart_core.c2
-rw-r--r--drivers/serial/dz.c6
-rw-r--r--drivers/serial/icom.c20
-rw-r--r--drivers/serial/imx.c16
-rw-r--r--drivers/serial/ioc3_serial.c54
-rw-r--r--drivers/serial/ioc4_serial.c68
-rw-r--r--drivers/serial/ip22zilog.c14
-rw-r--r--drivers/serial/jsm/jsm_neo.c2
-rw-r--r--drivers/serial/jsm/jsm_tty.c20
-rw-r--r--drivers/serial/m32r_sio.c6
-rw-r--r--drivers/serial/max3100.c16
-rw-r--r--drivers/serial/mcf.c4
-rw-r--r--drivers/serial/mpc52xx_uart.c4
-rw-r--r--drivers/serial/mpsc.c4
-rw-r--r--drivers/serial/msm_serial.c6
-rw-r--r--drivers/serial/mux.c4
-rw-r--r--drivers/serial/netx-serial.c6
-rw-r--r--drivers/serial/nwpserial.c4
-rw-r--r--drivers/serial/pmac_zilog.c20
-rw-r--r--drivers/serial/pnx8xxx_uart.c8
-rw-r--r--drivers/serial/pxa.c6
-rw-r--r--drivers/serial/sa1100.c8
-rw-r--r--drivers/serial/samsung.c8
-rw-r--r--drivers/serial/sb1250-duart.c6
-rw-r--r--drivers/serial/sc26xx.c10
-rw-r--r--drivers/serial/serial_core.c876
-rw-r--r--drivers/serial/serial_cs.c1
-rw-r--r--drivers/serial/serial_ks8695.c6
-rw-r--r--drivers/serial/serial_lh7a40x.c6
-rw-r--r--drivers/serial/serial_txx9.c4
-rw-r--r--drivers/serial/sh-sci.c10
-rw-r--r--drivers/serial/sn_console.c22
-rw-r--r--drivers/serial/sunhv.c8
-rw-r--r--drivers/serial/sunsab.c10
-rw-r--r--drivers/serial/sunsu.c6
-rw-r--r--drivers/serial/sunzilog.c14
-rw-r--r--drivers/serial/timbuart.c10
-rw-r--r--drivers/serial/uartlite.c19
-rw-r--r--drivers/serial/ucc_uart.c4
-rw-r--r--drivers/serial/vr41xx_siu.c6
-rw-r--r--drivers/serial/zs.c6
-rw-r--r--drivers/usb/class/cdc-acm.c5
-rw-r--r--drivers/usb/serial/ark3116.c51
-rw-r--r--drivers/usb/serial/belkin_sa.c4
-rw-r--r--drivers/usb/serial/ch341.c5
-rw-r--r--drivers/usb/serial/console.c32
-rw-r--r--drivers/usb/serial/cp210x.c12
-rw-r--r--drivers/usb/serial/cyberjack.c4
-rw-r--r--drivers/usb/serial/cypress_m8.c18
-rw-r--r--drivers/usb/serial/digi_acceleport.c6
-rw-r--r--drivers/usb/serial/empeg.c18
-rw-r--r--drivers/usb/serial/ftdi_sio.c6
-rw-r--r--drivers/usb/serial/garmin_gps.c3
-rw-r--r--drivers/usb/serial/generic.c3
-rw-r--r--drivers/usb/serial/io_edgeport.c6
-rw-r--r--drivers/usb/serial/io_ti.c3
-rw-r--r--drivers/usb/serial/ipaq.c9
-rw-r--r--drivers/usb/serial/ipw.c3
-rw-r--r--drivers/usb/serial/ir-usb.c6
-rw-r--r--drivers/usb/serial/iuu_phoenix.c34
-rw-r--r--drivers/usb/serial/keyspan.c3
-rw-r--r--drivers/usb/serial/keyspan.h3
-rw-r--r--drivers/usb/serial/keyspan_pda.c2
-rw-r--r--drivers/usb/serial/kl5kusb105.c10
-rw-r--r--drivers/usb/serial/kobil_sct.c28
-rw-r--r--drivers/usb/serial/mct_u232.c15
-rw-r--r--drivers/usb/serial/mos7720.c123
-rw-r--r--drivers/usb/serial/mos7840.c118
-rw-r--r--drivers/usb/serial/navman.c3
-rw-r--r--drivers/usb/serial/omninet.c6
-rw-r--r--drivers/usb/serial/opticon.c3
-rw-r--r--drivers/usb/serial/option.c6
-rw-r--r--drivers/usb/serial/oti6858.c27
-rw-r--r--drivers/usb/serial/pl2303.c5
-rw-r--r--drivers/usb/serial/sierra.c3
-rw-r--r--drivers/usb/serial/spcp8x5.c26
-rw-r--r--drivers/usb/serial/symbolserial.c3
-rw-r--r--drivers/usb/serial/ti_usb_3410_5052.c6
-rw-r--r--drivers/usb/serial/usb-serial.c385
-rw-r--r--drivers/usb/serial/usb_debug.c5
-rw-r--r--drivers/usb/serial/visor.c6
-rw-r--r--drivers/usb/serial/whiteheat.c11
-rw-r--r--include/linux/cyclades.h11
-rw-r--r--include/linux/hayesesp.h1
-rw-r--r--include/linux/kfifo.h4
-rw-r--r--include/linux/serial.h2
-rw-r--r--include/linux/serial_8250.h1
-rw-r--r--include/linux/serial_core.h93
-rw-r--r--include/linux/tty.h19
-rw-r--r--include/linux/usb/serial.h10
-rw-r--r--include/linux/vt.h32
-rw-r--r--include/linux/vt_kern.h16
-rw-r--r--kernel/kfifo.c2
-rw-r--r--kernel/power/console.c63
118 files changed, 2572 insertions, 3570 deletions
diff --git a/arch/mn10300/kernel/asm-offsets.c b/arch/mn10300/kernel/asm-offsets.c
index 2646fcbd7d89..82b40079ad76 100644
--- a/arch/mn10300/kernel/asm-offsets.c
+++ b/arch/mn10300/kernel/asm-offsets.c
@@ -95,7 +95,7 @@ void foo(void)
95 OFFSET(__iobase, mn10300_serial_port, _iobase); 95 OFFSET(__iobase, mn10300_serial_port, _iobase);
96 96
97 DEFINE(__UART_XMIT_SIZE, UART_XMIT_SIZE); 97 DEFINE(__UART_XMIT_SIZE, UART_XMIT_SIZE);
98 OFFSET(__xmit_buffer, uart_info, xmit.buf); 98 OFFSET(__xmit_buffer, uart_state, xmit.buf);
99 OFFSET(__xmit_head, uart_info, xmit.head); 99 OFFSET(__xmit_head, uart_state, xmit.head);
100 OFFSET(__xmit_tail, uart_info, xmit.tail); 100 OFFSET(__xmit_tail, uart_state, xmit.tail);
101} 101}
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/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/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/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/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/tty_io.c b/drivers/char/tty_io.c
index a3afa0c387cd..05f443c47bbe 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)
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/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);
diff --git a/drivers/isdn/gigaset/interface.c b/drivers/isdn/gigaset/interface.c
index 8ff7e35c7069..f33ac27de643 100644
--- a/drivers/isdn/gigaset/interface.c
+++ b/drivers/isdn/gigaset/interface.c
@@ -408,33 +408,28 @@ static int if_write_room(struct tty_struct *tty)
408 return retval; 408 return retval;
409} 409}
410 410
411/* FIXME: This function does not have error returns */
412
413static int if_chars_in_buffer(struct tty_struct *tty) 411static int if_chars_in_buffer(struct tty_struct *tty)
414{ 412{
415 struct cardstate *cs; 413 struct cardstate *cs;
416 int retval = -ENODEV; 414 int retval = 0;
417 415
418 cs = (struct cardstate *) tty->driver_data; 416 cs = (struct cardstate *) tty->driver_data;
419 if (!cs) { 417 if (!cs) {
420 pr_err("%s: no cardstate\n", __func__); 418 pr_err("%s: no cardstate\n", __func__);
421 return -ENODEV; 419 return 0;
422 } 420 }
423 421
424 gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__); 422 gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
425 423
426 if (mutex_lock_interruptible(&cs->mutex)) 424 mutex_lock(&cs->mutex);
427 return -ERESTARTSYS; // FIXME -EINTR?
428 425
429 if (!cs->connected) { 426 if (!cs->connected)
430 gig_dbg(DEBUG_IF, "not connected"); 427 gig_dbg(DEBUG_IF, "not connected");
431 retval = -ENODEV; 428 else if (!cs->open_count)
432 } else if (!cs->open_count)
433 dev_warn(cs->dev, "%s: device not opened\n", __func__); 429 dev_warn(cs->dev, "%s: device not opened\n", __func__);
434 else if (cs->mstate != MS_LOCKED) { 430 else if (cs->mstate != MS_LOCKED)
435 dev_warn(cs->dev, "can't write to unlocked device\n"); 431 dev_warn(cs->dev, "can't write to unlocked device\n");
436 retval = -EBUSY; 432 else
437 } else
438 retval = cs->ops->chars_in_buffer(cs); 433 retval = cs->ops->chars_in_buffer(cs);
439 434
440 mutex_unlock(&cs->mutex); 435 mutex_unlock(&cs->mutex);
diff --git a/drivers/net/slip.c b/drivers/net/slip.c
index 26f6ee93a064..e17c535a577e 100644
--- a/drivers/net/slip.c
+++ b/drivers/net/slip.c
@@ -616,6 +616,14 @@ static void sl_uninit(struct net_device *dev)
616 sl_free_bufs(sl); 616 sl_free_bufs(sl);
617} 617}
618 618
619/* Hook the destructor so we can free slip devices at the right point in time */
620static void sl_free_netdev(struct net_device *dev)
621{
622 int i = dev->base_addr;
623 free_netdev(dev);
624 slip_devs[i] = NULL;
625}
626
619static const struct net_device_ops sl_netdev_ops = { 627static const struct net_device_ops sl_netdev_ops = {
620 .ndo_init = sl_init, 628 .ndo_init = sl_init,
621 .ndo_uninit = sl_uninit, 629 .ndo_uninit = sl_uninit,
@@ -634,7 +642,7 @@ static const struct net_device_ops sl_netdev_ops = {
634static void sl_setup(struct net_device *dev) 642static void sl_setup(struct net_device *dev)
635{ 643{
636 dev->netdev_ops = &sl_netdev_ops; 644 dev->netdev_ops = &sl_netdev_ops;
637 dev->destructor = free_netdev; 645 dev->destructor = sl_free_netdev;
638 646
639 dev->hard_header_len = 0; 647 dev->hard_header_len = 0;
640 dev->addr_len = 0; 648 dev->addr_len = 0;
@@ -712,8 +720,6 @@ static void sl_sync(void)
712static struct slip *sl_alloc(dev_t line) 720static struct slip *sl_alloc(dev_t line)
713{ 721{
714 int i; 722 int i;
715 int sel = -1;
716 int score = -1;
717 struct net_device *dev = NULL; 723 struct net_device *dev = NULL;
718 struct slip *sl; 724 struct slip *sl;
719 725
@@ -724,55 +730,7 @@ static struct slip *sl_alloc(dev_t line)
724 dev = slip_devs[i]; 730 dev = slip_devs[i];
725 if (dev == NULL) 731 if (dev == NULL)
726 break; 732 break;
727
728 sl = netdev_priv(dev);
729 if (sl->leased) {
730 if (sl->line != line)
731 continue;
732 if (sl->tty)
733 return NULL;
734
735 /* Clear ESCAPE & ERROR flags */
736 sl->flags &= (1 << SLF_INUSE);
737 return sl;
738 }
739
740 if (sl->tty)
741 continue;
742
743 if (current->pid == sl->pid) {
744 if (sl->line == line && score < 3) {
745 sel = i;
746 score = 3;
747 continue;
748 }
749 if (score < 2) {
750 sel = i;
751 score = 2;
752 }
753 continue;
754 }
755 if (sl->line == line && score < 1) {
756 sel = i;
757 score = 1;
758 continue;
759 }
760 if (score < 0) {
761 sel = i;
762 score = 0;
763 }
764 }
765
766 if (sel >= 0) {
767 i = sel;
768 dev = slip_devs[i];
769 if (score > 1) {
770 sl = netdev_priv(dev);
771 sl->flags &= (1 << SLF_INUSE);
772 return sl;
773 }
774 } 733 }
775
776 /* Sorry, too many, all slots in use */ 734 /* Sorry, too many, all slots in use */
777 if (i >= slip_maxdev) 735 if (i >= slip_maxdev)
778 return NULL; 736 return NULL;
@@ -909,30 +867,13 @@ err_exit:
909} 867}
910 868
911/* 869/*
912
913 FIXME: 1,2 are fixed 3 was never true anyway.
914
915 Let me to blame a bit.
916 1. TTY module calls this funstion on soft interrupt.
917 2. TTY module calls this function WITH MASKED INTERRUPTS!
918 3. TTY module does not notify us about line discipline
919 shutdown,
920
921 Seems, now it is clean. The solution is to consider netdevice and
922 line discipline sides as two independent threads.
923
924 By-product (not desired): sl? does not feel hangups and remains open.
925 It is supposed, that user level program (dip, diald, slattach...)
926 will catch SIGHUP and make the rest of work.
927
928 I see no way to make more with current tty code. --ANK
929 */
930
931/*
932 * Close down a SLIP channel. 870 * Close down a SLIP channel.
933 * This means flushing out any pending queues, and then returning. This 871 * This means flushing out any pending queues, and then returning. This
934 * call is serialized against other ldisc functions. 872 * call is serialized against other ldisc functions.
873 *
874 * We also use this method fo a hangup event
935 */ 875 */
876
936static void slip_close(struct tty_struct *tty) 877static void slip_close(struct tty_struct *tty)
937{ 878{
938 struct slip *sl = tty->disc_data; 879 struct slip *sl = tty->disc_data;
@@ -951,10 +892,16 @@ static void slip_close(struct tty_struct *tty)
951 del_timer_sync(&sl->keepalive_timer); 892 del_timer_sync(&sl->keepalive_timer);
952 del_timer_sync(&sl->outfill_timer); 893 del_timer_sync(&sl->outfill_timer);
953#endif 894#endif
954 895 /* Flush network side */
955 /* Count references from TTY module */ 896 unregister_netdev(sl->dev);
897 /* This will complete via sl_free_netdev */
956} 898}
957 899
900static int slip_hangup(struct tty_struct *tty)
901{
902 slip_close(tty);
903 return 0;
904}
958 /************************************************************************ 905 /************************************************************************
959 * STANDARD SLIP ENCAPSULATION * 906 * STANDARD SLIP ENCAPSULATION *
960 ************************************************************************/ 907 ************************************************************************/
@@ -1311,6 +1258,7 @@ static struct tty_ldisc_ops sl_ldisc = {
1311 .name = "slip", 1258 .name = "slip",
1312 .open = slip_open, 1259 .open = slip_open,
1313 .close = slip_close, 1260 .close = slip_close,
1261 .hangup = slip_hangup,
1314 .ioctl = slip_ioctl, 1262 .ioctl = slip_ioctl,
1315 .receive_buf = slip_receive_buf, 1263 .receive_buf = slip_receive_buf,
1316 .write_wakeup = slip_write_wakeup, 1264 .write_wakeup = slip_write_wakeup,
@@ -1384,6 +1332,8 @@ static void __exit slip_exit(void)
1384 } 1332 }
1385 } while (busy && time_before(jiffies, timeout)); 1333 } while (busy && time_before(jiffies, timeout));
1386 1334
1335 /* FIXME: hangup is async so we should wait when doing this second
1336 phase */
1387 1337
1388 for (i = 0; i < slip_maxdev; i++) { 1338 for (i = 0; i < slip_maxdev; i++) {
1389 dev = slip_devs[i]; 1339 dev = slip_devs[i];
diff --git a/drivers/serial/21285.c b/drivers/serial/21285.c
index cb6d85d7ff43..1e3d19397a59 100644
--- a/drivers/serial/21285.c
+++ b/drivers/serial/21285.c
@@ -86,7 +86,7 @@ static void serial21285_enable_ms(struct uart_port *port)
86static irqreturn_t serial21285_rx_chars(int irq, void *dev_id) 86static irqreturn_t serial21285_rx_chars(int irq, void *dev_id)
87{ 87{
88 struct uart_port *port = dev_id; 88 struct uart_port *port = dev_id;
89 struct tty_struct *tty = port->info->port.tty; 89 struct tty_struct *tty = port->state->port.tty;
90 unsigned int status, ch, flag, rxs, max_count = 256; 90 unsigned int status, ch, flag, rxs, max_count = 256;
91 91
92 status = *CSR_UARTFLG; 92 status = *CSR_UARTFLG;
@@ -124,7 +124,7 @@ static irqreturn_t serial21285_rx_chars(int irq, void *dev_id)
124static irqreturn_t serial21285_tx_chars(int irq, void *dev_id) 124static irqreturn_t serial21285_tx_chars(int irq, void *dev_id)
125{ 125{
126 struct uart_port *port = dev_id; 126 struct uart_port *port = dev_id;
127 struct circ_buf *xmit = &port->info->xmit; 127 struct circ_buf *xmit = &port->state->xmit;
128 int count = 256; 128 int count = 256;
129 129
130 if (port->x_char) { 130 if (port->x_char) {
@@ -235,8 +235,8 @@ serial21285_set_termios(struct uart_port *port, struct ktermios *termios,
235 baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16); 235 baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
236 quot = uart_get_divisor(port, baud); 236 quot = uart_get_divisor(port, baud);
237 237
238 if (port->info && port->info->port.tty) { 238 if (port->state && port->state->port.tty) {
239 struct tty_struct *tty = port->info->port.tty; 239 struct tty_struct *tty = port->state->port.tty;
240 unsigned int b = port->uartclk / (16 * quot); 240 unsigned int b = port->uartclk / (16 * quot);
241 tty_encode_baud_rate(tty, b, b); 241 tty_encode_baud_rate(tty, b, b);
242 } 242 }
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index fb867a9f55e9..2209620d2349 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -1382,7 +1382,7 @@ static void serial8250_enable_ms(struct uart_port *port)
1382static void 1382static void
1383receive_chars(struct uart_8250_port *up, unsigned int *status) 1383receive_chars(struct uart_8250_port *up, unsigned int *status)
1384{ 1384{
1385 struct tty_struct *tty = up->port.info->port.tty; 1385 struct tty_struct *tty = up->port.state->port.tty;
1386 unsigned char ch, lsr = *status; 1386 unsigned char ch, lsr = *status;
1387 int max_count = 256; 1387 int max_count = 256;
1388 char flag; 1388 char flag;
@@ -1457,7 +1457,7 @@ ignore_char:
1457 1457
1458static void transmit_chars(struct uart_8250_port *up) 1458static void transmit_chars(struct uart_8250_port *up)
1459{ 1459{
1460 struct circ_buf *xmit = &up->port.info->xmit; 1460 struct circ_buf *xmit = &up->port.state->xmit;
1461 int count; 1461 int count;
1462 1462
1463 if (up->port.x_char) { 1463 if (up->port.x_char) {
@@ -1500,7 +1500,7 @@ static unsigned int check_modem_status(struct uart_8250_port *up)
1500 status |= up->msr_saved_flags; 1500 status |= up->msr_saved_flags;
1501 up->msr_saved_flags = 0; 1501 up->msr_saved_flags = 0;
1502 if (status & UART_MSR_ANY_DELTA && up->ier & UART_IER_MSI && 1502 if (status & UART_MSR_ANY_DELTA && up->ier & UART_IER_MSI &&
1503 up->port.info != NULL) { 1503 up->port.state != NULL) {
1504 if (status & UART_MSR_TERI) 1504 if (status & UART_MSR_TERI)
1505 up->port.icount.rng++; 1505 up->port.icount.rng++;
1506 if (status & UART_MSR_DDSR) 1506 if (status & UART_MSR_DDSR)
@@ -1510,7 +1510,7 @@ static unsigned int check_modem_status(struct uart_8250_port *up)
1510 if (status & UART_MSR_DCTS) 1510 if (status & UART_MSR_DCTS)
1511 uart_handle_cts_change(&up->port, status & UART_MSR_CTS); 1511 uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
1512 1512
1513 wake_up_interruptible(&up->port.info->delta_msr_wait); 1513 wake_up_interruptible(&up->port.state->port.delta_msr_wait);
1514 } 1514 }
1515 1515
1516 return status; 1516 return status;
@@ -1677,7 +1677,7 @@ static int serial_link_irq_chain(struct uart_8250_port *up)
1677 INIT_LIST_HEAD(&up->list); 1677 INIT_LIST_HEAD(&up->list);
1678 i->head = &up->list; 1678 i->head = &up->list;
1679 spin_unlock_irq(&i->lock); 1679 spin_unlock_irq(&i->lock);
1680 1680 irq_flags |= up->port.irqflags;
1681 ret = request_irq(up->port.irq, serial8250_interrupt, 1681 ret = request_irq(up->port.irq, serial8250_interrupt,
1682 irq_flags, "serial", i); 1682 irq_flags, "serial", i);
1683 if (ret < 0) 1683 if (ret < 0)
@@ -1764,7 +1764,7 @@ static void serial8250_backup_timeout(unsigned long data)
1764 up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS; 1764 up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
1765 spin_unlock_irqrestore(&up->port.lock, flags); 1765 spin_unlock_irqrestore(&up->port.lock, flags);
1766 if ((iir & UART_IIR_NO_INT) && (up->ier & UART_IER_THRI) && 1766 if ((iir & UART_IIR_NO_INT) && (up->ier & UART_IER_THRI) &&
1767 (!uart_circ_empty(&up->port.info->xmit) || up->port.x_char) && 1767 (!uart_circ_empty(&up->port.state->xmit) || up->port.x_char) &&
1768 (lsr & UART_LSR_THRE)) { 1768 (lsr & UART_LSR_THRE)) {
1769 iir &= ~(UART_IIR_ID | UART_IIR_NO_INT); 1769 iir &= ~(UART_IIR_ID | UART_IIR_NO_INT);
1770 iir |= UART_IIR_THRI; 1770 iir |= UART_IIR_THRI;
@@ -2026,7 +2026,7 @@ static int serial8250_startup(struct uart_port *port)
2026 * allow register changes to become visible. 2026 * allow register changes to become visible.
2027 */ 2027 */
2028 spin_lock_irqsave(&up->port.lock, flags); 2028 spin_lock_irqsave(&up->port.lock, flags);
2029 if (up->port.flags & UPF_SHARE_IRQ) 2029 if (up->port.irqflags & IRQF_SHARED)
2030 disable_irq_nosync(up->port.irq); 2030 disable_irq_nosync(up->port.irq);
2031 2031
2032 wait_for_xmitr(up, UART_LSR_THRE); 2032 wait_for_xmitr(up, UART_LSR_THRE);
@@ -2039,7 +2039,7 @@ static int serial8250_startup(struct uart_port *port)
2039 iir = serial_in(up, UART_IIR); 2039 iir = serial_in(up, UART_IIR);
2040 serial_out(up, UART_IER, 0); 2040 serial_out(up, UART_IER, 0);
2041 2041
2042 if (up->port.flags & UPF_SHARE_IRQ) 2042 if (up->port.irqflags & IRQF_SHARED)
2043 enable_irq(up->port.irq); 2043 enable_irq(up->port.irq);
2044 spin_unlock_irqrestore(&up->port.lock, flags); 2044 spin_unlock_irqrestore(&up->port.lock, flags);
2045 2045
@@ -2272,7 +2272,9 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
2272 /* 2272 /*
2273 * Ask the core to calculate the divisor for us. 2273 * Ask the core to calculate the divisor for us.
2274 */ 2274 */
2275 baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16); 2275 baud = uart_get_baud_rate(port, termios, old,
2276 port->uartclk / 16 / 0xffff,
2277 port->uartclk / 16);
2276 quot = serial8250_get_divisor(port, baud); 2278 quot = serial8250_get_divisor(port, baud);
2277 2279
2278 /* 2280 /*
@@ -2671,6 +2673,7 @@ static void __init serial8250_isa_init_ports(void)
2671 i++, up++) { 2673 i++, up++) {
2672 up->port.iobase = old_serial_port[i].port; 2674 up->port.iobase = old_serial_port[i].port;
2673 up->port.irq = irq_canonicalize(old_serial_port[i].irq); 2675 up->port.irq = irq_canonicalize(old_serial_port[i].irq);
2676 up->port.irqflags = old_serial_port[i].irqflags;
2674 up->port.uartclk = old_serial_port[i].baud_base * 16; 2677 up->port.uartclk = old_serial_port[i].baud_base * 16;
2675 up->port.flags = old_serial_port[i].flags; 2678 up->port.flags = old_serial_port[i].flags;
2676 up->port.hub6 = old_serial_port[i].hub6; 2679 up->port.hub6 = old_serial_port[i].hub6;
@@ -2679,7 +2682,7 @@ static void __init serial8250_isa_init_ports(void)
2679 up->port.regshift = old_serial_port[i].iomem_reg_shift; 2682 up->port.regshift = old_serial_port[i].iomem_reg_shift;
2680 set_io_from_upio(&up->port); 2683 set_io_from_upio(&up->port);
2681 if (share_irqs) 2684 if (share_irqs)
2682 up->port.flags |= UPF_SHARE_IRQ; 2685 up->port.irqflags |= IRQF_SHARED;
2683 } 2686 }
2684} 2687}
2685 2688
@@ -2869,6 +2872,7 @@ int __init early_serial_setup(struct uart_port *port)
2869 p->iobase = port->iobase; 2872 p->iobase = port->iobase;
2870 p->membase = port->membase; 2873 p->membase = port->membase;
2871 p->irq = port->irq; 2874 p->irq = port->irq;
2875 p->irqflags = port->irqflags;
2872 p->uartclk = port->uartclk; 2876 p->uartclk = port->uartclk;
2873 p->fifosize = port->fifosize; 2877 p->fifosize = port->fifosize;
2874 p->regshift = port->regshift; 2878 p->regshift = port->regshift;
@@ -2942,6 +2946,7 @@ static int __devinit serial8250_probe(struct platform_device *dev)
2942 port.iobase = p->iobase; 2946 port.iobase = p->iobase;
2943 port.membase = p->membase; 2947 port.membase = p->membase;
2944 port.irq = p->irq; 2948 port.irq = p->irq;
2949 port.irqflags = p->irqflags;
2945 port.uartclk = p->uartclk; 2950 port.uartclk = p->uartclk;
2946 port.regshift = p->regshift; 2951 port.regshift = p->regshift;
2947 port.iotype = p->iotype; 2952 port.iotype = p->iotype;
@@ -2954,7 +2959,7 @@ static int __devinit serial8250_probe(struct platform_device *dev)
2954 port.serial_out = p->serial_out; 2959 port.serial_out = p->serial_out;
2955 port.dev = &dev->dev; 2960 port.dev = &dev->dev;
2956 if (share_irqs) 2961 if (share_irqs)
2957 port.flags |= UPF_SHARE_IRQ; 2962 port.irqflags |= IRQF_SHARED;
2958 ret = serial8250_register_port(&port); 2963 ret = serial8250_register_port(&port);
2959 if (ret < 0) { 2964 if (ret < 0) {
2960 dev_err(&dev->dev, "unable to register port at index %d " 2965 dev_err(&dev->dev, "unable to register port at index %d "
@@ -3096,6 +3101,7 @@ int serial8250_register_port(struct uart_port *port)
3096 uart->port.iobase = port->iobase; 3101 uart->port.iobase = port->iobase;
3097 uart->port.membase = port->membase; 3102 uart->port.membase = port->membase;
3098 uart->port.irq = port->irq; 3103 uart->port.irq = port->irq;
3104 uart->port.irqflags = port->irqflags;
3099 uart->port.uartclk = port->uartclk; 3105 uart->port.uartclk = port->uartclk;
3100 uart->port.fifosize = port->fifosize; 3106 uart->port.fifosize = port->fifosize;
3101 uart->port.regshift = port->regshift; 3107 uart->port.regshift = port->regshift;
diff --git a/drivers/serial/8250.h b/drivers/serial/8250.h
index 520260326f3d..6e19ea3e48d5 100644
--- a/drivers/serial/8250.h
+++ b/drivers/serial/8250.h
@@ -25,6 +25,7 @@ struct old_serial_port {
25 unsigned char io_type; 25 unsigned char io_type;
26 unsigned char *iomem_base; 26 unsigned char *iomem_base;
27 unsigned short iomem_reg_shift; 27 unsigned short iomem_reg_shift;
28 unsigned long irqflags;
28}; 29};
29 30
30/* 31/*
diff --git a/drivers/serial/amba-pl010.c b/drivers/serial/amba-pl010.c
index 58a4879c7e48..429a8ae86933 100644
--- a/drivers/serial/amba-pl010.c
+++ b/drivers/serial/amba-pl010.c
@@ -117,7 +117,7 @@ static void pl010_enable_ms(struct uart_port *port)
117 117
118static void pl010_rx_chars(struct uart_amba_port *uap) 118static void pl010_rx_chars(struct uart_amba_port *uap)
119{ 119{
120 struct tty_struct *tty = uap->port.info->port.tty; 120 struct tty_struct *tty = uap->port.state->port.tty;
121 unsigned int status, ch, flag, rsr, max_count = 256; 121 unsigned int status, ch, flag, rsr, max_count = 256;
122 122
123 status = readb(uap->port.membase + UART01x_FR); 123 status = readb(uap->port.membase + UART01x_FR);
@@ -172,7 +172,7 @@ static void pl010_rx_chars(struct uart_amba_port *uap)
172 172
173static void pl010_tx_chars(struct uart_amba_port *uap) 173static void pl010_tx_chars(struct uart_amba_port *uap)
174{ 174{
175 struct circ_buf *xmit = &uap->port.info->xmit; 175 struct circ_buf *xmit = &uap->port.state->xmit;
176 int count; 176 int count;
177 177
178 if (uap->port.x_char) { 178 if (uap->port.x_char) {
@@ -225,7 +225,7 @@ static void pl010_modem_status(struct uart_amba_port *uap)
225 if (delta & UART01x_FR_CTS) 225 if (delta & UART01x_FR_CTS)
226 uart_handle_cts_change(&uap->port, status & UART01x_FR_CTS); 226 uart_handle_cts_change(&uap->port, status & UART01x_FR_CTS);
227 227
228 wake_up_interruptible(&uap->port.info->delta_msr_wait); 228 wake_up_interruptible(&uap->port.state->port.delta_msr_wait);
229} 229}
230 230
231static irqreturn_t pl010_int(int irq, void *dev_id) 231static irqreturn_t pl010_int(int irq, void *dev_id)
diff --git a/drivers/serial/amba-pl011.c b/drivers/serial/amba-pl011.c
index 72ba0c6d3551..ef7adc8135dd 100644
--- a/drivers/serial/amba-pl011.c
+++ b/drivers/serial/amba-pl011.c
@@ -124,7 +124,7 @@ static void pl011_enable_ms(struct uart_port *port)
124 124
125static void pl011_rx_chars(struct uart_amba_port *uap) 125static void pl011_rx_chars(struct uart_amba_port *uap)
126{ 126{
127 struct tty_struct *tty = uap->port.info->port.tty; 127 struct tty_struct *tty = uap->port.state->port.tty;
128 unsigned int status, ch, flag, max_count = 256; 128 unsigned int status, ch, flag, max_count = 256;
129 129
130 status = readw(uap->port.membase + UART01x_FR); 130 status = readw(uap->port.membase + UART01x_FR);
@@ -175,7 +175,7 @@ static void pl011_rx_chars(struct uart_amba_port *uap)
175 175
176static void pl011_tx_chars(struct uart_amba_port *uap) 176static void pl011_tx_chars(struct uart_amba_port *uap)
177{ 177{
178 struct circ_buf *xmit = &uap->port.info->xmit; 178 struct circ_buf *xmit = &uap->port.state->xmit;
179 int count; 179 int count;
180 180
181 if (uap->port.x_char) { 181 if (uap->port.x_char) {
@@ -226,7 +226,7 @@ static void pl011_modem_status(struct uart_amba_port *uap)
226 if (delta & UART01x_FR_CTS) 226 if (delta & UART01x_FR_CTS)
227 uart_handle_cts_change(&uap->port, status & UART01x_FR_CTS); 227 uart_handle_cts_change(&uap->port, status & UART01x_FR_CTS);
228 228
229 wake_up_interruptible(&uap->port.info->delta_msr_wait); 229 wake_up_interruptible(&uap->port.state->port.delta_msr_wait);
230} 230}
231 231
232static irqreturn_t pl011_int(int irq, void *dev_id) 232static irqreturn_t pl011_int(int irq, void *dev_id)
diff --git a/drivers/serial/atmel_serial.c b/drivers/serial/atmel_serial.c
index 607d43a31048..3551c5cb7094 100644
--- a/drivers/serial/atmel_serial.c
+++ b/drivers/serial/atmel_serial.c
@@ -427,7 +427,7 @@ static void atmel_rx_chars(struct uart_port *port)
427 */ 427 */
428static void atmel_tx_chars(struct uart_port *port) 428static void atmel_tx_chars(struct uart_port *port)
429{ 429{
430 struct circ_buf *xmit = &port->info->xmit; 430 struct circ_buf *xmit = &port->state->xmit;
431 431
432 if (port->x_char && UART_GET_CSR(port) & ATMEL_US_TXRDY) { 432 if (port->x_char && UART_GET_CSR(port) & ATMEL_US_TXRDY) {
433 UART_PUT_CHAR(port, port->x_char); 433 UART_PUT_CHAR(port, port->x_char);
@@ -560,7 +560,7 @@ static irqreturn_t atmel_interrupt(int irq, void *dev_id)
560static void atmel_tx_dma(struct uart_port *port) 560static void atmel_tx_dma(struct uart_port *port)
561{ 561{
562 struct atmel_uart_port *atmel_port = to_atmel_uart_port(port); 562 struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
563 struct circ_buf *xmit = &port->info->xmit; 563 struct circ_buf *xmit = &port->state->xmit;
564 struct atmel_dma_buffer *pdc = &atmel_port->pdc_tx; 564 struct atmel_dma_buffer *pdc = &atmel_port->pdc_tx;
565 int count; 565 int count;
566 566
@@ -663,14 +663,14 @@ static void atmel_rx_from_ring(struct uart_port *port)
663 * uart_start(), which takes the lock. 663 * uart_start(), which takes the lock.
664 */ 664 */
665 spin_unlock(&port->lock); 665 spin_unlock(&port->lock);
666 tty_flip_buffer_push(port->info->port.tty); 666 tty_flip_buffer_push(port->state->port.tty);
667 spin_lock(&port->lock); 667 spin_lock(&port->lock);
668} 668}
669 669
670static void atmel_rx_from_dma(struct uart_port *port) 670static void atmel_rx_from_dma(struct uart_port *port)
671{ 671{
672 struct atmel_uart_port *atmel_port = to_atmel_uart_port(port); 672 struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
673 struct tty_struct *tty = port->info->port.tty; 673 struct tty_struct *tty = port->state->port.tty;
674 struct atmel_dma_buffer *pdc; 674 struct atmel_dma_buffer *pdc;
675 int rx_idx = atmel_port->pdc_rx_idx; 675 int rx_idx = atmel_port->pdc_rx_idx;
676 unsigned int head; 676 unsigned int head;
@@ -776,7 +776,7 @@ static void atmel_tasklet_func(unsigned long data)
776 if (status_change & ATMEL_US_CTS) 776 if (status_change & ATMEL_US_CTS)
777 uart_handle_cts_change(port, !(status & ATMEL_US_CTS)); 777 uart_handle_cts_change(port, !(status & ATMEL_US_CTS));
778 778
779 wake_up_interruptible(&port->info->delta_msr_wait); 779 wake_up_interruptible(&port->state->port.delta_msr_wait);
780 780
781 atmel_port->irq_status_prev = status; 781 atmel_port->irq_status_prev = status;
782 } 782 }
@@ -795,7 +795,7 @@ static void atmel_tasklet_func(unsigned long data)
795static int atmel_startup(struct uart_port *port) 795static int atmel_startup(struct uart_port *port)
796{ 796{
797 struct atmel_uart_port *atmel_port = to_atmel_uart_port(port); 797 struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
798 struct tty_struct *tty = port->info->port.tty; 798 struct tty_struct *tty = port->state->port.tty;
799 int retval; 799 int retval;
800 800
801 /* 801 /*
@@ -854,7 +854,7 @@ static int atmel_startup(struct uart_port *port)
854 } 854 }
855 if (atmel_use_dma_tx(port)) { 855 if (atmel_use_dma_tx(port)) {
856 struct atmel_dma_buffer *pdc = &atmel_port->pdc_tx; 856 struct atmel_dma_buffer *pdc = &atmel_port->pdc_tx;
857 struct circ_buf *xmit = &port->info->xmit; 857 struct circ_buf *xmit = &port->state->xmit;
858 858
859 pdc->buf = xmit->buf; 859 pdc->buf = xmit->buf;
860 pdc->dma_addr = dma_map_single(port->dev, 860 pdc->dma_addr = dma_map_single(port->dev,
diff --git a/drivers/serial/bfin_5xx.c b/drivers/serial/bfin_5xx.c
index b4a7650af696..50abb7e557f4 100644
--- a/drivers/serial/bfin_5xx.c
+++ b/drivers/serial/bfin_5xx.c
@@ -42,6 +42,10 @@
42# undef CONFIG_EARLY_PRINTK 42# undef CONFIG_EARLY_PRINTK
43#endif 43#endif
44 44
45#ifdef CONFIG_SERIAL_BFIN_MODULE
46# undef CONFIG_EARLY_PRINTK
47#endif
48
45/* UART name and device definitions */ 49/* UART name and device definitions */
46#define BFIN_SERIAL_NAME "ttyBF" 50#define BFIN_SERIAL_NAME "ttyBF"
47#define BFIN_SERIAL_MAJOR 204 51#define BFIN_SERIAL_MAJOR 204
@@ -140,7 +144,7 @@ static void bfin_serial_stop_tx(struct uart_port *port)
140{ 144{
141 struct bfin_serial_port *uart = (struct bfin_serial_port *)port; 145 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
142#ifdef CONFIG_SERIAL_BFIN_DMA 146#ifdef CONFIG_SERIAL_BFIN_DMA
143 struct circ_buf *xmit = &uart->port.info->xmit; 147 struct circ_buf *xmit = &uart->port.state->xmit;
144#endif 148#endif
145 149
146 while (!(UART_GET_LSR(uart) & TEMT)) 150 while (!(UART_GET_LSR(uart) & TEMT))
@@ -167,7 +171,7 @@ static void bfin_serial_stop_tx(struct uart_port *port)
167static void bfin_serial_start_tx(struct uart_port *port) 171static void bfin_serial_start_tx(struct uart_port *port)
168{ 172{
169 struct bfin_serial_port *uart = (struct bfin_serial_port *)port; 173 struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
170 struct tty_struct *tty = uart->port.info->port.tty; 174 struct tty_struct *tty = uart->port.state->port.tty;
171 175
172#ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS 176#ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
173 if (uart->scts && !(bfin_serial_get_mctrl(&uart->port) & TIOCM_CTS)) { 177 if (uart->scts && !(bfin_serial_get_mctrl(&uart->port) & TIOCM_CTS)) {
@@ -239,10 +243,10 @@ static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
239 return; 243 return;
240 } 244 }
241 245
242 if (!uart->port.info || !uart->port.info->port.tty) 246 if (!uart->port.state || !uart->port.state->port.tty)
243 return; 247 return;
244#endif 248#endif
245 tty = uart->port.info->port.tty; 249 tty = uart->port.state->port.tty;
246 250
247 if (ANOMALY_05000363) { 251 if (ANOMALY_05000363) {
248 /* The BF533 (and BF561) family of processors have a nice anomaly 252 /* The BF533 (and BF561) family of processors have a nice anomaly
@@ -327,7 +331,7 @@ static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
327 331
328static void bfin_serial_tx_chars(struct bfin_serial_port *uart) 332static void bfin_serial_tx_chars(struct bfin_serial_port *uart)
329{ 333{
330 struct circ_buf *xmit = &uart->port.info->xmit; 334 struct circ_buf *xmit = &uart->port.state->xmit;
331 335
332 if (uart_circ_empty(xmit) || uart_tx_stopped(&uart->port)) { 336 if (uart_circ_empty(xmit) || uart_tx_stopped(&uart->port)) {
333#ifdef CONFIG_BF54x 337#ifdef CONFIG_BF54x
@@ -394,7 +398,7 @@ static irqreturn_t bfin_serial_tx_int(int irq, void *dev_id)
394#ifdef CONFIG_SERIAL_BFIN_DMA 398#ifdef CONFIG_SERIAL_BFIN_DMA
395static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart) 399static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart)
396{ 400{
397 struct circ_buf *xmit = &uart->port.info->xmit; 401 struct circ_buf *xmit = &uart->port.state->xmit;
398 402
399 uart->tx_done = 0; 403 uart->tx_done = 0;
400 404
@@ -432,7 +436,7 @@ static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart)
432 436
433static void bfin_serial_dma_rx_chars(struct bfin_serial_port *uart) 437static void bfin_serial_dma_rx_chars(struct bfin_serial_port *uart)
434{ 438{
435 struct tty_struct *tty = uart->port.info->port.tty; 439 struct tty_struct *tty = uart->port.state->port.tty;
436 int i, flg, status; 440 int i, flg, status;
437 441
438 status = UART_GET_LSR(uart); 442 status = UART_GET_LSR(uart);
@@ -525,7 +529,7 @@ void bfin_serial_rx_dma_timeout(struct bfin_serial_port *uart)
525static irqreturn_t bfin_serial_dma_tx_int(int irq, void *dev_id) 529static irqreturn_t bfin_serial_dma_tx_int(int irq, void *dev_id)
526{ 530{
527 struct bfin_serial_port *uart = dev_id; 531 struct bfin_serial_port *uart = dev_id;
528 struct circ_buf *xmit = &uart->port.info->xmit; 532 struct circ_buf *xmit = &uart->port.state->xmit;
529 533
530#ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS 534#ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
531 if (uart->scts && !(bfin_serial_get_mctrl(&uart->port)&TIOCM_CTS)) { 535 if (uart->scts && !(bfin_serial_get_mctrl(&uart->port)&TIOCM_CTS)) {
@@ -961,10 +965,10 @@ static void bfin_serial_set_ldisc(struct uart_port *port)
961 int line = port->line; 965 int line = port->line;
962 unsigned short val; 966 unsigned short val;
963 967
964 if (line >= port->info->port.tty->driver->num) 968 if (line >= port->state->port.tty->driver->num)
965 return; 969 return;
966 970
967 switch (port->info->port.tty->termios->c_line) { 971 switch (port->state->port.tty->termios->c_line) {
968 case N_IRDA: 972 case N_IRDA:
969 val = UART_GET_GCTL(&bfin_serial_ports[line]); 973 val = UART_GET_GCTL(&bfin_serial_ports[line]);
970 val |= (IREN | RPOLC); 974 val |= (IREN | RPOLC);
diff --git a/drivers/serial/bfin_sport_uart.c b/drivers/serial/bfin_sport_uart.c
index c108b1a0ce98..088bb35475f1 100644
--- a/drivers/serial/bfin_sport_uart.c
+++ b/drivers/serial/bfin_sport_uart.c
@@ -178,7 +178,7 @@ static int sport_uart_setup(struct sport_uart_port *up, int sclk, int baud_rate)
178static irqreturn_t sport_uart_rx_irq(int irq, void *dev_id) 178static irqreturn_t sport_uart_rx_irq(int irq, void *dev_id)
179{ 179{
180 struct sport_uart_port *up = dev_id; 180 struct sport_uart_port *up = dev_id;
181 struct tty_struct *tty = up->port.info->port.tty; 181 struct tty_struct *tty = up->port.state->port.tty;
182 unsigned int ch; 182 unsigned int ch;
183 183
184 do { 184 do {
@@ -205,7 +205,7 @@ static irqreturn_t sport_uart_tx_irq(int irq, void *dev_id)
205static irqreturn_t sport_uart_err_irq(int irq, void *dev_id) 205static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
206{ 206{
207 struct sport_uart_port *up = dev_id; 207 struct sport_uart_port *up = dev_id;
208 struct tty_struct *tty = up->port.info->port.tty; 208 struct tty_struct *tty = up->port.state->port.tty;
209 unsigned int stat = SPORT_GET_STAT(up); 209 unsigned int stat = SPORT_GET_STAT(up);
210 210
211 /* Overflow in RX FIFO */ 211 /* Overflow in RX FIFO */
@@ -290,7 +290,7 @@ fail1:
290 290
291static void sport_uart_tx_chars(struct sport_uart_port *up) 291static void sport_uart_tx_chars(struct sport_uart_port *up)
292{ 292{
293 struct circ_buf *xmit = &up->port.info->xmit; 293 struct circ_buf *xmit = &up->port.state->xmit;
294 294
295 if (SPORT_GET_STAT(up) & TXF) 295 if (SPORT_GET_STAT(up) & TXF)
296 return; 296 return;
diff --git a/drivers/serial/clps711x.c b/drivers/serial/clps711x.c
index 80e76426131d..b6acd19b458e 100644
--- a/drivers/serial/clps711x.c
+++ b/drivers/serial/clps711x.c
@@ -93,7 +93,7 @@ static void clps711xuart_enable_ms(struct uart_port *port)
93static irqreturn_t clps711xuart_int_rx(int irq, void *dev_id) 93static irqreturn_t clps711xuart_int_rx(int irq, void *dev_id)
94{ 94{
95 struct uart_port *port = dev_id; 95 struct uart_port *port = dev_id;
96 struct tty_struct *tty = port->info->port.tty; 96 struct tty_struct *tty = port->state->port.tty;
97 unsigned int status, ch, flg; 97 unsigned int status, ch, flg;
98 98
99 status = clps_readl(SYSFLG(port)); 99 status = clps_readl(SYSFLG(port));
@@ -147,7 +147,7 @@ static irqreturn_t clps711xuart_int_rx(int irq, void *dev_id)
147static irqreturn_t clps711xuart_int_tx(int irq, void *dev_id) 147static irqreturn_t clps711xuart_int_tx(int irq, void *dev_id)
148{ 148{
149 struct uart_port *port = dev_id; 149 struct uart_port *port = dev_id;
150 struct circ_buf *xmit = &port->info->xmit; 150 struct circ_buf *xmit = &port->state->xmit;
151 int count; 151 int count;
152 152
153 if (port->x_char) { 153 if (port->x_char) {
diff --git a/drivers/serial/cpm_uart/cpm_uart_core.c b/drivers/serial/cpm_uart/cpm_uart_core.c
index f8df0681e160..8d349b23249a 100644
--- a/drivers/serial/cpm_uart/cpm_uart_core.c
+++ b/drivers/serial/cpm_uart/cpm_uart_core.c
@@ -244,7 +244,7 @@ static void cpm_uart_int_rx(struct uart_port *port)
244 int i; 244 int i;
245 unsigned char ch; 245 unsigned char ch;
246 u8 *cp; 246 u8 *cp;
247 struct tty_struct *tty = port->info->port.tty; 247 struct tty_struct *tty = port->state->port.tty;
248 struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port; 248 struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
249 cbd_t __iomem *bdp; 249 cbd_t __iomem *bdp;
250 u16 status; 250 u16 status;
diff --git a/drivers/serial/dz.c b/drivers/serial/dz.c
index 6042b87797a1..57421d776329 100644
--- a/drivers/serial/dz.c
+++ b/drivers/serial/dz.c
@@ -197,7 +197,7 @@ static inline void dz_receive_chars(struct dz_mux *mux)
197 while ((status = dz_in(dport, DZ_RBUF)) & DZ_DVAL) { 197 while ((status = dz_in(dport, DZ_RBUF)) & DZ_DVAL) {
198 dport = &mux->dport[LINE(status)]; 198 dport = &mux->dport[LINE(status)];
199 uport = &dport->port; 199 uport = &dport->port;
200 tty = uport->info->port.tty; /* point to the proper dev */ 200 tty = uport->state->port.tty; /* point to the proper dev */
201 201
202 ch = UCHAR(status); /* grab the char */ 202 ch = UCHAR(status); /* grab the char */
203 flag = TTY_NORMAL; 203 flag = TTY_NORMAL;
@@ -249,7 +249,7 @@ static inline void dz_receive_chars(struct dz_mux *mux)
249 } 249 }
250 for (i = 0; i < DZ_NB_PORT; i++) 250 for (i = 0; i < DZ_NB_PORT; i++)
251 if (lines_rx[i]) 251 if (lines_rx[i])
252 tty_flip_buffer_push(mux->dport[i].port.info->port.tty); 252 tty_flip_buffer_push(mux->dport[i].port.state->port.tty);
253} 253}
254 254
255/* 255/*
@@ -268,7 +268,7 @@ static inline void dz_transmit_chars(struct dz_mux *mux)
268 268
269 status = dz_in(dport, DZ_CSR); 269 status = dz_in(dport, DZ_CSR);
270 dport = &mux->dport[LINE(status)]; 270 dport = &mux->dport[LINE(status)];
271 xmit = &dport->port.info->xmit; 271 xmit = &dport->port.state->xmit;
272 272
273 if (dport->port.x_char) { /* XON/XOFF chars */ 273 if (dport->port.x_char) { /* XON/XOFF chars */
274 dz_out(dport, DZ_TDR, dport->port.x_char); 274 dz_out(dport, DZ_TDR, dport->port.x_char);
diff --git a/drivers/serial/icom.c b/drivers/serial/icom.c
index cd1b6a45bb82..2d7feecaf492 100644
--- a/drivers/serial/icom.c
+++ b/drivers/serial/icom.c
@@ -617,7 +617,7 @@ static void shutdown(struct icom_port *icom_port)
617 * disable break condition 617 * disable break condition
618 */ 618 */
619 cmdReg = readb(&icom_port->dram->CmdReg); 619 cmdReg = readb(&icom_port->dram->CmdReg);
620 if ((cmdReg | CMD_SND_BREAK) == CMD_SND_BREAK) { 620 if (cmdReg & CMD_SND_BREAK) {
621 writeb(cmdReg & ~CMD_SND_BREAK, &icom_port->dram->CmdReg); 621 writeb(cmdReg & ~CMD_SND_BREAK, &icom_port->dram->CmdReg);
622 } 622 }
623} 623}
@@ -627,7 +627,7 @@ static int icom_write(struct uart_port *port)
627 unsigned long data_count; 627 unsigned long data_count;
628 unsigned char cmdReg; 628 unsigned char cmdReg;
629 unsigned long offset; 629 unsigned long offset;
630 int temp_tail = port->info->xmit.tail; 630 int temp_tail = port->state->xmit.tail;
631 631
632 trace(ICOM_PORT, "WRITE", 0); 632 trace(ICOM_PORT, "WRITE", 0);
633 633
@@ -638,11 +638,11 @@ static int icom_write(struct uart_port *port)
638 } 638 }
639 639
640 data_count = 0; 640 data_count = 0;
641 while ((port->info->xmit.head != temp_tail) && 641 while ((port->state->xmit.head != temp_tail) &&
642 (data_count <= XMIT_BUFF_SZ)) { 642 (data_count <= XMIT_BUFF_SZ)) {
643 643
644 ICOM_PORT->xmit_buf[data_count++] = 644 ICOM_PORT->xmit_buf[data_count++] =
645 port->info->xmit.buf[temp_tail]; 645 port->state->xmit.buf[temp_tail];
646 646
647 temp_tail++; 647 temp_tail++;
648 temp_tail &= (UART_XMIT_SIZE - 1); 648 temp_tail &= (UART_XMIT_SIZE - 1);
@@ -694,8 +694,8 @@ static inline void check_modem_status(struct icom_port *icom_port)
694 uart_handle_cts_change(&icom_port->uart_port, 694 uart_handle_cts_change(&icom_port->uart_port,
695 delta_status & ICOM_CTS); 695 delta_status & ICOM_CTS);
696 696
697 wake_up_interruptible(&icom_port->uart_port.info-> 697 wake_up_interruptible(&icom_port->uart_port.state->
698 delta_msr_wait); 698 port.delta_msr_wait);
699 old_status = status; 699 old_status = status;
700 } 700 }
701 spin_unlock(&icom_port->uart_port.lock); 701 spin_unlock(&icom_port->uart_port.lock);
@@ -718,10 +718,10 @@ static void xmit_interrupt(u16 port_int_reg, struct icom_port *icom_port)
718 icom_port->uart_port.icount.tx += count; 718 icom_port->uart_port.icount.tx += count;
719 719
720 for (i=0; i<count && 720 for (i=0; i<count &&
721 !uart_circ_empty(&icom_port->uart_port.info->xmit); i++) { 721 !uart_circ_empty(&icom_port->uart_port.state->xmit); i++) {
722 722
723 icom_port->uart_port.info->xmit.tail++; 723 icom_port->uart_port.state->xmit.tail++;
724 icom_port->uart_port.info->xmit.tail &= 724 icom_port->uart_port.state->xmit.tail &=
725 (UART_XMIT_SIZE - 1); 725 (UART_XMIT_SIZE - 1);
726 } 726 }
727 727
@@ -735,7 +735,7 @@ static void xmit_interrupt(u16 port_int_reg, struct icom_port *icom_port)
735static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port) 735static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
736{ 736{
737 short int count, rcv_buff; 737 short int count, rcv_buff;
738 struct tty_struct *tty = icom_port->uart_port.info->port.tty; 738 struct tty_struct *tty = icom_port->uart_port.state->port.tty;
739 unsigned short int status; 739 unsigned short int status;
740 struct uart_icount *icount; 740 struct uart_icount *icount;
741 unsigned long offset; 741 unsigned long offset;
diff --git a/drivers/serial/imx.c b/drivers/serial/imx.c
index 7485afd0df4c..18130f11238e 100644
--- a/drivers/serial/imx.c
+++ b/drivers/serial/imx.c
@@ -224,7 +224,7 @@ static void imx_mctrl_check(struct imx_port *sport)
224 if (changed & TIOCM_CTS) 224 if (changed & TIOCM_CTS)
225 uart_handle_cts_change(&sport->port, status & TIOCM_CTS); 225 uart_handle_cts_change(&sport->port, status & TIOCM_CTS);
226 226
227 wake_up_interruptible(&sport->port.info->delta_msr_wait); 227 wake_up_interruptible(&sport->port.state->port.delta_msr_wait);
228} 228}
229 229
230/* 230/*
@@ -236,7 +236,7 @@ static void imx_timeout(unsigned long data)
236 struct imx_port *sport = (struct imx_port *)data; 236 struct imx_port *sport = (struct imx_port *)data;
237 unsigned long flags; 237 unsigned long flags;
238 238
239 if (sport->port.info) { 239 if (sport->port.state) {
240 spin_lock_irqsave(&sport->port.lock, flags); 240 spin_lock_irqsave(&sport->port.lock, flags);
241 imx_mctrl_check(sport); 241 imx_mctrl_check(sport);
242 spin_unlock_irqrestore(&sport->port.lock, flags); 242 spin_unlock_irqrestore(&sport->port.lock, flags);
@@ -323,7 +323,7 @@ static void imx_enable_ms(struct uart_port *port)
323 323
324static inline void imx_transmit_buffer(struct imx_port *sport) 324static inline void imx_transmit_buffer(struct imx_port *sport)
325{ 325{
326 struct circ_buf *xmit = &sport->port.info->xmit; 326 struct circ_buf *xmit = &sport->port.state->xmit;
327 327
328 while (!(readl(sport->port.membase + UTS) & UTS_TXFULL)) { 328 while (!(readl(sport->port.membase + UTS) & UTS_TXFULL)) {
329 /* send xmit->buf[xmit->tail] 329 /* send xmit->buf[xmit->tail]
@@ -388,7 +388,7 @@ static irqreturn_t imx_rtsint(int irq, void *dev_id)
388 388
389 writel(USR1_RTSD, sport->port.membase + USR1); 389 writel(USR1_RTSD, sport->port.membase + USR1);
390 uart_handle_cts_change(&sport->port, !!val); 390 uart_handle_cts_change(&sport->port, !!val);
391 wake_up_interruptible(&sport->port.info->delta_msr_wait); 391 wake_up_interruptible(&sport->port.state->port.delta_msr_wait);
392 392
393 spin_unlock_irqrestore(&sport->port.lock, flags); 393 spin_unlock_irqrestore(&sport->port.lock, flags);
394 return IRQ_HANDLED; 394 return IRQ_HANDLED;
@@ -397,7 +397,7 @@ static irqreturn_t imx_rtsint(int irq, void *dev_id)
397static irqreturn_t imx_txint(int irq, void *dev_id) 397static irqreturn_t imx_txint(int irq, void *dev_id)
398{ 398{
399 struct imx_port *sport = dev_id; 399 struct imx_port *sport = dev_id;
400 struct circ_buf *xmit = &sport->port.info->xmit; 400 struct circ_buf *xmit = &sport->port.state->xmit;
401 unsigned long flags; 401 unsigned long flags;
402 402
403 spin_lock_irqsave(&sport->port.lock,flags); 403 spin_lock_irqsave(&sport->port.lock,flags);
@@ -427,7 +427,7 @@ static irqreturn_t imx_rxint(int irq, void *dev_id)
427{ 427{
428 struct imx_port *sport = dev_id; 428 struct imx_port *sport = dev_id;
429 unsigned int rx,flg,ignored = 0; 429 unsigned int rx,flg,ignored = 0;
430 struct tty_struct *tty = sport->port.info->port.tty; 430 struct tty_struct *tty = sport->port.state->port.tty;
431 unsigned long flags, temp; 431 unsigned long flags, temp;
432 432
433 spin_lock_irqsave(&sport->port.lock,flags); 433 spin_lock_irqsave(&sport->port.lock,flags);
@@ -900,11 +900,11 @@ imx_set_termios(struct uart_port *port, struct ktermios *termios,
900 rational_best_approximation(16 * div * baud, sport->port.uartclk, 900 rational_best_approximation(16 * div * baud, sport->port.uartclk,
901 1 << 16, 1 << 16, &num, &denom); 901 1 << 16, 1 << 16, &num, &denom);
902 902
903 if (port->info && port->info->port.tty) { 903 if (port->state && port->state->port.tty) {
904 tdiv64 = sport->port.uartclk; 904 tdiv64 = sport->port.uartclk;
905 tdiv64 *= num; 905 tdiv64 *= num;
906 do_div(tdiv64, denom * 16 * div); 906 do_div(tdiv64, denom * 16 * div);
907 tty_encode_baud_rate(sport->port.info->port.tty, 907 tty_encode_baud_rate(sport->port.state->port.tty,
908 (speed_t)tdiv64, (speed_t)tdiv64); 908 (speed_t)tdiv64, (speed_t)tdiv64);
909 } 909 }
910 910
diff --git a/drivers/serial/ioc3_serial.c b/drivers/serial/ioc3_serial.c
index ae3699d77dd0..d8983dd5c4b2 100644
--- a/drivers/serial/ioc3_serial.c
+++ b/drivers/serial/ioc3_serial.c
@@ -897,25 +897,25 @@ static void transmit_chars(struct uart_port *the_port)
897 char *start; 897 char *start;
898 struct tty_struct *tty; 898 struct tty_struct *tty;
899 struct ioc3_port *port = get_ioc3_port(the_port); 899 struct ioc3_port *port = get_ioc3_port(the_port);
900 struct uart_info *info; 900 struct uart_state *state;
901 901
902 if (!the_port) 902 if (!the_port)
903 return; 903 return;
904 if (!port) 904 if (!port)
905 return; 905 return;
906 906
907 info = the_port->info; 907 state = the_port->state;
908 tty = info->port.tty; 908 tty = state->port.tty;
909 909
910 if (uart_circ_empty(&info->xmit) || uart_tx_stopped(the_port)) { 910 if (uart_circ_empty(&state->xmit) || uart_tx_stopped(the_port)) {
911 /* Nothing to do or hw stopped */ 911 /* Nothing to do or hw stopped */
912 set_notification(port, N_ALL_OUTPUT, 0); 912 set_notification(port, N_ALL_OUTPUT, 0);
913 return; 913 return;
914 } 914 }
915 915
916 head = info->xmit.head; 916 head = state->xmit.head;
917 tail = info->xmit.tail; 917 tail = state->xmit.tail;
918 start = (char *)&info->xmit.buf[tail]; 918 start = (char *)&state->xmit.buf[tail];
919 919
920 /* write out all the data or until the end of the buffer */ 920 /* write out all the data or until the end of the buffer */
921 xmit_count = (head < tail) ? (UART_XMIT_SIZE - tail) : (head - tail); 921 xmit_count = (head < tail) ? (UART_XMIT_SIZE - tail) : (head - tail);
@@ -928,14 +928,14 @@ static void transmit_chars(struct uart_port *the_port)
928 /* advance the pointers */ 928 /* advance the pointers */
929 tail += result; 929 tail += result;
930 tail &= UART_XMIT_SIZE - 1; 930 tail &= UART_XMIT_SIZE - 1;
931 info->xmit.tail = tail; 931 state->xmit.tail = tail;
932 start = (char *)&info->xmit.buf[tail]; 932 start = (char *)&state->xmit.buf[tail];
933 } 933 }
934 } 934 }
935 if (uart_circ_chars_pending(&info->xmit) < WAKEUP_CHARS) 935 if (uart_circ_chars_pending(&state->xmit) < WAKEUP_CHARS)
936 uart_write_wakeup(the_port); 936 uart_write_wakeup(the_port);
937 937
938 if (uart_circ_empty(&info->xmit)) { 938 if (uart_circ_empty(&state->xmit)) {
939 set_notification(port, N_OUTPUT_LOWAT, 0); 939 set_notification(port, N_OUTPUT_LOWAT, 0);
940 } else { 940 } else {
941 set_notification(port, N_OUTPUT_LOWAT, 1); 941 set_notification(port, N_OUTPUT_LOWAT, 1);
@@ -956,7 +956,7 @@ ioc3_change_speed(struct uart_port *the_port,
956 unsigned int cflag; 956 unsigned int cflag;
957 int baud; 957 int baud;
958 int new_parity = 0, new_parity_enable = 0, new_stop = 0, new_data = 8; 958 int new_parity = 0, new_parity_enable = 0, new_stop = 0, new_data = 8;
959 struct uart_info *info = the_port->info; 959 struct uart_state *state = the_port->state;
960 960
961 cflag = new_termios->c_cflag; 961 cflag = new_termios->c_cflag;
962 962
@@ -997,14 +997,14 @@ ioc3_change_speed(struct uart_port *the_port,
997 997
998 the_port->ignore_status_mask = N_ALL_INPUT; 998 the_port->ignore_status_mask = N_ALL_INPUT;
999 999
1000 info->port.tty->low_latency = 1; 1000 state->port.tty->low_latency = 1;
1001 1001
1002 if (I_IGNPAR(info->port.tty)) 1002 if (I_IGNPAR(state->port.tty))
1003 the_port->ignore_status_mask &= ~(N_PARITY_ERROR 1003 the_port->ignore_status_mask &= ~(N_PARITY_ERROR
1004 | N_FRAMING_ERROR); 1004 | N_FRAMING_ERROR);
1005 if (I_IGNBRK(info->port.tty)) { 1005 if (I_IGNBRK(state->port.tty)) {
1006 the_port->ignore_status_mask &= ~N_BREAK; 1006 the_port->ignore_status_mask &= ~N_BREAK;
1007 if (I_IGNPAR(info->port.tty)) 1007 if (I_IGNPAR(state->port.tty))
1008 the_port->ignore_status_mask &= ~N_OVERRUN_ERROR; 1008 the_port->ignore_status_mask &= ~N_OVERRUN_ERROR;
1009 } 1009 }
1010 if (!(cflag & CREAD)) { 1010 if (!(cflag & CREAD)) {
@@ -1286,8 +1286,8 @@ static inline int do_read(struct uart_port *the_port, char *buf, int len)
1286 uart_handle_dcd_change 1286 uart_handle_dcd_change
1287 (port->ip_port, 0); 1287 (port->ip_port, 0);
1288 wake_up_interruptible 1288 wake_up_interruptible
1289 (&the_port->info-> 1289 (&the_port->state->
1290 delta_msr_wait); 1290 port.delta_msr_wait);
1291 } 1291 }
1292 1292
1293 /* If we had any data to return, we 1293 /* If we had any data to return, we
@@ -1392,21 +1392,21 @@ static int receive_chars(struct uart_port *the_port)
1392 struct tty_struct *tty; 1392 struct tty_struct *tty;
1393 unsigned char ch[MAX_CHARS]; 1393 unsigned char ch[MAX_CHARS];
1394 int read_count = 0, read_room, flip = 0; 1394 int read_count = 0, read_room, flip = 0;
1395 struct uart_info *info = the_port->info; 1395 struct uart_state *state = the_port->state;
1396 struct ioc3_port *port = get_ioc3_port(the_port); 1396 struct ioc3_port *port = get_ioc3_port(the_port);
1397 unsigned long pflags; 1397 unsigned long pflags;
1398 1398
1399 /* Make sure all the pointers are "good" ones */ 1399 /* Make sure all the pointers are "good" ones */
1400 if (!info) 1400 if (!state)
1401 return 0; 1401 return 0;
1402 if (!info->port.tty) 1402 if (!state->port.tty)
1403 return 0; 1403 return 0;
1404 1404
1405 if (!(port->ip_flags & INPUT_ENABLE)) 1405 if (!(port->ip_flags & INPUT_ENABLE))
1406 return 0; 1406 return 0;
1407 1407
1408 spin_lock_irqsave(&the_port->lock, pflags); 1408 spin_lock_irqsave(&the_port->lock, pflags);
1409 tty = info->port.tty; 1409 tty = state->port.tty;
1410 1410
1411 read_count = do_read(the_port, ch, MAX_CHARS); 1411 read_count = do_read(the_port, ch, MAX_CHARS);
1412 if (read_count > 0) { 1412 if (read_count > 0) {
@@ -1491,7 +1491,7 @@ ioc3uart_intr_one(struct ioc3_submodule *is,
1491 uart_handle_dcd_change(the_port, 1491 uart_handle_dcd_change(the_port,
1492 shadow & SHADOW_DCD); 1492 shadow & SHADOW_DCD);
1493 wake_up_interruptible 1493 wake_up_interruptible
1494 (&the_port->info->delta_msr_wait); 1494 (&the_port->state->port.delta_msr_wait);
1495 } else if ((port->ip_notify & N_DDCD) 1495 } else if ((port->ip_notify & N_DDCD)
1496 && !(shadow & SHADOW_DCD)) { 1496 && !(shadow & SHADOW_DCD)) {
1497 /* Flag delta DCD/no DCD */ 1497 /* Flag delta DCD/no DCD */
@@ -1511,7 +1511,7 @@ ioc3uart_intr_one(struct ioc3_submodule *is,
1511 uart_handle_cts_change(the_port, shadow 1511 uart_handle_cts_change(the_port, shadow
1512 & SHADOW_CTS); 1512 & SHADOW_CTS);
1513 wake_up_interruptible 1513 wake_up_interruptible
1514 (&the_port->info->delta_msr_wait); 1514 (&the_port->state->port.delta_msr_wait);
1515 } 1515 }
1516 } 1516 }
1517 1517
@@ -1721,14 +1721,14 @@ static void ic3_shutdown(struct uart_port *the_port)
1721{ 1721{
1722 unsigned long port_flags; 1722 unsigned long port_flags;
1723 struct ioc3_port *port; 1723 struct ioc3_port *port;
1724 struct uart_info *info; 1724 struct uart_state *state;
1725 1725
1726 port = get_ioc3_port(the_port); 1726 port = get_ioc3_port(the_port);
1727 if (!port) 1727 if (!port)
1728 return; 1728 return;
1729 1729
1730 info = the_port->info; 1730 state = the_port->state;
1731 wake_up_interruptible(&info->delta_msr_wait); 1731 wake_up_interruptible(&state->port.delta_msr_wait);
1732 1732
1733 spin_lock_irqsave(&the_port->lock, port_flags); 1733 spin_lock_irqsave(&the_port->lock, port_flags);
1734 set_notification(port, N_ALL, 0); 1734 set_notification(port, N_ALL, 0);
diff --git a/drivers/serial/ioc4_serial.c b/drivers/serial/ioc4_serial.c
index e5c58fe7e745..2e02c3026d24 100644
--- a/drivers/serial/ioc4_serial.c
+++ b/drivers/serial/ioc4_serial.c
@@ -1627,25 +1627,25 @@ static void transmit_chars(struct uart_port *the_port)
1627 char *start; 1627 char *start;
1628 struct tty_struct *tty; 1628 struct tty_struct *tty;
1629 struct ioc4_port *port = get_ioc4_port(the_port, 0); 1629 struct ioc4_port *port = get_ioc4_port(the_port, 0);
1630 struct uart_info *info; 1630 struct uart_state *state;
1631 1631
1632 if (!the_port) 1632 if (!the_port)
1633 return; 1633 return;
1634 if (!port) 1634 if (!port)
1635 return; 1635 return;
1636 1636
1637 info = the_port->info; 1637 state = the_port->state;
1638 tty = info->port.tty; 1638 tty = state->port.tty;
1639 1639
1640 if (uart_circ_empty(&info->xmit) || uart_tx_stopped(the_port)) { 1640 if (uart_circ_empty(&state->xmit) || uart_tx_stopped(the_port)) {
1641 /* Nothing to do or hw stopped */ 1641 /* Nothing to do or hw stopped */
1642 set_notification(port, N_ALL_OUTPUT, 0); 1642 set_notification(port, N_ALL_OUTPUT, 0);
1643 return; 1643 return;
1644 } 1644 }
1645 1645
1646 head = info->xmit.head; 1646 head = state->xmit.head;
1647 tail = info->xmit.tail; 1647 tail = state->xmit.tail;
1648 start = (char *)&info->xmit.buf[tail]; 1648 start = (char *)&state->xmit.buf[tail];
1649 1649
1650 /* write out all the data or until the end of the buffer */ 1650 /* write out all the data or until the end of the buffer */
1651 xmit_count = (head < tail) ? (UART_XMIT_SIZE - tail) : (head - tail); 1651 xmit_count = (head < tail) ? (UART_XMIT_SIZE - tail) : (head - tail);
@@ -1658,14 +1658,14 @@ static void transmit_chars(struct uart_port *the_port)
1658 /* advance the pointers */ 1658 /* advance the pointers */
1659 tail += result; 1659 tail += result;
1660 tail &= UART_XMIT_SIZE - 1; 1660 tail &= UART_XMIT_SIZE - 1;
1661 info->xmit.tail = tail; 1661 state->xmit.tail = tail;
1662 start = (char *)&info->xmit.buf[tail]; 1662 start = (char *)&state->xmit.buf[tail];
1663 } 1663 }
1664 } 1664 }
1665 if (uart_circ_chars_pending(&info->xmit) < WAKEUP_CHARS) 1665 if (uart_circ_chars_pending(&state->xmit) < WAKEUP_CHARS)
1666 uart_write_wakeup(the_port); 1666 uart_write_wakeup(the_port);
1667 1667
1668 if (uart_circ_empty(&info->xmit)) { 1668 if (uart_circ_empty(&state->xmit)) {
1669 set_notification(port, N_OUTPUT_LOWAT, 0); 1669 set_notification(port, N_OUTPUT_LOWAT, 0);
1670 } else { 1670 } else {
1671 set_notification(port, N_OUTPUT_LOWAT, 1); 1671 set_notification(port, N_OUTPUT_LOWAT, 1);
@@ -1686,7 +1686,7 @@ ioc4_change_speed(struct uart_port *the_port,
1686 int baud, bits; 1686 int baud, bits;
1687 unsigned cflag; 1687 unsigned cflag;
1688 int new_parity = 0, new_parity_enable = 0, new_stop = 0, new_data = 8; 1688 int new_parity = 0, new_parity_enable = 0, new_stop = 0, new_data = 8;
1689 struct uart_info *info = the_port->info; 1689 struct uart_state *state = the_port->state;
1690 1690
1691 cflag = new_termios->c_cflag; 1691 cflag = new_termios->c_cflag;
1692 1692
@@ -1738,14 +1738,14 @@ ioc4_change_speed(struct uart_port *the_port,
1738 1738
1739 the_port->ignore_status_mask = N_ALL_INPUT; 1739 the_port->ignore_status_mask = N_ALL_INPUT;
1740 1740
1741 info->port.tty->low_latency = 1; 1741 state->port.tty->low_latency = 1;
1742 1742
1743 if (I_IGNPAR(info->port.tty)) 1743 if (I_IGNPAR(state->port.tty))
1744 the_port->ignore_status_mask &= ~(N_PARITY_ERROR 1744 the_port->ignore_status_mask &= ~(N_PARITY_ERROR
1745 | N_FRAMING_ERROR); 1745 | N_FRAMING_ERROR);
1746 if (I_IGNBRK(info->port.tty)) { 1746 if (I_IGNBRK(state->port.tty)) {
1747 the_port->ignore_status_mask &= ~N_BREAK; 1747 the_port->ignore_status_mask &= ~N_BREAK;
1748 if (I_IGNPAR(info->port.tty)) 1748 if (I_IGNPAR(state->port.tty))
1749 the_port->ignore_status_mask &= ~N_OVERRUN_ERROR; 1749 the_port->ignore_status_mask &= ~N_OVERRUN_ERROR;
1750 } 1750 }
1751 if (!(cflag & CREAD)) { 1751 if (!(cflag & CREAD)) {
@@ -1784,7 +1784,7 @@ ioc4_change_speed(struct uart_port *the_port,
1784static inline int ic4_startup_local(struct uart_port *the_port) 1784static inline int ic4_startup_local(struct uart_port *the_port)
1785{ 1785{
1786 struct ioc4_port *port; 1786 struct ioc4_port *port;
1787 struct uart_info *info; 1787 struct uart_state *state;
1788 1788
1789 if (!the_port) 1789 if (!the_port)
1790 return -1; 1790 return -1;
@@ -1793,7 +1793,7 @@ static inline int ic4_startup_local(struct uart_port *the_port)
1793 if (!port) 1793 if (!port)
1794 return -1; 1794 return -1;
1795 1795
1796 info = the_port->info; 1796 state = the_port->state;
1797 1797
1798 local_open(port); 1798 local_open(port);
1799 1799
@@ -1801,7 +1801,7 @@ static inline int ic4_startup_local(struct uart_port *the_port)
1801 ioc4_set_proto(port, the_port->mapbase); 1801 ioc4_set_proto(port, the_port->mapbase);
1802 1802
1803 /* set the speed of the serial port */ 1803 /* set the speed of the serial port */
1804 ioc4_change_speed(the_port, info->port.tty->termios, 1804 ioc4_change_speed(the_port, state->port.tty->termios,
1805 (struct ktermios *)0); 1805 (struct ktermios *)0);
1806 1806
1807 return 0; 1807 return 0;
@@ -1882,7 +1882,7 @@ static void handle_intr(void *arg, uint32_t sio_ir)
1882 the_port = port->ip_port; 1882 the_port = port->ip_port;
1883 the_port->icount.dcd = 1; 1883 the_port->icount.dcd = 1;
1884 wake_up_interruptible 1884 wake_up_interruptible
1885 (&the_port-> info->delta_msr_wait); 1885 (&the_port->state->port.delta_msr_wait);
1886 } else if ((port->ip_notify & N_DDCD) 1886 } else if ((port->ip_notify & N_DDCD)
1887 && !(shadow & IOC4_SHADOW_DCD)) { 1887 && !(shadow & IOC4_SHADOW_DCD)) {
1888 /* Flag delta DCD/no DCD */ 1888 /* Flag delta DCD/no DCD */
@@ -1904,7 +1904,7 @@ static void handle_intr(void *arg, uint32_t sio_ir)
1904 the_port->icount.cts = 1904 the_port->icount.cts =
1905 (shadow & IOC4_SHADOW_CTS) ? 1 : 0; 1905 (shadow & IOC4_SHADOW_CTS) ? 1 : 0;
1906 wake_up_interruptible 1906 wake_up_interruptible
1907 (&the_port->info->delta_msr_wait); 1907 (&the_port->state->port.delta_msr_wait);
1908 } 1908 }
1909 } 1909 }
1910 1910
@@ -2236,8 +2236,8 @@ static inline int do_read(struct uart_port *the_port, unsigned char *buf,
2236 && port->ip_port) { 2236 && port->ip_port) {
2237 the_port->icount.dcd = 0; 2237 the_port->icount.dcd = 0;
2238 wake_up_interruptible 2238 wake_up_interruptible
2239 (&the_port->info-> 2239 (&the_port->state->
2240 delta_msr_wait); 2240 port.delta_msr_wait);
2241 } 2241 }
2242 2242
2243 /* If we had any data to return, we 2243 /* If we had any data to return, we
@@ -2341,17 +2341,17 @@ static void receive_chars(struct uart_port *the_port)
2341 unsigned char ch[IOC4_MAX_CHARS]; 2341 unsigned char ch[IOC4_MAX_CHARS];
2342 int read_count, request_count = IOC4_MAX_CHARS; 2342 int read_count, request_count = IOC4_MAX_CHARS;
2343 struct uart_icount *icount; 2343 struct uart_icount *icount;
2344 struct uart_info *info = the_port->info; 2344 struct uart_state *state = the_port->state;
2345 unsigned long pflags; 2345 unsigned long pflags;
2346 2346
2347 /* Make sure all the pointers are "good" ones */ 2347 /* Make sure all the pointers are "good" ones */
2348 if (!info) 2348 if (!state)
2349 return; 2349 return;
2350 if (!info->port.tty) 2350 if (!state->port.tty)
2351 return; 2351 return;
2352 2352
2353 spin_lock_irqsave(&the_port->lock, pflags); 2353 spin_lock_irqsave(&the_port->lock, pflags);
2354 tty = info->port.tty; 2354 tty = state->port.tty;
2355 2355
2356 request_count = tty_buffer_request_room(tty, IOC4_MAX_CHARS); 2356 request_count = tty_buffer_request_room(tty, IOC4_MAX_CHARS);
2357 2357
@@ -2430,19 +2430,19 @@ static void ic4_shutdown(struct uart_port *the_port)
2430{ 2430{
2431 unsigned long port_flags; 2431 unsigned long port_flags;
2432 struct ioc4_port *port; 2432 struct ioc4_port *port;
2433 struct uart_info *info; 2433 struct uart_state *state;
2434 2434
2435 port = get_ioc4_port(the_port, 0); 2435 port = get_ioc4_port(the_port, 0);
2436 if (!port) 2436 if (!port)
2437 return; 2437 return;
2438 2438
2439 info = the_port->info; 2439 state = the_port->state;
2440 port->ip_port = NULL; 2440 port->ip_port = NULL;
2441 2441
2442 wake_up_interruptible(&info->delta_msr_wait); 2442 wake_up_interruptible(&state->port.delta_msr_wait);
2443 2443
2444 if (info->port.tty) 2444 if (state->port.tty)
2445 set_bit(TTY_IO_ERROR, &info->port.tty->flags); 2445 set_bit(TTY_IO_ERROR, &state->port.tty->flags);
2446 2446
2447 spin_lock_irqsave(&the_port->lock, port_flags); 2447 spin_lock_irqsave(&the_port->lock, port_flags);
2448 set_notification(port, N_ALL, 0); 2448 set_notification(port, N_ALL, 0);
@@ -2538,7 +2538,7 @@ static int ic4_startup(struct uart_port *the_port)
2538 int retval; 2538 int retval;
2539 struct ioc4_port *port; 2539 struct ioc4_port *port;
2540 struct ioc4_control *control; 2540 struct ioc4_control *control;
2541 struct uart_info *info; 2541 struct uart_state *state;
2542 unsigned long port_flags; 2542 unsigned long port_flags;
2543 2543
2544 if (!the_port) 2544 if (!the_port)
@@ -2546,7 +2546,7 @@ static int ic4_startup(struct uart_port *the_port)
2546 port = get_ioc4_port(the_port, 1); 2546 port = get_ioc4_port(the_port, 1);
2547 if (!port) 2547 if (!port)
2548 return -ENODEV; 2548 return -ENODEV;
2549 info = the_port->info; 2549 state = the_port->state;
2550 2550
2551 control = port->ip_control; 2551 control = port->ip_control;
2552 if (!control) { 2552 if (!control) {
diff --git a/drivers/serial/ip22zilog.c b/drivers/serial/ip22zilog.c
index 0d9acbd0bb70..ebff4a1d4bcc 100644
--- a/drivers/serial/ip22zilog.c
+++ b/drivers/serial/ip22zilog.c
@@ -256,9 +256,9 @@ static struct tty_struct *ip22zilog_receive_chars(struct uart_ip22zilog_port *up
256 unsigned int r1; 256 unsigned int r1;
257 257
258 tty = NULL; 258 tty = NULL;
259 if (up->port.info != NULL && 259 if (up->port.state != NULL &&
260 up->port.info->port.tty != NULL) 260 up->port.state->port.tty != NULL)
261 tty = up->port.info->port.tty; 261 tty = up->port.state->port.tty;
262 262
263 for (;;) { 263 for (;;) {
264 ch = readb(&channel->control); 264 ch = readb(&channel->control);
@@ -354,7 +354,7 @@ static void ip22zilog_status_handle(struct uart_ip22zilog_port *up,
354 uart_handle_cts_change(&up->port, 354 uart_handle_cts_change(&up->port,
355 (status & CTS)); 355 (status & CTS));
356 356
357 wake_up_interruptible(&up->port.info->delta_msr_wait); 357 wake_up_interruptible(&up->port.state->port.delta_msr_wait);
358 } 358 }
359 359
360 up->prev_status = status; 360 up->prev_status = status;
@@ -404,9 +404,9 @@ static void ip22zilog_transmit_chars(struct uart_ip22zilog_port *up,
404 return; 404 return;
405 } 405 }
406 406
407 if (up->port.info == NULL) 407 if (up->port.state == NULL)
408 goto ack_tx_int; 408 goto ack_tx_int;
409 xmit = &up->port.info->xmit; 409 xmit = &up->port.state->xmit;
410 if (uart_circ_empty(xmit)) 410 if (uart_circ_empty(xmit))
411 goto ack_tx_int; 411 goto ack_tx_int;
412 if (uart_tx_stopped(&up->port)) 412 if (uart_tx_stopped(&up->port))
@@ -607,7 +607,7 @@ static void ip22zilog_start_tx(struct uart_port *port)
607 port->icount.tx++; 607 port->icount.tx++;
608 port->x_char = 0; 608 port->x_char = 0;
609 } else { 609 } else {
610 struct circ_buf *xmit = &port->info->xmit; 610 struct circ_buf *xmit = &port->state->xmit;
611 611
612 writeb(xmit->buf[xmit->tail], &channel->data); 612 writeb(xmit->buf[xmit->tail], &channel->data);
613 ZSDELAY(); 613 ZSDELAY();
diff --git a/drivers/serial/jsm/jsm_neo.c b/drivers/serial/jsm/jsm_neo.c
index 9dadaa11d266..b4b124e4828f 100644
--- a/drivers/serial/jsm/jsm_neo.c
+++ b/drivers/serial/jsm/jsm_neo.c
@@ -989,7 +989,7 @@ static void neo_param(struct jsm_channel *ch)
989 { 50, B50 }, 989 { 50, B50 },
990 }; 990 };
991 991
992 cflag = C_BAUD(ch->uart_port.info->port.tty); 992 cflag = C_BAUD(ch->uart_port.state->port.tty);
993 baud = 9600; 993 baud = 9600;
994 for (i = 0; i < ARRAY_SIZE(baud_rates); i++) { 994 for (i = 0; i < ARRAY_SIZE(baud_rates); i++) {
995 if (baud_rates[i].cflag == cflag) { 995 if (baud_rates[i].cflag == cflag) {
diff --git a/drivers/serial/jsm/jsm_tty.c b/drivers/serial/jsm/jsm_tty.c
index 00f4577d2f7f..7439c0373620 100644
--- a/drivers/serial/jsm/jsm_tty.c
+++ b/drivers/serial/jsm/jsm_tty.c
@@ -147,7 +147,7 @@ static void jsm_tty_send_xchar(struct uart_port *port, char ch)
147 struct ktermios *termios; 147 struct ktermios *termios;
148 148
149 spin_lock_irqsave(&port->lock, lock_flags); 149 spin_lock_irqsave(&port->lock, lock_flags);
150 termios = port->info->port.tty->termios; 150 termios = port->state->port.tty->termios;
151 if (ch == termios->c_cc[VSTART]) 151 if (ch == termios->c_cc[VSTART])
152 channel->ch_bd->bd_ops->send_start_character(channel); 152 channel->ch_bd->bd_ops->send_start_character(channel);
153 153
@@ -245,7 +245,7 @@ static int jsm_tty_open(struct uart_port *port)
245 channel->ch_cached_lsr = 0; 245 channel->ch_cached_lsr = 0;
246 channel->ch_stops_sent = 0; 246 channel->ch_stops_sent = 0;
247 247
248 termios = port->info->port.tty->termios; 248 termios = port->state->port.tty->termios;
249 channel->ch_c_cflag = termios->c_cflag; 249 channel->ch_c_cflag = termios->c_cflag;
250 channel->ch_c_iflag = termios->c_iflag; 250 channel->ch_c_iflag = termios->c_iflag;
251 channel->ch_c_oflag = termios->c_oflag; 251 channel->ch_c_oflag = termios->c_oflag;
@@ -278,7 +278,7 @@ static void jsm_tty_close(struct uart_port *port)
278 jsm_printk(CLOSE, INFO, &channel->ch_bd->pci_dev, "start\n"); 278 jsm_printk(CLOSE, INFO, &channel->ch_bd->pci_dev, "start\n");
279 279
280 bd = channel->ch_bd; 280 bd = channel->ch_bd;
281 ts = port->info->port.tty->termios; 281 ts = port->state->port.tty->termios;
282 282
283 channel->ch_flags &= ~(CH_STOPI); 283 channel->ch_flags &= ~(CH_STOPI);
284 284
@@ -530,7 +530,7 @@ void jsm_input(struct jsm_channel *ch)
530 if (!ch) 530 if (!ch)
531 return; 531 return;
532 532
533 tp = ch->uart_port.info->port.tty; 533 tp = ch->uart_port.state->port.tty;
534 534
535 bd = ch->ch_bd; 535 bd = ch->ch_bd;
536 if(!bd) 536 if(!bd)
@@ -849,7 +849,7 @@ int jsm_tty_write(struct uart_port *port)
849 u16 tail; 849 u16 tail;
850 u16 tmask; 850 u16 tmask;
851 u32 remain; 851 u32 remain;
852 int temp_tail = port->info->xmit.tail; 852 int temp_tail = port->state->xmit.tail;
853 struct jsm_channel *channel = (struct jsm_channel *)port; 853 struct jsm_channel *channel = (struct jsm_channel *)port;
854 854
855 tmask = WQUEUEMASK; 855 tmask = WQUEUEMASK;
@@ -865,10 +865,10 @@ int jsm_tty_write(struct uart_port *port)
865 data_count = 0; 865 data_count = 0;
866 if (bufcount >= remain) { 866 if (bufcount >= remain) {
867 bufcount -= remain; 867 bufcount -= remain;
868 while ((port->info->xmit.head != temp_tail) && 868 while ((port->state->xmit.head != temp_tail) &&
869 (data_count < remain)) { 869 (data_count < remain)) {
870 channel->ch_wqueue[head++] = 870 channel->ch_wqueue[head++] =
871 port->info->xmit.buf[temp_tail]; 871 port->state->xmit.buf[temp_tail];
872 872
873 temp_tail++; 873 temp_tail++;
874 temp_tail &= (UART_XMIT_SIZE - 1); 874 temp_tail &= (UART_XMIT_SIZE - 1);
@@ -880,10 +880,10 @@ int jsm_tty_write(struct uart_port *port)
880 data_count1 = 0; 880 data_count1 = 0;
881 if (bufcount > 0) { 881 if (bufcount > 0) {
882 remain = bufcount; 882 remain = bufcount;
883 while ((port->info->xmit.head != temp_tail) && 883 while ((port->state->xmit.head != temp_tail) &&
884 (data_count1 < remain)) { 884 (data_count1 < remain)) {
885 channel->ch_wqueue[head++] = 885 channel->ch_wqueue[head++] =
886 port->info->xmit.buf[temp_tail]; 886 port->state->xmit.buf[temp_tail];
887 887
888 temp_tail++; 888 temp_tail++;
889 temp_tail &= (UART_XMIT_SIZE - 1); 889 temp_tail &= (UART_XMIT_SIZE - 1);
@@ -892,7 +892,7 @@ int jsm_tty_write(struct uart_port *port)
892 } 892 }
893 } 893 }
894 894
895 port->info->xmit.tail = temp_tail; 895 port->state->xmit.tail = temp_tail;
896 896
897 data_count += data_count1; 897 data_count += data_count1;
898 if (data_count) { 898 if (data_count) {
diff --git a/drivers/serial/m32r_sio.c b/drivers/serial/m32r_sio.c
index 611c97a15654..bea5c215460c 100644
--- a/drivers/serial/m32r_sio.c
+++ b/drivers/serial/m32r_sio.c
@@ -286,7 +286,7 @@ static void m32r_sio_start_tx(struct uart_port *port)
286{ 286{
287#ifdef CONFIG_SERIAL_M32R_PLDSIO 287#ifdef CONFIG_SERIAL_M32R_PLDSIO
288 struct uart_sio_port *up = (struct uart_sio_port *)port; 288 struct uart_sio_port *up = (struct uart_sio_port *)port;
289 struct circ_buf *xmit = &up->port.info->xmit; 289 struct circ_buf *xmit = &up->port.state->xmit;
290 290
291 if (!(up->ier & UART_IER_THRI)) { 291 if (!(up->ier & UART_IER_THRI)) {
292 up->ier |= UART_IER_THRI; 292 up->ier |= UART_IER_THRI;
@@ -325,7 +325,7 @@ static void m32r_sio_enable_ms(struct uart_port *port)
325 325
326static void receive_chars(struct uart_sio_port *up, int *status) 326static void receive_chars(struct uart_sio_port *up, int *status)
327{ 327{
328 struct tty_struct *tty = up->port.info->port.tty; 328 struct tty_struct *tty = up->port.state->port.tty;
329 unsigned char ch; 329 unsigned char ch;
330 unsigned char flag; 330 unsigned char flag;
331 int max_count = 256; 331 int max_count = 256;
@@ -398,7 +398,7 @@ static void receive_chars(struct uart_sio_port *up, int *status)
398 398
399static void transmit_chars(struct uart_sio_port *up) 399static void transmit_chars(struct uart_sio_port *up)
400{ 400{
401 struct circ_buf *xmit = &up->port.info->xmit; 401 struct circ_buf *xmit = &up->port.state->xmit;
402 int count; 402 int count;
403 403
404 if (up->port.x_char) { 404 if (up->port.x_char) {
diff --git a/drivers/serial/max3100.c b/drivers/serial/max3100.c
index 9fd33e5622bd..75ab00631c41 100644
--- a/drivers/serial/max3100.c
+++ b/drivers/serial/max3100.c
@@ -184,7 +184,7 @@ static void max3100_timeout(unsigned long data)
184{ 184{
185 struct max3100_port *s = (struct max3100_port *)data; 185 struct max3100_port *s = (struct max3100_port *)data;
186 186
187 if (s->port.info) { 187 if (s->port.state) {
188 max3100_dowork(s); 188 max3100_dowork(s);
189 mod_timer(&s->timer, jiffies + s->poll_time); 189 mod_timer(&s->timer, jiffies + s->poll_time);
190 } 190 }
@@ -261,7 +261,7 @@ static void max3100_work(struct work_struct *w)
261 int rxchars; 261 int rxchars;
262 u16 tx, rx; 262 u16 tx, rx;
263 int conf, cconf, rts, crts; 263 int conf, cconf, rts, crts;
264 struct circ_buf *xmit = &s->port.info->xmit; 264 struct circ_buf *xmit = &s->port.state->xmit;
265 265
266 dev_dbg(&s->spi->dev, "%s\n", __func__); 266 dev_dbg(&s->spi->dev, "%s\n", __func__);
267 267
@@ -307,8 +307,8 @@ static void max3100_work(struct work_struct *w)
307 } 307 }
308 } 308 }
309 309
310 if (rxchars > 16 && s->port.info->port.tty != NULL) { 310 if (rxchars > 16 && s->port.state->port.tty != NULL) {
311 tty_flip_buffer_push(s->port.info->port.tty); 311 tty_flip_buffer_push(s->port.state->port.tty);
312 rxchars = 0; 312 rxchars = 0;
313 } 313 }
314 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 314 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
@@ -320,8 +320,8 @@ static void max3100_work(struct work_struct *w)
320 (!uart_circ_empty(xmit) && 320 (!uart_circ_empty(xmit) &&
321 !uart_tx_stopped(&s->port)))); 321 !uart_tx_stopped(&s->port))));
322 322
323 if (rxchars > 0 && s->port.info->port.tty != NULL) 323 if (rxchars > 0 && s->port.state->port.tty != NULL)
324 tty_flip_buffer_push(s->port.info->port.tty); 324 tty_flip_buffer_push(s->port.state->port.tty);
325} 325}
326 326
327static irqreturn_t max3100_irq(int irqno, void *dev_id) 327static irqreturn_t max3100_irq(int irqno, void *dev_id)
@@ -429,7 +429,7 @@ max3100_set_termios(struct uart_port *port, struct ktermios *termios,
429 int baud = 0; 429 int baud = 0;
430 unsigned cflag; 430 unsigned cflag;
431 u32 param_new, param_mask, parity = 0; 431 u32 param_new, param_mask, parity = 0;
432 struct tty_struct *tty = s->port.info->port.tty; 432 struct tty_struct *tty = s->port.state->port.tty;
433 433
434 dev_dbg(&s->spi->dev, "%s\n", __func__); 434 dev_dbg(&s->spi->dev, "%s\n", __func__);
435 if (!tty) 435 if (!tty)
@@ -529,7 +529,7 @@ max3100_set_termios(struct uart_port *port, struct ktermios *termios,
529 MAX3100_STATUS_OE; 529 MAX3100_STATUS_OE;
530 530
531 /* we are sending char from a workqueue so enable */ 531 /* we are sending char from a workqueue so enable */
532 s->port.info->port.tty->low_latency = 1; 532 s->port.state->port.tty->low_latency = 1;
533 533
534 if (s->poll_time > 0) 534 if (s->poll_time > 0)
535 del_timer_sync(&s->timer); 535 del_timer_sync(&s->timer);
diff --git a/drivers/serial/mcf.c b/drivers/serial/mcf.c
index 0eefb07bebaf..b44382442bf1 100644
--- a/drivers/serial/mcf.c
+++ b/drivers/serial/mcf.c
@@ -323,7 +323,7 @@ static void mcf_rx_chars(struct mcf_uart *pp)
323 uart_insert_char(port, status, MCFUART_USR_RXOVERRUN, ch, flag); 323 uart_insert_char(port, status, MCFUART_USR_RXOVERRUN, ch, flag);
324 } 324 }
325 325
326 tty_flip_buffer_push(port->info->port.tty); 326 tty_flip_buffer_push(port->state->port.tty);
327} 327}
328 328
329/****************************************************************************/ 329/****************************************************************************/
@@ -331,7 +331,7 @@ static void mcf_rx_chars(struct mcf_uart *pp)
331static void mcf_tx_chars(struct mcf_uart *pp) 331static void mcf_tx_chars(struct mcf_uart *pp)
332{ 332{
333 struct uart_port *port = &pp->port; 333 struct uart_port *port = &pp->port;
334 struct circ_buf *xmit = &port->info->xmit; 334 struct circ_buf *xmit = &port->state->xmit;
335 335
336 if (port->x_char) { 336 if (port->x_char) {
337 /* Send special char - probably flow control */ 337 /* Send special char - probably flow control */
diff --git a/drivers/serial/mpc52xx_uart.c b/drivers/serial/mpc52xx_uart.c
index abbd146c50d9..d7bcd074d383 100644
--- a/drivers/serial/mpc52xx_uart.c
+++ b/drivers/serial/mpc52xx_uart.c
@@ -745,7 +745,7 @@ static struct uart_ops mpc52xx_uart_ops = {
745static inline int 745static inline int
746mpc52xx_uart_int_rx_chars(struct uart_port *port) 746mpc52xx_uart_int_rx_chars(struct uart_port *port)
747{ 747{
748 struct tty_struct *tty = port->info->port.tty; 748 struct tty_struct *tty = port->state->port.tty;
749 unsigned char ch, flag; 749 unsigned char ch, flag;
750 unsigned short status; 750 unsigned short status;
751 751
@@ -812,7 +812,7 @@ mpc52xx_uart_int_rx_chars(struct uart_port *port)
812static inline int 812static inline int
813mpc52xx_uart_int_tx_chars(struct uart_port *port) 813mpc52xx_uart_int_tx_chars(struct uart_port *port)
814{ 814{
815 struct circ_buf *xmit = &port->info->xmit; 815 struct circ_buf *xmit = &port->state->xmit;
816 816
817 /* Process out of band chars */ 817 /* Process out of band chars */
818 if (port->x_char) { 818 if (port->x_char) {
diff --git a/drivers/serial/mpsc.c b/drivers/serial/mpsc.c
index 61d3ade5286c..b5496c28e60b 100644
--- a/drivers/serial/mpsc.c
+++ b/drivers/serial/mpsc.c
@@ -936,7 +936,7 @@ static int serial_polled;
936static int mpsc_rx_intr(struct mpsc_port_info *pi) 936static int mpsc_rx_intr(struct mpsc_port_info *pi)
937{ 937{
938 struct mpsc_rx_desc *rxre; 938 struct mpsc_rx_desc *rxre;
939 struct tty_struct *tty = pi->port.info->port.tty; 939 struct tty_struct *tty = pi->port.state->port.tty;
940 u32 cmdstat, bytes_in, i; 940 u32 cmdstat, bytes_in, i;
941 int rc = 0; 941 int rc = 0;
942 u8 *bp; 942 u8 *bp;
@@ -1109,7 +1109,7 @@ static void mpsc_setup_tx_desc(struct mpsc_port_info *pi, u32 count, u32 intr)
1109 1109
1110static void mpsc_copy_tx_data(struct mpsc_port_info *pi) 1110static void mpsc_copy_tx_data(struct mpsc_port_info *pi)
1111{ 1111{
1112 struct circ_buf *xmit = &pi->port.info->xmit; 1112 struct circ_buf *xmit = &pi->port.state->xmit;
1113 u8 *bp; 1113 u8 *bp;
1114 u32 i; 1114 u32 i;
1115 1115
diff --git a/drivers/serial/msm_serial.c b/drivers/serial/msm_serial.c
index f7c24baa1416..b05c5aa02cb4 100644
--- a/drivers/serial/msm_serial.c
+++ b/drivers/serial/msm_serial.c
@@ -88,7 +88,7 @@ static void msm_enable_ms(struct uart_port *port)
88 88
89static void handle_rx(struct uart_port *port) 89static void handle_rx(struct uart_port *port)
90{ 90{
91 struct tty_struct *tty = port->info->port.tty; 91 struct tty_struct *tty = port->state->port.tty;
92 unsigned int sr; 92 unsigned int sr;
93 93
94 /* 94 /*
@@ -136,7 +136,7 @@ static void handle_rx(struct uart_port *port)
136 136
137static void handle_tx(struct uart_port *port) 137static void handle_tx(struct uart_port *port)
138{ 138{
139 struct circ_buf *xmit = &port->info->xmit; 139 struct circ_buf *xmit = &port->state->xmit;
140 struct msm_port *msm_port = UART_TO_MSM(port); 140 struct msm_port *msm_port = UART_TO_MSM(port);
141 int sent_tx; 141 int sent_tx;
142 142
@@ -169,7 +169,7 @@ static void handle_delta_cts(struct uart_port *port)
169{ 169{
170 msm_write(port, UART_CR_CMD_RESET_CTS, UART_CR); 170 msm_write(port, UART_CR_CMD_RESET_CTS, UART_CR);
171 port->icount.cts++; 171 port->icount.cts++;
172 wake_up_interruptible(&port->info->delta_msr_wait); 172 wake_up_interruptible(&port->state->port.delta_msr_wait);
173} 173}
174 174
175static irqreturn_t msm_irq(int irq, void *dev_id) 175static irqreturn_t msm_irq(int irq, void *dev_id)
diff --git a/drivers/serial/mux.c b/drivers/serial/mux.c
index 953a5ffa9b44..7571aaa138b0 100644
--- a/drivers/serial/mux.c
+++ b/drivers/serial/mux.c
@@ -199,7 +199,7 @@ static void mux_break_ctl(struct uart_port *port, int break_state)
199static void mux_write(struct uart_port *port) 199static void mux_write(struct uart_port *port)
200{ 200{
201 int count; 201 int count;
202 struct circ_buf *xmit = &port->info->xmit; 202 struct circ_buf *xmit = &port->state->xmit;
203 203
204 if(port->x_char) { 204 if(port->x_char) {
205 UART_PUT_CHAR(port, port->x_char); 205 UART_PUT_CHAR(port, port->x_char);
@@ -243,7 +243,7 @@ static void mux_write(struct uart_port *port)
243static void mux_read(struct uart_port *port) 243static void mux_read(struct uart_port *port)
244{ 244{
245 int data; 245 int data;
246 struct tty_struct *tty = port->info->port.tty; 246 struct tty_struct *tty = port->state->port.tty;
247 __u32 start_count = port->icount.rx; 247 __u32 start_count = port->icount.rx;
248 248
249 while(1) { 249 while(1) {
diff --git a/drivers/serial/netx-serial.c b/drivers/serial/netx-serial.c
index 3e5dda8518b7..7735c9f35fa0 100644
--- a/drivers/serial/netx-serial.c
+++ b/drivers/serial/netx-serial.c
@@ -140,7 +140,7 @@ static void netx_enable_ms(struct uart_port *port)
140 140
141static inline void netx_transmit_buffer(struct uart_port *port) 141static inline void netx_transmit_buffer(struct uart_port *port)
142{ 142{
143 struct circ_buf *xmit = &port->info->xmit; 143 struct circ_buf *xmit = &port->state->xmit;
144 144
145 if (port->x_char) { 145 if (port->x_char) {
146 writel(port->x_char, port->membase + UART_DR); 146 writel(port->x_char, port->membase + UART_DR);
@@ -185,7 +185,7 @@ static unsigned int netx_tx_empty(struct uart_port *port)
185 185
186static void netx_txint(struct uart_port *port) 186static void netx_txint(struct uart_port *port)
187{ 187{
188 struct circ_buf *xmit = &port->info->xmit; 188 struct circ_buf *xmit = &port->state->xmit;
189 189
190 if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { 190 if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
191 netx_stop_tx(port); 191 netx_stop_tx(port);
@@ -201,7 +201,7 @@ static void netx_txint(struct uart_port *port)
201static void netx_rxint(struct uart_port *port) 201static void netx_rxint(struct uart_port *port)
202{ 202{
203 unsigned char rx, flg, status; 203 unsigned char rx, flg, status;
204 struct tty_struct *tty = port->info->port.tty; 204 struct tty_struct *tty = port->state->port.tty;
205 205
206 while (!(readl(port->membase + UART_FR) & FR_RXFE)) { 206 while (!(readl(port->membase + UART_FR) & FR_RXFE)) {
207 rx = readl(port->membase + UART_DR); 207 rx = readl(port->membase + UART_DR);
diff --git a/drivers/serial/nwpserial.c b/drivers/serial/nwpserial.c
index 9e150b19d726..e1ab8ec0a4a6 100644
--- a/drivers/serial/nwpserial.c
+++ b/drivers/serial/nwpserial.c
@@ -126,7 +126,7 @@ static void nwpserial_config_port(struct uart_port *port, int flags)
126static irqreturn_t nwpserial_interrupt(int irq, void *dev_id) 126static irqreturn_t nwpserial_interrupt(int irq, void *dev_id)
127{ 127{
128 struct nwpserial_port *up = dev_id; 128 struct nwpserial_port *up = dev_id;
129 struct tty_struct *tty = up->port.info->port.tty; 129 struct tty_struct *tty = up->port.state->port.tty;
130 irqreturn_t ret; 130 irqreturn_t ret;
131 unsigned int iir; 131 unsigned int iir;
132 unsigned char ch; 132 unsigned char ch;
@@ -261,7 +261,7 @@ static void nwpserial_start_tx(struct uart_port *port)
261 struct nwpserial_port *up; 261 struct nwpserial_port *up;
262 struct circ_buf *xmit; 262 struct circ_buf *xmit;
263 up = container_of(port, struct nwpserial_port, port); 263 up = container_of(port, struct nwpserial_port, port);
264 xmit = &up->port.info->xmit; 264 xmit = &up->port.state->xmit;
265 265
266 if (port->x_char) { 266 if (port->x_char) {
267 nwpserial_putchar(up, up->port.x_char); 267 nwpserial_putchar(up, up->port.x_char);
diff --git a/drivers/serial/pmac_zilog.c b/drivers/serial/pmac_zilog.c
index 9c1243fbd512..0700cd10b97c 100644
--- a/drivers/serial/pmac_zilog.c
+++ b/drivers/serial/pmac_zilog.c
@@ -242,12 +242,12 @@ static struct tty_struct *pmz_receive_chars(struct uart_pmac_port *uap)
242 } 242 }
243 243
244 /* Sanity check, make sure the old bug is no longer happening */ 244 /* Sanity check, make sure the old bug is no longer happening */
245 if (uap->port.info == NULL || uap->port.info->port.tty == NULL) { 245 if (uap->port.state == NULL || uap->port.state->port.tty == NULL) {
246 WARN_ON(1); 246 WARN_ON(1);
247 (void)read_zsdata(uap); 247 (void)read_zsdata(uap);
248 return NULL; 248 return NULL;
249 } 249 }
250 tty = uap->port.info->port.tty; 250 tty = uap->port.state->port.tty;
251 251
252 while (1) { 252 while (1) {
253 error = 0; 253 error = 0;
@@ -369,7 +369,7 @@ static void pmz_status_handle(struct uart_pmac_port *uap)
369 uart_handle_cts_change(&uap->port, 369 uart_handle_cts_change(&uap->port,
370 !(status & CTS)); 370 !(status & CTS));
371 371
372 wake_up_interruptible(&uap->port.info->delta_msr_wait); 372 wake_up_interruptible(&uap->port.state->port.delta_msr_wait);
373 } 373 }
374 374
375 if (status & BRK_ABRT) 375 if (status & BRK_ABRT)
@@ -420,9 +420,9 @@ static void pmz_transmit_chars(struct uart_pmac_port *uap)
420 return; 420 return;
421 } 421 }
422 422
423 if (uap->port.info == NULL) 423 if (uap->port.state == NULL)
424 goto ack_tx_int; 424 goto ack_tx_int;
425 xmit = &uap->port.info->xmit; 425 xmit = &uap->port.state->xmit;
426 if (uart_circ_empty(xmit)) { 426 if (uart_circ_empty(xmit)) {
427 uart_write_wakeup(&uap->port); 427 uart_write_wakeup(&uap->port);
428 goto ack_tx_int; 428 goto ack_tx_int;
@@ -655,7 +655,7 @@ static void pmz_start_tx(struct uart_port *port)
655 port->icount.tx++; 655 port->icount.tx++;
656 port->x_char = 0; 656 port->x_char = 0;
657 } else { 657 } else {
658 struct circ_buf *xmit = &port->info->xmit; 658 struct circ_buf *xmit = &port->state->xmit;
659 659
660 write_zsdata(uap, xmit->buf[xmit->tail]); 660 write_zsdata(uap, xmit->buf[xmit->tail]);
661 zssync(uap); 661 zssync(uap);
@@ -1645,7 +1645,7 @@ static int pmz_suspend(struct macio_dev *mdev, pm_message_t pm_state)
1645 state = pmz_uart_reg.state + uap->port.line; 1645 state = pmz_uart_reg.state + uap->port.line;
1646 1646
1647 mutex_lock(&pmz_irq_mutex); 1647 mutex_lock(&pmz_irq_mutex);
1648 mutex_lock(&state->mutex); 1648 mutex_lock(&state->port.mutex);
1649 1649
1650 spin_lock_irqsave(&uap->port.lock, flags); 1650 spin_lock_irqsave(&uap->port.lock, flags);
1651 1651
@@ -1676,7 +1676,7 @@ static int pmz_suspend(struct macio_dev *mdev, pm_message_t pm_state)
1676 /* Shut the chip down */ 1676 /* Shut the chip down */
1677 pmz_set_scc_power(uap, 0); 1677 pmz_set_scc_power(uap, 0);
1678 1678
1679 mutex_unlock(&state->mutex); 1679 mutex_unlock(&state->port.mutex);
1680 mutex_unlock(&pmz_irq_mutex); 1680 mutex_unlock(&pmz_irq_mutex);
1681 1681
1682 pmz_debug("suspend, switching complete\n"); 1682 pmz_debug("suspend, switching complete\n");
@@ -1705,7 +1705,7 @@ static int pmz_resume(struct macio_dev *mdev)
1705 state = pmz_uart_reg.state + uap->port.line; 1705 state = pmz_uart_reg.state + uap->port.line;
1706 1706
1707 mutex_lock(&pmz_irq_mutex); 1707 mutex_lock(&pmz_irq_mutex);
1708 mutex_lock(&state->mutex); 1708 mutex_lock(&state->port.mutex);
1709 1709
1710 spin_lock_irqsave(&uap->port.lock, flags); 1710 spin_lock_irqsave(&uap->port.lock, flags);
1711 if (!ZS_IS_OPEN(uap) && !ZS_IS_CONS(uap)) { 1711 if (!ZS_IS_OPEN(uap) && !ZS_IS_CONS(uap)) {
@@ -1737,7 +1737,7 @@ static int pmz_resume(struct macio_dev *mdev)
1737 } 1737 }
1738 1738
1739 bail: 1739 bail:
1740 mutex_unlock(&state->mutex); 1740 mutex_unlock(&state->port.mutex);
1741 mutex_unlock(&pmz_irq_mutex); 1741 mutex_unlock(&pmz_irq_mutex);
1742 1742
1743 /* Right now, we deal with delay by blocking here, I'll be 1743 /* Right now, we deal with delay by blocking here, I'll be
diff --git a/drivers/serial/pnx8xxx_uart.c b/drivers/serial/pnx8xxx_uart.c
index 1bb8f1b45767..0aa75a97531c 100644
--- a/drivers/serial/pnx8xxx_uart.c
+++ b/drivers/serial/pnx8xxx_uart.c
@@ -100,7 +100,7 @@ static void pnx8xxx_mctrl_check(struct pnx8xxx_port *sport)
100 if (changed & TIOCM_CTS) 100 if (changed & TIOCM_CTS)
101 uart_handle_cts_change(&sport->port, status & TIOCM_CTS); 101 uart_handle_cts_change(&sport->port, status & TIOCM_CTS);
102 102
103 wake_up_interruptible(&sport->port.info->delta_msr_wait); 103 wake_up_interruptible(&sport->port.state->port.delta_msr_wait);
104} 104}
105 105
106/* 106/*
@@ -112,7 +112,7 @@ static void pnx8xxx_timeout(unsigned long data)
112 struct pnx8xxx_port *sport = (struct pnx8xxx_port *)data; 112 struct pnx8xxx_port *sport = (struct pnx8xxx_port *)data;
113 unsigned long flags; 113 unsigned long flags;
114 114
115 if (sport->port.info) { 115 if (sport->port.state) {
116 spin_lock_irqsave(&sport->port.lock, flags); 116 spin_lock_irqsave(&sport->port.lock, flags);
117 pnx8xxx_mctrl_check(sport); 117 pnx8xxx_mctrl_check(sport);
118 spin_unlock_irqrestore(&sport->port.lock, flags); 118 spin_unlock_irqrestore(&sport->port.lock, flags);
@@ -181,7 +181,7 @@ static void pnx8xxx_enable_ms(struct uart_port *port)
181 181
182static void pnx8xxx_rx_chars(struct pnx8xxx_port *sport) 182static void pnx8xxx_rx_chars(struct pnx8xxx_port *sport)
183{ 183{
184 struct tty_struct *tty = sport->port.info->port.tty; 184 struct tty_struct *tty = sport->port.state->port.tty;
185 unsigned int status, ch, flg; 185 unsigned int status, ch, flg;
186 186
187 status = FIFO_TO_SM(serial_in(sport, PNX8XXX_FIFO)) | 187 status = FIFO_TO_SM(serial_in(sport, PNX8XXX_FIFO)) |
@@ -243,7 +243,7 @@ static void pnx8xxx_rx_chars(struct pnx8xxx_port *sport)
243 243
244static void pnx8xxx_tx_chars(struct pnx8xxx_port *sport) 244static void pnx8xxx_tx_chars(struct pnx8xxx_port *sport)
245{ 245{
246 struct circ_buf *xmit = &sport->port.info->xmit; 246 struct circ_buf *xmit = &sport->port.state->xmit;
247 247
248 if (sport->port.x_char) { 248 if (sport->port.x_char) {
249 serial_out(sport, PNX8XXX_FIFO, sport->port.x_char); 249 serial_out(sport, PNX8XXX_FIFO, sport->port.x_char);
diff --git a/drivers/serial/pxa.c b/drivers/serial/pxa.c
index a48a8a13d87b..6443b7ff274a 100644
--- a/drivers/serial/pxa.c
+++ b/drivers/serial/pxa.c
@@ -96,7 +96,7 @@ static void serial_pxa_stop_rx(struct uart_port *port)
96 96
97static inline void receive_chars(struct uart_pxa_port *up, int *status) 97static inline void receive_chars(struct uart_pxa_port *up, int *status)
98{ 98{
99 struct tty_struct *tty = up->port.info->port.tty; 99 struct tty_struct *tty = up->port.state->port.tty;
100 unsigned int ch, flag; 100 unsigned int ch, flag;
101 int max_count = 256; 101 int max_count = 256;
102 102
@@ -161,7 +161,7 @@ static inline void receive_chars(struct uart_pxa_port *up, int *status)
161 161
162static void transmit_chars(struct uart_pxa_port *up) 162static void transmit_chars(struct uart_pxa_port *up)
163{ 163{
164 struct circ_buf *xmit = &up->port.info->xmit; 164 struct circ_buf *xmit = &up->port.state->xmit;
165 int count; 165 int count;
166 166
167 if (up->port.x_char) { 167 if (up->port.x_char) {
@@ -220,7 +220,7 @@ static inline void check_modem_status(struct uart_pxa_port *up)
220 if (status & UART_MSR_DCTS) 220 if (status & UART_MSR_DCTS)
221 uart_handle_cts_change(&up->port, status & UART_MSR_CTS); 221 uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
222 222
223 wake_up_interruptible(&up->port.info->delta_msr_wait); 223 wake_up_interruptible(&up->port.state->port.delta_msr_wait);
224} 224}
225 225
226/* 226/*
diff --git a/drivers/serial/sa1100.c b/drivers/serial/sa1100.c
index 94530f01521e..7f5e26873220 100644
--- a/drivers/serial/sa1100.c
+++ b/drivers/serial/sa1100.c
@@ -117,7 +117,7 @@ static void sa1100_mctrl_check(struct sa1100_port *sport)
117 if (changed & TIOCM_CTS) 117 if (changed & TIOCM_CTS)
118 uart_handle_cts_change(&sport->port, status & TIOCM_CTS); 118 uart_handle_cts_change(&sport->port, status & TIOCM_CTS);
119 119
120 wake_up_interruptible(&sport->port.info->delta_msr_wait); 120 wake_up_interruptible(&sport->port.state->port.delta_msr_wait);
121} 121}
122 122
123/* 123/*
@@ -129,7 +129,7 @@ static void sa1100_timeout(unsigned long data)
129 struct sa1100_port *sport = (struct sa1100_port *)data; 129 struct sa1100_port *sport = (struct sa1100_port *)data;
130 unsigned long flags; 130 unsigned long flags;
131 131
132 if (sport->port.info) { 132 if (sport->port.state) {
133 spin_lock_irqsave(&sport->port.lock, flags); 133 spin_lock_irqsave(&sport->port.lock, flags);
134 sa1100_mctrl_check(sport); 134 sa1100_mctrl_check(sport);
135 spin_unlock_irqrestore(&sport->port.lock, flags); 135 spin_unlock_irqrestore(&sport->port.lock, flags);
@@ -189,7 +189,7 @@ static void sa1100_enable_ms(struct uart_port *port)
189static void 189static void
190sa1100_rx_chars(struct sa1100_port *sport) 190sa1100_rx_chars(struct sa1100_port *sport)
191{ 191{
192 struct tty_struct *tty = sport->port.info->port.tty; 192 struct tty_struct *tty = sport->port.state->port.tty;
193 unsigned int status, ch, flg; 193 unsigned int status, ch, flg;
194 194
195 status = UTSR1_TO_SM(UART_GET_UTSR1(sport)) | 195 status = UTSR1_TO_SM(UART_GET_UTSR1(sport)) |
@@ -239,7 +239,7 @@ sa1100_rx_chars(struct sa1100_port *sport)
239 239
240static void sa1100_tx_chars(struct sa1100_port *sport) 240static void sa1100_tx_chars(struct sa1100_port *sport)
241{ 241{
242 struct circ_buf *xmit = &sport->port.info->xmit; 242 struct circ_buf *xmit = &sport->port.state->xmit;
243 243
244 if (sport->port.x_char) { 244 if (sport->port.x_char) {
245 UART_PUT_CHAR(sport, sport->port.x_char); 245 UART_PUT_CHAR(sport, sport->port.x_char);
diff --git a/drivers/serial/samsung.c b/drivers/serial/samsung.c
index c8851a0db63a..1523e8d9ae77 100644
--- a/drivers/serial/samsung.c
+++ b/drivers/serial/samsung.c
@@ -196,7 +196,7 @@ s3c24xx_serial_rx_chars(int irq, void *dev_id)
196{ 196{
197 struct s3c24xx_uart_port *ourport = dev_id; 197 struct s3c24xx_uart_port *ourport = dev_id;
198 struct uart_port *port = &ourport->port; 198 struct uart_port *port = &ourport->port;
199 struct tty_struct *tty = port->info->port.tty; 199 struct tty_struct *tty = port->state->port.tty;
200 unsigned int ufcon, ch, flag, ufstat, uerstat; 200 unsigned int ufcon, ch, flag, ufstat, uerstat;
201 int max_count = 64; 201 int max_count = 64;
202 202
@@ -281,7 +281,7 @@ static irqreturn_t s3c24xx_serial_tx_chars(int irq, void *id)
281{ 281{
282 struct s3c24xx_uart_port *ourport = id; 282 struct s3c24xx_uart_port *ourport = id;
283 struct uart_port *port = &ourport->port; 283 struct uart_port *port = &ourport->port;
284 struct circ_buf *xmit = &port->info->xmit; 284 struct circ_buf *xmit = &port->state->xmit;
285 int count = 256; 285 int count = 256;
286 286
287 if (port->x_char) { 287 if (port->x_char) {
@@ -992,10 +992,10 @@ static int s3c24xx_serial_cpufreq_transition(struct notifier_block *nb,
992 struct ktermios *termios; 992 struct ktermios *termios;
993 struct tty_struct *tty; 993 struct tty_struct *tty;
994 994
995 if (uport->info == NULL) 995 if (uport->state == NULL)
996 goto exit; 996 goto exit;
997 997
998 tty = uport->info->port.tty; 998 tty = uport->state->port.tty;
999 999
1000 if (tty == NULL) 1000 if (tty == NULL)
1001 goto exit; 1001 goto exit;
diff --git a/drivers/serial/sb1250-duart.c b/drivers/serial/sb1250-duart.c
index 319e8b83f6be..a2f2b3254499 100644
--- a/drivers/serial/sb1250-duart.c
+++ b/drivers/serial/sb1250-duart.c
@@ -384,13 +384,13 @@ static void sbd_receive_chars(struct sbd_port *sport)
384 uart_insert_char(uport, status, M_DUART_OVRUN_ERR, ch, flag); 384 uart_insert_char(uport, status, M_DUART_OVRUN_ERR, ch, flag);
385 } 385 }
386 386
387 tty_flip_buffer_push(uport->info->port.tty); 387 tty_flip_buffer_push(uport->state->port.tty);
388} 388}
389 389
390static void sbd_transmit_chars(struct sbd_port *sport) 390static void sbd_transmit_chars(struct sbd_port *sport)
391{ 391{
392 struct uart_port *uport = &sport->port; 392 struct uart_port *uport = &sport->port;
393 struct circ_buf *xmit = &sport->port.info->xmit; 393 struct circ_buf *xmit = &sport->port.state->xmit;
394 unsigned int mask; 394 unsigned int mask;
395 int stop_tx; 395 int stop_tx;
396 396
@@ -440,7 +440,7 @@ static void sbd_status_handle(struct sbd_port *sport)
440 440
441 if (delta & ((M_DUART_IN_PIN2_VAL | M_DUART_IN_PIN0_VAL) << 441 if (delta & ((M_DUART_IN_PIN2_VAL | M_DUART_IN_PIN0_VAL) <<
442 S_DUART_IN_PIN_CHNG)) 442 S_DUART_IN_PIN_CHNG))
443 wake_up_interruptible(&uport->info->delta_msr_wait); 443 wake_up_interruptible(&uport->state->port.delta_msr_wait);
444} 444}
445 445
446static irqreturn_t sbd_interrupt(int irq, void *dev_id) 446static irqreturn_t sbd_interrupt(int irq, void *dev_id)
diff --git a/drivers/serial/sc26xx.c b/drivers/serial/sc26xx.c
index e0be11ceaa25..75038ad2b242 100644
--- a/drivers/serial/sc26xx.c
+++ b/drivers/serial/sc26xx.c
@@ -140,8 +140,8 @@ static struct tty_struct *receive_chars(struct uart_port *port)
140 char flag; 140 char flag;
141 u8 status; 141 u8 status;
142 142
143 if (port->info != NULL) /* Unopened serial console */ 143 if (port->state != NULL) /* Unopened serial console */
144 tty = port->info->port.tty; 144 tty = port->state->port.tty;
145 145
146 while (limit-- > 0) { 146 while (limit-- > 0) {
147 status = READ_SC_PORT(port, SR); 147 status = READ_SC_PORT(port, SR);
@@ -190,10 +190,10 @@ static void transmit_chars(struct uart_port *port)
190{ 190{
191 struct circ_buf *xmit; 191 struct circ_buf *xmit;
192 192
193 if (!port->info) 193 if (!port->state)
194 return; 194 return;
195 195
196 xmit = &port->info->xmit; 196 xmit = &port->state->xmit;
197 if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { 197 if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
198 sc26xx_disable_irq(port, IMR_TXRDY); 198 sc26xx_disable_irq(port, IMR_TXRDY);
199 return; 199 return;
@@ -316,7 +316,7 @@ static void sc26xx_stop_tx(struct uart_port *port)
316/* port->lock held by caller. */ 316/* port->lock held by caller. */
317static void sc26xx_start_tx(struct uart_port *port) 317static void sc26xx_start_tx(struct uart_port *port)
318{ 318{
319 struct circ_buf *xmit = &port->info->xmit; 319 struct circ_buf *xmit = &port->state->xmit;
320 320
321 while (!uart_circ_empty(xmit)) { 321 while (!uart_circ_empty(xmit)) {
322 if (!(READ_SC_PORT(port, SR) & SR_TXRDY)) { 322 if (!(READ_SC_PORT(port, SR) & SR_TXRDY)) {
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index b0bb29d804ae..2514d00c0f6f 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -29,10 +29,10 @@
29#include <linux/console.h> 29#include <linux/console.h>
30#include <linux/proc_fs.h> 30#include <linux/proc_fs.h>
31#include <linux/seq_file.h> 31#include <linux/seq_file.h>
32#include <linux/serial_core.h>
33#include <linux/smp_lock.h> 32#include <linux/smp_lock.h>
34#include <linux/device.h> 33#include <linux/device.h>
35#include <linux/serial.h> /* for serial_state and serial_icounter_struct */ 34#include <linux/serial.h> /* for serial_state and serial_icounter_struct */
35#include <linux/serial_core.h>
36#include <linux/delay.h> 36#include <linux/delay.h>
37#include <linux/mutex.h> 37#include <linux/mutex.h>
38 38
@@ -52,8 +52,6 @@ static struct lock_class_key port_lock_key;
52 52
53#define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8) 53#define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8)
54 54
55#define uart_users(state) ((state)->count + (state)->info.port.blocked_open)
56
57#ifdef CONFIG_SERIAL_CORE_CONSOLE 55#ifdef CONFIG_SERIAL_CORE_CONSOLE
58#define uart_console(port) ((port)->cons && (port)->cons->index == (port)->line) 56#define uart_console(port) ((port)->cons && (port)->cons->index == (port)->line)
59#else 57#else
@@ -71,19 +69,19 @@ static void uart_change_pm(struct uart_state *state, int pm_state);
71 */ 69 */
72void uart_write_wakeup(struct uart_port *port) 70void uart_write_wakeup(struct uart_port *port)
73{ 71{
74 struct uart_info *info = port->info; 72 struct uart_state *state = port->state;
75 /* 73 /*
76 * This means you called this function _after_ the port was 74 * This means you called this function _after_ the port was
77 * closed. No cookie for you. 75 * closed. No cookie for you.
78 */ 76 */
79 BUG_ON(!info); 77 BUG_ON(!state);
80 tasklet_schedule(&info->tlet); 78 tasklet_schedule(&state->tlet);
81} 79}
82 80
83static void uart_stop(struct tty_struct *tty) 81static void uart_stop(struct tty_struct *tty)
84{ 82{
85 struct uart_state *state = tty->driver_data; 83 struct uart_state *state = tty->driver_data;
86 struct uart_port *port = state->port; 84 struct uart_port *port = state->uart_port;
87 unsigned long flags; 85 unsigned long flags;
88 86
89 spin_lock_irqsave(&port->lock, flags); 87 spin_lock_irqsave(&port->lock, flags);
@@ -94,9 +92,9 @@ static void uart_stop(struct tty_struct *tty)
94static void __uart_start(struct tty_struct *tty) 92static void __uart_start(struct tty_struct *tty)
95{ 93{
96 struct uart_state *state = tty->driver_data; 94 struct uart_state *state = tty->driver_data;
97 struct uart_port *port = state->port; 95 struct uart_port *port = state->uart_port;
98 96
99 if (!uart_circ_empty(&state->info.xmit) && state->info.xmit.buf && 97 if (!uart_circ_empty(&state->xmit) && state->xmit.buf &&
100 !tty->stopped && !tty->hw_stopped) 98 !tty->stopped && !tty->hw_stopped)
101 port->ops->start_tx(port); 99 port->ops->start_tx(port);
102} 100}
@@ -104,7 +102,7 @@ static void __uart_start(struct tty_struct *tty)
104static void uart_start(struct tty_struct *tty) 102static void uart_start(struct tty_struct *tty)
105{ 103{
106 struct uart_state *state = tty->driver_data; 104 struct uart_state *state = tty->driver_data;
107 struct uart_port *port = state->port; 105 struct uart_port *port = state->uart_port;
108 unsigned long flags; 106 unsigned long flags;
109 107
110 spin_lock_irqsave(&port->lock, flags); 108 spin_lock_irqsave(&port->lock, flags);
@@ -115,7 +113,7 @@ static void uart_start(struct tty_struct *tty)
115static void uart_tasklet_action(unsigned long data) 113static void uart_tasklet_action(unsigned long data)
116{ 114{
117 struct uart_state *state = (struct uart_state *)data; 115 struct uart_state *state = (struct uart_state *)data;
118 tty_wakeup(state->info.port.tty); 116 tty_wakeup(state->port.tty);
119} 117}
120 118
121static inline void 119static inline void
@@ -141,12 +139,12 @@ uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)
141 */ 139 */
142static int uart_startup(struct uart_state *state, int init_hw) 140static int uart_startup(struct uart_state *state, int init_hw)
143{ 141{
144 struct uart_info *info = &state->info; 142 struct uart_port *uport = state->uart_port;
145 struct uart_port *port = state->port; 143 struct tty_port *port = &state->port;
146 unsigned long page; 144 unsigned long page;
147 int retval = 0; 145 int retval = 0;
148 146
149 if (info->flags & UIF_INITIALIZED) 147 if (port->flags & ASYNC_INITIALIZED)
150 return 0; 148 return 0;
151 149
152 /* 150 /*
@@ -154,26 +152,26 @@ static int uart_startup(struct uart_state *state, int init_hw)
154 * once we have successfully opened the port. Also set 152 * once we have successfully opened the port. Also set
155 * up the tty->alt_speed kludge 153 * up the tty->alt_speed kludge
156 */ 154 */
157 set_bit(TTY_IO_ERROR, &info->port.tty->flags); 155 set_bit(TTY_IO_ERROR, &port->tty->flags);
158 156
159 if (port->type == PORT_UNKNOWN) 157 if (uport->type == PORT_UNKNOWN)
160 return 0; 158 return 0;
161 159
162 /* 160 /*
163 * Initialise and allocate the transmit and temporary 161 * Initialise and allocate the transmit and temporary
164 * buffer. 162 * buffer.
165 */ 163 */
166 if (!info->xmit.buf) { 164 if (!state->xmit.buf) {
167 /* This is protected by the per port mutex */ 165 /* This is protected by the per port mutex */
168 page = get_zeroed_page(GFP_KERNEL); 166 page = get_zeroed_page(GFP_KERNEL);
169 if (!page) 167 if (!page)
170 return -ENOMEM; 168 return -ENOMEM;
171 169
172 info->xmit.buf = (unsigned char *) page; 170 state->xmit.buf = (unsigned char *) page;
173 uart_circ_clear(&info->xmit); 171 uart_circ_clear(&state->xmit);
174 } 172 }
175 173
176 retval = port->ops->startup(port); 174 retval = uport->ops->startup(uport);
177 if (retval == 0) { 175 if (retval == 0) {
178 if (init_hw) { 176 if (init_hw) {
179 /* 177 /*
@@ -185,20 +183,20 @@ static int uart_startup(struct uart_state *state, int init_hw)
185 * Setup the RTS and DTR signals once the 183 * Setup the RTS and DTR signals once the
186 * port is open and ready to respond. 184 * port is open and ready to respond.
187 */ 185 */
188 if (info->port.tty->termios->c_cflag & CBAUD) 186 if (port->tty->termios->c_cflag & CBAUD)
189 uart_set_mctrl(port, TIOCM_RTS | TIOCM_DTR); 187 uart_set_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
190 } 188 }
191 189
192 if (info->flags & UIF_CTS_FLOW) { 190 if (port->flags & ASYNC_CTS_FLOW) {
193 spin_lock_irq(&port->lock); 191 spin_lock_irq(&uport->lock);
194 if (!(port->ops->get_mctrl(port) & TIOCM_CTS)) 192 if (!(uport->ops->get_mctrl(uport) & TIOCM_CTS))
195 info->port.tty->hw_stopped = 1; 193 port->tty->hw_stopped = 1;
196 spin_unlock_irq(&port->lock); 194 spin_unlock_irq(&uport->lock);
197 } 195 }
198 196
199 info->flags |= UIF_INITIALIZED; 197 set_bit(ASYNCB_INITIALIZED, &port->flags);
200 198
201 clear_bit(TTY_IO_ERROR, &info->port.tty->flags); 199 clear_bit(TTY_IO_ERROR, &port->tty->flags);
202 } 200 }
203 201
204 if (retval && capable(CAP_SYS_ADMIN)) 202 if (retval && capable(CAP_SYS_ADMIN))
@@ -214,9 +212,9 @@ static int uart_startup(struct uart_state *state, int init_hw)
214 */ 212 */
215static void uart_shutdown(struct uart_state *state) 213static void uart_shutdown(struct uart_state *state)
216{ 214{
217 struct uart_info *info = &state->info; 215 struct uart_port *uport = state->uart_port;
218 struct uart_port *port = state->port; 216 struct tty_port *port = &state->port;
219 struct tty_struct *tty = info->port.tty; 217 struct tty_struct *tty = port->tty;
220 218
221 /* 219 /*
222 * Set the TTY IO error marker 220 * Set the TTY IO error marker
@@ -224,14 +222,12 @@ static void uart_shutdown(struct uart_state *state)
224 if (tty) 222 if (tty)
225 set_bit(TTY_IO_ERROR, &tty->flags); 223 set_bit(TTY_IO_ERROR, &tty->flags);
226 224
227 if (info->flags & UIF_INITIALIZED) { 225 if (test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags)) {
228 info->flags &= ~UIF_INITIALIZED;
229
230 /* 226 /*
231 * Turn off DTR and RTS early. 227 * Turn off DTR and RTS early.
232 */ 228 */
233 if (!tty || (tty->termios->c_cflag & HUPCL)) 229 if (!tty || (tty->termios->c_cflag & HUPCL))
234 uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS); 230 uart_clear_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
235 231
236 /* 232 /*
237 * clear delta_msr_wait queue to avoid mem leaks: we may free 233 * clear delta_msr_wait queue to avoid mem leaks: we may free
@@ -240,30 +236,30 @@ static void uart_shutdown(struct uart_state *state)
240 * any outstanding file descriptors should be pointing at 236 * any outstanding file descriptors should be pointing at
241 * hung_up_tty_fops now. 237 * hung_up_tty_fops now.
242 */ 238 */
243 wake_up_interruptible(&info->delta_msr_wait); 239 wake_up_interruptible(&port->delta_msr_wait);
244 240
245 /* 241 /*
246 * Free the IRQ and disable the port. 242 * Free the IRQ and disable the port.
247 */ 243 */
248 port->ops->shutdown(port); 244 uport->ops->shutdown(uport);
249 245
250 /* 246 /*
251 * Ensure that the IRQ handler isn't running on another CPU. 247 * Ensure that the IRQ handler isn't running on another CPU.
252 */ 248 */
253 synchronize_irq(port->irq); 249 synchronize_irq(uport->irq);
254 } 250 }
255 251
256 /* 252 /*
257 * kill off our tasklet 253 * kill off our tasklet
258 */ 254 */
259 tasklet_kill(&info->tlet); 255 tasklet_kill(&state->tlet);
260 256
261 /* 257 /*
262 * Free the transmit buffer page. 258 * Free the transmit buffer page.
263 */ 259 */
264 if (info->xmit.buf) { 260 if (state->xmit.buf) {
265 free_page((unsigned long)info->xmit.buf); 261 free_page((unsigned long)state->xmit.buf);
266 info->xmit.buf = NULL; 262 state->xmit.buf = NULL;
267 } 263 }
268} 264}
269 265
@@ -430,15 +426,16 @@ EXPORT_SYMBOL(uart_get_divisor);
430static void 426static void
431uart_change_speed(struct uart_state *state, struct ktermios *old_termios) 427uart_change_speed(struct uart_state *state, struct ktermios *old_termios)
432{ 428{
433 struct tty_struct *tty = state->info.port.tty; 429 struct tty_port *port = &state->port;
434 struct uart_port *port = state->port; 430 struct tty_struct *tty = port->tty;
431 struct uart_port *uport = state->uart_port;
435 struct ktermios *termios; 432 struct ktermios *termios;
436 433
437 /* 434 /*
438 * If we have no tty, termios, or the port does not exist, 435 * If we have no tty, termios, or the port does not exist,
439 * then we can't set the parameters for this port. 436 * then we can't set the parameters for this port.
440 */ 437 */
441 if (!tty || !tty->termios || port->type == PORT_UNKNOWN) 438 if (!tty || !tty->termios || uport->type == PORT_UNKNOWN)
442 return; 439 return;
443 440
444 termios = tty->termios; 441 termios = tty->termios;
@@ -447,16 +444,16 @@ uart_change_speed(struct uart_state *state, struct ktermios *old_termios)
447 * Set flags based on termios cflag 444 * Set flags based on termios cflag
448 */ 445 */
449 if (termios->c_cflag & CRTSCTS) 446 if (termios->c_cflag & CRTSCTS)
450 state->info.flags |= UIF_CTS_FLOW; 447 set_bit(ASYNCB_CTS_FLOW, &port->flags);
451 else 448 else
452 state->info.flags &= ~UIF_CTS_FLOW; 449 clear_bit(ASYNCB_CTS_FLOW, &port->flags);
453 450
454 if (termios->c_cflag & CLOCAL) 451 if (termios->c_cflag & CLOCAL)
455 state->info.flags &= ~UIF_CHECK_CD; 452 clear_bit(ASYNCB_CHECK_CD, &port->flags);
456 else 453 else
457 state->info.flags |= UIF_CHECK_CD; 454 set_bit(ASYNCB_CHECK_CD, &port->flags);
458 455
459 port->ops->set_termios(port, termios, old_termios); 456 uport->ops->set_termios(uport, termios, old_termios);
460} 457}
461 458
462static inline int 459static inline int
@@ -482,7 +479,7 @@ static int uart_put_char(struct tty_struct *tty, unsigned char ch)
482{ 479{
483 struct uart_state *state = tty->driver_data; 480 struct uart_state *state = tty->driver_data;
484 481
485 return __uart_put_char(state->port, &state->info.xmit, ch); 482 return __uart_put_char(state->uart_port, &state->xmit, ch);
486} 483}
487 484
488static void uart_flush_chars(struct tty_struct *tty) 485static void uart_flush_chars(struct tty_struct *tty)
@@ -508,8 +505,8 @@ uart_write(struct tty_struct *tty, const unsigned char *buf, int count)
508 return -EL3HLT; 505 return -EL3HLT;
509 } 506 }
510 507
511 port = state->port; 508 port = state->uart_port;
512 circ = &state->info.xmit; 509 circ = &state->xmit;
513 510
514 if (!circ->buf) 511 if (!circ->buf)
515 return 0; 512 return 0;
@@ -539,9 +536,9 @@ static int uart_write_room(struct tty_struct *tty)
539 unsigned long flags; 536 unsigned long flags;
540 int ret; 537 int ret;
541 538
542 spin_lock_irqsave(&state->port->lock, flags); 539 spin_lock_irqsave(&state->uart_port->lock, flags);
543 ret = uart_circ_chars_free(&state->info.xmit); 540 ret = uart_circ_chars_free(&state->xmit);
544 spin_unlock_irqrestore(&state->port->lock, flags); 541 spin_unlock_irqrestore(&state->uart_port->lock, flags);
545 return ret; 542 return ret;
546} 543}
547 544
@@ -551,9 +548,9 @@ static int uart_chars_in_buffer(struct tty_struct *tty)
551 unsigned long flags; 548 unsigned long flags;
552 int ret; 549 int ret;
553 550
554 spin_lock_irqsave(&state->port->lock, flags); 551 spin_lock_irqsave(&state->uart_port->lock, flags);
555 ret = uart_circ_chars_pending(&state->info.xmit); 552 ret = uart_circ_chars_pending(&state->xmit);
556 spin_unlock_irqrestore(&state->port->lock, flags); 553 spin_unlock_irqrestore(&state->uart_port->lock, flags);
557 return ret; 554 return ret;
558} 555}
559 556
@@ -572,11 +569,11 @@ static void uart_flush_buffer(struct tty_struct *tty)
572 return; 569 return;
573 } 570 }
574 571
575 port = state->port; 572 port = state->uart_port;
576 pr_debug("uart_flush_buffer(%d) called\n", tty->index); 573 pr_debug("uart_flush_buffer(%d) called\n", tty->index);
577 574
578 spin_lock_irqsave(&port->lock, flags); 575 spin_lock_irqsave(&port->lock, flags);
579 uart_circ_clear(&state->info.xmit); 576 uart_circ_clear(&state->xmit);
580 if (port->ops->flush_buffer) 577 if (port->ops->flush_buffer)
581 port->ops->flush_buffer(port); 578 port->ops->flush_buffer(port);
582 spin_unlock_irqrestore(&port->lock, flags); 579 spin_unlock_irqrestore(&port->lock, flags);
@@ -590,7 +587,7 @@ static void uart_flush_buffer(struct tty_struct *tty)
590static void uart_send_xchar(struct tty_struct *tty, char ch) 587static void uart_send_xchar(struct tty_struct *tty, char ch)
591{ 588{
592 struct uart_state *state = tty->driver_data; 589 struct uart_state *state = tty->driver_data;
593 struct uart_port *port = state->port; 590 struct uart_port *port = state->uart_port;
594 unsigned long flags; 591 unsigned long flags;
595 592
596 if (port->ops->send_xchar) 593 if (port->ops->send_xchar)
@@ -613,13 +610,13 @@ static void uart_throttle(struct tty_struct *tty)
613 uart_send_xchar(tty, STOP_CHAR(tty)); 610 uart_send_xchar(tty, STOP_CHAR(tty));
614 611
615 if (tty->termios->c_cflag & CRTSCTS) 612 if (tty->termios->c_cflag & CRTSCTS)
616 uart_clear_mctrl(state->port, TIOCM_RTS); 613 uart_clear_mctrl(state->uart_port, TIOCM_RTS);
617} 614}
618 615
619static void uart_unthrottle(struct tty_struct *tty) 616static void uart_unthrottle(struct tty_struct *tty)
620{ 617{
621 struct uart_state *state = tty->driver_data; 618 struct uart_state *state = tty->driver_data;
622 struct uart_port *port = state->port; 619 struct uart_port *port = state->uart_port;
623 620
624 if (I_IXOFF(tty)) { 621 if (I_IXOFF(tty)) {
625 if (port->x_char) 622 if (port->x_char)
@@ -635,35 +632,36 @@ static void uart_unthrottle(struct tty_struct *tty)
635static int uart_get_info(struct uart_state *state, 632static int uart_get_info(struct uart_state *state,
636 struct serial_struct __user *retinfo) 633 struct serial_struct __user *retinfo)
637{ 634{
638 struct uart_port *port = state->port; 635 struct uart_port *uport = state->uart_port;
636 struct tty_port *port = &state->port;
639 struct serial_struct tmp; 637 struct serial_struct tmp;
640 638
641 memset(&tmp, 0, sizeof(tmp)); 639 memset(&tmp, 0, sizeof(tmp));
642 640
643 /* Ensure the state we copy is consistent and no hardware changes 641 /* Ensure the state we copy is consistent and no hardware changes
644 occur as we go */ 642 occur as we go */
645 mutex_lock(&state->mutex); 643 mutex_lock(&port->mutex);
646 644
647 tmp.type = port->type; 645 tmp.type = uport->type;
648 tmp.line = port->line; 646 tmp.line = uport->line;
649 tmp.port = port->iobase; 647 tmp.port = uport->iobase;
650 if (HIGH_BITS_OFFSET) 648 if (HIGH_BITS_OFFSET)
651 tmp.port_high = (long) port->iobase >> HIGH_BITS_OFFSET; 649 tmp.port_high = (long) uport->iobase >> HIGH_BITS_OFFSET;
652 tmp.irq = port->irq; 650 tmp.irq = uport->irq;
653 tmp.flags = port->flags; 651 tmp.flags = uport->flags;
654 tmp.xmit_fifo_size = port->fifosize; 652 tmp.xmit_fifo_size = uport->fifosize;
655 tmp.baud_base = port->uartclk / 16; 653 tmp.baud_base = uport->uartclk / 16;
656 tmp.close_delay = state->close_delay / 10; 654 tmp.close_delay = port->close_delay / 10;
657 tmp.closing_wait = state->closing_wait == USF_CLOSING_WAIT_NONE ? 655 tmp.closing_wait = port->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
658 ASYNC_CLOSING_WAIT_NONE : 656 ASYNC_CLOSING_WAIT_NONE :
659 state->closing_wait / 10; 657 port->closing_wait / 10;
660 tmp.custom_divisor = port->custom_divisor; 658 tmp.custom_divisor = uport->custom_divisor;
661 tmp.hub6 = port->hub6; 659 tmp.hub6 = uport->hub6;
662 tmp.io_type = port->iotype; 660 tmp.io_type = uport->iotype;
663 tmp.iomem_reg_shift = port->regshift; 661 tmp.iomem_reg_shift = uport->regshift;
664 tmp.iomem_base = (void *)(unsigned long)port->mapbase; 662 tmp.iomem_base = (void *)(unsigned long)uport->mapbase;
665 663
666 mutex_unlock(&state->mutex); 664 mutex_unlock(&port->mutex);
667 665
668 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo))) 666 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
669 return -EFAULT; 667 return -EFAULT;
@@ -674,7 +672,8 @@ static int uart_set_info(struct uart_state *state,
674 struct serial_struct __user *newinfo) 672 struct serial_struct __user *newinfo)
675{ 673{
676 struct serial_struct new_serial; 674 struct serial_struct new_serial;
677 struct uart_port *port = state->port; 675 struct uart_port *uport = state->uart_port;
676 struct tty_port *port = &state->port;
678 unsigned long new_port; 677 unsigned long new_port;
679 unsigned int change_irq, change_port, closing_wait; 678 unsigned int change_irq, change_port, closing_wait;
680 unsigned int old_custom_divisor, close_delay; 679 unsigned int old_custom_divisor, close_delay;
@@ -691,58 +690,58 @@ static int uart_set_info(struct uart_state *state,
691 new_serial.irq = irq_canonicalize(new_serial.irq); 690 new_serial.irq = irq_canonicalize(new_serial.irq);
692 close_delay = new_serial.close_delay * 10; 691 close_delay = new_serial.close_delay * 10;
693 closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ? 692 closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
694 USF_CLOSING_WAIT_NONE : new_serial.closing_wait * 10; 693 ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
695 694
696 /* 695 /*
697 * This semaphore protects state->count. It is also 696 * This semaphore protects port->count. It is also
698 * very useful to prevent opens. Also, take the 697 * very useful to prevent opens. Also, take the
699 * port configuration semaphore to make sure that a 698 * port configuration semaphore to make sure that a
700 * module insertion/removal doesn't change anything 699 * module insertion/removal doesn't change anything
701 * under us. 700 * under us.
702 */ 701 */
703 mutex_lock(&state->mutex); 702 mutex_lock(&port->mutex);
704 703
705 change_irq = !(port->flags & UPF_FIXED_PORT) 704 change_irq = !(uport->flags & UPF_FIXED_PORT)
706 && new_serial.irq != port->irq; 705 && new_serial.irq != uport->irq;
707 706
708 /* 707 /*
709 * Since changing the 'type' of the port changes its resource 708 * Since changing the 'type' of the port changes its resource
710 * allocations, we should treat type changes the same as 709 * allocations, we should treat type changes the same as
711 * IO port changes. 710 * IO port changes.
712 */ 711 */
713 change_port = !(port->flags & UPF_FIXED_PORT) 712 change_port = !(uport->flags & UPF_FIXED_PORT)
714 && (new_port != port->iobase || 713 && (new_port != uport->iobase ||
715 (unsigned long)new_serial.iomem_base != port->mapbase || 714 (unsigned long)new_serial.iomem_base != uport->mapbase ||
716 new_serial.hub6 != port->hub6 || 715 new_serial.hub6 != uport->hub6 ||
717 new_serial.io_type != port->iotype || 716 new_serial.io_type != uport->iotype ||
718 new_serial.iomem_reg_shift != port->regshift || 717 new_serial.iomem_reg_shift != uport->regshift ||
719 new_serial.type != port->type); 718 new_serial.type != uport->type);
720 719
721 old_flags = port->flags; 720 old_flags = uport->flags;
722 new_flags = new_serial.flags; 721 new_flags = new_serial.flags;
723 old_custom_divisor = port->custom_divisor; 722 old_custom_divisor = uport->custom_divisor;
724 723
725 if (!capable(CAP_SYS_ADMIN)) { 724 if (!capable(CAP_SYS_ADMIN)) {
726 retval = -EPERM; 725 retval = -EPERM;
727 if (change_irq || change_port || 726 if (change_irq || change_port ||
728 (new_serial.baud_base != port->uartclk / 16) || 727 (new_serial.baud_base != uport->uartclk / 16) ||
729 (close_delay != state->close_delay) || 728 (close_delay != port->close_delay) ||
730 (closing_wait != state->closing_wait) || 729 (closing_wait != port->closing_wait) ||
731 (new_serial.xmit_fifo_size && 730 (new_serial.xmit_fifo_size &&
732 new_serial.xmit_fifo_size != port->fifosize) || 731 new_serial.xmit_fifo_size != uport->fifosize) ||
733 (((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0)) 732 (((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0))
734 goto exit; 733 goto exit;
735 port->flags = ((port->flags & ~UPF_USR_MASK) | 734 uport->flags = ((uport->flags & ~UPF_USR_MASK) |
736 (new_flags & UPF_USR_MASK)); 735 (new_flags & UPF_USR_MASK));
737 port->custom_divisor = new_serial.custom_divisor; 736 uport->custom_divisor = new_serial.custom_divisor;
738 goto check_and_exit; 737 goto check_and_exit;
739 } 738 }
740 739
741 /* 740 /*
742 * Ask the low level driver to verify the settings. 741 * Ask the low level driver to verify the settings.
743 */ 742 */
744 if (port->ops->verify_port) 743 if (uport->ops->verify_port)
745 retval = port->ops->verify_port(port, &new_serial); 744 retval = uport->ops->verify_port(uport, &new_serial);
746 745
747 if ((new_serial.irq >= nr_irqs) || (new_serial.irq < 0) || 746 if ((new_serial.irq >= nr_irqs) || (new_serial.irq < 0) ||
748 (new_serial.baud_base < 9600)) 747 (new_serial.baud_base < 9600))
@@ -757,7 +756,7 @@ static int uart_set_info(struct uart_state *state,
757 /* 756 /*
758 * Make sure that we are the sole user of this port. 757 * Make sure that we are the sole user of this port.
759 */ 758 */
760 if (uart_users(state) > 1) 759 if (tty_port_users(port) > 1)
761 goto exit; 760 goto exit;
762 761
763 /* 762 /*
@@ -771,31 +770,31 @@ static int uart_set_info(struct uart_state *state,
771 unsigned long old_iobase, old_mapbase; 770 unsigned long old_iobase, old_mapbase;
772 unsigned int old_type, old_iotype, old_hub6, old_shift; 771 unsigned int old_type, old_iotype, old_hub6, old_shift;
773 772
774 old_iobase = port->iobase; 773 old_iobase = uport->iobase;
775 old_mapbase = port->mapbase; 774 old_mapbase = uport->mapbase;
776 old_type = port->type; 775 old_type = uport->type;
777 old_hub6 = port->hub6; 776 old_hub6 = uport->hub6;
778 old_iotype = port->iotype; 777 old_iotype = uport->iotype;
779 old_shift = port->regshift; 778 old_shift = uport->regshift;
780 779
781 /* 780 /*
782 * Free and release old regions 781 * Free and release old regions
783 */ 782 */
784 if (old_type != PORT_UNKNOWN) 783 if (old_type != PORT_UNKNOWN)
785 port->ops->release_port(port); 784 uport->ops->release_port(uport);
786 785
787 port->iobase = new_port; 786 uport->iobase = new_port;
788 port->type = new_serial.type; 787 uport->type = new_serial.type;
789 port->hub6 = new_serial.hub6; 788 uport->hub6 = new_serial.hub6;
790 port->iotype = new_serial.io_type; 789 uport->iotype = new_serial.io_type;
791 port->regshift = new_serial.iomem_reg_shift; 790 uport->regshift = new_serial.iomem_reg_shift;
792 port->mapbase = (unsigned long)new_serial.iomem_base; 791 uport->mapbase = (unsigned long)new_serial.iomem_base;
793 792
794 /* 793 /*
795 * Claim and map the new regions 794 * Claim and map the new regions
796 */ 795 */
797 if (port->type != PORT_UNKNOWN) { 796 if (uport->type != PORT_UNKNOWN) {
798 retval = port->ops->request_port(port); 797 retval = uport->ops->request_port(uport);
799 } else { 798 } else {
800 /* Always success - Jean II */ 799 /* Always success - Jean II */
801 retval = 0; 800 retval = 0;
@@ -806,19 +805,19 @@ static int uart_set_info(struct uart_state *state,
806 * new port, try to restore the old settings. 805 * new port, try to restore the old settings.
807 */ 806 */
808 if (retval && old_type != PORT_UNKNOWN) { 807 if (retval && old_type != PORT_UNKNOWN) {
809 port->iobase = old_iobase; 808 uport->iobase = old_iobase;
810 port->type = old_type; 809 uport->type = old_type;
811 port->hub6 = old_hub6; 810 uport->hub6 = old_hub6;
812 port->iotype = old_iotype; 811 uport->iotype = old_iotype;
813 port->regshift = old_shift; 812 uport->regshift = old_shift;
814 port->mapbase = old_mapbase; 813 uport->mapbase = old_mapbase;
815 retval = port->ops->request_port(port); 814 retval = uport->ops->request_port(uport);
816 /* 815 /*
817 * If we failed to restore the old settings, 816 * If we failed to restore the old settings,
818 * we fail like this. 817 * we fail like this.
819 */ 818 */
820 if (retval) 819 if (retval)
821 port->type = PORT_UNKNOWN; 820 uport->type = PORT_UNKNOWN;
822 821
823 /* 822 /*
824 * We failed anyway. 823 * We failed anyway.
@@ -830,45 +829,45 @@ static int uart_set_info(struct uart_state *state,
830 } 829 }
831 830
832 if (change_irq) 831 if (change_irq)
833 port->irq = new_serial.irq; 832 uport->irq = new_serial.irq;
834 if (!(port->flags & UPF_FIXED_PORT)) 833 if (!(uport->flags & UPF_FIXED_PORT))
835 port->uartclk = new_serial.baud_base * 16; 834 uport->uartclk = new_serial.baud_base * 16;
836 port->flags = (port->flags & ~UPF_CHANGE_MASK) | 835 uport->flags = (uport->flags & ~UPF_CHANGE_MASK) |
837 (new_flags & UPF_CHANGE_MASK); 836 (new_flags & UPF_CHANGE_MASK);
838 port->custom_divisor = new_serial.custom_divisor; 837 uport->custom_divisor = new_serial.custom_divisor;
839 state->close_delay = close_delay; 838 port->close_delay = close_delay;
840 state->closing_wait = closing_wait; 839 port->closing_wait = closing_wait;
841 if (new_serial.xmit_fifo_size) 840 if (new_serial.xmit_fifo_size)
842 port->fifosize = new_serial.xmit_fifo_size; 841 uport->fifosize = new_serial.xmit_fifo_size;
843 if (state->info.port.tty) 842 if (port->tty)
844 state->info.port.tty->low_latency = 843 port->tty->low_latency =
845 (port->flags & UPF_LOW_LATENCY) ? 1 : 0; 844 (uport->flags & UPF_LOW_LATENCY) ? 1 : 0;
846 845
847 check_and_exit: 846 check_and_exit:
848 retval = 0; 847 retval = 0;
849 if (port->type == PORT_UNKNOWN) 848 if (uport->type == PORT_UNKNOWN)
850 goto exit; 849 goto exit;
851 if (state->info.flags & UIF_INITIALIZED) { 850 if (port->flags & ASYNC_INITIALIZED) {
852 if (((old_flags ^ port->flags) & UPF_SPD_MASK) || 851 if (((old_flags ^ uport->flags) & UPF_SPD_MASK) ||
853 old_custom_divisor != port->custom_divisor) { 852 old_custom_divisor != uport->custom_divisor) {
854 /* 853 /*
855 * If they're setting up a custom divisor or speed, 854 * If they're setting up a custom divisor or speed,
856 * instead of clearing it, then bitch about it. No 855 * instead of clearing it, then bitch about it. No
857 * need to rate-limit; it's CAP_SYS_ADMIN only. 856 * need to rate-limit; it's CAP_SYS_ADMIN only.
858 */ 857 */
859 if (port->flags & UPF_SPD_MASK) { 858 if (uport->flags & UPF_SPD_MASK) {
860 char buf[64]; 859 char buf[64];
861 printk(KERN_NOTICE 860 printk(KERN_NOTICE
862 "%s sets custom speed on %s. This " 861 "%s sets custom speed on %s. This "
863 "is deprecated.\n", current->comm, 862 "is deprecated.\n", current->comm,
864 tty_name(state->info.port.tty, buf)); 863 tty_name(port->tty, buf));
865 } 864 }
866 uart_change_speed(state, NULL); 865 uart_change_speed(state, NULL);
867 } 866 }
868 } else 867 } else
869 retval = uart_startup(state, 1); 868 retval = uart_startup(state, 1);
870 exit: 869 exit:
871 mutex_unlock(&state->mutex); 870 mutex_unlock(&port->mutex);
872 return retval; 871 return retval;
873} 872}
874 873
@@ -880,10 +879,11 @@ static int uart_set_info(struct uart_state *state,
880static int uart_get_lsr_info(struct uart_state *state, 879static int uart_get_lsr_info(struct uart_state *state,
881 unsigned int __user *value) 880 unsigned int __user *value)
882{ 881{
883 struct uart_port *port = state->port; 882 struct uart_port *uport = state->uart_port;
883 struct tty_port *port = &state->port;
884 unsigned int result; 884 unsigned int result;
885 885
886 result = port->ops->tx_empty(port); 886 result = uport->ops->tx_empty(uport);
887 887
888 /* 888 /*
889 * If we're about to load something into the transmit 889 * If we're about to load something into the transmit
@@ -891,9 +891,9 @@ static int uart_get_lsr_info(struct uart_state *state,
891 * avoid a race condition (depending on when the transmit 891 * avoid a race condition (depending on when the transmit
892 * interrupt happens). 892 * interrupt happens).
893 */ 893 */
894 if (port->x_char || 894 if (uport->x_char ||
895 ((uart_circ_chars_pending(&state->info.xmit) > 0) && 895 ((uart_circ_chars_pending(&state->xmit) > 0) &&
896 !state->info.port.tty->stopped && !state->info.port.tty->hw_stopped)) 896 !port->tty->stopped && !port->tty->hw_stopped))
897 result &= ~TIOCSER_TEMT; 897 result &= ~TIOCSER_TEMT;
898 898
899 return put_user(result, value); 899 return put_user(result, value);
@@ -902,19 +902,20 @@ static int uart_get_lsr_info(struct uart_state *state,
902static int uart_tiocmget(struct tty_struct *tty, struct file *file) 902static int uart_tiocmget(struct tty_struct *tty, struct file *file)
903{ 903{
904 struct uart_state *state = tty->driver_data; 904 struct uart_state *state = tty->driver_data;
905 struct uart_port *port = state->port; 905 struct tty_port *port = &state->port;
906 struct uart_port *uport = state->uart_port;
906 int result = -EIO; 907 int result = -EIO;
907 908
908 mutex_lock(&state->mutex); 909 mutex_lock(&port->mutex);
909 if ((!file || !tty_hung_up_p(file)) && 910 if ((!file || !tty_hung_up_p(file)) &&
910 !(tty->flags & (1 << TTY_IO_ERROR))) { 911 !(tty->flags & (1 << TTY_IO_ERROR))) {
911 result = port->mctrl; 912 result = uport->mctrl;
912 913
913 spin_lock_irq(&port->lock); 914 spin_lock_irq(&uport->lock);
914 result |= port->ops->get_mctrl(port); 915 result |= uport->ops->get_mctrl(uport);
915 spin_unlock_irq(&port->lock); 916 spin_unlock_irq(&uport->lock);
916 } 917 }
917 mutex_unlock(&state->mutex); 918 mutex_unlock(&port->mutex);
918 919
919 return result; 920 return result;
920} 921}
@@ -924,36 +925,39 @@ uart_tiocmset(struct tty_struct *tty, struct file *file,
924 unsigned int set, unsigned int clear) 925 unsigned int set, unsigned int clear)
925{ 926{
926 struct uart_state *state = tty->driver_data; 927 struct uart_state *state = tty->driver_data;
927 struct uart_port *port = state->port; 928 struct uart_port *uport = state->uart_port;
929 struct tty_port *port = &state->port;
928 int ret = -EIO; 930 int ret = -EIO;
929 931
930 mutex_lock(&state->mutex); 932 mutex_lock(&port->mutex);
931 if ((!file || !tty_hung_up_p(file)) && 933 if ((!file || !tty_hung_up_p(file)) &&
932 !(tty->flags & (1 << TTY_IO_ERROR))) { 934 !(tty->flags & (1 << TTY_IO_ERROR))) {
933 uart_update_mctrl(port, set, clear); 935 uart_update_mctrl(uport, set, clear);
934 ret = 0; 936 ret = 0;
935 } 937 }
936 mutex_unlock(&state->mutex); 938 mutex_unlock(&port->mutex);
937 return ret; 939 return ret;
938} 940}
939 941
940static int uart_break_ctl(struct tty_struct *tty, int break_state) 942static int uart_break_ctl(struct tty_struct *tty, int break_state)
941{ 943{
942 struct uart_state *state = tty->driver_data; 944 struct uart_state *state = tty->driver_data;
943 struct uart_port *port = state->port; 945 struct tty_port *port = &state->port;
946 struct uart_port *uport = state->uart_port;
944 947
945 mutex_lock(&state->mutex); 948 mutex_lock(&port->mutex);
946 949
947 if (port->type != PORT_UNKNOWN) 950 if (uport->type != PORT_UNKNOWN)
948 port->ops->break_ctl(port, break_state); 951 uport->ops->break_ctl(uport, break_state);
949 952
950 mutex_unlock(&state->mutex); 953 mutex_unlock(&port->mutex);
951 return 0; 954 return 0;
952} 955}
953 956
954static int uart_do_autoconfig(struct uart_state *state) 957static int uart_do_autoconfig(struct uart_state *state)
955{ 958{
956 struct uart_port *port = state->port; 959 struct uart_port *uport = state->uart_port;
960 struct tty_port *port = &state->port;
957 int flags, ret; 961 int flags, ret;
958 962
959 if (!capable(CAP_SYS_ADMIN)) 963 if (!capable(CAP_SYS_ADMIN))
@@ -964,33 +968,33 @@ static int uart_do_autoconfig(struct uart_state *state)
964 * changing, and hence any extra opens of the port while 968 * changing, and hence any extra opens of the port while
965 * we're auto-configuring. 969 * we're auto-configuring.
966 */ 970 */
967 if (mutex_lock_interruptible(&state->mutex)) 971 if (mutex_lock_interruptible(&port->mutex))
968 return -ERESTARTSYS; 972 return -ERESTARTSYS;
969 973
970 ret = -EBUSY; 974 ret = -EBUSY;
971 if (uart_users(state) == 1) { 975 if (tty_port_users(port) == 1) {
972 uart_shutdown(state); 976 uart_shutdown(state);
973 977
974 /* 978 /*
975 * If we already have a port type configured, 979 * If we already have a port type configured,
976 * we must release its resources. 980 * we must release its resources.
977 */ 981 */
978 if (port->type != PORT_UNKNOWN) 982 if (uport->type != PORT_UNKNOWN)
979 port->ops->release_port(port); 983 uport->ops->release_port(uport);
980 984
981 flags = UART_CONFIG_TYPE; 985 flags = UART_CONFIG_TYPE;
982 if (port->flags & UPF_AUTO_IRQ) 986 if (uport->flags & UPF_AUTO_IRQ)
983 flags |= UART_CONFIG_IRQ; 987 flags |= UART_CONFIG_IRQ;
984 988
985 /* 989 /*
986 * This will claim the ports resources if 990 * This will claim the ports resources if
987 * a port is found. 991 * a port is found.
988 */ 992 */
989 port->ops->config_port(port, flags); 993 uport->ops->config_port(uport, flags);
990 994
991 ret = uart_startup(state, 1); 995 ret = uart_startup(state, 1);
992 } 996 }
993 mutex_unlock(&state->mutex); 997 mutex_unlock(&port->mutex);
994 return ret; 998 return ret;
995} 999}
996 1000
@@ -999,11 +1003,15 @@ static int uart_do_autoconfig(struct uart_state *state)
999 * - mask passed in arg for lines of interest 1003 * - mask passed in arg for lines of interest
1000 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking) 1004 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
1001 * Caller should use TIOCGICOUNT to see which one it was 1005 * Caller should use TIOCGICOUNT to see which one it was
1006 *
1007 * FIXME: This wants extracting into a common all driver implementation
1008 * of TIOCMWAIT using tty_port.
1002 */ 1009 */
1003static int 1010static int
1004uart_wait_modem_status(struct uart_state *state, unsigned long arg) 1011uart_wait_modem_status(struct uart_state *state, unsigned long arg)
1005{ 1012{
1006 struct uart_port *port = state->port; 1013 struct uart_port *uport = state->uart_port;
1014 struct tty_port *port = &state->port;
1007 DECLARE_WAITQUEUE(wait, current); 1015 DECLARE_WAITQUEUE(wait, current);
1008 struct uart_icount cprev, cnow; 1016 struct uart_icount cprev, cnow;
1009 int ret; 1017 int ret;
@@ -1011,20 +1019,20 @@ uart_wait_modem_status(struct uart_state *state, unsigned long arg)
1011 /* 1019 /*
1012 * note the counters on entry 1020 * note the counters on entry
1013 */ 1021 */
1014 spin_lock_irq(&port->lock); 1022 spin_lock_irq(&uport->lock);
1015 memcpy(&cprev, &port->icount, sizeof(struct uart_icount)); 1023 memcpy(&cprev, &uport->icount, sizeof(struct uart_icount));
1016 1024
1017 /* 1025 /*
1018 * Force modem status interrupts on 1026 * Force modem status interrupts on
1019 */ 1027 */
1020 port->ops->enable_ms(port); 1028 uport->ops->enable_ms(uport);
1021 spin_unlock_irq(&port->lock); 1029 spin_unlock_irq(&uport->lock);
1022 1030
1023 add_wait_queue(&state->info.delta_msr_wait, &wait); 1031 add_wait_queue(&port->delta_msr_wait, &wait);
1024 for (;;) { 1032 for (;;) {
1025 spin_lock_irq(&port->lock); 1033 spin_lock_irq(&uport->lock);
1026 memcpy(&cnow, &port->icount, sizeof(struct uart_icount)); 1034 memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
1027 spin_unlock_irq(&port->lock); 1035 spin_unlock_irq(&uport->lock);
1028 1036
1029 set_current_state(TASK_INTERRUPTIBLE); 1037 set_current_state(TASK_INTERRUPTIBLE);
1030 1038
@@ -1048,7 +1056,7 @@ uart_wait_modem_status(struct uart_state *state, unsigned long arg)
1048 } 1056 }
1049 1057
1050 current->state = TASK_RUNNING; 1058 current->state = TASK_RUNNING;
1051 remove_wait_queue(&state->info.delta_msr_wait, &wait); 1059 remove_wait_queue(&port->delta_msr_wait, &wait);
1052 1060
1053 return ret; 1061 return ret;
1054} 1062}
@@ -1064,11 +1072,11 @@ static int uart_get_count(struct uart_state *state,
1064{ 1072{
1065 struct serial_icounter_struct icount; 1073 struct serial_icounter_struct icount;
1066 struct uart_icount cnow; 1074 struct uart_icount cnow;
1067 struct uart_port *port = state->port; 1075 struct uart_port *uport = state->uart_port;
1068 1076
1069 spin_lock_irq(&port->lock); 1077 spin_lock_irq(&uport->lock);
1070 memcpy(&cnow, &port->icount, sizeof(struct uart_icount)); 1078 memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
1071 spin_unlock_irq(&port->lock); 1079 spin_unlock_irq(&uport->lock);
1072 1080
1073 icount.cts = cnow.cts; 1081 icount.cts = cnow.cts;
1074 icount.dsr = cnow.dsr; 1082 icount.dsr = cnow.dsr;
@@ -1093,6 +1101,7 @@ uart_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd,
1093 unsigned long arg) 1101 unsigned long arg)
1094{ 1102{
1095 struct uart_state *state = tty->driver_data; 1103 struct uart_state *state = tty->driver_data;
1104 struct tty_port *port = &state->port;
1096 void __user *uarg = (void __user *)arg; 1105 void __user *uarg = (void __user *)arg;
1097 int ret = -ENOIOCTLCMD; 1106 int ret = -ENOIOCTLCMD;
1098 1107
@@ -1143,7 +1152,7 @@ uart_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd,
1143 if (ret != -ENOIOCTLCMD) 1152 if (ret != -ENOIOCTLCMD)
1144 goto out; 1153 goto out;
1145 1154
1146 mutex_lock(&state->mutex); 1155 mutex_lock(&port->mutex);
1147 1156
1148 if (tty_hung_up_p(filp)) { 1157 if (tty_hung_up_p(filp)) {
1149 ret = -EIO; 1158 ret = -EIO;
@@ -1160,14 +1169,14 @@ uart_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd,
1160 break; 1169 break;
1161 1170
1162 default: { 1171 default: {
1163 struct uart_port *port = state->port; 1172 struct uart_port *uport = state->uart_port;
1164 if (port->ops->ioctl) 1173 if (uport->ops->ioctl)
1165 ret = port->ops->ioctl(port, cmd, arg); 1174 ret = uport->ops->ioctl(uport, cmd, arg);
1166 break; 1175 break;
1167 } 1176 }
1168 } 1177 }
1169out_up: 1178out_up:
1170 mutex_unlock(&state->mutex); 1179 mutex_unlock(&port->mutex);
1171out: 1180out:
1172 return ret; 1181 return ret;
1173} 1182}
@@ -1175,10 +1184,10 @@ out:
1175static void uart_set_ldisc(struct tty_struct *tty) 1184static void uart_set_ldisc(struct tty_struct *tty)
1176{ 1185{
1177 struct uart_state *state = tty->driver_data; 1186 struct uart_state *state = tty->driver_data;
1178 struct uart_port *port = state->port; 1187 struct uart_port *uport = state->uart_port;
1179 1188
1180 if (port->ops->set_ldisc) 1189 if (uport->ops->set_ldisc)
1181 port->ops->set_ldisc(port); 1190 uport->ops->set_ldisc(uport);
1182} 1191}
1183 1192
1184static void uart_set_termios(struct tty_struct *tty, 1193static void uart_set_termios(struct tty_struct *tty,
@@ -1207,7 +1216,7 @@ static void uart_set_termios(struct tty_struct *tty,
1207 1216
1208 /* Handle transition to B0 status */ 1217 /* Handle transition to B0 status */
1209 if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD)) 1218 if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
1210 uart_clear_mctrl(state->port, TIOCM_RTS | TIOCM_DTR); 1219 uart_clear_mctrl(state->uart_port, TIOCM_RTS | TIOCM_DTR);
1211 1220
1212 /* Handle transition away from B0 status */ 1221 /* Handle transition away from B0 status */
1213 if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) { 1222 if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
@@ -1215,25 +1224,25 @@ static void uart_set_termios(struct tty_struct *tty,
1215 if (!(cflag & CRTSCTS) || 1224 if (!(cflag & CRTSCTS) ||
1216 !test_bit(TTY_THROTTLED, &tty->flags)) 1225 !test_bit(TTY_THROTTLED, &tty->flags))
1217 mask |= TIOCM_RTS; 1226 mask |= TIOCM_RTS;
1218 uart_set_mctrl(state->port, mask); 1227 uart_set_mctrl(state->uart_port, mask);
1219 } 1228 }
1220 1229
1221 /* Handle turning off CRTSCTS */ 1230 /* Handle turning off CRTSCTS */
1222 if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) { 1231 if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
1223 spin_lock_irqsave(&state->port->lock, flags); 1232 spin_lock_irqsave(&state->uart_port->lock, flags);
1224 tty->hw_stopped = 0; 1233 tty->hw_stopped = 0;
1225 __uart_start(tty); 1234 __uart_start(tty);
1226 spin_unlock_irqrestore(&state->port->lock, flags); 1235 spin_unlock_irqrestore(&state->uart_port->lock, flags);
1227 } 1236 }
1228 1237
1229 /* Handle turning on CRTSCTS */ 1238 /* Handle turning on CRTSCTS */
1230 if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) { 1239 if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {
1231 spin_lock_irqsave(&state->port->lock, flags); 1240 spin_lock_irqsave(&state->uart_port->lock, flags);
1232 if (!(state->port->ops->get_mctrl(state->port) & TIOCM_CTS)) { 1241 if (!(state->uart_port->ops->get_mctrl(state->uart_port) & TIOCM_CTS)) {
1233 tty->hw_stopped = 1; 1242 tty->hw_stopped = 1;
1234 state->port->ops->stop_tx(state->port); 1243 state->uart_port->ops->stop_tx(state->uart_port);
1235 } 1244 }
1236 spin_unlock_irqrestore(&state->port->lock, flags); 1245 spin_unlock_irqrestore(&state->uart_port->lock, flags);
1237 } 1246 }
1238#if 0 1247#if 0
1239 /* 1248 /*
@@ -1244,7 +1253,7 @@ static void uart_set_termios(struct tty_struct *tty,
1244 */ 1253 */
1245 if (!(old_termios->c_cflag & CLOCAL) && 1254 if (!(old_termios->c_cflag & CLOCAL) &&
1246 (tty->termios->c_cflag & CLOCAL)) 1255 (tty->termios->c_cflag & CLOCAL))
1247 wake_up_interruptible(&info->port.open_wait); 1256 wake_up_interruptible(&state->uart_port.open_wait);
1248#endif 1257#endif
1249} 1258}
1250 1259
@@ -1256,40 +1265,39 @@ static void uart_set_termios(struct tty_struct *tty,
1256static void uart_close(struct tty_struct *tty, struct file *filp) 1265static void uart_close(struct tty_struct *tty, struct file *filp)
1257{ 1266{
1258 struct uart_state *state = tty->driver_data; 1267 struct uart_state *state = tty->driver_data;
1259 struct uart_port *port; 1268 struct tty_port *port;
1269 struct uart_port *uport;
1260 1270
1261 BUG_ON(!kernel_locked()); 1271 BUG_ON(!kernel_locked());
1262 1272
1263 if (!state || !state->port) 1273 uport = state->uart_port;
1264 return; 1274 port = &state->port;
1265 1275
1266 port = state->port; 1276 pr_debug("uart_close(%d) called\n", uport->line);
1267 1277
1268 pr_debug("uart_close(%d) called\n", port->line); 1278 mutex_lock(&port->mutex);
1269
1270 mutex_lock(&state->mutex);
1271 1279
1272 if (tty_hung_up_p(filp)) 1280 if (tty_hung_up_p(filp))
1273 goto done; 1281 goto done;
1274 1282
1275 if ((tty->count == 1) && (state->count != 1)) { 1283 if ((tty->count == 1) && (port->count != 1)) {
1276 /* 1284 /*
1277 * Uh, oh. tty->count is 1, which means that the tty 1285 * Uh, oh. tty->count is 1, which means that the tty
1278 * structure will be freed. state->count should always 1286 * structure will be freed. port->count should always
1279 * be one in these conditions. If it's greater than 1287 * be one in these conditions. If it's greater than
1280 * one, we've got real problems, since it means the 1288 * one, we've got real problems, since it means the
1281 * serial port won't be shutdown. 1289 * serial port won't be shutdown.
1282 */ 1290 */
1283 printk(KERN_ERR "uart_close: bad serial port count; tty->count is 1, " 1291 printk(KERN_ERR "uart_close: bad serial port count; tty->count is 1, "
1284 "state->count is %d\n", state->count); 1292 "port->count is %d\n", port->count);
1285 state->count = 1; 1293 port->count = 1;
1286 } 1294 }
1287 if (--state->count < 0) { 1295 if (--port->count < 0) {
1288 printk(KERN_ERR "uart_close: bad serial port count for %s: %d\n", 1296 printk(KERN_ERR "uart_close: bad serial port count for %s: %d\n",
1289 tty->name, state->count); 1297 tty->name, port->count);
1290 state->count = 0; 1298 port->count = 0;
1291 } 1299 }
1292 if (state->count) 1300 if (port->count)
1293 goto done; 1301 goto done;
1294 1302
1295 /* 1303 /*
@@ -1299,24 +1307,24 @@ static void uart_close(struct tty_struct *tty, struct file *filp)
1299 */ 1307 */
1300 tty->closing = 1; 1308 tty->closing = 1;
1301 1309
1302 if (state->closing_wait != USF_CLOSING_WAIT_NONE) 1310 if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
1303 tty_wait_until_sent(tty, msecs_to_jiffies(state->closing_wait)); 1311 tty_wait_until_sent(tty, msecs_to_jiffies(port->closing_wait));
1304 1312
1305 /* 1313 /*
1306 * At this point, we stop accepting input. To do this, we 1314 * At this point, we stop accepting input. To do this, we
1307 * disable the receive line status interrupts. 1315 * disable the receive line status interrupts.
1308 */ 1316 */
1309 if (state->info.flags & UIF_INITIALIZED) { 1317 if (port->flags & ASYNC_INITIALIZED) {
1310 unsigned long flags; 1318 unsigned long flags;
1311 spin_lock_irqsave(&port->lock, flags); 1319 spin_lock_irqsave(&port->lock, flags);
1312 port->ops->stop_rx(port); 1320 uport->ops->stop_rx(uport);
1313 spin_unlock_irqrestore(&port->lock, flags); 1321 spin_unlock_irqrestore(&port->lock, flags);
1314 /* 1322 /*
1315 * Before we drop DTR, make sure the UART transmitter 1323 * Before we drop DTR, make sure the UART transmitter
1316 * has completely drained; this is especially 1324 * has completely drained; this is especially
1317 * important if there is a transmit FIFO! 1325 * important if there is a transmit FIFO!
1318 */ 1326 */
1319 uart_wait_until_sent(tty, port->timeout); 1327 uart_wait_until_sent(tty, uport->timeout);
1320 } 1328 }
1321 1329
1322 uart_shutdown(state); 1330 uart_shutdown(state);
@@ -1325,29 +1333,29 @@ static void uart_close(struct tty_struct *tty, struct file *filp)
1325 tty_ldisc_flush(tty); 1333 tty_ldisc_flush(tty);
1326 1334
1327 tty->closing = 0; 1335 tty->closing = 0;
1328 state->info.port.tty = NULL; 1336 tty_port_tty_set(port, NULL);
1329 1337
1330 if (state->info.port.blocked_open) { 1338 if (port->blocked_open) {
1331 if (state->close_delay) 1339 if (port->close_delay)
1332 msleep_interruptible(state->close_delay); 1340 msleep_interruptible(port->close_delay);
1333 } else if (!uart_console(port)) { 1341 } else if (!uart_console(uport)) {
1334 uart_change_pm(state, 3); 1342 uart_change_pm(state, 3);
1335 } 1343 }
1336 1344
1337 /* 1345 /*
1338 * Wake up anyone trying to open this port. 1346 * Wake up anyone trying to open this port.
1339 */ 1347 */
1340 state->info.flags &= ~UIF_NORMAL_ACTIVE; 1348 clear_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);
1341 wake_up_interruptible(&state->info.port.open_wait); 1349 wake_up_interruptible(&port->open_wait);
1342 1350
1343 done: 1351done:
1344 mutex_unlock(&state->mutex); 1352 mutex_unlock(&port->mutex);
1345} 1353}
1346 1354
1347static void uart_wait_until_sent(struct tty_struct *tty, int timeout) 1355static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
1348{ 1356{
1349 struct uart_state *state = tty->driver_data; 1357 struct uart_state *state = tty->driver_data;
1350 struct uart_port *port = state->port; 1358 struct uart_port *port = state->uart_port;
1351 unsigned long char_time, expire; 1359 unsigned long char_time, expire;
1352 1360
1353 if (port->type == PORT_UNKNOWN || port->fifosize == 0) 1361 if (port->type == PORT_UNKNOWN || port->fifosize == 0)
@@ -1412,22 +1420,22 @@ static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
1412static void uart_hangup(struct tty_struct *tty) 1420static void uart_hangup(struct tty_struct *tty)
1413{ 1421{
1414 struct uart_state *state = tty->driver_data; 1422 struct uart_state *state = tty->driver_data;
1415 struct uart_info *info = &state->info; 1423 struct tty_port *port = &state->port;
1416 1424
1417 BUG_ON(!kernel_locked()); 1425 BUG_ON(!kernel_locked());
1418 pr_debug("uart_hangup(%d)\n", state->port->line); 1426 pr_debug("uart_hangup(%d)\n", state->uart_port->line);
1419 1427
1420 mutex_lock(&state->mutex); 1428 mutex_lock(&port->mutex);
1421 if (info->flags & UIF_NORMAL_ACTIVE) { 1429 if (port->flags & ASYNC_NORMAL_ACTIVE) {
1422 uart_flush_buffer(tty); 1430 uart_flush_buffer(tty);
1423 uart_shutdown(state); 1431 uart_shutdown(state);
1424 state->count = 0; 1432 port->count = 0;
1425 info->flags &= ~UIF_NORMAL_ACTIVE; 1433 clear_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);
1426 info->port.tty = NULL; 1434 tty_port_tty_set(port, NULL);
1427 wake_up_interruptible(&info->port.open_wait); 1435 wake_up_interruptible(&port->open_wait);
1428 wake_up_interruptible(&info->delta_msr_wait); 1436 wake_up_interruptible(&port->delta_msr_wait);
1429 } 1437 }
1430 mutex_unlock(&state->mutex); 1438 mutex_unlock(&port->mutex);
1431} 1439}
1432 1440
1433/* 1441/*
@@ -1438,8 +1446,8 @@ static void uart_hangup(struct tty_struct *tty)
1438 */ 1446 */
1439static void uart_update_termios(struct uart_state *state) 1447static void uart_update_termios(struct uart_state *state)
1440{ 1448{
1441 struct tty_struct *tty = state->info.port.tty; 1449 struct tty_struct *tty = state->port.tty;
1442 struct uart_port *port = state->port; 1450 struct uart_port *port = state->uart_port;
1443 1451
1444 if (uart_console(port) && port->cons->cflag) { 1452 if (uart_console(port) && port->cons->cflag) {
1445 tty->termios->c_cflag = port->cons->cflag; 1453 tty->termios->c_cflag = port->cons->cflag;
@@ -1473,27 +1481,27 @@ static int
1473uart_block_til_ready(struct file *filp, struct uart_state *state) 1481uart_block_til_ready(struct file *filp, struct uart_state *state)
1474{ 1482{
1475 DECLARE_WAITQUEUE(wait, current); 1483 DECLARE_WAITQUEUE(wait, current);
1476 struct uart_info *info = &state->info; 1484 struct uart_port *uport = state->uart_port;
1477 struct uart_port *port = state->port; 1485 struct tty_port *port = &state->port;
1478 unsigned int mctrl; 1486 unsigned int mctrl;
1479 1487
1480 info->port.blocked_open++; 1488 port->blocked_open++;
1481 state->count--; 1489 port->count--;
1482 1490
1483 add_wait_queue(&info->port.open_wait, &wait); 1491 add_wait_queue(&port->open_wait, &wait);
1484 while (1) { 1492 while (1) {
1485 set_current_state(TASK_INTERRUPTIBLE); 1493 set_current_state(TASK_INTERRUPTIBLE);
1486 1494
1487 /* 1495 /*
1488 * If we have been hung up, tell userspace/restart open. 1496 * If we have been hung up, tell userspace/restart open.
1489 */ 1497 */
1490 if (tty_hung_up_p(filp) || info->port.tty == NULL) 1498 if (tty_hung_up_p(filp) || port->tty == NULL)
1491 break; 1499 break;
1492 1500
1493 /* 1501 /*
1494 * If the port has been closed, tell userspace/restart open. 1502 * If the port has been closed, tell userspace/restart open.
1495 */ 1503 */
1496 if (!(info->flags & UIF_INITIALIZED)) 1504 if (!(port->flags & ASYNC_INITIALIZED))
1497 break; 1505 break;
1498 1506
1499 /* 1507 /*
@@ -1506,8 +1514,8 @@ uart_block_til_ready(struct file *filp, struct uart_state *state)
1506 * have set TTY_IO_ERROR for a non-existant port. 1514 * have set TTY_IO_ERROR for a non-existant port.
1507 */ 1515 */
1508 if ((filp->f_flags & O_NONBLOCK) || 1516 if ((filp->f_flags & O_NONBLOCK) ||
1509 (info->port.tty->termios->c_cflag & CLOCAL) || 1517 (port->tty->termios->c_cflag & CLOCAL) ||
1510 (info->port.tty->flags & (1 << TTY_IO_ERROR))) 1518 (port->tty->flags & (1 << TTY_IO_ERROR)))
1511 break; 1519 break;
1512 1520
1513 /* 1521 /*
@@ -1515,37 +1523,37 @@ uart_block_til_ready(struct file *filp, struct uart_state *state)
1515 * not set RTS here - we want to make sure we catch 1523 * not set RTS here - we want to make sure we catch
1516 * the data from the modem. 1524 * the data from the modem.
1517 */ 1525 */
1518 if (info->port.tty->termios->c_cflag & CBAUD) 1526 if (port->tty->termios->c_cflag & CBAUD)
1519 uart_set_mctrl(port, TIOCM_DTR); 1527 uart_set_mctrl(uport, TIOCM_DTR);
1520 1528
1521 /* 1529 /*
1522 * and wait for the carrier to indicate that the 1530 * and wait for the carrier to indicate that the
1523 * modem is ready for us. 1531 * modem is ready for us.
1524 */ 1532 */
1525 spin_lock_irq(&port->lock); 1533 spin_lock_irq(&uport->lock);
1526 port->ops->enable_ms(port); 1534 uport->ops->enable_ms(uport);
1527 mctrl = port->ops->get_mctrl(port); 1535 mctrl = uport->ops->get_mctrl(uport);
1528 spin_unlock_irq(&port->lock); 1536 spin_unlock_irq(&uport->lock);
1529 if (mctrl & TIOCM_CAR) 1537 if (mctrl & TIOCM_CAR)
1530 break; 1538 break;
1531 1539
1532 mutex_unlock(&state->mutex); 1540 mutex_unlock(&port->mutex);
1533 schedule(); 1541 schedule();
1534 mutex_lock(&state->mutex); 1542 mutex_lock(&port->mutex);
1535 1543
1536 if (signal_pending(current)) 1544 if (signal_pending(current))
1537 break; 1545 break;
1538 } 1546 }
1539 set_current_state(TASK_RUNNING); 1547 set_current_state(TASK_RUNNING);
1540 remove_wait_queue(&info->port.open_wait, &wait); 1548 remove_wait_queue(&port->open_wait, &wait);
1541 1549
1542 state->count++; 1550 port->count++;
1543 info->port.blocked_open--; 1551 port->blocked_open--;
1544 1552
1545 if (signal_pending(current)) 1553 if (signal_pending(current))
1546 return -ERESTARTSYS; 1554 return -ERESTARTSYS;
1547 1555
1548 if (!info->port.tty || tty_hung_up_p(filp)) 1556 if (!port->tty || tty_hung_up_p(filp))
1549 return -EAGAIN; 1557 return -EAGAIN;
1550 1558
1551 return 0; 1559 return 0;
@@ -1554,24 +1562,26 @@ uart_block_til_ready(struct file *filp, struct uart_state *state)
1554static struct uart_state *uart_get(struct uart_driver *drv, int line) 1562static struct uart_state *uart_get(struct uart_driver *drv, int line)
1555{ 1563{
1556 struct uart_state *state; 1564 struct uart_state *state;
1565 struct tty_port *port;
1557 int ret = 0; 1566 int ret = 0;
1558 1567
1559 state = drv->state + line; 1568 state = drv->state + line;
1560 if (mutex_lock_interruptible(&state->mutex)) { 1569 port = &state->port;
1570 if (mutex_lock_interruptible(&port->mutex)) {
1561 ret = -ERESTARTSYS; 1571 ret = -ERESTARTSYS;
1562 goto err; 1572 goto err;
1563 } 1573 }
1564 1574
1565 state->count++; 1575 port->count++;
1566 if (!state->port || state->port->flags & UPF_DEAD) { 1576 if (!state->uart_port || state->uart_port->flags & UPF_DEAD) {
1567 ret = -ENXIO; 1577 ret = -ENXIO;
1568 goto err_unlock; 1578 goto err_unlock;
1569 } 1579 }
1570 return state; 1580 return state;
1571 1581
1572 err_unlock: 1582 err_unlock:
1573 state->count--; 1583 port->count--;
1574 mutex_unlock(&state->mutex); 1584 mutex_unlock(&port->mutex);
1575 err: 1585 err:
1576 return ERR_PTR(ret); 1586 return ERR_PTR(ret);
1577} 1587}
@@ -1590,6 +1600,7 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
1590{ 1600{
1591 struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state; 1601 struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state;
1592 struct uart_state *state; 1602 struct uart_state *state;
1603 struct tty_port *port;
1593 int retval, line = tty->index; 1604 int retval, line = tty->index;
1594 1605
1595 BUG_ON(!kernel_locked()); 1606 BUG_ON(!kernel_locked());
@@ -1606,16 +1617,18 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
1606 1617
1607 /* 1618 /*
1608 * We take the semaphore inside uart_get to guarantee that we won't 1619 * We take the semaphore inside uart_get to guarantee that we won't
1609 * be re-entered while allocating the info structure, or while we 1620 * be re-entered while allocating the state structure, or while we
1610 * request any IRQs that the driver may need. This also has the nice 1621 * request any IRQs that the driver may need. This also has the nice
1611 * side-effect that it delays the action of uart_hangup, so we can 1622 * side-effect that it delays the action of uart_hangup, so we can
1612 * guarantee that info->port.tty will always contain something reasonable. 1623 * guarantee that state->port.tty will always contain something
1624 * reasonable.
1613 */ 1625 */
1614 state = uart_get(drv, line); 1626 state = uart_get(drv, line);
1615 if (IS_ERR(state)) { 1627 if (IS_ERR(state)) {
1616 retval = PTR_ERR(state); 1628 retval = PTR_ERR(state);
1617 goto fail; 1629 goto fail;
1618 } 1630 }
1631 port = &state->port;
1619 1632
1620 /* 1633 /*
1621 * Once we set tty->driver_data here, we are guaranteed that 1634 * Once we set tty->driver_data here, we are guaranteed that
@@ -1623,25 +1636,25 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
1623 * Any failures from here onwards should not touch the count. 1636 * Any failures from here onwards should not touch the count.
1624 */ 1637 */
1625 tty->driver_data = state; 1638 tty->driver_data = state;
1626 state->port->info = &state->info; 1639 state->uart_port->state = state;
1627 tty->low_latency = (state->port->flags & UPF_LOW_LATENCY) ? 1 : 0; 1640 tty->low_latency = (state->uart_port->flags & UPF_LOW_LATENCY) ? 1 : 0;
1628 tty->alt_speed = 0; 1641 tty->alt_speed = 0;
1629 state->info.port.tty = tty; 1642 tty_port_tty_set(port, tty);
1630 1643
1631 /* 1644 /*
1632 * If the port is in the middle of closing, bail out now. 1645 * If the port is in the middle of closing, bail out now.
1633 */ 1646 */
1634 if (tty_hung_up_p(filp)) { 1647 if (tty_hung_up_p(filp)) {
1635 retval = -EAGAIN; 1648 retval = -EAGAIN;
1636 state->count--; 1649 port->count--;
1637 mutex_unlock(&state->mutex); 1650 mutex_unlock(&port->mutex);
1638 goto fail; 1651 goto fail;
1639 } 1652 }
1640 1653
1641 /* 1654 /*
1642 * Make sure the device is in D0 state. 1655 * Make sure the device is in D0 state.
1643 */ 1656 */
1644 if (state->count == 1) 1657 if (port->count == 1)
1645 uart_change_pm(state, 0); 1658 uart_change_pm(state, 0);
1646 1659
1647 /* 1660 /*
@@ -1654,18 +1667,18 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
1654 */ 1667 */
1655 if (retval == 0) 1668 if (retval == 0)
1656 retval = uart_block_til_ready(filp, state); 1669 retval = uart_block_til_ready(filp, state);
1657 mutex_unlock(&state->mutex); 1670 mutex_unlock(&port->mutex);
1658 1671
1659 /* 1672 /*
1660 * If this is the first open to succeed, adjust things to suit. 1673 * If this is the first open to succeed, adjust things to suit.
1661 */ 1674 */
1662 if (retval == 0 && !(state->info.flags & UIF_NORMAL_ACTIVE)) { 1675 if (retval == 0 && !(port->flags & ASYNC_NORMAL_ACTIVE)) {
1663 state->info.flags |= UIF_NORMAL_ACTIVE; 1676 set_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);
1664 1677
1665 uart_update_termios(state); 1678 uart_update_termios(state);
1666 } 1679 }
1667 1680
1668 fail: 1681fail:
1669 return retval; 1682 return retval;
1670} 1683}
1671 1684
@@ -1687,57 +1700,58 @@ static const char *uart_type(struct uart_port *port)
1687static void uart_line_info(struct seq_file *m, struct uart_driver *drv, int i) 1700static void uart_line_info(struct seq_file *m, struct uart_driver *drv, int i)
1688{ 1701{
1689 struct uart_state *state = drv->state + i; 1702 struct uart_state *state = drv->state + i;
1703 struct tty_port *port = &state->port;
1690 int pm_state; 1704 int pm_state;
1691 struct uart_port *port = state->port; 1705 struct uart_port *uport = state->uart_port;
1692 char stat_buf[32]; 1706 char stat_buf[32];
1693 unsigned int status; 1707 unsigned int status;
1694 int mmio; 1708 int mmio;
1695 1709
1696 if (!port) 1710 if (!uport)
1697 return; 1711 return;
1698 1712
1699 mmio = port->iotype >= UPIO_MEM; 1713 mmio = uport->iotype >= UPIO_MEM;
1700 seq_printf(m, "%d: uart:%s %s%08llX irq:%d", 1714 seq_printf(m, "%d: uart:%s %s%08llX irq:%d",
1701 port->line, uart_type(port), 1715 uport->line, uart_type(uport),
1702 mmio ? "mmio:0x" : "port:", 1716 mmio ? "mmio:0x" : "port:",
1703 mmio ? (unsigned long long)port->mapbase 1717 mmio ? (unsigned long long)uport->mapbase
1704 : (unsigned long long) port->iobase, 1718 : (unsigned long long)uport->iobase,
1705 port->irq); 1719 uport->irq);
1706 1720
1707 if (port->type == PORT_UNKNOWN) { 1721 if (uport->type == PORT_UNKNOWN) {
1708 seq_putc(m, '\n'); 1722 seq_putc(m, '\n');
1709 return; 1723 return;
1710 } 1724 }
1711 1725
1712 if (capable(CAP_SYS_ADMIN)) { 1726 if (capable(CAP_SYS_ADMIN)) {
1713 mutex_lock(&state->mutex); 1727 mutex_lock(&port->mutex);
1714 pm_state = state->pm_state; 1728 pm_state = state->pm_state;
1715 if (pm_state) 1729 if (pm_state)
1716 uart_change_pm(state, 0); 1730 uart_change_pm(state, 0);
1717 spin_lock_irq(&port->lock); 1731 spin_lock_irq(&uport->lock);
1718 status = port->ops->get_mctrl(port); 1732 status = uport->ops->get_mctrl(uport);
1719 spin_unlock_irq(&port->lock); 1733 spin_unlock_irq(&uport->lock);
1720 if (pm_state) 1734 if (pm_state)
1721 uart_change_pm(state, pm_state); 1735 uart_change_pm(state, pm_state);
1722 mutex_unlock(&state->mutex); 1736 mutex_unlock(&port->mutex);
1723 1737
1724 seq_printf(m, " tx:%d rx:%d", 1738 seq_printf(m, " tx:%d rx:%d",
1725 port->icount.tx, port->icount.rx); 1739 uport->icount.tx, uport->icount.rx);
1726 if (port->icount.frame) 1740 if (uport->icount.frame)
1727 seq_printf(m, " fe:%d", 1741 seq_printf(m, " fe:%d",
1728 port->icount.frame); 1742 uport->icount.frame);
1729 if (port->icount.parity) 1743 if (uport->icount.parity)
1730 seq_printf(m, " pe:%d", 1744 seq_printf(m, " pe:%d",
1731 port->icount.parity); 1745 uport->icount.parity);
1732 if (port->icount.brk) 1746 if (uport->icount.brk)
1733 seq_printf(m, " brk:%d", 1747 seq_printf(m, " brk:%d",
1734 port->icount.brk); 1748 uport->icount.brk);
1735 if (port->icount.overrun) 1749 if (uport->icount.overrun)
1736 seq_printf(m, " oe:%d", 1750 seq_printf(m, " oe:%d",
1737 port->icount.overrun); 1751 uport->icount.overrun);
1738 1752
1739#define INFOBIT(bit, str) \ 1753#define INFOBIT(bit, str) \
1740 if (port->mctrl & (bit)) \ 1754 if (uport->mctrl & (bit)) \
1741 strncat(stat_buf, (str), sizeof(stat_buf) - \ 1755 strncat(stat_buf, (str), sizeof(stat_buf) - \
1742 strlen(stat_buf) - 2) 1756 strlen(stat_buf) - 2)
1743#define STATBIT(bit, str) \ 1757#define STATBIT(bit, str) \
@@ -1958,7 +1972,7 @@ EXPORT_SYMBOL_GPL(uart_set_options);
1958 1972
1959static void uart_change_pm(struct uart_state *state, int pm_state) 1973static void uart_change_pm(struct uart_state *state, int pm_state)
1960{ 1974{
1961 struct uart_port *port = state->port; 1975 struct uart_port *port = state->uart_port;
1962 1976
1963 if (state->pm_state != pm_state) { 1977 if (state->pm_state != pm_state) {
1964 if (port->ops->pm) 1978 if (port->ops->pm)
@@ -1982,132 +1996,138 @@ static int serial_match_port(struct device *dev, void *data)
1982 return dev->devt == devt; /* Actually, only one tty per port */ 1996 return dev->devt == devt; /* Actually, only one tty per port */
1983} 1997}
1984 1998
1985int uart_suspend_port(struct uart_driver *drv, struct uart_port *port) 1999int uart_suspend_port(struct uart_driver *drv, struct uart_port *uport)
1986{ 2000{
1987 struct uart_state *state = drv->state + port->line; 2001 struct uart_state *state = drv->state + uport->line;
2002 struct tty_port *port = &state->port;
1988 struct device *tty_dev; 2003 struct device *tty_dev;
1989 struct uart_match match = {port, drv}; 2004 struct uart_match match = {uport, drv};
1990 2005
1991 mutex_lock(&state->mutex); 2006 mutex_lock(&port->mutex);
1992 2007
1993 if (!console_suspend_enabled && uart_console(port)) { 2008 if (!console_suspend_enabled && uart_console(uport)) {
1994 /* we're going to avoid suspending serial console */ 2009 /* we're going to avoid suspending serial console */
1995 mutex_unlock(&state->mutex); 2010 mutex_unlock(&port->mutex);
1996 return 0; 2011 return 0;
1997 } 2012 }
1998 2013
1999 tty_dev = device_find_child(port->dev, &match, serial_match_port); 2014 tty_dev = device_find_child(uport->dev, &match, serial_match_port);
2000 if (device_may_wakeup(tty_dev)) { 2015 if (device_may_wakeup(tty_dev)) {
2001 enable_irq_wake(port->irq); 2016 enable_irq_wake(uport->irq);
2002 put_device(tty_dev); 2017 put_device(tty_dev);
2003 mutex_unlock(&state->mutex); 2018 mutex_unlock(&port->mutex);
2004 return 0; 2019 return 0;
2005 } 2020 }
2006 port->suspended = 1; 2021 uport->suspended = 1;
2007 2022
2008 if (state->info.flags & UIF_INITIALIZED) { 2023 if (port->flags & ASYNC_INITIALIZED) {
2009 const struct uart_ops *ops = port->ops; 2024 const struct uart_ops *ops = uport->ops;
2010 int tries; 2025 int tries;
2011 2026
2012 state->info.flags = (state->info.flags & ~UIF_INITIALIZED) 2027 set_bit(ASYNCB_SUSPENDED, &port->flags);
2013 | UIF_SUSPENDED; 2028 clear_bit(ASYNCB_INITIALIZED, &port->flags);
2014 2029
2015 spin_lock_irq(&port->lock); 2030 spin_lock_irq(&uport->lock);
2016 ops->stop_tx(port); 2031 ops->stop_tx(uport);
2017 ops->set_mctrl(port, 0); 2032 ops->set_mctrl(uport, 0);
2018 ops->stop_rx(port); 2033 ops->stop_rx(uport);
2019 spin_unlock_irq(&port->lock); 2034 spin_unlock_irq(&uport->lock);
2020 2035
2021 /* 2036 /*
2022 * Wait for the transmitter to empty. 2037 * Wait for the transmitter to empty.
2023 */ 2038 */
2024 for (tries = 3; !ops->tx_empty(port) && tries; tries--) 2039 for (tries = 3; !ops->tx_empty(uport) && tries; tries--)
2025 msleep(10); 2040 msleep(10);
2026 if (!tries) 2041 if (!tries)
2027 printk(KERN_ERR "%s%s%s%d: Unable to drain " 2042 printk(KERN_ERR "%s%s%s%d: Unable to drain "
2028 "transmitter\n", 2043 "transmitter\n",
2029 port->dev ? dev_name(port->dev) : "", 2044 uport->dev ? dev_name(uport->dev) : "",
2030 port->dev ? ": " : "", 2045 uport->dev ? ": " : "",
2031 drv->dev_name, 2046 drv->dev_name,
2032 drv->tty_driver->name_base + port->line); 2047 drv->tty_driver->name_base + uport->line);
2033 2048
2034 ops->shutdown(port); 2049 ops->shutdown(uport);
2035 } 2050 }
2036 2051
2037 /* 2052 /*
2038 * Disable the console device before suspending. 2053 * Disable the console device before suspending.
2039 */ 2054 */
2040 if (uart_console(port)) 2055 if (uart_console(uport))
2041 console_stop(port->cons); 2056 console_stop(uport->cons);
2042 2057
2043 uart_change_pm(state, 3); 2058 uart_change_pm(state, 3);
2044 2059
2045 mutex_unlock(&state->mutex); 2060 mutex_unlock(&port->mutex);
2046 2061
2047 return 0; 2062 return 0;
2048} 2063}
2049 2064
2050int uart_resume_port(struct uart_driver *drv, struct uart_port *port) 2065int uart_resume_port(struct uart_driver *drv, struct uart_port *uport)
2051{ 2066{
2052 struct uart_state *state = drv->state + port->line; 2067 struct uart_state *state = drv->state + uport->line;
2068 struct tty_port *port = &state->port;
2053 struct device *tty_dev; 2069 struct device *tty_dev;
2054 struct uart_match match = {port, drv}; 2070 struct uart_match match = {uport, drv};
2071 struct ktermios termios;
2055 2072
2056 mutex_lock(&state->mutex); 2073 mutex_lock(&port->mutex);
2057 2074
2058 if (!console_suspend_enabled && uart_console(port)) { 2075 if (!console_suspend_enabled && uart_console(uport)) {
2059 /* no need to resume serial console, it wasn't suspended */ 2076 /* no need to resume serial console, it wasn't suspended */
2060 mutex_unlock(&state->mutex); 2077 /*
2078 * First try to use the console cflag setting.
2079 */
2080 memset(&termios, 0, sizeof(struct ktermios));
2081 termios.c_cflag = uport->cons->cflag;
2082 /*
2083 * If that's unset, use the tty termios setting.
2084 */
2085 if (termios.c_cflag == 0)
2086 termios = *state->port.tty->termios;
2087 else {
2088 termios.c_ispeed = termios.c_ospeed =
2089 tty_termios_input_baud_rate(&termios);
2090 termios.c_ispeed = termios.c_ospeed =
2091 tty_termios_baud_rate(&termios);
2092 }
2093 uport->ops->set_termios(uport, &termios, NULL);
2094 mutex_unlock(&port->mutex);
2061 return 0; 2095 return 0;
2062 } 2096 }
2063 2097
2064 tty_dev = device_find_child(port->dev, &match, serial_match_port); 2098 tty_dev = device_find_child(uport->dev, &match, serial_match_port);
2065 if (!port->suspended && device_may_wakeup(tty_dev)) { 2099 if (!uport->suspended && device_may_wakeup(tty_dev)) {
2066 disable_irq_wake(port->irq); 2100 disable_irq_wake(uport->irq);
2067 mutex_unlock(&state->mutex); 2101 mutex_unlock(&port->mutex);
2068 return 0; 2102 return 0;
2069 } 2103 }
2070 port->suspended = 0; 2104 uport->suspended = 0;
2071 2105
2072 /* 2106 /*
2073 * Re-enable the console device after suspending. 2107 * Re-enable the console device after suspending.
2074 */ 2108 */
2075 if (uart_console(port)) { 2109 if (uart_console(uport)) {
2076 struct ktermios termios;
2077
2078 /*
2079 * First try to use the console cflag setting.
2080 */
2081 memset(&termios, 0, sizeof(struct ktermios));
2082 termios.c_cflag = port->cons->cflag;
2083
2084 /*
2085 * If that's unset, use the tty termios setting.
2086 */
2087 if (state->info.port.tty && termios.c_cflag == 0)
2088 termios = *state->info.port.tty->termios;
2089
2090 uart_change_pm(state, 0); 2110 uart_change_pm(state, 0);
2091 port->ops->set_termios(port, &termios, NULL); 2111 uport->ops->set_termios(uport, &termios, NULL);
2092 console_start(port->cons); 2112 console_start(uport->cons);
2093 } 2113 }
2094 2114
2095 if (state->info.flags & UIF_SUSPENDED) { 2115 if (port->flags & ASYNC_SUSPENDED) {
2096 const struct uart_ops *ops = port->ops; 2116 const struct uart_ops *ops = uport->ops;
2097 int ret; 2117 int ret;
2098 2118
2099 uart_change_pm(state, 0); 2119 uart_change_pm(state, 0);
2100 spin_lock_irq(&port->lock); 2120 spin_lock_irq(&uport->lock);
2101 ops->set_mctrl(port, 0); 2121 ops->set_mctrl(uport, 0);
2102 spin_unlock_irq(&port->lock); 2122 spin_unlock_irq(&uport->lock);
2103 ret = ops->startup(port); 2123 ret = ops->startup(uport);
2104 if (ret == 0) { 2124 if (ret == 0) {
2105 uart_change_speed(state, NULL); 2125 uart_change_speed(state, NULL);
2106 spin_lock_irq(&port->lock); 2126 spin_lock_irq(&uport->lock);
2107 ops->set_mctrl(port, port->mctrl); 2127 ops->set_mctrl(uport, uport->mctrl);
2108 ops->start_tx(port); 2128 ops->start_tx(uport);
2109 spin_unlock_irq(&port->lock); 2129 spin_unlock_irq(&uport->lock);
2110 state->info.flags |= UIF_INITIALIZED; 2130 set_bit(ASYNCB_INITIALIZED, &port->flags);
2111 } else { 2131 } else {
2112 /* 2132 /*
2113 * Failed to resume - maybe hardware went away? 2133 * Failed to resume - maybe hardware went away?
@@ -2117,10 +2137,10 @@ int uart_resume_port(struct uart_driver *drv, struct uart_port *port)
2117 uart_shutdown(state); 2137 uart_shutdown(state);
2118 } 2138 }
2119 2139
2120 state->info.flags &= ~UIF_SUSPENDED; 2140 clear_bit(ASYNCB_SUSPENDED, &port->flags);
2121 } 2141 }
2122 2142
2123 mutex_unlock(&state->mutex); 2143 mutex_unlock(&port->mutex);
2124 2144
2125 return 0; 2145 return 0;
2126} 2146}
@@ -2232,10 +2252,10 @@ static int uart_poll_init(struct tty_driver *driver, int line, char *options)
2232 int parity = 'n'; 2252 int parity = 'n';
2233 int flow = 'n'; 2253 int flow = 'n';
2234 2254
2235 if (!state || !state->port) 2255 if (!state || !state->uart_port)
2236 return -1; 2256 return -1;
2237 2257
2238 port = state->port; 2258 port = state->uart_port;
2239 if (!(port->ops->poll_get_char && port->ops->poll_put_char)) 2259 if (!(port->ops->poll_get_char && port->ops->poll_put_char))
2240 return -1; 2260 return -1;
2241 2261
@@ -2253,10 +2273,10 @@ static int uart_poll_get_char(struct tty_driver *driver, int line)
2253 struct uart_state *state = drv->state + line; 2273 struct uart_state *state = drv->state + line;
2254 struct uart_port *port; 2274 struct uart_port *port;
2255 2275
2256 if (!state || !state->port) 2276 if (!state || !state->uart_port)
2257 return -1; 2277 return -1;
2258 2278
2259 port = state->port; 2279 port = state->uart_port;
2260 return port->ops->poll_get_char(port); 2280 return port->ops->poll_get_char(port);
2261} 2281}
2262 2282
@@ -2266,10 +2286,10 @@ static void uart_poll_put_char(struct tty_driver *driver, int line, char ch)
2266 struct uart_state *state = drv->state + line; 2286 struct uart_state *state = drv->state + line;
2267 struct uart_port *port; 2287 struct uart_port *port;
2268 2288
2269 if (!state || !state->port) 2289 if (!state || !state->uart_port)
2270 return; 2290 return;
2271 2291
2272 port = state->port; 2292 port = state->uart_port;
2273 port->ops->poll_put_char(port, ch); 2293 port->ops->poll_put_char(port, ch);
2274} 2294}
2275#endif 2295#endif
@@ -2360,14 +2380,12 @@ int uart_register_driver(struct uart_driver *drv)
2360 */ 2380 */
2361 for (i = 0; i < drv->nr; i++) { 2381 for (i = 0; i < drv->nr; i++) {
2362 struct uart_state *state = drv->state + i; 2382 struct uart_state *state = drv->state + i;
2383 struct tty_port *port = &state->port;
2363 2384
2364 state->close_delay = 500; /* .5 seconds */ 2385 tty_port_init(port);
2365 state->closing_wait = 30000; /* 30 seconds */ 2386 port->close_delay = 500; /* .5 seconds */
2366 mutex_init(&state->mutex); 2387 port->closing_wait = 30000; /* 30 seconds */
2367 2388 tasklet_init(&state->tlet, uart_tasklet_action,
2368 tty_port_init(&state->info.port);
2369 init_waitqueue_head(&state->info.delta_msr_wait);
2370 tasklet_init(&state->info.tlet, uart_tasklet_action,
2371 (unsigned long)state); 2389 (unsigned long)state);
2372 } 2390 }
2373 2391
@@ -2415,62 +2433,64 @@ struct tty_driver *uart_console_device(struct console *co, int *index)
2415 * level uart drivers to expand uart_port, rather than having yet 2433 * level uart drivers to expand uart_port, rather than having yet
2416 * more levels of structures. 2434 * more levels of structures.
2417 */ 2435 */
2418int uart_add_one_port(struct uart_driver *drv, struct uart_port *port) 2436int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
2419{ 2437{
2420 struct uart_state *state; 2438 struct uart_state *state;
2439 struct tty_port *port;
2421 int ret = 0; 2440 int ret = 0;
2422 struct device *tty_dev; 2441 struct device *tty_dev;
2423 2442
2424 BUG_ON(in_interrupt()); 2443 BUG_ON(in_interrupt());
2425 2444
2426 if (port->line >= drv->nr) 2445 if (uport->line >= drv->nr)
2427 return -EINVAL; 2446 return -EINVAL;
2428 2447
2429 state = drv->state + port->line; 2448 state = drv->state + uport->line;
2449 port = &state->port;
2430 2450
2431 mutex_lock(&port_mutex); 2451 mutex_lock(&port_mutex);
2432 mutex_lock(&state->mutex); 2452 mutex_lock(&port->mutex);
2433 if (state->port) { 2453 if (state->uart_port) {
2434 ret = -EINVAL; 2454 ret = -EINVAL;
2435 goto out; 2455 goto out;
2436 } 2456 }
2437 2457
2438 state->port = port; 2458 state->uart_port = uport;
2439 state->pm_state = -1; 2459 state->pm_state = -1;
2440 2460
2441 port->cons = drv->cons; 2461 uport->cons = drv->cons;
2442 port->info = &state->info; 2462 uport->state = state;
2443 2463
2444 /* 2464 /*
2445 * If this port is a console, then the spinlock is already 2465 * If this port is a console, then the spinlock is already
2446 * initialised. 2466 * initialised.
2447 */ 2467 */
2448 if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) { 2468 if (!(uart_console(uport) && (uport->cons->flags & CON_ENABLED))) {
2449 spin_lock_init(&port->lock); 2469 spin_lock_init(&uport->lock);
2450 lockdep_set_class(&port->lock, &port_lock_key); 2470 lockdep_set_class(&uport->lock, &port_lock_key);
2451 } 2471 }
2452 2472
2453 uart_configure_port(drv, state, port); 2473 uart_configure_port(drv, state, uport);
2454 2474
2455 /* 2475 /*
2456 * Register the port whether it's detected or not. This allows 2476 * Register the port whether it's detected or not. This allows
2457 * setserial to be used to alter this ports parameters. 2477 * setserial to be used to alter this ports parameters.
2458 */ 2478 */
2459 tty_dev = tty_register_device(drv->tty_driver, port->line, port->dev); 2479 tty_dev = tty_register_device(drv->tty_driver, uport->line, uport->dev);
2460 if (likely(!IS_ERR(tty_dev))) { 2480 if (likely(!IS_ERR(tty_dev))) {
2461 device_init_wakeup(tty_dev, 1); 2481 device_init_wakeup(tty_dev, 1);
2462 device_set_wakeup_enable(tty_dev, 0); 2482 device_set_wakeup_enable(tty_dev, 0);
2463 } else 2483 } else
2464 printk(KERN_ERR "Cannot register tty device on line %d\n", 2484 printk(KERN_ERR "Cannot register tty device on line %d\n",
2465 port->line); 2485 uport->line);
2466 2486
2467 /* 2487 /*
2468 * Ensure UPF_DEAD is not set. 2488 * Ensure UPF_DEAD is not set.
2469 */ 2489 */
2470 port->flags &= ~UPF_DEAD; 2490 uport->flags &= ~UPF_DEAD;
2471 2491
2472 out: 2492 out:
2473 mutex_unlock(&state->mutex); 2493 mutex_unlock(&port->mutex);
2474 mutex_unlock(&port_mutex); 2494 mutex_unlock(&port_mutex);
2475 2495
2476 return ret; 2496 return ret;
@@ -2485,16 +2505,16 @@ int uart_add_one_port(struct uart_driver *drv, struct uart_port *port)
2485 * core driver. No further calls will be made to the low-level code 2505 * core driver. No further calls will be made to the low-level code
2486 * for this port. 2506 * for this port.
2487 */ 2507 */
2488int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port) 2508int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
2489{ 2509{
2490 struct uart_state *state = drv->state + port->line; 2510 struct uart_state *state = drv->state + uport->line;
2491 struct uart_info *info; 2511 struct tty_port *port = &state->port;
2492 2512
2493 BUG_ON(in_interrupt()); 2513 BUG_ON(in_interrupt());
2494 2514
2495 if (state->port != port) 2515 if (state->uart_port != uport)
2496 printk(KERN_ALERT "Removing wrong port: %p != %p\n", 2516 printk(KERN_ALERT "Removing wrong port: %p != %p\n",
2497 state->port, port); 2517 state->uart_port, uport);
2498 2518
2499 mutex_lock(&port_mutex); 2519 mutex_lock(&port_mutex);
2500 2520
@@ -2502,37 +2522,35 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
2502 * Mark the port "dead" - this prevents any opens from 2522 * Mark the port "dead" - this prevents any opens from
2503 * succeeding while we shut down the port. 2523 * succeeding while we shut down the port.
2504 */ 2524 */
2505 mutex_lock(&state->mutex); 2525 mutex_lock(&port->mutex);
2506 port->flags |= UPF_DEAD; 2526 uport->flags |= UPF_DEAD;
2507 mutex_unlock(&state->mutex); 2527 mutex_unlock(&port->mutex);
2508 2528
2509 /* 2529 /*
2510 * Remove the devices from the tty layer 2530 * Remove the devices from the tty layer
2511 */ 2531 */
2512 tty_unregister_device(drv->tty_driver, port->line); 2532 tty_unregister_device(drv->tty_driver, uport->line);
2513 2533
2514 info = &state->info; 2534 if (port->tty)
2515 if (info && info->port.tty) 2535 tty_vhangup(port->tty);
2516 tty_vhangup(info->port.tty);
2517 2536
2518 /* 2537 /*
2519 * Free the port IO and memory resources, if any. 2538 * Free the port IO and memory resources, if any.
2520 */ 2539 */
2521 if (port->type != PORT_UNKNOWN) 2540 if (uport->type != PORT_UNKNOWN)
2522 port->ops->release_port(port); 2541 uport->ops->release_port(uport);
2523 2542
2524 /* 2543 /*
2525 * Indicate that there isn't a port here anymore. 2544 * Indicate that there isn't a port here anymore.
2526 */ 2545 */
2527 port->type = PORT_UNKNOWN; 2546 uport->type = PORT_UNKNOWN;
2528 2547
2529 /* 2548 /*
2530 * Kill the tasklet, and free resources. 2549 * Kill the tasklet, and free resources.
2531 */ 2550 */
2532 if (info) 2551 tasklet_kill(&state->tlet);
2533 tasklet_kill(&info->tlet);
2534 2552
2535 state->port = NULL; 2553 state->uart_port = NULL;
2536 mutex_unlock(&port_mutex); 2554 mutex_unlock(&port_mutex);
2537 2555
2538 return 0; 2556 return 0;
diff --git a/drivers/serial/serial_cs.c b/drivers/serial/serial_cs.c
index ed4648b556c7..a3bb49031a7f 100644
--- a/drivers/serial/serial_cs.c
+++ b/drivers/serial/serial_cs.c
@@ -884,6 +884,7 @@ static struct pcmcia_device_id serial_ids[] = {
884 PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0xa555, "SW_555_SER.cis"), /* Sierra Aircard 555 CDMA 1xrtt Modem -- pre update */ 884 PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0xa555, "SW_555_SER.cis"), /* Sierra Aircard 555 CDMA 1xrtt Modem -- pre update */
885 PCMCIA_DEVICE_CIS_MANF_CARD(0x013f, 0xa555, "SW_555_SER.cis"), /* Sierra Aircard 555 CDMA 1xrtt Modem -- post update */ 885 PCMCIA_DEVICE_CIS_MANF_CARD(0x013f, 0xa555, "SW_555_SER.cis"), /* Sierra Aircard 555 CDMA 1xrtt Modem -- post update */
886 PCMCIA_DEVICE_CIS_PROD_ID12("MultiTech", "PCMCIA 56K DataFax", 0x842047ee, 0xc2efcf03, "cis/MT5634ZLX.cis"), 886 PCMCIA_DEVICE_CIS_PROD_ID12("MultiTech", "PCMCIA 56K DataFax", 0x842047ee, 0xc2efcf03, "cis/MT5634ZLX.cis"),
887 PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-2", 0x96913a85, 0x27ab5437, "COMpad2.cis"),
887 PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "COMpad4.cis"), 888 PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "COMpad4.cis"),
888 PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "COMpad2.cis"), 889 PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "COMpad2.cis"),
889 PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "cis/RS-COM-2P.cis"), 890 PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "cis/RS-COM-2P.cis"),
diff --git a/drivers/serial/serial_ks8695.c b/drivers/serial/serial_ks8695.c
index 52db5cc3f900..2e71bbc04dac 100644
--- a/drivers/serial/serial_ks8695.c
+++ b/drivers/serial/serial_ks8695.c
@@ -154,7 +154,7 @@ static void ks8695uart_disable_ms(struct uart_port *port)
154static irqreturn_t ks8695uart_rx_chars(int irq, void *dev_id) 154static irqreturn_t ks8695uart_rx_chars(int irq, void *dev_id)
155{ 155{
156 struct uart_port *port = dev_id; 156 struct uart_port *port = dev_id;
157 struct tty_struct *tty = port->info->port.tty; 157 struct tty_struct *tty = port->state->port.tty;
158 unsigned int status, ch, lsr, flg, max_count = 256; 158 unsigned int status, ch, lsr, flg, max_count = 256;
159 159
160 status = UART_GET_LSR(port); /* clears pending LSR interrupts */ 160 status = UART_GET_LSR(port); /* clears pending LSR interrupts */
@@ -210,7 +210,7 @@ ignore_char:
210static irqreturn_t ks8695uart_tx_chars(int irq, void *dev_id) 210static irqreturn_t ks8695uart_tx_chars(int irq, void *dev_id)
211{ 211{
212 struct uart_port *port = dev_id; 212 struct uart_port *port = dev_id;
213 struct circ_buf *xmit = &port->info->xmit; 213 struct circ_buf *xmit = &port->state->xmit;
214 unsigned int count; 214 unsigned int count;
215 215
216 if (port->x_char) { 216 if (port->x_char) {
@@ -266,7 +266,7 @@ static irqreturn_t ks8695uart_modem_status(int irq, void *dev_id)
266 if (status & URMS_URTERI) 266 if (status & URMS_URTERI)
267 port->icount.rng++; 267 port->icount.rng++;
268 268
269 wake_up_interruptible(&port->info->delta_msr_wait); 269 wake_up_interruptible(&port->state->port.delta_msr_wait);
270 270
271 return IRQ_HANDLED; 271 return IRQ_HANDLED;
272} 272}
diff --git a/drivers/serial/serial_lh7a40x.c b/drivers/serial/serial_lh7a40x.c
index a7bf024a8286..ea744707c4d6 100644
--- a/drivers/serial/serial_lh7a40x.c
+++ b/drivers/serial/serial_lh7a40x.c
@@ -138,7 +138,7 @@ static void lh7a40xuart_enable_ms (struct uart_port* port)
138 138
139static void lh7a40xuart_rx_chars (struct uart_port* port) 139static void lh7a40xuart_rx_chars (struct uart_port* port)
140{ 140{
141 struct tty_struct* tty = port->info->port.tty; 141 struct tty_struct* tty = port->state->port.tty;
142 int cbRxMax = 256; /* (Gross) limit on receive */ 142 int cbRxMax = 256; /* (Gross) limit on receive */
143 unsigned int data; /* Received data and status */ 143 unsigned int data; /* Received data and status */
144 unsigned int flag; 144 unsigned int flag;
@@ -184,7 +184,7 @@ static void lh7a40xuart_rx_chars (struct uart_port* port)
184 184
185static void lh7a40xuart_tx_chars (struct uart_port* port) 185static void lh7a40xuart_tx_chars (struct uart_port* port)
186{ 186{
187 struct circ_buf* xmit = &port->info->xmit; 187 struct circ_buf* xmit = &port->state->xmit;
188 int cbTxMax = port->fifosize; 188 int cbTxMax = port->fifosize;
189 189
190 if (port->x_char) { 190 if (port->x_char) {
@@ -241,7 +241,7 @@ static void lh7a40xuart_modem_status (struct uart_port* port)
241 if (delta & CTS) 241 if (delta & CTS)
242 uart_handle_cts_change (port, status & CTS); 242 uart_handle_cts_change (port, status & CTS);
243 243
244 wake_up_interruptible (&port->info->delta_msr_wait); 244 wake_up_interruptible (&port->state->port.delta_msr_wait);
245} 245}
246 246
247static irqreturn_t lh7a40xuart_int (int irq, void* dev_id) 247static irqreturn_t lh7a40xuart_int (int irq, void* dev_id)
diff --git a/drivers/serial/serial_txx9.c b/drivers/serial/serial_txx9.c
index 54dd16d66a4b..0f7cf4c453e6 100644
--- a/drivers/serial/serial_txx9.c
+++ b/drivers/serial/serial_txx9.c
@@ -272,7 +272,7 @@ static void serial_txx9_initialize(struct uart_port *port)
272static inline void 272static inline void
273receive_chars(struct uart_txx9_port *up, unsigned int *status) 273receive_chars(struct uart_txx9_port *up, unsigned int *status)
274{ 274{
275 struct tty_struct *tty = up->port.info->port.tty; 275 struct tty_struct *tty = up->port.state->port.tty;
276 unsigned char ch; 276 unsigned char ch;
277 unsigned int disr = *status; 277 unsigned int disr = *status;
278 int max_count = 256; 278 int max_count = 256;
@@ -348,7 +348,7 @@ receive_chars(struct uart_txx9_port *up, unsigned int *status)
348 348
349static inline void transmit_chars(struct uart_txx9_port *up) 349static inline void transmit_chars(struct uart_txx9_port *up)
350{ 350{
351 struct circ_buf *xmit = &up->port.info->xmit; 351 struct circ_buf *xmit = &up->port.state->xmit;
352 int count; 352 int count;
353 353
354 if (up->port.x_char) { 354 if (up->port.x_char) {
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index 32dc2fc50e6b..85119fb7cb50 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -361,7 +361,7 @@ static inline int sci_rxroom(struct uart_port *port)
361 361
362static void sci_transmit_chars(struct uart_port *port) 362static void sci_transmit_chars(struct uart_port *port)
363{ 363{
364 struct circ_buf *xmit = &port->info->xmit; 364 struct circ_buf *xmit = &port->state->xmit;
365 unsigned int stopped = uart_tx_stopped(port); 365 unsigned int stopped = uart_tx_stopped(port);
366 unsigned short status; 366 unsigned short status;
367 unsigned short ctrl; 367 unsigned short ctrl;
@@ -426,7 +426,7 @@ static void sci_transmit_chars(struct uart_port *port)
426static inline void sci_receive_chars(struct uart_port *port) 426static inline void sci_receive_chars(struct uart_port *port)
427{ 427{
428 struct sci_port *sci_port = to_sci_port(port); 428 struct sci_port *sci_port = to_sci_port(port);
429 struct tty_struct *tty = port->info->port.tty; 429 struct tty_struct *tty = port->state->port.tty;
430 int i, count, copied = 0; 430 int i, count, copied = 0;
431 unsigned short status; 431 unsigned short status;
432 unsigned char flag; 432 unsigned char flag;
@@ -546,7 +546,7 @@ static inline int sci_handle_errors(struct uart_port *port)
546{ 546{
547 int copied = 0; 547 int copied = 0;
548 unsigned short status = sci_in(port, SCxSR); 548 unsigned short status = sci_in(port, SCxSR);
549 struct tty_struct *tty = port->info->port.tty; 549 struct tty_struct *tty = port->state->port.tty;
550 550
551 if (status & SCxSR_ORER(port)) { 551 if (status & SCxSR_ORER(port)) {
552 /* overrun error */ 552 /* overrun error */
@@ -600,7 +600,7 @@ static inline int sci_handle_errors(struct uart_port *port)
600 600
601static inline int sci_handle_fifo_overrun(struct uart_port *port) 601static inline int sci_handle_fifo_overrun(struct uart_port *port)
602{ 602{
603 struct tty_struct *tty = port->info->port.tty; 603 struct tty_struct *tty = port->state->port.tty;
604 int copied = 0; 604 int copied = 0;
605 605
606 if (port->type != PORT_SCIF) 606 if (port->type != PORT_SCIF)
@@ -623,7 +623,7 @@ static inline int sci_handle_breaks(struct uart_port *port)
623{ 623{
624 int copied = 0; 624 int copied = 0;
625 unsigned short status = sci_in(port, SCxSR); 625 unsigned short status = sci_in(port, SCxSR);
626 struct tty_struct *tty = port->info->port.tty; 626 struct tty_struct *tty = port->state->port.tty;
627 struct sci_port *s = to_sci_port(port); 627 struct sci_port *s = to_sci_port(port);
628 628
629 if (uart_handle_break(port)) 629 if (uart_handle_break(port))
diff --git a/drivers/serial/sn_console.c b/drivers/serial/sn_console.c
index d5276c012f78..9794e0cd3dcc 100644
--- a/drivers/serial/sn_console.c
+++ b/drivers/serial/sn_console.c
@@ -469,9 +469,9 @@ sn_receive_chars(struct sn_cons_port *port, unsigned long flags)
469 return; 469 return;
470 } 470 }
471 471
472 if (port->sc_port.info) { 472 if (port->sc_port.state) {
473 /* The serial_core stuffs are initilized, use them */ 473 /* The serial_core stuffs are initilized, use them */
474 tty = port->sc_port.info->port.tty; 474 tty = port->sc_port.state->port.tty;
475 } 475 }
476 else { 476 else {
477 /* Not registered yet - can't pass to tty layer. */ 477 /* Not registered yet - can't pass to tty layer. */
@@ -550,9 +550,9 @@ static void sn_transmit_chars(struct sn_cons_port *port, int raw)
550 550
551 BUG_ON(!port->sc_is_asynch); 551 BUG_ON(!port->sc_is_asynch);
552 552
553 if (port->sc_port.info) { 553 if (port->sc_port.state) {
554 /* We're initilized, using serial core infrastructure */ 554 /* We're initilized, using serial core infrastructure */
555 xmit = &port->sc_port.info->xmit; 555 xmit = &port->sc_port.state->xmit;
556 } else { 556 } else {
557 /* Probably sn_sal_switch_to_asynch has been run but serial core isn't 557 /* Probably sn_sal_switch_to_asynch has been run but serial core isn't
558 * initilized yet. Just return. Writes are going through 558 * initilized yet. Just return. Writes are going through
@@ -927,7 +927,7 @@ sn_sal_console_write(struct console *co, const char *s, unsigned count)
927 /* We can't look at the xmit buffer if we're not registered with serial core 927 /* We can't look at the xmit buffer if we're not registered with serial core
928 * yet. So only do the fancy recovery after registering 928 * yet. So only do the fancy recovery after registering
929 */ 929 */
930 if (!port->sc_port.info) { 930 if (!port->sc_port.state) {
931 /* Not yet registered with serial core - simple case */ 931 /* Not yet registered with serial core - simple case */
932 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count); 932 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
933 return; 933 return;
@@ -936,8 +936,8 @@ sn_sal_console_write(struct console *co, const char *s, unsigned count)
936 /* somebody really wants this output, might be an 936 /* somebody really wants this output, might be an
937 * oops, kdb, panic, etc. make sure they get it. */ 937 * oops, kdb, panic, etc. make sure they get it. */
938 if (spin_is_locked(&port->sc_port.lock)) { 938 if (spin_is_locked(&port->sc_port.lock)) {
939 int lhead = port->sc_port.info->xmit.head; 939 int lhead = port->sc_port.state->xmit.head;
940 int ltail = port->sc_port.info->xmit.tail; 940 int ltail = port->sc_port.state->xmit.tail;
941 int counter, got_lock = 0; 941 int counter, got_lock = 0;
942 942
943 /* 943 /*
@@ -962,13 +962,13 @@ sn_sal_console_write(struct console *co, const char *s, unsigned count)
962 break; 962 break;
963 } else { 963 } else {
964 /* still locked */ 964 /* still locked */
965 if ((lhead != port->sc_port.info->xmit.head) 965 if ((lhead != port->sc_port.state->xmit.head)
966 || (ltail != 966 || (ltail !=
967 port->sc_port.info->xmit.tail)) { 967 port->sc_port.state->xmit.tail)) {
968 lhead = 968 lhead =
969 port->sc_port.info->xmit.head; 969 port->sc_port.state->xmit.head;
970 ltail = 970 ltail =
971 port->sc_port.info->xmit.tail; 971 port->sc_port.state->xmit.tail;
972 counter = 0; 972 counter = 0;
973 } 973 }
974 } 974 }
diff --git a/drivers/serial/sunhv.c b/drivers/serial/sunhv.c
index 1df5325faab2..d548652dee50 100644
--- a/drivers/serial/sunhv.c
+++ b/drivers/serial/sunhv.c
@@ -184,8 +184,8 @@ static struct tty_struct *receive_chars(struct uart_port *port)
184{ 184{
185 struct tty_struct *tty = NULL; 185 struct tty_struct *tty = NULL;
186 186
187 if (port->info != NULL) /* Unopened serial console */ 187 if (port->state != NULL) /* Unopened serial console */
188 tty = port->info->port.tty; 188 tty = port->state->port.tty;
189 189
190 if (sunhv_ops->receive_chars(port, tty)) 190 if (sunhv_ops->receive_chars(port, tty))
191 sun_do_break(); 191 sun_do_break();
@@ -197,10 +197,10 @@ static void transmit_chars(struct uart_port *port)
197{ 197{
198 struct circ_buf *xmit; 198 struct circ_buf *xmit;
199 199
200 if (!port->info) 200 if (!port->state)
201 return; 201 return;
202 202
203 xmit = &port->info->xmit; 203 xmit = &port->state->xmit;
204 if (uart_circ_empty(xmit) || uart_tx_stopped(port)) 204 if (uart_circ_empty(xmit) || uart_tx_stopped(port))
205 return; 205 return;
206 206
diff --git a/drivers/serial/sunsab.c b/drivers/serial/sunsab.c
index 0355efe115d9..d1ad34128635 100644
--- a/drivers/serial/sunsab.c
+++ b/drivers/serial/sunsab.c
@@ -117,8 +117,8 @@ receive_chars(struct uart_sunsab_port *up,
117 int count = 0; 117 int count = 0;
118 int i; 118 int i;
119 119
120 if (up->port.info != NULL) /* Unopened serial console */ 120 if (up->port.state != NULL) /* Unopened serial console */
121 tty = up->port.info->port.tty; 121 tty = up->port.state->port.tty;
122 122
123 /* Read number of BYTES (Character + Status) available. */ 123 /* Read number of BYTES (Character + Status) available. */
124 if (stat->sreg.isr0 & SAB82532_ISR0_RPF) { 124 if (stat->sreg.isr0 & SAB82532_ISR0_RPF) {
@@ -229,7 +229,7 @@ static void sunsab_tx_idle(struct uart_sunsab_port *);
229static void transmit_chars(struct uart_sunsab_port *up, 229static void transmit_chars(struct uart_sunsab_port *up,
230 union sab82532_irq_status *stat) 230 union sab82532_irq_status *stat)
231{ 231{
232 struct circ_buf *xmit = &up->port.info->xmit; 232 struct circ_buf *xmit = &up->port.state->xmit;
233 int i; 233 int i;
234 234
235 if (stat->sreg.isr1 & SAB82532_ISR1_ALLS) { 235 if (stat->sreg.isr1 & SAB82532_ISR1_ALLS) {
@@ -297,7 +297,7 @@ static void check_status(struct uart_sunsab_port *up,
297 up->port.icount.dsr++; 297 up->port.icount.dsr++;
298 } 298 }
299 299
300 wake_up_interruptible(&up->port.info->delta_msr_wait); 300 wake_up_interruptible(&up->port.state->port.delta_msr_wait);
301} 301}
302 302
303static irqreturn_t sunsab_interrupt(int irq, void *dev_id) 303static irqreturn_t sunsab_interrupt(int irq, void *dev_id)
@@ -429,7 +429,7 @@ static void sunsab_tx_idle(struct uart_sunsab_port *up)
429static void sunsab_start_tx(struct uart_port *port) 429static void sunsab_start_tx(struct uart_port *port)
430{ 430{
431 struct uart_sunsab_port *up = (struct uart_sunsab_port *) port; 431 struct uart_sunsab_port *up = (struct uart_sunsab_port *) port;
432 struct circ_buf *xmit = &up->port.info->xmit; 432 struct circ_buf *xmit = &up->port.state->xmit;
433 int i; 433 int i;
434 434
435 up->interrupt_mask1 &= ~(SAB82532_IMR1_ALLS|SAB82532_IMR1_XPR); 435 up->interrupt_mask1 &= ~(SAB82532_IMR1_ALLS|SAB82532_IMR1_XPR);
diff --git a/drivers/serial/sunsu.c b/drivers/serial/sunsu.c
index 47c6837850b1..68d262b15749 100644
--- a/drivers/serial/sunsu.c
+++ b/drivers/serial/sunsu.c
@@ -311,7 +311,7 @@ static void sunsu_enable_ms(struct uart_port *port)
311static struct tty_struct * 311static struct tty_struct *
312receive_chars(struct uart_sunsu_port *up, unsigned char *status) 312receive_chars(struct uart_sunsu_port *up, unsigned char *status)
313{ 313{
314 struct tty_struct *tty = up->port.info->port.tty; 314 struct tty_struct *tty = up->port.state->port.tty;
315 unsigned char ch, flag; 315 unsigned char ch, flag;
316 int max_count = 256; 316 int max_count = 256;
317 int saw_console_brk = 0; 317 int saw_console_brk = 0;
@@ -389,7 +389,7 @@ receive_chars(struct uart_sunsu_port *up, unsigned char *status)
389 389
390static void transmit_chars(struct uart_sunsu_port *up) 390static void transmit_chars(struct uart_sunsu_port *up)
391{ 391{
392 struct circ_buf *xmit = &up->port.info->xmit; 392 struct circ_buf *xmit = &up->port.state->xmit;
393 int count; 393 int count;
394 394
395 if (up->port.x_char) { 395 if (up->port.x_char) {
@@ -441,7 +441,7 @@ static void check_modem_status(struct uart_sunsu_port *up)
441 if (status & UART_MSR_DCTS) 441 if (status & UART_MSR_DCTS)
442 uart_handle_cts_change(&up->port, status & UART_MSR_CTS); 442 uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
443 443
444 wake_up_interruptible(&up->port.info->delta_msr_wait); 444 wake_up_interruptible(&up->port.state->port.delta_msr_wait);
445} 445}
446 446
447static irqreturn_t sunsu_serial_interrupt(int irq, void *dev_id) 447static irqreturn_t sunsu_serial_interrupt(int irq, void *dev_id)
diff --git a/drivers/serial/sunzilog.c b/drivers/serial/sunzilog.c
index e09d3cebb4fb..ef693ae22e7f 100644
--- a/drivers/serial/sunzilog.c
+++ b/drivers/serial/sunzilog.c
@@ -328,9 +328,9 @@ sunzilog_receive_chars(struct uart_sunzilog_port *up,
328 unsigned char ch, r1, flag; 328 unsigned char ch, r1, flag;
329 329
330 tty = NULL; 330 tty = NULL;
331 if (up->port.info != NULL && /* Unopened serial console */ 331 if (up->port.state != NULL && /* Unopened serial console */
332 up->port.info->port.tty != NULL) /* Keyboard || mouse */ 332 up->port.state->port.tty != NULL) /* Keyboard || mouse */
333 tty = up->port.info->port.tty; 333 tty = up->port.state->port.tty;
334 334
335 for (;;) { 335 for (;;) {
336 336
@@ -451,7 +451,7 @@ static void sunzilog_status_handle(struct uart_sunzilog_port *up,
451 uart_handle_cts_change(&up->port, 451 uart_handle_cts_change(&up->port,
452 (status & CTS)); 452 (status & CTS));
453 453
454 wake_up_interruptible(&up->port.info->delta_msr_wait); 454 wake_up_interruptible(&up->port.state->port.delta_msr_wait);
455 } 455 }
456 456
457 up->prev_status = status; 457 up->prev_status = status;
@@ -501,9 +501,9 @@ static void sunzilog_transmit_chars(struct uart_sunzilog_port *up,
501 return; 501 return;
502 } 502 }
503 503
504 if (up->port.info == NULL) 504 if (up->port.state == NULL)
505 goto ack_tx_int; 505 goto ack_tx_int;
506 xmit = &up->port.info->xmit; 506 xmit = &up->port.state->xmit;
507 if (uart_circ_empty(xmit)) 507 if (uart_circ_empty(xmit))
508 goto ack_tx_int; 508 goto ack_tx_int;
509 509
@@ -705,7 +705,7 @@ static void sunzilog_start_tx(struct uart_port *port)
705 port->icount.tx++; 705 port->icount.tx++;
706 port->x_char = 0; 706 port->x_char = 0;
707 } else { 707 } else {
708 struct circ_buf *xmit = &port->info->xmit; 708 struct circ_buf *xmit = &port->state->xmit;
709 709
710 writeb(xmit->buf[xmit->tail], &channel->data); 710 writeb(xmit->buf[xmit->tail], &channel->data);
711 ZSDELAY(); 711 ZSDELAY();
diff --git a/drivers/serial/timbuart.c b/drivers/serial/timbuart.c
index 063a313b755c..34b31da01d09 100644
--- a/drivers/serial/timbuart.c
+++ b/drivers/serial/timbuart.c
@@ -77,7 +77,7 @@ static void timbuart_flush_buffer(struct uart_port *port)
77 77
78static void timbuart_rx_chars(struct uart_port *port) 78static void timbuart_rx_chars(struct uart_port *port)
79{ 79{
80 struct tty_struct *tty = port->info->port.tty; 80 struct tty_struct *tty = port->state->port.tty;
81 81
82 while (ioread32(port->membase + TIMBUART_ISR) & RXDP) { 82 while (ioread32(port->membase + TIMBUART_ISR) & RXDP) {
83 u8 ch = ioread8(port->membase + TIMBUART_RXFIFO); 83 u8 ch = ioread8(port->membase + TIMBUART_RXFIFO);
@@ -86,7 +86,7 @@ static void timbuart_rx_chars(struct uart_port *port)
86 } 86 }
87 87
88 spin_unlock(&port->lock); 88 spin_unlock(&port->lock);
89 tty_flip_buffer_push(port->info->port.tty); 89 tty_flip_buffer_push(port->state->port.tty);
90 spin_lock(&port->lock); 90 spin_lock(&port->lock);
91 91
92 dev_dbg(port->dev, "%s - total read %d bytes\n", 92 dev_dbg(port->dev, "%s - total read %d bytes\n",
@@ -95,7 +95,7 @@ static void timbuart_rx_chars(struct uart_port *port)
95 95
96static void timbuart_tx_chars(struct uart_port *port) 96static void timbuart_tx_chars(struct uart_port *port)
97{ 97{
98 struct circ_buf *xmit = &port->info->xmit; 98 struct circ_buf *xmit = &port->state->xmit;
99 99
100 while (!(ioread32(port->membase + TIMBUART_ISR) & TXBF) && 100 while (!(ioread32(port->membase + TIMBUART_ISR) & TXBF) &&
101 !uart_circ_empty(xmit)) { 101 !uart_circ_empty(xmit)) {
@@ -118,7 +118,7 @@ static void timbuart_handle_tx_port(struct uart_port *port, u32 isr, u32 *ier)
118{ 118{
119 struct timbuart_port *uart = 119 struct timbuart_port *uart =
120 container_of(port, struct timbuart_port, port); 120 container_of(port, struct timbuart_port, port);
121 struct circ_buf *xmit = &port->info->xmit; 121 struct circ_buf *xmit = &port->state->xmit;
122 122
123 if (uart_circ_empty(xmit) || uart_tx_stopped(port)) 123 if (uart_circ_empty(xmit) || uart_tx_stopped(port))
124 return; 124 return;
@@ -231,7 +231,7 @@ static void timbuart_mctrl_check(struct uart_port *port, u32 isr, u32 *ier)
231 iowrite32(CTS_DELTA, port->membase + TIMBUART_ISR); 231 iowrite32(CTS_DELTA, port->membase + TIMBUART_ISR);
232 cts = timbuart_get_mctrl(port); 232 cts = timbuart_get_mctrl(port);
233 uart_handle_cts_change(port, cts & TIOCM_CTS); 233 uart_handle_cts_change(port, cts & TIOCM_CTS);
234 wake_up_interruptible(&port->info->delta_msr_wait); 234 wake_up_interruptible(&port->state->port.delta_msr_wait);
235 } 235 }
236 236
237 *ier |= CTS_DELTA; 237 *ier |= CTS_DELTA;
diff --git a/drivers/serial/uartlite.c b/drivers/serial/uartlite.c
index 3317148a4b93..377f2712289e 100644
--- a/drivers/serial/uartlite.c
+++ b/drivers/serial/uartlite.c
@@ -75,7 +75,7 @@ static struct uart_port ulite_ports[ULITE_NR_UARTS];
75 75
76static int ulite_receive(struct uart_port *port, int stat) 76static int ulite_receive(struct uart_port *port, int stat)
77{ 77{
78 struct tty_struct *tty = port->info->port.tty; 78 struct tty_struct *tty = port->state->port.tty;
79 unsigned char ch = 0; 79 unsigned char ch = 0;
80 char flag = TTY_NORMAL; 80 char flag = TTY_NORMAL;
81 81
@@ -125,7 +125,7 @@ static int ulite_receive(struct uart_port *port, int stat)
125 125
126static int ulite_transmit(struct uart_port *port, int stat) 126static int ulite_transmit(struct uart_port *port, int stat)
127{ 127{
128 struct circ_buf *xmit = &port->info->xmit; 128 struct circ_buf *xmit = &port->state->xmit;
129 129
130 if (stat & ULITE_STATUS_TXFULL) 130 if (stat & ULITE_STATUS_TXFULL)
131 return 0; 131 return 0;
@@ -154,17 +154,22 @@ static int ulite_transmit(struct uart_port *port, int stat)
154static irqreturn_t ulite_isr(int irq, void *dev_id) 154static irqreturn_t ulite_isr(int irq, void *dev_id)
155{ 155{
156 struct uart_port *port = dev_id; 156 struct uart_port *port = dev_id;
157 int busy; 157 int busy, n = 0;
158 158
159 do { 159 do {
160 int stat = readb(port->membase + ULITE_STATUS); 160 int stat = readb(port->membase + ULITE_STATUS);
161 busy = ulite_receive(port, stat); 161 busy = ulite_receive(port, stat);
162 busy |= ulite_transmit(port, stat); 162 busy |= ulite_transmit(port, stat);
163 n++;
163 } while (busy); 164 } while (busy);
164 165
165 tty_flip_buffer_push(port->info->port.tty); 166 /* work done? */
166 167 if (n > 1) {
167 return IRQ_HANDLED; 168 tty_flip_buffer_push(port->state->port.tty);
169 return IRQ_HANDLED;
170 } else {
171 return IRQ_NONE;
172 }
168} 173}
169 174
170static unsigned int ulite_tx_empty(struct uart_port *port) 175static unsigned int ulite_tx_empty(struct uart_port *port)
@@ -221,7 +226,7 @@ static int ulite_startup(struct uart_port *port)
221 int ret; 226 int ret;
222 227
223 ret = request_irq(port->irq, ulite_isr, 228 ret = request_irq(port->irq, ulite_isr,
224 IRQF_DISABLED | IRQF_SAMPLE_RANDOM, "uartlite", port); 229 IRQF_SHARED | IRQF_SAMPLE_RANDOM, "uartlite", port);
225 if (ret) 230 if (ret)
226 return ret; 231 return ret;
227 232
diff --git a/drivers/serial/ucc_uart.c b/drivers/serial/ucc_uart.c
index e945e780b5c9..0c08f286a2ef 100644
--- a/drivers/serial/ucc_uart.c
+++ b/drivers/serial/ucc_uart.c
@@ -327,7 +327,7 @@ static int qe_uart_tx_pump(struct uart_qe_port *qe_port)
327 unsigned char *p; 327 unsigned char *p;
328 unsigned int count; 328 unsigned int count;
329 struct uart_port *port = &qe_port->port; 329 struct uart_port *port = &qe_port->port;
330 struct circ_buf *xmit = &port->info->xmit; 330 struct circ_buf *xmit = &port->state->xmit;
331 331
332 bdp = qe_port->rx_cur; 332 bdp = qe_port->rx_cur;
333 333
@@ -466,7 +466,7 @@ static void qe_uart_int_rx(struct uart_qe_port *qe_port)
466 int i; 466 int i;
467 unsigned char ch, *cp; 467 unsigned char ch, *cp;
468 struct uart_port *port = &qe_port->port; 468 struct uart_port *port = &qe_port->port;
469 struct tty_struct *tty = port->info->port.tty; 469 struct tty_struct *tty = port->state->port.tty;
470 struct qe_bd *bdp; 470 struct qe_bd *bdp;
471 u16 status; 471 u16 status;
472 unsigned int flg; 472 unsigned int flg;
diff --git a/drivers/serial/vr41xx_siu.c b/drivers/serial/vr41xx_siu.c
index dac550e57c29..3beb6ab4fa68 100644
--- a/drivers/serial/vr41xx_siu.c
+++ b/drivers/serial/vr41xx_siu.c
@@ -318,7 +318,7 @@ static inline void receive_chars(struct uart_port *port, uint8_t *status)
318 char flag; 318 char flag;
319 int max_count = RX_MAX_COUNT; 319 int max_count = RX_MAX_COUNT;
320 320
321 tty = port->info->port.tty; 321 tty = port->state->port.tty;
322 lsr = *status; 322 lsr = *status;
323 323
324 do { 324 do {
@@ -386,7 +386,7 @@ static inline void check_modem_status(struct uart_port *port)
386 if (msr & UART_MSR_DCTS) 386 if (msr & UART_MSR_DCTS)
387 uart_handle_cts_change(port, msr & UART_MSR_CTS); 387 uart_handle_cts_change(port, msr & UART_MSR_CTS);
388 388
389 wake_up_interruptible(&port->info->delta_msr_wait); 389 wake_up_interruptible(&port->state->port.delta_msr_wait);
390} 390}
391 391
392static inline void transmit_chars(struct uart_port *port) 392static inline void transmit_chars(struct uart_port *port)
@@ -394,7 +394,7 @@ static inline void transmit_chars(struct uart_port *port)
394 struct circ_buf *xmit; 394 struct circ_buf *xmit;
395 int max_count = TX_MAX_COUNT; 395 int max_count = TX_MAX_COUNT;
396 396
397 xmit = &port->info->xmit; 397 xmit = &port->state->xmit;
398 398
399 if (port->x_char) { 399 if (port->x_char) {
400 siu_write(port, UART_TX, port->x_char); 400 siu_write(port, UART_TX, port->x_char);
diff --git a/drivers/serial/zs.c b/drivers/serial/zs.c
index d8c2809b1ab6..1a7fd3e70315 100644
--- a/drivers/serial/zs.c
+++ b/drivers/serial/zs.c
@@ -602,12 +602,12 @@ static void zs_receive_chars(struct zs_port *zport)
602 uart_insert_char(uport, status, Rx_OVR, ch, flag); 602 uart_insert_char(uport, status, Rx_OVR, ch, flag);
603 } 603 }
604 604
605 tty_flip_buffer_push(uport->info->port.tty); 605 tty_flip_buffer_push(uport->state->port.tty);
606} 606}
607 607
608static void zs_raw_transmit_chars(struct zs_port *zport) 608static void zs_raw_transmit_chars(struct zs_port *zport)
609{ 609{
610 struct circ_buf *xmit = &zport->port.info->xmit; 610 struct circ_buf *xmit = &zport->port.state->xmit;
611 611
612 /* XON/XOFF chars. */ 612 /* XON/XOFF chars. */
613 if (zport->port.x_char) { 613 if (zport->port.x_char) {
@@ -686,7 +686,7 @@ static void zs_status_handle(struct zs_port *zport, struct zs_port *zport_a)
686 uport->icount.rng++; 686 uport->icount.rng++;
687 687
688 if (delta) 688 if (delta)
689 wake_up_interruptible(&uport->info->delta_msr_wait); 689 wake_up_interruptible(&uport->state->port.delta_msr_wait);
690 690
691 spin_lock(&scc->zlock); 691 spin_lock(&scc->zlock);
692 } 692 }
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 2bfc41ece0e1..85a1a55815cf 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -858,10 +858,7 @@ static void acm_tty_set_termios(struct tty_struct *tty,
858 if (!ACM_READY(acm)) 858 if (!ACM_READY(acm))
859 return; 859 return;
860 860
861 /* FIXME: Needs to support the tty_baud interface */ 861 newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
862 /* FIXME: Broken on sparc */
863 newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
864 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
865 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0; 862 newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
866 newline.bParityType = termios->c_cflag & PARENB ? 863 newline.bParityType = termios->c_cflag & PARENB ?
867 (termios->c_cflag & PARODD ? 1 : 2) + 864 (termios->c_cflag & PARODD ? 1 : 2) +
diff --git a/drivers/usb/serial/ark3116.c b/drivers/usb/serial/ark3116.c
index aec61880f36c..5d25d3e52bf6 100644
--- a/drivers/usb/serial/ark3116.c
+++ b/drivers/usb/serial/ark3116.c
@@ -35,11 +35,6 @@ static struct usb_device_id id_table [] = {
35}; 35};
36MODULE_DEVICE_TABLE(usb, id_table); 36MODULE_DEVICE_TABLE(usb, id_table);
37 37
38struct ark3116_private {
39 spinlock_t lock;
40 u8 termios_initialized;
41};
42
43static inline void ARK3116_SND(struct usb_serial *serial, int seq, 38static inline void ARK3116_SND(struct usb_serial *serial, int seq,
44 __u8 request, __u8 requesttype, 39 __u8 request, __u8 requesttype,
45 __u16 value, __u16 index) 40 __u16 value, __u16 index)
@@ -82,22 +77,11 @@ static inline void ARK3116_RCV_QUIET(struct usb_serial *serial,
82static int ark3116_attach(struct usb_serial *serial) 77static int ark3116_attach(struct usb_serial *serial)
83{ 78{
84 char *buf; 79 char *buf;
85 struct ark3116_private *priv;
86 int i;
87
88 for (i = 0; i < serial->num_ports; ++i) {
89 priv = kzalloc(sizeof(struct ark3116_private), GFP_KERNEL);
90 if (!priv)
91 goto cleanup;
92 spin_lock_init(&priv->lock);
93
94 usb_set_serial_port_data(serial->port[i], priv);
95 }
96 80
97 buf = kmalloc(1, GFP_KERNEL); 81 buf = kmalloc(1, GFP_KERNEL);
98 if (!buf) { 82 if (!buf) {
99 dbg("error kmalloc -> out of mem?"); 83 dbg("error kmalloc -> out of mem?");
100 goto cleanup; 84 return -ENOMEM;
101 } 85 }
102 86
103 /* 3 */ 87 /* 3 */
@@ -149,13 +133,16 @@ static int ark3116_attach(struct usb_serial *serial)
149 133
150 kfree(buf); 134 kfree(buf);
151 return 0; 135 return 0;
136}
152 137
153cleanup: 138static void ark3116_init_termios(struct tty_struct *tty)
154 for (--i; i >= 0; --i) { 139{
155 kfree(usb_get_serial_port_data(serial->port[i])); 140 struct ktermios *termios = tty->termios;
156 usb_set_serial_port_data(serial->port[i], NULL); 141 *termios = tty_std_termios;
157 } 142 termios->c_cflag = B9600 | CS8
158 return -ENOMEM; 143 | CREAD | HUPCL | CLOCAL;
144 termios->c_ispeed = 9600;
145 termios->c_ospeed = 9600;
159} 146}
160 147
161static void ark3116_set_termios(struct tty_struct *tty, 148static void ark3116_set_termios(struct tty_struct *tty,
@@ -163,10 +150,8 @@ static void ark3116_set_termios(struct tty_struct *tty,
163 struct ktermios *old_termios) 150 struct ktermios *old_termios)
164{ 151{
165 struct usb_serial *serial = port->serial; 152 struct usb_serial *serial = port->serial;
166 struct ark3116_private *priv = usb_get_serial_port_data(port);
167 struct ktermios *termios = tty->termios; 153 struct ktermios *termios = tty->termios;
168 unsigned int cflag = termios->c_cflag; 154 unsigned int cflag = termios->c_cflag;
169 unsigned long flags;
170 int baud; 155 int baud;
171 int ark3116_baud; 156 int ark3116_baud;
172 char *buf; 157 char *buf;
@@ -176,16 +161,6 @@ static void ark3116_set_termios(struct tty_struct *tty,
176 161
177 dbg("%s - port %d", __func__, port->number); 162 dbg("%s - port %d", __func__, port->number);
178 163
179 spin_lock_irqsave(&priv->lock, flags);
180 if (!priv->termios_initialized) {
181 *termios = tty_std_termios;
182 termios->c_cflag = B9600 | CS8
183 | CREAD | HUPCL | CLOCAL;
184 termios->c_ispeed = 9600;
185 termios->c_ospeed = 9600;
186 priv->termios_initialized = 1;
187 }
188 spin_unlock_irqrestore(&priv->lock, flags);
189 164
190 cflag = termios->c_cflag; 165 cflag = termios->c_cflag;
191 termios->c_cflag &= ~(CMSPAR|CRTSCTS); 166 termios->c_cflag &= ~(CMSPAR|CRTSCTS);
@@ -318,8 +293,7 @@ static void ark3116_set_termios(struct tty_struct *tty,
318 return; 293 return;
319} 294}
320 295
321static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port, 296static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port)
322 struct file *filp)
323{ 297{
324 struct ktermios tmp_termios; 298 struct ktermios tmp_termios;
325 struct usb_serial *serial = port->serial; 299 struct usb_serial *serial = port->serial;
@@ -334,7 +308,7 @@ static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port,
334 return -ENOMEM; 308 return -ENOMEM;
335 } 309 }
336 310
337 result = usb_serial_generic_open(tty, port, filp); 311 result = usb_serial_generic_open(tty, port);
338 if (result) 312 if (result)
339 goto err_out; 313 goto err_out;
340 314
@@ -455,6 +429,7 @@ static struct usb_serial_driver ark3116_device = {
455 .num_ports = 1, 429 .num_ports = 1,
456 .attach = ark3116_attach, 430 .attach = ark3116_attach,
457 .set_termios = ark3116_set_termios, 431 .set_termios = ark3116_set_termios,
432 .init_termios = ark3116_init_termios,
458 .ioctl = ark3116_ioctl, 433 .ioctl = ark3116_ioctl,
459 .tiocmget = ark3116_tiocmget, 434 .tiocmget = ark3116_tiocmget,
460 .open = ark3116_open, 435 .open = ark3116_open,
diff --git a/drivers/usb/serial/belkin_sa.c b/drivers/usb/serial/belkin_sa.c
index 7033b031b443..a0467bc61627 100644
--- a/drivers/usb/serial/belkin_sa.c
+++ b/drivers/usb/serial/belkin_sa.c
@@ -92,7 +92,7 @@ static int debug;
92static int belkin_sa_startup(struct usb_serial *serial); 92static int belkin_sa_startup(struct usb_serial *serial);
93static void belkin_sa_release(struct usb_serial *serial); 93static void belkin_sa_release(struct usb_serial *serial);
94static int belkin_sa_open(struct tty_struct *tty, 94static int belkin_sa_open(struct tty_struct *tty,
95 struct usb_serial_port *port, struct file *filp); 95 struct usb_serial_port *port);
96static void belkin_sa_close(struct usb_serial_port *port); 96static void belkin_sa_close(struct usb_serial_port *port);
97static void belkin_sa_read_int_callback(struct urb *urb); 97static void belkin_sa_read_int_callback(struct urb *urb);
98static void belkin_sa_set_termios(struct tty_struct *tty, 98static void belkin_sa_set_termios(struct tty_struct *tty,
@@ -213,7 +213,7 @@ static void belkin_sa_release(struct usb_serial *serial)
213 213
214 214
215static int belkin_sa_open(struct tty_struct *tty, 215static int belkin_sa_open(struct tty_struct *tty,
216 struct usb_serial_port *port, struct file *filp) 216 struct usb_serial_port *port)
217{ 217{
218 int retval = 0; 218 int retval = 0;
219 219
diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
index 2830766f5b39..8c894a7d5dcf 100644
--- a/drivers/usb/serial/ch341.c
+++ b/drivers/usb/serial/ch341.c
@@ -300,8 +300,7 @@ static void ch341_close(struct usb_serial_port *port)
300 300
301 301
302/* open this device, set default parameters */ 302/* open this device, set default parameters */
303static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port, 303static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port)
304 struct file *filp)
305{ 304{
306 struct usb_serial *serial = port->serial; 305 struct usb_serial *serial = port->serial;
307 struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]); 306 struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]);
@@ -333,7 +332,7 @@ static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port,
333 return -EPROTO; 332 return -EPROTO;
334 } 333 }
335 334
336 r = usb_serial_generic_open(tty, port, filp); 335 r = usb_serial_generic_open(tty, port);
337 336
338out: return r; 337out: return r;
339} 338}
diff --git a/drivers/usb/serial/console.c b/drivers/usb/serial/console.c
index 0e4f2e41ace5..b22ac3258523 100644
--- a/drivers/usb/serial/console.c
+++ b/drivers/usb/serial/console.c
@@ -16,6 +16,7 @@
16#include <linux/slab.h> 16#include <linux/slab.h>
17#include <linux/tty.h> 17#include <linux/tty.h>
18#include <linux/console.h> 18#include <linux/console.h>
19#include <linux/serial.h>
19#include <linux/usb.h> 20#include <linux/usb.h>
20#include <linux/usb/serial.h> 21#include <linux/usb/serial.h>
21 22
@@ -63,7 +64,7 @@ static int usb_console_setup(struct console *co, char *options)
63 char *s; 64 char *s;
64 struct usb_serial *serial; 65 struct usb_serial *serial;
65 struct usb_serial_port *port; 66 struct usb_serial_port *port;
66 int retval = 0; 67 int retval;
67 struct tty_struct *tty = NULL; 68 struct tty_struct *tty = NULL;
68 struct ktermios *termios = NULL, dummy; 69 struct ktermios *termios = NULL, dummy;
69 70
@@ -116,13 +117,17 @@ static int usb_console_setup(struct console *co, char *options)
116 return -ENODEV; 117 return -ENODEV;
117 } 118 }
118 119
119 port = serial->port[0]; 120 retval = usb_autopm_get_interface(serial->interface);
121 if (retval)
122 goto error_get_interface;
123
124 port = serial->port[co->index - serial->minor];
120 tty_port_tty_set(&port->port, NULL); 125 tty_port_tty_set(&port->port, NULL);
121 126
122 info->port = port; 127 info->port = port;
123 128
124 ++port->port.count; 129 ++port->port.count;
125 if (port->port.count == 1) { 130 if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags)) {
126 if (serial->type->set_termios) { 131 if (serial->type->set_termios) {
127 /* 132 /*
128 * allocate a fake tty so the driver can initialize 133 * allocate a fake tty so the driver can initialize
@@ -150,9 +155,9 @@ static int usb_console_setup(struct console *co, char *options)
150 /* only call the device specific open if this 155 /* only call the device specific open if this
151 * is the first time the port is opened */ 156 * is the first time the port is opened */
152 if (serial->type->open) 157 if (serial->type->open)
153 retval = serial->type->open(NULL, port, NULL); 158 retval = serial->type->open(NULL, port);
154 else 159 else
155 retval = usb_serial_generic_open(NULL, port, NULL); 160 retval = usb_serial_generic_open(NULL, port);
156 161
157 if (retval) { 162 if (retval) {
158 err("could not open USB console port"); 163 err("could not open USB console port");
@@ -168,6 +173,7 @@ static int usb_console_setup(struct console *co, char *options)
168 kfree(termios); 173 kfree(termios);
169 kfree(tty); 174 kfree(tty);
170 } 175 }
176 set_bit(ASYNCB_INITIALIZED, &port->port.flags);
171 } 177 }
172 /* Now that any required fake tty operations are completed restore 178 /* Now that any required fake tty operations are completed restore
173 * the tty port count */ 179 * the tty port count */
@@ -175,18 +181,22 @@ static int usb_console_setup(struct console *co, char *options)
175 /* The console is special in terms of closing the device so 181 /* The console is special in terms of closing the device so
176 * indicate this port is now acting as a system console. */ 182 * indicate this port is now acting as a system console. */
177 port->console = 1; 183 port->console = 1;
178 retval = 0;
179 184
180out: 185 mutex_unlock(&serial->disc_mutex);
181 return retval; 186 return retval;
182free_termios: 187
188 free_termios:
183 kfree(termios); 189 kfree(termios);
184 tty_port_tty_set(&port->port, NULL); 190 tty_port_tty_set(&port->port, NULL);
185free_tty: 191 free_tty:
186 kfree(tty); 192 kfree(tty);
187reset_open_count: 193 reset_open_count:
188 port->port.count = 0; 194 port->port.count = 0;
189 goto out; 195 usb_autopm_put_interface(serial->interface);
196 error_get_interface:
197 usb_serial_put(serial);
198 mutex_unlock(&serial->disc_mutex);
199 return retval;
190} 200}
191 201
192static void usb_console_write(struct console *co, 202static void usb_console_write(struct console *co,
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
index 985cbcf48bda..4a208fe85bc9 100644
--- a/drivers/usb/serial/cp210x.c
+++ b/drivers/usb/serial/cp210x.c
@@ -33,8 +33,7 @@
33/* 33/*
34 * Function Prototypes 34 * Function Prototypes
35 */ 35 */
36static int cp210x_open(struct tty_struct *, struct usb_serial_port *, 36static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *);
37 struct file *);
38static void cp210x_cleanup(struct usb_serial_port *); 37static void cp210x_cleanup(struct usb_serial_port *);
39static void cp210x_close(struct usb_serial_port *); 38static void cp210x_close(struct usb_serial_port *);
40static void cp210x_get_termios(struct tty_struct *, 39static void cp210x_get_termios(struct tty_struct *,
@@ -368,8 +367,7 @@ static unsigned int cp210x_quantise_baudrate(unsigned int baud) {
368 return baud; 367 return baud;
369} 368}
370 369
371static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port, 370static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port)
372 struct file *filp)
373{ 371{
374 struct usb_serial *serial = port->serial; 372 struct usb_serial *serial = port->serial;
375 int result; 373 int result;
@@ -399,12 +397,6 @@ static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port,
399 397
400 /* Configure the termios structure */ 398 /* Configure the termios structure */
401 cp210x_get_termios(tty, port); 399 cp210x_get_termios(tty, port);
402
403 /* Set the DTR and RTS pins low */
404 cp210x_tiocmset_port(tty ? (struct usb_serial_port *) tty->driver_data
405 : port,
406 NULL, TIOCM_DTR | TIOCM_RTS, 0);
407
408 return 0; 400 return 0;
409} 401}
410 402
diff --git a/drivers/usb/serial/cyberjack.c b/drivers/usb/serial/cyberjack.c
index 336523fd7366..b0f6402a91ca 100644
--- a/drivers/usb/serial/cyberjack.c
+++ b/drivers/usb/serial/cyberjack.c
@@ -61,7 +61,7 @@ static int cyberjack_startup(struct usb_serial *serial);
61static void cyberjack_disconnect(struct usb_serial *serial); 61static void cyberjack_disconnect(struct usb_serial *serial);
62static void cyberjack_release(struct usb_serial *serial); 62static void cyberjack_release(struct usb_serial *serial);
63static int cyberjack_open(struct tty_struct *tty, 63static int cyberjack_open(struct tty_struct *tty,
64 struct usb_serial_port *port, struct file *filp); 64 struct usb_serial_port *port);
65static void cyberjack_close(struct usb_serial_port *port); 65static void cyberjack_close(struct usb_serial_port *port);
66static int cyberjack_write(struct tty_struct *tty, 66static int cyberjack_write(struct tty_struct *tty,
67 struct usb_serial_port *port, const unsigned char *buf, int count); 67 struct usb_serial_port *port, const unsigned char *buf, int count);
@@ -173,7 +173,7 @@ static void cyberjack_release(struct usb_serial *serial)
173} 173}
174 174
175static int cyberjack_open(struct tty_struct *tty, 175static int cyberjack_open(struct tty_struct *tty,
176 struct usb_serial_port *port, struct file *filp) 176 struct usb_serial_port *port)
177{ 177{
178 struct cyberjack_private *priv; 178 struct cyberjack_private *priv;
179 unsigned long flags; 179 unsigned long flags;
diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c
index 59adfe123110..e0a8b715f2f2 100644
--- a/drivers/usb/serial/cypress_m8.c
+++ b/drivers/usb/serial/cypress_m8.c
@@ -172,8 +172,7 @@ static int cypress_earthmate_startup(struct usb_serial *serial);
172static int cypress_hidcom_startup(struct usb_serial *serial); 172static int cypress_hidcom_startup(struct usb_serial *serial);
173static int cypress_ca42v2_startup(struct usb_serial *serial); 173static int cypress_ca42v2_startup(struct usb_serial *serial);
174static void cypress_release(struct usb_serial *serial); 174static void cypress_release(struct usb_serial *serial);
175static int cypress_open(struct tty_struct *tty, 175static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port);
176 struct usb_serial_port *port, struct file *filp);
177static void cypress_close(struct usb_serial_port *port); 176static void cypress_close(struct usb_serial_port *port);
178static void cypress_dtr_rts(struct usb_serial_port *port, int on); 177static void cypress_dtr_rts(struct usb_serial_port *port, int on);
179static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port, 178static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port,
@@ -633,8 +632,7 @@ static void cypress_release(struct usb_serial *serial)
633} 632}
634 633
635 634
636static int cypress_open(struct tty_struct *tty, 635static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port)
637 struct usb_serial_port *port, struct file *filp)
638{ 636{
639 struct cypress_private *priv = usb_get_serial_port_data(port); 637 struct cypress_private *priv = usb_get_serial_port_data(port);
640 struct usb_serial *serial = port->serial; 638 struct usb_serial *serial = port->serial;
@@ -659,15 +657,7 @@ static int cypress_open(struct tty_struct *tty,
659 spin_unlock_irqrestore(&priv->lock, flags); 657 spin_unlock_irqrestore(&priv->lock, flags);
660 658
661 /* Set termios */ 659 /* Set termios */
662 result = cypress_write(tty, port, NULL, 0); 660 cypress_send(port);
663
664 if (result) {
665 dev_err(&port->dev,
666 "%s - failed setting the control lines - error %d\n",
667 __func__, result);
668 return result;
669 } else
670 dbg("%s - success setting the control lines", __func__);
671 661
672 if (tty) 662 if (tty)
673 cypress_set_termios(tty, port, &priv->tmp_termios); 663 cypress_set_termios(tty, port, &priv->tmp_termios);
@@ -1005,6 +995,8 @@ static void cypress_set_termios(struct tty_struct *tty,
1005 dbg("%s - port %d", __func__, port->number); 995 dbg("%s - port %d", __func__, port->number);
1006 996
1007 spin_lock_irqsave(&priv->lock, flags); 997 spin_lock_irqsave(&priv->lock, flags);
998 /* We can't clean this one up as we don't know the device type
999 early enough */
1008 if (!priv->termios_initialized) { 1000 if (!priv->termios_initialized) {
1009 if (priv->chiptype == CT_EARTHMATE) { 1001 if (priv->chiptype == CT_EARTHMATE) {
1010 *(tty->termios) = tty_std_termios; 1002 *(tty->termios) = tty_std_termios;
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index f4808091c47c..ab3dd991586b 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -453,8 +453,7 @@ static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
453static void digi_write_bulk_callback(struct urb *urb); 453static void digi_write_bulk_callback(struct urb *urb);
454static int digi_write_room(struct tty_struct *tty); 454static int digi_write_room(struct tty_struct *tty);
455static int digi_chars_in_buffer(struct tty_struct *tty); 455static int digi_chars_in_buffer(struct tty_struct *tty);
456static int digi_open(struct tty_struct *tty, struct usb_serial_port *port, 456static int digi_open(struct tty_struct *tty, struct usb_serial_port *port);
457 struct file *filp);
458static void digi_close(struct usb_serial_port *port); 457static void digi_close(struct usb_serial_port *port);
459static int digi_carrier_raised(struct usb_serial_port *port); 458static int digi_carrier_raised(struct usb_serial_port *port);
460static void digi_dtr_rts(struct usb_serial_port *port, int on); 459static void digi_dtr_rts(struct usb_serial_port *port, int on);
@@ -1347,8 +1346,7 @@ static int digi_carrier_raised(struct usb_serial_port *port)
1347 return 0; 1346 return 0;
1348} 1347}
1349 1348
1350static int digi_open(struct tty_struct *tty, struct usb_serial_port *port, 1349static int digi_open(struct tty_struct *tty, struct usb_serial_port *port)
1351 struct file *filp)
1352{ 1350{
1353 int ret; 1351 int ret;
1354 unsigned char buf[32]; 1352 unsigned char buf[32];
diff --git a/drivers/usb/serial/empeg.c b/drivers/usb/serial/empeg.c
index 80cb3471adbe..33c9e9cf9eb2 100644
--- a/drivers/usb/serial/empeg.c
+++ b/drivers/usb/serial/empeg.c
@@ -79,8 +79,7 @@ static int debug;
79#define EMPEG_PRODUCT_ID 0x0001 79#define EMPEG_PRODUCT_ID 0x0001
80 80
81/* function prototypes for an empeg-car player */ 81/* function prototypes for an empeg-car player */
82static int empeg_open(struct tty_struct *tty, struct usb_serial_port *port, 82static int empeg_open(struct tty_struct *tty, struct usb_serial_port *port);
83 struct file *filp);
84static void empeg_close(struct usb_serial_port *port); 83static void empeg_close(struct usb_serial_port *port);
85static int empeg_write(struct tty_struct *tty, struct usb_serial_port *port, 84static int empeg_write(struct tty_struct *tty, struct usb_serial_port *port,
86 const unsigned char *buf, 85 const unsigned char *buf,
@@ -90,8 +89,7 @@ static int empeg_chars_in_buffer(struct tty_struct *tty);
90static void empeg_throttle(struct tty_struct *tty); 89static void empeg_throttle(struct tty_struct *tty);
91static void empeg_unthrottle(struct tty_struct *tty); 90static void empeg_unthrottle(struct tty_struct *tty);
92static int empeg_startup(struct usb_serial *serial); 91static int empeg_startup(struct usb_serial *serial);
93static void empeg_set_termios(struct tty_struct *tty, 92static void empeg_init_termios(struct tty_struct *tty);
94 struct usb_serial_port *port, struct ktermios *old_termios);
95static void empeg_write_bulk_callback(struct urb *urb); 93static void empeg_write_bulk_callback(struct urb *urb);
96static void empeg_read_bulk_callback(struct urb *urb); 94static void empeg_read_bulk_callback(struct urb *urb);
97 95
@@ -123,7 +121,7 @@ static struct usb_serial_driver empeg_device = {
123 .throttle = empeg_throttle, 121 .throttle = empeg_throttle,
124 .unthrottle = empeg_unthrottle, 122 .unthrottle = empeg_unthrottle,
125 .attach = empeg_startup, 123 .attach = empeg_startup,
126 .set_termios = empeg_set_termios, 124 .init_termios = empeg_init_termios,
127 .write = empeg_write, 125 .write = empeg_write,
128 .write_room = empeg_write_room, 126 .write_room = empeg_write_room,
129 .chars_in_buffer = empeg_chars_in_buffer, 127 .chars_in_buffer = empeg_chars_in_buffer,
@@ -142,17 +140,13 @@ static int bytes_out;
142/****************************************************************************** 140/******************************************************************************
143 * Empeg specific driver functions 141 * Empeg specific driver functions
144 ******************************************************************************/ 142 ******************************************************************************/
145static int empeg_open(struct tty_struct *tty, struct usb_serial_port *port, 143static int empeg_open(struct tty_struct *tty,struct usb_serial_port *port)
146 struct file *filp)
147{ 144{
148 struct usb_serial *serial = port->serial; 145 struct usb_serial *serial = port->serial;
149 int result = 0; 146 int result = 0;
150 147
151 dbg("%s - port %d", __func__, port->number); 148 dbg("%s - port %d", __func__, port->number);
152 149
153 /* Force default termio settings */
154 empeg_set_termios(tty, port, NULL) ;
155
156 bytes_in = 0; 150 bytes_in = 0;
157 bytes_out = 0; 151 bytes_out = 0;
158 152
@@ -425,11 +419,9 @@ static int empeg_startup(struct usb_serial *serial)
425} 419}
426 420
427 421
428static void empeg_set_termios(struct tty_struct *tty, 422static void empeg_init_termios(struct tty_struct *tty)
429 struct usb_serial_port *port, struct ktermios *old_termios)
430{ 423{
431 struct ktermios *termios = tty->termios; 424 struct ktermios *termios = tty->termios;
432 dbg("%s - port %d", __func__, port->number);
433 425
434 /* 426 /*
435 * The empeg-car player wants these particular tty settings. 427 * The empeg-car player wants these particular tty settings.
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 8fec5d4455c9..76a17f915eef 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -747,8 +747,7 @@ static int ftdi_sio_probe(struct usb_serial *serial,
747 const struct usb_device_id *id); 747 const struct usb_device_id *id);
748static int ftdi_sio_port_probe(struct usb_serial_port *port); 748static int ftdi_sio_port_probe(struct usb_serial_port *port);
749static int ftdi_sio_port_remove(struct usb_serial_port *port); 749static int ftdi_sio_port_remove(struct usb_serial_port *port);
750static int ftdi_open(struct tty_struct *tty, 750static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port);
751 struct usb_serial_port *port, struct file *filp);
752static void ftdi_close(struct usb_serial_port *port); 751static void ftdi_close(struct usb_serial_port *port);
753static void ftdi_dtr_rts(struct usb_serial_port *port, int on); 752static void ftdi_dtr_rts(struct usb_serial_port *port, int on);
754static int ftdi_write(struct tty_struct *tty, struct usb_serial_port *port, 753static int ftdi_write(struct tty_struct *tty, struct usb_serial_port *port,
@@ -1680,8 +1679,7 @@ static int ftdi_sio_port_remove(struct usb_serial_port *port)
1680 return 0; 1679 return 0;
1681} 1680}
1682 1681
1683static int ftdi_open(struct tty_struct *tty, 1682static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
1684 struct usb_serial_port *port, struct file *filp)
1685{ /* ftdi_open */ 1683{ /* ftdi_open */
1686 struct usb_device *dev = port->serial->dev; 1684 struct usb_device *dev = port->serial->dev;
1687 struct ftdi_private *priv = usb_get_serial_port_data(port); 1685 struct ftdi_private *priv = usb_get_serial_port_data(port);
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index 8839f1c70b7f..20432d345529 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -933,8 +933,7 @@ static int garmin_init_session(struct usb_serial_port *port)
933 933
934 934
935 935
936static int garmin_open(struct tty_struct *tty, 936static int garmin_open(struct tty_struct *tty, struct usb_serial_port *port)
937 struct usb_serial_port *port, struct file *filp)
938{ 937{
939 unsigned long flags; 938 unsigned long flags;
940 int status = 0; 939 int status = 0;
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index ce57f6a32bdf..d9398e9f30ce 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -114,8 +114,7 @@ void usb_serial_generic_deregister(void)
114#endif 114#endif
115} 115}
116 116
117int usb_serial_generic_open(struct tty_struct *tty, 117int usb_serial_generic_open(struct tty_struct *tty, struct usb_serial_port *port)
118 struct usb_serial_port *port, struct file *filp)
119{ 118{
120 struct usb_serial *serial = port->serial; 119 struct usb_serial *serial = port->serial;
121 int result = 0; 120 int result = 0;
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index 0191693625d6..dc0f832657e6 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -205,8 +205,7 @@ static void edge_bulk_out_data_callback(struct urb *urb);
205static void edge_bulk_out_cmd_callback(struct urb *urb); 205static void edge_bulk_out_cmd_callback(struct urb *urb);
206 206
207/* function prototypes for the usbserial callbacks */ 207/* function prototypes for the usbserial callbacks */
208static int edge_open(struct tty_struct *tty, struct usb_serial_port *port, 208static int edge_open(struct tty_struct *tty, struct usb_serial_port *port);
209 struct file *filp);
210static void edge_close(struct usb_serial_port *port); 209static void edge_close(struct usb_serial_port *port);
211static int edge_write(struct tty_struct *tty, struct usb_serial_port *port, 210static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
212 const unsigned char *buf, int count); 211 const unsigned char *buf, int count);
@@ -852,8 +851,7 @@ static void edge_bulk_out_cmd_callback(struct urb *urb)
852 * If successful, we return 0 851 * If successful, we return 0
853 * Otherwise we return a negative error number. 852 * Otherwise we return a negative error number.
854 *****************************************************************************/ 853 *****************************************************************************/
855static int edge_open(struct tty_struct *tty, 854static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
856 struct usb_serial_port *port, struct file *filp)
857{ 855{
858 struct edgeport_port *edge_port = usb_get_serial_port_data(port); 856 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
859 struct usb_serial *serial; 857 struct usb_serial *serial;
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index e8bc42f92e79..d4cc0f7af400 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -1831,8 +1831,7 @@ static void edge_bulk_out_callback(struct urb *urb)
1831 tty_kref_put(tty); 1831 tty_kref_put(tty);
1832} 1832}
1833 1833
1834static int edge_open(struct tty_struct *tty, 1834static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
1835 struct usb_serial_port *port, struct file *filp)
1836{ 1835{
1837 struct edgeport_port *edge_port = usb_get_serial_port_data(port); 1836 struct edgeport_port *edge_port = usb_get_serial_port_data(port);
1838 struct edgeport_serial *edge_serial; 1837 struct edgeport_serial *edge_serial;
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c
index 2545d45ce16f..24fcc64b837d 100644
--- a/drivers/usb/serial/ipaq.c
+++ b/drivers/usb/serial/ipaq.c
@@ -75,7 +75,7 @@ static int initial_wait;
75 75
76/* Function prototypes for an ipaq */ 76/* Function prototypes for an ipaq */
77static int ipaq_open(struct tty_struct *tty, 77static int ipaq_open(struct tty_struct *tty,
78 struct usb_serial_port *port, struct file *filp); 78 struct usb_serial_port *port);
79static void ipaq_close(struct usb_serial_port *port); 79static void ipaq_close(struct usb_serial_port *port);
80static int ipaq_calc_num_ports(struct usb_serial *serial); 80static int ipaq_calc_num_ports(struct usb_serial *serial);
81static int ipaq_startup(struct usb_serial *serial); 81static int ipaq_startup(struct usb_serial *serial);
@@ -587,7 +587,7 @@ static int bytes_in;
587static int bytes_out; 587static int bytes_out;
588 588
589static int ipaq_open(struct tty_struct *tty, 589static int ipaq_open(struct tty_struct *tty,
590 struct usb_serial_port *port, struct file *filp) 590 struct usb_serial_port *port)
591{ 591{
592 struct usb_serial *serial = port->serial; 592 struct usb_serial *serial = port->serial;
593 struct ipaq_private *priv; 593 struct ipaq_private *priv;
@@ -628,11 +628,6 @@ static int ipaq_open(struct tty_struct *tty,
628 priv->free_len += PACKET_SIZE; 628 priv->free_len += PACKET_SIZE;
629 } 629 }
630 630
631 if (tty) {
632 /* FIXME: These two are bogus */
633 tty->raw = 1;
634 tty->real_raw = 1;
635 }
636 /* 631 /*
637 * Lose the small buffers usbserial provides. Make larger ones. 632 * Lose the small buffers usbserial provides. Make larger ones.
638 */ 633 */
diff --git a/drivers/usb/serial/ipw.c b/drivers/usb/serial/ipw.c
index 29ad038b9c8d..727d323f092a 100644
--- a/drivers/usb/serial/ipw.c
+++ b/drivers/usb/serial/ipw.c
@@ -193,8 +193,7 @@ static void ipw_read_bulk_callback(struct urb *urb)
193 return; 193 return;
194} 194}
195 195
196static int ipw_open(struct tty_struct *tty, 196static int ipw_open(struct tty_struct *tty, struct usb_serial_port *port)
197 struct usb_serial_port *port, struct file *filp)
198{ 197{
199 struct usb_device *dev = port->serial->dev; 198 struct usb_device *dev = port->serial->dev;
200 u8 buf_flow_static[16] = IPW_BYTES_FLOWINIT; 199 u8 buf_flow_static[16] = IPW_BYTES_FLOWINIT;
diff --git a/drivers/usb/serial/ir-usb.c b/drivers/usb/serial/ir-usb.c
index 66009b6b763a..95d8d26b9a44 100644
--- a/drivers/usb/serial/ir-usb.c
+++ b/drivers/usb/serial/ir-usb.c
@@ -86,8 +86,7 @@ static int buffer_size;
86static int xbof = -1; 86static int xbof = -1;
87 87
88static int ir_startup (struct usb_serial *serial); 88static int ir_startup (struct usb_serial *serial);
89static int ir_open(struct tty_struct *tty, struct usb_serial_port *port, 89static int ir_open(struct tty_struct *tty, struct usb_serial_port *port);
90 struct file *filep);
91static void ir_close(struct usb_serial_port *port); 90static void ir_close(struct usb_serial_port *port);
92static int ir_write(struct tty_struct *tty, struct usb_serial_port *port, 91static int ir_write(struct tty_struct *tty, struct usb_serial_port *port,
93 const unsigned char *buf, int count); 92 const unsigned char *buf, int count);
@@ -296,8 +295,7 @@ static int ir_startup(struct usb_serial *serial)
296 return 0; 295 return 0;
297} 296}
298 297
299static int ir_open(struct tty_struct *tty, 298static int ir_open(struct tty_struct *tty, struct usb_serial_port *port)
300 struct usb_serial_port *port, struct file *filp)
301{ 299{
302 char *buffer; 300 char *buffer;
303 int result = 0; 301 int result = 0;
diff --git a/drivers/usb/serial/iuu_phoenix.c b/drivers/usb/serial/iuu_phoenix.c
index 96873a7a32b0..6138c1cda35f 100644
--- a/drivers/usb/serial/iuu_phoenix.c
+++ b/drivers/usb/serial/iuu_phoenix.c
@@ -71,7 +71,6 @@ struct iuu_private {
71 spinlock_t lock; /* store irq state */ 71 spinlock_t lock; /* store irq state */
72 wait_queue_head_t delta_msr_wait; 72 wait_queue_head_t delta_msr_wait;
73 u8 line_status; 73 u8 line_status;
74 u8 termios_initialized;
75 int tiostatus; /* store IUART SIGNAL for tiocmget call */ 74 int tiostatus; /* store IUART SIGNAL for tiocmget call */
76 u8 reset; /* if 1 reset is needed */ 75 u8 reset; /* if 1 reset is needed */
77 int poll; /* number of poll */ 76 int poll; /* number of poll */
@@ -1018,14 +1017,24 @@ static void iuu_close(struct usb_serial_port *port)
1018 } 1017 }
1019} 1018}
1020 1019
1021static int iuu_open(struct tty_struct *tty, 1020static void iuu_init_termios(struct tty_struct *tty)
1022 struct usb_serial_port *port, struct file *filp) 1021{
1022 *(tty->termios) = tty_std_termios;
1023 tty->termios->c_cflag = CLOCAL | CREAD | CS8 | B9600
1024 | TIOCM_CTS | CSTOPB | PARENB;
1025 tty->termios->c_ispeed = 9600;
1026 tty->termios->c_ospeed = 9600;
1027 tty->termios->c_lflag = 0;
1028 tty->termios->c_oflag = 0;
1029 tty->termios->c_iflag = 0;
1030}
1031
1032static int iuu_open(struct tty_struct *tty, struct usb_serial_port *port)
1023{ 1033{
1024 struct usb_serial *serial = port->serial; 1034 struct usb_serial *serial = port->serial;
1025 u8 *buf; 1035 u8 *buf;
1026 int result; 1036 int result;
1027 u32 actual; 1037 u32 actual;
1028 unsigned long flags;
1029 struct iuu_private *priv = usb_get_serial_port_data(port); 1038 struct iuu_private *priv = usb_get_serial_port_data(port);
1030 1039
1031 dbg("%s - port %d", __func__, port->number); 1040 dbg("%s - port %d", __func__, port->number);
@@ -1064,21 +1073,7 @@ static int iuu_open(struct tty_struct *tty,
1064 port->bulk_in_buffer, 512, 1073 port->bulk_in_buffer, 512,
1065 NULL, NULL); 1074 NULL, NULL);
1066 1075
1067 /* set the termios structure */ 1076 priv->poll = 0;
1068 spin_lock_irqsave(&priv->lock, flags);
1069 if (tty && !priv->termios_initialized) {
1070 *(tty->termios) = tty_std_termios;
1071 tty->termios->c_cflag = CLOCAL | CREAD | CS8 | B9600
1072 | TIOCM_CTS | CSTOPB | PARENB;
1073 tty->termios->c_ispeed = 9600;
1074 tty->termios->c_ospeed = 9600;
1075 tty->termios->c_lflag = 0;
1076 tty->termios->c_oflag = 0;
1077 tty->termios->c_iflag = 0;
1078 priv->termios_initialized = 1;
1079 priv->poll = 0;
1080 }
1081 spin_unlock_irqrestore(&priv->lock, flags);
1082 1077
1083 /* initialize writebuf */ 1078 /* initialize writebuf */
1084#define FISH(a, b, c, d) do { \ 1079#define FISH(a, b, c, d) do { \
@@ -1201,6 +1196,7 @@ static struct usb_serial_driver iuu_device = {
1201 .tiocmget = iuu_tiocmget, 1196 .tiocmget = iuu_tiocmget,
1202 .tiocmset = iuu_tiocmset, 1197 .tiocmset = iuu_tiocmset,
1203 .set_termios = iuu_set_termios, 1198 .set_termios = iuu_set_termios,
1199 .init_termios = iuu_init_termios,
1204 .attach = iuu_startup, 1200 .attach = iuu_startup,
1205 .release = iuu_release, 1201 .release = iuu_release,
1206}; 1202};
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index 2594b8743d3f..f8c4b07033ff 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -1209,8 +1209,7 @@ static int keyspan_write_room(struct tty_struct *tty)
1209} 1209}
1210 1210
1211 1211
1212static int keyspan_open(struct tty_struct *tty, 1212static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port)
1213 struct usb_serial_port *port, struct file *filp)
1214{ 1213{
1215 struct keyspan_port_private *p_priv; 1214 struct keyspan_port_private *p_priv;
1216 struct keyspan_serial_private *s_priv; 1215 struct keyspan_serial_private *s_priv;
diff --git a/drivers/usb/serial/keyspan.h b/drivers/usb/serial/keyspan.h
index 3107ed15af64..30771e5b3973 100644
--- a/drivers/usb/serial/keyspan.h
+++ b/drivers/usb/serial/keyspan.h
@@ -36,8 +36,7 @@
36 36
37/* Function prototypes for Keyspan serial converter */ 37/* Function prototypes for Keyspan serial converter */
38static int keyspan_open (struct tty_struct *tty, 38static int keyspan_open (struct tty_struct *tty,
39 struct usb_serial_port *port, 39 struct usb_serial_port *port);
40 struct file *filp);
41static void keyspan_close (struct usb_serial_port *port); 40static void keyspan_close (struct usb_serial_port *port);
42static void keyspan_dtr_rts (struct usb_serial_port *port, int on); 41static void keyspan_dtr_rts (struct usb_serial_port *port, int on);
43static int keyspan_startup (struct usb_serial *serial); 42static int keyspan_startup (struct usb_serial *serial);
diff --git a/drivers/usb/serial/keyspan_pda.c b/drivers/usb/serial/keyspan_pda.c
index d0b12e40c2b1..257c16cc6b2a 100644
--- a/drivers/usb/serial/keyspan_pda.c
+++ b/drivers/usb/serial/keyspan_pda.c
@@ -681,7 +681,7 @@ static int keyspan_pda_carrier_raised(struct usb_serial_port *port)
681 681
682 682
683static int keyspan_pda_open(struct tty_struct *tty, 683static int keyspan_pda_open(struct tty_struct *tty,
684 struct usb_serial_port *port, struct file *filp) 684 struct usb_serial_port *port)
685{ 685{
686 struct usb_serial *serial = port->serial; 686 struct usb_serial *serial = port->serial;
687 unsigned char room; 687 unsigned char room;
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c
index 0f44bb8e8d4f..a61673133d7d 100644
--- a/drivers/usb/serial/kl5kusb105.c
+++ b/drivers/usb/serial/kl5kusb105.c
@@ -75,8 +75,7 @@ static int debug;
75static int klsi_105_startup(struct usb_serial *serial); 75static int klsi_105_startup(struct usb_serial *serial);
76static void klsi_105_disconnect(struct usb_serial *serial); 76static void klsi_105_disconnect(struct usb_serial *serial);
77static void klsi_105_release(struct usb_serial *serial); 77static void klsi_105_release(struct usb_serial *serial);
78static int klsi_105_open(struct tty_struct *tty, 78static int klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port);
79 struct usb_serial_port *port, struct file *filp);
80static void klsi_105_close(struct usb_serial_port *port); 79static void klsi_105_close(struct usb_serial_port *port);
81static int klsi_105_write(struct tty_struct *tty, 80static int klsi_105_write(struct tty_struct *tty,
82 struct usb_serial_port *port, const unsigned char *buf, int count); 81 struct usb_serial_port *port, const unsigned char *buf, int count);
@@ -358,8 +357,7 @@ static void klsi_105_release(struct usb_serial *serial)
358 } 357 }
359} /* klsi_105_release */ 358} /* klsi_105_release */
360 359
361static int klsi_105_open(struct tty_struct *tty, 360static int klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port)
362 struct usb_serial_port *port, struct file *filp)
363{ 361{
364 struct klsi_105_private *priv = usb_get_serial_port_data(port); 362 struct klsi_105_private *priv = usb_get_serial_port_data(port);
365 int retval = 0; 363 int retval = 0;
@@ -371,10 +369,6 @@ static int klsi_105_open(struct tty_struct *tty,
371 369
372 dbg("%s port %d", __func__, port->number); 370 dbg("%s port %d", __func__, port->number);
373 371
374 /* force low_latency on so that our tty_push actually forces
375 * the data through
376 * tty->low_latency = 1; */
377
378 /* Do a defined restart: 372 /* Do a defined restart:
379 * Set up sane default baud rate and send the 'READ_ON' 373 * Set up sane default baud rate and send the 'READ_ON'
380 * vendor command. 374 * vendor command.
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index 6db0e561f680..45ea694b3ae6 100644
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -70,8 +70,7 @@ static int debug;
70/* Function prototypes */ 70/* Function prototypes */
71static int kobil_startup(struct usb_serial *serial); 71static int kobil_startup(struct usb_serial *serial);
72static void kobil_release(struct usb_serial *serial); 72static void kobil_release(struct usb_serial *serial);
73static int kobil_open(struct tty_struct *tty, 73static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port);
74 struct usb_serial_port *port, struct file *filp);
75static void kobil_close(struct usb_serial_port *port); 74static void kobil_close(struct usb_serial_port *port);
76static int kobil_write(struct tty_struct *tty, struct usb_serial_port *port, 75static int kobil_write(struct tty_struct *tty, struct usb_serial_port *port,
77 const unsigned char *buf, int count); 76 const unsigned char *buf, int count);
@@ -85,7 +84,7 @@ static void kobil_read_int_callback(struct urb *urb);
85static void kobil_write_callback(struct urb *purb); 84static void kobil_write_callback(struct urb *purb);
86static void kobil_set_termios(struct tty_struct *tty, 85static void kobil_set_termios(struct tty_struct *tty,
87 struct usb_serial_port *port, struct ktermios *old); 86 struct usb_serial_port *port, struct ktermios *old);
88 87static void kobil_init_termios(struct tty_struct *tty);
89 88
90static struct usb_device_id id_table [] = { 89static struct usb_device_id id_table [] = {
91 { USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_ADAPTER_B_PRODUCT_ID) }, 90 { USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_ADAPTER_B_PRODUCT_ID) },
@@ -120,6 +119,7 @@ static struct usb_serial_driver kobil_device = {
120 .release = kobil_release, 119 .release = kobil_release,
121 .ioctl = kobil_ioctl, 120 .ioctl = kobil_ioctl,
122 .set_termios = kobil_set_termios, 121 .set_termios = kobil_set_termios,
122 .init_termios = kobil_init_termios,
123 .tiocmget = kobil_tiocmget, 123 .tiocmget = kobil_tiocmget,
124 .tiocmset = kobil_tiocmset, 124 .tiocmset = kobil_tiocmset,
125 .open = kobil_open, 125 .open = kobil_open,
@@ -210,9 +210,17 @@ static void kobil_release(struct usb_serial *serial)
210 kfree(usb_get_serial_port_data(serial->port[i])); 210 kfree(usb_get_serial_port_data(serial->port[i]));
211} 211}
212 212
213static void kobil_init_termios(struct tty_struct *tty)
214{
215 /* Default to echo off and other sane device settings */
216 tty->termios->c_lflag = 0;
217 tty->termios->c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN | XCASE);
218 tty->termios->c_iflag = IGNBRK | IGNPAR | IXOFF;
219 /* do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D) */
220 tty->termios->c_oflag &= ~ONLCR;
221}
213 222
214static int kobil_open(struct tty_struct *tty, 223static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port)
215 struct usb_serial_port *port, struct file *filp)
216{ 224{
217 int result = 0; 225 int result = 0;
218 struct kobil_private *priv; 226 struct kobil_private *priv;
@@ -226,16 +234,6 @@ static int kobil_open(struct tty_struct *tty,
226 /* someone sets the dev to 0 if the close method has been called */ 234 /* someone sets the dev to 0 if the close method has been called */
227 port->interrupt_in_urb->dev = port->serial->dev; 235 port->interrupt_in_urb->dev = port->serial->dev;
228 236
229 if (tty) {
230
231 /* Default to echo off and other sane device settings */
232 tty->termios->c_lflag = 0;
233 tty->termios->c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN |
234 XCASE);
235 tty->termios->c_iflag = IGNBRK | IGNPAR | IXOFF;
236 /* do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D) */
237 tty->termios->c_oflag &= ~ONLCR;
238 }
239 /* allocate memory for transfer buffer */ 237 /* allocate memory for transfer buffer */
240 transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL); 238 transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
241 if (!transfer_buffer) 239 if (!transfer_buffer)
diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
index d8825e159aa5..ad4998bbf16f 100644
--- a/drivers/usb/serial/mct_u232.c
+++ b/drivers/usb/serial/mct_u232.c
@@ -93,8 +93,7 @@ static int debug;
93 */ 93 */
94static int mct_u232_startup(struct usb_serial *serial); 94static int mct_u232_startup(struct usb_serial *serial);
95static void mct_u232_release(struct usb_serial *serial); 95static void mct_u232_release(struct usb_serial *serial);
96static int mct_u232_open(struct tty_struct *tty, 96static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port);
97 struct usb_serial_port *port, struct file *filp);
98static void mct_u232_close(struct usb_serial_port *port); 97static void mct_u232_close(struct usb_serial_port *port);
99static void mct_u232_dtr_rts(struct usb_serial_port *port, int on); 98static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
100static void mct_u232_read_int_callback(struct urb *urb); 99static void mct_u232_read_int_callback(struct urb *urb);
@@ -421,8 +420,7 @@ static void mct_u232_release(struct usb_serial *serial)
421 } 420 }
422} /* mct_u232_release */ 421} /* mct_u232_release */
423 422
424static int mct_u232_open(struct tty_struct *tty, 423static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
425 struct usb_serial_port *port, struct file *filp)
426{ 424{
427 struct usb_serial *serial = port->serial; 425 struct usb_serial *serial = port->serial;
428 struct mct_u232_private *priv = usb_get_serial_port_data(port); 426 struct mct_u232_private *priv = usb_get_serial_port_data(port);
@@ -568,10 +566,13 @@ static void mct_u232_read_int_callback(struct urb *urb)
568 * Work-a-round: handle the 'usual' bulk-in pipe here 566 * Work-a-round: handle the 'usual' bulk-in pipe here
569 */ 567 */
570 if (urb->transfer_buffer_length > 2) { 568 if (urb->transfer_buffer_length > 2) {
571 tty = tty_port_tty_get(&port->port);
572 if (urb->actual_length) { 569 if (urb->actual_length) {
573 tty_insert_flip_string(tty, data, urb->actual_length); 570 tty = tty_port_tty_get(&port->port);
574 tty_flip_buffer_push(tty); 571 if (tty) {
572 tty_insert_flip_string(tty, data,
573 urb->actual_length);
574 tty_flip_buffer_push(tty);
575 }
575 tty_kref_put(tty); 576 tty_kref_put(tty);
576 } 577 }
577 goto exit; 578 goto exit;
diff --git a/drivers/usb/serial/mos7720.c b/drivers/usb/serial/mos7720.c
index ccd4dd340d2c..763e32a44be0 100644
--- a/drivers/usb/serial/mos7720.c
+++ b/drivers/usb/serial/mos7720.c
@@ -85,7 +85,7 @@ static int debug;
85#define MOSCHIP_DEVICE_ID_7720 0x7720 85#define MOSCHIP_DEVICE_ID_7720 0x7720
86#define MOSCHIP_DEVICE_ID_7715 0x7715 86#define MOSCHIP_DEVICE_ID_7715 0x7715
87 87
88static struct usb_device_id moschip_port_id_table [] = { 88static struct usb_device_id moschip_port_id_table[] = {
89 { USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7720) }, 89 { USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7720) },
90 { } /* terminating entry */ 90 { } /* terminating entry */
91}; 91};
@@ -319,8 +319,7 @@ static int send_mos_cmd(struct usb_serial *serial, __u8 request, __u16 value,
319 return status; 319 return status;
320} 320}
321 321
322static int mos7720_open(struct tty_struct *tty, 322static int mos7720_open(struct tty_struct *tty, struct usb_serial_port *port)
323 struct usb_serial_port *port, struct file *filp)
324{ 323{
325 struct usb_serial *serial; 324 struct usb_serial *serial;
326 struct usb_serial_port *port0; 325 struct usb_serial_port *port0;
@@ -378,10 +377,14 @@ static int mos7720_open(struct tty_struct *tty,
378 /* Initialize MCS7720 -- Write Init values to corresponding Registers 377 /* Initialize MCS7720 -- Write Init values to corresponding Registers
379 * 378 *
380 * Register Index 379 * Register Index
380 * 0 : THR/RHR
381 * 1 : IER 381 * 1 : IER
382 * 2 : FCR 382 * 2 : FCR
383 * 3 : LCR 383 * 3 : LCR
384 * 4 : MCR 384 * 4 : MCR
385 * 5 : LSR
386 * 6 : MSR
387 * 7 : SPR
385 * 388 *
386 * 0x08 : SP1/2 Control Reg 389 * 0x08 : SP1/2 Control Reg
387 */ 390 */
@@ -1250,20 +1253,88 @@ static void mos7720_set_termios(struct tty_struct *tty,
1250static int get_lsr_info(struct tty_struct *tty, 1253static int get_lsr_info(struct tty_struct *tty,
1251 struct moschip_port *mos7720_port, unsigned int __user *value) 1254 struct moschip_port *mos7720_port, unsigned int __user *value)
1252{ 1255{
1253 int count; 1256 struct usb_serial_port *port = tty->driver_data;
1254 unsigned int result = 0; 1257 unsigned int result = 0;
1258 unsigned char data = 0;
1259 int port_number = port->number - port->serial->minor;
1260 int count;
1255 1261
1256 count = mos7720_chars_in_buffer(tty); 1262 count = mos7720_chars_in_buffer(tty);
1257 if (count == 0) { 1263 if (count == 0) {
1258 dbg("%s -- Empty", __func__); 1264 send_mos_cmd(port->serial, MOS_READ, port_number,
1259 result = TIOCSER_TEMT; 1265 UART_LSR, &data);
1266 if ((data & (UART_LSR_TEMT | UART_LSR_THRE))
1267 == (UART_LSR_TEMT | UART_LSR_THRE)) {
1268 dbg("%s -- Empty", __func__);
1269 result = TIOCSER_TEMT;
1270 }
1260 } 1271 }
1261
1262 if (copy_to_user(value, &result, sizeof(int))) 1272 if (copy_to_user(value, &result, sizeof(int)))
1263 return -EFAULT; 1273 return -EFAULT;
1264 return 0; 1274 return 0;
1265} 1275}
1266 1276
1277static int mos7720_tiocmget(struct tty_struct *tty, struct file *file)
1278{
1279 struct usb_serial_port *port = tty->driver_data;
1280 struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
1281 unsigned int result = 0;
1282 unsigned int mcr ;
1283 unsigned int msr ;
1284
1285 dbg("%s - port %d", __func__, port->number);
1286
1287 mcr = mos7720_port->shadowMCR;
1288 msr = mos7720_port->shadowMSR;
1289
1290 result = ((mcr & UART_MCR_DTR) ? TIOCM_DTR : 0) /* 0x002 */
1291 | ((mcr & UART_MCR_RTS) ? TIOCM_RTS : 0) /* 0x004 */
1292 | ((msr & UART_MSR_CTS) ? TIOCM_CTS : 0) /* 0x020 */
1293 | ((msr & UART_MSR_DCD) ? TIOCM_CAR : 0) /* 0x040 */
1294 | ((msr & UART_MSR_RI) ? TIOCM_RI : 0) /* 0x080 */
1295 | ((msr & UART_MSR_DSR) ? TIOCM_DSR : 0); /* 0x100 */
1296
1297 dbg("%s -- %x", __func__, result);
1298
1299 return result;
1300}
1301
1302static int mos7720_tiocmset(struct tty_struct *tty, struct file *file,
1303 unsigned int set, unsigned int clear)
1304{
1305 struct usb_serial_port *port = tty->driver_data;
1306 struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
1307 unsigned int mcr ;
1308 unsigned char lmcr;
1309
1310 dbg("%s - port %d", __func__, port->number);
1311 dbg("he was at tiocmget");
1312
1313 mcr = mos7720_port->shadowMCR;
1314
1315 if (set & TIOCM_RTS)
1316 mcr |= UART_MCR_RTS;
1317 if (set & TIOCM_DTR)
1318 mcr |= UART_MCR_DTR;
1319 if (set & TIOCM_LOOP)
1320 mcr |= UART_MCR_LOOP;
1321
1322 if (clear & TIOCM_RTS)
1323 mcr &= ~UART_MCR_RTS;
1324 if (clear & TIOCM_DTR)
1325 mcr &= ~UART_MCR_DTR;
1326 if (clear & TIOCM_LOOP)
1327 mcr &= ~UART_MCR_LOOP;
1328
1329 mos7720_port->shadowMCR = mcr;
1330 lmcr = mos7720_port->shadowMCR;
1331
1332 send_mos_cmd(port->serial, MOS_WRITE,
1333 port->number - port->serial->minor, UART_MCR, &lmcr);
1334
1335 return 0;
1336}
1337
1267static int set_modem_info(struct moschip_port *mos7720_port, unsigned int cmd, 1338static int set_modem_info(struct moschip_port *mos7720_port, unsigned int cmd,
1268 unsigned int __user *value) 1339 unsigned int __user *value)
1269{ 1340{
@@ -1301,14 +1372,6 @@ static int set_modem_info(struct moschip_port *mos7720_port, unsigned int cmd,
1301 mcr &= ~UART_MCR_LOOP; 1372 mcr &= ~UART_MCR_LOOP;
1302 break; 1373 break;
1303 1374
1304 case TIOCMSET:
1305 /* turn off the RTS and DTR and LOOPBACK
1306 * and then only turn on what was asked to */
1307 mcr &= ~(UART_MCR_RTS | UART_MCR_DTR | UART_MCR_LOOP);
1308 mcr |= ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0);
1309 mcr |= ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0);
1310 mcr |= ((arg & TIOCM_LOOP) ? UART_MCR_LOOP : 0);
1311 break;
1312 } 1375 }
1313 1376
1314 mos7720_port->shadowMCR = mcr; 1377 mos7720_port->shadowMCR = mcr;
@@ -1320,28 +1383,6 @@ static int set_modem_info(struct moschip_port *mos7720_port, unsigned int cmd,
1320 return 0; 1383 return 0;
1321} 1384}
1322 1385
1323static int get_modem_info(struct moschip_port *mos7720_port,
1324 unsigned int __user *value)
1325{
1326 unsigned int result = 0;
1327 unsigned int msr = mos7720_port->shadowMSR;
1328 unsigned int mcr = mos7720_port->shadowMCR;
1329
1330 result = ((mcr & UART_MCR_DTR) ? TIOCM_DTR: 0) /* 0x002 */
1331 | ((mcr & UART_MCR_RTS) ? TIOCM_RTS: 0) /* 0x004 */
1332 | ((msr & UART_MSR_CTS) ? TIOCM_CTS: 0) /* 0x020 */
1333 | ((msr & UART_MSR_DCD) ? TIOCM_CAR: 0) /* 0x040 */
1334 | ((msr & UART_MSR_RI) ? TIOCM_RI: 0) /* 0x080 */
1335 | ((msr & UART_MSR_DSR) ? TIOCM_DSR: 0); /* 0x100 */
1336
1337
1338 dbg("%s -- %x", __func__, result);
1339
1340 if (copy_to_user(value, &result, sizeof(int)))
1341 return -EFAULT;
1342 return 0;
1343}
1344
1345static int get_serial_info(struct moschip_port *mos7720_port, 1386static int get_serial_info(struct moschip_port *mos7720_port,
1346 struct serial_struct __user *retinfo) 1387 struct serial_struct __user *retinfo)
1347{ 1388{
@@ -1392,17 +1433,11 @@ static int mos7720_ioctl(struct tty_struct *tty, struct file *file,
1392 /* FIXME: These should be using the mode methods */ 1433 /* FIXME: These should be using the mode methods */
1393 case TIOCMBIS: 1434 case TIOCMBIS:
1394 case TIOCMBIC: 1435 case TIOCMBIC:
1395 case TIOCMSET:
1396 dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET", 1436 dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET",
1397 __func__, port->number); 1437 __func__, port->number);
1398 return set_modem_info(mos7720_port, cmd, 1438 return set_modem_info(mos7720_port, cmd,
1399 (unsigned int __user *)arg); 1439 (unsigned int __user *)arg);
1400 1440
1401 case TIOCMGET:
1402 dbg("%s (%d) TIOCMGET", __func__, port->number);
1403 return get_modem_info(mos7720_port,
1404 (unsigned int __user *)arg);
1405
1406 case TIOCGSERIAL: 1441 case TIOCGSERIAL:
1407 dbg("%s (%d) TIOCGSERIAL", __func__, port->number); 1442 dbg("%s (%d) TIOCGSERIAL", __func__, port->number);
1408 return get_serial_info(mos7720_port, 1443 return get_serial_info(mos7720_port,
@@ -1557,6 +1592,8 @@ static struct usb_serial_driver moschip7720_2port_driver = {
1557 .attach = mos7720_startup, 1592 .attach = mos7720_startup,
1558 .release = mos7720_release, 1593 .release = mos7720_release,
1559 .ioctl = mos7720_ioctl, 1594 .ioctl = mos7720_ioctl,
1595 .tiocmget = mos7720_tiocmget,
1596 .tiocmset = mos7720_tiocmset,
1560 .set_termios = mos7720_set_termios, 1597 .set_termios = mos7720_set_termios,
1561 .write = mos7720_write, 1598 .write = mos7720_write,
1562 .write_room = mos7720_write_room, 1599 .write_room = mos7720_write_room,
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c
index 270009afdf77..f11abf52be7d 100644
--- a/drivers/usb/serial/mos7840.c
+++ b/drivers/usb/serial/mos7840.c
@@ -824,8 +824,7 @@ static int mos7840_serial_probe(struct usb_serial *serial,
824 * Otherwise we return a negative error number. 824 * Otherwise we return a negative error number.
825 *****************************************************************************/ 825 *****************************************************************************/
826 826
827static int mos7840_open(struct tty_struct *tty, 827static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
828 struct usb_serial_port *port, struct file *filp)
829{ 828{
830 int response; 829 int response;
831 int j; 830 int j;
@@ -2134,106 +2133,6 @@ static int mos7840_get_lsr_info(struct tty_struct *tty,
2134} 2133}
2135 2134
2136/***************************************************************************** 2135/*****************************************************************************
2137 * mos7840_set_modem_info
2138 * function to set modem info
2139 *****************************************************************************/
2140
2141/* FIXME: Should be using the model control hooks */
2142
2143static int mos7840_set_modem_info(struct moschip_port *mos7840_port,
2144 unsigned int cmd, unsigned int __user *value)
2145{
2146 unsigned int mcr;
2147 unsigned int arg;
2148 __u16 Data;
2149 int status;
2150 struct usb_serial_port *port;
2151
2152 if (mos7840_port == NULL)
2153 return -1;
2154
2155 port = (struct usb_serial_port *)mos7840_port->port;
2156 if (mos7840_port_paranoia_check(port, __func__)) {
2157 dbg("%s", "Invalid port");
2158 return -1;
2159 }
2160
2161 mcr = mos7840_port->shadowMCR;
2162
2163 if (copy_from_user(&arg, value, sizeof(int)))
2164 return -EFAULT;
2165
2166 switch (cmd) {
2167 case TIOCMBIS:
2168 if (arg & TIOCM_RTS)
2169 mcr |= MCR_RTS;
2170 if (arg & TIOCM_DTR)
2171 mcr |= MCR_RTS;
2172 if (arg & TIOCM_LOOP)
2173 mcr |= MCR_LOOPBACK;
2174 break;
2175
2176 case TIOCMBIC:
2177 if (arg & TIOCM_RTS)
2178 mcr &= ~MCR_RTS;
2179 if (arg & TIOCM_DTR)
2180 mcr &= ~MCR_RTS;
2181 if (arg & TIOCM_LOOP)
2182 mcr &= ~MCR_LOOPBACK;
2183 break;
2184
2185 case TIOCMSET:
2186 /* turn off the RTS and DTR and LOOPBACK
2187 * and then only turn on what was asked to */
2188 mcr &= ~(MCR_RTS | MCR_DTR | MCR_LOOPBACK);
2189 mcr |= ((arg & TIOCM_RTS) ? MCR_RTS : 0);
2190 mcr |= ((arg & TIOCM_DTR) ? MCR_DTR : 0);
2191 mcr |= ((arg & TIOCM_LOOP) ? MCR_LOOPBACK : 0);
2192 break;
2193 }
2194
2195 lock_kernel();
2196 mos7840_port->shadowMCR = mcr;
2197
2198 Data = mos7840_port->shadowMCR;
2199 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
2200 unlock_kernel();
2201 if (status < 0) {
2202 dbg("setting MODEM_CONTROL_REGISTER Failed");
2203 return -1;
2204 }
2205
2206 return 0;
2207}
2208
2209/*****************************************************************************
2210 * mos7840_get_modem_info
2211 * function to get modem info
2212 *****************************************************************************/
2213
2214static int mos7840_get_modem_info(struct moschip_port *mos7840_port,
2215 unsigned int __user *value)
2216{
2217 unsigned int result = 0;
2218 __u16 msr;
2219 unsigned int mcr = mos7840_port->shadowMCR;
2220 mos7840_get_uart_reg(mos7840_port->port,
2221 MODEM_STATUS_REGISTER, &msr);
2222 result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0) /* 0x002 */
2223 |((mcr & MCR_RTS) ? TIOCM_RTS : 0) /* 0x004 */
2224 |((msr & MOS7840_MSR_CTS) ? TIOCM_CTS : 0) /* 0x020 */
2225 |((msr & MOS7840_MSR_CD) ? TIOCM_CAR : 0) /* 0x040 */
2226 |((msr & MOS7840_MSR_RI) ? TIOCM_RI : 0) /* 0x080 */
2227 |((msr & MOS7840_MSR_DSR) ? TIOCM_DSR : 0); /* 0x100 */
2228
2229 dbg("%s -- %x", __func__, result);
2230
2231 if (copy_to_user(value, &result, sizeof(int)))
2232 return -EFAULT;
2233 return 0;
2234}
2235
2236/*****************************************************************************
2237 * mos7840_get_serial_info 2136 * mos7840_get_serial_info
2238 * function to get information about serial port 2137 * function to get information about serial port
2239 *****************************************************************************/ 2138 *****************************************************************************/
@@ -2281,7 +2180,6 @@ static int mos7840_ioctl(struct tty_struct *tty, struct file *file,
2281 struct async_icount cnow; 2180 struct async_icount cnow;
2282 struct async_icount cprev; 2181 struct async_icount cprev;
2283 struct serial_icounter_struct icount; 2182 struct serial_icounter_struct icount;
2284 int mosret = 0;
2285 2183
2286 if (mos7840_port_paranoia_check(port, __func__)) { 2184 if (mos7840_port_paranoia_check(port, __func__)) {
2287 dbg("%s", "Invalid port"); 2185 dbg("%s", "Invalid port");
@@ -2303,20 +2201,6 @@ static int mos7840_ioctl(struct tty_struct *tty, struct file *file,
2303 return mos7840_get_lsr_info(tty, argp); 2201 return mos7840_get_lsr_info(tty, argp);
2304 return 0; 2202 return 0;
2305 2203
2306 /* FIXME: use the modem hooks and remove this */
2307 case TIOCMBIS:
2308 case TIOCMBIC:
2309 case TIOCMSET:
2310 dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET", __func__,
2311 port->number);
2312 mosret =
2313 mos7840_set_modem_info(mos7840_port, cmd, argp);
2314 return mosret;
2315
2316 case TIOCMGET:
2317 dbg("%s (%d) TIOCMGET", __func__, port->number);
2318 return mos7840_get_modem_info(mos7840_port, argp);
2319
2320 case TIOCGSERIAL: 2204 case TIOCGSERIAL:
2321 dbg("%s (%d) TIOCGSERIAL", __func__, port->number); 2205 dbg("%s (%d) TIOCGSERIAL", __func__, port->number);
2322 return mos7840_get_serial_info(mos7840_port, argp); 2206 return mos7840_get_serial_info(mos7840_port, argp);
diff --git a/drivers/usb/serial/navman.c b/drivers/usb/serial/navman.c
index f5f3751a888c..5ceaa4c6be09 100644
--- a/drivers/usb/serial/navman.c
+++ b/drivers/usb/serial/navman.c
@@ -80,8 +80,7 @@ exit:
80 __func__, result); 80 __func__, result);
81} 81}
82 82
83static int navman_open(struct tty_struct *tty, 83static int navman_open(struct tty_struct *tty, struct usb_serial_port *port)
84 struct usb_serial_port *port, struct file *filp)
85{ 84{
86 int result = 0; 85 int result = 0;
87 86
diff --git a/drivers/usb/serial/omninet.c b/drivers/usb/serial/omninet.c
index 56857ddbd70b..062265038bf0 100644
--- a/drivers/usb/serial/omninet.c
+++ b/drivers/usb/serial/omninet.c
@@ -64,8 +64,7 @@ static int debug;
64#define BT_IGNITIONPRO_ID 0x2000 64#define BT_IGNITIONPRO_ID 0x2000
65 65
66/* function prototypes */ 66/* function prototypes */
67static int omninet_open(struct tty_struct *tty, struct usb_serial_port *port, 67static int omninet_open(struct tty_struct *tty, struct usb_serial_port *port);
68 struct file *filp);
69static void omninet_close(struct usb_serial_port *port); 68static void omninet_close(struct usb_serial_port *port);
70static void omninet_read_bulk_callback(struct urb *urb); 69static void omninet_read_bulk_callback(struct urb *urb);
71static void omninet_write_bulk_callback(struct urb *urb); 70static void omninet_write_bulk_callback(struct urb *urb);
@@ -163,8 +162,7 @@ static int omninet_attach(struct usb_serial *serial)
163 return 0; 162 return 0;
164} 163}
165 164
166static int omninet_open(struct tty_struct *tty, 165static int omninet_open(struct tty_struct *tty, struct usb_serial_port *port)
167 struct usb_serial_port *port, struct file *filp)
168{ 166{
169 struct usb_serial *serial = port->serial; 167 struct usb_serial *serial = port->serial;
170 struct usb_serial_port *wport; 168 struct usb_serial_port *wport;
diff --git a/drivers/usb/serial/opticon.c b/drivers/usb/serial/opticon.c
index 336bba79ad32..1085a577c5c1 100644
--- a/drivers/usb/serial/opticon.c
+++ b/drivers/usb/serial/opticon.c
@@ -144,8 +144,7 @@ exit:
144 spin_unlock(&priv->lock); 144 spin_unlock(&priv->lock);
145} 145}
146 146
147static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port, 147static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port)
148 struct file *filp)
149{ 148{
150 struct opticon_private *priv = usb_get_serial_data(port->serial); 149 struct opticon_private *priv = usb_get_serial_data(port->serial);
151 unsigned long flags; 150 unsigned long flags;
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index c784ddbe7b61..fe47051dbef2 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -45,8 +45,7 @@
45/* Function prototypes */ 45/* Function prototypes */
46static int option_probe(struct usb_serial *serial, 46static int option_probe(struct usb_serial *serial,
47 const struct usb_device_id *id); 47 const struct usb_device_id *id);
48static int option_open(struct tty_struct *tty, struct usb_serial_port *port, 48static int option_open(struct tty_struct *tty, struct usb_serial_port *port);
49 struct file *filp);
50static void option_close(struct usb_serial_port *port); 49static void option_close(struct usb_serial_port *port);
51static void option_dtr_rts(struct usb_serial_port *port, int on); 50static void option_dtr_rts(struct usb_serial_port *port, int on);
52 51
@@ -961,8 +960,7 @@ static int option_chars_in_buffer(struct tty_struct *tty)
961 return data_len; 960 return data_len;
962} 961}
963 962
964static int option_open(struct tty_struct *tty, 963static int option_open(struct tty_struct *tty, struct usb_serial_port *port)
965 struct usb_serial_port *port, struct file *filp)
966{ 964{
967 struct option_port_private *portdata; 965 struct option_port_private *portdata;
968 int i, err; 966 int i, err;
diff --git a/drivers/usb/serial/oti6858.c b/drivers/usb/serial/oti6858.c
index 3cece27325e7..0f4a70ce3823 100644
--- a/drivers/usb/serial/oti6858.c
+++ b/drivers/usb/serial/oti6858.c
@@ -141,11 +141,11 @@ struct oti6858_control_pkt {
141 && ((a)->frame_fmt == (priv)->pending_setup.frame_fmt)) 141 && ((a)->frame_fmt == (priv)->pending_setup.frame_fmt))
142 142
143/* function prototypes */ 143/* function prototypes */
144static int oti6858_open(struct tty_struct *tty, 144static int oti6858_open(struct tty_struct *tty, struct usb_serial_port *port);
145 struct usb_serial_port *port, struct file *filp);
146static void oti6858_close(struct usb_serial_port *port); 145static void oti6858_close(struct usb_serial_port *port);
147static void oti6858_set_termios(struct tty_struct *tty, 146static void oti6858_set_termios(struct tty_struct *tty,
148 struct usb_serial_port *port, struct ktermios *old); 147 struct usb_serial_port *port, struct ktermios *old);
148static void oti6858_init_termios(struct tty_struct *tty);
149static int oti6858_ioctl(struct tty_struct *tty, struct file *file, 149static int oti6858_ioctl(struct tty_struct *tty, struct file *file,
150 unsigned int cmd, unsigned long arg); 150 unsigned int cmd, unsigned long arg);
151static void oti6858_read_int_callback(struct urb *urb); 151static void oti6858_read_int_callback(struct urb *urb);
@@ -186,6 +186,7 @@ static struct usb_serial_driver oti6858_device = {
186 .write = oti6858_write, 186 .write = oti6858_write,
187 .ioctl = oti6858_ioctl, 187 .ioctl = oti6858_ioctl,
188 .set_termios = oti6858_set_termios, 188 .set_termios = oti6858_set_termios,
189 .init_termios = oti6858_init_termios,
189 .tiocmget = oti6858_tiocmget, 190 .tiocmget = oti6858_tiocmget,
190 .tiocmset = oti6858_tiocmset, 191 .tiocmset = oti6858_tiocmset,
191 .read_bulk_callback = oti6858_read_bulk_callback, 192 .read_bulk_callback = oti6858_read_bulk_callback,
@@ -206,7 +207,6 @@ struct oti6858_private {
206 struct { 207 struct {
207 u8 read_urb_in_use; 208 u8 read_urb_in_use;
208 u8 write_urb_in_use; 209 u8 write_urb_in_use;
209 u8 termios_initialized;
210 } flags; 210 } flags;
211 struct delayed_work delayed_write_work; 211 struct delayed_work delayed_write_work;
212 212
@@ -447,6 +447,14 @@ static int oti6858_chars_in_buffer(struct tty_struct *tty)
447 return chars; 447 return chars;
448} 448}
449 449
450static void oti6858_init_termios(struct tty_struct *tty)
451{
452 *(tty->termios) = tty_std_termios;
453 tty->termios->c_cflag = B38400 | CS8 | CREAD | HUPCL | CLOCAL;
454 tty->termios->c_ispeed = 38400;
455 tty->termios->c_ospeed = 38400;
456}
457
450static void oti6858_set_termios(struct tty_struct *tty, 458static void oti6858_set_termios(struct tty_struct *tty,
451 struct usb_serial_port *port, struct ktermios *old_termios) 459 struct usb_serial_port *port, struct ktermios *old_termios)
452{ 460{
@@ -464,16 +472,6 @@ static void oti6858_set_termios(struct tty_struct *tty,
464 return; 472 return;
465 } 473 }
466 474
467 spin_lock_irqsave(&priv->lock, flags);
468 if (!priv->flags.termios_initialized) {
469 *(tty->termios) = tty_std_termios;
470 tty->termios->c_cflag = B38400 | CS8 | CREAD | HUPCL | CLOCAL;
471 tty->termios->c_ispeed = 38400;
472 tty->termios->c_ospeed = 38400;
473 priv->flags.termios_initialized = 1;
474 }
475 spin_unlock_irqrestore(&priv->lock, flags);
476
477 cflag = tty->termios->c_cflag; 475 cflag = tty->termios->c_cflag;
478 476
479 spin_lock_irqsave(&priv->lock, flags); 477 spin_lock_irqsave(&priv->lock, flags);
@@ -566,8 +564,7 @@ static void oti6858_set_termios(struct tty_struct *tty,
566 spin_unlock_irqrestore(&priv->lock, flags); 564 spin_unlock_irqrestore(&priv->lock, flags);
567} 565}
568 566
569static int oti6858_open(struct tty_struct *tty, 567static int oti6858_open(struct tty_struct *tty, struct usb_serial_port *port)
570 struct usb_serial_port *port, struct file *filp)
571{ 568{
572 struct oti6858_private *priv = usb_get_serial_port_data(port); 569 struct oti6858_private *priv = usb_get_serial_port_data(port);
573 struct ktermios tmp_termios; 570 struct ktermios tmp_termios;
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 3e86815b2705..a63ea99936f7 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -691,8 +691,7 @@ static void pl2303_close(struct usb_serial_port *port)
691 691
692} 692}
693 693
694static int pl2303_open(struct tty_struct *tty, 694static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
695 struct usb_serial_port *port, struct file *filp)
696{ 695{
697 struct ktermios tmp_termios; 696 struct ktermios tmp_termios;
698 struct usb_serial *serial = port->serial; 697 struct usb_serial *serial = port->serial;
@@ -714,8 +713,6 @@ static int pl2303_open(struct tty_struct *tty,
714 if (tty) 713 if (tty)
715 pl2303_set_termios(tty, port, &tmp_termios); 714 pl2303_set_termios(tty, port, &tmp_termios);
716 715
717 /* FIXME: need to assert RTS and DTR if CRTSCTS off */
718
719 dbg("%s - submitting read urb", __func__); 716 dbg("%s - submitting read urb", __func__);
720 port->read_urb->dev = serial->dev; 717 port->read_urb->dev = serial->dev;
721 result = usb_submit_urb(port->read_urb, GFP_KERNEL); 718 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index f48d05e0acc1..55391bbe1230 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -734,8 +734,7 @@ static void sierra_close(struct usb_serial_port *port)
734 } 734 }
735} 735}
736 736
737static int sierra_open(struct tty_struct *tty, 737static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
738 struct usb_serial_port *port, struct file *filp)
739{ 738{
740 struct sierra_port_private *portdata; 739 struct sierra_port_private *portdata;
741 struct usb_serial *serial = port->serial; 740 struct usb_serial *serial = port->serial;
diff --git a/drivers/usb/serial/spcp8x5.c b/drivers/usb/serial/spcp8x5.c
index 3c249d8e8b8e..61e7c40b94fb 100644
--- a/drivers/usb/serial/spcp8x5.c
+++ b/drivers/usb/serial/spcp8x5.c
@@ -299,7 +299,6 @@ struct spcp8x5_private {
299 wait_queue_head_t delta_msr_wait; 299 wait_queue_head_t delta_msr_wait;
300 u8 line_control; 300 u8 line_control;
301 u8 line_status; 301 u8 line_status;
302 u8 termios_initialized;
303}; 302};
304 303
305/* desc : when device plug in,this function would be called. 304/* desc : when device plug in,this function would be called.
@@ -498,6 +497,15 @@ static void spcp8x5_close(struct usb_serial_port *port)
498 dev_dbg(&port->dev, "usb_unlink_urb(read_urb) = %d\n", result); 497 dev_dbg(&port->dev, "usb_unlink_urb(read_urb) = %d\n", result);
499} 498}
500 499
500static void spcp8x5_init_termios(struct tty_struct *tty)
501{
502 /* for the 1st time call this function */
503 *(tty->termios) = tty_std_termios;
504 tty->termios->c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL;
505 tty->termios->c_ispeed = 115200;
506 tty->termios->c_ospeed = 115200;
507}
508
501/* set the serial param for transfer. we should check if we really need to 509/* set the serial param for transfer. we should check if we really need to
502 * transfer. if we set flow control we should do this too. */ 510 * transfer. if we set flow control we should do this too. */
503static void spcp8x5_set_termios(struct tty_struct *tty, 511static void spcp8x5_set_termios(struct tty_struct *tty,
@@ -514,16 +522,6 @@ static void spcp8x5_set_termios(struct tty_struct *tty,
514 int i; 522 int i;
515 u8 control; 523 u8 control;
516 524
517 /* for the 1st time call this function */
518 spin_lock_irqsave(&priv->lock, flags);
519 if (!priv->termios_initialized) {
520 *(tty->termios) = tty_std_termios;
521 tty->termios->c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL;
522 tty->termios->c_ispeed = 115200;
523 tty->termios->c_ospeed = 115200;
524 priv->termios_initialized = 1;
525 }
526 spin_unlock_irqrestore(&priv->lock, flags);
527 525
528 /* check that they really want us to change something */ 526 /* check that they really want us to change something */
529 if (!tty_termios_hw_change(tty->termios, old_termios)) 527 if (!tty_termios_hw_change(tty->termios, old_termios))
@@ -623,8 +621,7 @@ static void spcp8x5_set_termios(struct tty_struct *tty,
623 621
624/* open the serial port. do some usb system call. set termios and get the line 622/* open the serial port. do some usb system call. set termios and get the line
625 * status of the device. then submit the read urb */ 623 * status of the device. then submit the read urb */
626static int spcp8x5_open(struct tty_struct *tty, 624static int spcp8x5_open(struct tty_struct *tty, struct usb_serial_port *port)
627 struct usb_serial_port *port, struct file *filp)
628{ 625{
629 struct ktermios tmp_termios; 626 struct ktermios tmp_termios;
630 struct usb_serial *serial = port->serial; 627 struct usb_serial *serial = port->serial;
@@ -658,8 +655,6 @@ static int spcp8x5_open(struct tty_struct *tty,
658 priv->line_status = status & 0xf0 ; 655 priv->line_status = status & 0xf0 ;
659 spin_unlock_irqrestore(&priv->lock, flags); 656 spin_unlock_irqrestore(&priv->lock, flags);
660 657
661 /* FIXME: need to assert RTS and DTR if CRTSCTS off */
662
663 dbg("%s - submitting read urb", __func__); 658 dbg("%s - submitting read urb", __func__);
664 port->read_urb->dev = serial->dev; 659 port->read_urb->dev = serial->dev;
665 ret = usb_submit_urb(port->read_urb, GFP_KERNEL); 660 ret = usb_submit_urb(port->read_urb, GFP_KERNEL);
@@ -1011,6 +1006,7 @@ static struct usb_serial_driver spcp8x5_device = {
1011 .carrier_raised = spcp8x5_carrier_raised, 1006 .carrier_raised = spcp8x5_carrier_raised,
1012 .write = spcp8x5_write, 1007 .write = spcp8x5_write,
1013 .set_termios = spcp8x5_set_termios, 1008 .set_termios = spcp8x5_set_termios,
1009 .init_termios = spcp8x5_init_termios,
1014 .ioctl = spcp8x5_ioctl, 1010 .ioctl = spcp8x5_ioctl,
1015 .tiocmget = spcp8x5_tiocmget, 1011 .tiocmget = spcp8x5_tiocmget,
1016 .tiocmset = spcp8x5_tiocmset, 1012 .tiocmset = spcp8x5_tiocmset,
diff --git a/drivers/usb/serial/symbolserial.c b/drivers/usb/serial/symbolserial.c
index 6157fac9366b..cb7e95f9fcbf 100644
--- a/drivers/usb/serial/symbolserial.c
+++ b/drivers/usb/serial/symbolserial.c
@@ -124,8 +124,7 @@ exit:
124 spin_unlock(&priv->lock); 124 spin_unlock(&priv->lock);
125} 125}
126 126
127static int symbol_open(struct tty_struct *tty, struct usb_serial_port *port, 127static int symbol_open(struct tty_struct *tty, struct usb_serial_port *port)
128 struct file *filp)
129{ 128{
130 struct symbol_private *priv = usb_get_serial_data(port->serial); 129 struct symbol_private *priv = usb_get_serial_data(port->serial);
131 unsigned long flags; 130 unsigned long flags;
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index 3bc609fe2242..1e9dc8821698 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -98,8 +98,7 @@ struct ti_device {
98 98
99static int ti_startup(struct usb_serial *serial); 99static int ti_startup(struct usb_serial *serial);
100static void ti_release(struct usb_serial *serial); 100static void ti_release(struct usb_serial *serial);
101static int ti_open(struct tty_struct *tty, struct usb_serial_port *port, 101static int ti_open(struct tty_struct *tty, struct usb_serial_port *port);
102 struct file *file);
103static void ti_close(struct usb_serial_port *port); 102static void ti_close(struct usb_serial_port *port);
104static int ti_write(struct tty_struct *tty, struct usb_serial_port *port, 103static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
105 const unsigned char *data, int count); 104 const unsigned char *data, int count);
@@ -492,8 +491,7 @@ static void ti_release(struct usb_serial *serial)
492} 491}
493 492
494 493
495static int ti_open(struct tty_struct *tty, 494static int ti_open(struct tty_struct *tty, struct usb_serial_port *port)
496 struct usb_serial_port *port, struct file *file)
497{ 495{
498 struct ti_port *tport = usb_get_serial_port_data(port); 496 struct ti_port *tport = usb_get_serial_port_data(port);
499 struct ti_device *tdev; 497 struct ti_device *tdev;
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 99188c92068b..9d7ca4868d37 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -43,8 +43,6 @@
43#define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/" 43#define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
44#define DRIVER_DESC "USB Serial Driver core" 44#define DRIVER_DESC "USB Serial Driver core"
45 45
46static void port_free(struct usb_serial_port *port);
47
48/* Driver structure we register with the USB core */ 46/* Driver structure we register with the USB core */
49static struct usb_driver usb_serial_driver = { 47static struct usb_driver usb_serial_driver = {
50 .name = "usbserial", 48 .name = "usbserial",
@@ -68,6 +66,11 @@ static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
68static DEFINE_MUTEX(table_lock); 66static DEFINE_MUTEX(table_lock);
69static LIST_HEAD(usb_serial_driver_list); 67static LIST_HEAD(usb_serial_driver_list);
70 68
69/*
70 * Look up the serial structure. If it is found and it hasn't been
71 * disconnected, return with its disc_mutex held and its refcount
72 * incremented. Otherwise return NULL.
73 */
71struct usb_serial *usb_serial_get_by_index(unsigned index) 74struct usb_serial *usb_serial_get_by_index(unsigned index)
72{ 75{
73 struct usb_serial *serial; 76 struct usb_serial *serial;
@@ -75,8 +78,15 @@ struct usb_serial *usb_serial_get_by_index(unsigned index)
75 mutex_lock(&table_lock); 78 mutex_lock(&table_lock);
76 serial = serial_table[index]; 79 serial = serial_table[index];
77 80
78 if (serial) 81 if (serial) {
79 kref_get(&serial->kref); 82 mutex_lock(&serial->disc_mutex);
83 if (serial->disconnected) {
84 mutex_unlock(&serial->disc_mutex);
85 serial = NULL;
86 } else {
87 kref_get(&serial->kref);
88 }
89 }
80 mutex_unlock(&table_lock); 90 mutex_unlock(&table_lock);
81 return serial; 91 return serial;
82} 92}
@@ -125,8 +135,10 @@ static void return_serial(struct usb_serial *serial)
125 135
126 dbg("%s", __func__); 136 dbg("%s", __func__);
127 137
138 mutex_lock(&table_lock);
128 for (i = 0; i < serial->num_ports; ++i) 139 for (i = 0; i < serial->num_ports; ++i)
129 serial_table[serial->minor + i] = NULL; 140 serial_table[serial->minor + i] = NULL;
141 mutex_unlock(&table_lock);
130} 142}
131 143
132static void destroy_serial(struct kref *kref) 144static void destroy_serial(struct kref *kref)
@@ -145,161 +157,157 @@ static void destroy_serial(struct kref *kref)
145 157
146 serial->type->release(serial); 158 serial->type->release(serial);
147 159
148 for (i = 0; i < serial->num_ports; ++i) { 160 /* Now that nothing is using the ports, they can be freed */
161 for (i = 0; i < serial->num_port_pointers; ++i) {
149 port = serial->port[i]; 162 port = serial->port[i];
150 if (port) 163 if (port) {
164 port->serial = NULL;
151 put_device(&port->dev); 165 put_device(&port->dev);
152 }
153
154 /* If this is a "fake" port, we have to clean it up here, as it will
155 * not get cleaned up in port_release() as it was never registered with
156 * the driver core */
157 if (serial->num_ports < serial->num_port_pointers) {
158 for (i = serial->num_ports;
159 i < serial->num_port_pointers; ++i) {
160 port = serial->port[i];
161 if (port)
162 port_free(port);
163 } 166 }
164 } 167 }
165 168
166 usb_put_dev(serial->dev); 169 usb_put_dev(serial->dev);
167
168 /* free up any memory that we allocated */
169 kfree(serial); 170 kfree(serial);
170} 171}
171 172
172void usb_serial_put(struct usb_serial *serial) 173void usb_serial_put(struct usb_serial *serial)
173{ 174{
174 mutex_lock(&table_lock);
175 kref_put(&serial->kref, destroy_serial); 175 kref_put(&serial->kref, destroy_serial);
176 mutex_unlock(&table_lock);
177} 176}
178 177
179/***************************************************************************** 178/*****************************************************************************
180 * Driver tty interface functions 179 * Driver tty interface functions
181 *****************************************************************************/ 180 *****************************************************************************/
182static int serial_open (struct tty_struct *tty, struct file *filp) 181
182/**
183 * serial_install - install tty
184 * @driver: the driver (USB in our case)
185 * @tty: the tty being created
186 *
187 * Create the termios objects for this tty. We use the default
188 * USB serial settings but permit them to be overridden by
189 * serial->type->init_termios.
190 *
191 * This is the first place a new tty gets used. Hence this is where we
192 * acquire references to the usb_serial structure and the driver module,
193 * where we store a pointer to the port, and where we do an autoresume.
194 * All these actions are reversed in serial_release().
195 */
196static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
183{ 197{
198 int idx = tty->index;
184 struct usb_serial *serial; 199 struct usb_serial *serial;
185 struct usb_serial_port *port; 200 struct usb_serial_port *port;
186 unsigned int portNumber; 201 int retval = -ENODEV;
187 int retval = 0;
188 int first = 0;
189 202
190 dbg("%s", __func__); 203 dbg("%s", __func__);
191 204
192 /* get the serial object associated with this tty pointer */ 205 serial = usb_serial_get_by_index(idx);
193 serial = usb_serial_get_by_index(tty->index); 206 if (!serial)
194 if (!serial) { 207 return retval;
195 tty->driver_data = NULL;
196 return -ENODEV;
197 }
198 208
199 mutex_lock(&serial->disc_mutex); 209 port = serial->port[idx - serial->minor];
200 portNumber = tty->index - serial->minor; 210 if (!port)
201 port = serial->port[portNumber]; 211 goto error_no_port;
202 if (!port || serial->disconnected) 212 if (!try_module_get(serial->type->driver.owner))
203 retval = -ENODEV; 213 goto error_module_get;
204 else 214
205 get_device(&port->dev); 215 /* perform the standard setup */
206 /* 216 retval = tty_init_termios(tty);
207 * Note: Our locking order requirement does not allow port->mutex
208 * to be acquired while serial->disc_mutex is held.
209 */
210 mutex_unlock(&serial->disc_mutex);
211 if (retval) 217 if (retval)
212 goto bailout_serial_put; 218 goto error_init_termios;
213 219
214 if (mutex_lock_interruptible(&port->mutex)) { 220 retval = usb_autopm_get_interface(serial->interface);
215 retval = -ERESTARTSYS; 221 if (retval)
216 goto bailout_port_put; 222 goto error_get_interface;
217 } 223
224 mutex_unlock(&serial->disc_mutex);
218 225
219 ++port->port.count; 226 /* allow the driver to update the settings */
227 if (serial->type->init_termios)
228 serial->type->init_termios(tty);
220 229
221 /* set up our port structure making the tty driver
222 * remember our port object, and us it */
223 tty->driver_data = port; 230 tty->driver_data = port;
224 tty_port_tty_set(&port->port, tty);
225 231
226 /* If the console is attached, the device is already open */ 232 /* Final install (we use the default method) */
227 if (port->port.count == 1 && !port->console) { 233 tty_driver_kref_get(driver);
228 first = 1; 234 tty->count++;
229 /* lock this module before we call it 235 driver->ttys[idx] = tty;
230 * this may fail, which means we must bail out, 236 return retval;
231 * safe because we are called with BKL held */
232 if (!try_module_get(serial->type->driver.owner)) {
233 retval = -ENODEV;
234 goto bailout_mutex_unlock;
235 }
236 237
238 error_get_interface:
239 error_init_termios:
240 module_put(serial->type->driver.owner);
241 error_module_get:
242 error_no_port:
243 usb_serial_put(serial);
244 mutex_unlock(&serial->disc_mutex);
245 return retval;
246}
247
248static int serial_open(struct tty_struct *tty, struct file *filp)
249{
250 struct usb_serial_port *port = tty->driver_data;
251 struct usb_serial *serial = port->serial;
252 int retval;
253
254 dbg("%s - port %d", __func__, port->number);
255
256 spin_lock_irq(&port->port.lock);
257 if (!tty_hung_up_p(filp))
258 ++port->port.count;
259 spin_unlock_irq(&port->port.lock);
260 tty_port_tty_set(&port->port, tty);
261
262 /* Do the device-specific open only if the hardware isn't
263 * already initialized.
264 */
265 if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags)) {
266 if (mutex_lock_interruptible(&port->mutex))
267 return -ERESTARTSYS;
237 mutex_lock(&serial->disc_mutex); 268 mutex_lock(&serial->disc_mutex);
238 if (serial->disconnected) 269 if (serial->disconnected)
239 retval = -ENODEV; 270 retval = -ENODEV;
240 else 271 else
241 retval = usb_autopm_get_interface(serial->interface); 272 retval = port->serial->type->open(tty, port);
242 if (retval)
243 goto bailout_module_put;
244
245 /* only call the device specific open if this
246 * is the first time the port is opened */
247 retval = serial->type->open(tty, port, filp);
248 if (retval)
249 goto bailout_interface_put;
250 mutex_unlock(&serial->disc_mutex); 273 mutex_unlock(&serial->disc_mutex);
274 mutex_unlock(&port->mutex);
275 if (retval)
276 return retval;
251 set_bit(ASYNCB_INITIALIZED, &port->port.flags); 277 set_bit(ASYNCB_INITIALIZED, &port->port.flags);
252 } 278 }
253 mutex_unlock(&port->mutex); 279
254 /* Now do the correct tty layer semantics */ 280 /* Now do the correct tty layer semantics */
255 retval = tty_port_block_til_ready(&port->port, tty, filp); 281 retval = tty_port_block_til_ready(&port->port, tty, filp);
256 if (retval == 0) {
257 if (!first)
258 usb_serial_put(serial);
259 return 0;
260 }
261 mutex_lock(&port->mutex);
262 if (first == 0)
263 goto bailout_mutex_unlock;
264 /* Undo the initial port actions */
265 mutex_lock(&serial->disc_mutex);
266bailout_interface_put:
267 usb_autopm_put_interface(serial->interface);
268bailout_module_put:
269 mutex_unlock(&serial->disc_mutex);
270 module_put(serial->type->driver.owner);
271bailout_mutex_unlock:
272 port->port.count = 0;
273 tty->driver_data = NULL;
274 tty_port_tty_set(&port->port, NULL);
275 mutex_unlock(&port->mutex);
276bailout_port_put:
277 put_device(&port->dev);
278bailout_serial_put:
279 usb_serial_put(serial);
280 return retval; 282 return retval;
281} 283}
282 284
283/** 285/**
284 * serial_do_down - shut down hardware 286 * serial_down - shut down hardware
285 * @port: port to shut down 287 * @port: port to shut down
286 *
287 * Shut down a USB port unless it is the console. We never shut down the
288 * console hardware as it will always be in use.
289 * 288 *
290 * Don't free any resources at this point 289 * Shut down a USB serial port unless it is the console. We never
290 * shut down the console hardware as it will always be in use.
291 */ 291 */
292static void serial_do_down(struct usb_serial_port *port) 292static void serial_down(struct usb_serial_port *port)
293{ 293{
294 struct usb_serial_driver *drv = port->serial->type; 294 struct usb_serial_driver *drv = port->serial->type;
295 struct usb_serial *serial; 295 struct usb_serial *serial;
296 struct module *owner; 296 struct module *owner;
297 297
298 /* The console is magical, do not hang up the console hardware 298 /*
299 or there will be tears */ 299 * The console is magical. Do not hang up the console hardware
300 * or there will be tears.
301 */
300 if (port->console) 302 if (port->console)
301 return; 303 return;
302 304
305 /* Don't call the close method if the hardware hasn't been
306 * initialized.
307 */
308 if (!test_and_clear_bit(ASYNCB_INITIALIZED, &port->port.flags))
309 return;
310
303 mutex_lock(&port->mutex); 311 mutex_lock(&port->mutex);
304 serial = port->serial; 312 serial = port->serial;
305 owner = serial->type->driver.owner; 313 owner = serial->type->driver.owner;
@@ -310,79 +318,69 @@ static void serial_do_down(struct usb_serial_port *port)
310 mutex_unlock(&port->mutex); 318 mutex_unlock(&port->mutex);
311} 319}
312 320
313/** 321static void serial_hangup(struct tty_struct *tty)
314 * serial_do_free - free resources post close/hangup
315 * @port: port to free up
316 *
317 * Do the resource freeing and refcount dropping for the port. We must
318 * be careful about ordering and we must avoid freeing up the console.
319 */
320
321static void serial_do_free(struct usb_serial_port *port)
322{ 322{
323 struct usb_serial *serial; 323 struct usb_serial_port *port = tty->driver_data;
324 struct module *owner;
325 324
326 /* The console is magical, do not hang up the console hardware 325 dbg("%s - port %d", __func__, port->number);
327 or there will be tears */
328 if (port->console)
329 return;
330 326
331 serial = port->serial; 327 serial_down(port);
332 owner = serial->type->driver.owner; 328 tty_port_hangup(&port->port);
333 put_device(&port->dev);
334 /* Mustn't dereference port any more */
335 mutex_lock(&serial->disc_mutex);
336 if (!serial->disconnected)
337 usb_autopm_put_interface(serial->interface);
338 mutex_unlock(&serial->disc_mutex);
339 usb_serial_put(serial);
340 /* Mustn't dereference serial any more */
341 module_put(owner);
342} 329}
343 330
344static void serial_close(struct tty_struct *tty, struct file *filp) 331static void serial_close(struct tty_struct *tty, struct file *filp)
345{ 332{
346 struct usb_serial_port *port = tty->driver_data; 333 struct usb_serial_port *port = tty->driver_data;
347 334
348 if (!port)
349 return;
350
351 dbg("%s - port %d", __func__, port->number); 335 dbg("%s - port %d", __func__, port->number);
352 336
353 /* FIXME: 337 if (tty_hung_up_p(filp))
354 This leaves a very narrow race. Really we should do the
355 serial_do_free() on tty->shutdown(), but tty->shutdown can
356 be called from IRQ context and serial_do_free can sleep.
357
358 The right fix is probably to make the tty free (which is rare)
359 and thus tty->shutdown() occur via a work queue and simplify all
360 the drivers that use it.
361 */
362 if (tty_hung_up_p(filp)) {
363 /* serial_hangup already called serial_down at this point.
364 Another user may have already reopened the port but
365 serial_do_free is refcounted */
366 serial_do_free(port);
367 return; 338 return;
368 }
369
370 if (tty_port_close_start(&port->port, tty, filp) == 0) 339 if (tty_port_close_start(&port->port, tty, filp) == 0)
371 return; 340 return;
372 341 serial_down(port);
373 serial_do_down(port);
374 tty_port_close_end(&port->port, tty); 342 tty_port_close_end(&port->port, tty);
375 tty_port_tty_set(&port->port, NULL); 343 tty_port_tty_set(&port->port, NULL);
376 serial_do_free(port);
377} 344}
378 345
379static void serial_hangup(struct tty_struct *tty) 346/**
347 * serial_release - free resources post close/hangup
348 * @port: port to free up
349 *
350 * Do the resource freeing and refcount dropping for the port.
351 * Avoid freeing the console.
352 *
353 * Called when the last tty kref is dropped.
354 */
355static void serial_release(struct tty_struct *tty)
380{ 356{
381 struct usb_serial_port *port = tty->driver_data; 357 struct usb_serial_port *port = tty->driver_data;
382 serial_do_down(port); 358 struct usb_serial *serial;
383 tty_port_hangup(&port->port); 359 struct module *owner;
384 /* We must not free port yet - the USB serial layer depends on it's 360
385 continued existence */ 361 /* The console is magical. Do not hang up the console hardware
362 * or there will be tears.
363 */
364 if (port->console)
365 return;
366
367 dbg("%s - port %d", __func__, port->number);
368
369 /* Standard shutdown processing */
370 tty_shutdown(tty);
371
372 tty->driver_data = NULL;
373
374 serial = port->serial;
375 owner = serial->type->driver.owner;
376
377 mutex_lock(&serial->disc_mutex);
378 if (!serial->disconnected)
379 usb_autopm_put_interface(serial->interface);
380 mutex_unlock(&serial->disc_mutex);
381
382 usb_serial_put(serial);
383 module_put(owner);
386} 384}
387 385
388static int serial_write(struct tty_struct *tty, const unsigned char *buf, 386static int serial_write(struct tty_struct *tty, const unsigned char *buf,
@@ -527,6 +525,7 @@ static int serial_proc_show(struct seq_file *m, void *v)
527 525
528 seq_putc(m, '\n'); 526 seq_putc(m, '\n');
529 usb_serial_put(serial); 527 usb_serial_put(serial);
528 mutex_unlock(&serial->disc_mutex);
530 } 529 }
531 return 0; 530 return 0;
532} 531}
@@ -596,14 +595,6 @@ static void usb_serial_port_work(struct work_struct *work)
596 tty_kref_put(tty); 595 tty_kref_put(tty);
597} 596}
598 597
599static void port_release(struct device *dev)
600{
601 struct usb_serial_port *port = to_usb_serial_port(dev);
602
603 dbg ("%s - %s", __func__, dev_name(dev));
604 port_free(port);
605}
606
607static void kill_traffic(struct usb_serial_port *port) 598static void kill_traffic(struct usb_serial_port *port)
608{ 599{
609 usb_kill_urb(port->read_urb); 600 usb_kill_urb(port->read_urb);
@@ -623,8 +614,12 @@ static void kill_traffic(struct usb_serial_port *port)
623 usb_kill_urb(port->interrupt_out_urb); 614 usb_kill_urb(port->interrupt_out_urb);
624} 615}
625 616
626static void port_free(struct usb_serial_port *port) 617static void port_release(struct device *dev)
627{ 618{
619 struct usb_serial_port *port = to_usb_serial_port(dev);
620
621 dbg ("%s - %s", __func__, dev_name(dev));
622
628 /* 623 /*
629 * Stop all the traffic before cancelling the work, so that 624 * Stop all the traffic before cancelling the work, so that
630 * nobody will restart it by calling usb_serial_port_softint. 625 * nobody will restart it by calling usb_serial_port_softint.
@@ -935,6 +930,11 @@ int usb_serial_probe(struct usb_interface *interface,
935 mutex_init(&port->mutex); 930 mutex_init(&port->mutex);
936 INIT_WORK(&port->work, usb_serial_port_work); 931 INIT_WORK(&port->work, usb_serial_port_work);
937 serial->port[i] = port; 932 serial->port[i] = port;
933 port->dev.parent = &interface->dev;
934 port->dev.driver = NULL;
935 port->dev.bus = &usb_serial_bus_type;
936 port->dev.release = &port_release;
937 device_initialize(&port->dev);
938 } 938 }
939 939
940 /* set up the endpoint information */ 940 /* set up the endpoint information */
@@ -1077,15 +1077,10 @@ int usb_serial_probe(struct usb_interface *interface,
1077 /* register all of the individual ports with the driver core */ 1077 /* register all of the individual ports with the driver core */
1078 for (i = 0; i < num_ports; ++i) { 1078 for (i = 0; i < num_ports; ++i) {
1079 port = serial->port[i]; 1079 port = serial->port[i];
1080 port->dev.parent = &interface->dev;
1081 port->dev.driver = NULL;
1082 port->dev.bus = &usb_serial_bus_type;
1083 port->dev.release = &port_release;
1084
1085 dev_set_name(&port->dev, "ttyUSB%d", port->number); 1080 dev_set_name(&port->dev, "ttyUSB%d", port->number);
1086 dbg ("%s - registering %s", __func__, dev_name(&port->dev)); 1081 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1087 port->dev_state = PORT_REGISTERING; 1082 port->dev_state = PORT_REGISTERING;
1088 retval = device_register(&port->dev); 1083 retval = device_add(&port->dev);
1089 if (retval) { 1084 if (retval) {
1090 dev_err(&port->dev, "Error registering port device, " 1085 dev_err(&port->dev, "Error registering port device, "
1091 "continuing\n"); 1086 "continuing\n");
@@ -1103,39 +1098,7 @@ exit:
1103 return 0; 1098 return 0;
1104 1099
1105probe_error: 1100probe_error:
1106 for (i = 0; i < num_bulk_in; ++i) { 1101 usb_serial_put(serial);
1107 port = serial->port[i];
1108 if (!port)
1109 continue;
1110 usb_free_urb(port->read_urb);
1111 kfree(port->bulk_in_buffer);
1112 }
1113 for (i = 0; i < num_bulk_out; ++i) {
1114 port = serial->port[i];
1115 if (!port)
1116 continue;
1117 usb_free_urb(port->write_urb);
1118 kfree(port->bulk_out_buffer);
1119 }
1120 for (i = 0; i < num_interrupt_in; ++i) {
1121 port = serial->port[i];
1122 if (!port)
1123 continue;
1124 usb_free_urb(port->interrupt_in_urb);
1125 kfree(port->interrupt_in_buffer);
1126 }
1127 for (i = 0; i < num_interrupt_out; ++i) {
1128 port = serial->port[i];
1129 if (!port)
1130 continue;
1131 usb_free_urb(port->interrupt_out_urb);
1132 kfree(port->interrupt_out_buffer);
1133 }
1134
1135 /* free up any memory that we allocated */
1136 for (i = 0; i < serial->num_port_pointers; ++i)
1137 kfree(serial->port[i]);
1138 kfree(serial);
1139 return -EIO; 1102 return -EIO;
1140} 1103}
1141EXPORT_SYMBOL_GPL(usb_serial_probe); 1104EXPORT_SYMBOL_GPL(usb_serial_probe);
@@ -1161,10 +1124,7 @@ void usb_serial_disconnect(struct usb_interface *interface)
1161 if (port) { 1124 if (port) {
1162 struct tty_struct *tty = tty_port_tty_get(&port->port); 1125 struct tty_struct *tty = tty_port_tty_get(&port->port);
1163 if (tty) { 1126 if (tty) {
1164 /* The hangup will occur asynchronously but 1127 tty_vhangup(tty);
1165 the object refcounts will sort out all the
1166 cleanup */
1167 tty_hangup(tty);
1168 tty_kref_put(tty); 1128 tty_kref_put(tty);
1169 } 1129 }
1170 kill_traffic(port); 1130 kill_traffic(port);
@@ -1189,8 +1149,7 @@ void usb_serial_disconnect(struct usb_interface *interface)
1189 } 1149 }
1190 serial->type->disconnect(serial); 1150 serial->type->disconnect(serial);
1191 1151
1192 /* let the last holder of this object 1152 /* let the last holder of this object cause it to be cleaned up */
1193 * cause it to be cleaned up */
1194 usb_serial_put(serial); 1153 usb_serial_put(serial);
1195 dev_info(dev, "device disconnected\n"); 1154 dev_info(dev, "device disconnected\n");
1196} 1155}
@@ -1246,6 +1205,8 @@ static const struct tty_operations serial_ops = {
1246 .chars_in_buffer = serial_chars_in_buffer, 1205 .chars_in_buffer = serial_chars_in_buffer,
1247 .tiocmget = serial_tiocmget, 1206 .tiocmget = serial_tiocmget,
1248 .tiocmset = serial_tiocmset, 1207 .tiocmset = serial_tiocmset,
1208 .shutdown = serial_release,
1209 .install = serial_install,
1249 .proc_fops = &serial_proc_fops, 1210 .proc_fops = &serial_proc_fops,
1250}; 1211};
1251 1212
diff --git a/drivers/usb/serial/usb_debug.c b/drivers/usb/serial/usb_debug.c
index 614800972dc3..7b5bfc4edd3d 100644
--- a/drivers/usb/serial/usb_debug.c
+++ b/drivers/usb/serial/usb_debug.c
@@ -43,11 +43,10 @@ static struct usb_driver debug_driver = {
43 .no_dynamic_id = 1, 43 .no_dynamic_id = 1,
44}; 44};
45 45
46static int usb_debug_open(struct tty_struct *tty, struct usb_serial_port *port, 46static int usb_debug_open(struct tty_struct *tty, struct usb_serial_port *port)
47 struct file *filp)
48{ 47{
49 port->bulk_out_size = USB_DEBUG_MAX_PACKET_SIZE; 48 port->bulk_out_size = USB_DEBUG_MAX_PACKET_SIZE;
50 return usb_serial_generic_open(tty, port, filp); 49 return usb_serial_generic_open(tty, port);
51} 50}
52 51
53/* This HW really does not support a serial break, so one will be 52/* This HW really does not support a serial break, so one will be
diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
index f5d0f64dcc52..1aa5d20a5d99 100644
--- a/drivers/usb/serial/visor.c
+++ b/drivers/usb/serial/visor.c
@@ -36,8 +36,7 @@
36#define DRIVER_DESC "USB HandSpring Visor / Palm OS driver" 36#define DRIVER_DESC "USB HandSpring Visor / Palm OS driver"
37 37
38/* function prototypes for a handspring visor */ 38/* function prototypes for a handspring visor */
39static int visor_open(struct tty_struct *tty, struct usb_serial_port *port, 39static int visor_open(struct tty_struct *tty, struct usb_serial_port *port);
40 struct file *filp);
41static void visor_close(struct usb_serial_port *port); 40static void visor_close(struct usb_serial_port *port);
42static int visor_write(struct tty_struct *tty, struct usb_serial_port *port, 41static int visor_write(struct tty_struct *tty, struct usb_serial_port *port,
43 const unsigned char *buf, int count); 42 const unsigned char *buf, int count);
@@ -273,8 +272,7 @@ static int stats;
273/****************************************************************************** 272/******************************************************************************
274 * Handspring Visor specific driver functions 273 * Handspring Visor specific driver functions
275 ******************************************************************************/ 274 ******************************************************************************/
276static int visor_open(struct tty_struct *tty, struct usb_serial_port *port, 275static int visor_open(struct tty_struct *tty, struct usb_serial_port *port)
277 struct file *filp)
278{ 276{
279 struct usb_serial *serial = port->serial; 277 struct usb_serial *serial = port->serial;
280 struct visor_private *priv = usb_get_serial_port_data(port); 278 struct visor_private *priv = usb_get_serial_port_data(port);
diff --git a/drivers/usb/serial/whiteheat.c b/drivers/usb/serial/whiteheat.c
index 8d126dd7a02e..62424eec33ec 100644
--- a/drivers/usb/serial/whiteheat.c
+++ b/drivers/usb/serial/whiteheat.c
@@ -146,7 +146,7 @@ static int whiteheat_firmware_attach(struct usb_serial *serial);
146static int whiteheat_attach(struct usb_serial *serial); 146static int whiteheat_attach(struct usb_serial *serial);
147static void whiteheat_release(struct usb_serial *serial); 147static void whiteheat_release(struct usb_serial *serial);
148static int whiteheat_open(struct tty_struct *tty, 148static int whiteheat_open(struct tty_struct *tty,
149 struct usb_serial_port *port, struct file *filp); 149 struct usb_serial_port *port);
150static void whiteheat_close(struct usb_serial_port *port); 150static void whiteheat_close(struct usb_serial_port *port);
151static int whiteheat_write(struct tty_struct *tty, 151static int whiteheat_write(struct tty_struct *tty,
152 struct usb_serial_port *port, 152 struct usb_serial_port *port,
@@ -259,7 +259,7 @@ static int firm_send_command(struct usb_serial_port *port, __u8 command,
259 __u8 *data, __u8 datasize); 259 __u8 *data, __u8 datasize);
260static int firm_open(struct usb_serial_port *port); 260static int firm_open(struct usb_serial_port *port);
261static int firm_close(struct usb_serial_port *port); 261static int firm_close(struct usb_serial_port *port);
262static int firm_setup_port(struct tty_struct *tty); 262static void firm_setup_port(struct tty_struct *tty);
263static int firm_set_rts(struct usb_serial_port *port, __u8 onoff); 263static int firm_set_rts(struct usb_serial_port *port, __u8 onoff);
264static int firm_set_dtr(struct usb_serial_port *port, __u8 onoff); 264static int firm_set_dtr(struct usb_serial_port *port, __u8 onoff);
265static int firm_set_break(struct usb_serial_port *port, __u8 onoff); 265static int firm_set_break(struct usb_serial_port *port, __u8 onoff);
@@ -659,8 +659,7 @@ static void whiteheat_release(struct usb_serial *serial)
659 return; 659 return;
660} 660}
661 661
662static int whiteheat_open(struct tty_struct *tty, 662static int whiteheat_open(struct tty_struct *tty, struct usb_serial_port *port)
663 struct usb_serial_port *port, struct file *filp)
664{ 663{
665 int retval = 0; 664 int retval = 0;
666 665
@@ -1211,7 +1210,7 @@ static int firm_close(struct usb_serial_port *port)
1211} 1210}
1212 1211
1213 1212
1214static int firm_setup_port(struct tty_struct *tty) 1213static void firm_setup_port(struct tty_struct *tty)
1215{ 1214{
1216 struct usb_serial_port *port = tty->driver_data; 1215 struct usb_serial_port *port = tty->driver_data;
1217 struct whiteheat_port_settings port_settings; 1216 struct whiteheat_port_settings port_settings;
@@ -1286,7 +1285,7 @@ static int firm_setup_port(struct tty_struct *tty)
1286 port_settings.lloop = 0; 1285 port_settings.lloop = 0;
1287 1286
1288 /* now send the message to the device */ 1287 /* now send the message to the device */
1289 return firm_send_command(port, WHITEHEAT_SETUP_PORT, 1288 firm_send_command(port, WHITEHEAT_SETUP_PORT,
1290 (__u8 *)&port_settings, sizeof(port_settings)); 1289 (__u8 *)&port_settings, sizeof(port_settings));
1291} 1290}
1292 1291
diff --git a/include/linux/cyclades.h b/include/linux/cyclades.h
index 1fbdea4f08eb..a5049eaf782d 100644
--- a/include/linux/cyclades.h
+++ b/include/linux/cyclades.h
@@ -499,6 +499,7 @@ struct cyclades_card {
499 void __iomem *p9050; 499 void __iomem *p9050;
500 struct RUNTIME_9060 __iomem *p9060; 500 struct RUNTIME_9060 __iomem *p9060;
501 } ctl_addr; 501 } ctl_addr;
502 struct BOARD_CTRL __iomem *board_ctrl; /* cyz specific */
502 int irq; 503 int irq;
503 unsigned int num_chips; /* 0 if card absent, -1 if Z/PCI, else Y */ 504 unsigned int num_chips; /* 0 if card absent, -1 if Z/PCI, else Y */
504 unsigned int first_line; /* minor number of first channel on card */ 505 unsigned int first_line; /* minor number of first channel on card */
@@ -541,6 +542,15 @@ struct cyclades_port {
541 int magic; 542 int magic;
542 struct tty_port port; 543 struct tty_port port;
543 struct cyclades_card *card; 544 struct cyclades_card *card;
545 union {
546 struct {
547 void __iomem *base_addr;
548 } cyy;
549 struct {
550 struct CH_CTRL __iomem *ch_ctrl;
551 struct BUF_CTRL __iomem *buf_ctrl;
552 } cyz;
553 } u;
544 int line; 554 int line;
545 int flags; /* defined in tty.h */ 555 int flags; /* defined in tty.h */
546 int type; /* UART type */ 556 int type; /* UART type */
@@ -568,7 +578,6 @@ struct cyclades_port {
568 struct cyclades_idle_stats idle_stats; 578 struct cyclades_idle_stats idle_stats;
569 struct cyclades_icount icount; 579 struct cyclades_icount icount;
570 struct completion shutdown_wait; 580 struct completion shutdown_wait;
571 wait_queue_head_t delta_msr_wait;
572 int throttle; 581 int throttle;
573}; 582};
574 583
diff --git a/include/linux/hayesesp.h b/include/linux/hayesesp.h
index 940aeb51d53f..92b08cfe4a75 100644
--- a/include/linux/hayesesp.h
+++ b/include/linux/hayesesp.h
@@ -96,7 +96,6 @@ struct esp_struct {
96 int xmit_head; 96 int xmit_head;
97 int xmit_tail; 97 int xmit_tail;
98 int xmit_cnt; 98 int xmit_cnt;
99 wait_queue_head_t delta_msr_wait;
100 wait_queue_head_t break_wait; 99 wait_queue_head_t break_wait;
101 struct async_icount icount; /* kernel counters for the 4 input interrupts */ 100 struct async_icount icount; /* kernel counters for the 4 input interrupts */
102 struct hayes_esp_config config; /* port configuration */ 101 struct hayes_esp_config config; /* port configuration */
diff --git a/include/linux/kfifo.h b/include/linux/kfifo.h
index 29f62e1733ff..ad6bdf5a5970 100644
--- a/include/linux/kfifo.h
+++ b/include/linux/kfifo.h
@@ -38,7 +38,7 @@ extern struct kfifo *kfifo_alloc(unsigned int size, gfp_t gfp_mask,
38 spinlock_t *lock); 38 spinlock_t *lock);
39extern void kfifo_free(struct kfifo *fifo); 39extern void kfifo_free(struct kfifo *fifo);
40extern unsigned int __kfifo_put(struct kfifo *fifo, 40extern unsigned int __kfifo_put(struct kfifo *fifo,
41 unsigned char *buffer, unsigned int len); 41 const unsigned char *buffer, unsigned int len);
42extern unsigned int __kfifo_get(struct kfifo *fifo, 42extern unsigned int __kfifo_get(struct kfifo *fifo,
43 unsigned char *buffer, unsigned int len); 43 unsigned char *buffer, unsigned int len);
44 44
@@ -77,7 +77,7 @@ static inline void kfifo_reset(struct kfifo *fifo)
77 * bytes copied. 77 * bytes copied.
78 */ 78 */
79static inline unsigned int kfifo_put(struct kfifo *fifo, 79static inline unsigned int kfifo_put(struct kfifo *fifo,
80 unsigned char *buffer, unsigned int len) 80 const unsigned char *buffer, unsigned int len)
81{ 81{
82 unsigned long flags; 82 unsigned long flags;
83 unsigned int ret; 83 unsigned int ret;
diff --git a/include/linux/serial.h b/include/linux/serial.h
index e5bb75a63802..c8613c3ff9d3 100644
--- a/include/linux/serial.h
+++ b/include/linux/serial.h
@@ -122,6 +122,7 @@ struct serial_uart_config {
122 122
123/* Internal flags used only by kernel */ 123/* Internal flags used only by kernel */
124#define ASYNCB_INITIALIZED 31 /* Serial port was initialized */ 124#define ASYNCB_INITIALIZED 31 /* Serial port was initialized */
125#define ASYNCB_SUSPENDED 30 /* Serial port is suspended */
125#define ASYNCB_NORMAL_ACTIVE 29 /* Normal device is active */ 126#define ASYNCB_NORMAL_ACTIVE 29 /* Normal device is active */
126#define ASYNCB_BOOT_AUTOCONF 28 /* Autoconfigure port on bootup */ 127#define ASYNCB_BOOT_AUTOCONF 28 /* Autoconfigure port on bootup */
127#define ASYNCB_CLOSING 27 /* Serial port is closing */ 128#define ASYNCB_CLOSING 27 /* Serial port is closing */
@@ -133,6 +134,7 @@ struct serial_uart_config {
133#define ASYNCB_FIRST_KERNEL 22 134#define ASYNCB_FIRST_KERNEL 22
134 135
135#define ASYNC_HUP_NOTIFY (1U << ASYNCB_HUP_NOTIFY) 136#define ASYNC_HUP_NOTIFY (1U << ASYNCB_HUP_NOTIFY)
137#define ASYNC_SUSPENDED (1U << ASYNCB_SUSPENDED)
136#define ASYNC_FOURPORT (1U << ASYNCB_FOURPORT) 138#define ASYNC_FOURPORT (1U << ASYNCB_FOURPORT)
137#define ASYNC_SAK (1U << ASYNCB_SAK) 139#define ASYNC_SAK (1U << ASYNCB_SAK)
138#define ASYNC_SPLIT_TERMIOS (1U << ASYNCB_SPLIT_TERMIOS) 140#define ASYNC_SPLIT_TERMIOS (1U << ASYNCB_SPLIT_TERMIOS)
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index d4d2a78ad43e..fb46aba11fb5 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -22,6 +22,7 @@ struct plat_serial8250_port {
22 void __iomem *membase; /* ioremap cookie or NULL */ 22 void __iomem *membase; /* ioremap cookie or NULL */
23 resource_size_t mapbase; /* resource base */ 23 resource_size_t mapbase; /* resource base */
24 unsigned int irq; /* interrupt number */ 24 unsigned int irq; /* interrupt number */
25 unsigned long irqflags; /* request_irq flags */
25 unsigned int uartclk; /* UART clock rate */ 26 unsigned int uartclk; /* UART clock rate */
26 void *private_data; 27 void *private_data;
27 unsigned char regshift; /* register shift */ 28 unsigned char regshift; /* register shift */
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 23d2fb051f97..d58e460844dd 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -20,6 +20,8 @@
20#ifndef LINUX_SERIAL_CORE_H 20#ifndef LINUX_SERIAL_CORE_H
21#define LINUX_SERIAL_CORE_H 21#define LINUX_SERIAL_CORE_H
22 22
23#include <linux/serial.h>
24
23/* 25/*
24 * The type definitions. These are from Ted Ts'o's serial.h 26 * The type definitions. These are from Ted Ts'o's serial.h
25 */ 27 */
@@ -186,7 +188,6 @@
186#include <linux/sysrq.h> 188#include <linux/sysrq.h>
187 189
188struct uart_port; 190struct uart_port;
189struct uart_info;
190struct serial_struct; 191struct serial_struct;
191struct device; 192struct device;
192 193
@@ -265,6 +266,7 @@ struct uart_port {
265 unsigned int (*serial_in)(struct uart_port *, int); 266 unsigned int (*serial_in)(struct uart_port *, int);
266 void (*serial_out)(struct uart_port *, int, int); 267 void (*serial_out)(struct uart_port *, int, int);
267 unsigned int irq; /* irq number */ 268 unsigned int irq; /* irq number */
269 unsigned long irqflags; /* irq flags */
268 unsigned int uartclk; /* base uart clock */ 270 unsigned int uartclk; /* base uart clock */
269 unsigned int fifosize; /* tx fifo size */ 271 unsigned int fifosize; /* tx fifo size */
270 unsigned char x_char; /* xon/xoff char */ 272 unsigned char x_char; /* xon/xoff char */
@@ -283,7 +285,7 @@ struct uart_port {
283 285
284 unsigned int read_status_mask; /* driver specific */ 286 unsigned int read_status_mask; /* driver specific */
285 unsigned int ignore_status_mask; /* driver specific */ 287 unsigned int ignore_status_mask; /* driver specific */
286 struct uart_info *info; /* pointer to parent info */ 288 struct uart_state *state; /* pointer to parent state */
287 struct uart_icount icount; /* statistics */ 289 struct uart_icount icount; /* statistics */
288 290
289 struct console *cons; /* struct console, if any */ 291 struct console *cons; /* struct console, if any */
@@ -335,52 +337,16 @@ struct uart_port {
335}; 337};
336 338
337/* 339/*
338 * This is the state information which is only valid when the port
339 * is open; it may be cleared the core driver once the device has
340 * been closed. Either the low level driver or the core can modify
341 * stuff here.
342 */
343typedef unsigned int __bitwise__ uif_t;
344
345struct uart_info {
346 struct tty_port port;
347 struct circ_buf xmit;
348 uif_t flags;
349
350/*
351 * Definitions for info->flags. These are _private_ to serial_core, and
352 * are specific to this structure. They may be queried by low level drivers.
353 *
354 * FIXME: use the ASY_ definitions
355 */
356#define UIF_CHECK_CD ((__force uif_t) (1 << 25))
357#define UIF_CTS_FLOW ((__force uif_t) (1 << 26))
358#define UIF_NORMAL_ACTIVE ((__force uif_t) (1 << 29))
359#define UIF_INITIALIZED ((__force uif_t) (1 << 31))
360#define UIF_SUSPENDED ((__force uif_t) (1 << 30))
361
362 struct tasklet_struct tlet;
363 wait_queue_head_t delta_msr_wait;
364};
365
366/*
367 * This is the state information which is persistent across opens. 340 * This is the state information which is persistent across opens.
368 * The low level driver must not to touch any elements contained
369 * within.
370 */ 341 */
371struct uart_state { 342struct uart_state {
372 unsigned int close_delay; /* msec */ 343 struct tty_port port;
373 unsigned int closing_wait; /* msec */
374
375#define USF_CLOSING_WAIT_INF (0)
376#define USF_CLOSING_WAIT_NONE (~0U)
377 344
378 int count;
379 int pm_state; 345 int pm_state;
380 struct uart_info info; 346 struct circ_buf xmit;
381 struct uart_port *port;
382 347
383 struct mutex mutex; 348 struct tasklet_struct tlet;
349 struct uart_port *uart_port;
384}; 350};
385 351
386#define UART_XMIT_SIZE PAGE_SIZE 352#define UART_XMIT_SIZE PAGE_SIZE
@@ -461,7 +427,7 @@ int uart_resume_port(struct uart_driver *reg, struct uart_port *port);
461 427
462static inline int uart_tx_stopped(struct uart_port *port) 428static inline int uart_tx_stopped(struct uart_port *port)
463{ 429{
464 struct tty_struct *tty = port->info->port.tty; 430 struct tty_struct *tty = port->state->port.tty;
465 if(tty->stopped || tty->hw_stopped) 431 if(tty->stopped || tty->hw_stopped)
466 return 1; 432 return 1;
467 return 0; 433 return 0;
@@ -476,7 +442,7 @@ uart_handle_sysrq_char(struct uart_port *port, unsigned int ch)
476#ifdef SUPPORT_SYSRQ 442#ifdef SUPPORT_SYSRQ
477 if (port->sysrq) { 443 if (port->sysrq) {
478 if (ch && time_before(jiffies, port->sysrq)) { 444 if (ch && time_before(jiffies, port->sysrq)) {
479 handle_sysrq(ch, port->info->port.tty); 445 handle_sysrq(ch, port->state->port.tty);
480 port->sysrq = 0; 446 port->sysrq = 0;
481 return 1; 447 return 1;
482 } 448 }
@@ -494,7 +460,7 @@ uart_handle_sysrq_char(struct uart_port *port, unsigned int ch)
494 */ 460 */
495static inline int uart_handle_break(struct uart_port *port) 461static inline int uart_handle_break(struct uart_port *port)
496{ 462{
497 struct uart_info *info = port->info; 463 struct uart_state *state = port->state;
498#ifdef SUPPORT_SYSRQ 464#ifdef SUPPORT_SYSRQ
499 if (port->cons && port->cons->index == port->line) { 465 if (port->cons && port->cons->index == port->line) {
500 if (!port->sysrq) { 466 if (!port->sysrq) {
@@ -505,7 +471,7 @@ static inline int uart_handle_break(struct uart_port *port)
505 } 471 }
506#endif 472#endif
507 if (port->flags & UPF_SAK) 473 if (port->flags & UPF_SAK)
508 do_SAK(info->port.tty); 474 do_SAK(state->port.tty);
509 return 0; 475 return 0;
510} 476}
511 477
@@ -515,22 +481,23 @@ static inline int uart_handle_break(struct uart_port *port)
515 * @status: new carrier detect status, nonzero if active 481 * @status: new carrier detect status, nonzero if active
516 */ 482 */
517static inline void 483static inline void
518uart_handle_dcd_change(struct uart_port *port, unsigned int status) 484uart_handle_dcd_change(struct uart_port *uport, unsigned int status)
519{ 485{
520 struct uart_info *info = port->info; 486 struct uart_state *state = uport->state;
487 struct tty_port *port = &state->port;
521 488
522 port->icount.dcd++; 489 uport->icount.dcd++;
523 490
524#ifdef CONFIG_HARD_PPS 491#ifdef CONFIG_HARD_PPS
525 if ((port->flags & UPF_HARDPPS_CD) && status) 492 if ((uport->flags & UPF_HARDPPS_CD) && status)
526 hardpps(); 493 hardpps();
527#endif 494#endif
528 495
529 if (info->flags & UIF_CHECK_CD) { 496 if (port->flags & ASYNC_CHECK_CD) {
530 if (status) 497 if (status)
531 wake_up_interruptible(&info->port.open_wait); 498 wake_up_interruptible(&port->open_wait);
532 else if (info->port.tty) 499 else if (port->tty)
533 tty_hangup(info->port.tty); 500 tty_hangup(port->tty);
534 } 501 }
535} 502}
536 503
@@ -540,24 +507,24 @@ uart_handle_dcd_change(struct uart_port *port, unsigned int status)
540 * @status: new clear to send status, nonzero if active 507 * @status: new clear to send status, nonzero if active
541 */ 508 */
542static inline void 509static inline void
543uart_handle_cts_change(struct uart_port *port, unsigned int status) 510uart_handle_cts_change(struct uart_port *uport, unsigned int status)
544{ 511{
545 struct uart_info *info = port->info; 512 struct tty_port *port = &uport->state->port;
546 struct tty_struct *tty = info->port.tty; 513 struct tty_struct *tty = port->tty;
547 514
548 port->icount.cts++; 515 uport->icount.cts++;
549 516
550 if (info->flags & UIF_CTS_FLOW) { 517 if (port->flags & ASYNC_CTS_FLOW) {
551 if (tty->hw_stopped) { 518 if (tty->hw_stopped) {
552 if (status) { 519 if (status) {
553 tty->hw_stopped = 0; 520 tty->hw_stopped = 0;
554 port->ops->start_tx(port); 521 uport->ops->start_tx(uport);
555 uart_write_wakeup(port); 522 uart_write_wakeup(uport);
556 } 523 }
557 } else { 524 } else {
558 if (!status) { 525 if (!status) {
559 tty->hw_stopped = 1; 526 tty->hw_stopped = 1;
560 port->ops->stop_tx(port); 527 uport->ops->stop_tx(uport);
561 } 528 }
562 } 529 }
563 } 530 }
@@ -569,7 +536,7 @@ static inline void
569uart_insert_char(struct uart_port *port, unsigned int status, 536uart_insert_char(struct uart_port *port, unsigned int status,
570 unsigned int overrun, unsigned int ch, unsigned int flag) 537 unsigned int overrun, unsigned int ch, unsigned int flag)
571{ 538{
572 struct tty_struct *tty = port->info->port.tty; 539 struct tty_struct *tty = port->state->port.tty;
573 540
574 if ((status & port->ignore_status_mask & ~overrun) == 0) 541 if ((status & port->ignore_status_mask & ~overrun) == 0)
575 tty_insert_flip_char(tty, ch, flag); 542 tty_insert_flip_char(tty, ch, flag);
diff --git a/include/linux/tty.h b/include/linux/tty.h
index a916a318004e..f0f43d08d8b8 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -187,7 +187,12 @@ struct tty_port;
187struct tty_port_operations { 187struct tty_port_operations {
188 /* Return 1 if the carrier is raised */ 188 /* Return 1 if the carrier is raised */
189 int (*carrier_raised)(struct tty_port *port); 189 int (*carrier_raised)(struct tty_port *port);
190 /* Control the DTR line */
190 void (*dtr_rts)(struct tty_port *port, int raise); 191 void (*dtr_rts)(struct tty_port *port, int raise);
192 /* Called when the last close completes or a hangup finishes
193 IFF the port was initialized. Do not use to free resources */
194 void (*shutdown)(struct tty_port *port);
195 void (*drop)(struct tty_port *port);
191}; 196};
192 197
193struct tty_port { 198struct tty_port {
@@ -198,11 +203,12 @@ struct tty_port {
198 int count; /* Usage count */ 203 int count; /* Usage count */
199 wait_queue_head_t open_wait; /* Open waiters */ 204 wait_queue_head_t open_wait; /* Open waiters */
200 wait_queue_head_t close_wait; /* Close waiters */ 205 wait_queue_head_t close_wait; /* Close waiters */
206 wait_queue_head_t delta_msr_wait; /* Modem status change */
201 unsigned long flags; /* TTY flags ASY_*/ 207 unsigned long flags; /* TTY flags ASY_*/
202 struct mutex mutex; /* Locking */ 208 struct mutex mutex; /* Locking */
203 unsigned char *xmit_buf; /* Optional buffer */ 209 unsigned char *xmit_buf; /* Optional buffer */
204 int close_delay; /* Close port delay */ 210 unsigned int close_delay; /* Close port delay */
205 int closing_wait; /* Delay for output */ 211 unsigned int closing_wait; /* Delay for output */
206 int drain_delay; /* Set to zero if no pure time 212 int drain_delay; /* Set to zero if no pure time
207 based drain is needed else 213 based drain is needed else
208 set to size of fifo */ 214 set to size of fifo */
@@ -459,6 +465,12 @@ extern int tty_port_block_til_ready(struct tty_port *port,
459extern int tty_port_close_start(struct tty_port *port, 465extern int tty_port_close_start(struct tty_port *port,
460 struct tty_struct *tty, struct file *filp); 466 struct tty_struct *tty, struct file *filp);
461extern void tty_port_close_end(struct tty_port *port, struct tty_struct *tty); 467extern void tty_port_close_end(struct tty_port *port, struct tty_struct *tty);
468extern void tty_port_close(struct tty_port *port,
469 struct tty_struct *tty, struct file *filp);
470extern inline int tty_port_users(struct tty_port *port)
471{
472 return port->count + port->blocked_open;
473}
462 474
463extern int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc); 475extern int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc);
464extern int tty_unregister_ldisc(int disc); 476extern int tty_unregister_ldisc(int disc);
@@ -524,5 +536,8 @@ extern int pcxe_open(struct tty_struct *tty, struct file *filp);
524extern int vt_ioctl(struct tty_struct *tty, struct file *file, 536extern int vt_ioctl(struct tty_struct *tty, struct file *file,
525 unsigned int cmd, unsigned long arg); 537 unsigned int cmd, unsigned long arg);
526 538
539extern long vt_compat_ioctl(struct tty_struct *tty, struct file * file,
540 unsigned int cmd, unsigned long arg);
541
527#endif /* __KERNEL__ */ 542#endif /* __KERNEL__ */
528#endif 543#endif
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index 0ec50ba62139..7b85e327af91 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -238,9 +238,8 @@ struct usb_serial_driver {
238 int (*resume)(struct usb_serial *serial); 238 int (*resume)(struct usb_serial *serial);
239 239
240 /* serial function calls */ 240 /* serial function calls */
241 /* Called by console with tty = NULL and by tty */ 241 /* Called by console and by the tty layer */
242 int (*open)(struct tty_struct *tty, 242 int (*open)(struct tty_struct *tty, struct usb_serial_port *port);
243 struct usb_serial_port *port, struct file *filp);
244 void (*close)(struct usb_serial_port *port); 243 void (*close)(struct usb_serial_port *port);
245 int (*write)(struct tty_struct *tty, struct usb_serial_port *port, 244 int (*write)(struct tty_struct *tty, struct usb_serial_port *port,
246 const unsigned char *buf, int count); 245 const unsigned char *buf, int count);
@@ -261,6 +260,9 @@ struct usb_serial_driver {
261 be an attached tty at this point */ 260 be an attached tty at this point */
262 void (*dtr_rts)(struct usb_serial_port *port, int on); 261 void (*dtr_rts)(struct usb_serial_port *port, int on);
263 int (*carrier_raised)(struct usb_serial_port *port); 262 int (*carrier_raised)(struct usb_serial_port *port);
263 /* Called by the usb serial hooks to allow the user to rework the
264 termios state */
265 void (*init_termios)(struct tty_struct *tty);
264 /* USB events */ 266 /* USB events */
265 void (*read_int_callback)(struct urb *urb); 267 void (*read_int_callback)(struct urb *urb);
266 void (*write_int_callback)(struct urb *urb); 268 void (*write_int_callback)(struct urb *urb);
@@ -300,7 +302,7 @@ static inline void usb_serial_console_disconnect(struct usb_serial *serial) {}
300extern struct usb_serial *usb_serial_get_by_index(unsigned int minor); 302extern struct usb_serial *usb_serial_get_by_index(unsigned int minor);
301extern void usb_serial_put(struct usb_serial *serial); 303extern void usb_serial_put(struct usb_serial *serial);
302extern int usb_serial_generic_open(struct tty_struct *tty, 304extern int usb_serial_generic_open(struct tty_struct *tty,
303 struct usb_serial_port *port, struct file *filp); 305 struct usb_serial_port *port);
304extern int usb_serial_generic_write(struct tty_struct *tty, 306extern int usb_serial_generic_write(struct tty_struct *tty,
305 struct usb_serial_port *port, const unsigned char *buf, int count); 307 struct usb_serial_port *port, const unsigned char *buf, int count);
306extern void usb_serial_generic_close(struct usb_serial_port *port); 308extern void usb_serial_generic_close(struct usb_serial_port *port);
diff --git a/include/linux/vt.h b/include/linux/vt.h
index 02c1c0288770..7afca0d72139 100644
--- a/include/linux/vt.h
+++ b/include/linux/vt.h
@@ -1,17 +1,6 @@
1#ifndef _LINUX_VT_H 1#ifndef _LINUX_VT_H
2#define _LINUX_VT_H 2#define _LINUX_VT_H
3 3
4#ifdef __KERNEL__
5struct notifier_block;
6
7struct vt_notifier_param {
8 struct vc_data *vc; /* VC on which the update happened */
9 unsigned int c; /* Printed char */
10};
11
12extern int register_vt_notifier(struct notifier_block *nb);
13extern int unregister_vt_notifier(struct notifier_block *nb);
14#endif
15 4
16/* 5/*
17 * These constants are also useful for user-level apps (e.g., VC 6 * These constants are also useful for user-level apps (e.g., VC
@@ -74,4 +63,25 @@ struct vt_consize {
74#define VT_UNLOCKSWITCH 0x560C /* allow vt switching */ 63#define VT_UNLOCKSWITCH 0x560C /* allow vt switching */
75#define VT_GETHIFONTMASK 0x560D /* return hi font mask */ 64#define VT_GETHIFONTMASK 0x560D /* return hi font mask */
76 65
66struct vt_event {
67 unsigned int event;
68#define VT_EVENT_SWITCH 0x0001 /* Console switch */
69#define VT_EVENT_BLANK 0x0002 /* Screen blank */
70#define VT_EVENT_UNBLANK 0x0004 /* Screen unblank */
71#define VT_EVENT_RESIZE 0x0008 /* Resize display */
72#define VT_MAX_EVENT 0x000F
73 unsigned int old; /* Old console */
74 unsigned int new; /* New console (if changing) */
75 unsigned int pad[4]; /* Padding for expansion */
76};
77
78#define VT_WAITEVENT 0x560E /* Wait for an event */
79
80struct vt_setactivate {
81 unsigned int console;
82 struct vt_mode mode;
83};
84
85#define VT_SETACTIVATE 0x560F /* Activate and set the mode of a console */
86
77#endif /* _LINUX_VT_H */ 87#endif /* _LINUX_VT_H */
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
index 2f1113467f70..c0c4e1103a73 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -13,6 +13,7 @@
13#include <linux/console_struct.h> 13#include <linux/console_struct.h>
14#include <linux/mm.h> 14#include <linux/mm.h>
15#include <linux/consolemap.h> 15#include <linux/consolemap.h>
16#include <linux/notifier.h>
16 17
17/* 18/*
18 * Presently, a lot of graphics programs do not restore the contents of 19 * Presently, a lot of graphics programs do not restore the contents of
@@ -91,7 +92,8 @@ int con_copy_unimap(struct vc_data *dst_vc, struct vc_data *src_vc);
91#endif 92#endif
92 93
93/* vt.c */ 94/* vt.c */
94int vt_waitactive(int vt); 95void vt_event_post(unsigned int event, unsigned int old, unsigned int new);
96int vt_waitactive(int n);
95void change_console(struct vc_data *new_vc); 97void change_console(struct vc_data *new_vc);
96void reset_vc(struct vc_data *vc); 98void reset_vc(struct vc_data *vc);
97extern int unbind_con_driver(const struct consw *csw, int first, int last, 99extern int unbind_con_driver(const struct consw *csw, int first, int last,
@@ -116,4 +118,16 @@ struct vt_spawn_console {
116}; 118};
117extern struct vt_spawn_console vt_spawn_con; 119extern struct vt_spawn_console vt_spawn_con;
118 120
121extern int vt_move_to_console(unsigned int vt, int alloc);
122
123/* Interfaces for VC notification of character events (for accessibility etc) */
124
125struct vt_notifier_param {
126 struct vc_data *vc; /* VC on which the update happened */
127 unsigned int c; /* Printed char */
128};
129
130extern int register_vt_notifier(struct notifier_block *nb);
131extern int unregister_vt_notifier(struct notifier_block *nb);
132
119#endif /* _VT_KERN_H */ 133#endif /* _VT_KERN_H */
diff --git a/kernel/kfifo.c b/kernel/kfifo.c
index 26539e3228e5..3765ff3c1bbe 100644
--- a/kernel/kfifo.c
+++ b/kernel/kfifo.c
@@ -117,7 +117,7 @@ EXPORT_SYMBOL(kfifo_free);
117 * writer, you don't need extra locking to use these functions. 117 * writer, you don't need extra locking to use these functions.
118 */ 118 */
119unsigned int __kfifo_put(struct kfifo *fifo, 119unsigned int __kfifo_put(struct kfifo *fifo,
120 unsigned char *buffer, unsigned int len) 120 const unsigned char *buffer, unsigned int len)
121{ 121{
122 unsigned int l; 122 unsigned int l;
123 123
diff --git a/kernel/power/console.c b/kernel/power/console.c
index a3961b205de7..5187136fe1de 100644
--- a/kernel/power/console.c
+++ b/kernel/power/console.c
@@ -14,56 +14,13 @@
14#define SUSPEND_CONSOLE (MAX_NR_CONSOLES-1) 14#define SUSPEND_CONSOLE (MAX_NR_CONSOLES-1)
15 15
16static int orig_fgconsole, orig_kmsg; 16static int orig_fgconsole, orig_kmsg;
17static int disable_vt_switch;
18
19/*
20 * Normally during a suspend, we allocate a new console and switch to it.
21 * When we resume, we switch back to the original console. This switch
22 * can be slow, so on systems where the framebuffer can handle restoration
23 * of video registers anyways, there's little point in doing the console
24 * switch. This function allows you to disable it by passing it '0'.
25 */
26void pm_set_vt_switch(int do_switch)
27{
28 acquire_console_sem();
29 disable_vt_switch = !do_switch;
30 release_console_sem();
31}
32EXPORT_SYMBOL(pm_set_vt_switch);
33 17
34int pm_prepare_console(void) 18int pm_prepare_console(void)
35{ 19{
36 acquire_console_sem(); 20 orig_fgconsole = vt_move_to_console(SUSPEND_CONSOLE, 1);
37 21 if (orig_fgconsole < 0)
38 if (disable_vt_switch) {
39 release_console_sem();
40 return 0;
41 }
42
43 orig_fgconsole = fg_console;
44
45 if (vc_allocate(SUSPEND_CONSOLE)) {
46 /* we can't have a free VC for now. Too bad,
47 * we don't want to mess the screen for now. */
48 release_console_sem();
49 return 1; 22 return 1;
50 }
51 23
52 if (set_console(SUSPEND_CONSOLE)) {
53 /*
54 * We're unable to switch to the SUSPEND_CONSOLE.
55 * Let the calling function know so it can decide
56 * what to do.
57 */
58 release_console_sem();
59 return 1;
60 }
61 release_console_sem();
62
63 if (vt_waitactive(SUSPEND_CONSOLE)) {
64 pr_debug("Suspend: Can't switch VCs.");
65 return 1;
66 }
67 orig_kmsg = kmsg_redirect; 24 orig_kmsg = kmsg_redirect;
68 kmsg_redirect = SUSPEND_CONSOLE; 25 kmsg_redirect = SUSPEND_CONSOLE;
69 return 0; 26 return 0;
@@ -71,19 +28,9 @@ int pm_prepare_console(void)
71 28
72void pm_restore_console(void) 29void pm_restore_console(void)
73{ 30{
74 acquire_console_sem(); 31 if (orig_fgconsole >= 0) {
75 if (disable_vt_switch) { 32 vt_move_to_console(orig_fgconsole, 0);
76 release_console_sem(); 33 kmsg_redirect = orig_kmsg;
77 return;
78 }
79 set_console(orig_fgconsole);
80 release_console_sem();
81
82 if (vt_waitactive(orig_fgconsole)) {
83 pr_debug("Resume: Can't switch VCs.");
84 return;
85 } 34 }
86
87 kmsg_redirect = orig_kmsg;
88} 35}
89#endif 36#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-12-25 05:39:14 -0500