?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[ARM] 4186/1: iop: remove cp6_enable/disable routines
[linux-2.6/x86.git] / drivers / char / tty_ioctl.c
blobdee47f40c6a3878656f5bcacddcabd98c34da676
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_wait_until_sent - wait for I/O to finish
44 * @tty: tty we are waiting for
45 * @timeout: how long we will wait
46 *
47 * Wait for characters pending in a tty driver to hit the wire, or
48 * for a timeout to occur (eg due to flow control)
49 *
50 * Locking: none
51 */
52
53 void tty_wait_until_sent(struct tty_struct * tty, long timeout)
54 {
55 DECLARE_WAITQUEUE(wait, current);
56
57 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
58 char buf[64];
59
60 printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
61 #endif
62 if (!tty->driver->chars_in_buffer)
63 return;
64 add_wait_queue(&tty->write_wait, &wait);
65 if (!timeout)
66 timeout = MAX_SCHEDULE_TIMEOUT;
67 do {
68 #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
69 printk(KERN_DEBUG "waiting %s...(%d)\n", tty_name(tty, buf),
70 tty->driver->chars_in_buffer(tty));
71 #endif
72 set_current_state(TASK_INTERRUPTIBLE);
73 if (signal_pending(current))
74 goto stop_waiting;
75 if (!tty->driver->chars_in_buffer(tty))
76 break;
77 timeout = schedule_timeout(timeout);
78 } while (timeout);
79 if (tty->driver->wait_until_sent)
80 tty->driver->wait_until_sent(tty, timeout);
81 stop_waiting:
82 set_current_state(TASK_RUNNING);
83 remove_wait_queue(&tty->write_wait, &wait);
84 }
85
86 EXPORT_SYMBOL(tty_wait_until_sent);
87
88 static void unset_locked_termios(struct ktermios *termios,
89 struct ktermios *old,
90 struct ktermios *locked)
91 {
92 int i;
93
94 #define NOSET_MASK(x,y,z) (x = ((x) & ~(z)) | ((y) & (z)))
95
96 if (!locked) {
97 printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
98 return;
99 }
100
101 NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
102 NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
103 NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
104 NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
105 termios->c_line = locked->c_line ? old->c_line : termios->c_line;
106 for (i=0; i < NCCS; i++)
107 termios->c_cc[i] = locked->c_cc[i] ?
108 old->c_cc[i] : termios->c_cc[i];
109 /* FIXME: What should we do for i/ospeed */
110 }
111
112 /*
113 * Routine which returns the baud rate of the tty
114 *
115 * Note that the baud_table needs to be kept in sync with the
116 * include/asm/termbits.h file.
117 */
118 static const speed_t baud_table[] = {
119 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
120 9600, 19200, 38400, 57600, 115200, 230400, 460800,
121 #ifdef __sparc__
122 76800, 153600, 307200, 614400, 921600
123 #else
124 500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
125 2500000, 3000000, 3500000, 4000000
126 #endif
127 };
128
129 #ifndef __sparc__
130 static const tcflag_t baud_bits[] = {
131 B0, B50, B75, B110, B134, B150, B200, B300, B600,
132 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
133 B57600, B115200, B230400, B460800, B500000, B576000,
134 B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
135 B3000000, B3500000, B4000000
136 };
137 #else
138 static const tcflag_t baud_bits[] = {
139 B0, B50, B75, B110, B134, B150, B200, B300, B600,
140 B1200, B1800, B2400, B4800, B9600, B19200, B38400,
141 B57600, B115200, B230400, B460800, B76800, B153600,
142 B307200, B614400, B921600
143 };
144 #endif
145
146 static int n_baud_table = ARRAY_SIZE(baud_table);
147
148 /**
149 * tty_termios_baud_rate
150 * @termios: termios structure
151 *
152 * Convert termios baud rate data into a speed. This should be called
153 * with the termios lock held if this termios is a terminal termios
154 * structure. May change the termios data. Device drivers can call this
155 * function but should use ->c_[io]speed directly as they are updated.
156 *
157 * Locking: none
158 */
159
160 speed_t tty_termios_baud_rate(struct ktermios *termios)
161 {
162 unsigned int cbaud;
163
164 cbaud = termios->c_cflag & CBAUD;
165
166 #ifdef BOTHER
167 /* Magic token for arbitary speed via c_ispeed/c_ospeed */
168 if (cbaud == BOTHER)
169 return termios->c_ospeed;
170 #endif
171 if (cbaud & CBAUDEX) {
172 cbaud &= ~CBAUDEX;
173
174 if (cbaud < 1 || cbaud + 15 > n_baud_table)
175 termios->c_cflag &= ~CBAUDEX;
176 else
177 cbaud += 15;
178 }
179 return baud_table[cbaud];
180 }
181
182 EXPORT_SYMBOL(tty_termios_baud_rate);
183
184 /**
185 * tty_termios_input_baud_rate
186 * @termios: termios structure
187 *
188 * Convert termios baud rate data into a speed. This should be called
189 * with the termios lock held if this termios is a terminal termios
190 * structure. May change the termios data. Device drivers can call this
191 * function but should use ->c_[io]speed directly as they are updated.
192 *
193 * Locking: none
194 */
195
196 speed_t tty_termios_input_baud_rate(struct ktermios *termios)
197 {
198 #ifdef IBSHIFT
199 unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
200
201 if (cbaud == B0)
202 return tty_termios_baud_rate(termios);
203
204 /* Magic token for arbitary speed via c_ispeed*/
205 if (cbaud == BOTHER)
206 return termios->c_ispeed;
207
208 if (cbaud & CBAUDEX) {
209 cbaud &= ~CBAUDEX;
210
211 if (cbaud < 1 || cbaud + 15 > n_baud_table)
212 termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
213 else
214 cbaud += 15;
215 }
216 return baud_table[cbaud];
217 #else
218 return tty_termios_baud_rate(termios);
219 #endif
220 }
221
222 EXPORT_SYMBOL(tty_termios_input_baud_rate);
223
224 #ifdef BOTHER
225
226 /**
227 * tty_termios_encode_baud_rate
228 * @termios: termios structure
229 * @ispeed: input speed
230 * @ospeed: output speed
231 *
232 * Encode the speeds set into the passed termios structure. This is
233 * used as a library helper for drivers os that they can report back
234 * the actual speed selected when it differs from the speed requested
235 *
236 * For now input and output speed must agree.
237 *
238 * Locking: Caller should hold termios lock. This is already held
239 * when calling this function from the driver termios handler.
240 */
241
242 void tty_termios_encode_baud_rate(struct ktermios *termios, speed_t ibaud, speed_t obaud)
243 {
244 int i = 0;
245 int ifound = 0, ofound = 0;
246
247 termios->c_ispeed = ibaud;
248 termios->c_ospeed = obaud;
249
250 termios->c_cflag &= ~CBAUD;
251 /* Identical speed means no input encoding (ie B0 << IBSHIFT)*/
252 if (termios->c_ispeed == termios->c_ospeed)
253 ifound = 1;
254
255 do {
256 if (obaud == baud_table[i]) {
257 termios->c_cflag |= baud_bits[i];
258 ofound = 1;
259 /* So that if ibaud == obaud we don't set it */
260 continue;
261 }
262 if (ibaud == baud_table[i]) {
263 termios->c_cflag |= (baud_bits[i] << IBSHIFT);
264 ifound = 1;
265 }
266 }
267 while(++i < n_baud_table);
268 if (!ofound)
269 termios->c_cflag |= BOTHER;
270 if (!ifound)
271 termios->c_cflag |= (BOTHER << IBSHIFT);
272 }
273
274 EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
275
276 #endif
277
278 /**
279 * tty_get_baud_rate - get tty bit rates
280 * @tty: tty to query
281 *
282 * Returns the baud rate as an integer for this terminal. The
283 * termios lock must be held by the caller and the terminal bit
284 * flags may be updated.
285 *
286 * Locking: none
287 */
288
289 speed_t tty_get_baud_rate(struct tty_struct *tty)
290 {
291 speed_t baud = tty_termios_baud_rate(tty->termios);
292
293 if (baud == 38400 && tty->alt_speed) {
294 if (!tty->warned) {
295 printk(KERN_WARNING "Use of setserial/setrocket to "
296 "set SPD_* flags is deprecated\n");
297 tty->warned = 1;
298 }
299 baud = tty->alt_speed;
300 }
301
302 return baud;
303 }
304
305 EXPORT_SYMBOL(tty_get_baud_rate);
306
307 /**
308 * change_termios - update termios values
309 * @tty: tty to update
310 * @new_termios: desired new value
311 *
312 * Perform updates to the termios values set on this terminal. There
313 * is a bit of layering violation here with n_tty in terms of the
314 * internal knowledge of this function.
315 *
316 * Locking: termios_sem
317 */
318
319 static void change_termios(struct tty_struct * tty, struct ktermios * new_termios)
320 {
321 int canon_change;
322 struct ktermios old_termios = *tty->termios;
323 struct tty_ldisc *ld;
324
325 /*
326 * Perform the actual termios internal changes under lock.
327 */
328
329
330 /* FIXME: we need to decide on some locking/ordering semantics
331 for the set_termios notification eventually */
332 mutex_lock(&tty->termios_mutex);
333
334 *tty->termios = *new_termios;
335 unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
336 canon_change = (old_termios.c_lflag ^ tty->termios->c_lflag) & ICANON;
337 if (canon_change) {
338 memset(&tty->read_flags, 0, sizeof tty->read_flags);
339 tty->canon_head = tty->read_tail;
340 tty->canon_data = 0;
341 tty->erasing = 0;
342 }
343
344
345 if (canon_change && !L_ICANON(tty) && tty->read_cnt)
346 /* Get characters left over from canonical mode. */
347 wake_up_interruptible(&tty->read_wait);
348
349 /* See if packet mode change of state. */
350
351 if (tty->link && tty->link->packet) {
352 int old_flow = ((old_termios.c_iflag & IXON) &&
353 (old_termios.c_cc[VSTOP] == '\023') &&
354 (old_termios.c_cc[VSTART] == '\021'));
355 int new_flow = (I_IXON(tty) &&
356 STOP_CHAR(tty) == '\023' &&
357 START_CHAR(tty) == '\021');
358 if (old_flow != new_flow) {
359 tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
360 if (new_flow)
361 tty->ctrl_status |= TIOCPKT_DOSTOP;
362 else
363 tty->ctrl_status |= TIOCPKT_NOSTOP;
364 wake_up_interruptible(&tty->link->read_wait);
365 }
366 }
367
368 if (tty->driver->set_termios)
369 (*tty->driver->set_termios)(tty, &old_termios);
370
371 ld = tty_ldisc_ref(tty);
372 if (ld != NULL) {
373 if (ld->set_termios)
374 (ld->set_termios)(tty, &old_termios);
375 tty_ldisc_deref(ld);
376 }
377 mutex_unlock(&tty->termios_mutex);
378 }
379
380 /**
381 * set_termios - set termios values for a tty
382 * @tty: terminal device
383 * @arg: user data
384 * @opt: option information
385 *
386 * Helper function to prepare termios data and run neccessary other
387 * functions before using change_termios to do the actual changes.
388 *
389 * Locking:
390 * Called functions take ldisc and termios_sem locks
391 */
392
393 static int set_termios(struct tty_struct * tty, void __user *arg, int opt)
394 {
395 struct ktermios tmp_termios;
396 struct tty_ldisc *ld;
397 int retval = tty_check_change(tty);
398
399 if (retval)
400 return retval;
401
402 memcpy(&tmp_termios, tty->termios, sizeof(struct ktermios));
403
404 if (opt & TERMIOS_TERMIO) {
405 if (user_termio_to_kernel_termios(&tmp_termios,
406 (struct termio __user *)arg))
407 return -EFAULT;
408 #ifdef TCGETS2
409 } else if (opt & TERMIOS_OLD) {
410 if (user_termios_to_kernel_termios_1(&tmp_termios,
411 (struct termios __user *)arg))
412 return -EFAULT;
413 } else {
414 if (user_termios_to_kernel_termios(&tmp_termios,
415 (struct termios2 __user *)arg))
416 return -EFAULT;
417 }
418 #else
419 } else if (user_termios_to_kernel_termios(&tmp_termios,
420 (struct termios __user *)arg))
421 return -EFAULT;
422 #endif
423
424 /* If old style Bfoo values are used then load c_ispeed/c_ospeed with the real speed
425 so its unconditionally usable */
426 tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
427 tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
428
429 ld = tty_ldisc_ref(tty);
430
431 if (ld != NULL) {
432 if ((opt & TERMIOS_FLUSH) && ld->flush_buffer)
433 ld->flush_buffer(tty);
434 tty_ldisc_deref(ld);
435 }
436
437 if (opt & TERMIOS_WAIT) {
438 tty_wait_until_sent(tty, 0);
439 if (signal_pending(current))
440 return -EINTR;
441 }
442
443 change_termios(tty, &tmp_termios);
444 return 0;
445 }
446
447 static int get_termio(struct tty_struct * tty, struct termio __user * termio)
448 {
449 if (kernel_termios_to_user_termio(termio, tty->termios))
450 return -EFAULT;
451 return 0;
452 }
453
454 static unsigned long inq_canon(struct tty_struct * tty)
455 {
456 int nr, head, tail;
457
458 if (!tty->canon_data || !tty->read_buf)
459 return 0;
460 head = tty->canon_head;
461 tail = tty->read_tail;
462 nr = (head - tail) & (N_TTY_BUF_SIZE-1);
463 /* Skip EOF-chars.. */
464 while (head != tail) {
465 if (test_bit(tail, tty->read_flags) &&
466 tty->read_buf[tail] == __DISABLED_CHAR)
467 nr--;
468 tail = (tail+1) & (N_TTY_BUF_SIZE-1);
469 }
470 return nr;
471 }
472
473 #ifdef TIOCGETP
474 /*
475 * These are deprecated, but there is limited support..
476 *
477 * The "sg_flags" translation is a joke..
478 */
479 static int get_sgflags(struct tty_struct * tty)
480 {
481 int flags = 0;
482
483 if (!(tty->termios->c_lflag & ICANON)) {
484 if (tty->termios->c_lflag & ISIG)
485 flags |= 0x02; /* cbreak */
486 else
487 flags |= 0x20; /* raw */
488 }
489 if (tty->termios->c_lflag & ECHO)
490 flags |= 0x08; /* echo */
491 if (tty->termios->c_oflag & OPOST)
492 if (tty->termios->c_oflag & ONLCR)
493 flags |= 0x10; /* crmod */
494 return flags;
495 }
496
497 static int get_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
498 {
499 struct sgttyb tmp;
500
501 mutex_lock(&tty->termios_mutex);
502 tmp.sg_ispeed = tty->termios->c_ispeed;
503 tmp.sg_ospeed = tty->termios->c_ospeed;
504 tmp.sg_erase = tty->termios->c_cc[VERASE];
505 tmp.sg_kill = tty->termios->c_cc[VKILL];
506 tmp.sg_flags = get_sgflags(tty);
507 mutex_unlock(&tty->termios_mutex);
508
509 return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
510 }
511
512 static void set_sgflags(struct ktermios * termios, int flags)
513 {
514 termios->c_iflag = ICRNL | IXON;
515 termios->c_oflag = 0;
516 termios->c_lflag = ISIG | ICANON;
517 if (flags & 0x02) { /* cbreak */
518 termios->c_iflag = 0;
519 termios->c_lflag &= ~ICANON;
520 }
521 if (flags & 0x08) { /* echo */
522 termios->c_lflag |= ECHO | ECHOE | ECHOK |
523 ECHOCTL | ECHOKE | IEXTEN;
524 }
525 if (flags & 0x10) { /* crmod */
526 termios->c_oflag |= OPOST | ONLCR;
527 }
528 if (flags & 0x20) { /* raw */
529 termios->c_iflag = 0;
530 termios->c_lflag &= ~(ISIG | ICANON);
531 }
532 if (!(termios->c_lflag & ICANON)) {
533 termios->c_cc[VMIN] = 1;
534 termios->c_cc[VTIME] = 0;
535 }
536 }
537
538 /**
539 * set_sgttyb - set legacy terminal values
540 * @tty: tty structure
541 * @sgttyb: pointer to old style terminal structure
542 *
543 * Updates a terminal from the legacy BSD style terminal information
544 * structure.
545 *
546 * Locking: termios_sem
547 */
548
549 static int set_sgttyb(struct tty_struct * tty, struct sgttyb __user * sgttyb)
550 {
551 int retval;
552 struct sgttyb tmp;
553 struct ktermios termios;
554
555 retval = tty_check_change(tty);
556 if (retval)
557 return retval;
558
559 if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
560 return -EFAULT;
561
562 mutex_lock(&tty->termios_mutex);
563 termios = *tty->termios;
564 termios.c_cc[VERASE] = tmp.sg_erase;
565 termios.c_cc[VKILL] = tmp.sg_kill;
566 set_sgflags(&termios, tmp.sg_flags);
567 /* Try and encode into Bfoo format */
568 #ifdef BOTHER
569 tty_termios_encode_baud_rate(&termios, termios.c_ispeed, termios.c_ospeed);
570 #endif
571 mutex_unlock(&tty->termios_mutex);
572 change_termios(tty, &termios);
573 return 0;
574 }
575 #endif
576
577 #ifdef TIOCGETC
578 static int get_tchars(struct tty_struct * tty, struct tchars __user * tchars)
579 {
580 struct tchars tmp;
581
582 tmp.t_intrc = tty->termios->c_cc[VINTR];
583 tmp.t_quitc = tty->termios->c_cc[VQUIT];
584 tmp.t_startc = tty->termios->c_cc[VSTART];
585 tmp.t_stopc = tty->termios->c_cc[VSTOP];
586 tmp.t_eofc = tty->termios->c_cc[VEOF];
587 tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
588 return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
589 }
590
591 static int set_tchars(struct tty_struct * tty, struct tchars __user * tchars)
592 {
593 struct tchars tmp;
594
595 if (copy_from_user(&tmp, tchars, sizeof(tmp)))
596 return -EFAULT;
597 tty->termios->c_cc[VINTR] = tmp.t_intrc;
598 tty->termios->c_cc[VQUIT] = tmp.t_quitc;
599 tty->termios->c_cc[VSTART] = tmp.t_startc;
600 tty->termios->c_cc[VSTOP] = tmp.t_stopc;
601 tty->termios->c_cc[VEOF] = tmp.t_eofc;
602 tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
603 return 0;
604 }
605 #endif
606
607 #ifdef TIOCGLTC
608 static int get_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
609 {
610 struct ltchars tmp;
611
612 tmp.t_suspc = tty->termios->c_cc[VSUSP];
613 tmp.t_dsuspc = tty->termios->c_cc[VSUSP]; /* what is dsuspc anyway? */
614 tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
615 tmp.t_flushc = tty->termios->c_cc[VEOL2]; /* what is flushc anyway? */
616 tmp.t_werasc = tty->termios->c_cc[VWERASE];
617 tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
618 return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
619 }
620
621 static int set_ltchars(struct tty_struct * tty, struct ltchars __user * ltchars)
622 {
623 struct ltchars tmp;
624
625 if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
626 return -EFAULT;
627
628 tty->termios->c_cc[VSUSP] = tmp.t_suspc;
629 tty->termios->c_cc[VEOL2] = tmp.t_dsuspc; /* what is dsuspc anyway? */
630 tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
631 tty->termios->c_cc[VEOL2] = tmp.t_flushc; /* what is flushc anyway? */
632 tty->termios->c_cc[VWERASE] = tmp.t_werasc;
633 tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
634 return 0;
635 }
636 #endif
637
638 /**
639 * send_prio_char - send priority character
640 *
641 * Send a high priority character to the tty even if stopped
642 *
643 * Locking: none for xchar method, write ordering for write method.
644 */
645
646 static int send_prio_char(struct tty_struct *tty, char ch)
647 {
648 int was_stopped = tty->stopped;
649
650 if (tty->driver->send_xchar) {
651 tty->driver->send_xchar(tty, ch);
652 return 0;
653 }
654
655 if (mutex_lock_interruptible(&tty->atomic_write_lock))
656 return -ERESTARTSYS;
657
658 if (was_stopped)
659 start_tty(tty);
660 tty->driver->write(tty, &ch, 1);
661 if (was_stopped)
662 stop_tty(tty);
663 mutex_unlock(&tty->atomic_write_lock);
664 return 0;
665 }
666
667 int n_tty_ioctl(struct tty_struct * tty, struct file * file,
668 unsigned int cmd, unsigned long arg)
669 {
670 struct tty_struct * real_tty;
671 void __user *p = (void __user *)arg;
672 int retval;
673 struct tty_ldisc *ld;
674
675 if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
676 tty->driver->subtype == PTY_TYPE_MASTER)
677 real_tty = tty->link;
678 else
679 real_tty = tty;
680
681 switch (cmd) {
682 #ifdef TIOCGETP
683 case TIOCGETP:
684 return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
685 case TIOCSETP:
686 case TIOCSETN:
687 return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
688 #endif
689 #ifdef TIOCGETC
690 case TIOCGETC:
691 return get_tchars(real_tty, p);
692 case TIOCSETC:
693 return set_tchars(real_tty, p);
694 #endif
695 #ifdef TIOCGLTC
696 case TIOCGLTC:
697 return get_ltchars(real_tty, p);
698 case TIOCSLTC:
699 return set_ltchars(real_tty, p);
700 #endif
701 case TCSETSF:
702 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_OLD);
703 case TCSETSW:
704 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_OLD);
705 case TCSETS:
706 return set_termios(real_tty, p, TERMIOS_OLD);
707 #ifndef TCGETS2
708 case TCGETS:
709 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios))
710 return -EFAULT;
711 return 0;
712 #else
713 case TCGETS:
714 if (kernel_termios_to_user_termios_1((struct termios __user *)arg, real_tty->termios))
715 return -EFAULT;
716 return 0;
717 case TCGETS2:
718 if (kernel_termios_to_user_termios((struct termios2 __user *)arg, real_tty->termios))
719 return -EFAULT;
720 return 0;
721 case TCSETSF2:
722 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT);
723 case TCSETSW2:
724 return set_termios(real_tty, p, TERMIOS_WAIT);
725 case TCSETS2:
726 return set_termios(real_tty, p, 0);
727 #endif
728 case TCGETA:
729 return get_termio(real_tty, p);
730 case TCSETAF:
731 return set_termios(real_tty, p, TERMIOS_FLUSH | TERMIOS_WAIT | TERMIOS_TERMIO);
732 case TCSETAW:
733 return set_termios(real_tty, p, TERMIOS_WAIT | TERMIOS_TERMIO);
734 case TCSETA:
735 return set_termios(real_tty, p, TERMIOS_TERMIO);
736 case TCXONC:
737 retval = tty_check_change(tty);
738 if (retval)
739 return retval;
740 switch (arg) {
741 case TCOOFF:
742 if (!tty->flow_stopped) {
743 tty->flow_stopped = 1;
744 stop_tty(tty);
745 }
746 break;
747 case TCOON:
748 if (tty->flow_stopped) {
749 tty->flow_stopped = 0;
750 start_tty(tty);
751 }
752 break;
753 case TCIOFF:
754 if (STOP_CHAR(tty) != __DISABLED_CHAR)
755 return send_prio_char(tty, STOP_CHAR(tty));
756 break;
757 case TCION:
758 if (START_CHAR(tty) != __DISABLED_CHAR)
759 return send_prio_char(tty, START_CHAR(tty));
760 break;
761 default:
762 return -EINVAL;
763 }
764 return 0;
765 case TCFLSH:
766 retval = tty_check_change(tty);
767 if (retval)
768 return retval;
769
770 ld = tty_ldisc_ref(tty);
771 switch (arg) {
772 case TCIFLUSH:
773 if (ld && ld->flush_buffer)
774 ld->flush_buffer(tty);
775 break;
776 case TCIOFLUSH:
777 if (ld && ld->flush_buffer)
778 ld->flush_buffer(tty);
779 /* fall through */
780 case TCOFLUSH:
781 if (tty->driver->flush_buffer)
782 tty->driver->flush_buffer(tty);
783 break;
784 default:
785 tty_ldisc_deref(ld);
786 return -EINVAL;
787 }
788 tty_ldisc_deref(ld);
789 return 0;
790 case TIOCOUTQ:
791 return put_user(tty->driver->chars_in_buffer ?
792 tty->driver->chars_in_buffer(tty) : 0,
793 (int __user *) arg);
794 case TIOCINQ:
795 retval = tty->read_cnt;
796 if (L_ICANON(tty))
797 retval = inq_canon(tty);
798 return put_user(retval, (unsigned int __user *) arg);
799 case TIOCGLCKTRMIOS:
800 if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios_locked))
801 return -EFAULT;
802 return 0;
803
804 case TIOCSLCKTRMIOS:
805 if (!capable(CAP_SYS_ADMIN))
806 return -EPERM;
807 if (user_termios_to_kernel_termios(real_tty->termios_locked, (struct termios __user *) arg))
808 return -EFAULT;
809 return 0;
810
811 case TIOCPKT:
812 {
813 int pktmode;
814
815 if (tty->driver->type != TTY_DRIVER_TYPE_PTY ||
816 tty->driver->subtype != PTY_TYPE_MASTER)
817 return -ENOTTY;
818 if (get_user(pktmode, (int __user *) arg))
819 return -EFAULT;
820 if (pktmode) {
821 if (!tty->packet) {
822 tty->packet = 1;
823 tty->link->ctrl_status = 0;
824 }
825 } else
826 tty->packet = 0;
827 return 0;
828 }
829 case TIOCGSOFTCAR:
830 return put_user(C_CLOCAL(tty) ? 1 : 0, (int __user *)arg);
831 case TIOCSSOFTCAR:
832 if (get_user(arg, (unsigned int __user *) arg))
833 return -EFAULT;
834 mutex_lock(&tty->termios_mutex);
835 tty->termios->c_cflag =
836 ((tty->termios->c_cflag & ~CLOCAL) |
837 (arg ? CLOCAL : 0));
838 mutex_unlock(&tty->termios_mutex);
839 return 0;
840 default:
841 return -ENOIOCTLCMD;
842 }
843 }
844
845 EXPORT_SYMBOL(n_tty_ioctl);
x86 "subsystem" repository