开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
tty_ioctl.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：13k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

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.  */
  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>
  23. #include <asm/io.h>
  24. #include <asm/bitops.h>
  25. #include <asm/uaccess.h>
  26. #include <asm/system.h>
  28. #undef TTY_DEBUG_WAIT_UNTIL_SENT
  30. #undef DEBUG
  32. /*
  33.  * Internal flag options for termios setting behavior
  34.  */
  35. #define TERMIOS_FLUSH 1
  36. #define TERMIOS_WAIT 2
  37. #define TERMIOS_TERMIO 4
  39. void tty_wait_until_sent(struct tty_struct * tty, long timeout)
  40. {
  41. DECLARE_WAITQUEUE(wait, current);
  43. #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
  44. char buf[64];
  46. printk(KERN_DEBUG "%s wait until sent...n", tty_name(tty, buf));
  47. #endif
  48. if (!tty->driver.chars_in_buffer)
  49. return;
  50. add_wait_queue(&tty->write_wait, &wait);
  51. if (!timeout)
  52. timeout = MAX_SCHEDULE_TIMEOUT;
  53. do {
  54. #ifdef TTY_DEBUG_WAIT_UNTIL_SENT
  55. printk(KERN_DEBUG "waiting %s...(%d)n", tty_name(tty, buf),
  56.        tty->driver.chars_in_buffer(tty));
  57. #endif
  58. set_current_state(TASK_INTERRUPTIBLE);
  59. if (signal_pending(current))
  60. goto stop_waiting;
  61. if (!tty->driver.chars_in_buffer(tty))
  62. break;
  63. timeout = schedule_timeout(timeout);
  64. } while (timeout);
  65. if (tty->driver.wait_until_sent)
  66. tty->driver.wait_until_sent(tty, timeout);
  67. stop_waiting:
  68. current->state = TASK_RUNNING;
  69. remove_wait_queue(&tty->write_wait, &wait);
  70. }
  72. static void unset_locked_termios(struct termios *termios,
  73.  struct termios *old,
  74.  struct termios *locked)
  75. {
  76. int i;
  78. #define NOSET_MASK(x,y,z) (x = ((x) & ~(z)) | ((y) & (z)))
  80. if (!locked) {
  81. printk(KERN_WARNING "Warning?!? termios_locked is NULL.n");
  82. return;
  83. }
  85. NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
  86. NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
  87. NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
  88. NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
  89. termios->c_line = locked->c_line ? old->c_line : termios->c_line;
  90. for (i=0; i < NCCS; i++)
  91. termios->c_cc[i] = locked->c_cc[i] ?
  92. old->c_cc[i] : termios->c_cc[i];
  93. }
  95. static void change_termios(struct tty_struct * tty, struct termios * new_termios)
  96. {
  97. int canon_change;
  98. struct termios old_termios = *tty->termios;
  100. cli();
  101. *tty->termios = *new_termios;
  102. unset_locked_termios(tty->termios, &old_termios, tty->termios_locked);
  103. canon_change = (old_termios.c_lflag ^ tty->termios->c_lflag) & ICANON;
  104. if (canon_change) {
  105. memset(&tty->read_flags, 0, sizeof tty->read_flags);
  106. tty->canon_head = tty->read_tail;
  107. tty->canon_data = 0;
  108. tty->erasing = 0;
  109. }
  110. sti();
  111. if (canon_change && !L_ICANON(tty) && tty->read_cnt)
  112. /* Get characters left over from canonical mode. */
  113. wake_up_interruptible(&tty->read_wait);
  115. /* see if packet mode change of state */
  117. if (tty->link && tty->link->packet) {
  118. int old_flow = ((old_termios.c_iflag & IXON) &&
  119. (old_termios.c_cc[VSTOP] == '23') &&
  120. (old_termios.c_cc[VSTART] == '21'));
  121. int new_flow = (I_IXON(tty) &&
  122. STOP_CHAR(tty) == '23' &&
  123. START_CHAR(tty) == '21');
  124. if (old_flow != new_flow) {
  125. tty->ctrl_status &= ~(TIOCPKT_DOSTOP | TIOCPKT_NOSTOP);
  126. if (new_flow)
  127. tty->ctrl_status |= TIOCPKT_DOSTOP;
  128. else
  129. tty->ctrl_status |= TIOCPKT_NOSTOP;
  130. wake_up_interruptible(&tty->link->read_wait);
  131. }
  132. }
  134. if (tty->driver.set_termios)
  135. (*tty->driver.set_termios)(tty, &old_termios);
  137. if (tty->ldisc.set_termios)
  138. (*tty->ldisc.set_termios)(tty, &old_termios);
  139. }
  141. static int set_termios(struct tty_struct * tty, unsigned long arg, int opt)
  142. {
  143. struct termios tmp_termios;
  144. int retval = tty_check_change(tty);
  146. if (retval)
  147. return retval;
  149. if (opt & TERMIOS_TERMIO) {
  150. memcpy(&tmp_termios, tty->termios, sizeof(struct termios));
  151. if (user_termio_to_kernel_termios(&tmp_termios,
  152.   (struct termio *) arg))
  153. return -EFAULT;
  154. } else {
  155. if (user_termios_to_kernel_termios(&tmp_termios,
  156.    (struct termios *) arg))
  157. return -EFAULT;
  158. }
  160. if ((opt & TERMIOS_FLUSH) && tty->ldisc.flush_buffer)
  161. tty->ldisc.flush_buffer(tty);
  163. if (opt & TERMIOS_WAIT) {
  164. tty_wait_until_sent(tty, 0);
  165. if (signal_pending(current))
  166. return -EINTR;
  167. }
  169. change_termios(tty, &tmp_termios);
  170. return 0;
  171. }
  173. static int get_termio(struct tty_struct * tty, struct termio * termio)
  174. {
  175. if (kernel_termios_to_user_termio(termio, tty->termios))
  176. return -EFAULT;
  177. return 0;
  178. }
  180. static unsigned long inq_canon(struct tty_struct * tty)
  181. {
  182. int nr, head, tail;
  184. if (!tty->canon_data || !tty->read_buf)
  185. return 0;
  186. head = tty->canon_head;
  187. tail = tty->read_tail;
  188. nr = (head - tail) & (N_TTY_BUF_SIZE-1);
  189. /* Skip EOF-chars.. */
  190. while (head != tail) {
  191. if (test_bit(tail, &tty->read_flags) &&
  192.     tty->read_buf[tail] == __DISABLED_CHAR)
  193. nr--;
  194. tail = (tail+1) & (N_TTY_BUF_SIZE-1);
  195. }
  196. return nr;
  197. }
  199. #ifdef TIOCGETP
  200. /*
  201.  * These are deprecated, but there is limited support..
  202.  *
  203.  * The "sg_flags" translation is a joke..
  204.  */
  205. static int get_sgflags(struct tty_struct * tty)
  206. {
  207. int flags = 0;
  209. if (!(tty->termios->c_lflag & ICANON)) {
  210. if (tty->termios->c_lflag & ISIG)
  211. flags |= 0x02; /* cbreak */
  212. else
  213. flags |= 0x20; /* raw */
  214. }
  215. if (tty->termios->c_lflag & ECHO)
  216. flags |= 0x08; /* echo */
  217. if (tty->termios->c_oflag & OPOST)
  218. if (tty->termios->c_oflag & ONLCR)
  219. flags |= 0x10; /* crmod */
  220. return flags;
  221. }
  223. static int get_sgttyb(struct tty_struct * tty, struct sgttyb * sgttyb)
  224. {
  225. struct sgttyb tmp;
  227. tmp.sg_ispeed = 0;
  228. tmp.sg_ospeed = 0;
  229. tmp.sg_erase = tty->termios->c_cc[VERASE];
  230. tmp.sg_kill = tty->termios->c_cc[VKILL];
  231. tmp.sg_flags = get_sgflags(tty);
  232. return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
  233. }
  235. static void set_sgflags(struct termios * termios, int flags)
  236. {
  237. termios->c_iflag = ICRNL | IXON;
  238. termios->c_oflag = 0;
  239. termios->c_lflag = ISIG | ICANON;
  240. if (flags & 0x02) { /* cbreak */
  241. termios->c_iflag = 0;
  242. termios->c_lflag &= ~ICANON;
  243. }
  244. if (flags & 0x08) { /* echo */
  245. termios->c_lflag |= ECHO | ECHOE | ECHOK |
  246.     ECHOCTL | ECHOKE | IEXTEN;
  247. }
  248. if (flags & 0x10) { /* crmod */
  249. termios->c_oflag |= OPOST | ONLCR;
  250. }
  251. if (flags & 0x20) { /* raw */
  252. termios->c_iflag = 0;
  253. termios->c_lflag &= ~(ISIG | ICANON);
  254. }
  255. if (!(termios->c_lflag & ICANON)) {
  256. termios->c_cc[VMIN] = 1;
  257. termios->c_cc[VTIME] = 0;
  258. }
  259. }
  261. static int set_sgttyb(struct tty_struct * tty, struct sgttyb * sgttyb)
  262. {
  263. int retval;
  264. struct sgttyb tmp;
  265. struct termios termios;
  267. retval = tty_check_change(tty);
  268. if (retval)
  269. return retval;
  270. termios =  *tty->termios;
  271. if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
  272. return -EFAULT;
  273. termios.c_cc[VERASE] = tmp.sg_erase;
  274. termios.c_cc[VKILL] = tmp.sg_kill;
  275. set_sgflags(&termios, tmp.sg_flags);
  276. change_termios(tty, &termios);
  277. return 0;
  278. }
  279. #endif
  281. #ifdef TIOCGETC
  282. static int get_tchars(struct tty_struct * tty, struct tchars * tchars)
  283. {
  284. struct tchars tmp;
  286. tmp.t_intrc = tty->termios->c_cc[VINTR];
  287. tmp.t_quitc = tty->termios->c_cc[VQUIT];
  288. tmp.t_startc = tty->termios->c_cc[VSTART];
  289. tmp.t_stopc = tty->termios->c_cc[VSTOP];
  290. tmp.t_eofc = tty->termios->c_cc[VEOF];
  291. tmp.t_brkc = tty->termios->c_cc[VEOL2]; /* what is brkc anyway? */
  292. return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
  293. }
  295. static int set_tchars(struct tty_struct * tty, struct tchars * tchars)
  296. {
  297. struct tchars tmp;
  299. if (copy_from_user(&tmp, tchars, sizeof(tmp)))
  300. return -EFAULT;
  301. tty->termios->c_cc[VINTR] = tmp.t_intrc;
  302. tty->termios->c_cc[VQUIT] = tmp.t_quitc;
  303. tty->termios->c_cc[VSTART] = tmp.t_startc;
  304. tty->termios->c_cc[VSTOP] = tmp.t_stopc;
  305. tty->termios->c_cc[VEOF] = tmp.t_eofc;
  306. tty->termios->c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
  307. return 0;
  308. }
  309. #endif
  311. #ifdef TIOCGLTC
  312. static int get_ltchars(struct tty_struct * tty, struct ltchars * ltchars)
  313. {
  314. struct ltchars tmp;
  316. tmp.t_suspc = tty->termios->c_cc[VSUSP];
  317. tmp.t_dsuspc = tty->termios->c_cc[VSUSP]; /* what is dsuspc anyway? */
  318. tmp.t_rprntc = tty->termios->c_cc[VREPRINT];
  319. tmp.t_flushc = tty->termios->c_cc[VEOL2]; /* what is flushc anyway? */
  320. tmp.t_werasc = tty->termios->c_cc[VWERASE];
  321. tmp.t_lnextc = tty->termios->c_cc[VLNEXT];
  322. return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
  323. }
  325. static int set_ltchars(struct tty_struct * tty, struct ltchars * ltchars)
  326. {
  327. struct ltchars tmp;
  329. if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
  330. return -EFAULT;
  332. tty->termios->c_cc[VSUSP] = tmp.t_suspc;
  333. tty->termios->c_cc[VEOL2] = tmp.t_dsuspc; /* what is dsuspc anyway? */
  334. tty->termios->c_cc[VREPRINT] = tmp.t_rprntc;
  335. tty->termios->c_cc[VEOL2] = tmp.t_flushc; /* what is flushc anyway? */
  336. tty->termios->c_cc[VWERASE] = tmp.t_werasc;
  337. tty->termios->c_cc[VLNEXT] = tmp.t_lnextc;
  338. return 0;
  339. }
  340. #endif
  342. /*
  343.  * Send a high priority character to the tty.
  344.  */
  345. void send_prio_char(struct tty_struct *tty, char ch)
  346. {
  347. int was_stopped = tty->stopped;
  349. if (tty->driver.send_xchar) {
  350. tty->driver.send_xchar(tty, ch);
  351. return;
  352. }
  353. if (was_stopped)
  354. start_tty(tty);
  355. tty->driver.write(tty, 0, &ch, 1);
  356. if (was_stopped)
  357. stop_tty(tty);
  358. }
  360. int n_tty_ioctl(struct tty_struct * tty, struct file * file,
  361.        unsigned int cmd, unsigned long arg)
  362. {
  363. struct tty_struct * real_tty;
  364. int retval;
  366. if (tty->driver.type == TTY_DRIVER_TYPE_PTY &&
  367.     tty->driver.subtype == PTY_TYPE_MASTER)
  368. real_tty = tty->link;
  369. else
  370. real_tty = tty;
  372. switch (cmd) {
  373. #ifdef TIOCGETP
  374. case TIOCGETP:
  375. return get_sgttyb(real_tty, (struct sgttyb *) arg);
  376. case TIOCSETP:
  377. case TIOCSETN:
  378. return set_sgttyb(real_tty, (struct sgttyb *) arg);
  379. #endif
  380. #ifdef TIOCGETC
  381. case TIOCGETC:
  382. return get_tchars(real_tty, (struct tchars *) arg);
  383. case TIOCSETC:
  384. return set_tchars(real_tty, (struct tchars *) arg);
  385. #endif
  386. #ifdef TIOCGLTC
  387. case TIOCGLTC:
  388. return get_ltchars(real_tty, (struct ltchars *) arg);
  389. case TIOCSLTC:
  390. return set_ltchars(real_tty, (struct ltchars *) arg);
  391. #endif
  392. case TCGETS:
  393. if (kernel_termios_to_user_termios((struct termios *)arg, real_tty->termios))
  394. return -EFAULT;
  395. return 0;
  396. case TCSETSF:
  397. return set_termios(real_tty, arg,  TERMIOS_FLUSH);
  398. case TCSETSW:
  399. return set_termios(real_tty, arg, TERMIOS_WAIT);
  400. case TCSETS:
  401. return set_termios(real_tty, arg, 0);
  402. case TCGETA:
  403. return get_termio(real_tty,(struct termio *) arg);
  404. case TCSETAF:
  405. return set_termios(real_tty, arg, TERMIOS_FLUSH | TERMIOS_TERMIO);
  406. case TCSETAW:
  407. return set_termios(real_tty, arg, TERMIOS_WAIT | TERMIOS_TERMIO);
  408. case TCSETA:
  409. return set_termios(real_tty, arg, TERMIOS_TERMIO);
  410. case TCXONC:
  411. retval = tty_check_change(tty);
  412. if (retval)
  413. return retval;
  414. switch (arg) {
  415. case TCOOFF:
  416. if (!tty->flow_stopped) {
  417. tty->flow_stopped = 1;
  418. stop_tty(tty);
  419. }
  420. break;
  421. case TCOON:
  422. if (tty->flow_stopped) {
  423. tty->flow_stopped = 0;
  424. start_tty(tty);
  425. }
  426. break;
  427. case TCIOFF:
  428. if (STOP_CHAR(tty) != __DISABLED_CHAR)
  429. send_prio_char(tty, STOP_CHAR(tty));
  430. break;
  431. case TCION:
  432. if (START_CHAR(tty) != __DISABLED_CHAR)
  433. send_prio_char(tty, START_CHAR(tty));
  434. break;
  435. default:
  436. return -EINVAL;
  437. }
  438. return 0;
  439. case TCFLSH:
  440. retval = tty_check_change(tty);
  441. if (retval)
  442. return retval;
  443. switch (arg) {
  444. case TCIFLUSH:
  445. if (tty->ldisc.flush_buffer)
  446. tty->ldisc.flush_buffer(tty);
  447. break;
  448. case TCIOFLUSH:
  449. if (tty->ldisc.flush_buffer)
  450. tty->ldisc.flush_buffer(tty);
  451. /* fall through */
  452. case TCOFLUSH:
  453. if (tty->driver.flush_buffer)
  454. tty->driver.flush_buffer(tty);
  455. break;
  456. default:
  457. return -EINVAL;
  458. }
  459. return 0;
  460. case TIOCOUTQ:
  461. return put_user(tty->driver.chars_in_buffer ?
  462. tty->driver.chars_in_buffer(tty) : 0,
  463. (int *) arg);
  464. case TIOCINQ:
  465. retval = tty->read_cnt;
  466. if (L_ICANON(tty))
  467. retval = inq_canon(tty);
  468. return put_user(retval, (unsigned int *) arg);
  469. case TIOCGLCKTRMIOS:
  470. if (kernel_termios_to_user_termios((struct termios *)arg, real_tty->termios_locked))
  471. return -EFAULT;
  472. return 0;
  474. case TIOCSLCKTRMIOS:
  475. if (!capable(CAP_SYS_ADMIN))
  476. return -EPERM;
  477. if (user_termios_to_kernel_termios(real_tty->termios_locked, (struct termios *) arg))
  478. return -EFAULT;
  479. return 0;
  481. case TIOCPKT:
  482. {
  483. int pktmode;
  485. if (tty->driver.type != TTY_DRIVER_TYPE_PTY ||
  486.     tty->driver.subtype != PTY_TYPE_MASTER)
  487. return -ENOTTY;
  488. if (get_user(pktmode, (int *) arg))
  489. return -EFAULT;
  490. if (pktmode) {
  491. if (!tty->packet) {
  492. tty->packet = 1;
  493. tty->link->ctrl_status = 0;
  494. }
  495. } else
  496. tty->packet = 0;
  497. return 0;
  498. }
  499. case TIOCGSOFTCAR:
  500. return put_user(C_CLOCAL(tty) ? 1 : 0, (int *) arg);
  501. case TIOCSSOFTCAR:
  502. if (get_user(arg, (unsigned int *) arg))
  503. return -EFAULT;
  504. tty->termios->c_cflag =
  505. ((tty->termios->c_cflag & ~CLOCAL) |
  506.  (arg ? CLOCAL : 0));
  507. return 0;
  508. default:
  509. return -ENOIOCTLCMD;
  510. }
  511. }
  513. EXPORT_SYMBOL(n_tty_ioctl);