blob: 6fd60fece6b4b01684695b7df4af376e695ff873 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
3 *
4 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
5 * which can be dynamically activated and de-activated by the line
6 * discipline handling modules (like SLIP).
7 */
8
9#include <linux/types.h>
10#include <linux/termios.h>
11#include <linux/errno.h>
12#include <linux/sched.h>
13#include <linux/kernel.h>
14#include <linux/major.h>
15#include <linux/tty.h>
16#include <linux/fcntl.h>
17#include <linux/string.h>
18#include <linux/mm.h>
19#include <linux/module.h>
20#include <linux/bitops.h>
Arjan van de Ven5785c952006-09-29 02:00:43 -070021#include <linux/mutex.h>
Thomas Meyer8193c422011-10-05 23:13:13 +020022#include <linux/compat.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
24#include <asm/io.h>
25#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
27#undef TTY_DEBUG_WAIT_UNTIL_SENT
28
29#undef DEBUG
30
31/*
32 * Internal flag options for termios setting behavior
33 */
34#define TERMIOS_FLUSH 1
35#define TERMIOS_WAIT 2
36#define TERMIOS_TERMIO 4
Alan Coxedc6afc2006-12-08 02:38:44 -080037#define TERMIOS_OLD 8
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
Alan Coxaf9b8972006-08-27 01:24:01 -070039
Alan Coxd81ed102008-10-13 10:41:42 +010040/**
41 * tty_chars_in_buffer - characters pending
42 * @tty: terminal
43 *
44 * Return the number of bytes of data in the device private
45 * output queue. If no private method is supplied there is assumed
46 * to be no queue on the device.
47 */
48
Alan Coxf34d7a52008-04-30 00:54:13 -070049int tty_chars_in_buffer(struct tty_struct *tty)
50{
51 if (tty->ops->chars_in_buffer)
52 return tty->ops->chars_in_buffer(tty);
53 else
54 return 0;
55}
Alan Coxf34d7a52008-04-30 00:54:13 -070056EXPORT_SYMBOL(tty_chars_in_buffer);
57
Alan Coxd81ed102008-10-13 10:41:42 +010058/**
59 * tty_write_room - write queue space
60 * @tty: terminal
61 *
62 * Return the number of bytes that can be queued to this device
63 * at the present time. The result should be treated as a guarantee
64 * and the driver cannot offer a value it later shrinks by more than
65 * the number of bytes written. If no method is provided 2K is always
66 * returned and data may be lost as there will be no flow control.
67 */
68
Alan Coxf34d7a52008-04-30 00:54:13 -070069int tty_write_room(struct tty_struct *tty)
70{
71 if (tty->ops->write_room)
72 return tty->ops->write_room(tty);
73 return 2048;
74}
Alan Coxf34d7a52008-04-30 00:54:13 -070075EXPORT_SYMBOL(tty_write_room);
76
Alan Coxd81ed102008-10-13 10:41:42 +010077/**
78 * tty_driver_flush_buffer - discard internal buffer
79 * @tty: terminal
80 *
81 * Discard the internal output buffer for this device. If no method
82 * is provided then either the buffer cannot be hardware flushed or
83 * there is no buffer driver side.
84 */
Alan Coxf34d7a52008-04-30 00:54:13 -070085void tty_driver_flush_buffer(struct tty_struct *tty)
86{
87 if (tty->ops->flush_buffer)
88 tty->ops->flush_buffer(tty);
89}
Alan Coxf34d7a52008-04-30 00:54:13 -070090EXPORT_SYMBOL(tty_driver_flush_buffer);
91
Alan Coxd81ed102008-10-13 10:41:42 +010092/**
93 * tty_throttle - flow control
94 * @tty: terminal
95 *
96 * Indicate that a tty should stop transmitting data down the stack.
Peter Hurley6a1c0682013-06-15 09:14:23 -040097 * Takes the termios rwsem to protect against parallel throttle/unthrottle
Alan Cox38db8972009-06-11 12:44:17 +010098 * and also to ensure the driver can consistently reference its own
99 * termios data at this point when implementing software flow control.
Alan Coxd81ed102008-10-13 10:41:42 +0100100 */
101
Alan Cox39c2e602008-04-30 00:54:18 -0700102void tty_throttle(struct tty_struct *tty)
103{
Peter Hurley6a1c0682013-06-15 09:14:23 -0400104 down_write(&tty->termios_rwsem);
Alan Cox39c2e602008-04-30 00:54:18 -0700105 /* check TTY_THROTTLED first so it indicates our state */
106 if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
107 tty->ops->throttle)
108 tty->ops->throttle(tty);
Peter Hurley70bc1262013-03-06 08:20:52 -0500109 tty->flow_change = 0;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400110 up_write(&tty->termios_rwsem);
Alan Cox39c2e602008-04-30 00:54:18 -0700111}
112EXPORT_SYMBOL(tty_throttle);
113
Alan Coxd81ed102008-10-13 10:41:42 +0100114/**
115 * tty_unthrottle - flow control
116 * @tty: terminal
117 *
118 * Indicate that a tty may continue transmitting data down the stack.
Peter Hurley6a1c0682013-06-15 09:14:23 -0400119 * Takes the termios rwsem to protect against parallel throttle/unthrottle
Alan Cox38db8972009-06-11 12:44:17 +0100120 * and also to ensure the driver can consistently reference its own
121 * termios data at this point when implementing software flow control.
122 *
123 * Drivers should however remember that the stack can issue a throttle,
124 * then change flow control method, then unthrottle.
Alan Coxd81ed102008-10-13 10:41:42 +0100125 */
126
Alan Cox39c2e602008-04-30 00:54:18 -0700127void tty_unthrottle(struct tty_struct *tty)
128{
Peter Hurley6a1c0682013-06-15 09:14:23 -0400129 down_write(&tty->termios_rwsem);
Alan Cox39c2e602008-04-30 00:54:18 -0700130 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
131 tty->ops->unthrottle)
132 tty->ops->unthrottle(tty);
Peter Hurley70bc1262013-03-06 08:20:52 -0500133 tty->flow_change = 0;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400134 up_write(&tty->termios_rwsem);
Alan Cox39c2e602008-04-30 00:54:18 -0700135}
136EXPORT_SYMBOL(tty_unthrottle);
Alan Coxf34d7a52008-04-30 00:54:13 -0700137
Alan Coxaf9b8972006-08-27 01:24:01 -0700138/**
Peter Hurley70bc1262013-03-06 08:20:52 -0500139 * tty_throttle_safe - flow control
140 * @tty: terminal
141 *
142 * Similar to tty_throttle() but will only attempt throttle
143 * if tty->flow_change is TTY_THROTTLE_SAFE. Prevents an accidental
144 * throttle due to race conditions when throttling is conditional
145 * on factors evaluated prior to throttling.
146 *
147 * Returns 0 if tty is throttled (or was already throttled)
148 */
149
150int tty_throttle_safe(struct tty_struct *tty)
151{
152 int ret = 0;
153
Peter Hurleyd8c1f922013-06-15 09:14:31 -0400154 mutex_lock(&tty->throttle_mutex);
Peter Hurley70bc1262013-03-06 08:20:52 -0500155 if (!test_bit(TTY_THROTTLED, &tty->flags)) {
156 if (tty->flow_change != TTY_THROTTLE_SAFE)
157 ret = 1;
158 else {
Peter Hurley579a00a2013-04-15 11:06:06 -0400159 set_bit(TTY_THROTTLED, &tty->flags);
Peter Hurley70bc1262013-03-06 08:20:52 -0500160 if (tty->ops->throttle)
161 tty->ops->throttle(tty);
162 }
163 }
Peter Hurleyd8c1f922013-06-15 09:14:31 -0400164 mutex_unlock(&tty->throttle_mutex);
Peter Hurley70bc1262013-03-06 08:20:52 -0500165
166 return ret;
167}
168
169/**
170 * tty_unthrottle_safe - flow control
171 * @tty: terminal
172 *
173 * Similar to tty_unthrottle() but will only attempt unthrottle
174 * if tty->flow_change is TTY_UNTHROTTLE_SAFE. Prevents an accidental
175 * unthrottle due to race conditions when unthrottling is conditional
176 * on factors evaluated prior to unthrottling.
177 *
178 * Returns 0 if tty is unthrottled (or was already unthrottled)
179 */
180
181int tty_unthrottle_safe(struct tty_struct *tty)
182{
183 int ret = 0;
184
Peter Hurleyd8c1f922013-06-15 09:14:31 -0400185 mutex_lock(&tty->throttle_mutex);
Peter Hurley70bc1262013-03-06 08:20:52 -0500186 if (test_bit(TTY_THROTTLED, &tty->flags)) {
187 if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
188 ret = 1;
189 else {
Peter Hurley579a00a2013-04-15 11:06:06 -0400190 clear_bit(TTY_THROTTLED, &tty->flags);
Peter Hurley70bc1262013-03-06 08:20:52 -0500191 if (tty->ops->unthrottle)
192 tty->ops->unthrottle(tty);
193 }
194 }
Peter Hurleyd8c1f922013-06-15 09:14:31 -0400195 mutex_unlock(&tty->throttle_mutex);
Peter Hurley70bc1262013-03-06 08:20:52 -0500196
197 return ret;
198}
199
200/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700201 * tty_wait_until_sent - wait for I/O to finish
202 * @tty: tty we are waiting for
203 * @timeout: how long we will wait
204 *
205 * Wait for characters pending in a tty driver to hit the wire, or
206 * for a timeout to occur (eg due to flow control)
207 *
208 * Locking: none
209 */
210
Alan Cox355d95a12008-02-08 04:18:48 -0800211void tty_wait_until_sent(struct tty_struct *tty, long timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213#ifdef TTY_DEBUG_WAIT_UNTIL_SENT
214 char buf[64];
Alan Cox355d95a12008-02-08 04:18:48 -0800215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
217#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 if (!timeout)
219 timeout = MAX_SCHEDULE_TIMEOUT;
Jiri Slaby5a52bd42007-07-15 23:40:18 -0700220 if (wait_event_interruptible_timeout(tty->write_wait,
Alan Coxf34d7a52008-04-30 00:54:13 -0700221 !tty_chars_in_buffer(tty), timeout) >= 0) {
222 if (tty->ops->wait_until_sent)
223 tty->ops->wait_until_sent(tty, timeout);
Alan Cox0ee9cbb2008-04-30 00:53:32 -0700224 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226EXPORT_SYMBOL(tty_wait_until_sent);
227
Alan Coxd81ed102008-10-13 10:41:42 +0100228
229/*
230 * Termios Helper Methods
231 */
232
Alan Coxedc6afc2006-12-08 02:38:44 -0800233static void unset_locked_termios(struct ktermios *termios,
234 struct ktermios *old,
235 struct ktermios *locked)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236{
237 int i;
Alan Cox355d95a12008-02-08 04:18:48 -0800238
239#define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
241 if (!locked) {
242 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
243 return;
244 }
245
246 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
247 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
248 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
249 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
250 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
Alan Cox355d95a12008-02-08 04:18:48 -0800251 for (i = 0; i < NCCS; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 termios->c_cc[i] = locked->c_cc[i] ?
253 old->c_cc[i] : termios->c_cc[i];
Alan Coxedc6afc2006-12-08 02:38:44 -0800254 /* FIXME: What should we do for i/ospeed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255}
256
Alan Coxedc6afc2006-12-08 02:38:44 -0800257/*
258 * Routine which returns the baud rate of the tty
259 *
260 * Note that the baud_table needs to be kept in sync with the
261 * include/asm/termbits.h file.
262 */
263static const speed_t baud_table[] = {
264 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
265 9600, 19200, 38400, 57600, 115200, 230400, 460800,
266#ifdef __sparc__
267 76800, 153600, 307200, 614400, 921600
268#else
269 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
270 2500000, 3000000, 3500000, 4000000
271#endif
272};
273
274#ifndef __sparc__
275static const tcflag_t baud_bits[] = {
276 B0, B50, B75, B110, B134, B150, B200, B300, B600,
277 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
278 B57600, B115200, B230400, B460800, B500000, B576000,
279 B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
280 B3000000, B3500000, B4000000
281};
282#else
283static const tcflag_t baud_bits[] = {
284 B0, B50, B75, B110, B134, B150, B200, B300, B600,
285 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
286 B57600, B115200, B230400, B460800, B76800, B153600,
287 B307200, B614400, B921600
288};
289#endif
290
291static int n_baud_table = ARRAY_SIZE(baud_table);
292
293/**
294 * tty_termios_baud_rate
295 * @termios: termios structure
296 *
297 * Convert termios baud rate data into a speed. This should be called
298 * with the termios lock held if this termios is a terminal termios
299 * structure. May change the termios data. Device drivers can call this
300 * function but should use ->c_[io]speed directly as they are updated.
301 *
302 * Locking: none
303 */
304
305speed_t tty_termios_baud_rate(struct ktermios *termios)
306{
307 unsigned int cbaud;
308
309 cbaud = termios->c_cflag & CBAUD;
310
311#ifdef BOTHER
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300312 /* Magic token for arbitrary speed via c_ispeed/c_ospeed */
Alan Coxedc6afc2006-12-08 02:38:44 -0800313 if (cbaud == BOTHER)
314 return termios->c_ospeed;
315#endif
316 if (cbaud & CBAUDEX) {
317 cbaud &= ~CBAUDEX;
318
319 if (cbaud < 1 || cbaud + 15 > n_baud_table)
320 termios->c_cflag &= ~CBAUDEX;
321 else
322 cbaud += 15;
323 }
324 return baud_table[cbaud];
325}
Alan Coxedc6afc2006-12-08 02:38:44 -0800326EXPORT_SYMBOL(tty_termios_baud_rate);
327
328/**
329 * tty_termios_input_baud_rate
330 * @termios: termios structure
331 *
332 * Convert termios baud rate data into a speed. This should be called
333 * with the termios lock held if this termios is a terminal termios
334 * structure. May change the termios data. Device drivers can call this
335 * function but should use ->c_[io]speed directly as they are updated.
336 *
337 * Locking: none
338 */
339
340speed_t tty_termios_input_baud_rate(struct ktermios *termios)
341{
342#ifdef IBSHIFT
343 unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
344
345 if (cbaud == B0)
346 return tty_termios_baud_rate(termios);
347
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300348 /* Magic token for arbitrary speed via c_ispeed*/
Alan Coxedc6afc2006-12-08 02:38:44 -0800349 if (cbaud == BOTHER)
350 return termios->c_ispeed;
351
352 if (cbaud & CBAUDEX) {
353 cbaud &= ~CBAUDEX;
354
355 if (cbaud < 1 || cbaud + 15 > n_baud_table)
356 termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
357 else
358 cbaud += 15;
359 }
360 return baud_table[cbaud];
361#else
362 return tty_termios_baud_rate(termios);
363#endif
364}
Alan Coxedc6afc2006-12-08 02:38:44 -0800365EXPORT_SYMBOL(tty_termios_input_baud_rate);
366
Alan Coxedc6afc2006-12-08 02:38:44 -0800367/**
368 * tty_termios_encode_baud_rate
Alan Cox78137e32007-02-10 01:45:57 -0800369 * @termios: ktermios structure holding user requested state
Alan Coxedc6afc2006-12-08 02:38:44 -0800370 * @ispeed: input speed
371 * @ospeed: output speed
372 *
373 * Encode the speeds set into the passed termios structure. This is
Uwe Kleine-Königf98e5b82011-04-12 09:59:29 +0200374 * used as a library helper for drivers so that they can report back
Alan Coxedc6afc2006-12-08 02:38:44 -0800375 * the actual speed selected when it differs from the speed requested
376 *
Alan Cox78137e32007-02-10 01:45:57 -0800377 * For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
378 * we need to carefully set the bits when the user does not get the
379 * desired speed. We allow small margins and preserve as much of possible
Dirk Hohndel06fe9fb2009-09-28 21:43:57 -0400380 * of the input intent to keep compatibility.
Alan Coxedc6afc2006-12-08 02:38:44 -0800381 *
382 * Locking: Caller should hold termios lock. This is already held
383 * when calling this function from the driver termios handler.
Alan Cox5f519d72007-10-16 23:30:07 -0700384 *
385 * The ifdefs deal with platforms whose owners have yet to update them
386 * and will all go away once this is done.
Alan Coxedc6afc2006-12-08 02:38:44 -0800387 */
388
Maciej W. Rozycki75e8b712007-10-18 03:04:35 -0700389void tty_termios_encode_baud_rate(struct ktermios *termios,
390 speed_t ibaud, speed_t obaud)
Alan Coxedc6afc2006-12-08 02:38:44 -0800391{
392 int i = 0;
Alan Cox78137e32007-02-10 01:45:57 -0800393 int ifound = -1, ofound = -1;
394 int iclose = ibaud/50, oclose = obaud/50;
395 int ibinput = 0;
Alan Coxedc6afc2006-12-08 02:38:44 -0800396
Alan Cox5f519d72007-10-16 23:30:07 -0700397 if (obaud == 0) /* CD dropped */
398 ibaud = 0; /* Clear ibaud to be sure */
399
Alan Coxedc6afc2006-12-08 02:38:44 -0800400 termios->c_ispeed = ibaud;
401 termios->c_ospeed = obaud;
402
Alan Cox5f519d72007-10-16 23:30:07 -0700403#ifdef BOTHER
Alan Cox78137e32007-02-10 01:45:57 -0800404 /* If the user asked for a precise weird speed give a precise weird
405 answer. If they asked for a Bfoo speed they many have problems
406 digesting non-exact replies so fuzz a bit */
407
408 if ((termios->c_cflag & CBAUD) == BOTHER)
409 oclose = 0;
410 if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
411 iclose = 0;
412 if ((termios->c_cflag >> IBSHIFT) & CBAUD)
413 ibinput = 1; /* An input speed was specified */
Alan Cox5f519d72007-10-16 23:30:07 -0700414#endif
Alan Coxedc6afc2006-12-08 02:38:44 -0800415 termios->c_cflag &= ~CBAUD;
Alan Coxedc6afc2006-12-08 02:38:44 -0800416
Alan Cox5f519d72007-10-16 23:30:07 -0700417 /*
418 * Our goal is to find a close match to the standard baud rate
419 * returned. Walk the baud rate table and if we get a very close
420 * match then report back the speed as a POSIX Bxxxx value by
421 * preference
422 */
423
Alan Coxedc6afc2006-12-08 02:38:44 -0800424 do {
Maciej W. Rozycki75e8b712007-10-18 03:04:35 -0700425 if (obaud - oclose <= baud_table[i] &&
426 obaud + oclose >= baud_table[i]) {
Alan Coxedc6afc2006-12-08 02:38:44 -0800427 termios->c_cflag |= baud_bits[i];
Alan Cox78137e32007-02-10 01:45:57 -0800428 ofound = i;
Alan Coxedc6afc2006-12-08 02:38:44 -0800429 }
Maciej W. Rozycki75e8b712007-10-18 03:04:35 -0700430 if (ibaud - iclose <= baud_table[i] &&
431 ibaud + iclose >= baud_table[i]) {
432 /* For the case input == output don't set IBAUD bits
433 if the user didn't do so */
Alan Cox5f519d72007-10-16 23:30:07 -0700434 if (ofound == i && !ibinput)
435 ifound = i;
436#ifdef IBSHIFT
437 else {
438 ifound = i;
Alan Cox78137e32007-02-10 01:45:57 -0800439 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
Alan Cox5f519d72007-10-16 23:30:07 -0700440 }
441#endif
Alan Coxedc6afc2006-12-08 02:38:44 -0800442 }
Jiri Slaby68043962007-07-15 23:40:18 -0700443 } while (++i < n_baud_table);
Alan Cox5f519d72007-10-16 23:30:07 -0700444
445 /*
446 * If we found no match then use BOTHER if provided or warn
447 * the user their platform maintainer needs to wake up if not.
448 */
449#ifdef BOTHER
Alan Cox78137e32007-02-10 01:45:57 -0800450 if (ofound == -1)
Alan Coxedc6afc2006-12-08 02:38:44 -0800451 termios->c_cflag |= BOTHER;
Alan Cox78137e32007-02-10 01:45:57 -0800452 /* Set exact input bits only if the input and output differ or the
453 user already did */
Jiri Slaby68043962007-07-15 23:40:18 -0700454 if (ifound == -1 && (ibaud != obaud || ibinput))
Alan Coxedc6afc2006-12-08 02:38:44 -0800455 termios->c_cflag |= (BOTHER << IBSHIFT);
Alan Cox5f519d72007-10-16 23:30:07 -0700456#else
457 if (ifound == -1 || ofound == -1) {
Marcin Slusarz9074d962009-08-09 21:54:03 +0200458 printk_once(KERN_WARNING "tty: Unable to return correct "
Alan Cox5f519d72007-10-16 23:30:07 -0700459 "speed data as your architecture needs updating.\n");
460 }
461#endif
Alan Coxedc6afc2006-12-08 02:38:44 -0800462}
Alan Coxedc6afc2006-12-08 02:38:44 -0800463EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
464
Alan Coxd81ed102008-10-13 10:41:42 +0100465/**
466 * tty_encode_baud_rate - set baud rate of the tty
467 * @ibaud: input baud rate
468 * @obad: output baud rate
469 *
470 * Update the current termios data for the tty with the new speed
Peter Hurley6a1c0682013-06-15 09:14:23 -0400471 * settings. The caller must hold the termios_rwsem for the tty in
Alan Coxd81ed102008-10-13 10:41:42 +0100472 * question.
473 */
474
Alan Cox5f519d72007-10-16 23:30:07 -0700475void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
476{
Alan Coxadc8d742012-07-14 15:31:47 +0100477 tty_termios_encode_baud_rate(&tty->termios, ibaud, obaud);
Alan Cox5f519d72007-10-16 23:30:07 -0700478}
479EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
Alan Coxedc6afc2006-12-08 02:38:44 -0800480
481/**
Alan Cox5f519d72007-10-16 23:30:07 -0700482 * tty_termios_copy_hw - copy hardware settings
483 * @new: New termios
484 * @old: Old termios
485 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300486 * Propagate the hardware specific terminal setting bits from
Alan Cox5f519d72007-10-16 23:30:07 -0700487 * the old termios structure to the new one. This is used in cases
488 * where the hardware does not support reconfiguration or as a helper
489 * in some cases where only minimal reconfiguration is supported
490 */
491
492void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
493{
494 /* The bits a dumb device handles in software. Smart devices need
495 to always provide a set_termios method */
496 new->c_cflag &= HUPCL | CREAD | CLOCAL;
497 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
498 new->c_ispeed = old->c_ispeed;
499 new->c_ospeed = old->c_ospeed;
500}
Alan Cox5f519d72007-10-16 23:30:07 -0700501EXPORT_SYMBOL(tty_termios_copy_hw);
502
503/**
Alan Coxbf5e5832008-01-08 14:55:51 +0000504 * tty_termios_hw_change - check for setting change
505 * @a: termios
506 * @b: termios to compare
507 *
508 * Check if any of the bits that affect a dumb device have changed
509 * between the two termios structures, or a speed change is needed.
510 */
511
512int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
513{
514 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
515 return 1;
516 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
517 return 1;
518 return 0;
519}
520EXPORT_SYMBOL(tty_termios_hw_change);
521
522/**
Alan Cox8d075b12011-02-14 16:27:53 +0000523 * tty_set_termios - update termios values
Alan Coxaf9b8972006-08-27 01:24:01 -0700524 * @tty: tty to update
525 * @new_termios: desired new value
526 *
527 * Perform updates to the termios values set on this terminal. There
528 * is a bit of layering violation here with n_tty in terms of the
529 * internal knowledge of this function.
530 *
Peter Hurley6a1c0682013-06-15 09:14:23 -0400531 * Locking: termios_rwsem
Alan Coxaf9b8972006-08-27 01:24:01 -0700532 */
533
Alan Cox8d075b12011-02-14 16:27:53 +0000534int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535{
Alan Cox978e5952008-04-30 00:53:59 -0700536 struct ktermios old_termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 struct tty_ldisc *ld;
Alan Cox04f378b2008-04-30 00:53:29 -0700538 unsigned long flags;
Alan Cox355d95a12008-02-08 04:18:48 -0800539
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 /*
541 * Perform the actual termios internal changes under lock.
542 */
Alan Cox355d95a12008-02-08 04:18:48 -0800543
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
545 /* FIXME: we need to decide on some locking/ordering semantics
546 for the set_termios notification eventually */
Peter Hurley6a1c0682013-06-15 09:14:23 -0400547 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100548 old_termios = tty->termios;
549 tty->termios = *new_termios;
550 unset_locked_termios(&tty->termios, &old_termios, &tty->termios_locked);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
552 /* See if packet mode change of state. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 if (tty->link && tty->link->packet) {
hyc@symas.com26df6d12010-06-22 10:14:49 -0700554 int extproc = (old_termios.c_lflag & EXTPROC) |
Alan Coxadc8d742012-07-14 15:31:47 +0100555 (tty->termios.c_lflag & EXTPROC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 int old_flow = ((old_termios.c_iflag & IXON) &&
557 (old_termios.c_cc[VSTOP] == '\023') &&
558 (old_termios.c_cc[VSTART] == '\021'));
559 int new_flow = (I_IXON(tty) &&
560 STOP_CHAR(tty) == '\023' &&
561 START_CHAR(tty) == '\021');
hyc@symas.com26df6d12010-06-22 10:14:49 -0700562 if ((old_flow != new_flow) || extproc) {
Alan Cox04f378b2008-04-30 00:53:29 -0700563 spin_lock_irqsave(&tty->ctrl_lock, flags);
hyc@symas.com26df6d12010-06-22 10:14:49 -0700564 if (old_flow != new_flow) {
565 tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
566 if (new_flow)
567 tty->ctrl_status |= TIOCPKT_DOSTOP;
568 else
569 tty->ctrl_status |= TIOCPKT_NOSTOP;
570 }
571 if (extproc)
572 tty->ctrl_status |= TIOCPKT_IOCTL;
Alan Cox04f378b2008-04-30 00:53:29 -0700573 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 wake_up_interruptible(&tty->link->read_wait);
575 }
576 }
Alan Cox355d95a12008-02-08 04:18:48 -0800577
Alan Coxf34d7a52008-04-30 00:54:13 -0700578 if (tty->ops->set_termios)
579 (*tty->ops->set_termios)(tty, &old_termios);
Alan Cox5f519d72007-10-16 23:30:07 -0700580 else
Alan Coxadc8d742012-07-14 15:31:47 +0100581 tty_termios_copy_hw(&tty->termios, &old_termios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582
583 ld = tty_ldisc_ref(tty);
584 if (ld != NULL) {
Alan Coxa352def2008-07-16 21:53:12 +0100585 if (ld->ops->set_termios)
586 (ld->ops->set_termios)(tty, &old_termios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 tty_ldisc_deref(ld);
588 }
Peter Hurley6a1c0682013-06-15 09:14:23 -0400589 up_write(&tty->termios_rwsem);
Alan Cox8d075b12011-02-14 16:27:53 +0000590 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591}
Alan Cox8d075b12011-02-14 16:27:53 +0000592EXPORT_SYMBOL_GPL(tty_set_termios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593
Alan Coxaf9b8972006-08-27 01:24:01 -0700594/**
595 * set_termios - set termios values for a tty
596 * @tty: terminal device
597 * @arg: user data
598 * @opt: option information
599 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200600 * Helper function to prepare termios data and run necessary other
Alan Cox8d075b12011-02-14 16:27:53 +0000601 * functions before using tty_set_termios to do the actual changes.
Alan Coxaf9b8972006-08-27 01:24:01 -0700602 *
603 * Locking:
Peter Hurley6a1c0682013-06-15 09:14:23 -0400604 * Called functions take ldisc and termios_rwsem locks
Alan Coxaf9b8972006-08-27 01:24:01 -0700605 */
606
Alan Cox355d95a12008-02-08 04:18:48 -0800607static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608{
Alan Coxedc6afc2006-12-08 02:38:44 -0800609 struct ktermios tmp_termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 struct tty_ldisc *ld;
611 int retval = tty_check_change(tty);
612
613 if (retval)
614 return retval;
615
Peter Hurley6a1c0682013-06-15 09:14:23 -0400616 down_read(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100617 tmp_termios = tty->termios;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400618 up_read(&tty->termios_rwsem);
Alan Cox64bb6c52006-12-08 02:38:47 -0800619
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 if (opt & TERMIOS_TERMIO) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 if (user_termio_to_kernel_termios(&tmp_termios,
622 (struct termio __user *)arg))
623 return -EFAULT;
Alan Coxedc6afc2006-12-08 02:38:44 -0800624#ifdef TCGETS2
625 } else if (opt & TERMIOS_OLD) {
Alan Coxedc6afc2006-12-08 02:38:44 -0800626 if (user_termios_to_kernel_termios_1(&tmp_termios,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 (struct termios __user *)arg))
628 return -EFAULT;
Alan Cox64bb6c52006-12-08 02:38:47 -0800629 } else {
630 if (user_termios_to_kernel_termios(&tmp_termios,
631 (struct termios2 __user *)arg))
632 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 }
Alan Cox64bb6c52006-12-08 02:38:47 -0800634#else
635 } else if (user_termios_to_kernel_termios(&tmp_termios,
636 (struct termios __user *)arg))
637 return -EFAULT;
638#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
Alan Cox355d95a12008-02-08 04:18:48 -0800640 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
641 * with the real speed so its unconditionally usable */
Alan Coxedc6afc2006-12-08 02:38:44 -0800642 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
643 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
644
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 ld = tty_ldisc_ref(tty);
Alan Cox355d95a12008-02-08 04:18:48 -0800646
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 if (ld != NULL) {
Alan Coxa352def2008-07-16 21:53:12 +0100648 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
649 ld->ops->flush_buffer(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 tty_ldisc_deref(ld);
651 }
Alan Cox355d95a12008-02-08 04:18:48 -0800652
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 if (opt & TERMIOS_WAIT) {
654 tty_wait_until_sent(tty, 0);
655 if (signal_pending(current))
Oleg Nesterov183d95c2013-01-29 20:07:41 +0100656 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 }
658
Alan Cox8d075b12011-02-14 16:27:53 +0000659 tty_set_termios(tty, &tmp_termios);
Alan Cox5f519d72007-10-16 23:30:07 -0700660
661 /* FIXME: Arguably if tmp_termios == tty->termios AND the
662 actual requested termios was not tmp_termios then we may
663 want to return an error as no user requested change has
664 succeeded */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 return 0;
666}
667
Alan Cox26a2e202009-06-11 14:03:13 +0100668static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
669{
Peter Hurley6a1c0682013-06-15 09:14:23 -0400670 down_read(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100671 *kterm = tty->termios;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400672 up_read(&tty->termios_rwsem);
Alan Cox26a2e202009-06-11 14:03:13 +0100673}
674
675static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
676{
Peter Hurley6a1c0682013-06-15 09:14:23 -0400677 down_read(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100678 *kterm = tty->termios_locked;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400679 up_read(&tty->termios_rwsem);
Alan Cox26a2e202009-06-11 14:03:13 +0100680}
681
Alan Cox355d95a12008-02-08 04:18:48 -0800682static int get_termio(struct tty_struct *tty, struct termio __user *termio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683{
Alan Cox26a2e202009-06-11 14:03:13 +0100684 struct ktermios kterm;
685 copy_termios(tty, &kterm);
686 if (kernel_termios_to_user_termio(termio, &kterm))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 return -EFAULT;
688 return 0;
689}
690
Alan Cox1d65b4a2008-10-13 10:38:18 +0100691
692#ifdef TCGETX
693
694/**
695 * set_termiox - set termiox fields if possible
696 * @tty: terminal
697 * @arg: termiox structure from user
698 * @opt: option flags for ioctl type
699 *
700 * Implement the device calling points for the SYS5 termiox ioctl
701 * interface in Linux
702 */
703
704static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
705{
706 struct termiox tnew;
707 struct tty_ldisc *ld;
708
709 if (tty->termiox == NULL)
710 return -EINVAL;
711 if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
712 return -EFAULT;
713
714 ld = tty_ldisc_ref(tty);
715 if (ld != NULL) {
716 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
717 ld->ops->flush_buffer(tty);
718 tty_ldisc_deref(ld);
719 }
720 if (opt & TERMIOS_WAIT) {
721 tty_wait_until_sent(tty, 0);
722 if (signal_pending(current))
Oleg Nesterov183d95c2013-01-29 20:07:41 +0100723 return -ERESTARTSYS;
Alan Cox1d65b4a2008-10-13 10:38:18 +0100724 }
725
Peter Hurley6a1c0682013-06-15 09:14:23 -0400726 down_write(&tty->termios_rwsem);
Alan Cox1d65b4a2008-10-13 10:38:18 +0100727 if (tty->ops->set_termiox)
728 tty->ops->set_termiox(tty, &tnew);
Peter Hurley6a1c0682013-06-15 09:14:23 -0400729 up_write(&tty->termios_rwsem);
Alan Cox1d65b4a2008-10-13 10:38:18 +0100730 return 0;
731}
732
733#endif
734
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735
736#ifdef TIOCGETP
737/*
738 * These are deprecated, but there is limited support..
739 *
740 * The "sg_flags" translation is a joke..
741 */
Alan Cox355d95a12008-02-08 04:18:48 -0800742static int get_sgflags(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743{
744 int flags = 0;
745
Alan Coxadc8d742012-07-14 15:31:47 +0100746 if (!(tty->termios.c_lflag & ICANON)) {
747 if (tty->termios.c_lflag & ISIG)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 flags |= 0x02; /* cbreak */
749 else
750 flags |= 0x20; /* raw */
751 }
Alan Coxadc8d742012-07-14 15:31:47 +0100752 if (tty->termios.c_lflag & ECHO)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 flags |= 0x08; /* echo */
Alan Coxadc8d742012-07-14 15:31:47 +0100754 if (tty->termios.c_oflag & OPOST)
755 if (tty->termios.c_oflag & ONLCR)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 flags |= 0x10; /* crmod */
757 return flags;
758}
759
Alan Cox355d95a12008-02-08 04:18:48 -0800760static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761{
762 struct sgttyb tmp;
763
Peter Hurley6a1c0682013-06-15 09:14:23 -0400764 down_read(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100765 tmp.sg_ispeed = tty->termios.c_ispeed;
766 tmp.sg_ospeed = tty->termios.c_ospeed;
767 tmp.sg_erase = tty->termios.c_cc[VERASE];
768 tmp.sg_kill = tty->termios.c_cc[VKILL];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 tmp.sg_flags = get_sgflags(tty);
Peter Hurley6a1c0682013-06-15 09:14:23 -0400770 up_read(&tty->termios_rwsem);
Alan Cox355d95a12008-02-08 04:18:48 -0800771
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
773}
774
Alan Cox355d95a12008-02-08 04:18:48 -0800775static void set_sgflags(struct ktermios *termios, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776{
Alan Cox9833fac2012-07-17 17:05:40 +0100777 termios->c_iflag = ICRNL | IXON;
778 termios->c_oflag = 0;
779 termios->c_lflag = ISIG | ICANON;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 if (flags & 0x02) { /* cbreak */
Alan Cox9833fac2012-07-17 17:05:40 +0100781 termios->c_iflag = 0;
782 termios->c_lflag &= ~ICANON;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 }
784 if (flags & 0x08) { /* echo */
Alan Cox9833fac2012-07-17 17:05:40 +0100785 termios->c_lflag |= ECHO | ECHOE | ECHOK |
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 ECHOCTL | ECHOKE | IEXTEN;
787 }
788 if (flags & 0x10) { /* crmod */
Alan Cox9833fac2012-07-17 17:05:40 +0100789 termios->c_oflag |= OPOST | ONLCR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 }
791 if (flags & 0x20) { /* raw */
Alan Cox9833fac2012-07-17 17:05:40 +0100792 termios->c_iflag = 0;
793 termios->c_lflag &= ~(ISIG | ICANON);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 }
Alan Cox9833fac2012-07-17 17:05:40 +0100795 if (!(termios->c_lflag & ICANON)) {
796 termios->c_cc[VMIN] = 1;
797 termios->c_cc[VTIME] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 }
799}
800
Alan Coxaf9b8972006-08-27 01:24:01 -0700801/**
802 * set_sgttyb - set legacy terminal values
803 * @tty: tty structure
804 * @sgttyb: pointer to old style terminal structure
805 *
806 * Updates a terminal from the legacy BSD style terminal information
807 * structure.
808 *
Peter Hurley6a1c0682013-06-15 09:14:23 -0400809 * Locking: termios_rwsem
Alan Coxaf9b8972006-08-27 01:24:01 -0700810 */
811
Alan Cox355d95a12008-02-08 04:18:48 -0800812static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813{
814 int retval;
815 struct sgttyb tmp;
Alan Coxedc6afc2006-12-08 02:38:44 -0800816 struct ktermios termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
818 retval = tty_check_change(tty);
819 if (retval)
820 return retval;
Alan Cox355d95a12008-02-08 04:18:48 -0800821
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
823 return -EFAULT;
824
Peter Hurley6a1c0682013-06-15 09:14:23 -0400825 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100826 termios = tty->termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 termios.c_cc[VERASE] = tmp.sg_erase;
828 termios.c_cc[VKILL] = tmp.sg_kill;
829 set_sgflags(&termios, tmp.sg_flags);
Alan Coxedc6afc2006-12-08 02:38:44 -0800830 /* Try and encode into Bfoo format */
831#ifdef BOTHER
Alan Cox355d95a12008-02-08 04:18:48 -0800832 tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
833 termios.c_ospeed);
Alan Coxedc6afc2006-12-08 02:38:44 -0800834#endif
Peter Hurley6a1c0682013-06-15 09:14:23 -0400835 up_write(&tty->termios_rwsem);
Alan Cox8d075b12011-02-14 16:27:53 +0000836 tty_set_termios(tty, &termios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 return 0;
838}
839#endif
840
841#ifdef TIOCGETC
Alan Cox355d95a12008-02-08 04:18:48 -0800842static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843{
844 struct tchars tmp;
845
Peter Hurley6a1c0682013-06-15 09:14:23 -0400846 down_read(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100847 tmp.t_intrc = tty->termios.c_cc[VINTR];
848 tmp.t_quitc = tty->termios.c_cc[VQUIT];
849 tmp.t_startc = tty->termios.c_cc[VSTART];
850 tmp.t_stopc = tty->termios.c_cc[VSTOP];
851 tmp.t_eofc = tty->termios.c_cc[VEOF];
852 tmp.t_brkc = tty->termios.c_cc[VEOL2]; /* what is brkc anyway? */
Peter Hurley6a1c0682013-06-15 09:14:23 -0400853 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
855}
856
Alan Cox355d95a12008-02-08 04:18:48 -0800857static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858{
859 struct tchars tmp;
860
861 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
862 return -EFAULT;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400863 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100864 tty->termios.c_cc[VINTR] = tmp.t_intrc;
865 tty->termios.c_cc[VQUIT] = tmp.t_quitc;
866 tty->termios.c_cc[VSTART] = tmp.t_startc;
867 tty->termios.c_cc[VSTOP] = tmp.t_stopc;
868 tty->termios.c_cc[VEOF] = tmp.t_eofc;
869 tty->termios.c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
Peter Hurley6a1c0682013-06-15 09:14:23 -0400870 up_write(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 return 0;
872}
873#endif
874
875#ifdef TIOCGLTC
Alan Cox355d95a12008-02-08 04:18:48 -0800876static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877{
878 struct ltchars tmp;
879
Peter Hurley6a1c0682013-06-15 09:14:23 -0400880 down_read(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100881 tmp.t_suspc = tty->termios.c_cc[VSUSP];
Alan Cox355d95a12008-02-08 04:18:48 -0800882 /* what is dsuspc anyway? */
Alan Coxadc8d742012-07-14 15:31:47 +0100883 tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
884 tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
Alan Cox355d95a12008-02-08 04:18:48 -0800885 /* what is flushc anyway? */
Alan Coxadc8d742012-07-14 15:31:47 +0100886 tmp.t_flushc = tty->termios.c_cc[VEOL2];
887 tmp.t_werasc = tty->termios.c_cc[VWERASE];
888 tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
Peter Hurley6a1c0682013-06-15 09:14:23 -0400889 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
891}
892
Alan Cox355d95a12008-02-08 04:18:48 -0800893static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894{
895 struct ltchars tmp;
896
897 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
898 return -EFAULT;
899
Peter Hurley6a1c0682013-06-15 09:14:23 -0400900 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100901 tty->termios.c_cc[VSUSP] = tmp.t_suspc;
Alan Cox355d95a12008-02-08 04:18:48 -0800902 /* what is dsuspc anyway? */
Alan Coxadc8d742012-07-14 15:31:47 +0100903 tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
904 tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
Alan Cox355d95a12008-02-08 04:18:48 -0800905 /* what is flushc anyway? */
Alan Coxadc8d742012-07-14 15:31:47 +0100906 tty->termios.c_cc[VEOL2] = tmp.t_flushc;
907 tty->termios.c_cc[VWERASE] = tmp.t_werasc;
908 tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400909 up_write(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 return 0;
911}
912#endif
913
Alan Coxaf9b8972006-08-27 01:24:01 -0700914/**
915 * send_prio_char - send priority character
916 *
917 * Send a high priority character to the tty even if stopped
918 *
Alan Cox5f412b22006-09-29 02:01:40 -0700919 * Locking: none for xchar method, write ordering for write method.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 */
Alan Coxaf9b8972006-08-27 01:24:01 -0700921
Alan Cox5f412b22006-09-29 02:01:40 -0700922static int send_prio_char(struct tty_struct *tty, char ch)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923{
924 int was_stopped = tty->stopped;
925
Alan Coxf34d7a52008-04-30 00:54:13 -0700926 if (tty->ops->send_xchar) {
927 tty->ops->send_xchar(tty, ch);
Alan Cox5f412b22006-09-29 02:01:40 -0700928 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 }
Alan Cox5f412b22006-09-29 02:01:40 -0700930
Alan Cox9c1729d2007-07-15 23:39:43 -0700931 if (tty_write_lock(tty, 0) < 0)
Alan Cox5f412b22006-09-29 02:01:40 -0700932 return -ERESTARTSYS;
933
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 if (was_stopped)
935 start_tty(tty);
Alan Coxf34d7a52008-04-30 00:54:13 -0700936 tty->ops->write(tty, &ch, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 if (was_stopped)
938 stop_tty(tty);
Alan Cox9c1729d2007-07-15 23:39:43 -0700939 tty_write_unlock(tty);
Alan Cox5f412b22006-09-29 02:01:40 -0700940 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941}
942
Alan Cox0fc00e22007-11-07 01:24:56 -0800943/**
Alan Cox1c2630c2008-04-30 00:53:34 -0700944 * tty_change_softcar - carrier change ioctl helper
945 * @tty: tty to update
946 * @arg: enable/disable CLOCAL
947 *
948 * Perform a change to the CLOCAL state and call into the driver
Peter Hurley6a1c0682013-06-15 09:14:23 -0400949 * layer to make it visible. All done with the termios rwsem
Alan Cox1c2630c2008-04-30 00:53:34 -0700950 */
951
952static int tty_change_softcar(struct tty_struct *tty, int arg)
953{
954 int ret = 0;
955 int bit = arg ? CLOCAL : 0;
Alan Coxf34d7a52008-04-30 00:54:13 -0700956 struct ktermios old;
Alan Cox1c2630c2008-04-30 00:53:34 -0700957
Peter Hurley6a1c0682013-06-15 09:14:23 -0400958 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100959 old = tty->termios;
960 tty->termios.c_cflag &= ~CLOCAL;
961 tty->termios.c_cflag |= bit;
Alan Coxf34d7a52008-04-30 00:54:13 -0700962 if (tty->ops->set_termios)
963 tty->ops->set_termios(tty, &old);
Alan Coxadc8d742012-07-14 15:31:47 +0100964 if ((tty->termios.c_cflag & CLOCAL) != bit)
Alan Cox1c2630c2008-04-30 00:53:34 -0700965 ret = -EINVAL;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400966 up_write(&tty->termios_rwsem);
Alan Cox1c2630c2008-04-30 00:53:34 -0700967 return ret;
968}
969
970/**
Alan Cox0fc00e22007-11-07 01:24:56 -0800971 * tty_mode_ioctl - mode related ioctls
972 * @tty: tty for the ioctl
973 * @file: file pointer for the tty
974 * @cmd: command
975 * @arg: ioctl argument
976 *
977 * Perform non line discipline specific mode control ioctls. This
978 * is designed to be called by line disciplines to ensure they provide
979 * consistent mode setting.
980 */
981
Alan Cox355d95a12008-02-08 04:18:48 -0800982int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
Alan Cox0fc00e22007-11-07 01:24:56 -0800983 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984{
Alan Cox355d95a12008-02-08 04:18:48 -0800985 struct tty_struct *real_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 void __user *p = (void __user *)arg;
Alan Cox8f520022008-10-13 10:38:46 +0100987 int ret = 0;
Alan Cox26a2e202009-06-11 14:03:13 +0100988 struct ktermios kterm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989
Alan Cox8d075b12011-02-14 16:27:53 +0000990 BUG_ON(file == NULL);
991
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
993 tty->driver->subtype == PTY_TYPE_MASTER)
994 real_tty = tty->link;
995 else
996 real_tty = tty;
997
998 switch (cmd) {
999#ifdef TIOCGETP
Alan Cox355d95a12008-02-08 04:18:48 -08001000 case TIOCGETP:
1001 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
1002 case TIOCSETP:
1003 case TIOCSETN:
1004 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005#endif
1006#ifdef TIOCGETC
Alan Cox355d95a12008-02-08 04:18:48 -08001007 case TIOCGETC:
1008 return get_tchars(real_tty, p);
1009 case TIOCSETC:
1010 return set_tchars(real_tty, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011#endif
1012#ifdef TIOCGLTC
Alan Cox355d95a12008-02-08 04:18:48 -08001013 case TIOCGLTC:
1014 return get_ltchars(real_tty, p);
1015 case TIOCSLTC:
1016 return set_ltchars(real_tty, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017#endif
Alan Cox355d95a12008-02-08 04:18:48 -08001018 case TCSETSF:
1019 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
1020 case TCSETSW:
1021 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
1022 case TCSETS:
1023 return set_termios(real_tty, p, TERMIOS_OLD);
Alan Coxedc6afc2006-12-08 02:38:44 -08001024#ifndef TCGETS2
Alan Cox355d95a12008-02-08 04:18:48 -08001025 case TCGETS:
Alan Cox26a2e202009-06-11 14:03:13 +01001026 copy_termios(real_tty, &kterm);
1027 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
Alan Cox8f520022008-10-13 10:38:46 +01001028 ret = -EFAULT;
Alan Cox8f520022008-10-13 10:38:46 +01001029 return ret;
Alan Coxedc6afc2006-12-08 02:38:44 -08001030#else
Alan Cox355d95a12008-02-08 04:18:48 -08001031 case TCGETS:
Alan Cox26a2e202009-06-11 14:03:13 +01001032 copy_termios(real_tty, &kterm);
1033 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
Alan Cox8f520022008-10-13 10:38:46 +01001034 ret = -EFAULT;
Alan Cox8f520022008-10-13 10:38:46 +01001035 return ret;
Alan Cox355d95a12008-02-08 04:18:48 -08001036 case TCGETS2:
Alan Cox26a2e202009-06-11 14:03:13 +01001037 copy_termios(real_tty, &kterm);
1038 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
Alan Cox8f520022008-10-13 10:38:46 +01001039 ret = -EFAULT;
Alan Cox8f520022008-10-13 10:38:46 +01001040 return ret;
Alan Cox355d95a12008-02-08 04:18:48 -08001041 case TCSETSF2:
1042 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
1043 case TCSETSW2:
1044 return set_termios(real_tty, p, TERMIOS_WAIT);
1045 case TCSETS2:
1046 return set_termios(real_tty, p, 0);
Alan Coxedc6afc2006-12-08 02:38:44 -08001047#endif
Alan Cox355d95a12008-02-08 04:18:48 -08001048 case TCGETA:
1049 return get_termio(real_tty, p);
1050 case TCSETAF:
1051 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
1052 case TCSETAW:
1053 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
1054 case TCSETA:
1055 return set_termios(real_tty, p, TERMIOS_TERMIO);
Alan Cox0fc00e22007-11-07 01:24:56 -08001056#ifndef TCGETS2
Alan Cox355d95a12008-02-08 04:18:48 -08001057 case TIOCGLCKTRMIOS:
Alan Cox26a2e202009-06-11 14:03:13 +01001058 copy_termios_locked(real_tty, &kterm);
1059 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
Alan Cox8f520022008-10-13 10:38:46 +01001060 ret = -EFAULT;
Alan Cox8f520022008-10-13 10:38:46 +01001061 return ret;
Alan Cox355d95a12008-02-08 04:18:48 -08001062 case TIOCSLCKTRMIOS:
1063 if (!capable(CAP_SYS_ADMIN))
1064 return -EPERM;
Alan Cox26a2e202009-06-11 14:03:13 +01001065 copy_termios_locked(real_tty, &kterm);
1066 if (user_termios_to_kernel_termios(&kterm,
Alan Cox355d95a12008-02-08 04:18:48 -08001067 (struct termios __user *) arg))
Alan Cox26a2e202009-06-11 14:03:13 +01001068 return -EFAULT;
Peter Hurley6a1c0682013-06-15 09:14:23 -04001069 down_write(&real_tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +01001070 real_tty->termios_locked = kterm;
Peter Hurley6a1c0682013-06-15 09:14:23 -04001071 up_write(&real_tty->termios_rwsem);
Alan Cox26a2e202009-06-11 14:03:13 +01001072 return 0;
Alan Cox0fc00e22007-11-07 01:24:56 -08001073#else
Alan Cox355d95a12008-02-08 04:18:48 -08001074 case TIOCGLCKTRMIOS:
Alan Cox26a2e202009-06-11 14:03:13 +01001075 copy_termios_locked(real_tty, &kterm);
1076 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
Alan Cox8f520022008-10-13 10:38:46 +01001077 ret = -EFAULT;
Alan Cox8f520022008-10-13 10:38:46 +01001078 return ret;
Alan Cox355d95a12008-02-08 04:18:48 -08001079 case TIOCSLCKTRMIOS:
1080 if (!capable(CAP_SYS_ADMIN))
Alan Cox26a2e202009-06-11 14:03:13 +01001081 return -EPERM;
1082 copy_termios_locked(real_tty, &kterm);
1083 if (user_termios_to_kernel_termios_1(&kterm,
Alan Cox355d95a12008-02-08 04:18:48 -08001084 (struct termios __user *) arg))
Alan Cox26a2e202009-06-11 14:03:13 +01001085 return -EFAULT;
Peter Hurley6a1c0682013-06-15 09:14:23 -04001086 down_write(&real_tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +01001087 real_tty->termios_locked = kterm;
Peter Hurley6a1c0682013-06-15 09:14:23 -04001088 up_write(&real_tty->termios_rwsem);
Alan Cox8f520022008-10-13 10:38:46 +01001089 return ret;
Alan Cox0fc00e22007-11-07 01:24:56 -08001090#endif
Alan Cox1d65b4a2008-10-13 10:38:18 +01001091#ifdef TCGETX
Mike Frysinger5dca6072009-06-16 17:01:02 +01001092 case TCGETX: {
1093 struct termiox ktermx;
Alan Cox1d65b4a2008-10-13 10:38:18 +01001094 if (real_tty->termiox == NULL)
1095 return -EINVAL;
Peter Hurley6a1c0682013-06-15 09:14:23 -04001096 down_read(&real_tty->termios_rwsem);
Alan Cox26a2e202009-06-11 14:03:13 +01001097 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
Peter Hurley6a1c0682013-06-15 09:14:23 -04001098 up_read(&real_tty->termios_rwsem);
Alan Cox26a2e202009-06-11 14:03:13 +01001099 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
1100 ret = -EFAULT;
Alan Cox8f520022008-10-13 10:38:46 +01001101 return ret;
Mike Frysinger5dca6072009-06-16 17:01:02 +01001102 }
Alan Cox1d65b4a2008-10-13 10:38:18 +01001103 case TCSETX:
1104 return set_termiox(real_tty, p, 0);
1105 case TCSETXW:
1106 return set_termiox(real_tty, p, TERMIOS_WAIT);
1107 case TCSETXF:
1108 return set_termiox(real_tty, p, TERMIOS_FLUSH);
1109#endif
Alan Cox355d95a12008-02-08 04:18:48 -08001110 case TIOCGSOFTCAR:
Alan Cox26a2e202009-06-11 14:03:13 +01001111 copy_termios(real_tty, &kterm);
1112 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
Alan Cox355d95a12008-02-08 04:18:48 -08001113 (int __user *)arg);
Alan Cox8f520022008-10-13 10:38:46 +01001114 return ret;
Alan Cox355d95a12008-02-08 04:18:48 -08001115 case TIOCSSOFTCAR:
1116 if (get_user(arg, (unsigned int __user *) arg))
1117 return -EFAULT;
Alan Coxf753f322008-08-26 19:52:47 +01001118 return tty_change_softcar(real_tty, arg);
Alan Cox355d95a12008-02-08 04:18:48 -08001119 default:
1120 return -ENOIOCTLCMD;
Alan Cox0fc00e22007-11-07 01:24:56 -08001121 }
1122}
Alan Cox0fc00e22007-11-07 01:24:56 -08001123EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1124
Alan Cox0fc00e22007-11-07 01:24:56 -08001125
Peter Hurleye7f38802013-03-11 16:44:45 -04001126/* Caller guarantees ldisc reference is held */
1127static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1128{
1129 struct tty_ldisc *ld = tty->ldisc;
1130
Alan Cox0fc00e22007-11-07 01:24:56 -08001131 switch (arg) {
1132 case TCIFLUSH:
Ilya Zykova1bf9582013-01-16 13:07:50 +04001133 if (ld && ld->ops->flush_buffer) {
Alan Coxa352def2008-07-16 21:53:12 +01001134 ld->ops->flush_buffer(tty);
Ilya Zykova1bf9582013-01-16 13:07:50 +04001135 tty_unthrottle(tty);
1136 }
Alan Cox0fc00e22007-11-07 01:24:56 -08001137 break;
1138 case TCIOFLUSH:
Ilya Zykova1bf9582013-01-16 13:07:50 +04001139 if (ld && ld->ops->flush_buffer) {
Alan Coxa352def2008-07-16 21:53:12 +01001140 ld->ops->flush_buffer(tty);
Ilya Zykova1bf9582013-01-16 13:07:50 +04001141 tty_unthrottle(tty);
1142 }
Alan Cox0fc00e22007-11-07 01:24:56 -08001143 /* fall through */
1144 case TCOFLUSH:
Alan Coxf34d7a52008-04-30 00:54:13 -07001145 tty_driver_flush_buffer(tty);
Alan Cox0fc00e22007-11-07 01:24:56 -08001146 break;
1147 default:
Alan Cox0fc00e22007-11-07 01:24:56 -08001148 return -EINVAL;
1149 }
Alan Cox0fc00e22007-11-07 01:24:56 -08001150 return 0;
1151}
Peter Hurleye7f38802013-03-11 16:44:45 -04001152
1153int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1154{
1155 struct tty_ldisc *ld;
1156 int retval = tty_check_change(tty);
1157 if (retval)
1158 return retval;
1159
1160 ld = tty_ldisc_ref_wait(tty);
1161 retval = __tty_perform_flush(tty, arg);
1162 if (ld)
1163 tty_ldisc_deref(ld);
1164 return retval;
1165}
Alan Cox0fc00e22007-11-07 01:24:56 -08001166EXPORT_SYMBOL_GPL(tty_perform_flush);
1167
Alan Cox47afa7a2008-10-13 10:44:17 +01001168int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
Alan Cox0fc00e22007-11-07 01:24:56 -08001169 unsigned int cmd, unsigned long arg)
1170{
Alan Cox0fc00e22007-11-07 01:24:56 -08001171 int retval;
1172
Alan Cox0fc00e22007-11-07 01:24:56 -08001173 switch (cmd) {
Alan Cox355d95a12008-02-08 04:18:48 -08001174 case TCXONC:
1175 retval = tty_check_change(tty);
1176 if (retval)
1177 return retval;
1178 switch (arg) {
1179 case TCOOFF:
1180 if (!tty->flow_stopped) {
1181 tty->flow_stopped = 1;
1182 stop_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 }
Alan Cox355d95a12008-02-08 04:18:48 -08001184 break;
1185 case TCOON:
1186 if (tty->flow_stopped) {
1187 tty->flow_stopped = 0;
1188 start_tty(tty);
1189 }
1190 break;
1191 case TCIOFF:
1192 if (STOP_CHAR(tty) != __DISABLED_CHAR)
1193 return send_prio_char(tty, STOP_CHAR(tty));
1194 break;
1195 case TCION:
1196 if (START_CHAR(tty) != __DISABLED_CHAR)
1197 return send_prio_char(tty, START_CHAR(tty));
1198 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 default:
Alan Cox355d95a12008-02-08 04:18:48 -08001200 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 }
Alan Cox355d95a12008-02-08 04:18:48 -08001202 return 0;
1203 case TCFLSH:
Peter Hurley5cec7bf2013-09-25 20:13:04 -04001204 retval = tty_check_change(tty);
1205 if (retval)
1206 return retval;
Peter Hurleye7f38802013-03-11 16:44:45 -04001207 return __tty_perform_flush(tty, arg);
Alan Cox355d95a12008-02-08 04:18:48 -08001208 default:
1209 /* Try the mode commands */
1210 return tty_mode_ioctl(tty, file, cmd, arg);
1211 }
1212}
Alan Cox47afa7a2008-10-13 10:44:17 +01001213EXPORT_SYMBOL(n_tty_ioctl_helper);
Thomas Meyer8193c422011-10-05 23:13:13 +02001214
1215#ifdef CONFIG_COMPAT
1216long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
1217 unsigned int cmd, unsigned long arg)
1218{
1219 switch (cmd) {
1220 case TIOCGLCKTRMIOS:
1221 case TIOCSLCKTRMIOS:
1222 return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
1223 default:
1224 return -ENOIOCTLCMD;
1225 }
1226}
1227EXPORT_SYMBOL(n_tty_compat_ioctl_helper);
1228#endif
1229