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 DECLARE_WAITQUEUE(wait, current);
57 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
60 printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
62 if (!tty->driver->chars_in_buffer)
64 add_wait_queue(&tty->write_wait, &wait);
66 timeout = MAX_SCHEDULE_TIMEOUT;
68 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
69 printk(KERN_DEBUG "waiting %s...(%d)\n", tty_name(tty, buf),
70 tty->driver->chars_in_buffer(tty));
72 set_current_state(TASK_INTERRUPTIBLE);
73 if (signal_pending(current))
75 if (!tty->driver->chars_in_buffer(tty))
77 timeout = schedule_timeout(timeout);
79 if (tty->driver->wait_until_sent)
80 tty->driver->wait_until_sent(tty, timeout);
82 set_current_state(TASK_RUNNING);
83 remove_wait_queue(&tty->write_wait, &wait);
86 EXPORT_SYMBOL(tty_wait_until_sent);
88 static void unset_locked_termios(struct ktermios *termios,
90 struct ktermios *locked)
94 #define NOSET_MASK(x,y,z) (x = ((x) & ~(z)) | ((y) & (z)))
97 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
101 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
102 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
103 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
104 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
105 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
106 for (i=0; i < NCCS; i++)
107 termios->c_cc[i] = locked->c_cc[i] ?
108 old->c_cc[i] : termios->c_cc[i];
109 /* FIXME: What should we do for i/ospeed */
113 * Routine which returns the baud rate of the tty
115 * Note that the baud_table needs to be kept in sync with the
116 * include/asm/termbits.h file.
118 static const speed_t baud_table[] = {
119 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
120 9600, 19200, 38400, 57600, 115200, 230400, 460800,
122 76800, 153600, 307200, 614400, 921600
124 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
125 2500000, 3000000, 3500000, 4000000
130 static const tcflag_t baud_bits[] = {
131 B0, B50, B75, B110, B134, B150, B200, B300, B600,
132 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
133 B57600, B115200, B230400, B460800, B500000, B576000,
134 B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
135 B3000000, B3500000, B4000000
138 static const tcflag_t baud_bits[] = {
139 B0, B50, B75, B110, B134, B150, B200, B300, B600,
140 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
141 B57600, B115200, B230400, B460800, B76800, B153600,
142 B307200, B614400, B921600
146 static int n_baud_table = ARRAY_SIZE(baud_table);
149 * tty_termios_baud_rate
150 * @termios: termios structure
152 * Convert termios baud rate data into a speed. This should be called
153 * with the termios lock held if this termios is a terminal termios
154 * structure. May change the termios data. Device drivers can call this
155 * function but should use ->c_[io]speed directly as they are updated.
160 speed_t tty_termios_baud_rate(struct ktermios *termios)
164 cbaud = termios->c_cflag & CBAUD;
167 /* Magic token for arbitary speed via c_ispeed/c_ospeed */
169 return termios->c_ospeed;
171 if (cbaud & CBAUDEX) {
174 if (cbaud < 1 || cbaud + 15 > n_baud_table)
175 termios->c_cflag &= ~CBAUDEX;
179 return baud_table[cbaud];
182 EXPORT_SYMBOL(tty_termios_baud_rate);
185 * tty_termios_input_baud_rate
186 * @termios: termios structure
188 * Convert termios baud rate data into a speed. This should be called
189 * with the termios lock held if this termios is a terminal termios
190 * structure. May change the termios data. Device drivers can call this
191 * function but should use ->c_[io]speed directly as they are updated.
196 speed_t tty_termios_input_baud_rate(struct ktermios *termios)
199 unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
202 return tty_termios_baud_rate(termios);
204 /* Magic token for arbitary speed via c_ispeed*/
206 return termios->c_ispeed;
208 if (cbaud & CBAUDEX) {
211 if (cbaud < 1 || cbaud + 15 > n_baud_table)
212 termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
216 return baud_table[cbaud];
218 return tty_termios_baud_rate(termios);
222 EXPORT_SYMBOL(tty_termios_input_baud_rate);
227 * tty_termios_encode_baud_rate
228 * @termios: termios structure
229 * @ispeed: input speed
230 * @ospeed: output speed
232 * Encode the speeds set into the passed termios structure. This is
233 * used as a library helper for drivers os that they can report back
234 * the actual speed selected when it differs from the speed requested
236 * For now input and output speed must agree.
238 * Locking: Caller should hold termios lock. This is already held
239 * when calling this function from the driver termios handler.
242 void tty_termios_encode_baud_rate(struct ktermios *termios, speed_t ibaud, speed_t obaud)
245 int ifound = 0, ofound = 0;
247 termios->c_ispeed = ibaud;
248 termios->c_ospeed = obaud;
250 termios->c_cflag &= ~CBAUD;
251 /* Identical speed means no input encoding (ie B0 << IBSHIFT)*/
252 if (termios->c_ispeed == termios->c_ospeed)
256 if (obaud == baud_table[i]) {
257 termios->c_cflag |= baud_bits[i];
259 /* So that if ibaud == obaud we don't set it */
262 if (ibaud == baud_table[i]) {
263 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
267 while(++i < n_baud_table);
269 termios->c_cflag |= BOTHER;
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 if (opt & TERMIOS_TERMIO) {
403 memcpy(&tmp_termios, tty->termios, sizeof(struct ktermios));
404 if (user_termio_to_kernel_termios(&tmp_termios,
405 (struct termio __user *)arg))
408 } else if (opt & TERMIOS_OLD) {
409 memcpy(&tmp_termios, tty->termios, sizeof(struct termios));
410 if (user_termios_to_kernel_termios_1(&tmp_termios,
411 (struct termios_v1 __user *)arg))
415 if (user_termios_to_kernel_termios(&tmp_termios,
416 (struct termios __user *)arg))
420 /* If old style Bfoo values are used then load c_ispeed/c_ospeed with the real speed
421 so its unconditionally usable */
422 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
423 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
425 ld = tty_ldisc_ref(tty);
428 if ((opt & TERMIOS_FLUSH) && ld->flush_buffer)
429 ld->flush_buffer(tty);
433 if (opt & TERMIOS_WAIT) {
434 tty_wait_until_sent(tty, 0);
435 if (signal_pending(current))
439 change_termios(tty, &tmp_termios);
443 static int get_termio(struct tty_struct * tty, struct termio __user * termio)
445 if (kernel_termios_to_user_termio(termio, tty->termios))
450 static unsigned long inq_canon(struct tty_struct * tty)
454 if (!tty->canon_data || !tty->read_buf)
456 head = tty->canon_head;
457 tail = tty->read_tail;
458 nr = (head - tail) & (N_TTY_BUF_SIZE-1);
459 /* Skip EOF-chars.. */
460 while (head != tail) {
461 if (test_bit(tail, tty->read_flags) &&
462 tty->read_buf[tail] == __DISABLED_CHAR)
464 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
471 * These are deprecated, but there is limited support..
473 * The "sg_flags" translation is a joke..
475 static int get_sgflags(struct tty_struct * tty)
479 if (!(tty->termios->c_lflag & ICANON)) {
480 if (tty->termios->c_lflag & ISIG)
481 flags |= 0x02; /* cbreak */
483 flags |= 0x20; /* raw */
485 if (tty->termios->c_lflag & ECHO)
486 flags |= 0x08; /* echo */
487 if (tty->termios->c_oflag & OPOST)
488 if (tty->termios->c_oflag & ONLCR)
489 flags |= 0x10; /* crmod */
493 static int get_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
497 mutex_lock(&tty->termios_mutex);
498 tmp.sg_ispeed = tty->termios->c_ispeed;
499 tmp.sg_ospeed = tty->termios->c_ospeed;
500 tmp.sg_erase = tty->termios->c_cc[VERASE];
501 tmp.sg_kill = tty->termios->c_cc[VKILL];
502 tmp.sg_flags = get_sgflags(tty);
503 mutex_unlock(&tty->termios_mutex);
505 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
508 static void set_sgflags(struct ktermios * termios, int flags)
510 termios->c_iflag = ICRNL | IXON;
511 termios->c_oflag = 0;
512 termios->c_lflag = ISIG | ICANON;
513 if (flags & 0x02) { /* cbreak */
514 termios->c_iflag = 0;
515 termios->c_lflag &= ~ICANON;
517 if (flags & 0x08) { /* echo */
518 termios->c_lflag |= ECHO | ECHOE | ECHOK |
519 ECHOCTL | ECHOKE | IEXTEN;
521 if (flags & 0x10) { /* crmod */
522 termios->c_oflag |= OPOST | ONLCR;
524 if (flags & 0x20) { /* raw */
525 termios->c_iflag = 0;
526 termios->c_lflag &= ~(ISIG | ICANON);
528 if (!(termios->c_lflag & ICANON)) {
529 termios->c_cc[VMIN] = 1;
530 termios->c_cc[VTIME] = 0;
535 * set_sgttyb - set legacy terminal values
536 * @tty: tty structure
537 * @sgttyb: pointer to old style terminal structure
539 * Updates a terminal from the legacy BSD style terminal information
542 * Locking: termios_sem
545 static int set_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
549 struct ktermios termios;
551 retval = tty_check_change(tty);
555 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
558 mutex_lock(&tty->termios_mutex);
559 termios = *tty->termios;
560 termios.c_cc[VERASE] = tmp.sg_erase;
561 termios.c_cc[VKILL] = tmp.sg_kill;
562 set_sgflags(&termios, tmp.sg_flags);
563 /* Try and encode into Bfoo format */
565 tty_termios_encode_baud_rate(&termios, termios.c_ispeed, termios.c_ospeed);
567 mutex_unlock(&tty->termios_mutex);
568 change_termios(tty, &termios);
574 static int get_tchars(struct tty_struct * tty, struct tchars __user * tchars)
578 tmp.t_intrc = tty->termios->c_cc[VINTR];
579 tmp.t_quitc = tty->termios->c_cc[VQUIT];
580 tmp.t_startc = tty->termios->c_cc[VSTART];
581 tmp.t_stopc = tty->termios->c_cc[VSTOP];
582 tmp.t_eofc = tty->termios->c_cc[VEOF];
583 tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
584 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
587 static int set_tchars(struct tty_struct * tty, struct tchars __user * tchars)
591 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
593 tty->termios->c_cc[VINTR] = tmp.t_intrc;
594 tty->termios->c_cc[VQUIT] = tmp.t_quitc;
595 tty->termios->c_cc[VSTART] = tmp.t_startc;
596 tty->termios->c_cc[VSTOP] = tmp.t_stopc;
597 tty->termios->c_cc[VEOF] = tmp.t_eofc;
598 tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
604 static int get_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
608 tmp.t_suspc = tty->termios->c_cc[VSUSP];
609 tmp.t_dsuspc = tty->termios->c_cc[VSUSP]; /* what is dsuspc anyway? */
610 tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
611 tmp.t_flushc = tty->termios->c_cc[VEOL2]; /* what is flushc anyway? */
612 tmp.t_werasc = tty->termios->c_cc[VWERASE];
613 tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
614 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
617 static int set_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
621 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
624 tty->termios->c_cc[VSUSP] = tmp.t_suspc;
625 tty->termios->c_cc[VEOL2] = tmp.t_dsuspc; /* what is dsuspc anyway? */
626 tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
627 tty->termios->c_cc[VEOL2] = tmp.t_flushc; /* what is flushc anyway? */
628 tty->termios->c_cc[VWERASE] = tmp.t_werasc;
629 tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
635 * send_prio_char - send priority character
637 * Send a high priority character to the tty even if stopped
639 * Locking: none for xchar method, write ordering for write method.
642 static int send_prio_char(struct tty_struct *tty, char ch)
644 int was_stopped = tty->stopped;
646 if (tty->driver->send_xchar) {
647 tty->driver->send_xchar(tty, ch);
651 if (mutex_lock_interruptible(&tty->atomic_write_lock))
656 tty->driver->write(tty, &ch, 1);
659 mutex_unlock(&tty->atomic_write_lock);
663 int n_tty_ioctl(struct tty_struct * tty, struct file * file,
664 unsigned int cmd, unsigned long arg)
666 struct tty_struct * real_tty;
667 void __user *p = (void __user *)arg;
669 struct tty_ldisc *ld;
671 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
672 tty->driver->subtype == PTY_TYPE_MASTER)
673 real_tty = tty->link;
680 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
683 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
687 return get_tchars(real_tty, p);
689 return set_tchars(real_tty, p);
693 return get_ltchars(real_tty, p);
695 return set_ltchars(real_tty, p);
698 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
700 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
702 return set_termios(real_tty, p, TERMIOS_OLD);
705 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios))
710 if (kernel_termios_to_user_termios_1((struct termios_v1 __user *)arg, real_tty->termios))
714 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios))
718 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
720 return set_termios(real_tty, p, TERMIOS_WAIT);
722 return set_termios(real_tty, p, 0);
725 return get_termio(real_tty, p);
727 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
729 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
731 return set_termios(real_tty, p, TERMIOS_TERMIO);
733 retval = tty_check_change(tty);
738 if (!tty->flow_stopped) {
739 tty->flow_stopped = 1;
744 if (tty->flow_stopped) {
745 tty->flow_stopped = 0;
750 if (STOP_CHAR(tty) != __DISABLED_CHAR)
751 return send_prio_char(tty, STOP_CHAR(tty));
754 if (START_CHAR(tty) != __DISABLED_CHAR)
755 return send_prio_char(tty, START_CHAR(tty));
762 retval = tty_check_change(tty);
766 ld = tty_ldisc_ref(tty);
769 if (ld && ld->flush_buffer)
770 ld->flush_buffer(tty);
773 if (ld && ld->flush_buffer)
774 ld->flush_buffer(tty);
777 if (tty->driver->flush_buffer)
778 tty->driver->flush_buffer(tty);
787 return put_user(tty->driver->chars_in_buffer ?
788 tty->driver->chars_in_buffer(tty) : 0,
791 retval = tty->read_cnt;
793 retval = inq_canon(tty);
794 return put_user(retval, (unsigned int __user *) arg);
796 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios_locked))
801 if (!capable(CAP_SYS_ADMIN))
803 if (user_termios_to_kernel_termios(real_tty->termios_locked, (struct termios __user *) arg))
811 if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
812 tty->driver->subtype != PTY_TYPE_MASTER)
814 if (get_user(pktmode, (int __user *) arg))
819 tty->link->ctrl_status = 0;
826 return put_user(C_CLOCAL(tty) ? 1 : 0, (int __user *)arg);
828 if (get_user(arg, (unsigned int __user *) arg))
830 mutex_lock(&tty->termios_mutex);
831 tty->termios->c_cflag =
832 ((tty->termios->c_cflag & ~CLOCAL) |
834 mutex_unlock(&tty->termios_mutex);
841 EXPORT_SYMBOL(n_tty_ioctl);