1
2
3
4
5
6
7
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#include "tty.h"
25
26#include <asm/io.h>
27#include <linux/uaccess.h>
28
29#undef TTY_DEBUG_WAIT_UNTIL_SENT
30
31#ifdef TTY_DEBUG_WAIT_UNTIL_SENT
32# define tty_debug_wait_until_sent(tty, f, args...) tty_debug(tty, f, ##args)
33#else
34# define tty_debug_wait_until_sent(tty, f, args...) do {} while (0)
35#endif
36
37#undef DEBUG
38
39
40
41
42#define TERMIOS_FLUSH 1
43#define TERMIOS_WAIT 2
44#define TERMIOS_TERMIO 4
45#define TERMIOS_OLD 8
46
47
48
49
50
51
52
53
54
55
56
57unsigned int tty_chars_in_buffer(struct tty_struct *tty)
58{
59 if (tty->ops->chars_in_buffer)
60 return tty->ops->chars_in_buffer(tty);
61 return 0;
62}
63EXPORT_SYMBOL(tty_chars_in_buffer);
64
65
66
67
68
69
70
71
72
73
74
75
76unsigned int 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
86
87
88
89
90
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
101
102
103
104
105
106
107
108
109
110
111
112void tty_unthrottle(struct tty_struct *tty)
113{
114 down_write(&tty->termios_rwsem);
115 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
116 tty->ops->unthrottle)
117 tty->ops->unthrottle(tty);
118 tty->flow_change = 0;
119 up_write(&tty->termios_rwsem);
120}
121EXPORT_SYMBOL(tty_unthrottle);
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136int tty_throttle_safe(struct tty_struct *tty)
137{
138 int ret = 0;
139
140 mutex_lock(&tty->throttle_mutex);
141 if (!tty_throttled(tty)) {
142 if (tty->flow_change != TTY_THROTTLE_SAFE)
143 ret = 1;
144 else {
145 set_bit(TTY_THROTTLED, &tty->flags);
146 if (tty->ops->throttle)
147 tty->ops->throttle(tty);
148 }
149 }
150 mutex_unlock(&tty->throttle_mutex);
151
152 return ret;
153}
154
155
156
157
158
159
160
161
162
163
164
165
166
167int tty_unthrottle_safe(struct tty_struct *tty)
168{
169 int ret = 0;
170
171 mutex_lock(&tty->throttle_mutex);
172 if (tty_throttled(tty)) {
173 if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
174 ret = 1;
175 else {
176 clear_bit(TTY_THROTTLED, &tty->flags);
177 if (tty->ops->unthrottle)
178 tty->ops->unthrottle(tty);
179 }
180 }
181 mutex_unlock(&tty->throttle_mutex);
182
183 return ret;
184}
185
186
187
188
189
190
191
192
193
194
195
196
197void tty_wait_until_sent(struct tty_struct *tty, long timeout)
198{
199 tty_debug_wait_until_sent(tty, "wait until sent, timeout=%ld\n", timeout);
200
201 if (!timeout)
202 timeout = MAX_SCHEDULE_TIMEOUT;
203
204 timeout = wait_event_interruptible_timeout(tty->write_wait,
205 !tty_chars_in_buffer(tty), timeout);
206 if (timeout <= 0)
207 return;
208
209 if (timeout == MAX_SCHEDULE_TIMEOUT)
210 timeout = 0;
211
212 if (tty->ops->wait_until_sent)
213 tty->ops->wait_until_sent(tty, timeout);
214}
215EXPORT_SYMBOL(tty_wait_until_sent);
216
217
218
219
220
221
222static void unset_locked_termios(struct tty_struct *tty, struct ktermios *old)
223{
224 struct ktermios *termios = &tty->termios;
225 struct ktermios *locked = &tty->termios_locked;
226 int i;
227
228#define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
229
230 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
231 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
232 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
233 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
234 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
235 for (i = 0; i < NCCS; i++)
236 termios->c_cc[i] = locked->c_cc[i] ?
237 old->c_cc[i] : termios->c_cc[i];
238
239}
240
241
242
243
244
245
246
247
248
249
250
251
252void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
253{
254
255
256 new->c_cflag &= HUPCL | CREAD | CLOCAL;
257 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
258 new->c_ispeed = old->c_ispeed;
259 new->c_ospeed = old->c_ospeed;
260}
261EXPORT_SYMBOL(tty_termios_copy_hw);
262
263
264
265
266
267
268
269
270
271
272int tty_termios_hw_change(const struct ktermios *a, const struct ktermios *b)
273{
274 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
275 return 1;
276 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
277 return 1;
278 return 0;
279}
280EXPORT_SYMBOL(tty_termios_hw_change);
281
282
283
284
285
286
287
288
289unsigned char tty_get_char_size(unsigned int cflag)
290{
291 switch (cflag & CSIZE) {
292 case CS5:
293 return 5;
294 case CS6:
295 return 6;
296 case CS7:
297 return 7;
298 case CS8:
299 default:
300 return 8;
301 }
302}
303EXPORT_SYMBOL_GPL(tty_get_char_size);
304
305
306
307
308
309
310
311
312
313
314unsigned char tty_get_frame_size(unsigned int cflag)
315{
316 unsigned char bits = 2 + tty_get_char_size(cflag);
317
318 if (cflag & CSTOPB)
319 bits++;
320 if (cflag & PARENB)
321 bits++;
322
323 return bits;
324}
325EXPORT_SYMBOL_GPL(tty_get_frame_size);
326
327
328
329
330
331
332
333
334
335
336
337
338int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
339{
340 struct ktermios old_termios;
341 struct tty_ldisc *ld;
342
343 WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
344 tty->driver->subtype == PTY_TYPE_MASTER);
345
346
347
348
349
350
351
352 down_write(&tty->termios_rwsem);
353 old_termios = tty->termios;
354 tty->termios = *new_termios;
355 unset_locked_termios(tty, &old_termios);
356
357 if (tty->ops->set_termios)
358 tty->ops->set_termios(tty, &old_termios);
359 else
360 tty_termios_copy_hw(&tty->termios, &old_termios);
361
362 ld = tty_ldisc_ref(tty);
363 if (ld != NULL) {
364 if (ld->ops->set_termios)
365 ld->ops->set_termios(tty, &old_termios);
366 tty_ldisc_deref(ld);
367 }
368 up_write(&tty->termios_rwsem);
369 return 0;
370}
371EXPORT_SYMBOL_GPL(tty_set_termios);
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
387{
388 struct ktermios tmp_termios;
389 struct tty_ldisc *ld;
390 int retval = tty_check_change(tty);
391
392 if (retval)
393 return retval;
394
395 down_read(&tty->termios_rwsem);
396 tmp_termios = tty->termios;
397 up_read(&tty->termios_rwsem);
398
399 if (opt & TERMIOS_TERMIO) {
400 if (user_termio_to_kernel_termios(&tmp_termios,
401 (struct termio __user *)arg))
402 return -EFAULT;
403#ifdef TCGETS2
404 } else if (opt & TERMIOS_OLD) {
405 if (user_termios_to_kernel_termios_1(&tmp_termios,
406 (struct termios __user *)arg))
407 return -EFAULT;
408 } else {
409 if (user_termios_to_kernel_termios(&tmp_termios,
410 (struct termios2 __user *)arg))
411 return -EFAULT;
412 }
413#else
414 } else if (user_termios_to_kernel_termios(&tmp_termios,
415 (struct termios __user *)arg))
416 return -EFAULT;
417#endif
418
419
420
421 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
422 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
423
424 ld = tty_ldisc_ref(tty);
425
426 if (ld != NULL) {
427 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
428 ld->ops->flush_buffer(tty);
429 tty_ldisc_deref(ld);
430 }
431
432 if (opt & TERMIOS_WAIT) {
433 tty_wait_until_sent(tty, 0);
434 if (signal_pending(current))
435 return -ERESTARTSYS;
436 }
437
438 tty_set_termios(tty, &tmp_termios);
439
440
441
442
443
444 return 0;
445}
446
447static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
448{
449 down_read(&tty->termios_rwsem);
450 *kterm = tty->termios;
451 up_read(&tty->termios_rwsem);
452}
453
454static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
455{
456 down_read(&tty->termios_rwsem);
457 *kterm = tty->termios_locked;
458 up_read(&tty->termios_rwsem);
459}
460
461static int get_termio(struct tty_struct *tty, struct termio __user *termio)
462{
463 struct ktermios kterm;
464 copy_termios(tty, &kterm);
465 if (kernel_termios_to_user_termio(termio, &kterm))
466 return -EFAULT;
467 return 0;
468}
469
470#ifdef TIOCGETP
471
472
473
474
475
476static int get_sgflags(struct tty_struct *tty)
477{
478 int flags = 0;
479
480 if (!L_ICANON(tty)) {
481 if (L_ISIG(tty))
482 flags |= 0x02;
483 else
484 flags |= 0x20;
485 }
486 if (L_ECHO(tty))
487 flags |= 0x08;
488 if (O_OPOST(tty))
489 if (O_ONLCR(tty))
490 flags |= 0x10;
491 return flags;
492}
493
494static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
495{
496 struct sgttyb tmp;
497
498 down_read(&tty->termios_rwsem);
499 tmp.sg_ispeed = tty->termios.c_ispeed;
500 tmp.sg_ospeed = tty->termios.c_ospeed;
501 tmp.sg_erase = tty->termios.c_cc[VERASE];
502 tmp.sg_kill = tty->termios.c_cc[VKILL];
503 tmp.sg_flags = get_sgflags(tty);
504 up_read(&tty->termios_rwsem);
505
506 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
507}
508
509static void set_sgflags(struct ktermios *termios, int flags)
510{
511 termios->c_iflag = ICRNL | IXON;
512 termios->c_oflag = 0;
513 termios->c_lflag = ISIG | ICANON;
514 if (flags & 0x02) {
515 termios->c_iflag = 0;
516 termios->c_lflag &= ~ICANON;
517 }
518 if (flags & 0x08) {
519 termios->c_lflag |= ECHO | ECHOE | ECHOK |
520 ECHOCTL | ECHOKE | IEXTEN;
521 }
522 if (flags & 0x10) {
523 termios->c_oflag |= OPOST | ONLCR;
524 }
525 if (flags & 0x20) {
526 termios->c_iflag = 0;
527 termios->c_lflag &= ~(ISIG | ICANON);
528 }
529 if (!(termios->c_lflag & ICANON)) {
530 termios->c_cc[VMIN] = 1;
531 termios->c_cc[VTIME] = 0;
532 }
533}
534
535
536
537
538
539
540
541
542
543
544
545
546static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
547{
548 int retval;
549 struct sgttyb tmp;
550 struct ktermios termios;
551
552 retval = tty_check_change(tty);
553 if (retval)
554 return retval;
555
556 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
557 return -EFAULT;
558
559 down_write(&tty->termios_rwsem);
560 termios = tty->termios;
561 termios.c_cc[VERASE] = tmp.sg_erase;
562 termios.c_cc[VKILL] = tmp.sg_kill;
563 set_sgflags(&termios, tmp.sg_flags);
564
565#ifdef BOTHER
566 tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
567 termios.c_ospeed);
568#endif
569 up_write(&tty->termios_rwsem);
570 tty_set_termios(tty, &termios);
571 return 0;
572}
573#endif
574
575#ifdef TIOCGETC
576static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
577{
578 struct tchars tmp;
579
580 down_read(&tty->termios_rwsem);
581 tmp.t_intrc = tty->termios.c_cc[VINTR];
582 tmp.t_quitc = tty->termios.c_cc[VQUIT];
583 tmp.t_startc = tty->termios.c_cc[VSTART];
584 tmp.t_stopc = tty->termios.c_cc[VSTOP];
585 tmp.t_eofc = tty->termios.c_cc[VEOF];
586 tmp.t_brkc = tty->termios.c_cc[VEOL2];
587 up_read(&tty->termios_rwsem);
588 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
589}
590
591static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
592{
593 struct tchars tmp;
594
595 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
596 return -EFAULT;
597 down_write(&tty->termios_rwsem);
598 tty->termios.c_cc[VINTR] = tmp.t_intrc;
599 tty->termios.c_cc[VQUIT] = tmp.t_quitc;
600 tty->termios.c_cc[VSTART] = tmp.t_startc;
601 tty->termios.c_cc[VSTOP] = tmp.t_stopc;
602 tty->termios.c_cc[VEOF] = tmp.t_eofc;
603 tty->termios.c_cc[VEOL2] = tmp.t_brkc;
604 up_write(&tty->termios_rwsem);
605 return 0;
606}
607#endif
608
609#ifdef TIOCGLTC
610static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
611{
612 struct ltchars tmp;
613
614 down_read(&tty->termios_rwsem);
615 tmp.t_suspc = tty->termios.c_cc[VSUSP];
616
617 tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
618 tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
619
620 tmp.t_flushc = tty->termios.c_cc[VEOL2];
621 tmp.t_werasc = tty->termios.c_cc[VWERASE];
622 tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
623 up_read(&tty->termios_rwsem);
624 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
625}
626
627static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
628{
629 struct ltchars tmp;
630
631 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
632 return -EFAULT;
633
634 down_write(&tty->termios_rwsem);
635 tty->termios.c_cc[VSUSP] = tmp.t_suspc;
636
637 tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
638 tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
639
640 tty->termios.c_cc[VEOL2] = tmp.t_flushc;
641 tty->termios.c_cc[VWERASE] = tmp.t_werasc;
642 tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
643 up_write(&tty->termios_rwsem);
644 return 0;
645}
646#endif
647
648
649
650
651
652
653
654
655
656
657static int tty_change_softcar(struct tty_struct *tty, int arg)
658{
659 int ret = 0;
660 int bit = arg ? CLOCAL : 0;
661 struct ktermios old;
662
663 down_write(&tty->termios_rwsem);
664 old = tty->termios;
665 tty->termios.c_cflag &= ~CLOCAL;
666 tty->termios.c_cflag |= bit;
667 if (tty->ops->set_termios)
668 tty->ops->set_termios(tty, &old);
669 if (C_CLOCAL(tty) != bit)
670 ret = -EINVAL;
671 up_write(&tty->termios_rwsem);
672 return ret;
673}
674
675
676
677
678
679
680
681
682
683
684
685
686
687int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
688 unsigned int cmd, unsigned long arg)
689{
690 struct tty_struct *real_tty;
691 void __user *p = (void __user *)arg;
692 int ret = 0;
693 struct ktermios kterm;
694
695 BUG_ON(file == NULL);
696
697 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
698 tty->driver->subtype == PTY_TYPE_MASTER)
699 real_tty = tty->link;
700 else
701 real_tty = tty;
702
703 switch (cmd) {
704#ifdef TIOCGETP
705 case TIOCGETP:
706 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
707 case TIOCSETP:
708 case TIOCSETN:
709 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
710#endif
711#ifdef TIOCGETC
712 case TIOCGETC:
713 return get_tchars(real_tty, p);
714 case TIOCSETC:
715 return set_tchars(real_tty, p);
716#endif
717#ifdef TIOCGLTC
718 case TIOCGLTC:
719 return get_ltchars(real_tty, p);
720 case TIOCSLTC:
721 return set_ltchars(real_tty, p);
722#endif
723 case TCSETSF:
724 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
725 case TCSETSW:
726 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
727 case TCSETS:
728 return set_termios(real_tty, p, TERMIOS_OLD);
729#ifndef TCGETS2
730 case TCGETS:
731 copy_termios(real_tty, &kterm);
732 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
733 ret = -EFAULT;
734 return ret;
735#else
736 case TCGETS:
737 copy_termios(real_tty, &kterm);
738 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
739 ret = -EFAULT;
740 return ret;
741 case TCGETS2:
742 copy_termios(real_tty, &kterm);
743 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
744 ret = -EFAULT;
745 return ret;
746 case TCSETSF2:
747 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
748 case TCSETSW2:
749 return set_termios(real_tty, p, TERMIOS_WAIT);
750 case TCSETS2:
751 return set_termios(real_tty, p, 0);
752#endif
753 case TCGETA:
754 return get_termio(real_tty, p);
755 case TCSETAF:
756 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
757 case TCSETAW:
758 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
759 case TCSETA:
760 return set_termios(real_tty, p, TERMIOS_TERMIO);
761#ifndef TCGETS2
762 case TIOCGLCKTRMIOS:
763 copy_termios_locked(real_tty, &kterm);
764 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
765 ret = -EFAULT;
766 return ret;
767 case TIOCSLCKTRMIOS:
768 if (!capable(CAP_SYS_ADMIN))
769 return -EPERM;
770 copy_termios_locked(real_tty, &kterm);
771 if (user_termios_to_kernel_termios(&kterm,
772 (struct termios __user *) arg))
773 return -EFAULT;
774 down_write(&real_tty->termios_rwsem);
775 real_tty->termios_locked = kterm;
776 up_write(&real_tty->termios_rwsem);
777 return 0;
778#else
779 case TIOCGLCKTRMIOS:
780 copy_termios_locked(real_tty, &kterm);
781 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
782 ret = -EFAULT;
783 return ret;
784 case TIOCSLCKTRMIOS:
785 if (!capable(CAP_SYS_ADMIN))
786 return -EPERM;
787 copy_termios_locked(real_tty, &kterm);
788 if (user_termios_to_kernel_termios_1(&kterm,
789 (struct termios __user *) arg))
790 return -EFAULT;
791 down_write(&real_tty->termios_rwsem);
792 real_tty->termios_locked = kterm;
793 up_write(&real_tty->termios_rwsem);
794 return ret;
795#endif
796#ifdef TCGETX
797 case TCGETX:
798 case TCSETX:
799 case TCSETXW:
800 case TCSETXF:
801 return -ENOTTY;
802#endif
803 case TIOCGSOFTCAR:
804 copy_termios(real_tty, &kterm);
805 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
806 (int __user *)arg);
807 return ret;
808 case TIOCSSOFTCAR:
809 if (get_user(arg, (unsigned int __user *) arg))
810 return -EFAULT;
811 return tty_change_softcar(real_tty, arg);
812 default:
813 return -ENOIOCTLCMD;
814 }
815}
816EXPORT_SYMBOL_GPL(tty_mode_ioctl);
817
818
819
820static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
821{
822 struct tty_ldisc *ld = tty->ldisc;
823
824 switch (arg) {
825 case TCIFLUSH:
826 if (ld && ld->ops->flush_buffer) {
827 ld->ops->flush_buffer(tty);
828 tty_unthrottle(tty);
829 }
830 break;
831 case TCIOFLUSH:
832 if (ld && ld->ops->flush_buffer) {
833 ld->ops->flush_buffer(tty);
834 tty_unthrottle(tty);
835 }
836 fallthrough;
837 case TCOFLUSH:
838 tty_driver_flush_buffer(tty);
839 break;
840 default:
841 return -EINVAL;
842 }
843 return 0;
844}
845
846int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
847{
848 struct tty_ldisc *ld;
849 int retval = tty_check_change(tty);
850 if (retval)
851 return retval;
852
853 ld = tty_ldisc_ref_wait(tty);
854 retval = __tty_perform_flush(tty, arg);
855 if (ld)
856 tty_ldisc_deref(ld);
857 return retval;
858}
859EXPORT_SYMBOL_GPL(tty_perform_flush);
860
861int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
862 unsigned int cmd, unsigned long arg)
863{
864 int retval;
865
866 switch (cmd) {
867 case TCXONC:
868 retval = tty_check_change(tty);
869 if (retval)
870 return retval;
871 switch (arg) {
872 case TCOOFF:
873 spin_lock_irq(&tty->flow.lock);
874 if (!tty->flow.tco_stopped) {
875 tty->flow.tco_stopped = true;
876 __stop_tty(tty);
877 }
878 spin_unlock_irq(&tty->flow.lock);
879 break;
880 case TCOON:
881 spin_lock_irq(&tty->flow.lock);
882 if (tty->flow.tco_stopped) {
883 tty->flow.tco_stopped = false;
884 __start_tty(tty);
885 }
886 spin_unlock_irq(&tty->flow.lock);
887 break;
888 case TCIOFF:
889 if (STOP_CHAR(tty) != __DISABLED_CHAR)
890 retval = tty_send_xchar(tty, STOP_CHAR(tty));
891 break;
892 case TCION:
893 if (START_CHAR(tty) != __DISABLED_CHAR)
894 retval = tty_send_xchar(tty, START_CHAR(tty));
895 break;
896 default:
897 return -EINVAL;
898 }
899 return retval;
900 case TCFLSH:
901 retval = tty_check_change(tty);
902 if (retval)
903 return retval;
904 return __tty_perform_flush(tty, arg);
905 default:
906
907 return tty_mode_ioctl(tty, file, cmd, arg);
908 }
909}
910EXPORT_SYMBOL(n_tty_ioctl_helper);
911