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>
26 #include <asm/uaccess.h>
27 #include <asm/system.h>
29 #undef TTY_DEBUG_WAIT_UNTIL_SENT
34 * Internal flag options for termios setting behavior
36 #define TERMIOS_FLUSH 1
37 #define TERMIOS_WAIT 2
38 #define TERMIOS_TERMIO 4
43 * tty_wait_until_sent - wait for I/O to finish
44 * @tty: tty we are waiting for
45 * @timeout: how long we will wait
47 * Wait for characters pending in a tty driver to hit the wire, or
48 * for a timeout to occur (eg due to flow control)
53 void tty_wait_until_sent(struct tty_struct * tty, long timeout)
55 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
58 printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
60 if (!tty->driver->chars_in_buffer)
63 timeout = MAX_SCHEDULE_TIMEOUT;
64 if (wait_event_interruptible_timeout(tty->write_wait,
65 !tty->driver->chars_in_buffer(tty), timeout))
67 if (tty->driver->wait_until_sent)
68 tty->driver->wait_until_sent(tty, timeout);
71 EXPORT_SYMBOL(tty_wait_until_sent);
73 static void unset_locked_termios(struct ktermios *termios,
75 struct ktermios *locked)
79 #define NOSET_MASK(x,y,z) (x = ((x) & ~(z)) | ((y) & (z)))
82 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
86 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
87 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
88 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
89 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
90 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
91 for (i=0; i < NCCS; i++)
92 termios->c_cc[i] = locked->c_cc[i] ?
93 old->c_cc[i] : termios->c_cc[i];
94 /* FIXME: What should we do for i/ospeed */
98 * Routine which returns the baud rate of the tty
100 * Note that the baud_table needs to be kept in sync with the
101 * include/asm/termbits.h file.
103 static const speed_t baud_table[] = {
104 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
105 9600, 19200, 38400, 57600, 115200, 230400, 460800,
107 76800, 153600, 307200, 614400, 921600
109 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
110 2500000, 3000000, 3500000, 4000000
115 static const tcflag_t baud_bits[] = {
116 B0, B50, B75, B110, B134, B150, B200, B300, B600,
117 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
118 B57600, B115200, B230400, B460800, B500000, B576000,
119 B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
120 B3000000, B3500000, B4000000
123 static const tcflag_t baud_bits[] = {
124 B0, B50, B75, B110, B134, B150, B200, B300, B600,
125 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
126 B57600, B115200, B230400, B460800, B76800, B153600,
127 B307200, B614400, B921600
131 static int n_baud_table = ARRAY_SIZE(baud_table);
134 * tty_termios_baud_rate
135 * @termios: termios structure
137 * Convert termios baud rate data into a speed. This should be called
138 * with the termios lock held if this termios is a terminal termios
139 * structure. May change the termios data. Device drivers can call this
140 * function but should use ->c_[io]speed directly as they are updated.
145 speed_t tty_termios_baud_rate(struct ktermios *termios)
149 cbaud = termios->c_cflag & CBAUD;
152 /* Magic token for arbitary speed via c_ispeed/c_ospeed */
154 return termios->c_ospeed;
156 if (cbaud & CBAUDEX) {
159 if (cbaud < 1 || cbaud + 15 > n_baud_table)
160 termios->c_cflag &= ~CBAUDEX;
164 return baud_table[cbaud];
167 EXPORT_SYMBOL(tty_termios_baud_rate);
170 * tty_termios_input_baud_rate
171 * @termios: termios structure
173 * Convert termios baud rate data into a speed. This should be called
174 * with the termios lock held if this termios is a terminal termios
175 * structure. May change the termios data. Device drivers can call this
176 * function but should use ->c_[io]speed directly as they are updated.
181 speed_t tty_termios_input_baud_rate(struct ktermios *termios)
184 unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
187 return tty_termios_baud_rate(termios);
189 /* Magic token for arbitary speed via c_ispeed*/
191 return termios->c_ispeed;
193 if (cbaud & CBAUDEX) {
196 if (cbaud < 1 || cbaud + 15 > n_baud_table)
197 termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
201 return baud_table[cbaud];
203 return tty_termios_baud_rate(termios);
207 EXPORT_SYMBOL(tty_termios_input_baud_rate);
212 * tty_termios_encode_baud_rate
213 * @termios: ktermios structure holding user requested state
214 * @ispeed: input speed
215 * @ospeed: output speed
217 * Encode the speeds set into the passed termios structure. This is
218 * used as a library helper for drivers os that they can report back
219 * the actual speed selected when it differs from the speed requested
221 * For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
222 * we need to carefully set the bits when the user does not get the
223 * desired speed. We allow small margins and preserve as much of possible
224 * of the input intent to keep compatiblity.
226 * Locking: Caller should hold termios lock. This is already held
227 * when calling this function from the driver termios handler.
230 void tty_termios_encode_baud_rate(struct ktermios *termios, speed_t ibaud, speed_t obaud)
233 int ifound = -1, ofound = -1;
234 int iclose = ibaud/50, oclose = obaud/50;
237 termios->c_ispeed = ibaud;
238 termios->c_ospeed = obaud;
240 /* If the user asked for a precise weird speed give a precise weird
241 answer. If they asked for a Bfoo speed they many have problems
242 digesting non-exact replies so fuzz a bit */
244 if ((termios->c_cflag & CBAUD) == BOTHER)
246 if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
248 if ((termios->c_cflag >> IBSHIFT) & CBAUD)
249 ibinput = 1; /* An input speed was specified */
251 termios->c_cflag &= ~CBAUD;
254 if (obaud - oclose >= baud_table[i] && obaud + oclose <= baud_table[i]) {
255 termios->c_cflag |= baud_bits[i];
258 if (ibaud - iclose >= baud_table[i] && ibaud + iclose <= baud_table[i]) {
259 /* For the case input == output don't set IBAUD bits if the user didn't do so */
260 if (ofound != i || ibinput)
261 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
265 while(++i < n_baud_table);
267 termios->c_cflag |= BOTHER;
268 /* Set exact input bits only if the input and output differ or the
270 if (ifound == -1 && (ibaud != obaud || ibinput))
271 termios->c_cflag |= (BOTHER << IBSHIFT);
274 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
279 * tty_get_baud_rate - get tty bit rates
282 * Returns the baud rate as an integer for this terminal. The
283 * termios lock must be held by the caller and the terminal bit
284 * flags may be updated.
289 speed_t tty_get_baud_rate(struct tty_struct *tty)
291 speed_t baud = tty_termios_baud_rate(tty->termios);
293 if (baud == 38400 && tty->alt_speed) {
295 printk(KERN_WARNING "Use of setserial/setrocket to "
296 "set SPD_* flags is deprecated\n");
299 baud = tty->alt_speed;
305 EXPORT_SYMBOL(tty_get_baud_rate);
308 * change_termios - update termios values
309 * @tty: tty to update
310 * @new_termios: desired new value
312 * Perform updates to the termios values set on this terminal. There
313 * is a bit of layering violation here with n_tty in terms of the
314 * internal knowledge of this function.
316 * Locking: termios_sem
319 static void change_termios(struct tty_struct * tty, struct ktermios * new_termios)
322 struct ktermios old_termios = *tty->termios;
323 struct tty_ldisc *ld;
326 * Perform the actual termios internal changes under lock.
330 /* FIXME: we need to decide on some locking/ordering semantics
331 for the set_termios notification eventually */
332 mutex_lock(&tty->termios_mutex);
334 *tty->termios = *new_termios;
335 unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
336 canon_change = (old_termios.c_lflag ^ tty->termios->c_lflag) & ICANON;
338 memset(&tty->read_flags, 0, sizeof tty->read_flags);
339 tty->canon_head = tty->read_tail;
345 if (canon_change && !L_ICANON(tty) && tty->read_cnt)
346 /* Get characters left over from canonical mode. */
347 wake_up_interruptible(&tty->read_wait);
349 /* See if packet mode change of state. */
351 if (tty->link && tty->link->packet) {
352 int old_flow = ((old_termios.c_iflag & IXON) &&
353 (old_termios.c_cc[VSTOP] == '\023') &&
354 (old_termios.c_cc[VSTART] == '\021'));
355 int new_flow = (I_IXON(tty) &&
356 STOP_CHAR(tty) == '\023' &&
357 START_CHAR(tty) == '\021');
358 if (old_flow != new_flow) {
359 tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
361 tty->ctrl_status |= TIOCPKT_DOSTOP;
363 tty->ctrl_status |= TIOCPKT_NOSTOP;
364 wake_up_interruptible(&tty->link->read_wait);
368 if (tty->driver->set_termios)
369 (*tty->driver->set_termios)(tty, &old_termios);
371 ld = tty_ldisc_ref(tty);
374 (ld->set_termios)(tty, &old_termios);
377 mutex_unlock(&tty->termios_mutex);
381 * set_termios - set termios values for a tty
382 * @tty: terminal device
384 * @opt: option information
386 * Helper function to prepare termios data and run neccessary other
387 * functions before using change_termios to do the actual changes.
390 * Called functions take ldisc and termios_sem locks
393 static int set_termios(struct tty_struct * tty, void __user *arg, int opt)
395 struct ktermios tmp_termios;
396 struct tty_ldisc *ld;
397 int retval = tty_check_change(tty);
402 memcpy(&tmp_termios, tty->termios, sizeof(struct ktermios));
404 if (opt & TERMIOS_TERMIO) {
405 if (user_termio_to_kernel_termios(&tmp_termios,
406 (struct termio __user *)arg))
409 } else if (opt & TERMIOS_OLD) {
410 if (user_termios_to_kernel_termios_1(&tmp_termios,
411 (struct termios __user *)arg))
414 if (user_termios_to_kernel_termios(&tmp_termios,
415 (struct termios2 __user *)arg))
419 } else if (user_termios_to_kernel_termios(&tmp_termios,
420 (struct termios __user *)arg))
424 /* If old style Bfoo values are used then load c_ispeed/c_ospeed with the real speed
425 so its unconditionally usable */
426 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
427 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
429 ld = tty_ldisc_ref(tty);
432 if ((opt & TERMIOS_FLUSH) && ld->flush_buffer)
433 ld->flush_buffer(tty);
437 if (opt & TERMIOS_WAIT) {
438 tty_wait_until_sent(tty, 0);
439 if (signal_pending(current))
443 change_termios(tty, &tmp_termios);
447 static int get_termio(struct tty_struct * tty, struct termio __user * termio)
449 if (kernel_termios_to_user_termio(termio, tty->termios))
454 static unsigned long inq_canon(struct tty_struct * tty)
458 if (!tty->canon_data || !tty->read_buf)
460 head = tty->canon_head;
461 tail = tty->read_tail;
462 nr = (head - tail) & (N_TTY_BUF_SIZE-1);
463 /* Skip EOF-chars.. */
464 while (head != tail) {
465 if (test_bit(tail, tty->read_flags) &&
466 tty->read_buf[tail] == __DISABLED_CHAR)
468 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
475 * These are deprecated, but there is limited support..
477 * The "sg_flags" translation is a joke..
479 static int get_sgflags(struct tty_struct * tty)
483 if (!(tty->termios->c_lflag & ICANON)) {
484 if (tty->termios->c_lflag & ISIG)
485 flags |= 0x02; /* cbreak */
487 flags |= 0x20; /* raw */
489 if (tty->termios->c_lflag & ECHO)
490 flags |= 0x08; /* echo */
491 if (tty->termios->c_oflag & OPOST)
492 if (tty->termios->c_oflag & ONLCR)
493 flags |= 0x10; /* crmod */
497 static int get_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
501 mutex_lock(&tty->termios_mutex);
502 tmp.sg_ispeed = tty->termios->c_ispeed;
503 tmp.sg_ospeed = tty->termios->c_ospeed;
504 tmp.sg_erase = tty->termios->c_cc[VERASE];
505 tmp.sg_kill = tty->termios->c_cc[VKILL];
506 tmp.sg_flags = get_sgflags(tty);
507 mutex_unlock(&tty->termios_mutex);
509 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
512 static void set_sgflags(struct ktermios * termios, int flags)
514 termios->c_iflag = ICRNL | IXON;
515 termios->c_oflag = 0;
516 termios->c_lflag = ISIG | ICANON;
517 if (flags & 0x02) { /* cbreak */
518 termios->c_iflag = 0;
519 termios->c_lflag &= ~ICANON;
521 if (flags & 0x08) { /* echo */
522 termios->c_lflag |= ECHO | ECHOE | ECHOK |
523 ECHOCTL | ECHOKE | IEXTEN;
525 if (flags & 0x10) { /* crmod */
526 termios->c_oflag |= OPOST | ONLCR;
528 if (flags & 0x20) { /* raw */
529 termios->c_iflag = 0;
530 termios->c_lflag &= ~(ISIG | ICANON);
532 if (!(termios->c_lflag & ICANON)) {
533 termios->c_cc[VMIN] = 1;
534 termios->c_cc[VTIME] = 0;
539 * set_sgttyb - set legacy terminal values
540 * @tty: tty structure
541 * @sgttyb: pointer to old style terminal structure
543 * Updates a terminal from the legacy BSD style terminal information
546 * Locking: termios_sem
549 static int set_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
553 struct ktermios termios;
555 retval = tty_check_change(tty);
559 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
562 mutex_lock(&tty->termios_mutex);
563 termios = *tty->termios;
564 termios.c_cc[VERASE] = tmp.sg_erase;
565 termios.c_cc[VKILL] = tmp.sg_kill;
566 set_sgflags(&termios, tmp.sg_flags);
567 /* Try and encode into Bfoo format */
569 tty_termios_encode_baud_rate(&termios, termios.c_ispeed, termios.c_ospeed);
571 mutex_unlock(&tty->termios_mutex);
572 change_termios(tty, &termios);
578 static int get_tchars(struct tty_struct * tty, struct tchars __user * tchars)
582 tmp.t_intrc = tty->termios->c_cc[VINTR];
583 tmp.t_quitc = tty->termios->c_cc[VQUIT];
584 tmp.t_startc = tty->termios->c_cc[VSTART];
585 tmp.t_stopc = tty->termios->c_cc[VSTOP];
586 tmp.t_eofc = tty->termios->c_cc[VEOF];
587 tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
588 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
591 static int set_tchars(struct tty_struct * tty, struct tchars __user * tchars)
595 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
597 tty->termios->c_cc[VINTR] = tmp.t_intrc;
598 tty->termios->c_cc[VQUIT] = tmp.t_quitc;
599 tty->termios->c_cc[VSTART] = tmp.t_startc;
600 tty->termios->c_cc[VSTOP] = tmp.t_stopc;
601 tty->termios->c_cc[VEOF] = tmp.t_eofc;
602 tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
608 static int get_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
612 tmp.t_suspc = tty->termios->c_cc[VSUSP];
613 tmp.t_dsuspc = tty->termios->c_cc[VSUSP]; /* what is dsuspc anyway? */
614 tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
615 tmp.t_flushc = tty->termios->c_cc[VEOL2]; /* what is flushc anyway? */
616 tmp.t_werasc = tty->termios->c_cc[VWERASE];
617 tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
618 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
621 static int set_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
625 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
628 tty->termios->c_cc[VSUSP] = tmp.t_suspc;
629 tty->termios->c_cc[VEOL2] = tmp.t_dsuspc; /* what is dsuspc anyway? */
630 tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
631 tty->termios->c_cc[VEOL2] = tmp.t_flushc; /* what is flushc anyway? */
632 tty->termios->c_cc[VWERASE] = tmp.t_werasc;
633 tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
639 * send_prio_char - send priority character
641 * Send a high priority character to the tty even if stopped
643 * Locking: none for xchar method, write ordering for write method.
646 static int send_prio_char(struct tty_struct *tty, char ch)
648 int was_stopped = tty->stopped;
650 if (tty->driver->send_xchar) {
651 tty->driver->send_xchar(tty, ch);
655 if (tty_write_lock(tty, 0) < 0)
660 tty->driver->write(tty, &ch, 1);
663 tty_write_unlock(tty);
667 int n_tty_ioctl(struct tty_struct * tty, struct file * file,
668 unsigned int cmd, unsigned long arg)
670 struct tty_struct * real_tty;
671 void __user *p = (void __user *)arg;
673 struct tty_ldisc *ld;
675 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
676 tty->driver->subtype == PTY_TYPE_MASTER)
677 real_tty = tty->link;
684 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
687 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
691 return get_tchars(real_tty, p);
693 return set_tchars(real_tty, p);
697 return get_ltchars(real_tty, p);
699 return set_ltchars(real_tty, p);
702 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
704 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
706 return set_termios(real_tty, p, TERMIOS_OLD);
709 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios))
714 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, real_tty->termios))
718 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, real_tty->termios))
722 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
724 return set_termios(real_tty, p, TERMIOS_WAIT);
726 return set_termios(real_tty, p, 0);
729 return get_termio(real_tty, p);
731 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
733 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
735 return set_termios(real_tty, p, TERMIOS_TERMIO);
737 retval = tty_check_change(tty);
742 if (!tty->flow_stopped) {
743 tty->flow_stopped = 1;
748 if (tty->flow_stopped) {
749 tty->flow_stopped = 0;
754 if (STOP_CHAR(tty) != __DISABLED_CHAR)
755 return send_prio_char(tty, STOP_CHAR(tty));
758 if (START_CHAR(tty) != __DISABLED_CHAR)
759 return send_prio_char(tty, START_CHAR(tty));
766 retval = tty_check_change(tty);
770 ld = tty_ldisc_ref(tty);
773 if (ld && ld->flush_buffer)
774 ld->flush_buffer(tty);
777 if (ld && ld->flush_buffer)
778 ld->flush_buffer(tty);
781 if (tty->driver->flush_buffer)
782 tty->driver->flush_buffer(tty);
791 return put_user(tty->driver->chars_in_buffer ?
792 tty->driver->chars_in_buffer(tty) : 0,
795 retval = tty->read_cnt;
797 retval = inq_canon(tty);
798 return put_user(retval, (unsigned int __user *) arg);
800 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios_locked))
805 if (!capable(CAP_SYS_ADMIN))
807 if (user_termios_to_kernel_termios(real_tty->termios_locked, (struct termios __user *) arg))
815 if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
816 tty->driver->subtype != PTY_TYPE_MASTER)
818 if (get_user(pktmode, (int __user *) arg))
823 tty->link->ctrl_status = 0;
830 return put_user(C_CLOCAL(tty) ? 1 : 0, (int __user *)arg);
832 if (get_user(arg, (unsigned int __user *) arg))
834 mutex_lock(&tty->termios_mutex);
835 tty->termios->c_cflag =
836 ((tty->termios->c_cflag & ~CLOCAL) |
838 mutex_unlock(&tty->termios_mutex);
845 EXPORT_SYMBOL(n_tty_ioctl);