intel-iommu: Fix enabling snooping feature by mistake
[linux-2.6.git] / 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
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 compatiblity.
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                 static int warned;
397                 if (!warned++)
398                         printk(KERN_WARNING "tty: Unable to return correct "
399                           "speed data as your architecture needs updating.\n");
400         }
401 #endif
402 }
403 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
404
405 /**
406  *      tty_encode_baud_rate            -       set baud rate of the tty
407  *      @ibaud: input baud rate
408  *      @obad: output baud rate
409  *
410  *      Update the current termios data for the tty with the new speed
411  *      settings. The caller must hold the termios_mutex for the tty in
412  *      question.
413  */
414
415 void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
416 {
417         tty_termios_encode_baud_rate(tty->termios, ibaud, obaud);
418 }
419 EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
420
421 /**
422  *      tty_get_baud_rate       -       get tty bit rates
423  *      @tty: tty to query
424  *
425  *      Returns the baud rate as an integer for this terminal. The
426  *      termios lock must be held by the caller and the terminal bit
427  *      flags may be updated.
428  *
429  *      Locking: none
430  */
431
432 speed_t tty_get_baud_rate(struct tty_struct *tty)
433 {
434         speed_t baud = tty_termios_baud_rate(tty->termios);
435
436         if (baud == 38400 && tty->alt_speed) {
437                 if (!tty->warned) {
438                         printk(KERN_WARNING "Use of setserial/setrocket to "
439                                             "set SPD_* flags is deprecated\n");
440                         tty->warned = 1;
441                 }
442                 baud = tty->alt_speed;
443         }
444
445         return baud;
446 }
447 EXPORT_SYMBOL(tty_get_baud_rate);
448
449 /**
450  *      tty_termios_copy_hw     -       copy hardware settings
451  *      @new: New termios
452  *      @old: Old termios
453  *
454  *      Propogate the hardware specific terminal setting bits from
455  *      the old termios structure to the new one. This is used in cases
456  *      where the hardware does not support reconfiguration or as a helper
457  *      in some cases where only minimal reconfiguration is supported
458  */
459
460 void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old)
461 {
462         /* The bits a dumb device handles in software. Smart devices need
463            to always provide a set_termios method */
464         new->c_cflag &= HUPCL | CREAD | CLOCAL;
465         new->c_cflag |= old->c_cflag & ~(HUPCL | CREAD | CLOCAL);
466         new->c_ispeed = old->c_ispeed;
467         new->c_ospeed = old->c_ospeed;
468 }
469 EXPORT_SYMBOL(tty_termios_copy_hw);
470
471 /**
472  *      tty_termios_hw_change   -       check for setting change
473  *      @a: termios
474  *      @b: termios to compare
475  *
476  *      Check if any of the bits that affect a dumb device have changed
477  *      between the two termios structures, or a speed change is needed.
478  */
479
480 int tty_termios_hw_change(struct ktermios *a, struct ktermios *b)
481 {
482         if (a->c_ispeed != b->c_ispeed || a->c_ospeed != b->c_ospeed)
483                 return 1;
484         if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL | CREAD | CLOCAL))
485                 return 1;
486         return 0;
487 }
488 EXPORT_SYMBOL(tty_termios_hw_change);
489
490 /**
491  *      change_termios          -       update termios values
492  *      @tty: tty to update
493  *      @new_termios: desired new value
494  *
495  *      Perform updates to the termios values set on this terminal. There
496  *      is a bit of layering violation here with n_tty in terms of the
497  *      internal knowledge of this function.
498  *
499  *      Locking: termios_mutex
500  */
501
502 static void change_termios(struct tty_struct *tty, struct ktermios *new_termios)
503 {
504         struct ktermios old_termios;
505         struct tty_ldisc *ld;
506         unsigned long flags;
507
508         /*
509          *      Perform the actual termios internal changes under lock.
510          */
511
512
513         /* FIXME: we need to decide on some locking/ordering semantics
514            for the set_termios notification eventually */
515         mutex_lock(&tty->termios_mutex);
516         old_termios = *tty->termios;
517         *tty->termios = *new_termios;
518         unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
519
520         /* See if packet mode change of state. */
521         if (tty->link && tty->link->packet) {
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) {
529                         spin_lock_irqsave(&tty->ctrl_lock, flags);
530                         tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
531                         if (new_flow)
532                                 tty->ctrl_status |= TIOCPKT_DOSTOP;
533                         else
534                                 tty->ctrl_status |= TIOCPKT_NOSTOP;
535                         spin_unlock_irqrestore(&tty->ctrl_lock, flags);
536                         wake_up_interruptible(&tty->link->read_wait);
537                 }
538         }
539
540         if (tty->ops->set_termios)
541                 (*tty->ops->set_termios)(tty, &old_termios);
542         else
543                 tty_termios_copy_hw(tty->termios, &old_termios);
544
545         ld = tty_ldisc_ref(tty);
546         if (ld != NULL) {
547                 if (ld->ops->set_termios)
548                         (ld->ops->set_termios)(tty, &old_termios);
549                 tty_ldisc_deref(ld);
550         }
551         mutex_unlock(&tty->termios_mutex);
552 }
553
554 /**
555  *      set_termios             -       set termios values for a tty
556  *      @tty: terminal device
557  *      @arg: user data
558  *      @opt: option information
559  *
560  *      Helper function to prepare termios data and run necessary other
561  *      functions before using change_termios to do the actual changes.
562  *
563  *      Locking:
564  *              Called functions take ldisc and termios_mutex locks
565  */
566
567 static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
568 {
569         struct ktermios tmp_termios;
570         struct tty_ldisc *ld;
571         int retval = tty_check_change(tty);
572
573         if (retval)
574                 return retval;
575
576         mutex_lock(&tty->termios_mutex);
577         memcpy(&tmp_termios, tty->termios, sizeof(struct ktermios));
578         mutex_unlock(&tty->termios_mutex);
579
580         if (opt & TERMIOS_TERMIO) {
581                 if (user_termio_to_kernel_termios(&tmp_termios,
582                                                 (struct termio __user *)arg))
583                         return -EFAULT;
584 #ifdef TCGETS2
585         } else if (opt & TERMIOS_OLD) {
586                 if (user_termios_to_kernel_termios_1(&tmp_termios,
587                                                 (struct termios __user *)arg))
588                         return -EFAULT;
589         } else {
590                 if (user_termios_to_kernel_termios(&tmp_termios,
591                                                 (struct termios2 __user *)arg))
592                         return -EFAULT;
593         }
594 #else
595         } else if (user_termios_to_kernel_termios(&tmp_termios,
596                                         (struct termios __user *)arg))
597                 return -EFAULT;
598 #endif
599
600         /* If old style Bfoo values are used then load c_ispeed/c_ospeed
601          * with the real speed so its unconditionally usable */
602         tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
603         tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
604
605         ld = tty_ldisc_ref(tty);
606
607         if (ld != NULL) {
608                 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
609                         ld->ops->flush_buffer(tty);
610                 tty_ldisc_deref(ld);
611         }
612
613         if (opt & TERMIOS_WAIT) {
614                 tty_wait_until_sent(tty, 0);
615                 if (signal_pending(current))
616                         return -EINTR;
617         }
618
619         change_termios(tty, &tmp_termios);
620
621         /* FIXME: Arguably if tmp_termios == tty->termios AND the
622            actual requested termios was not tmp_termios then we may
623            want to return an error as no user requested change has
624            succeeded */
625         return 0;
626 }
627
628 static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
629 {
630         mutex_lock(&tty->termios_mutex);
631         memcpy(kterm, tty->termios, sizeof(struct ktermios));
632         mutex_unlock(&tty->termios_mutex);
633 }
634
635 static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
636 {
637         mutex_lock(&tty->termios_mutex);
638         memcpy(kterm, tty->termios_locked, sizeof(struct ktermios));
639         mutex_unlock(&tty->termios_mutex);
640 }
641
642 static int get_termio(struct tty_struct *tty, struct termio __user *termio)
643 {
644         struct ktermios kterm;
645         copy_termios(tty, &kterm);
646         if (kernel_termios_to_user_termio(termio, &kterm))
647                 return -EFAULT;
648         return 0;
649 }
650
651
652 #ifdef TCGETX
653
654 /**
655  *      set_termiox     -       set termiox fields if possible
656  *      @tty: terminal
657  *      @arg: termiox structure from user
658  *      @opt: option flags for ioctl type
659  *
660  *      Implement the device calling points for the SYS5 termiox ioctl
661  *      interface in Linux
662  */
663
664 static int set_termiox(struct tty_struct *tty, void __user *arg, int opt)
665 {
666         struct termiox tnew;
667         struct tty_ldisc *ld;
668
669         if (tty->termiox == NULL)
670                 return -EINVAL;
671         if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
672                 return -EFAULT;
673
674         ld = tty_ldisc_ref(tty);
675         if (ld != NULL) {
676                 if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
677                         ld->ops->flush_buffer(tty);
678                 tty_ldisc_deref(ld);
679         }
680         if (opt & TERMIOS_WAIT) {
681                 tty_wait_until_sent(tty, 0);
682                 if (signal_pending(current))
683                         return -EINTR;
684         }
685
686         mutex_lock(&tty->termios_mutex);
687         if (tty->ops->set_termiox)
688                 tty->ops->set_termiox(tty, &tnew);
689         mutex_unlock(&tty->termios_mutex);
690         return 0;
691 }
692
693 #endif
694
695
696 #ifdef TIOCGETP
697 /*
698  * These are deprecated, but there is limited support..
699  *
700  * The "sg_flags" translation is a joke..
701  */
702 static int get_sgflags(struct tty_struct *tty)
703 {
704         int flags = 0;
705
706         if (!(tty->termios->c_lflag & ICANON)) {
707                 if (tty->termios->c_lflag & ISIG)
708                         flags |= 0x02;          /* cbreak */
709                 else
710                         flags |= 0x20;          /* raw */
711         }
712         if (tty->termios->c_lflag & ECHO)
713                 flags |= 0x08;                  /* echo */
714         if (tty->termios->c_oflag & OPOST)
715                 if (tty->termios->c_oflag & ONLCR)
716                         flags |= 0x10;          /* crmod */
717         return flags;
718 }
719
720 static int get_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
721 {
722         struct sgttyb tmp;
723
724         mutex_lock(&tty->termios_mutex);
725         tmp.sg_ispeed = tty->termios->c_ispeed;
726         tmp.sg_ospeed = tty->termios->c_ospeed;
727         tmp.sg_erase = tty->termios->c_cc[VERASE];
728         tmp.sg_kill = tty->termios->c_cc[VKILL];
729         tmp.sg_flags = get_sgflags(tty);
730         mutex_unlock(&tty->termios_mutex);
731
732         return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
733 }
734
735 static void set_sgflags(struct ktermios *termios, int flags)
736 {
737         termios->c_iflag = ICRNL | IXON;
738         termios->c_oflag = 0;
739         termios->c_lflag = ISIG | ICANON;
740         if (flags & 0x02) {     /* cbreak */
741                 termios->c_iflag = 0;
742                 termios->c_lflag &= ~ICANON;
743         }
744         if (flags & 0x08) {             /* echo */
745                 termios->c_lflag |= ECHO | ECHOE | ECHOK |
746                                     ECHOCTL | ECHOKE | IEXTEN;
747         }
748         if (flags & 0x10) {             /* crmod */
749                 termios->c_oflag |= OPOST | ONLCR;
750         }
751         if (flags & 0x20) {     /* raw */
752                 termios->c_iflag = 0;
753                 termios->c_lflag &= ~(ISIG | ICANON);
754         }
755         if (!(termios->c_lflag & ICANON)) {
756                 termios->c_cc[VMIN] = 1;
757                 termios->c_cc[VTIME] = 0;
758         }
759 }
760
761 /**
762  *      set_sgttyb              -       set legacy terminal values
763  *      @tty: tty structure
764  *      @sgttyb: pointer to old style terminal structure
765  *
766  *      Updates a terminal from the legacy BSD style terminal information
767  *      structure.
768  *
769  *      Locking: termios_mutex
770  */
771
772 static int set_sgttyb(struct tty_struct *tty, struct sgttyb __user *sgttyb)
773 {
774         int retval;
775         struct sgttyb tmp;
776         struct ktermios termios;
777
778         retval = tty_check_change(tty);
779         if (retval)
780                 return retval;
781
782         if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
783                 return -EFAULT;
784
785         mutex_lock(&tty->termios_mutex);
786         termios = *tty->termios;
787         termios.c_cc[VERASE] = tmp.sg_erase;
788         termios.c_cc[VKILL] = tmp.sg_kill;
789         set_sgflags(&termios, tmp.sg_flags);
790         /* Try and encode into Bfoo format */
791 #ifdef BOTHER
792         tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
793                                                 termios.c_ospeed);
794 #endif
795         mutex_unlock(&tty->termios_mutex);
796         change_termios(tty, &termios);
797         return 0;
798 }
799 #endif
800
801 #ifdef TIOCGETC
802 static int get_tchars(struct tty_struct *tty, struct tchars __user *tchars)
803 {
804         struct tchars tmp;
805
806         mutex_lock(&tty->termios_mutex);
807         tmp.t_intrc = tty->termios->c_cc[VINTR];
808         tmp.t_quitc = tty->termios->c_cc[VQUIT];
809         tmp.t_startc = tty->termios->c_cc[VSTART];
810         tmp.t_stopc = tty->termios->c_cc[VSTOP];
811         tmp.t_eofc = tty->termios->c_cc[VEOF];
812         tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
813         mutex_unlock(&tty->termios_mutex);
814         return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
815 }
816
817 static int set_tchars(struct tty_struct *tty, struct tchars __user *tchars)
818 {
819         struct tchars tmp;
820
821         if (copy_from_user(&tmp, tchars, sizeof(tmp)))
822                 return -EFAULT;
823         mutex_lock(&tty->termios_mutex);
824         tty->termios->c_cc[VINTR] = tmp.t_intrc;
825         tty->termios->c_cc[VQUIT] = tmp.t_quitc;
826         tty->termios->c_cc[VSTART] = tmp.t_startc;
827         tty->termios->c_cc[VSTOP] = tmp.t_stopc;
828         tty->termios->c_cc[VEOF] = tmp.t_eofc;
829         tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
830         mutex_unlock(&tty->termios_mutex);
831         return 0;
832 }
833 #endif
834
835 #ifdef TIOCGLTC
836 static int get_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
837 {
838         struct ltchars tmp;
839
840         mutex_lock(&tty->termios_mutex);
841         tmp.t_suspc = tty->termios->c_cc[VSUSP];
842         /* what is dsuspc anyway? */
843         tmp.t_dsuspc = tty->termios->c_cc[VSUSP];
844         tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
845         /* what is flushc anyway? */
846         tmp.t_flushc = tty->termios->c_cc[VEOL2];
847         tmp.t_werasc = tty->termios->c_cc[VWERASE];
848         tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
849         mutex_unlock(&tty->termios_mutex);
850         return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
851 }
852
853 static int set_ltchars(struct tty_struct *tty, struct ltchars __user *ltchars)
854 {
855         struct ltchars tmp;
856
857         if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
858                 return -EFAULT;
859
860         mutex_lock(&tty->termios_mutex);
861         tty->termios->c_cc[VSUSP] = tmp.t_suspc;
862         /* what is dsuspc anyway? */
863         tty->termios->c_cc[VEOL2] = tmp.t_dsuspc;
864         tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
865         /* what is flushc anyway? */
866         tty->termios->c_cc[VEOL2] = tmp.t_flushc;
867         tty->termios->c_cc[VWERASE] = tmp.t_werasc;
868         tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
869         mutex_unlock(&tty->termios_mutex);
870         return 0;
871 }
872 #endif
873
874 /**
875  *      send_prio_char          -       send priority character
876  *
877  *      Send a high priority character to the tty even if stopped
878  *
879  *      Locking: none for xchar method, write ordering for write method.
880  */
881
882 static int send_prio_char(struct tty_struct *tty, char ch)
883 {
884         int     was_stopped = tty->stopped;
885
886         if (tty->ops->send_xchar) {
887                 tty->ops->send_xchar(tty, ch);
888                 return 0;
889         }
890
891         if (tty_write_lock(tty, 0) < 0)
892                 return -ERESTARTSYS;
893
894         if (was_stopped)
895                 start_tty(tty);
896         tty->ops->write(tty, &ch, 1);
897         if (was_stopped)
898                 stop_tty(tty);
899         tty_write_unlock(tty);
900         return 0;
901 }
902
903 /**
904  *      tty_change_softcar      -       carrier change ioctl helper
905  *      @tty: tty to update
906  *      @arg: enable/disable CLOCAL
907  *
908  *      Perform a change to the CLOCAL state and call into the driver
909  *      layer to make it visible. All done with the termios mutex
910  */
911
912 static int tty_change_softcar(struct tty_struct *tty, int arg)
913 {
914         int ret = 0;
915         int bit = arg ? CLOCAL : 0;
916         struct ktermios old;
917
918         mutex_lock(&tty->termios_mutex);
919         old = *tty->termios;
920         tty->termios->c_cflag &= ~CLOCAL;
921         tty->termios->c_cflag |= bit;
922         if (tty->ops->set_termios)
923                 tty->ops->set_termios(tty, &old);
924         if ((tty->termios->c_cflag & CLOCAL) != bit)
925                 ret = -EINVAL;
926         mutex_unlock(&tty->termios_mutex);
927         return ret;
928 }
929
930 /**
931  *      tty_mode_ioctl          -       mode related ioctls
932  *      @tty: tty for the ioctl
933  *      @file: file pointer for the tty
934  *      @cmd: command
935  *      @arg: ioctl argument
936  *
937  *      Perform non line discipline specific mode control ioctls. This
938  *      is designed to be called by line disciplines to ensure they provide
939  *      consistent mode setting.
940  */
941
942 int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
943                         unsigned int cmd, unsigned long arg)
944 {
945         struct tty_struct *real_tty;
946         void __user *p = (void __user *)arg;
947         int ret = 0;
948         struct ktermios kterm;
949
950         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
951             tty->driver->subtype == PTY_TYPE_MASTER)
952                 real_tty = tty->link;
953         else
954                 real_tty = tty;
955
956         switch (cmd) {
957 #ifdef TIOCGETP
958         case TIOCGETP:
959                 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
960         case TIOCSETP:
961         case TIOCSETN:
962                 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
963 #endif
964 #ifdef TIOCGETC
965         case TIOCGETC:
966                 return get_tchars(real_tty, p);
967         case TIOCSETC:
968                 return set_tchars(real_tty, p);
969 #endif
970 #ifdef TIOCGLTC
971         case TIOCGLTC:
972                 return get_ltchars(real_tty, p);
973         case TIOCSLTC:
974                 return set_ltchars(real_tty, p);
975 #endif
976         case TCSETSF:
977                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
978         case TCSETSW:
979                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
980         case TCSETS:
981                 return set_termios(real_tty, p, TERMIOS_OLD);
982 #ifndef TCGETS2
983         case TCGETS:
984                 copy_termios(real_tty, &kterm);
985                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
986                         ret = -EFAULT;
987                 return ret;
988 #else
989         case TCGETS:
990                 copy_termios(real_tty, &kterm);
991                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
992                         ret = -EFAULT;
993                 return ret;
994         case TCGETS2:
995                 copy_termios(real_tty, &kterm);
996                 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
997                         ret = -EFAULT;
998                 return ret;
999         case TCSETSF2:
1000                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
1001         case TCSETSW2:
1002                 return set_termios(real_tty, p, TERMIOS_WAIT);
1003         case TCSETS2:
1004                 return set_termios(real_tty, p, 0);
1005 #endif
1006         case TCGETA:
1007                 return get_termio(real_tty, p);
1008         case TCSETAF:
1009                 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
1010         case TCSETAW:
1011                 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
1012         case TCSETA:
1013                 return set_termios(real_tty, p, TERMIOS_TERMIO);
1014 #ifndef TCGETS2
1015         case TIOCGLCKTRMIOS:
1016                 copy_termios_locked(real_tty, &kterm);
1017                 if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
1018                         ret = -EFAULT;
1019                 return ret;
1020         case TIOCSLCKTRMIOS:
1021                 if (!capable(CAP_SYS_ADMIN))
1022                         return -EPERM;
1023                 copy_termios_locked(real_tty, &kterm);
1024                 if (user_termios_to_kernel_termios(&kterm,
1025                                                (struct termios __user *) arg))
1026                         return -EFAULT;
1027                 mutex_lock(&real_tty->termios_mutex);
1028                 memcpy(real_tty->termios_locked, &kterm, sizeof(struct ktermios));
1029                 mutex_unlock(&real_tty->termios_mutex);
1030                 return 0;
1031 #else
1032         case TIOCGLCKTRMIOS:
1033                 copy_termios_locked(real_tty, &kterm);
1034                 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
1035                         ret = -EFAULT;
1036                 return ret;
1037         case TIOCSLCKTRMIOS:
1038                 if (!capable(CAP_SYS_ADMIN))
1039                         return -EPERM;
1040                 copy_termios_locked(real_tty, &kterm);
1041                 if (user_termios_to_kernel_termios_1(&kterm,
1042                                                (struct termios __user *) arg))
1043                         return -EFAULT;
1044                 mutex_lock(&real_tty->termios_mutex);
1045                 memcpy(real_tty->termios_locked, &kterm, sizeof(struct ktermios));
1046                 mutex_unlock(&real_tty->termios_mutex);
1047                 return ret;
1048 #endif
1049 #ifdef TCGETX
1050         case TCGETX: {
1051                 struct termiox ktermx;
1052                 if (real_tty->termiox == NULL)
1053                         return -EINVAL;
1054                 mutex_lock(&real_tty->termios_mutex);
1055                 memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
1056                 mutex_unlock(&real_tty->termios_mutex);
1057                 if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
1058                         ret = -EFAULT;
1059                 return ret;
1060         }
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);