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