2 * linux/drivers/char/tty_ioctl.c
4 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
6 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
7 * which can be dynamically activated and de-activated by the line
8 * discipline handling modules (like SLIP).
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>
21 #include <linux/module.h>
22 #include <linux/bitops.h>
23 #include <linux/mutex.h>
24 #include <linux/smp_lock.h>
27 #include <asm/uaccess.h>
28 #include <asm/system.h>
30 #undef TTY_DEBUG_WAIT_UNTIL_SENT
35 * Internal flag options for termios setting behavior
37 #define TERMIOS_FLUSH 1
38 #define TERMIOS_WAIT 2
39 #define TERMIOS_TERMIO 4
44 * tty_wait_until_sent - wait for I/O to finish
45 * @tty: tty we are waiting for
46 * @timeout: how long we will wait
48 * Wait for characters pending in a tty driver to hit the wire, or
49 * for a timeout to occur (eg due to flow control)
54 void tty_wait_until_sent(struct tty_struct
*tty
, long timeout
)
56 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
59 printk(KERN_DEBUG
"%s wait until sent...\n", tty_name(tty
, buf
));
61 if (!tty
->driver
->chars_in_buffer
)
64 timeout
= MAX_SCHEDULE_TIMEOUT
;
66 if (wait_event_interruptible_timeout(tty
->write_wait
,
67 !tty
->driver
->chars_in_buffer(tty
), timeout
) >= 0) {
68 if (tty
->driver
->wait_until_sent
)
69 tty
->driver
->wait_until_sent(tty
, timeout
);
73 EXPORT_SYMBOL(tty_wait_until_sent
);
75 static void unset_locked_termios(struct ktermios
*termios
,
77 struct ktermios
*locked
)
81 #define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
84 printk(KERN_WARNING
"Warning?!? termios_locked is NULL.\n");
88 NOSET_MASK(termios
->c_iflag
, old
->c_iflag
, locked
->c_iflag
);
89 NOSET_MASK(termios
->c_oflag
, old
->c_oflag
, locked
->c_oflag
);
90 NOSET_MASK(termios
->c_cflag
, old
->c_cflag
, locked
->c_cflag
);
91 NOSET_MASK(termios
->c_lflag
, old
->c_lflag
, locked
->c_lflag
);
92 termios
->c_line
= locked
->c_line
? old
->c_line
: termios
->c_line
;
93 for (i
= 0; i
< NCCS
; i
++)
94 termios
->c_cc
[i
] = locked
->c_cc
[i
] ?
95 old
->c_cc
[i
] : termios
->c_cc
[i
];
96 /* FIXME: What should we do for i/ospeed */
100 * Routine which returns the baud rate of the tty
102 * Note that the baud_table needs to be kept in sync with the
103 * include/asm/termbits.h file.
105 static const speed_t baud_table
[] = {
106 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
107 9600, 19200, 38400, 57600, 115200, 230400, 460800,
109 76800, 153600, 307200, 614400, 921600
111 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
112 2500000, 3000000, 3500000, 4000000
117 static const tcflag_t baud_bits
[] = {
118 B0
, B50
, B75
, B110
, B134
, B150
, B200
, B300
, B600
,
119 B1200
, B1800
, B2400
, B4800
, B9600
, B19200
, B38400
,
120 B57600
, B115200
, B230400
, B460800
, B500000
, B576000
,
121 B921600
, B1000000
, B1152000
, B1500000
, B2000000
, B2500000
,
122 B3000000
, B3500000
, B4000000
125 static const tcflag_t baud_bits
[] = {
126 B0
, B50
, B75
, B110
, B134
, B150
, B200
, B300
, B600
,
127 B1200
, B1800
, B2400
, B4800
, B9600
, B19200
, B38400
,
128 B57600
, B115200
, B230400
, B460800
, B76800
, B153600
,
129 B307200
, B614400
, B921600
133 static int n_baud_table
= ARRAY_SIZE(baud_table
);
136 * tty_termios_baud_rate
137 * @termios: termios structure
139 * Convert termios baud rate data into a speed. This should be called
140 * with the termios lock held if this termios is a terminal termios
141 * structure. May change the termios data. Device drivers can call this
142 * function but should use ->c_[io]speed directly as they are updated.
147 speed_t
tty_termios_baud_rate(struct ktermios
*termios
)
151 cbaud
= termios
->c_cflag
& CBAUD
;
154 /* Magic token for arbitary speed via c_ispeed/c_ospeed */
156 return termios
->c_ospeed
;
158 if (cbaud
& CBAUDEX
) {
161 if (cbaud
< 1 || cbaud
+ 15 > n_baud_table
)
162 termios
->c_cflag
&= ~CBAUDEX
;
166 return baud_table
[cbaud
];
168 EXPORT_SYMBOL(tty_termios_baud_rate
);
171 * tty_termios_input_baud_rate
172 * @termios: termios structure
174 * Convert termios baud rate data into a speed. This should be called
175 * with the termios lock held if this termios is a terminal termios
176 * structure. May change the termios data. Device drivers can call this
177 * function but should use ->c_[io]speed directly as they are updated.
182 speed_t
tty_termios_input_baud_rate(struct ktermios
*termios
)
185 unsigned int cbaud
= (termios
->c_cflag
>> IBSHIFT
) & CBAUD
;
188 return tty_termios_baud_rate(termios
);
190 /* Magic token for arbitary speed via c_ispeed*/
192 return termios
->c_ispeed
;
194 if (cbaud
& CBAUDEX
) {
197 if (cbaud
< 1 || cbaud
+ 15 > n_baud_table
)
198 termios
->c_cflag
&= ~(CBAUDEX
<< IBSHIFT
);
202 return baud_table
[cbaud
];
204 return tty_termios_baud_rate(termios
);
207 EXPORT_SYMBOL(tty_termios_input_baud_rate
);
210 * tty_termios_encode_baud_rate
211 * @termios: ktermios structure holding user requested state
212 * @ispeed: input speed
213 * @ospeed: output speed
215 * Encode the speeds set into the passed termios structure. This is
216 * used as a library helper for drivers os that they can report back
217 * the actual speed selected when it differs from the speed requested
219 * For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
220 * we need to carefully set the bits when the user does not get the
221 * desired speed. We allow small margins and preserve as much of possible
222 * of the input intent to keep compatiblity.
224 * Locking: Caller should hold termios lock. This is already held
225 * when calling this function from the driver termios handler.
227 * The ifdefs deal with platforms whose owners have yet to update them
228 * and will all go away once this is done.
231 void tty_termios_encode_baud_rate(struct ktermios
*termios
,
232 speed_t ibaud
, speed_t obaud
)
235 int ifound
= -1, ofound
= -1;
236 int iclose
= ibaud
/50, oclose
= obaud
/50;
239 if (obaud
== 0) /* CD dropped */
240 ibaud
= 0; /* Clear ibaud to be sure */
242 termios
->c_ispeed
= ibaud
;
243 termios
->c_ospeed
= obaud
;
246 /* If the user asked for a precise weird speed give a precise weird
247 answer. If they asked for a Bfoo speed they many have problems
248 digesting non-exact replies so fuzz a bit */
250 if ((termios
->c_cflag
& CBAUD
) == BOTHER
)
252 if (((termios
->c_cflag
>> IBSHIFT
) & CBAUD
) == BOTHER
)
254 if ((termios
->c_cflag
>> IBSHIFT
) & CBAUD
)
255 ibinput
= 1; /* An input speed was specified */
257 termios
->c_cflag
&= ~CBAUD
;
260 * Our goal is to find a close match to the standard baud rate
261 * returned. Walk the baud rate table and if we get a very close
262 * match then report back the speed as a POSIX Bxxxx value by
267 if (obaud
- oclose
<= baud_table
[i
] &&
268 obaud
+ oclose
>= baud_table
[i
]) {
269 termios
->c_cflag
|= baud_bits
[i
];
272 if (ibaud
- iclose
<= baud_table
[i
] &&
273 ibaud
+ iclose
>= baud_table
[i
]) {
274 /* For the case input == output don't set IBAUD bits
275 if the user didn't do so */
276 if (ofound
== i
&& !ibinput
)
281 termios
->c_cflag
|= (baud_bits
[i
] << IBSHIFT
);
285 } while (++i
< n_baud_table
);
288 * If we found no match then use BOTHER if provided or warn
289 * the user their platform maintainer needs to wake up if not.
293 termios
->c_cflag
|= BOTHER
;
294 /* Set exact input bits only if the input and output differ or the
296 if (ifound
== -1 && (ibaud
!= obaud
|| ibinput
))
297 termios
->c_cflag
|= (BOTHER
<< IBSHIFT
);
299 if (ifound
== -1 || ofound
== -1) {
302 printk(KERN_WARNING
"tty: Unable to return correct "
303 "speed data as your architecture needs updating.\n");
307 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate
);
309 void tty_encode_baud_rate(struct tty_struct
*tty
, speed_t ibaud
, speed_t obaud
)
311 tty_termios_encode_baud_rate(tty
->termios
, ibaud
, obaud
);
313 EXPORT_SYMBOL_GPL(tty_encode_baud_rate
);
316 * tty_get_baud_rate - get tty bit rates
319 * Returns the baud rate as an integer for this terminal. The
320 * termios lock must be held by the caller and the terminal bit
321 * flags may be updated.
326 speed_t
tty_get_baud_rate(struct tty_struct
*tty
)
328 speed_t baud
= tty_termios_baud_rate(tty
->termios
);
330 if (baud
== 38400 && tty
->alt_speed
) {
332 printk(KERN_WARNING
"Use of setserial/setrocket to "
333 "set SPD_* flags is deprecated\n");
336 baud
= tty
->alt_speed
;
341 EXPORT_SYMBOL(tty_get_baud_rate
);
344 * tty_termios_copy_hw - copy hardware settings
348 * Propogate the hardware specific terminal setting bits from
349 * the old termios structure to the new one. This is used in cases
350 * where the hardware does not support reconfiguration or as a helper
351 * in some cases where only minimal reconfiguration is supported
354 void tty_termios_copy_hw(struct ktermios
*new, struct ktermios
*old
)
356 /* The bits a dumb device handles in software. Smart devices need
357 to always provide a set_termios method */
358 new->c_cflag
&= HUPCL
| CREAD
| CLOCAL
;
359 new->c_cflag
|= old
->c_cflag
& ~(HUPCL
| CREAD
| CLOCAL
);
360 new->c_ispeed
= old
->c_ispeed
;
361 new->c_ospeed
= old
->c_ospeed
;
363 EXPORT_SYMBOL(tty_termios_copy_hw
);
366 * tty_termios_hw_change - check for setting change
368 * @b: termios to compare
370 * Check if any of the bits that affect a dumb device have changed
371 * between the two termios structures, or a speed change is needed.
374 int tty_termios_hw_change(struct ktermios
*a
, struct ktermios
*b
)
376 if (a
->c_ispeed
!= b
->c_ispeed
|| a
->c_ospeed
!= b
->c_ospeed
)
378 if ((a
->c_cflag
^ b
->c_cflag
) & ~(HUPCL
| CREAD
| CLOCAL
))
382 EXPORT_SYMBOL(tty_termios_hw_change
);
385 * change_termios - update termios values
386 * @tty: tty to update
387 * @new_termios: desired new value
389 * Perform updates to the termios values set on this terminal. There
390 * is a bit of layering violation here with n_tty in terms of the
391 * internal knowledge of this function.
393 * Locking: termios_sem
396 static void change_termios(struct tty_struct
*tty
, struct ktermios
*new_termios
)
399 struct ktermios old_termios
;
400 struct tty_ldisc
*ld
;
404 * Perform the actual termios internal changes under lock.
408 /* FIXME: we need to decide on some locking/ordering semantics
409 for the set_termios notification eventually */
410 mutex_lock(&tty
->termios_mutex
);
411 old_termios
= *tty
->termios
;
412 *tty
->termios
= *new_termios
;
413 unset_locked_termios(tty
->termios
, &old_termios
, tty
->termios_locked
);
414 canon_change
= (old_termios
.c_lflag
^ tty
->termios
->c_lflag
) & ICANON
;
416 memset(&tty
->read_flags
, 0, sizeof tty
->read_flags
);
417 tty
->canon_head
= tty
->read_tail
;
422 /* This bit should be in the ldisc code */
423 if (canon_change
&& !L_ICANON(tty
) && tty
->read_cnt
)
424 /* Get characters left over from canonical mode. */
425 wake_up_interruptible(&tty
->read_wait
);
427 /* See if packet mode change of state. */
428 if (tty
->link
&& tty
->link
->packet
) {
429 int old_flow
= ((old_termios
.c_iflag
& IXON
) &&
430 (old_termios
.c_cc
[VSTOP
] == '\023') &&
431 (old_termios
.c_cc
[VSTART
] == '\021'));
432 int new_flow
= (I_IXON(tty
) &&
433 STOP_CHAR(tty
) == '\023' &&
434 START_CHAR(tty
) == '\021');
435 if (old_flow
!= new_flow
) {
436 spin_lock_irqsave(&tty
->ctrl_lock
, flags
);
437 tty
->ctrl_status
&= ~(TIOCPKT_DOSTOP
| TIOCPKT_NOSTOP
);
439 tty
->ctrl_status
|= TIOCPKT_DOSTOP
;
441 tty
->ctrl_status
|= TIOCPKT_NOSTOP
;
442 spin_unlock_irqrestore(&tty
->ctrl_lock
, flags
);
443 wake_up_interruptible(&tty
->link
->read_wait
);
447 if (tty
->driver
->set_termios
)
448 (*tty
->driver
->set_termios
)(tty
, &old_termios
);
450 tty_termios_copy_hw(tty
->termios
, &old_termios
);
452 ld
= tty_ldisc_ref(tty
);
455 (ld
->set_termios
)(tty
, &old_termios
);
458 mutex_unlock(&tty
->termios_mutex
);
462 * set_termios - set termios values for a tty
463 * @tty: terminal device
465 * @opt: option information
467 * Helper function to prepare termios data and run necessary other
468 * functions before using change_termios to do the actual changes.
471 * Called functions take ldisc and termios_sem locks
474 static int set_termios(struct tty_struct
*tty
, void __user
*arg
, int opt
)
476 struct ktermios tmp_termios
;
477 struct tty_ldisc
*ld
;
478 int retval
= tty_check_change(tty
);
483 mutex_lock(&tty
->termios_mutex
);
484 memcpy(&tmp_termios
, tty
->termios
, sizeof(struct ktermios
));
485 mutex_unlock(&tty
->termios_mutex
);
487 if (opt
& TERMIOS_TERMIO
) {
488 if (user_termio_to_kernel_termios(&tmp_termios
,
489 (struct termio __user
*)arg
))
492 } else if (opt
& TERMIOS_OLD
) {
493 if (user_termios_to_kernel_termios_1(&tmp_termios
,
494 (struct termios __user
*)arg
))
497 if (user_termios_to_kernel_termios(&tmp_termios
,
498 (struct termios2 __user
*)arg
))
502 } else if (user_termios_to_kernel_termios(&tmp_termios
,
503 (struct termios __user
*)arg
))
507 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
508 * with the real speed so its unconditionally usable */
509 tmp_termios
.c_ispeed
= tty_termios_input_baud_rate(&tmp_termios
);
510 tmp_termios
.c_ospeed
= tty_termios_baud_rate(&tmp_termios
);
512 ld
= tty_ldisc_ref(tty
);
515 if ((opt
& TERMIOS_FLUSH
) && ld
->flush_buffer
)
516 ld
->flush_buffer(tty
);
520 if (opt
& TERMIOS_WAIT
) {
521 tty_wait_until_sent(tty
, 0);
522 if (signal_pending(current
))
526 change_termios(tty
, &tmp_termios
);
528 /* FIXME: Arguably if tmp_termios == tty->termios AND the
529 actual requested termios was not tmp_termios then we may
530 want to return an error as no user requested change has
535 static int get_termio(struct tty_struct
*tty
, struct termio __user
*termio
)
537 if (kernel_termios_to_user_termio(termio
, tty
->termios
))
542 static unsigned long inq_canon(struct tty_struct
*tty
)
546 if (!tty
->canon_data
|| !tty
->read_buf
)
548 head
= tty
->canon_head
;
549 tail
= tty
->read_tail
;
550 nr
= (head
- tail
) & (N_TTY_BUF_SIZE
-1);
551 /* Skip EOF-chars.. */
552 while (head
!= tail
) {
553 if (test_bit(tail
, tty
->read_flags
) &&
554 tty
->read_buf
[tail
] == __DISABLED_CHAR
)
556 tail
= (tail
+1) & (N_TTY_BUF_SIZE
-1);
563 * These are deprecated, but there is limited support..
565 * The "sg_flags" translation is a joke..
567 static int get_sgflags(struct tty_struct
*tty
)
571 if (!(tty
->termios
->c_lflag
& ICANON
)) {
572 if (tty
->termios
->c_lflag
& ISIG
)
573 flags
|= 0x02; /* cbreak */
575 flags
|= 0x20; /* raw */
577 if (tty
->termios
->c_lflag
& ECHO
)
578 flags
|= 0x08; /* echo */
579 if (tty
->termios
->c_oflag
& OPOST
)
580 if (tty
->termios
->c_oflag
& ONLCR
)
581 flags
|= 0x10; /* crmod */
585 static int get_sgttyb(struct tty_struct
*tty
, struct sgttyb __user
*sgttyb
)
589 mutex_lock(&tty
->termios_mutex
);
590 tmp
.sg_ispeed
= tty
->termios
->c_ispeed
;
591 tmp
.sg_ospeed
= tty
->termios
->c_ospeed
;
592 tmp
.sg_erase
= tty
->termios
->c_cc
[VERASE
];
593 tmp
.sg_kill
= tty
->termios
->c_cc
[VKILL
];
594 tmp
.sg_flags
= get_sgflags(tty
);
595 mutex_unlock(&tty
->termios_mutex
);
597 return copy_to_user(sgttyb
, &tmp
, sizeof(tmp
)) ? -EFAULT
: 0;
600 static void set_sgflags(struct ktermios
*termios
, int flags
)
602 termios
->c_iflag
= ICRNL
| IXON
;
603 termios
->c_oflag
= 0;
604 termios
->c_lflag
= ISIG
| ICANON
;
605 if (flags
& 0x02) { /* cbreak */
606 termios
->c_iflag
= 0;
607 termios
->c_lflag
&= ~ICANON
;
609 if (flags
& 0x08) { /* echo */
610 termios
->c_lflag
|= ECHO
| ECHOE
| ECHOK
|
611 ECHOCTL
| ECHOKE
| IEXTEN
;
613 if (flags
& 0x10) { /* crmod */
614 termios
->c_oflag
|= OPOST
| ONLCR
;
616 if (flags
& 0x20) { /* raw */
617 termios
->c_iflag
= 0;
618 termios
->c_lflag
&= ~(ISIG
| ICANON
);
620 if (!(termios
->c_lflag
& ICANON
)) {
621 termios
->c_cc
[VMIN
] = 1;
622 termios
->c_cc
[VTIME
] = 0;
627 * set_sgttyb - set legacy terminal values
628 * @tty: tty structure
629 * @sgttyb: pointer to old style terminal structure
631 * Updates a terminal from the legacy BSD style terminal information
634 * Locking: termios_sem
637 static int set_sgttyb(struct tty_struct
*tty
, struct sgttyb __user
*sgttyb
)
641 struct ktermios termios
;
643 retval
= tty_check_change(tty
);
647 if (copy_from_user(&tmp
, sgttyb
, sizeof(tmp
)))
650 mutex_lock(&tty
->termios_mutex
);
651 termios
= *tty
->termios
;
652 termios
.c_cc
[VERASE
] = tmp
.sg_erase
;
653 termios
.c_cc
[VKILL
] = tmp
.sg_kill
;
654 set_sgflags(&termios
, tmp
.sg_flags
);
655 /* Try and encode into Bfoo format */
657 tty_termios_encode_baud_rate(&termios
, termios
.c_ispeed
,
660 mutex_unlock(&tty
->termios_mutex
);
661 change_termios(tty
, &termios
);
667 static int get_tchars(struct tty_struct
*tty
, struct tchars __user
*tchars
)
671 mutex_lock(&tty
->termios_mutex
);
672 tmp
.t_intrc
= tty
->termios
->c_cc
[VINTR
];
673 tmp
.t_quitc
= tty
->termios
->c_cc
[VQUIT
];
674 tmp
.t_startc
= tty
->termios
->c_cc
[VSTART
];
675 tmp
.t_stopc
= tty
->termios
->c_cc
[VSTOP
];
676 tmp
.t_eofc
= tty
->termios
->c_cc
[VEOF
];
677 tmp
.t_brkc
= tty
->termios
->c_cc
[VEOL2
]; /* what is brkc anyway? */
678 mutex_unlock(&tty
->termios_mutex
);
679 return copy_to_user(tchars
, &tmp
, sizeof(tmp
)) ? -EFAULT
: 0;
682 static int set_tchars(struct tty_struct
*tty
, struct tchars __user
*tchars
)
686 if (copy_from_user(&tmp
, tchars
, sizeof(tmp
)))
688 mutex_lock(&tty
->termios_mutex
);
689 tty
->termios
->c_cc
[VINTR
] = tmp
.t_intrc
;
690 tty
->termios
->c_cc
[VQUIT
] = tmp
.t_quitc
;
691 tty
->termios
->c_cc
[VSTART
] = tmp
.t_startc
;
692 tty
->termios
->c_cc
[VSTOP
] = tmp
.t_stopc
;
693 tty
->termios
->c_cc
[VEOF
] = tmp
.t_eofc
;
694 tty
->termios
->c_cc
[VEOL2
] = tmp
.t_brkc
; /* what is brkc anyway? */
695 mutex_unlock(&tty
->termios_mutex
);
701 static int get_ltchars(struct tty_struct
*tty
, struct ltchars __user
*ltchars
)
705 mutex_lock(&tty
->termios_mutex
);
706 tmp
.t_suspc
= tty
->termios
->c_cc
[VSUSP
];
707 /* what is dsuspc anyway? */
708 tmp
.t_dsuspc
= tty
->termios
->c_cc
[VSUSP
];
709 tmp
.t_rprntc
= tty
->termios
->c_cc
[VREPRINT
];
710 /* what is flushc anyway? */
711 tmp
.t_flushc
= tty
->termios
->c_cc
[VEOL2
];
712 tmp
.t_werasc
= tty
->termios
->c_cc
[VWERASE
];
713 tmp
.t_lnextc
= tty
->termios
->c_cc
[VLNEXT
];
714 mutex_unlock(&tty
->termios_mutex
);
715 return copy_to_user(ltchars
, &tmp
, sizeof(tmp
)) ? -EFAULT
: 0;
718 static int set_ltchars(struct tty_struct
*tty
, struct ltchars __user
*ltchars
)
722 if (copy_from_user(&tmp
, ltchars
, sizeof(tmp
)))
725 mutex_lock(&tty
->termios_mutex
);
726 tty
->termios
->c_cc
[VSUSP
] = tmp
.t_suspc
;
727 /* what is dsuspc anyway? */
728 tty
->termios
->c_cc
[VEOL2
] = tmp
.t_dsuspc
;
729 tty
->termios
->c_cc
[VREPRINT
] = tmp
.t_rprntc
;
730 /* what is flushc anyway? */
731 tty
->termios
->c_cc
[VEOL2
] = tmp
.t_flushc
;
732 tty
->termios
->c_cc
[VWERASE
] = tmp
.t_werasc
;
733 tty
->termios
->c_cc
[VLNEXT
] = tmp
.t_lnextc
;
734 mutex_unlock(&tty
->termios_mutex
);
740 * send_prio_char - send priority character
742 * Send a high priority character to the tty even if stopped
744 * Locking: none for xchar method, write ordering for write method.
747 static int send_prio_char(struct tty_struct
*tty
, char ch
)
749 int was_stopped
= tty
->stopped
;
751 if (tty
->driver
->send_xchar
) {
752 tty
->driver
->send_xchar(tty
, ch
);
756 if (tty_write_lock(tty
, 0) < 0)
761 tty
->driver
->write(tty
, &ch
, 1);
764 tty_write_unlock(tty
);
769 * tty_change_softcar - carrier change ioctl helper
770 * @tty: tty to update
771 * @arg: enable/disable CLOCAL
773 * Perform a change to the CLOCAL state and call into the driver
774 * layer to make it visible. All done with the termios mutex
777 static int tty_change_softcar(struct tty_struct
*tty
, int arg
)
780 int bit
= arg
? CLOCAL
: 0;
781 struct ktermios old
= *tty
->termios
;
783 mutex_lock(&tty
->termios_mutex
);
784 tty
->termios
->c_cflag
&= ~CLOCAL
;
785 tty
->termios
->c_cflag
|= bit
;
786 if (tty
->driver
->set_termios
)
787 tty
->driver
->set_termios(tty
, &old
);
788 if ((tty
->termios
->c_cflag
& CLOCAL
) != bit
)
790 mutex_unlock(&tty
->termios_mutex
);
795 * tty_mode_ioctl - mode related ioctls
796 * @tty: tty for the ioctl
797 * @file: file pointer for the tty
799 * @arg: ioctl argument
801 * Perform non line discipline specific mode control ioctls. This
802 * is designed to be called by line disciplines to ensure they provide
803 * consistent mode setting.
806 int tty_mode_ioctl(struct tty_struct
*tty
, struct file
*file
,
807 unsigned int cmd
, unsigned long arg
)
809 struct tty_struct
*real_tty
;
810 void __user
*p
= (void __user
*)arg
;
812 if (tty
->driver
->type
== TTY_DRIVER_TYPE_PTY
&&
813 tty
->driver
->subtype
== PTY_TYPE_MASTER
)
814 real_tty
= tty
->link
;
821 return get_sgttyb(real_tty
, (struct sgttyb __user
*) arg
);
824 return set_sgttyb(real_tty
, (struct sgttyb __user
*) arg
);
828 return get_tchars(real_tty
, p
);
830 return set_tchars(real_tty
, p
);
834 return get_ltchars(real_tty
, p
);
836 return set_ltchars(real_tty
, p
);
839 return set_termios(real_tty
, p
, TERMIOS_FLUSH
| TERMIOS_WAIT
| TERMIOS_OLD
);
841 return set_termios(real_tty
, p
, TERMIOS_WAIT
| TERMIOS_OLD
);
843 return set_termios(real_tty
, p
, TERMIOS_OLD
);
846 if (kernel_termios_to_user_termios((struct termios __user
*)arg
, real_tty
->termios
))
851 if (kernel_termios_to_user_termios_1((struct termios __user
*)arg
, real_tty
->termios
))
855 if (kernel_termios_to_user_termios((struct termios2 __user
*)arg
, real_tty
->termios
))
859 return set_termios(real_tty
, p
, TERMIOS_FLUSH
| TERMIOS_WAIT
);
861 return set_termios(real_tty
, p
, TERMIOS_WAIT
);
863 return set_termios(real_tty
, p
, 0);
866 return get_termio(real_tty
, p
);
868 return set_termios(real_tty
, p
, TERMIOS_FLUSH
| TERMIOS_WAIT
| TERMIOS_TERMIO
);
870 return set_termios(real_tty
, p
, TERMIOS_WAIT
| TERMIOS_TERMIO
);
872 return set_termios(real_tty
, p
, TERMIOS_TERMIO
);
875 if (kernel_termios_to_user_termios((struct termios __user
*)arg
, real_tty
->termios_locked
))
879 if (!capable(CAP_SYS_ADMIN
))
881 if (user_termios_to_kernel_termios(real_tty
->termios_locked
,
882 (struct termios __user
*) arg
))
887 if (kernel_termios_to_user_termios_1((struct termios __user
*)arg
, real_tty
->termios_locked
))
891 if (!capable(CAP_SYS_ADMIN
))
893 if (user_termios_to_kernel_termios_1(real_tty
->termios_locked
,
894 (struct termios __user
*) arg
))
899 return put_user(C_CLOCAL(tty
) ? 1 : 0,
902 if (get_user(arg
, (unsigned int __user
*) arg
))
904 return tty_change_softcar(tty
, arg
);
909 EXPORT_SYMBOL_GPL(tty_mode_ioctl
);
911 int tty_perform_flush(struct tty_struct
*tty
, unsigned long arg
)
913 struct tty_ldisc
*ld
;
914 int retval
= tty_check_change(tty
);
918 ld
= tty_ldisc_ref(tty
);
921 if (ld
&& ld
->flush_buffer
)
922 ld
->flush_buffer(tty
);
925 if (ld
&& ld
->flush_buffer
)
926 ld
->flush_buffer(tty
);
929 if (tty
->driver
->flush_buffer
)
930 tty
->driver
->flush_buffer(tty
);
939 EXPORT_SYMBOL_GPL(tty_perform_flush
);
941 int n_tty_ioctl(struct tty_struct
*tty
, struct file
*file
,
942 unsigned int cmd
, unsigned long arg
)
944 struct tty_struct
*real_tty
;
948 if (tty
->driver
->type
== TTY_DRIVER_TYPE_PTY
&&
949 tty
->driver
->subtype
== PTY_TYPE_MASTER
)
950 real_tty
= tty
->link
;
956 retval
= tty_check_change(tty
);
961 if (!tty
->flow_stopped
) {
962 tty
->flow_stopped
= 1;
967 if (tty
->flow_stopped
) {
968 tty
->flow_stopped
= 0;
973 if (STOP_CHAR(tty
) != __DISABLED_CHAR
)
974 return send_prio_char(tty
, STOP_CHAR(tty
));
977 if (START_CHAR(tty
) != __DISABLED_CHAR
)
978 return send_prio_char(tty
, START_CHAR(tty
));
985 return tty_perform_flush(tty
, arg
);
987 return put_user(tty
->driver
->chars_in_buffer
?
988 tty
->driver
->chars_in_buffer(tty
) : 0,
991 retval
= tty
->read_cnt
;
993 retval
= inq_canon(tty
);
994 return put_user(retval
, (unsigned int __user
*) arg
);
999 if (tty
->driver
->type
!= TTY_DRIVER_TYPE_PTY
||
1000 tty
->driver
->subtype
!= PTY_TYPE_MASTER
)
1002 if (get_user(pktmode
, (int __user
*) arg
))
1004 spin_lock_irqsave(&tty
->ctrl_lock
, flags
);
1008 tty
->link
->ctrl_status
= 0;
1012 spin_unlock_irqrestore(&tty
->ctrl_lock
, flags
);
1016 /* Try the mode commands */
1017 return tty_mode_ioctl(tty
, file
, cmd
, arg
);
1020 EXPORT_SYMBOL(n_tty_ioctl
);