Merge git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc
[linux-2.6] / drivers / char / tty_ioctl.c
1 /*
2  *  linux/drivers/char/tty_ioctl.c
3  *
4  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
5  *
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).
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 #include <linux/smp_lock.h>
25
26 #include <asm/io.h>
27 #include <asm/uaccess.h>
28 #include <asm/system.h>
29
30 #undef TTY_DEBUG_WAIT_UNTIL_SENT
31
32 #undef  DEBUG
33
34 /*
35  * Internal flag options for termios setting behavior
36  */
37 #define TERMIOS_FLUSH   1
38 #define TERMIOS_WAIT    2
39 #define TERMIOS_TERMIO  4
40 #define TERMIOS_OLD     8
41
42
43 int tty_chars_in_buffer(struct tty_struct *tty)
44 {
45         if (tty->ops->chars_in_buffer)
46                 return tty->ops->chars_in_buffer(tty);
47         else
48                 return 0;
49 }
50
51 EXPORT_SYMBOL(tty_chars_in_buffer);
52
53 int tty_write_room(struct tty_struct *tty)
54 {
55         if (tty->ops->write_room)
56                 return tty->ops->write_room(tty);
57         return 2048;
58 }
59
60 EXPORT_SYMBOL(tty_write_room);
61
62 void tty_driver_flush_buffer(struct tty_struct *tty)
63 {
64         if (tty->ops->flush_buffer)
65                 tty->ops->flush_buffer(tty);
66 }
67
68 EXPORT_SYMBOL(tty_driver_flush_buffer);
69
70 void tty_throttle(struct tty_struct *tty)
71 {
72         /* check TTY_THROTTLED first so it indicates our state */
73         if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
74             tty->ops->throttle)
75                 tty->ops->throttle(tty);
76 }
77 EXPORT_SYMBOL(tty_throttle);
78
79 void tty_unthrottle(struct tty_struct *tty)
80 {
81         if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
82             tty->ops->unthrottle)
83                 tty->ops->unthrottle(tty);
84 }
85 EXPORT_SYMBOL(tty_unthrottle);
86
87 /**
88  *      tty_wait_until_sent     -       wait for I/O to finish
89  *      @tty: tty we are waiting for
90  *      @timeout: how long we will wait
91  *
92  *      Wait for characters pending in a tty driver to hit the wire, or
93  *      for a timeout to occur (eg due to flow control)
94  *
95  *      Locking: none
96  */
97
98 void tty_wait_until_sent(struct tty_struct *tty, long timeout)
99 {
100 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
101         char buf[64];
102
103         printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
104 #endif
105         if (!timeout)
106                 timeout = MAX_SCHEDULE_TIMEOUT;
107         if (wait_event_interruptible_timeout(tty->write_wait,
108                         !tty_chars_in_buffer(tty), timeout) >= 0) {
109                 if (tty->ops->wait_until_sent)
110                         tty->ops->wait_until_sent(tty, timeout);
111         }
112 }
113 EXPORT_SYMBOL(tty_wait_until_sent);
114
115 static void unset_locked_termios(struct ktermios *termios,
116                                  struct ktermios *old,
117                                  struct ktermios *locked)
118 {
119         int     i;
120
121 #define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) | ((y) & (z)))
122
123         if (!locked) {
124                 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
125                 return;
126         }
127
128         NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
129         NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
130         NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
131         NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
132         termios->c_line = locked->c_line ? old->c_line : termios->c_line;
133         for (i = 0; i < NCCS; i++)
134                 termios->c_cc[i] = locked->c_cc[i] ?
135                         old->c_cc[i] : termios->c_cc[i];
136         /* FIXME: What should we do for i/ospeed */
137 }
138
139 /*
140  * Routine which returns the baud rate of the tty
141  *
142  * Note that the baud_table needs to be kept in sync with the
143  * include/asm/termbits.h file.
144  */
145 static const speed_t baud_table[] = {
146         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
147         9600, 19200, 38400, 57600, 115200, 230400, 460800,
148 #ifdef __sparc__
149         76800, 153600, 307200, 614400, 921600
150 #else
151         500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
152         2500000, 3000000, 3500000, 4000000
153 #endif
154 };
155
156 #ifndef __sparc__
157 static const tcflag_t baud_bits[] = {
158         B0, B50, B75, B110, B134, B150, B200, B300, B600,
159         B1200, B1800, B2400, B4800, B9600, B19200, B38400,
160         B57600, B115200, B230400, B460800, B500000, B576000,
161         B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
162         B3000000, B3500000, B4000000
163 };
164 #else
165 static const tcflag_t baud_bits[] = {
166         B0, B50, B75, B110, B134, B150, B200, B300, B600,
167         B1200, B1800, B2400, B4800, B9600, B19200, B38400,
168         B57600, B115200, B230400, B460800, B76800, B153600,
169         B307200, B614400, B921600
170 };
171 #endif
172
173 static int n_baud_table = ARRAY_SIZE(baud_table);
174
175 /**
176  *      tty_termios_baud_rate
177  *      @termios: termios structure
178  *
179  *      Convert termios baud rate data into a speed. This should be called
180  *      with the termios lock held if this termios is a terminal termios
181  *      structure. May change the termios data. Device drivers can call this
182  *      function but should use ->c_[io]speed directly as they are updated.
183  *
184  *      Locking: none
185  */
186
187 speed_t tty_termios_baud_rate(struct ktermios *termios)
188 {
189         unsigned int cbaud;
190
191         cbaud = termios->c_cflag & CBAUD;
192
193 #ifdef BOTHER
194         /* Magic token for arbitary speed via c_ispeed/c_ospeed */
195         if (cbaud == BOTHER)
196                 return termios->c_ospeed;
197 #endif
198         if (cbaud & CBAUDEX) {
199                 cbaud &= ~CBAUDEX;
200
201                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
202                         termios->c_cflag &= ~CBAUDEX;
203                 else
204                         cbaud += 15;
205         }
206         return baud_table[cbaud];
207 }
208 EXPORT_SYMBOL(tty_termios_baud_rate);
209
210 /**
211  *      tty_termios_input_baud_rate
212  *      @termios: termios structure
213  *
214  *      Convert termios baud rate data into a speed. This should be called
215  *      with the termios lock held if this termios is a terminal termios
216  *      structure. May change the termios data. Device drivers can call this
217  *      function but should use ->c_[io]speed directly as they are updated.
218  *
219  *      Locking: none
220  */
221
222 speed_t tty_termios_input_baud_rate(struct ktermios *termios)
223 {
224 #ifdef IBSHIFT
225         unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
226
227         if (cbaud == B0)
228                 return tty_termios_baud_rate(termios);
229
230         /* Magic token for arbitary speed via c_ispeed*/
231         if (cbaud == BOTHER)
232                 return termios->c_ispeed;
233
234         if (cbaud & CBAUDEX) {
235                 cbaud &= ~CBAUDEX;
236
237                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
238                         termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
239                 else
240                         cbaud += 15;
241         }
242         return baud_table[cbaud];
243 #else
244         return tty_termios_baud_rate(termios);
245 #endif
246 }
247 EXPORT_SYMBOL(tty_termios_input_baud_rate);
248
249 /**
250  *      tty_termios_encode_baud_rate
251  *      @termios: ktermios structure holding user requested state
252  *      @ispeed: input speed
253  *      @ospeed: output speed
254  *
255  *      Encode the speeds set into the passed termios structure. This is
256  *      used as a library helper for drivers os that they can report back
257  *      the actual speed selected when it differs from the speed requested
258  *
259  *      For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
260  *      we need to carefully set the bits when the user does not get the
261  *      desired speed. We allow small margins and preserve as much of possible
262  *      of the input intent to keep compatiblity.
263  *
264  *      Locking: Caller should hold termios lock. This is already held
265  *      when calling this function from the driver termios handler.
266  *
267  *      The ifdefs deal with platforms whose owners have yet to update them
268  *      and will all go away once this is done.
269  */
270
271 void tty_termios_encode_baud_rate(struct ktermios *termios,
272                                   speed_t ibaud, speed_t obaud)
273 {
274         int i = 0;
275         int ifound = -1, ofound = -1;
276         int iclose = ibaud/50, oclose = obaud/50;
277         int ibinput = 0;
278
279         if (obaud == 0)                 /* CD dropped             */
280                 ibaud = 0;              /* Clear ibaud to be sure */
281
282         termios->c_ispeed = ibaud;
283         termios->c_ospeed = obaud;
284
285 #ifdef BOTHER
286         /* If the user asked for a precise weird speed give a precise weird
287            answer. If they asked for a Bfoo speed they many have problems
288            digesting non-exact replies so fuzz a bit */
289
290         if ((termios->c_cflag & CBAUD) == BOTHER)
291                 oclose = 0;
292         if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
293                 iclose = 0;
294         if ((termios->c_cflag >> IBSHIFT) & CBAUD)
295                 ibinput = 1;    /* An input speed was specified */
296 #endif
297         termios->c_cflag &= ~CBAUD;
298
299         /*
300          *      Our goal is to find a close match to the standard baud rate
301          *      returned. Walk the baud rate table and if we get a very close
302          *      match then report back the speed as a POSIX Bxxxx value by
303          *      preference
304          */
305
306         do {
307                 if (obaud - oclose <= baud_table[i] &&
308                     obaud + oclose >= baud_table[i]) {
309                         termios->c_cflag |= baud_bits[i];
310                         ofound = i;
311                 }
312                 if (ibaud - iclose <= baud_table[i] &&
313                     ibaud + iclose >= baud_table[i]) {
314                         /* For the case input == output don't set IBAUD bits
315                            if the user didn't do so */
316                         if (ofound == i && !ibinput)
317                                 ifound  = i;
318 #ifdef IBSHIFT
319                         else {
320                                 ifound = i;
321                                 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
322                         }
323 #endif
324                 }
325         } while (++i < n_baud_table);
326
327         /*
328          *      If we found no match then use BOTHER if provided or warn
329          *      the user their platform maintainer needs to wake up if not.
330          */
331 #ifdef BOTHER
332         if (ofound == -1)
333                 termios->c_cflag |= BOTHER;
334         /* Set exact input bits only if the input and output differ or the
335            user already did */
336         if (ifound == -1 && (ibaud != obaud || ibinput))
337                 termios->c_cflag |= (BOTHER << IBSHIFT);
338 #else
339         if (ifound == -1 || ofound == -1) {
340                 static int warned;
341                 if (!warned++)
342                         printk(KERN_WARNING "tty: Unable to return correct "
343                           "speed data as your architecture needs updating.\n");
344         }
345 #endif
346 }
347 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
348
349 void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
350 {
351         tty_termios_encode_baud_rate(tty->termios, ibaud, obaud);
352 }
353 EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
354
355 /**
356  *      tty_get_baud_rate       -       get tty bit rates
357  *      @tty: tty to query
358  *
359  *      Returns the baud rate as an integer for this terminal. The
360  *      termios lock must be held by the caller and the terminal bit
361  *      flags may be updated.
362  *
363  *      Locking: none
364  */
365
366 speed_t tty_get_baud_rate(struct tty_struct *tty)
367 {
368         speed_t baud = tty_termios_baud_rate(tty->termios);
369
370         if (baud == 38400 && tty->alt_speed) {
371                 if (!tty->warned) {
372                         printk(KERN_WARNING "Use of setserial/setrocket to "
373                                             "set SPD_* flags is deprecated\n");
374                         tty->warned = 1;
375                 }
376                 baud = tty->alt_speed;
377         }
378
379         return baud;
380 }
381 EXPORT_SYMBOL(tty_get_baud_rate);
382
383 /**
384  *      tty_termios_copy_hw     -       copy hardware settings
385  *      @new: New termios
386  *      @old: Old termios
387  *
388  *      Propogate the hardware specific terminal setting bits from
389  *      the old termios structure to the new one. This is used in cases
390  *      where the hardware does not support reconfiguration or as a helper
391  *      in some cases where only minimal reconfiguration is supported
392  */
393
394 void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
395 {
396         /* The bits a dumb device handles in software. Smart devices need
397            to always provide a set_termios method */
398         new->c_cflag &= HUPCL | CREAD | CLOCAL;
399         new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
400         new->c_ispeed = old->c_ispeed;
401         new->c_ospeed = old->c_ospeed;
402 }
403 EXPORT_SYMBOL(tty_termios_copy_hw);
404
405 /**
406  *      tty_termios_hw_change   -       check for setting change
407  *      @a: termios
408  *      @b: termios to compare
409  *
410  *      Check if any of the bits that affect a dumb device have changed
411  *      between the two termios structures, or a speed change is needed.
412  */
413
414 int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
415 {
416         if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
417                 return 1;
418         if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
419                 return 1;
420         return 0;
421 }
422 EXPORT_SYMBOL(tty_termios_hw_change);
423
424 /**
425  *      change_termios          -       update termios values
426  *      @tty: tty to update
427  *      @new_termios: desired new value
428  *
429  *      Perform updates to the termios values set on this terminal. There
430  *      is a bit of layering violation here with n_tty in terms of the
431  *      internal knowledge of this function.
432  *
433  *      Locking: termios_sem
434  */
435
436 static void change_termios(struct tty_struct *tty, struct ktermios *new_termios)
437 {
438         int canon_change;
439         struct ktermios old_termios;
440         struct tty_ldisc *ld;
441         unsigned long flags;
442
443         /*
444          *      Perform the actual termios internal changes under lock.
445          */
446
447
448         /* FIXME: we need to decide on some locking/ordering semantics
449            for the set_termios notification eventually */
450         mutex_lock(&tty->termios_mutex);
451         old_termios = *tty->termios;
452         *tty->termios = *new_termios;
453         unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
454         canon_change = (old_termios.c_lflag ^ tty->termios->c_lflag) & ICANON;
455         if (canon_change) {
456                 memset(&tty->read_flags, 0, sizeof tty->read_flags);
457                 tty->canon_head = tty->read_tail;
458                 tty->canon_data = 0;
459                 tty->erasing = 0;
460         }
461
462         /* This bit should be in the ldisc code */
463         if (canon_change && !L_ICANON(tty) && tty->read_cnt)
464                 /* Get characters left over from canonical mode. */
465                 wake_up_interruptible(&tty->read_wait);
466
467         /* See if packet mode change of state. */
468         if (tty->link && tty->link->packet) {
469                 int old_flow = ((old_termios.c_iflag & IXON) &&
470                                 (old_termios.c_cc[VSTOP] == '\023') &&
471                                 (old_termios.c_cc[VSTART] == '\021'));
472                 int new_flow = (I_IXON(tty) &&
473                                 STOP_CHAR(tty) == '\023' &&
474                                 START_CHAR(tty) == '\021');
475                 if (old_flow != new_flow) {
476                         spin_lock_irqsave(&tty->ctrl_lock, flags);
477                         tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
478                         if (new_flow)
479                                 tty->ctrl_status |= TIOCPKT_DOSTOP;
480                         else
481                                 tty->ctrl_status |= TIOCPKT_NOSTOP;
482                         spin_unlock_irqrestore(&tty->ctrl_lock, flags);
483                         wake_up_interruptible(&tty->link->read_wait);
484                 }
485         }
486
487         if (tty->ops->set_termios)
488                 (*tty->ops->set_termios)(tty, &old_termios);
489         else
490                 tty_termios_copy_hw(tty->termios, &old_termios);
491
492         ld = tty_ldisc_ref(tty);
493         if (ld != NULL) {
494                 if (ld->set_termios)
495                         (ld->set_termios)(tty, &old_termios);
496                 tty_ldisc_deref(ld);
497         }
498         mutex_unlock(&tty->termios_mutex);
499 }
500
501 /**
502  *      set_termios             -       set termios values for a tty
503  *      @tty: terminal device
504  *      @arg: user data
505  *      @opt: option information
506  *
507  *      Helper function to prepare termios data and run necessary other
508  *      functions before using change_termios to do the actual changes.
509  *
510  *      Locking:
511  *              Called functions take ldisc and termios_sem locks
512  */
513
514 static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
515 {
516         struct ktermios tmp_termios;
517         struct tty_ldisc *ld;
518         int retval = tty_check_change(tty);
519
520         if (retval)
521                 return retval;
522
523         mutex_lock(&tty->termios_mutex);
524         memcpy(&tmp_termios, tty->termios, sizeof(struct ktermios));
525         mutex_unlock(&tty->termios_mutex);
526
527         if (opt & TERMIOS_TERMIO) {
528                 if (user_termio_to_kernel_termios(&tmp_termios,
529                                                 (struct termio __user *)arg))
530                         return -EFAULT;
531 #ifdef TCGETS2
532         } else if (opt & TERMIOS_OLD) {
533                 if (user_termios_to_kernel_termios_1(&tmp_termios,
534                                                 (struct termios __user *)arg))
535                         return -EFAULT;
536         } else {
537                 if (user_termios_to_kernel_termios(&tmp_termios,
538                                                 (struct termios2 __user *)arg))
539                         return -EFAULT;
540         }
541 #else
542         } else if (user_termios_to_kernel_termios(&tmp_termios,
543                                         (struct termios __user *)arg))
544                 return -EFAULT;
545 #endif
546
547         /* If old style Bfoo values are used then load c_ispeed/c_ospeed
548          * with the real speed so its unconditionally usable */
549         tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
550         tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
551
552         ld = tty_ldisc_ref(tty);
553
554         if (ld != NULL) {
555                 if ((opt & TERMIOS_FLUSH) && ld->flush_buffer)
556                         ld->flush_buffer(tty);
557                 tty_ldisc_deref(ld);
558         }
559
560         if (opt & TERMIOS_WAIT) {
561                 tty_wait_until_sent(tty, 0);
562                 if (signal_pending(current))
563                         return -EINTR;
564         }
565
566         change_termios(tty, &tmp_termios);
567
568         /* FIXME: Arguably if tmp_termios == tty->termios AND the
569            actual requested termios was not tmp_termios then we may
570            want to return an error as no user requested change has
571            succeeded */
572         return 0;
573 }
574
575 static int get_termio(struct tty_struct *tty, struct termio __user *termio)
576 {
577         if (kernel_termios_to_user_termio(termio, tty->termios))
578                 return -EFAULT;
579         return 0;
580 }
581
582 static unsigned long inq_canon(struct tty_struct *tty)
583 {
584         int nr, head, tail;
585
586         if (!tty->canon_data || !tty->read_buf)
587                 return 0;
588         head = tty->canon_head;
589         tail = tty->read_tail;
590         nr = (head - tail) & (N_TTY_BUF_SIZE-1);
591         /* Skip EOF-chars.. */
592         while (head != tail) {
593                 if (test_bit(tail, tty->read_flags) &&
594                     tty->read_buf[tail] == __DISABLED_CHAR)
595                         nr--;
596                 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
597         }
598         return nr;
599 }
600
601 #ifdef TIOCGETP
602 /*
603  * These are deprecated, but there is limited support..
604  *
605  * The "sg_flags" translation is a joke..
606  */
607 static int get_sgflags(struct tty_struct *tty)
608 {
609         int flags = 0;
610
611         if (!(tty->termios->c_lflag & ICANON)) {
612                 if (tty->termios->c_lflag & ISIG)
613                         flags |= 0x02;          /* cbreak */
614                 else
615                         flags |= 0x20;          /* raw */
616         }
617         if (tty->termios->c_lflag & ECHO)
618                 flags |= 0x08;                  /* echo */
619         if (tty->termios->c_oflag & OPOST)
620                 if (tty->termios->c_oflag & ONLCR)
621                         flags |= 0x10;          /* crmod */
622         return flags;
623 }
624
625 static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
626 {
627         struct sgttyb tmp;
628
629         mutex_lock(&tty->termios_mutex);
630         tmp.sg_ispeed = tty->termios->c_ispeed;
631         tmp.sg_ospeed = tty->termios->c_ospeed;
632         tmp.sg_erase = tty->termios->c_cc[VERASE];
633         tmp.sg_kill = tty->termios->c_cc[VKILL];
634         tmp.sg_flags = get_sgflags(tty);
635         mutex_unlock(&tty->termios_mutex);
636
637         return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
638 }
639
640 static void set_sgflags(struct ktermios *termios, int flags)
641 {
642         termios->c_iflag = ICRNL | IXON;
643         termios->c_oflag = 0;
644         termios->c_lflag = ISIG | ICANON;
645         if (flags & 0x02) {     /* cbreak */
646                 termios->c_iflag = 0;
647                 termios->c_lflag &= ~ICANON;
648         }
649         if (flags & 0x08) {             /* echo */
650                 termios->c_lflag |= ECHO | ECHOE | ECHOK |
651                                     ECHOCTL | ECHOKE | IEXTEN;
652         }
653         if (flags & 0x10) {             /* crmod */
654                 termios->c_oflag |= OPOST | ONLCR;
655         }
656         if (flags & 0x20) {     /* raw */
657                 termios->c_iflag = 0;
658                 termios->c_lflag &= ~(ISIG | ICANON);
659         }
660         if (!(termios->c_lflag & ICANON)) {
661                 termios->c_cc[VMIN] = 1;
662                 termios->c_cc[VTIME] = 0;
663         }
664 }
665
666 /**
667  *      set_sgttyb              -       set legacy terminal values
668  *      @tty: tty structure
669  *      @sgttyb: pointer to old style terminal structure
670  *
671  *      Updates a terminal from the legacy BSD style terminal information
672  *      structure.
673  *
674  *      Locking: termios_sem
675  */
676
677 static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
678 {
679         int retval;
680         struct sgttyb tmp;
681         struct ktermios termios;
682
683         retval = tty_check_change(tty);
684         if (retval)
685                 return retval;
686
687         if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
688                 return -EFAULT;
689
690         mutex_lock(&tty->termios_mutex);
691         termios = *tty->termios;
692         termios.c_cc[VERASE] = tmp.sg_erase;
693         termios.c_cc[VKILL] = tmp.sg_kill;
694         set_sgflags(&termios, tmp.sg_flags);
695         /* Try and encode into Bfoo format */
696 #ifdef BOTHER
697         tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
698                                                 termios.c_ospeed);
699 #endif
700         mutex_unlock(&tty->termios_mutex);
701         change_termios(tty, &termios);
702         return 0;
703 }
704 #endif
705
706 #ifdef TIOCGETC
707 static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
708 {
709         struct tchars tmp;
710
711         mutex_lock(&tty->termios_mutex);
712         tmp.t_intrc = tty->termios->c_cc[VINTR];
713         tmp.t_quitc = tty->termios->c_cc[VQUIT];
714         tmp.t_startc = tty->termios->c_cc[VSTART];
715         tmp.t_stopc = tty->termios->c_cc[VSTOP];
716         tmp.t_eofc = tty->termios->c_cc[VEOF];
717         tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
718         mutex_unlock(&tty->termios_mutex);
719         return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
720 }
721
722 static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
723 {
724         struct tchars tmp;
725
726         if (copy_from_user(&tmp, tchars, sizeof(tmp)))
727                 return -EFAULT;
728         mutex_lock(&tty->termios_mutex);
729         tty->termios->c_cc[VINTR] = tmp.t_intrc;
730         tty->termios->c_cc[VQUIT] = tmp.t_quitc;
731         tty->termios->c_cc[VSTART] = tmp.t_startc;
732         tty->termios->c_cc[VSTOP] = tmp.t_stopc;
733         tty->termios->c_cc[VEOF] = tmp.t_eofc;
734         tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
735         mutex_unlock(&tty->termios_mutex);
736         return 0;
737 }
738 #endif
739
740 #ifdef TIOCGLTC
741 static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
742 {
743         struct ltchars tmp;
744
745         mutex_lock(&tty->termios_mutex);
746         tmp.t_suspc = tty->termios->c_cc[VSUSP];
747         /* what is dsuspc anyway? */
748         tmp.t_dsuspc = tty->termios->c_cc[VSUSP];
749         tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
750         /* what is flushc anyway? */
751         tmp.t_flushc = tty->termios->c_cc[VEOL2];
752         tmp.t_werasc = tty->termios->c_cc[VWERASE];
753         tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
754         mutex_unlock(&tty->termios_mutex);
755         return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
756 }
757
758 static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
759 {
760         struct ltchars tmp;
761
762         if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
763                 return -EFAULT;
764
765         mutex_lock(&tty->termios_mutex);
766         tty->termios->c_cc[VSUSP] = tmp.t_suspc;
767         /* what is dsuspc anyway? */
768         tty->termios->c_cc[VEOL2] = tmp.t_dsuspc;
769         tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
770         /* what is flushc anyway? */
771         tty->termios->c_cc[VEOL2] = tmp.t_flushc;
772         tty->termios->c_cc[VWERASE] = tmp.t_werasc;
773         tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
774         mutex_unlock(&tty->termios_mutex);
775         return 0;
776 }
777 #endif
778
779 /**
780  *      send_prio_char          -       send priority character
781  *
782  *      Send a high priority character to the tty even if stopped
783  *
784  *      Locking: none for xchar method, write ordering for write method.
785  */
786
787 static int send_prio_char(struct tty_struct *tty, char ch)
788 {
789         int     was_stopped = tty->stopped;
790
791         if (tty->ops->send_xchar) {
792                 tty->ops->send_xchar(tty, ch);
793                 return 0;
794         }
795
796         if (tty_write_lock(tty, 0) < 0)
797                 return -ERESTARTSYS;
798
799         if (was_stopped)
800                 start_tty(tty);
801         tty->ops->write(tty, &ch, 1);
802         if (was_stopped)
803                 stop_tty(tty);
804         tty_write_unlock(tty);
805         return 0;
806 }
807
808 /**
809  *      tty_change_softcar      -       carrier change ioctl helper
810  *      @tty: tty to update
811  *      @arg: enable/disable CLOCAL
812  *
813  *      Perform a change to the CLOCAL state and call into the driver
814  *      layer to make it visible. All done with the termios mutex
815  */
816
817 static int tty_change_softcar(struct tty_struct *tty, int arg)
818 {
819         int ret = 0;
820         int bit = arg ? CLOCAL : 0;
821         struct ktermios old;
822
823         mutex_lock(&tty->termios_mutex);
824         old = *tty->termios;
825         tty->termios->c_cflag &= ~CLOCAL;
826         tty->termios->c_cflag |= bit;
827         if (tty->ops->set_termios)
828                 tty->ops->set_termios(tty, &old);
829         if ((tty->termios->c_cflag & CLOCAL) != bit)
830                 ret = -EINVAL;
831         mutex_unlock(&tty->termios_mutex);
832         return ret;
833 }
834
835 /**
836  *      tty_mode_ioctl          -       mode related ioctls
837  *      @tty: tty for the ioctl
838  *      @file: file pointer for the tty
839  *      @cmd: command
840  *      @arg: ioctl argument
841  *
842  *      Perform non line discipline specific mode control ioctls. This
843  *      is designed to be called by line disciplines to ensure they provide
844  *      consistent mode setting.
845  */
846
847 int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
848                         unsigned int cmd, unsigned long arg)
849 {
850         struct tty_struct *real_tty;
851         void __user *p = (void __user *)arg;
852
853         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
854             tty->driver->subtype == PTY_TYPE_MASTER)
855                 real_tty = tty->link;
856         else
857                 real_tty = tty;
858
859         switch (cmd) {
860 #ifdef TIOCGETP
861         case TIOCGETP:
862                 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
863         case TIOCSETP:
864         case TIOCSETN:
865                 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
866 #endif
867 #ifdef TIOCGETC
868         case TIOCGETC:
869                 return get_tchars(real_tty, p);
870         case TIOCSETC:
871                 return set_tchars(real_tty, p);
872 #endif
873 #ifdef TIOCGLTC
874         case TIOCGLTC:
875                 return get_ltchars(real_tty, p);
876         case TIOCSLTC:
877                 return set_ltchars(real_tty, p);
878 #endif
879         case TCSETSF:
880                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
881         case TCSETSW:
882                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
883         case TCSETS:
884                 return set_termios(real_tty, p, TERMIOS_OLD);
885 #ifndef TCGETS2
886         case TCGETS:
887                 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios))
888                         return -EFAULT;
889                 return 0;
890 #else
891         case TCGETS:
892                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, real_tty->termios))
893                         return -EFAULT;
894                 return 0;
895         case TCGETS2:
896                 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, real_tty->termios))
897                         return -EFAULT;
898                 return 0;
899         case TCSETSF2:
900                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
901         case TCSETSW2:
902                 return set_termios(real_tty, p, TERMIOS_WAIT);
903         case TCSETS2:
904                 return set_termios(real_tty, p, 0);
905 #endif
906         case TCGETA:
907                 return get_termio(real_tty, p);
908         case TCSETAF:
909                 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
910         case TCSETAW:
911                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
912         case TCSETA:
913                 return set_termios(real_tty, p, TERMIOS_TERMIO);
914 #ifndef TCGETS2
915         case TIOCGLCKTRMIOS:
916                 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios_locked))
917                         return -EFAULT;
918                 return 0;
919         case TIOCSLCKTRMIOS:
920                 if (!capable(CAP_SYS_ADMIN))
921                         return -EPERM;
922                 if (user_termios_to_kernel_termios(real_tty->termios_locked,
923                                                (struct termios __user *) arg))
924                         return -EFAULT;
925                 return 0;
926 #else
927         case TIOCGLCKTRMIOS:
928                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, real_tty->termios_locked))
929                         return -EFAULT;
930                 return 0;
931         case TIOCSLCKTRMIOS:
932                 if (!capable(CAP_SYS_ADMIN))
933                         return -EPERM;
934                 if (user_termios_to_kernel_termios_1(real_tty->termios_locked,
935                                                (struct termios __user *) arg))
936                         return -EFAULT;
937                         return 0;
938 #endif
939         case TIOCGSOFTCAR:
940                 return put_user(C_CLOCAL(tty) ? 1 : 0,
941                                                 (int __user *)arg);
942         case TIOCSSOFTCAR:
943                 if (get_user(arg, (unsigned int __user *) arg))
944                         return -EFAULT;
945                 return tty_change_softcar(tty, arg);
946         default:
947                 return -ENOIOCTLCMD;
948         }
949 }
950 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
951
952 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
953 {
954         struct tty_ldisc *ld;
955         int retval = tty_check_change(tty);
956         if (retval)
957                 return retval;
958
959         ld = tty_ldisc_ref(tty);
960         switch (arg) {
961         case TCIFLUSH:
962                 if (ld && ld->flush_buffer)
963                         ld->flush_buffer(tty);
964                 break;
965         case TCIOFLUSH:
966                 if (ld && ld->flush_buffer)
967                         ld->flush_buffer(tty);
968                 /* fall through */
969         case TCOFLUSH:
970                 tty_driver_flush_buffer(tty);
971                 break;
972         default:
973                 tty_ldisc_deref(ld);
974                 return -EINVAL;
975         }
976         tty_ldisc_deref(ld);
977         return 0;
978 }
979 EXPORT_SYMBOL_GPL(tty_perform_flush);
980
981 int n_tty_ioctl(struct tty_struct *tty, struct file *file,
982                        unsigned int cmd, unsigned long arg)
983 {
984         struct tty_struct *real_tty;
985         unsigned long flags;
986         int retval;
987
988         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
989             tty->driver->subtype == PTY_TYPE_MASTER)
990                 real_tty = tty->link;
991         else
992                 real_tty = tty;
993
994         switch (cmd) {
995         case TCXONC:
996                 retval = tty_check_change(tty);
997                 if (retval)
998                         return retval;
999                 switch (arg) {
1000                 case TCOOFF:
1001                         if (!tty->flow_stopped) {
1002                                 tty->flow_stopped = 1;
1003                                 stop_tty(tty);
1004                         }
1005                         break;
1006                 case TCOON:
1007                         if (tty->flow_stopped) {
1008                                 tty->flow_stopped = 0;
1009                                 start_tty(tty);
1010                         }
1011                         break;
1012                 case TCIOFF:
1013                         if (STOP_CHAR(tty) != __DISABLED_CHAR)
1014                                 return send_prio_char(tty, STOP_CHAR(tty));
1015                         break;
1016                 case TCION:
1017                         if (START_CHAR(tty) != __DISABLED_CHAR)
1018                                 return send_prio_char(tty, START_CHAR(tty));
1019                         break;
1020                 default:
1021                         return -EINVAL;
1022                 }
1023                 return 0;
1024         case TCFLSH:
1025                 return tty_perform_flush(tty, arg);
1026         case TIOCOUTQ:
1027                 return put_user(tty_chars_in_buffer(tty), (int __user *) arg);
1028         case TIOCINQ:
1029                 retval = tty->read_cnt;
1030                 if (L_ICANON(tty))
1031                         retval = inq_canon(tty);
1032                 return put_user(retval, (unsigned int __user *) arg);
1033         case TIOCPKT:
1034         {
1035                 int pktmode;
1036
1037                 if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
1038                     tty->driver->subtype != PTY_TYPE_MASTER)
1039                         return -ENOTTY;
1040                 if (get_user(pktmode, (int __user *) arg))
1041                         return -EFAULT;
1042                 spin_lock_irqsave(&tty->ctrl_lock, flags);
1043                 if (pktmode) {
1044                         if (!tty->packet) {
1045                                 tty->packet = 1;
1046                                 tty->link->ctrl_status = 0;
1047                         }
1048                 } else
1049                         tty->packet = 0;
1050                 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
1051                 return 0;
1052         }
1053         default:
1054                 /* Try the mode commands */
1055                 return tty_mode_ioctl(tty, file, cmd, arg);
1056         }
1057 }
1058 EXPORT_SYMBOL(n_tty_ioctl);