Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
4 *
5 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
6 * which can be dynamically activated and de-activated by the line
7 * discipline handling modules (like SLIP).
8 */
9
10#include <linux/types.h>
11#include <linux/termios.h>
12#include <linux/errno.h>
13#include <linux/sched/signal.h>
14#include <linux/kernel.h>
15#include <linux/major.h>
16#include <linux/tty.h>
17#include <linux/fcntl.h>
18#include <linux/string.h>
19#include <linux/mm.h>
20#include <linux/module.h>
21#include <linux/bitops.h>
22#include <linux/mutex.h>
23#include <linux/compat.h>
24
25#include <asm/io.h>
26#include <linux/uaccess.h>
27
28#undef TTY_DEBUG_WAIT_UNTIL_SENT
29
30#ifdef TTY_DEBUG_WAIT_UNTIL_SENT
31# define tty_debug_wait_until_sent(tty, f, args...) tty_debug(tty, f, ##args)
32#else
33# define tty_debug_wait_until_sent(tty, f, args...) do {} while (0)
34#endif
35
36#undef DEBUG
37
38/*
39 * Internal flag options for termios setting behavior
40 */
41#define TERMIOS_FLUSH 1
42#define TERMIOS_WAIT 2
43#define TERMIOS_TERMIO 4
44#define TERMIOS_OLD 8
45
46
47/**
48 * tty_chars_in_buffer - characters pending
49 * @tty: terminal
50 *
51 * Return the number of bytes of data in the device private
52 * output queue. If no private method is supplied there is assumed
53 * to be no queue on the device.
54 */
55
56int tty_chars_in_buffer(struct tty_struct *tty)
57{
58 if (tty->ops->chars_in_buffer)
59 return tty->ops->chars_in_buffer(tty);
60 else
61 return 0;
62}
63EXPORT_SYMBOL(tty_chars_in_buffer);
64
65/**
66 * tty_write_room - write queue space
67 * @tty: terminal
68 *
69 * Return the number of bytes that can be queued to this device
70 * at the present time. The result should be treated as a guarantee
71 * and the driver cannot offer a value it later shrinks by more than
72 * the number of bytes written. If no method is provided 2K is always
73 * returned and data may be lost as there will be no flow control.
74 */
75
76int tty_write_room(struct tty_struct *tty)
77{
78 if (tty->ops->write_room)
79 return tty->ops->write_room(tty);
80 return 2048;
81}
82EXPORT_SYMBOL(tty_write_room);
83
84/**
85 * tty_driver_flush_buffer - discard internal buffer
86 * @tty: terminal
87 *
88 * Discard the internal output buffer for this device. If no method
89 * is provided then either the buffer cannot be hardware flushed or
90 * there is no buffer driver side.
91 */
92void tty_driver_flush_buffer(struct tty_struct *tty)
93{
94 if (tty->ops->flush_buffer)
95 tty->ops->flush_buffer(tty);
96}
97EXPORT_SYMBOL(tty_driver_flush_buffer);
98
99/**
100 * tty_throttle - flow control
101 * @tty: terminal
102 *
103 * Indicate that a tty should stop transmitting data down the stack.
104 * Takes the termios rwsem to protect against parallel throttle/unthrottle
105 * and also to ensure the driver can consistently reference its own
106 * termios data at this point when implementing software flow control.
107 */
108
109void tty_throttle(struct tty_struct *tty)
110{
111 down_write(&tty->termios_rwsem);
112 /* check TTY_THROTTLED first so it indicates our state */
113 if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
114 tty->ops->throttle)
115 tty->ops->throttle(tty);
116 tty->flow_change = 0;
117 up_write(&tty->termios_rwsem);
118}
119EXPORT_SYMBOL(tty_throttle);
120
121/**
122 * tty_unthrottle - flow control
123 * @tty: terminal
124 *
125 * Indicate that a tty may continue transmitting data down the stack.
126 * Takes the termios rwsem to protect against parallel throttle/unthrottle
127 * and also to ensure the driver can consistently reference its own
128 * termios data at this point when implementing software flow control.
129 *
130 * Drivers should however remember that the stack can issue a throttle,
131 * then change flow control method, then unthrottle.
132 */
133
134void tty_unthrottle(struct tty_struct *tty)
135{
136 down_write(&tty->termios_rwsem);
137 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
138 tty->ops->unthrottle)
139 tty->ops->unthrottle(tty);
140 tty->flow_change = 0;
141 up_write(&tty->termios_rwsem);
142}
143EXPORT_SYMBOL(tty_unthrottle);
144
145/**
146 * tty_throttle_safe - flow control
147 * @tty: terminal
148 *
149 * Similar to tty_throttle() but will only attempt throttle
150 * if tty->flow_change is TTY_THROTTLE_SAFE. Prevents an accidental
151 * throttle due to race conditions when throttling is conditional
152 * on factors evaluated prior to throttling.
153 *
154 * Returns 0 if tty is throttled (or was already throttled)
155 */
156
157int tty_throttle_safe(struct tty_struct *tty)
158{
159 int ret = 0;
160
161 mutex_lock(&tty->throttle_mutex);
162 if (!tty_throttled(tty)) {
163 if (tty->flow_change != TTY_THROTTLE_SAFE)
164 ret = 1;
165 else {
166 set_bit(TTY_THROTTLED, &tty->flags);
167 if (tty->ops->throttle)
168 tty->ops->throttle(tty);
169 }
170 }
171 mutex_unlock(&tty->throttle_mutex);
172
173 return ret;
174}
175
176/**
177 * tty_unthrottle_safe - flow control
178 * @tty: terminal
179 *
180 * Similar to tty_unthrottle() but will only attempt unthrottle
181 * if tty->flow_change is TTY_UNTHROTTLE_SAFE. Prevents an accidental
182 * unthrottle due to race conditions when unthrottling is conditional
183 * on factors evaluated prior to unthrottling.
184 *
185 * Returns 0 if tty is unthrottled (or was already unthrottled)
186 */
187
188int tty_unthrottle_safe(struct tty_struct *tty)
189{
190 int ret = 0;
191
192 mutex_lock(&tty->throttle_mutex);
193 if (tty_throttled(tty)) {
194 if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
195 ret = 1;
196 else {
197 clear_bit(TTY_THROTTLED, &tty->flags);
198 if (tty->ops->unthrottle)
199 tty->ops->unthrottle(tty);
200 }
201 }
202 mutex_unlock(&tty->throttle_mutex);
203
204 return ret;
205}
206
207/**
208 * tty_wait_until_sent - wait for I/O to finish
209 * @tty: tty we are waiting for
210 * @timeout: how long we will wait
211 *
212 * Wait for characters pending in a tty driver to hit the wire, or
213 * for a timeout to occur (eg due to flow control)
214 *
215 * Locking: none
216 */
217
218void tty_wait_until_sent(struct tty_struct *tty, long timeout)
219{
220 tty_debug_wait_until_sent(tty, "wait until sent, timeout=%ld\n", timeout);
221
222 if (!timeout)
223 timeout = MAX_SCHEDULE_TIMEOUT;
224
225 timeout = wait_event_interruptible_timeout(tty->write_wait,
226 !tty_chars_in_buffer(tty), timeout);
227 if (timeout <= 0)
228 return;
229
230 if (timeout == MAX_SCHEDULE_TIMEOUT)
231 timeout = 0;
232
233 if (tty->ops->wait_until_sent)
234 tty->ops->wait_until_sent(tty, timeout);
235}
236EXPORT_SYMBOL(tty_wait_until_sent);
237
238
239/*
240 * Termios Helper Methods
241 */
242
243static void unset_locked_termios(struct tty_struct *tty, struct ktermios *old)
244{
245 struct ktermios *termios = &tty->termios;
246 struct ktermios *locked = &tty->termios_locked;
247 int i;
248
249#define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
250
251 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
252 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
253 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
254 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
255 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
256 for (i = 0; i < NCCS; i++)
257 termios->c_cc[i] = locked->c_cc[i] ?
258 old->c_cc[i] : termios->c_cc[i];
259 /* FIXME: What should we do for i/ospeed */
260}
261
262/**
263 * tty_termios_copy_hw - copy hardware settings
264 * @new: New termios
265 * @old: Old termios
266 *
267 * Propagate the hardware specific terminal setting bits from
268 * the old termios structure to the new one. This is used in cases
269 * where the hardware does not support reconfiguration or as a helper
270 * in some cases where only minimal reconfiguration is supported
271 */
272
273void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
274{
275 /* The bits a dumb device handles in software. Smart devices need
276 to always provide a set_termios method */
277 new->c_cflag &= HUPCL | CREAD | CLOCAL;
278 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
279 new->c_ispeed = old->c_ispeed;
280 new->c_ospeed = old->c_ospeed;
281}
282EXPORT_SYMBOL(tty_termios_copy_hw);
283
284/**
285 * tty_termios_hw_change - check for setting change
286 * @a: termios
287 * @b: termios to compare
288 *
289 * Check if any of the bits that affect a dumb device have changed
290 * between the two termios structures, or a speed change is needed.
291 */
292
293int tty_termios_hw_change(const struct ktermios *a, const struct ktermios *b)
294{
295 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
296 return 1;
297 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
298 return 1;
299 return 0;
300}
301EXPORT_SYMBOL(tty_termios_hw_change);
302
303/**
304 * tty_set_termios - update termios values
305 * @tty: tty to update
306 * @new_termios: desired new value
307 *
308 * Perform updates to the termios values set on this terminal.
309 * A master pty's termios should never be set.
310 *
311 * Locking: termios_rwsem
312 */
313
314int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
315{
316 struct ktermios old_termios;
317 struct tty_ldisc *ld;
318
319 WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
320 tty->driver->subtype == PTY_TYPE_MASTER);
321 /*
322 * Perform the actual termios internal changes under lock.
323 */
324
325
326 /* FIXME: we need to decide on some locking/ordering semantics
327 for the set_termios notification eventually */
328 down_write(&tty->termios_rwsem);
329 old_termios = tty->termios;
330 tty->termios = *new_termios;
331 unset_locked_termios(tty, &old_termios);
332
333 if (tty->ops->set_termios)
334 tty->ops->set_termios(tty, &old_termios);
335 else
336 tty_termios_copy_hw(&tty->termios, &old_termios);
337
338 ld = tty_ldisc_ref(tty);
339 if (ld != NULL) {
340 if (ld->ops->set_termios)
341 ld->ops->set_termios(tty, &old_termios);
342 tty_ldisc_deref(ld);
343 }
344 up_write(&tty->termios_rwsem);
345 return 0;
346}
347EXPORT_SYMBOL_GPL(tty_set_termios);
348
349/**
350 * set_termios - set termios values for a tty
351 * @tty: terminal device
352 * @arg: user data
353 * @opt: option information
354 *
355 * Helper function to prepare termios data and run necessary other
356 * functions before using tty_set_termios to do the actual changes.
357 *
358 * Locking:
359 * Called functions take ldisc and termios_rwsem locks
360 */
361
362static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
363{
364 struct ktermios tmp_termios;
365 struct tty_ldisc *ld;
366 int retval = tty_check_change(tty);
367
368 if (retval)
369 return retval;
370
371 down_read(&tty->termios_rwsem);
372 tmp_termios = tty->termios;
373 up_read(&tty->termios_rwsem);
374
375 if (opt & TERMIOS_TERMIO) {
376 if (user_termio_to_kernel_termios(&tmp_termios,
377 (struct termio __user *)arg))
378 return -EFAULT;
379#ifdef TCGETS2
380 } else if (opt & TERMIOS_OLD) {
381 if (user_termios_to_kernel_termios_1(&tmp_termios,
382 (struct termios __user *)arg))
383 return -EFAULT;
384 } else {
385 if (user_termios_to_kernel_termios(&tmp_termios,
386 (struct termios2 __user *)arg))
387 return -EFAULT;
388 }
389#else
390 } else if (user_termios_to_kernel_termios(&tmp_termios,
391 (struct termios __user *)arg))
392 return -EFAULT;
393#endif
394
395 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
396 * with the real speed so its unconditionally usable */
397 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
398 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
399
400 ld = tty_ldisc_ref(tty);
401
402 if (ld != NULL) {
403 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
404 ld->ops->flush_buffer(tty);
405 tty_ldisc_deref(ld);
406 }
407
408 if (opt & TERMIOS_WAIT) {
409 tty_wait_until_sent(tty, 0);
410 if (signal_pending(current))
411 return -ERESTARTSYS;
412 }
413
414 tty_set_termios(tty, &tmp_termios);
415
416 /* FIXME: Arguably if tmp_termios == tty->termios AND the
417 actual requested termios was not tmp_termios then we may
418 want to return an error as no user requested change has
419 succeeded */
420 return 0;
421}
422
423static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
424{
425 down_read(&tty->termios_rwsem);
426 *kterm = tty->termios;
427 up_read(&tty->termios_rwsem);
428}
429
430static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
431{
432 down_read(&tty->termios_rwsem);
433 *kterm = tty->termios_locked;
434 up_read(&tty->termios_rwsem);
435}
436
437static int get_termio(struct tty_struct *tty, struct termio __user *termio)
438{
439 struct ktermios kterm;
440 copy_termios(tty, &kterm);
441 if (kernel_termios_to_user_termio(termio, &kterm))
442 return -EFAULT;
443 return 0;
444}
445
446
447#ifdef TCGETX
448
449/**
450 * set_termiox - set termiox fields if possible
451 * @tty: terminal
452 * @arg: termiox structure from user
453 * @opt: option flags for ioctl type
454 *
455 * Implement the device calling points for the SYS5 termiox ioctl
456 * interface in Linux
457 */
458
459static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
460{
461 struct termiox tnew;
462 struct tty_ldisc *ld;
463
464 if (tty->termiox == NULL)
465 return -EINVAL;
466 if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
467 return -EFAULT;
468
469 ld = tty_ldisc_ref(tty);
470 if (ld != NULL) {
471 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
472 ld->ops->flush_buffer(tty);
473 tty_ldisc_deref(ld);
474 }
475 if (opt & TERMIOS_WAIT) {
476 tty_wait_until_sent(tty, 0);
477 if (signal_pending(current))
478 return -ERESTARTSYS;
479 }
480
481 down_write(&tty->termios_rwsem);
482 if (tty->ops->set_termiox)
483 tty->ops->set_termiox(tty, &tnew);
484 up_write(&tty->termios_rwsem);
485 return 0;
486}
487
488#endif
489
490
491#ifdef TIOCGETP
492/*
493 * These are deprecated, but there is limited support..
494 *
495 * The "sg_flags" translation is a joke..
496 */
497static int get_sgflags(struct tty_struct *tty)
498{
499 int flags = 0;
500
501 if (!L_ICANON(tty)) {
502 if (L_ISIG(tty))
503 flags |= 0x02; /* cbreak */
504 else
505 flags |= 0x20; /* raw */
506 }
507 if (L_ECHO(tty))
508 flags |= 0x08; /* echo */
509 if (O_OPOST(tty))
510 if (O_ONLCR(tty))
511 flags |= 0x10; /* crmod */
512 return flags;
513}
514
515static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
516{
517 struct sgttyb tmp;
518
519 down_read(&tty->termios_rwsem);
520 tmp.sg_ispeed = tty->termios.c_ispeed;
521 tmp.sg_ospeed = tty->termios.c_ospeed;
522 tmp.sg_erase = tty->termios.c_cc[VERASE];
523 tmp.sg_kill = tty->termios.c_cc[VKILL];
524 tmp.sg_flags = get_sgflags(tty);
525 up_read(&tty->termios_rwsem);
526
527 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
528}
529
530static void set_sgflags(struct ktermios *termios, int flags)
531{
532 termios->c_iflag = ICRNL | IXON;
533 termios->c_oflag = 0;
534 termios->c_lflag = ISIG | ICANON;
535 if (flags & 0x02) { /* cbreak */
536 termios->c_iflag = 0;
537 termios->c_lflag &= ~ICANON;
538 }
539 if (flags & 0x08) { /* echo */
540 termios->c_lflag |= ECHO | ECHOE | ECHOK |
541 ECHOCTL | ECHOKE | IEXTEN;
542 }
543 if (flags & 0x10) { /* crmod */
544 termios->c_oflag |= OPOST | ONLCR;
545 }
546 if (flags & 0x20) { /* raw */
547 termios->c_iflag = 0;
548 termios->c_lflag &= ~(ISIG | ICANON);
549 }
550 if (!(termios->c_lflag & ICANON)) {
551 termios->c_cc[VMIN] = 1;
552 termios->c_cc[VTIME] = 0;
553 }
554}
555
556/**
557 * set_sgttyb - set legacy terminal values
558 * @tty: tty structure
559 * @sgttyb: pointer to old style terminal structure
560 *
561 * Updates a terminal from the legacy BSD style terminal information
562 * structure.
563 *
564 * Locking: termios_rwsem
565 */
566
567static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
568{
569 int retval;
570 struct sgttyb tmp;
571 struct ktermios termios;
572
573 retval = tty_check_change(tty);
574 if (retval)
575 return retval;
576
577 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
578 return -EFAULT;
579
580 down_write(&tty->termios_rwsem);
581 termios = tty->termios;
582 termios.c_cc[VERASE] = tmp.sg_erase;
583 termios.c_cc[VKILL] = tmp.sg_kill;
584 set_sgflags(&termios, tmp.sg_flags);
585 /* Try and encode into Bfoo format */
586#ifdef BOTHER
587 tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
588 termios.c_ospeed);
589#endif
590 up_write(&tty->termios_rwsem);
591 tty_set_termios(tty, &termios);
592 return 0;
593}
594#endif
595
596#ifdef TIOCGETC
597static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
598{
599 struct tchars tmp;
600
601 down_read(&tty->termios_rwsem);
602 tmp.t_intrc = tty->termios.c_cc[VINTR];
603 tmp.t_quitc = tty->termios.c_cc[VQUIT];
604 tmp.t_startc = tty->termios.c_cc[VSTART];
605 tmp.t_stopc = tty->termios.c_cc[VSTOP];
606 tmp.t_eofc = tty->termios.c_cc[VEOF];
607 tmp.t_brkc = tty->termios.c_cc[VEOL2]; /* what is brkc anyway? */
608 up_read(&tty->termios_rwsem);
609 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
610}
611
612static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
613{
614 struct tchars tmp;
615
616 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
617 return -EFAULT;
618 down_write(&tty->termios_rwsem);
619 tty->termios.c_cc[VINTR] = tmp.t_intrc;
620 tty->termios.c_cc[VQUIT] = tmp.t_quitc;
621 tty->termios.c_cc[VSTART] = tmp.t_startc;
622 tty->termios.c_cc[VSTOP] = tmp.t_stopc;
623 tty->termios.c_cc[VEOF] = tmp.t_eofc;
624 tty->termios.c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
625 up_write(&tty->termios_rwsem);
626 return 0;
627}
628#endif
629
630#ifdef TIOCGLTC
631static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
632{
633 struct ltchars tmp;
634
635 down_read(&tty->termios_rwsem);
636 tmp.t_suspc = tty->termios.c_cc[VSUSP];
637 /* what is dsuspc anyway? */
638 tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
639 tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
640 /* what is flushc anyway? */
641 tmp.t_flushc = tty->termios.c_cc[VEOL2];
642 tmp.t_werasc = tty->termios.c_cc[VWERASE];
643 tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
644 up_read(&tty->termios_rwsem);
645 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
646}
647
648static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
649{
650 struct ltchars tmp;
651
652 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
653 return -EFAULT;
654
655 down_write(&tty->termios_rwsem);
656 tty->termios.c_cc[VSUSP] = tmp.t_suspc;
657 /* what is dsuspc anyway? */
658 tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
659 tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
660 /* what is flushc anyway? */
661 tty->termios.c_cc[VEOL2] = tmp.t_flushc;
662 tty->termios.c_cc[VWERASE] = tmp.t_werasc;
663 tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
664 up_write(&tty->termios_rwsem);
665 return 0;
666}
667#endif
668
669/**
670 * tty_change_softcar - carrier change ioctl helper
671 * @tty: tty to update
672 * @arg: enable/disable CLOCAL
673 *
674 * Perform a change to the CLOCAL state and call into the driver
675 * layer to make it visible. All done with the termios rwsem
676 */
677
678static int tty_change_softcar(struct tty_struct *tty, int arg)
679{
680 int ret = 0;
681 int bit = arg ? CLOCAL : 0;
682 struct ktermios old;
683
684 down_write(&tty->termios_rwsem);
685 old = tty->termios;
686 tty->termios.c_cflag &= ~CLOCAL;
687 tty->termios.c_cflag |= bit;
688 if (tty->ops->set_termios)
689 tty->ops->set_termios(tty, &old);
690 if (C_CLOCAL(tty) != bit)
691 ret = -EINVAL;
692 up_write(&tty->termios_rwsem);
693 return ret;
694}
695
696/**
697 * tty_mode_ioctl - mode related ioctls
698 * @tty: tty for the ioctl
699 * @file: file pointer for the tty
700 * @cmd: command
701 * @arg: ioctl argument
702 *
703 * Perform non line discipline specific mode control ioctls. This
704 * is designed to be called by line disciplines to ensure they provide
705 * consistent mode setting.
706 */
707
708int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
709 unsigned int cmd, unsigned long arg)
710{
711 struct tty_struct *real_tty;
712 void __user *p = (void __user *)arg;
713 int ret = 0;
714 struct ktermios kterm;
715
716 BUG_ON(file == NULL);
717
718 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
719 tty->driver->subtype == PTY_TYPE_MASTER)
720 real_tty = tty->link;
721 else
722 real_tty = tty;
723
724 switch (cmd) {
725#ifdef TIOCGETP
726 case TIOCGETP:
727 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
728 case TIOCSETP:
729 case TIOCSETN:
730 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
731#endif
732#ifdef TIOCGETC
733 case TIOCGETC:
734 return get_tchars(real_tty, p);
735 case TIOCSETC:
736 return set_tchars(real_tty, p);
737#endif
738#ifdef TIOCGLTC
739 case TIOCGLTC:
740 return get_ltchars(real_tty, p);
741 case TIOCSLTC:
742 return set_ltchars(real_tty, p);
743#endif
744 case TCSETSF:
745 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
746 case TCSETSW:
747 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
748 case TCSETS:
749 return set_termios(real_tty, p, TERMIOS_OLD);
750#ifndef TCGETS2
751 case TCGETS:
752 copy_termios(real_tty, &kterm);
753 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
754 ret = -EFAULT;
755 return ret;
756#else
757 case TCGETS:
758 copy_termios(real_tty, &kterm);
759 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
760 ret = -EFAULT;
761 return ret;
762 case TCGETS2:
763 copy_termios(real_tty, &kterm);
764 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
765 ret = -EFAULT;
766 return ret;
767 case TCSETSF2:
768 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
769 case TCSETSW2:
770 return set_termios(real_tty, p, TERMIOS_WAIT);
771 case TCSETS2:
772 return set_termios(real_tty, p, 0);
773#endif
774 case TCGETA:
775 return get_termio(real_tty, p);
776 case TCSETAF:
777 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
778 case TCSETAW:
779 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
780 case TCSETA:
781 return set_termios(real_tty, p, TERMIOS_TERMIO);
782#ifndef TCGETS2
783 case TIOCGLCKTRMIOS:
784 copy_termios_locked(real_tty, &kterm);
785 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
786 ret = -EFAULT;
787 return ret;
788 case TIOCSLCKTRMIOS:
789 if (!capable(CAP_SYS_ADMIN))
790 return -EPERM;
791 copy_termios_locked(real_tty, &kterm);
792 if (user_termios_to_kernel_termios(&kterm,
793 (struct termios __user *) arg))
794 return -EFAULT;
795 down_write(&real_tty->termios_rwsem);
796 real_tty->termios_locked = kterm;
797 up_write(&real_tty->termios_rwsem);
798 return 0;
799#else
800 case TIOCGLCKTRMIOS:
801 copy_termios_locked(real_tty, &kterm);
802 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
803 ret = -EFAULT;
804 return ret;
805 case TIOCSLCKTRMIOS:
806 if (!capable(CAP_SYS_ADMIN))
807 return -EPERM;
808 copy_termios_locked(real_tty, &kterm);
809 if (user_termios_to_kernel_termios_1(&kterm,
810 (struct termios __user *) arg))
811 return -EFAULT;
812 down_write(&real_tty->termios_rwsem);
813 real_tty->termios_locked = kterm;
814 up_write(&real_tty->termios_rwsem);
815 return ret;
816#endif
817#ifdef TCGETX
818 case TCGETX: {
819 struct termiox ktermx;
820 if (real_tty->termiox == NULL)
821 return -EINVAL;
822 down_read(&real_tty->termios_rwsem);
823 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
824 up_read(&real_tty->termios_rwsem);
825 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
826 ret = -EFAULT;
827 return ret;
828 }
829 case TCSETX:
830 return set_termiox(real_tty, p, 0);
831 case TCSETXW:
832 return set_termiox(real_tty, p, TERMIOS_WAIT);
833 case TCSETXF:
834 return set_termiox(real_tty, p, TERMIOS_FLUSH);
835#endif
836 case TIOCGSOFTCAR:
837 copy_termios(real_tty, &kterm);
838 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
839 (int __user *)arg);
840 return ret;
841 case TIOCSSOFTCAR:
842 if (get_user(arg, (unsigned int __user *) arg))
843 return -EFAULT;
844 return tty_change_softcar(real_tty, arg);
845 default:
846 return -ENOIOCTLCMD;
847 }
848}
849EXPORT_SYMBOL_GPL(tty_mode_ioctl);
850
851
852/* Caller guarantees ldisc reference is held */
853static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
854{
855 struct tty_ldisc *ld = tty->ldisc;
856
857 switch (arg) {
858 case TCIFLUSH:
859 if (ld && ld->ops->flush_buffer) {
860 ld->ops->flush_buffer(tty);
861 tty_unthrottle(tty);
862 }
863 break;
864 case TCIOFLUSH:
865 if (ld && ld->ops->flush_buffer) {
866 ld->ops->flush_buffer(tty);
867 tty_unthrottle(tty);
868 }
869 fallthrough;
870 case TCOFLUSH:
871 tty_driver_flush_buffer(tty);
872 break;
873 default:
874 return -EINVAL;
875 }
876 return 0;
877}
878
879int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
880{
881 struct tty_ldisc *ld;
882 int retval = tty_check_change(tty);
883 if (retval)
884 return retval;
885
886 ld = tty_ldisc_ref_wait(tty);
887 retval = __tty_perform_flush(tty, arg);
888 if (ld)
889 tty_ldisc_deref(ld);
890 return retval;
891}
892EXPORT_SYMBOL_GPL(tty_perform_flush);
893
894int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
895 unsigned int cmd, unsigned long arg)
896{
897 int retval;
898
899 switch (cmd) {
900 case TCXONC:
901 retval = tty_check_change(tty);
902 if (retval)
903 return retval;
904 switch (arg) {
905 case TCOOFF:
906 spin_lock_irq(&tty->flow_lock);
907 if (!tty->flow_stopped) {
908 tty->flow_stopped = 1;
909 __stop_tty(tty);
910 }
911 spin_unlock_irq(&tty->flow_lock);
912 break;
913 case TCOON:
914 spin_lock_irq(&tty->flow_lock);
915 if (tty->flow_stopped) {
916 tty->flow_stopped = 0;
917 __start_tty(tty);
918 }
919 spin_unlock_irq(&tty->flow_lock);
920 break;
921 case TCIOFF:
922 if (STOP_CHAR(tty) != __DISABLED_CHAR)
923 retval = tty_send_xchar(tty, STOP_CHAR(tty));
924 break;
925 case TCION:
926 if (START_CHAR(tty) != __DISABLED_CHAR)
927 retval = tty_send_xchar(tty, START_CHAR(tty));
928 break;
929 default:
930 return -EINVAL;
931 }
932 return retval;
933 case TCFLSH:
934 retval = tty_check_change(tty);
935 if (retval)
936 return retval;
937 return __tty_perform_flush(tty, arg);
938 default:
939 /* Try the mode commands */
940 return tty_mode_ioctl(tty, file, cmd, arg);
941 }
942}
943EXPORT_SYMBOL(n_tty_ioctl_helper);
1/*
2 * 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>
21#include <linux/mutex.h>
22#include <linux/compat.h>
23
24#include <asm/io.h>
25#include <asm/uaccess.h>
26
27#undef TTY_DEBUG_WAIT_UNTIL_SENT
28
29#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
35#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
43#define TERMIOS_OLD 8
44
45
46/**
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
55int 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}
62EXPORT_SYMBOL(tty_chars_in_buffer);
63
64/**
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
75int 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}
81EXPORT_SYMBOL(tty_write_room);
82
83/**
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 */
91void tty_driver_flush_buffer(struct tty_struct *tty)
92{
93 if (tty->ops->flush_buffer)
94 tty->ops->flush_buffer(tty);
95}
96EXPORT_SYMBOL(tty_driver_flush_buffer);
97
98/**
99 * tty_throttle - flow control
100 * @tty: terminal
101 *
102 * Indicate that a tty should stop transmitting data down the stack.
103 * Takes the termios rwsem to protect against parallel throttle/unthrottle
104 * and also to ensure the driver can consistently reference its own
105 * termios data at this point when implementing software flow control.
106 */
107
108void tty_throttle(struct tty_struct *tty)
109{
110 down_write(&tty->termios_rwsem);
111 /* 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);
115 tty->flow_change = 0;
116 up_write(&tty->termios_rwsem);
117}
118EXPORT_SYMBOL(tty_throttle);
119
120/**
121 * tty_unthrottle - flow control
122 * @tty: terminal
123 *
124 * Indicate that a tty may continue transmitting data down the stack.
125 * Takes the termios rwsem to protect against parallel throttle/unthrottle
126 * 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.
131 */
132
133void tty_unthrottle(struct tty_struct *tty)
134{
135 down_write(&tty->termios_rwsem);
136 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
137 tty->ops->unthrottle)
138 tty->ops->unthrottle(tty);
139 tty->flow_change = 0;
140 up_write(&tty->termios_rwsem);
141}
142EXPORT_SYMBOL(tty_unthrottle);
143
144/**
145 * 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
160 mutex_lock(&tty->throttle_mutex);
161 if (!test_bit(TTY_THROTTLED, &tty->flags)) {
162 if (tty->flow_change != TTY_THROTTLE_SAFE)
163 ret = 1;
164 else {
165 set_bit(TTY_THROTTLED, &tty->flags);
166 if (tty->ops->throttle)
167 tty->ops->throttle(tty);
168 }
169 }
170 mutex_unlock(&tty->throttle_mutex);
171
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
191 mutex_lock(&tty->throttle_mutex);
192 if (test_bit(TTY_THROTTLED, &tty->flags)) {
193 if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
194 ret = 1;
195 else {
196 clear_bit(TTY_THROTTLED, &tty->flags);
197 if (tty->ops->unthrottle)
198 tty->ops->unthrottle(tty);
199 }
200 }
201 mutex_unlock(&tty->throttle_mutex);
202
203 return ret;
204}
205
206/**
207 * 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
217void tty_wait_until_sent(struct tty_struct *tty, long timeout)
218{
219 tty_debug_wait_until_sent(tty, "wait until sent, timeout=%ld\n", timeout);
220
221 if (!timeout)
222 timeout = MAX_SCHEDULE_TIMEOUT;
223
224 timeout = wait_event_interruptible_timeout(tty->write_wait,
225 !tty_chars_in_buffer(tty), timeout);
226 if (timeout <= 0)
227 return;
228
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);
234}
235EXPORT_SYMBOL(tty_wait_until_sent);
236
237
238/*
239 * Termios Helper Methods
240 */
241
242static void unset_locked_termios(struct tty_struct *tty, struct ktermios *old)
243{
244 struct ktermios *termios = &tty->termios;
245 struct ktermios *locked = &tty->termios_locked;
246 int i;
247
248#define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
249
250 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;
255 for (i = 0; i < NCCS; i++)
256 termios->c_cc[i] = locked->c_cc[i] ?
257 old->c_cc[i] : termios->c_cc[i];
258 /* FIXME: What should we do for i/ospeed */
259}
260
261/*
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
316 /* Magic token for arbitrary speed via c_ispeed/c_ospeed */
317 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}
330EXPORT_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
352 /* Magic token for arbitrary speed via c_ispeed*/
353 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}
369EXPORT_SYMBOL(tty_termios_input_baud_rate);
370
371/**
372 * tty_termios_encode_baud_rate
373 * @termios: ktermios structure holding user requested state
374 * @ispeed: input speed
375 * @ospeed: output speed
376 *
377 * Encode the speeds set into the passed termios structure. This is
378 * used as a library helper for drivers so that they can report back
379 * the actual speed selected when it differs from the speed requested
380 *
381 * 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
384 * of the input intent to keep compatibility.
385 *
386 * Locking: Caller should hold termios lock. This is already held
387 * when calling this function from the driver termios handler.
388 *
389 * The ifdefs deal with platforms whose owners have yet to update them
390 * and will all go away once this is done.
391 */
392
393void tty_termios_encode_baud_rate(struct ktermios *termios,
394 speed_t ibaud, speed_t obaud)
395{
396 int i = 0;
397 int ifound = -1, ofound = -1;
398 int iclose = ibaud/50, oclose = obaud/50;
399 int ibinput = 0;
400
401 if (obaud == 0) /* CD dropped */
402 ibaud = 0; /* Clear ibaud to be sure */
403
404 termios->c_ispeed = ibaud;
405 termios->c_ospeed = obaud;
406
407#ifdef BOTHER
408 /* If the user asked for a precise weird speed give a precise weird
409 answer. If they asked for a Bfoo speed they may have problems
410 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 */
418#endif
419 termios->c_cflag &= ~CBAUD;
420
421 /*
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
428 do {
429 if (obaud - oclose <= baud_table[i] &&
430 obaud + oclose >= baud_table[i]) {
431 termios->c_cflag |= baud_bits[i];
432 ofound = i;
433 }
434 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 */
438 if (ofound == i && !ibinput)
439 ifound = i;
440#ifdef IBSHIFT
441 else {
442 ifound = i;
443 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
444 }
445#endif
446 }
447 } while (++i < n_baud_table);
448
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
454 if (ofound == -1)
455 termios->c_cflag |= BOTHER;
456 /* Set exact input bits only if the input and output differ or the
457 user already did */
458 if (ifound == -1 && (ibaud != obaud || ibinput))
459 termios->c_cflag |= (BOTHER << IBSHIFT);
460#else
461 if (ifound == -1 || ofound == -1)
462 pr_warn_once("tty: Unable to return correct speed data as your architecture needs updating.\n");
463#endif
464}
465EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
466
467/**
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
473 * settings. The caller must hold the termios_rwsem for the tty in
474 * question.
475 */
476
477void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
478{
479 tty_termios_encode_baud_rate(&tty->termios, ibaud, obaud);
480}
481EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
482
483/**
484 * tty_termios_copy_hw - copy hardware settings
485 * @new: New termios
486 * @old: Old termios
487 *
488 * Propagate the hardware specific terminal setting bits from
489 * 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}
503EXPORT_SYMBOL(tty_termios_copy_hw);
504
505/**
506 * 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/**
525 * tty_set_termios - update termios values
526 * @tty: tty to update
527 * @new_termios: desired new value
528 *
529 * Perform updates to the termios values set on this terminal.
530 * A master pty's termios should never be set.
531 *
532 * Locking: termios_rwsem
533 */
534
535int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
536{
537 struct ktermios old_termios;
538 struct tty_ldisc *ld;
539
540 WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
541 tty->driver->subtype == PTY_TYPE_MASTER);
542 /*
543 * Perform the actual termios internal changes under lock.
544 */
545
546
547 /* FIXME: we need to decide on some locking/ordering semantics
548 for the set_termios notification eventually */
549 down_write(&tty->termios_rwsem);
550 old_termios = tty->termios;
551 tty->termios = *new_termios;
552 unset_locked_termios(tty, &old_termios);
553
554 if (tty->ops->set_termios)
555 tty->ops->set_termios(tty, &old_termios);
556 else
557 tty_termios_copy_hw(&tty->termios, &old_termios);
558
559 ld = tty_ldisc_ref(tty);
560 if (ld != NULL) {
561 if (ld->ops->set_termios)
562 ld->ops->set_termios(tty, &old_termios);
563 tty_ldisc_deref(ld);
564 }
565 up_write(&tty->termios_rwsem);
566 return 0;
567}
568EXPORT_SYMBOL_GPL(tty_set_termios);
569
570/**
571 * set_termios - set termios values for a tty
572 * @tty: terminal device
573 * @arg: user data
574 * @opt: option information
575 *
576 * Helper function to prepare termios data and run necessary other
577 * functions before using tty_set_termios to do the actual changes.
578 *
579 * Locking:
580 * Called functions take ldisc and termios_rwsem locks
581 */
582
583static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
584{
585 struct ktermios tmp_termios;
586 struct tty_ldisc *ld;
587 int retval = tty_check_change(tty);
588
589 if (retval)
590 return retval;
591
592 down_read(&tty->termios_rwsem);
593 tmp_termios = tty->termios;
594 up_read(&tty->termios_rwsem);
595
596 if (opt & TERMIOS_TERMIO) {
597 if (user_termio_to_kernel_termios(&tmp_termios,
598 (struct termio __user *)arg))
599 return -EFAULT;
600#ifdef TCGETS2
601 } else if (opt & TERMIOS_OLD) {
602 if (user_termios_to_kernel_termios_1(&tmp_termios,
603 (struct termios __user *)arg))
604 return -EFAULT;
605 } else {
606 if (user_termios_to_kernel_termios(&tmp_termios,
607 (struct termios2 __user *)arg))
608 return -EFAULT;
609 }
610#else
611 } else if (user_termios_to_kernel_termios(&tmp_termios,
612 (struct termios __user *)arg))
613 return -EFAULT;
614#endif
615
616 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
617 * with the real speed so its unconditionally usable */
618 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
619 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
620
621 ld = tty_ldisc_ref(tty);
622
623 if (ld != NULL) {
624 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
625 ld->ops->flush_buffer(tty);
626 tty_ldisc_deref(ld);
627 }
628
629 if (opt & TERMIOS_WAIT) {
630 tty_wait_until_sent(tty, 0);
631 if (signal_pending(current))
632 return -ERESTARTSYS;
633 }
634
635 tty_set_termios(tty, &tmp_termios);
636
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 */
641 return 0;
642}
643
644static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
645{
646 down_read(&tty->termios_rwsem);
647 *kterm = tty->termios;
648 up_read(&tty->termios_rwsem);
649}
650
651static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
652{
653 down_read(&tty->termios_rwsem);
654 *kterm = tty->termios_locked;
655 up_read(&tty->termios_rwsem);
656}
657
658static int get_termio(struct tty_struct *tty, struct termio __user *termio)
659{
660 struct ktermios kterm;
661 copy_termios(tty, &kterm);
662 if (kernel_termios_to_user_termio(termio, &kterm))
663 return -EFAULT;
664 return 0;
665}
666
667
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))
699 return -ERESTARTSYS;
700 }
701
702 down_write(&tty->termios_rwsem);
703 if (tty->ops->set_termiox)
704 tty->ops->set_termiox(tty, &tnew);
705 up_write(&tty->termios_rwsem);
706 return 0;
707}
708
709#endif
710
711
712#ifdef TIOCGETP
713/*
714 * These are deprecated, but there is limited support..
715 *
716 * The "sg_flags" translation is a joke..
717 */
718static int get_sgflags(struct tty_struct *tty)
719{
720 int flags = 0;
721
722 if (!L_ICANON(tty)) {
723 if (L_ISIG(tty))
724 flags |= 0x02; /* cbreak */
725 else
726 flags |= 0x20; /* raw */
727 }
728 if (L_ECHO(tty))
729 flags |= 0x08; /* echo */
730 if (O_OPOST(tty))
731 if (O_ONLCR(tty))
732 flags |= 0x10; /* crmod */
733 return flags;
734}
735
736static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
737{
738 struct sgttyb tmp;
739
740 down_read(&tty->termios_rwsem);
741 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];
745 tmp.sg_flags = get_sgflags(tty);
746 up_read(&tty->termios_rwsem);
747
748 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
749}
750
751static void set_sgflags(struct ktermios *termios, int flags)
752{
753 termios->c_iflag = ICRNL | IXON;
754 termios->c_oflag = 0;
755 termios->c_lflag = ISIG | ICANON;
756 if (flags & 0x02) { /* cbreak */
757 termios->c_iflag = 0;
758 termios->c_lflag &= ~ICANON;
759 }
760 if (flags & 0x08) { /* echo */
761 termios->c_lflag |= ECHO | ECHOE | ECHOK |
762 ECHOCTL | ECHOKE | IEXTEN;
763 }
764 if (flags & 0x10) { /* crmod */
765 termios->c_oflag |= OPOST | ONLCR;
766 }
767 if (flags & 0x20) { /* raw */
768 termios->c_iflag = 0;
769 termios->c_lflag &= ~(ISIG | ICANON);
770 }
771 if (!(termios->c_lflag & ICANON)) {
772 termios->c_cc[VMIN] = 1;
773 termios->c_cc[VTIME] = 0;
774 }
775}
776
777/**
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 *
785 * Locking: termios_rwsem
786 */
787
788static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
789{
790 int retval;
791 struct sgttyb tmp;
792 struct ktermios termios;
793
794 retval = tty_check_change(tty);
795 if (retval)
796 return retval;
797
798 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
799 return -EFAULT;
800
801 down_write(&tty->termios_rwsem);
802 termios = tty->termios;
803 termios.c_cc[VERASE] = tmp.sg_erase;
804 termios.c_cc[VKILL] = tmp.sg_kill;
805 set_sgflags(&termios, tmp.sg_flags);
806 /* Try and encode into Bfoo format */
807#ifdef BOTHER
808 tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
809 termios.c_ospeed);
810#endif
811 up_write(&tty->termios_rwsem);
812 tty_set_termios(tty, &termios);
813 return 0;
814}
815#endif
816
817#ifdef TIOCGETC
818static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
819{
820 struct tchars tmp;
821
822 down_read(&tty->termios_rwsem);
823 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? */
829 up_read(&tty->termios_rwsem);
830 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
831}
832
833static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
834{
835 struct tchars tmp;
836
837 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
838 return -EFAULT;
839 down_write(&tty->termios_rwsem);
840 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? */
846 up_write(&tty->termios_rwsem);
847 return 0;
848}
849#endif
850
851#ifdef TIOCGLTC
852static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
853{
854 struct ltchars tmp;
855
856 down_read(&tty->termios_rwsem);
857 tmp.t_suspc = tty->termios.c_cc[VSUSP];
858 /* what is dsuspc anyway? */
859 tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
860 tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
861 /* what is flushc anyway? */
862 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];
865 up_read(&tty->termios_rwsem);
866 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
867}
868
869static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
870{
871 struct ltchars tmp;
872
873 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
874 return -EFAULT;
875
876 down_write(&tty->termios_rwsem);
877 tty->termios.c_cc[VSUSP] = tmp.t_suspc;
878 /* what is dsuspc anyway? */
879 tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
880 tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
881 /* what is flushc anyway? */
882 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;
885 up_write(&tty->termios_rwsem);
886 return 0;
887}
888#endif
889
890/**
891 * 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
896 * layer to make it visible. All done with the termios rwsem
897 */
898
899static int tty_change_softcar(struct tty_struct *tty, int arg)
900{
901 int ret = 0;
902 int bit = arg ? CLOCAL : 0;
903 struct ktermios old;
904
905 down_write(&tty->termios_rwsem);
906 old = tty->termios;
907 tty->termios.c_cflag &= ~CLOCAL;
908 tty->termios.c_cflag |= bit;
909 if (tty->ops->set_termios)
910 tty->ops->set_termios(tty, &old);
911 if (C_CLOCAL(tty) != bit)
912 ret = -EINVAL;
913 up_write(&tty->termios_rwsem);
914 return ret;
915}
916
917/**
918 * 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
929int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
930 unsigned int cmd, unsigned long arg)
931{
932 struct tty_struct *real_tty;
933 void __user *p = (void __user *)arg;
934 int ret = 0;
935 struct ktermios kterm;
936
937 BUG_ON(file == NULL);
938
939 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
947 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);
952#endif
953#ifdef TIOCGETC
954 case TIOCGETC:
955 return get_tchars(real_tty, p);
956 case TIOCSETC:
957 return set_tchars(real_tty, p);
958#endif
959#ifdef TIOCGLTC
960 case TIOCGLTC:
961 return get_ltchars(real_tty, p);
962 case TIOCSLTC:
963 return set_ltchars(real_tty, p);
964#endif
965 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);
971#ifndef TCGETS2
972 case TCGETS:
973 copy_termios(real_tty, &kterm);
974 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
975 ret = -EFAULT;
976 return ret;
977#else
978 case TCGETS:
979 copy_termios(real_tty, &kterm);
980 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
981 ret = -EFAULT;
982 return ret;
983 case TCGETS2:
984 copy_termios(real_tty, &kterm);
985 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
986 ret = -EFAULT;
987 return ret;
988 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);
994#endif
995 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);
1003#ifndef TCGETS2
1004 case TIOCGLCKTRMIOS:
1005 copy_termios_locked(real_tty, &kterm);
1006 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
1007 ret = -EFAULT;
1008 return ret;
1009 case TIOCSLCKTRMIOS:
1010 if (!capable(CAP_SYS_ADMIN))
1011 return -EPERM;
1012 copy_termios_locked(real_tty, &kterm);
1013 if (user_termios_to_kernel_termios(&kterm,
1014 (struct termios __user *) arg))
1015 return -EFAULT;
1016 down_write(&real_tty->termios_rwsem);
1017 real_tty->termios_locked = kterm;
1018 up_write(&real_tty->termios_rwsem);
1019 return 0;
1020#else
1021 case TIOCGLCKTRMIOS:
1022 copy_termios_locked(real_tty, &kterm);
1023 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
1024 ret = -EFAULT;
1025 return ret;
1026 case TIOCSLCKTRMIOS:
1027 if (!capable(CAP_SYS_ADMIN))
1028 return -EPERM;
1029 copy_termios_locked(real_tty, &kterm);
1030 if (user_termios_to_kernel_termios_1(&kterm,
1031 (struct termios __user *) arg))
1032 return -EFAULT;
1033 down_write(&real_tty->termios_rwsem);
1034 real_tty->termios_locked = kterm;
1035 up_write(&real_tty->termios_rwsem);
1036 return ret;
1037#endif
1038#ifdef TCGETX
1039 case TCGETX: {
1040 struct termiox ktermx;
1041 if (real_tty->termiox == NULL)
1042 return -EINVAL;
1043 down_read(&real_tty->termios_rwsem);
1044 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
1045 up_read(&real_tty->termios_rwsem);
1046 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
1047 ret = -EFAULT;
1048 return ret;
1049 }
1050 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
1057 case TIOCGSOFTCAR:
1058 copy_termios(real_tty, &kterm);
1059 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
1060 (int __user *)arg);
1061 return ret;
1062 case TIOCSSOFTCAR:
1063 if (get_user(arg, (unsigned int __user *) arg))
1064 return -EFAULT;
1065 return tty_change_softcar(real_tty, arg);
1066 default:
1067 return -ENOIOCTLCMD;
1068 }
1069}
1070EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1071
1072
1073/* 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
1078 switch (arg) {
1079 case TCIFLUSH:
1080 if (ld && ld->ops->flush_buffer) {
1081 ld->ops->flush_buffer(tty);
1082 tty_unthrottle(tty);
1083 }
1084 break;
1085 case TCIOFLUSH:
1086 if (ld && ld->ops->flush_buffer) {
1087 ld->ops->flush_buffer(tty);
1088 tty_unthrottle(tty);
1089 }
1090 /* fall through */
1091 case TCOFLUSH:
1092 tty_driver_flush_buffer(tty);
1093 break;
1094 default:
1095 return -EINVAL;
1096 }
1097 return 0;
1098}
1099
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}
1113EXPORT_SYMBOL_GPL(tty_perform_flush);
1114
1115int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
1116 unsigned int cmd, unsigned long arg)
1117{
1118 int retval;
1119
1120 switch (cmd) {
1121 case TCXONC:
1122 retval = tty_check_change(tty);
1123 if (retval)
1124 return retval;
1125 switch (arg) {
1126 case TCOOFF:
1127 spin_lock_irq(&tty->flow_lock);
1128 if (!tty->flow_stopped) {
1129 tty->flow_stopped = 1;
1130 __stop_tty(tty);
1131 }
1132 spin_unlock_irq(&tty->flow_lock);
1133 break;
1134 case TCOON:
1135 spin_lock_irq(&tty->flow_lock);
1136 if (tty->flow_stopped) {
1137 tty->flow_stopped = 0;
1138 __start_tty(tty);
1139 }
1140 spin_unlock_irq(&tty->flow_lock);
1141 break;
1142 case TCIOFF:
1143 if (STOP_CHAR(tty) != __DISABLED_CHAR)
1144 retval = tty_send_xchar(tty, STOP_CHAR(tty));
1145 break;
1146 case TCION:
1147 if (START_CHAR(tty) != __DISABLED_CHAR)
1148 retval = tty_send_xchar(tty, START_CHAR(tty));
1149 break;
1150 default:
1151 return -EINVAL;
1152 }
1153 return retval;
1154 case TCFLSH:
1155 retval = tty_check_change(tty);
1156 if (retval)
1157 return retval;
1158 return __tty_perform_flush(tty, arg);
1159 default:
1160 /* Try the mode commands */
1161 return tty_mode_ioctl(tty, file, cmd, arg);
1162 }
1163}
1164EXPORT_SYMBOL(n_tty_ioctl_helper);
1165
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