blob: bf36ac9aee41cdb7aa1172e65c55d5bd5e20beda [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
Peter Hurleyff8339d2015-07-12 22:49:11 -040029#ifdef TTY_DEBUG_WAIT_UNTIL_SENT
30# define tty_debug_wait_until_sent(tty, f, args...) tty_debug(tty, f, ##args)
31#else
32# define tty_debug_wait_until_sent(tty, f, args...) do {} while (0)
33#endif
34
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#undef DEBUG
36
37/*
38 * Internal flag options for termios setting behavior
39 */
40#define TERMIOS_FLUSH 1
41#define TERMIOS_WAIT 2
42#define TERMIOS_TERMIO 4
Alan Coxedc6afc2006-12-08 02:38:44 -080043#define TERMIOS_OLD 8
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Alan Coxaf9b8972006-08-27 01:24:01 -070045
Alan Coxd81ed102008-10-13 10:41:42 +010046/**
47 * tty_chars_in_buffer - characters pending
48 * @tty: terminal
49 *
50 * Return the number of bytes of data in the device private
51 * output queue. If no private method is supplied there is assumed
52 * to be no queue on the device.
53 */
54
Alan Coxf34d7a52008-04-30 00:54:13 -070055int tty_chars_in_buffer(struct tty_struct *tty)
56{
57 if (tty->ops->chars_in_buffer)
58 return tty->ops->chars_in_buffer(tty);
59 else
60 return 0;
61}
Alan Coxf34d7a52008-04-30 00:54:13 -070062EXPORT_SYMBOL(tty_chars_in_buffer);
63
Alan Coxd81ed102008-10-13 10:41:42 +010064/**
65 * tty_write_room - write queue space
66 * @tty: terminal
67 *
68 * Return the number of bytes that can be queued to this device
69 * at the present time. The result should be treated as a guarantee
70 * and the driver cannot offer a value it later shrinks by more than
71 * the number of bytes written. If no method is provided 2K is always
72 * returned and data may be lost as there will be no flow control.
73 */
74
Alan Coxf34d7a52008-04-30 00:54:13 -070075int tty_write_room(struct tty_struct *tty)
76{
77 if (tty->ops->write_room)
78 return tty->ops->write_room(tty);
79 return 2048;
80}
Alan Coxf34d7a52008-04-30 00:54:13 -070081EXPORT_SYMBOL(tty_write_room);
82
Alan Coxd81ed102008-10-13 10:41:42 +010083/**
84 * tty_driver_flush_buffer - discard internal buffer
85 * @tty: terminal
86 *
87 * Discard the internal output buffer for this device. If no method
88 * is provided then either the buffer cannot be hardware flushed or
89 * there is no buffer driver side.
90 */
Alan Coxf34d7a52008-04-30 00:54:13 -070091void tty_driver_flush_buffer(struct tty_struct *tty)
92{
93 if (tty->ops->flush_buffer)
94 tty->ops->flush_buffer(tty);
95}
Alan Coxf34d7a52008-04-30 00:54:13 -070096EXPORT_SYMBOL(tty_driver_flush_buffer);
97
Alan Coxd81ed102008-10-13 10:41:42 +010098/**
99 * tty_throttle - flow control
100 * @tty: terminal
101 *
102 * Indicate that a tty should stop transmitting data down the stack.
Peter Hurley6a1c0682013-06-15 09:14:23 -0400103 * Takes the termios rwsem to protect against parallel throttle/unthrottle
Alan Cox38db8972009-06-11 12:44:17 +0100104 * and also to ensure the driver can consistently reference its own
105 * termios data at this point when implementing software flow control.
Alan Coxd81ed102008-10-13 10:41:42 +0100106 */
107
Alan Cox39c2e602008-04-30 00:54:18 -0700108void tty_throttle(struct tty_struct *tty)
109{
Peter Hurley6a1c0682013-06-15 09:14:23 -0400110 down_write(&tty->termios_rwsem);
Alan Cox39c2e602008-04-30 00:54:18 -0700111 /* check TTY_THROTTLED first so it indicates our state */
112 if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
113 tty->ops->throttle)
114 tty->ops->throttle(tty);
Peter Hurley70bc1262013-03-06 08:20:52 -0500115 tty->flow_change = 0;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400116 up_write(&tty->termios_rwsem);
Alan Cox39c2e602008-04-30 00:54:18 -0700117}
118EXPORT_SYMBOL(tty_throttle);
119
Alan Coxd81ed102008-10-13 10:41:42 +0100120/**
121 * tty_unthrottle - flow control
122 * @tty: terminal
123 *
124 * Indicate that a tty may continue transmitting data down the stack.
Peter Hurley6a1c0682013-06-15 09:14:23 -0400125 * Takes the termios rwsem to protect against parallel throttle/unthrottle
Alan Cox38db8972009-06-11 12:44:17 +0100126 * and also to ensure the driver can consistently reference its own
127 * termios data at this point when implementing software flow control.
128 *
129 * Drivers should however remember that the stack can issue a throttle,
130 * then change flow control method, then unthrottle.
Alan Coxd81ed102008-10-13 10:41:42 +0100131 */
132
Alan Cox39c2e602008-04-30 00:54:18 -0700133void tty_unthrottle(struct tty_struct *tty)
134{
Peter Hurley6a1c0682013-06-15 09:14:23 -0400135 down_write(&tty->termios_rwsem);
Alan Cox39c2e602008-04-30 00:54:18 -0700136 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
137 tty->ops->unthrottle)
138 tty->ops->unthrottle(tty);
Peter Hurley70bc1262013-03-06 08:20:52 -0500139 tty->flow_change = 0;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400140 up_write(&tty->termios_rwsem);
Alan Cox39c2e602008-04-30 00:54:18 -0700141}
142EXPORT_SYMBOL(tty_unthrottle);
Alan Coxf34d7a52008-04-30 00:54:13 -0700143
Alan Coxaf9b8972006-08-27 01:24:01 -0700144/**
Peter Hurley70bc1262013-03-06 08:20:52 -0500145 * tty_throttle_safe - flow control
146 * @tty: terminal
147 *
148 * Similar to tty_throttle() but will only attempt throttle
149 * if tty->flow_change is TTY_THROTTLE_SAFE. Prevents an accidental
150 * throttle due to race conditions when throttling is conditional
151 * on factors evaluated prior to throttling.
152 *
153 * Returns 0 if tty is throttled (or was already throttled)
154 */
155
156int tty_throttle_safe(struct tty_struct *tty)
157{
158 int ret = 0;
159
Peter Hurleyd8c1f922013-06-15 09:14:31 -0400160 mutex_lock(&tty->throttle_mutex);
Peter Hurley97ef38b2016-04-09 17:11:36 -0700161 if (!tty_throttled(tty)) {
Peter Hurley70bc1262013-03-06 08:20:52 -0500162 if (tty->flow_change != TTY_THROTTLE_SAFE)
163 ret = 1;
164 else {
Peter Hurley579a00a2013-04-15 11:06:06 -0400165 set_bit(TTY_THROTTLED, &tty->flags);
Peter Hurley70bc1262013-03-06 08:20:52 -0500166 if (tty->ops->throttle)
167 tty->ops->throttle(tty);
168 }
169 }
Peter Hurleyd8c1f922013-06-15 09:14:31 -0400170 mutex_unlock(&tty->throttle_mutex);
Peter Hurley70bc1262013-03-06 08:20:52 -0500171
172 return ret;
173}
174
175/**
176 * tty_unthrottle_safe - flow control
177 * @tty: terminal
178 *
179 * Similar to tty_unthrottle() but will only attempt unthrottle
180 * if tty->flow_change is TTY_UNTHROTTLE_SAFE. Prevents an accidental
181 * unthrottle due to race conditions when unthrottling is conditional
182 * on factors evaluated prior to unthrottling.
183 *
184 * Returns 0 if tty is unthrottled (or was already unthrottled)
185 */
186
187int tty_unthrottle_safe(struct tty_struct *tty)
188{
189 int ret = 0;
190
Peter Hurleyd8c1f922013-06-15 09:14:31 -0400191 mutex_lock(&tty->throttle_mutex);
Peter Hurley97ef38b2016-04-09 17:11:36 -0700192 if (tty_throttled(tty)) {
Peter Hurley70bc1262013-03-06 08:20:52 -0500193 if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
194 ret = 1;
195 else {
Peter Hurley579a00a2013-04-15 11:06:06 -0400196 clear_bit(TTY_THROTTLED, &tty->flags);
Peter Hurley70bc1262013-03-06 08:20:52 -0500197 if (tty->ops->unthrottle)
198 tty->ops->unthrottle(tty);
199 }
200 }
Peter Hurleyd8c1f922013-06-15 09:14:31 -0400201 mutex_unlock(&tty->throttle_mutex);
Peter Hurley70bc1262013-03-06 08:20:52 -0500202
203 return ret;
204}
205
206/**
Alan Coxaf9b8972006-08-27 01:24:01 -0700207 * tty_wait_until_sent - wait for I/O to finish
208 * @tty: tty we are waiting for
209 * @timeout: how long we will wait
210 *
211 * Wait for characters pending in a tty driver to hit the wire, or
212 * for a timeout to occur (eg due to flow control)
213 *
214 * Locking: none
215 */
216
Alan Cox355d95a12008-02-08 04:18:48 -0800217void tty_wait_until_sent(struct tty_struct *tty, long timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
Peter Hurleyd435cef2015-11-08 13:01:19 -0500219 tty_debug_wait_until_sent(tty, "wait until sent, timeout=%ld\n", timeout);
Peter Hurleyff8339d2015-07-12 22:49:11 -0400220
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 if (!timeout)
222 timeout = MAX_SCHEDULE_TIMEOUT;
Johan Hovold79fbf4a2015-03-04 10:39:06 +0100223
Johan Hovoldc37bc682015-03-04 10:39:07 +0100224 timeout = wait_event_interruptible_timeout(tty->write_wait,
225 !tty_chars_in_buffer(tty), timeout);
226 if (timeout <= 0)
Johan Hovold79fbf4a2015-03-04 10:39:06 +0100227 return;
Johan Hovold79fbf4a2015-03-04 10:39:06 +0100228
229 if (timeout == MAX_SCHEDULE_TIMEOUT)
230 timeout = 0;
231
232 if (tty->ops->wait_until_sent)
233 tty->ops->wait_until_sent(tty, timeout);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235EXPORT_SYMBOL(tty_wait_until_sent);
236
Alan Coxd81ed102008-10-13 10:41:42 +0100237
238/*
239 * Termios Helper Methods
240 */
241
Peter Hurleyd97ba9c2015-11-08 13:01:16 -0500242static void unset_locked_termios(struct tty_struct *tty, struct ktermios *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243{
Peter Hurleyd97ba9c2015-11-08 13:01:16 -0500244 struct ktermios *termios = &tty->termios;
245 struct ktermios *locked = &tty->termios_locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 int i;
Alan Cox355d95a12008-02-08 04:18:48 -0800247
248#define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
251 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
252 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
253 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
254 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
Alan Cox355d95a12008-02-08 04:18:48 -0800255 for (i = 0; i < NCCS; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 termios->c_cc[i] = locked->c_cc[i] ?
257 old->c_cc[i] : termios->c_cc[i];
Alan Coxedc6afc2006-12-08 02:38:44 -0800258 /* FIXME: What should we do for i/ospeed */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259}
260
Alan Coxedc6afc2006-12-08 02:38:44 -0800261/*
262 * Routine which returns the baud rate of the tty
263 *
264 * Note that the baud_table needs to be kept in sync with the
265 * include/asm/termbits.h file.
266 */
267static const speed_t baud_table[] = {
268 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
269 9600, 19200, 38400, 57600, 115200, 230400, 460800,
270#ifdef __sparc__
271 76800, 153600, 307200, 614400, 921600
272#else
273 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
274 2500000, 3000000, 3500000, 4000000
275#endif
276};
277
278#ifndef __sparc__
279static const tcflag_t baud_bits[] = {
280 B0, B50, B75, B110, B134, B150, B200, B300, B600,
281 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
282 B57600, B115200, B230400, B460800, B500000, B576000,
283 B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
284 B3000000, B3500000, B4000000
285};
286#else
287static const tcflag_t baud_bits[] = {
288 B0, B50, B75, B110, B134, B150, B200, B300, B600,
289 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
290 B57600, B115200, B230400, B460800, B76800, B153600,
291 B307200, B614400, B921600
292};
293#endif
294
295static int n_baud_table = ARRAY_SIZE(baud_table);
296
297/**
298 * tty_termios_baud_rate
299 * @termios: termios structure
300 *
301 * Convert termios baud rate data into a speed. This should be called
302 * with the termios lock held if this termios is a terminal termios
303 * structure. May change the termios data. Device drivers can call this
304 * function but should use ->c_[io]speed directly as they are updated.
305 *
306 * Locking: none
307 */
308
309speed_t tty_termios_baud_rate(struct ktermios *termios)
310{
311 unsigned int cbaud;
312
313 cbaud = termios->c_cflag & CBAUD;
314
315#ifdef BOTHER
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300316 /* Magic token for arbitrary speed via c_ispeed/c_ospeed */
Alan Coxedc6afc2006-12-08 02:38:44 -0800317 if (cbaud == BOTHER)
318 return termios->c_ospeed;
319#endif
320 if (cbaud & CBAUDEX) {
321 cbaud &= ~CBAUDEX;
322
323 if (cbaud < 1 || cbaud + 15 > n_baud_table)
324 termios->c_cflag &= ~CBAUDEX;
325 else
326 cbaud += 15;
327 }
328 return baud_table[cbaud];
329}
Alan Coxedc6afc2006-12-08 02:38:44 -0800330EXPORT_SYMBOL(tty_termios_baud_rate);
331
332/**
333 * tty_termios_input_baud_rate
334 * @termios: termios structure
335 *
336 * Convert termios baud rate data into a speed. This should be called
337 * with the termios lock held if this termios is a terminal termios
338 * structure. May change the termios data. Device drivers can call this
339 * function but should use ->c_[io]speed directly as they are updated.
340 *
341 * Locking: none
342 */
343
344speed_t tty_termios_input_baud_rate(struct ktermios *termios)
345{
346#ifdef IBSHIFT
347 unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
348
349 if (cbaud == B0)
350 return tty_termios_baud_rate(termios);
351
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300352 /* Magic token for arbitrary speed via c_ispeed*/
Alan Coxedc6afc2006-12-08 02:38:44 -0800353 if (cbaud == BOTHER)
354 return termios->c_ispeed;
355
356 if (cbaud & CBAUDEX) {
357 cbaud &= ~CBAUDEX;
358
359 if (cbaud < 1 || cbaud + 15 > n_baud_table)
360 termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
361 else
362 cbaud += 15;
363 }
364 return baud_table[cbaud];
365#else
366 return tty_termios_baud_rate(termios);
367#endif
368}
Alan Coxedc6afc2006-12-08 02:38:44 -0800369EXPORT_SYMBOL(tty_termios_input_baud_rate);
370
Alan Coxedc6afc2006-12-08 02:38:44 -0800371/**
372 * tty_termios_encode_baud_rate
Alan Cox78137e32007-02-10 01:45:57 -0800373 * @termios: ktermios structure holding user requested state
Alan Coxedc6afc2006-12-08 02:38:44 -0800374 * @ispeed: input speed
375 * @ospeed: output speed
376 *
377 * Encode the speeds set into the passed termios structure. This is
Uwe Kleine-Königf98e5b82011-04-12 09:59:29 +0200378 * used as a library helper for drivers so that they can report back
Alan Coxedc6afc2006-12-08 02:38:44 -0800379 * the actual speed selected when it differs from the speed requested
380 *
Alan Cox78137e32007-02-10 01:45:57 -0800381 * For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
382 * we need to carefully set the bits when the user does not get the
383 * desired speed. We allow small margins and preserve as much of possible
Dirk Hohndel06fe9fb2009-09-28 21:43:57 -0400384 * of the input intent to keep compatibility.
Alan Coxedc6afc2006-12-08 02:38:44 -0800385 *
386 * Locking: Caller should hold termios lock. This is already held
387 * when calling this function from the driver termios handler.
Alan Cox5f519d72007-10-16 23:30:07 -0700388 *
389 * The ifdefs deal with platforms whose owners have yet to update them
390 * and will all go away once this is done.
Alan Coxedc6afc2006-12-08 02:38:44 -0800391 */
392
Maciej W. Rozycki75e8b712007-10-18 03:04:35 -0700393void tty_termios_encode_baud_rate(struct ktermios *termios,
394 speed_t ibaud, speed_t obaud)
Alan Coxedc6afc2006-12-08 02:38:44 -0800395{
396 int i = 0;
Alan Cox78137e32007-02-10 01:45:57 -0800397 int ifound = -1, ofound = -1;
398 int iclose = ibaud/50, oclose = obaud/50;
399 int ibinput = 0;
Alan Coxedc6afc2006-12-08 02:38:44 -0800400
Alan Cox5f519d72007-10-16 23:30:07 -0700401 if (obaud == 0) /* CD dropped */
402 ibaud = 0; /* Clear ibaud to be sure */
403
Alan Coxedc6afc2006-12-08 02:38:44 -0800404 termios->c_ispeed = ibaud;
405 termios->c_ospeed = obaud;
406
Alan Cox5f519d72007-10-16 23:30:07 -0700407#ifdef BOTHER
Alan Cox78137e32007-02-10 01:45:57 -0800408 /* If the user asked for a precise weird speed give a precise weird
Matthias Bruggera1d51aa22014-08-08 13:01:21 +0200409 answer. If they asked for a Bfoo speed they may have problems
Alan Cox78137e32007-02-10 01:45:57 -0800410 digesting non-exact replies so fuzz a bit */
411
412 if ((termios->c_cflag & CBAUD) == BOTHER)
413 oclose = 0;
414 if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
415 iclose = 0;
416 if ((termios->c_cflag >> IBSHIFT) & CBAUD)
417 ibinput = 1; /* An input speed was specified */
Alan Cox5f519d72007-10-16 23:30:07 -0700418#endif
Alan Coxedc6afc2006-12-08 02:38:44 -0800419 termios->c_cflag &= ~CBAUD;
Alan Coxedc6afc2006-12-08 02:38:44 -0800420
Alan Cox5f519d72007-10-16 23:30:07 -0700421 /*
422 * Our goal is to find a close match to the standard baud rate
423 * returned. Walk the baud rate table and if we get a very close
424 * match then report back the speed as a POSIX Bxxxx value by
425 * preference
426 */
427
Alan Coxedc6afc2006-12-08 02:38:44 -0800428 do {
Maciej W. Rozycki75e8b712007-10-18 03:04:35 -0700429 if (obaud - oclose <= baud_table[i] &&
430 obaud + oclose >= baud_table[i]) {
Alan Coxedc6afc2006-12-08 02:38:44 -0800431 termios->c_cflag |= baud_bits[i];
Alan Cox78137e32007-02-10 01:45:57 -0800432 ofound = i;
Alan Coxedc6afc2006-12-08 02:38:44 -0800433 }
Maciej W. Rozycki75e8b712007-10-18 03:04:35 -0700434 if (ibaud - iclose <= baud_table[i] &&
435 ibaud + iclose >= baud_table[i]) {
436 /* For the case input == output don't set IBAUD bits
437 if the user didn't do so */
Alan Cox5f519d72007-10-16 23:30:07 -0700438 if (ofound == i && !ibinput)
439 ifound = i;
440#ifdef IBSHIFT
441 else {
442 ifound = i;
Alan Cox78137e32007-02-10 01:45:57 -0800443 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
Alan Cox5f519d72007-10-16 23:30:07 -0700444 }
445#endif
Alan Coxedc6afc2006-12-08 02:38:44 -0800446 }
Jiri Slaby68043962007-07-15 23:40:18 -0700447 } while (++i < n_baud_table);
Alan Cox5f519d72007-10-16 23:30:07 -0700448
449 /*
450 * If we found no match then use BOTHER if provided or warn
451 * the user their platform maintainer needs to wake up if not.
452 */
453#ifdef BOTHER
Alan Cox78137e32007-02-10 01:45:57 -0800454 if (ofound == -1)
Alan Coxedc6afc2006-12-08 02:38:44 -0800455 termios->c_cflag |= BOTHER;
Alan Cox78137e32007-02-10 01:45:57 -0800456 /* Set exact input bits only if the input and output differ or the
457 user already did */
Jiri Slaby68043962007-07-15 23:40:18 -0700458 if (ifound == -1 && (ibaud != obaud || ibinput))
Alan Coxedc6afc2006-12-08 02:38:44 -0800459 termios->c_cflag |= (BOTHER << IBSHIFT);
Alan Cox5f519d72007-10-16 23:30:07 -0700460#else
Peter Hurley89222e62015-11-08 13:01:18 -0500461 if (ifound == -1 || ofound == -1)
462 pr_warn_once("tty: Unable to return correct speed data as your architecture needs updating.\n");
Alan Cox5f519d72007-10-16 23:30:07 -0700463#endif
Alan Coxedc6afc2006-12-08 02:38:44 -0800464}
Alan Coxedc6afc2006-12-08 02:38:44 -0800465EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
466
Alan Coxd81ed102008-10-13 10:41:42 +0100467/**
468 * tty_encode_baud_rate - set baud rate of the tty
469 * @ibaud: input baud rate
470 * @obad: output baud rate
471 *
472 * Update the current termios data for the tty with the new speed
Peter Hurley6a1c0682013-06-15 09:14:23 -0400473 * settings. The caller must hold the termios_rwsem for the tty in
Alan Coxd81ed102008-10-13 10:41:42 +0100474 * question.
475 */
476
Alan Cox5f519d72007-10-16 23:30:07 -0700477void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
478{
Alan Coxadc8d742012-07-14 15:31:47 +0100479 tty_termios_encode_baud_rate(&tty->termios, ibaud, obaud);
Alan Cox5f519d72007-10-16 23:30:07 -0700480}
481EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
Alan Coxedc6afc2006-12-08 02:38:44 -0800482
483/**
Alan Cox5f519d72007-10-16 23:30:07 -0700484 * tty_termios_copy_hw - copy hardware settings
485 * @new: New termios
486 * @old: Old termios
487 *
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300488 * Propagate the hardware specific terminal setting bits from
Alan Cox5f519d72007-10-16 23:30:07 -0700489 * the old termios structure to the new one. This is used in cases
490 * where the hardware does not support reconfiguration or as a helper
491 * in some cases where only minimal reconfiguration is supported
492 */
493
494void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
495{
496 /* The bits a dumb device handles in software. Smart devices need
497 to always provide a set_termios method */
498 new->c_cflag &= HUPCL | CREAD | CLOCAL;
499 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
500 new->c_ispeed = old->c_ispeed;
501 new->c_ospeed = old->c_ospeed;
502}
Alan Cox5f519d72007-10-16 23:30:07 -0700503EXPORT_SYMBOL(tty_termios_copy_hw);
504
505/**
Alan Coxbf5e5832008-01-08 14:55:51 +0000506 * tty_termios_hw_change - check for setting change
507 * @a: termios
508 * @b: termios to compare
509 *
510 * Check if any of the bits that affect a dumb device have changed
511 * between the two termios structures, or a speed change is needed.
512 */
513
514int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
515{
516 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
517 return 1;
518 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
519 return 1;
520 return 0;
521}
522EXPORT_SYMBOL(tty_termios_hw_change);
523
524/**
Alan Cox8d075b12011-02-14 16:27:53 +0000525 * tty_set_termios - update termios values
Alan Coxaf9b8972006-08-27 01:24:01 -0700526 * @tty: tty to update
527 * @new_termios: desired new value
528 *
Peter Hurleydbfcd852014-10-16 15:33:23 -0400529 * Perform updates to the termios values set on this terminal.
Peter Hurley6460fbb2014-10-16 15:33:22 -0400530 * A master pty's termios should never be set.
531 *
Peter Hurley6a1c0682013-06-15 09:14:23 -0400532 * Locking: termios_rwsem
Alan Coxaf9b8972006-08-27 01:24:01 -0700533 */
534
Frederic Danisb00f5c22015-04-10 15:13:05 +0200535int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536{
Alan Cox978e5952008-04-30 00:53:59 -0700537 struct ktermios old_termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 struct tty_ldisc *ld;
Alan Cox355d95a12008-02-08 04:18:48 -0800539
Peter Hurley6460fbb2014-10-16 15:33:22 -0400540 WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
541 tty->driver->subtype == PTY_TYPE_MASTER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 /*
543 * Perform the actual termios internal changes under lock.
544 */
Alan Cox355d95a12008-02-08 04:18:48 -0800545
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
547 /* FIXME: we need to decide on some locking/ordering semantics
548 for the set_termios notification eventually */
Peter Hurley6a1c0682013-06-15 09:14:23 -0400549 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100550 old_termios = tty->termios;
551 tty->termios = *new_termios;
Peter Hurleyd97ba9c2015-11-08 13:01:16 -0500552 unset_locked_termios(tty, &old_termios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
Alan Coxf34d7a52008-04-30 00:54:13 -0700554 if (tty->ops->set_termios)
Peter Hurleyc961bfb2014-11-05 12:26:25 -0500555 tty->ops->set_termios(tty, &old_termios);
Alan Cox5f519d72007-10-16 23:30:07 -0700556 else
Alan Coxadc8d742012-07-14 15:31:47 +0100557 tty_termios_copy_hw(&tty->termios, &old_termios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
559 ld = tty_ldisc_ref(tty);
560 if (ld != NULL) {
Alan Coxa352def2008-07-16 21:53:12 +0100561 if (ld->ops->set_termios)
Peter Hurleyc961bfb2014-11-05 12:26:25 -0500562 ld->ops->set_termios(tty, &old_termios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 tty_ldisc_deref(ld);
564 }
Peter Hurley6a1c0682013-06-15 09:14:23 -0400565 up_write(&tty->termios_rwsem);
Alan Cox8d075b12011-02-14 16:27:53 +0000566 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567}
Frederic Danisb00f5c22015-04-10 15:13:05 +0200568EXPORT_SYMBOL_GPL(tty_set_termios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
Alan Coxaf9b8972006-08-27 01:24:01 -0700570/**
571 * set_termios - set termios values for a tty
572 * @tty: terminal device
573 * @arg: user data
574 * @opt: option information
575 *
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200576 * Helper function to prepare termios data and run necessary other
Alan Cox8d075b12011-02-14 16:27:53 +0000577 * functions before using tty_set_termios to do the actual changes.
Alan Coxaf9b8972006-08-27 01:24:01 -0700578 *
579 * Locking:
Peter Hurley6a1c0682013-06-15 09:14:23 -0400580 * Called functions take ldisc and termios_rwsem locks
Alan Coxaf9b8972006-08-27 01:24:01 -0700581 */
582
Alan Cox355d95a12008-02-08 04:18:48 -0800583static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584{
Alan Coxedc6afc2006-12-08 02:38:44 -0800585 struct ktermios tmp_termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 struct tty_ldisc *ld;
587 int retval = tty_check_change(tty);
588
589 if (retval)
590 return retval;
591
Peter Hurley6a1c0682013-06-15 09:14:23 -0400592 down_read(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100593 tmp_termios = tty->termios;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400594 up_read(&tty->termios_rwsem);
Alan Cox64bb6c52006-12-08 02:38:47 -0800595
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 if (opt & TERMIOS_TERMIO) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 if (user_termio_to_kernel_termios(&tmp_termios,
598 (struct termio __user *)arg))
599 return -EFAULT;
Alan Coxedc6afc2006-12-08 02:38:44 -0800600#ifdef TCGETS2
601 } else if (opt & TERMIOS_OLD) {
Alan Coxedc6afc2006-12-08 02:38:44 -0800602 if (user_termios_to_kernel_termios_1(&tmp_termios,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 (struct termios __user *)arg))
604 return -EFAULT;
Alan Cox64bb6c52006-12-08 02:38:47 -0800605 } else {
606 if (user_termios_to_kernel_termios(&tmp_termios,
607 (struct termios2 __user *)arg))
608 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 }
Alan Cox64bb6c52006-12-08 02:38:47 -0800610#else
611 } else if (user_termios_to_kernel_termios(&tmp_termios,
612 (struct termios __user *)arg))
613 return -EFAULT;
614#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615
Alan Cox355d95a12008-02-08 04:18:48 -0800616 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
617 * with the real speed so its unconditionally usable */
Alan Coxedc6afc2006-12-08 02:38:44 -0800618 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
619 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
620
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 ld = tty_ldisc_ref(tty);
Alan Cox355d95a12008-02-08 04:18:48 -0800622
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 if (ld != NULL) {
Alan Coxa352def2008-07-16 21:53:12 +0100624 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
625 ld->ops->flush_buffer(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 tty_ldisc_deref(ld);
627 }
Alan Cox355d95a12008-02-08 04:18:48 -0800628
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 if (opt & TERMIOS_WAIT) {
630 tty_wait_until_sent(tty, 0);
631 if (signal_pending(current))
Oleg Nesterov183d95c2013-01-29 20:07:41 +0100632 return -ERESTARTSYS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 }
634
Alan Cox8d075b12011-02-14 16:27:53 +0000635 tty_set_termios(tty, &tmp_termios);
Alan Cox5f519d72007-10-16 23:30:07 -0700636
637 /* FIXME: Arguably if tmp_termios == tty->termios AND the
638 actual requested termios was not tmp_termios then we may
639 want to return an error as no user requested change has
640 succeeded */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 return 0;
642}
643
Alan Cox26a2e202009-06-11 14:03:13 +0100644static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
645{
Peter Hurley6a1c0682013-06-15 09:14:23 -0400646 down_read(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100647 *kterm = tty->termios;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400648 up_read(&tty->termios_rwsem);
Alan Cox26a2e202009-06-11 14:03:13 +0100649}
650
651static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
652{
Peter Hurley6a1c0682013-06-15 09:14:23 -0400653 down_read(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100654 *kterm = tty->termios_locked;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400655 up_read(&tty->termios_rwsem);
Alan Cox26a2e202009-06-11 14:03:13 +0100656}
657
Alan Cox355d95a12008-02-08 04:18:48 -0800658static int get_termio(struct tty_struct *tty, struct termio __user *termio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659{
Alan Cox26a2e202009-06-11 14:03:13 +0100660 struct ktermios kterm;
661 copy_termios(tty, &kterm);
662 if (kernel_termios_to_user_termio(termio, &kterm))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 return -EFAULT;
664 return 0;
665}
666
Alan Cox1d65b4a2008-10-13 10:38:18 +0100667
668#ifdef TCGETX
669
670/**
671 * set_termiox - set termiox fields if possible
672 * @tty: terminal
673 * @arg: termiox structure from user
674 * @opt: option flags for ioctl type
675 *
676 * Implement the device calling points for the SYS5 termiox ioctl
677 * interface in Linux
678 */
679
680static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
681{
682 struct termiox tnew;
683 struct tty_ldisc *ld;
684
685 if (tty->termiox == NULL)
686 return -EINVAL;
687 if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
688 return -EFAULT;
689
690 ld = tty_ldisc_ref(tty);
691 if (ld != NULL) {
692 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
693 ld->ops->flush_buffer(tty);
694 tty_ldisc_deref(ld);
695 }
696 if (opt & TERMIOS_WAIT) {
697 tty_wait_until_sent(tty, 0);
698 if (signal_pending(current))
Oleg Nesterov183d95c2013-01-29 20:07:41 +0100699 return -ERESTARTSYS;
Alan Cox1d65b4a2008-10-13 10:38:18 +0100700 }
701
Peter Hurley6a1c0682013-06-15 09:14:23 -0400702 down_write(&tty->termios_rwsem);
Alan Cox1d65b4a2008-10-13 10:38:18 +0100703 if (tty->ops->set_termiox)
704 tty->ops->set_termiox(tty, &tnew);
Peter Hurley6a1c0682013-06-15 09:14:23 -0400705 up_write(&tty->termios_rwsem);
Alan Cox1d65b4a2008-10-13 10:38:18 +0100706 return 0;
707}
708
709#endif
710
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711
712#ifdef TIOCGETP
713/*
714 * These are deprecated, but there is limited support..
715 *
716 * The "sg_flags" translation is a joke..
717 */
Alan Cox355d95a12008-02-08 04:18:48 -0800718static int get_sgflags(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719{
720 int flags = 0;
721
Peter Hurley9db276f2016-01-10 20:36:15 -0800722 if (!L_ICANON(tty)) {
723 if (L_ISIG(tty))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 flags |= 0x02; /* cbreak */
725 else
726 flags |= 0x20; /* raw */
727 }
Peter Hurley9db276f2016-01-10 20:36:15 -0800728 if (L_ECHO(tty))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 flags |= 0x08; /* echo */
Peter Hurley9db276f2016-01-10 20:36:15 -0800730 if (O_OPOST(tty))
731 if (O_ONLCR(tty))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 flags |= 0x10; /* crmod */
733 return flags;
734}
735
Alan Cox355d95a12008-02-08 04:18:48 -0800736static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737{
738 struct sgttyb tmp;
739
Peter Hurley6a1c0682013-06-15 09:14:23 -0400740 down_read(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100741 tmp.sg_ispeed = tty->termios.c_ispeed;
742 tmp.sg_ospeed = tty->termios.c_ospeed;
743 tmp.sg_erase = tty->termios.c_cc[VERASE];
744 tmp.sg_kill = tty->termios.c_cc[VKILL];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 tmp.sg_flags = get_sgflags(tty);
Peter Hurley6a1c0682013-06-15 09:14:23 -0400746 up_read(&tty->termios_rwsem);
Alan Cox355d95a12008-02-08 04:18:48 -0800747
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
749}
750
Alan Cox355d95a12008-02-08 04:18:48 -0800751static void set_sgflags(struct ktermios *termios, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752{
Alan Cox9833fac2012-07-17 17:05:40 +0100753 termios->c_iflag = ICRNL | IXON;
754 termios->c_oflag = 0;
755 termios->c_lflag = ISIG | ICANON;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 if (flags & 0x02) { /* cbreak */
Alan Cox9833fac2012-07-17 17:05:40 +0100757 termios->c_iflag = 0;
758 termios->c_lflag &= ~ICANON;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 }
760 if (flags & 0x08) { /* echo */
Alan Cox9833fac2012-07-17 17:05:40 +0100761 termios->c_lflag |= ECHO | ECHOE | ECHOK |
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 ECHOCTL | ECHOKE | IEXTEN;
763 }
764 if (flags & 0x10) { /* crmod */
Alan Cox9833fac2012-07-17 17:05:40 +0100765 termios->c_oflag |= OPOST | ONLCR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 }
767 if (flags & 0x20) { /* raw */
Alan Cox9833fac2012-07-17 17:05:40 +0100768 termios->c_iflag = 0;
769 termios->c_lflag &= ~(ISIG | ICANON);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 }
Alan Cox9833fac2012-07-17 17:05:40 +0100771 if (!(termios->c_lflag & ICANON)) {
772 termios->c_cc[VMIN] = 1;
773 termios->c_cc[VTIME] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 }
775}
776
Alan Coxaf9b8972006-08-27 01:24:01 -0700777/**
778 * set_sgttyb - set legacy terminal values
779 * @tty: tty structure
780 * @sgttyb: pointer to old style terminal structure
781 *
782 * Updates a terminal from the legacy BSD style terminal information
783 * structure.
784 *
Peter Hurley6a1c0682013-06-15 09:14:23 -0400785 * Locking: termios_rwsem
Alan Coxaf9b8972006-08-27 01:24:01 -0700786 */
787
Alan Cox355d95a12008-02-08 04:18:48 -0800788static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789{
790 int retval;
791 struct sgttyb tmp;
Alan Coxedc6afc2006-12-08 02:38:44 -0800792 struct ktermios termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
794 retval = tty_check_change(tty);
795 if (retval)
796 return retval;
Alan Cox355d95a12008-02-08 04:18:48 -0800797
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
799 return -EFAULT;
800
Peter Hurley6a1c0682013-06-15 09:14:23 -0400801 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100802 termios = tty->termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 termios.c_cc[VERASE] = tmp.sg_erase;
804 termios.c_cc[VKILL] = tmp.sg_kill;
805 set_sgflags(&termios, tmp.sg_flags);
Alan Coxedc6afc2006-12-08 02:38:44 -0800806 /* Try and encode into Bfoo format */
807#ifdef BOTHER
Alan Cox355d95a12008-02-08 04:18:48 -0800808 tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
809 termios.c_ospeed);
Alan Coxedc6afc2006-12-08 02:38:44 -0800810#endif
Peter Hurley6a1c0682013-06-15 09:14:23 -0400811 up_write(&tty->termios_rwsem);
Alan Cox8d075b12011-02-14 16:27:53 +0000812 tty_set_termios(tty, &termios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 return 0;
814}
815#endif
816
817#ifdef TIOCGETC
Alan Cox355d95a12008-02-08 04:18:48 -0800818static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819{
820 struct tchars tmp;
821
Peter Hurley6a1c0682013-06-15 09:14:23 -0400822 down_read(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100823 tmp.t_intrc = tty->termios.c_cc[VINTR];
824 tmp.t_quitc = tty->termios.c_cc[VQUIT];
825 tmp.t_startc = tty->termios.c_cc[VSTART];
826 tmp.t_stopc = tty->termios.c_cc[VSTOP];
827 tmp.t_eofc = tty->termios.c_cc[VEOF];
828 tmp.t_brkc = tty->termios.c_cc[VEOL2]; /* what is brkc anyway? */
Peter Hurley6a1c0682013-06-15 09:14:23 -0400829 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
831}
832
Alan Cox355d95a12008-02-08 04:18:48 -0800833static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834{
835 struct tchars tmp;
836
837 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
838 return -EFAULT;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400839 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100840 tty->termios.c_cc[VINTR] = tmp.t_intrc;
841 tty->termios.c_cc[VQUIT] = tmp.t_quitc;
842 tty->termios.c_cc[VSTART] = tmp.t_startc;
843 tty->termios.c_cc[VSTOP] = tmp.t_stopc;
844 tty->termios.c_cc[VEOF] = tmp.t_eofc;
845 tty->termios.c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
Peter Hurley6a1c0682013-06-15 09:14:23 -0400846 up_write(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 return 0;
848}
849#endif
850
851#ifdef TIOCGLTC
Alan Cox355d95a12008-02-08 04:18:48 -0800852static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853{
854 struct ltchars tmp;
855
Peter Hurley6a1c0682013-06-15 09:14:23 -0400856 down_read(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100857 tmp.t_suspc = tty->termios.c_cc[VSUSP];
Alan Cox355d95a12008-02-08 04:18:48 -0800858 /* what is dsuspc anyway? */
Alan Coxadc8d742012-07-14 15:31:47 +0100859 tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
860 tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
Alan Cox355d95a12008-02-08 04:18:48 -0800861 /* what is flushc anyway? */
Alan Coxadc8d742012-07-14 15:31:47 +0100862 tmp.t_flushc = tty->termios.c_cc[VEOL2];
863 tmp.t_werasc = tty->termios.c_cc[VWERASE];
864 tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
Peter Hurley6a1c0682013-06-15 09:14:23 -0400865 up_read(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
867}
868
Alan Cox355d95a12008-02-08 04:18:48 -0800869static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870{
871 struct ltchars tmp;
872
873 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
874 return -EFAULT;
875
Peter Hurley6a1c0682013-06-15 09:14:23 -0400876 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100877 tty->termios.c_cc[VSUSP] = tmp.t_suspc;
Alan Cox355d95a12008-02-08 04:18:48 -0800878 /* what is dsuspc anyway? */
Alan Coxadc8d742012-07-14 15:31:47 +0100879 tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
880 tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
Alan Cox355d95a12008-02-08 04:18:48 -0800881 /* what is flushc anyway? */
Alan Coxadc8d742012-07-14 15:31:47 +0100882 tty->termios.c_cc[VEOL2] = tmp.t_flushc;
883 tty->termios.c_cc[VWERASE] = tmp.t_werasc;
884 tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400885 up_write(&tty->termios_rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 return 0;
887}
888#endif
889
Alan Coxaf9b8972006-08-27 01:24:01 -0700890/**
Alan Cox1c2630c2008-04-30 00:53:34 -0700891 * tty_change_softcar - carrier change ioctl helper
892 * @tty: tty to update
893 * @arg: enable/disable CLOCAL
894 *
895 * Perform a change to the CLOCAL state and call into the driver
Peter Hurley6a1c0682013-06-15 09:14:23 -0400896 * layer to make it visible. All done with the termios rwsem
Alan Cox1c2630c2008-04-30 00:53:34 -0700897 */
898
899static int tty_change_softcar(struct tty_struct *tty, int arg)
900{
901 int ret = 0;
902 int bit = arg ? CLOCAL : 0;
Alan Coxf34d7a52008-04-30 00:54:13 -0700903 struct ktermios old;
Alan Cox1c2630c2008-04-30 00:53:34 -0700904
Peter Hurley6a1c0682013-06-15 09:14:23 -0400905 down_write(&tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +0100906 old = tty->termios;
907 tty->termios.c_cflag &= ~CLOCAL;
908 tty->termios.c_cflag |= bit;
Alan Coxf34d7a52008-04-30 00:54:13 -0700909 if (tty->ops->set_termios)
910 tty->ops->set_termios(tty, &old);
Peter Hurley9db276f2016-01-10 20:36:15 -0800911 if (C_CLOCAL(tty) != bit)
Alan Cox1c2630c2008-04-30 00:53:34 -0700912 ret = -EINVAL;
Peter Hurley6a1c0682013-06-15 09:14:23 -0400913 up_write(&tty->termios_rwsem);
Alan Cox1c2630c2008-04-30 00:53:34 -0700914 return ret;
915}
916
917/**
Alan Cox0fc00e22007-11-07 01:24:56 -0800918 * tty_mode_ioctl - mode related ioctls
919 * @tty: tty for the ioctl
920 * @file: file pointer for the tty
921 * @cmd: command
922 * @arg: ioctl argument
923 *
924 * Perform non line discipline specific mode control ioctls. This
925 * is designed to be called by line disciplines to ensure they provide
926 * consistent mode setting.
927 */
928
Alan Cox355d95a12008-02-08 04:18:48 -0800929int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
Alan Cox0fc00e22007-11-07 01:24:56 -0800930 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931{
Alan Cox355d95a12008-02-08 04:18:48 -0800932 struct tty_struct *real_tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 void __user *p = (void __user *)arg;
Alan Cox8f520022008-10-13 10:38:46 +0100934 int ret = 0;
Alan Cox26a2e202009-06-11 14:03:13 +0100935 struct ktermios kterm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936
Alan Cox8d075b12011-02-14 16:27:53 +0000937 BUG_ON(file == NULL);
938
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
940 tty->driver->subtype == PTY_TYPE_MASTER)
941 real_tty = tty->link;
942 else
943 real_tty = tty;
944
945 switch (cmd) {
946#ifdef TIOCGETP
Alan Cox355d95a12008-02-08 04:18:48 -0800947 case TIOCGETP:
948 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
949 case TIOCSETP:
950 case TIOCSETN:
951 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952#endif
953#ifdef TIOCGETC
Alan Cox355d95a12008-02-08 04:18:48 -0800954 case TIOCGETC:
955 return get_tchars(real_tty, p);
956 case TIOCSETC:
957 return set_tchars(real_tty, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958#endif
959#ifdef TIOCGLTC
Alan Cox355d95a12008-02-08 04:18:48 -0800960 case TIOCGLTC:
961 return get_ltchars(real_tty, p);
962 case TIOCSLTC:
963 return set_ltchars(real_tty, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964#endif
Alan Cox355d95a12008-02-08 04:18:48 -0800965 case TCSETSF:
966 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
967 case TCSETSW:
968 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
969 case TCSETS:
970 return set_termios(real_tty, p, TERMIOS_OLD);
Alan Coxedc6afc2006-12-08 02:38:44 -0800971#ifndef TCGETS2
Alan Cox355d95a12008-02-08 04:18:48 -0800972 case TCGETS:
Alan Cox26a2e202009-06-11 14:03:13 +0100973 copy_termios(real_tty, &kterm);
974 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
Alan Cox8f520022008-10-13 10:38:46 +0100975 ret = -EFAULT;
Alan Cox8f520022008-10-13 10:38:46 +0100976 return ret;
Alan Coxedc6afc2006-12-08 02:38:44 -0800977#else
Alan Cox355d95a12008-02-08 04:18:48 -0800978 case TCGETS:
Alan Cox26a2e202009-06-11 14:03:13 +0100979 copy_termios(real_tty, &kterm);
980 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
Alan Cox8f520022008-10-13 10:38:46 +0100981 ret = -EFAULT;
Alan Cox8f520022008-10-13 10:38:46 +0100982 return ret;
Alan Cox355d95a12008-02-08 04:18:48 -0800983 case TCGETS2:
Alan Cox26a2e202009-06-11 14:03:13 +0100984 copy_termios(real_tty, &kterm);
985 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
Alan Cox8f520022008-10-13 10:38:46 +0100986 ret = -EFAULT;
Alan Cox8f520022008-10-13 10:38:46 +0100987 return ret;
Alan Cox355d95a12008-02-08 04:18:48 -0800988 case TCSETSF2:
989 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
990 case TCSETSW2:
991 return set_termios(real_tty, p, TERMIOS_WAIT);
992 case TCSETS2:
993 return set_termios(real_tty, p, 0);
Alan Coxedc6afc2006-12-08 02:38:44 -0800994#endif
Alan Cox355d95a12008-02-08 04:18:48 -0800995 case TCGETA:
996 return get_termio(real_tty, p);
997 case TCSETAF:
998 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
999 case TCSETAW:
1000 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
1001 case TCSETA:
1002 return set_termios(real_tty, p, TERMIOS_TERMIO);
Alan Cox0fc00e22007-11-07 01:24:56 -08001003#ifndef TCGETS2
Alan Cox355d95a12008-02-08 04:18:48 -08001004 case TIOCGLCKTRMIOS:
Alan Cox26a2e202009-06-11 14:03:13 +01001005 copy_termios_locked(real_tty, &kterm);
1006 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
Alan Cox8f520022008-10-13 10:38:46 +01001007 ret = -EFAULT;
Alan Cox8f520022008-10-13 10:38:46 +01001008 return ret;
Alan Cox355d95a12008-02-08 04:18:48 -08001009 case TIOCSLCKTRMIOS:
1010 if (!capable(CAP_SYS_ADMIN))
1011 return -EPERM;
Alan Cox26a2e202009-06-11 14:03:13 +01001012 copy_termios_locked(real_tty, &kterm);
1013 if (user_termios_to_kernel_termios(&kterm,
Alan Cox355d95a12008-02-08 04:18:48 -08001014 (struct termios __user *) arg))
Alan Cox26a2e202009-06-11 14:03:13 +01001015 return -EFAULT;
Peter Hurley6a1c0682013-06-15 09:14:23 -04001016 down_write(&real_tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +01001017 real_tty->termios_locked = kterm;
Peter Hurley6a1c0682013-06-15 09:14:23 -04001018 up_write(&real_tty->termios_rwsem);
Alan Cox26a2e202009-06-11 14:03:13 +01001019 return 0;
Alan Cox0fc00e22007-11-07 01:24:56 -08001020#else
Alan Cox355d95a12008-02-08 04:18:48 -08001021 case TIOCGLCKTRMIOS:
Alan Cox26a2e202009-06-11 14:03:13 +01001022 copy_termios_locked(real_tty, &kterm);
1023 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
Alan Cox8f520022008-10-13 10:38:46 +01001024 ret = -EFAULT;
Alan Cox8f520022008-10-13 10:38:46 +01001025 return ret;
Alan Cox355d95a12008-02-08 04:18:48 -08001026 case TIOCSLCKTRMIOS:
1027 if (!capable(CAP_SYS_ADMIN))
Alan Cox26a2e202009-06-11 14:03:13 +01001028 return -EPERM;
1029 copy_termios_locked(real_tty, &kterm);
1030 if (user_termios_to_kernel_termios_1(&kterm,
Alan Cox355d95a12008-02-08 04:18:48 -08001031 (struct termios __user *) arg))
Alan Cox26a2e202009-06-11 14:03:13 +01001032 return -EFAULT;
Peter Hurley6a1c0682013-06-15 09:14:23 -04001033 down_write(&real_tty->termios_rwsem);
Alan Coxadc8d742012-07-14 15:31:47 +01001034 real_tty->termios_locked = kterm;
Peter Hurley6a1c0682013-06-15 09:14:23 -04001035 up_write(&real_tty->termios_rwsem);
Alan Cox8f520022008-10-13 10:38:46 +01001036 return ret;
Alan Cox0fc00e22007-11-07 01:24:56 -08001037#endif
Alan Cox1d65b4a2008-10-13 10:38:18 +01001038#ifdef TCGETX
Mike Frysinger5dca6072009-06-16 17:01:02 +01001039 case TCGETX: {
1040 struct termiox ktermx;
Alan Cox1d65b4a2008-10-13 10:38:18 +01001041 if (real_tty->termiox == NULL)
1042 return -EINVAL;
Peter Hurley6a1c0682013-06-15 09:14:23 -04001043 down_read(&real_tty->termios_rwsem);
Alan Cox26a2e202009-06-11 14:03:13 +01001044 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
Peter Hurley6a1c0682013-06-15 09:14:23 -04001045 up_read(&real_tty->termios_rwsem);
Alan Cox26a2e202009-06-11 14:03:13 +01001046 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
1047 ret = -EFAULT;
Alan Cox8f520022008-10-13 10:38:46 +01001048 return ret;
Mike Frysinger5dca6072009-06-16 17:01:02 +01001049 }
Alan Cox1d65b4a2008-10-13 10:38:18 +01001050 case TCSETX:
1051 return set_termiox(real_tty, p, 0);
1052 case TCSETXW:
1053 return set_termiox(real_tty, p, TERMIOS_WAIT);
1054 case TCSETXF:
1055 return set_termiox(real_tty, p, TERMIOS_FLUSH);
1056#endif
Alan Cox355d95a12008-02-08 04:18:48 -08001057 case TIOCGSOFTCAR:
Alan Cox26a2e202009-06-11 14:03:13 +01001058 copy_termios(real_tty, &kterm);
1059 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
Alan Cox355d95a12008-02-08 04:18:48 -08001060 (int __user *)arg);
Alan Cox8f520022008-10-13 10:38:46 +01001061 return ret;
Alan Cox355d95a12008-02-08 04:18:48 -08001062 case TIOCSSOFTCAR:
1063 if (get_user(arg, (unsigned int __user *) arg))
1064 return -EFAULT;
Alan Coxf753f322008-08-26 19:52:47 +01001065 return tty_change_softcar(real_tty, arg);
Alan Cox355d95a12008-02-08 04:18:48 -08001066 default:
1067 return -ENOIOCTLCMD;
Alan Cox0fc00e22007-11-07 01:24:56 -08001068 }
1069}
Alan Cox0fc00e22007-11-07 01:24:56 -08001070EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1071
Alan Cox0fc00e22007-11-07 01:24:56 -08001072
Peter Hurleye7f38802013-03-11 16:44:45 -04001073/* Caller guarantees ldisc reference is held */
1074static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1075{
1076 struct tty_ldisc *ld = tty->ldisc;
1077
Alan Cox0fc00e22007-11-07 01:24:56 -08001078 switch (arg) {
1079 case TCIFLUSH:
Ilya Zykova1bf9582013-01-16 13:07:50 +04001080 if (ld && ld->ops->flush_buffer) {
Alan Coxa352def2008-07-16 21:53:12 +01001081 ld->ops->flush_buffer(tty);
Ilya Zykova1bf9582013-01-16 13:07:50 +04001082 tty_unthrottle(tty);
1083 }
Alan Cox0fc00e22007-11-07 01:24:56 -08001084 break;
1085 case TCIOFLUSH:
Ilya Zykova1bf9582013-01-16 13:07:50 +04001086 if (ld && ld->ops->flush_buffer) {
Alan Coxa352def2008-07-16 21:53:12 +01001087 ld->ops->flush_buffer(tty);
Ilya Zykova1bf9582013-01-16 13:07:50 +04001088 tty_unthrottle(tty);
1089 }
Alan Cox0fc00e22007-11-07 01:24:56 -08001090 /* fall through */
1091 case TCOFLUSH:
Alan Coxf34d7a52008-04-30 00:54:13 -07001092 tty_driver_flush_buffer(tty);
Alan Cox0fc00e22007-11-07 01:24:56 -08001093 break;
1094 default:
Alan Cox0fc00e22007-11-07 01:24:56 -08001095 return -EINVAL;
1096 }
Alan Cox0fc00e22007-11-07 01:24:56 -08001097 return 0;
1098}
Peter Hurleye7f38802013-03-11 16:44:45 -04001099
1100int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1101{
1102 struct tty_ldisc *ld;
1103 int retval = tty_check_change(tty);
1104 if (retval)
1105 return retval;
1106
1107 ld = tty_ldisc_ref_wait(tty);
1108 retval = __tty_perform_flush(tty, arg);
1109 if (ld)
1110 tty_ldisc_deref(ld);
1111 return retval;
1112}
Alan Cox0fc00e22007-11-07 01:24:56 -08001113EXPORT_SYMBOL_GPL(tty_perform_flush);
1114
Alan Cox47afa7a2008-10-13 10:44:17 +01001115int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
Alan Cox0fc00e22007-11-07 01:24:56 -08001116 unsigned int cmd, unsigned long arg)
1117{
Alan Cox0fc00e22007-11-07 01:24:56 -08001118 int retval;
1119
Alan Cox0fc00e22007-11-07 01:24:56 -08001120 switch (cmd) {
Alan Cox355d95a12008-02-08 04:18:48 -08001121 case TCXONC:
1122 retval = tty_check_change(tty);
1123 if (retval)
1124 return retval;
1125 switch (arg) {
1126 case TCOOFF:
Peter Hurleyc545b662014-09-10 15:06:33 -04001127 spin_lock_irq(&tty->flow_lock);
Alan Cox355d95a12008-02-08 04:18:48 -08001128 if (!tty->flow_stopped) {
1129 tty->flow_stopped = 1;
Peter Hurleyc545b662014-09-10 15:06:33 -04001130 __stop_tty(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 }
Peter Hurleyc545b662014-09-10 15:06:33 -04001132 spin_unlock_irq(&tty->flow_lock);
Alan Cox355d95a12008-02-08 04:18:48 -08001133 break;
1134 case TCOON:
Peter Hurleyc545b662014-09-10 15:06:33 -04001135 spin_lock_irq(&tty->flow_lock);
Alan Cox355d95a12008-02-08 04:18:48 -08001136 if (tty->flow_stopped) {
1137 tty->flow_stopped = 0;
Peter Hurleyc545b662014-09-10 15:06:33 -04001138 __start_tty(tty);
Alan Cox355d95a12008-02-08 04:18:48 -08001139 }
Peter Hurleyc545b662014-09-10 15:06:33 -04001140 spin_unlock_irq(&tty->flow_lock);
Alan Cox355d95a12008-02-08 04:18:48 -08001141 break;
1142 case TCIOFF:
1143 if (STOP_CHAR(tty) != __DISABLED_CHAR)
Peter Hurleyc274f6e2014-09-10 15:06:35 -04001144 retval = tty_send_xchar(tty, STOP_CHAR(tty));
Alan Cox355d95a12008-02-08 04:18:48 -08001145 break;
1146 case TCION:
1147 if (START_CHAR(tty) != __DISABLED_CHAR)
Peter Hurleyc274f6e2014-09-10 15:06:35 -04001148 retval = tty_send_xchar(tty, START_CHAR(tty));
Alan Cox355d95a12008-02-08 04:18:48 -08001149 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150 default:
Alan Cox355d95a12008-02-08 04:18:48 -08001151 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 }
Peter Hurleyc274f6e2014-09-10 15:06:35 -04001153 return retval;
Alan Cox355d95a12008-02-08 04:18:48 -08001154 case TCFLSH:
Peter Hurley5cec7bf2013-09-25 20:13:04 -04001155 retval = tty_check_change(tty);
1156 if (retval)
1157 return retval;
Peter Hurleye7f38802013-03-11 16:44:45 -04001158 return __tty_perform_flush(tty, arg);
Alan Cox355d95a12008-02-08 04:18:48 -08001159 default:
1160 /* Try the mode commands */
1161 return tty_mode_ioctl(tty, file, cmd, arg);
1162 }
1163}
Alan Cox47afa7a2008-10-13 10:44:17 +01001164EXPORT_SYMBOL(n_tty_ioctl_helper);
Thomas Meyer8193c422011-10-05 23:13:13 +02001165
1166#ifdef CONFIG_COMPAT
1167long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
1168 unsigned int cmd, unsigned long arg)
1169{
1170 switch (cmd) {
1171 case TIOCGLCKTRMIOS:
1172 case TIOCSLCKTRMIOS:
1173 return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
1174 default:
1175 return -ENOIOCTLCMD;
1176 }
1177}
1178EXPORT_SYMBOL(n_tty_compat_ioctl_helper);
1179#endif
1180