2 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
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).
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>
19 #include <linux/module.h>
20 #include <linux/bitops.h>
21 #include <linux/mutex.h>
22 #include <linux/compat.h>
25 #include <asm/uaccess.h>
26 #include <asm/system.h>
28 #undef TTY_DEBUG_WAIT_UNTIL_SENT
33 * Internal flag options for termios setting behavior
35 #define TERMIOS_FLUSH 1
36 #define TERMIOS_WAIT 2
37 #define TERMIOS_TERMIO 4
42 * tty_chars_in_buffer - characters pending
45 * Return the number of bytes of data in the device private
46 * output queue. If no private method is supplied there is assumed
47 * to be no queue on the device.
50 int tty_chars_in_buffer(struct tty_struct *tty)
52 if (tty->ops->chars_in_buffer)
53 return tty->ops->chars_in_buffer(tty);
57 EXPORT_SYMBOL(tty_chars_in_buffer);
60 * tty_write_room - write queue space
63 * Return the number of bytes that can be queued to this device
64 * at the present time. The result should be treated as a guarantee
65 * and the driver cannot offer a value it later shrinks by more than
66 * the number of bytes written. If no method is provided 2K is always
67 * returned and data may be lost as there will be no flow control.
70 int tty_write_room(struct tty_struct *tty)
72 if (tty->ops->write_room)
73 return tty->ops->write_room(tty);
76 EXPORT_SYMBOL(tty_write_room);
79 * tty_driver_flush_buffer - discard internal buffer
82 * Discard the internal output buffer for this device. If no method
83 * is provided then either the buffer cannot be hardware flushed or
84 * there is no buffer driver side.
86 void tty_driver_flush_buffer(struct tty_struct *tty)
88 if (tty->ops->flush_buffer)
89 tty->ops->flush_buffer(tty);
91 EXPORT_SYMBOL(tty_driver_flush_buffer);
94 * tty_throttle - flow control
97 * Indicate that a tty should stop transmitting data down the stack.
98 * Takes the termios mutex to protect against parallel throttle/unthrottle
99 * and also to ensure the driver can consistently reference its own
100 * termios data at this point when implementing software flow control.
103 void tty_throttle(struct tty_struct *tty)
105 mutex_lock(&tty->termios_mutex);
106 /* check TTY_THROTTLED first so it indicates our state */
107 if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
109 tty->ops->throttle(tty);
110 mutex_unlock(&tty->termios_mutex);
112 EXPORT_SYMBOL(tty_throttle);
115 * tty_unthrottle - flow control
118 * Indicate that a tty may continue transmitting data down the stack.
119 * Takes the termios mutex to protect against parallel throttle/unthrottle
120 * and also to ensure the driver can consistently reference its own
121 * termios data at this point when implementing software flow control.
123 * Drivers should however remember that the stack can issue a throttle,
124 * then change flow control method, then unthrottle.
127 void tty_unthrottle(struct tty_struct *tty)
129 mutex_lock(&tty->termios_mutex);
130 if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
131 tty->ops->unthrottle)
132 tty->ops->unthrottle(tty);
133 mutex_unlock(&tty->termios_mutex);
135 EXPORT_SYMBOL(tty_unthrottle);
138 * tty_wait_until_sent - wait for I/O to finish
139 * @tty: tty we are waiting for
140 * @timeout: how long we will wait
142 * Wait for characters pending in a tty driver to hit the wire, or
143 * for a timeout to occur (eg due to flow control)
148 void tty_wait_until_sent(struct tty_struct *tty, long timeout)
150 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
153 printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
156 timeout = MAX_SCHEDULE_TIMEOUT;
158 if (wait_event_interruptible_timeout(tty->write_wait,
159 !tty_chars_in_buffer(tty), timeout) < 0) {
163 if (timeout == MAX_SCHEDULE_TIMEOUT)
166 if (tty->ops->wait_until_sent)
167 tty->ops->wait_until_sent(tty, timeout);
169 EXPORT_SYMBOL(tty_wait_until_sent);
173 * Termios Helper Methods
176 static void unset_locked_termios(struct ktermios *termios,
177 struct ktermios *old,
178 struct ktermios *locked)
182 #define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
185 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
189 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
190 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
191 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
192 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
193 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
194 for (i = 0; i < NCCS; i++)
195 termios->c_cc[i] = locked->c_cc[i] ?
196 old->c_cc[i] : termios->c_cc[i];
197 /* FIXME: What should we do for i/ospeed */
201 * Routine which returns the baud rate of the tty
203 * Note that the baud_table needs to be kept in sync with the
204 * include/asm/termbits.h file.
206 static const speed_t baud_table[] = {
207 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
208 9600, 19200, 38400, 57600, 115200, 230400, 460800,
210 76800, 153600, 307200, 614400, 921600
212 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
213 2500000, 3000000, 3500000, 4000000
218 static const tcflag_t baud_bits[] = {
219 B0, B50, B75, B110, B134, B150, B200, B300, B600,
220 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
221 B57600, B115200, B230400, B460800, B500000, B576000,
222 B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
223 B3000000, B3500000, B4000000
226 static const tcflag_t baud_bits[] = {
227 B0, B50, B75, B110, B134, B150, B200, B300, B600,
228 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
229 B57600, B115200, B230400, B460800, B76800, B153600,
230 B307200, B614400, B921600
234 static int n_baud_table = ARRAY_SIZE(baud_table);
237 * tty_termios_baud_rate
238 * @termios: termios structure
240 * Convert termios baud rate data into a speed. This should be called
241 * with the termios lock held if this termios is a terminal termios
242 * structure. May change the termios data. Device drivers can call this
243 * function but should use ->c_[io]speed directly as they are updated.
248 speed_t tty_termios_baud_rate(struct ktermios *termios)
252 cbaud = termios->c_cflag & CBAUD;
255 /* Magic token for arbitrary speed via c_ispeed/c_ospeed */
257 return termios->c_ospeed;
259 if (cbaud & CBAUDEX) {
262 if (cbaud < 1 || cbaud + 15 > n_baud_table)
263 termios->c_cflag &= ~CBAUDEX;
267 return baud_table[cbaud];
269 EXPORT_SYMBOL(tty_termios_baud_rate);
272 * tty_termios_input_baud_rate
273 * @termios: termios structure
275 * Convert termios baud rate data into a speed. This should be called
276 * with the termios lock held if this termios is a terminal termios
277 * structure. May change the termios data. Device drivers can call this
278 * function but should use ->c_[io]speed directly as they are updated.
283 speed_t tty_termios_input_baud_rate(struct ktermios *termios)
286 unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
289 return tty_termios_baud_rate(termios);
291 /* Magic token for arbitrary speed via c_ispeed*/
293 return termios->c_ispeed;
295 if (cbaud & CBAUDEX) {
298 if (cbaud < 1 || cbaud + 15 > n_baud_table)
299 termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
303 return baud_table[cbaud];
305 return tty_termios_baud_rate(termios);
308 EXPORT_SYMBOL(tty_termios_input_baud_rate);
311 * tty_termios_encode_baud_rate
312 * @termios: ktermios structure holding user requested state
313 * @ispeed: input speed
314 * @ospeed: output speed
316 * Encode the speeds set into the passed termios structure. This is
317 * used as a library helper for drivers so that they can report back
318 * the actual speed selected when it differs from the speed requested
320 * For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
321 * we need to carefully set the bits when the user does not get the
322 * desired speed. We allow small margins and preserve as much of possible
323 * of the input intent to keep compatibility.
325 * Locking: Caller should hold termios lock. This is already held
326 * when calling this function from the driver termios handler.
328 * The ifdefs deal with platforms whose owners have yet to update them
329 * and will all go away once this is done.
332 void tty_termios_encode_baud_rate(struct ktermios *termios,
333 speed_t ibaud, speed_t obaud)
336 int ifound = -1, ofound = -1;
337 int iclose = ibaud/50, oclose = obaud/50;
340 if (obaud == 0) /* CD dropped */
341 ibaud = 0; /* Clear ibaud to be sure */
343 termios->c_ispeed = ibaud;
344 termios->c_ospeed = obaud;
347 /* If the user asked for a precise weird speed give a precise weird
348 answer. If they asked for a Bfoo speed they many have problems
349 digesting non-exact replies so fuzz a bit */
351 if ((termios->c_cflag & CBAUD) == BOTHER)
353 if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
355 if ((termios->c_cflag >> IBSHIFT) & CBAUD)
356 ibinput = 1; /* An input speed was specified */
358 termios->c_cflag &= ~CBAUD;
361 * Our goal is to find a close match to the standard baud rate
362 * returned. Walk the baud rate table and if we get a very close
363 * match then report back the speed as a POSIX Bxxxx value by
368 if (obaud - oclose <= baud_table[i] &&
369 obaud + oclose >= baud_table[i]) {
370 termios->c_cflag |= baud_bits[i];
373 if (ibaud - iclose <= baud_table[i] &&
374 ibaud + iclose >= baud_table[i]) {
375 /* For the case input == output don't set IBAUD bits
376 if the user didn't do so */
377 if (ofound == i && !ibinput)
382 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
386 } while (++i < n_baud_table);
389 * If we found no match then use BOTHER if provided or warn
390 * the user their platform maintainer needs to wake up if not.
394 termios->c_cflag |= BOTHER;
395 /* Set exact input bits only if the input and output differ or the
397 if (ifound == -1 && (ibaud != obaud || ibinput))
398 termios->c_cflag |= (BOTHER << IBSHIFT);
400 if (ifound == -1 || ofound == -1) {
401 printk_once(KERN_WARNING "tty: Unable to return correct "
402 "speed data as your architecture needs updating.\n");
406 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
409 * tty_encode_baud_rate - set baud rate of the tty
410 * @ibaud: input baud rate
411 * @obad: output baud rate
413 * Update the current termios data for the tty with the new speed
414 * settings. The caller must hold the termios_mutex for the tty in
418 void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
420 tty_termios_encode_baud_rate(tty->termios, ibaud, obaud);
422 EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
425 * tty_get_baud_rate - get tty bit rates
428 * Returns the baud rate as an integer for this terminal. The
429 * termios lock must be held by the caller and the terminal bit
430 * flags may be updated.
435 speed_t tty_get_baud_rate(struct tty_struct *tty)
437 speed_t baud = tty_termios_baud_rate(tty->termios);
439 if (baud == 38400 && tty->alt_speed) {
441 printk(KERN_WARNING "Use of setserial/setrocket to "
442 "set SPD_* flags is deprecated\n");
445 baud = tty->alt_speed;
450 EXPORT_SYMBOL(tty_get_baud_rate);
453 * tty_termios_copy_hw - copy hardware settings
457 * Propagate the hardware specific terminal setting bits from
458 * the old termios structure to the new one. This is used in cases
459 * where the hardware does not support reconfiguration or as a helper
460 * in some cases where only minimal reconfiguration is supported
463 void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
465 /* The bits a dumb device handles in software. Smart devices need
466 to always provide a set_termios method */
467 new->c_cflag &= HUPCL | CREAD | CLOCAL;
468 new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
469 new->c_ispeed = old->c_ispeed;
470 new->c_ospeed = old->c_ospeed;
472 EXPORT_SYMBOL(tty_termios_copy_hw);
475 * tty_termios_hw_change - check for setting change
477 * @b: termios to compare
479 * Check if any of the bits that affect a dumb device have changed
480 * between the two termios structures, or a speed change is needed.
483 int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
485 if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
487 if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
491 EXPORT_SYMBOL(tty_termios_hw_change);
494 * tty_set_termios - update termios values
495 * @tty: tty to update
496 * @new_termios: desired new value
498 * Perform updates to the termios values set on this terminal. There
499 * is a bit of layering violation here with n_tty in terms of the
500 * internal knowledge of this function.
502 * Locking: termios_mutex
505 int tty_set_termios(struct tty_struct *tty, struct ktermios *new_termios)
507 struct ktermios old_termios;
508 struct tty_ldisc *ld;
512 * Perform the actual termios internal changes under lock.
516 /* FIXME: we need to decide on some locking/ordering semantics
517 for the set_termios notification eventually */
518 mutex_lock(&tty->termios_mutex);
519 old_termios = *tty->termios;
520 *tty->termios = *new_termios;
521 unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
523 /* See if packet mode change of state. */
524 if (tty->link && tty->link->packet) {
525 int extproc = (old_termios.c_lflag & EXTPROC) |
526 (tty->termios->c_lflag & EXTPROC);
527 int old_flow = ((old_termios.c_iflag & IXON) &&
528 (old_termios.c_cc[VSTOP] == '\023') &&
529 (old_termios.c_cc[VSTART] == '\021'));
530 int new_flow = (I_IXON(tty) &&
531 STOP_CHAR(tty) == '\023' &&
532 START_CHAR(tty) == '\021');
533 if ((old_flow != new_flow) || extproc) {
534 spin_lock_irqsave(&tty->ctrl_lock, flags);
535 if (old_flow != new_flow) {
536 tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
538 tty->ctrl_status |= TIOCPKT_DOSTOP;
540 tty->ctrl_status |= TIOCPKT_NOSTOP;
543 tty->ctrl_status |= TIOCPKT_IOCTL;
544 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
545 wake_up_interruptible(&tty->link->read_wait);
549 if (tty->ops->set_termios)
550 (*tty->ops->set_termios)(tty, &old_termios);
552 tty_termios_copy_hw(tty->termios, &old_termios);
554 ld = tty_ldisc_ref(tty);
556 if (ld->ops->set_termios)
557 (ld->ops->set_termios)(tty, &old_termios);
560 mutex_unlock(&tty->termios_mutex);
563 EXPORT_SYMBOL_GPL(tty_set_termios);
566 * set_termios - set termios values for a tty
567 * @tty: terminal device
569 * @opt: option information
571 * Helper function to prepare termios data and run necessary other
572 * functions before using tty_set_termios to do the actual changes.
575 * Called functions take ldisc and termios_mutex locks
578 static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
580 struct ktermios tmp_termios;
581 struct tty_ldisc *ld;
582 int retval = tty_check_change(tty);
587 mutex_lock(&tty->termios_mutex);
588 memcpy(&tmp_termios, tty->termios, sizeof(struct ktermios));
589 mutex_unlock(&tty->termios_mutex);
591 if (opt & TERMIOS_TERMIO) {
592 if (user_termio_to_kernel_termios(&tmp_termios,
593 (struct termio __user *)arg))
596 } else if (opt & TERMIOS_OLD) {
597 if (user_termios_to_kernel_termios_1(&tmp_termios,
598 (struct termios __user *)arg))
601 if (user_termios_to_kernel_termios(&tmp_termios,
602 (struct termios2 __user *)arg))
606 } else if (user_termios_to_kernel_termios(&tmp_termios,
607 (struct termios __user *)arg))
611 /* If old style Bfoo values are used then load c_ispeed/c_ospeed
612 * with the real speed so its unconditionally usable */
613 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
614 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
616 ld = tty_ldisc_ref(tty);
619 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
620 ld->ops->flush_buffer(tty);
624 if (opt & TERMIOS_WAIT) {
625 tty_wait_until_sent(tty, 0);
626 if (signal_pending(current))
630 tty_set_termios(tty, &tmp_termios);
632 /* FIXME: Arguably if tmp_termios == tty->termios AND the
633 actual requested termios was not tmp_termios then we may
634 want to return an error as no user requested change has
639 static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
641 mutex_lock(&tty->termios_mutex);
642 memcpy(kterm, tty->termios, sizeof(struct ktermios));
643 mutex_unlock(&tty->termios_mutex);
646 static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
648 mutex_lock(&tty->termios_mutex);
649 memcpy(kterm, tty->termios_locked, sizeof(struct ktermios));
650 mutex_unlock(&tty->termios_mutex);
653 static int get_termio(struct tty_struct *tty, struct termio __user *termio)
655 struct ktermios kterm;
656 copy_termios(tty, &kterm);
657 if (kernel_termios_to_user_termio(termio, &kterm))
666 * set_termiox - set termiox fields if possible
668 * @arg: termiox structure from user
669 * @opt: option flags for ioctl type
671 * Implement the device calling points for the SYS5 termiox ioctl
675 static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
678 struct tty_ldisc *ld;
680 if (tty->termiox == NULL)
682 if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
685 ld = tty_ldisc_ref(tty);
687 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
688 ld->ops->flush_buffer(tty);
691 if (opt & TERMIOS_WAIT) {
692 tty_wait_until_sent(tty, 0);
693 if (signal_pending(current))
697 mutex_lock(&tty->termios_mutex);
698 if (tty->ops->set_termiox)
699 tty->ops->set_termiox(tty, &tnew);
700 mutex_unlock(&tty->termios_mutex);
709 * These are deprecated, but there is limited support..
711 * The "sg_flags" translation is a joke..
713 static int get_sgflags(struct tty_struct *tty)
717 if (!(tty->termios->c_lflag & ICANON)) {
718 if (tty->termios->c_lflag & ISIG)
719 flags |= 0x02; /* cbreak */
721 flags |= 0x20; /* raw */
723 if (tty->termios->c_lflag & ECHO)
724 flags |= 0x08; /* echo */
725 if (tty->termios->c_oflag & OPOST)
726 if (tty->termios->c_oflag & ONLCR)
727 flags |= 0x10; /* crmod */
731 static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
735 mutex_lock(&tty->termios_mutex);
736 tmp.sg_ispeed = tty->termios->c_ispeed;
737 tmp.sg_ospeed = tty->termios->c_ospeed;
738 tmp.sg_erase = tty->termios->c_cc[VERASE];
739 tmp.sg_kill = tty->termios->c_cc[VKILL];
740 tmp.sg_flags = get_sgflags(tty);
741 mutex_unlock(&tty->termios_mutex);
743 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
746 static void set_sgflags(struct ktermios *termios, int flags)
748 termios->c_iflag = ICRNL | IXON;
749 termios->c_oflag = 0;
750 termios->c_lflag = ISIG | ICANON;
751 if (flags & 0x02) { /* cbreak */
752 termios->c_iflag = 0;
753 termios->c_lflag &= ~ICANON;
755 if (flags & 0x08) { /* echo */
756 termios->c_lflag |= ECHO | ECHOE | ECHOK |
757 ECHOCTL | ECHOKE | IEXTEN;
759 if (flags & 0x10) { /* crmod */
760 termios->c_oflag |= OPOST | ONLCR;
762 if (flags & 0x20) { /* raw */
763 termios->c_iflag = 0;
764 termios->c_lflag &= ~(ISIG | ICANON);
766 if (!(termios->c_lflag & ICANON)) {
767 termios->c_cc[VMIN] = 1;
768 termios->c_cc[VTIME] = 0;
773 * set_sgttyb - set legacy terminal values
774 * @tty: tty structure
775 * @sgttyb: pointer to old style terminal structure
777 * Updates a terminal from the legacy BSD style terminal information
780 * Locking: termios_mutex
783 static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
787 struct ktermios termios;
789 retval = tty_check_change(tty);
793 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
796 mutex_lock(&tty->termios_mutex);
797 termios = *tty->termios;
798 termios.c_cc[VERASE] = tmp.sg_erase;
799 termios.c_cc[VKILL] = tmp.sg_kill;
800 set_sgflags(&termios, tmp.sg_flags);
801 /* Try and encode into Bfoo format */
803 tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
806 mutex_unlock(&tty->termios_mutex);
807 tty_set_termios(tty, &termios);
813 static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
817 mutex_lock(&tty->termios_mutex);
818 tmp.t_intrc = tty->termios->c_cc[VINTR];
819 tmp.t_quitc = tty->termios->c_cc[VQUIT];
820 tmp.t_startc = tty->termios->c_cc[VSTART];
821 tmp.t_stopc = tty->termios->c_cc[VSTOP];
822 tmp.t_eofc = tty->termios->c_cc[VEOF];
823 tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
824 mutex_unlock(&tty->termios_mutex);
825 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
828 static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
832 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
834 mutex_lock(&tty->termios_mutex);
835 tty->termios->c_cc[VINTR] = tmp.t_intrc;
836 tty->termios->c_cc[VQUIT] = tmp.t_quitc;
837 tty->termios->c_cc[VSTART] = tmp.t_startc;
838 tty->termios->c_cc[VSTOP] = tmp.t_stopc;
839 tty->termios->c_cc[VEOF] = tmp.t_eofc;
840 tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
841 mutex_unlock(&tty->termios_mutex);
847 static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
851 mutex_lock(&tty->termios_mutex);
852 tmp.t_suspc = tty->termios->c_cc[VSUSP];
853 /* what is dsuspc anyway? */
854 tmp.t_dsuspc = tty->termios->c_cc[VSUSP];
855 tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
856 /* what is flushc anyway? */
857 tmp.t_flushc = tty->termios->c_cc[VEOL2];
858 tmp.t_werasc = tty->termios->c_cc[VWERASE];
859 tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
860 mutex_unlock(&tty->termios_mutex);
861 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
864 static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
868 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
871 mutex_lock(&tty->termios_mutex);
872 tty->termios->c_cc[VSUSP] = tmp.t_suspc;
873 /* what is dsuspc anyway? */
874 tty->termios->c_cc[VEOL2] = tmp.t_dsuspc;
875 tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
876 /* what is flushc anyway? */
877 tty->termios->c_cc[VEOL2] = tmp.t_flushc;
878 tty->termios->c_cc[VWERASE] = tmp.t_werasc;
879 tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
880 mutex_unlock(&tty->termios_mutex);
886 * send_prio_char - send priority character
888 * Send a high priority character to the tty even if stopped
890 * Locking: none for xchar method, write ordering for write method.
893 static int send_prio_char(struct tty_struct *tty, char ch)
895 int was_stopped = tty->stopped;
897 if (tty->ops->send_xchar) {
898 tty->ops->send_xchar(tty, ch);
902 if (tty_write_lock(tty, 0) < 0)
907 tty->ops->write(tty, &ch, 1);
910 tty_write_unlock(tty);
915 * tty_change_softcar - carrier change ioctl helper
916 * @tty: tty to update
917 * @arg: enable/disable CLOCAL
919 * Perform a change to the CLOCAL state and call into the driver
920 * layer to make it visible. All done with the termios mutex
923 static int tty_change_softcar(struct tty_struct *tty, int arg)
926 int bit = arg ? CLOCAL : 0;
929 mutex_lock(&tty->termios_mutex);
931 tty->termios->c_cflag &= ~CLOCAL;
932 tty->termios->c_cflag |= bit;
933 if (tty->ops->set_termios)
934 tty->ops->set_termios(tty, &old);
935 if ((tty->termios->c_cflag & CLOCAL) != bit)
937 mutex_unlock(&tty->termios_mutex);
942 * tty_mode_ioctl - mode related ioctls
943 * @tty: tty for the ioctl
944 * @file: file pointer for the tty
946 * @arg: ioctl argument
948 * Perform non line discipline specific mode control ioctls. This
949 * is designed to be called by line disciplines to ensure they provide
950 * consistent mode setting.
953 int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
954 unsigned int cmd, unsigned long arg)
956 struct tty_struct *real_tty;
957 void __user *p = (void __user *)arg;
959 struct ktermios kterm;
961 BUG_ON(file == NULL);
963 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
964 tty->driver->subtype == PTY_TYPE_MASTER)
965 real_tty = tty->link;
972 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
975 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
979 return get_tchars(real_tty, p);
981 return set_tchars(real_tty, p);
985 return get_ltchars(real_tty, p);
987 return set_ltchars(real_tty, p);
990 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
992 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
994 return set_termios(real_tty, p, TERMIOS_OLD);
997 copy_termios(real_tty, &kterm);
998 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
1003 copy_termios(real_tty, &kterm);
1004 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
1008 copy_termios(real_tty, &kterm);
1009 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
1013 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
1015 return set_termios(real_tty, p, TERMIOS_WAIT);
1017 return set_termios(real_tty, p, 0);
1020 return get_termio(real_tty, p);
1022 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
1024 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
1026 return set_termios(real_tty, p, TERMIOS_TERMIO);
1028 case TIOCGLCKTRMIOS:
1029 copy_termios_locked(real_tty, &kterm);
1030 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
1033 case TIOCSLCKTRMIOS:
1034 if (!capable(CAP_SYS_ADMIN))
1036 copy_termios_locked(real_tty, &kterm);
1037 if (user_termios_to_kernel_termios(&kterm,
1038 (struct termios __user *) arg))
1040 mutex_lock(&real_tty->termios_mutex);
1041 memcpy(real_tty->termios_locked, &kterm, sizeof(struct ktermios));
1042 mutex_unlock(&real_tty->termios_mutex);
1045 case TIOCGLCKTRMIOS:
1046 copy_termios_locked(real_tty, &kterm);
1047 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
1050 case TIOCSLCKTRMIOS:
1051 if (!capable(CAP_SYS_ADMIN))
1053 copy_termios_locked(real_tty, &kterm);
1054 if (user_termios_to_kernel_termios_1(&kterm,
1055 (struct termios __user *) arg))
1057 mutex_lock(&real_tty->termios_mutex);
1058 memcpy(real_tty->termios_locked, &kterm, sizeof(struct ktermios));
1059 mutex_unlock(&real_tty->termios_mutex);
1064 struct termiox ktermx;
1065 if (real_tty->termiox == NULL)
1067 mutex_lock(&real_tty->termios_mutex);
1068 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
1069 mutex_unlock(&real_tty->termios_mutex);
1070 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
1075 return set_termiox(real_tty, p, 0);
1077 return set_termiox(real_tty, p, TERMIOS_WAIT);
1079 return set_termiox(real_tty, p, TERMIOS_FLUSH);
1082 copy_termios(real_tty, &kterm);
1083 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
1087 if (get_user(arg, (unsigned int __user *) arg))
1089 return tty_change_softcar(real_tty, arg);
1091 return -ENOIOCTLCMD;
1094 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1096 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1098 struct tty_ldisc *ld;
1099 int retval = tty_check_change(tty);
1103 ld = tty_ldisc_ref_wait(tty);
1106 if (ld && ld->ops->flush_buffer)
1107 ld->ops->flush_buffer(tty);
1110 if (ld && ld->ops->flush_buffer)
1111 ld->ops->flush_buffer(tty);
1114 tty_driver_flush_buffer(tty);
1117 tty_ldisc_deref(ld);
1120 tty_ldisc_deref(ld);
1123 EXPORT_SYMBOL_GPL(tty_perform_flush);
1125 int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
1126 unsigned int cmd, unsigned long arg)
1128 unsigned long flags;
1133 retval = tty_check_change(tty);
1138 if (!tty->flow_stopped) {
1139 tty->flow_stopped = 1;
1144 if (tty->flow_stopped) {
1145 tty->flow_stopped = 0;
1150 if (STOP_CHAR(tty) != __DISABLED_CHAR)
1151 return send_prio_char(tty, STOP_CHAR(tty));
1154 if (START_CHAR(tty) != __DISABLED_CHAR)
1155 return send_prio_char(tty, START_CHAR(tty));
1162 return tty_perform_flush(tty, arg);
1167 if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
1168 tty->driver->subtype != PTY_TYPE_MASTER)
1170 if (get_user(pktmode, (int __user *) arg))
1172 spin_lock_irqsave(&tty->ctrl_lock, flags);
1176 tty->link->ctrl_status = 0;
1180 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
1184 /* Try the mode commands */
1185 return tty_mode_ioctl(tty, file, cmd, arg);
1188 EXPORT_SYMBOL(n_tty_ioctl_helper);
1190 #ifdef CONFIG_COMPAT
1191 long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
1192 unsigned int cmd, unsigned long arg)
1195 case TIOCGLCKTRMIOS:
1196 case TIOCSLCKTRMIOS:
1197 return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
1199 return -ENOIOCTLCMD;
1202 EXPORT_SYMBOL(n_tty_compat_ioctl_helper);