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