Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[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
951         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
952             tty->driver->subtype == PTY_TYPE_MASTER)
953                 real_tty = tty->link;
954         else
955                 real_tty = tty;
956
957         switch (cmd) {
958 #ifdef TIOCGETP
959         case TIOCGETP:
960                 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
961         case TIOCSETP:
962         case TIOCSETN:
963                 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
964 #endif
965 #ifdef TIOCGETC
966         case TIOCGETC:
967                 return get_tchars(real_tty, p);
968         case TIOCSETC:
969                 return set_tchars(real_tty, p);
970 #endif
971 #ifdef TIOCGLTC
972         case TIOCGLTC:
973                 return get_ltchars(real_tty, p);
974         case TIOCSLTC:
975                 return set_ltchars(real_tty, p);
976 #endif
977         case TCSETSF:
978                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
979         case TCSETSW:
980                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
981         case TCSETS:
982                 return set_termios(real_tty, p, TERMIOS_OLD);
983 #ifndef TCGETS2
984         case TCGETS:
985                 copy_termios(real_tty, &kterm);
986                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
987                         ret = -EFAULT;
988                 return ret;
989 #else
990         case TCGETS:
991                 copy_termios(real_tty, &kterm);
992                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
993                         ret = -EFAULT;
994                 return ret;
995         case TCGETS2:
996                 copy_termios(real_tty, &kterm);
997                 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
998                         ret = -EFAULT;
999                 return ret;
1000         case TCSETSF2:
1001                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
1002         case TCSETSW2:
1003                 return set_termios(real_tty, p, TERMIOS_WAIT);
1004         case TCSETS2:
1005                 return set_termios(real_tty, p, 0);
1006 #endif
1007         case TCGETA:
1008                 return get_termio(real_tty, p);
1009         case TCSETAF:
1010                 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
1011         case TCSETAW:
1012                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
1013         case TCSETA:
1014                 return set_termios(real_tty, p, TERMIOS_TERMIO);
1015 #ifndef TCGETS2
1016         case TIOCGLCKTRMIOS:
1017                 copy_termios_locked(real_tty, &kterm);
1018                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
1019                         ret = -EFAULT;
1020                 return ret;
1021         case TIOCSLCKTRMIOS:
1022                 if (!capable(CAP_SYS_ADMIN))
1023                         return -EPERM;
1024                 copy_termios_locked(real_tty, &kterm);
1025                 if (user_termios_to_kernel_termios(&kterm,
1026                                                (struct termios __user *) arg))
1027                         return -EFAULT;
1028                 mutex_lock(&real_tty->termios_mutex);
1029                 memcpy(real_tty->termios_locked, &kterm, sizeof(struct ktermios));
1030                 mutex_unlock(&real_tty->termios_mutex);
1031                 return 0;
1032 #else
1033         case TIOCGLCKTRMIOS:
1034                 copy_termios_locked(real_tty, &kterm);
1035                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
1036                         ret = -EFAULT;
1037                 return ret;
1038         case TIOCSLCKTRMIOS:
1039                 if (!capable(CAP_SYS_ADMIN))
1040                         return -EPERM;
1041                 copy_termios_locked(real_tty, &kterm);
1042                 if (user_termios_to_kernel_termios_1(&kterm,
1043                                                (struct termios __user *) arg))
1044                         return -EFAULT;
1045                 mutex_lock(&real_tty->termios_mutex);
1046                 memcpy(real_tty->termios_locked, &kterm, sizeof(struct ktermios));
1047                 mutex_unlock(&real_tty->termios_mutex);
1048                 return ret;
1049 #endif
1050 #ifdef TCGETX
1051         case TCGETX: {
1052                 struct termiox ktermx;
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         }
1062         case TCSETX:
1063                 return set_termiox(real_tty, p, 0);
1064         case TCSETXW:
1065                 return set_termiox(real_tty, p, TERMIOS_WAIT);
1066         case TCSETXF:
1067                 return set_termiox(real_tty, p, TERMIOS_FLUSH);
1068 #endif          
1069         case TIOCGSOFTCAR:
1070                 copy_termios(real_tty, &kterm);
1071                 ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
1072                                                 (int __user *)arg);
1073                 return ret;
1074         case TIOCSSOFTCAR:
1075                 if (get_user(arg, (unsigned int __user *) arg))
1076                         return -EFAULT;
1077                 return tty_change_softcar(real_tty, arg);
1078         default:
1079                 return -ENOIOCTLCMD;
1080         }
1081 }
1082 EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1083
1084 int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1085 {
1086         struct tty_ldisc *ld;
1087         int retval = tty_check_change(tty);
1088         if (retval)
1089                 return retval;
1090
1091         ld = tty_ldisc_ref_wait(tty);
1092         switch (arg) {
1093         case TCIFLUSH:
1094                 if (ld && ld->ops->flush_buffer)
1095                         ld->ops->flush_buffer(tty);
1096                 break;
1097         case TCIOFLUSH:
1098                 if (ld && ld->ops->flush_buffer)
1099                         ld->ops->flush_buffer(tty);
1100                 /* fall through */
1101         case TCOFLUSH:
1102                 tty_driver_flush_buffer(tty);
1103                 break;
1104         default:
1105                 tty_ldisc_deref(ld);
1106                 return -EINVAL;
1107         }
1108         tty_ldisc_deref(ld);
1109         return 0;
1110 }
1111 EXPORT_SYMBOL_GPL(tty_perform_flush);
1112
1113 int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
1114                        unsigned int cmd, unsigned long arg)
1115 {
1116         unsigned long flags;
1117         int retval;
1118
1119         switch (cmd) {
1120         case TCXONC:
1121                 retval = tty_check_change(tty);
1122                 if (retval)
1123                         return retval;
1124                 switch (arg) {
1125                 case TCOOFF:
1126                         if (!tty->flow_stopped) {
1127                                 tty->flow_stopped = 1;
1128                                 stop_tty(tty);
1129                         }
1130                         break;
1131                 case TCOON:
1132                         if (tty->flow_stopped) {
1133                                 tty->flow_stopped = 0;
1134                                 start_tty(tty);
1135                         }
1136                         break;
1137                 case TCIOFF:
1138                         if (STOP_CHAR(tty) != __DISABLED_CHAR)
1139                                 return send_prio_char(tty, STOP_CHAR(tty));
1140                         break;
1141                 case TCION:
1142                         if (START_CHAR(tty) != __DISABLED_CHAR)
1143                                 return send_prio_char(tty, START_CHAR(tty));
1144                         break;
1145                 default:
1146                         return -EINVAL;
1147                 }
1148                 return 0;
1149         case TCFLSH:
1150                 return tty_perform_flush(tty, arg);
1151         case TIOCPKT:
1152         {
1153                 int pktmode;
1154
1155                 if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
1156                     tty->driver->subtype != PTY_TYPE_MASTER)
1157                         return -ENOTTY;
1158                 if (get_user(pktmode, (int __user *) arg))
1159                         return -EFAULT;
1160                 spin_lock_irqsave(&tty->ctrl_lock, flags);
1161                 if (pktmode) {
1162                         if (!tty->packet) {
1163                                 tty->packet = 1;
1164                                 tty->link->ctrl_status = 0;
1165                         }
1166                 } else
1167                         tty->packet = 0;
1168                 spin_unlock_irqrestore(&tty->ctrl_lock, flags);
1169                 return 0;
1170         }
1171         default:
1172                 /* Try the mode commands */
1173                 return tty_mode_ioctl(tty, file, cmd, arg);
1174         }
1175 }
1176 EXPORT_SYMBOL(n_tty_ioctl_helper);