Merge branch 'master' of git://oak/home/sfr/kernels/iseries/work
[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
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
40
41 /**
42  *      tty_wait_until_sent     -       wait for I/O to finish
43  *      @tty: tty we are waiting for
44  *      @timeout: how long we will wait
45  *
46  *      Wait for characters pending in a tty driver to hit the wire, or
47  *      for a timeout to occur (eg due to flow control)
48  *
49  *      Locking: none
50  */
51
52 void tty_wait_until_sent(struct tty_struct * tty, long timeout)
53 {
54         DECLARE_WAITQUEUE(wait, current);
55
56 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
57         char buf[64];
58         
59         printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
60 #endif
61         if (!tty->driver->chars_in_buffer)
62                 return;
63         add_wait_queue(&tty->write_wait, &wait);
64         if (!timeout)
65                 timeout = MAX_SCHEDULE_TIMEOUT;
66         do {
67 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
68                 printk(KERN_DEBUG "waiting %s...(%d)\n", tty_name(tty, buf),
69                        tty->driver->chars_in_buffer(tty));
70 #endif
71                 set_current_state(TASK_INTERRUPTIBLE);
72                 if (signal_pending(current))
73                         goto stop_waiting;
74                 if (!tty->driver->chars_in_buffer(tty))
75                         break;
76                 timeout = schedule_timeout(timeout);
77         } while (timeout);
78         if (tty->driver->wait_until_sent)
79                 tty->driver->wait_until_sent(tty, timeout);
80 stop_waiting:
81         set_current_state(TASK_RUNNING);
82         remove_wait_queue(&tty->write_wait, &wait);
83 }
84
85 EXPORT_SYMBOL(tty_wait_until_sent);
86
87 static void unset_locked_termios(struct termios *termios,
88                                  struct termios *old,
89                                  struct termios *locked)
90 {
91         int     i;
92         
93 #define NOSET_MASK(x,y,z) (x = ((x) & ~(z)) | ((y) & (z)))
94
95         if (!locked) {
96                 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
97                 return;
98         }
99
100         NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
101         NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
102         NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
103         NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
104         termios->c_line = locked->c_line ? old->c_line : termios->c_line;
105         for (i=0; i < NCCS; i++)
106                 termios->c_cc[i] = locked->c_cc[i] ?
107                         old->c_cc[i] : termios->c_cc[i];
108 }
109
110 /**
111  *      change_termios          -       update termios values
112  *      @tty: tty to update
113  *      @new_termios: desired new value
114  *
115  *      Perform updates to the termios values set on this terminal. There
116  *      is a bit of layering violation here with n_tty in terms of the
117  *      internal knowledge of this function.
118  *
119  *      Locking: termios_sem
120  */
121
122 static void change_termios(struct tty_struct * tty, struct termios * new_termios)
123 {
124         int canon_change;
125         struct termios old_termios = *tty->termios;
126         struct tty_ldisc *ld;
127         
128         /*
129          *      Perform the actual termios internal changes under lock.
130          */
131          
132
133         /* FIXME: we need to decide on some locking/ordering semantics
134            for the set_termios notification eventually */
135         mutex_lock(&tty->termios_mutex);
136
137         *tty->termios = *new_termios;
138         unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
139         canon_change = (old_termios.c_lflag ^ tty->termios->c_lflag) & ICANON;
140         if (canon_change) {
141                 memset(&tty->read_flags, 0, sizeof tty->read_flags);
142                 tty->canon_head = tty->read_tail;
143                 tty->canon_data = 0;
144                 tty->erasing = 0;
145         }
146         
147         
148         if (canon_change && !L_ICANON(tty) && tty->read_cnt)
149                 /* Get characters left over from canonical mode. */
150                 wake_up_interruptible(&tty->read_wait);
151
152         /* See if packet mode change of state. */
153
154         if (tty->link && tty->link->packet) {
155                 int old_flow = ((old_termios.c_iflag & IXON) &&
156                                 (old_termios.c_cc[VSTOP] == '\023') &&
157                                 (old_termios.c_cc[VSTART] == '\021'));
158                 int new_flow = (I_IXON(tty) &&
159                                 STOP_CHAR(tty) == '\023' &&
160                                 START_CHAR(tty) == '\021');
161                 if (old_flow != new_flow) {
162                         tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
163                         if (new_flow)
164                                 tty->ctrl_status |= TIOCPKT_DOSTOP;
165                         else
166                                 tty->ctrl_status |= TIOCPKT_NOSTOP;
167                         wake_up_interruptible(&tty->link->read_wait);
168                 }
169         }
170            
171         if (tty->driver->set_termios)
172                 (*tty->driver->set_termios)(tty, &old_termios);
173
174         ld = tty_ldisc_ref(tty);
175         if (ld != NULL) {
176                 if (ld->set_termios)
177                         (ld->set_termios)(tty, &old_termios);
178                 tty_ldisc_deref(ld);
179         }
180         mutex_unlock(&tty->termios_mutex);
181 }
182
183 /**
184  *      set_termios             -       set termios values for a tty
185  *      @tty: terminal device
186  *      @arg: user data
187  *      @opt: option information
188  *
189  *      Helper function to prepare termios data and run neccessary other
190  *      functions before using change_termios to do the actual changes.
191  *
192  *      Locking:
193  *              Called functions take ldisc and termios_sem locks
194  */
195
196 static int set_termios(struct tty_struct * tty, void __user *arg, int opt)
197 {
198         struct termios tmp_termios;
199         struct tty_ldisc *ld;
200         int retval = tty_check_change(tty);
201
202         if (retval)
203                 return retval;
204
205         if (opt & TERMIOS_TERMIO) {
206                 memcpy(&tmp_termios, tty->termios, sizeof(struct termios));
207                 if (user_termio_to_kernel_termios(&tmp_termios,
208                                                 (struct termio __user *)arg))
209                         return -EFAULT;
210         } else {
211                 if (user_termios_to_kernel_termios(&tmp_termios,
212                                                 (struct termios __user *)arg))
213                         return -EFAULT;
214         }
215
216         ld = tty_ldisc_ref(tty);
217         
218         if (ld != NULL) {
219                 if ((opt & TERMIOS_FLUSH) && ld->flush_buffer)
220                         ld->flush_buffer(tty);
221                 tty_ldisc_deref(ld);
222         }
223         
224         if (opt & TERMIOS_WAIT) {
225                 tty_wait_until_sent(tty, 0);
226                 if (signal_pending(current))
227                         return -EINTR;
228         }
229
230         change_termios(tty, &tmp_termios);
231         return 0;
232 }
233
234 static int get_termio(struct tty_struct * tty, struct termio __user * termio)
235 {
236         if (kernel_termios_to_user_termio(termio, tty->termios))
237                 return -EFAULT;
238         return 0;
239 }
240
241 static unsigned long inq_canon(struct tty_struct * tty)
242 {
243         int nr, head, tail;
244
245         if (!tty->canon_data || !tty->read_buf)
246                 return 0;
247         head = tty->canon_head;
248         tail = tty->read_tail;
249         nr = (head - tail) & (N_TTY_BUF_SIZE-1);
250         /* Skip EOF-chars.. */
251         while (head != tail) {
252                 if (test_bit(tail, tty->read_flags) &&
253                     tty->read_buf[tail] == __DISABLED_CHAR)
254                         nr--;
255                 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
256         }
257         return nr;
258 }
259
260 #ifdef TIOCGETP
261 /*
262  * These are deprecated, but there is limited support..
263  *
264  * The "sg_flags" translation is a joke..
265  */
266 static int get_sgflags(struct tty_struct * tty)
267 {
268         int flags = 0;
269
270         if (!(tty->termios->c_lflag & ICANON)) {
271                 if (tty->termios->c_lflag & ISIG)
272                         flags |= 0x02;          /* cbreak */
273                 else
274                         flags |= 0x20;          /* raw */
275         }
276         if (tty->termios->c_lflag & ECHO)
277                 flags |= 0x08;                  /* echo */
278         if (tty->termios->c_oflag & OPOST)
279                 if (tty->termios->c_oflag & ONLCR)
280                         flags |= 0x10;          /* crmod */
281         return flags;
282 }
283
284 static int get_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
285 {
286         struct sgttyb tmp;
287
288         mutex_lock(&tty->termios_mutex);
289         tmp.sg_ispeed = 0;
290         tmp.sg_ospeed = 0;
291         tmp.sg_erase = tty->termios->c_cc[VERASE];
292         tmp.sg_kill = tty->termios->c_cc[VKILL];
293         tmp.sg_flags = get_sgflags(tty);
294         mutex_unlock(&tty->termios_mutex);
295         
296         return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
297 }
298
299 static void set_sgflags(struct termios * termios, int flags)
300 {
301         termios->c_iflag = ICRNL | IXON;
302         termios->c_oflag = 0;
303         termios->c_lflag = ISIG | ICANON;
304         if (flags & 0x02) {     /* cbreak */
305                 termios->c_iflag = 0;
306                 termios->c_lflag &= ~ICANON;
307         }
308         if (flags & 0x08) {             /* echo */
309                 termios->c_lflag |= ECHO | ECHOE | ECHOK |
310                                     ECHOCTL | ECHOKE | IEXTEN;
311         }
312         if (flags & 0x10) {             /* crmod */
313                 termios->c_oflag |= OPOST | ONLCR;
314         }
315         if (flags & 0x20) {     /* raw */
316                 termios->c_iflag = 0;
317                 termios->c_lflag &= ~(ISIG | ICANON);
318         }
319         if (!(termios->c_lflag & ICANON)) {
320                 termios->c_cc[VMIN] = 1;
321                 termios->c_cc[VTIME] = 0;
322         }
323 }
324
325 /**
326  *      set_sgttyb              -       set legacy terminal values
327  *      @tty: tty structure
328  *      @sgttyb: pointer to old style terminal structure
329  *
330  *      Updates a terminal from the legacy BSD style terminal information
331  *      structure.
332  *
333  *      Locking: termios_sem
334  */
335
336 static int set_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
337 {
338         int retval;
339         struct sgttyb tmp;
340         struct termios termios;
341
342         retval = tty_check_change(tty);
343         if (retval)
344                 return retval;
345         
346         if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
347                 return -EFAULT;
348
349         mutex_lock(&tty->termios_mutex);
350         termios =  *tty->termios;
351         termios.c_cc[VERASE] = tmp.sg_erase;
352         termios.c_cc[VKILL] = tmp.sg_kill;
353         set_sgflags(&termios, tmp.sg_flags);
354         mutex_unlock(&tty->termios_mutex);
355         change_termios(tty, &termios);
356         return 0;
357 }
358 #endif
359
360 #ifdef TIOCGETC
361 static int get_tchars(struct tty_struct * tty, struct tchars __user * tchars)
362 {
363         struct tchars tmp;
364
365         tmp.t_intrc = tty->termios->c_cc[VINTR];
366         tmp.t_quitc = tty->termios->c_cc[VQUIT];
367         tmp.t_startc = tty->termios->c_cc[VSTART];
368         tmp.t_stopc = tty->termios->c_cc[VSTOP];
369         tmp.t_eofc = tty->termios->c_cc[VEOF];
370         tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
371         return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
372 }
373
374 static int set_tchars(struct tty_struct * tty, struct tchars __user * tchars)
375 {
376         struct tchars tmp;
377
378         if (copy_from_user(&tmp, tchars, sizeof(tmp)))
379                 return -EFAULT;
380         tty->termios->c_cc[VINTR] = tmp.t_intrc;
381         tty->termios->c_cc[VQUIT] = tmp.t_quitc;
382         tty->termios->c_cc[VSTART] = tmp.t_startc;
383         tty->termios->c_cc[VSTOP] = tmp.t_stopc;
384         tty->termios->c_cc[VEOF] = tmp.t_eofc;
385         tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
386         return 0;
387 }
388 #endif
389
390 #ifdef TIOCGLTC
391 static int get_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
392 {
393         struct ltchars tmp;
394
395         tmp.t_suspc = tty->termios->c_cc[VSUSP];
396         tmp.t_dsuspc = tty->termios->c_cc[VSUSP];       /* what is dsuspc anyway? */
397         tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
398         tmp.t_flushc = tty->termios->c_cc[VEOL2];       /* what is flushc anyway? */
399         tmp.t_werasc = tty->termios->c_cc[VWERASE];
400         tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
401         return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
402 }
403
404 static int set_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
405 {
406         struct ltchars tmp;
407
408         if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
409                 return -EFAULT;
410
411         tty->termios->c_cc[VSUSP] = tmp.t_suspc;
412         tty->termios->c_cc[VEOL2] = tmp.t_dsuspc;       /* what is dsuspc anyway? */
413         tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
414         tty->termios->c_cc[VEOL2] = tmp.t_flushc;       /* what is flushc anyway? */
415         tty->termios->c_cc[VWERASE] = tmp.t_werasc;
416         tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
417         return 0;
418 }
419 #endif
420
421 /**
422  *      send_prio_char          -       send priority character
423  *
424  *      Send a high priority character to the tty even if stopped
425  *
426  *      Locking: none for xchar method, write ordering for write method.
427  */
428
429 static int send_prio_char(struct tty_struct *tty, char ch)
430 {
431         int     was_stopped = tty->stopped;
432
433         if (tty->driver->send_xchar) {
434                 tty->driver->send_xchar(tty, ch);
435                 return 0;
436         }
437
438         if (mutex_lock_interruptible(&tty->atomic_write_lock))
439                 return -ERESTARTSYS;
440
441         if (was_stopped)
442                 start_tty(tty);
443         tty->driver->write(tty, &ch, 1);
444         if (was_stopped)
445                 stop_tty(tty);
446         mutex_unlock(&tty->atomic_write_lock);
447         return 0;
448 }
449
450 int n_tty_ioctl(struct tty_struct * tty, struct file * file,
451                        unsigned int cmd, unsigned long arg)
452 {
453         struct tty_struct * real_tty;
454         void __user *p = (void __user *)arg;
455         int retval;
456         struct tty_ldisc *ld;
457
458         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
459             tty->driver->subtype == PTY_TYPE_MASTER)
460                 real_tty = tty->link;
461         else
462                 real_tty = tty;
463
464         switch (cmd) {
465 #ifdef TIOCGETP
466                 case TIOCGETP:
467                         return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
468                 case TIOCSETP:
469                 case TIOCSETN:
470                         return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
471 #endif
472 #ifdef TIOCGETC
473                 case TIOCGETC:
474                         return get_tchars(real_tty, p);
475                 case TIOCSETC:
476                         return set_tchars(real_tty, p);
477 #endif
478 #ifdef TIOCGLTC
479                 case TIOCGLTC:
480                         return get_ltchars(real_tty, p);
481                 case TIOCSLTC:
482                         return set_ltchars(real_tty, p);
483 #endif
484                 case TCGETS:
485                         if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios))
486                                 return -EFAULT;
487                         return 0;
488                 case TCSETSF:
489                         return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
490                 case TCSETSW:
491                         return set_termios(real_tty, p, TERMIOS_WAIT);
492                 case TCSETS:
493                         return set_termios(real_tty, p, 0);
494                 case TCGETA:
495                         return get_termio(real_tty, p);
496                 case TCSETAF:
497                         return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
498                 case TCSETAW:
499                         return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
500                 case TCSETA:
501                         return set_termios(real_tty, p, TERMIOS_TERMIO);
502                 case TCXONC:
503                         retval = tty_check_change(tty);
504                         if (retval)
505                                 return retval;
506                         switch (arg) {
507                         case TCOOFF:
508                                 if (!tty->flow_stopped) {
509                                         tty->flow_stopped = 1;
510                                         stop_tty(tty);
511                                 }
512                                 break;
513                         case TCOON:
514                                 if (tty->flow_stopped) {
515                                         tty->flow_stopped = 0;
516                                         start_tty(tty);
517                                 }
518                                 break;
519                         case TCIOFF:
520                                 if (STOP_CHAR(tty) != __DISABLED_CHAR)
521                                         return send_prio_char(tty, STOP_CHAR(tty));
522                                 break;
523                         case TCION:
524                                 if (START_CHAR(tty) != __DISABLED_CHAR)
525                                         return send_prio_char(tty, START_CHAR(tty));
526                                 break;
527                         default:
528                                 return -EINVAL;
529                         }
530                         return 0;
531                 case TCFLSH:
532                         retval = tty_check_change(tty);
533                         if (retval)
534                                 return retval;
535                                 
536                         ld = tty_ldisc_ref(tty);
537                         switch (arg) {
538                         case TCIFLUSH:
539                                 if (ld && ld->flush_buffer)
540                                         ld->flush_buffer(tty);
541                                 break;
542                         case TCIOFLUSH:
543                                 if (ld && ld->flush_buffer)
544                                         ld->flush_buffer(tty);
545                                 /* fall through */
546                         case TCOFLUSH:
547                                 if (tty->driver->flush_buffer)
548                                         tty->driver->flush_buffer(tty);
549                                 break;
550                         default:
551                                 tty_ldisc_deref(ld);
552                                 return -EINVAL;
553                         }
554                         tty_ldisc_deref(ld);
555                         return 0;
556                 case TIOCOUTQ:
557                         return put_user(tty->driver->chars_in_buffer ?
558                                         tty->driver->chars_in_buffer(tty) : 0,
559                                         (int __user *) arg);
560                 case TIOCINQ:
561                         retval = tty->read_cnt;
562                         if (L_ICANON(tty))
563                                 retval = inq_canon(tty);
564                         return put_user(retval, (unsigned int __user *) arg);
565                 case TIOCGLCKTRMIOS:
566                         if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios_locked))
567                                 return -EFAULT;
568                         return 0;
569
570                 case TIOCSLCKTRMIOS:
571                         if (!capable(CAP_SYS_ADMIN))
572                                 return -EPERM;
573                         if (user_termios_to_kernel_termios(real_tty->termios_locked, (struct termios __user *) arg))
574                                 return -EFAULT;
575                         return 0;
576
577                 case TIOCPKT:
578                 {
579                         int pktmode;
580
581                         if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
582                             tty->driver->subtype != PTY_TYPE_MASTER)
583                                 return -ENOTTY;
584                         if (get_user(pktmode, (int __user *) arg))
585                                 return -EFAULT;
586                         if (pktmode) {
587                                 if (!tty->packet) {
588                                         tty->packet = 1;
589                                         tty->link->ctrl_status = 0;
590                                 }
591                         } else
592                                 tty->packet = 0;
593                         return 0;
594                 }
595                 case TIOCGSOFTCAR:
596                         return put_user(C_CLOCAL(tty) ? 1 : 0, (int __user *)arg);
597                 case TIOCSSOFTCAR:
598                         if (get_user(arg, (unsigned int __user *) arg))
599                                 return -EFAULT;
600                         mutex_lock(&tty->termios_mutex);
601                         tty->termios->c_cflag =
602                                 ((tty->termios->c_cflag & ~CLOCAL) |
603                                  (arg ? CLOCAL : 0));
604                         mutex_unlock(&tty->termios_mutex);
605                         return 0;
606                 default:
607                         return -ENOIOCTLCMD;
608                 }
609 }
610
611 EXPORT_SYMBOL(n_tty_ioctl);