1
2
3
4
5
6
7
8
9
10
11#include <linux/types.h>
12#include <linux/termios.h>
13#include <linux/errno.h>
14#include <linux/sched.h>
15#include <linux/kernel.h>
16#include <linux/major.h>
17#include <linux/tty.h>
18#include <linux/fcntl.h>
19#include <linux/string.h>
20#include <linux/mm.h>
21#include <linux/module.h>
22#include <linux/bitops.h>
23#include <linux/mutex.h>
24
25#include <asm/io.h>
26#include <asm/uaccess.h>
27#include <asm/system.h>
28
29#undef TTY_DEBUG_WAIT_UNTIL_SENT
30
31#undef DEBUG
32
33
34
35
36#define TERMIOS_FLUSH 1
37#define TERMIOS_WAIT 2
38#define TERMIOS_TERMIO 4
39#define TERMIOS_OLD 8
40
41
42
43
44
45
46
47
48
49
50
51int tty_chars_in_buffer(struct tty_struct *tty)
52{
53 if (tty->ops->chars_in_buffer)
54 return tty->ops->chars_in_buffer(tty);
55 else
56 return 0;
57}
58EXPORT_SYMBOL(tty_chars_in_buffer);
59
60
61
62
63
64
65
66
67
68
69
70
71int tty_write_room(struct tty_struct *tty)
72{
73 if (tty->ops->write_room)
74 return tty->ops->write_room(tty);
75 return 2048;
76}
77EXPORT_SYMBOL(tty_write_room);
78
79
80
81
82
83
84
85
86
87void tty_driver_flush_buffer(struct tty_struct *tty)
88{
89 if (tty->ops->flush_buffer)
90 tty->ops->flush_buffer(tty);
91}
92EXPORT_SYMBOL(tty_driver_flush_buffer);
93
94
95
96
97
98
99
100
101
102
103
104void tty_throttle(struct tty_struct *tty)
105{
106 mutex_lock(&tty->termios_mutex);
107
108 if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
109 tty->ops->throttle)
110 tty->ops->throttle(tty);
111 mutex_unlock(&tty->termios_mutex);
112}
113EXPORT_SYMBOL(tty_throttle);
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128void tty_unthrottle(struct tty_struct *tty)
129{
130 mutex_lock(&tty->termios_mutex);
131 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
132 tty->ops->unthrottle)
133 tty->ops->unthrottle(tty);
134 mutex_unlock(&tty->termios_mutex);
135}
136EXPORT_SYMBOL(tty_unthrottle);
137
138
139
140
141
142
143
144
145
146
147
148
149void tty_wait_until_sent(struct tty_struct *tty, long timeout)
150{
151#ifdef TTY_DEBUG_WAIT_UNTIL_SENT
152 char buf[64];
153
154 printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
155#endif
156 if (!timeout)
157 timeout = MAX_SCHEDULE_TIMEOUT;
158 if (wait_event_interruptible_timeout(tty->write_wait,
159 !tty_chars_in_buffer(tty), timeout) >= 0) {
160 if (tty->ops->wait_until_sent)
161 tty->ops->wait_until_sent(tty, timeout);
162 }
163}
164EXPORT_SYMBOL(tty_wait_until_sent);
165
166
167
168
169
170
171static void unset_locked_termios(struct ktermios *termios,
172 struct ktermios *old,
173 struct ktermios *locked)
174{
175 int i;
176
177#define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
178
179 if (!locked) {
180 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
181 return;
182 }
183
184 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
185 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
186 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
187 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
188 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
189 for (i = 0; i < NCCS; i++)
190 termios->c_cc[i] = locked->c_cc[i] ?
191 old->c_cc[i] : termios->c_cc[i];
192
193}
194
195
196
197
198
199
200
201static const speed_t baud_table[] = {
202 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
203 9600, 19200, 38400, 57600, 115200, 230400, 460800,
204#ifdef __sparc__
205 76800, 153600, 307200, 614400, 921600
206#else
207 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
208 2500000, 3000000, 3500000, 4000000
209#endif
210};
211
212#ifndef __sparc__
213static const tcflag_t baud_bits[] = {
214 B0, B50, B75, B110, B134, B150, B200, B300, B600,
215 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
216 B57600, B115200, B230400, B460800, B500000, B576000,
217 B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
218 B3000000, B3500000, B4000000
219};
220#else
221static const tcflag_t baud_bits[] = {
222 B0, B50, B75, B110, B134, B150, B200, B300, B600,
223 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
224 B57600, B115200, B230400, B460800, B76800, B153600,
225 B307200, B614400, B921600
226};
227#endif
228
229static int n_baud_table = ARRAY_SIZE(baud_table);
230
231
232
233
234
235
236
237
238
239
240
241
242
243speed_t tty_termios_baud_rate(struct ktermios *termios)
244{
245 unsigned int cbaud;
246
247 cbaud = termios->c_cflag & CBAUD;
248
249#ifdef BOTHER
250
251 if (cbaud == BOTHER)
252 return termios->c_ospeed;
253#endif
254 if (cbaud & CBAUDEX) {
255 cbaud &= ~CBAUDEX;
256
257 if (cbaud < 1 || cbaud + 15 > n_baud_table)
258 termios->c_cflag &= ~CBAUDEX;
259 else
260 cbaud += 15;
261 }
262 return baud_table[cbaud];
263}
264EXPORT_SYMBOL(tty_termios_baud_rate);
265
266
267
268
269
270
271
272
273
274
275
276
277
278speed_t tty_termios_input_baud_rate(struct ktermios *termios)
279{
280#ifdef IBSHIFT
281 unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
282
283 if (cbaud == B0)
284 return tty_termios_baud_rate(termios);
285
286
287 if (cbaud == BOTHER)
288 return termios->c_ispeed;
289
290 if (cbaud & CBAUDEX) {
291 cbaud &= ~CBAUDEX;
292
293 if (cbaud < 1 || cbaud + 15 > n_baud_table)
294 termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
295 else
296 cbaud += 15;
297 }
298 return baud_table[cbaud];
299#else
300 return tty_termios_baud_rate(termios);
301#endif
302}
303EXPORT_SYMBOL(tty_termios_input_baud_rate);
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327void tty_termios_encode_baud_rate(struct ktermios *termios,
328 speed_t ibaud, speed_t obaud)
329{
330 int i = 0;
331 int ifound = -1, ofound = -1;
332 int iclose = ibaud/50, oclose = obaud/50;
333 int ibinput = 0;
334
335 if (obaud == 0)
336 ibaud = 0;
337
338 termios->c_ispeed = ibaud;
339 termios->c_ospeed = obaud;
340
341#ifdef BOTHER
342
343
344
345
346 if ((termios->c_cflag & CBAUD) == BOTHER)
347 oclose = 0;
348 if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
349 iclose = 0;
350 if ((termios->c_cflag >> IBSHIFT) & CBAUD)
351 ibinput = 1;
352#endif
353 termios->c_cflag &= ~CBAUD;
354
355
356
357
358
359
360
361
362 do {
363 if (obaud - oclose <= baud_table[i] &&
364 obaud + oclose >= baud_table[i]) {
365 termios->c_cflag |= baud_bits[i];
366 ofound = i;
367 }
368 if (ibaud - iclose <= baud_table[i] &&
369 ibaud + iclose >= baud_table[i]) {
370
371
372 if (ofound == i && !ibinput)
373 ifound = i;
374#ifdef IBSHIFT
375 else {
376 ifound = i;
377 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
378 }
379#endif
380 }
381 } while (++i < n_baud_table);
382
383
384
385
386
387#ifdef BOTHER
388 if (ofound == -1)
389 termios->c_cflag |= BOTHER;
390
391
392 if (ifound == -1 && (ibaud != obaud || ibinput))
393 termios->c_cflag |= (BOTHER << IBSHIFT);
394#else
395 if (ifound == -1 || ofound == -1) {
396 printk_once(KERN_WARNING "tty: Unable to return correct "
397 "speed data as your architecture needs updating.\n");
398 }
399#endif
400}
401EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
402
403
404
405
406
407
408
409
410
411
412
413void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
414{
415 tty_termios_encode_baud_rate(tty->termios, ibaud, obaud);
416}
417EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
418
419
420
421
422
423
424
425
426
427
428
429
430speed_t tty_get_baud_rate(struct tty_struct *tty)
431{
432 speed_t baud = tty_termios_baud_rate(tty->termios);
433
434 if (baud == 38400 && tty->alt_speed) {
435 if (!tty->warned) {
436 printk(KERN_WARNING "Use of setserial/setrocket to "
437 "set SPD_* flags is deprecated\n");
438 tty->warned = 1;
439 }
440 baud = tty->alt_speed;
441 }
442
443 return baud;
444}
445EXPORT_SYMBOL(tty_get_baud_rate);
446
447
448
449
450
451
452
453
454
455
456
457
458void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
459{
460
461
462 new->c_cflag &= HUPCL | CREAD | CLOCAL;
463 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
464 new->c_ispeed = old->c_ispeed;
465 new->c_ospeed = old->c_ospeed;
466}
467EXPORT_SYMBOL(tty_termios_copy_hw);
468
469
470
471
472
473
474
475
476
477
478int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
479{
480 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
481 return 1;
482 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
483 return 1;
484 return 0;
485}
486EXPORT_SYMBOL(tty_termios_hw_change);
487
488
489
490
491
492
493
494
495
496
497
498
499
500static void change_termios(struct tty_struct *tty, struct ktermios *new_termios)
501{
502 struct ktermios old_termios;
503 struct tty_ldisc *ld;
504 unsigned long flags;
505
506
507
508
509
510
511
512
513 mutex_lock(&tty->termios_mutex);
514 old_termios = *tty->termios;
515 *tty->termios = *new_termios;
516 unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
517
518
519 if (tty->link && tty->link->packet) {
520 int extproc = (old_termios.c_lflag & EXTPROC) |
521 (tty->termios->c_lflag & EXTPROC);
522 int old_flow = ((old_termios.c_iflag & IXON) &&
523 (old_termios.c_cc[VSTOP] == '\023') &&
524 (old_termios.c_cc[VSTART] == '\021'));
525 int new_flow = (I_IXON(tty) &&
526 STOP_CHAR(tty) == '\023' &&
527 START_CHAR(tty) == '\021');
528 if ((old_flow != new_flow) || extproc) {
529 spin_lock_irqsave(&tty->ctrl_lock, flags);
530 if (old_flow != new_flow) {
531 tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
532 if (new_flow)
533 tty->ctrl_status |= TIOCPKT_DOSTOP;
534 else
535 tty->ctrl_status |= TIOCPKT_NOSTOP;
536 }
537 if (extproc)
538 tty->ctrl_status |= TIOCPKT_IOCTL;
539 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
540 wake_up_interruptible(&tty->link->read_wait);
541 }
542 }
543
544 if (tty->ops->set_termios)
545 (*tty->ops->set_termios)(tty, &old_termios);
546 else
547 tty_termios_copy_hw(tty->termios, &old_termios);
548
549 ld = tty_ldisc_ref(tty);
550 if (ld != NULL) {
551 if (ld->ops->set_termios)
552 (ld->ops->set_termios)(tty, &old_termios);
553 tty_ldisc_deref(ld);
554 }
555 mutex_unlock(&tty->termios_mutex);
556}
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
572{
573 struct ktermios tmp_termios;
574 struct tty_ldisc *ld;
575 int retval = tty_check_change(tty);
576
577 if (retval)
578 return retval;
579
580 mutex_lock(&tty->termios_mutex);
581 memcpy(&tmp_termios, tty->termios, sizeof(struct ktermios));
582 mutex_unlock(&tty->termios_mutex);
583
584 if (opt & TERMIOS_TERMIO) {
585 if (user_termio_to_kernel_termios(&tmp_termios,
586 (struct termio __user *)arg))
587 return -EFAULT;
588#ifdef TCGETS2
589 } else if (opt & TERMIOS_OLD) {
590 if (user_termios_to_kernel_termios_1(&tmp_termios,
591 (struct termios __user *)arg))
592 return -EFAULT;
593 } else {
594 if (user_termios_to_kernel_termios(&tmp_termios,
595 (struct termios2 __user *)arg))
596 return -EFAULT;
597 }
598#else
599 } else if (user_termios_to_kernel_termios(&tmp_termios,
600 (struct termios __user *)arg))
601 return -EFAULT;
602#endif
603
604
605
606 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
607 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
608
609 ld = tty_ldisc_ref(tty);
610
611 if (ld != NULL) {
612 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
613 ld->ops->flush_buffer(tty);
614 tty_ldisc_deref(ld);
615 }
616
617 if (opt & TERMIOS_WAIT) {
618 tty_wait_until_sent(tty, 0);
619 if (signal_pending(current))
620 return -EINTR;
621 }
622
623 change_termios(tty, &tmp_termios);
624
625
626
627
628
629 return 0;
630}
631
632static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
633{
634 mutex_lock(&tty->termios_mutex);
635 memcpy(kterm, tty->termios, sizeof(struct ktermios));
636 mutex_unlock(&tty->termios_mutex);
637}
638
639static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
640{
641 mutex_lock(&tty->termios_mutex);
642 memcpy(kterm, tty->termios_locked, sizeof(struct ktermios));
643 mutex_unlock(&tty->termios_mutex);
644}
645
646static int get_termio(struct tty_struct *tty, struct termio __user *termio)
647{
648 struct ktermios kterm;
649 copy_termios(tty, &kterm);
650 if (kernel_termios_to_user_termio(termio, &kterm))
651 return -EFAULT;
652 return 0;
653}
654
655
656#ifdef TCGETX
657
658
659
660
661
662
663
664
665
666
667
668static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
669{
670 struct termiox tnew;
671 struct tty_ldisc *ld;
672
673 if (tty->termiox == NULL)
674 return -EINVAL;
675 if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
676 return -EFAULT;
677
678 ld = tty_ldisc_ref(tty);
679 if (ld != NULL) {
680 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
681 ld->ops->flush_buffer(tty);
682 tty_ldisc_deref(ld);
683 }
684 if (opt & TERMIOS_WAIT) {
685 tty_wait_until_sent(tty, 0);
686 if (signal_pending(current))
687 return -EINTR;
688 }
689
690 mutex_lock(&tty->termios_mutex);
691 if (tty->ops->set_termiox)
692 tty->ops->set_termiox(tty, &tnew);
693 mutex_unlock(&tty->termios_mutex);
694 return 0;
695}
696
697#endif
698
699
700#ifdef TIOCGETP
701
702
703
704
705
706static int get_sgflags(struct tty_struct *tty)
707{
708 int flags = 0;
709
710 if (!(tty->termios->c_lflag & ICANON)) {
711 if (tty->termios->c_lflag & ISIG)
712 flags |= 0x02;
713 else
714 flags |= 0x20;
715 }
716 if (tty->termios->c_lflag & ECHO)
717 flags |= 0x08;
718 if (tty->termios->c_oflag & OPOST)
719 if (tty->termios->c_oflag & ONLCR)
720 flags |= 0x10;
721 return flags;
722}
723
724static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
725{
726 struct sgttyb tmp;
727
728 mutex_lock(&tty->termios_mutex);
729 tmp.sg_ispeed = tty->termios->c_ispeed;
730 tmp.sg_ospeed = tty->termios->c_ospeed;
731 tmp.sg_erase = tty->termios->c_cc[VERASE];
732 tmp.sg_kill = tty->termios->c_cc[VKILL];
733 tmp.sg_flags = get_sgflags(tty);
734 mutex_unlock(&tty->termios_mutex);
735
736 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
737}
738
739static void set_sgflags(struct ktermios *termios, int flags)
740{
741 termios->c_iflag = ICRNL | IXON;
742 termios->c_oflag = 0;
743 termios->c_lflag = ISIG | ICANON;
744 if (flags & 0x02) {
745 termios->c_iflag = 0;
746 termios->c_lflag &= ~ICANON;
747 }
748 if (flags & 0x08) {
749 termios->c_lflag |= ECHO | ECHOE | ECHOK |
750 ECHOCTL | ECHOKE | IEXTEN;
751 }
752 if (flags & 0x10) {
753 termios->c_oflag |= OPOST | ONLCR;
754 }
755 if (flags & 0x20) {
756 termios->c_iflag = 0;
757 termios->c_lflag &= ~(ISIG | ICANON);
758 }
759 if (!(termios->c_lflag & ICANON)) {
760 termios->c_cc[VMIN] = 1;
761 termios->c_cc[VTIME] = 0;
762 }
763}
764
765
766
767
768
769
770
771
772
773
774
775
776static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
777{
778 int retval;
779 struct sgttyb tmp;
780 struct ktermios termios;
781
782 retval = tty_check_change(tty);
783 if (retval)
784 return retval;
785
786 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
787 return -EFAULT;
788
789 mutex_lock(&tty->termios_mutex);
790 termios = *tty->termios;
791 termios.c_cc[VERASE] = tmp.sg_erase;
792 termios.c_cc[VKILL] = tmp.sg_kill;
793 set_sgflags(&termios, tmp.sg_flags);
794
795#ifdef BOTHER
796 tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
797 termios.c_ospeed);
798#endif
799 mutex_unlock(&tty->termios_mutex);
800 change_termios(tty, &termios);
801 return 0;
802}
803#endif
804
805#ifdef TIOCGETC
806static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
807{
808 struct tchars tmp;
809
810 mutex_lock(&tty->termios_mutex);
811 tmp.t_intrc = tty->termios->c_cc[VINTR];
812 tmp.t_quitc = tty->termios->c_cc[VQUIT];
813 tmp.t_startc = tty->termios->c_cc[VSTART];
814 tmp.t_stopc = tty->termios->c_cc[VSTOP];
815 tmp.t_eofc = tty->termios->c_cc[VEOF];
816 tmp.t_brkc = tty->termios->c_cc[VEOL2];
817 mutex_unlock(&tty->termios_mutex);
818 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
819}
820
821static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
822{
823 struct tchars tmp;
824
825 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
826 return -EFAULT;
827 mutex_lock(&tty->termios_mutex);
828 tty->termios->c_cc[VINTR] = tmp.t_intrc;
829 tty->termios->c_cc[VQUIT] = tmp.t_quitc;
830 tty->termios->c_cc[VSTART] = tmp.t_startc;
831 tty->termios->c_cc[VSTOP] = tmp.t_stopc;
832 tty->termios->c_cc[VEOF] = tmp.t_eofc;
833 tty->termios->c_cc[VEOL2] = tmp.t_brkc;
834 mutex_unlock(&tty->termios_mutex);
835 return 0;
836}
837#endif
838
839#ifdef TIOCGLTC
840static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
841{
842 struct ltchars tmp;
843
844 mutex_lock(&tty->termios_mutex);
845 tmp.t_suspc = tty->termios->c_cc[VSUSP];
846
847 tmp.t_dsuspc = tty->termios->c_cc[VSUSP];
848 tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
849
850 tmp.t_flushc = tty->termios->c_cc[VEOL2];
851 tmp.t_werasc = tty->termios->c_cc[VWERASE];
852 tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
853 mutex_unlock(&tty->termios_mutex);
854 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
855}
856
857static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
858{
859 struct ltchars tmp;
860
861 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
862 return -EFAULT;
863
864 mutex_lock(&tty->termios_mutex);
865 tty->termios->c_cc[VSUSP] = tmp.t_suspc;
866
867 tty->termios->c_cc[VEOL2] = tmp.t_dsuspc;
868 tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
869
870 tty->termios->c_cc[VEOL2] = tmp.t_flushc;
871 tty->termios->c_cc[VWERASE] = tmp.t_werasc;
872 tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
873 mutex_unlock(&tty->termios_mutex);
874 return 0;
875}
876#endif
877
878
879
880
881
882
883
884
885
886static int send_prio_char(struct tty_struct *tty, char ch)
887{
888 int was_stopped = tty->stopped;
889
890 if (tty->ops->send_xchar) {
891 tty->ops->send_xchar(tty, ch);
892 return 0;
893 }
894
895 if (tty_write_lock(tty, 0) < 0)
896 return -ERESTARTSYS;
897
898 if (was_stopped)
899 start_tty(tty);
900 tty->ops->write(tty, &ch, 1);
901 if (was_stopped)
902 stop_tty(tty);
903 tty_write_unlock(tty);
904 return 0;
905}
906
907
908
909
910
911
912
913
914
915
916static int tty_change_softcar(struct tty_struct *tty, int arg)
917{
918 int ret = 0;
919 int bit = arg ? CLOCAL : 0;
920 struct ktermios old;
921
922 mutex_lock(&tty->termios_mutex);
923 old = *tty->termios;
924 tty->termios->c_cflag &= ~CLOCAL;
925 tty->termios->c_cflag |= bit;
926 if (tty->ops->set_termios)
927 tty->ops->set_termios(tty, &old);
928 if ((tty->termios->c_cflag & CLOCAL) != bit)
929 ret = -EINVAL;
930 mutex_unlock(&tty->termios_mutex);
931 return ret;
932}
933
934
935
936
937
938
939
940
941
942
943
944
945
946int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
947 unsigned int cmd, unsigned long arg)
948{
949 struct tty_struct *real_tty;
950 void __user *p = (void __user *)arg;
951 int ret = 0;
952 struct ktermios kterm;
953
954 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
955 tty->driver->subtype == PTY_TYPE_MASTER)
956 real_tty = tty->link;
957 else
958 real_tty = tty;
959
960 switch (cmd) {
961#ifdef TIOCGETP
962 case TIOCGETP:
963 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
964 case TIOCSETP:
965 case TIOCSETN:
966 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
967#endif
968#ifdef TIOCGETC
969 case TIOCGETC:
970 return get_tchars(real_tty, p);
971 case TIOCSETC:
972 return set_tchars(real_tty, p);
973#endif
974#ifdef TIOCGLTC
975 case TIOCGLTC:
976 return get_ltchars(real_tty, p);
977 case TIOCSLTC:
978 return set_ltchars(real_tty, p);
979#endif
980 case TCSETSF:
981 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
982 case TCSETSW:
983 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
984 case TCSETS:
985 return set_termios(real_tty, p, TERMIOS_OLD);
986#ifndef TCGETS2
987 case TCGETS:
988 copy_termios(real_tty, &kterm);
989 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
990 ret = -EFAULT;
991 return ret;
992#else
993 case TCGETS:
994 copy_termios(real_tty, &kterm);
995 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
996 ret = -EFAULT;
997 return ret;
998 case TCGETS2:
999 copy_termios(real_tty, &kterm);
1000 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
1001 ret = -EFAULT;
1002 return ret;
1003 case TCSETSF2:
1004 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
1005 case TCSETSW2:
1006 return set_termios(real_tty, p, TERMIOS_WAIT);
1007 case TCSETS2:
1008 return set_termios(real_tty, p, 0);
1009#endif
1010 case TCGETA:
1011 return get_termio(real_tty, p);
1012 case TCSETAF:
1013 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
1014 case TCSETAW:
1015 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
1016 case TCSETA:
1017 return set_termios(real_tty, p, TERMIOS_TERMIO);
1018#ifndef TCGETS2
1019 case TIOCGLCKTRMIOS:
1020 copy_termios_locked(real_tty, &kterm);
1021 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
1022 ret = -EFAULT;
1023 return ret;
1024 case TIOCSLCKTRMIOS:
1025 if (!capable(CAP_SYS_ADMIN))
1026 return -EPERM;
1027 copy_termios_locked(real_tty, &kterm);
1028 if (user_termios_to_kernel_termios(&kterm,
1029 (struct termios __user *) arg))
1030 return -EFAULT;
1031 mutex_lock(&real_tty->termios_mutex);
1032 memcpy(real_tty->termios_locked, &kterm, sizeof(struct ktermios));
1033 mutex_unlock(&real_tty->termios_mutex);
1034 return 0;
1035#else
1036 case TIOCGLCKTRMIOS:
1037 copy_termios_locked(real_tty, &kterm);
1038 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
1039 ret = -EFAULT;
1040 return ret;
1041 case TIOCSLCKTRMIOS:
1042 if (!capable(CAP_SYS_ADMIN))
1043 return -EPERM;
1044 copy_termios_locked(real_tty, &kterm);
1045 if (user_termios_to_kernel_termios_1(&kterm,
1046 (struct termios __user *) arg))
1047 return -EFAULT;
1048 mutex_lock(&real_tty->termios_mutex);
1049 memcpy(real_tty->termios_locked, &kterm, sizeof(struct ktermios));
1050 mutex_unlock(&real_tty->termios_mutex);
1051 return ret;
1052#endif
1053#ifdef TCGETX
1054 case TCGETX: {
1055 struct termiox ktermx;
1056 if (real_tty->termiox == NULL)
1057 return -EINVAL;
1058 mutex_lock(&real_tty->termios_mutex);
1059 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
1060 mutex_unlock(&real_tty->termios_mutex);
1061 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
1062 ret = -EFAULT;
1063 return ret;
1064 }
1065 case TCSETX:
1066 return set_termiox(real_tty, p, 0);
1067 case TCSETXW:
1068 return set_termiox(real_tty, p, TERMIOS_WAIT);
1069 case TCSETXF:
1070 return set_termiox(real_tty, p, TERMIOS_FLUSH);
1071#endif
1072 case TIOCGSOFTCAR:
1073 copy_termios(real_tty, &kterm);
1074 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
1075 (int __user *)arg);
1076 return ret;
1077 case TIOCSSOFTCAR:
1078 if (get_user(arg, (unsigned int __user *) arg))
1079 return -EFAULT;
1080 return tty_change_softcar(real_tty, arg);
1081 default:
1082 return -ENOIOCTLCMD;
1083 }
1084}
1085EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1086
1087int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1088{
1089 struct tty_ldisc *ld;
1090 int retval = tty_check_change(tty);
1091 if (retval)
1092 return retval;
1093
1094 ld = tty_ldisc_ref_wait(tty);
1095 switch (arg) {
1096 case TCIFLUSH:
1097 if (ld && ld->ops->flush_buffer)
1098 ld->ops->flush_buffer(tty);
1099 break;
1100 case TCIOFLUSH:
1101 if (ld && ld->ops->flush_buffer)
1102 ld->ops->flush_buffer(tty);
1103
1104 case TCOFLUSH:
1105 tty_driver_flush_buffer(tty);
1106 break;
1107 default:
1108 tty_ldisc_deref(ld);
1109 return -EINVAL;
1110 }
1111 tty_ldisc_deref(ld);
1112 return 0;
1113}
1114EXPORT_SYMBOL_GPL(tty_perform_flush);
1115
1116int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
1117 unsigned int cmd, unsigned long arg)
1118{
1119 unsigned long flags;
1120 int retval;
1121
1122 switch (cmd) {
1123 case TCXONC:
1124 retval = tty_check_change(tty);
1125 if (retval)
1126 return retval;
1127 switch (arg) {
1128 case TCOOFF:
1129 if (!tty->flow_stopped) {
1130 tty->flow_stopped = 1;
1131 stop_tty(tty);
1132 }
1133 break;
1134 case TCOON:
1135 if (tty->flow_stopped) {
1136 tty->flow_stopped = 0;
1137 start_tty(tty);
1138 }
1139 break;
1140 case TCIOFF:
1141 if (STOP_CHAR(tty) != __DISABLED_CHAR)
1142 return send_prio_char(tty, STOP_CHAR(tty));
1143 break;
1144 case TCION:
1145 if (START_CHAR(tty) != __DISABLED_CHAR)
1146 return send_prio_char(tty, START_CHAR(tty));
1147 break;
1148 default:
1149 return -EINVAL;
1150 }
1151 return 0;
1152 case TCFLSH:
1153 return tty_perform_flush(tty, arg);
1154 case TIOCPKT:
1155 {
1156 int pktmode;
1157
1158 if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
1159 tty->driver->subtype != PTY_TYPE_MASTER)
1160 return -ENOTTY;
1161 if (get_user(pktmode, (int __user *) arg))
1162 return -EFAULT;
1163 spin_lock_irqsave(&tty->ctrl_lock, flags);
1164 if (pktmode) {
1165 if (!tty->packet) {
1166 tty->packet = 1;
1167 tty->link->ctrl_status = 0;
1168 }
1169 } else
1170 tty->packet = 0;
1171 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
1172 return 0;
1173 }
1174 default:
1175
1176 return tty_mode_ioctl(tty, file, cmd, arg);
1177 }
1178}
1179EXPORT_SYMBOL(n_tty_ioctl_helper);
1180